【Java】Java访问修饰符：权限控制的核心逻辑

By - YunYang
Posted on 2026-04-082026-04-08
Posted in Java

【Java】Java访问修饰符：权限控制的核心逻辑

大家好，我是云扬。

作为 Java 开发者，我们每天都在和访问修饰符打交道，但很多人往往只停留在 “会用” 的层面，却忽略了其背后的设计思想和核心价值。访问修饰符是 Java 面向对象封装特性的核心实现手段，合理使用它，能让代码结构更清晰、维护性更强，也能有效避免不必要的访问冲突。今天，我就和大家一起深入拆解 Java 访问修饰符的底层逻辑与实战技巧。

一、访问修饰符的核心定位：封装的基石

在面向对象编程中，封装是三大特性之一，其核心思想是 “隐藏内部实现，暴露对外接口”。而访问修饰符，正是实现这一思想的关键工具。它通过控制类、方法、变量的访问范围，实现了以下核心价值：

隐藏实现细节：将类的内部状态和辅助方法私有化，仅暴露必要的接口供外部调用，降低代码耦合度；
规范访问边界：明确不同代码单元的访问权限，避免误操作修改核心数据，提升代码安全性；
避免命名冲突：通过包访问权限，限制类的作用域，解决多模块下的类名重复问题。

Java 提供了四种访问修饰符，按权限从严格到宽松依次为：private（私有）、默认（包访问）、protected（受保护）、public（公开）。需要特别注意的是：类的访问权限仅支持默认和 public 两种，而方法、成员变量可使用全部四种修饰符。

二、类的访问权限：包与全局的边界

类的访问权限决定了它在整个项目中的 “可见范围”，这是我们定义类时首先要明确的规则。

1. 默认访问权限（包访问权限）

如果类不添加任何访问修饰符，就属于默认访问权限。这种权限下，类仅对当前包内的所有类可见，跨包的类无法导入和使用它，也无法继承它。

我们用一个简单的示例来看：

// 所在包：com.yunyang.demo.base
// 默认访问权限的类，仅同包可见
class DefaultClass {
    public void sayHello() {
        System.out.println("我是默认访问权限的类，只有同包能访问我！");
    }
}

// 同包内的测试类，可正常访问默认类
public class SamePackageTest {
    public static void main(String[] args) {
        DefaultClass demo = new DefaultClass();
        demo.sayHello(); // 输出：我是默认访问权限的类，只有同包能访问我！
    }
}

如果我们在另一个包（如com.yunyang.demo.other）中尝试导入DefaultClass并使用，编译器会直接报错：DefaultClass is not visible in this package。

2. public 访问权限

用public修饰的类，拥有全局访问权限—— 任何包的类都可以通过import关键字导入并使用，也可以继承它。

但有两个硬性规则必须遵守：

一个.java源文件中只能有一个 public 类；
public 类的类名必须与.java文件名完全一致（区分大小写）。

示例代码如下：

// 文件名必须为 PublicClass.java（与public类名一致）
// 所在包：com.yunyang.demo.publics
public class PublicClass {
    public void sayHello() {
        System.out.println("我是public类，全局都能访问我！");
    }
}

// 跨包测试类，所在包：com.yunyang.demo.test
package com.yunyang.demo.test;

// 导入public类
import com.yunyang.demo.publics.PublicClass;

public class CrossPackageTest {
    public static void main(String[] args) {
        PublicClass demo = new PublicClass();
        demo.sayHello(); // 输出：我是public类，全局都能访问我！
    }
}

public类通常用于定义对外暴露的核心接口、工具类、启动类等，是项目模块间交互的核心载体。

三、成员与方法的访问权限：四权分立的实战逻辑

对于类的成员变量和方法，四种访问修饰符的权限差异是学习的重点。我们可以从类内、同包、跨包子类、全局四个维度来理解，结合代码示例会更直观。

1. 定义测试父类

我们先创建一个父类，包含四种修饰符的成员变量和方法，作为后续测试的基础：

// 所在包：com.yunyang.demo.parent
package com.yunyang.demo.parent;

public class ParentClass {
    // 1. private：仅类内可见
    private String privateField = "私有变量";
    private void privateMethod() {
        System.out.println("私有方法：" + privateField);
    }

    // 2. 默认：同包可见
    String defaultField = "默认变量";
    void defaultMethod() {
        System.out.println("默认方法：" + defaultField);
    }

    // 3. protected：同包可见，跨包子类可见
    protected String protectedField = "受保护变量";
    protected void protectedMethod() {
        System.out.println("受保护方法：" + protectedField);
    }

    // 4. public：全局可见
    public String publicField = "公开变量";
    public void publicMethod() {
        System.out.println("公开方法：" + publicField);
    }

