文章目录

1.JUnit测试
- 1.1 不用JUnit测试
- 1.2使用JUnit测试
2.反射
3.注解

1.JUnit测试

黑盒测试：只关注输入是否对应正确的输出，不需要写代码
白盒测试：关注代码内部的实现细节，需要写代码

1.1 不用JUnit测试

传统测试案例中使用main方法测试代码的正确性

package com.weeks.junit;

/**
 * 一个实体类
 */
public class Calculator {
    
    
    public int add(int a, int b){
    
    
        return a + b;
    }
    
    public int sub(int a, int b){
    
    
        return a - b;
    }
}

使用main方法测试

package com.weeks.junit;

/**
 * 测试类
 */
public class CalculatorTest {
    
    
    public static void main(String[] args) {
    
    
        //新建一个实体类对象
        Calculator calculator = new Calculator();
        //测试add方法
//        int result = calculator.add(3, 5);
        //测试sub方法
        int result = calculator.sub(5, 3);
        System.out.println(result);
    }
}

这种传统的测试方法的缺点很明显：就是在main方法中测试时为方法之间不互相影响就使用注释或者使用不同的变量名称测试不同的方法，使得代码的测试逻辑在别人看来很不清晰。为了解决这个问题可以使用JUnit。

1.2使用JUnit测试

引入JUnit单元测试，属于白盒测试
步骤：

定义一个测试类（测试用例），约定熟成的规则
- 测试类名：被测试的类名Test，CalculatorTest
- 包名：xxx.xxx.xx.test，com.weeks.test
定义测试方法：可以独立运行
给方法加上@Test注解
导入JUnit依赖环境

package com.weeks.test;

import com.weeks.junit.Calculator;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;

public class CalculatorTest {
    
    

    /**
     * 测试add方法
     */
    @Test
    public void testAdd(){
    
    
        Calculator calculator = new Calculator();
        int result = calculator.add(3, 5);
//        System.out.println(calculator.add(3, 5));
		//一般测试中很少使用输出作为测试结果，一般使用断言希望结果与测试结果是否一致
        Assert.assertEquals(8, result);
        System.out.println("testAdd...");
    }
}

判定结果
- 红色：失败
- 绿色：成功
- 一般会使用断言来处理结果：Assert.assertEquals(期望的结果, 运算的结果)
补充
- @Before:修饰的方法会在测试方法之前被自动执行
- @After:修饰的方法在测试方法执行之后自定被执行

package com.weeks.test;

import com.weeks.junit.Calculator;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;

public class CalculatorTest {
    
    

    /**
     * 初始化方法
     * 所有方法在执行之前执行init方法
     */
    @Before
    public void init(){
    
    
        System.out.println("init...");
    }

    /**
     * 关闭资源的方法
     * 在所有方法执行之后执行close方法
     */
    @After
    public void close(){
    
    
        System.out.println("close...");
    }
    /**
     * 测试add方法
     */
    @Test
    public void testAdd(){
    
    
        Calculator calculator = new Calculator();
        int result = calculator.add(3, 5);
//        System.out.println(calculator.add(3, 5));
        Assert.assertEquals(8, result);
        System.out.println("testAdd...");
    }
}

执行的结果是：

init...
testAdd...
close...

2.反射

2.1 反射的概念

要了解反射就要了解Java程序运行的三个阶段
在这里插入图片描述

反射就是将类的各个组成部分封装为其他对象。反射是框架设计的灵魂
框架是一种半成品的软件，可以在框架的基础上进行软件开发，简化编码
反射的好处：
- 可以在程序运行过程中操作这些对象
- 可以解藕，提高程序的可扩展性

2.2 获取Class对象的方式

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

package com.weeks.refection.domain;

/**
 * 一个实体类
 */
public class Person {
    
    
    private String name;
    private int age;

