java反射

• 所谓的反射实际上是通过clazz.getClass()方法获取一个类型为Class类型的对象，通过getName()、getPackage()、getMethods()等方法获取类的相关数据；
• 获取类的反射对象

1.Class.forName(全类名)–一般用这个
2.类名.class 
3.对象.getClass()方法

Example2 example2 = new Example2();
Class a1 = Class.forName("Example2");
System.out.println(a1);
Class a = Example2.class;
System.out.println(a);
Class<? extends Example2> exampleC = example2.getClass();
System.out.println(exampleC);

// out
class Example2
class Example2
class Example2

• 反射对象常用方法：

clazz.getName(); // 获取类名
clazz.getPackage; // 获取包名

clazz.getInterfaces(); // 获取接口
clazz.getSuperclass(); // 获取父类

clazz.getMethod();
//获取所有公共方法（1本类，父类，接口。2非私有）
clazz.getMethods(String name, 参数);
clazz.getDeclaredMethod(String name, 参数)
clazz.getDeclaredMethods(); //获取本类所有方法（包括私有） 

clazz.getConstructor(String name, 参数); //获取单个public权限的构造器
clazz.getConstructors(); // 获取多个public权限的构造器
 获取单个（有参根据传入的是什么类型找对应的构造函数）
clazz.geDeclaredtConstructor(String name, 参数); // 获取单个所有权限的构造器
clazz.getDeclaredConstructors(); // 获取多个所有权限的构造器

clazz.getField(String name);  // 获取所有公共属性（1本类，父类，接口。2非私有）
clazz.getFields();  // 获取所有公共属性（1本类，父类，接口。2非私有）
clazz.getDeclaredField(String name); // 获取本类单个属性（包括私有） 
clazz.getDeclaredFields(); // 获取本类所有属性（包括私有） 

clazz.getClasses() // 获取public内部类
clazz.getDeclaredClasses() // 获取内部所有的类

• 通过反射访问构造方法

public class Main1 {
    public static void main(String[] args) throws IllegalAccessException, InvocationTargetException, InstantiationException {
        Example1 example1 = new Example1("10", "20", "30");
        Class<? extends Example1> exampleC = example1.getClass();
        Constructor[] constructors = exampleC.getDeclaredConstructors();
        for (Constructor constructor: constructors){
            System.out.println("constructor: " + constructor);
            Class[] types = constructor.getParameterTypes();
            for (Class type: types){
                System.out.println("type: " + type);
            }
            Class[] exceptions = constructor.getExceptionTypes();
            for (Class exception: exceptions){
                System.out.println("exception: " + exception);
            }
            Example1 example2 = (Example1) constructor.newInstance("10", "20");
        }
    }
}

public class Example1 {
    private String s;
    private int i1, i2, i3;
    public Example1(){

    }
    public Example1(String s, int i){
        this.s = s;
        this.i1 = i;
    }
    public Example1(String... args){
        if (1 < args.length){
            this.i1 = Integer.valueOf(args[0]);
        }
        if (2 < args.length){
            this.i2 = Integer.valueOf(args[1]);
        }
        if (13 < args.length){
            this.i3 = Integer.valueOf(args[2]);
        }
    }

    public void print(){
        System.out.println("s" + s);
        System.out.println("i1" + i1);
        System.out.println("i2" + i2);
        System.out.println("i3" + i3);
    }
}

• 通过反射获取成员变量

public class Main2 {
    public static void main(String[] args) throws IllegalAccessException {
        Example2 example2 = new Example2();
        Class<? extends Example2> exampleC = example2.getClass();
        // 只能获取public权限的成员变量
        Field[] fields1 = exampleC.getFields();
        for (Field field: fields1){

            System.out.println("field1的名称" + field.getName());
            System.out.println("field1的类型" + field.getType());
        }
        // 获取所有权限类型的成员变量
        Field[] fields2 = exampleC.getDeclaredFields();
        for (Field field: fields2){
            System.out.println("field2的名称" + field.getName());
            System.out.println("field2的类型" + field.getType());
            // 我们边通过设置忽略访问权限直接访问私有的成员变量
            field.setAccessible(true);
            if (field.getType() == int.class){
                field.setInt(example2, 1);
            }

        }
    }
}

public class Example2 {
    private int i;
    public float f;
    protected boolean b;
    private String s;
}

• 访问方法

public class Main3 {

    public static void main(String[] args) throws InvocationTargetException, IllegalAccessException {
        Example3 example3 = new Example3();
        Class<? extends Example3> clazz = example3.getClass();
        Method[] methods = clazz.getDeclaredMethods();
        for (Method method: methods){
            System.out.println("getName: " + method.getName());
            System.out.println("getReturnType: " + method.getReturnType());
            System.out.println("getParameterTypes: " + method.getParameterTypes());
            System.out.println("isVarArgs: " + method.isVarArgs());
            if (method.getName().equals("staticMethod")){
                method.invoke(example3);
            }
            if (method.getName().equals("publicMethod")){
                method.invoke(example3 ,1);
            }

        }

    }
}

public class Example3 {
    static void staticMethod(){
        System.out.println("执行static方法");
    }

    public int publicMethod(int i){
        System.out.println("执行public方法");
        return i * 100;
    }

    protected int protectedMethod(String s, int i){
        System.out.println("执行protected方法");
        return Integer.valueOf(s) + i;
    }

    private String privateMethod(String... strings){
        System.out.println("执行private方法");
        StringBuffer stringBuffer = new StringBuffer();
        for (String string: strings){
            stringBuffer.append(string);
        }
        return stringBuffer.toString();
    }
}