java基本数据类型

|--------|---------|------|------------------------|-----------|
| 数据类型 | 关键字 | 字节大小 | 取值范围 | 默认值 |
| 字节型 | byte | 1字节 | -128 ~ 127 | 0 |
| 短整型 | short | 2字节 | -32768 ~ 32767 | 0 |
| 整型 | int | 4字节 | -2^31 到 2^31-1 | 0 |
| 长整型 | long | 8字节 | -2^63 到 2^63-1 | 0L |
| 单精度浮点数 | ﬂoat | 4字节 | 大约 3.4e−038 到 3.4e+038 | 0.0f |
| 双精度浮点数 | double | 8字节 | 大约 1.7e−308 到 1.7e+308 | 0.0d |
| 字符型 | char | 2字节 | 0 ~ 65535 | '\u0000' |
| 布尔型 | boolean | 未固定 | true 和 false | false |

对于以下的数据类型来说:

1.在main方法中定义变量没有初始化的话，他是没有初始值的，是不能够直接访问的。

**2.**但是在类里面main方法外面定义变量没有初始化的话，他是默认有一个初始值的，可以直接访问。

如:

java 复制代码

public class Test {
    int b;
    public void print(){
        System.out.println(b);// b没初始化一样可以访问
    }
    public static void main(String[] args) {
        Test test=new Test();
        test.print();
//        int a;
//        System.out.println(a);
    }
}

Error:变量"a"可能尚未初始化(红色)

一.基本数据类型

1.整型变量

(1)整型变量

大小：4 字节（32 位）

取值范围：-2,147,483,648 到 2,147,483,647（即 -2^31 到 2^31-1）

默认值：0

用途：最常用的整数类型，用于大多数场合的整数运算。

对于整型来说，比较需要注意的就是避免溢出:

下面是一个例子：

java 复制代码

import java.lang.management.MonitorInfo;

public class Test {
    public static void main(String[] args) {
        System.out.println(Integer.MIN_VALUE);
        System.out.println(Integer.MAX_VALUE);
        int num = 2147483647;  // 最大值
        num += 1;  // 这会导致溢出
        System.out.println("加一后的数为: " + num);  // 输出: -2147483648 (溢出)

        int safeNum = Math.addExact(2147483647, 1);  // 通过标准库避免溢出，会抛出异常
    }
}

结果为（如果没有int safeNum = Math.addExact(2147483647, 1);这一句不会报错，就没有红色字体部分）:

(2)长整型变量

大小：8 字节（64 位）

取值范围：-9,223,372,036,854,775,808 到 9,223,372,036,854,775,807（即 -2^63 到 2^63-1）

默认值：0L

用途：用于处理比 int 类型更大的整数运算，适合需要存储非常大的整数的场景。

注意事项：

用于存储非常大的整数，范围比 int 大得多。
赋值时常需要在数值后面加上 L(当然也可以小写l)，否则会被视为 int 类型。

例子如下:

java 复制代码

import java.lang.management.MonitorInfo;

public class Test {
    public static void main(String[] args) {
        System.out.println(Long.MIN_VALUE);  //long最大值
        System.out.println(Long.MAX_VALUE);  //long最小值
        
        long largeNumber = 9223372036854775807L;  // 最大值
        long minimumNumber=-9223372036854775808L;
        long largeNumber1 = 9223372036854775807l; //小写l
//        long minimumNumber1=-9223372036854775808; //(没加L)Error:Integer number too large
        
        System.out.println("Large Number: " + largeNumber);
        System.out.println("Minimum Number: "+minimumNumber);
        //long invalidNumber = 9223372036854775808L;  // 编译错误，超出范围
    }
}

(3)短整型变量

大小：2 字节（16 位）

取值范围：-32,768 到 32,767（即 -2^15 到 2^15-1）

默认值：0

用途：比 byte 容量大一些，可以处理更大的整数，但仍然用于节省内存。

注意事项：

范围在 -32,768 到 32,767 之间，适用于比 byte 更大的整数场合。
通常用的场景不多，因为 int 已经是常规选项。

例子如下:

java 复制代码

public class Test {
    public static void main(String[] args) {
        System.out.println(Short.MIN_VALUE); //short最小值
        System.out.println(Short.MAX_VALUE); //short最大值
        
        short s1 = 32767;  // 最大值
        short s2 = -32768; // 最小值
        //short s3 = 32768;  // 编译错误，超出范围

        System.out.println("s1: " + s1);  // 输出: 32767
        System.out.println("s2: " + s2);  // 输出: -32768
    }
}

(4)字节型变量

大小：1 字节（8 位）

取值范围：-128 到 127（即 -2^7 到 2^7-1）

默认值：0

用途：用于节省内存空间的场合，尤其是在大量数据处理时。由于占用字节最少，适合处理小范围的数值。

注意事项：

