java访问修饰符

在 Java 里，private 和 public 属于访问修饰符，其作用是管控类、方法、变量等的访问权限。除此之外，Java 还有 protected 访问修饰符以及默认（不写修饰符）的访问级别。下面为你详细介绍这四种访问修饰符：

1. private

• 含义：private 是访问限制最严格的修饰符。被 private 修饰的成员（变量、方法等）仅能在定义它的类内部被访问。
• 用途：一般用于封装类的内部实现细节，防止外部直接访问和修改，以此保证数据的安全性和完整性。
• 示例代码：

class Person {
    // 私有成员变量
    private String name;
    private int age;

    // 私有方法
    private void printInfo() {
        System.out.println("Name: " + name + ", Age: " + age);
    }

    // 公共方法，用于间接访问私有成员
    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void showInfo() {
        // 在类内部可以访问私有方法
        printInfo();
    }
}

public class Main {
    public static void main(String[] args) {
        Person person = new Person();
        person.setName("Alice");
        person.setAge(25);
        // 不能直接访问私有成员变量和方法
        // person.name = "Bob";  // 编译错误
        // person.printInfo();   // 编译错误
        person.showInfo();
    }
}

2. public

• 含义：public 是访问限制最宽松的修饰符。被 public 修饰的成员可以在任何地方被访问，只要能获取到该类的实例。
• 用途：通常用于定义类的公共接口，让外部代码能够方便地使用类的功能。
• 示例代码：

class Calculator {
    // 公共方法
    public int add(int a, int b) {
        return a + b;
    }
}

public class Main {
    public static void main(String[] args) {
        Calculator calculator = new Calculator();
        // 可以在其他类中直接访问公共方法
        int result = calculator.add(3, 5);
        System.out.println("Result: " + result);
    }
}

3. protected

• 含义：被 protected 修饰的成员可以在同一包内的任何类中被访问，同时也能在不同包的子类中被访问。
• 用途：常用于实现继承关系中的代码复用和扩展，让子类能够访问父类的一些成员，但又对外部类进行一定的限制。
• 示例代码：

// 父类
package parentPackage;
public class Parent {
    // 受保护的成员变量
    protected int protectedValue = 10;

    // 受保护的方法
    protected void printValue() {
        System.out.println("Protected value: " + protectedValue);
    }
}

// 同一包内的类
package parentPackage;
public class SamePackageClass {
    public static void main(String[] args) {
        Parent parent = new Parent();
        // 可以在同一包内访问受保护的成员
        System.out.println(parent.protectedValue);
        parent.printValue();
    }
}

// 不同包的子类
package childPackage;
import parentPackage.Parent;
public class Child extends Parent {
    public void accessParentProtectedMembers() {
        // 可以在子类中访问受保护的成员
        System.out.println(protectedValue);
        printValue();
    }
}

4. 默认（不写修饰符）

• 含义：若成员没有使用任何访问修饰符，那么它具有默认的访问级别，也称为包访问权限。具有默认访问级别的成员只能在同一包内的类中被访问。
• 用途：用于在包内部组织和封装代码，让包内的类可以相互访问，但对外部包进行限制。
• 示例代码：

// 同一包内的类
package myPackage;
class MyClass {
    // 默认访问级别的成员变量
    String defaultValue = "Default";

    // 默认访问级别的方法
    void printDefaultValue() {
        System.out.println(defaultValue);
    }
}

// 同一包内的另一个类
package myPackage;
public class AnotherClass {
    public static void main(String[] args) {
        MyClass myClass = new MyClass();
        // 可以在同一包内访问默认访问级别的成员
        System.out.println(myClass.defaultValue);
        myClass.printDefaultValue();
    }
}

下面以表格形式总结这四种访问修饰符的访问权限：

访问修饰符	同一类内	同一包内	不同包的子类	不同包的非子类
private	可以	不可以	不可以	不可以
默认	可以	可以	不可以	不可以
protected	可以	可以	可以	不可以
public	可以	可以	可以	可以