第1章 Junit单元测试

  • 测试分类:
    • 黑盒测试:不需要写代码,给输入值,看程序是否能够输出期望的值。
    • 白盒测试:需要写代码的。关注程序具体的执行流程。

1.1 Junit介绍

​ Junit是一个Java语言的单元测试框架,属于白盒测试,简单理解为可以用于取代java的main方法。Junit属于第三方工具,需要导入jar包后使用。

1.2 Junit的使用

  1. 编写测试类,简单理解Junit可以用于取代java的main方法
  2. 在测试类方法上添加注解 @Test
  3. @Test修饰的方法要求:public void 方法名() {…} ,方法名自定义建议test开头,没有参数。
  4. 添加Junit库到lib文件夹中,然后进行jar包关联
  5. 使用:点击方法左侧绿色箭头,执行当前方法(方法必须标记@Test)。执行结果红色:代表失败;执行结果
    绿色:代表成功

1.3 常用注解

  • @Test,用于修饰需要执行的测试方法
  • @Before,修饰的方法会在测试方法之前被自动执行
  • @After,修饰的方法会在测试方法执行之后自动被执行

第2章 反射:框架设计的灵魂

  • 框架:半成品软件。可以在框架的基础上进行软件开发,简化编码
  • 反射:将java代码的各个组成部分封装为其他对象,可以在程序运行过程中操作这些对象,这就是java的反射
    机制,如下图。
  • 反射的好处:
    1. 可以在程序运行过程中,操作这些对象。
    2. 可以解耦,提高程序的可扩展性。

2.1 获取Class对象的方式

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

2.2 获取Class对象的信息

​ 知道怎么获取Class对象之后,接下来就介绍几个Class类中常用的方法了。

Class对象相关方法

  1.  
String getSimpleName(); 获得简单类名,只是类名,没有包
  1.  
String getName(); 获取完整类名,包含包名+类名
  1.  
T newInstance() ;创建此 Class 对象所表示的类的一个新实例。要求:类必须有public的无参数构造方法

编写代码演示:
1.获取简单类名、获取完成类名
2.创建对象

2.3 Constructor类

​ Constructor是构造方法类,类中的每一个构造方法都是Constructor的对象,通过Constructor对象可以实例化对象。

Class类中与Constructor相关方法

  1. Constructor getConstructor(Class... parameterTypes)
    根据参数类型获取构造方法对象,只能获得public修饰的构造方法。
    如果不存在对应的构造方法,则会抛出 java.lang.NoSuchMethodException 异常。
  2. Constructor getDeclaredConstructor(Class... parameterTypes)
    根据参数类型获取构造方法对象,包括private修饰的构造方法。
    如果不存在对应的构造方法,则会抛出 java.lang.NoSuchMethodException 异常。
  3. Constructor[] getConstructors()
    获取所有的public修饰的构造方法
  4. Constructor[] getDeclaredConstructors()
    获取所有构造方法,包括privat修饰的

Constructor类中常用方法

  1. T newInstance(Object... initargs)
    根据指定参数创建对象。
  2. void setAccessible(true)
    暴力反射,设置为可以直接访问私有类型的构造方法。

2.4 Method类

​ Method是方法类,类中的每一个方法都是Method的对象,通过Method对象可以调用方法。

Class类中与Method相关方法

  1. Method getMethod("方法名", 方法的参数类型... 类型)
    根据方法名和参数类型获得一个方法对象,只能是获取public修饰的
  2. Method getDeclaredMethod("方法名", 方法的参数类型... 类型)
    根据方法名和参数类型获得一个方法对象,包括private修饰的
  3. Method[] getMethods()
    获取所有的public修饰的成员方法,包括父类中。
  4. Method[] getDeclaredMethods()
    获取当前类中所有的方法,包含私有的,不包括父类中。

