Java基础知识总结（第九篇）：泛型和JUnit5

class Person<E> {
    E s;//E 表示 s 的数据类型, 该数据类型在定义 Person 对象的时候指定,即在编译期间，就确定 E 是什么类型

    public Person(E s) {//E 也可以是参数类型
        this.s = s;
    }

    public E f() {//返回类型使用 E
        return s;
    }
}

二、泛型的语法

1.泛型的声明

interface接口<T>{}和class类<K,V>{}

1)其中，T,K,V不代表值，而是表示类型。

2)任意字母都可以。常用T表示，是Type的缩写

2.泛型的实例化

List<String> strList = new Arravlist<String>();

3.泛型使用的注意事项

（1）interface List<T>{},public class HashSet<E>{}中T,E只能是引用类型

（2）在给泛型指定具体类型后，可以传入该类型或者其子类类型

（3）泛型使用形式

List<Integer> list1 =new ArrayList<Integer>()

List<Integer> list2 =new ArrayList<>()

（4）如果这样写List list3 =new ArrayList()（默认给它的泛型是<E>，E就是Object)

三、自定义泛型类

1.基本语法

class 类名<T,R...> {//....表示可以有多个泛型

成员

}

2.说明

（1）普通成员可以使用泛型(属性、方法、返回值)

（2）使用泛型的数组，不能初始化

（3）静态方法和静态属性不能使用泛型（因为静态是和类相关的，静态的加载在泛型之前，在类加载时，对象还没有创建，泛型还没有指定类型，所以，如果静态方法和静态属性使用了泛型，JVM 就无法完成初始化）

（4）泛型类的类型，是在创建对象时确定的(因为创建对象时，需要指定确定类型)

（5）如果在创建对象时，没有指定类型，默认为Object

class Tiger<T, R, M> {
    String name;
    R r; //属性使用到泛型
    M m;
    T t;
    //因为数组在new的时候不能确定 T 的类型，就无法在内存开空间
    T[] ts;
    public Tiger(String name) {
        this.name = name;
    }
    public Tiger(R r, M m, T t) {//构造器使用泛型
        this.r = r;
        this.m = m;
        this.t = t;
    }
}

四、自定义泛型接口

1.基本语法

interface接口名<T,R...>{

}

2.说明

（1）接口中，静态成员也不能使用泛型(原因和泛型类一样)

（2）因为接口中属性默认的修饰符是public final static，所以属性不能使用泛型

（3）泛型接口的类型，在继承接口或者实现接口时确定

（4）没有指定类型，默认为Object

interface IUsb<U, R> {
    int n = 10;
    //普通方法中，可以使用接口泛型
    R get(U u);
    void hi(R r);
    void run(R r1, R r2, U u1, U u2);
    //在 jdk8 中，在接口中，使用默认方法, 也是可以使用泛型
    default R method(U u) {
        return null;
    }
}

//在继承接口 指定泛型接口的类型
interface IA extends IUsb<String, Double> {
}

//实现 IA 接口时，因为 IA 在继承 IUsu 接口时，指定了 U 为 String R 为 Double
//，在实现 IUsu 接口的方法时，使用 String 替换 U, 是 Double 替换 R
class AA implements IA {
    @Override
    public Double get(String s) {
        return null;
    }
    @Override
    public void hi(Double aDouble) {
    }
    @Override
    public void run(Double r1, Double r2, String u1, String u2) {
    }
}

//实现接口时，直接指定泛型接口的类型
//给 U 指定 Integer 给 R 指定了 Float
//所以，当我们实现 IUsb 方法时，会使用 Integer 替换 U, 使用 Float 替换 R
class BB implements IUsb<Integer, Float> {
    @Override
    public Float get(Integer integer) {
        return null;
    }
    @Override
    public void hi(Float aFloat) {
    }
    @Override
    public void run(Float r1, Float r2, Integer u1, Integer u2) {
    }
}

五、自定义泛型方法

1.基本语法

修饰符 <T,R..>返回类型方法名(参数列表) {

}

