• 【JAVA入门】JUnit单元测试、类加载器、反射、注解

    目录

    Junit单元测试

    一、测试分类

    二、Junit概述

    三、Junit的使用

    类加载器

    一、类加载器概述

    二、类的加载时机

    三、类的加载器

    反射（Reflection）

    一、反射（Reflection）机制概述

    静态语言

    利用反射机制提供的功能

    反射相关的主要API

    二、Class类及获取Class

    三、 反射获取构造方法

    四、反射获取空参构造方法并运行

    五、 反射带参构造方法并运行

    六、反射创建对象的快捷方式

    七、 反射获取私有构造方法并运行

    八、反射获取成员方法

    九、反射调用get_set方法

    十、反射获取私有方法并运行

    十一、 反射案例分析

    十二、反射案例代码实现

    十三、 反射案例代码实现优化

    注解

    一、 注解的介绍

    二、 自定义注解

    三、自定义注解基本使用

    四、 自定义注解使用的注意事项

    五、 元注解@Target介绍

    六、元注解@Retention介绍

    七、注解解析获取到类上的注解

    八、注解解析获取到方法上的注解

    Junit单元测试

    一、测试分类

    黑盒测试：不需要写代码，输入值看程序是否能够输出期望的值。

    白盒测试：需要写代码，关注程序具体的执行流程。

    二、Junit概述

    Junit是java编程语言的单元测试工具。Junit是一个非常重要的测试工具

    • Junit是一个开放源代码的测试工具。

    • 提供注解来识别测试方法：@Test、@Before、@After

    • Junit测试可以让代码编写更快，并提高质量

    • Junit简洁，花费时间较少

    • Junit在一个条中显示进度，如果运行良好是绿色，反之为红色

    三、Junit的使用

    1. 步骤:
    2.     1.模块名称上右键/new/directory/输入名称lib确定   
    3.     2.把junit的jar包复制到文件夹lib中
    4.     3.文件夹lib上右键/Add as Library/在对话框中输入以下内容后/ok
    5.         Name: 输入lib
    6.         Level:输入Module Library
    7.         Add to module: 输入当前模块名
    8. ============================================================
    9. //只能用在非静态无返回值无参数的方法上
    10. /* 运行:
    11.         方法上右键运行,运行的是含有@Test注解的方法
    12.         类上右键运行,运行的是类当中含有@Test注解的所有方法
    13.         绿条: 正常运行
    14.         红条: 出现问题,异常了
    15. ​
    16.   常用注解
    17.         - @Test，用于修饰需要执行的测试方法
    18.         - @Before，修饰的方法会在测试方法之前被自动执行
    19.         - @After，修饰的方法会在测试方法执行之后自动被执行
    20.  */
    21. import org.junit.Test;
    22. public class DemoJunit {
    23.     @Test
    24.     public void method(){
    25.         System.out.println("method...");
    26.     }
    27.     @Test
    28.     public void fun(){
    29.         System.out.println("fun...");
    30.     }
    31.     @Test
    32.     public void show(){
    33.         System.out.println("show...");
    34.     }
    35.     @Before
    36.    public void before(){
    37.        System.out.println("before...");
    38.    }
    39.    @After
    40.    public void after(){
    41.        System.out.println("after...");
    42.    }
    43. }
    44. =========================================================
    45. 运行结果：
    46. before...
    47. method...
    48. after...
    49. before...
    50. fun...
    51. after...
    52. before...
    53. show...
    54. after...
    55. ​

    类加载器

    一、类加载器概述

    类加载器：负责将.class文件（存储的物理文件）加载到内存中

    二、类的加载时机

    1. public class DemoClass {
    2.     public static void main(String[] args) {
    3.         // 1. 创建类的实例。
    4.          DemoClassFather father = new DemoClassFather();
    5.         // 2. 类的静态变量，或者为静态变量赋值。
    6.         System.out.println(DemoClassFather.str);
    7.         // 3. 类的静态方法。
    8.         DemoClassFather.method();
    9.         // 4. 使用反射方式来强制创建某个类或接口对应的java.lang.Class对象。
    10.         // 5. 初始化某个类的子类。
    11.         new Son();
    12.         // 6. 直接使用java.exe命令来运行某个主类。
    13.     }
    14. }
    15. ======================================================================
    16. //父类
    17. public class DemoClassFather {
    18.     //静态变量
    19.     static String str ="haha";
    20.     //静态代码块
    21.     static {
    22.         System.out.println("DemoClassFather被加载。。。");
    23.     }
    24.     //静态方法
    25.     public static void method(){
    26.         System.out.println("method.....");
    27.     }
    28. }
    29. class Son extends DemoClassFather{
    30. static {
    31.     System.out.println("Son被加载。。。。");
    32. }
    33. }

    三、类的加载器

    1.  
    2.     类加载器:
    3.         1.作用:
    4.             负责把.class文件加载到内存的方法区中.
    5.             将class文件（硬盘）加载到内存生成Class对象。
    6.         2.组成:
    7.             (1)BootstrapClassLoader 根类加载器
    8.                 也被称为引导类加载器，负责Java核心类的加载
    9.                 引导类加载器BootstrapClassLoader：
    10.                     用C++编写的，是JVM自带的类加载器，
    11.                     负责Java平台核心库，用来加载核心类库。该加载器无法直接获取
    12.                 比如System,String等。
    13. ​
    14.             (2)ExtClassLoader 扩展类加载器
    15.                 负责JRE的扩展目录中jar包的加载
    16.                 在JDK中JRE的lib目录下ext目录
    17. ​
    18.             (3)AppClassLoader 系统类加载器/应用类加载器
    19.                 Java语言编写的类加载器，负责加载我们定义的类和第三方jar包中的类。
    20. ​
    21.         3.获取类加载器
    22.             java.lang.Class类
    23.             成员方法:
    24.                  public ClassLoader getClassLoader(): 返回该类的类加载器。
    25. ​
    26.             java.lang.ClassLoader类
    27.             成员方法:
    28.                  public ClassLoader getParent(): 返回委托的父类加载器。
    29. ​
    30.          4.类加载器加载机制:
    31.             双亲委派机制: 谁用谁加载
    32.             比如:
    33.                 public Person {
    34.                     String s = name;
    35.                     DNSNameService
    36.                     ...
    37.                 }
    38. ​
    39.                 java Person
    40.                 Person类是由AppClassLoader加载
    41.                 Person类内部使用String,原则上来讲,应该由AppClassLoader加载
    42.                 但是,先找父加载器ExtClassLoader,不负责
    43.                 ExtClassLoader找父加载器BootstrapClassLoader,负责
    44. ​
    45.                 Person类内部使用DNSNameService,原则上来讲,应该由AppClassLoader加载
    46.                 但是,先找父加载器ExtClassLoader,负责
    47.                 不管怎样? .class文件只能被加载一次
    48.     注意:
    49.         BootstrapClassLoader 根类/引导类/核心类加载器 String,System
    50.         ExtClassLoader 扩展类加载器 DNSNameService
    51.         AppClassLoader 系统类加载器/应用类加载器
    52.         它们之间不存在继承关系,最终的父类 java.lang.ClassLoader
    53. ================================================================================ 
    54. public class Demo03ClassLoader {
    55.     @Test
    56.     public void boot(){
    57.         //String 由BootstrapClassLoader加载,C++实现,不让我们获取
    58.         ClassLoader c = String.class.getClassLoader();
    59.         System.out.println(c);//null
    60.     }
    61. ​
    62.     @Test
    63.     public void ext() {
    64.         //由扩展类加载器加载：获取扩展类的class对象
    65.         ClassLoader c = DNSNameService.class.getClassLoader();
    66.         System.out.println(c);//sun.misc.Launcher$ExtClassLoader@452b3a41
    67.     }
    68. ​
    69.     @Test
    70.     public void app(){
    71.         //由App类加载器加载
    72.         ClassLoader c = Demo03ClassLoader.class.getClassLoader();
    73.         System.out.println(c);//sun.misc.Launcher$AppClassLoader@18b4aac2
    74.     }
    75. ​
    76.     @Test
    77.     public void app2() {
    78.         //由App类加载器加载：
    79.         ClassLoader c = Demo03ClassLoader.class.getClassLoader();
    80.         System.out.println(c);//sun.misc.Launcher$AppClassLoader@18b4aac2
    81.         ClassLoader p = c.getParent();//委托父加载器
    82.         System.out.println(p);//sun.misc.Launcher$ExtClassLoader@452b3a41
    83. ​
    84.         ClassLoader pp = p.getParent();
    85.         System.out.println(pp);//null
    86.     }
    87. ​
    88. }
    89. ​

     

    反射（Reflection）

    注意: 1.当第一次使用类的信息时,该类的.class文件,会被加载到内存中的方法区中 2.jvm同时为加载到内存方法区的.class文件,创建一个Class类型的对象,该对象被保存在堆内存中 相当于堆内存中的Class类型的对象,指向了方法区的.class文件 3.一个类的.class文件,只能被加载一次,所以对应的Class类型的对象,只有一个 4.任意类型(基本类型/引用类型)都有对应的Class类型的对象 什么叫做反射呢?   通过获取Class类型的对象,从而操作对应的.class文件   说白了: 通过Class类型的对象获取.class文件中的成员变量/成员方法/构造方法并执行

    一、反射（Reflection）机制概述

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

    加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构。

    是一类在运行时可以改变其结构的语言：例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或是其他结构上的变化。通俗点说就是在运行时代码可以根据某些条件改变自身结构。主要动态语言：Object-C、C#、JavaScript、PHP、Python、Erlang。

    静态语言

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

    Java不是动态语言，但Java可以称之为“准动态语言”。即Java有一定的动态性，我们可以利用反射机制、字节码操作获得类似动态语言的特性。Java的动态性让编程的时候更加灵活！

    利用反射机制提供的功能

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

    反射相关的主要API

    java.lang.Class:代表一个类 java.lang.reflect.Method:代表类的方法 java.lang.reflect.Field:代表类的成员变量 java.lang.reflect.Constructor:代表类的构造器

    二、Class类及获取Class

    1. import org.junit.Test;
    2. ​
    3. import java.lang.annotation.ElementType;
    4. import java.lang.reflect.Constructor;
    5. import java.lang.reflect.Field;
    6. import java.lang.reflect.Method;
    7. /*
    8.     获取Class对象的方式
    9.         方式一:
    10.         java.lang.Object类,成员方法:
    11.             public Class getClass(): 获取Class类型的对象
    12. ​
    13.         方式二:
    14.             任意类型(基本/引用),隐藏的class属性,获取该类对应的Class对象
    15. ​
    16.         方式三:
    17.             java.lang.Class类,静态方法:
    18.             public static Class forName(String className)
    19.                 返回与带有给定字符串名的类或接口相关联的 Class 对象。
    20.                 参数:
    21.                    String className: 类/接口 的全名称(包名+类/接口名)
    22. ​
    23.        建议使用方式三:
    24.             参数是String,可以写在配置文件中
    25. ​
    26.         Class类的成员方法:
    27.             public String getSimpleName(): 获得简单类名，只是类名，没有包
    28.             public String getName(): 获取完整类名，包含包名+类名
    29.  */
    30. public class ReflectionTest {
    31.     @Test
    32.     public void test3() throws ClassNotFoundException {
    33.         //方式一：
    34.         Class c1 = Person.class;
    35.         System.out.println(c1);
    36. ​
    37.         //方式二：通过运行时类的对象,调用getClass()
    38.         Person p1 = new Person();
    39.         Class c2 = p1.getClass();
    40.         System.out.println(c2);
    41. ​
    42.         //方式三：调用Class的静态方法：forName(String classPath)
    43.         Class c3 = Class.forName("www.gh110.com");
    44. //        c3 = Class.forName("www.123.com");
    45.         System.out.println(c3);
    46. ​
    47.         System.out.println(c1 == c2);
    48.         System.out.println(c1 == c3);
    49. ​
    50.         //方式四：使用类的加载器：ClassLoader  (了解)
    51.         ClassLoader classLoader = ReflectionTest.class.getClassLoader();
    52.         Class c4 = classLoader.loadClass("www.gh110.com");
    53.         System.out.println(c4);
    54. ​
    55.         System.out.println(c1 == c4);
    56.     }
    57. }

    三、 反射获取构造方法

    1.  
    2.     反射获取构造方法
    3.     步骤:
    4.         1.获取Class类型的对象(推荐使用: Class.forName)
    5.         2.java.lang.Class类,成员方法: 作用获取构造方法对象的
    6.              public Constructor[] getConstructors():
    7.                 获取所有的public修饰的所有构造方法
    8.                 每个构造方法,被封装成了一个Constructor对象,存储到数组中,并返回数组
    9.                 
    10.              public Constructor[] getDeclaredConstructors():
    11.                 获取所有的构造方法(包含public,默认,protected,private修饰的)
    12.                 每个构造方法,被封装成了一个Constructor对象,存储到数组中,并返回数组
    13. ​
    14.              public Constructor getConstructor(Class... parameterTypes)
    15.                 根据参数类型获取构造方法对象，只能获得public修饰的构造方法。
    16.                 如果不存在对应的构造方法，则会抛出 java.lang.NoSuchMethodException 异常。
    17.                 参数是可变参数,调用此方法时,可以不写参数,获取的空参构造
    18.                             可以写参数,给定的参数必须是Class对象
    19.                                 比如:
    20.                                     参数 String name,int age
    21.                                     调用此方法: String.class,int.class
    22. ​
    23.             public Constructor getDeclaredConstructor(Class... parameterTypes)
    24.                 根据参数类型获取构造方法对象，可以获得private修饰的构造方法。
    25.  
    26. ​
    27.         3.练习:
    28.             获取public修饰的所有构造方法对象
    29.             获取所有构造方法对象(包含private修饰的)
    30.             获取public修饰的空参构造方法对象
    31.             获取public修饰的第一个参数是String类型,第二个参数是int类型的构造方法对象
    32.             获取public修饰的参数是int类型的构造方法对象
    33.  
    34. =========================================================================================
    35. public class Demo04GetConstructor {
    36.     public static void main(String[] args) throws Exception {
    37.         //1.获取Class类型的对象(推荐使用: Class.forName)
    38.         Class clazz = Class.forName("domain.User");
    39.         //获取所有的public修饰的所有构造方法
    40.         Constructor[] cons = clazz.getConstructors();
    41.         //增强for遍历
    42.         for (Constructor con : cons) {
    43.             System.out.println(con);
    44.         }
    45.         System.out.println("----------------");
    46.         //获取public修饰的空参构造方法对象
    47.         Constructor con1 = clazz.getConstructor();
    48.         System.out.println(con1);
    49.         //获取public修饰的第一个参数是String类型,第二个参数是int类型的构造方法对象
    50.         Constructor con2 = clazz.getConstructor(String.class, int.class);
    51.         System.out.println(con2);
    52.         //获取public修饰的参数是int类型的构造方法对象
    53.         //报异常: NoSuchMethodException,没有这个方法异常,因为方法是private修饰
    54.         //Constructor con3 = clazz.getConstructor(int.class);
    55.         //System.out.println(con3);
    56.         //获取private修饰的参数是int类型的构造方法对象
    57.         Constructor con4 = clazz.getDeclaredConstructor(int.class);
    58.         System.out.println(con4);
    59.     }
    60. }

    四、反射获取空参构造方法并运行

    1.  
    2.     反射获取空参构造方法并运行
    3.     步骤:
    4.         1.获取Class类型的对象(推荐使用: Class.forName)
    5.         2.Class对象调用getConstructor方法,获取空参构造方法对象
    6.         3.执行空参构造方法对象,从而创建一个具体的对象
    7.             java.lang.reflect.Constructor类,成员方法:
    8.                 public Object newInstance(Object... params):
    9.                     根据方法参数传递的具体数据,调用指定的构造方法,从而创建一个具体的对象
    10.                     参数:
    11.                         Object... params: 可变参数
    12.                             传递数组,参数列表,不传参都可以
    13.                     作用:
    14.                         创建对象时,成员变量需要具体的数据
    15.         举例(空参构造):
    16.             不使用反射
    17.                 User user = new User();
    18. ​
    19.             使用反射:
    20.                 获取到了空参构造方法对象
    21.                 Constructor con = ...;//空参构造方法被封装到了Constructor对象con中
    22.                 //newInstance方法内部会把Constructor对象con中封装的空参构造执行一次,
    23.                 //从而创建一个具体的对象出来
    24.                 Object obj = con.newInstance();
    25. ​
    26.         举例(满参构造):------此处很重要,帮助大家理解------
    27.             不使用反射
    28.                 User user = new User("zhangsan",18);
    29. ​
    30.             使用反射:
    31.                 获取到了满参构造方法对象
    32.                 Constructor con = ...;//满参构造方法被封装到了Constructor对象con中
    33.                 //newInstance方法内部会把Constructor对象con中封装的满参构造执行一次,
    34.                 //并且newInstance方法会把自己接收到的参数,交给Constructor对象con中封装的满参构造
    35.                 //从而创建一个带数据的具体的对象出来
    36.                 Object obj = con.newInstance("zhangsan",18);
    37. =========================================================================================
    38. public class Demo05NewInstance {
    39.     public static void main(String[] args) throws Exception {
    40.         //1.获取Class类型的对象(推荐使用: Class.forName)
    41.         Class clazz = Class.forName("domain.User");
    42.         //2.Class对象调用getConstructor方法,获取空参构造方法对象
    43.         Constructor con = clazz.getConstructor();
    44.         //3.执行空参构造方法对象,从而创建一个具体的对象
    45.         User user = (User)con.newInstance();
    46.         System.out.println(user);
    47.     }
    48. }

    五、 反射带参构造方法并运行

    1.  
    2.     反射带参构造方法并运行
    3.     步骤:
    4.         1.获取Class类型的对象(推荐: Class.forName(...))
    5.         2.Class类型的对象调用getConstructor方法,获取指定的构造方法对象
    6.         3.构造方法对象调用newInstance方法,创建一个具体的对象
    7.         4.打印对象
    8. ========================================================================
    9. public class Demo06NewInstance {
    10.     public static void main(String[] args) throws Exception {
    11.         //1.获取Class类型的对象(推荐: Class.forName(...))
    12.         Class clazz = Class.forName("domain.User");
    13.         //2.Class类型的对象调用getConstructor方法,获取指定的构造方法对象
    14.         //获取public修饰,指定参数类型的构造方法对象
    15.         Constructor con = clazz.getConstructor(String.class, int.class);
    16.         //3.构造方法对象调用newInstance方法,创建一个具体的对象
    17.         User user = (User) con.newInstance("张三",18);
    18.         //4.打印对象
    19.         System.out.println(user);
    20.     }
    21. }
     

    六、反射创建对象的快捷方式

    1.  
    2.     反射创建对象的快捷方式
    3.     步骤:
    4.         1.获取Class类型的对象(推荐: Class.forName(...))
    5.         2.Class对象调用newInstance方法,创建一个具体的对象
    6.             java.lang.Class类,成员方法:
    7.             public T newInstance()
    8.                 创建此 Class 对象所表示的类的一个新实例。
    9.                 底层原理:
    10.                     (1)获取空参构造方法对象
    11.                     (2)空参构造方法对象调用newInstance方法
    12. ​
    13.         3.打印对象
    14. =======================================================================
    15. public class Demo07NewInstance {
    16.     public static void main(String[] args) throws Exception {
    17.         //1.获取Class类型的对象(推荐: Class.forName(...))
    18.         Class clazz = Class.forName("domain.User");
    19.         //2.Class对象调用newInstance方法,创建一个具体的对象
    20.         User user = (User)clazz.newInstance();
    21.         //3.打印对象
    22.         System.out.println(user);
    23.     }
    24. }
    25. ​

    七、 反射获取私有构造方法并运行

    1.  
    2.     反射获取私有构造方法并运行       暴力反射
    3.     步骤:
    4.         1.获取Class类型的对象(推荐使用: Class.forName)
    5.         2.Class对象调用getDeclaredConstructor方法,获取指定参数私有构造方法对象
    6.         3.指定参数私有构造方法对象调用setAccessible方法,取消 Java 语言访问检查
    7.         4.指定参数私有构造方法对象调用newInstance方法,创建一个具体的对象
    8.         5.打印对象
    9.     注意:
    10.         java.lang.reflect.AccessibleObject类,成员方法:
    11.         public void setAccessible(boolean flag):
    12.             将此对象的 accessible 标志设置为指示的布尔值。
    13.             参数:
    14.                 boolean flag
    15.                 true: 取消 Java 语言访问检查        private 失效
    16.                 false: 实施 Java 语言访问检查       private 有效
    17. ​
    18.         AccessibleObject类,子类:
    19.             Constructor,Field,Method类,都可以调用setAccessible方法
    20.             从而进行暴力反射
    21. ====================================================================================
    22. public class Demo08NewInstance {
    23.     public static void main(String[] args) throws Exception {
    24.         //1.获取Class类型的对象(推荐使用: Class.forName)
    25.         Class clazz = Class.forName("domain.User");
    26.         //2.Class对象调用getDeclaredConstructor方法,获取指定参数私有构造方法对象
    27.         Constructor con = clazz.getDeclaredConstructor(int.class);
    28.         //3.指定参数私有构造方法对象调用setAccessible方法,取消 Java 语言访问检查
    29.         con.setAccessible(true);
    30.         //4.指定参数私有构造方法对象调用newInstance方法,创建一个具体的对象
    31.         User user = (User) con.newInstance(28);
    32.         //5.打印对象
    33.         System.out.println(user);
    34.     }
    35. }
    36. ​

    八、反射获取成员方法

    1. /*
    2.     Javabean类的介绍
    3.         1.所有成员变量必须private修饰
    4.         2.必须提供对应的get和set方法
    5.         3.必须提供空参构造(满参构造是可选的)
    6.  */
    7. public class User {
    8.     private String name;
    9.     private int age;
    10. ​
    11.     private char[] my2CharArray(String str) {
    12.         return str.toCharArray();
    13.     }
    14. ​
    15.     public int getSum(int a, int b) {
    16.         return a + b;
    17.     }
    18. ​
    19.     @Override
    20.     public String toString() {
    21.         return "User{" +
    22.                 "name='" + name + '\'' +
    23.                 ", age=" + age +
    24.                 '}';
    25.     }
    26. ​
    27.     //空参构造
    28.     public User() {
    29.     }
    30. ​
    31.     //满参
    32.     public User(String name, int age) {
    33.         this.name = name;
    34.         this.age = age;
    35.     }
    36. ​
    37.     //只给name赋值
    38.     public User(String name) {
    39.         this.name = name;
    40.     }
    41. ​
    42.     //只给age赋值
    43.     private User(int age) {
    44.         this.age = age;
    45.     }
    46. ​
    47.     public String getName() {
    48.         return name;
    49.     }
    50. ​
    51.     public void setName(String name) {
    52.         this.name = name;
    53.     }
    54. ​
    55.     public int getAge() {
    56.         return age;
    57.     }
    58. ​
    59.     public void setAge(int age) {
    60.         this.age = age;
    61.     }
    62. }
    63. ​
    64. /*
    65.     反射获取成员方法
    66.     步骤:
    67.         1.获取Class类型的对象(推荐使用: Class.forName)
    68.         2.java.lang.Class类,成员方法: 作用获取成员方法对象的
    69.             public  Method[] getMethods()
    70.                 获取所有的public修饰的成员方法，包括父类中。
    71.                 每个成员方法被封装成为一个Method对象,存储到数组中,并返回
    72.              public Method getMethod(String methodName, Class... params)
    73.                 根据方法名和参数类型获得一个方法对象，只能是获取public修饰的
    74.                 参数:
    75.                     String methodName: 方法的名字
    76.                     Class... params: 方法参数类型对应的Class对象
    77.                         可变参数: 传递数组,参数列表,不传参
    78.             Method getDeclaredMethod(String name, Class... params)
    79.                 根据方法名和参数类型获得一个方法对象，可以获取private修饰的
    80.         3.练习:
    81.             获取任意修饰符的所有成员方法
    82.             获取public修饰符的所有成员方法
    83.             获取public修饰的名称为toString的没有参数的方法
    84.             获取public修饰的名称为setName的参数为String类型的方法
    85.             获取public修饰的名称为getSum的参数为两个int类型的方法
    86.             获取public修饰的名称为my2CharArray的参数为String类型的方法
    87.  */
    88. public class Demo01GetMethod {
    89.     public static void main(String[] args) throws Exception {
    90.         //1.获取Class类型的对象(推荐使用: Class.forName)
    91.         Class clazz = Class.forName("domain.User");
    92.         //2.获取所有public修饰包含父类的成员方法对象组成的数组
    93.         Method[] ms = clazz.getMethods();
    94.         //增强for遍历
    95.         for (Method m : ms) {
    96.             System.out.println(m);
    97.         }
    98.         System.out.println("----------------");
    99.         //获取public修饰的名称为toString的没有参数的方法
    100.         Method m1 = clazz.getMethod("toString");
    101.         System.out.println(m1);
    102.         //获取public修饰的名称为setName的参数为String类型的方法
    103.         Method m2 = clazz.getMethod("setName", String.class);
    104.         System.out.println(m2);
    105.         //获取public修饰的名称为getSum的参数为两个int类型的方法
    106.         Method m3 = clazz.getMethod("getSum", int.class, int.class);
    107.         System.out.println(m3);
    108.         //获取public修饰的名称为my2CharArray的参数为String类型的方法
    109.         //该方法private修饰,无法获取报出异常
    110.         //Method m4 = clazz.getMethod("my2CharArray", String.class);
    111.         //System.out.println(m4);
    112.         //获取private修饰的名称为my2CharArray的参数为String类型的方法
    113.         Method m5 = clazz.getDeclaredMethod("my2CharArray", String.class);
    114.         System.out.println(m5);
    115.     }
    116. }
    117. ​

    九、反射调用get_set方法

    1.  
    2.     反射调用get_set方法
    3.     步骤:
    4.         1.获取Class类型的对象(推荐使用: Class.forName)
    5.         2.Class类型的对象调用newInstance方法,创建具体的对象
    6.         3.Class类型的对象调用getMethod方法,获取get和set方法对应的Method对象
    7.         4.get和set方法对应的Method对象调用invoke方法,执行对应的功能
    8.             java.lang.reflect.Method类,成员方法:
    9.             public Object invoke(Object obj, Object... args)
    10.                 对带有指定参数的指定对象调用由此 Method 对象表示的底层方法。
    11.                 参数:
    12.                     Object obj: 成员方法的调用必须由对象支持
    13.                     Object... args: 执行成员方法时,需要的具体的参数
    14. ​
    15.                 返回值类型:
    16.                     java.lang.Object类型: 成员方法执行后的返回值类型(被提升为Object类型)
    17.                     如果方法的返回值类型是void: 返回null
    18.         不使用反射:
    19.             User user = new User();
    20.             user.setName("张三");
    21.         使用反射:
    22.             已经获取到了setName方法对应的Method对象
    23.             已经把setName方法封装到Method对象setNameMethod中
    24.             Method setNameMethod = clazz.getMethod(...);
    25.             User user = new User();//通过反射创建也可以
    26.             //invoke方法内部使用invoke方法接收到的参数User对象user
    27.             //调用它内部封装的成员方法setName,同时调用该成员方法setName的时候传递参数"张三"
    28.             setNameMethod.invoke(user,"张三");
    29. =========================================================================================
    30. public class Demo02Invoke {
    31.     public static void main(String[] args) throws Exception {
    32.         //1.获取Class类型的对象(推荐使用: Class.forName)
    33.         Class clazz = Class.forName("domain.User");
    34.         //2.Class类型的对象调用newInstance方法,创建具体的对象
    35.         User user = (User) clazz.newInstance();
    36.         //3.Class类型的对象调用getMethod方法,获取get和set方法对应的Method对象
    37.         Method setNameMethod = clazz.getMethod("setName", String.class);
    38.         Method setAgeMethod = clazz.getMethod("setAge", int.class);
    39.         Method getNameMethod = clazz.getMethod("getName");
    40.         Method getAgeMethod = clazz.getMethod("getAge");
    41.         //4.get和set方法对应的Method对象调用invoke方法,执行对应的功能
    42.         //执行set方法,给成员变量赋值
    43.         Object value = setNameMethod.invoke(user, "张三");
    44.         System.out.println(value);//null
    45.         value = setAgeMethod.invoke(user, 38);
    46.         System.out.println(value);//null
    47.         //System.out.println(user);
    48.         //执行get方法,获取成员变量的值
    49.         String name = (String) getNameMethod.invoke(user);
    50.         int age = (int) getAgeMethod.invoke(user);
    51.         System.out.println(name+"::::"+age);
    52.     }
    53. }

    十、反射获取私有方法并运行

    1.  
    2.     反射获取私有方法并运行
    3.     步骤:
    4.         1.获取Class类型的对象(推荐使用: Class.forName)
    5.         2.Class类型的对象调用newInstance方法,创建具体的对象
    6.         3.Class类型的对象调用getDeclaredMethod方法,获取private修饰的方法对应的Method对象
    7.         4.private修饰的方法对应的Method对象调用setAccessible方法,取消 Java 语言访问检查
    8.         5.private修饰的方法对应的Method对象调用调用invoke方法,执行对应的功能
    9.     注意:
    10.         java.lang.reflect.AccessibleObject类,成员方法:
    11.         public void setAccessible(boolean flag):
    12.             将此对象的 accessible 标志设置为指示的布尔值。
    13.             参数:
    14.                 boolean flag
    15.                 true: 取消 Java 语言访问检查        private 失效
    16.                 false: 实施 Java 语言访问检查       private 有效
    17.         AccessibleObject类,子类:
    18.             Constructor,Field,Method类,都可以调用setAccessible方法
    19.             从而进行暴力反射
    20. =========================================================================================
    21. public class Demo03Invoke {
    22.     public static void main(String[] args) throws Exception {
    23.         //1.获取Class类型的对象(推荐使用: Class.forName)
    24.         Class clazz = Class.forName("domain.User");
    25.         //2.Class类型的对象调用newInstance方法,创建具体的对象
    26.         User user = (User)clazz.newInstance();
    27.         //3.Class类型的对象调用getDeclaredMethod方法,获取private修饰的方法对应的Method对象
    28.         Method m = clazz.getDeclaredMethod("my2CharArray", String.class);
    29.         //4.private修饰的方法对应的Method对象调用setAccessible方法,取消 Java 语言访问检查
    30.         m.setAccessible(true);
    31.         //5.private修饰的方法对应的Method对象调用调用invoke方法,执行对应的功能
    32.         char[] chs = (char[]) m.invoke(user,"helloworld");
    33.         System.out.println(new String(chs));
    34.     }
    35. }

    十一、 反射案例分析

    1. /*
    2.     反射案例
    3.         需求：
    4.             写一个"框架"，不能改变该类的任何代码的前提下，可以帮我们创建任意类的对象，并且执行其中任意方法
    5.         步骤:
    6.             1.定义配置文件config.properties,以属性名=属性值
    7.                 className=itheima02.Dog
    8.                 methodName=eat
    9.                 注意:
    10.                     配置文件config.properties必须写在src根路径下
    11. ​
    12.             2.需要把配置文件信息,加载到Properties集合对象中
    13.             3.获取类的全名称和方法名称
    14.             4.获取类的Class类型的对象
    15.             5.根据Class类型的对象获取要执行的方法对应的Method对象
    16.             6.Class类型的对象创建一个具体的对象出来
    17.             7.Method对象调用invoke方法,执行具体的功能
    18.  */
    19. //抽象父类
    20. public abstract class Animal {
    21.     public abstract void eat();
    22. }
    23. //子类
    24. public class Cat extends Animal {
    25.     @Override
    26.     public void eat() {
    27.         System.out.println("猫吃鱼...");
    28.     }
    29. }
    30. //子类
    31. public class Dog extends Animal {
    32.     @Override
    33.     public void eat() {
    34.         System.out.println("狗吃骨头....");
    35.     }
    36. }

    十二、反射案例代码实现

    1. public class Demo02ReflectTest {
    2.     public static void main(String[] args) throws Exception {
    3.         //2.需要把配置文件信息,加载到Properties集合对象中
    4.         Properties props = new Properties();
    5. ​
    6.         props.load(new FileInputStream("day14\\src\\config.properties"));
    7. ​
    8.         //3.获取类的全名称和方法名称
    9.         //类的全名称
    10.         String className = props.getProperty("className");
    11.         //方法名称
    12.         String methodName = props.getProperty("methodName");
    13. ​
    14.         //4.获取类的Class类型的对象
    15.         Class clazz = Class.forName(className);
    16. ​
    17.         //5.根据Class类型的对象获取要执行的方法对应的Method对象
    18.         Method eatMethod = clazz.getMethod("eat");
    19. ​
    20.         //6.Class类型的对象创建一个具体的对象出来
    21.         Object obj = clazz.newInstance();
    22. ​
    23.         //7.Method对象调用invoke方法,执行具体的功能
    24.         eatMethod.invoke(obj);
    25.     }
    26. }

    十三、 反射案例代码实现优化

    1. /*
    2.     反射案例
    3.         需求：
    4.             写一个"框架"，不能改变该类的任何代码的前提下，可以帮我们创建任意类的对象，并且执行其中任意方法
    5.         步骤:
    6.             1.定义配置文件config.properties,以属性名=属性值
    7.                 className=itheima02.Dog
    8.                 methodName=eat
    9.                 注意:
    10.                     配置文件config.properties必须写在src根路径下
    11.                     src下写的java源代码,项目完成后,给客户的是.class文件
    12.                     配置文件会跟着.class文件,到类路径(存储.class文件的路径)下,同步的
    13.             2.需要把配置文件信息,加载到Properties集合对象中
    14.             3.获取类的全名称和方法名称
    15.             4.获取类的Class类型的对象
    16.             5.根据Class类型的对象获取要执行的方法对应的Method对象
    17.             6.Class类型的对象创建一个具体的对象出来
    18.             7.Method对象调用invoke方法,执行具体的功能
    19. ​
    20.         java.lang.Class类,成员方法:
    21.             public ClassLoader getClassLoader(): 返回该类的类加载器。
    22.             java.lang.ClassLoader类,成员方法:
    23.                 public InputStream getResourceAsStream(String name): 返回读取指定资源的输入流。
    24.                     指定资源: 类路径(该方法直接到类路径下扫描配置文件)
    25.                     如果配置文件写在src根下:
    26.                         String name: 只需要写文件名.扩展名 config.properties
    27. ​
    28.                     如果配置文件写在src/itheima02下:
    29. ​
    30.                         String name: itheima02/config.properties
    31. ​
    32. ​
    33.  */
    34. public class Demo03ReflectTest {
    35.     public static void main(String[] args) throws Exception {
    36.         //2.需要把配置文件信息,加载到Properties集合对象中
    37.         Properties props = new Properties();
    38.         //获取类加载器
    39.         ClassLoader classLoader = Demo03ReflectTest.class.getClassLoader();
    40. ​
    41.         //通过类加载器,获取资源的字节输入流
    42.         InputStream is = classLoader.getResourceAsStream("config.properties");
    43. ​
    44.         props.load(is);
    45. ​
    46.         //3.获取类的全名称和方法名称
    47.         //类的全名称
    48.         String className = props.getProperty("className");
    49.         //方法名称
    50.         String methodName = props.getProperty("methodName");
    51. ​
    52.         //4.获取类的Class类型的对象
    53.         Class clazz = Class.forName(className);
    54. ​
    55.         //5.根据Class类型的对象获取要执行的方法对应的Method对象
    56.         Method eatMethod = clazz.getMethod("eat");
    57. ​
    58.         //6.Class类型的对象创建一个具体的对象出来
    59.         Object obj = clazz.newInstance();
    60. ​
    61.         //7.Method对象调用invoke方法,执行具体的功能
    62.         eatMethod.invoke(obj);
    63.     }
    64. }
    65. ​
    66. /*
    67.     反射案例
    68.         需求：
    69.             写一个"框架"，不能改变该类的任何代码的前提下，可以帮我们创建任意类的对象，并且执行其中任意方法
    70.         步骤:
    71.             1.定义配置文件config.properties,以属性名=属性值
    72.                 className=itheima02.Dog
    73.                 methodName=eat
    74.                 注意:
    75.                     配置文件config.properties必须写在src根路径下
    76.                     src下写的java源代码,项目完成后,给客户的是.class文件
    77.                     配置文件会跟着.class文件,到类路径(存储.class文件的路径)下,同步的
    78.             2.需要把配置文件信息,加载到Properties集合对象中
    79.             3.获取类的全名称和方法名称
    80.             4.获取类的Class类型的对象
    81.             5.根据Class类型的对象获取要执行的方法对应的Method对象
    82.             6.Class类型的对象创建一个具体的对象出来
    83.             7.Method对象调用invoke方法,执行具体的功能
    84. ​
    85.         java.lang.Class类,成员方法:
    86.             public ClassLoader getClassLoader(): 返回该类的类加载器。
    87.             java.lang.ClassLoader类,成员方法:
    88.                 public InputStream getResourceAsStream(String name): 返回读取指定资源的输入流。
    89.                     指定资源: 类路径(该方法直接到类路径下扫描配置文件)
    90.                     如果配置文件写在src根下:
    91.                         String name: 只需要写文件名.扩展名 config.properties
    92. ​
    93.                     如果配置文件写在src/itheima02下:
    94. ​
    95.                         String name: itheima02/config.properties
    96.                         
    97.         java.util.ResourceBundle类: 获取资源的类
    98.         注意: 该类是抽象类,不能直接创建对象,可以创建子类对象
    99.         发现:
    100.             该类中提供了静态方法,用于获取该抽象类的子类对象
    101.             public static final ResourceBundle getBundle(String baseName): 
    102.                 获取抽象类ResourceBundle的子类对象
    103.             参数:
    104.                 String baseName: 如果配置文件写在src根下,此处只需要写文件名(不需要写扩展名)
    105.     
    106.         ResourceBundle类的成员方法:
    107.             public final String getString(String key): 
    108.                 根据String类型的属性名,获取String类型属性值(根据键找值)
    109. ​
    110.  */
    111. public class Demo04ReflectTest {
    112.     public static void main(String[] args) throws Exception {
    113.         //创建子类管理类ResourceBundle的对象
    114.         ResourceBundle resourceBundle = ResourceBundle.getBundle("config");
    115. ​
    116.         //3.获取类的全名称和方法名称
    117.         String className = resourceBundle.getString("className");
    118.         String methodName = resourceBundle.getString("methodName");
    119. ​
    120.         //4.获取类的Class类型的对象
    121.         Class clazz = Class.forName(className);
    122. ​
    123.         //5.根据Class类型的对象获取要执行的方法对应的Method对象
    124.         Method eatMethod = clazz.getMethod("eat");
    125. ​
    126.         //6.Class类型的对象创建一个具体的对象出来
    127.         Object obj = clazz.newInstance();
    128. ​
    129.         //7.Method对象调用invoke方法,执行具体的功能
    130.         eatMethod.invoke(obj);
    131.     }
    132. }

     

    注解

    一、 注解的介绍

    1.概念:
