10.Java-Junit&注解&枚举

最新推荐文章于 2024-06-24 22:42:45 发布
最新推荐文章于 2024-06-24 22:42:45 发布
阅读量170 收藏
点赞数
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_29294165/article/details/120675236
版权

一、Junit

属于白盒测试

1. 普通测试麻烦说明

  • 没有使用junit的时候缺点：
    * 1.测试一定走main方法，是程序的入口，main方法的格式必须不能写错
    * 2.要是在同一个main方法中测试的话，那么不需要测试的东西必须注释掉。
    * 3.测试逻辑如果分开，需要定义多个测试类，麻烦
    * 4.业务逻辑和测试代码，都混淆了

1. 代码

package com.fj.Junit.Junit;

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

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

2. 调用代码

package com.fj.Junit.Junit;

public class Demo01 {
    public static void main(String[] args) {

        /*****************************************************************
         * 没有使用junit的时候缺点：
         * 1.测试一定走main方法，是程序的入口，main方法的格式必须不能写错
         * 2.要是在同一个main方法中测试的话，那么不需要测试的东西必须注释掉。
         * 3.测试逻辑如果分开，需要定义多个测试类，麻烦
         * 4.业务逻辑和测试代码，都混淆了
         * ***************************************************************
         */
        //测试加法
        Calculator cal = new Calculator();
        int result = cal.add(10,20);
        System.out.println(result);
        int result1 = cal.sub(20,10);
        System.out.println(result1);
    }

}

2. Junit 的使用

1.使用说明

  • 【1】一般测试和业务做一个分离，分离为不同的包：建议起名：公司域名倒着写+test
  • 【2】测试类的名字： ****Test—>见名知意
  • 【3】测试方法的定义->这个方法可以独立运行，不依托与main方法
  • 名字：testAdd() testSub() 见名知意
  • 参数：无参
  • 返回值：无返回值
  • 【4】测试方法定义完以后，不能直接就独立运行，必须要在方法前加入一个注解：@Test
  • 【5】导入Junit的依赖环境：
    在这里插入图片描述
  • 【6】代码演示

