在同一个类中调用（最常见、最合法）

这是private方法设计的初衷，如果你想在当前类内部复用一段逻辑，就可以将其声明为private,然后在同一个类的其他方法中调用它。

public class MyClass {
    // 这是一个public方法，作为类的对外接口
    public void publicMethod() {
        System.out.println("调用 publicMethod");
        // 在同一个类中，可以直接调用 private 方法
        this.privateMethod();
    }
    // 这是一个private方法，作为内部实现细节
    private void privateMethod() {
        System.out.println("调用 privateMethod，执行内部逻辑");
    }
    public static void main(String[] args) {
        MyClass myClass = new MyClass();
        myClass.publicMethod(); // 正确调用
        // myClass.privateMethod(); // 编译错误！因为 main 方法虽然在同一个类文件中，但它在静态上下文中，不能直接访问非静态的 private 方法
    }
}

注意：即使在main方法中，它属于静态上下文，而privateMethod是非静态实例方法，所以也不能直接调用,必须通过创建类的实例来调用。

通过反射（核心技巧）

反射是Java语言提供的一个强大的机制，它允许程序在运行时检查和操作类、方法、字段等，通过反射，我们可以绕过访问修饰符的限制，调用private方法。

这是在单元测试、框架开发等场景下最常用的技术。

步骤：

1. 获取Class对象：代表你要操作的类。
2. 获取Method对象：通过Class对象和方法的名称、参数类型来获取指定的方法。
3. 解除私有访问限制：调用Method.setAccessible(true)，这是最关键的一步,它会关闭Java的访问检查。
4. 调用方法：使用Method.invoke()方法来执行该方法。

代码示例：

假设我们有另一个类TargetClass，其中包含一个private方法。

// TargetClass.java
package com.example;
public class TargetClass {
    private String privateMethod(String name, int age) {
        return "Hello, " + name + "! You are " + age + " years old.";
    }
}

我们在另一个类ReflectionDemo中通过反射来调用TargetClass的privateMethod。

// ReflectionDemo.java
package com.example;
import java.lang.reflect.Method;
public class ReflectionDemo {
    public static void main(String[] args) throws Exception {
        // 1. 获取 TargetClass 的 Class 对象
        Class<?> targetClass = Class.forName("com.example.TargetClass");
        // 2. 创建 TargetClass 的实例
        Object instance = targetClass.getDeclaredConstructor().newInstance();
        // 3. 获取 privateMethod 的 Method 对象
        // 需要使用 getDeclaredMethod，因为它可以获取类中声明的所有方法（包括private），而不考虑继承
        // 参数1：方法名
        // 参数2：方法参数的类型列表
        Method privateMethod = targetClass.getDeclaredMethod("privateMethod", String.class, int.class);
        // 4. 解除私有访问限制
        privateMethod.setAccessible(true);
        // 5. 调用方法
        // invoke 方法的第一个参数是调用该方法的对象实例，后续参数是传递给方法的参数值
        Object result = privateMethod.invoke(instance, "Alice", 30);
        // 6. 输出结果
        System.out.println(result); // 输出: Hello, Alice! You are 30 years old.
    }
}

关键点说明：

• getDeclaredMethod() vs getMethod()：

  • getDeclaredMethod(String name, Class<?>... parameterTypes)：获取当前类中声明的指定方法（包括private, protected, default）,但不包括继承来的方法。
  • getMethod(String name, Class<?>... parameterTypes)：获取公共方法,包括从父类或接口继承来的公共方法。
  • 要调用private方法，必须使用getDeclaredMethod()。

• setAccessible(true)：这是反射“暴力破解”的核心，它告诉虚拟机：“不要进行访问权限检查，让我执行它”。

  
  （图片来源网络，侵删）

• invoke(Object obj, Object... args)：

  • obj：要调用方法的对象实例，如果方法是静态的（static），则此参数可以是null。
  • args：传递给方法的参数值。

通过内部类

内部类（非静态内部类）可以访问其外部类的所有成员，包括private成员，我们可以利用这一点来间接调用private方法。

public class OuterClass {
    private String outerPrivateField = "Outer Private Field";
    // 外部类的私有方法
    private void outerPrivateMethod() {
        System.out.println("This is OuterClass's private method.");
        System.out.println("Can access outer private field: " + outerPrivateField);
    }
    // 定义一个内部类
    class InnerClass {
        public void callOuterPrivateMethod() {
            // 内部类可以直接访问外部类的 private 方法
            outerPrivateMethod();
        }
    }
    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        OuterClass.InnerClass inner = outer.new InnerClass();
        inner.callOuterPrivateMethod();
    }
}

输出：

This is OuterClass's private method.
Can access outer private field: Outer Private Field

这种方法的局限性很大，因为它要求你能够修改private方法所在类的代码，为其添加一个内部类，它不适用于调用第三方库中类的private方法。

通过序列化与反序列化（非常罕见且危险）

这是一种非常规的“黑科技”，利用了Java序列化的机制,基本思路是：

1. 将包含private方法的对象序列化（Serialize）成字节流。
2. 在字节流中，可以修改或移除与private方法访问控制相关的信息。
3. 将修改后的字节流反序列化（Deserialize）回一个新的对象。
4. 这个新对象可能会失去对原始private方法的访问限制。

这种方法极其复杂、脆弱、不安全，并且依赖于JVM的内部实现细节，强烈不推荐在生产环境中使用。 它更多存在于理论探讨或某些非常特殊的攻击场景中。

总结与对比

最佳实践与建议

1. 优先遵守封装原则：请审视你是否真的需要调用private方法，很多时候，问题可以通过重构代码、调整类的设计来解决，将需要调用的方法改为default或protected，或者通过组合、委托等设计模式。

2. 反射是最后的手段：当你无法修改源码（测试一个第三方库的类）并且确实需要访问其内部实现时，反射是正确的选择，但在使用反射时,务必：

   • 添加充分的注释,说明为什么使用反射以及它的目的。
   • 进行异常处理（NoSuchMethodException, IllegalAccessException, InvocationTargetException等）。
   • 考虑性能开销。

3. 警惕安全性：在应用服务器（如Tomcat）或安全管理器（SecurityManager）环境下，反射操作可能会被禁止，抛出SecurityException。

虽然Java提供了多种技术来“打破”private的限制，但开发者应始终保持对封装性的敬畏,只在必要时使用这些高级特性。