java:泛型

后端 java
发布时间 :
字数:3k 阅读 :
  1. 为什么要有泛型
    1. 泛型的设计背景
    2. 泛型的概念
    3. 那么为什么要有泛型呢，直接Object不是也可以存储数据吗?
  2. 在集合中使用泛型
    1. ArrayList
    2. HashMap
  3. 自定义泛型结构
    1. 泛型的声明
    2. 泛型的实例化
    3. 泛型类与泛型接口
    4. 泛型方法
  4. 泛型在继承上的体现
  5. 通配符的使用

课程：宋红康 JAVA

为什么要有泛型

泛型的设计背景

集合容器类在设计阶段/声明阶段不能确定这个容器到底实际存的是什么类型的对象，所以在JDK1.5之前只能把元素类型设计为Object，JDK1.5之后使用泛型来解决。因为这个时候除了元素的类型不确定，其他的部分是确定的，例如关于这个元素如何保存，如何管理等是确定的，因此此时把元素的类型设计成一个参数，这个类型参数叫做泛型。Collection<E>，List<E>， ArrayList<E> 这 个<E>就是类型参数，即泛型。

泛型的概念

  1. 所谓泛型，就是允许在定义类、接口时通过一个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型。这个类型参数将在使用时(例如，继承或实现这个接口，用这个类型声明变量、创建对象时)确定(即传入实际的类型参数，也称为类型实参)。
  2. 从JDK1.5以后，Java引入了“参数化类型( Parameterized type )”的概念，允许我们在创建集合时再指定集合元素的类型，正如: List<String>， 这表明该List只能保存字符串类型的对象。
  3. JDK1.5改写了集合框架中的全部接口和类，为这些接口、类增加了泛型支持，从而可以在声明集合变量、创建集合对象时传入类型实参。

那么为什么要有泛型呢，直接Object不是也可以存储数据吗?

  1. 解决元素存储的安全性问题，好比商品、药品标签，不会弄错。

  2. 解决获取数据元素时，需要类型强制转换的问题，好比不用每回拿商品、药品都要辨别。

    //在集合中使用泛型之前的情况：
@Test
public void test1(){
    ArrayList list = new ArrayList();
    //需求：存放学生的成绩
    list.add(78);
    list.add(76);
    list.add(89);
    list.add(88);
    //问题一：类型不安全
    //        list.add("Tom");
    for(Object score : list){
        //问题二：强转时，可能出现ClassCastException
        int stuScore = (Integer) score;
        System.out.println(stuScore);
    }
}

    Java泛型可以保证如果程序在编译时没有发出警告，运行时就不会产生ClassCastException异常。同时，代码更加简洁、健壮。

在集合中使用泛型

ArrayList

//在集合中使用泛型的情况：以ArrayList为例
@Test
public void test2(){
    ArrayList<Integer> list =  new ArrayList<Integer>();

    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<Integer> iterator = list.iterator();
    while(iterator.hasNext()){
        int stuScore = iterator.next();
        System.out.println(stuScore);
    }
}

HashMap

//在集合中使用泛型的情况：以HashMap为例
@Test
public void test3(){
    // 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);
    }
}

自定义泛型结构

泛型的声明

泛型的声明：interface List<T>和class GenTest<K,V>

其中，T,K,V不代表值，而是表示类型。这里使用任意字母都可以。

常用T表示，是Type的缩写。

泛型的实例化

一定要在类名后面指定类型参数的值(类型)。如:

List<String> strList = new ArrayList<String>();

Iterator<Customer> iterator = customers.iterator();

T只能是类，不能用基本数据类型填充。但可以使用包装类填充

把一个集合中的内容限制为一个特定的数据类型，这就是generics背后的核心思想