注解（Annotation）: 也叫元数据。一种代码级别的说明。
它是JDK1.5及以后版本引入的一个特性，与类、接口、枚举是在同一个层次。
它可以声明在包、类、字段、方法、局部变量、方法参数等的前面，用来对这些元素进行说明，注释。   
2.作用分类:
 (1)编写文档：通过代码里标识的注解生成文档【例如，生成文档doc文档】
 (2)代码分析：通过代码里标识的注解对代码进行分析【例如，注解的反射】
 (3)编译检查：通过代码里标识的注解让编译器能够实现基本的编译检查【例如，Override】​
3.常见注解
(1)@author：用来标识作者名
(2)@version：用于标识对象的版本号，适用范围：文件、类、方法。
(3)@Override：用来修饰方法声明，告诉编译器该方法是重写父类中的方法，如果父类不存在该方法，则编译失败。
(4)@FunctionalInterface: 检测是否是函数式接口的

    Locale: zh_CN

    Other command line arguments:

     -encoding UTF-8 -charset UTF-8 -windowtitle "IOUtils类的使用" -link http://docs.Oracle.com/javase/7/docs/api

    二、 自定义注解

    格式:
  public @interface 注解名 {
             属性集
            }
​
1.空注解: 没有任何属性  看MyAnno01
2.有属性集的注解:       看MyAnno02
     属性的定义格式一:数据类型 属性名(); 没有默认值的属性
     属性的定义格式二:数据类型 属性名() default 默认值; 有默认值的属性
