Java反射、注解、枚举

已于 2022-11-02 14:26:26 修改
阅读量271 收藏 2
点赞数
分类专栏： 后端 文章标签： java
于 2022-10-30 23:26:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44735933/article/details/127606419
版权

1.反射

一、什么是反射？

Java反射是Java被视为动态语言的很重要的一个特性。
Java通过反射的Api可以做到获取运行时类的任何信息。包括其类、属性、方法、注解、父类等任何信息。并且可以直接操作任意对象的内部属性及方法。

二、反射能用来做什么？

  1. 在运行时判断任意一个对象所属的类。
  2. 在运行时构造任意一个类的对象。
  3. 在运行时判断任意一个类所具有的成员变量和方法。
  4. 在运行时获取泛型信息。
  5. 在运行时调用任意一个对象成员变量和方法。
  6. 在运行时处理注解。
  7. 生成动态代理。

三、获取class实例的方式。

获取Class实例的方式

  • 方式一：调用运行时类的属性。 .class Class<Person> clazz1 = Person.class;
  • 方式二：通过运行时类的对象 调用getClass这个方法 Class<? extends Person> aClass = person.getClass();
  • 方式三：调用Class的静态方法 Class.forName(String classPath)
  • 方式四：使用类的加载器：ClassLoader

Class的实例就对应着一个运行时类。 加载到内存中的运行时类，会缓存一定的时间，在此时间之内，我们可以通过不同的方式来获取此运行时类。

四、通过反射创建运行时类的对象。

newInstance():调用此方法创建对应的运行时类的对象。内部调用了运行时类的空参构造器。

要想此方法能够正常的创建运行时类的对象，要求：

  1. 运行时类必须提供空参构造器。
  2. 空参构造器的访问权限得够（通常设置为public的）

五、类加载器

系统类加载器：加载自己创建的一些类。
扩展类加载器：加载Java的lib下得扩展类。
引导类加载器：主要负责加载java的核心类库，无法加载自定义类的。

六、随机创建运行时类对象，体验动态性

	@Test
    public void testNewInstance1() throws Exception {

        int num = new Random().nextInt(3);
        String classPath = "";

        switch (num) {
            case 0: classPath = "java.util.Date"; break;
            case 1: classPath = "java.lang.Object"; break;
            case 2: classPath = "com.starcpdk.Person"; break;
        }

        Object obj = getInstance(classPath);
        System.out.println(obj);


    }

    /**
     * 创建一个指定类的对象
     * @param classPath 指定类的全类名
     * @return
     * @throws Exception
     */
    public Object getInstance(String classPath) throws Exception {
        Class<?> clazz = Class.forName(classPath);
        return clazz.newInstance();

    }

七、创建对象的几种方式

  1. new + 构造器
  2. 调用方法获取实例。XXX、XXXs、XXXFactory、XXXBuilder等。
  3. clone方法克隆对象。
  4. 反射方式创建对象。调用newInstance()使用类或者构造器调用。

八、clazz获取一些结构。

  1. 获取构造器。
// 获取当前运行时类中声明为public的构造器
Constructor<?>[] constructors = personClass.getConstructors();
// 获取当前运行时类的所有构造器
Constructor<?>[] declaredConstructors = personClass.getDeclaredConstructors();
  1. 获取运行时类的父类
// 获取运行时类的父类
Class<? super Person> superclass = personClass.getSuperclass();

// 获取运行时类的带泛型的父类
Type genericSuperclass = personClass.getGenericSuperclass();

// 获取运行时类的带泛型的父类
Type genericSuperclass = personClass.getGenericSuperclass();
// 获取父类的泛型类型
ParameterizedType parameterizedType = (ParameterizedType) genericSuperclass;
Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
System.out.println(((Class)actualTypeArguments[0]).getName());
  1. 获取运行时类实现的接口
// 获取运行时类实现的接口
Class<?>[] interfaces = personClass.getInterfaces();
// 获取运行时类的父类实现的接口。
Class<?>[] interfaces1 = personClass.getSuperclass().getInterfaces();
  1. 获取当前运行时类 所在的包
Package aPackage = personClass.getPackage();
  1. 获取运行时类 声明的注解
Annotation[] annotations = personClass.getAnnotations();
  1. 获取运行时类的方法
// 获取当前运行时类及其所以父类中声明为public的所有方法
Method[] methods = personClass.getMethods();
// 获取当前运行时类中的所有方法。（不包含父类中声明的方法）
Method[] declaredMethods = personClass.getDeclaredMethods();

