一，基础数据类型

变量就是申请内存来存储值。也就是说，当创建变量的时候，需要在内存中申请空间，内存管理系统根据变量的类型为变量分配存储空间，分配的空间只能用来储存该类型数据，每个变量相当于向内存申请了一个小空间

java有两大数据类型：内置数据类型，引用数据类型；

内置数据类型

内置数据类型是 Java 语言内置的、不可再分的基本数据类型，共 8 种。它们是构建所有 Java 程序的基础

整数型：

byte

// 范围：-128 到 127
byte b1 = 100;     // 十进制
byte b2 = 0x64;    // 十六进制：100
byte b3 = 0144;    // 八进制：100
byte b4 = 0b01100100; // 二进制：100（Java 7+）

// 使用场景：文件读写、网络传输、节省内存
byte[] buffer = new byte[1024]; // 常用在网络IO中
// 这是一个网络缓冲区相当于中转站
Socket socket = new Socket("example.com", 80);
InputStream in = socket.getInputStream();  // 网线入口
byte[] header = new byte[1024];            // 缓冲区
int len = in.read(header);                // 网线 → 缓冲区

注意事项：Java 允许 byte 类型使用十进制、十六进制、八进制和二进制表示，但最终都必须落在 byte 的范围（-128 到 127）内。

short

// 范围：-32,768 到 32,767
short s1 = 10000;
short s2 = (short) 35000; // 需要强制转换，会有精度损失

// 使用场景：16位处理器兼容、节省内存的大数组
short[] pixels = new short[1920 * 1080]; // 图像处理

int 

//最常用的整数类型：数组索引、循环计数器、常规业务数据（如年龄、数量、ID）方法返回值：大部分API方法返回int。

// 1. 数组索引
int[] numbers = {10, 20, 30, 40, 50};
int index = 2; // 索引从0开始
System.out.println("索引 " + index + " 对应的值是: " + numbers[index]);

// 2. 循环计数器
for (int i = 0; i < numbers.length; i++) {
   System.out.println("循环计数器 i = " + i + ", 值 = " + numbers[i]);
}

long

//时间戳：System.currentTimeMillis() 返回long表示毫秒数。
//大数值场景：需要表示超过21亿的值（如全球人口、文件大小、高并发计数）。
long startTime = System.currentTimeMillis(); // 返回当前时间的毫秒数（long）

// 模拟一些耗时操作（例如循环计算）
long sum = 0;
for (int i = 0; i < 1_000_000; i++) {
   sum += i;
  }

 long endTime = System.currentTimeMillis();
 long elapsed = endTime - startTime; // 计算耗时（毫秒）
 System.out.println("循环计算 1 到 999,999 的和: " + sum);
 System.out.println("耗时: " + elapsed + " 毫秒");

浮点型：

float

//图形处理：OpenGL或3D游戏中的顶点坐标、颜色值。
//节省内存：存储大量浮点数且精度要求不高时（如传感器数据）。
//注意，Java 中 float 字面量需要加 f 或 F 后缀，否则默认为 double。
 // ---------- 场景1：图形处理（顶点坐标和颜色）----------
        // 定义一个三角形的三个顶点坐标 (x, y, z)，每个分量用 float
        float[] vertexPositions = {
            0.0f, 0.5f, 0.0f,   // 顶点0
            -0.5f, -0.5f, 0.0f, // 顶点1
            0.5f, -0.5f, 0.0f   // 顶点2
        };

        // 定义每个顶点的颜色 (r, g, b, a)，范围 0.0f ~ 1.0f
        float[] vertexColors = {
            1.0f, 0.0f, 0.0f, 1.0f, // 顶点0 红色
            0.0f, 1.0f, 0.0f, 1.0f, // 顶点1 绿色
            0.0f, 0.0f, 1.0f, 1.0f  // 顶点2 蓝色
        };

double

double 是最常用的浮点型数据类型

//科学计算：大多数数学函数（如Math.sqrt）默认使用double。
//货币计算（需注意精度问题，通常用BigDecimal代替）。
//普通小数：业务中常用的浮点数类型，如价格、百分比。
// 基本声明和初始化
double d1 = 3.14;           // 十进制形式
double d2 = 3.14d;          // 可选的 d/D 后缀
double d3 = 3.14D;          // 大写D也可以
double d4 = .5;             // 0.5 的简写
double d5 = 3.14e2;         // 科学计数法：314.0

// 基本常量
System.out.println(Double.MAX_VALUE);    // 最大值 1.7976931348623157E308
System.out.println(Double.MIN_VALUE);    // 最小值 4.9E-324
System.out.println(Double.SIZE);         // 位数 64
System.out.println(Double.BYTES);        // 字节数 8

布尔型

boolean

boolean数据类型表示一位的信息；
只有两个取值：true 和 false；
boolean one = true；

字符型

char

char 类型是一个单一的 16 位 Unicode 字符；
char 数据类型可以储存任何字符；
char letter = 'A';

二、引用数据类型

1. 类（Class）

// 定义一个类
class Person {
    String name;
    int age;
    
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public void introduce() {
        System.out.println("我叫" + name + "，今年" + age + "岁");
    }
}

public class ClassType {
    public static void main(String[] args) {
        // 创建对象（引用类型）
        Person person1 = new Person("张三", 25);
        Person person2 = person1;  // 引用赋值，指向同一个对象
        
        person1.introduce();
        person2.introduce();
        
        // 修改person1会影响person2
        person1.name = "李四";
        person1.introduce();  // 李四
        person2.introduce();  // 李四
        
        // null引用
        Person person3 = null;
        // person3.introduce(); // NullPointerException
    }
}