​3.注解属性可以选择的数据类型: 8种基本类型,String类型,枚举类型,注解类型,Class类型以及以上任意类型对应的一维数组
 

    1. public class Demo03Annotation {
    2. }
    3. ​​​​​​​//空注解
    4. public @interface MyAnno01 {
    5. }
    6. //定义有属性集的注解
    7. public @interface MyAnno02 {
    8.     String name();//String 类型的属性 name,没有默认值
    9.     int age() default 18;//int 类型的属性 age,默认值 18
    10.     String[] hobbies();//String 类型的数组 hobbies
    11.     MyAnno01 myAnno01();//注解类型
    12. }

    三、自定义注解基本使用

    空注解使用格式: 直接使用
               @注解名称            
有属性集注解使用格式:
               @注解名称(属性名1=属性值1,属性名2=属性值2,属性名3={元素1,元素2...})
注意事项:
1.空注解可以直接使用
2.一个注解只能在一个位置上使用一次,一个位置上可以使用多个不同的注解
3.如果注解有属性,那么必须给属性赋值才能使用键值对的方式赋值 属性名=属性值 多个属性,隔开。如果属性是数组类型 并且只有一个属性值 那么{}可以省略 如果多个属性值 {}不能省略
4.如果属性没有默认值 必须赋值 如果有默认值 可以不赋值

    1. @MyAnno01
    2. //@MyAnno01 //同一位置不能使用第二次
    3. @MyAnno02(name="张三",age=28,hobbies={"看球","撸代码"},myAnno01=@MyAnno01)
    4. public class Demo04UseAnnotation {
    5.     @MyAnno01
    6.     @MyAnno02(name="李四",hobbies = "看球",myAnno01 = @MyAnno01)
    7.     public static void main(String[] args) {
    8. ​
    9.     }
    10. }

    四、 自定义注解使用的注意事项

    注意事项：
