钟文志的部落格

在 Java 中，访问修饰符用于控制类、方法、变量以及构造函数的访问权限。Java 提供了四种不同的访问修饰符：

public：public 修饰符表示该类、方法、变量或构造函数可以被任何其他类访问。即公共的，没有访问限制。
private：private 修饰符表示该类、方法、变量或构造函数只能被其所在类内部的其他成员访问。即私有的，只能在类的内部访问。
protected：protected 修饰符表示该类、方法、变量或构造函数只能被其所在类内部的其他成员访问，以及该类的子类访问。即受保护的，可以在类的内部和子类中访问。
默认（不使用任何修饰符）：如果没有使用上述三种修饰符之一，那么默认的访问修饰符将被应用。默认修饰符表示该类、方法、变量或构造函数只能被同一个包内的其他类访问。即包级私有的，只能在同一个包内访问。

下面是一些示例：

public class MyClass {
    public int publicVariable;
    private int privateVariable;
    protected int protectedVariable;
    int defaultVariable; // 默认访问修饰符，相当于包级私有

    public void publicMethod() {
        // 可以访问所有成员
    }

    private void privateMethod() {
        // 只能在类的内部访问
    }

    protected void protectedMethod() {
        // 可以在类的内部和子类中访问
    }

    void defaultMethod() {
        // 只能在同一个包内访问
    }
}

需要根据具体的需求选择适当的访问修饰符，以保证代码的封装性和安全性。

public 修饰符

public 修饰符是 Java 中访问修饰符的一种，它用于声明一个类、方法、变量或接口可以被任何其他类访问。具体来说，使用 public 修饰符可以使得被修饰的类、方法、变量或接口在整个程序中都是可见和可访问的。

下面是一些 public 修饰符的用法和特点：

类：使用 public 修饰符声明的类可以被任何其他类访问。这意味着其他类可以创建该类的对象，并且可以访问该类的公共成员（字段和方法）。
方法：使用 public 修饰符声明的方法可以被任何其他类调用。这意味着其他类可以通过对象引用或类名调用该方法。
变量：使用 public 修饰符声明的变量可以被任何其他类访问。这意味着其他类可以读取和修改该变量的值。
接口：使用 public 修饰符声明的接口可以被任何其他类实现。这意味着其他类可以实现该接口，并根据接口定义的规范提供相应的实现。

需要注意的是，使用 public 修饰符并不意味着该类、方法、变量或接口就是全局可见的。在不同的包package或模块module中，需要根据访问修饰符的规则来确定是否可以访问 public 成员。

private 修饰符

private 修饰符是 Java 中的访问修饰符之一，它用于声明一个类的成员（字段和方法）只能在当前类内部访问。具体来说，使用 private 修饰符可以限制对类的成员的访问，使其只能在声明该成员的类中被访问。

下面是一些 private 修饰符的用法和特点：

成员：使用 private 修饰符声明的成员（字段和方法）只能在声明该成员的类中直接访问。这意味着其他类无法直接访问该成员，只有在当前类的内部才能使用。
封装：private 修饰符实现了封装（Encapsulation）的概念，即将类的内部细节隐藏起来，只暴露必要的接口给外部使用。通过将成员设置为 private，可以防止外部类直接修改类的内部状态，提高了类的安全性和可维护性。
Getter和Setter方法：通常情况下，如果需要在外部访问私有成员，可以通过公共的Getter和Setter方法来间接获取和修改私有成员的值。Getter方法用于获取私有字段的值，Setter方法用于设置私有字段的值。

需要注意的是，private 修饰符仅限于当前类的内部访问，其他类无法直接访问私有成员。但是，可以通过反射机制来绕过 private 修饰符的限制，但这不是推荐的做法，因为它破坏了封装性。

protected 修饰符

在 Java 中，protected 是一种访问修饰符，用于控制成员变量和方法的可见性和访问权限。当使用 protected 修饰符时，成员变量和方法可以在同一包内的其他类和子类中访问，但不能在不同包中的非子类中访问。

下面是一些关于 protected 修饰符的重要点：

可以在类、接口、成员变量和方法上使用 protected 修饰符。
protected 成员可以在同一包内的其他类中被访问。
protected 成员可以在不同包中的子类中被访问。
protected 成员不能在不同包中的非子类中被访问。
protected 成员对于同一包中的其他类和不同包中的子类来说是可见的，但对于不同包中的非子类是不可见的。
protected 修饰符提供了一种限制访问的方式，允许继承和扩展类的功能，同时限制了对于类的直接访问。

下面是一个示例代码，演示了 protected 修饰符的使用：

package com.example;

public class Parent {
    protected int protectedVariable;

    protected void protectedMethod() {
        // 可以在同一包内的其他类和不同包中的子类中访问
    }
}

package com.example;