@Test
public void test2() throws Exception {
    Class<Person> personClass = Person.class;
    Method[] declaredMethods = personClass.getDeclaredMethods();
    for (Method declaredMethod : declaredMethods) {

        // 4. 获取方法名
        System.out.print("方法名是：" + declaredMethod.getName() + ":\t");

        // 只能获取Runtime的生命周期的注解
        // 1. 获取方法声明的注解
        Annotation[] annotations = declaredMethod.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.print("注解是：" + annotation + "\t");
        }

        // 2、获取权限修饰符
        int modifiers = declaredMethod.getModifiers();
        System.out.print("权限修饰符是：" + Modifier.toString(modifiers) + "\t");

        // 3.获取返回值类型
        Class<?> returnType = declaredMethod.getReturnType();
        System.out.print("返回值类型是：" + returnType.getName() + "\t");

        // 5. 获取形参列表
        Class<?>[] parameterTypes = declaredMethod.getParameterTypes();
        if (!(parameterTypes == null || parameterTypes.length == 0)) {
            for (Class<?> parameterType : parameterTypes) {
                System.out.print("形参类型：" + parameterType.getName() + " args_" + " ");
            }
        }

        // 6. 抛出的异常
        Class<?>[] exceptionTypes = declaredMethod.getExceptionTypes();
        for (Class<?> exceptionType : exceptionTypes) {
            System.out.print("异常：" + exceptionType.getName());
        }

        System.out.println();
    }
}
  1. 获取运行时类的属性结构
// getFields() ：获取当前运行时类及其父类声明为public访问权限的属性
Field[] fields = personClass.getFields();
// getDeclaredFields():获取当前运行时类中所有的属性。（不包含父类的属性）
Field[] declaredFields = personClass.getDeclaredFields();

// 权限修饰符 数据类型  变量名
@Test
public void test1() {

    Class<Person> personClass = Person.class;
    Field[] declaredFields = personClass.getDeclaredFields();
    for (Field declaredField : declaredFields) {
        // 权限修饰符
        int modifiers = declaredField.getModifiers();
//            System.out.println(modifiers);
        System.out.print(Modifier.toString(modifiers) + "\t");

        // 数据类型
        Class<?> type = declaredField.getType();
        System.out.print(type.getName() + "\t");

        // 变量名
        String name = declaredField.getName();
        System.out.println(name);
    }

}
  1. 使用运行时类中的一些属性或方法
package com.starcpdk.java2;

/**
 * @Author 姚云峰
 * @Email
 * @Date 2022/10/27 14:02
 * @Version 1.0
 */

import com.starcpdk.test.Person;
import org.junit.jupiter.api.Test;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

/**
 * 调用运行类中指定的结构：属性、方法、构造器
 */
public class ReflectionTest {

    /**
     * 获取
     */
    @Test
    public void testField() throws Exception {

        // 获取指定的属性
        Class<Person> personClass = Person.class;

        // 创建运行时类的对象。
        Person person = personClass.newInstance();

        // 获取指定属性 , 要求运行时类中的属性声明为public的。
        // 通常不采用此方式
        Field id = personClass.getField("id");

        // 设置当前属性的值
        // 参数1：指明设置哪儿个对象的属性， 参数2：指明将此属性值设置为多少
        id.set(person , 1234);

        // 获取当前属性的值
        // 参数1：获取哪儿个对象的当前属性的值
        int pId = (int) id.get(person);
        System.out.println(pId);
    }


    /**
     * 操作运行时类中的属性。
     * @throws Exception
     */
    @Test
    public void testField1() throws Exception {
        Class<Person> personClass = Person.class;

        // 创建运行时类的对象。
        Person person = personClass.newInstance();

        // 获取指定变量名的属性
        Field age = personClass.getDeclaredField("age");
        // 保证当前属性是可访问的。
        age.setAccessible(true);
        // 获取、设置指定对象的此属性的值。
        age.set(person , 12);

        Object o = age.get(person);
        System.out.println(o);
    }

    /**
     * 操作运行时类中的方法
     * 参数1：指明获取方法的名称。
     * 参数2：指明获取方法的形参列表。
     */
    @Test
    public void testMethod() throws Exception {
        Class<Person> personClass = Person.class;
        Person person = personClass.newInstance();

        Method show = personClass.getDeclaredMethod("show", String.class);
        /**
         * invoke()
         * 参数1：方法的调用者。
         * 参数2：给方法形参赋值的实参。
         * invoke()的返回值就是对应类中调用的方法的返回值。
         */
        show.setAccessible(true);
        Object hahah = show.invoke(person, "哈哈哈哈");
        System.out.println(hahah);


        Method showDesc = personClass.getDeclaredMethod("showDesc");
        showDesc.setAccessible(true);
        // 如果调用的方法没有=返回值 ， 则返回null
        Object invoke = showDesc.invoke(Person.class);
        System.out.println(invoke);

    }

