Java基本数据类型

@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; 编译错误,运算之后变为double类型*/	
	}

	@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变为了int类型,而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在静态数组的范围内，所以不是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的
*/