泛型类与泛型接口

  1. 泛型类可能有多个参数，此时应将多个参数一起放在尖括号内。比如:<E1,E2,E3>

  2. 泛型类的构造器如下: public GenericClass(){}。而下面是错误的: public GenericClass<E>(){}

  3. 泛型如果不指定，将被擦除，泛型对应的类型均按照Object处理（也就是如果实例化时，没有指明泛型的类型。默认类型为java.lang.Object类型。），但不等价于Object。经验：泛型要使用一路都用。要不用，一路都不要用。

    public class Order<T> {

    String orderName;
    int orderId;
    //类的内部结构就可以使用类的泛型
    T orderT;
    public Order(){
        //编译不通过：泛型不可可以直接实例化
        //T[] arr = new T[10];
        //编译通过
        T[] arr = (T[]) new Object[10];
    }

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

}

@Test
public void test1(){
    //如果定义了泛型类，实例化没有指明类的泛型，则认为此泛型类型为Object类型
    //要求：如果大家定义了类是带泛型的，建议在实例化时要指明类的泛型。
    Order order = new Order();
    order.setOrderT(123);
    order.setOrderT("ABC");
    //建议：实例化时指明类的泛型
    Order<String> order1 = new Order<String>("orderAA",1001,"order:AA");
    order1.setOrderT("AA:hello");
}

  4. 如果泛型结构是一个接口或抽象类，则不可创建泛型类的对象。

  5. jdk1.7，泛型的简化操作: ArrayList<Fruit> flist = new ArrayList<>();

  6. 泛型的指定中不能使用基本数据类型，可以使用包装类替换。

  7. 异常类不能是泛型的

    public void show(){
//编译不通过
//        try{
//
//
//        }catch(T t){
//
//        }}

}

  8. 不能使用new E[ ]。但是可以:E[ ] elements = (E[ ])new Object[capacity];

    public Order(){
    //编译不通过：泛型不可可以直接实例化
    //T[] arr = new T[10];
    //编译通过
    T[] arr = (T[]) new Object[10];
}

  9. 父类有泛型，子类可以选择保留泛型也可以选择指定泛型类型

    public class SubOrder extends Order<Integer> {//SubOrder:不是泛型类
}

public class SubOrder1<T> extends Order<T> {//SubOrder1<T>:仍然是泛型类
}

@Test
public void test2(){
    SubOrder sub1 = new SubOrder();
    //由于子类在继承带泛型的父类时，指明了泛型类型。则实例化子类对象时，不再需要指明泛型。
    sub1.setOrderT(1122);
    //但如果在继承泛型的时候没有指定泛型类型，就需要在实例化的时候指定
    SubOrder1<String> sub2 = new SubOrder1<>();
    sub2.setOrderT("order2...");
}

  10. 泛型不同的引用不能相互赋值。

    @Test
public void test3(){
    ArrayList<String> list1 = null;
    ArrayList<Integer> list2 = new ArrayList<Integer>();
    //泛型不同的引用不能相互赋值。
    //list1 = list2;
    Person p1 = null;
    Person p2 = null;
    p1 = p2;
}

  11. 在类/接口上声明的泛型，在本类或本接口中即代表某种类型，可以作为非静态属性的类型、非静态方法的参数类型、非静态方法的返回值类型。但在静态方法中不能使用类的泛型。

    public class Order<T> {
 //静态方法中不能使用类的泛型。
//    public static void show(T orderT){
//        System.out.println(orderT);
//    }
}

泛型方法

  1. 方法也可以被泛型化，不管此时定义在其中的类是不是泛型类。在泛型方法中可以定义泛型参数，此时，参数的类型就是传入数据的类型。
  2. 泛型方法的格式：[访问权限] <泛型> 返回类型 方法名([泛型标识参数名称])抛出的异常
  3. 泛型方法，可以声明为静态的。原因：泛型参数是在调用方法时确定的。并非在实例化类时确定。
//泛型方法：在方法中出现了泛型的结构，泛型参数与类的泛型参数没有任何关系。
//换句话说，泛型方法所属的类是不是泛型类都没有关系。
//泛型方法，可以声明为静态的。原因：泛型参数是在调用方法时确定的。并非在实例化类时确定。
public static <E>  List<E> copyFromArrayToList(E[] arr){
    ArrayList<E> list = new ArrayList<>();
    for(E e : arr){
        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);
}