取值范围 ：-128 到 127，超出该范围会发生溢出。
内存占用 ：1 字节，用于节省空间。
用途：适用于需要处理大量数据但内存有限的场景，如处理二进制数据。
溢出处理：进行位运算时要小心，防止溢出，比如进行加法时可能会超出最大值。

例子如下：

java 复制代码

import java.lang.management.MonitorInfo;

public class Test {
    public static void main(String[] args) {
        System.out.println(Byte.MIN_VALUE); //byte最小值
        System.out.println(Byte.MAX_VALUE); //byte最大值

        byte a = 127; // 最大值
        byte b = -128; // 最小值
        System.out.println(a); // 输出 127
        System.out.println(b); // 输出 -128

        // 溢出示例
        byte c = (byte) (a + 1); // 溢出，结果为 -128
        System.out.println(c); // 输出 -128
    }
}

2.浮点型变量

(1)双精度浮点型

大小：8 字节（64 位）

精度：约 15 位有效数字

默认的浮点数类型，常用于高精度运算。

精度：double 有 15-16 位有效数字，精度比 float 高。
内存占用 ：8 字节。
用途：默认的浮点数类型，适用于需要较高精度的场景，如科学计算。
字面量标识 ：无需特殊标识，浮点数默认是 double，但为了表达意图明确，通常会在数值后加 d 或 D，如 3.14d。

例子如下:

java 复制代码

import java.lang.management.MonitorInfo;

public class Test {
    public static void main(String[] args) {
        System.out.println(Double.MIN_VALUE); // double最小值
        System.out.println(Double.MAX_VALUE); // double最大值

        double a = 3.14159265358979323846;
        System.out.println(a); // 输出 3.141592653589793

        // 精度问题（稍微更好，但仍有误差）
        double b = 1.1234567890123456789;
        System.out.println(b); // 输出 1.1234567890123457，精度丢失
    }
}

对此，在财务和涉及精确计算的工作中，通常不使用 float 和 double 数据类型。原因主要与 浮点数的精度问题 和 舍入误差 有关。

(2)单精度浮点型

float：

大小：4 字节（32 位）

精度：约 7 位有效数字

用于表示单精度浮点数，常用于节省内存的场景。

注意事项：

精度：浮点数只能精确到 6-7 位有效数字，无法表示精确的小数。
内存占用 ：4 字节。
用途：适用于对内存要求严格且精度不太高的场景。
字面量标识 ：浮点数的字面量默认是 double 类型，使用 float 时需在数字后加上 f 或 F，如 3.14f。
误差：计算中可能会出现精度误差，尤其是在做金融等要求高精度的场景时，要避免使用 float 和 double。

例子如下:

java 复制代码

import java.lang.management.MonitorInfo;

public class Test {
    public static void main(String[] args) {
        System.out.println(Float.MIN_VALUE); // double最小值
        System.out.println(Float.MAX_VALUE); // double最大值

        float a = 3.14f; // 注意加 'f' 表示 float 类型
//        float b=3.24;  //Error:Incompatible types. Found: 'double', required: 'float'
        System.out.println(a); // 输出 3.14

        // 精度问题
        float c = 1.123456789f; // 超过 7 位有效数字
        System.out.println(c); // 输出 1.1234568，精度丢失
    }
}

3.字符型变量

(1)字符型

大小：2 字节（16 位）

取值范围：0 到 65,535（即 Unicode 字符集）

表示单个字符，如 'A'、'B' 或 Unicode 字符。char 实际上存储的是一个无符号的整数，表示对应的字符编码。

注意事项:

字符编码 ：char 在 Java 中使用 Unicode 编码，占用 2 字节，可以表示全球所有语言的字符。取值范围为 0 到 65,535。
字符常量 ：字符常量使用单引号 括起来，如 'A'。它实际存储的是字符的 Unicode 编码值。
强制转换 ：char 可以和整数类型进行强制转换，比如将 char 转换为其对应的 Unicode 编码整数，或将整数转换为对应的字符。
表示范围 ：如果处理 ASCII 字符（如 A-Z，a-z，0-9），可以使用 char，否则要注意处理 Unicode 字符的情况。
中文占用字节:在java中一个中文字符（汉字）通常占用 2 个字节。

例子如下:

java 复制代码

import java.lang.management.MonitorInfo;

public class Test {
    public static void main(String[] args) {
        //这里的character表示char，但是这里打印结果会不可见,这是因为:
        /*Character.MIN_VALUE：表示最小的 char 值，等于 \u0000，即 Unicode 编码中的第一个字符（空字符）。
          Character.MAX_VALUE：表示最大的 char 值，等于 \uFFFF，即 Unicode 中的最后一个字符。*/
        System.out.println(Character.MIN_VALUE); // char最小值
        System.out.println(Character.MAX_VALUE); // char最大值

        char a = 'A'; // 使用单引号表示字符
        char b = 65; // 可以直接赋值为 Unicode 编码
        System.out.println(a); // 输出 A
        System.out.println(b); // 输出 A

        // Unicode 字符
        char c = '\u0041'; // Unicode 编码 A
        System.out.println(c); // 输出 A

        char d='帅';
//        char e='帅哥'; //Error:Too many characters in character literal
        System.out.println(d);
    }
}