----重点----  MyAnno03,MyAnno04,MyAnno05
- 当注解中只有一个属性且名称是value，在使用注解时给value属性赋值可以直接给属性值，
无论value是单值元素还是数组类型。
- 如果属性有默认值，则使用注解的时候，这个属性可以不用赋值。
- 如果属性没有默认值，那么在使用注解时一定要给属性赋值。


    1. @MyAnno03("张三")
    2. @MyAnno04 //有默认值的属性,不管属性名是什么,都可以省略
    3. @MyAnno05({"打乒乓球","撸代码"})
    4. public class Demo05AnnotationNotice {
    5.     @MyAnno04("李四")
    6.     public static void main(String[] args) {
    7. ​
    8.     }
    9. }
    10. public @interface MyAnno03 {
    11.     String value();
    12. }
    13. public @interface MyAnno04 {
    14.     String value() default "李四";
    15. }
    16. public @interface MyAnno05 {
    17.     String[] value();
    18. }

    五、 元注解@Target介绍

    1.作用:
  用来限制自定义注解的生命周期(只存在于源代码中,存在于class文件中,存在于运行时期的内存中)
  用来限制自定义注解的使用范围(只能写在类上,只能写方法上,既能写在类上又能写在方法上等等)
2.限制自定义注解的使用范围(在什么位置可以使用)
            元注解(限制自定义注解的注解)之@Target,源代码:
            public @interface Target {
                ElementType[] value();
            }
