Java-单元测试、反射、注解-第25节

最新推荐文章于 2022-11-03 13:38:58 发布
最新推荐文章于 2022-11-03 13:38:58 发布
阅读量147 收藏
点赞数
分类专栏： java-WEB 文章标签： java 反射 单元测试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zuefeng/article/details/109774821
版权

学习目标：

  • 学会使用单元测试对程序进行测试
  • 理解什么是反射，并会使用反射
  • 熟练使用注解，能够自定义注解

学习内容：

一、junit单元测试
1、测试分类
  • 黑盒测试：不需要编写代码，只需要提供输入，观察得到的是不是期望的输出
  • 白盒测试：需要编写代码，关注的是程序执行过程
2、Junit（白盒测试）使用
  • 步骤
    • 定义一个测试类
      测试类名：被测试的类名Test CaculatorTest
      包名：xxx.xx.xx.test 1.2.test
    • 定义测试方法：可以独立运行
      方法名：test测试的方法名 testAdd()
      返回值：void
      参数：空参
    • 给方法加@Test
    • 导入Junit依赖环境
  • 判定结果
    • 红色：失败
    • 绿色：成功
    • 一般我们使用断言操作来处理结果
      Assert.assertEqual(期望的结果,运算的结果)
  • appendix
    • @Before
      修饰的方法会在测试方法执行之前被自动执行
    • @After
      修饰的方法会在测试方法执行之后被自动执行
二、反射：框架设计的灵魂
1、框架
  • 半成品软件，可以在框架的基础上进行软件开发，简化编码
2、反射
  • 将类的各个组成部分封装为其他对象，就是反射机制
3、优势
  • 可以在程序运行过程中，操作这些对象
  • 可以解耦，提高程序的可扩展性
4、获取class对象的方式
  • Class.forName(“全类名”); 将字节码文件加载进内存，返回class对象
    • 多用于配置文件，将类名定义在配置文件中。读取文件，加载类
  • 类名.class; 通过类名的属性class获取
    • 多用于参数的传递
  • 对象.getClass(); getClass方法在Object类中定义着
    • 多用于对象获取字节码的方式
  • 结论：
    • 同一个字节码文件(*.class)在一次程序运行的过程中，只会被加载一次，不论通过哪一种方式获取的class对象都是同一个。
5、使用class对象
  • a、获取类型的方法
    • 获取变量
      • Field getField(String name)
        返回一个 Field 对象，它反映此 Class 对象所表示的类或接口的指定公共成员字段。
      • Field[] getFields()
        返回一个包含某些 Field 对象的数组，这些对象反映此 Class 对象所表示的类或接口的所有可访问公共字段。
      • Field getDeclaredField(String name)
        返回一个 Field 对象，该对象反映此 Class 对象所表示的类或接口的指定已声明字段。
      • Field[] getDeclaredFields()
        返回 Field 对象的一个数组，这些对象反映此 Class 对象所表示的类或接口所声明的所有字段。
    • 使用成员变量（通过获得的变量对象调用）
      • void set(Object obj, Object value);
        设置值
      • get(Object obj);
        获取值
      • setAccessable(true);
        忽略访问权限修饰符的安全检查，暴力反射
    • 获取构造方法
      • Constructor getConstructor(Class<?>… parameterTypes)
        返回一个 Constructor 对象，它反映此 Class 对象所表示的类的指定公共构造方法。
      • Constructor<?>[] getConstructors()
        返回一个包含某些 Constructor 对象的数组，这些对象反映此 Class 对象所表示的类的所有公共构造方法。
      • Constructor getDeclaredConstructor(Class<?>… parameterTypes)
        返回一个 Constructor 对象，该对象反映此 Class 对象所表示的类或接口的指定构造方法。
      • Constructor<?>[] getDeclaredConstructors()
        返回 Constructor 对象的一个数组，这些对象反映此 Class 对象表示的类声明的所有构造方法。
    • 使用构造方法
      • T newInstance(Object… initargs)
        获取有参构造并创建实例，使用此 Constructor 对象表示的构造方法来创建该构造方法的声明类的新实例，并用指定的初始化参数初始化该实例。
      • T newInstance()
        无参构造时可以不进行获取直接创建此 Class 对象所表示的类的一个新实例。
    • 获取成员方法
      • Method getMethod(String name, Class<?>… parameterTypes)
        返回一个 Method 对象，它反映此 Class 对象所表示的类或接口的指定公共成员方法。
      • Method[] getMethods()
        返回一个包含某些 Method 对象的数组，这些对象反映此 Class 对象所表示的类或接口（包括那些由该类或接口声明的以及从超类和超接口继承的那些的类或接口）的公共 member 方法。
      • Method getDeclaredMethod(String name, Class<?>… parameterTypes)
        返回一个 Method 对象，该对象反映此 Class 对象所表示的类或接口的指定已声明方法。
      • Method[] getDeclaredMethods()
        返回 Method 对象的一个数组，这些对象反映此 Class 对象表示的类或接口声明的所有方法，包括公共、保护、默认（包）访问和私有方法，但不包括继承的方法。
    • 执行成员方法
      • Object invoke(Object obj, Object… args)
        对带有指定参数的指定对象调用由此 Method 对象表示的底层方法。
      • String getName()
        获取方法名，以 String 形式返回此 Method 对象表示的方法名称。
    • 获取类名
      • String getName()
        以 String 的形式返回此 Class 对象所表示的实体（类、接口、数组类、基本类型或 void）名称。
