我在上海乐字节学习Java的三十天

一、测试分类

1.黑盒测试

定义：不需要写代码，给输入值，看程序是否能够输出期望的值。

特点：程序的代码，程序里面涉及到的一些算法，结构...都看不到

2.白盒测试

定义：需要写代码的，关注程序具体的执行流程。

特点：程序的代码，程序的信息，程序员是看的到的，并且还能够做一定的修改

二、Junit使用：白盒测试

1. 定义一个测试类(测试用例)
   • 建议：
   • 测试类名：被测试的类名Test CalculatorTest
   • 包名：xxx.xxx.xx.test com.bianyiit.cast.test
2. 定义测试方法：可以独立运行
   • 建议：
   • 方法名：test测试的方法名 testAdd()
   • 返回值：void
   • 参数列表：空参
3. 给方法加@Test
4. 导入junit依赖环境

1.定义一个类Calculator

package com.bianyiit.cast;

public class Calculator {
    //CalculatorTest
    /**
     *
     * @param a
     * @param b
     * @return
     */
    public int getAdd(int a,int b){
        //int c=3/0;
        return a-b;
    }

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

2.定义一个测试类(测试用例)

package com.bianyiit.test;

import com.bianyiit.cast.Calculator;
import org.junit.Assert;
import org.junit.Test;

/*测试类---用来测试Calculator这个类*/
public class CalculatorTest { //测试类不能独立运行
    //测试类没有主方法

    //可以定义测试方法（可以独立运行的）
    //测试方法的格式：给方法加注解@Test
    @Test
    public void testgetAdd(){  //建议空参，返回值为void，方法名：test+测试的方法名
        //创建Calcutor对象
        Calculator c=new Calculator();
        int add = c.getAdd(1, 2);
        System.out.println(add);
    }
    @Test
    public void testgetSub(){
        Calculator c=new Calculator();
        int sub = c.getSub(5, 4);
        System.out.println(sub);
    }
}

注意：刚开始@Test是不可用的，在它左边有个小灯泡，点击，然后添加Junit4的依赖，然后点击OK，就可以了

2.1 输出结果：

判定结果：
红色：失败
绿色：成功

测试注重的不是被测试的程序结果，而是它是否存在错误

一般我们会使用断言操作来处理结果--Assert.assertEquals(期望的结果,运算的结果);

package com.bianyiit.test;
import com.bianyiit.cast.Calculator;
import org.junit.Test;

/*测试类---用来测试Calculator这个类*/
public class CalculatorTest { //测试类不能独立运行
    //测试类没有主方法

