2021-04-01：java第30天:Junit单元测试，反射以及注解的基本知识

最新推荐文章于 2022-03-01 17:01:15 发布

qq_41179957

最新推荐文章于 2022-03-01 17:01:15 发布

阅读量119

点赞数

本文链接：https://blog.csdn.net/qq_41179957/article/details/115387288

版权

今日内容:

1.Junit单元测试

2.反射

3.注解

(1) Junit单元测试概述

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

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

package Part3.Day_30basis.junit;

public class Calculator {
    public int add(int a,int b){
        return a+b;
    }
    public int sub(int a,int b){
        return a-b;
    }
}


package Part3.Day_30basis.test;


import Part3.Day_30basis.junit.Calculator;
import org.junit.Assert;
import org.junit.Test;

public class CalculatorTest {
    /*
        测试add方法
     */
    @Test
    public void testAdd(){
        //System.out.println("我被执行了");
        //1.创建计算器对象
        //2.调用计算器方法
        Calculator c = new Calculator();
        int result = c.add(1,2);
        System.out.println(result);

        //3.断言 我断言这个结果是3
        Assert.assertEquals(3,result);
    }
}

补充注解 Before 和After

package Part3.Day_30basis.test;


import Part3.Day_30basis.junit.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("test add...");
        //System.out.println("我被执行了");
        //1.创建计算器对象
        //2.调用计算器方法
        Calculator c = new Calculator();
        int result = c.add(1,2);
        //System.out.println(result);

        //3.断言 我断言这个结果是3
        Assert.assertEquals(3,result);
    }
}

2.反射：框架设计的灵魂

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

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

好处：（1）可以在程序的运行过程中操作这些对象：举个例子，IDEA你打String. 后面有成员方法的提示。实际上就是打出了类对象里封装的成员方法数组

（2）可以解耦，提高程序的可扩展性

Class对象里的获取功能：

（1）获取成员变量

package Part3.Day_30basis.reflect;

import Part3.Day_30basis.domain.Person;

import java.lang.reflect.Field;

public class reflectdemo02 {
    public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException {
        Class<Person> personClass = Person.class;
        Field[] fields = personClass.getFields();
        for (Field field : fields) {
            System.out.println(field);
        }
        //public java.lang.String Part3.Day_30basis.domain.Person.a
        //getfields 是获取所有public的成员变量
        Field a = personClass.getField("a");
        //获取成员变量a的值
        Person p = new Person();

        Object value = a.get(p);
        System.out.println(value);
        System.out.println(a);
        //public java.lang.String Part3.Day_30basis.domain.Person.a
        System.out.println("========");
        a.set(p,"张三");
        System.out.println(p); //toString方法

        Field[] df = personClass.getDeclaredFields();
        //获取所有成员变量，不考虑修饰符
        for (Field field : df) {
            System.out.println(field);
        }
        System.out.println("==========");
        Field d = personClass.getDeclaredField("d");
        //在反射中不管私有和共有都可以访问，但需要方法去忽略访问权限修饰符
        d.setAccessible(true);//暴力反射
        Object value2 = d.get(p);
        System.out.println(value2);
    }
}

（2）获取构造方法

package Part3.Day_30basis.reflect;

import Part3.Day_30basis.domain.Person;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class reflectdemo03 {
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        Class personClass = Person.class;

        Constructor constructor = personClass.getConstructor(String.class, int.class);
        System.out.println(constructor);
        //public Part3.Day_30basis.domain.Person(java.lang.String,int)
        //创建对象
        Object person = constructor.newInstance("张三",23);
        System.out.println(person);
        Object p1 = personClass.newInstance();
        System.out.println(p1);
    }
}

（3）获取成员方法

在反射面前没有什么是隐私的，有就变为accessible后就可以修改了

package Part3.Day_30basis.reflect;

import Part3.Day_30basis.domain.Person;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class reflectiondemo04 {
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        Class<Person> personClass = Person.class;
        //获取方法
        Method eat_method = personClass.getMethod("eat");
        //传一个对象，执行方法
        Person p = new Person();

        eat_method.invoke(p);//传递对象，和方法参数列表
        Method eat_method1 = personClass.getMethod("eat",String.class);
        //    public Method getMethod(String name, Class<?>... parameterTypes)
        eat_method1.invoke(p,"饭");


        //获取所有public 修饰的方法
        Method[] methods = personClass.getMethods();
        for (Method method : methods) {
            System.out.println(method);
            //不仅仅只有我看到的，还有Object对象继承下来的方法也存在
            String name = method.getName();
            System.out.println(name);
        }

        String className = personClass.getName();
        System.out.println(className);
    }
}

