Java中的注解和反射怎么使用

这篇文章主要讲解了“Java中的注解和反射怎么使用”，文中的讲解内容简单清晰，易于学习与理解，下面请大家跟着小编的思路慢慢深入，一起来研究和学习“Java中的注解和反射怎么使用”吧！

1、注解（Annotation）

1.1 什么是注解(Annotation)

注解不是程序本身，可以在程序编译、类加载和运行时被读取，并执行相应的处理。注解的格式为"@注释名(参数值)"，可以附加在包、类、方法和字段上，通过反射机制实现实现注解的访问。

1.2 内置注解

@Override：限定子类重写方法

该注解表示覆盖的是其父类的方法，当子类重写父类方法时，确保子类确实重写了父类的方法，避免出现低级错误

@Overridepublic String toString() {    return super.toString();}

@Deprecated：标记已过时

该注解表示某个属性、方法或类等已过时（程序员不鼓励使用的程序元素，通常是因为它是危险的，或者因为存在更好的替代方法），当其他程序使用已过时的属性、方法或者类时，编译器会给出警告（删除线）。

@Deprecatedpublic static void test() {    System.out.println("标记已过时");}

@SuppressWarnings(参数)：抑制编译器警告

该注解作用的类、方法和属性会取消显示编译器警告，其参数主要是进行警告说明以及取消(unchecked)等。

