Java 关键字与标识符

在 Java 中，关键字是语言保留的特殊单词，不能用作标识符。标识符是程序员定义的名称，用于标识类、方法、变量等。理解关键字和标识符的规则，是编写正确 Java 代码的基础。

Java 保留字与关键字

什么是关键字

关键字（Keywords） 是 Java 语言中具有特殊含义的保留字，不能用作变量名、类名、方法名等标识符。

Java 关键字列表

访问控制

• public：公共的，可以被任何类访问
• private：私有的，只能在本类中访问
• protected：受保护的，可以在本类、同包和子类中访问
• default（隐式）：包私有，只能在同一包中访问

类、方法和变量修饰符

• class：定义类
• interface：定义接口
• abstract：抽象的
• final：最终的，不可修改
• static：静态的
• synchronized：同步的
• volatile：易变的
• transient：瞬态的
• native：本地的

程序控制

• if：条件判断
• else：否则
• switch：多分支选择
• case：分支
• default：默认分支
• for：for 循环
• while：while 循环
• do：do-while 循环
• break：跳出循环或 switch
• continue：继续下一次循环
• return：返回

异常处理

• try：尝试执行
• catch：捕获异常
• finally：最终执行
• throw：抛出异常
• throws：声明可能抛出的异常

面向对象

• extends：继承
• implements：实现接口
• this：当前对象
• super：父类对象
• new：创建对象
• instanceof：判断对象类型

数据类型

• byte：字节型
• short：短整型
• int：整型
• long：长整型
• float：单精度浮点型
• double：双精度浮点型
• char：字符型
• boolean：布尔型
• void：无返回值

其他

• package：包声明
• import：导入
• enum：枚举
• assert：断言
• const：保留字（未使用）
• goto：保留字（未使用）

关键字使用示例

// 类定义
public class Student {
    // 变量修饰符
    private String name;
    private static int count;
    private final int id;
    
    // 构造方法
    public Student(String name, int id) {
        this.name = name;
        this.id = id;
        count++;
    }
    
    // 方法
    public void study() {
        if (name != null) {
            System.out.println(name + " is studying");
        }
    }
    
    // 静态方法
    public static int getCount() {
        return count;
    }
}

合法标识符命名规则

什么是标识符

标识符（Identifier） 是程序员定义的名称，用于标识：

• 类名
• 方法名
• 变量名
• 包名
• 接口名
• 常量名

命名规则

1. 基本规则

• 必须以字母、下划线（_）或美元符号（$）开头
• 后续字符可以是字母、数字、下划线或美元符号
• 不能是关键字或保留字
• 区分大小写
• 没有长度限制（但建议合理长度）

2. 合法标识符示例

// ✅ 合法
String name;
int age;
double _price;
String $value;
int studentCount;
String firstName;
int MAX_SIZE;
String user_name;

3. 非法标识符示例

// ❌ 非法：以数字开头
int 2name;

// ❌ 非法：包含特殊字符
String user-name;
int user@id;

// ❌ 非法：是关键字
int class;
String public;

// ❌ 非法：包含空格
String user name;

标识符分类

1. 类名和接口名

规范：大驼峰命名（PascalCase）

// ✅ 正确
public class StudentManager { }
public class UserService { }
public interface Runnable { }
public interface Comparable { }

// ❌ 错误
public class studentManager { }  // 应该首字母大写
public class user_service { }    // 应该使用驼峰命名

2. 方法名和变量名

规范：小驼峰命名（camelCase）

// ✅ 正确
public void getUserName() { }
public void calculateTotal() { }
int studentCount = 10;
String firstName = "John";

// ❌ 错误
public void GetUserName() { }  // 应该首字母小写
int student_count = 10;        // 应该使用驼峰命名

3. 常量名

规范：全大写下划线分隔（UPPER_SNAKE_CASE）

// ✅ 正确
public static final int MAX_SIZE = 100;
public static final String DEFAULT_NAME = "Unknown";
public static final double PI = 3.14159;

// ❌ 错误
public static final int maxSize = 100;      // 应该全大写
public static final String defaultName = "Unknown";  // 应该全大写

4. 包名

规范：全小写，点分隔

// ✅ 正确
package com.example.project;
package org.apache.commons;

// ❌ 错误
package com.Example.Project;  // 应该全小写
package COM.EXAMPLE;           // 应该全小写

命名规范与常用约定

Java 命名约定总结

