JavaEE Day01 基础加强

今日内容

1.Junit单元测试（测试类）

2.反射

3.注解

一、Junit单元测试

1.概述

测试分类

• 1. 黑盒测试：不需要写代码，给输入值，看程序是否能够输出期望的值
• 2.白盒测试：需要写代码的，关注程序具体的执行流程

2.Junit的使用：白盒测试

package com.liujinhui.Day1209BaseEnhance;
/*
    计算器类
* */
public class Calculator {
    /**
     * @author: Liu Jinhui
     * @description: TODO
     * @date: 2020/12/9 15:54
     * @return  * @param null
     */
    public int add(int a, int b){
//        int i=3/0;
        //改成-
        return a+b;
    }
    /**
     * @author: Liu Jinhui
     * @description: 加法
     * @date: 2020/12/9 15:55

     * @return  * @param null
     */
    public int sub(int a, int b){
        int c=a-b;
        return c;
    }
}

使用

package com.liujinhui.Day1209BaseEnhance;
import com.liujinhui.Day1209BaseEnhance.Calculator;
public class CalculatorTest {
    /**
     * @author: Liu Jinhui
     * @description: TODO
     * @date: 2020/12/9 15:57
     * @return  * @param null
     */
    public static void main(String[] args) {
        //创建对象
        Calculator calculator=new Calculator();
        //调用方法
        /*int result=calculator.add(1,2);
        System.out.println(result);*/
        //测试其他代码需要注释该部分，不方便进行统一管理

        int sub = calculator.sub(1, 1);
        System.out.println(sub);
        String str="abc";

    }
}

步骤

-1.定义一个测试类（测试用例）

建议

• 测试类名：被测试的类名 Test CalculatorTest
• 包名：xxx.xxx.xx.test cn.itcast.test
  
  
  

 -2.定义 测试方法：可以独立运行

 建议：

• 方法名： test测试的方法名 testAdd（）
• 返回值：void
• 参数列表：空参数
  

  package com.liujinhui.Day1209BaseEnhance.test;
  
  import com.liujinhui.Day1209BaseEnhance.Calculator;
  import org.junit.After;
  import org.junit.Assert;
  import org.junit.Before;
  import org.junit.Test;
  
  public class CalculatorTest {
      /*
          初始化方法：
              用于资源申请，所有测试方法执行之前都会执行该方法
  
      * */
      @Before
      public void init(){
          System.out.println("init...");
      }
      /*
          释放资源的方法：
          在所有测试方法执行完后，都会自动执行该方法
      * */
      @After
      public void close(){
          System.out.println("close");
      }
      /*
      * 测试add方法
      * */
      @Test
      public void testAdd(){
  //        System.out.println("我被执行了");
          //1.创建计算器对象
          Calculator c=new Calculator();
          //2.调用add方法
          int result = c.add(1, 2);
          //绿色成功，但结果不是想要的结果
          //一般不会输出
          //System.out.println(result);
          //3.断言：断言结果是3
          System.out.println("testAdd...");
          Assert.assertEquals(3,result);
      }
      @Test
      public void testSub(){
          System.out.println("testSub...");
          //1.创建计算器对象
          Calculator c=new Calculator();
          //2.调用add方法
          int result = c.sub(1, 2);
          //3.断言
          Assert.assertEquals(11,result);
      }
  }

-3.给方法加@Test注解，就可以独立运行了

-4.导入Junit的依赖环境

结果判定：

    红色：失败

    绿色：成功

    一般会使用断言操作处理结果

    Assert.assertEquals(期望的结果,运算的结果);

3.Junit_@Before&@After

很多代码操作重复，使用两个注解

@Before资源的申请，修饰的方法会在测试方法之前自动执行

@After资源的释放，修饰的方法会在测试方法之后自动被执行

二、反射

1.概述

反射是框架设计的灵魂

框架：半成品软件。可以在框架的基础上进行软件开发，简化编码

反射：将类的各个组成部分封装为其他对象，这就是反射机制

第一个阶段：源文件.java--->目标文件.class：源代码阶段，代码还在硬盘上

第二个阶段：通过类加载器对象ClassLoader把字节码文件加载进内存

内存中有一个对象描述字节码文件，该对象叫Class类对象

