Java基础之反射和枚举

一：反射

1.什么是反射

Java的反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法。
对于任意一个对象，都能够调用它的任意方法和属性，同样也可以修改部分类型信息。
这种动态获取信息以及动态调用动态方法的功能称为Java语言的反射机制。

2.反射相关的类

类名	用途
Class类	代表类的实体，在运行的Java程序中表示类和接口
Field类	代表类的成员变量/类的属性
Method类	代表类的方法
Constructor类	代表类的构造方法

2.1 Class类

获取 Class 类对象的三种方式

1. 使用 Class.forName(“类的全路径名”);静态方法
   前提：已明确类的全路径名
2. 使用 .class 方法
   说明：仅适合在编译前就已经明确要操作的 Class
3. 使用类对象的 getClass() 方法

接下来利用代码演示获取 Class 类对象的代码

package reflex;

class Student{
    //私有属性name
    private String name = "bit";
    //公有属性age
    public int age = 18;
    //不带参数的构造方法
    public Student(){
        System.out.println("Student()");
    }
    private Student(String name,int age) {
        this.name = name;
        this.age = age;
        System.out.println("Student(String,name)");
    }
    private void eat(){
        System.out.println("i am eat");
    }
    public void sleep(){
        System.out.println("i am pig");
    }
    private void function(String str) {
        System.out.println(str);
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

public class TestDemo1 {

    public static void main(String[] args) {
        // 1. 通过 对象.getClass() 来获取 Class对象
        Student s1 = new Student();
        Class c1 = s1.getClass();

        // 2.直接通过 类名.class 的方式得到 Class 对象
        // 直接通过 类名.class 的方式得到,该方法最为安全可靠，程序性能更高
        //  这说明任何一个类都有一个隐含的静态成员变量 class
        Class c2 = Student.class;

        Class c3 = null;

        try {
            //注意这里是类的全路径，如果有包需要加包的路径

            //通过 Class 对象的 forName() 静态方法来获取，用的最多，
            //但可能抛出 ClassNotFoundException 异常
            c3 = Class.forName("reflex.Student");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        // 一个类在 JVM 中只会有一个 Class 实例
        System.out.println(c1.equals(c2));
        System.out.println(c2.equals(c3));
        System.out.println(c2.equals(c3));
    }
}

在类外对 Student 进行反射的代码案例

package reflex;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class ReflexClassDemo {
    // 利用Class对象 获取 创建对象
    public static void reflectNewInstance() {
        try {
            Class<?> classStudent = Class.forName("reflex.Student");
            Object objectStudent = classStudent.newInstance();
            Student student = (Student) objectStudent;
            System.out.println("获得学生对象："+student);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
    // 反射私有的构造方法 -> 利用获得的构造函数来创建新的对象
    public static void reflectPrivateConstructor() {
        try {
            Class<?> classStudent = Class.forName("reflex.Student");
            // 传入私有构造函数的参数
            Constructor<?> declaredConstructorStudent = classStudent.getDeclaredConstructor(String.class,int.class);
            declaredConstructorStudent.setAccessible(true);
            Object objectStudet = (Student)declaredConstructorStudent.newInstance("lu",18);
            System.out.println(objectStudet);
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
    // 反射私有属性
    public static void reflectPrivateField() {
        try {
            Class<?> classStudent = Class.forName("reflex.Student");
            Field field = classStudent.getDeclaredField("name");
            field.setAccessible(true);

            Object objectStudent = (Student)classStudent.newInstance();
            field.set(objectStudent,"lu");

            String name = (String) field.get(objectStudent);
            System.out.println("修改后的name值为:"+name);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    // 反射私有方法 function
    public static void reflectPrivateMethod() {
        try {
            Class<?> classStudent = Class.forName("reflex.Student");
            // function方法有一个 String 类型的参数
            Method methodStudent = classStudent.getDeclaredMethod("function",String.class);
            System.out.println("私有方法的方法名为："+methodStudent.getName());
            //私有的一般都要加
            methodStudent.setAccessible(true);
            Object objectStudent = classStudent.newInstance();
            Student student = (Student) objectStudent;
            // 反射调用方法使用 invoke代表：调用 student 这个对象 methodStudent 表示的方法，并且传参
            // “我是给私有的function函数传的参数“
            methodStudent.invoke(student,"我是给私有的function函数传的参数");
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
    public static void main(String[] args) {
        // reflectNewInstance();
        // Student()
        // 获得学生对象：Student{name='bit', age=18}

        // reflectPrivateConstructor();
        // Student(String,name)
        // Student{name='lu', age=18}

        // reflectPrivateField();
        // Student()
        // 修改后的name值为:lu

        // reflectPrivateMethod();
        // 私有方法的方法名为：function
        // Student()
        // 我是给私有的function函数传的参数
    }
}

3.反射的优缺点

优点：

1. 对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法
2. 增加程序的灵活性和扩展性，降低耦合性，提高自适应能力
3. 反射已经运用在很多流行框架中

缺点：

1. 使用反射会有效率问题。会导致程序效率降低
2. 反射技术绕过源代码的技术，因而会带来维护问题。

二：枚举

package Test_Enum;

public enum TestDemo1 {
    // 枚举对象
    RED("red",1),BLACK("black",2),GREEN("green",3),WHITE("white",4);

    private  String name;
    private  int ordinal;

    TestDemo1(String name, int ordinal) {
        this.name = name;
        this.ordinal = ordinal;
    }

    public static TestDemo1 getEnumKey (int key) {
        for (TestDemo1 t: TestDemo1.values()) {
            if(t.ordinal == key) {
                return t;
            }
        }
        return null;
    }

    public static void main(String[] args) {
        System.out.println(getEnumKey(2));
    }


    public static void main1(String[] args) {

        System.out.println(GREEN.compareTo(WHITE));

        //valueOf()：将普通字符串转换为枚举实例
        System.out.println(TestDemo1.valueOf("RED"));

        // values():以数组形式返回枚举类型的所有成员
        TestDemo1[] Enums = TestDemo1.values();

        for (int i = 0; i < Enums.length; i++) {
            // ordinal() 表示序号
            System.out.print(Enums[i]+" "+Enums[i].ordinal());
        }



        TestDemo1 testDemo1 = TestDemo1.BLACK;

        // 不能做 switch case 参数的有 long boolean float double 四种类型
        switch (testDemo1) {
            case RED:
                System.out.println("red");
                break;
            case BLACK:
                System.out.println("black");
                break;
            case WHITE:
                System.out.println("WHITE");
                break;
            case GREEN:
                System.out.println("black");
                break;
            default:
                break;
        }
    }

}

枚举的优缺点

优点：

1. 枚举常量更简单安全 。
2. 枚举具有内置方法 ，代码更优雅

缺点：

1. 不可继承，无法扩展

能否通过反射来获取枚举的构造方法？不能！