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

简介

在 Java 编程语言中，访问修饰符用于控制类、方法和变量的访问级别。public、private 和 protected 是三种主要的访问修饰符，它们在确保代码的封装性、安全性以及可维护性方面发挥着至关重要的作用。理解这些访问修饰符的概念、使用方法和最佳实践，对于编写高质量的 Java 代码至关重要。本文将详细探讨这三个访问修饰符，帮助你更好地掌握 Java 中的访问控制机制。

基础概念
- public 访问修饰符
- private 访问修饰符
- protected 访问修饰符
使用方法
- 修饰类
- 修饰方法
- 修饰变量
常见实践
- 封装数据
- 提供访问器和修改器
- 继承中的访问控制
最佳实践
- 最小化访问权限
- 遵循命名约定
- 避免过度使用 public
小结
参考资料

基础概念

`public` 访问修饰符

public 修饰的成员（类、方法、变量）具有最广泛的访问权限。任何其他类都可以访问 public 成员，无论它们在哪个包中。这意味着 public 成员可以在整个项目中被自由地访问和使用。

`private` 访问修饰符

private 修饰的成员只能在定义它们的类内部被访问。这是实现封装的重要手段，将类的内部状态和实现细节隐藏起来，对外提供统一的接口，从而提高代码的安全性和可维护性。

`protected` 访问修饰符

protected 修饰的成员可以在定义它们的类内部、同一包中的其他类以及不同包中的子类访问。protected 访问修饰符主要用于在继承层次结构中控制成员的访问权限，使得子类能够访问父类的某些成员。

使用方法

修饰类

public 类：一个 Java 源文件中最多只能有一个 public 类，并且该类的名称必须与源文件的名称相同。public 类可以被任何其他类访问和实例化。

public class PublicClass {
    // 类的成员
}

private 类：类不能被直接声明为 private。不过，内部类可以被声明为 private，此时它只能在外部类内部被访问和使用。

public class OuterClass {
    private class InnerClass {
        // 内部类的成员
    }
}

protected 类：类不能被直接声明为 protected。与 private 类类似，内部类可以被声明为 protected，此时它可以在外部类所在的包以及任何子类中被访问。

修饰方法

public 方法：public 方法可以被任何类调用，常用于提供对外的接口，让其他类能够使用该方法的功能。

public class MyClass {
    public void publicMethod() {
        System.out.println("This is a public method.");
    }
}

private 方法：private 方法只能在定义它的类内部被调用，通常用于实现类的内部逻辑，不希望外部类直接调用。

public class MyClass {
    private void privateMethod() {
        System.out.println("This is a private method.");
    }
}

protected 方法：protected 方法可以在定义它的类内部、同一包中的其他类以及不同包中的子类调用。常用于在继承体系中让子类能够扩展或修改父类的行为。

public class ParentClass {
    protected void protectedMethod() {
        System.out.println("This is a protected method in ParentClass.");
    }
}

public class ChildClass extends ParentClass {
    @Override
    protected void protectedMethod() {
        System.out.println("This is a protected method in ChildClass.");
    }
}

修饰变量

public 变量：public 变量可以被任何类访问和修改，使用时需谨慎，因为这可能破坏数据的封装性。

public class MyClass {
    public int publicVariable;
}

private 变量：private 变量只能在定义它的类内部被访问和修改，通常通过 public 的访问器（getter）和修改器（setter）方法来间接访问和修改。

public class MyClass {
    private int privateVariable;

    public int getPrivateVariable() {
        return privateVariable;
    }

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

protected 变量：protected 变量可以在定义它的类内部、同一包中的其他类以及不同包中的子类访问。

public class ParentClass {
    protected int protectedVariable;
}

public class ChildClass extends ParentClass {
    public void accessProtectedVariable() {
        protectedVariable = 10;
    }
}

常见实践

封装数据

使用 private 修饰符将类的成员变量封装起来，对外提供 public 的访问器和修改器方法，这样可以隐藏类的内部实现细节，提高代码的安全性和可维护性。

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 的访问器和修改器方法，可以对 private 变量进行安全的访问和修改，同时可以在方法中添加必要的逻辑，如数据验证。

public class Circle {
    private double radius;

    public double getRadius() {
        return radius;
    }

    public void setRadius(double radius) {
        if (radius > 0) {
            this.radius = radius;
        } else {
            System.out.println("Radius must be positive.");
        }
    }

    public double calculateArea() {
        return Math.PI * radius * radius;
    }
}

继承中的访问控制

在继承关系中，protected 修饰符用于控制父类成员在子类中的访问权限。子类可以访问父类的 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! Woof!");
    }
}

最佳实践

最小化访问权限

尽可能使用最小的访问权限来修饰类、方法和变量。只将必要的成员声明为 public，其他成员应根据其使用范围选择 private 或 protected，以提高代码的封装性和安全性。

遵循命名约定

对于 private 变量，通常使用小写字母开头的命名方式，如 private int myVariable。对于 public 方法，使用大写字母开头的驼峰命名法，如 public void myMethod()。遵循统一的命名约定可以提高代码的可读性。

避免过度使用 `public`

过度使用 public 修饰符会破坏代码的封装性，使得类的内部实现细节暴露给外部。尽量将类的实现细节隐藏在内部，通过合理的接口来与外部进行交互。

小结

public、private 和 protected 是 Java 中重要的访问修饰符，它们在控制类、方法和变量的访问权限方面发挥着关键作用。通过合理使用这些访问修饰符，可以实现代码的封装、提高安全性和可维护性。在实际编程中，应根据具体需求选择合适的访问修饰符，并遵循最佳实践原则，以编写高质量的 Java 代码。

参考资料

希望这篇博客能帮助你深入理解并高效使用 Java 中的 public、private 和 protected 访问修饰符。如果你有任何问题或建议，欢迎在评论区留言。