03_跨包访问与权限控制

一、跨包访问的基本概念

跨包访问指在一个包中的类访问另一个包中的类或其成员（属性、方法、构造器）。由于 Java 中包是独立的命名空间，跨包访问需遵循特定规则，核心受访问权限控制和类导入机制影响。

跨包访问的前提：

• 被访问的类或成员必须具备允许跨包访问的权限
• 若被访问的类不在当前包中，需通过import语句导入或使用全限定名

二、跨包访问的实现方式

2.1 导入类（import 语句）

当需要多次访问其他包中的类时，使用import语句导入该类，可简化代码（无需每次使用全限定名）。

语法：

import 包名.类名; // 导入指定类

示例：

// 包：com.example.package1
package com.example.package1;

public class PublicClass {
    public void publicMethod() {
        System.out.println("跨包可访问的方法");
    }
}

// 包：com.example.package2（跨包访问）
package com.example.package2;

// 导入package1中的PublicClass
import com.example.package1.PublicClass;

public class Test {
    public static void main(String[] args) {
        // 直接使用类名访问
        PublicClass obj = new PublicClass();
        obj.publicMethod(); // 调用跨包类的方法
    }
}

2.2 使用全限定名

当需要访问的类与当前包中的类同名（类名冲突），或仅需访问一次时，可使用全限定名（包名 + 类名）访问，无需导入。

示例：

// 包：com.example.package2
package com.example.package2;

public class Test {
    public static void main(String[] args) {
        // 使用全限定名访问package1中的PublicClass
        com.example.package1.PublicClass obj = new com.example.package1.PublicClass();
        obj.publicMethod();
    }
}

2.3 注意事项

导入子包需显式声明：import com.example.仅导入com.example包下的类，不包含其子包（如com.example.subpackage需单独导入com.example.subpackage.）。
默认导入的类：java.lang包中的类（如String、System）默认被导入，无需手动声明。

三、权限控制对跨包访问的影响

权限控制决定了跨包访问时能否访问类的成员（属性、方法、构造器），核心是通过访问修饰符限制访问范围。以下是权限控制在跨包访问中的表现：

3.1 可跨包访问的成员

3.1.1 public 修饰的成员

被public修饰的成员（类、属性、方法）可被任何包中的类访问，是跨包访问最常用的权限。

示例：

// 包：com.example.package1
package com.example.package1;

public class PublicClass {
    public String publicField = "公共属性"; // public属性
    
    public void publicMethod() { // public方法
        System.out.println("公共方法");
    }
}

// 包：com.example.package2（跨包访问）
package com.example.package2;

import com.example.package1.PublicClass;

public class Test {
    public static void main(String[] args) {
        PublicClass obj = new PublicClass();
        System.out.println(obj.publicField); // 可访问public属性
        obj.publicMethod(); // 可访问public方法
    }
}

3.1.2 protected 修饰的成员（特殊场景）

protected成员通常用于同包或子类访问，但在跨包场景中，只有子类才能访问父类的 protected 成员。

示例：

// 包：com.example.package1
package com.example.package1;

public class Parent {
    protected void protectedMethod() {
        System.out.println("父类的protected方法");
    }
}

// 包：com.example.package2（跨包子类）
package com.example.package2;

import com.example.package1.Parent;

// 跨包继承Parent
public class Child extends Parent {
    public void test() {
        // 子类可访问父类的protected方法
        protectedMethod(); // 合法
    }
}

// 包：com.example.package2（非子类）
public class NonChild {
    public static void main(String[] args) {
        Parent parent = new Parent();
        // 非子类无法跨包访问protected方法
        // parent.protectedMethod(); // 编译错误
    }
}

3.2 不可跨包访问的成员

1. 默认权限（无修饰符）的成员：仅允许同一包中的类访问，跨包无法访问。

// 包：com.example.package1
package com.example.package1;

class DefaultClass { // 默认权限类（仅同包可见）
    void defaultMethod() {} // 默认权限方法
}

// 包：com.example.package2
import com.example.package1.DefaultClass; // 编译错误：DefaultClass跨包不可见

2. private 修饰的成员：仅允许当前类内部访问，任何跨类（包括同包和跨包）都无法访问。

// 包：com.example.package1
package com.example.package1;

public class TestClass {
    private int privateField = 10; // private属性
}

// 包：com.example.package2
import com.example.package1.TestClass;

public class Test {
    public static void main(String[] args) {
        TestClass obj = new TestClass();
        // System.out.println(obj.privateField); // 编译错误：private成员不可访问
    }
}

修饰符	跨包非子类访问	跨包子类访问
private	禁止	禁止
默认 （无修饰符）	禁止	禁止
protected	禁止	允许
public	允许	允许

四、跨包访问的常见问题与解决方案

4.1 类不可见：找不到类或无法访问

原因：被访问的类是默认权限（无修饰符）或private（类不能用private修饰，实际为默认权限），跨包无法访问。

解决方案：将类声明为public，确保跨包可见。

// 错误：默认权限类，跨包不可见
class MyClass { ... }

// 正确：public类，跨包可见
public class MyClass { ... }

4.2 成员不可访问：编译报错 “xxx has private access”

原因：尝试访问的成员是private或默认权限，跨包无访问权限。

解决方案：

• 若需跨包访问，将成员修饰符改为public；
• 若仅允许子类访问，改为protected并通过继承访问。

4.3 类名冲突：导入的包中存在同名类

原因：不同包中的类名相同，导入时无法区分。

解决方案：使用全限定名访问其中一个类。

// 包1：com.example.A
// 包2：com.test.A
import com.example.A;

public class Test {
    public static void main(String[] args) {
        A a1 = new A(); // com.example.A
        com.test.A a2 = new com.test.A(); // 使用全限定名访问另一个类
    }
}

五、跨包访问的最佳实践

1. 最小权限原则：仅将必要的类和成员声明为public，避免过度暴露内部实现（如工具类的辅助方法可设为private）。
2. 通过接口访问：跨包访问时，优先定义public接口，实现类可隐藏细节，仅暴露接口方法。

// 公共接口（public）
public interface UserService {
    void addUser();
}

// 实现类（可设为默认权限，仅同包可见）
class UserServiceImpl implements UserService {
    public void addUser() { ... } // 实现接口方法，需为public
}

3. 避免频繁跨包访问：过度的跨包访问会增加代码耦合度，建议按模块划分包，减少跨包依赖。

六、总结

跨包访问是 Java 中多包结构项目的常见需求，其核心受导入机制和权限控制影响：

• 导入机制：通过import语句或全限定名访问其他包的类；
• 权限控制：public成员可被任何跨包类访问，protected成员仅允许跨包子类访问，默认权限和private成员跨包不可访问。

合理设计类和成员的权限，遵循最小权限原则，能在保证功能的同时提高代码的安全性和可维护性。