Java私有方法访问限制：内部类与静态代理应用示例

原创短命女 2024-10-06 11:27 35阅读 0赞

在Java中，私有方法默认是不可见的，外部代码无法直接访问。为了实现对这些私有方法的访问控制，我们通常会使用以下两种方式：

1. 内部类（Inner Class）
   - 当一个类包含另一个类时，内部类可以访问外部类的所有非私有成员。

示例：
```java
public class OuterClass {
    private String privateString;

// 公开构造器
    public OuterClass(String privateString) {
        this.privateString = privateString;
    }

// 内部类，可以访问外部的非私有方法
    public class InnerClass {
        // 访问外部私有变量
        public void accessPrivateVariable() {
            OuterClass outer = new OuterClass("Visible String"); // 创建外部类对象
            System.out.println(outer.privateString); // 输出私有字符串
        }
    }

// 主函数，运行内部类的例子
    public static void main(String[] args) {
        OuterClass outer = new OuterClass("Visible String");
        InnerClass inner = outer.new InnerClass(); // 创建内部类对象

inner.accessPrivateVariable(); // 调用访问外部私有变量的方法
    }
}
```

2. 静态代理（Static Proxy）
   - 当需要对一个已存在的目标对象进行控制，且不想改变原有对象时，可以使用静态代理。

示例：
```java
// 假设我们有一个被代理的目标类
public class TargetClass {
    private String privateString;

// 公开构造器
    public TargetClass(String privateString) {
        this.privateString = privateString;
    }

// 需要被代理的方法
    public void methodToProxy() {
        System.out.println("Performing operation in the target class.");
    }
}

// 使用Java反射API创建静态代理类
import java.lang.reflect.Method;

public class ProxyClass implements TargetClass {

// 需要代理的目标对象
    private TargetClass target;

// 创建代理类的构造器，用于接收目标对象
    public ProxyClass(TargetClass target) {
        this.target = target;
    }

@Override
    public void methodToProxy() {
        System.out.println("Proxying operation to the target class through the proxy object.");
        // 在这里，你可以添加任何需要在代理类中执行的逻辑
        target.methodToProxy(); // 调用目标对象的方法
    }
}

// 使用静态代理来控制访问
public class AccessControlExample {
    public static void main(String[] args) {
        TargetClass target = new TargetClass("Visible String")); // 创建目标对象

ProxyClass proxy = new ProxyClass(target); // 创建代理类，并将其设置为目标对象

// 通过代理类调用目标对象的方法
        proxy.methodToProxy();

// 试图直接访问私有变量，将会抛出异常
        try {
            System.out.println(proxy.target.privateString); // 这将抛出异常，因为privateString是私有的
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
```

通过上述示例，你可以看到如何使用内部类和静态代理来控制对Java私有方法的访问。