    /**
     * 调用运行时类中指定的构造器。
     *
     * 参数：指明构造器的参数列表
     *
     * @throws Exception
     */
    @Test
    public void testConstructor() throws Exception {
        Class<Person> personClass = Person.class;
        Constructor<Person> declaredConstructor = personClass.getDeclaredConstructor(String.class);
        declaredConstructor.setAccessible(true);
        Person tom = declaredConstructor.newInstance("Tom");

        System.out.println(tom);

    }
}

2. 枚举

一、什么是枚举

类中对象的个数是确定的，有限个。
枚举类中的属性的修饰符是 private final 的。
枚举类中的对象的修饰符是 public static final 的。

二、枚举类常用方法

  • values(): 返回一个数组，即枚举类中的所有对象
  • valueOf(String str) 找指定名的对象 ， 如果提供的str，在枚举类对象中没有，则抛异常。IllegalArgumentException
  • toString() 默认返回枚举类对象名称

三、例子

如何自定义枚举

/**
 * @Author 姚云峰
 * @Email
 * @Date 2022/8/20 16:02
 * @Version 1.0
 * <p>
 * <p>
 * 枚举类的使用
 */
public class SeasonTest {

}

/**
 * 自定义枚举实现
 */
class Season {

    private final String seasonName;
    private final String seasonDescription;

    private Season(String seasonName, String seasonDescription) {
        this.seasonName = seasonName;
        this.seasonDescription = seasonDescription;
    }

    public static final Season SPRING = new Season("春天" , "春暖花开");
    public static final Season SUMMER = new Season("夏天" , "夏日炎炎");
    public static final Season AUTUMN = new Season("秋天" , "秋高气爽");
    public static final Season WINTER = new Season("冬天" , "冰天雪地");

}

/**
 * @Author 姚云峰
 * @Email
 * @Date 2022/8/20 16:16
 * @Version 1.0
 *
 * 使用enum关键字创建枚举类
 *
 * 常用方法：
 *  values(): 返回一个数组，即枚举类中的所有对象
 *  valueOf(String str)  找指定名的对象 ， 如果提供的str，在枚举类对象中没有，则抛异常。IllegalArgumentException
 *  toString()   默认返回枚举类对象名称
 *
 *
 */
public class SeasonTestEnum {
    public static void main(String[] args) {
        System.out.println(Season1.SPRING);
    }
}

interface Info{
    void show();
}

enum枚举类。

// 枚举类实现接口。
// 可以统一重写接口方法
// 也可以每个枚举值都重写接口方法
enum Season1 implements Info{


    // 提供当前类枚举对象
    SPRING("春天","春暖花开"){
        @Override
        public void show() {
            System.out.println("春天在哪儿里");
        }
    },
    SUMMER("夏天","夏日炎炎") {
        @Override
        public void show() {
            System.out.println("夏宁");
        }
    },
    AUTUMN("秋天","秋高气爽") {
        @Override
        public void show() {
            System.out.println("秋天不回来");
        }
    },
    WINTER("冬天","冰天雪地") {
        @Override
        public void show() {
            System.out.println("大约在冬季");
        }
    };

    private final String seasonName;
    private final String seasonDescription;

    private Season1(String seasonName, String seasonDescription) {
        this.seasonName = seasonName;
        this.seasonDescription = seasonDescription;
    }

    // @Override
    // public void show() {
    //     System.out.println("这是一个季节。。。。。。");
    // }
}

注解

一、什么是注解，怎么定义

使用@interface关键字声明。
内部定义成员，通常使用value表示
可以指定成员的默认值，使用default定义默认值。
如果自定义的注解没有成员，表明是一个标识作用。
如果注解有成员，使用注解时需要指明成员的值。
自定义注解必须配上注解的信息处理流程（反射的方式）才有意义。
自定义注解通常都会指明两个元注解，即：@Retention \ @Target。

@Repeatable(MyAnnotations.class)
//@Inherited // 可继承注解。
@Retention(RetentionPolicy.RUNTIME)
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE , TYPE_PARAMETER , TYPE_USE})
public @interface MyAnnotation {
    String value() default "world";
}

