反射&枚举

• 概念：在运行状态中，可以得到任意一个类的全部属性和方法，对于任意一个对象都能调用它的属性和方法，这种动态获取信息和动态调用对象方法的功能就是反射机制。

• 前提：反射的前提是 一定要拿到字节码文件对象
  .java文件是不能直接运行的，需要先编译为.class文件，然后通过双亲委派机制被类的加载器加载成字节码文件对象，才可以在JVM中运行。
  在java中，一切皆对象，当字节码文件被加载到JVM中，就会形成一个类对象，而且一个类最多被加载一次。

• 实现
  先创建一个类

class Student {
    private String name;
    private String gender;
    private int age;

    public Student() {
        System.out.println("Student()");
    }

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

    private Student(String name, String gender, int age) {
        this.name = name;
        this.gender = gender;
        this.age = age;
    }

    public void setAge(int age){
        this.age=age;
    }
    private void setName(String name) {
        this.name = name;
    }

    private String getName() {
        return name;
    }

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

反射机制：

public class Test {
    public static void main(String[] args) throws Exception {
        Student student=new Student();

        //拿到类对象
        //方法一：需要知道全路径名
        Class<?> stu=Class.forName("Student");
        //方法二：类的静态方法
        Class<?> s=Student.class;
        //方法三：对象的静态方法
        Class<?> t=student.getClass();

        //反射构造器

        //拿到指定构造方法(非私有)，参数一定要匹配
        Constructor<?> stuCon1=stu.getConstructor(String.class,int.class);
        System.out.println(stuCon1);

        //拿到所有非私有构造方法，用数组来接收
        Constructor<?>[] stuCon2=stu.getConstructors();
        System.out.println(stuCon2.length);

        //拿到声明的构造方法
        Constructor<?> stuCon3=stu.getDeclaredConstructor(String.class,String.class,int.class);
        System.out.println(stuCon3);

        //拿到所有声明的构造方法(包括私有)
        Constructor<?>[] stuCon4=stu.getDeclaredConstructors();
        System.out.println(stuCon4.length);




        //创造对象实例
        //非私有构造方法构造
        Constructor<?> t1=stu.getConstructor(String.class,int.class);
        Student inst1=(Student)t1.newInstance("petrt",19);
        System.out.println(inst1);

        //私有构造方法构造(需要设置一下访问权限)
        Constructor<?> t2=stu.getDeclaredConstructor(String.class,String.class,int.class);
        t2.setAccessible(true);
        Student inst2=(Student)t2.newInstance("zhangsan","男",20);
        System.out.println(inst2);



        //反射属性

        //拿到非私有属性
        Field[] f1=stu.getFields();

        //拿到所有声明属性
        Field[] f2=stu.getDeclaredFields();

        //拿到私有属性
        Field name=stu.getDeclaredField("name");
        name.setAccessible(true);
        name.set(inst2,"lisi");
        System.out.println(name.get(inst2));
        System.out.println(inst2);

        Field age=stu.getDeclaredField("age");
        age.setAccessible(true);
        age.set(inst2,23);
        System.out.println(age.get(inst2));
        System.out.println(inst2);



        //反射方法
        //获取所有本类声明方法
        Method[] m1=stu.getDeclaredMethods();
        System.out.println(m1.length);
        System.out.println(Arrays.toString(m1));

        //获取所有非私有方法(包括继承基类的public方法)
        Method[] m2=stu.getMethods();
        System.out.println(m2.length);
        System.out.println(Arrays.toString(m2));

        //拿到私有方法
        Method setname=stu.getDeclaredMethod("setName",String.class);
        setname.setAccessible(true);
        setname.invoke(inst2,"wangwu");
        System.out.println(inst2);


        Method getname=stu.getDeclaredMethod("getName");
        getname.setAccessible(true);
        System.out.println(getname.invoke(inst2));

        //拿到公有方法
        Method setage=stu.getDeclaredMethod("setAge",int.class);
        setage.invoke(inst2,25);
        System.out.println(inst2);

    }

}

• 优点：对于任意一个类都可以知道它的属性和方法，对于任意一个对象都可以调用它的属性和方法；增加了程序的耦合性和扩展性；反射已经应用在很多流行框架中了，如：Struts、Hibernate、Spring 等等

• 缺点：应用反射会降低效率；绕过了源代码技术，会带来维护问题；用反射比相应的直接代码更复杂

• 枚举

//自定义枚举的构造函数默认是private，不能写成非private
    //枚举不能在类外直接实例化，也不能继承
enum EnumColor{
    RED("红",1),Black("黑",2);
    String color;
    int num;
    EnumColor(String color, int num) {
        this.color=color;
        this.num=num;
    }
}

注意：枚举不能反射
反射效率低的原因：

• invoke()方法会对方法参数进行封装和解封操作，invoke()方法参数为Object[]类型，如果咱们传一个基本数据类型，就会将其封装为Object类，生成字节码时，还会将其解封为未封装前，还会对参数进行校验。
• invoke()会检查方法的可见性。
• invoke()方法难以内联，invoke()就像是一块独木桥，各个调用的方法都需要挤过去，在各个调用点上调用的方法收集的信息比较乱，会影响内联程序的判断。
• 即使编译器没办法进行优化，因为是动态加载的类型。