java的注解和反射

01_基础加强笔记

内容

1. Junit单元测试
2. 反射
3. 注解

第一章.Junit单元测试

1.测试分类

1.黑盒测试

不需要写代码，给输入值，看程序是否能够输出期望的值

2.白盒测试

需要写代码，关注程序具体的执行流程

第二章.Junit使用：白盒测试

1.步骤

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

   建议：

   • 测试类名：被测试的类名+Test 如AddTest
   • 包名：xxx.xxx.xxx.test

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

   建议：

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

3. 给方法加@Test

   注意：

4. 导入Junit以来环境

2.判定结果

• 红色：失败
• 绿色：成功
• 一般我们会使用断言操作来处理结果
  • Assert.assertEquals(期望的结果，运行结果);

3.补充

• @Before：修饰的方法会在测试方法前被自动执行
• @After：修饰的方法会在测试的方法执行之后自动执行

第三章.反射：框架设计的灵魂

1.框架

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

2.反射

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

好处

1. 可以在程序运行的过程中，操作这些对象
2. 可以解耦（降低程序的耦合性，一些紧密程度），提高程序的可扩展性

获取class对象的方式

1. Class.forname("全类名")：将字节码文件加载进内存，返回class对象
   • 多用于配置文件，将类名定义在配置文件中。读取文件，加载类
2. 类名.class: 通过类名的属性class获取
   • 多用于参数的传递
3. 对象.getClass()：getClass() 方法在Object类中定义着
   • 多用于对象的获取字节码的方式

结论

同一个字节码文件(*.class)在一次程序运行过程中，只会被加载一次，不论通过哪一种方式获取class对象都是同一个

注意

使用的时候要在IDEA当前文件夹下新建文件夹 导包第三方的

public class Calculator {
    /**
     * 加法
     * @param a
     * @param b
     * @return
     */
    public int add(int a,int b){
        return a+b;
    }

    /**
     * 减法
     * @param a
     * @param b
     * @return
     */
    public int sub(int a,int b){
        return a-b;
    }

}

测试类

public class CalcilattorTest {
    /**
     * 测试add方法
     */
    @Test
    public void testAdd(){
        // 1.创建计算器对象
        Calculator c = new Calculator();
        // 2.调用add方法
        int add = c.add(1, 3);
        // 3.断言  我判断这个结果的值
        Assert.assertEquals(4,add);
    }
    @Test
    public void testSub(){
        // 1.创建计算器对象
        Calculator ca = new Calculator();
        int sub = ca.sub(1, 3);
        Assert.assertEquals(-1,sub);

    }
}

3.class对象功能

1.获取功能

1.获取成员变量们

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

• Field getField(String name) 获取指定名称的 public修饰的成员变量

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

• Field getDeclaredField(String name)

  返回一个 Field 对象，该对象反映此 Class 对象所表示的类或接口的指定已声明字段。

注意

Field：成员变量

操作

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

2. 获取值 get(Object obj)

3. 忽略访问权限修饰符的安全检查 setAccessible(true):暴力反射

   Field d = personClass.getDeclaredField("d");
           // 忽略访问权限修饰符的安全检查
           d.setAccessible(true);// 暴力反射
           Object value2 = d.get(p);
           System.out.println(value2);
   

2.获取构造方法们

• Constructor<?>[] getConstructors()

  返回一个包含某些 Constructor 对象的数组，这些对象反映此 Class 对象所表示的类的所有公共构造方法。

• Constructor getConstructor(类<?>... parameterTypes)

  返回一个 Constructor 对象，该对象反映此 Class 对象所表示的类或接口的指定构造方法。

• Constructor getDeclaredConstructor(类<?>... parameterTypes)

  返回一个 Constructor 对象，该对象反映此 Class 对象所表示的类或接口的指定构造方法。

• Constructor<?>[] getDeclaredConstructors()

  返回 Constructor 对象的一个数组，这些对象反映此 Class 对象表示的类声明的所有构造方法。

Constructor:构造方法

创建对象： T newInstance(Object... initargs)

如果使用空参数构造方法创建对象，操作可以简化：Class对象的newInstance方法

3.获取成员方法们

• Method[] getMethods()

  返回一个包含某些 Method 对象的数组，这些对象反映此 Class 对象所表示的类或接口（包括那些由该类或接口声明的以及从超类和超接口继承的那些的类或接口）的公共 member 方法。

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

  返回一个 Method 对象，它反映此 Class 对象所表示的类或接口的指定公共成员方法。

• Method[] getDeclaredMethods()

  返回 Method 对象的一个数组，这些对象反映此 Class 对象表示的类或接口声明的所有方法，包括公共、保护、默认（包）访问和私有方法，但不包括继承的方法。

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

  返回一个 Method 对象，该对象反映此 Class 对象所表示的类或接口的指定已声明方法

Method：方法对象

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

获取方法名称：String getName:获取方法名

4. 获取全类名

• String getName()

  以 String 的形式返回此 Class 对象所表示的实体（类、接口、数组类、基本类型或 void）名称。

案例

需求：写一个"框架"，不能改变该类的任何代码的前提下，可以帮我们创建任意类的对象，并且执行其中任意方法

实现：
1. 配置文件
2. 反射

步骤：

1. 将需要创建的对象的全类名和需要执行的方法定义在配置文件中
   2. 在程序中加载读取配置文件
   3. 使用反射技术来加载类文件进内存
   4. 创建对象
   5. 执行方法

示例代码

定义一个File配置文件

className = domain.Person
methodName = eat

