Java reflection calls inner class

1. Reflect the inner class that calls the default access permissions

package com.blueStarWei.invoke;

import java.lang.reflect.Method;

import com.blueStarWei.invoke.OuterClass.InnerClass;

class OuterClass {
    public void func(){
        System.out.println("Outer Class.");
    }
    
    class InnerClass {
        private String mName;
        public InnerClass(String mName) {
            this.mName = mName;
        }
        void getName(){
            System.out.println("Name is : "+mName);
        }
        
    }
}


public class OuterInnerClass {

    public  static  void main(String[] args) {
         try {
             /* Instantiate inner class through reflection
             * The power is: when the inner class is private (private class InnerClass), it can also be called
             * */
            Class outerClass = Class.forName("com.blueStarWei.invoke.OuterClass");
            Class innerClass = Class.forName("com.blueStarWei.invoke.OuterClass$InnerClass");
            Method method = innerClass.getDeclaredMethod("getName" );
             // TODO study it
             // The first parameter of the inner class newInstance must be a reference to the outer class instance 
            method.invoke(innerClass.getDeclaredConstructors()[0].newInstance(outerClass .newInstance(),"Wei")); // Name is : Wei
            
            /* regular method to instantiate inner class
             * When the inner class is private, the inner class cannot be instantiated in this way
             * */
            OuterClass outerClass1 = new OuterClass();
            InnerClass innerClass1 = outerClass1.new InnerClass("David");
            innerClass1.getName();//Name is : David
        } catch (Exception e) {
            e.printStackTrace ();
        }
    }
}

 

2. Reflection call static inner class

package com.blueStarWei.invoke;

import java.lang.reflect.Method;

class OuterClass {
    public void func(){
        System.out.println("Outer Class.");
    }
    
    static class InnerClass {
        private String mName;
        public InnerClass(String mName) {
            this.mName = mName;
        }
        void getName(){
            System.out.println("Name is : "+mName);
        }
    }
}


public class StaticInnerClass {

    public  static  void main(String[] args) {
         try {
             /* Instantiate inner class by reflection */ 
            Class outerClass = Class.forName("com.blueStarWei.invoke.OuterClass" );
            Class innerClass = Class.forName("com.blueStarWei.invoke.OuterClass$InnerClass");
            Method method = innerClass.getDeclaredMethod("getName" );
             // The static inner class does not hold a reference to the outer class and does not need to pass a reference to the instance object of the outer class 
            method.invoke(innerClass.getDeclaredConstructors()[0].newInstance(" Wei")); // Name is : Wei 
            
        } catch (Exception e) {
            e.printStackTrace ();
        }
    }
}

 

3. Reflection call anonymous inner class

package com.blueStarWei.invoke;

class OuterClass {
    public Runnable runnable = new Runnable() {
        @Override
        public void run() {
            System.out.println("This is InnerClass.");
        }
    };
}

public class AnonymousInnerClass {
    public static void main(String[] args) {
        try {
            Class outerClass = Class.forName("com.blueStarWei.invoke.OuterClass" );
             // Take anonymous inner class as member variable of outer class 
            Runnable runnable = (Runnable) outerClass.getDeclaredField("runnable" ).get(outerClass. newInstance());
            runnable.run();
        } catch (Exception e) {
            e.printStackTrace ();
        }
    }
}

 

　　 For more content, please visit: http://www.cnblogs.com/BlueStarWei/