Java泛型详解

泛型类及其方法

1. 泛型定义在类名上， ,T 可以是任意字符如A、B、C。
2. 类中的方法（普通方法、静态方法、构造方法）可以使用类的泛型T。

package com.example.demo;


import lombok.Data;

import java.util.Collections;
import java.util.List;
import java.util.Set;

/**
 * @author CCL
 * @createTime 2021年12月24日
 */
@Data
public class Demo1<T> {
    private int age;
    private T a;

    public Demo1(int age, T a) {
        this.age = age;
        this.a = a;
    }

    /**
     * 入参为泛型，出参为void
     */
    public void call(T a) {
        this.a = a;
        System.out.println(a);
    }

    /**
     * 入参为泛型，出参为特定类型
     */
    public String say(T a) {
        return a.toString();
    }

    /**
     * 入参为泛型，出参为泛型，List<T>为出参类型
     */
    public List<T> cry(T a) {
        return Collections.singletonList(a);
    }

    /**
     * 入参为泛型，出参为泛型
     *
     * @param set
     * @return
     */
    public List<T> cry(Set<T> set) {
        return Collections.singletonList(set.iterator().next());
    }

    /**
     * 用<>表示的方法才是泛型方法，否则只能是使用了类泛型的方法
     * @param e
     * @param t
     * @param <E>
     */
    public <E> void fun1(E e,T t){
        System.out.println(e.toString());
        System.out.println(t.toString());
    }
}

普通类中的泛型方法

1. 类可以没有泛型。
2. 方法必须在公开符和返回参数之间用 标识这是一个泛型方法。

import java.util.Collections;
import java.util.List;

public class Demo2 {
    //泛型作为入参
    public <E> void fun1(E t){
        System.out.println(t.toString());
    }
    //有返回值的泛型
    public <E> List<E> fun2(E t){
        return Collections.singletonList(t);
    }
    //多个泛型
    public <E,T> List<E> fun2(E e,T t){
        System.out.println(e);
        System.out.println(t);
        return Collections.singletonList(e);
    }
}

泛型的范围限定

1. 用泛型限定T只能是某个类的子类

示例1：用在类上，并泛型调用方法

public class Demo3<T extends Number> {

    public void demo(T t){
        System.out.println(t.intValue());
    }

    public static void main(String[] args) {
        Demo3<Long> demo3 = new Demo3<>();
        Long size = 4L;
        demo3.demo(size);
    }
}

示例2：用在集合上，可以get,get出来的使用泛型指定的父类型来接收。但add时无论什么类型都会报错。

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

        List<? extends Number> list= new ArrayList<>();
        List<String> strList = Arrays.asList("a", "b");
        List<Integer> intList = Arrays.asList(1, 2);
        //Integer为Number的子类型，赋值正常
        list=intList;
        //String的List在编译时会报错
        list=strList;
    }
}

示例3：

    public void play(){
        //这里赋值没问题
        List<? extends A> list = Arrays.asList(new A(), new B(), new C());
        //取出可以
        A a0 = list.get(0);
        A a1 = list.get(1);
        A a2 = list.get(2);
        //下面所有add编译报错，因为
        list.add(new A());
        list.add(new B());
        list.add(new C());
        list.add(new Object());

    }

2. 限定下限

用泛型设定?只能是指定类型及其父类。
用在集合上时，可以add指定类型及其父类，get时只能用Object接收。

class A {}
class B extends A{}
class C extends B{}

    public static void main(String[] args) {
        List<? super B> list = new ArrayList<>();
        list.add(new A());//报错，只能add B及其父类
        list.add(new B());
        list.add(new C());
        System.out.println(list);
        //get出的类型为Object
        Object object = list.get(0);

    }

3.无限定通配符

无限定通配符表示不需要限定任何类型。

 class PairAlg {
     public  boolean play(List<?> p) {
         return p.get(0) == null || p.get(1) == null;
     }
    public static boolean hasNulls(List<?> p) {
        return p.get(0) == null || p.get(1) == null;
    }
}