Java中的泛型

---

一、泛型概述

• 泛型：是JDK5中引入的特性，可以在编译阶段约束操作的数据类型，并进行检查
• 格式：<数据类型>
• 优点：
  • 统一数据类型
  • 把运行期间的问题提前到编译期间，避免了强制类型转化可能出现的异常，因为在编译阶段就能确定

注意：

• 泛型只能支持引用数据类型，不能写基本数据类型
• 指定泛型的具体类型后，传递数据时，可以传入该类类型或其子类类型
• 如果不写泛型，类型默认是Object

 ArrayList<String> s=new ArrayList<>();

二、泛型类

• 使用场景：当一个类，某个变量的数据类型不确定是，就可以定义带有泛型的类
• 格式：修饰符 class 类名<类型>{ }

 public class ArrayList<E>{   //创建该类对象时，E就确定类型
        
    }
//E可理解为变量，但是不是用来记录数据的，而是记录数据的类型，可以写成T、E、K、V等

MyArrayList.java

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

Demo.java

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

        MyArrayList<String> list=new MyArrayList<>();
        list.add("aaa");
        list.add("bbb");

        System.out.println(list);
    }
}

三、泛型方法

• 格式：修饰符 <类型> 返回值类型 方法名（类型 变量名）{ }

• 方法中形参类型不确定时候有两种方法

1. 使用类名后面定义的泛型< E >

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

所有方法都能用

2. 在方法申明上定义自己的泛型

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

只有本方法能用

四、泛型接口

• 格式：修饰符 interface 接口名<类型>{ }
• 泛型接口的两种使用方式：

1. 实现类给出的具体类型

public class MyArrayList 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;
    }
 }

2. 实现类延续泛型，创建实现类对象时在确定类型

public class MyArrayList2<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;
    }
}

五、泛型的继承和通配符

• 泛型不具备继承性，但数据具有继承性

public class GenericsDemo {
    public static void main(String[] args) {
        ArrayList<Ye> list1=new ArrayList<>();
        ArrayList<Fu> list2=new ArrayList<>();
        ArrayList<Zi> list3=new ArrayList<>();
//        调用method方法
        method(list1);
        method(list2);  //报错
        method(list3);  //报错，因为泛型不具备继承性。

        //不报错，数据具有继承性
        list1.add(new Ye());
        list1.add(new Fu());
        list1.add(new Zi());
    }
    public static void method(ArrayList<Ye> list){

    }
}

class Ye{

}

class Fu extends Ye{

}

class Zi extends Fu{

}

• 通配符

在泛型离写什么方法，它就只能传递什么数据类型，所以存在一个弊端：即它课接受任意数据类型如上例中的Ye Fu Zi 甚至Student对象，但是如果只希望传递Ye Fu Zi，此时就要用到通配符。

?：表示不确定的类型
? extends E ：表示可以传递E或者E的所有子类类型
? super E ：表示可以传递E或者E的所有父类类型

public class GenericsDemo3 {
   
    public static void main(String[] args) {
        ArrayList<Ye> list1=new ArrayList<>();
        ArrayList<Fu> list2=new ArrayList<>();
        ArrayList<Zi> list3=new ArrayList<>();      
        method(list1);
        method(list2);
        method(list3);

    }
    public static<E> void method(ArrayList<? extends Ye> list){

    }
}

class Ye{

}

class Fu extends Ye{

}

class Zi extends Fu{

}

六、没有泛型的时候，集合如何存储数据

• 没有给集合指定类型，默认所有数据类型都是Object类型，此时可往集合里添加任意数据类型
• 缺点：获取数据时，无法使用它的特有行为