🔢 数据类型与变量

数据类型分类

Java 的数据类型分为两大类：

1. 基本数据类型（Primitive Types）：8 种
2. 引用数据类型（Reference Types）：类、接口、数组等

基本数据类型

数值类型

整数类型

类型	大小	取值范围	默认值
byte	1 字节	-128 ~ 127	0
short	2 字节	-32,768 ~ 32,767	0
int	4 字节	-2³¹ ~ 2³¹-1	0
long	8 字节	-2⁶³ ~ 2⁶³-1	0L

byte b = 100;
short s = 1000;
int i = 100000;
long l = 10000000000L;  // long 类型需要加 L 或 l 后缀

// 进制表示
int binary = 0b1010;    // 二进制：10
int octal = 012;        // 八进制：10
int hex = 0xFF;         // 十六进制：255

浮点类型

类型	大小	精度	默认值
float	4 字节	约 7 位有效数字	0.0f
double	8 字节	约 15 位有效数字	0.0d

float f = 3.14f;        // float 需要加 f 或 F 后缀
double d = 3.141592653589793;

// 科学计数法
double scientific = 1.23e5;  // 123000.0

字符类型

类型	大小	取值范围	默认值
char	2 字节	'\u0000' ~ '\uffff' (0 ~ 65535)	'\u0000'

char c1 = 'A';
char c2 = 65;           // Unicode 码
char c3 = '\u0041';     // Unicode 转义
char c4 = '\n';         // 转义字符

// 字符运算
char ch = 'A';
System.out.println(ch + 1);  // 输出：66 (字符转换为 int)

布尔类型

类型	大小	取值	默认值
boolean	JVM 实现相关	true 或 false	false

boolean isActive = true;
boolean isFinished = false;

// 布尔表达式
boolean result = (5 > 3);  // true

变量

变量声明

// 声明变量
int age;
String name;

// 声明并初始化
int age = 25;
String name = "张三";

// 同时声明多个变量
int x = 1, y = 2, z = 3;

变量类型

1. 局部变量（Local Variable）

在方法、构造方法或语句块中定义的变量：

public void method() {
    int localVar = 10;  // 局部变量
    System.out.println(localVar);
}

特点：

• 必须显式初始化才能使用
• 作用域仅限于定义它的代码块
• 存储在栈内存中

2. 实例变量（Instance Variable）

在类中但在方法外定义的变量：

public class Student {
    private String name;  // 实例变量
    private int age;      // 实例变量
    
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

特点：

• 有默认值（数值类型为 0，boolean 为 false，引用类型为 null）
• 每个对象都有独立的副本
• 存储在堆内存中

3. 类变量（静态变量，Static Variable）

使用 static 关键字声明的变量：

public class Counter {
    private static int count = 0;  // 类变量
    