Method类中常用方法

  1. Object invoke(Object obj, Object... args)
    根据参数args调用对象obj的该成员方法
    如果obj=null,则表示该方法是静态方法
  2. void setAccessible(boolean flag)
    暴力反射,设置为可以直接调用私有修饰的成员方法

2.5 反射案例

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

  1. 配置文件
  2. 反射

步骤:

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

编写代码演示
pro.properties

className=com.itheima.domain.Student
methodName=sleep

Student.java

package com.itheima.domain;
public class Student {
    public void sleep(){
    	System.out.println("sleep...");
    }
}

RefectTest.java

public class ReflectTest {
    @Test
    public void test() throws Exception {
        //可以创建任意类的对象,可以执行任意方法
        //前提:不能改变该类的任何代码。可以创建任意类的对象,可以执行任意方法
        //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);
    }
}

第3章 注解

3.1 注解概述

定义:注解(Annotation),也叫元数据。一种代码级别的说明。它是JDK1.5及以后版本引入的一个特性,与类、
接口、枚举是在同一个层次。它可以声明在包、类、字段、方法、局部变量、方法参数等的前面,用来对这些元素
进行说明,注释。

作用分类:

  • 编写文档:通过代码里标识的注解生成文档【例如,生成文档doc文档】
  • 代码分析:通过代码里标识的注解对代码进行分析【例如,注解的反射】
  • 编译检查:通过代码里标识的注解让编译器能够实现基本的编译检查【例如,Override】

常见注解

  1. @author:用来标识作者名
  2. @version:用于标识对象的版本号,适用范围:文件、类、方法。
  3. @Override :用来修饰方法声明,告诉编译器该方法是重写父类中的方法,如果父类不存在该方法,则编译
    失败。

3.2 自定义注解

定义格式

元注解
public @interface 注解名称{
	属性列表;
}
  • 注解本质上就是一个接口,该接口默认继承Annotation接口
public interface MyAnno extends java.lang.annotation.Annotation {}

注解的属性

  1. 属性的作用
    可以让用户在使用注解时传递参数,让注解的功能更加强大。
  2. 属性的格式
    格式1:数据类型 属性名();
    格式2:数据类型 属性名() default 默认值;
  3. 属性定义示例
public @interface Student {
    String name(); // 姓名
    int age() default 18; // 年龄
    String gender() default "男"; // 性别
}
// 该注解就有了三个属性:name,age,gender
  1. 属性适用的数据类型
    八种基本数据类型(int,float,boolean,byte,double,char,long,short)
    String类型,Class类型,枚举类型,注解类型
    以上所有类型的一维数组

3.3 使用自定义注解

在程序中使用(解析)注解的步骤(获取注解中定义的属性值):

  1. 获取注解定义的位置的对象 (Class,Method,Field)
  2. 获取指定的注解 getAnnotation(Class)
  3. 调用注解中的抽象方法获取配置的属性值

定义注解

  1. 定义一个注解:Book
  • 包含属性:String value() 书名
  • 包含属性:double price() 价格,默认值为 100
  • 包含属性:String[] authors() 多位作者
  1. 代码实现
public @interface Book {
    // 书名
    String value();
    // 价格
    double price() default 100;
    // 多位作者
    String[] authors();
}

使用注解

  1. 定义类在成员方法上使用Book注解
/**
* @author itheima
* @version 1.0
*/
public class BookShelf {
    @Book(value = "西游记",price = 998,authors = {"吴承恩","白求恩"})
    public void showBook(){
    }
}
  1. 使用注意事项
  • 如果属性有默认值,则使用注解的时候,这个属性可以不用赋值。
  • 如果属性没有默认值,那么在使用注解时一定要给属性赋值。

特殊属性value

  1. 当注解中只有一个属性且名称是value,在使用注解时给value属性赋值可以直接给属性值,无论value是单
    值元素还是数组类型。