三、注解
1、简介
  • 概念
    • JDK1.5之后的新特性
    • 说明程序的
    • 使用注解：@注解名称
  • 作用分类
    • 编写文档：通过代码里的标识的注解生成文档（生成DOC文档，Javadoc Java文件）
    • 代码分析：通过代码里标识的注解对代码进行分析（使用反射）、
    • 编译检查：通过代码里标识的注解让编译器能够实现基本的编译检查（Override）
2、JDK中预定义的一些注解
  • @Override
    • 检查是否对父类进行重写
  • @Deprecated
    • 标定该方法已经过时
  • @SuppressWarnings(“all”)
    • 压制所有的异常信息
3、自定义注解
  • 格式
    • 元注解
    • public @interface 注解名称{}
  • 本质
    • 注解本质上是一个接口，该接口默认继承Annotation接口
    • public interface MyAnno extends java.lang.annotation.Annotation {}
  • 属性
    接口中的抽象方法
    • 返回值类型
      • 基本数据类型
      • String
      • 枚举
      • 注解
      • 以上类型的数组
    • 定义了属性在使用时需要赋值
      • 如果定义属性时，如果使用default关键字初始化，则不必进行赋值
      • 只有一个属性需要赋值，并名称为value，可以不写属性名直接传值
      • 数组赋值时如果只有一个值，可以省略{}
  • d、元注解
    描述注解的注解
    • @Target(value={}) 描述注解作用的位置
      • ElementType.TYPE 作用于类上
      • ElementType.METHOD 作用于方法上
      • ElementType.FIELD 作用于成员变量上
    • @Retention() 描述注解保留到哪一阶段
      • RetentionPolicy.RUNTIME 保留到运行阶段
      • RetentionPolicy.SOURCE 保留到源码阶段
      • RetentionPolicy.CLASS 保留到编码阶段
    • @Documented 描述注解在生成API文档时是否被保留
    • @Inherited 描述注解在子类中是否会被继承
4、在程序中使用（解析）注解
  • 获取注解定义的位置的对象 （class，method，field）
  • 获取指定的注解
    • getAnnotation(Class) 在内存中生成一个该注解接口的子类实现对象
  • 调用注解中的抽象方法获取配置的属性值
5、小结
  • 以后大多数时候，我们会使用注解，而不是自定义注解
  • 注解给谁用：
    • 编译器
    • 解析程序
  • 注解不是程序的一部分，可以理解为注解就是一个标签

学习产出：

1、 Junit

package xuefeng.cn.demo01Junit;

/**
 * Design a caculator
 */

public class Caculator {
    /**
     * add
     * @param a
     * @param b
     * @return
     */
    public int Add(int a, int b){
        return a+b;
    }

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


package xuefeng.cn.demo02test;

import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import xuefeng.cn.demo01Junit.Caculator;

public class CaculatorTest {
    @Before
    public void init(){
        System.out.println("init...");
    }

    @Test
    public void testAdd(){
        Caculator c = new Caculator();
        int result = c.Add(1, 2);
        Assert.assertEquals(3,result);
    }