2.说明

（1）泛型方法，可以定义在普通类中，也可以定义在泛型类中

（2）当泛型方法被调用时，类型才会确定。每次方法调用时，类型可以不一样。

（3）public void eat(E e){},修饰符后没有<T,R..>，则eat方法不是泛型方法，而是使用了泛型

class Bird<T,R,M>{
        public <E> void fly(E t) {
            System.out.println(t);
        }
}
class Fish {
    public <A> A show(A t){
            System.out.println("t的值："+t);
            System.out.println("t的类型："+t.getClass().getSimpleName());
            return t;
    }
}

六、泛型的继承和通配

（1）泛型不具备继承性

List<Object> list =new ArrayList<String>();//不能这样写

（2）<?>:支持任意泛型类型

（3）<?extends A>:支持A类以及A类的子类，规定了泛型的上限

（4）<?super A>:支持A类以及A类的父类，不限于直接父类，规定了泛型的下限

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

        Object o = new String("xx");

        //泛型没有继承性
        //List<Object> list = new ArrayList<String>();

        //举例说明下面三个方法的使用
        List<Object> list1 = new ArrayList<>();
        List<String> list2 = new ArrayList<>();
        List<AA> list3 = new ArrayList<>();
        List<BB> list4 = new ArrayList<>();
        List<CC> list5 = new ArrayList<>();

        //如果是 List<?> c ，可以接受任意的泛型类型
        printCollection1(list1);
        printCollection1(list2);
        printCollection1(list3);
        printCollection1(list4);
        printCollection1(list5);

        //List<? extends AA> c： 表示 上限，可以接受 AA或者AA子类
//        printCollection2(list1);//×
//        printCollection2(list2);//×
        printCollection2(list3);//√
        printCollection2(list4);//√
        printCollection2(list5);//√

        //List<? super AA> c: 支持AA类以及AA类的父类，不限于直接父类
        printCollection3(list1);//√
        //printCollection3(list2);//×
        printCollection3(list3);//√
        //printCollection3(list4);//×
        //printCollection3(list5);//×

    }
    // ? extends AA 表示 上限，可以接受 AA或者AA子类
    public static void printCollection2(List<? extends AA> c) {
        for (Object object : c) {
            System.out.println(object);
        }
    }

    //说明: List<?> 表示 任意的泛型类型都可以接受
    public static void printCollection1(List<?> c) {
        for (Object object : c) { // 通配符，取出时，就是Object
            System.out.println(object);
        }
    }



    // ? super 子类类名AA:支持AA类以及AA类的父类，不限于直接父类，
    //规定了泛型的下限
    public static void printCollection3(List<? super AA> c) {
        for (Object object : c) {
            System.out.println(object);
        }
    }

}

//AA是BB的父类，BB是CC的父类
class AA {
}
class BB extends AA {
}
class CC extends BB {
}

七、JUnit5

1.基本介绍

（1）JUnit5是一个Java语言的单元测试框架

（2）JUnit5包括JUnit Platform、JUnit Jupiter和JUnit Vintage

2.maven中安装JUnit5

在pom.xml配置文件中添加以下依赖

<dependencies>
    <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter</artifactId>
        <version>5.8.2</version>
        <scope>test</scope>
    </dependency>
</dependencies>

3.使用

在测试用例上添加@Test注解

@Test
public void test1(){
    System.out.println("test1方法被运行");
}

在命令行执行需注意

（1）要对对应module路径下面执行mvn test命令

（2）要符合JUnit5命令规则，即以Test开头或者以Test结尾

IDEA快速生成测试文件：在对应类名上鼠标右键->Go To->Test

4.JUnit5命名规则

（1）单元测试代码文件

默认写在工程目录：src/test/java
不允许写在业务代码目录下

（2）测试资源文件

默认写在资源目录：src/test/resources

（3）默认命名规则：以Test开头或者以Test结尾

注意：idea并没有针对文件名做限制，但是使用mven构建时，则不会收集不满足规则要求的用例