Java 修饰符

Java 修饰符

Java 修饰符是用来控制类、变量、方法和构造函数的访问权限和行为的特殊关键字。

✅ Java 修饰符主要分为两类：

• 访问修饰符（Access Modifiers）
• 非访问修饰符（Non-Access Modifiers）

下面是包含类、变量、方法和构造函数的Person类，展示了各种修饰符的合理使用：

public class Person {    // public类 - 任何其他类都能访问
    private String name;    // private变量 - 只能在本类中使用
    private int age;

    public Person(String name, int age) {   // public构造方法 - 所有类都能使用
        this.name = name;
        this.age = age;
    }

    protected void celebrateBirthday() {    // protected方法 - 只能被本类、子类和同包类使用
        System.out.println(name + "过生日啦！现在年龄：" + age);
    }

    public void introduce() {   // public方法 - 所有类都能使用
        System.out.println("大家好，我是" + name + "，今年" + age + "岁");
    }
}

---

访问修饰符 (Access Modifiers)

✅ 控制访问级别的修饰符：

• public：对所有类可见。适用场景：类、方法、变量、构造器。
• protected：对同一包内的类和所有子类可见。适用场景：变量、方法。注意：不能修饰类（Class）
• default：仅对同一包（package）内的类可见，不使用任何修饰符。适用场景：类、变量、方法构造器。
• private：仅对当前类可见。适用场景：变量、方法。注意：不能修饰类（Class）

✅ 访问修饰符权限一览表：

1. 公有访问修饰符（public）

在面向对象编程中，public是最开放的访问修饰符，它表示被修饰的成员（属性、方法、类等）可以被任何其他代码访问，无论这些代码是否在同一个类、同一个包或不同的包中。

这种公有访问修饰符通常将类提供给外部使用的接口方法中。

✅ 如下例所示，使用了公有访问控制修饰符：

public class MyClass {
    public int publicField;  // 公有字段

    public void publicMethod() {  // 公有方法
        System.out.println("这是一个公有方法");
    }
}

2. 受保护的访问修饰符（protected）

protected是面向对象编程中的一种访问控制修饰符，它提供了比private更宽松但比public更严格的访问权限。

这种受保护的访问修饰符可以被类的成员函数访问，也可以被派生类成员函数访问。

✅ 如下例所示，使用了受保护的访问控制修饰符：

// 基类
class Parent {
    protected int protectedValue = 10;  // protected变量

    protected void showValue() {        // protected方法
        System.out.println("父类的值: " + protectedValue);
    }
}

// 派生类
class Child extends Parent {
    public void changeValue() {
        protectedValue = 20;  // 可以访问父类的protected变量
        System.out.println("修改后的值: " + protectedValue);
    }

    public void callParentMethod() {
        showValue();  // 可以调用父类的protected方法
    }
}

// 测试类
public class Main {
    public static void main(String[] args) {
        Child child = new Child();

        child.callParentMethod();  // 输出: 父类的值: 10
        child.changeValue();       // 输出: 修改后的值: 20
        child.callParentMethod();  // 输出: 父类的值: 20

        // 下面这行会报错 - 类外不能直接访问protected成员
        // child.protectedValue = 30;  // 错误
        // child.showValue();         // 错误
    }
}

3. 默认访问修饰符

如果类、变量、方法或构造函数的定义中没有显式指定任何访问修饰符（如public、protected或private），那么它们将默认具有包级私有（package-private）访问权限。

这种默认访问修饰符意味着这些成员只能被同一个包内的其他类访问，而不能被其他包中的类访问。

需要注意的是，对于类而言，如果没有指定访问修饰符，它只能是包级私有的或者是嵌套类（内部类）；而顶层类（非嵌套类）要么是public的，要么是包级私有的。

✅ 如下例所示，类、变量和方法的声明可以不使用任何修饰符：

// 文件1: Employee.java (包 com.company)
package com.company;

// 默认访问修饰符的类（仅当前包可见）
class Employee {
    // 默认访问修饰符的变量（仅当前包可见）
    String name;
    int age;