描述所有字节码的共同特征：

成员变量（拿到值，设置值）--封装为Field对象---很多个Field[] field

构造方法（创建对象）--封装为Constructor对象--Constructor[] constructor数组描述所有的构造方法

成员方法（其他功能）--封装为Method对象--Method[] method

第三个阶段：调用 Person对象，属于第三个阶段（运行时阶段）

反射：将类的各个组成部分封装为其他对象，这就是反射机制

Person对象，Student对象都是通过类对象阶段创建的

类的成员变量封装为Field对象

将构造方法封装为Constructor对象

就叫反射机制

好处：

        -1.可以在程序运行过程中去操作这些对象。获取、执行等，在运行过程中很重要

把method对象数组的成员展示出来可以

       - 2.解耦（降低耦合性和紧密程度），来提高程序的 可扩展性

2.反射_获取字节码Class对象的三种方式

API中的操作，主要是获取class类对象，三种方式分别代表三个阶段

源代码阶段（1）Class.forName("全类名（包名.类名）")：将字节码文件加载进内存，返回Class对象

【只有字节码文件，没有进内存，需要手动将其加载到内存，使用forName这种手动加载方式】

【写全类名常用于配置文件，将类名定义在配置文件中，读取文件，加载类】

类对象阶段（2）类名.class：通过类名的属性class获取

【字节码已经加载到内存，不需要再加载，只需要获取，没有对象通过类名的属性获取该对象】

【多用于参数的传递】

运行时阶段（3）对象.getClass()：getClass() 返回此 Object的运行时类，在Object类中定义

【已经有对象，可以通过对象的方法进行获取类对象，封装在Object中的方法】

【多用于对象的获取字节码方式】

结论：同一个字节码文件（*.class）在一次程序运行过程中，只会被加载一次，无论通过哪种方式加载到内存中的类对象只有一个

package com.liujinhui.Day1209BaseEnhance.reflect;
import com.liujinhui.Day1209BaseEnhance.domain.Person;
import com.liujinhui.Day1209BaseEnhance.domain.Student;

public class ReflectDemo1 {
    /*
        获取class的三种方式
            源代码阶段（1）Class.forName("全类名（包名.类名）")：将字节码文件加载进内存，返回Class对象
            【只有字节码文件，没有进内存，需要手动将其加载到内存，使用forName这种手动加载方式】
            类对象阶段（2）类名.class：通过类名的属性class获取
            【字节码已经加载到内存，不需要再加载，只需要获取，没有对象通过类名的属性获取该对象】
            运行时阶段（3）对象.getClass()：getClass() 返回此 Object的运行时类，在Object类中定义
            【已经有对象，可以通过对象的方法进行获取类对象，封装在Object中的方法】
    * */
    public static void main(String[] args) throws Exception{
        //1.Class.forName("全类名（包名.类名）")
        //Class类的静态方法static Class<?> forName(String className) 返回与给定字符串名称的类或接口相关联的 Class对象。
        Class<?> cls1 = Class.forName("com.liujinhui.Day1209BaseEnhance.domain.Person");
        //如果遇到ClassNotFoundClass，是自定义，则说明，类名写错了，需要重写类名
        System.out.println(cls1);//class com.liujinhui.Day1209BaseEnhance.domain.Person
        //2.类名.class
        Class cls2 = Person.class;//删掉泛型
        System.out.println(cls2);
        //3.对象.getClass()：
        Person p=new Person();
        Class cls3 = p.getClass();
        System.out.println(cls3);
        //打印形式一样，直接使用==比较三个对象是否相等
        //==比较的是对象的内存地址
        System.out.println(cls1==cls2);
        System.out.println(cls2==cls3);
        //true
        Class c = Student.class;
        System.out.println(c==cls1);//每个字节码文件的物理文件对应的class类对象都不相同
    }
}

3.反射_Class对象功能概述

使用Class对象，前提知道功能

大部分是获取get方法

常见的获取功能：    

        1.获取成员变量们Field[]对象    

Field[] getFields()    获取所有public修饰的成员变量

Field getField(String name) 

Field[] getDeclaredFields() 获取所有的成员变量，不考虑修饰符

Field getDeclaredField(String name) 

        2.获取成员方法们Method[]

Method[] getMethods() 

