概要

本文主要是总结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作为默认值。

    1. //注解可以显式赋值,如果没有默认值,则必须赋值
    2. @myAnnotation(id = 3)
    3. public class testAnnotation {
    4. @myAnnotation(id = 5,school = {"THU","CMU"})
    5. public void test(){
    6. }
    7. }
    8. @Target(value = {ElementType.METHOD,ElementType.TYPE})
    9. @Retention(RetentionPolicy.RUNTIME)
    10. @interface myAnnotation{
    11. //注解的参数:参数类型+参数名()
    12. String name() default "";
    13. int id();
    14. int age() default 0;
    15. String[] school() default {"HDU"};
    16. }

反射:

什么是反射

  • 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:代表类的构造器

      1. public class test{
      2. public static void main(String[] args) throws ClassNotFoundException {
      3. //通过反射获得类的Class对象
      4. Class<?> c1 = Class.forName("JavaDoc.User");
      5. Class<?> c2 = Class.forName("JavaDoc.User");
      6. Class<?> c3 = Class.forName("JavaDoc.User");
      7. //一个类在内存中只有一个Class对象
      8. //一个类被加载后,类的整个结构都会被封装在Class对象中
      9. System.out.println(c1.hashCode());
      10. System.out.println(c2.hashCode());
      11. System.out.println(c3.hashCode());
      12. }
      13. }
      14. //实体类 pojo ,Entity
      15. class User{...}
      16. //输出结果:hashCode相同
      17. 1846274136
      18. 1846274136
      19. 1846274136

获得Class类的方式

  • 若已知具体的类,通过类的class属性获取。

  • 若已知某个类的实例化对象,调用该实例的getClass()方法获取Class对象。

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

    1. public class test02{
    2. public static void main(String[] args) throws ClassNotFoundException {
    3. Student student = new Student();
    4. //通过forName获得
    5. Class c1 = Class.forName("JavaDoc.Student");
    6. //通过对象获得
    7. Class c2 = student.getClass();
    8. //通过类名.class获得
    9. Class c3 = Student.class;
    10. System.out.println(c1.hashCode());
    11. System.out.println(c2.hashCode());
    12. System.out.println(c3.hashCode());
    13. //获得父类类型
    14. System.out.println(c1.getSuperclass().hashCode());
    15. }
    16. }
    17. //实体类 pojo ,Entity
    18. class Person{...}
    19. class Student extends Person{...}

Java内存分析

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

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

Class类初始化

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

    • 当虚拟机启动时,先初始化main方法所在的类。
    • 调用类的静态成员(除了final常量)和静态方法会发生初始化。
    • 使用java.lang.reflect包反射调用会发生初始化。
  • 类的被动引用不会发生类的初始化

    • 当访问一个静态域时,只有真正声明这个域的类才会被初始化。如当通过子类引用父类的静态变量,不会导致子类初始化。
    • 通过数组定义类的引用,不会触发此类的初始化。
    • 引用常量不会触发此类的初始化。
    1. public class test03{
    2. static {
    3. System.out.println("Main类被加载");
    4. }
    5. public static void main(String[] args){
    6. //主动引用
    7. Son son = new Son();
    8. //final不会初始化父类和子类
    9. System.out.println(Son.M);
    10. }
    11. }
    12. class Father{
    13. static int b = 3;
    14. static {
    15. System.out.println("父类被加载");
    16. }
    17. }
    18. class Son extends Father{
    19. static {
    20. System.out.println("子类被加载");
    21. m = 200;
    22. }
    23. static int m = 100;
    24. static final int M = 1;
    25. }
    26. //输出结果
    27. Main类被加载
    28. 父类被加载
    29. 子类被加载
    30. 100

类加载器

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

  • 系统类加载器:

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

  • 扩展类加载器:

    负责jre/lib/ext目录下的jar包装入工作库。

  • 引导类加载器:

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

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

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

    1. public class test04{
    2. public static void main(String[] args){
    3. //获取系统类加载器
    4. ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
    5. System.out.println(systemClassLoader);
    6. //获取系统类加载器的父类加载器 --> 扩展类加载器
    7. ClassLoader parent = systemClassLoader.getParent();
    8. System.out.println(parent);
    9. //获取扩展类加载器的父类加载器 --> 根加载器(c/c++)
    10. ClassLoader parent1 = parent.getParent();
    11. System.out.println(parent1);
    12. //获取可加载的系统类加载器
    13. System.out.println(System.getProperty("java.class.path"));
    14. }
    15. }