    //可以定义测试方法（可以独立运行的）
    //测试方法的格式：给方法加注解@Test
    @Test
    public void testgetAdd(){  //建议空参，返回值为void，方法名：test+测试的方法名
        //创建Calcutor对象
        Calculator c=new Calculator();
        int add = c.getAdd(1, 2);
        //一般会使用断言操作来处理结果
        //Assert.assertEquals(3,add); //断言 我要断言期望的值和真正得到的值一样的时候，证明被测试的方法没有错误，否则被测试的方法是存在错误的
        //期望的结果，运算的结果
        System.out.println(add);
    }
}

2.2 输出结果
在这里插入图片描述

分析：我要断言期望的值和真正得到的值一样的时候，证明被测试的方法没有错误，否则被测试的方法是存在错误的

3.在java中更倾向于测试方法可以具备独立运行的功能

package com.bianyiit.cast;

import org.junit.Test;

public class CeShiDemo1 {
    public static void main(String[] args) {
        System.out.println("show方法");
    }
    //进行单元测试和实现main方法的效果是一样的，都是输出show方法
    @Test
    public void show(){
        System.out.println("show方法");
    }
}

3.1 输出结果

4.单元测试的补充说明

补充：(需要掌握的)
@Before:
修饰的方法会在测试方法之前被自动执行
@After:
修饰的方法会在测试方法执行之后自动被执行

package com.bianyiit.test;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;

public class BeforeAfterTest {
    //@Before:修饰的方法会在测试方法之前被自动执行（用来申请资源空间）
    //@After：修饰的方法会在测试方法之后被自动执行（用来释放资源用的）
    /*测试方法*/
    @Before
    public void init(){
        System.out.println("这是init初始化方法...");
    }
    @After
    public void close(){
        //一般是释放资源用的
        System.out.println("这是close方法...");
    }
    @Test
    public void test1(){
        System.out.println("这是一个测试方法...");
        //int a=10/0;
    }
}

4.1 输出结果

5.总结

1.在一个类中可以自己定义一个单独的测试方法，可以具备独立运行的功能，在方法上面加@Test
然后导入Junit依赖环境
2.@Before @After放在方法上面的含义
@Before标明的方法，里面放用来申请资源空间的代码
@After标明的方法，里面用来放释放资源空间的代码
只要测试方法一执行，@Before先执行，@After最后执行的

三、注解

1.注释与注解的区别

注解：说明程序的。给计算机看的
注释：用文字描述程序的。给程序员看的

2.注解定义

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

3.概念描述

• JDK1.5之后的新特性
• 说明程序的
• 使用注解：@注解名称

4.作用分类

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

5.JDK中预定义的一些注解（内置注解）

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

@Override注解标注截图--检测被该注解标注的方法是否是继承自父类(接口)的

@Deprecated注解标注截图--该注解标注的内容，表示已过时

添加@SuppressWarnings：压制警告之前的截图

添加@SuppressWarnings：压制警告之后的截图----没有黄线的警告信息了

6.自定义注解

格式：
public @interface 注解名称{
属性列表;

格式截图

• 本质：注解本质上就是一个接口，该接口默认继承Annotation接口
• public interface MyAnno extends java.lang.annotation.Annotation {}
  所有的注解都继承了Annotation这个接口。 可以看成是注解的最顶层

7.自定义注解里面可以有哪些方法呢？？

1.注解本身就是一个接口
2.注解中定义常量没有意义，所以注解中只能有抽象方法
3.接口中一般我们写抽象方法是按照下面的格式写的--public abstract int[] arr();
4.属性的返回值类型有下列取值
* 基本数据类型
* String
* 枚举
* 注解
* 以上类型的数组
5.使用自定义注解的时候，需要给注解中的属性赋值，给属性赋值的时候需要注意的细节
*当注释里面只有一个属性，并且属性名为value的时候，属性名是可以省略的
*给数组进行赋值的时候，只有一个值，那么大括号是可以省略的
当属性定义了default的时候，使用注解的时候可以省略赋值的操作/

package com.bianyiit.cast;

import java.lang.annotation.*;

public @interface MyAnnotationDemo { //注解本身就是一个接口
    //注解里面可以存在哪些东西？？--方法
    //接口里面可以存在哪些东西？常量和抽象方法
    String method1();   //注解里面的属性对应接口中的方法
    int age() default 20;
    public abstract int[] arr();
    int[] method3();
    Week week();
    //SuppressWarnings my();
}
//枚举
enum Week{
    Monday,Tuesday
}

//自定义注解的使用
@MyAnnotationDemo(method1 = "张三", arr ={1,2},week = Week.Monday)
public class MyAnnoTestDemo {}

8.元注解的使用

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

对自定义注解的元注解

@Target(value = {ElementType.TYPE,ElementType.FIELD,ElementType.METHOD})//用来标明此注解能够起到作用的位置（TYPE代表只能在类上面起作用）
@Retention(value = RetentionPolicy.RUNTIME)//描述注解被保留的阶段（RUNTIME代表运行期）/自定义注解一般都会选择Runtime 可以让JVM进行识别/
@Documented //将注解加载到api文档中
@Inherited//描述注解是否被子类继承

@interface MyAnnotationYuanZhuJie{ }

这里只对@Target的作用范围进行解释说明，当Target的值为ElementType.TYPE时代表只能在类上面起作用

当Target的值为ElementType.TYPE时代表该自定义注解可以在类、字段和方法上面起作用

当更改为ElementType.TYPE,ElementType.FIELD,ElementType.METHOD之后，这里就没有报错了

推荐一个老师，她那里可以免费领取视频资料及配套资料V:lezijie006 备注67，没有备注老师不会通过哦！！！

四、注解总结

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