// 定义注解Book
public @interface Book {
    // 书名
    String value();
}
// 使用注解Book
public class BookShelf {
    @Book("西游记")
    public void showBook(){
    }
}
或
public class BookShelf {
    @Book(value="西游记")
    public void showBook(){
    }
}
  1. 如果注解中除了value属性还有其他属性,且至少有一个属性没有默认值,则在使用注解给属性赋值时,
    value属性名不能省略。
// 定义注解Book
public @interface Book {
    // 书名
    String value();
    // 价格
    double price() default 100;
    // 多位作者
    String[] authors();
}
// 使用Book注解:正确方式
@Book(value="红楼梦",authors = "曹雪芹")
public class BookShelf {
// 使用Book注解:正确方式
    @Book(value="西游记",authors = {"吴承恩","白求恩"})
    public void showBook(){
    }
}
// 使用Book注解:错误方式
public class BookShelf {
	@Book("西游记",authors = {"吴承恩","白求恩"})
    public void showBook(){
    }
}
// 此时value属性名不能省略了。

3.4 注解之元注解

默认情况下,注解可以用在任何地方,比如类,成员方法,构造方法,成员变量等地方。如果要限制注解的使用位
置怎么办?那就要学习一个新的知识点:元注解。
@Target
@Retention

元注解之@Target

  • 作用:指明此注解用在哪个位置,如果不写默认是任何地方都可以使用。
    • 可选的参数值在枚举类ElemenetType中包括:
TYPE: 用在类,接口上
FIELD:用在成员变量上
METHOD: 用在方法上
PARAMETER:用在参数上
CONSTRUCTOR:用在构造方法上
LOCAL_VARIABLE:用在局部变量上

元注解之@Retention

  • 作用:定义该注解的生命周期(有效范围)。
    • 可选的参数值在枚举类型RetentionPolicy中包括
SOURCE:注解只存在于Java源代码中,编译生成的字节码文件中就不存在了。
CLASS:注解存在于Java源代码、编译以后的字节码文件中,运行的时候内存中没有,默认值。
RUNTIME:注解存在于Java源代码中、编译以后的字节码文件中、运行时内存中,程序可以通过反射获取该注解。

元注解使用示例

@Target({ElementType.METHOD,ElementType.TYPE})
@interface Stu{
	String name();
}
// 类
@Stu(name="jack")
public class AnnotationDemo02 {
    // 成员变量
    @Stu(name = "lily") // 编译失败
    private String gender;
    // 成员方法
    @Stu(name="rose")
    public void test(){
    }
    // 构造方法
    @Stu(name="lucy") // 编译失败
    public AnnotationDemo02(){}
}

3.5 注解解析

什么是注解解析

通过Java技术获取注解数据的过程则称为注解解析。

与注解解析相关的接口

  • Anontation:所有注解类型的公共接口,类似所有类的父类是Object。
  • AnnotatedElement:定义了与注解解析相关的方法,常用方法以下四个:
boolean isAnnotationPresent(Class annotationClass); 判断当前对象是否有指定的注解,有则返回true,否则
返回false。
T getAnnotation(Class<T> annotationClass); 获得当前对象上指定的注解对象。
Annotation[] getAnnotations(); 获得当前对象及其从父类上继承的所有的注解对象。
Annotation[] getDeclaredAnnotations();获得当前对象上所有的注解对象,不包括父类的。

获取注解数据的原理

注解作用在那个成员上,就通过反射获得该成员的对象来得到它的注解。

  • 如注解作用在方法上,就通过方法(Method)对象得到它的注解
// 得到方法对象
Method method = clazz.getDeclaredMethod("方法名");
// 根据注解名得到方法上的注解对象
Book book = method.getAnnotation(Book.class);
  • 如注解作用在类上,就通过Class对象得到它的注解
// 获得Class对象
Class c = 类名.class;
// 根据注解的Class获得使用在类上的注解对象
Book book = c.getAnnotation(Book.class);

使用反射获取注解的数据