java.lang.annotation.ElementType 枚举 可以理解为类,里面都是静态内容,直接用类名/枚举名调用
TYPE： 用在类,接口上
FIELD：用在成员变量上
METHOD： 用在方法上
PARAMETER：用在参数上
CONSTRUCTOR：用在构造方法上
LOCAL_VARIABLE：用在局部变量上
​

    1. @MyAnno06
    2. public class Demo05YuanAnnotation {
    3.     //@MyAnno06 //错误了,该注解只能写在类/方法上
    4.     private String name;
    5.     @MyAnno06
    6.     public static void main(String[] args) {
    7. ​
    8.     }
    9. }
    10. /*
    11.     限制注解的使用范围: 指定写在类上/方法上
    12.     使用元注解: Target
    13.  */
    14. @Target({ElementType.TYPE,ElementType.METHOD})
    15. public @interface MyAnno06 {
    16. }

    六、元注解@Retention介绍

    1.作用:
 用来限制自定义注解的生命周期(只存在于源代码中,存在于class文件中,存在于运行时期的内存中)
 用来限制自定义注解的使用范围(只能写在类上,只能写方法上,既能写在类上又能写在方法上等等)
2.限制自定义注解的生命周期(存在到什么时候,源代码中,生成的.class文件中,还是运行.class文件的时)
            元注解(限制自定义注解的注解)之@Retention
            public @interface Retention {
                RetentionPolicy value();
            }

