java private方法怎么调用

在Java中，private方法是类的成员方法，只能在类的内部调用，private关键字表示这个方法只能被类的成员(包括静态成员)访问，不能被类的对象或者外部类访问，如何调用private方法呢？本文将从以下几个方面进行详细介绍：

1、使用this关键字调用private方法

2、通过创建类的对象调用private方法

3、使用继承和super关键字调用父类的private方法

4、通过静态方法调用私有方法

5、使用反射机制调用私有方法

使用this关键字调用private方法

在类的内部，可以使用this关键字来调用其他成员(包括private方法)和属性，this关键字指向当前对象，可以用来调用同一个类中的其他非static方法，下面是一个示例：

public class MyClass {
    private void myPrivateMethod() {
        System.out.println("这是一个私有方法");
    }
    public void callPrivateMethod() {
        this.myPrivateMethod(); // 使用this关键字调用私有方法
    }
    public static void main(String[] args) {
        MyClass obj = new MyClass();
        obj.callPrivateMethod(); // 通过创建对象调用私有方法
    }
}

通过创建类的对象调用private方法

当需要在一个对象上调用另一个对象的private方法时，可以通过创建该对象的实例来实现，下面是一个示例：

public class MyClass {
    private void myPrivateMethod() {
        System.out.println("这是一个私有方法");
    }
}
public class Main {
    public static void main(String[] args) {
        MyClass obj1 = new MyClass();
        obj1.myPrivateMethod(); // 通过创建对象调用私有方法
    }
}

使用继承和super关键字调用父类的private方法

如果一个类继承了另一个类，并且想要调用父类的私有方法，可以通过super关键字来实现，super关键字用于调用父类的方法，而父类的方法可以是public、protected或private，下面是一个示例：

class Parent {
    private void parentPrivateMethod() {
        System.out.println("这是一个父类的私有方法");
    }
}
class Child extends Parent {
    private void childPrivateMethod() {
        super.parentPrivateMethod(); // 使用super关键字调用父类的私有方法
    }
}
public class Main {
    public static void main(String[] args) {
        Child obj = new Child();
        obj.childPrivateMethod(); // 通过继承和super关键字调用父类的私有方法
    }
}

通过静态方法调用私有方法

在Java中，可以使用静态方法来调用其他静态方法或非静态方法，由于私有方法只能在类的内部访问，因此不能直接通过静态方法调用私有方法，可以通过反射机制来实现这一目的，下面是一个示例：

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import org.junit.Test;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;
public class TestReflection {
    private void myPrivateMethod() { System.out.println("This is a private method"); }
     @Test public void testReflection() throws Exception { List<String> allowedNames = Arrays.asList("main", "apply", "isAccessible"); Method method = getClass().getDeclaredMethod("myPrivateMethod", (Class<?>[])null); if (method == null || Modifier.isPrivate(method.getModifiers())) throw new RuntimeException("No such method"); method.setAccessible(true); try { method.invoke(this, (Object[])null); fail("Should throw an IllegalAccessException"); return; } catch (IllegalAccessException expected) {} try { method.invoke(new TestReflection(), (Object[])null); fail("Should throw an InvocationTargetException"); return; } catch (InvocationTargetException e) {} try { method.invoke((Object)new TestReflection(), (Object[])null); fail("Should throw an IllegalArgumentException"); return; } catch (IllegalArgumentException expected) {} try { method.invoke((Object)new TestReflection(), new Object[] {}); fail("Should throw an IllegalArgumentException"); return; } catch (IllegalArgumentException expected) {} try { method.invoke((Object)new TestReflection(), Stream.of(new Object[0]).toArray()); fail("Should throw an IllegalArgumentException"); return; } catch (IllegalArgumentException expected) {} try { method.invoke((Object)new TestReflection(), new String[] {"abc"}); fail("Should throw an IllegalArgumentException"); return; } catch (IllegalArgumentException expected) {} try { method.invoke((Object)new TestReflection(), Arrays.asList("abc")); fail("Should throw an IllegalArgumentException"); return; } catch (IllegalArgumentException expected) {} try { method.invoke((Object)new TestReflection(), new Object[] {"abc"}); fail("Should throw an IllegalArgumentException"); return; } catch (IllegalArgumentException expected) {} try { method.invoke((Object)new TestReflection(), Stream.of(new Object[] {"abc"}).collect(Collectors.toList())); fail("Should throw an IllegalArgumentException"); return; } catch (IllegalArgumentException expected) {} try { method.invoke((Object)new TestReflection(), Arrays.asList(new Object[] {"abc"})); fail("Should throw an IllegalArgumentException"); return; } catch (IllegalArgumentException expected) {} try { method.invoke((Object)new TestReflection(), Stream.of(new Object[] {"abc"}).map(o -> o).collect(Collectors.toList())); fail("Should throw an IllegalArgumentException"); return; } catch (IllegalArgumentException expected) {} try { method.invoke((Object)new TestReflection(), Arrays.asList(Stream.of(new Object[] {"abc"})).flatMap(o -> o).collect(Collects