泛型在继承上的体现

虽然类A是类B的父类，但是G<A> 和G<B>二者不具备子父类关系，二者是并列关系。

补充：类A是类B的父类，A<G> 是 B<G> 的父类

@Test
public void test1(){
    Object obj = null;
    String str = null;
    obj = str;

    Object[] arr1 = null;
    String[] arr2 = null;
    arr1 = arr2;
    //编译不通过
    //Date date = new Date();
    //str = date;
    List<Object> list1 = null;
    List<String> list2 = new ArrayList<String>();
    //此时的list1和list2的类型不具有子父类关系
    //编译不通过
    //list1 = list2;
    /*
    反证法：
    假设list1 = list2;
       list1.add(123);导致混入非String的数据。出错。
     */
    show(list1);
    show1(list2);
}

public void show1(List<String> list){

}

public void show(List<Object> list){

}

通配符的使用

  1. 通配符：?

  2. 类A是类B的父类，G<A>和G<B>是没有关系的，二者共同的父类是：G<?>

    @Test
public void test3(){
    List<Object> list1 = null;
    List<String> list2 = null;
    List<?> list = null;
    list = list1;
    list = list2;
    //编译通过
    print(list1);
    print(list2);
    //
    List<String> list3 = new ArrayList<>();
    list3.add("AA");
    list3.add("BB");
    list3.add("CC");
    list = list3;
    //添加(写入)：对于List<?>就不能向其内部添加数据。
    //除了添加null之外。
    //        list.add("DD");
    //        list.add('?');
    list.add(null);
    //获取(读取)：允许读取数据，读取的数据类型为Object。
    Object o = list.get(0);
    System.out.println(o);
}

public void print(List<?> list){
    Iterator<?> iterator = list.iterator();
    while(iterator.hasNext()){
        Object obj = iterator.next();
        System.out.println(obj);
    }
}

  3. 有限制条件的通配符的使用

    • ? extends A： G<? extends A> 可以接受<=A类型的集合
    • ? super A：G<? super A> 可以接受>=A 类型的集合
    @Test
public void test4(){
    //？号表示一个范围，而? extends Person就表示这个范围是Person或者Person的子类
    //也就是可以接受<=Person类型的集合
    List<? extends Person> list1 = null;
    //？号表示一个范围，而? super Person就表示这个范围是Person或者Person的父类
    //也就是可以接受>=Person类型的集合
    List<? super Person> list2 = null;

    List<Student> list3 = new ArrayList<Student>();
    List<Person> list4 = new ArrayList<Person>();
    List<Object> list5 = new ArrayList<Object>();

    list1 = list3;
    list1 = list4;
    //list1 = list5;

    //list2 = list3;
    list2 = list4;
    list2 = list5;

    //读取数据：
    list1 = list3;
    // List<? extends Person> list1：从list1里面读取出来的数，最小也要用Person接收
    //因为list1最大的类型就是Person
    Person p = list1.get(0);
    //编译不通过
    //Student s = list1.get(0);

    list2 = list4;
    //List<? super Person> list2：list2最大的类型就是Object，所有需要用Object来接收
    Object obj = list2.get(0);
    ////编译不通过
    //Person obj = list2.get(0);

    //写入数据：
    //编译不通过：因为万一我们的范围是比Student小，所以这里编译不通过
    //可以传null， List<? extends Person> list1最小类的级别是null
    //list1.add(new Student());

    //编译通过：List<? super Person> list2最小类的级别是Person
    //所以list里面放Person和Student，元素一定的是可以接收的
    list2.add(new Person());
    list2.add(new Student());
}

转载请注明来源，欢迎对文章中的引用来源进行考证，欢迎指出任何有错误或不够清晰的表达。可以在下面评论区评论，也可以邮件至 1909773034@qq.com

赏

©2017 XieShaoLin

Built with Hexo and 3-hexo theme

×

喜欢就点赞,疼爱就打赏