该注解是单属性的,属性名value,使用时,可以不写属性名
java.lang.annotation.RetentionPolicy 枚举 可以理解为类,里面都是静态内容,直接用类名/枚举名调用
SOURCE：注解只存在于Java源代码中，编译生成的字节码文件中就不存在了。
CLASS：注解存在于Java源代码、编译以后的字节码文件中，运行的时候内存中没有，默认值。
RUNTIME：注解存在于Java源代码中、编译以后的字节码文件中、运行时内存中，程序可以通过反射获取该注解。


    1. @MyAnno07
    2. //@MyAnno08//只能用在方法上/成员变量上
    3. public class Demo06YuanAnnotation {
    4.     //@MyAnno07 //错误了,该注解只能写在类/方法上
    5.     @MyAnno08
    6.     private String name;
    7.     @MyAnno07
    8.     @MyAnno08
    9.     public static void main(String[] args) {
    10. ​
    11.     }
    12. }
    13. /*
    14.     定义注解:
    15.         只能用在方法上/类上
    16.         保留在class文件中,运行时期内存中没有
    17.  */
    18. @Target({ElementType.TYPE,ElementType.METHOD})
    19. @Retention(RetentionPolicy.CLASS)
    20. public @interface MyAnno07 {
    21. }
    22. ​
    23. /*
    24.     定义注解:
    25.         只能用在方法上/成员变量上
    26.         保留在源文件中,class文件中没有
    27.  */
    28. @Target({ElementType.METHOD,ElementType.FIELD})
    29. @Retention(RetentionPolicy.SOURCE)
    30. public @interface MyAnno08 {
    31. ​
    32. }

    七、注解解析获取到类上的注解

    注解本质上就是一个接口，该接口默认继承Annotation接口
