泛型的基本使用

• JDK5增加了泛型机制。有了泛型之后，定义一些接口，就有了统一的规范、并且对集合框架的的操作会更加友好。

  ArrayList<String> list = new ArrayList<String>();
  list.add("LDL");
  String str = list.get(0);

• 在没有泛型的时候，如果想要向ArrayList数组中存储数据，则必须得是Object类型的数据，因为Object类型是所有类的基类。类似下面这样的一个所有类可以使用的集合。 ```java class Arraylist { private Object[] objs; private int i = 0; public void add(Object obj) {

    objs[i++] = obj;

  }

  public Object get(int i) {

    return objs[i];

  } }

- 存储和读取数据操作
```java
Arraylist list = new Arraylist();
list.add("LDL");
list.add(new Date());
String str = (String)list.get(0);

• 因为类型是Object的，所以其可以存储任何数据类型的数据，就会导致读取数据的时候，需要对类型进行强转。
• 使用类型参数解决了元素的不确定性——参数类型为 String 的集合中是不允许存放其他类型元素的，取出数据的时候也不需要强制类型转换了

• 使用泛型类来定义MyArrayList类

  public class MyArrayList<E> {
    private Object[] elementData;
    private int      size = 0;
  
    public MyArrayList(int initialCapacity) {
        this.elementData = new Object[initialCapacity];
    }
  
    public boolean add(E e) {
        elementData[size++] = e;
        return true;
    }
  
    E elementData(int index) {
        return (E) elementData[index];
    }
  }
  

• 一个泛型类就是具有一个或多个类型变量的类。MyArrayList 类引入的类型变量为 E（Element，元素的首字母），使用尖括号 <> 括起来，放在类名的后面。

• 然后，我们可以用具体的类型（比如字符串）替换类型变量来实例化泛型类。

  public class MyArrayListTest {
    public static void main(String[] args) {
        MyArrayList<String> listStr = new MyArrayList<>(10);
        listStr.add("LDL");
        System.out.println(listStr.elementData(0));
  
        MyArrayList<Date> listDate = new MyArrayList<>(10);
        listDate.add(new Date());
        System.out.println(listDate.elementData(0));
  
    }
  }
  

• 其次，我们还可以在一个非泛型的类（或者泛型类）中定义泛型方法 ```java public class MyArrayList2 { private Object[] elementData; private int size = 0;

  public T[] toArray(T[] a) {

    return (T[]) Arrays.copyOf(elementData, size, a.getClass());
  

  }

  public T copyObject(T t) {

    return t;
  

  } }

class MyArrayList3 { private Object[] elementData; private int size = 0;

public <T> T[] toArray(T[] a) {
    return (T[]) Arrays.copyOf(elementData, size, a.getClass());
}

public <T> T copyObject(T t) {
    return t;
}

}

![image.png](https://cdn.nlark.com/yuque/0/2022/png/1806904/1641518250125-0df01f54-7eaf-40c6-b0f1-2457a61ac0d4.png#clientId=u7f5991a5-8dbe-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=279&id=u314bbffb&margin=%5Bobject%20Object%5D&name=image.png&originHeight=558&originWidth=1338&originalType=binary&ratio=1&rotation=0&showTitle=false&size=84045&status=done&style=none&taskId=u0b7657ed-a613-4b0f-b466-793e8028300&title=&width=669)
```java
class MyArrayList3<E> {
    private Object[] elementData;
    private int      size = 0;

    public <T> T[] toArray(T[] a) {
        return (T[]) Arrays.copyOf(elementData, size, a.getClass());
    }

    // 方法参数类型可无
    public <T> T copyObject() {
        return (T) new Object();
    }
}

• 泛型的变量修饰符 extends 限定上限 ```java public class MyArrayList5 { private Object[] elementData; private int size = 0;

  public MyArrayList5(int initialCapacity) {

    this.elementData = new Object[initialCapacity];
  

  }

  public boolean add(E e) {

    elementData[size++] = e;
    return true;
  

  }

  E elementData(int index) {

    return (E) elementData[index];
  

  } }

```java
public class ZQ {

}

class ZQ1 extends ZQ {

}

class ZQ2 extends ZQ {

}

class ZQTest {
    public static void main(String[] args) {
        MyArrayList5 listExtends = new MyArrayList5<>(3);
        listExtends.add(new ZQ());
        listExtends.add(new ZQ1());
        listExtends.add(new ZQ2());
    }
}

• 泛型修饰符 supper 下限 ```java public class InfoSupper {

  private T var; // 定义泛型变量

  public void setVar(T var) {

    this.var = var;
  

  }

  public T getVar() {

    return this.var;
  

  }

  public String toString() { // 直接打印

    return this.var.toString();
  

  } }

class GenericsDemo21 { public static void main(String args[]) { InfoSupper i1 = new InfoSupper<>(); // 声明String的泛型对象 InfoSupper