二、什么是元注解

元注解：对现有注解进行解释说明的注解。
@Retention：指定所修饰的Annotation的声明周期： SOURCE\CLASS(默认行为)\RUNTIME
只有声明为RUNTIME声明的注解，才能通过反射获取。
@Target：用于指定被修饰的Annotation能用于修饰哪儿些程序元素。
@Documented：表示所修饰的注解在被javadoc解析时，保留下来。
@Inherited：具有继承性，如果某个类使用了被@Inherited修饰的Annotation，则其子类将自动具有该注解。

通过反射获取注解信息：

Class<Student> studentClass = Student.class;
Annotation[] annotations = studentClass.getAnnotations();

  • 可重复注解、类型注解

    • 可重复注解:
      • MyAnnotation上声明@Repeatable，成员值为MyAnnotations.class
      • MyAnnotation的Target和Retention和MyAnnotations相同。

  • 类型注解：

    • ElementType.TYPE_PARAMETER : 表示该注解能写在类型变量的声明语句中（如：泛型声明）
    • ElementType.TYPE_USE：表示该注解能写在使用类型的任何语句中。

三、注解使用场景

  1. 生成文档相关注解
  2. 在编译时进行格式检查
    @Override：限定重写父类方法，该注解只能用于方法
    @Deprecate：用于标识锁修饰的元素（类、方法）已过时。通常是因为锁修饰的结构危险或存在更好的选择。
    @SuppressWarnings：抑制编译器警告。

四、例子

@Repeatable(MyAnnotations.class)
//@Inherited // 可继承注解。
@Retention(RetentionPolicy.RUNTIME)
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE , TYPE_PARAMETER , TYPE_USE})
public @interface MyAnnotation {
    String value() default "world";
}

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.ElementType.LOCAL_VARIABLE;

@Retention(RetentionPolicy.RUNTIME)
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
public @interface MyAnnotations {
    MyAnnotation[] value();
}

import org.junit.Test;

import java.lang.annotation.Annotation;
import java.util.ArrayList;


/**
 *
 */
public class AnnotationTest {
    @Test
    public void testAnnotation() {
        Class<Student> studentClass = Student.class;
        Annotation[] annotations = studentClass.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }
    }
}

@MyAnnotation(value = "hello")
@MyAnnotation(value = "abc")
// jdk8之前使用重复注解的方式
//@MyAnnotations({@MyAnnotation(value = "hello") , @MyAnnotation(value = "abc")})


class Person{
    private String name;
    private int age;

    public Person() {
    }

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

    public void walk(){
        System.out.println("人走路");
    }
}

class Student extends Person {
    @Override
    public void walk() {
        super.walk();
    }
}