java.lang.annotation.Annotation接口：所有注解类型的公共接口，类似所有类的父类是Object。
前面用过的元注解 @Target @Retention 就是该接口的实现类对象
需求说明
1. 定义注解Books，要求如下：
    - 包含属性：String value()   书名
    - 包含属性：double price()  价格，默认值为 100
    - 包含属性：String[] authors() 多位作者
    - 限制注解使用的位置：类和成员方法上
    - 指定注解的有效范围：RUNTIME
2. 定义BookStore类，在类和成员方法上使用Book注解
3. 定义Demo06AnnotationTest测试类获取Book注解上的数据
获取类上定义的注解
 java.lang.Class类,成员方法public  A getAnnotation(Class annotationClass)如果该元素的指定注解类型的注解存在于此对象(Class对象)上，则返回这个注解，否则返回 null；获得当前对象上指定的注解对象。
​public boolean isAnnotationPresent(Class annotationClass):判断当前对象(Class对象)是否有指定的注解，有则返回true，否则返回false。​​
步骤:
1.获取类的Class类型的对象
2.Class类型的对象调用方法,判断是否具有Books注解
3.如果有,Class类型的对象调用方法获取Books注解对象
4.打印Books注解对象的属性值

    1. /*
    2.     定义注解Books，要求如下：
    3.        - 包含属性：String value()   书名
    4.        - 包含属性：double price()  价格，默认值为 100
    5.        - 包含属性：String[] authors() 多位作者
    6.        - 限制注解使用的位置：类和成员方法上
    7.        - 指定注解的有效范围：RUNTIME
    8.  */
    9. //限制注解使用的位置：类和成员方法上
    10. @Target({ElementType.TYPE,ElementType.METHOD})
    11. //指定注解的有效范围：RUNTIME
    12. @Retention(RetentionPolicy.RUNTIME)
    13. public @interface Books {
    14.     String value();//书名
    15.     double price() default 100;//价格，默认值为 100
    16.     String[] authors();//多位作者
    17. }
    18. @Books(value = "面向对象",price = 180,authors = {"响哥","刚哥"})
    19. public class BookStore {
    20.     @Books(value = "jdk8新特性",authors = "响哥")
    21.     public void show() {
    22. ​
    23.     }
    24. }
    25. ​
    26. //获取类上注解信息的测试类
    27. public class Demo06AnnotationTest {
    28.     @Test
    29.     public void getParseClassAnnotation() throws Exception {
    30.         //1.获取类的Class类型的对象
    31.         Class clazz = Class.forName("itheima06.BookStore");
    32. ​
    33.         //2.Class类型的对象调用方法,判断是否具有Books注解
    34.         if(clazz.isAnnotationPresent(Books.class)) {
    35.             //3.如果有,Class类型的对象调用方法获取Books注解对象
    36.             Books booksAnno = clazz.getAnnotation(Books.class);
    37. ​
    38.             //4.打印Books注解对象的属性值
    39.             String bookName = booksAnno.value();
    40.             double price = booksAnno.price();
    41.             String[] authors = booksAnno.authors();
    42.             System.out.println(bookName+"::"+price+"::"+ Arrays.toString(authors));
    43.         }
    44.     }
    45. }
    46. ​

    八、注解解析获取到方法上的注解

    注解本质上就是一个接口，该接口默认继承Annotation接口
 java.lang.annotation.Anontation接口：所有注解类型的公共接口，类似所有类的父类是Object。
            前面用过的元注解 @Target @Rentention 就是该接口的实现类对象