    // 默认访问修饰符的构造方法（仅当前包可见）
    Employee(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 默认访问修饰符的方法（仅当前包可见）
    void displayInfo() {
        System.out.println("员工姓名: " + name + ", 年龄: " + age);
    }
}

// 文件2: Main.java (包 com.company)
package com.company;

public class Main {
    public static void main(String[] args) {
        // 同包中可以访问默认修饰符的类、构造方法、变量和方法
        Employee emp = new Employee("张三", 28);
        emp.name = "李四";  // 可以访问默认修饰符的变量
        emp.displayInfo(); // 可以调用默认修饰符的方法
    }
}

以上实例中，Employee类和它的成员变量name、age以及方法displayInfo()都使用默认访问修饰符进行了定义。Main类与Employee类在同一包中（com.company），因此可以访问Employee类及其所有默认访问权限的成员变量和方法。

4. 私有访问修饰符（private）

private是面向对象编程中的一种访问控制修饰符（access modifier），用于限制类成员的访问权限。

使用private修饰的成员（字段、方法、内部类等）只能在声明它们的类内部访问，其他类（包括子类）都无法直接访问。

✅ 如下例所示，使用了私有访问修饰符：

public class Cat {
    // private字段：只有本类能直接访问
    private String secretName = "喵小黑";

    // public方法：外部通过这个方法间接访问private字段
    public String getSecretName() {
        return secretName;
    }
}

public class Test {
    public static void main(String[] args) {
        Cat cat = new Cat();
        // System.out.println(cat.secretName);  // 报错！private字段不能直接访问
        System.out.println(cat.getSecretName()); // 正确：通过public方法访问
    }
}

---

非访问修饰符 (Non-Access Modifiers)

非访问修饰符是用来控制类、方法、变量等行为的修饰符，它们不控制访问权限，而是提供其他方面的控制。

✅ 提供其他功能的修饰符：

1. static 修饰符

static表示 "静态的"，用于修饰静态变量、静态方法，使其成为类成员而非实例成员。

类成员（static 成员）解决了成员数据共享、不依赖实例的操作、类级别初始化和配置和内存效率考虑等问题。

类成员（static 成员）与实例成员的关键区别：

✅ 以下是定义了静态变量（类变量）和静态方法的实例代码：

public class Counter {
    // 静态变量（类变量）
    static int count = 0;  // 所有对象共享

    // 静态方法
    static void increment() {
        count++;  // 修改静态变量
    }

    public static void main(String[] args) {
        Counter.increment();  // 直接通过类名调用静态方法
        Counter.increment();

        System.out.println("当前计数: " + Counter.count);  // 输出: 当前计数: 2
    }
}

2. final 修饰符

final表示 "最终的"，用于修饰变量、方法和类，使其成为不可修改的常量或不可继承的实体。

该修饰符确保了数据的不可变性约束、方法行为的稳定性保持以及类继承的精确控制。

✅ final修饰符核心特性：

✅ 以下定义了final的变量、方法和类的实例代码：

// 1. final类 - 不能被继承
final class MyFinalClass {
    // 2. final变量 - 常量
    final int CONSTANT = 100;
    static final double PI = 3.14159;

    // 3. final方法 - 不能被子类重写
    final void showFinalMethod() {
        System.out.println("Final方法，值: " + CONSTANT);
    }

    void showNormalMethod() {
        System.out.println("普通方法，PI: " + PI);
    }
}

public class FinalKeywordDemo {
    public static void main(String[] args) {
        MyFinalClass obj = new MyFinalClass();

        // 使用final变量
        System.out.println("常量值: " + obj.CONSTANT);
        System.out.println("静态常量PI: " + MyFinalClass.PI);

        // 调用方法
        obj.showFinalMethod();
        obj.showNormalMethod();

        // final局部变量
        final String message = "Hello, final!";
        System.out.println(message);
    }
}

其他的修饰符在这里就一一不介绍了，后续会在代码笔记栏目中陆续补全。

---

---