对于中文占用字节数例子:

java 复制代码

public class Test {
    public static void main(String[] args) {
        String chineseCharacter = "汉";
        System.out.println("汉字: " + chineseCharacter);
        System.out.println("占用字节数: " + Character.BYTES); // 输出 2
    }
}

4.布尔型变量

(1)布尔型

大小：1 位（通常表示为 1 或 0）

取值范围：true 或 false

用于条件判断和控制流程。

注意事项：

取值范围 ：只包含两个值：true 和 false。
内存占用：虽然布尔变量逻辑上只需要 1 位，但 JVM 实际可能会分配 1 字节或更多来存储它。
用途：常用于条件判断，布尔值无法与数字进行转换（例如 0 或 1 不会自动转换为 false 或 true）。
逻辑运算 ：常用逻辑运算符，如 &&（与），||（或），!（非）进行布尔运算。

例子如下：

java 复制代码

import java.lang.management.MonitorInfo;

public class Test {
    public static void main(String[] args) {
        boolean a = true;
        boolean b = false;
        System.out.println(a); // 输出 true
        System.out.println(b); // 输出 false

        // 条件判断
        if (a) {
            System.out.println("a 是 true");
        } else {
            System.out.println("a 是 false");
        }
    }
}

二.类型提升

自动类型提升规则：

小的整型会自动提升为 int：

所有的 byte、short 和 char 类型在表达式中都会被自动提升为 int。

如果表达式中有 long 类型的变量，int 也会被提升为 long。

浮点数的提升：

如果表达式中包含 float 和 double，那么 float 会自动提升为 double。

布尔类型没有提升：

布尔类型 boolean 不能参与类型提升，只能是 true 或 false，不能和数字类型相互转换或提升。

举个例子：

java 复制代码

public class TypePromotion {
    public static void main(String[] args) {
        byte b = 10;
        char c = 'A';  // Unicode值 65
        int i = b + c; // 自动提升到 int 类型
        System.out.println(i);  // 输出 75

        int x = 10;
        long y = 100L;
        long z = x + y;  // x 自动提升为 long
        System.out.println(z);  // 输出 110

        float f = 3.14f;
        double d = 5.678;
        double result = f + d;  // f 自动提升为 double
        System.out.println(result);  // 输出 8.818
    }
}

结果为:

注意事项：

自动类型提升遵循从低到高的顺序： byte -> short -> int -> long -> float -> double

如果表达式中的任意一部分是 long，则整个表达式的结果会提升为 long 类型；同理，如果是 float 或 double，则最终结果会提升到相应类型。

三.类型转换

类型转换的两种情况：

自动转换（隐式转换）：

从较低精度的数据类型转换为较高精度的数据类型时，可以隐式转换。例如，从 int 转换为 long，从 float 转换为 double。

强制转换（显式转换）：

从较高精度的数据类型转换为较低精度的数据类型时，需要进行显式类型转换。这可能会导致精度损失或溢出。

说再多都不如一个例子来的更明白：

java 复制代码

public class TypeCasting {
    public static void main(String[] args) {
        // 隐式转换 (自动转换)
        int i = 100;
        long l = i;  // int 自动转换为 long
        System.out.println(l);  // 输出 100

        float f = i;  // int 自动转换为 float
        System.out.println(f);  // 输出 100.0

        // 显式转换 (强制转换)
        double d = 9.99;
        int x = (int) d;  // double 强制转换为 int，精度损失
        System.out.println(x);  // 输出 9

        long y = 10000000000L;
        int z = (int) y;  // long 强制转换为 int，可能溢出
        System.out.println(z);  // 结果可能不是预期的，输出 -727379968
    }
}

结果:

注意事项:

精度损失：

在进行浮点数到整数的强制类型转换时，小数部分会被截断，不进行四舍五入。例如，(int) 9.99 的结果是 9。

溢出问题：

当较大的数据类型转换为较小的类型时，如果超出了目标类型的表示范围，可能会发生溢出，导致值不准确。例如，long 转换为 int 时，如果超出 int 的范围，结果将出现意外行为。

字符到整数的转换：

char 可以隐式转换为 int，因为每个字符都有一个对应的 Unicode 值。

java基本数据类型

一.基本数据类型

1.整型变量

(1)整型变量

(2)长整型变量

(3)短整型变量

(4)字节型变量

2.浮点型变量

(1)双精度浮点型

(2)单精度浮点型

3.字符型变量

(1)字符型

4.布尔型变量

(1)布尔型

二.类型提升

**三.**类型转换

三.类型转换