    // 类内统一调用测试
    public void innerCallTest() {
        // 类内可访问所有成员/方法
        privateMethod();
        defaultMethod();
        protectedMethod();
        publicMethod();
    }
}

2. 同包非子类访问测试

在父类所在的包中，创建一个非子类的测试类，验证访问权限：

// 所在包：com.yunyang.demo.parent
package com.yunyang.demo.parent;

public class SamePackageNonSubTest {
    public static void main(String[] args) {
        ParentClass parent = new ParentClass();

        // 可访问：默认、protected、public
        parent.defaultMethod();
        parent.protectedMethod();
        parent.publicMethod();

        // 编译报错：private仅类内可访问
        // parent.privateMethod();

        // 可访问同包变量
        System.out.println(parent.defaultField + " | " + parent.protectedField + " | " + parent.publicField);
    }
}

结论：同包非子类中，无法访问private修饰的成员和方法，其余权限均开放。

3. 跨包子类访问测试

创建一个跨包的子类，继承父类，验证子类的访问权限：

// 所在包：com.yunyang.demo.child
package com.yunyang.demo.child;

import com.yunyang.demo.parent.ParentClass;

// 跨包子类
public class ChildClass extends ParentClass {
    public void childCallTest() {
        // 可访问：protected、public（子类继承权限）
        protectedMethod();
        publicMethod();

        // 编译报错：默认权限跨包不可见
        // defaultMethod();

        // 编译报错：private无访问权限
        // privateMethod();

        // 可访问继承的变量
        System.out.println(protectedField + " | " + publicField);
    }
}

结论：跨包子类中，可访问protected和public修饰的成员和方法，private和默认权限均无法访问。

4. 跨包非子类访问测试

在父类的不同包中，创建一个非子类的测试类，验证全局访问权限：

// 所在包：com.yunyang.demo.other
package com.yunyang.demo.other;

import com.yunyang.demo.parent.ParentClass;

public class CrossPackageNonSubTest {
    public static void main(String[] args) {
        ParentClass parent = new ParentClass();

        // 仅可访问：public
        parent.publicMethod();
        System.out.println(parent.publicField);

        // 编译报错：默认、protected跨包非子类不可见
        // parent.defaultMethod();
        // parent.protectedMethod();

        // 编译报错：private无访问权限
        // parent.privateMethod();
    }
}

5. 权限范围总结表

为了方便记忆，我整理了一张权限对比表，这张表是理解访问修饰符的核心：

修饰符	类内可见	同包可见	跨包子类可见	全局可见
private	✅	❌	❌	❌
默认	✅	✅	❌	❌
protected	✅	✅	✅	❌
public	✅	✅	✅	✅

四、实战避坑指南：合理使用访问修饰符的核心原则

在实际开发中，访问修饰符的使用不是随意的，需要遵循以下原则，才能发挥其最大价值：

1. 成员变量：优先使用 private，通过 getter/setter 暴露

这是封装的核心原则。将成员变量私有化，避免外部直接修改内部状态，通过public的 getter/setter 方法控制访问和修改逻辑，既能保证数据安全，又能在方法中增加校验逻辑。

示例：

public class User {
    // 私有变量，隐藏内部状态
    private String username;
    private int age;

    // 公开的getter方法，提供读取权限
    public String getUsername() {
        return username;
    }

    // 公开的setter方法，提供修改权限并增加校验
    public void setAge(int age) {
        if (age > 0 && age < 120) {
            this.age = age;
        } else {
            throw new IllegalArgumentException("年龄不合法！");
        }
    }
}

2. 方法：按职责划分权限

仅类内使用的辅助方法：用private，避免对外暴露；
同包内复用的方法：用默认权限，减少跨包依赖；
供子类继承扩展的方法：用protected，明确继承边界；
对外暴露的核心接口：用public，是模块交互的入口。

3. 类：明确作用域，避免过度暴露

仅当前包使用的辅助类、内部类：用默认权限，降低全局命名压力；
对外提供核心功能的工具类、接口类：用public，是模块间交互的载体；
避免将核心业务类设为public，除非必须对外暴露。

4. 避免滥用默认权限

默认访问权限的类、成员，在项目迭代中容易被误跨包访问，导致代码耦合和维护问题。明确的权限定义（private/protected/public）能让代码结构更清晰，降低后期维护成本。

五、总结

Java 访问修饰符的本质，是权限控制的艺术，其核心是服务于封装特性。我们不仅要记住四种修饰符的权限范围，更要理解其背后的设计思想 —— 隐藏细节、规范边界、降低耦合。

在实际开发中，遵循 “最小权限原则”：能不暴露的就不暴露，能缩小范围的就缩小范围，让代码既安全又易维护。希望这篇文章能帮大家彻底吃透访问修饰符，写出更优雅的 Java 代码。

Tags:Java

云扬のBlog