JAVA注解与反射

最新推荐文章于 2023-03-16 21:44:31 发布

让时间来沉淀吧

最新推荐文章于 2023-03-16 21:44:31 发布

阅读量306

点赞数

分类专栏： JAVA进阶文章标签：反射 java class

本文链接：https://blog.csdn.net/qq_34488912/article/details/106402910

版权

JAVA进阶专栏收录该内容

7 篇文章 0 订阅

订阅专栏

1.注解

概念：也叫元数据，一种代码级别的说明，一个标签，对程序的说明，给计算机、编译器、解析程序用。
本质：接口，继承Annotation接口。
作用：一般分成以下三类：
a.编写文档：生成doc文档，参照之前写的博客。
b.代码分析：通过代码里标识的注解对代码分析，反射操作注解，核心。
c.编译检查：例如@Override检查标注的方法是否继承自父类。

1.1IDK中预定义的注解

@Override：检查标注的方法是否继承自父类。
@Deprecated:标注的内容已过时。
@SuppressWarnings：压制警告，抑制编译警告。
一般传递参数all @@SuppressWarnings(all)

1.2元注解

@Target:描述注解能够作用的位置。
ElementType取值：
TYPE：可以作用在本类上。
METHOD:可以作用在方法上上。
FIELD: 可以作用于成员变量上。
@Retention：描述注解被保留的阶段
source:源文件中<class:class文件中<RUNTIME:运行时阶段（一般是这个）
@Retention（RetentionPolicy.RUNTIME）
@Documented:描述注解是否被抽取到api文档中
@Inherited：描述注解是否被子类继承

1.3自定义注解

格式：

public @interface 注解名称{
        //属性列表,接口中的抽象方法
        String name();
        int value();
        
    }

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

//自定义注解
public class Test02 {
    //注解可以显示赋值，如果没有默认值，我们就必须给注解赋值
    @MyAnnotation1(name = "小A",schools = "南理工")
    public void test1() {
    }

    @MyAnnotation2("呵呵")
    public void test2() {
    }
}

@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface  MyAnnotation1{
    //注解的参数：参数类型+参数名
    String name() default "";
    int age() default 0;
    int id() default -1;   //如果默认值为-1.则不存在
    String[] schools() default {"清华","北大"};
}

@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation2{
    String value();
}