Method getMethod(String name, Class<?>... parameterTypes) 

Method[] getDeclaredMethods() 

Method getDeclaredMethod(String name, Class<?>... parameterTypes) 

        3.获取构造方法们Constructor[]

Constructor<?>[] getConstructors() 

Constructor<T> getConstructor(Class<?>... parameterTypes) 

Constructor<?>[] getDeclaredConstructors() 

Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes) 

        4.获取类名

String getName() 

String getPackageName() 

4.反射_Class对象功能_获取Field

Field成员变量的操作：

        1.设置值void set(Object obj, Object value) 

        2.获取值Object get(Object obj)，根据成员变量找到对应的对象

        3.忽略访问权限的安全检查d.setAccessible(true);//暴力反射

package com.liujinhui.Day1209BaseEnhance.domain;

public class Person {
    private String name;
    private int age;
    public String a;
    protected String b;
    String c;
    private String d;

    public Person() {
    }

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

    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;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", a='" + a + '\'' +
                ", b='" + b + '\'' +
                ", c='" + c + '\'' +
                ", d='" + d + '\'' +
                '}';
    }
}

package com.liujinhui.Day1209BaseEnhance.reflect;
import com.liujinhui.Day1209BaseEnhance.domain.Person;
import java.lang.reflect.Field;
public class ReflectDemo2 {
    /*
   1.获取成员变量们Field[]对象
    Field[]	getFields()：获取所有public修饰的成员变量
    Field getField(String name)
    Field[] getDeclaredFields()获取所有的成员变量，不考虑修饰符
    Field getDeclaredField(String name)
    2.获取成员方法们Method[]
    Method[] getMethods()
    Method getMethod(String name, Class<?>... parameterTypes)
    Method[] getDeclaredMethods()
    Method getDeclaredMethod(String name, Class<?>... parameterTypes)
    3.获取构造方法们Constructor[]
    Constructor<?>[] getConstructors()
    Constructor<T> getConstructor(Class<?>... parameterTypes)
    Constructor<?>[] getDeclaredConstructors()
    Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)
    4.获取类名
    String getName()
    String getPackageName()
    * */
    public static void main(String[] args) throws Exception{
        //1.获取Person的Class对象
        Class personClass = Person.class;
        //Field[]	getFields()
        Field[] fields = personClass.getFields();
        for (Field field : fields) {
            /*
                public String a;
                protected String b;
                String c;
                private String d;
            * */
        }
        //遍历可以输入.for或iter
        for (Field field : fields) {
            //一个都没有打印，应该是有两个成员变量的
            System.out.println(field);
        }
        System.out.println("================");
        Field a = personClass.getField("a");
        System.out.println(a);//public java.lang.String com.liujinhui.Day1209BaseEnhance.domain.Person.a
        Person p = new Person();
        Object value = a.get(p);//成员变量new之后是有初始值null的，局部变量没有初始值
        System.out.println(value);
        //设置a的值
        a.set(p,"张三");
        System.out.println(p);//Person{name='null', age=0, a='张三', b='null', c='null', d='null'}
        System.out.println("================");
        //Field[] getDeclaredFields()
        Field[] declaredFields = personClass.getDeclaredFields();//获取所有的成员变量，不考虑修饰符
        for (Field declaredField : declaredFields) {
            System.out.println(declaredField);
        }
        /*
            private java.lang.String com.liujinhui.Day1209BaseEnhance.domain.Person.name
            private int com.liujinhui.Day1209BaseEnhance.domain.Person.age
            public java.lang.String com.liujinhui.Day1209BaseEnhance.domain.Person.a
            protected java.lang.String com.liujinhui.Day1209BaseEnhance.domain.Person.b
            java.lang.String com.liujinhui.Day1209BaseEnhance.domain.Person.c
            private java.lang.String com.liujinhui.Day1209BaseEnhance.domain.Person.d
        * */
        //Field getDeclaredField(String name)
        //使用非public修饰的变量时，需要忽略访问权限修饰符的安全检查
        Field d = personClass.getDeclaredField("d");
        d.setAccessible(true);//暴力反射
        Object value2 = d.get(p);//p是一个Person对象，根据成员变量找到对应的对象
        System.out.println(value2);//会抛异常
        //暴力反射后打印null
    }
}

