一、泛型概述：

泛型：是JDK5中引入的特性，可以在编译阶段约束操作的数据类型，并进行检查

泛型的格式：<数据类型>

注意：泛型只支持引用数据类型

泛型的好处：

①统一数据类型。

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

泛型的细节：

①泛型中不能写基本数据类型

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

③如果不写泛型，类型默认是Object

泛型可以在很多地方进行定义：类后面---泛型类，方法上面---泛型方法，接口后面---泛型接口

1. 泛型类：使用场景：当一个类中，某个变量的数据类型不确时，就可以定义带有泛型的类

格式：修饰符 class 类名<类型>{}

举例：public class ArrayList<E>{}

此处E可以理解为变量，但是不是用来记录数据的，而是记录数据的类型，可以写成：T,E,K,V 

 泛型类的书写：

package a05mygenericsdemo;

import java.util.Arrays;

//当编写一个类时，如果不确定类型，那么这个类就可以定义为泛型类
public class MyArrayList <E>{
    Object[] obj=new Object[10];
    int size;
    //E:表示不确定的类型，该类型在类名后面已经定义过了
    //e:形参的名字，变量名
    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);
    }
}

泛型类的使用：

package a05mygenericsdemo;

public class GenericsDemo2 {
    public static void main(String[] args) {
//        MyArrayList<String> list =new MyArrayList<>();
//        list.add("aaa");
//        list.add("bbb");
//        list.add("ccc");
//        System.out.println(list);

        MyArrayList<Integer> list2=new MyArrayList<>();
        list2.add(123);
        list2.add(456);
        list2.add(789);
        int i = list2.get(0);
        System.out.println(i);
    }
}

运行结果：

2.泛型方法：

方法中形参类型不确定时:

方案1：可以使用类名后面定义的泛型---所有方法都能用

方案2：在方法声明上定义自己的泛型---只有本方法能用

格式：修饰符 <类型> 返回值类型(类型，变量名){}

举例：public <T> void show(T t){}

此处T可以理解为变量，但是不是用来记录数据的，而是记录数据的类型，可以写成：T,E,K,V 

泛型方法的练习：

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

ListUtil类：

package a05mygenericsdemo;

import java.util.ArrayList;

public class ListUtil {
    //参数1：集合
    //参数2~最后：要添加的元素
    private ListUtil(){}
    public static<E> void addAll(ArrayList<E> list,E ...e){
        for (E element : e) {
            list.add(element);
        }
    }
}

使用类：

package a05mygenericsdemo;

import java.util.ArrayList;

public class GenericsDemo3 {
    public static void main(String[] args) {
        ArrayList<String> list=new ArrayList<>();
        ListUtil.addAll(list,"aaa","bbb","ccc","ddd");
        System.out.println(list);
    }
}

运行结果：

3.泛型接口：

格式：修饰符interface 接口名<类型>{}

举例：public interface List<E>{}

泛型接口的使用：

方式1：实现类给出具体类型

方式2：实现类延续泛型，创建对象时再确定

使用方式1代码演示：实现类：

package a05mygenericsdemo;

import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

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;
    }
}

使用类：

package a05mygenericsdemo;

public class GenericsDemo4 {
    public static void main(String[] args) {
        MyArrayList2 list=new MyArrayList2();
        list.add("abc");
        

    }
}

使用方式2代码演示：实现类

package a05mygenericsdemo;

import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

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;
    }
}

使用类：

package a05mygenericsdemo;

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

    }
}