java（通过反射操作对象）

通过反射创建对象：

1、方式一：调用类中的public修饰的无参构造器

2、方式二：调用类中的指定构造器

3、Class类相关方法

        newInstance：调用类中的无参构造器，获取对应类的对象

        getConstructor( Class...clazz )：根据参数列表，获取对应的构造器对象

        getDecalaredConstructor( Class...clazz)：根据参数列表，获取对应的构造器对象

4、Constructor类相关方法

        setAccessible：暴破

        newInstance(Object...obj)：调用构造器

public class ReflectCreateInstance {
    public static void main(String[] args) throws Exception{
        //先获取到User类的Class对象
        Class<?> userClass = Class.forName("reflection_.User");
        //通过public的无参构造器创建实例
        Object o = userClass.newInstance();
        System.out.println(o);
        //通过public的有参构造器创建实例
        Object jack = userClass.getConstructor(String.class).newInstance("jack");
        System.out.println(jack);
        //通过非public的有参构造器创建实例
        //得到private的构造器对象
        Constructor<?> declaredConstructor = userClass.getDeclaredConstructor(String.class, int.class);
        declaredConstructor.setAccessible(true);//使用反射可以访问private构造器
        Object milan = declaredConstructor.newInstance("milan", 20);
        System.out.println(milan);
    }
}
class User{
    private String name;
    private int age;
    public User(){}

    public User(String name) {
        this.name = name;
    }

    private User(String name, int age){
        this.age=age;
        this.name=name;
    }
    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

通过反射访问类中成员：

1.根据属性名获取Field对象

        Field field = class对象.getDeclaredField(属性名)

2.暴破：f.setAccessible（true）

3.访问

        f.set（o，值）

        syso（f.get（o））

4.如果是静态属性，则set和get中的参数o，可以写成null

public class ReflectAccessProperty {
    public static void main(String[] args) throws Exception{
        Class<?> studentClass = Class.forName("reflection_.Student");
        Object o = studentClass.newInstance();
        Field age = studentClass.getDeclaredField("age");
        age.set(o,20);//通过反射设置属性的值
        System.out.println(o);
        System.out.println(age.get(o));
        //操作静态属性
        Field name = studentClass.getDeclaredField("name");
        name.setAccessible(true);
        name.set(o,"jack");
        System.out.println(o);
        System.out.println(name.get(null));
    }
}
class Student{
    private static String name;
    public int age;
    public Student(){}
    @Override
    public String toString() {
        return "Student{" +
                "age=" + age +
                '}';
    }
}

通过反射访问方法：

1.根据方法名和参数列表获取Method方法对象：

        Method m = clazz.getDeclaredMethod(方法名，XX.class);

2.获取对象：Object o = claszz.newInstance();

3.暴破：m.setAccessible(true)

4.访问：Object returnValue = m.invoke(o，实参列表)

5.注意：如果是静态方法，则invoke的参数o，可以写成null

public class ReflectMethod {
    public static void main(String[] args) throws Exception{
        Class<?> bossClass = Class.forName("reflection_.Boss");
        Object o = bossClass.newInstance();
        Method hi = bossClass.getMethod("hi", String.class);
        hi.invoke(o,"hello");
        //操作静态方法
        Method say = bossClass.getDeclaredMethod("say", int.class, String.class, char.class);
        say.setAccessible(true);
        System.out.println(say.invoke(o,20,"jack",'c'));

    }
}
class Boss{
    public int age;
    private static String name;

    public Boss() {}
    private static String say(int n,String s,char c){
        return n+" "+s+" "+c;
    }
    public void hi(String s){
        System.out.println(s);
    }
}