类的运行时结构

  • getName()
  • getFields()
  • getMethods()
  • getConstructors()
  • ......
  1. public class test05{
  2. public static void main(String[] args) throws ClassNotFoundException {
  3. Class<?> c1 = Class.forName("JavaDoc.User");
  4. //getFields只能获取public类型信息
  5. System.out.println("===getFields====");
  6. Field[] field = c1.getFields();
  7. for (Field field1 : field) {
  8. System.out.println(field1);
  9. }
  10. //getDeclaredFields可获取所有信息
  11. System.out.println("===getDeclaredFields====");
  12. field = c1.getDeclaredFields();
  13. for (Field field1 : field) {
  14. System.out.println(field1);
  15. }
  16. }
  17. }
  18. class User{
  19. public double score;
  20. private String name;
  21. private int id;
  22. private int age;
  23. }
  24. //输出结果
  25. ===getFields====
  26. public double JavaDoc.User.score
  27. ===getDeclaredFields====
  28. public double JavaDoc.User.score
  29. private java.lang.String JavaDoc.User.name
  30. private int JavaDoc.User.id
  31. private int JavaDoc.User.age

动态创建对象执行方法

创建类的对象:

调用Class对象的newInstance()方法

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

创建步骤:

  • 通过Class类中的getDeclaredConstructor()取得本类的指定形参类型的构造器。
  • 向构造器的形参中传递一个对象数组进去,里面包含了构造器中所需的各个参数。
  • 通过Constructor实例化对象。
  1. public class test06{
  2. public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
  3. Class<?> c1 = Class.forName("JavaDoc.User");
  4. //newInstance默认调用无参构造
  5. User user = (User) c1.newInstance();
  6. System.out.println(user);
  7. //通过构造器声明含参构造重新调用newInstance
  8. Constructor<?> constructor = c1.getDeclaredConstructor(String.class, int.class, int.class);
  9. User user2 = (User) constructor.newInstance("zhangsan", 001, 20);
  10. System.out.println(user2);
  11. //通过反射机制调用User类中的方法
  12. Method setName = c1.getDeclaredMethod("setId", int.class);
  13. setName.invoke(user,001);
  14. System.out.println(user.getId());
  15. //通过关闭程序权限检测,操作程序的私有属性
  16. User user4 = (User) c1.newInstance();
  17. Field name = c1.getDeclaredField("name");
  18. name.setAccessible(true);
  19. name.set(user4,"zhangsan2");
  20. System.out.println(user4.getName());
  21. }
  22. }
  23. class User{
  24. ...
  25. public User() {
  26. }
  27. public User(String name, int id, int age) {
  28. this.name = name;
  29. this.id = id;
  30. this.age = age;
  31. }
  32. ...
  33. }

反射操作注解

  1. public class test07{
  2. public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
  3. Class<?> c1 = Class.forName("JavaDoc.User");
  4. //通过反射获得注解
  5. Annotation[] annotations = c1.getAnnotations();
  6. for (Annotation annotation : annotations) {
  7. System.out.println(annotation);
  8. }
  9. //获得注解内部value值
  10. Table table = c1.getAnnotation(Table.class);
  11. System.out.println(table.value());
  12. //获取内部指定字段的注解信息
  13. Field f1 = c1.getDeclaredField("name");
  14. fieldStudent field = f1.getAnnotation(fieldStudent.class);
  15. System.out.println(field.columnName());
  16. System.out.println(field.type());
  17. System.out.println(field.length());
  18. }
  19. }
  20. @Table(value = "db_User")
  21. class User{
  22. @fieldStudent(columnName = "db_name",type = "varchar",length = 3)
  23. private String name;
  24. @fieldStudent(columnName = "db_id",type = "int",length = 10)
  25. private int id;
  26. @fieldStudent(columnName = "db_age",type = "int",length = 10)
  27. private int age;
  28. }
  29. //类名的注解
  30. @Target(ElementType.TYPE)
  31. @Retention(RetentionPolicy.RUNTIME)
  32. @interface Table{
  33. String value();
  34. }
  35. //属性的注解
  36. @Target(ElementType.FIELD)
  37. @Retention(RetentionPolicy.RUNTIME)
  38. @interface fieldStudent{
  39. String columnName();
  40. String type();
  41. int length();
  42. }
  43. //程序输出
  44. @JavaDoc.Table(value=db_User)
  45. db_User
  46. db_name
  47. varchar
  48. 3

