Java 中的访问修饰符：public、private、protected

简介

在 Java 编程中，访问修饰符是用于控制类、变量、方法和构造函数的可访问性的关键字。public、private 和 protected 是最常用的三种访问修饰符。合理使用这些修饰符对于确保代码的安全性、封装性以及可维护性至关重要。本文将深入探讨这三种访问修饰符的基础概念、使用方法、常见实践以及最佳实践。

基础概念
- public
- private
- protected
使用方法
- 修饰类
- 修饰成员变量
- 修饰成员方法
- 修饰构造函数
常见实践
- 封装数据
- 提供访问器和修改器
- 继承中的访问控制
最佳实践
- 最小化可访问性原则
- 合理使用访问修饰符来增强封装性
- 文档化访问修饰符的使用意图
小结
参考资料

基础概念

public

public 修饰符表示被修饰的元素（类、变量、方法、构造函数）具有最大的可访问性。任何其他类都可以访问 public 修饰的元素，无论它们在哪个包中。

private

private 修饰符表示被修饰的元素只能在定义它的类内部被访问。这意味着其他类无法直接访问 private 修饰的变量、方法或构造函数，从而实现了数据的封装和隐藏。

protected

protected 修饰符表示被修饰的元素可以在以下范围内被访问： 1. 在定义它的类内部。 2. 在同一个包中的其他类。 3. 在不同包中的子类。

使用方法

修饰类

只有 public 和默认（没有显式修饰符）可以修饰类。

// public 类，可以被任何其他类访问
public class PublicClass {
    // 类的成员
}

// 默认类，只能被同一个包中的其他类访问
class DefaultClass {
    // 类的成员
}

修饰成员变量

public class AccessModifierExample {
    // public 变量，任何类都可以访问
    public int publicVariable;

    // private 变量，只能在当前类内部访问
    private int privateVariable;

    // protected 变量，在当前类、同包类和不同包子类中可访问
    protected int protectedVariable;
}

修饰成员方法

public class AccessModifierExample {
    // public 方法，任何类都可以调用
    public void publicMethod() {
        System.out.println("This is a public method.");
    }

    // private 方法，只能在当前类内部调用
    private void privateMethod() {
        System.out.println("This is a private method.");
    }

    // protected 方法，在当前类、同包类和不同包子类中可调用
    protected void protectedMethod() {
        System.out.println("This is a protected method.");
    }
}

修饰构造函数

public class AccessModifierExample {
    // public 构造函数，任何类都可以创建该类的实例
    public AccessModifierExample() {
        // 构造函数逻辑
    }

    // private 构造函数，只能在当前类内部创建实例
    private AccessModifierExample(int value) {
        // 构造函数逻辑
    }

    // protected 构造函数，在当前类、同包类和不同包子类中可用于创建实例
    protected AccessModifierExample(String name) {
        // 构造函数逻辑
    }
}

常见实践

封装数据

通过将成员变量声明为 private，并提供 public 的访问器（getter）和修改器（setter）方法，可以实现数据的封装。

public class Person {
    private String name;
    private int age;

    // 访问器方法
    public String getName() {
        return name;
    }

    // 修改器方法
    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age >= 0) {
            this.age = age;
        } else {
            System.out.println("Age cannot be negative.");
        }
    }
}

提供访问器和修改器

访问器和修改器方法不仅可以控制对数据的访问，还可以在方法内部添加额外的逻辑，如数据验证。

public class Main {
    public static void main(String[] args) {
        Person person = new Person();
        person.setName("John");
        person.setAge(30);

        System.out.println("Name: " + person.getName());
        System.out.println("Age: " + person.getAge());
    }
}

继承中的访问控制

在继承中，protected 修饰符常用于允许子类访问父类的某些成员。

// 父类
public class Animal {
    protected String name;

    public Animal(String name) {
        this.name = name;
    }

    protected void makeSound() {
        System.out.println("The animal makes a sound.");
    }
}

// 子类
public class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }

    @Override
    protected void makeSound() {
        System.out.println("Woof!");
    }
}

最佳实践

最小化可访问性原则

尽可能将类、变量和方法的可访问性设置为最小。只有在必要时才使用 public，优先考虑 private 或 protected。

合理使用访问修饰符来增强封装性

将数据成员声明为 private，并通过 public 的访问器和修改器方法来控制对数据的访问，这样可以提高代码的安全性和可维护性。

文档化访问修饰符的使用意图

在编写代码时，使用注释来解释为什么选择特定的访问修饰符，这有助于其他开发人员理解代码的设计意图。

小结

public、private 和 protected 是 Java 中重要的访问修饰符，它们在控制类、变量、方法和构造函数的可访问性方面起着关键作用。通过合理使用这些修饰符，可以实现数据的封装、增强代码的安全性和可维护性。在实际编程中，应遵循最小化可访问性原则，根据具体需求选择合适的访问修饰符。