需求说明
​1. 定义注解Books，要求如下：
           - 包含属性：String value()   书名
           - 包含属性：double price()  价格，默认值为 100
           - 包含属性：String[] authors() 多位作者
           - 限制注解使用的位置：类和成员方法上
           - 指定注解的有效范围：RUNTIME
2. 定义BookStore类，在类和成员方法上使用Book注解
3. 定义Demo06AnnotationTest测试类获取Book注解上的数据
获取类上定义的注解
java.lang.reflect.Method类,
成员方法public  A getAnnotation(Class annotationClass)
如果该元素的指定注解类型的注解存在于此对象(Class对象)上，则返回这个注解，否则返回 null
获得当前对象上指定的注解对象。
public boolean isAnnotationPresent(Class annotationClass):判断当前对象(Class对象)是否有指定的注解，有则返回true，否则返回false。
步骤:
1.获取类的Class类型的对象
2.Class类型的对象调用方法,获取方法对象
3.方法对象调用方法,判断是否具有Books注解
4.如果有,方法对象调用方法获取Books注解对象
5.打印Books注解对象的属性值
总结:
1、java.lang.reflect.AnnotatedElement接口: 规定操作注解的方法
2、public abstract boolean isAnnotationPresent(Class clazz): 判断是否含有指定参数类型的注解,有返回true,没有返回false
3、public abstract  T getAnnotation(Class clazz):获取指定参数类型的注解对象,没有获取到的,返回null
参数:Class clazz: 注解的Class对象
常用实现类:Class,Method,Constructor,Field  类 都实现了以上方法             
总结:
1.获取类上的注解: 使用Class对象直接获取
2.获取方法上的注解: 使用Method对象直接获取
3.获取构造方法上的注解: 使用Constructor对象直接获取
4.获取成员变量上的注解: 使用Field对象直接获取
注意:Method对象/Constructor对象/Field对象 都被必须由Class对象获取

    1.  
    2. public class Demo07AnnotationTest {
    3.     @Test
    4.     public void parseMethodAnnotation() throws Exception {
    5.         //1.获取类的Class类型的对象
    6.         Class clazz = Class.forName("itheima06.BookStore");
    7. ​
    8.         //2.Class类型的对象调用方法,获取方法对象
    9.         Method showMethod = clazz.getMethod("show");
    10. ​
    11.         //2.方法对象调用方法,判断是否具有Books注解
    12.         if(showMethod.isAnnotationPresent(Books.class)) {
    13.             //3.如果有,方法对象调用方法获取Books注解对象
    14.             Books booksAnno = showMethod.getAnnotation(Books.class);
    15. ​
    16.             //4.打印Books注解对象的属性值
    17.             String bookName = booksAnno.value();
    18.             double price = booksAnno.price();
    19.             String[] authors = booksAnno.authors();
    20.             System.out.println(bookName+"::"+price+"::"+ Arrays.toString(authors));
    21. ​
    22.         }
    23.     }
    24. }
    25. ​

     

     

  • 相关阅读:
    双机热备综合实验（VRRP+OSPF+VTP+NAT+DHCP）
    数据结构难题小解析
    Maven编译打包本地jar包rt.jar
    单元测试的重要性
    js数组方法复习汇总
    《搞定音频技术》
    类型与特点
    《动手学深度学习 Pytorch版》 8.6 循环神经网络的简洁实现
    主站侧通讯问题定位工具
    Django更换数据库和迁移数据方案
  • 原文地址：https://blog.csdn.net/qq_49047454/article/details/126921130