注解和反射笔记

最新推荐文章于 2025-04-05 00:31:02 发布

文艺范ya

最新推荐文章于 2025-04-05 00:31:02 发布

阅读量138

点赞数 1

分类专栏： JAVA 文章标签： java

原文链接：https://www.bilibili.com/video/BV1p4411P7V3?p=12&spm_id_from=pageDriver

版权

JAVA 专栏收录该内容

182 篇文章

订阅专栏

注解

注解是JDK5.0开始引入的新技术；

注解的作用是：

不是程序本身，可以对程序做出解释
可以被其他程序读取

注解的格式是：

注解是以"@注释名"在代码中存在的，还可以添加一些参数

注解可以在什么地方使用：

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

元注解的作用：负责注解其他注解，JAVA定义了4个标准的meta-annotation类型，他们被用来提供对其他注解类型进行说明。

@Target :用于描述注解的使用范围。
@Retention :表示需要在什么级别保存该注释信息，用于描述注解的生命周期。（SOURCE<CLASS<RUNTIME）一般使用RUNTIME。
@Document :说明该注解将被包含在javadoc中。
@Inherited :说明子类可以继承父类中的该注解。

package demopacket;

import java.lang.annotation.*;

//测试元注解
@MyAnnotation
public class test {
    @MyAnnotation
    public void tt() {

    }
}

//定义一个元注解
//Target 表示我们的注解可以用在哪些地方
@Target(value = {ElementType.METHOD, ElementType.TYPE})

//表示我们的注解在什么地方还有效
@Retention(value = RetentionPolicy.RUNTIME)

//表示该注解将被包含在javadoc中
@Documented

//子类可以继承父类中的该注解
@Inherited
@interface MyAnnotation {

}

自定义注解：

使用@interface自定义注解，自动继承java.lang.annotation.Annotation接口

