How to call a private method that exists inside a private inner class

Question

I want to test a private method that existe inside a private inner class

 public class MyBigClass {
    private class MyInnerClass {
       private void wantedMethod() {
       }
    }
 }

I want to call the wantedMethod() to test it

Here is my code

Class[] classes = MyBigClass.class.getDeclaredClasses();
    for (int i = 0; i < classes.length; i++) {
        // this code print "MyInnerClass"
        System.out.println(">> inner classes >> " + classes[i].getSimpleName());
        if (classes[i].getSimpleName().equals("MyInnerClass")) {
            Class clazz = classes[i];
            // Constructor c=clazz.getConstructor();
            Method[] methods = clazz.getDeclaredMethods();
            // this code print "wantedMethod"
            for (int j = 0; j < methods.length; j++) {
                System.out.println("inner class methods >>  " + methods[i].getName());
            }

        }

    }    

Problem : I cannot call wantedMethod()

Answer 1

If you want to invoke a non-static method you need to call it on instance of a class which has such method. In your case you want to call it on instance of private inner class MyInnerClass.

But since you don't have any instance of such class yet you need to create it. Since Java can't let inner class object be created without outer class object, you will need to have such outer object too (instance of MyBigClass).

So generally these are steps you need to take:

• create outer class object (if you don't have one),
• by using that outer class object create inner class object,
• invoke method on inner class object.

You can do it like this:
(just remember that default constructors of class have same visibility as visibility of that class. So private class will have private default constructor, so we will need to make it accessible before we can use it)

try {
    //creating outer class object
    Object outer = new MyBigClass();
    
    //creating inner class object
    Class<?> innerClass = Class.forName("MyBigClass$MyInnerClass");
    Constructor<?> constructor = innerClass.getDeclaredConstructor(MyBigClass.class);//constructors of inner classes require as first parameter instance of its outer class
    constructor.setAccessible(true);//private inner class has private default constructor
    Object child = constructor.newInstance(outer);//created inner object must know which outer object is used to create it

    //TADA!!!
    //invoking method on inner class object
    Method method = innerClass.getDeclaredMethod("wantedMethod",new Class<?>[]{});
    method.setAccessible(true);//since method is private
    method.invoke(child,new Object[]{});
    
} catch (ClassNotFoundException | NoSuchMethodException | SecurityException | InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException e1) {
    // TODO Auto-generated catch block
    e1.printStackTrace();
}

You can find more info about creating inner class object via reflection in this question

Answer 2

This is because your class isn't named CodeCircuit. Remove that if condition and it will work.

Also remove the line Constructor c=clazz.getConstructor(); as it throws an exception.

After making these changes, your own code prints

>> inner classes >> MyInnerClass
inner class methods >>  wantedMethod

EDIT

Use this code to execute the method.

    Class<?>[] classes = MyBigClass.class.getDeclaredClasses();

    for (Class<?> clazz : classes) {
        if(clazz.getSimpleName().equals("MyInnerClass")) {
            Method method = clazz.getDeclaredMethod("wantedMethod", new Class[] {});
            method.setAccessible(true);
            method.invoke(clazz.getDeclaredConstructor(MyBigClass.class).newInstance(new MyBigClass()), new Object[] {});
        }
    }

The syntax is a bit strange, making you to use the outer class for getting hold of the inner class constructor. It behaves as if you have a constructor with the below signature defined in your inner class:

public MyInnerClass(MyBigClass bigClass) {
}

But, I assume that's how Java handles inner (nested) classes using reflection.

Note that you'll have to provide a public constructor for your inner class.

public class MyBigClass {
    private class MyInnerClass {
        public MyInnerClass() {
            System.out.println("hello");
        }
        private void wantedMethod() {
            System.out.println("world");
        }
    }
}

You'll also have to setAccessible(true) on the private method in order to be able to invoke it.

EDIT 2

Upon further investigation, when I decompiled the generated MyBigClass$MyInnerClass.class class, I found that my hunch was right:

public class MyBigClass$MyInnerClass {
    public MyBigClass$MyInnerClass(MyBigClass paramMyBigClass) {
        System.out.println("hello");
    }
    private void wantedMethod() {
        System.out.println("world");
    }
}

Would be really glad if someone can throw some light into this behaviour