    @Test
    public void testSub(){
        Caculator c = new Caculator();
        int result = c.Sub(2, 1);
        Assert.assertEquals(1,result);
    }

    @After
    public void Close(){
        System.out.println("close...");
    }

}

2、Reflect

  • 获取class对象的方式
package xuefeng.cn.demo03Reflect;

import xuefeng.cn.domain.Person;

public class Demo01GetClass {
    public static void main(String[] args) throws Exception {
//        第一种方式：直接用class的forName方法获取
        Class cls1 = Class.forName("xuefeng.cn.domain.Person");
        System.out.println(cls1);
//        第二种方式，类名.class获取
        Class cls2 = Person.class;
        System.out.println(cls2);
//        第三种方式，通过对象调用getClass()方法获得
        Person person = new Person();
        Class cls3 = person.getClass();
        System.out.println(cls3);
    }
}
  • 获取变量
package xuefeng.cn.demo03Reflect;

import xuefeng.cn.domain.Person;

import java.lang.reflect.Field;

public class Demo02GetField {
    public static void main(String[] args) throws Exception {
        Person p = new Person();
        Class<Person> cls = Person.class;
        Field[] fields = cls.getFields();
        for (Field field : fields) {
            System.out.println(field);
        }
        System.out.println("------------");
        Field a = cls.getField("a");
        Object val1 = a.get(p);
        System.out.println(val1);
        a.set(p,"Hello");
        Object val2 = a.get(p);
        System.out.println(val2);
        System.out.println("===============");

        Field[] declaredFields = cls.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println(declaredField);
        }
        System.out.println("--------------");
        Field d = cls.getDeclaredField("d");
        d.setAccessible(true);
        Object val3 = d.get(p);
        System.out.println(val3);
    }
}
  • 获取构造方法
package xuefeng.cn.demo03Reflect;

import xuefeng.cn.domain.Person;

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

public class Demo03GetConstructor {
    public static void main(String[] args) throws Exception {
        Person p = new Person();
        Class<Person> cls = Person.class;

        Constructor<Person> constructor = cls.getConstructor();
        Person person = constructor.newInstance();
        System.out.println(person);
        System.out.println("------------");

        Constructor<Person> constructor1 = cls.getConstructor(String.class, int.class);
        Person person1 = constructor1.newInstance("Jim", 18);
        System.out.println(person1);
        System.out.println("------------");

        Constructor<Person> constructor2 = cls.getConstructor();
        Person person2 = constructor2.newInstance();
        System.out.println(person2);
        System.out.println("--------------");

    }
}
  • 获取成员方法
package xuefeng.cn.demo03Reflect;

import xuefeng.cn.domain.Person;

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

public class Demo04GetMethod {
    public static void main(String[] args) throws Exception {
        Class<Person> cls = Person.class;
        Person person = new Person();

        Method method = cls.getMethod("eat");
        method.invoke(person);
        System.out.println("------------");


        Method method1 = cls.getMethod("drink", String.class);
        method1.invoke(person, "bear");
        System.out.println("------------");

        Method[] methods = cls.getMethods();
        for (Method method2 : methods) {
            method2.setAccessible(true);
            System.out.println(method2);
            System.out.println(method2.getName());
        }
        System.out.println("--------------");
        
    }
}
  • 练习：
package xuefeng.cn.demo03Reflect;

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

import xuefeng.cn.domain.Person;

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

public class Demo05Training {
    public static void main(String[] args) throws Exception {
//        1、加载配置文件
//        1.1创建properties对象
        Properties properties = new Properties();
//        1.2加载配置文件，转换成一个集合
//        1.2.1获取class目录下的配置文件
        ClassLoader classLoader = Demo05Training.class.getClassLoader();
        InputStream is = classLoader.getResourceAsStream("Pro.Properties");
        properties.load(is);

//        2、获取配置文件中定义的数据
        String className = properties.getProperty("className");
        String methodName = properties.getProperty("methodName");

//        3、加载该类进内存
        Class aClass = Class.forName(className);
//        4、创建对象
        Object obj = aClass.newInstance();
//        5、获取方法对象
        Method method = aClass.getMethod(methodName);
//        6、执行方法
        method.invoke(obj);
    }
}

