第二章 5.基本数据类型转换

基本数据类型转换
自动类型转换
1.当java程序在进行赋值或者运算时,精度小的类型自动转换为精度大的数据类型,这个就是自动类型转换
数据类型按精度(容量)大小排序
(1) char-->int-->long-->float-->double
(2) byte-->short-->int-->long-->float-->double

public class Data_AutoConvert{
    public static void main(String[] args){
        //1.当java程序在进行赋值或者运算时,精度小的类型自动转换为精度大的数据类型,这个就是自动类型转换
        //演示自动转换
        int num = 'c'; //ok char-->int
        double d = 80; //ok int-->double
        System.out.println(num); //99
        System.out.println(d); //80.0
    }
}

2.有多种类型的数据混合运算时,系统首先自动将所有数据转换成容量最大的那种数据类型,然后再进行计算

public class Data_AutoConvert {
    public static void main(String[] args) {
        //2.有多种类型的数据混合运算时,系统首先自动将所有数据转换成容量最大的那种数据类型,然后再进行计算
        int n1 = 10; //ok

        //报错,因为int + double-->double(8个[字节]物体放不进4个箱子[字节]的容器)
        //float d1 = n1 + 1.1;  //java: 不兼容的类型: 从double转换到float可能会有损失

        //正确写法
        //double d1 = n1 + 1.1; //ok
        //float d1 = n1 + 1.1F; //int + float==>结果类型时float
    }
}

3.当我们把精度(容量)大的数据类型赋值给精度(容量)小的数据类型时,就会报错,反之就会进行自动类型转换
//double放不进int里
//int n2 = 1.1; //java: 不兼容的类型: 从double转换到int可能会有损失

4.(byte,short)和char之间不会相互自动转换

public class Data_AutoConvert{
    public static void main(String[] args){
        //4.(byte,short)和char之间不会相互自动转换
        //当把具体数赋给 byte 时,(1)先判断该数是否在byte范围内,如果时就可以
        //                    (2)如果是用变量赋值的,直接判断类型
        byte b1 = 10;
        int n3 = 1;
        // 错误,原因:变量赋值,直接判断类型
        //byte b2 = n3;    //n3是个int(4个字节)放不进byte(1个字节)容量

        //错误,原因byte不能自动转换成char
        //char c1 = b1;
        //同理,short也不能自动转换成char
    }
}

5.byte,short,char 他们三者可以计算,在计算时首先转换成int类型

public class Data_AutoConvert {
    public static void main(String[] args) {
        //5.byte,short,char 他们三者可以计算,在计算时首先转换成int类型
        byte b2 = 1;
        byte b3 = 2;
        short s1 = 1;
        //short s2 = b2 + s1; //报错,b2 + s1 =>int,又因为int(4个字节)物体放不进short(2个字节)容量里面
        int s2 = b2 + s1; //正确

        //byte b4 = b2 + b3; //报错,b2和b3这两个byte类型先转换成int在运算(short-->int),int + int = int,"int(4个字节)物体放不进byte(1个字节)容量里"
    }
}

6.boolean不参与转换

public class Data_AutoConvert {
    public static void main(String[] args) {
        //6.boolean不参与转换
        boolean pass = true;
        //int num100 = pass;  //报错,boolean不参与类型的转换
    }
}

7.自动提升原则:表达式结果的类型自动提升为 操作数中最大的类型(与第二点类似)

public class Data_AutoConvert{
    public static void main(String[] args){
        //7.自动提升原则:表达式结果的类型自动提升为 操作数中最大的类型
        byte a1 = 1;
        short a2 = 1;
        long a3 = 1;
        double a4 = 1;
        double a5 = a1 + a2 + a3 + a4; //(a1 + a2 + a3 + a4)-->double
        //float a6 = a1 + a2 + a3 + a4; //(a1 + a2 + a3 + a4)-->double放不进float里面
    }
}

自动转换类型总代码

package cn.javageiyegun.demo02.Data_type;
//基本数据类型转换
//自动类型转换