```java
package com.fj.Junit.Junit;

import org.junit.Test;

/**
 * 测试方法
 */
public class CalculatorTest {
    @Test
    public void testAdd() {
        System.out.println("测试add方法");
        Calculator cal = new Calculator();
        int result = cal.add(10, 20);
        System.out.println(result);

    }
    @Test
    public void testSub() {
        System.out.println("测试Sub方法");
        Calculator cal = new Calculator();
        int result = cal.sub(10, 20);
        System.out.println(result);
    }
}
  • 【7】绿色正常，红色异常
    在这里插入图片描述
  • 【8】即使出现绿色接口，也不代表代码，通过，可能出现逻辑错误
  • 【9】加入断言Assert.assertEquals：预测结果，判断一下我预测的结果和实际的结果是否一致
    1. 如果疏忽吧加法携程成减法，如下代码
package com.fj.Junit.Junit;

public class Calculator {
    //加法

    public int add(int a, int b) {
        //int num = 6 / 0;
        return a - b;
    }

    //减法
    public int sub(int a, int b) {
        return a - b;
    }
}
  1. 测试中加入断言，如下代码
package com.fj.Junit.Junit;

import org.junit.Assert;
import org.junit.Test;

/**
 * 测试方法
 */
public class CalculatorTest {
    @Test
    public void testAdd() {
        System.out.println("测试add方法");
        Calculator cal = new Calculator();
        int result = cal.add(10, 30);
       // System.out.println(result); //程序的运行结果可以不关注
        //加入断言：预测结果，判断一下我预测的结果和实际的结果是否一致：
        Assert.assertEquals(40,result);

    }
    @Test
    public void testSub() {
        System.out.println("测试Sub方法");
        Calculator cal = new Calculator();
        int result = cal.sub(10, 20);
        System.out.println(result);
    }
}
  1. 返回结果：
测试add方法

java.lang.AssertionError: 
Expected :40
Actual   :-20
<Click to see difference>


	at org.junit.Assert.fail(Assert.java:89)
	at org.junit.Assert.failNotEquals(Assert.java:835)
	at org.junit.Assert.assertEquals(Assert.java:647)
	at org.junit.Assert.assertEquals(Assert.java:633)
	at com.fj.Junit.Junit.CalculatorTest.testAdd(CalculatorTest.java:17)
	at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:77)
	at java.base/jdk.internal.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
	at java.base/java.lang.reflect.Method.invoke(Method.java:568)
	at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:59)
	at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)
	at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:56)
	at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17)
	at org.junit.runners.ParentRunner$3.evaluate(ParentRunner.java:306)
	at org.junit.runners.BlockJUnit4ClassRunner$1.evaluate(BlockJUnit4ClassRunner.java:100)
	at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:366)
	at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:103)
	at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:63)
	at org.junit.runners.ParentRunner$4.run(ParentRunner.java:331)
	at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:79)
	at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:329)
	at org.junit.runners.ParentRunner.access$100(ParentRunner.java:66)
	at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:293)
	at org.junit.runners.ParentRunner$3.evaluate(ParentRunner.java:306)
	at org.junit.runners.ParentRunner.run(ParentRunner.java:413)
	at org.junit.runner.JUnitCore.run(JUnitCore.java:137)
	at com.intellij.junit4.JUnit4IdeaTestRunner.startRunnerWithArgs(JUnit4IdeaTestRunner.java:69)
	at com.intellij.rt.junit.IdeaTestRunner$Repeater.startRunnerWithArgs(IdeaTestRunner.java:33)
	at com.intellij.rt.junit.JUnitStarter.prepareStreamsAndStart(JUnitStarter.java:235)
	at com.intellij.rt.junit.JUnitStarter.main(JUnitStarter.java:54)


Process finished with exit code -1

二、注解

1. 注解介绍

  • 【1】 @Before： 在测试方法之间执行 ，一般会在@Before 修饰的那个方法中加入一些申请资源的代码：申请数据库资源，申请io资源，申请网络资源…
  • 【2】@After： 在方法执行之后执行，一般会在@After修饰的那个方法中加入释放资源的代码：释放数据库资源，释放io资源，释放网络资源…
  • 【3】@Override：限定重写父类方法，该注解只能用于方法。@Override的作用：限定重写的方法，只要重写方法有问题，就有错误提示
  • 【4】@Deprecated：用于表示所修饰的元素（类，方法，构造器，属性等）已过时。通常是因为所修饰的结构危险或存在更好的选择。@Deprecated作用：在方法前加入@Deprecated，这个方法就会变成废弃、过期、过时方法
  • 【5】@SuppressWarnings：抑制编辑器警告@SuppressWarnings("unused") int age =10;
  • 【6】代码演示
package com.fj.Junit.Junit;

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("方法执行开始了..........");
    }
    @After
    public void close(){
        System.out.println("方法执行结束了..........");
    }

    @Test
    public void testAdd() {
        System.out.println("测试add方法");
        Calculator cal = new Calculator();
        int result = cal.add(10, 30);
        // System.out.println(result); //程序的运行结果可以不关注
        //加入断言：预测结果，判断一下我预测的结果和实际的结果是否一致：
        Assert.assertEquals(40, result);

    }

    @Test
    public void testSub() {
        System.out.println("测试Sub方法");
        Calculator cal = new Calculator();
        int result = cal.sub(10, 20);
        // System.out.println(result);
    }
}
  • 结果：
方法执行开始了..........
测试add方法
方法执行结束了..........

Process finished with exit code 0
  • 【7】注意
    在这里插入图片描述

2. 生成JvaDoc文档注解

  • Tools-> Generate JAVADoc…在这里插入图片描述
  • 定义参数：其他参数：-encoding utf-8 -charset utf-8
    在这里插入图片描述

3. 自定义注解

【1】自定义注解使用很少，一般情况下都是现成的
【2】如何使用自定义注解：
定义注解的声明使用关键字是：@interface

package com.fj.Junit.anno;

/**
 * 声明注解
 */
public @interface MyAnnotation {
}

【3】注解的内部：

  1. 以@SuppressWarnings为例，发现内部：String[] value();是属性还是方法？
    答案：看上去是无参数方法，实际理解为一个成员变量，一个属性。
    无参数方法名字—>成员变量的名字
    无参数方法的返回值—>成员变量的类型
    这个参数叫 配置参数
    无参数方法的类型：基本数据类型（八种），String,枚举，注解类型，还可以是以上类型所对应的数组
    ps:如果只有一个成员变量的话，就起名叫value
public @interface SuppressWarnings {
    /**
     * The set of warnings that are to be suppressed by the compiler in the
     * annotated element.  Duplicate names are permitted.  The second and
     * successive occurrences of a name are ignored.  The presence of
     * unrecognized warning names is <i>not</i> an error: Compilers must
     * ignore any warning names they do not recognize.  They are, however,
     * free to emit a warning if an annotation contains an unrecognized
     * warning name.
     *
     * <p> The string {@code "unchecked"} is used to suppress
     * unchecked warnings. Compiler vendors should document the
     * additional warning names they support in conjunction with this
     * annotation type. They are encouraged to cooperate to ensure
     * that the same names work across multiple compilers.
     * @return the set of warnings to be suppressed
     */
    String[] value();
}

【4】使用注解

  • 使用注解的话，如果你定义了配置参数，就必须给赋值操作
  • 如果只有一个参数，并且这个参数的名字为value的话，value=可以不写
  • 如果你给配置参数设置了默认值，使用的时候无需传值
  • 一个注解的内部可以不定义配置参数的
  • 内部没有定义配置参数的注解->标记
  • 内部定义配置参数的注解->元数据
  1. 定义注解代码：
package com.fj.Junit.anno;

/**
 * 声明注解
 */
public @interface MyAnnotation {
    //
    String[] value();
}
  1. 使用注解代码
package com.fj.Junit.anno;

/**
 * @author fj 
 */
@MyAnnotation(value = {"dd","ee","ddd"})
public class Person {
  
}
  1. 使用注解，value=不写
package com.fj.Junit.anno;

/**
 * @author fj 
 */
@MyAnnotation({"dd","ee","ddd"})
public class Person {
  
}
  1. 配置参数默认值代码
package com.fj.Junit.anno;

public @interface MyAnnotation2 {
    String value() default "abc";
}
  1. 配置参数默认值调用代码
package com.fj.Junit.anno;
package com.fj.Junit.anno;

/**
 * @author fj 
 */
@MyAnnotation({"dd","ee","ddd"})
@MyAnnotation2
public class Person {
  
}
  1. 内部不定义配置参数的注解
package com.fj.Junit.anno;

public @interface MyAnnotation3 {
}

4. 元注解

元注解就是用于修饰其他注解的注解
举例：

@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE, MODULE})
@Retention(RetentionPolicy.SOURCE)
public @interface SuppressWarnings {

JDK5.0提供了四种元注解：Retention,Target,Documented,Inherited
五重注解说明：引用Gene Xu的五种注解博客，点击跳转

三、枚举

1. JDK1.5之前枚举类说明

在java中，类的对象是有限的，确定的。这个类我们可以定义为枚举类。
枚举类

package com.fj.Junit.test_enum;

/**
 * 枚举类
 */
public class Season {
    public String getSeasonName() {
        return seasonName;
    }

    public void setSeasonName(String seasonName) {
        this.seasonName = seasonName;
    }

    public String getSeasonDesc() {
        return seasonDesc;
    }

    public void setSeasonDesc(String seasonDesc) {
        this.seasonDesc = seasonDesc;
    }

    @Override
    public String toString() {
        return "Season{" +
                "seasonName='" + seasonName + '\'' +
                ", seasonDesc='" + seasonDesc + '\'' +
                '}';
    }

    //属性
    private String seasonName;//季节名称
    private String seasonDesc;//季节描述

    //利用构造器对属性进行赋值
    //私有化
    private Season(String seasonName, String seasonDesc) {
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;
    }

    //提供枚举类的有限的确定的对象：
    public static final Season SPRING = new Season("春天", "春暖花开");
    public static final Season SUMMER = new Season("夏天", "烈日洋洋");
    public static final Season AUTUMN = new Season("秋天", "硕果累累");
    public static final Season WINTER = new Season("冬天", "冰天雪地");


}

调用枚举类：

package com.fj.Junit.test_enum;

public class Demo01 {
    public static void main(String[] args) {
        Season summer = Season.SUMMER;
        System.out.println(summer);
        System.out.println(summer.getSeasonName());
    }
}

2. JDK1.5之后枚举类

  • 确定的对象–> enum枚举类要求对象（常量）必须放在最开始的位置,多个对象之间用，隔开，最后一个用；
  • 用enum修饰
  • enum关键字对应的枚举类的上次父类实：java.lang.Enum
  • 但是我们自定义的枚举类的上层父类，是objetc
package com.fj.Junit.test_enum2;

/**
 * 枚举类
 */
public enum Season {
    //确定的对象--> enum枚举类要求对象（常量）必须防砸最开始的位置,多个对象之间用，隔开，最后一个用；
    SPRING("春天", "春暖花开"),
    SUMMER("夏天", "烈日洋洋"),
    AUTUMN("秋天", "硕果累累"),
    WINTER("冬天", "冰天雪地");

    public String getSeasonName() {
        return seasonName;
    }

    public void setSeasonName(String seasonName) {
        this.seasonName = seasonName;
    }

    public String getSeasonDesc() {
        return seasonDesc;
    }

    public void setSeasonDesc(String seasonDesc) {
        this.seasonDesc = seasonDesc;
    }

    @Override
    public String toString() {
        return "Season{" +
                "seasonName='" + seasonName + '\'' +
                ", seasonDesc='" + seasonDesc + '\'' +
                '}';
    }

    //属性
    private String seasonName;//季节名称
    private String seasonDesc;//季节描述

    //利用构造器对属性进行赋值
    //私有化
    private Season(String seasonName, String seasonDesc) {
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;
    }


}

调用枚举类

package com.fj.Junit.test_enum2;

public class Demo01 {
    public static void main(String[] args) {
        Season spring = Season.SPRING;
        System.out.println(spring);
        //enum关键字对应的枚举类的上次父类实：java.lang.Enum
        //但是我们自定义的枚举类的上层父类，是objetc
        System.out.println(Season.class.getSuperclass().getName());
    }
}

3. 空枚举类

为什么这么简单：因为这个枚举类底层没有属性，构造器，toSting，get方法，然后按理来说应该写为SPRINT() ,现在脸（）可以省略，就变成SPRINT

package com.fj.Junit.test_enum3;

/**
 * 枚举类
 */
public enum Season {
    SPRING,
    SUMMER,
    AUTUMN,
    WINTER;
}

4. Enum方法

package com.fj.Junit.test_enum3;

public class Demo01 {
    public static void main(String[] args) {
        //用enum关键字创建的season枚举类上面的父类实：java.lang.Enum,常用方法子类Season可以直接拿过来使用
        //toString() 获取对象的名字
        Season autumn = Season.AUTUMN;
        System.out.println(autumn);
        System.out.println("======================");
        //values 返回枚举类对象的数组
        Season[] values = Season.values();
        for(Season s:values){
            System.out.println(s);
        }
        System.out.println("======================");
        //valueOf  注意：对象的名字必须正确。
        //通过对象名字获取这个枚举对象
        Season autumn1 = Season.valueOf("AUTUMN");
        System.out.println(autumn1);
    }
}

5. 枚举类实现接口

1.枚举类实现接口

【1】定义一个接口

package com.fj.Junit.test_enum4;

/**
 * 接口
 */
public interface Demo01 {
    void Show();
}

【2】枚举类实现这个接口

package com.fj.Junit.test_enum4;

/**
 * 枚举类
 */
public enum Season implements Demo01 {
    SPRING,
    SUMMER,
    AUTUMN,
    WINTER;

    @Override
    public void Show() {
        System.out.println("Show");
    }
}

【3】测试类：
所有的枚举对象，调用这个show方法的时候走得都是同一个方法，结构也是相同的

package com.fj.Junit.test_enum4;

public class Test {
    public static void main(String[] args) {
        Season autumn = Season.AUTUMN;
        autumn.Show();
        Season summer = Season.SUMMER;
        summer.Show();
    }
}

结果：

Show
Show

Process finished with exit code 0

2. 枚举类实现接口各自实现接口方法

【1】接口类

package com.fj.Junit.test_enum4;

/**
 * 接口
 */
public interface Demo01 {
    void Show();
}

【2】枚举类

package com.fj.Junit.test_enum4;

/**
 * 枚举类
 */
public enum Season implements Demo01 {
    SPRING{
        @Override
        public void Show() {
            System.out.println("这是春天");;
        }
    },
    SUMMER{
        @Override
        public void Show() {
            System.out.println("这是夏天");
        }
    },
    AUTUMN{
        @Override
        public void Show() {
            System.out.println("这是秋天");
        }
    },
    WINTER{
        @Override
        public void Show() {
            System.out.println("这是冬天");
        }
    };

/*    @Override
    public void Show() {
        System.out.println("Show");
    }*/
}

【3】 测试类

package com.fj.Junit.test_enum4;

public class Test {
    public static void main(String[] args) {
        Season autumn = Season.AUTUMN;
        autumn.Show();
        Season summer = Season.SUMMER;
        summer.Show();
    }
}

结果：

这是秋天
这是夏天

Process finished with exit code 0

6. 枚举的应用

1. 应用1

  1. 枚举类
package com.fj.Junit.test_enum5;

public enum Gender {
    男,
    女;
}
  1. 普通类
package com.fj.Junit.test_enum5;

public class Person {
    //属性
    private int age;
    private String name;
    private Gender sex;

    public Gender getSex() {
        return sex;
    }

    public void setSex(Gender sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                ", name='" + name + '\'' +
                ", sex=" + sex +
                '}';
    }
}
  1. 测试类
package com.fj.Junit.test_enum5;

public class Test {
    public static void main(String[] args) {
        Person p = new Person();
        p.setAge(19);
        p.setName("kk");
        p.setSex(Gender.女);//传入枚举类对象-->在入口处对参数进行了限制
        System.out.println(p);
    }
}

结果：

Person{age=19, name='kk', sex=女}

Process finished with exit code 0

2. 应用2：

  1. 枚举类：
package com.fj.Junit.test_enum5;

public enum Gender {
    男,
    女;
}
  1. 测试类
package com.fj.Junit.test_enum5;

public class Demo02 {
    public static void main(String[] args) {
        Gender sex = Gender.男;
        //switch 后面（）中可以传入枚举类型
        //switch 后面（） ：int,short,byte,char,String,枚举类型
        switch (sex){
            case 女:
                System.out.println("女");
                break;
            case 男:
                System.out.println("男");
                break;
        }

    }
}
Java 注解设计 -- Java 语言注解的介绍、高阶应用与自定义注解
栗筝i的博客
06-15 2172
Java 注解（Annotations）是自 JDK 1.5 引入的一种特性，它们提供了一种在代码中嵌入额外信息的机制，这些信息不会直接影响代码的执行，但可用于编译检查、代码分析、或在运行时的处理。注解可以被用来注释包、类、接口、字段、方法参数、局部变量等。一类是 Java 自带的标准注解，包括@Override（标明重写某个方法）、（标明某个类或方法过时）和（标明要忽略的警告），使用这些注解后编译器就会进行检查；一类为元注解，元注解是用于定义注解的注解，包括@Retention。
带你快速看完9.8分神作《Effective Java》—— 枚举 & 注解篇
如切如磋，如琢如磨
12-16 1500
豆瓣评分9.8的图书《Effective Java》，是当今世界顶尖高手Josh Bloch的著作，在我之前的文章里我也提到过，编程就像练武，既需要外在的武功招式（编程语言、工具、中间件等等），也需要修炼心法（设计模式、源码等等）学霸、学神OR开挂 我个人在Java领域也已经学习了近5年，在修炼“内功”的方面也通过各种途径接触到了一些编程规约，例如阿里巴巴的泰山版规约，在此基础下读这本书的时候仍是让我受到了很大的冲激，学习到了很多约定背后的细节问题，还有一些让我欣赏此书的点是，书中对于编程规约的解释让我感
第11章_Junit&注解&枚举
M_Jaydy的博客
12-20 240
Java学习笔记 第11章_Junit&注解&枚举
反射和注解,枚举,junit单元测试
sichenss的博客
03-17 208
学习笔记
【JAVA学习第十七天】Junit、注解、枚举、反射基础
weixin_56185617的博客
04-22 111
1
【java高级】枚举Enum、泛型Generic、注解Annotation、单元测试Junit
A-Itfuture的博客
09-10 502
【java高级】枚举Enum、泛型Generic、注解Annotation、单元测试Junit【枚举Enum】【泛型Generic】【注解Annotation】【单元测试Junit】知识图谱 【枚举Enum】 使用 类的对象是有限个，确定的。如：日期月份等 当需要定义一组常量时，建议枚举 JDK1.5之前，自定义枚举 JDK1.5之后，enum关键字定义枚举 属性应为不允许被改变，故private final修饰，构造器中赋值， 自定义枚举 1.私有化类的构造器，保证不在外部创建对象 2.在类内部创建枚
Android S GTS 常见的 fail 项
LEON
08-21 4414
Android S GTS 常见的fail项
java——Junit单元测试、反射、注解
m0_52196529的博客
11-10 386
java——Junit单元测试、反射、注解
JUnit_Test_Code.zip_JUnit_JUnit测试_junit测试脚本
09-22
JUnit是Java编程语言中最常用的单元测试框架之一，它允许开发者对代码进行自动化测试，确保代码的质量和功能的正确性。本资源&quot;JUnit_Test_Code.zip&quot;包含了一份关于如何使用JUnit进行测试的实例，以及图文并茂的讲解...
重学java 85.Java反射、注解、枚举总结
最新发布
m0_73983707的博客
06-24 866
Junit是一个单元测试框架,可以代替main方法去执行其他的方法public @interface 注解名{}a.数据类型 属性名() ——> 此属性没有默认值,需要在使用注解的时候为其赋值b.数据类型 属性名0) default 值 ——> 此属性有默认值,如果有需要,还可以二次赋值public enum 枚举类名{}
单元测试系列之一：如何使用JUnit、JaCoCo和EclEmma提高单元测试覆盖率
weixin_33856370的博客
04-18 536
更多原创测试技术文章同步更新到微信公众号 ：三国测，敬请扫码关注个人的微信号，感谢！ 原文链接：http://www.cnblogs.com/zishi/p/6726664.html -----如何快速完成单元测试代码 1. JUnit安装（http://junit.org/junit4/ 目前最新版本是4.12） 注：下面的一些演示图片是按照我...
枚举的值为null是怎么处理
HQ\(^o^)/的博客
09-29 1825
当后端给我们返回值的值是以数字来代表他的含义，但，因其他原因，后端可能会给我们返回一个null，但null没有定义的数字。这时，我们需要对这个返回值null做处理。原代码其实只需要在在v-for的同级加一行代码即可但也要注意顺序。
Java基础学习笔记31——Junit单元测试
weixin_44623055的博客
01-22 816
1、Junit单元测试分类： 黑盒测试：不需要写代码。给输入值，看程序是否能够输出期望的值； 白盒测试：需要写代码的，关注程序具体的执行流程。 2、Junit的使用 使用步骤： 定义一个测试类（测试用例），建议 测试类名：被测试的类名Test，如CalculatorTest；包名 xxx.xxx.xx.test ，如aa.bbb.c.test 定义测试方法：可以独立运行，建议 方法名：test测试的方法名，如testAdd()；返回值：void；参数列表：空参 给方法加@Test 导入Ju
Junit单元测试遇见的一个枚举类型的坑（枚举类型详解）
weixin_33971977的博客
11-28 1735
2019独角兽企业重金招聘Python工程师标准&gt;&gt;&gt; ...
JUnit+Mock
热门推荐
若明天不见
02-14 1万+
一、JUnit常用注解与断言 　　@Test注解的public void方法将会被当做测试用例 　　JUnit每次都会创建一个新的测试实例，然后调用@Test注解方法，任何异常的抛出都会认为测试失败 　Mock通常是指，在测试一个对象A时，我们构造一些假的对象来模拟与A之间的交互，而这些Mock对象的行为是我们事先设定且符合预期。通过这些Mock对象来测试A正常逻辑，异常逻辑或压力情况下工作是否正常。
SSM框架基础所需要的依赖
phubing
02-11 885
1.需要抽取的版本号 &lt;properties&gt; spring核心版本 &lt;spring.version&gt;5.0.3.RELEASE&lt;/spring.version&gt; mybatis集合版本 &lt;mybatis.version&gt;3.4.5&lt;/mybatis.version&gt; &lt;myba...
Junit测试报错：java.lang.AssertionError at org.junit.Assert.assertTrue
u012161251的博客
05-30 4297
Junit测试报错： java.lang.AssertionError at org.junit.Assert.fail(Assert.java:86) at org.junit.Assert.assertTrue(Assert.java:41) at org.junit.Assert.assertTrue(Assert.java:52) at Calculator.Calcul...
Method类的Invoke方法
maxcode
01-05 1621
Dto：dto里面放的都是同一类型的字段 /* * Creation : 2 Dec 2015 */ package com.java.invoke; public class Dto { private Integer Col1; private Integer Col2; private Integer Col3; private Integer Co
关于JUnit5 你必须知道的(三) 深入理解JUnit 5扩展机制
qq_35448165的博客
12-20 1780
假设你对于JUnit 5有基本的认识，并且对其扩展机制有初步了解。如果你不清楚JUnit 基本的架构和使用，可以参考之前的三篇博客 关于JUnit5 你必须知道的(一) JUnit5架构和环境搭建 关于JUnit5 你必须知道的(二)JUnit 5的新特性 单元测试之JUnit 5 参数化测试使用手册 ...
Java枚举、注解、反射与单元测试详解
&quot;该资源是关于Java编程的教程，涵盖了枚举、注解、反射以及单元测试和Lombok工具的使用。&quot; 在Java编程中，枚举（Enumeration）是一种特殊的类，从Java 1.5版本开始引入，它提供了一种更安全、更规范的方式来表示...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值