3、 注解

  • 编写文档
package xuefeng.cn.demo04Annotation;

/**
 * ע��javadoc��ʾ
 * @author xuefeng
 * @version 1.0
 * @since 1.5
 */
public class Demo01Doc {
    /**
     * ����������֮��
     * @param a ����
     * @param b ����
     * @return  ����֮��
     */
    public int add(int a, int b){
        return a+b;
    }
}
  • JDK中预定义的一些注解
package xuefeng.cn.demo04Annotation;

@SuppressWarnings("all")
public class Demo02Anno {
    @Override
    public String toString() {
        return "Demo02Anno{}";
    }
    @Deprecated
    public void show(){
        System.out.println("111");
    }

    public void show1(){
        System.out.println("222");
    }
}
  • 自定义注解、属性赋值
package xuefeng.cn.demo04Annotation;

public enum Enum {
    p1,p2;
}


package xuefeng.cn.demo04Annotation;

@SuppressWarnings("all")
public @interface Anno {
}


package xuefeng.cn.demo04Annotation;

public @interface Demo03MyAnno {
    public abstract String show();
    int age();
    Enum en();
    Anno anno();
    String[] strs();
}


package xuefeng.cn.demo04Annotation;

@Demo03MyAnno(show = "hello",age = 12,
        en = Enum.p1,anno = @Anno(),strs = {"12","ads"})
public class Demo04Test {
}
  • 元注解
package xuefeng.cn.demo04Annotation;


import java.lang.annotation.*;

