@Test
	public void d() {
		int a=100;//這個100就是直接量
		a=a+100;//但是這個a+100不是直接量
		double b=3.14;
	}

@Test
	public void e(){
		long a=200;//200是直接量，默認為int類型這里是自動轉換為弄類型
		
		/*long b=100000000000;*/
		//100000000000是個整數直接量，默認應該為int類型，但是超出了int類型的取值范圍
		
		long c=1000000000000L;
		//在整數直接量后面將了一個L，表示該直接量不再默認為int類型，為long類型，所以沒錯
		
		/*float d=34.3;*/
		//浮點型直接量默認為double,double類型大，所以不能直接轉換為float
		
		float e=34.3f;
		//在浮點數直接量后面加上一個f，表示該直接量不再默認為double，為float類型
	}

@Test 
	public void f() {
		byte a=100;
		short b=200;
		char c=100;//注意char類型是一種特殊的int類型，可以不用寫成單引號括起來的
		
		/*byte d=128;直接量128超出了byte類型的取值范圍*/
		
		/*char e=-1;直接量-1不在char類型的取值范圍內*/
		
	}

@Test
	public void g() {
		int a=3;
		double b=4;
		System.out.println(a+b);//輸出7.0
		
		float c=3.2f;
		/*c=c+3.14; 編譯錯誤,運算之后變?yōu)閐ouble類型*/	
	}

	@Test
	public void h() {
		byte a=3;
		byte b=4;
		/*byte c=a+b;
		 * 編譯錯誤,此處由于byte類型參與運算時，先直接轉換為int類型，
		 * 所以最后的結果也是int類型，但是得出的結果不能叫做int類型的直接量，所以編譯錯誤
		 * */
		int d=a+b;
	}

@Test
	public void j() {
		int a=128;
		byte b=(byte)a;
		System.out.println(b);//輸出-128，出現了數據溢出
		
		double c=1.23;
		int d=(int)c;
		System.out.println(d);//輸出1，精度丟失
	}

@Test
	public void k() {
		int a=10000000;
		int b=10000000;
		int c=a*b;
		System.out.println(c);//輸出276447232，得到的結果超出了int類型的范圍，數據溢出
	}

@Test
	public void a() {
	/*1.參數為基本數據類型		
	 * 作用：將基本數據類型轉換為對應包裝類 * */
		Integer i=Integer.valueOf(10);
		System.out.println(i);//輸出10
	
	/*2.參數為String字符串時，
	 * 作用：返回指定字符串值的包裝類對象
	 * 	*/
		Integer a=Integer.valueOf("100");
		System.out.println(a);//輸出100
		
		Integer b=Integer.valueOf("100a")為
		System.out.println(b);//運行錯誤，字符串的值不少一個int類型的
		
	}

@Test
	public void b() {
		/*作用：將給定字符串裝換為對應的基本數據類型
		 * 前提是該字符串必須正確描述該基本數據類型表示的值*/
		int a=Integer.parseInt("100");
		System.out.println(a);//輸出100
		
		int b=Integer.parseInt("100a");
		System.out.println(b);//運行錯誤，字符串的值不為int類型
				
	}

@Test
	public void c() {
		/*作用：將包裝類對象轉換為對應的基本數據類型*/
		
		Integer a=Integer.valueOf(100);//將基本數據類型轉換為包裝類對象
		int b=a.intValue();//將包裝類對象轉換為對應的基本數據類型
		System.out.println(b);//輸出100
		
		Double c=Double.valueOf(2.33);
		double d=c.doubleValue();
		System.out.println(d);
	}

@Test
	public void d() {
		/*自動裝箱：valueOf*/
		Integer i=123;//原理是 Integer i=Integer.valueOf(123);
		
		/*自動拆箱*/
		int i1=i+1;//原理是	int i1=i.intValue()+1;
		
		Integer a=123;
		Integer b=123;
		Integer c=a+b;
		/*原理為Integer c=Integer.valueOf(a.intValue()+b.intValue());*/
	}

 public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

public static void main(String[] args) {
		int a=10;
		double b=3.4;
		System.out.println(a>b?a:b);
		System.out.println(a);
	}
/*輸出：10.0   10
解析：這里是一個很容易讓人不注意的類型轉化，這里a與b參與了運算，
所以類型向類型大的方向轉化，10就變成了10.0，但是a本身是沒有變化的*/

public static void main(String[] args) {
		short a=1;	//第一行
		 a=a+1;		//第二行
		 a+=1;		//第三行
}
/*第幾行的代碼會出錯？
答案：第二行會出錯，由于a+1變?yōu)榱薸nt類型,而int類型不能直接賦值給short類型
但是+=這種情況是特殊的，所以不會出錯；
*/

public static void main(String[] args) {
		Integer a1=127;
		Integer a2=127;
		int a3=127;
		Integer b1=128;
		Integer b2=128;
		int b3=128;
		System.out.println(a1==a2);
		System.out.println(a1==a3);
		System.out.println(b1==b2);
		System.out.println(b1==b3);	
}
/*輸出：true true false true
解析：自動裝箱時采用valueOf方法，由于127在靜態(tài)數組的范圍內，所以不是new的，
而128的兩個引用是指向new出現對象的，所以第一個是true，第三個是false。
而包裝類和基本數據類型比較時，只要數值是相等的，就相等
*/

public static void main(String[] args) {
		System.out.println(0.1*3==0.3);
		System.out.println(0.1*4);
}
/*輸出：false 0.4
解析：有些浮點數不能準確的表示出來，與整數相乘之后出精度丟失，常見為小數位含3的
*/