class Generic<@MyAnnotation T>{
    public void show() throws @MyAnnotation RuntimeException{
        ArrayList<@MyAnnotation String> objects = new ArrayList<>();
        int num = (@MyAnnotation int)10L;
    }
}
starcpdk微信～
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
第十六章：Java之反射和枚举
快乐江湖的博客
10-12 717
Java反射(reflection)：反射机制是指在运行状态中，对于任意一个类，我们都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性。这种动态获取信息以及动态调用对象方法的功能称之为Java的反射机制在日常的第三方应用开发过程中，经常会遇到某个类的某个成员变量、方法或是属性是私有的或是只对系统应用开放，这时候就可以利用Java的反射机制通过反射来获取所需的私有成员或是方法。
Java反射、注解
浅谈Android
09-25 1805
最近本着不求甚解的态度重温了一下主流框架的源码，所以趁热打铁的总结一下，学习框架或开发框架所必备的基础知识： Java反射 Java注解 注解代码自动生成 Java动态代理 AOP 一、反射 1.1、简介 本文简单总结一下Java反射和注解，反射可以算是必备条件了，基本学习的主流框架中都会看到反射的身影，他的灵活使用也为很多逻辑的扩展提供了可能，通过Java的反射机制，可以在程序中访...
【JavaSE】Java反射与枚举的使用
weixin_62533201的博客
10-22 190
Java反射与枚举的使用
java 字符串转枚举_java 使用反射将字符串转换为枚举值，其中枚举类型可以是以下几种 - 糯米PHP...
weixin_39698255的博客
02-16 492
假设我有一个将另一个对象作为id的类：public SomeClass{private final ID id;...}ID然后定义如下。请注意，将枚举拆分(分为逻辑分组)的原因是，否则单个枚举将包含1000+个值。这样就需要接口使所有枚举仍属于同一类型。public interface ID{public enum Name1 implements ID { ... constants ... ...
Java 枚举的使用与反射应用
最新发布
devops
05-14 550
Java枚举是一种特殊的数据类型，用于定义一组常量集合，可以定义简单的枚举常量，也可以为枚举常量添加属性和方法。// 定义表示星期的枚举类型MONDAY, // 星期一TUESDAY, // 星期二WEDNESDAY, // 星期三THURSDAY, // 星期四FRIDAY, // 星期五SATURDAY, // 星期六SUNDAY // 星期日带参数定义允许枚举常量携带额外信息，使枚举更具灵活性。// 定义表示季节的枚举类型，每个季节携带中文名称SPRING(1,"春天"),
反射&枚举
Krive~Irving
06-02 1325
反射,枚举
Java之反射
weixin_44321790的博客
03-26 188
Java之反射 一、反射的概述 1. 反射的简介 Reflection（反射)是被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。 加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们形象的称之为：反射。 通常的方式：引入需要的“包类”名称--
Java高级之枚举、注解、反射
yy1127620991的博客
09-26 197
目录枚举、注解、反射枚举类(Enum)1. 概述2. 枚举类型定义格式3. 枚举的常用方法4. 枚举实现接口5. 注意事项注解(Annotation)1. 概述2. 内置注解4. 元注解5. 自定义注解注解架构注意事项举例反射(Reflection)1. 概述2. 类加载器3. 获得Class的3种方式4. 获取Method通过class对象 获取一个类的方法执行Method方法5. 获取Filed通过class对象 获取一个类的属性Field 属性的对象类型6. 获取注解获取类/属性/方法对象的注解对象
java中的注解
12-22
属性可以有默认值，支持基本类型、String、其他注解、枚举类型以及这些类型的数组。属性值可以通过反射API访问，如`annotationInstance.value()`。 4. **元注解** - **元注解**是对注解的注解，提供了关于注解如何...
Java元注解.docx
01-29
如`TYPE`（类、接口、枚举）、`FIELD`（字段）、`METHOD`（方法）、`PARAMETER`（参数）、`CONSTRUCTOR`（构造器）、`LOCAL_VARIABLE`（局部变量）、`ANNOTATION_TYPE`（其他注解）、`PACKAGE`（包）、`TYPE_...
java元注解的介绍说明
10-09
Java元注解是Java语言中的一种高级特性，它们主要用于注解其他注解，为自定义注解添加附加信息，使得注解在不同的阶段能够得到适当的处理。这些元注解不仅帮助开发人员定制注解的行为，还对注解的可见性和处理方式...
java 通过反射获取枚举类，及枚举类的值，枚举类枚举实例名
10-09
java 通过反射获取枚举类，及枚举类的值，枚举类枚举实例名。本项目为普通java项目
通过枚举反向给实体类赋值
05-16
通过枚举反向给实体类赋值工具类，减少表单提交时通过request.getParameter(name)方式获取提交值的重复操作
java自定义注解接口实现方案
09-05
最后，通过Java的反射机制，我们可以解析并使用这个注解： ```java public class AnnTest { public void parseMethod(Class<?> clazz) { try { Object obj = clazz.getConstructor(new Class[] {}).newInstance...
简单谈谈java自定义注解
08-29
Java 自定义注解详解 Java 中的注解（Annotation）是一种元数据，能够提供信息给编译器、IDE、框架等工具，以便他们在编译、运行时做出相应的处理。从 Java 1.5 开始，Java 引入了注解，目前流行的框架都在使用注解...
使用反射将string转换为enum
weixin_30840573的博客
12-15 324
很简单就一句话的代码。 1 if (item.PropertyType.IsEnum) 2 { 3 item.SetValue(obj, Enum.Parse(item.PropertyType, val), nu...
认识Java中的反射与枚举
m0_56911284的博客
12-11 676
一篇文章带你认识Java中的反射
【无标题】JAVA反射,枚举
qq_45524626的博客
03-01 147
JAVA反射,枚举
Java工作笔记-枚举类型反射
IT1995的博客
04-09 6243
这里枚举类型有自己的反射方式： 这里我先总结下逻辑： 1. 通过getEnumConstatnts返回目前枚举中存在的对象。 2. 通过getMehod获取方法。 3. 最后用这个对象调用其方法。 程序运行截图如下： 其中对应的枚举： 源码如下： Em.java package en; public enum Em { ONE_EM(10001, "O...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值