一个架构案例：

写一个框架，帮我们创建任意类对象，并且执行其中任意方法

像int, double类型等等，都是一种架构

改配置文件会使程序扩展性更强一些

package Part3.Day_30basis.reflect;

import Part3.Day_30basis.domain.Person;

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

/*
    写一个框架，帮我们创建任意类对象，并且执行其中任意方法
    将需要创建的对象的全类名和需要执行的方法定义在配置文件中
    在程序中加载读取配置文件
    使用反射技术来加载文件进内存
    创建对象
    执行方法
 */
public class practice {  //假设的框架类
    public static void main(String[] args) throws IOException, ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
        /*Person p = new Person();
        p.eat();*/
        /*
        前提：不能改变该类的任何代码，可以创建任意类的对象， 执行任意方法
         */

        //1.创建Properties对象
        Properties pro = new Properties();
        //2.加载配置文件，转换为一个集合
        //获取class目录下的配置文件
        ClassLoader classLoader = practice.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. 注解的概念

元数据：就是注解通过代码里表示的

javadoc test.java 会生成一个index.hdml文件 ANSI编码是本地默认编码。中文是GDK编码

package Part3.Day_30basis.annotation;

public @interface MyAnno {
    int show1();  //接口中的抽象方法
    String show2() default "张三";
    /*Person per();//枚举类型

    Myanno2 anno2(); //注解类型
    String[] strs();*/
}


package Part3.Day_30basis.annotation;
@MyAnno(show1 = 1) //如果只有一个属性的话
@MyAnno3
public class Worker {

    public void show(){}
}

package Part3.Day_30basis.annotation;

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

/**
 * @Target 藐视注解能够作用的位置
 * @Retention 描述注解被保留的阶段
 * @Documented 描述注解是否被抽取到api文档中
 * @Inherited 描述注解是否被子类继承
 */

@Target(value={ElementType.TYPE}) //表示该MyAnno3只能作用于类上
public @interface MyAnno3 {

}

抓取Calculator的异常案例：

用Check注解去测试，Bug输出到bug.txt文件中：

package Part3.Day_30basis.junit;

public class Calculator {
    @Check
    public int add(int a,int b){
        return a+b;
    }
    @Check
    public int sub(int a,int b){
        return a-b;
    }
}




package Part3.Day_30basis.junit;

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

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

}




package Part3.Day_30basis.junit.test;

import Part3.Day_30basis.junit.Calculator;
import Part3.Day_30basis.junit.Check;

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);
                    //6.捕获异常
                } catch (Exception e) {
                    number++;
                    bw.write(method.getName()+"方法出异常了");
                    bw.newLine();
                    bw.write("异常的名称"+e.getCause().getClass().getSimpleName());
                    bw.newLine();
                    bw.write("异常的原因"+e.getCause().getMessage());
                    bw.write("--------------");
                }

            }
        }
        bw.write("本次测试一共出现"+number+"次异常");
        bw.flush();
        bw.close();


    }
}

此处复习一下写输出文件：

BufferedWriter bw= new BufferedWriter(new FileWriter("bug.txt"));

bw.write(method.getName()+"方法出异常了");
bw.newLine();
bw.write("本次测试一共出现"+number+"次异常");
bw.flush();
bw.close();

//这里用BufferedWriter创建对象，对象传入FileWriter（“文件名和地址”）

//bw.flush刷新进文件   bw.close()关闭流

qq_41179957

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
2021-04-01：java第30天:Junit单元测试，反射以及注解的基本知识

今日内容:1.Junit单元测试2.反射3.注解(1) Junit单元测试概述测试分类： a. 黑盒测试：不需要写代码，输入值看程序是否能够输出期望的值 b. 白盒测试：需要写代码，关注程序具体的执行流程package Part3.Day_30basis.junit;public class Calculator { public int add(int a,int b){ return a+b; ...
复制链接

扫一扫

2021-04-01：java第30天:Junit单元测试，反射以及注解的基本知识

“相关推荐”对你有帮助么？