public class ReflectTest {
    public static void main(String[] args) throws Exception {
        // 可以创建任意类的对象，可以执行任意方法
        /*
            前提：不能改变该类的任何代码，可以创建任意类对象，可以执行人和方法
         */
        /*Person p = new Person();
        p.eat();*/

        // 1.加载配置文件
        // 1.1创建Properties对象
        Properties pro = new Properties();
        // 1.2加载配置文件，转换为一个集合
        // 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.概念

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

注释：用文字描述程序。给程序员看的

2.定义

注解（Annotation），也叫元数据。一种代码级别的说明。它是JDK1.5及以后版本引入的一个特性，与类、接口、枚举是在同一个层次。它可以声明在包、类、字段、方法、局部变量、方法参数等的前面，用来对这些元素进行说明，注释。从JDK5开始,Java增加对元数据的支持，也就是注解，注解与注释是有一定区别的，可以把注解理解为代码里的特殊标记，这些标记可以在编译，类加载，运行时被读取，并执行相应的处理。通过注解开发人员可以在不改变原有代码和逻辑的情况下在源代码中嵌入补充信息。

概念描述

• JDK1.5之后的新特性
• 说明程序的
• 使用注解：@注解名称

作用分类

​ ①编写文档：通过代码里标识的注解生成文档【生成文档doc文档】
​ ②代码分析：通过代码里标识的注解对代码进行分析【使用反射】
​ ③编译检查：通过代码里标识的注解让编译器能够实现基本的编译检查【Override】

JDK中预定义的一些注解

• @Override ：检测被该注解标注的方法是否是继承自父类(接口)的

@Override
public String toString(){
    return super.toString();
}

• @Deprecated：该注解标注的内容，表示已过时

  @Deprecated
  public void show(){
      // 有缺陷
  }
  
  public void show02(){
      // 替代show方法
  }
  

• @SuppressWarnings：压制警告

  • 一般传递参数all @SuppressWarnings("all")

3.自定义注解

1.格式

元注解
public @interface 注解名称{
属性列表;
}

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

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

2.属性

属性：接口中的抽象方法

要求

1. 属性的返回值类型有下列取值
   • 基本数据类型
     • String
     • 枚举
     • 注解
     • 以上类型的数组
2. 定义了属性，在使用时需要给属性赋值
   1. 如果定义属性时，使用default关键字给属性默认初始化值，则使用注解时，可以不进行属性的赋值。
   2. 如果只有一个属性需要赋值，并且属性的名称是value，则value可以省略，直接定义值即可。
   3. 数组赋值时，值使用{}包裹。如果数组中只有一个值，则{}可以省略

3.元注解

用于描述注解的注解

• @Target：描述注解能够作用的位置
  • ElementType取值：
    • TYPE：可以作用于类上
    • METHOD：可以作用于方法上
    • FIELD：可以作用于成员变量上
• @Retention：描述注解被保留的阶段
  • @Retention(RetentionPolicy.RUNTIME)：当前被描述的注解，会保留到class字节码文件中，并被JVM读取到
    • @Documented：描述注解是否被抽取到api文档中
    • @Inherited：描述注解是否被子类继承

4.解析注解

在程序中（解析）注解

获取注解中定义的属性值

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

2. 获取指定的注解

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

   示例代码

   注解

   /**
    * 定义一个注解
    * 描述需要执行的类名，和方法名
    */
   // 直接可以做用于类上
   @Target({ElementType.TYPE})
   // 能够保留在RUNTIME阶段
   @Retention(RetentionPolicy.RUNTIME)
   public @interface Pro {
       String className();
       String methodName();
   
   }
   

   被调用的类和方法

   public class Demo01 {
       public void show(){
           System.out.println("demo01...show...");
       }
   }
   

   框架类

   /**
    * 框架类
    */
   @Pro(className = "jiexizhujie.Demo01",methodName = "show")
   public class ReflectTest {
       public static void main(String[] args) throws Exception {
           /*
               前提：不能改变该类的任何代码，可以创建任意类对象，可以执行任意方法
            */
           // 1.解析注解
           // 1.1获取该类的字节码文件对象
           Class<ReflectTest> reflectTestClass = ReflectTest.class;
           // 2.获取上边的注解对象
           // 其实就是内存中生成了一个该类注解接口的子类实现对象
            /*
           相当于
        public class ProImpl implements Pro{
        public String className();{
           return "jiexizhujie.Demo01";
           }
           public String methodName(){
           return "show";
           }
        }
        */
           Pro an = reflectTestClass.getAnnotation(Pro.class);
           // 3.调用注解对象中定义的抽象方法，获取返回值
           String className = an.className();
           String methodName = an.methodName();
           System.out.println(className);
           System.out.println(methodName);
           // 4.加载该类进内存
           Class cls = Class.forName(className);
           // 5.创建对象
           Object obj = cls.newInstance();
           // 6.获取对象方法
           Method method = cls.getMethod(methodName);
           // 7.执行方法
           method.invoke(obj);
   
       }
   }
   
   
   

案例

简单的测试框架

示例代码

测试的类

public class Calculator {
    // 加法
    @Check
    public void add(){
        String str = null;
        str.toString();
        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....");
    }
}

注解

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

测试框架

/**
 * 简单的框架测试
 *
 * 当方法执行后，会自动自行检测所有的方法（加了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.newLine();
                }
            }
        }
        bw.write("本次测试一共出现了："+number+"次异常");

        bw.flush();
        bw.close();
    }

}

运行结果

// 生成bug.txt
add方法异常了
异常的名称：NullPointerException
异常的原因：null
----------------------
div方法异常了
异常的名称：ArithmeticException
异常的原因：/ by zero
----------------------
本次测试一共出现了：2次异常

小结

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

2. 注解给谁用？

   1. 编译器
   2. 给解析程序用

3. 注解不是程序的一部分，可以理解为注解就是一个标签

图解