枚举、反射

我会带着你远行 2024-03-17 11:27 23阅读 0赞

## 枚举 ##

jdk1.5之前，需要自己实现枚举

### 自己实现枚举 ###

public class StatusEnum {
    
        private final String id;
        private final String code;
        private final String name;
    
        private StatusEnum(String id, String code, String name){
            this.id = id;
            this.code = code;
            this.name = name;
        }
    
        public static final StatusEnum TODO = new StatusEnum("1","todo","待完成");
        public static final StatusEnum DONE = new StatusEnum("2","todo","已完成");
        public static final StatusEnum DOING = new StatusEnum("3","doing","正在完成");
    
        public String getId() {
            return id;
        }
    
        public String getCode() {
            return code;
        }
    
        public String getName() {
            return name;
        }
    
        @Override
        public String toString() {
            return "StatusEnum{" +
                    "id='" + id + '\'' +
                    ", code='" + code + '\'' +
                    ", name='" + name + '\'' +
                    '}';
        }
    }

jdk1.5之后，提供了枚举

### jdk提供的枚举 ###

public enum StatusEnum2 {
    
        TODO("1","todo","待完成"),
    
        DONE("2","todo","已完成"),
    
        DOING("3","doing","正在完成");
    
        private final String id;
        private final String code;
        private final String name;
    
    
        StatusEnum2(String id, String code, String name) {
            this.id = id;
            this.code = code;
            this.name = name;
        }
    
        public String getId() {
            return id;
        }
    
        public String getCode() {
            return code;
        }
    
        public String getName() {
            return name;
        }
    }

枚举的父类是java.lang.Enum

### 没有属性的枚举 ###

public enum StatusEnum3 {
    
        TODO,
    
        DONE,
    
        DOING;
    
    }

### 枚举类常用的方法 ###

toString(): 返回对象名

values：静态方法，获取所有对象名

valueOf(name): 根据name或者对象

StatusEnum3 doing = StatusEnum3.DOING;
            System.out.println(doing.toString());
    
            StatusEnum3[] values = StatusEnum3.values();
            for(StatusEnum3 statusEnum3: values){
                System.out.println(statusEnum3.toString());
            }
    
            StatusEnum3 done = StatusEnum3.valueOf("DONE");
            System.out.println(done.toString());

![fbf82ef489014ab4a7f79ea8017c8258.png][]

### 枚举类也可以实现接口 ###

接口

public interface TestInterface {
        
        void show();
    }

枚举类

public enum StatusEnum3 implements TestInterface{
    
        TODO,
    
        DONE,
    
        DOING;
    
    
        @Override
        public void show() {
            System.out.println("xxx");
        }
    }

此时，枚举对象调用接口方法时，调用的是同一个方法。

如果想要每种类型的枚举调用不同的方法实现，可以这样做：

public enum StatusEnum3 implements TestInterface{
    
        TODO{
            @Override
            public void show() {
                // todo something
            }
        },
    
        DONE{
            @Override
            public void show() {
                // todo something
            }
        },
    
        DOING{
            @Override
            public void show() {
                // todo something
            }
        };
        
    }

### 枚举搭配switch case使用 ###

case中不用写StatusEnum3.TODO,直接写TODO就可以了

StatusEnum3 statusEnum3 = StatusEnum3.DOING;
            switch (statusEnum3){
                case TODO: // do something 
                    break;
                case DOING: // do something 
                    break;
                case DONE: // do something 
                    break;
            }

## 反射 ##

JAVA反射机制是在**运行状态**中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制。

在运行期间，如果我们要产生某个类的对象，Java虚拟机(JVM)会检查该类型的Class对象是否已被加载。如果没有被加载，JVM会根据类的名称找到.class文件并加载它。一旦某个类型的Class对象已被加载到内存，就可以用它来产生该类型的所有对象。

### 获取字节码信息的四种方式 ###

1. 通过对象获取

2. 通过内置class获取

3.通过forName获取

4.通过类加载器获取

public class Test {
    
        public static void main(String[] args) throws ClassNotFoundException {
            // 通过对象获取
            Person person = new Person();
            Class<? extends Person> personClass = person.getClass();
            // 通过内置class获取
            Class<Person> personClass2 = Person.class;
            // 通过Class.forName获取
            Class<?> personClass3 = Class.forName("com.xy.shirotest.reflectTest.Person");
            // 通过类加载器获取
            Class<?> personClass4= Test.class.getClassLoader()
                    .loadClass("com.xy.shirotest.reflectTest.Person");
        }
    }

获取的所有字节码都是同一个。一个类只有一个字节码信息

