Java中的反射，枚举，lambda

1.反射

JAVA中反射是动态获取信息以及动态调用对象方法的一种反射机制。
Java反射就是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；并且能改变它的属性。而这也是Java被视为动态语言的一个关键性质。

先定义一个类，用以操作该类：

class Cat {
    private String name = "秘密";

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

    public Cat() {

    }

    public void eat(String food) {
        System.out.println(name +"正在吃"+food);
    }

    public void eat(String food1,String food2) {
        System.out.println(name+"正在吃"+food1+","+food2);
    }
}

①借助反射实例化对象

public static void testInstance() throws ClassNotFoundException, IllegalAccessException, InstantiationException{
        Class catClass = Class.forName("Cat");

        Cat cat = (Cat)catClass.newInstance();
    }

②借助反射获取对象的属性

 public static void testField() throws ClassNotFoundException, NoSuchFieldException, IllegalAccessException {
        //获取类对象
        Class catClass = Class.forName("Cat");
        //借助类对象，获取指定的Field对象
        Field field = catClass.getDeclaredField("name");
        field.setAccessible(true);//专门处理private成员方式
        //根据图纸修改
        Cat cat = new Cat();
        field.set(cat,"步步");//根据图纸修改属性
        String name = (String)field.get(cat);
        System.out.println(name);
    }

③借助反射获取对象方法

 public static void testMethod() throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        Class catClass = Class.forName("Cat");
        //从第二个参数开始都是用来描述是哪个版本的eat
        Method method = catClass.getMethod("eat",String.class);
       // Method method2 = catClass.getMethod("eat",String.class,String.class);
        Cat cat = new Cat();
        method.invoke(cat,"鱼");
    }

④借助反射调用构造方法

 public static void testConstructor() throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        Class catClass = Class.forName("Cat");
        Constructor constructor = catClass.getConstructor(String.class);
        constructor.setAccessible(true);
        Cat cat = (Cat) constructor.newInstance("小黑");
        cat.eat("猫粮");
    }

2.枚举

//用于表示穷举的概念,不建议完成其他不该完成的工作

enum Sex {
    MALE,
    FEMALE,
    UNKNOWN;
}
public class TestEnum {
    public static final int Male = 0;
    public static final int Female = 1;
    public static final int UnKnow = 2;

    public static void main(String[] args) {
        /*if (Male+1 == Female) {

        }*///编译可以通过但不合理


        /*if (Sex.MALE+1 == Sex.FEMALE) {

        }*///用枚举编译直接报错
        Sex s = Sex.MALE;
        System.out.println(s);
        System.out.println(Arrays.toString(Sex.values()));
    }
}

3.lambda

public class TestLambda {
    static class Student {
        public String name;
        public int score;

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

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

    public static void main(String[] args) {
        Student[] students = {
                new Student("张三",98),
                new Student("李四",90),
                new Student("王五",95),
                new Student("赵六",92),
                new Student("妮妮",99)
        };
       /* Arrays.sort(students, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return o1.score - o2.score;
            }
        });*/
       //lambda表达式
       Arrays.sort(students,(o1,o2) -> o1.score - o2.score);
        System.out.println(Arrays.toString(students));

    }
}