泛型

泛型

一：为什么要有泛型

• 可以理解为标签
• 在集合容器声明阶段不能确定这个容器到底实际存什么类型的对象，JDK1.5之后使用泛型来解决。因此把元素的类型设计成一个参数，这个参数叫做泛型。Collection、LIst、ArrayList，这个就是类型参数，即泛型。

二：在集合中使用泛型

package day07;

import java.util.*;

//泛型使用
@SuppressWarnings("all")
public class GenericTest {
    public static void main(String[] args) {
//        没有使用泛型
        ArrayList list = new ArrayList();
        list.add(78);
        list.add("ni");
        list.add(true);
        for (Object o : list) {
//            当在使用时候会出问题
//            int stuScore = (Integer) o;
            System.out.println(o);
        }

//        使用泛型
        ArrayList<Integer> list1 = new ArrayList<Integer>();
        list1.add(99);
        list1.add(90);
        for (Integer integer : list1) {
            int stuScore = integer;
            System.out.println(stuScore);
        }

//        迭代器
        Iterator<Integer> iterator = list1.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }

        Map<String,Integer> hashMap = new HashMap<String,Integer>();

        hashMap.put("Tom",11);
        hashMap.put("xiaoming",12);

//        泛型嵌套
        Set<Map.Entry<String, Integer>> entries = hashMap.entrySet();
        for (Map.Entry<String, Integer> entry : entries) {
            System.out.println(entries);
        }

//        迭代器
        Iterator<Map.Entry<String, Integer>> iterator1 = entries.iterator();
        while (iterator1.hasNext()){
            System.out.println(iterator1.next());
        }
    }
}

三：自定义泛型结构

• 自定义泛型结构：泛型类、泛型接口、泛型方法

泛型类

package day07;

//自定义泛型类型

public class Order<T> {
    String name;
    int Id;

//
    T t;

    public Order(){
    }

    public Order(String name, int id, T t) {
        this.name = name;
        Id = id;
        this.t = t;
    }

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }

    @Override
    public String toString() {
        return "Order{" +
                "name='" + name + '\'' +
                ", Id=" + Id +
                ", t=" + t +
                '}';
    }
}

package day07;

//测试：自定义泛型类
public class GenericClass {
    public static void main(String[] args) {
//        如果定义了泛型类，实力化没有指明类的泛型，则认为此泛型为Object类
//        要求：如果大家定义类是带泛型的，建议实力化要指明类的泛型
        Order order = new Order();
        order.setT(123);
        order.setT("ABC");

        Order<String> stringOrder = new Order<String>();
        stringOrder.setT("一");
        System.out.println(stringOrder.getT());
    }
}

自定义泛型类泛型接口注意点

• 泛型类可以有多个参数，<E1,E2,E3>
• 泛型类的构造器和普通类构造器一样
• 泛型的不同的引用不能相互赋值
• 泛型如果不确定，将被擦除。要用就一直用。要不就不要用
• 如果泛型类是一个接口或或抽象类，则不可以创建泛型类的对象
• 泛型类的指定不能使用基本数据类型，可以使用包装类替代
• 在类/接口上声明的泛型，在本类或本接口中即代表某种类型，可以作为非静态属性的类型，、非静态方法的参数类型、非静态方法的返回值类型。但是：静态方法中不能使用类的泛型
• 异常类不能是泛型
• 父类有泛型，子类可以选择保留泛型也可以选择指定泛型的类型
  • 子类不保留父类的泛型：按需实现
    • 没有类型：擦除
    • 具体类型
  • 子类保留父类的泛型：泛型子类
    • 全部保留
    • 部分保留

自定泛型方法

• 可以为static修改的

public static <E> List<E> show(E[] arr){
  ArrayList<E> arrayList = new ArrayList<E>();
  for (E e : arr) {
    arrayList.add(e);
  }
  return arrayList;
}

四：泛型在继承上的体现

package day07;

import java.util.ArrayList;
import java.util.List;

//测试泛型继承方面使用
@SuppressWarnings("all")
public class GenericExtend {
    public static void main(String[] args) {
        List<Object> list = null;
        List<String> list1 = null;

//      B类继承A类。但是G<A>和G<B>二者不具备父子类关系，二者是并列关系
//        list = list1;

//      类A是类B的父类，A<E>是B<E>父类
        List<String> list2 = null;
        ArrayList<String> list3 = null;
        list1 = list3;
        list2 = list3;
    }
}

五：通配符的使用

• 通配符：？

package day07;

import java.util.Iterator;
import java.util.List;

//测试通配符
@SuppressWarnings("all")
public class Demo01 {
    public static void main(String[] args) {
//        类A是类B的父类，G<A>和G<B>是没有关系的，二者共同的父类是G<?>
        List<Object> list1 = null;
        List<String> list2 = null;
        
        List<?> list = null;
        
        list = list1;
        list = list2;
        
        print(list);
        print(list1);
        print(list2);
    }
    
    public static void print(List<?> list){
        Iterator<?> iterator = list.iterator();
        while (iterator.hasNext()){
            Object obj = iterator.next();
            System.out.println(obj);
        }
    }
}