public class Child extends Parent {
    public void accessProtectedMember() {
        protectedVariable = 10; // 可以访问父类的protected成员变量
        protectedMethod(); // 可以调用父类的protected方法
    }
}

package com.anotherpackage;

import com.example.Parent;

public class AnotherClass {
    public void accessProtectedMember() {
        Parent parent = new Parent();
        parent.protectedVariable = 10; // 无法访问父类的protected成员变量
        parent.protectedMethod(); // 无法调用父类的protected方法
    }
}

在上面的示例中，Parent类中的protectedVariable和protectedMethod()可以在Child类中被访问，因为Child是Parent的子类。然而，在AnotherClass中，由于它不是Parent的子类，无法访问Parent类中的protected成员。

推荐把 private 方法放到后面，因为 public 方法定义了类对外提供的功能，阅读代码的时候，应该先关注 public 方法。

由于 Java 支持嵌套类，如果一个类内部还定义了嵌套类，那么，嵌套类拥有访问 private 的权限。

package 修饰符

package 修饰符是默认的修饰符，它表示一个类、方法或成员变量可以被同一个包中的其他类访问。如果没有显式地指定访问修饰符，那么默认情况下，类、方法和成员变量都将使用 package 修饰符。当一个类、方法或成员变量被声明为 package 修饰符时，它可以在同一个包中的其他类中被访问。这意味着在同一个包中的类可以直接访问被 package 修饰的类、方法或成员变量，而不需要使用任何访问修饰符。下面是一个示例，展示了 package 修饰符的使用：

// 文件名: MyClass.java
package com.example;

public class MyClass {
    // 使用package修饰符
    int myVariable;

    void myMethod() {
        // 在同一个包中可以直接访问myVariable
        myVariable = 10;
    }
}

在上面的示例中，MyClass类被声明为com.example包中的一个类。因此，在同一个包中的其他类可以直接访问MyClass类中被package修饰的成员变量myVariable和方法myMethod。

需要注意的是，如果一个类、方法或成员变量没有使用任何访问修饰符，它将默认为 package修饰符。因此，在同一个包中的其他类可以直接访问它。

局部变量

局部变量是在方法、构造函数或代码块中声明的变量。它们只在声明它们的方法、构造函数或代码块中可见和可访问，并且在方法、构造函数或代码块执行结束后会被销毁。局部变量的作用域仅限于声明它们的代码块。这意味着在其他方法、构造函数或代码块中无法访问局部变量。

下面是一个示例，展示了局部变量的使用：

public class MyClass {
    public void myMethod() {
        int x = 10; // 声明并初始化一个局部变量x

        if (x > 5) {
            int y = 20; // 声明并初始化一个局部变量y
            System.out.println(x + y); // 可以在代码块中访问x和y
        }

        // 在这里无法访问变量y，它的作用域仅限于if代码块内部
        System.out.println(x); // 可以在方法中访问变量x
    }
}

在上面的示例中，myMethod方法中声明了两个局部变量x和y。变量x在整个方法中都是可见和可访问的，而变量y的作用域仅限于if代码块内部。

需要注意的是，局部变量在声明时必须进行初始化，即给变量赋予一个初始值。否则，编译器将会报错。局部变量的生命周期仅限于其所在的方法、构造函数或代码块的执行期间。一旦方法、构造函数或代码块执行结束，局部变量将被销毁。

final修饰符

final 修饰符用于表示一个最终的实体，可以应用于类、方法和变量。当 final 修饰一个类时，表示该类是不可继承的，即不能有子类。这可以用于确保类的完整性和安全性，防止其他类对其进行修改或扩展。

当 final 修饰一个方法时，表示该方法不能被子类重写。这可以用于确保方法的行为不会被子类修改，保持方法的稳定性和一致性。当 final 修饰一个变量时，表示该变量是一个常量，即其值不能被修改。一旦被赋值后，final 变量的值将保持不变。这可以用于定义常量，例如数学中的π或者表示一些固定不变的值。

final 修饰符的使用需要谨慎考虑。对于类和方法，应该仔细思考是否需要限制其继承或重写的能力。对于变量，应该确保其确实是一个常量，否则可能会导致不可预料的问题。

总之，final 修饰符可以用于限制类、方法和变量的修改和扩展，提高代码的可靠性和安全性。如果不确定是否需要 public，就不声明为 public，即尽可能少地暴露对外的字段和方法。把方法定义为 package 权限有助于测试，因为测试类和被测试类只要位于同一个 package，测试代码就可以访问被测试类的 package 权限方法。一个.java文件只能包含一个 public 类，但可以包含多个非 public 类。如果有 public 类，文件名必须和 public 类的名字相同。

public 修饰符 ​

private 修饰符 ​

protected 修饰符 ​

package 修饰符 ​