java——泛型和JUnit

1、泛型的理解和好处

1.1、使用传统方法的问题分析

1、不能对加入到集合 ArrayList中的数据类型进行约束(不安全)

2、遍历的时候，需要进行类型转换,如果集合中的数据量较大，对效率有影响

1.2、泛型的好处

1、编译时，检查添加元素的类型，提高了安全性

2、减少了类型转换的次数,提高效率

1）不使用泛型

Dog-加入-> Object-取出-> Dog

放入到ArrayList 会先转成 Object,在取出时，还需要转换成Dog

2）使用泛型

Dog -> Dog -> Dog

放入时，和取出时，不需要类型转换，提高效率

3、不再提示编译警告

二、泛型的介绍

int a = 10;

泛(广泛)型(类型)=>Integer, String,Dog

1、泛型又称参数化类型，是Jdk5.0出现的新特性,解决数据类型的安全性问题

2、在类声明或实例化时只要指定好需要的具体的类型即可。

3、Java泛型可以保证如果程序在编译时没有发出警告，运行时就不会产生ClassCastException异常。同时，代码更加简洁、健壮

4、泛型的作用是:可以在类声明时通过一个标识表示类中某个属性的类型，或者是某个方法的返回值的类型，或者是参数类型。

三、泛型的语法

3.1、泛型的声明

interface 接口<T>{}
class 类名 <K,V>{}//比如: List, ArrayList

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

2、任意字母都可以。常用T表示，是Type的缩写(T、E、U、R、M、V......)

3.2、泛型的实例

要在类名后面指定类型参数的值(类型)。如:

List<String> strList = new ArrayList<String>();
Iterator<Customer> iterator = customers.iterator();

3.3、泛型使用举例

使用泛型方式给 HashSet 放入 3 个学生对象

HashSet<Student> students = new HashSet<Student>();
students.add(new Student("jack", 18));
students.add(new Student("tom", 28));
students.add(new Student("mary", 19));

遍历

HashSet<Student> students = new HashSet<Student>();
students.add(new Student("jack", 18));
students.add(new Student("tom", 28));
students.add(new Student("mary", 19));
for (Student student : students) {
    System.out.println(student);
}

HashMap<String, Student> hm = new HashMap<String,Student>;
hm.put("milan", new Student("milan", 38));
hm.put("smith", new Student("smith", 48));
hm.put("hsp", new Student("hsp", 28));
Set<Map.Entry<String, Student>> entries = hm.entrySet();
Iterator<Map.Entry<String, Student>> iterator = entries.iterator();
System.out.println("==============================");
while (iterator.hasNext()) {
    Map.Entry<String, Student> next = iterator.next();
    System.out.println(next.getKey() + "-" + next.getValue());
}

 3.4、泛型使用的注意事项和细节

1. interface List<T>{}， public class HashSet<E>{}，...

说明：T，E只能是引用类型

判断正误

List<Integer> list = new ArrayList<Integer>0: //OK
List<int> list2 = new ArrayList<int>();//错误

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

3.泛型使用形式

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

3.如果这样写List list3 = new ArrayList();默认给他的泛型是[<E> E就是Object]

四、自定义泛型（难）

4.1、基本语法

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

4.2、注意细节

1、普通成员可以使用泛型(属性、方法)

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

3、静态方法中不能使用类的泛型

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

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

import java.util.Arrays;

@SuppressWarnings({"all"})
public class CustomGeneric_ {
    public static void main(String[] args) {

        //T=Double, R=String, M=Integer
        Tiger<Double,String,Integer> g = new Tiger<>("john");
        g.setT(10.9); //OK
        //g.setT("yy"); //错误，类型不对
        System.out.println(g);
        Tiger g2 = new Tiger("john~~");//OK T=Object R=Object M=Object
        g2.setT("yy"); //OK ,因为 T=Object "yy"=String 是Object子类
        System.out.println("g2=" + g2);

    }
}

//1. Tiger 后面泛型，所以我们把 Tiger 就称为自定义泛型类
//2, T, R, M 泛型的标识符, 一般是单个大写字母
//3. 泛型标识符可以有多个.
//4. 普通成员可以使用泛型 (属性、方法)
//5. 使用泛型的数组，不能初始化
//6. 静态方法中不能使用类的泛型
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;
    }

    public Tiger(String name, R r, M m, T t) {//构造器使用泛型
        this.name = name;
        this.r = r;
        this.m = m;
        this.t = t;
    }

    //因为静态是和类相关的，在类加载时，对象还没有创建
    //所以，如果静态方法和静态属性使用了泛型，JVM就无法完成初始化
//    static R r2;
//    public static void m1(M m) {
//
//    }

    //方法使用泛型

    public String getName() {
        return name;
    }

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

    public R getR() {
        return r;
    }

    public void setR(R r) {//方法使用到泛型
        this.r = r;
    }

    public M getM() {//返回类型可以使用泛型.
        return m;
    }

    public void setM(M m) {
        this.m = m;
    }

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }

    @Override
    public String toString() {
        return "Tiger{" +
                "name='" + name + '\'' +
                ", r=" + r +
                ", m=" + m +
                ", t=" + t +
                ", ts=" + Arrays.toString(ts) +
                '}';
    }
}

4.3、自定义泛型接口

4.3.1、基本语法

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

4.3.2、注意细节

1、接口中，静态成员也不能使用泛型(这个和泛型类规定一样)

2、泛型接口的类型,在继承接口或者实现接口时确定

3、没有指定类型，默认为Object

4.4、自定义泛型方法

4.4.1、基本语法

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

4.4.2、注意细节

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

2、当泛型方法被调用时，类型会确定

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

五、泛型的继承和通配符说明

1、泛型不具备继承性

List<Object> list = new ArrayList<String>();//对吗? ×

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

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

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

六、JUnit

6.1、为什么需要 JUnit

1、一个类有很多功能代码需要测试，为了测试，就需要写入到main方法中

2、如果有多个功能代码测试，就需要来回注销，切换很麻烦

3、如果可以直接运行一个方法，就方便很多，并且可以给出相关信息，就好了->JUnit

6.2、基本介绍

1、JUnit是一个Java语言的单元测试框架

2、多数Java的开发环境都已经集成了JUnit作为单元测试的工具

6.3、使用方法

import org.junit.Test;
public class JUnit_ {
    public static void main(String[] args) {
        //传统方式
        //new JUnit_().m1();
        //new JUnit_().m2();

    }


    @Test
    public void m1() {
        System.out.println("m1方法被调用");
    }

    @Test
    public void m2() {
        System.out.println("m2方法被调用");
    }

    @Test
    public void m3() {
        System.out.println("m3方法被调用");
    }
}