    public Person() {
    
    
    }

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

package com.weeks.refection.domain;

/**
 * 反射获取对象
 */
public class RefectionDemo {
    
    
    public static void main(String[] args) throws Exception {
    
    
        //反射获取Class对象的三种方法
        //1.Class.forName(全类名)
        Class cls1 = Class.forName("com.weeks.refection.domain.Person");
        System.out.println(cls1);
        //2.类名.class
        Class cls2 = Person.class;
        System.out.println(cls2);
        //3.对象.getClass()
        Person person = new Person();
        Class cls3 = person.getClass();
        System.out.println(cls3);

        //比较三个对象是否相等
        System.out.println(cls1 == cls2);
        System.out.println(cls1 == cls3);
    }
}

结果

class com.weeks.refection.domain.Person
class com.weeks.refection.domain.Person
class com.weeks.refection.domain.Person
true
true

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

2.3 Class对象功能

获取功能：
- 获取成员变量们
  - Field[] getFields() ：获取所有public修饰的成员变量
  - Field getField(String name) 获取指定名称的 public修饰的成员变量
  - Field[] getDeclaredFields() 获取所有的成员变量，不考虑修饰符
  - Field getDeclaredField(String name)
- 获取构造方法们
  - Constructor<?>[] getConstructors()
  - Constructor getConstructor(类<?>… parameterTypes)
  - Constructor getDeclaredConstructor(类<?>… parameterTypes)
  - Constructor<?>[] getDeclaredConstructors()
- 获取成员方法们：
  - Method[] getMethods()
  - Method getMethod(String name, 类<?>… parameterTypes)
  - Method[] getDeclaredMethods()
  - Method getDeclaredMethod(String name, 类<?>… parameterTypes)
- 获取全类名
  - String getName()

Field：成员变量
- 操作：
  - 设置值: void set(Object obj, Object value)
  - 获取值: get(Object obj)
  - 忽略访问权限修饰符的安全检查: setAccessible(true):暴力反射
Constructor:构造方法
- 创建对象：
  - T newInstance(Object… initargs)
  - 如果使用空参数构造方法创建对象，操作可以简化：Class对象的newInstance方法
Method：方法对象
- 执行方法：
  - Object invoke(Object obj, Object… args)

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

package com.weeks.refection;

import com.weeks.refection.domain.TestClassObject;
import org.junit.Test;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class RefectionDemo2 {
    
    

    //成员变量们
    @Test
    public void classGetFiles() throws Exception {
    
    
        //获取Class对象
        Class testClassObjectClass = TestClassObject.class;
        //1.getField()获取单个Class成员变量，只能获取public修饰的成员变量
        Field m_pub = testClassObjectClass.getField("m_pub");
        System.out.println(m_pub);
        //1.1.获取成员变量的两个目的就是获取值和设置值
        TestClassObject testClassObject = new TestClassObject();
        //获取值
        Object m_pub_value = m_pub.get(testClassObject);
        System.out.println(m_pub_value);
        //设置值
        m_pub.set(testClassObject, "public_value");
        System.out.println(m_pub.get(testClassObject));
        System.out.println("========================");

        //2.getFields()获取多个成员变量,也是只能获取public修饰成员变量
        Field[] fields = testClassObjectClass.getFields();
        for(Field field : fields){
    
    
            System.out.println(field);
        }
        System.out.println("========================");

        //3.getDeclaredField()获取private修饰的成员变量
        Field m_pri = testClassObjectClass.getDeclaredField("m_pri");
        //设置私有成员变量的值，注意先进行暴力反射后才能设置
        m_pri.setAccessible(true);//暴力反射
        m_pri.set(testClassObject, "private_value");
        System.out.println(m_pri.get(testClassObject));
        System.out.println("========================");

        //4.getDeclaredFields()获取所有的成员变量，包括私有成员变量
        Field[] declaredFields = testClassObjectClass.getDeclaredFields();
        for (Field field : declaredFields){
    
    
            System.out.println(field);
        }
    }

    //构造方法们
    @Test
    public void classGetConstructor() throws Exception {
    
    
        //获取Class对象
        Class<TestClassObject> testClassObjectClass = TestClassObject.class;
        //1.getConstructor()获取单个public修饰的构造方法
        Constructor<TestClassObject> csPublic = testClassObjectClass.getConstructor(String.class);
        //1.1.获取构造方法的目的就是创建变量
        TestClassObject testClassObject1 = csPublic.newInstance("m_pub");
        System.out.println(testClassObject1);
        System.out.println("=====================");

        //2.getConstructors()获取所有public修饰的构造方法
        Constructor<?>[] constructors = testClassObjectClass.getConstructors();
        for (Constructor constructor : constructors){
    
    
            System.out.println(constructor);
        }
        System.out.println("=====================");

        //3.获取private修饰的构造方法
        Constructor<TestClassObject> dcsPrivate = testClassObjectClass.getDeclaredConstructor(String.class, String.class, String.class, String.class);
        dcsPrivate.setAccessible(true);//需要暴力反射
        TestClassObject testClassObject2 = dcsPrivate.newInstance("m_pub", "m_pro", "m_def", "m_pri");
        System.out.println(testClassObject2);
        System.out.println("=====================");

        //4.获取所有构造方法
        Constructor<?>[] declaredConstructors = testClassObjectClass.getDeclaredConstructors();
        for(Constructor constructor : declaredConstructors){
    
    
            System.out.println(constructor);
        }
    }

    //成员方法们
    @Test
    public void classGetMethod() throws Exception {
    
    
        //获取Class对象
        Class<TestClassObject> testClassObjectClass = TestClassObject.class;
        //1.getMethod()获取单个public修饰的成员方法
        //1.1.无参
        Method publicMethod = testClassObjectClass.getMethod("publicMethod");
        //调用成员方法
        TestClassObject testClassObject = new TestClassObject();
        publicMethod.invoke(testClassObject);
        //1.2.有参
        Method publicMethodWithParam = testClassObjectClass.getMethod("publicMethod", String.class);
        publicMethodWithParam.invoke(testClassObject, "我是一个String类型的参数");
        System.out.println("=====================");

        //2.getMethods()获取所有public修饰的成员方法,包括父类的public方法
        Method[] methods = testClassObjectClass.getMethods();
        for (Method method : methods){
    
    
            System.out.println(method);
        }
        System.out.println("=====================");

        //3.getDeclaredMethod()获取单个私有成员方法
        Method privateMethod = testClassObjectClass.getDeclaredMethod("privateMethod");
        privateMethod.setAccessible(true);//需要暴力反射
        privateMethod.invoke(testClassObject);
        System.out.println("=====================");

        //4.获取所有成员方法，包括父类的方法
        Method[] declaredMethods = testClassObjectClass.getDeclaredMethods();
        for (Method method : declaredMethods){
    
    
            System.out.println(method);
        }
    }

    //获取类名
    @Test
    public void classGetClassName(){
    
    
        //获取Class对象
        Class<TestClassObject> testClassObjectClass = TestClassObject.class;
        //获取类名
        String className = testClassObjectClass.getName();

        System.out.println(className);
    }
}

2.4 案例：

需求：写一个"框架"，不能改变该类的任何代码的前提下，可以帮我们创建任意类的对象，并且执行其中任意方法
- 实现：
  - 配置文件
  - 反射
- 步骤：
  - 将需要创建的对象的全类名和需要执行的方法定义在配置文件中
  - 在程序中加载读取配置文件
  - 使用反射技术来加载类文件进内存
  - 创建对象
  - 执行方法

package com.weeks.refection.domain;

public class Student {
    
    
    public void learning(){
    
    
        System.out.println("正在学习");
    }
}

package com.weeks.refection.domain;

public class Teacher {
    
    
    public void teaching(){
    
    
        System.out.println("正在教学");
    }
}

通过该配置文件改变需要加载的类和方法

className=com.weeks.refection.domain.Student
methodName=learning

className=com.weeks.refection.domain.Teacher
methodName=teaching

package com.weeks.refection;

import java.io.InputStream;
import java.lang.reflect.Method;
import java.util.Properties;

/**
 * 框架类，在不改变源代码的前提下，创建任意类的实例对象
 * 调用创建类实例对象的方法
 */
public class RefectionFrameDemo {
    
    
    public static void main(String[] args) throws Exception {
    
    
        //1.将需要创建的对象的全类名和需要执行的方法定义在配置文件中
        //2.使用加载配置文件，通过类加载器和properties
        ClassLoader classLoader = RefectionFrameDemo.class.getClassLoader();
        InputStream is = classLoader.getResourceAsStream("pro.properties");
        Properties properties = new Properties();
        properties.load(is);
        String className = (String) properties.get("className");
        String methodName = (String) properties.get("methodName");

        //3.使用反射技术来加载文件进内存
        Class<?> aClass = Class.forName(className);
        //4.创建对象
        Object instance = aClass.newInstance();
        //5.获取方法执行方法
        Method method = aClass.getMethod(methodName);
        method.invoke(instance);
    }
}

3.注解

3.1 概念相关

定义：注解（Annotation），也叫元数据。一种代码级别的说明。它是JDK1.5及以后版本引入的一个特性，与类、接口、枚举是在同一个层次。它可以声明在包、类、字段、方法、局部变量、方法参数等的前面，用来对这些元素进行说明，注释。（注解主要用于说明程序，给计算机看的）
概念描述：
- JDK1.5之后的新特性
- 说明程序的
- 使用注解：@注解名称

3.2 作用分类

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

3.3 JDK中预定义的一些注解

@Override ：检测被该注解标注的方法是否是继承自父类(接口)的
@Deprecated：该注解标注的内容，表示已过时
@SuppressWarnings：压制警告
- 一般传递参数all @SuppressWarnings("all")

3.3 自定义注解

格式：

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

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

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

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

package com.weeks.annotation.domain;
/**
* 一个枚举类，用于自定义注解时的属性是枚举类型的示例
*/
public enum EnumClassDemo {
    
    
    MEMBER1, MEMBER2;
}

package com.weeks.annotation.myannotation;

import com.weeks.annotation.domain.EnumClassDemo;
/**
* 自定义的注解类型
*/
public @interface myAnnotationDemo1 {
    
    
    String attribute1() default "attribute1_value";//返回值是字符串类型，默认值是“attribute1_value”
    EnumClassDemo attribute2() default EnumClassDemo.MEMBER1;//返回值是枚举类型，默认值是该枚举类型的一个实例
    //特殊的属性名value，当只有当个属性时，在使用赋值时可以忽略value=
    int value();
}

3.4 元注解：用于描述注解的注解

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

package com.weeks.annotation.myannotation;

import com.weeks.annotation.domain.EnumClassDemo;

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 myAnnotationDemo1 {
    
    
    String attribute1() default "attribute1_value";
    EnumClassDemo attribute2() default EnumClassDemo.MEMBER1;
    //特殊的属性名value，当只有当个属性时，在使用赋值时可以忽略value=
    int value();
}

3.5 在程序使用(解析)注解：获取注解中定义的属性值

获取注解定义的位置的对象（Class，Method,Field）
获取指定的注解
- getAnnotation(Class)

public @interfaces Prp(){
    
    
	String className();
	String methodName();
}

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

public class ProImpl implements Pro{
    
    
    public String className(){
    
    
        return "cn.itcast.annotation.Demo1";
    }
    public String methodName(){
    
    
        return "show";
    }
}

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

3.6 案例：简单的测试框架

重新编写反射中的案例，使用注解代替配置文件进行className和methodName的注入

package com.weeks.annotation.myannotation;

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

package com.weeks.refection;

import com.weeks.annotation.myannotation.Pro;

import java.lang.reflect.Method;

@Pro(className = "com.weeks.refection.domain.Student", methodName = "learning")
public class RefectionFrameDemo2 {
    
    
    public static void main(String[] args) throws Exception {
    
    
        //1.解析注解
        //1.1获取该类的字节码文件对象
        Class<RefectionFrameDemo2> refectionFrameDemo2Class = RefectionFrameDemo2.class;
        //2.获取上面的注解对象
        //其实就是在内存中生成一个该注解接口的子类实现对象
        /**
         * public class ProImpl implements Pro(){
         *     public String className(){
         *         return "com.weeks.refection.domain.Student";
         *     }
         *     public String method(){
         *         return "learning";
         *     }
         * }
         */
        Pro annotation = refectionFrameDemo2Class.getAnnotation(Pro.class);
        //3.调用注解对象中定义的抽象类方法，获取返回值
        String className = annotation.className();
        String methodName = annotation.methodName();

        //4.加载该类对象进内存
        Class<?> aClass = Class.forName(className);

        //5.创建对象
        Object o = aClass.newInstance();

        //7.获取该类的方法对象
        Method method = aClass.getMethod(methodName);

        //8.调用该方法
        method.invoke(o);
    }
}

小结：

以后大多数时候，我们会使用注解，而不是自定义注解
注解给谁用？
- 编译器
- 给解析程序用
注解不是程序的一部分，可以理解为注解就是一个标签

JavaWeb之Java基础知识增强