public class Data_AutoConvert {
    public static void main(String[] args) {

        //1.当java程序在进行赋值或者运算时,精度小的类型自动转换为精度大的数据类型,这个就是自动类型转换
        //演示自动转换
        int num = 'c'; //ok char-->int
        double d = 80; //ok int-->double
        System.out.println(num); //99
        System.out.println(d); //80.0

        //2.有多种类型的数据混合运算时,系统首先自动将所有数据转换成容量最大的那种数据类型,然后再进行计算
        int n1 = 10; //ok

        //报错,因为int + double-->double(8个[字节]物体放不进4个箱子[字节]的容器)
        //float d1 = n1 + 1.1;  //java: 不兼容的类型: 从double转换到float可能会有损失

        //正确写法
        //double d1 = n1 + 1.1; //ok
        //float d1 = n1 + 1.1F; //int + float==>结果类型时float

        //3.当我们把精度(容量)大的数据类型赋值给精度(容量)小的数据类型时,就会报错,反之就会进行自动类型转换
        //double放不进int里
        //int n2 = 1.1; //java: 不兼容的类型: 从double转换到int可能会有损失


        //4.(byte,short)和char之间不会相互自动转换
        //当把具体数赋给 byte 时,(1)先判断该数是否在byte范围内,如果时就可以
        //                    (2)如果是用变量赋值的,直接判断类型
        byte b1 = 10;
        int n3 = 1;
        // 错误,原因:变量赋值,直接判断类型
        //byte b2 = n3;    //n3是个int(4个字节)放不进byte(1个字节)容量

        //错误,原因byte不能自动转换成char
        //char c1 = b1;
        //同理,short也不能自动转换成char

        //5.byte,short,char 他们三者可以计算,在计算时首先转换成int类型
        byte b2 = 1;
        byte b3 = 2;
        short s1 = 1;
        //short s2 = b2 + s1; //报错,b2 + s1 =>int,又因为int(4个字节)物体放不进short(2个字节)容量
        int s2 = b2 + s1; //正确

        //byte b4 = b2 + b3; //报错,b2和b3这两个byte类型先转换成int在运算(short-->int),int + int = int,"int(4个字节)物体放不进byte(1个字节)容量"

        //6.boolean不参与转换
        boolean pass = true;
        //int num100 = pass;  //报错,boolean不参与类型的转换

        //7.自动提升原则:表达式结果的类型自动提升为 操作数中最大的类型
        byte a1 = 1;
        short a2 = 1;
        long a3 = 1;
        double a4 = 1;
        double a5 = a1 + a2 + a3 + a4; //(a1 + a2 + a3 + a4)-->double
        //float a6 = a1 + a2 + a3 + a4; //(a1 + a2 + a3 + a4)-->double放不进float里面
    }
}

强制类型转换
自动类型转换的逆过程,将容量大的数据类型转换为容量小的数据类型.使用时要加上强制转换符(),但可能造成精度降低或溢出,格外要注意
1.当进行数据的大小转换从 大-->小,就需要使用到强制转换

public class Data_ForceConvert {
    public static void main(String[] args) {
        //演示强制类型转换
        //1.当进行数据的大小转换从 大-->小,就需要使用到强制转换
        int n1 = (int)1.9;
        System.out.println("n1 = " + n1); //1 , 造成精度损失

        int n2 = 2000;
        byte b1 = (byte)n2;
        System.out.println("b1 = " + b1); //数据溢出

    }
}

2.强转符号只针对于最近的操作数有效,往往会使用小括号提升优先级

public class Data_ForceConvert {
    public static void main(String[] args) {
        //2.强转符号只针对于最近的操作数有效,往往会使用小括号提升优先级
        //int x = (int)10*3.5+6*1.5; //编译错误:double放不进int类型里
        int b = (int)(10*3.5+6*1.5); //(int)44.0 --> 44
        System.out.println(b); //44
    }
}

3.char类型可以保存int的常量值,但不能保存int的变量值,需要强转

public class Data_ForceConvert {
    public static void main(String[] args) {
        //3.char类型可以保存int的常量值,但不能保存int的变量值,需要强转
        char c1 = 100; //ok
        int m = 100;
        //m是个int(4个字节)放不进char(1个字节)容量
        //char c2 = m; // 错误,原因:变量赋值,直接判断类型
        char c3 = (char)m;
        System.out.println(c3); //100对应的字符d
    }
}

4.byte,short和char类型在进行运算时,当做int类型处理[上一小节讲过]

强制转换类型总代码:

package cn.javageiyegun.demo02.Data_type;

public class Data_ForceConvert {
    public static void main(String[] args) {
        //演示强制类型转换
        int n1 = (int)1.9;
        System.out.println("n1 = " + n1); //1 , 造成精度损失

        int n2 = 2000;
        byte b1 = (byte)n2;
        System.out.println("b1 = " + b1); //数据溢出

        //1.当进行数据的大小转换从 大-->小,就需要使用到强制转换
        //2.强转符号只针对于最近的操作数有效,往往会使用小括号提升优先级
        //int x = (int)10*3.5+6*1.5; //编译错误:double放不进int类型里
        int b = (int)(10*3.5+6*1.5); //(int)44.0 --> 44
        System.out.println(b); //44

        //3.char类型可以保存int的常量值,但不能保存int的变量值,需要强转
        char c1 = 100; //ok
        int m = 100;
        //m是个int(4个字节)放不进char(1个字节)容量
        //char c2 = m; // 错误,原因:变量赋值,直接判断类型
        char c3 = (char)m;
        System.out.println(c3); //100对应的字符d
    }
}