如果只有一个属性需要赋值，并且属性的名称是value,则value可以省略，直接定义即可。
1.4获取注解
getAnnotation(class）

2.反射

概念：将类的各个组成部分封装为其他对象，是框架设计的灵魂。
好处：可以在程序运行过程中操作对象；可以解耦，提高程序的耦合性。
缺点：对象性能有影响，总是慢于直接执行相同的操作。
Class类:
class本身也是一个类；
只能由系统建立对象；
一个加载的类在JVM中只会有一个Class实例；
一个Class实例对应的是一个加载到JVM中的一个.class文件；
每个类的实例都会记得自己是由哪个class实例生成的；
通过Class可以完整的得到一个类所有被加载的结构；
Class类是Reflection反射的根源，针对任何想动态加载，运行的类，唯有先获得相应的Class对象。

类的加载：
在这里插入图片描述

类加载内存分析：

public class Test05 {

    public static void main(String[] args) {
        A a = new A();
        System.out.println(A.m);

        /**
         * 1.加载到内存，会产生一个类对应的Class对象
         * 2.链接，链接结束后m=0  链接：把Java的二进制代码合并到JVM运行状态之中的过程
         * 3.初始化
         * <clinit>(){
         *      System.out.println("A类静态代码块初始化");
         *      m = 300;
         *      m = 100;
         * }
         * m = 100
         */
    }

}

class A {
    static {
        System.out.println("A类静态代码块初始化");
        m = 300;
    }

    static int m = 100;

    public A() {
        System.out.println("A类的无参构造初始化");
    }
}

在这里插入图片描述

//测试类什么时候会初始化
public class Test06 {

    static {
        System.out.println("Main类被加载");
    }

    public static void main(String[] args) throws ClassNotFoundException {
        //1.主动引用  父类没被引用，会先加载它的父类
//        Son son = new Son();

        //2.反射也会产生主动引用
//        Class.forName("com.lcy.reflection.Son");

        //3.不会产生类的引用的方法b
//        System.out.println(Son.b);   //子类引用父类的静态方法或者变量，并不会让子类加载

//        Son[] sons = new Son[8];    //这是一个名字和一片空间而已，并不会加载类

//        System.out.println(Son.M);  //常量并不会引起父类和子类的初始化 常量在链接阶段就存入常量池中了

    }

}

class Father {

    static int b = 2;

    static {
        System.out.println("父类被加载");
    }
}

class Son extends Father {

    static {
        System.out.println("子类被加载");
        m = 300;
    }

    static int m = 100;
    static final int M = 1;
}

2.1获取Class对象的方式

1.Class.forName(“全类名”)：
2.类名.class：
3.对象.getClass(）：

public class Person {
    String name;
    //setter、getter、tostring方法省略
}

//测试Class类的创建方式有哪些
public class Test{
    public static void main(String[] args) throws ClassNotFoundException {
        Person person = new Person();
        person.setName("猪猪侠");
        System.out.println("这个人是:"+person.name);

        //1.通过对象获得
        Class c1 = person.getClass();
        System.out.println(c1.hashCode());

        //2.forName获得
        Class c2 = Class.forName("reflect.Person");
        System.out.println(c2.hashCode());

        //3.通过类名.class获得
        Class c3 = Person.class;
        System.out.println(c3.hashCode());

        //4. 基本内置类型的包装类都有一个Type属性
        Class c4 = Integer.TYPE;
        System.out.println(c4.hashCode());
        System.out.println(c4);

        //获得父类类型
        Class c5 = c1.getSuperclass();
        System.out.println(c5);
        
        //继承的子类
        Person stu = new Student();
        Class c6 = stu.getClass();
        System.out.println(c6);//class reflect.Student
    }
}

2.2Class对象功能

带有Declared的表示获取全部，private修饰的也可以获取到。
1.获取成员变量
Field[] getFields() ：获取所有public修饰的成员变量
Field getField(String name) 获取指定名称的 public修饰的成员变量

Field[] getDeclaredFields() 获取所有的成员变量，不考虑修饰符
Field getDeclaredField(String name)

2.获取构造方法
Constructor<?>[] getConstructors()
Constructor getConstructor(类<?>… parameterTypes)

Constructor getDeclaredConstructor(类<?>… parameterTypes)
Constructor<?>[] getDeclaredConstructors()

3.获取成员方法们：
Method[] getMethods()
Method getMethod(String name, 类<?>… parameterTypes)

Method[] getDeclaredMethods()
Method getDeclaredMethod(String name, 类<?>… parameterTypes)

4.获取全类名
String getName()

2.3创建对象的方式

创建User对象

public class User {
    int id;
    String name;
    private String jineng;
    
    void yijineng(){
        System.out.println("长虹落日");
    }

    private void erjineng(){
        System.out.println("这贯穿地板的雷霆");
    }

    public User() {
    }

    public User(int id, String name, String jineng) {
        this.id = id;
        this.name = name;
        this.jineng = jineng;
    }
    //setter、getter、tostring方法省略

//动态的创建对象,通过反射
public class Test {
    public static void main(String[] args) throws Exception {
        //获得Class对象
        Class c1 = Class.forName("reflect.User");

        //构造一个对象,此调用必须要有默认构造函数
        User user1 = (User) c1.newInstance();
        System.out.println(user1);  //调用默认的空参数构造方法

        //通过构造器创建对象
        Constructor constructor = c1.getDeclaredConstructor(int.class, String.class, String.class);
        User user2 = (User) constructor.newInstance(1, "虹猫", "落舞飞花");
        System.out.println(user2);
    }
}

在这里插入图片描述

2.4反射操作类中的属性和方法

2.4.1操作属性
1.设置值
void set(Object obj, Object value)
2. 获取值
get(Object obj)
3. 忽略访问权限修饰符的安全检查
setAccessible(true):暴力反射
2.4.2操作方法
1.执行方法：
Object invoke(Object obj, Object… args)
2.获取方法名称：
String getName:获取方法名

//创建user3对象
        User user3 = (User) c1.newInstance();
        /*public void setName(String name) {
        this.name = name;
        }*/
        //通过反射获取一个方法
        Method setName = c1.getDeclaredMethod("setName", String.class);
        //invoke :激活的意思   (对象，"方法的值")
        setName.invoke(user3,"臭屁琦");
        System.out.println(user3.getName());

        //通过反射操作属性
        User user4 = (User) c1.newInstance();
        Field name = c1.getDeclaredField("name");
        //不能直接操作私有属性，关闭安全检测，暴力反射可以提高效率
        name.setAccessible(true);
        name.set(user4,"朱琳");
        Object o = name.get(user4);
        System.out.println(o);
        System.out.println(user4.getName());

在这里插入图片描述

2.5反射操作泛型

/通过反射获取泛型
public class Test11 {

    public void test01(Map<String,User> map, List<User> list) {
        System.out.println("test01");
    }

    public Map<String,User> test02() {
        System.out.println("test02");
        return null;
    }


    public static void main(String[] args) throws NoSuchMethodException {
        /*
        #java.util.Map<java.lang.String, com.lcy.reflection.User>
        class java.lang.String
        class com.lcy.reflection.User
        #java.util.List<com.lcy.reflection.User>
        class com.lcy.reflection.User
        */
        //加载的方法和参数
        Method method = Test11.class.getMethod("test01", Map.class, List.class);
        //获得泛型的参数类型
        Type[] genericParameterTypes = method.getGenericParameterTypes();

        for (Type type :genericParameterTypes) {  //打印泛型
            System.out.println("#"+type);
            if (type instanceof ParameterizedType) {  //想知道里面的参数类型
                //强转获得真实的泛型参数信息
                Type[] typeArguments = ((ParameterizedType) type).getActualTypeArguments();
                for (Type temp :typeArguments) {
                    System.out.println(temp);
                }
            }
        }

        /*
        class java.lang.String
        class com.lcy.reflection.User
         */
        method = Test11.class.getMethod("test02",null);
        //获得返回值类型
        Type genericReturnType = method.getGenericReturnType();
        if (genericReturnType instanceof  ParameterizedType) {
            Type[] types = ((ParameterizedType) genericReturnType).getActualTypeArguments();
            for (Type temp :types) {
                System.out.println(temp);
            }
        }
    }
}

2.6.反射操作注解

package reflect;

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

@Tablezhu("db_stu")
class Student {
    @Fieldzhu(columnName = "db_id", type = "int", length = 10)
    private int id;
    @Fieldzhu(columnName = "db_name", type = "String", length = 10)
    private String name;
    @Fieldzhu(columnName = "db_age", type = "varchar", length = 5)
    private int age;

    public Student() {
    }

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

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

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}
//类名的注解
@Target(ElementType.TYPE)   //设置作用域
@Retention(RetentionPolicy.RUNTIME)  //设置什么级别可以获取
@interface Tablezhu{
    String value();
}

//属性的注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface Fieldzhu{
    String columnName();  //列名的注解
    String type();      //类型
    int length();       //长度
}

package reflect;

import java.lang.annotation.Annotation;
import java.lang.reflect.Field;

//反射操作注解
public class test1 {

    public static void main(String[] args) throws Exception {
        Class c1 = Class.forName("reflect.Student");

        //通过反射获得注解
        Annotation[] annotations = c1.getAnnotations();
        for (Annotation annotation :annotations) {
            //找到了外面的注解@reflection.Tablezhu(value=db_stu)
            System.out.println(annotation);
        }

        //获得注解value的值db_stu
        Tablezhu tablezhu = (Tablezhu) c1.getAnnotation(Tablezhu.class);
        String value = tablezhu.value();
        System.out.println(value);

        /**
         * 获得类指定的注解
         * db_stu
         * db_name
         * String
         * 10
         */
        Field f = c1.getDeclaredField("name");  //name对应表中的字段
        Fieldzhu annotation = f.getAnnotation(Fieldzhu.class);
        System.out.println(annotation.columnName());
        System.out.println(annotation.type());
        System.out.println(annotation.length());

    }

}