反射获得对象，方法，构造方法，并赋值

反射：

   Reflection
   反编译：通过对类文件的操作，实现源码的复现。
   反射：在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法（看不到源码）。
   动态获取。
   主要可以获得 所有的 属性（公有，私有，受保护，默认）
                     方法（公有，私有，受保护，默认）
       还能对属性进行赋值，对方法进行赋值
   优点：针对大型软件，如果进行升级和改造，可以通过反射机制动态调用方法，来更改原来方法的不足，提高软件的灵活性。

反射的使用：

   一：Object -> getClass();返回此Object的运行时的类
   二：任何数据类型（基本数据类型）都有一个静态的class属性。
       Object.class;
   三：使用class的静态方法：forName  (推荐使用)
       class.forname("");返回与给定字符串名称或接口相关联的类的对象

获得构造方法并赋值

/**
 * 反射 调用构造方法：
 * getConstructors() 返回一个数组包含 Constructor物体反射所有的 类对象表示的类的公共调用构造方法。（只返回public修饰的构造方法）
 * getDeclaredConstructors() 反射所有构造方法
 *
 */
public class ReflectionMain1 {
    public static void main(String[] args) throws NoSuchMethodException {
        try {
        	//Class.forName("类的全路径")
        	//如果只知道想要反射的类名，不知道路径的话
        	
        	//方法一 getClass()
        	/*Student s=new Student();
        	Class c = s.getClass();
        	System.out.println(c.getName());*/
        	
        	//方法二 Class
        	/*Class<Student> sc = Student.class;
        	System.out.println(sc.getName());*/
        	
            Class a = Class.forName("Demo14.Student");
            System.out.println("输出public修饰的调用构造方法");
            Constructor[] cons = a.getConstructors();
            for(Constructor c:cons){
                System.out.println(c);
            }
            System.out.println("输出所有调用构造方法");
            Constructor[] con = a.getDeclaredConstructors();
            for(Constructor c:con){
                System.out.println(c);
            }

            System.out.println();
            
            //getDeclaredConstructor();括号里面写的是想要赋值的构造方法的参数类型
            Constructor co = a.getDeclaredConstructor(String.class);
            System.out.println(co);
            
            //private类型是不可访问的，所以要用setAccessible为true去暴力访问
            //暴力访问private类型
            co.setAccessible(true);
            
            //进行赋值
            Object obj=co.newInstance("zyl");
            System.out.println(obj);

            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

获得对象并赋值

/**
 * 反射 调用对象：
 * getFields() 返回public修饰的对象
 * getDeclaredFields 返回所有对象
 */
public class ReflectionMain2 {
    public static void main(String[] args) throws ClassNotFoundException{
        Class a = Class.forName("Demo14.Student");
        Field[] f = a.getFields();
        for(Field f1:f){
            System.out.println(f1);
        }

        Field[] f1=a.getDeclaredFields();
        for(Field f2:f1){
            System.out.println(f2);
        }

        Field name = null;
        try {
        	//getDeclaredField();括号里面为想要赋值的对象名
            name = a.getDeclaredField("name");
            
            //暴力访问
            name.setAccessible(true);
            
            //如果需要给对象的成员变量赋值，首先要有对象
            //获得一个无参构造函数，之后实例化赋给o
            Object o = a.getDeclaredConstructor().newInstance();
            name.set(o,"zyl");
            System.out.println(o);
        } catch (NoSuchFieldException | NoSuchMethodException | InstantiationException | IllegalAccessException | InvocationTargetException e) {
            e.printStackTrace();
        }
    }
}

获得方法并赋值

/**
 * 反射获得方法并调用
 * getMethods() 返回所有public修饰的方法
 * getDeclaredMethods() 返回所有方法
 */
public class ReflectionMain3 {
    public static void main(String[] args) throws ClassNotFoundException{
        Class a = Class.forName("Demo14.Student");
        Method[] m = a.getMethods();
        for(Method m1:m){
            System.out.println(m1);
        }
        Method show = null;
        try {
        	//a.getMethod();括号里面为想要赋值的方法名以及参数类型
            show = a.getMethod("show", String.class);
            System.out.println(show);
            
            //实例化对象
            Object o = a.getDeclaredConstructor().newInstance();
            show.invoke(o, "zyl");
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }

    }
}

Student类

package Demo14;

public class Student {
    private String name;
    private int age;
    private char sex;
    private String borth;

    protected Student(String name, char sex) {
        this.sex = sex;
        this.name = name;
    }

    private Student(String borth) {
        this.borth = borth;
    }

    public Student(String name, String borth, char sex) {
        this.borth = borth;
        this.name = name;
        this.sex = sex;
    }

    Student(String name, int age,char sex) {
        this.name = name;
        this.age = age;
    }
    Student(){

    }

    public void show(String name){
        System.out.println("你好"+name);
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex=" + sex +
                ", borth='" + borth + '\'' +
                '}';
    }

    public String getName() {
        return name;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public String getBorth() {
        return borth;
    }

    public void setBorth(String borth) {
        this.borth = borth;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}