第三章：Java的基本数据类型

基本数据类型的内存占用

计算byte的取值范围
	以字节为例：1字节等于8位，2的8次方等于128，最大值是128-1，最小值是-128，所以范围是-128~127
	同理计算：short int long float double

基本数据类型的排序

（char、byte、short) < int < long < float < double

注意：括号中的三个类型不能相互转换

代码演示：基本数据类型的取值范围

注意：编译运行计算“字符”类型取值范围最值时，最值是个字符符号属于正常现象

public class Demo {
    public static void main(String[] args) {
        System.out.println("char的最小值：" + Character.MIN_VALUE);
        System.out.println("char的最大值：" + Character.MAX_VALUE);
        System.out.println("int的最小值：" + Integer.MIN_VALUE);
        System.out.println("int的最大值：" + Integer.MAX_VALUE);
        
        System.out.println("short的最小值：" + Short.MIN_VALUE);
        System.out.println("short的最大值：" + Short.MAX_VALUE);
        System.out.println("byte的最小值：" + Byte.MIN_VALUE);
        System.out.println("byte的最大值：" + Byte.MAX_VALUE);
        System.out.println("long的最小值：" + Long.MIN_VALUE);
        System.out.println("long的最大值：" + Long.MAX_VALUE);
        System.out.println("float的最小值：" + Float.MIN_VALUE);
        System.out.println("float的最大值：" + Float.MAX_VALUE);
        System.out.println("double的最小值：" + Double.MIN_VALUE);
        System.out.println("double的最大值：" + Double.MAX_VALUE);
    }
}

代码演示：基本数据类型的默认值

public class Demo {
    static byte b;
    static short s;
    static int i;
    static long l;
    static float f;
    static double d;
    static char c;
    static boolean bb;
    // 静态变量与静态方法都属于类
	// 静态方法直接访问静态变量（无需创建对象）
    public static void main(String[] args) {			// 运行结果
        System.out.println("byte的默认值是" + b);		// 0
        System.out.println("short的默认值是" + s);		// 0
        System.out.println("int的默认值是" + i);			// 0
        System.out.println("long的默认值是" + l);		// 0
        System.out.println("float的默认值是" + f);		// 0.0
        System.out.println("double的默认值是" + d);		// 0.0
        System.out.println("char的默认值是" + c);		// “运行结果为无内容（null）”
        System.out.println("boolean的默认值是" + bb); 	// false
    }
}

基本数据类型的定义方式

注意：浮点型默认类型是double，整型默认类型是int

代码演示：浮点型的定义方式

public class Demo {
    public static void main(String[] args) {
        // float num1 = 1.1; 
        // 编译期系统直接报错
        // 原因：1.1默认是double类型占8个字节，而float类型仅占4个字节，所以无法存储
        
        // 单精度浮点型的三种初始化方式 
        float num2 = 2.2f;	
        float num3 = 3.3F;
        float num4 = (float)4.4;

		// 双精度浮点型的三种初始化方式
        double num5 = 5.5;
        double num6 = 6.6l;
        double num7 = 7.7L;
    }
}

代码演示：整型的定义方式

public class Demo {
    public static void main(String[] args) {
    	// 长整型的三种初始化的方式
        long num1 = 10;
        long num2 = 20l;
        long num3 = 30L;
        
        // 整型的两种初始化的方式
        int num4 = 40;
        int num5 = (int)50;
    }
}

代码演示：字符型的定义与访问

类型中的 byte、char、short都是以 int类型的数值进行计算，运行可能会出现溢出情况！！！

public class Demo {
    public static void main(String[] args) {
		char ch = 97;
        System.out.println(ch); // 运行结果：a
        // 解析：97在ACSII码中所对应的值是 a

        char a = 'A';   // char类型的 a 变量赋值为 A，所对应的 ASCII 值为65
        char b = 'B';   // char类型的 b 变量赋值为 B，所对应的 ASCII 值为66
        System.out.println("A 的 ASCII 值与 B 的ASCII 值相加结果为" + (a+b));	
        // 运行结果：A 的 ASCII 值与 B 的ASCII 值相加结果为131
    }
}

基本数据类型转换常见的错误

代码演示：byte或short类型相加的易错点

public class Demo {
    public static void main(String[] args) {
        byte b1 = 1;
        byte b2 = 1;
        // byte i = b1 + b2; 
        // 编译期系统报错
        // 原因：b1+b2相当于int+int，等号左右两边类型不相等
        
        byte i = (byte)(b1 + b2);   // 通过强制转换，等号左右类型相等
        System.out.println("b1 + b2 = " + i);	// 运行结果：b1 + b2 = 2
    }
}
//	对于short类型相加，也是相同的操作

代码演示：整型数溢出

public class Demo {
    public static void main(String[] args) {
        int num1 = 220000000;
        int num2 = 10;
        long num3 = num1 * num2;
        System.out.println("num1 * num2 = " + num3);    // 运行结果：num1 * num2 = -2094967296
		// num1 * num2 出现结果溢出情况
		// 原因：int * int 结果终究是int类型中的取值范围，只不过将int类型的结果存放在long类型的变量中
		
        int num4 = 220000000;
        long num5 = 10;
        long num6 = num4 * num5;
        System.out.println("num4 * num5 = " + num6);    // 运行结果：num4 * num5 = 2200000000
        //  num4 * num5 结果正确
        // 原因：int * long 结果存储在大类型（long）中
    }
}

代码演示：两数运算，取值为大类型更为精准

public class Demo {
    public static void main(String[] args) {
        int apple = 3;
        double price = 3.33;

        double total1 = apple * price;
        int total2 = (int)(apple * price);
        System.out.println("获取total1 = " + total1);	//	运行结果：9.99
        System.out.println("获取total2 = " + total2);	//	运行结果：9
        // 浮点型转整型，发生精度丢失
    }
}

总结：自动转换与强制转换

自动类型转换：由小类型存储至大类型（等号左边是大类型，右边是小类型）

强制类型转换：由大类型存储至小类型（等号左边是小类型，右边是大类型）
	强制转换可能会出现的三种情况
		1. 例如：int + int = byte；编译报错，等号左右两边类型不相同
		2. 例如：long类型转为int类型；有可能会出现数据溢出
		3. 例如：(int)(3.3 * 3)；浮点型转为整型，会发生精度丢失

代码演示：通过int型定义 二进制、八进制、十六进制

public class HelloWorld {
    public static void main(String []args) {
    	int a = 10;			// 十进制
		int b = 0x123;		// 0x 表示十六进制 最高位：F
		int c = 0123;		// 0 表示八进制   最高位：7
		int d = 0b101;		// 0b 表示二进制  最高位：1
		
		System.out.println(a);			// 运行结果 10
		System.out.println(b);			// 运行结果 291
		System.out.println(c);			// 运行结果 93
		System.out.println(d);			// 运行结果 5
		
    }
}