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

简介

在 Java 编程语言中，访问修饰符（public、protected、private）扮演着至关重要的角色。它们用于控制类、方法和变量的访问级别，决定了代码在不同的类、包和继承结构中的可见性和可访问性。理解这些访问修饰符的使用对于编写安全、可维护且结构良好的 Java 代码至关重要。

基础概念
- public 修饰符
- protected 修饰符
- private 修饰符
使用方法
- 修饰类
- 修饰方法
- 修饰变量
常见实践
- 类的访问控制
- 方法的访问控制
- 变量的访问控制
最佳实践
- 封装原则
- 继承中的访问控制
- 包的设计
小结
参考资料

基础概念

`public` 修饰符

public 是 Java 中访问级别最高的修饰符。被 public 修饰的类、方法或变量可以在任何地方被访问，无论是在同一个包内还是不同的包中，甚至是在不同的项目中（只要能正确导入类）。

`protected` 修饰符

protected 修饰符的访问级别低于 public。被 protected 修饰的成员（方法或变量）可以在同一个包内的所有类中被访问，并且在不同包中的子类也可以访问。这意味着 protected 成员对于子类提供了一定的可见性，同时又限制了其他无关类的访问。

`private` 修饰符

private 是访问级别最低的修饰符。被 private 修饰的成员只能在定义该成员的类内部被访问，其他任何类都无法直接访问这些成员，包括子类和同一包内的其他类。

使用方法

修饰类

// public 类，可以在任何地方被访问
public class PublicClass {
    // 类的成员
}

// 默认（包级）访问修饰符的类，只能在同一个包内被访问
class PackageLevelClass {
    // 类的成员
}

// private 不能修饰类
// private class PrivateClass {}  // 编译错误

修饰方法

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

    // protected 方法，在同一包内或不同包的子类中可调用
    protected void protectedMethod() {
        System.out.println("This is a protected method.");
    }

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

    public void callPrivateMethod() {
        privateMethod(); // 在本类内部调用 private 方法
    }
}

修饰变量

public class VariableAccessExample {
    // public 变量，可以在任何地方被访问和修改
    public int publicVariable = 10;

    // protected 变量，在同一包内或不同包的子类中可访问
    protected int protectedVariable = 20;

    // private 变量，只能在本类内部被访问和修改
    private int privateVariable = 30;

    public int getPrivateVariable() {
        return privateVariable;
    }

    public void setPrivateVariable(int value) {
        privateVariable = value;
    }
}

常见实践

类的访问控制

通常，提供给外部使用的类会声明为 public，例如 Java 标准库中的类，像 String、ArrayList 等。
对于一些内部使用的类，不需要对外公开，可以使用默认（包级）访问修饰符，这样可以限制其访问范围在同一个包内。

方法的访问控制

类的公共接口方法通常声明为 public，以便外部代码可以调用这些方法来使用类的功能。
对于一些辅助方法，只在类内部或子类中使用，可以声明为 protected 或 private。例如，一个复杂算法中的子步骤方法可以声明为 private，防止外部误调用。

变量的访问控制

为了实现数据封装，实例变量通常声明为 private，通过 public 的 getter 和 setter 方法来访问和修改这些变量。这样可以对变量的访问进行控制和验证。

最佳实践

封装原则

将类的成员变量声明为 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 {
            throw new IllegalArgumentException("Age cannot be negative.");
        }
    }
}

继承中的访问控制

在继承体系中，合理使用 protected 修饰符。子类可以继承父类的 protected 成员，并根据需要进行扩展或重写。这样可以实现代码的复用和功能的扩展，同时保持一定的访问控制。

class Animal {
    protected String name;

    protected void makeSound() {
        System.out.println("Some sound");
    }
}

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

包的设计

合理划分包结构，将相关的类放在同一个包内。包内的类可以使用默认（包级）访问修饰符进行内部交互，而对外提供 public 的类和接口。这样可以提高代码的模块化和可管理性。

小结

public、protected 和 private 访问修饰符是 Java 中控制代码访问权限的重要工具。public 用于完全公开的类、方法和变量；protected 用于在包内和子类中可见的成员；private 用于完全隐藏在类内部的成员。通过合理使用这些访问修饰符，可以实现数据封装、提高代码的安全性和可维护性，遵循面向对象编程的最佳实践。

参考资料

Oracle Java 教程 - 访问修饰符
《Effective Java》 - Joshua Bloch
《Java 核心技术》 - Cay S. Horstmann, Gary Cornell

希望通过这篇博客，读者能够深入理解并在实际项目中高效使用 public、protected 和 private 访问修饰符。