Java三大修饰符：public、private、protected，一文彻底搞懂访问控制

📝 前言：在前面的博客中，我们学习了面向对象的三大特性——封装、继承和多态。而实现封装的核心工具，就是Java的访问控制修饰符。它们像一道道防火墙，决定了哪些代码可以访问，哪些代码需要被隐藏。

今天，我们就来彻底搞懂Java中最重要的三个访问修饰符：public、private和protected，以及它们如何构建出安全可靠的面向对象程序。

🔒 一、 为什么要使用访问修饰符？

想象一下，如果你的银行账户余额可以被任何人随意修改，或者公司的核心算法被竞争对手直接复制，后果不堪设想。访问修饰符就是Java提供的"权限管理"机制，它们的主要作用是：

1. 封装性：隐藏类的内部实现细节
2. 安全性：防止非法访问和修改
3. 可维护性：控制代码的访问范围，便于后续修改

🌐 二、 public：无限制的公开访问

public是最开放的修饰符，被它修饰的成员可以在任何地方被访问，没有任何访问限制。

适用场景：

• 类的公共接口
• 需要被外部调用的方法
• 常量（如public static final）

代码示例：

public class Calculator {
    // 公共方法，可以被任何类调用
    public int add(int a, int b) {
        return a + b;
    }
    
    // 公共常量
    public static final double PI = 3.14159;
}

// 在其他类中调用
public class Test {
    public static void main(String[] args) {
        Calculator calc = new Calculator();
        int result = calc.add(5, 3); // 可以自由调用
        System.out.println("PI = " + Calculator.PI); // 可以直接访问常量
    }
}

🔒 三、 private：最严格的私有保护

private是最严格的修饰符，被它修饰的成员只能在定义它的类内部访问，外部类完全无法访问。

适用场景：

• 类的私有属性（封装的核心）
• 辅助方法（只供类内部使用）
• 敏感数据

代码示例：

public class BankAccount {
    // 私有属性，外部无法直接访问
    private double balance;
    
    // 公共方法，通过方法间接访问私有属性
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }
    
    // 私有方法，只供类内部使用
    private void validateAmount(double amount) {
        if (amount <= 0) {
            throw new IllegalArgumentException("金额必须大于0");
        }
    }
}

// 在其他类中尝试访问private成员（会编译错误）
public class Test {
    public static void main(String[] args) {
        BankAccount account = new BankAccount();
        // account.balance = 1000; // 编译错误：balance has private access in BankAccount
        // account.validateAmount(100); // 编译错误：validateAmount has private access
    }
}

🛡️ 四、 protected：受保护的访问

protected介于public和private之间，被它修饰的成员可以被：

1. 同一个包中的类访问
2. 不同包中的子类访问（继承关系）

适用场景：

• 需要被子类继承和重写的方法
• 包内共享但对外部隐藏的成员

代码示例：

// 父类在com.example包中
package com.example;

public class Animal {
    // protected方法，子类可以访问
    protected void eat() {
        System.out.println("动物在吃饭");
    }
}

// 子类在com.example.sub包中
package com.example.sub;

import com.example.Animal;

public class Dog extends Animal {
    @Override
    protected void eat() {
        System.out.println("狗在啃骨头");
    }
    
    public void test() {
        eat(); // 子类可以访问父类的protected方法
    }
}

// 非子类在com.example包中
package com.example;

public class Cat {
    public void feed(Animal animal) {
        animal.eat(); // 同包中的类可以访问protected方法
    }
}

📦 五、 默认访问权限（包级私有）

如果没有显式使用任何修饰符，那么成员具有"包级私有"访问权限，只能在同一个包内访问。

适用场景：

• 包内共享的工具方法
• 不需要对外暴露的内部实现

代码示例：

// 在com.example包中
package com.example;

class Utils {
    // 默认访问权限，只能在com.example包内访问
    static void printMessage() {
        System.out.println("这是一个工具方法");
    }
}

// 在com.example包中的另一个类
public class Test {
    public static void main(String[] args) {
        Utils.printMessage(); // 可以访问
    }
}

// 在com.other包中
package com.other;

import com.example.Utils;

public class OtherClass {
    public static void main(String[] args) {
        // Utils.printMessage(); // 编译错误：Utils is not public in com.example.Utils
    }
}

🎯 六、 访问权限总结表

修饰符	同类	同包	子类	任何地方
public	✅	✅	✅	✅
protected	✅	✅	✅	❌
默认	✅	✅	❌	❌
private	✅	❌	❌	❌

⚠️ 七、 避坑指南

1. 过度使用public：不要把所有成员都设为public，这会破坏封装性。
2. protected的滥用：protected会暴露给子类，要谨慎使用。
3. private的过度使用：如果所有方法都是private，那这个类就没有存在的意义了。
4. 默认权限的误解：默认权限不是"没有权限"，而是"包级私有"。

💎 八、 最佳实践

1. 属性私有化：所有属性都应该用private修饰，通过public方法访问。
2. 方法按需开放：只开放必要的方法为public，其他用protected或private。
3. 常量用public static final：公共常量可以安全地公开。
4. 工具类方法用static：避免实例化，提高性能。

🎉 九、 总结

Java的三个访问修饰符是面向对象编程的基石，它们共同构建了代码的安全性和可维护性：

• public：对外开放的接口
• private：内部实现的保护
• protected：子类继承的桥梁

掌握这三个修饰符，你就能写出更加专业、更加安全的Java代码，真正实现面向对象的封装特性。

💬 互动时间：你在项目中是如何选择使用这些修饰符的？有没有遇到过因为权限设置不当导致的bug？欢迎在评论区分享你的经验和故事！如果觉得这篇文章对你有帮助，别忘了点赞👍 + 收藏⭐，我们下期见！