java-泛型

泛型就是一种接收数据类型的一种数据类型。

package com.xxb.generic;

import java.util.ArrayList;

public class Generic01 {
    @SuppressWarnings({"all"})
    public static void main(String[] args) {
        //        alt+insert
        ArrayList<Dog> objects = new ArrayList<Dog>();
        objects.add(new Dog("xxx",10));
        objects.add(new Dog("sss",20));
        objects.add(new Dog("mmm",30));
//        objects.add(new Cat("喵呜",30));
        for (Dog dog : objects) {
            System.out.println(dog.getName()+"-"+dog.getAge());
        }

    }
}
class Dog{
    private String name;
    private int age;
    public Dog(String name,int age){
        this.name=name;
        this.age=age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}
class Cat{
    private String name;
    private int age;
    public Cat(String name,int age){
        this.name=name;
        this.age=age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

泛型的语法

实例

package com.xxb.generic;

import java.util.*;

@SuppressWarnings({"all"})
public class TestGeneric2 {
    public static void main(String[] args) {
        //使用泛型方式给HashSet放入3个学生对象
        HashSet<Student> students = new HashSet<Student>();
        students.add(new Student("jack",18));
        students.add(new Student("mark",20));
        students.add(new Student("fuck",15));
        //遍历
        for (Student student:students) {
            System.out.println(student);
        }

        //使用hashMap
        HashMap<String, Student> hm = new HashMap<String,Student>();
        hm.put("jack",new Student("jack",28));
        hm.put("mark",new Student("mark",15));
        hm.put("fuck",new Student("fuck",12));

        //迭代器 EntrySet 循环  var快捷键
        Set<Map.Entry<String, Student>> entries = hm.entrySet();
        Iterator<Map.Entry<String, Student>> iterator = entries.iterator();
        while (iterator.hasNext()) {
            Map.Entry<String, Student> next =  iterator.next();
            System.out.println(next.getKey()+'-'+next.getValue());
        }



    }
}
class Student {
    public  String name;
    private  int age;

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

泛型使用细节

实例

package com.xxb.generic;

import java.util.ArrayList;
@SuppressWarnings({"all"})
public class GenericDetail {
    public static void main(String[] args) {
        //1.泛型类型是一个引用类型，不是基本数据类型
        ArrayList<Integer> integers = new ArrayList<Integer>();//ok
        //ArrayList<int> ints = new ArrayList<int>();//error ,int不是一个引用类型

        //2.在给泛型指定具体类型后,可以传入该类型或者其子类类型
        //因为E制定了A类型，构造器传入了new A()
        Pig<A> aPig = new Pig<A>(new A());
//        Pig<A> aPig1 = new Pig<A>(new B());//error
        Pig<A> aPig1 = new Pig<A>(new C());//C是A的子类型

        //3.泛型使用形式
        ArrayList<Integer> integers1 = new ArrayList<Integer>();

        //实际开发中，我们往往简写
        //编译器会进行类型推断，推荐使用下面写法
        ArrayList<Integer> objects = new ArrayList<>();

        //4. 如果是这样写 泛型默认是Object
        ArrayList arrayList=new ArrayList();
        //等价于 ArrayList<Object> arrayList=new ArrayList<>();


    }
}
class A{}
class B{}
class C extends A{}
class Pig<E>{
    E e;

    public Pig(E e) {
        this.e = e;
    }
}

自定义泛型

自定义泛型类

package com.xxb.customgeneric;

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

    }
}
// 1. Tiger后面泛型 所以我们把Tiger就称为自定义泛型类
// 2. T R  M 泛型的标识符 ，一般是单个大写字母
// 3. 泛型的标识符可以是多个。
// 4. 普通 成员可以使用泛型(属性、方法)
// 5. 使用泛型的数组不能初始化。
class Tiger<T,R,M>{
    String name;
    R r; //属性使用到泛型
    M m;
    T t;
    //因为数组在new 不能确定T的类型，就无法在内存开空间。
//    T[]=new T[8]; error
//    因为静态是和类相关的，在类加载的时候 对象还没有创建。 泛型只有类创建的时候才会初始化
    //所以，如果静态方法和静态属性使用了泛型，JVM就无法完成初始化。
//    static  R r2;
    public Tiger(String name, R r, M m, T t) {//构造器使用泛型
        this.name = name;
        this.r = r;
        this.m = m;
        this.t = t;
    }

    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;
    }
}

自定义泛型接口

package com.xxb.customgeneric;

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

    }
}
/**
 * 自定义泛型接口 使用说明
 * 1. 接口中，静态成员也不能使用泛型
 * 2.泛型接口的类型，在继承接口或者实现接口时确定
 */
interface  IUsb<U,R>{
    //接口中的成员都是静态的
    //普通方法中，可以使用接口泛型
    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在继承IUsb接口时，指定了U为String R为Double
//在实现IUsb接口的方法时，使用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) {

    }

    @Override
    public Double method(String s) {
        return IA.super.method(s);
    }
}

//实现接口时，直接指定泛型接口的类型
//给U指定Integer 给R指定了Float
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) {

    }

    @Override
    public Float method(Integer integer) {
        return IUsb.super.method(integer);
    }
}

//没有指定类型  默认为Object
class CC implements  IUsb{
    @Override
    public Object get(Object o) {
        return null;
    }

    @Override
    public void hi(Object o) {

    }

    @Override
    public void run(Object r1, Object r2, Object u1, Object u2) {

    }
}

自定义泛型方法

package com.xxb.customgeneric;

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

    }
}

class Car<T,R>{//普通类
    public void run(){
        //普通方法
    }
    public <U,M> void eat(U u, M m){
        //泛型方法

    }
    //说明
    //1.下面hi方法不是泛型方法
    //2.是hi方法使用了类声明的泛型
    public void hi(T t){

    }
    //泛型方法，可以使用类声明的泛型，也可以使用自己声明泛型
    public <K> void hello(R r, K k){

    }
    

泛型的继承和通配符

package com.xxb.customgeneric;

import java.util.ArrayList;
import java.util.List;

/**
 * 泛型的继承和通配符
 */
public class GenericExtends {
    public static void main(String[] args) {
        Object o =new String("xx");

        //泛型没有继承性
        //List<Object> list =new ArrayList<String>(); error
        List <Object> list1=new ArrayList<>();
        List <String> list2=new ArrayList<>();
        List <DD> list3=new ArrayList<>();
        List <EE> list4=new ArrayList<>();
        List <FF> list5=new ArrayList<>();
        printCollection1(list3);
        printCollection2(list5);
        printCollection3(list3);

    }
    //说明 List<?>表示任意泛型类型都可以接收
    public  static void printCollection1(List<?> c){
        for (Object o :c) {
            System.out.println(o);
        }

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

    }

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






}

class DD{

}
class EE extends DD{

}

class FF extends EE{

}

​

​

JUnit的使用