2. 接口（Interface）

// 定义接口
interface Animal {
    void sound();  // 抽象方法
    default void sleep() {  // 默认方法
        System.out.println("睡觉");
    }
}

// 实现接口
class Dog implements Animal {
    @Override
    public void sound() {
        System.out.println("汪汪");
    }
    
    // 可以添加自己的方法
    public void run() {
        System.out.println("跑步");
    }
}

public class InterfaceType {
    public static void main(String[] args) {
        Animal dog = new Dog();  // 接口引用指向实现类对象
        dog.sound();
        dog.sleep();
        // dog.run(); // 编译错误：Animal接口中没有run方法
        
        Dog realDog = new Dog();  // 实际类型引用
        realDog.run();  // 可以调用自己的方法
    }
}

3. 数组（Array）

public class ArrayType {
    public static void main(String[] args) {
        // 一维数组
        int[] numbers = new int[5];  // 默认值：0
        numbers[0] = 10;
        numbers[1] = 20;
        
        int[] scores = {95, 87, 76, 92};  // 静态初始化
        
        System.out.println("第一个数: " + numbers[0]);
        System.out.println("数组长度: " + scores.length);
        
        // 二维数组
        int[][] matrix = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };
        System.out.println("中间元素: " + matrix[1][1]);  // 5
        
        // 对象数组
        Person[] people = new Person[3];
        people[0] = new Person("王五", 30);
        people[1] = new Person("赵六", 28);
        
        // 遍历数组
        for (Person p : people) {
            if (p != null) {
                p.introduce();
            }
        }
        
        // 多维不规则数组
        int[][] jagged = new int[3][];
        jagged[0] = new int[]{1, 2};
        jagged[1] = new int[]{3, 4, 5};
        jagged[2] = new int[]{6};
    }
}

4. 枚举（Enum）

// 定义枚举
enum Season {
    SPRING("春", 1),
    SUMMER("夏", 2),
    AUTUMN("秋", 3),
    WINTER("冬", 4);
    
    private String name;
    private int code;
    
    Season(String name, int code) {
        this.name = name;
        this.code = code;
    }
    
    public String getName() {
        return name;
    }
    
    public int getCode() {
        return code;
    }
}

public class EnumType {
    public static void main(String[] args) {
        Season season = Season.SPRING;
        
        System.out.println("季节: " + season);
        System.out.println("名称: " + season.getName());
        System.out.println("代码: " + season.getCode());
        
        // 遍历枚举
        for (Season s : Season.values()) {
            System.out.println(s + ": " + s.getName());
        }
        
        // switch中使用枚举
        switch (season) {
            case SPRING:
                System.out.println("春天来了");
                break;
            case SUMMER:
                System.out.println("夏天来了");
                break;
            default:
                System.out.println("其他季节");
        }
    }
}

5. 字符串（String）

public class StringType {
    public static void main(String[] args) {
        // 创建字符串
        String str1 = "Hello";
        String str2 = new String("World");
        String str3 = "Hello";
        
        // 字符串池（常量池）机制
        System.out.println(str1 == str3);      // true（指向同一个对象）
        System.out.println(str1 == str2);      // false（不同对象）
        System.out.println(str1.equals(str2)); // false
        
        // 字符串操作
        String str4 = str1 + " " + str2;       // 拼接
        System.out.println(str4);  // Hello World
        
        System.out.println("长度: " + str4.length());
        System.out.println("大写: " + str4.toUpperCase());
        System.out.println("子串: " + str4.substring(6));  // World
        System.out.println("替换: " + str4.replace('o', 'O'));
        
        // StringBuilder（可变字符串）
        StringBuilder sb = new StringBuilder();
        sb.append("Hello");
        sb.append(" ");
        sb.append("World");
        sb.insert(5, ",");
        System.out.println("StringBuilder: " + sb);  // Hello, World
    }
}

三、变量类型

变量类型指的是变量可以存储什么类型的数据以及如何存储这些数据。简单来说，变量类型决定了：

• 变量能存什么值（数字、文字、true/false等）

• 占用多少内存空间

• 可以做什么操作

在Java中，变量类型主要分为三类：局部变量、实例变量（成员变量）和静态变量（类变量）。让我详细说明每种类型及其使用场景。

局部变量

局部变量是在方法、构造函数或块内部声明的变量，它们在声明的方法、构造函数或块执行结束后被销毁，局部变量在声明时需要初始化，否则会导致编译错误。

public void exampleMethod() {
    int localVar = 10; // 局部变量
    // ...
}

实例变量

实例变量是在类中声明，但在方法、构造函数或块之外，它们属于类的实例，每个类的实例都有自己的副本，如果不明确初始化，实例变量会被赋予默认值（数值类型为0，boolean类型为false，对象引用类型为null）。

public class ExampleClass {
    int instanceVar; // 实例变量
}

静态变量和类变量

类变量是在类中用 static 关键字声明的变量，它们属于类而不是实例，所有该类的实例共享同一个类变量的值，类变量在类加载时被初始化，而且只初始化一次。

public class ExampleClass {
    static int classVar; // 类变量
}

参数变量

参数是方法或构造函数声明中的变量，用于接收调用该方法或构造函数时传递的值，参数变量的作用域只限于方法内部。

public void exampleMethod(int parameterVar) {
    // 参数变量
    // ...
}