泛型的概念

  • 泛型：标签
  • 举例：
    • 中药店，每个抽屉外面贴着标签
    • 超市购物架上很多瓶子，每个瓶子装的是什么，有标签
  • 所谓泛型，就是允许在定义类、接口时通过一个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型。这个类型参数将在使用时（例如，继承或实现这个接口，用这个类型声明变量、创建对象时）确定（即传入实际的类型参数，也称为类型实参）。

集合中没有泛型的问题：

  1. aArrayList list = new ArrayList();
  2. //需求：存放学生的成绩
  3. list.add(78);
  4. list.add(76);
  5. list.add(89);
  6. list.add(88);
  7. //问题一：类型不安全
  8. list.add("Tom");
  10. for (Object score : list) {
  11.     //问题二：强转时，可能出现ClassCastException
  12.     int stuScore = (Integer) score;
  14.     System.out.println(stuScore);
  16. }

集合中使用泛型

  1. 集合接口或集合类在jdk5.0时都修改为带泛型的结构。
  2. 在实例化集合类时，可以指明具体的泛型类型。
  3. 指明完以后，在集合类或接口中凡是定义类或接口时，内部结构（比如：方法、构造器、属性等）使用到类的泛型的位置，都指定为实例化的泛型类型。

比如：add(E e) —->实例化以后：add(Integer e)

  1. 注意点：泛型的类型必须是类，不能是基本数据类型，需要用到基本数据类型的位置，拿包装类替换。
  2. 如果实例化时，没有指明泛型的类型，默认类型为java.lang.Object类型。
  • ArrayList ```java ArrayList list = new ArrayList();

list.add(78); list.add(87); list.add(99); list.add(65); //编译时，就会进行类型检查，保证数据的安全 // list.add(“Tom”);

//方式一： for (Integer score : list) { //避免了强转操作 int stuScore = score;

System.out.println(stuScore);

}

//方式二： Iterator iterator = list.iterator(); while (iterator.hasNext()) { int stuScore = iterator.next(); System.out.println(stuScore); }


- HashMap
```java
//        Map<String,Integer> map = new HashMap<String,Integer>();
//jdk7新特性：类型推断
Map<String, Integer> map = new HashMap<>();

map.put("Tom", 87);
map.put("Jerry", 87);
map.put("Jack", 67);

//        map.put(123,"ABC");
//泛型的嵌套
Set<Map.Entry<String, Integer>> entry = map.entrySet();
Iterator<Map.Entry<String, Integer>> iterator = entry.iterator();

while (iterator.hasNext()) {
    Map.Entry<String, Integer> e = iterator.next();
    String key = e.getKey();
    Integer value = e.getValue();
    System.out.println(key + "----" + value);
}

}

自定义泛型结构

可以理解为一种宏的替换，泛指的类型。

image.png
image.png
image.png

泛型类、泛型接口

public class Order<T> {
    String orderName;
    int orderId;
    //类的内部结构就可以使用类的范型
    T orderT;

    public Order() {
    }

    public Order(String orderName, int orderId, T orderT) {
        this.orderName = orderName;
        this.orderId = orderId;
        this.orderT = orderT;
    }


    public T getOrderT() {
        return orderT;
    }

    public void setOrderT(T orderT) {
        this.orderT = orderT;
    }

    @Override
    public String toString() {
        return "Order{" +
                "orderName='" + orderName + '\'' +
                ", orderId=" + orderId +
                ", orderT=" + orderT +
                '}';
    }
}
  • 如果定义了泛型类，实例化没有指明类的泛型，则认为此泛型类型为Object类型。

  • 要求：如果定义了类是带泛型的，建议在实例化时要指明类的泛型。 ```java @Test public void test2() {

    Order order = new Order(); order.setOrderT(123); order.setOrderT(“ABC”);

Order<String> order1 = new Order<>("orderAA", 1001, "order:AA");
order1.setOrderT("AA:hello");

}


**泛型类继承的两种情况**
```java
//SubOrder1不是泛型类
class SubOrder1 extends Order<Integer> {

}

//SubOrder2<T>仍是泛型类
class SubOrder2<T> extends Order<T> {

}

@Test
public void test3() {
    //由于子类在继承带泛型的父类时，指明了范型类型，则实例化子类对象时，不再需要指明泛型。
    SubOrder1 sub1 = new SubOrder1();
    sub1.setOrderT(1122);

    SubOrder2<String> sub2 = new SubOrder2<>();
    sub2.setOrderT("1122");
}

泛型方法

  • 在方法中出现了泛型结构，泛型参数与类的泛型参数没有任何关系（换句话说：泛型方法所属的类是不是泛型类都没有关系）。

  • 泛型方法可以声明为静态的，因为泛型参数是在调用方法时确定的，并非在实例化类时确定。

    public <E> List<E> copyFromArrayToList(E[] array) {
  ArrayList<E> list = new ArrayList<>();
  for (E e : array) {
      list.add(e);
  }
  return list;
}

    @Test
public void test4() {
  Order<String> order = new Order<>();
  Integer[] arr = new Integer[]{1, 2, 3, 4};

  //泛型方法在调用时，指明泛型参数的类型。
  List<Integer> list = order.copyFromArrayToList(arr);
  System.out.println(list);
}

泛型在继承上的体现

image.png

public void testGenericAndSubClass() {
    Person[] persons = null;
    Man[] mans = null;
    // 而 Person[] 是 Man[] 的父类.
    persons = mans;
    Person p = mans[0];
    // 在泛型的集合上
    List<Person> personList = null;
    List<Man> manList = null;
    // personList = manList;(报错)
}

通配符

image.png
image.png

public static void main(String[] args) {
    List<?> list = null;
    list = new ArrayList<String>();
    list = new ArrayList<Double>();
    // list.add(3);//编译不通过
    list.add(null);
    List<String> l1 = new ArrayList<String>();
    List<Integer> l2 = new ArrayList<Integer>();
    l1.add("尚硅谷");
    l2.add(15);
    read(l1);
    read(l2);
}
public static void read(List<?> list) {
    for (Object o : list) {
        System.out.println(o);
    }
}

有限制的通配符
image.png