Java中的泛型(看这篇就够了)

泛型

• 泛型的本质是参数化类型，即所操作的数据类型被指定为一个参数
• 可以声明泛型类、泛型方法和泛型接口（下一章介绍接口）
• 下面通过例题演示一下泛型类和泛型方法
  泛型的通配符：K、T、V、E、？

K - Key（键）
T - Type（Java 类），T代表在调用时的指定类型。会进行类型推断
V - Value（值）、N - Number（数值类型）
E - Element (在集合中使用，因为集合中存放的是元素)，E是对各方法中的泛型类型进行限制，以保证同一个对象调用不同的方法时，操作的类型必定是相同的。E可以用其它任意字母代替
？- 表示不确定的java类型，是类型通配符，代表所有类型。？不会进行类型推断

泛型的好处是在编译的时候检查类型安全

泛型的由来

我们都知道Java里的集合(list,map…)是可以存放任意对象的，只要把对象存储集合后，那么这时他们都会被提升成Object类型。当我们在取出每一个对象，并且进行相应的操作，这时必须采用类型转换。看下面这段示例代码

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class JavaTest{
    public static void main(String[] args) {
        Collection coll = new ArrayList();
        coll.add("mobai");
        coll.add("墨白");
        coll.add(5);//由于集合没有做任何限定，任何类型都可以给其中存放
        Iterator it = coll.iterator();
        while (it.hasNext()) {
            //需要打印每个字符串的长度,就要把迭代出来的对象转成String类型
            String str = (String) it.next();
            System.out.println(str.length());
        }
    }
}

Exception in thread "main" 5
2
java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String

为什么会发生类型转换异常呢？我们来分析下：由于集合中什么类型的元素都可以存储。导致取出时强转引发运行时 ClassCastException。怎么来解决这个问题呢？
Collection虽然可以存储各种对象，但实际上通常Collection只存储同一类型对象。例如都是存储字符串对象。因此 在JDK5之后，新增了泛型(Generic)语法，让你在设计API时可以指定类或方法支持泛型，这样的话我们使用API的时候也变得更为简洁，并得到了编译时期的语法检查。

例：泛型类(紧跟类名后面)

由ArrayList源码做延伸

class ArrayList<E> {
    public boolean add(E e) {
    }
    public E get(int index) {
    }
}

E—>Integer

class ArrayList<Integer> {
    public boolean add(Integer e) {
    }
    public Integer get(int index) {
    }
}

测试demo：

class GeneralType<Type> {
    Type object;

    public GeneralType(Type object) {
        this.object = object;
    }

    public Type getObj() {
        return object;
    }
}

public class Test {
    public static void main(String args[]) {
        GeneralType<Integer> i = new GeneralType<Integer>(2);
        GeneralType<Double> d = new GeneralType<Double>(0.33);
        System.out.println("i.object=" + i.getObj());
        System.out.println("i.object =" + d.getObj());
    }
}

i.object=2
i.object =0.33

例：泛型方法(紧跟修饰符public后面)

class GeneralMethod {
    public <Type> void printClassName(Type object) {
        System.out.println(object.getClass().getName());
    }
}

public class Test {
    public static void main(String[] args) {
        GeneralMethod gm = new GeneralMethod();
        gm.printClassName("hello");
        gm.printClassName(3);
        gm.printClassName(3.0f);
        gm.printClassName(3.0);
    }
}

java.lang.String
java.lang.Integer
java.lang.Float
java.lang.Double

例：泛型接口(接口名后)

interface MyGenericInterface<E> {
    public abstract void add(E e);
    public abstract E gitE();
}

class MyImpl2<E> implements MyGenericInterface<E> {
    @Override
    public void add(E e) {
    }
    
    @Override
    public E gitE() {
        return null;
    }
}

public class JavaTest {
    public static void main(String[] args) {
        MyImpl2<String> my = new MyImpl2<String>();
        my.add("墨白");
    }
}

例：?通配符使用

//变量赋值或变量声明时候使用
List<?> list;
List<? extends Number> uNumberList;
List<? super Integer> intgerList;

有限制的泛型

之前设置泛型的时候，实际上是可以任意设置的，只要是类就可以设置。但是在JAVA的泛型中可以指定一个泛型的上限和下限。
泛型的上限：
格式：类型名称 <? extends 类 > 对象名称 意义：只能接收该类类型型及其子类
泛型的下限：
格式：类型名称 <? super 类 > 对象名称 意义：只能接收该类类型及其父类型
举个例子,比如：现已知Object类，String 类，Number类，Integer类，其中Number是Integer的父类

public class JavaTest {
public static void main(String[] args) {
        Collection<Integer> c1 = new ArrayList<Integer>();
        Collection<String> c2 = new ArrayList<String>();
        Collection<Number> c3 = new ArrayList<Number>();
        Collection<Object> c4 = new ArrayList<Object>();

        getElementOne(c1);
        getElementOne(c2);// 编译报错
        getElementOne(c3);
        getElementOne(c4);// 编译报错

        getElementTow(c1);// 编译报错
        getElementTow(c2);// 编译报错
        getElementTow(c3);
        getElementTow(c4);
    }
    // 泛型的上限：此时的泛型?，必须是Number类型或者Number类型的子类
    public static void getElementOne(Collection<? extends Number> collection){}
    // 泛型的下限：此时的泛型?，必须是Number类型或者Number类型的父类
    public static void getElementTow(Collection<? super Number> collection){}
}

List<? extends T>和List <? super T>有什么区别?

List<? extends T>只能接收该类类型型及其子类类型的List
List<? super T>只能接收该类类型及其父类型的List
例如List<? extends Number>可以接受List<Integer>或List<Float>