5.反射_Class对象功能_获取Constructor

Constructor构造方法：

        创建对象

                    T newInstance(Object... initargs) 

                    如果使用空参数的构造方法创建对象，操作可以简化，简化到class对象中的T newInstance() 

                    Object o = personClass.newInstance();

package com.liujinhui.Day1209BaseEnhance.reflect;
import com.liujinhui.Day1209BaseEnhance.domain.Person;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
public class ReflectDemo3 {
    /*
    获取构造方法们Constructor[]
    Constructor<?>[] getConstructors()
    Constructor<T> getConstructor(Class<?>... parameterTypes)
    Constructor<?>[] getDeclaredConstructors()
    Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)
    * */
    public static void main(String[] args) throws Exception{
        //1.获取Person的Class对象
        Class personClass = Person.class;
        /*
            获取构造方法们Constructor[]
            Constructor<?>[] getConstructors()
            Constructor<T> getConstructor(Class<?>... parameterTypes)
            Constructor<?>[] getDeclaredConstructors()
            Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)
    * */
        Constructor constructor = personClass.getConstructor(String.class, int.class);
        System.out.println(constructor);//public com.liujinhui.Day1209BaseEnhance.domain.Person(java.lang.String,int)
        //创建对象
        Object person = constructor.newInstance("张三", 23);
        System.out.println(person);//Person{name='张三', age=23, a='null', b='null', c='null', d='null'}
        System.out.println("=============");
        //创建空参数的构造器
        Constructor constructor1 = personClass.getConstructor();
        constructor1.setAccessible(true);//也可以使用暴力反射
        Object person1 = constructor1.newInstance();
        System.out.println(person1);//Person{name='null', age=0, a='null', b='null', c='null', d='null'}
        //如果使用空参数的构造方法创建对象，操作可以简化，简化到class对象中的T newInstance()
        Object o = personClass.newInstance();
        System.out.println(o);
    }
}

6.反射_Class对象功能_获取Method方法对象

Method是成员方法

操作：

        执行方法Object invoke(Object obj, Object... args) 

        获取方法名称String getName()

package com.liujinhui.Day1209BaseEnhance.reflect;
import com.liujinhui.Day1209BaseEnhance.domain.Person;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class ReflectDemo4 {
    /*
   获取成员方法们Method[]
    Method[] getMethods()
    Method getMethod(String name, Class<?>... parameterTypes)
    Method[] getDeclaredMethods()
    Method getDeclaredMethod(String name, Class<?>... parameterTypes)
    * */
    public static void main(String[] args) throws Exception{
        //1.获取Person的Class对象
        Class personClass = Person.class;
         /*
           获取成员方法们Method[]
            Method[] getMethods()
            Method getMethod(String name, Class<?>... parameterTypes)获取指定名称的方法
            Method[] getDeclaredMethods()
            Method getDeclaredMethod(String name, Class<?>... parameterTypes)
        * */
        Method eat_method = personClass.getMethod("eat");
        //执行方法，传递对象
        Person p=new Person();
        eat_method.invoke(p);//执行p对象对应的eat方法
        //有参数方法
        Method eat_method2 = personClass.getMethod("eat", String.class);
        eat_method2.invoke(p,"饭");
        //获取所有public修饰的方法
        Method[] methods = personClass.getMethods();
        for (Method method : methods) {
            method.setAccessible(true);//也可以设置暴力反射
            System.out.println(method);//会打印父类隐藏的一些方法
            String name = method.getName();
            System.out.println(name);
        }
        //获取类名
        String className = personClass.getName();
        System.out.println(className);//打印全类名com.liujinhui.Day1209BaseEnhance.domain.Person
    }
}

7.反射_案例

需求：写一个“框架”，不能改变该类的任何代码前提下，可以创建任意类的对象并执行任意类的方法

实现

        1.配置文件

className=com.liujinhui.Day1209BaseEnhance.domain.Student
methodName=sleep

        2.反射

步骤

        1.将需要创建的对象的全类名和需要执行的方法定义在配置文件中

        2.在程序中加载读取配置文件

        3.使用反射技术来加载类文件进内存

        4.创建对象

        5.执行方法

package com.liujinhui.Day1209BaseEnhance.domain;