需求说明
  1. 定义注解Book,要求如下:
    • 包含属性:String value() 书名
    • 包含属性:double price() 价格,默认值为 100
    • 包含属性:String[] authors() 多位作者
    • 限制注解使用的位置:类和成员方法上
    • 指定注解的有效范围:RUNTIME
  2. 定义BookStore类,在类和成员方法上使用Book注解
  3. 定义TestAnnotation测试类获取Book注解上的数据
代码实现

注解Book

@Target({ElementType.METHOD,ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface Book {
    // 书名
    String value();
    // 价格
    double price() default 100;
    // 作者
    String[] authors();
}

BookStore类

@Book(value = "红楼梦",authors = "曹雪芹",price = 998)
public class BookStore {
    @Book(value = "西游记",authors = "吴承恩")
    public void buyBook(){
    }
}

TestAnnotation类

public class TestAnnotation {
    public static void main(String[] args) throws Exception{
        System.out.println("---------获取类上注解的数据----------");
        test01();
        System.out.println("---------获取成员方法上注解的数据----------");
        test02();
    }
    /**
    * 获取BookStore类上使用的Book注解数据
    */
    public static void test01(){
        // 获得BookStore类对应的Class对象
        Class c = BookStore.class;
        // 判断BookStore类是否使用了Book注解
        if(c.isAnnotationPresent(Book.class)) {
            // 根据注解Class对象获取注解对象
            Book book = (Book) c.getAnnotation(Book.class);
            // 输出book注解属性值
            System.out.println("书名:" + book.value());
            System.out.println("价格:" + book.price());
            System.out.println("作者:" + Arrays.toString(book.authors()));
        }
    }
    /**
    * 获取BookStore类成员方法buyBook使用的Book注解数据
    */
    public static void test02() throws Exception{
        // 获得BookStore类对应的Class对象
        Class c = BookStore.class;
        // 获得成员方法buyBook对应的Method对象
        Method m = c.getMethod("buyBook");
        // 判断成员方法buyBook上是否使用了Book注解
        if(m.isAnnotationPresent(Book.class)) {
            // 根据注解Class对象获取注解对象
            Book book = (Book) m.getAnnotation(Book.class);
            // 输出book注解属性值
            System.out.println("书名:" + book.value());
            System.out.println("价格:" + book.price());
            System.out.println("作者:" + Arrays.toString(book.authors()));
        }
    }
}

输出结果:

-------获取类上注解的数据-------

书名: 红楼梦

价格: 998.0

作者: [曹雪芹]

-------获取成员方法上注解的数据-------

书名: 西游记

价格: 100.0

作者: [吴承恩]

3.6 注解案例

案例说明

模拟Junit测试的@Test

案例分析

  1. 模拟Junit测试的注释@Test,首先需要编写自定义注解@MyTest,并添加元注解,保证自定义注解只能修饰
    方法,且在运行时可以获得。
  2. 然后编写目标类(测试类),然后给目标方法(测试方法)使用 @MyTest注解,编写三个方法,其中两个加
    上@MyTest注解。
  3. 最后编写调用类,使用main方法调用目标类,模拟Junit的运行,只要有@MyTest注释的方法都会运行。

案例代码

注解MyTest
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyTest {
}
目标类MyTestDemo
public class MyTestDemo {
    @MyTest
    public void test01(){
    	System.out.println("test01");
    }
    public void test02(){
    	System.out.println("test02");
    }
    @MyTest
    public void test03(){
    	System.out.println("test03");
    }
}

调用类TestMyTest

public class TestMyTest {
    public static void main(String[] args) throws Exception{
        // 获得MyTestDemo类Class对象
        Class c = MyTestDemo.class;
        // 获得所有的成员方法对象
        Method[] methods = c.getMethods();
        // 创建MyTestDemo类对象
        Object obj = c.newInstance();
        // 遍历数组
        for (Method m:methods) {
            // 判断方法m上是否使用注解MyTest
            if(m.isAnnotationPresent(MyTest.class)){
                // 执行方法m
                m.invoke(obj);
            }
        }
    }
}

输出结果:

test01

test03