@interface 用来声明一个注解，格式：@interface 注解名{定义内容}
其中的每个一方法实际上是声明了一个配置参数
方法的名称就是参数的名称
返回值类型就是参数的类型(返回值是基本类型，Class，String，Enum
可以通过default来声明参数的默认值
如果只有一个参数成员，一般参数名为value
注解元素必须要有值，我们定义注解元素时，经常使用空字符串，0作为默认值

package demopacket;

import java.lang.annotation.*;

//测试元注解

public class test {
    @MyAnnotation(name = "张三")
    @MyAnnotation01("李四")
    public void tt() {

    }
}

//定义一个元注解
//Target 表示我们的注解可以用在哪些地方
@Target(value = {ElementType.METHOD, ElementType.TYPE})

//表示我们的注解在什么地方还有效
@Retention(value = RetentionPolicy.RUNTIME)

//表示该注解将被包含在javadoc中
@Documented

//子类可以继承父类中的该注解
@Inherited
@interface MyAnnotation {
    //注解的参数:参数类型+参数名();  这不是一个方法
    String name();

    String age() default "";//给一个默认值，可以不写不会报错，默认为空。

    int id() default -1; //如果默认值位-1，表示不存在。

    String[] school() default {"清华", "北大"};
}

@Target(value = {ElementType.METHOD, ElementType.TYPE})
@Retention(value = RetentionPolicy.RUNTIME)
//当注解只有一个值的时候，命名一般使用value,这样在使用的时候可以不写value。
@interface MyAnnotation01 {
    String value();
}

反射机制

在这里插入图片描述
JAVA反射机制提供的功能

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

JAVA反射的优点和缺点：

优点：可以实现动态创建对象和编译，体现出很大的灵活性。
缺点：对性能有影响，慢

package demopacket;

public class test {
    public static void main(String[] args) throws ClassNotFoundException {
        //通过反射获取类的class对象
        Class<?> c1= Class.forName("demopacket.User");
        Class<?> c2= Class.forName("demopacket.User");
        Class<?> c3= Class.forName("demopacket.User");
        Class<?> c4= Class.forName("demopacket.User");
        System.out.println(c1);//class demopacket.User

        //一个类在内存中只有一个class对象
        //一个类被加载后，类的整个结构都会被封装在class对象中
        System.out.println(c1.hashCode()); //381259350
        System.out.println(c2.hashCode()); //381259350
        System.out.println(c3.hashCode()); //381259350
        System.out.println(c4.hashCode()); //381259350
    }
}

class User {
    private String name;
    private int age;
    private int id;

    public User() {
    }

    public User(String name, int age, int id) {
        this.name = name;
        this.age = age;
        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;
    }

    public int getId() {
        return id;
    }

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

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

在这里插入图片描述

package demopacket;

public class test {
    public static void main(String[] args) throws ClassNotFoundException {
        User user = new Student();
        System.out.println(user.name);
        //第一种方法，通过对象获取
        Class<? extends User> c1 = user.getClass();
        //方式二：forName获得
        Class<?> c2 = Class.forName("demopacket.Student");
        //方式三 通过类名.class
        Class<Student> c3 = Student.class;
        System.out.println(c1.hashCode());//2129789493
        System.out.println(c2.hashCode());//2129789493
        System.out.println(c3.hashCode());//2129789493
        //方式四：基本内置属性的包装类都有一个Type属性
        Class<Integer> c4 = Integer.TYPE;
        System.out.println(c4);//int
        //获得父类类型
        Class<?> c5 = c1.getSuperclass();
        System.out.println(c5);//class demopacket.User
    }
}

class User {
    String name;

    public User() {
    }

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

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                '}';
    }
}

class Student extends User {
    public Student() {
        this.name = "学生";
    }
}

class Teacher extends User {
    public Teacher() {
        this.name = "老师";
    }
}

哪些类型可以有Class对象？

class:外部类、成员（成员内部类、静态内部类），局部内部类，匿名内部类。
interface：接口
[]：数组
enum：枚举
annotation：注解
primitive type：基本数据类型
void

package demopacket;

import java.lang.annotation.ElementType;
import java.util.Comparator;

//所有类型的class
//只要元素类型和和维度一样就是同一个class
public class test {
    public static void main(String[] args) {
        Class c1 = Object.class;
        Class c2 = Comparator.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;
        Class c9 = Class.class;
        System.out.println(c1);
        System.out.println(c2);
        System.out.println(c3);
        System.out.println(c4);
        System.out.println(c5);
        System.out.println(c6);
        System.out.println(c7);
        System.out.println(c8);
        System.out.println(c9);
    }
}

class java.lang.Object
interface java.util.Comparator
class [Ljava.lang.String;
class [[I
interface java.lang.Override
class java.lang.annotation.ElementType
class java.lang.Integer
void
class java.lang.Class

Process finished with exit code 0

类的加载

加载：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时的数据结构，然后生成一个代表这个类的java.lang.Class对象
链接：将Java类的二进制代码合并到JVM的运行状态之中的过程
验证：确保加载的类信息符合JVM规范，没有安全方面的问题
准备：正式为类变量（static）分配内存并设置类变量默认初始值的阶段，这些内存在方法区中进行分配
解析：虚拟机常量池内的符号引用（常量名）替换为直接引用（地址）的过程
初始化：执行类构造器()方法的过程。类构造器()方法是由编译期自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的
当初始化一个类的时候，如果发现其父类还没有初始化，则需要先触发其父类的初始化。
虚拟机会保证一个类的()方法在多线程环境中被正确加锁和同步。

类的初始化

类的主动引用（一定会发生类的初始化）
- 当虚拟机启动，先初始化main方法所在的类
- new一个类的对象
- 调用类的静态成员**（除了final常量）**和静态方法
- 使用java.lang.reflect包的方法对类进行反射调用
- 当初始化一个类，如果其父类没有初始化，则会先初始化它的父类
类的被动引用（不会发生类的初始化）
- 当访问一个静态域时，只有真正声明这个域的类才会被初始化。如：当通过子类引用父类的静态变量或方法，不会导致子类的初始化。
- 通过数组定义引用，不会触发此类的初始化
- 引用常量不会触发此类的初始化（常量在链接阶段就存在调用类的常量池中了）

通过反射获取类的信息

User user = new User();
c1 = user.getClass();
//获得包名+类名
c1.getName();
//获得类名
c1.getSimpleName();
//获得public属性
c1.getFields();
//获得所有属性
c1.getDeclaredFields();
//获得指定属性
c1.getDeclaredField("name");
//获得本类及其父类的全部public方法
c1.getMethods();
//获得本类的所有方法
c1.getDeclaredMethods();
//获得指定方法,第二个参数是方法参数的类型 需要这个参数，因为JAVA有重载，参数就是类型.class。
c1.getMethod("getName",null);
c1.getMethod("setName",String.class);
//构造器
//获得public方法
Constructor[] constructors = c1.getConstructors();
for (Constructor constructor : constructors) {
    System.out.println(constructor);
}
//获得全部方法
Constructor[] declaredConstructors = c1.getDeclaredConstructors();
for (Constructor declaredConstructor : declaredConstructors) {
   System.out.println(declaredConstructor);
}
//获取指定的构造器
Constructor declaredConstructor = c1.getDeclaredConstructor(String.class,int.class,int.class);
System.out.println(declaredConstructor);

有了Class对象能做什么？

创建类的对象：调用Class对象的newInstance()方法

类必须有一个无参数的构造器。
类的构造器的访问权限需要足够。

 没有无参构造器怎么办？

在操作的时候明确的调用类中的构造器，并将参数传递进去之后，才可以实例化操作。

通过Class类的getDeclaredConstructor(Class … parameterTypes)取得本类的指定形参类型的构造器。
向构造器的形参中传递一个对象数组进去，里面包含了构造器中所需的各个参数。
通过Constructor实例化对象。

package demopacket;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class test {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
        //通过反射获取类的class对象
        Class<?> c1 = Class.forName("demopacket.User");
        User user = (User) c1.newInstance();//本质是调用类的无参构造器
        System.out.println(user);//User{name='null', age=0, id=0}

        //t通过构造器创建对象
        Constructor constructor = c1.getDeclaredConstructor(String.class, int.class, int.class);
        User u = (User) constructor.newInstance("张三", 10, 2);
        System.out.println(u);//User{name='张三', age=10, id=2}
    }
}

class User {
    private String name;
    private int age;
    private int id;

    public User() {
    }

    public User(String name, int age, int id) {
        this.name = name;
        this.age = age;
        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;
    }

    public int getId() {
        return id;
    }

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

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

调用类的方法

Class c1 = Class.forName("com.tyh.test.User");
User user = (User)c1.newInstance();
Method setName = c1.getDeclaredMethod("setName",String.class);
//通过invoke()进行调用，第一个参数是对象，第二个参数是方法的参数
//invoke()就是激活的意思
setName.invoke(user,"张三");

反射操作注解

import java.lang.annotation.*;

public class test {

    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        Class c1 = Class.forName("com.Student");
        //通过反射获得注解
        Annotation[] annotations = c1.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }

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

        //获得类指定的注解
        java.lang.reflect.Field f = c1.getDeclaredField("name");
        Field annotation = f.getAnnotation(Field.class);
        System.out.println(annotation.columnName());
        System.out.println(annotation.type());
        System.out.println(annotation.length());
    }

}

@Table("db_student")
class Student{

    @Field(columnName = "db_id",type = "int",length = 10)
    private int id;
    @Field(columnName = "db_age",type = "int",length = 4)
    private int age;
    @Field(columnName = "db_name",type = "varchar",length = 3)
    private String name;

    private Student(){

    }

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

    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 "Student{" +
                "id=" + id +
                ", age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}


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

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