public class Student {
    public void sleep(){
        System.out.println("sleep...");
    }
}

package com.liujinhui.Day1209BaseEnhance.reflect;
import java.io.InputStream;
import java.lang.reflect.Method;
import java.util.Properties;
/*
    假设的框架类
    改配置文件使程序的扩展性更强，配置文件中使用了全类名，则使用了反射机制
* */
public class ReflectTest {
    /**
     * @author: Liu Jinhui
     * @description: 创建任意对象
     * @date: 2020/12/9 20:42
     * @return  * @param null
     */
    public static void main(String[] args) throws Exception{
        //可以创建任意类的对象，可以执行任意方法
        /*
            前提：不能改变该类的任何代码，可以创建任意类的对象，可以执行任意方法
        * */
        //1.加载配置文件
        //1.1.创建Properties对象
        Properties pro=new Properties();
        //1.2加载配置文件，转换为一个双列map集合
        //1.2.1获取class目录下配置文件的方式，使用类加载器完成
        ClassLoader classLoader = ReflectTest.class.getClassLoader();
        //得到该类下的配置文件流
        InputStream is = classLoader.getResourceAsStream("pro.properties");
        //加载属性流
        pro.load(is);
        //2.获取配置文件中定义的数据
        String className = pro.getProperty("className");
        String methodName = pro.getProperty("methodName");
        //3.加载该类进内存
        Class cls = Class.forName(className);
        //4.创建对象
        Object obj = cls.newInstance();
        //5.获取方法对象
        Method method = cls.getMethod(methodName);
        //6.执行方法
        method.invoke(obj);
    }
}

三、注解

1.注解_概念

注释：（单行多行文档）用文字描述程序，方便阅读，给程序员看的

注解：说明程序，给计算机看的

Java 注解(Annotation)又称 Java 标注,是 JDK5.0 引入的一种注释机制。 Java 语言中的类、方法、变量、参数和包等都可以被标注。

概念描述：jdk1.5之后，用于说明程序

使用注解：@注解名称

作用分类：

（1）编译检查【Override】

（2）编写文档【生成doc文档】

通过代码里表示的注解生成doc文档

package com.liujinhui.Day1209BaseEnhance.annotation;
/**
 * @author ljh
 * @version 1.0
 * @since 1.5
 */
public class AnnoDemo1 {
    /**
     *计算两个数的和
     * @param a 整数
     * @param b 整数
     * @return 两数的和
     */
    public int add(int a,int b){
        return a+b;
    }
}

有乱码https://blog.csdn.net/qq_44666176/article/details/99732522

（3）代码分析：通过代码里标识的注解对代码进行分析【使用反射】

学习

• Java中预定义的一些注解
• 自定义注解
• 在程序中使用（解析）注解

2.注解_JDK内置注解

@Override - 检查该方法是否是重写方法。如果发现其父类，或者是引用的接口中并没有该方法时，会报编译错误。【检查是否继承自父类】

@Deprecated - 标记过时方法。如果使用该方法，会报编译警告。【表示该注解的内容已过时】

date推荐使用日历类

@SuppressWarnings - 指示编译器去忽略注解中声明的警告。【压制警告，一般传递参数all】

@SuppressWarnings("all")

package com.liujinhui.Day1209BaseEnhance.annotation;

import java.util.Date;

/**
 *
 * JDK内置注解
     @Override - 检查该方法是否是重写方法。如果发现其父类，或者是引用的接口中并没有该方法时，会报编译错误。【检查是否继承自父类】
     @Deprecated - 标记过时方法。如果使用该方法，会报编译警告。【表示该注解的内容已过时】
     @SuppressWarnings - 指示编译器去忽略注解中声明的警告。【压制警告】
 */
@SuppressWarnings("all")//压制此类的所有警告
public class AnnoDemo2 {
    //表示该类是继承自父类后重写的类，而不是自定义类，更安全
    @Override
    public String toString(){
        return super.toString();
    }
    //标注已过时
    @Deprecated
    public void show1(){
        //有缺陷
    }
    @SuppressWarnings("all")//压制show2的警告
    public void show2(){
        //替代show1方法
    }
    public void demo(){
        show1();
        Date date=new Date();
    }
}

3.注解_自定义注解_格式&本质

