Java 泛型

泛型的概念

在1.5之前， 没有泛型的感念；一个list中可以添加String类型的数据，也可以添加Integer类型的数据。很容易出现问题
在1.5之后，有了泛型的概念；可以在编译期间对类型进行限定，避免出现问题

泛型的重要概念

泛型的使用位置

1. 可以用在类上；在类中，不要想的太复杂，就把T当成String类型来看待；String类型怎么使用，T类型就怎么使用

// T表示传入的类型
public class Printer<T> {
    // 定义的泛型变量
    private T content;

    // 构造器传入的泛型对象
    public Printer(T content) {
        this.content = content;
    }

    // 在类中的方法，就把T当做String这种类型的变量，正常使用就行
    public T getContent() {
        return content;
    }

    // 此处直接打印T类型的对象
   public void print(){
       System.out.println(content);
   }
}

2. 也可以用在方法上【作用在方法上时，与类的定义的泛型标签要不一致】
   1. 作用在方法上时，如果使用和类中定义的泛型一致，则直接使用即可。

// T表示传入的类型
public class Printer<T> {
    // 定义的泛型变量
    private T content;

    // 构造器传入的泛型对象
    public Printer(T content) {
        this.content = content;
    }

    // 在类中的方法，把T当做String这种类型的变量，正常使用就行
    public T getContent() {
        return content;
    }

    // 此处直接打印T类型的对象[推荐这种方法，直接使用泛型数据]
   public void print(){
       System.out.println(content);
   }

    /**
    * 此处的T和类定义的T一致，因此，使用的类实例化时候传入的类型
    * 比如:
    * 1.Printer<String> printer = new Printer<>("hello"); 此处使用的String类型；
    * 2.调用printStr方法时，传入的参数类型必须和String一致，否则编译器会报错
    * 3.如果确定类型不一致，则使用新的标签来定义方法，如：public <E> String printStr(E data)
    * @param data
    * @return
    */
   public String printStr(T data){
        return data+"str";
   }
        
}

2. 如果类型不一致 ，则需要新的类型标签；要在返回值前面加上标签来表示方法的泛型 格式是：public String print(E data)

public class Printer<T> {
    private T content;

    public Printer(T content) {
        this.content = content;
    }

    public T getContent() {
        return content;
    }

   public void print(){
       System.out.println(content);
   }
    
    /**
     * 用在方法上时，要在返回值前面加上泛型<E>
     * @param data
     * @param <E>
     */
   public <E> void print(E data){
       System.out.println("print data:"+data);
   }
}

3. 泛型作用在方法上时，也可能是类上没有泛型，只是方法有泛型

public class PrinterTest {

    // 此方法，使用了泛型
    public <T> void print(T content){
        System.out.println(content);
    }
}

T，K，V，E等标签

1. 以上是定义泛型的常用标签；

T表示Type， K表示Key，V表示Value，E表示Element

2. T，K，V，E有一些常用的意义，因此，泛型用来当做标签。也可以用其他字母来做标签

/**
 * 用H用作泛型的标签
 * @author zouruihuisz
 * @version v1.0
 * @date 2024/8/9
 */
public class GenericClass<H> {
    // H用作泛型的标签
    H data;
    public GenericClass(H data){
        this.data = data;
    }

    public void print(){
        System.out.println(data);
    }
}

多标签使用，通配符 ？，上界extends ，下界 Super

1. 多个标签用在泛型中

/**
 * 多个标签用在泛型中
 * @author zouruihuisz
 * @version v1.0
 * @date 2024/8/9
 */
public class MultiTabGenericClass<K,V> {
    K key;
    V value;
    public MultiTabGenericClass(K key, V value) {
        this.key = key;
        this.value = value;
    }

    public static void main(String[] args) {
        MultiTabGenericClass<String, Integer> multiTabGenericClass = new MultiTabGenericClass<>("key", 1);
        System.out.println(multiTabGenericClass.key);
        System.out.println(multiTabGenericClass.value);
    }

}

2. 在extends中，使用&继承类或接口；方式是： <T extends Class & Interface> 一定是类在前，接口在后 ;同时，传入的对象必须继承了类并实现了接口

/**
 * @author zouruihuisz
 * @version v1.0
 * @date 2024/8/9
 */
public class ExtendsMultiTest {

    public static void main(String[] args) {
        Car car = new Car();
        // car对象继承了Vehicle类，并实现了Thing接口
        test(car);
    }

    /**
     * 1. 在extends上限中，使用了&符号，表示同时继承类和接口；类在前面，接口在后面
     * 2. 传入的对象，也必须是继承了Vehicle类和实现了Thing接口
     * @param e
     * @param <E>
     */
    public static <E extends Vehicle & Thing> void test(E e){
        System.out.println("enter element " +e);
    }
}

3. 使用通配符？与extends一起使用。 方式是： Collection<? extends Class >； class表示上限;但只能用到Collection中，不能单独使用

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

/**
 * 通配符？测试用例
 * @author zouruihuisz
 * @version v1.0
 * @date 2024/8/9
 */
public class GeneralGenericTest {
    public static void main(String[] args) {

        List<Animal> list1 = new ArrayList<>();
        // Cat继承了Animal
        list1.add(new Cat("白色"));
        list1.add(new Cat("黑色"));
        list1.add(new Cat("花色"));
        test2(list1);
    }

    /**
     * 1. 通配符？只能用在Collection或实现类中,如下代码所示；不能像这样: <? extends Animal>单独使用
     * @param list
     */
    public static void test2(List<? extends Animal> list){

        list.stream().forEach(System.out::println);
    }
}
      

4. 使用通配符？与super一起使用。 方式是： Collection<? super Class >； class表示上限;但只能用到Collection中，不能单独使用

package com.kingreda.cn.generic;

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

/**
 * 通配符？测试用例
 * @author zouruihuisz
 * @version v1.0
 * @date 2024/8/9
 */
public class GeneralGenericTest {
    public static void main(String[] args) {

        List<Animal> list1 = new ArrayList<>();
        // Animal是Cat的父类
        list1.add(new Animal("白色"));
        list1.add(new Animal("黑色"));
        list1.add(new Animal("花色"));
        test2(list1);
    }

    /**
     * 1. 通配符？只能用在Collection或实现类中,如下代码所示；不能像这样: <? super Cat>单独使用
     * @param list
     */
    public static void test2(List<? super Cat> list){
        // 传入的是Cat的父类Animal对象
        list.stream().forEach(System.out::println);
    }
}