浅谈Java注解与反射

最新推荐文章于 2022-12-02 09:10:32 发布

Judicious_x

最新推荐文章于 2022-12-02 09:10:32 发布

阅读量299

点赞数

分类专栏： Java 文章标签： java intellij-idea

本文链接：https://blog.csdn.net/m0_56195064/article/details/122464489

版权

Java 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

注解的作用

不是程序本身，可以对程序作出解释（这一点和注释一样），可以被其他程序（比如：编译器等）读取 通过反射读取。

注解格式：以“@注释名”在代码中存在，还可以添加一些参数值

定义注解的格式：

@interface Name{
}

注解使用地方：

可以附加在package，class，method，field等上面，相当于给他们添加了额外的辅助信息，可以通过反射机制编程实现对这些元数据的访问。

注解还有检查和约束的功能约束代表注解的作用域如果作用域在方法上就代表只能在方法上使用。

三个内置注解

@Override
重写的注解具有检查和约束的功能比如方法名的检查
@Deprecated
不推荐使用但是可以使用或许存在更好的方法
@SuppressWarnings(“all”)
镇压警告该注解可以让警告不在显示传入的参数代表镇压该方法的全部警告

元注解

作用：负责注解其他注解，Java定义了4个标准的meta-annotation类型，被用来提供对其他annotation类型作说明。
Retention：注解的有效时期
SOURCE（源码期）< CLASS （编译期) < RUNTIME（运行期）

//定义一个注解
//Target 表示我们的注解可以用在哪些地方 传入value数组 数组内的数据代表作用域的使用范围
@Target(value = {ElementType.TYPE, ElementType.METHOD})
//Retention  注解的有效时期
@Retention(value = RetentionPolicy.CLASS)
//表示是否将我们的注解生成在Java doc中
@Documented
//子类可以继承父类的注解
@Inherited
@interface MyAnnotation {

}

自定义注解

//自定义注解
public class Annotation3 {

    //注解可以显示赋值（有默认值也可以显示）  如果没有默认值 就需要给注解赋值
    @MyAnnotation1(name = "test",age = 0)
    public void test(){
    }

    //如果该注解内部只有一个参数并用value命名的话可以直接赋值
    @MyAnnotation2("keyl")
    public void test2(){}
}

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation1 {
    //不是方法 是参数
    //注解的参数 ： 参数类型 + 参数名();
    //default 给参数赋默认值
    String name() default "";
    int age() default  -1;
    //如果int类型的赋值为-1就代表不存在 indexof 如果找不到就返回-1

}

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation2 {
    String value();
    //如果只有一个参数的话通常用value表示
}

注解的参数：参数类型 + 参数名（）；

如果该注解只有一个参数没有初始化赋值并且该注解的名字为value时在使用该注解时可以直接赋值其他的需要注解名 = xxx 来赋值

注解没有初始化时使用一定要赋值

反射机制

动态语言（Object-C，C#，JavaScript，PHP，Python）

是一类在运行时可以改变其结构的语言：例如新的函数，对象，甚至代码可以被引起，已有的函数可以被删除或是其他结构上的变化。通俗点说就是在运行时代码可以根据某些条件改变自身结构。

静态语言（Java，C，C++）

与动态语言相对应的，运行时结构不可变的语言就是静态语言。

Java不是动态语言，但Java可以称为”准动态语言“，即Java有一定的动态性，我们可以利用反射机制获得类似动态语言的特性。）

反射

Reflection（反射）是Java被视为动态语言的关键，它允许程序在执行期借助Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。

Class c = Class.forName("java.lang.String")

加载完类之后，在堆内存的方法区就产生了一个Class对象，这个对象就包含了完整的类的结构信息。可以通过这个对象看到类的结构。Class类管理反射

反射方式：实例化对象 -> getClass()方法 -> 得到完整的”包类“名称

Java反射的优缺点

优点：实现动态创建对象和编译，体现出很大的灵活性

缺点：对性能有影响

获得Class类的方法

方法一：通过对象获得

Class c1 = p1.getClass();

方法二：forname获得

Class c2 = Class.forName("JavaDemo.Student");

方法三：通过类名.class获得

Class c3 = Student.class;

方法四：基本类型的包装类都有一个Type属性

Class c4 = Integer.TYPE;

获取父类类型

Class c5 = c1.getSuperclass();

所有类型的Class

        Class c1 = Object.class;        //类
        Class c2 = Comparable.class;    //接口
        Class c3 = String[].class;      //一维数组
        Class c4 = int[][].class;       //二维数组
        Class c5 = Override.class;      //注解
        Class c6 = ElementType.class;   //枚举
        Class c7 = Integer.class;       //基本数据类型
        Class c8 = void.class;          //void
        Class c9 = Class.class;         //Class

类的初始化

主动引用（一定会发生类的初始化）

当虚拟机启动，先初始化main方法所在的类
new一个类的对象
调用类的静态成员（除了final常量）和静态方法
使用java.lang.reflect包的方法对类进行反射调用
当初始化一个类，如果其父类也没有被初始化，则会先初始化父类

被动引用（不会发生类的初始化）

引用常量类不会被初始化（常量在链接阶段就存入调用类的常量池中）
通过数组定义类的引用不会初始化该类
访问静态域时，只有真正声明这个域的类才会被初始化

反射的基本操作

获取类的名字

        System.out.println(c1.getName());   //获得包名+类名
        System.out.println(c1.getSimpleName());  //获得类名

获取类的属性

        Field[] fields = c1.getFields();    //只能找到public属性的
        fields = c1.getDeclaredFields();    //找到全部的属性

        //获得指定属性的值
        Field name = c1.getDeclaredField("name");

获取类的方法

        Method[] m = c1.getMethods();      //获得本类及其父类的全部public方法
        m = c1.getDeclaredMethods();        //获得本类的所有方法

        //获得指定的方法
        //重载 有参数的需要传入参数  没有传入null
        Method m1 = c1.getMethod("getName",null);
        m1 = c1.getMethod("setName",String.class);

获取类的构造器

        Constructor[] c = c1.getConstructors(); //public类
        c = c1.getDeclaredConstructors();   //全部

        //获得指定构造器的方法
        Constructor c2 = c1.getConstructor(String.class, int.class);

获取注解信息的demo

        Class c1 = Class.forName("JavaDemo.Student2");

        //通过反射获得注解
        java.lang.annotation.Annotation[] annotations =  c1.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }

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

        //获得类指定的注解
        Field f = c1.getDeclaredField("name");
        Fields tab1 = f.getAnnotation(Fields.class);
        System.out.println(tab1.Name());
        System.out.println(tab1.length());
        System.out.println(tab1.type());

@Tab("student")
class Student2{

    @Fields(Name = "db_id", type = "int", length = 10)
    private int id;
    @Fields(Name = "db_age", type = "int", length = 10)
    private int age;
    @Fields(Name = "db_name", type = "String", length = 20)
    private String name;

    public Student2() {
    }

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

    public int getId() {
        return id;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

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

//类名的注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface Tab {
    String value();
}

//属性的注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface Fields {
    String Name();
    String type();
    int length();
}