变量与常量

变量和常量是程序中存储数据的基本单元。

变量

变量三要素：类型、名称、值

// 完整声明
int age;        // 声明变量
age = 25;       // 赋值

// 声明时初始化
int score = 100;

// 多个同类型变量
int x = 1, y = 2, z = 3;

变量分类

类型	声明位置	生命周期	默认值
局部变量	方法或代码块内部	方法/代码块执行期间	无（必须初始化）
实例变量	类中，方法外	对象存在期间	有默认值
静态变量	类中，方法外，static 修饰	程序运行期间	有默认值

public class Variables {
    // 实例变量
    private String name = "Java";

    // 静态变量
    private static int count = 0;

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

命名规范

// GOOD: 有意义的命名
int userAge;
String userName;
boolean isActive;

// BAD: 无意义的命名
int a;
String n;
boolean flag;

常量

使用 final 关键字修饰，定义后不能被修改。

// 声明常量
final int MAX_COUNT = 100;
final String APP_NAME = "MyApp";

// 尝试修改会编译错误
// MAX_COUNT = 200;  // 编译错误

命名规范

常量名称使用大写字母和下划线。

// GOOD
final int MAX_RETRY_COUNT = 3;
final String DEFAULT_CHARSET = "UTF-8";
final double PI = 3.14159;

// BAD
final int maxCount = 3;      // 应该全大写
final int MAX_COUNT = 3;     // 应该用下划线

静态常量

使用 static final 修饰。

public class Constants {
    // 静态常量 - 推荐
    public static final int MAX_SIZE = 1000;

    // 实例常量 - 不推荐
    public final int INSTANCE_CONST = 1;
}

何时使用常量

用常量替代魔法值（Magic Number），让代码更易读。

public class UserService {
    // 使用常量替代魔法值
    private static final int MAX_LOGIN_ATTEMPTS = 5;
    private static final int PASSWORD_MIN_LENGTH = 6;
    private static final int PASSWORD_MAX_LENGTH = 20;
    private static final String DEFAULT_ROLE = "USER";

    public boolean login(String password, int attempts) {
        if (attempts > MAX_LOGIN_ATTEMPTS) {
            return false;
        }

        return password.length() >= PASSWORD_MIN_LENGTH
            && password.length() <= PASSWORD_MAX_LENGTH;
    }
}

成员变量 vs 局部变量

对比项	成员变量	局部变量
声明位置	类中，方法外	方法内或代码块内
修饰符	public/private/static 等	无
存储位置	堆内存	栈内存
生命周期	对象存在期间	方法/代码块执行期间
默认值	有	无（必须显式初始化）
初始化	自动初始化	必须手动初始化

public class Example {
    // 成员变量 - 有默认值
    private String name;      // 默认 null
    private int age;          // 默认 0
    private boolean active;   // 默认 false

    public void method() {
        // 局部变量 - 必须初始化
        int count = 0;
        // 编译错误：count 未初始化
        // System.out.println(count);

        count = 10;  // 必须先赋值
        System.out.println(count);  // OK
    }
}

变量的作用域

public class ScopeDemo {
    private int classScope = 1;  // 类作用域

    public void method() {
        int methodScope = 2;  // 方法作用域

        if (true) {
            int blockScope = 3;  // 代码块作用域

            // 可以访问外部变量
            System.out.println(classScope);
            System.out.println(methodScope);
            System.out.println(blockScope);
        }

        // 超出作用域，无法访问 blockScope
        // System.out.println(blockScope);
    }
}

作用域屏蔽

同名变量在内部代码块会屏蔽外部变量。

int count = 10;

if (true) {
    // 内部 count 屏蔽了外部 count
    int count = 20;  // 编译错误：变量已定义
}

// 同名变量应使用不同代码块
if (true) {
    int count = 20;  // 这是新变量
}
System.out.println(count);  // 输出 10

常量应用场景

配置常量

public class AppConfig {
    public static final String APP_NAME = "JTechVault";
    public static final String VERSION = "1.0.0";
    public static final String AUTHOR = "Java Developer";
}

状态常量

public class OrderStatus {
    public static final int PENDING = 0;
    public static final int PAID = 1;
    public static final int SHIPPED = 2;
    public static final int DELIVERED = 3;
    public static final int CANCELLED = 4;

    public static String getStatusName(int status) {
        switch (status) {
            case PENDING: return "待支付";
            case PAID: return "已支付";
            case SHIPPED: return "已发货";
            case DELIVERED: return "已送达";
            case CANCELLED: return "已取消";
            default: return "未知状态";
        }
    }
}

限制常量

public class UserValidator {
    private static final int MIN_AGE = 0;
    private static final int MAX_AGE = 150;
    private static final int MIN_NAME_LENGTH = 2;
    private static final int MAX_NAME_LENGTH = 50;

    public boolean validateAge(int age) {
        return age >= MIN_AGE && age <= MAX_AGE;
    }

    public boolean validateName(String name) {
        return name != null
            && name.length() >= MIN_NAME_LENGTH
            && name.length() <= MAX_NAME_LENGTH;
    }
}

最佳实践

变量初始化

// GOOD: 声明时初始化
int count = 0;
String name = "";

// GOOD: 使用前初始化
int result;
if (condition) {
    result = 1;
} else {
    result = 2;
}

// BAD: 声明但不初始化
int count;
System.out.println(count);  // 编译错误

常量集中管理

// GOOD: 常量类统一管理
public class SystemConstants {
    public static final int PAGE_SIZE_DEFAULT = 20;
    public static final int PAGE_SIZE_MAX = 100;
    public static final int SESSION_TIMEOUT = 1800;  // 秒
}

// BAD: 常量分散定义
public class UserService {
    public static final int PAGE_SIZE = 20;
}

public class OrderService {
    public static final int PAGE_SIZE = 20;  // 重复定义
}

使用 enum 代替常量组

// BAD: 使用 int 常量
public static final int STATUS_SUCCESS = 1;
public static final int STATUS_FAIL = 0;

// GOOD: 使用枚举
public enum Status {
    SUCCESS,
    FAIL
}