    public static void increment() {
        count++;
    }
}

特点：

• 属于类，所有实例共享
• 可以通过类名直接访问
• 存储在方法区

常量

使用 final 关键字定义常量：

// 常量命名通常使用全大写
final int MAX_SIZE = 100;
final String COMPANY_NAME = "My Company";

// 静态常量
public static final double PI = 3.14159;

// 对象常量（引用不可变，但对象内容可变）
final List<String> list = new ArrayList<>();
list.add("item");  // ✅ 可以
// list = new ArrayList<>();  // ❌ 错误

类型转换

自动类型转换（隐式转换）

小类型自动转换为大类型：

byte b = 10;
int i = b;        // byte → int（自动转换）

int i = 100;
long l = i;       // int → long（自动转换）

float f = 3.14f;
double d = f;     // float → double（自动转换）

char c = 'A';
int i = c;        // char → int（自动转换，取 Unicode 码）

转换规则：

byte → short → int → long → float → double
         ↑
        char

强制类型转换（显式转换）

大类型转换为小类型需要强制转换：

int i = 100;
byte b = (byte) i;  // int → byte（强制转换）

double d = 3.14;
int i = (int) d;    // double → int（强制转换，丢失小数部分）

long l = 10000000000L;
int i = (int) l;    // 可能溢出

注意事项：

• 可能丢失精度或溢出
• 需要显式指定目标类型

double d = 3.999;
int i = (int) d;    // i = 3（截断，不是四舍五入）

int i = 300;
byte b = (byte) i;  // b = 44（溢出，300 超出 byte 范围）

包装类（Wrapper Classes）

基本数据类型对应的包装类：

基本类型	包装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

装箱和拆箱

// 自动装箱（Autoboxing）
Integer i = 10;        // 自动将 int 转换为 Integer

// 自动拆箱（Unboxing）
int value = i;         // 自动将 Integer 转换为 int

// 手动装箱
Integer i1 = Integer.valueOf(10);
Integer i2 = new Integer(10);  // 不推荐，已废弃

// 手动拆箱
int value = i1.intValue();

包装类的使用

// 字符串转换
String str = "123";
int num = Integer.parseInt(str);      // 字符串转 int
String numStr = String.valueOf(123);  // int 转字符串

// 最大值和最小值
int max = Integer.MAX_VALUE;  // 2147483647
int min = Integer.MIN_VALUE;  // -2147483648

// 进制转换
String binary = Integer.toBinaryString(10);  // "1010"
String hex = Integer.toHexString(255);       // "ff"

字符串类型

String 类

// 字符串创建
String str1 = "Hello";
String str2 = new String("Hello");
char[] chars = {'H', 'e', 'l', 'l', 'o'};
String str3 = new String(chars);

// 字符串是不可变的
String s = "Hello";
s = s + " World";  // 创建新对象，原对象不变

字符串操作

String str = "Hello World";

// 长度
int length = str.length();  // 11

// 连接
String result = str.concat(" Java");  // "Hello World Java"
String result2 = str + " Java";       // 使用 + 运算符

// 比较
boolean equals = str.equals("Hello World");      // true
boolean equalsIgnoreCase = str.equalsIgnoreCase("hello world");  // true
int compare = str.compareTo("Hello");  // 返回差值

// 查找
boolean contains = str.contains("World");  // true
int index = str.indexOf("World");          // 6
int lastIndex = str.lastIndexOf("l");      // 9

// 提取
String sub = str.substring(0, 5);         // "Hello"
char ch = str.charAt(0);                  // 'H'

// 替换
String replaced = str.replace("World", "Java");  // "Hello Java"

// 分割
String[] parts = str.split(" ");           // ["Hello", "World"]

// 转换大小写
String upper = str.toUpperCase();          // "HELLO WORLD"
String lower = str.toLowerCase();          // "hello world"

// 去除空格
String trimmed = "  Hello  ".trim();       // "Hello"

引用数据类型

数组

// 数组声明和初始化
int[] arr1 = new int[5];              // 声明长度为 5 的数组
int[] arr2 = {1, 2, 3, 4, 5};         // 直接初始化
int[] arr3 = new int[]{1, 2, 3};      // 另一种初始化方式

// 访问数组元素
int first = arr2[0];                  // 1
arr2[0] = 10;                         // 修改元素

// 数组长度
int length = arr2.length;             // 5

对象引用

// 创建对象
String str = new String("Hello");
Student student = new Student("张三", 25);

// 引用传递
String s1 = "Hello";
String s2 = s1;  // s1 和 s2 指向同一个对象

默认值

基本数据类型默认值

byte b;        // 0
short s;       // 0
int i;         // 0
long l;        // 0L
float f;       // 0.0f
double d;      // 0.0d
char c;        // '\u0000'
boolean bool;  // false

引用数据类型默认值

String str;    // null
Object obj;    // null
int[] arr;     // null

作用域

public class ScopeDemo {
    private int instanceVar = 10;  // 实例变量
    private static int classVar = 20;  // 类变量
    
    public void method() {
        int localVar = 30;  // 局部变量
        
        {
            int blockVar = 40;  // 块变量
            System.out.println(blockVar);  // 可以访问
        }
        // System.out.println(blockVar);  // ❌ 错误，超出作用域
    }
}

完整示例

public class DataTypeDemo {
    // 类变量
    private static int count = 0;
    
    // 实例变量
    private String name;
    private int age;
    
    public DataTypeDemo(String name, int age) {
        this.name = name;
        this.age = age;
        count++;
    }
    
    public void displayInfo() {
        // 局部变量
        String info = "姓名: " + name + ", 年龄: " + age;
        System.out.println(info);
        System.out.println("总计数: " + count);
    }
    
    public static void main(String[] args) {
        // 基本数据类型
        byte b = 100;
        short s = 1000;
        int i = 100000;
        long l = 10000000000L;
        float f = 3.14f;
        double d = 3.14159;
        char c = 'A';
        boolean bool = true;
        
        // 引用数据类型
        String str = "Hello World";
        DataTypeDemo demo = new DataTypeDemo("张三", 25);
        
        // 类型转换
        int intValue = (int) d;  // 3
        double doubleValue = i;  // 100000.0
        
        // 包装类
        Integer integer = 100;
        int primitive = integer;
        
        demo.displayInfo();
    }
}

下一步

了解了数据类型和变量后，可以继续学习：

• 运算符与表达式 - 学习各种运算符的使用
• 控制流程 - 学习条件语句和循环

---

💡 提示：理解数据类型和变量是掌握 Java 编程的基础