Java注解与反射

程序员文章站 2022-07-03 19:59:41

概要本文主要是总结Java注解与反射的相关知识，加深自己对Java类动态语言的理解，同时为日后学习Spring打下基础。注解：什么是注解Annotation的作用不是程序本身，但是可以对程序作出解释。可以被其他程序（比如：编译器等）读取。Annotation的格式：注解是以“@注释名”在代码中存在的，还可以添加一些参数值，例如：@SuppressWarnings(value=“unchecked”)。Annotation使用范围：附加在package、class、meth...

概要

本文主要是总结Java注解与反射的相关知识，加深自己对Java类动态语言的理解，同时为日后学习Spring打下基础。

注解：

什么是注解

Annotation的作用
- 不是程序本身，但是可以对程序作出解释。
- 可以被其他程序（比如：编译器等）读取。
Annotation的格式：
- 注解是以“@注释名”在代码中存在的，还可以添加一些参数值，例如：@SuppressWarnings(value=“unchecked”)。
Annotation使用范围：
- 附加在package、class、method、field等上面，相当于给他们添加了额外的辅助信息，然后通过反射机制编程实现对这些元数据的访问。

内置注解

Override：

定义在java.lang.Override中，此注释只适用于修辞方法，表示一个方法声明打算重写超类中的另一个方法声明。
Deprecated：

定义在java.lang.Deprecated中，此注释可以用于修辞方法、属性、类，表示不鼓励程序员使用这样的元素，通常是因为它很危险或者有更好的选择。
SuppressWarnings：

定义在java.lang.SuppressWarnings中，用来抑制编译时警告信息，与前两个注释不同，此注解需要添加一个参数才可正常使用：

➢SuppressWarnings(“all”)

➢SuppressWarnings(“unchecked”)

➢SuppressWarnings(value={“deprecation”,“unchecked”})

➢…

元注解

元注解的作用就是负责注解其他注解，Java定义了4个标准的meta-annotation类型，他们被用来提供对其他annotaion类型作说明。
这些类型和他们所支持的类在java.lang.annotation包可以找到:

➢@Target：用于描述注解的使用范围（即被描述的注解可以用在什么地方）

➢@Retention:表示需要在什么级别保存该注释信息，用于描述注解的生命周期（SOURCE<CLASS<RUNTIME）。

➢@Document:说明该注解将被包含在javadoc中。

➢@Inherited:说明子类可以继承父类中的该注解。

自定义注解

使用@interface自定义注解，格式：public @interface 注解名{定义内容}。
自定义注解内部的参数格式：参数类型+参数名()；若只有一个参数成员，参数名默认为value。

注解的元素必须要有值，我们定义注解元素时，一般默认使用空字符串，0作为默认值。