3.1格式分两部分

      元注解

       public @interface 注解名称(){

            属性列表

}

反编译看注解的功能

3.2本质：注解本质上是一个接口，该接口默认继承Annotation 接口

public interface MyAnno extends java.lang.annotation.Annotation {

}

Annotation 接口

所有注释类型扩展的公共接口，手动扩展这个接口不限定注释类型，此接口本身并不定义注释类型。

3.3属性：接口中可以定义的成员方法

4.注解_自定义注解_属性定义

属性：接口中的抽象方法

    要求

        1.属性的返回值类型只允许下列取值（没有void）

                    基本数据类型    

                    String

                    枚举

                    注解

                    以上类型的数组

package com.liujinhui.Day1209BaseEnhance.annotation;

public enum Person {
    p1,p2;
}

package com.liujinhui.Day1209BaseEnhance.annotation;
public @interface MyAnno {
    int show1();
    String show2();
    Person per();
    MyAnno2 anno2();
    String[] show3();
}

        2.定义了属性，在使用时需要给属性赋值

                    如果定义属性时，使用default关键字给属性默认初始化值，则使用注解时可以不进行属性的赋值，取默认值

                    如果只有一个属性需要赋值，且该属性名为value，可直接写值，不写value

package com.liujinhui.Day1209BaseEnhance.annotation;
public @interface MyAnno {
    int age();
   String name() default "张三";
    Person per();
    MyAnno2 anno2();
    String[] show3();
}

  @MyAnno(age = 1,name="张三")//所以称为属性
    public void demo(){
        show1();
        Date date=new Date();
    }

则@SuppressWarnings("all")的属性肯定是value

                数组赋值时，值使用｛｝包裹，如果数组中只有一个值，｛｝可以省略

5.注解_自定义注解_元注解

5.1介绍用于描述注解的注解

@Target(ElementType.METHOD)//作用位置：方法
@Retention(RetentionPolicy.SOURCE)//能被保留到什么阶段：Source源码阶段
public @interface ZJName {
}

@Target：描述注解能够作用的位置

                @Target(value = {ElementType.TYPE})//表示该Anno3注解可以作用于类上

                @Target(value = {ElementType.METHOD})//表示该Anno3注解可以作用于方法上

                @Target(value = {ElementType.FIELD})//表示该Anno3注解可以作用于成员变量上

                @Target(value = {ElementType.TYPE,ElementType.FIELD,ElementType.METHOD})

@Retention：描述注解被保留的阶段（Source/Class/Runtime）

     @Retention(RetentionPolicy.RUNTIME)当前被描述的注解，会保留到class字节码文件中，并被JVM读取到

@Documented：描述 注解是否被抽取到API文档中

@Inherited：描述注解是否被子类继承，加注解后，子类会自动继承父类的注解

5.2使用

import java.lang.annotation.*;
@Target(value = {ElementType.TYPE,ElementType.FIELD,ElementType.METHOD})//表示该Anno3注解只能作用于类上
@Retention(RetentionPolicy.RUNTIME)
@Documented
//可以抽取到文档中
@Inherited
public @interface MyAnno3 {
}

6.注解_解析注解（注解属性值的获取/注解解析）

解析注解：获取注解中定义的属性值

