1.泛型

 介绍：

        泛型可以在编译阶段约束操作的数据类型，并进行检查。

应用场景：

        如果在定义类、方法、接口的时候，如果类型不确定，就可以使用泛型。

格式：

        <数据类型>

注意：

        泛型只支持引用数据类型

如下图中<String>，就是泛型

细节：

        1.指定泛型的具体类型后，传递数据时，可以传入该类型或者其子类类型

        2.如果不写泛型，类型默认为Object

好处：

        1.统一数据类型

        2.把运行时期的问题提前到了编译期间，避免了强制类型转换可能出现的异常，因为在编译阶段类型就能确定下来

扩展：

        Java中的泛型为伪泛型，即若使用泛型确定类型后，元素若要存入集合，泛型就会检查是否为规定的类，存入集合中时，元素为Object类，但是获取元素时代码底层会将Object类强转成泛型规定的类。

        且编译时会擦除泛型，在class文件中，集合中的元素仍为Object类。

2.泛型类

        泛型类即在类名后面添加泛型约束的类。

下面创建一个泛型类

代码演示：

泛型类MyArratList：

public class MyArrayList <E> {

    Object[] obj = new Object[10];
    int size;

    public boolean add(E e) {
        obj[size] = e;
        size++;
        return true;
    }

    public E get(int index) {
        return (E) obj[index];
    }

    @Override
    public String toString() {
        return Arrays.toString(obj);
    }
}

测试类GenericsDemo：

public class GenericsDemo {
    public static void main(String[] args) {
        MyArrayList<Integer> list = new MyArrayList<>();

        list.add(111);
        list.add(222);
        list.add(333);

        System.out.println(list);

        System.out.println(list.get(1));

    }
}

运行结果：

3.泛型方法

介绍：

        泛型方法有两种形式，一种是泛型类中的方法都可以使用类名后定义的泛型，第二种是在方法申明上定义自己的泛型（只有本方法能用）下面详细介绍第二种形式。

格式：

修饰符 <类型> 返回值类型 方法名（类型 变量名）{

}

小练习：

        定义一个工具类ListUtil，类中定义一个静态方法addAll，用来添加多个集合元素

代码：

ListUtil类：

public class ListUtil {
    //因为是工具类，不需要构造方法
    private ListUtil(){}

    public static <E> void addAll(ArrayList<E> list,E...e) {
        for (E element : e) {
            list.add(element);
        }
    }
}

测试类Test：

public class Test {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();

        ListUtil.addAll(list,"aaa", "bbb", "ccc");
        System.out.println(list);
    }
}

运行结果：

4.泛型接口

        当借口中类型不确定时，就可以使用泛型接口

格式：

        修饰符 interface 接口名<类型>{

}

使用方法：

方法一.实现类给出具体类型

代码演示：

演示代码具体类型为String

List<String>即为泛型接口，重写List中的方法后，其中的泛型方法类型也被指定为String

public class MyArrayList2 implements List<String> {
    @Override
    public int size() {
        return 0;
    }

    @Override
    public boolean isEmpty() {
        return false;
    }

    @Override
    public boolean contains(Object o) {
        return false;
    }

    @Override
    public Iterator<String> iterator() {
        return null;
    }

    @Override
    public Object[] toArray() {
        return new Object[0];
    }

    @Override
    public <T> T[] toArray(T[] a) {
        return null;
    }

    @Override
    public boolean add(String s) {
        return false;
    }

    @Override
    public boolean remove(Object o) {
        return false;
    }

    @Override
    public boolean containsAll(Collection<?> c) {
        return false;
    }

    @Override
    public boolean addAll(Collection<? extends String> c) {
        return false;
    }

    @Override
    public boolean addAll(int index, Collection<? extends String> c) {
        return false;
    }

    @Override
    public boolean removeAll(Collection<?> c) {
        return false;
    }

    @Override
    public boolean retainAll(Collection<?> c) {
        return false;
    }

    @Override
    public void clear() {

    }

    @Override
    public String get(int index) {
        return null;
    }

    @Override
    public String set(int index, String element) {
        return null;
    }

    @Override
    public void add(int index, String element) {

    }

    @Override
    public String remove(int index) {
        return null;
    }

    @Override
    public int indexOf(Object o) {
        return 0;
    }

    @Override
    public int lastIndexOf(Object o) {
        return 0;
    }

    @Override
    public ListIterator<String> listIterator() {
        return null;
    }

    @Override
    public ListIterator<String> listIterator(int index) {
        return null;
    }

    @Override
    public List<String> subList(int fromIndex, int toIndex) {
        return null;
    }
}

方法二.实现类延续泛型，创建对象时再确定

代码演示：

这种情况下重写的List方法中使用泛型的继续使用类名后定义的泛型

public class MyArrayList3<E> implements List<E> {
    @Override
    public int size() {
        return 0;
    }

    @Override
    public boolean isEmpty() {
        return false;
    }

    @Override
    public boolean contains(Object o) {
        return false;
    }

    @Override
    public Iterator<E> iterator() {
        return null;
    }

    @Override
    public Object[] toArray() {
        return new Object[0];
    }

    @Override
    public <T> T[] toArray(T[] a) {
        return null;
    }

    @Override
    public boolean add(E e) {
        return false;
    }

    @Override
    public boolean remove(Object o) {
        return false;
    }

    @Override
    public boolean containsAll(Collection<?> c) {
        return false;
    }

    @Override
    public boolean addAll(Collection<? extends E> c) {
        return false;
    }

    @Override
    public boolean addAll(int index, Collection<? extends E> c) {
        return false;
    }

    @Override
    public boolean removeAll(Collection<?> c) {
        return false;
    }

    @Override
    public boolean retainAll(Collection<?> c) {
        return false;
    }

    @Override
    public void clear() {

    }

    @Override
    public E get(int index) {
        return null;
    }

    @Override
    public E set(int index, E element) {
        return null;
    }

    @Override
    public void add(int index, E element) {

    }

    @Override
    public E remove(int index) {
        return null;
    }

    @Override
    public int indexOf(Object o) {
        return 0;
    }

    @Override
    public int lastIndexOf(Object o) {
        return 0;
    }

    @Override
    public ListIterator<E> listIterator() {
        return null;
    }

    @Override
    public ListIterator<E> listIterator(int index) {
        return null;
    }

    @Override
    public List<E> subList(int fromIndex, int toIndex) {
        return null;
    }
}

5.泛型通配符

作用：

        可以限制类型的范围

应用场景：

        如果类型不确定，但是知道传递的都是哪个继承体系中的，就可以使用泛型的通配符

格式：

        ？ extend E                表示可以传递E和E的所有子类类型

        ？ super E                  表示可以传递E和E的所有父类类型

代码演示：

public class GenericsDemo2 {
    public static void main(String[] args) {
        //创建Ye Fu Zi的集合
        ArrayList<Ye> list1 = new ArrayList<>();
        ArrayList<Fu> list2 = new ArrayList<>();
        ArrayList<Zi> list3 = new ArrayList<>();
        //调用方法
        method(list1);
        method(list2);
        method(list3);


    }
    //定义方法在集合中调用对象
    public static void method(ArrayList<? extends Ye> list){
        System.out.println(list);
    }

    //创建最高父类爷
    class Ye{}
    //创建父继承爷
    class Fu extends Ye{}
    //创建子继承父
    class Zi extends Fu{}
}

运行结果：

 

也可以把上述method方法中的泛型通配符改成<? super Zi> 和上述代码效果一样。