@SuppressWarnings("取消此类的所有警告")public class BuiltAnnotation {        @SuppressWarnings("取消此属性的警告")    private String username;    @SuppressWarnings("取消此方法的警告")    public static void main(String[] args) {        // ...    }}

1.3 元注解(meta-annotation)

元注解的作用就是负责注解其他注解，Java定义了4个标准的元注解类型，他们被用来提供对其他注解的作用范围及类型进行说明，通过元注解可以自定义其他注解。

@Target：描述注解的使用范围

例如@Target(ElementType.METHOD)表示作用在方法上，@Target(ElementType.TYPE)表示作用在类或接口上等

@Documented@Retention(RetentionPolicy.RUNTIME)@Target(ElementType.ANNOTATION_TYPE)public @interface Target {        ElementType[] value();}

@Retention：表示需要在什么级别保存该注解信息，用于描述注解的生命周期

通常自定义的注解都使用@Retention(RetentionPolicy.RUNTIME)，也就是运行时期作用。

@Documented@Retention(RetentionPolicy.RUNTIME)@Target(ElementType.ANNOTATION_TYPE)public @interface Retention {        RetentionPolicy value();}

@Document：说明该注将被包含在javadoc中

@Iherited：定义子类是否可继承父类定义的注解。

@Inherited仅针对 @Target(ElementType.TYPE) 类型的注解有用，并且只能是 class 的继承，对 interface 的继承无效：

1.4 自定义注解

定义注解

@Target({ElementType.METHOD, ElementType.TYPE})@Retention(RetentionPolicy.RUNTIME)public @interface Report{        int type() default 0;    String value() default "LonerMJ";}

使用注解

@Report(type = 1, value = "test")public class CustomerAnnotation {    @Report(type = 1, value = "test")    public void testCustomerAnnotation() {        System.out.println("测试自定义注解");    }}

2、反射（Reflection）

2.1 反射和反射机制

反射

Reflection（反射）是指程序在运行期可以拿到一个对象的所有信息。

反射机制

反射机制是指程序在运行时，通过Reflection api获取任何类的内容信息，并能直接操作任何对象的内部属性及方法。

2.2 Class类的获取方式和常用方法

java.lang.Class类，实现反射的核心类，类加载完成之后，在堆内存的方法区中就会产生一个Class对象（一个类只有一个Class对象），这个对象包含了类的完整结构信息，通过这个对象看到类的结构。

Class类的获取方式

public class InstantiationClass {    public static void main(String[] args) throws ClassNotFoundException {        Teacher teacher = new Teacher("张三", "123456");        // 方式一：调用Class类的静态方法forName(String className)        Class<?> c1 = Class.forName("com.loner.mj.reflection.Teacher");        // 方式二：已知某个类的实例，调用该实例的getClass()方法，getClass是Object类中的方法。        Class<? extends Teacher> c2 = teacher.getClass();        // 方式三：已知具体类，通过类的class属性获取，该方法最安全可靠，程序性能最高        Class<Teacher> c3 = Teacher.class;        // 方式四：通过基本内置类型的包装类的TYPE属性获得CLass实例        Class<Integer> c4 = Integer.TYPE;        // 方式五：通过当前子类的Class对象获得父类的Class对象        Class<?> c5 = c1.getSuperclass();    }}

Class类的常用方法

public class ReflectionMethods {    public static void main(String[] args) throws NoSuchFieldException, NoSuchMethodException {        Class<Worker> workerClass = Worker.class;                System.out.println(workerClass.getName());        System.out.println(workerClass.getSimpleName());        System.out.println(workerClass.getSuperclass());        System.out.println(workerClass.getPackage());        Class<?>[] interfaces = workerClass.getInterfaces();        for (Class<?> i : interfaces) {            System.out.println(i);        }                // 获取所有的属性        Field[] declaredFields = workerClass.getDeclaredFields();        for (Field declaredField : declaredFields) {            System.out.println(declaredField);        }        // 获取指定属性        System.out.println(workerClass.getDeclaredField("username"));        // 获取所有公共属性        Field[] fields = workerClass.getFields();        for (Field field : fields) {            System.out.println(field);        }                // 获取所有构造方法        Constructor<?>[] declaredConstructors = workerClass.getDeclaredConstructors();        for (Constructor<?> declaredConstructor : declaredConstructors) {            System.out.println(declaredConstructor);        }        // 获取指定的构造方法        System.out.println(workerClass.getDeclaredConstructor(String.class, String.class));                // 获取所有的方法        Method[] declaredMethods = workerClass.getDeclaredMethods();        for (Method declaredMethod : declaredMethods) {            System.out.println(declaredMethod);        }        // 获取指定方法        System.out.println(workerClass.getDeclaredMethod("getUsername", null));        // 获取所有功能方法        Method[] methods = workerClass.getMethods();        for (Method method : methods) {            System.out.println(method);        }    }}

哪些类型具有Class对象

public class InstantiationClass {    public static void main(String[] args) throws ClassNotFoundException {        // 类（外部类，成员（成员内部类，静态内部类），局部内部类，匿名内部类。）        Class<Object> objectClass = Object.class;        // 接口        Class<Comparable> comparableClass = Comparable.class;        // 数组        Class<String[]> strinGClass = String[].class;        Class<int[][]> intClass = int[][].class;        // 枚举        Class<ElementType> elementTypeClass = ElementType.class;        // 注解        Class<Override> overrideClass = Override.class;        // 基本数据类型        Class<Integer> integerClass = Integer.class;        // void        Class<Void> voidClass = void.class;        // Class        Class<Class> classClass = Class.class;    }}

2.3 反射的使用

反射操作对象

public class UseClass {    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException, NoSuchFieldException {        Class<User> userClass = User.class;                Constructor<User> declaredConstructor = userClass.getDeclaredConstructor(String.class, String.class);        User user = declaredConstructor.newInstance("张三", "123456");        System.out.println(user);                Method setUsername = userClass.getDeclaredMethod("setUsername", String.class);        // invoke(Object, 参数)：激活，即执行相关操作为该对象        setUsername.invoke(user, "李四");        Method setPassWord = userClass.getDeclaredMethod("setPassword", String.class);        setPassword.invoke(user, "123456");        System.out.println(user);                Field username = userClass.getDeclaredField("username");        username.setAccessible(true);        username.set(user, "用户名");        System.out.println(user);    }}

反射操作泛型

Java采用泛型擦除的机制来引入泛型，Java中的泛型仅仅是给编译器javac使用的，确保数据的安全性和免去强制类型转换问题。但是，一旦编译完成，所有和泛型有关的类型全部擦除。

为了通过反射操作这些类型，Java新增了ParameterizedType，GenericArrayType，TypeVariable和WildcardType几种类型来代表不能被归一到Class类中的类型但是又和原始类型齐名的类型。

ParameterizedType：表示一种参数化类型，比如Collection

GenericArrayType：表示一种元素类型是参数化类型或者类型变量的数组类型

TypeVariable：是各种类型变量的公共父接口

WildcardType：代表一种通配符类型表达式

public class ClassOperateGenerics {    public Map<String, String> list() {        System.out.println("返回值是泛型");        return new HashMap<>();    }    public void test(Map<String, User> map, List<Integer> list) {        System.out.println("参数是泛型");    }    public static void main(String[] args) throws NoSuchMethodException {                Method method = ClassOperateGenerics.class.getMethod("test", Map.class, List.class);        // 获取所有方法参数的泛型        Type[] genericParameterTypes = method.getGenericParameterTypes();        for (Type genericParameterType : genericParameterTypes) {            // java.util.Map<java.lang.String, com.loner.mj.reflection.User>            System.out.println(genericParameterType);            if (genericParameterType instanceof ParameterizedType) {                // 获取所有泛型的真实参数                Type[] actualTypeArguments = ((ParameterizedType) genericParameterType).getActualTypeArguments();                for (Type actualTypeArgument : actualTypeArguments) {                    // String, User, Integer                    System.out.println(actualTypeArgument);                }            }        }                Method list = ClassOperateGenerics.class.getMethod("list", null);        // 获取方法返回值的泛型        Type genericReturnType = list.getGenericReturnType();        if (genericReturnType instanceof ParameterizedType) {            // 获取所有泛型的真实参数            Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();            for (Type actualTypeArgument : actualTypeArguments) {                System.out.println(actualTypeArgument);            }        }    }}

反射操作注解

public class ClassOperateAnnotation {    public static void main(String[] args) throws NoSuchFieldException {        Class<People> peopleClass = People.class;        // 获取类的所有注解        Annotation[] declaredAnnotations = peopleClass.getDeclaredAnnotations();        for (Annotation declaredAnnotation : declaredAnnotations) {            System.out.println(declaredAnnotation);        }        // 获取类的注解的值        Table declaredAnnotation = peopleClass.getDeclaredAnnotation(Table.class);        System.out.println(declaredAnnotation.value());        // 获取属性的注解        Field name = peopleClass.getDeclaredField("name");        Fields annotation = name.getAnnotation(Fields.class);        System.out.println(annotation.name());    }}

感谢各位的阅读，以上就是“Java中的注解和反射怎么使用”的内容了，经过本文的学习后，相信大家对Java中的注解和反射怎么使用这一问题有了更深刻的体会，具体使用情况还需要大家实践验证。这里是编程网，小编将为大家推送更多相关知识点的文章，欢迎关注！