@Target({ElementType.TYPE,ElementType.METHOD,ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface Demo05MyAnno1 {

}
  • 练习一
package xuefeng.cn.demo04Annotation;

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 xuefeng.cn.demo04Annotation;

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

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

@Pro(className = "xuefeng.cn.domain.Student",methodName = "sleep")
public class Demo06Training {
    public static void main(String[] args) throws Exception {
//        1、加载配置文件
        Class<Demo06Training> trainingClass = Demo06Training.class;
        Pro pro = trainingClass.getAnnotation(Pro.class);


//        2、获取配置文件中定义的数据
        String className = pro.className();
        String methodName = pro.methodName();

//        3、加载该类进内存
        Class aClass = Class.forName(className);
//        4、创建对象
        Object obj = aClass.newInstance();
//        5、获取方法对象
        Method method = aClass.getMethod(methodName);
//        6、执行方法
        method.invoke(obj);
    }
}
  • 练习二
package xuefeng.cn.demo04Annotation;

public class Caculator {
    @CheckTest
    public int add(){
        return 1+0;
    }

    @CheckTest
    public int sub(){
        return 1-0;
    }

    @CheckTest
    public int pub(){
        return 1*0;
    }

    @CheckTest
    public int div(){
        return 1/0;
    }

    public void show(){
        System.out.println("Achieve......");
    }
}


package xuefeng.cn.demo04Annotation;

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 CheckTest {
}


package xuefeng.cn.demo04Annotation;

/*
测试框架
*/

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

public class Demo07Check {
    public static void main(String[] args) throws IOException {
        Caculator caculator = new Caculator();
        Class<? extends Caculator> aClass = caculator.getClass();
        Method[] methods = aClass.getMethods();

        int number = 0;
        BufferedWriter log = new BufferedWriter(new FileWriter("bug.txt"));

        for (Method method : methods) {
            if (method.isAnnotationPresent(CheckTest.class)){
                try {
                    method.invoke(caculator);
                } catch (Exception e) {
                    number++;
                    log.write(method.getName());
                    log.newLine();
                    log.write("The Exception Name:" + e.getCause().getClass().getSimpleName());
                    log.newLine();
                    log.write("The Exception Reason:" + e.getCause().getMessage());
                    log.newLine();
                    log.write("--------------------");
                    log.newLine();
                }
            }
        }
        log.write("After the test check, find "+number+" faults!!!");
        log.flush();
        log.close();
    }
}

4、附件

package xuefeng.cn.domain;

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

    public void eat(){
        System.out.println("eat...");
    }
    public void drink(String sth){
        System.out.println("drink..."+sth);
    }

    public Person() {
    }

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

    public String getName() {
        return Name;
    }

    public void setName(String name) {
        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 xuefeng.cn.domain;

public class Student {
    public void sleep(){
        System.out.println("Sleep...");
    }
}
Xue__Feng
关注
专栏目录
【IT十八掌徐培成】Java基础第25天-01.反射基础.zip
08-07
Java反射机制是Java编程语言中的一个重要特性，它允许运行中的Java程序对自身进行检查并且可以直接操作程序的内部属性。在“【IT十八掌徐培成】Java基础第25天-01.反射基础”这一课程中，徐培成老师会深入讲解这个...
【Java学习笔记】单元测试、反射、注解、动态代理
weixin_52144018的博客
03-22 630
【Java学习笔记】单元测试、反射、注释、动态代理
Java学习-单元测试、反射
weixin_46051964的博客
08-31 434
【代码】Java学习-单元测试。
java-单元测试和反射
最新发布
ZRX_ZYH的博客
11-03 213
关于Java中的单元测试和反射的学习笔记
回顾Junit单元测试、反射、注解知识点
zzj092的博客
08-05 370
Junit单元测试： * 测试分类： 1. 黑盒测试：不需要写代码，给输入值，看程序是否能够输出期望的值。 2. 白盒测试：需要写代码的。关注程序具体的执行流程。 * Junit使用：白盒测试 * 步骤： 1. 定义一个测试类(测试用例) * 建议： * 测试类名：被测试的类名Test ...
Java单元测试+反射+注解
xxu_tianxin的博客
04-10 228
今日内容 Junit单元测试(如何编写测试类的代码和主方法) 反射(后期学习框架的灵魂) 注解 Junit使用步骤 定义一个测试类(也叫测试用例) 建议：测试类名：被测试的类+Test 包名：xxx.xxx.test 定义测试方法(可以独立运行) 建议：方法名：test+测试的方法名 返回值：void 参数：空参 给方法加上 @Test 注解 导入Junit依赖环境 不然步骤3会报错 判断结...
Java-practice
03-16
九、Java反射和注解 反射允许在运行时检查和修改类、接口、字段和方法的信息。注解是一种元数据，可以用于编译时或运行时的代码处理，如Spring框架中的依赖注入就是基于注解实现的。 十、Java虚拟机（JVM） 理解JVM...
java-study-lyn:Java研究
04-19
JUnit是Java的单元测试框架，通过编写测试用例确保代码的质量和稳定性。 在"java-study-lyn"的学习过程中，你可能会遇到以上提到的许多知识点，并通过实际编程练习来加深理解。持续学习和实践是提高Java技能的关键...
Core Java, Volume II--Advanced Features(10th)
12-11
这本书是Java核心技术的第二卷，专为已经掌握Java基础的开发者设计，旨在深入探讨和理解Java的高级特性和最佳实践。在第10版中，作者对Java的最新版本进行了更新，确保读者能够了解到最新的技术动态。 一、多线程与...
Java语言程序设计（梁勇）第21-30章全部完整习题答案
09-16
第25章到第28章可能涵盖了反射、注解、网络编程和数据库连接等内容。反射允许在运行时检查类和对象，创建动态类型的行为。注解提供了一种元数据的方式来标记代码，增强编译器或运行时环境的功能。网络编程涉及Socket...
JavaWeb---反射
qq_42514129的博客
10-26 263
User user = new User(23,&amp;amp;quot;唐嫣&amp;amp;quot;); 反射field.set(user,&amp;amp;quot;柳岩&amp;amp;quot;)可以将user的值改变为23,柳岩 Map&amp;amp;amp;lt;String,String[]&amp;amp;amp;gt; map = getParameterMap(); 数组直接打印得到的是哈希地址值,集合是{...}的样式
JAVA中Junit,反射和注解
Milk的博客
11-19 156
一.Junit单元测试 1.Junit概述 测试分类： （1）黑盒测试：不需要写代码，给输入值，看程序是否能够输出期望的值。 （2）白盒测试：需要写代码。关注程序具体的执行流程。 2.Junit的使用步骤 junit:白盒测试 步骤： （1）定义一个测试类（测试用例） 建议 测试类名：被测试的类名Test CalculatorTest 包名：xxx.xxx.xx.test cn.itcast....
JAVA小练习37——使用java类描述一个计算器，计算器具备 公共属性： 操作数1 、操作数2 、 运算符. 公共的功能：运算。要求： 计算器的属性需要封装起来，不能直接对计算器的属性赋值。
Eric_The_Red的博客
05-21 3364
class Caculator{ private int num1; private int num2; private char option; public void setNum1(int n1) { num1=n1; } public void setNum2(int n2) { num2=n2; } public void setOption(char o) { i...
JavaWeb(一)之单元测试，反射，注解
qq_32719221的博客
10-16 234
要点 Junit单元测试 反射 注解 Junit单元测试： 测试分类： 1. 黑盒测试：不需要写代码，给输入值，看程序是否能够输出期望的值。 2. 白盒测试：需要写代码的。关注程序具体的执行流程。 技巧: 快速写注释 /**回车 Junit使用：白盒测试 步骤： 定义一个测试类(测试用例) 建议： 测试类名：被测试的类名Test CalculatorTest 包名：xxx....
Java进阶知识笔记14--【junit、反射、注解】
Kuber
10-10 379
今日内容 Junit单元测试 反射 注解 Junit单元测试： 测试分类： 黑盒测试：不需要写代码，给输入值，看程序是否能够输出期望的值。 白盒测试：需要写代码的。关注程序具体的执行流程。 Junit使用：白盒测试 步骤： 定义一个测试类(测试用例) 建议： 测试类名：被测试的类名Test CalculatorTest 包名：xxx.xxx.xx.test cn.itcast.test 定义测试方法：可以独立运行 建议： 方法名：test测试的方法名 testAdd()
1.Juit
qq_45925322的博客
04-13 266
Junit单元测试 Junit使用： 步骤： *1.定义一个测试类（建议Test） *2.包名：xxx.xxx.Test *3.测试方法：可以独立运行 *方法名：建议test，参数直接为空，给某个方法加个@Test *@Before 在方法前面加上，会在所有方法执行前执行，相当于构造函数 *@After 在方法前面加上，会在所有方法执行后执行，相当于析构函数 *4.导入Junit的依赖环境 *5.断言： *Java中的Assert类提供了公共接口 反射：框架设计的灵魂
【JAVA】单元测试工具-Mockito学习心得
猫球球的博客
01-16 1529
前一段时间换到了一个新的项目，开始疯狂加班，连学习都暂时停滞了。好在新的项目有新的要求，也经常会遇上新的问题，和新的技术，就算是在加班，也不失为一种学习的过程。 在原本的项目中我是从来不写单元测试的，第一是没有人做此要求，第二是我不会。一个java开发还没有研究过单元测试，说不定会笑死人，但是因为从来用不上，我也就从没有意识到自己需要补充这方面的知识。但是在新的工作环境中, 总是会遇到新的问题，...
IBM技术论坛：使用 Cobertura 和反射机制提高单元测试中的代码覆盖率
1ouis的专栏
01-15 1174
引言 单元测试是软件开发过程中重要的质量保证环节。单元测试可以减少代码中潜在的错误，使缺陷更早地被发现，从而降低了软件的维护成本。软件代码的质量由单元测试来保证，而单元测试自身的质量与效率问题也不容忽视。提高单元测试的质量与效率，不仅能够使软件代码更加有保证，而且能够节省开发人员编写或者修改单元测试代码的时间。衡量单元测试质量与效率的指标多种多样，代码覆盖率是其中一个极为重要的指标。一般而言
java之Junit单元测试、反射和注解总结
xiaoyong5854的博客
07-05 721
1 Junit单元测试 测试分类： 黑盒测试：不需要写代码，给输入值，看程序是否能够输出期望的值。 白盒测试：需要写代码的。关注程序具体的执行流程。 Junit使用：白盒测试 定义一个测试类(测试用例) 测试类名：被测试的类名Test Demo02Calculator 包名：xxx.xxx.xx.test package Demo01 定义测试方法：可以独立运行 * 方法名：test测试的方法名 testAdd() * 返回值：void *
Java编程24小时教练第二版：初学者指南
23. 注解与反射 - 第二十三课涵盖了注解的定义和使用，以及反射机制在动态访问类信息上的应用。 24. 远程方法调用 - 第二十四课简要介绍了Java中的远程方法调用（RMI）技术，用于分布式系统的组件交互。 通过这...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值