Java中的访问修饰符：分类、作用及应用场景

在Java编程中，访问修饰符（Access Modifiers）是控制类、方法、变量和构造函数访问权限的关键工具。通过合理使用访问修饰符，可以有效地封装代码，保护数据，并确保代码的安全性和可维护性。本文将详细介绍Java中的四种访问修饰符：public、protected、default（包级私有）和private，并探讨它们的作用及应用场景。

1. 访问修饰符的分类

Java提供了四种访问修饰符，用于控制类、方法、变量和构造函数的可见性：

public：公共的，表示对所有类可见。
protected：受保护的，表示对同一包内的类和所有子类可见。
default（包级私有）：默认的，表示对同一包内的类可见。
private：私有的，表示仅对同一类内部可见。

1.1 访问修饰符的可见性范围

访问修饰符	同一类	同一包	子类	其他包
`public`	✔️	✔️	✔️	✔️
`protected`	✔️	✔️	✔️	❌
`default`	✔️	✔️	❌	❌
`private`	✔️	❌	❌	❌

2. 访问修饰符的作用

2.1 `public`

public是最宽松的访问修饰符，表示对所有类可见。使用public修饰的类、方法、变量或构造函数可以在任何地方被访问。

应用场景：

类：通常用于定义公共API，供其他包中的类使用。
方法：用于定义类的公共接口，供外部调用。
变量：用于定义类的公共属性，供外部访问和修改。

示例代码：

public class PublicExample {
    public int publicVariable = 10;

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

public class Main {
    public static void main(String[] args) {
        PublicExample obj = new PublicExample();
        System.out.println(obj.publicVariable); // 输出: 10
        obj.publicMethod(); // 输出: This is a public method
    }
}

2.2 `protected`

protected修饰符表示对同一包内的类和所有子类可见。protected成员不能被不同包中的非子类访问。

应用场景：

方法：用于定义子类可以重写的方法，同时限制外部包的访问。
变量：用于定义子类可以访问的变量，同时限制外部包的访问。

示例代码：

package com.example.package1;

public class ProtectedExample {
    protected int protectedVariable = 20;

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

package com.example.package1;

public class SubClass extends ProtectedExample {
    public void accessProtectedMembers() {
        System.out.println(protectedVariable); // 输出: 20
        protectedMethod(); // 输出: This is a protected method
    }
}

package com.example.package2;

import com.example.package1.ProtectedExample;

public class OtherPackageClass {
    public static void main(String[] args) {
        ProtectedExample obj = new ProtectedExample();
        // 编译错误: protectedVariable 和 protectedMethod 在不同包中不可见
        // System.out.println(obj.protectedVariable);
        // obj.protectedMethod();
    }
}

2.3 `default`（包级私有）

default修饰符是默认的访问级别，表示对同一包内的类可见。如果一个类、方法或变量没有显式地指定访问修饰符，那么它默认是default。

应用场景：

类：用于定义包内使用的工具类或辅助类。
方法：用于定义包内使用的辅助方法。
变量：用于定义包内使用的辅助变量。

示例代码：

package com.example.package1;

class DefaultExample {
    int defaultVariable = 30;

    void defaultMethod() {
        System.out.println("This is a default method");
    }
}

package com.example.package1;

public class SamePackageClass {
    public static void main(String[] args) {
        DefaultExample obj = new DefaultExample();
        System.out.println(obj.defaultVariable); // 输出: 30
        obj.defaultMethod(); // 输出: This is a default method
    }
}

package com.example.package2;

import com.example.package1.DefaultExample;

public class OtherPackageClass {
    public static void main(String[] args) {
        DefaultExample obj = new DefaultExample();
        // 编译错误: defaultVariable 和 defaultMethod 在不同包中不可见
        // System.out.println(obj.defaultVariable);
        // obj.defaultMethod();
    }
}

2.4 `private`

private是最严格的访问修饰符，表示仅对同一类内部可见。使用private修饰的成员不能被外部类访问。

应用场景：

方法：用于定义类的内部实现细节，防止外部调用。
变量：用于定义类的私有属性，防止外部直接访问和修改。

示例代码：

public class PrivateExample {
    private int privateVariable = 40;

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

    public void accessPrivateMembers() {
        System.out.println(privateVariable); // 输出: 40
        privateMethod(); // 输出: This is a private method
    }
}

public class Main {
    public static void main(String[] args) {
        PrivateExample obj = new PrivateExample();
        obj.accessPrivateMembers();

        // 编译错误: privateVariable 和 privateMethod 在类外部不可见
        // System.out.println(obj.privateVariable);
        // obj.privateMethod();
    }
}