步骤：    

        1.获取注解定义的位置的对象（Class,Method,Field）

        2.获取指定注解

                getAnnotation(Class)

 //其实就是在内存中生成了一个该注解接口的子类实现对象

            public class ProIMpl implements Pro{

                   public String className(){

                        return "com.liujinhui.Day1209BaseEnhance.annotation.Demo1";

                   }

                   public String methodName(){

                        return "show";

                   }

         3.调用注解中的抽象方法获取配置的属性值

package com.liujinhui.Day1209BaseEnhance.annotation;

public class Demo1 {
    public void show(){
        System.out.println("demo1 show");
    }
}

package com.liujinhui.Day1209BaseEnhance.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/*
    描述需要执行的类名和方法名
 */
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface Pro {
    String className();
    String methodName();
}
/*
    public class ProIMpl implements Pro{
           public String className(){
                return  "com.liujinhui.Day1209BaseEnhance.annotation.Demo1";
           }
           public String methodName(){
                return "show";
           }

 */

package com.liujinhui.Day1209BaseEnhance.annotation;
import java.io.InputStream;
import java.lang.reflect.Method;
import java.util.Properties;
/*
    假设的框架类
    改配置文件使程序的扩展性更强，配置文件中使用了全类名，则使用了反射机制
* */
@Pro(className = "com.liujinhui.Day1209BaseEnhance.annotation.Demo1",methodName = "show")
//要写全类名
public class ReflectTest {
    /**
     * @author: Liu Jinhui
     * @description: 创建任意对象
     * @date: 2020/12/9 20:42
     * @return  * @param null
     */
    public static void main(String[] args) throws Exception{
        //可以创建任意类的对象，可以执行任意方法
        /*
            前提：不能改变该类的任何代码，可以创建任意类的对象，可以执行任意方法
        * */
        //1.解析注解
        //1.1获取该类的字节码文件对象
        Class<ReflectTest> reflectTestClass = ReflectTest.class;
        //2.获取上面的注解对象
        //method也有getAnno
        Pro an = reflectTestClass.getAnnotation(Pro.class);
        //其实就是在内存中生成了一个该注解接口的子类实现对象
        /*
            public class ProIMpl implements Pro{
                   public String className(){
                        return  "com.liujinhui.Day1209BaseEnhance.annotation.Demo1";
                   }
                   public String methodName(){
                        return "show";
                   }
         */
        //3.调用注解对象中调用的抽象方法，获取返回值
        String className = an.className();
        String methodName = an.methodName();
        System.out.println(className+methodName);
        //4.加载该类进内存
        Class cls = Class.forName(className);
        //5.创建对象
        Object obj = cls.newInstance();
        //6.获取方法对象
        Method method = cls.getMethod(methodName);
        //7.执行方法
        method.invoke(obj);
    }
}

7.注解_案例_简单的测试框架

package com.liujinhui.Day1209BaseEnhance.annotation.demo;

/**
 * 小明定义的计算器类
 * 需要测试是否有错误
 */
public class Calculator {
    //加法
    @Check
    public void add(){
        System.out.println("1+0="+(1+0));
    }
    //减法
    @Check
    public void sub(){
        System.out.println("1 - 0 ="+(1 - 0));
    }
    //乘法
    @Check
    public void mul(){
        System.out.println("1*0="+(1*0));
    }
    //除法
    @Check
    public void div(){
        System.out.println("1/0="+(1/0));
    }
    //结果
    public void show(){
        System.out.println("永无bug...");
    }
}

package com.liujinhui.Day1209BaseEnhance.annotation.demo;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(value = {ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface Check {
}

package com.liujinhui.Day1209BaseEnhance.annotation.demo;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**
 * 简单的测试框架
 * 当主方法执行后，会自动执行被检测的所有方法（加了@Check的方法）
 * 判断方法是否有异常，并记录到文件中
 */
public class TestCheck {
    public static void main(String[] args) throws IOException {
        //1.创建计算器对象
        Calculator c = new Calculator();
        //2.获取字节码文件对象
        Class cls = c.getClass();
        //3.获取所有的方法
        Method[] methods = cls.getMethods();
        int number=0;//记录异常出现的次数
        BufferedWriter bw=new BufferedWriter(new FileWriter("bug.txt"));
        for (Method method : methods) {
            //4.判断方法上是否有check注解
            if (method.isAnnotationPresent(Check.class)) {
                //判断当前方法上有无指定注解
                //5.有就执行该方法
                try {
                    method.invoke(c);
                } catch (Exception e) {
                    //6.捕获异常
                    number++;
                    //记录到文件中
                    bw.write(method.getName() + "方法出异常了");
                    bw.newLine();
                    bw.write("异常的名称：" + e.getCause().getClass().getSimpleName());
                    bw.newLine();
                    bw.write("异常的原因：" + e.getCause().getMessage());
                    bw.newLine();
                    bw.write("-----------------------");
                }
            }
        }
        bw.write("本次测试共出现"+ number +"次异常");
        bw.flush();
        bw.close();
    }
}

小结：

    1.以后大多数时候，会使用注解而不是自定义注解

    2.注解给谁用？

            给编译器解析程序用(TestCheck)

    3.注解不是程序的一部分，相当于程序的标签

来自为知笔记(Wiz)