java泛型详解

注：Java中的泛型，只在编译阶段有效。
泛型类和泛型接口一样的规则，这里就不讲泛型接口了

一、泛型类

简单泛型类。

    public static void main(String[] args) {
        //泛型类
        Demo<Integer> dw = new Demo<Integer>();
        dw.show(11);
        Demo<String>d1 = new Demo<String>();
        d1.print("haha");
    }

class Demo<T> {
    public void show(T t) {
        System.out.println("show: " + t);
    }
    public void print(T t) {
        System.out.println("show: " + t);
    }
}

---

泛型类在继承上的体现。

注：

• 子类【重写方法】的参数类型 -->随父类而定；
• 子类新增的方法，参数类型随子类而定；
• 子类中使用父类的【属性】 -->随父类而定；
• 子类使用自己的属性–>随子类而定。

父类

public class Father<T1, T2> {

    public void show(T1 t1, T2 t2) {
        System.out.println(t1 + "-" + t2);
    }
}

子类1

class Son<A, B> extends Father{//等价于class Son extends Father<Object,Object>{
    public void showSon(A a, B b) {
        System.out.println(a + "-" + b);
    }
}

子类2

class Son2 extends Father<Integer, String> {
}

子类3

class Son3<T1, T2>extends Father<Integer, String> {
}

子类4

class Son4<T1, T2, A, B> extends Father<T1, T2> {
}

测试

public static void main(String[] args) {
        Father<String, Integer> father = new Father<>();
        father.show("张", 1);
        
        Son<String,Integer> son = new Son<>();
        //子类调用父类的方法，泛型参数随父类而定，父类没定义泛型，默认<Object,Object>
        son.show("张", "j");
        son.showSon("张", 2);
    }

二、泛型方法

静态方法不可以访问类上定义的泛型。
如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。

  public static void main(String[] args) {
		Demo2 d = new Demo2();
		d.show("hello boy!");
		d.print("Alex i love you !");
		Integer integer = d.print2(2);
		System.out.println(integer);
		Demo2.method("Sdf");
   }

class Demo2 {
    public <T> void show(T t) {
        System.out.println("show: " + t);
    }

    public <Q> void print(Q q) {
        System.out.println("print:" + q);
    }

    public <Q> Q print2(Q q) {
        return q;
    }

	/**
     * 泛型静态方法
     * @param t
     * @param <W>
     */
    public static <W> void method(W t) {
        System.out.println("method: " + t);
    }

}

三、泛型的通配符、有限制的通配符

？表示通配符，对于List<?>就不能向其内部添加数据，除了添加null之外。允许读取数据，读取的数据类型为Object。
注意：
1、不能用在泛型方法声明上，返回值类型前面<>不能使用?。
2、不能用在泛型类的声明上。
3、不能用在创建对象上。

<? extends Object> 和?一样，不能添加数据, 只能读取。只允许泛型为Object及Object子类的引用调用。

<? super Object> 可以添加和读取，只允许泛型为Object及Object父类的引用调用。

代码样例

    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("aaa");
        demo01(list);
        demo02(list);
        demo03(list);
    }

    public static void demo01(List<?> list) {
        //list.add("bbb");//编译失败
        list.stream().forEach(System.out::println);
    }

    public static void demo02(List<? extends Object> list) {
        //list.add("bbb");//编译失败
        list.stream().forEach(System.out::println);
    }

    public static void demo03(List<? super String> list) {
        list.add("bbb");//编译成功
        list.stream().forEach(System.out::println);
    }