Java-数据类型-CSDN博客

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

        byte a = 10;
        short b = 20;
        int c = 30;
        long d = 40L;
        float e = 1.0f;
        double f = 3.14;
        char g = '中';
        boolean h = true;

    }
}

1.2 long 和 float 的书写

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

        long a = 10L;   //为了区分 int 和 long 类型，
                        //一般建议：long 类型变量后面加上 'l' 或者 'L'
        long b = 20l;   //一般更加以大写 L ,因为小写 l 容易与数字 1 相混淆

        float c = 3.14f;   //为了区分 float 和 double 类型
        float d = 3.14F;   //一般建议：float 类型变量后面加上 'f' 或者 'F'

    }
}

1.3 char 的表示原理

计算机中的字符本质上是一个整数。

而 Java 中使用 Unicode 表示字符。

对于 Java 中的 char 类型，一个字符占用两个字节，所以表示的字符种类很多，包括中文。

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

        char a = 65;
        char b = '中';

        System.out.println(a);  //输出 A
        System.out.println(b);  //输出 中

    }
}

1.4 赋初值

在 Java 中，如果要使用基本数据类型定义的变量，那么要在使用之前赋初值，否则会在编译期间报错。

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

        int a = 10;
        System.out.println(a);  //这样没问题

        int b;
        b = 20;
        System.out.println(b);  //这样也没问题

        int c;
//        System.out.println(c);  //执行了这一步就会报错，因为 c 没有初始化，所以不能使用

    }
}

1.5 boolean 类型

boolean 类型的变量只有两种取值，ture 表示真，flase 表示假。

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

        boolean a = true;
        boolean b = false;

        System.out.println(a);  //输出 true
        System.out.println(b);  //输出 false

    }
}

1.6 类型转换

Java 作为一个强类型编程语言，当不同类型之间的变量相互赋值的时候，会有严格的校验。

在 Java 中，当参与运算的数据类型不一致时，就会进行类型转换。

Java 中类型转换主要分为两类：自动类型转换（隐式）和强制类型转换（显示）。

1.6.1 自动类型转换（隐式）

自动类型转换（隐式）：代码不需要经过任何处理，在代码编译时，编辑器会自动进行处理。

特点：数据范围小的数据类型转为数据范围大的数据类型时会自动进行。

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

        System.out.println(1024);   //整形默认是 int 类型，所以输出 1024
        System.out.println(3.14);   //浮点型默认是 double 类型，所以输出 3.14

        int a = 100;
        long b = 10L;
        b = a;  //a和b都是整形，a的范围小，b的范围大，当将a赋值给b时，编译器会自动将a提升为long类型，然后赋值
//        a = b;  //编译报错，long的范围比int的范围大，会有数据丢失，不安全

        float f = 3.14f;
        double d = 5.12;

        d = f;  //编译器会将f转换为double，然后进行赋值
//        f = d;  //编译报错，long的范围比int的范围大，会有数据丢失，不安全

        byte b1 = 100;  //编译通过，100没有超出byte的范围，编译器隐式将100转换为byte类型
//        byte b2 = 128;  //编译报错，128超出byte的范围，超出了byte的范围，有数据丢失
        
        
    }
}

1.6.2 强制类型转换（显示）

强制类型转换（显示）：当进行操作时，代码需要经过一定的格式处理，不能自动完成。

特点：数据范围大的到数据范围小的。

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

        int a = 10;
        long b = 20L;
        b = a;  //int-->long,数据类型由小到大，隐式转换
        a = (int) b;  //long-->int,数据类型由大到小，需要强转，否则编译失败

        float f = 3.14f;
        double d = 5.12;
        d = f;  //float-->double,数据类型由小到大，隐式转换
        f = (float) d;  //double-->float,数据类型由大到小，需要强转，否则编译失败

//        a = d;  //编译报错，类型不兼容
        a = (int) d;  //int类型没有double表示的数据范围大，需要强转，小数点之后的全部丢弃

        byte b1 = 100;  //编译通过，100默认为int类型，没有超出byte的范围，编译器隐式将100转换为byte类型
        byte b2 = (byte) 257;  //257默认为int，超出byte的范围，需要显式转换，否则编译失败

        boolean flag = true;
//        a = flag;  //编译失败：类型不兼容
//        flag = a;  //编译失败：类型不兼容

    }
}

1.7 类型提升

不同类型的数据之间相互运算时，数据类型小的会被提升到数据类型大的。

1.7.1 int 和 long 之间：int 会被提升为 long

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

        int a = 10;
        long b = 20L;
//        int c = a + b;  //编译报错,a + b ==> int + long -> long + long .赋值给int时会丢失数据
        long d = a + b;  //编译通过，a + b ==> int + long -> long + long .赋值给long时不会丢失数据
    }
}

1.7.2 byte 和 byte 的运算

public class Main {
    public static void main(String[] args) {
        
        byte a = 10;
        byte b = 20;
//        byte c = a + b;   //编译报错，byte + byte -> int + int .但把int类型赋值给byte时会丢失数据。
        byte c = (byte) (a + b);  //编译通过
        
    }
}