Java注解与反射

程序员文章站 2022-04-15 19:09:22

概要本文主要是总结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实现方法详解

详解提高使用Java反射的效率方法

AngularJS实现与Java Web服务器交互操作示例【附demo源码下载】

.net core 反射的介绍与使用

详解Java编程中的反射在Android开发中的应用

java语言的主要特点是什么（python与java的区别）

Java 中的 equals,==与 hashCode 的区别与联系

java递归与非递归实现扫描文件夹下所有文件

Java中位运算(移位、位与、或、异或、非）的简单实例

java中extends与implements的区别浅谈

Java注解与反射

概要

注解：

什么是注解

内置注解

元注解

自定义注解

反射：

什么是反射

获得Class类的方式

Java内存分析

Class类初始化

类加载器

类的运行时结构

动态创建对象执行方法

创建类的对象：

创建步骤：

反射操作注解

散列表的原理与Java实现方法详解

详解提高使用Java反射的效率方法

AngularJS实现与Java Web服务器交互操作示例【附demo源码下载】

.net core 反射的介绍与使用

详解Java编程中的反射在Android开发中的应用

java语言的主要特点是什么（python与java的区别）

Java 中的 equals,==与 hashCode 的区别与联系

java递归与非递归实现扫描文件夹下所有文件

Java中位运算(移位、位与、或、异或、非） 的简单实例

java中extends与implements的区别浅谈

Java中位运算(移位、位与、或、异或、非）的简单实例