Java注解与反射的更多相关文章

  1. 小白都能学会的Java注解与反射机制

    前言 Java注解和反射是很基础的Java知识了,为何还要讲它呢?因为我在面试应聘者的过程中,发现不少面试者很少使用过注解和反射,甚至有人只能说出@Override这一个注解.我建议大家还是尽量能在开 ...

  2. Java注解和反射笔记

    Java注解和反射笔记 1 注解 1.1 定义 Annotation是从JDK1.5开始引入的技术 作用 不是程序本身,可以对程序作出解释 可以被其他程序(编译器等)读取 格式 @注释名,可以添加一些 ...

  3. Java注解和反射

    1.注解(Annotation) 1.1.什么是注解(Annotation) 注解不是程序本身,可以在程序编译.类加载和运行时被读取,并执行相应的处理.注解的格式为"@注释名(参数值)&qu ...

  4. java注解实例-反射生成sql

    定义描述用户表的注解: package dao; import java.lang.annotation.ElementType; import java.lang.annotation.Retent ...

  5. JAVA 注解和反射

    通过反射来获取类 Class MyTest{ private String name; public String showName{ System.out.println(this.name); } ...

  6. java注解和反射学习

    spring框架很多地方都应用了注解,如@controller,所以要学会自定义注解及注解处理器. Class<?> cl=Class.froName(className) //通过类名加 ...

  7. java自定义注解与反射

    java注解与反射一.Java中提供了四种元注解,专门负责注解其他的注解,分别如下 1.@Retention元注解,表示需要在什么级别保存该注释信息(生命周期).可选的RetentionPoicy参数 ...

  8. Java基于注解和反射导入导出Excel

    代码地址如下:http://www.demodashi.com/demo/11995.html 1. 构建项目 使用Spring Boot快速构建一个Web工程,并导入与操作Excel相关的POI包以 ...

  9. Java注解Annotation与自定义注解详解

    Java注解简介 开发中经常使用到注解,在项目中也偶尔会见到过自定义注解,今天就来探讨一下这个注解是什么鬼,以及注解的应用场景和如何自定义注解. 下面列举开发中常见的注解 @Override:用于标识 ...

随机推荐

  1. css兼容大部分浏览器的文本超出部分显示省略号

    css之字体多行省略(兼容大部分浏览器) 字体单行显示省略号 <style> .box1{ width: 500px; height: 1.5em; overflow: hidden; t ...

  2. 聊聊Java

    聊聊Java 笔记源于 视频教程Bilibili:狂神说Java 关注公众号:狂神说 能干嘛? 热度 TIOBE 狂神计划 三高:高可用.高性能.高并发 全球几千万的程序员都会Java,真正精通的不到 ...

  3. 解决只能通过localhost访问Elasticsearch的问题

    解决只能通过localhost访问Elasticsearch的问题   在默认情况下Elasticsearch是无法通过外网访问的 需要绑定地址,原因如下:   具体方法为: vim /opt/es/ ...

  4. Rancher1.6 部署prometheus

    一.rancher基础配置 镜像:prom/prometheus:latest 映射端口:9090:9090 服务连接: blackbox-exporter cadvisor node-exporte ...

  5. 解决Chrome插件安装时程序包无效:"CRX_HEADER_INVALID"

    打开chorme的扩展程序(设置——>更多工具——>扩展程序)chrome://extensions 选择开发者模式 拖拽.crx至Chrome的扩展程序列表 安装失败 报错为:程序包无效 ...

  6. requests接口自动化9-共享session和传递cookie

    前言: session:用requests.session()创建会话,可以将会话信息传递给其他接口 cookie:用RequestsCookieJar或者cookie字典传递cookie信息 fil ...

  7. Django之 Views组件

    本节内容 路由系统 models模型 admin views视图 template模板 我们已经学过了基本的view写法 单纯返回字符串 1 2 3 4 5 6 7 8 def current_dat ...

  8. 数据可视化之PowerQuery篇(十九)PowerBI数据分析实践第三弹 | 趋势分析法

    https://zhuanlan.zhihu.com/p/133484654 ​本文为星球嘉宾"海艳"的PowerBI数据分析工作实践系列分享之三,她深入浅出的介绍了PowerBI ...

  9. MySQL数据库修改表名

    修改表名 例:把表user 修改为tenant,SQL如下: rename table user to tenant:

  10. ASP.NET Core3.1使用Identity Server4建立Authorization Server-2

    前言 建立Web Api项目 在同一个解决方案下建立一个Web Api项目IdentityServer4.WebApi,然后修改Web Api的launchSettings.json.参考第一节,当然 ...