//注解可以显式赋值，如果没有默认值，则必须赋值
@myAnnotation(id = 3)
public class testAnnotation {
    @myAnnotation(id = 5,school = {"THU","CMU"})
    public void test(){

    }
}
@Target(value = {ElementType.METHOD,ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@interface myAnnotation{
    //注解的参数：参数类型+参数名()
    String name() default "";
    int id();
    int age() default 0;
    String[] school() default {"HDU"};
}

反射：

什么是反射

Reflection是Java被视为动态语言的关键，反射机制允许程序在执行期间借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。
Java在加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。我们通过这个对象可以看到类的结构，这种过程称为反射。
- 正常方式：引入需要的“包类”名称➜通过new实例化➜取得实例化对象
- 反射方式：实例化对象➜getClass()方法➜取得完整的“包类”名称

反射相关的API

java.lang.Class：代表一个类
java.lang.reflect.Method：代表类的方法
java.lang.reflect.Field：代表类的成员变量

java.lang.reflect.Constructor：代表类的构造器

public class test{
    public static void main(String[] args) throws ClassNotFoundException {
        //通过反射获得类的Class对象
        Class<?> c1 = Class.forName("JavaDoc.User");
        Class<?> c2 = Class.forName("JavaDoc.User");
        Class<?> c3 = Class.forName("JavaDoc.User");
        //一个类在内存中只有一个Class对象
        //一个类被加载后，类的整个结构都会被封装在Class对象中
        System.out.println(c1.hashCode());
        System.out.println(c2.hashCode());
        System.out.println(c3.hashCode());
    }
}
//实体类 pojo ,Entity
class User{...}
//输出结果：hashCode相同
1846274136
1846274136
1846274136

获得Class类的方式

若已知具体的类，通过类的class属性获取。
若已知某个类的实例化对象，调用该实例的getClass()方法获取Class对象。

若已知一个类的全类名，且该类在类路径下，可以通过Class类的静态方法forName()方法获取。

public class test02{
    public static void main(String[] args) throws ClassNotFoundException {
        Student student = new Student();
        //通过forName获得
        Class c1 = Class.forName("JavaDoc.Student");
        //通过对象获得
        Class c2 = student.getClass();
        //通过类名.class获得
        Class c3 = Student.class;
      
        System.out.println(c1.hashCode());
        System.out.println(c2.hashCode());
        System.out.println(c3.hashCode());
        //获得父类类型
        System.out.println(c1.getSuperclass().hashCode());
    }
}
//实体类 pojo ,Entity
class Person{...}
class Student extends Person{...}

Java内存分析

Java内存区域	功能
堆	存放new的对象和数组，可以被所有的线程共享，不会存放别的对象引用
栈	存放基本类型变量（包含具体数值）和引用对象的变量（包含具体地址）
方法区	可以被所有线程共享，包含了所有class和static变量

这里只是浅显列出，详细分析需要参考Java的JVM。

Class类初始化

类的主动引用一定会发生类的初始化
- 当虚拟机启动时，先初始化main方法所在的类。
- 调用类的静态成员（除了final常量）和静态方法会发生初始化。
- 使用java.lang.reflect包反射调用会发生初始化。

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

当访问一个静态域时，只有真正声明这个域的类才会被初始化。如当通过子类引用父类的静态变量，不会导致子类初始化。
通过数组定义类的引用，不会触发此类的初始化。
引用常量不会触发此类的初始化。

public class test03{
    static {
        System.out.println("Main类被加载");
    }
    public static void main(String[] args){
        //主动引用
        Son son = new Son();
      	//final不会初始化父类和子类
        System.out.println(Son.M);
    }
}
class Father{
    static int b = 3;
    static {
        System.out.println("父类被加载");
    }
}
class Son extends Father{
  static {
        System.out.println("子类被加载");
        m = 200;
    }
    static int m = 100;
    static final int M = 1;
}
//输出结果
Main类被加载
父类被加载
子类被加载
100

类加载器

类加载器作用是用来把类装载进内存，JVM规范定义了如下类型的类加载器：

系统类加载器：

负责java -classpath或- D，导入java.class.path所指定的目录下的类与jar包装入工作，是最常用的加载器。
扩展类加载器：

负责jre/lib/ext目录下的jar包装入工作库。
引导类加载器：

采取C++编写，是JVM自带的类加载器，负责Java平台的核心库，用来装载核心类库，无法直接获取。

类加载器采取双亲委派机制，自底向上检查类是否已经装载，自顶向下尝试加载类。

自定义类加载器⇨System Classloader⇨Extension Classloader⇨Bootstrap Classloader

public class test04{
    public static void main(String[] args){
        //获取系统类加载器
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        System.out.println(systemClassLoader);
        //获取系统类加载器的父类加载器 --> 扩展类加载器
        ClassLoader parent = systemClassLoader.getParent();
        System.out.println(parent);
        //获取扩展类加载器的父类加载器 --> 根加载器（c/c++）
        ClassLoader parent1 = parent.getParent();
        System.out.println(parent1);
        //获取可加载的系统类加载器
        System.out.println(System.getProperty("java.class.path"));
    }
}

类的运行时结构

getName()
getFields()
getMethods()
getConstructors()
…

public class test05{
    public static void main(String[] args) throws ClassNotFoundException {
        Class<?> c1 = Class.forName("JavaDoc.User");

        //getFields只能获取public类型信息
        System.out.println("===getFields====");
        Field[] field = c1.getFields();
        for (Field field1 : field) {
            System.out.println(field1);
        }
        //getDeclaredFields可获取所有信息
        System.out.println("===getDeclaredFields====");
        field = c1.getDeclaredFields();
        for (Field field1 : field) {
            System.out.println(field1);
        }
    }
}
class User{
    public double score;
    private String name;
    private int id;
    private int age;
}
//输出结果
===getFields====
public double JavaDoc.User.score
===getDeclaredFields====
public double JavaDoc.User.score
private java.lang.String JavaDoc.User.name
private int JavaDoc.User.id
private int JavaDoc.User.age

动态创建对象执行方法

创建类的对象：

调用Class对象的newInstance()方法

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

创建步骤：

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

public class test06{
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
        Class<?> c1 = Class.forName("JavaDoc.User");
        //newInstance默认调用无参构造
        User user = (User) c1.newInstance();
        System.out.println(user);

        //通过构造器声明含参构造重新调用newInstance
        Constructor<?> constructor = c1.getDeclaredConstructor(String.class, int.class, int.class);
        User user2 = (User) constructor.newInstance("zhangsan", 001, 20);
        System.out.println(user2);

        //通过反射机制调用User类中的方法
        Method setName = c1.getDeclaredMethod("setId", int.class);
        setName.invoke(user,001);
        System.out.println(user.getId());

        //通过关闭程序权限检测，操作程序的私有属性
        User user4 = (User) c1.newInstance();
        Field name = c1.getDeclaredField("name");
        name.setAccessible(true);
        name.set(user4,"zhangsan2");
        System.out.println(user4.getName());
    }
}
class User{
    ...
    public User() {
    }

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

反射操作注解

public class test07{
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        Class<?> c1 = Class.forName("JavaDoc.User");
        //通过反射获得注解
        Annotation[] annotations = c1.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }
        //获得注解内部value值
        Table table = c1.getAnnotation(Table.class);
        System.out.println(table.value());
        //获取内部指定字段的注解信息
        Field f1 = c1.getDeclaredField("name");
        fieldStudent field = f1.getAnnotation(fieldStudent.class);
        System.out.println(field.columnName());
        System.out.println(field.type());
        System.out.println(field.length());
    }
}
@Table(value = "db_User")
class User{
    @fieldStudent(columnName = "db_name",type = "varchar",length = 3)
    private String name;
    @fieldStudent(columnName = "db_id",type = "int",length = 10)
    private int id;
    @fieldStudent(columnName = "db_age",type = "int",length = 10)
    private int age;
}

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

//属性的注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface fieldStudent{
    String columnName();
    String type();
    int length();
}
//程序输出
@JavaDoc.Table(value=db_User)
db_User
db_name
varchar
3

本文地址：https://blog.csdn.net/qq_30277753/article/details/107701378

Java注解与反射

概要

注解：

什么是注解

内置注解

元注解

自定义注解

反射：

什么是反射

获得Class类的方式

Java内存分析

Class类初始化

类加载器

类的运行时结构

动态创建对象执行方法

创建类的对象：

创建步骤：

反射操作注解

Java Base64位编码与String字符串的相互转换,Base64与Bitmap的相互转换实例代码

Java：控制反转（IoC）与依赖注入（DI）

深入理解Java注解的使用方法

java与c#的语法区别详细介绍

java自定义注解接口实现方案

JAVA POST与GET数据传递时中文乱码问题解决方法

JSP 中Spring组合注解与元注解实例详解

Java实现的对称加密算法AES定义与用法详解

JAVA中数组插入与删除指定元素的实例代码

Java实现的对称加密算法3DES定义与用法示例