### Class类的具体实例 ###

1. 类

2. 接口

3. 数组

4. 基本数据类型

5. 注解

6. void

// 可以作为Class类的实例
            // 类
            Class<Object> objectClass = Object.class;
            // 接口
            Class<Serializable> serializableClass = Serializable.class;
            // 数组
            int[] a = {1,2,3};
            // 同一维度，同一个类型的字节码文件一样
            Class<? extends int[]> aClass = a.getClass();
            // 基本数据类型
            Class<Integer> integerClass = int.class;
            // 注解
            Class<Controller> controllerClass = Controller.class;
            // void
            Class<Void> voidClass = void.class;

### 获取构造器 ###

// 根据字节码获取构造器
            // 获取字节码
            Class<Object> clazz = Object.class;
            
            // 获取public类型的所有构造器
            Constructor<?>[] publicConstructors = clazz.getConstructors();
            // 获取public类型无参构造器
            Constructor<Object> publicWucanConstructor = clazz.getConstructor();
            // 获取public类型指定构造器(参数根据构造器的参数类型来设定)
            Constructor<Object> publicConstructor = clazz.getConstructor(int.class, double.class);
            
            // 获取所有访问修饰符的构造器
            Constructor<?>[] declaredConstructors = clazz.getDeclaredConstructors();
            // 获取所有访问修饰符的无参构造器
            Constructor<Object> wucanDeclaredConstructor = clazz.getDeclaredConstructor();
            // 获取所有访问修饰符的指定构造器(参数根据构造器的参数类型来设定)
            Constructor<Object> declaredConstructor = clazz.getDeclaredConstructor(int.class, double.class);
    
            // 通过构造器创建对象
            Object o1 = publicWucanConstructor.newInstance();
            // 
            Object o2 = declaredConstructor.newInstance(1, 1.2);

### 获取属性、给属性设值 ###

// 获取当前类和父类中，所有被public修饰的属性
            Field[] fields = clazz.getFields();
    
            // 获取当前类中所有属性
            Field[] declaredFields = clazz.getDeclaredFields();
    
            // 根据属性名获取属性public
            Field gender = clazz.getField("gender");
    
    
            // 获取属性具体信息 ---------------------
            // 获取属性名
            String name = gender.getName();
            // 获取属性类型
            String typeName = gender.getType().getName();
            // 获取访问修饰符
            String modifier = Modifier.toString(gender.getModifiers());
            
            // 给属性设值
            Object obj = clazz.newInstance();
            gender.set(obj, "男");

### 获取方法 ###

/* 获取方法 */ 
            // 获取运行时类和所有父类的public方法
            Method[] publicMethods = clazz.getMethods();
            // 根据方法名获取不带参数的public方法（运行时类和所有父类的）
            Method eat = clazz.getMethod("eat");
            // 根据方法名和参数类型获取public方法（运行时类和所有父类的）
            Method sleep = clazz.getMethod("sleep", int.class, long.class);
    
            // 获取运行时类所有方法
            Method[] declaredMethods = clazz.getDeclaredMethods();
            // 根据方法名获取不带参数的方法
            Method hello = clazz.getMethod("hello");
            // 根据方法名和参数类型获取方法
            Method world = clazz.getDeclaredMethod("world", String.class, double.class);
    
            /* 获取方法相关参数 */
            // 方法修饰符
            String methodModifier = Modifier.toString(world.getModifiers());
            // 方法返回值类型
            Class<?> returnType = world.getReturnType();
            // 方法名
            String methodName = world.getName();
            // 方法参数列表类型
            Class<?>[] parameterTypes = world.getParameterTypes();
            // 注解 只能获取RUNTIME类型的注解
            Annotation[] annotations = world.getAnnotations();
            
            /* 方法调用 */
            Object o = clazz.newInstance();
            Object invokeReturn = world.invoke(o, "zhangsan", 19.8);

### 获取其他信息 ###

// 获取运行时class的接口
            Class<?>[] interfaces = clazz.getInterfaces();
            // 获取父类
            Class<? super Object> superclass = clazz.getSuperclass();
            // 获取父类接口
            Class<?>[] superInterfaces = superclass.getInterfaces();
            // 获取当前类的包
            Package aPackage = clazz.getPackage();
            // 获取当前类的注解
            Annotation[] classAnnotations = clazz.getAnnotations();

## 测试 ##

黑盒测试：不需要关注代码

白盒测试：需要关注代码

junit单元测试属于白盒测试

[fbf82ef489014ab4a7f79ea8017c8258.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/c363bb73385340418cb544f269b75717.png