类型	命名规范	示例
类名	大驼峰（PascalCase）	StudentManager
接口名	大驼峰（PascalCase）	Runnable
方法名	小驼峰（camelCase）	getUserName()
变量名	小驼峰（camelCase）	studentCount
常量名	全大写下划线（UPPER_SNAKE_CASE）	MAX_SIZE
包名	全小写，点分隔	com.example.project
参数名	小驼峰（camelCase）	userName
局部变量	小驼峰（camelCase）	tempValue

命名最佳实践

1. 使用有意义的名称

// ✅ 好：名称清晰表达含义
int studentCount;
String userName;
public void calculateTotalPrice() { }

// ❌ 差：名称不清晰
int x;
String s;
public void calc() { }

2. 避免缩写（除非是通用缩写）

// ✅ 好：清晰完整
String userName;
int studentCount;

// ⚠️ 可接受：通用缩写
String id;  // ID 是通用缩写
String url; // URL 是通用缩写

// ❌ 差：不清晰的缩写
String usrNm;
int stdCnt;

3. 布尔变量使用 is/has/can 前缀

// ✅ 好：布尔变量命名
boolean isActive;
boolean hasPermission;
boolean canEdit;
boolean isEmpty;

// ❌ 差：不够清晰
boolean active;
boolean permission;

4. 集合使用复数形式

// ✅ 好：集合使用复数
List<Student> students;
Map<String, User> users;
Set<String> names;

// ❌ 差：单数形式
List<Student> student;

5. 方法名使用动词

// ✅ 好：方法名是动词
public void calculateTotal() { }
public String getUserName() { }
public boolean isValid() { }

// ❌ 差：方法名是名词
public void total() { }
public String userName() { }

常见命名模式

Getter 和 Setter 方法

public class Student {
    private String name;
    private int age;
    
    // Getter：get + 属性名（首字母大写）
    public String getName() {
        return name;
    }
    
    // Setter：set + 属性名（首字母大写）
    public void setName(String name) {
        this.name = name;
    }
    
    // 布尔类型使用 is 前缀
    private boolean active;
    
    public boolean isActive() {
        return active;
    }
}

构造方法

// 构造方法名与类名相同
public class Student {
    public Student() { }  // 无参构造
    public Student(String name) { }  // 有参构造
}

常量

public class Constants {
    // 公共常量
    public static final int MAX_SIZE = 100;
    public static final String DEFAULT_NAME = "Unknown";
    
    // 私有常量
    private static final int INTERNAL_VALUE = 50;
}

实际示例

示例 1：完整的类定义

package com.example.model;

// 类名：大驼峰
public class StudentManager {
    // 常量：全大写下划线
    private static final int MAX_STUDENTS = 100;
    
    // 静态变量：小驼峰
    private static int studentCount = 0;
    
    // 实例变量：小驼峰
    private String managerName;
    private List<Student> students;
    
    // 构造方法：与类名相同
    public StudentManager(String managerName) {
        this.managerName = managerName;
        this.students = new ArrayList<>();
    }
    
    // 方法名：小驼峰，动词开头
    public void addStudent(Student student) {
        if (students.size() < MAX_STUDENTS) {
            students.add(student);
            studentCount++;
        }
    }
    
    // Getter：get + 属性名
    public String getManagerName() {
        return managerName;
    }
    
    // 布尔方法：is + 属性名
    public boolean isEmpty() {
        return students.isEmpty();
    }
}

示例 2：接口定义

// 接口名：大驼峰，通常以 -able 或 I- 开头（可选）
public interface Runnable {
    // 方法名：小驼峰
    void run();
}

public interface Comparable<T> {
    int compareTo(T other);
}

示例 3：枚举定义

// 枚举名：大驼峰
public enum Status {
    // 枚举值：全大写下划线
    ACTIVE,
    INACTIVE,
    PENDING
}

小结

Java 关键字与标识符要点：

• 关键字：语言保留的特殊单词，不能用作标识符
• 标识符规则：字母/下划线/$ 开头，后续可以是字母/数字/下划线/$
• 命名规范：类名大驼峰、方法变量小驼峰、常量全大写
• 最佳实践：有意义、清晰、遵循约定

关键规则：

• 不能使用关键字作为标识符
• 标识符区分大小写
• 遵循命名规范提高代码可读性
• 使用有意义的名称

掌握了关键字和标识符的规则，你就能编写规范的 Java 代码。在下一章，我们将学习 Java 的数据类型。