3.面向对象 - Java泛型 - 《JAVA》

1、泛型的介绍
2、泛型的使用
3、泛型通配符
- 3.1 通配符基本使用
- 3.1 受限通配符
  - List<？ super T>
  - List<? extends T>

1、泛型的介绍

泛型：是一种把明确类型的工作推迟到创建对象或者调用方法的时候才去明确的特殊的类型。也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，而这种参数类型可以用在类、方法和接口中，分别被称为泛型类、泛型方法、泛型接口。

泛型主要来提供编译期的类型安全，确保在泛型集合上只能使用正确的对象，避免在运行时出现异常

//1.不使用泛型， 在运行时报错
ArrayList arr = new ArrayList();
arr.add("helloWorld");
arr.add(88);
for (int i = 0; i < arr.size(); i++) {
    String str = (String)arr.get(i);
    System.out.println(str.length()); 
    //运行时报错，类型转换错误
    //java.lang.Integer cannot be cast to java.lang.String
}
//2.使用泛型，则能够在编译阶段就发现错误
ArrayList<String> arrayList = new ArrayList<>();
arrayList.add("helloWorld");
arrayList.add(88);    // 在编译阶段，编译器就会报错

2、泛型的使用

泛型通常会被大量的使用在集合当中。泛型有三种使用方式，分别为：泛型类、泛型方法、泛型接口。将数据类型作为参数进行传递。

2.1 泛型类

泛型类型用于类的定义中，被称为泛型类。通过泛型可以完成对一组类的操作对外开放相同的接口。最典型的就是各种集合框架容器类，如：List、Set、Map。

泛型类的定义格式：

修饰符 class 类名<代表泛型的变量> { }

/**
 * @param <T> 这里解释下<T>中的T:
 *           此处的T可以随便写为任意标识，常见的有T、E等形式的参数表示泛型
 *           泛型在定义的时候不具体，使用的时候才变得具体。
 *           在使用的时候确定泛型的具体数据类型。即在创建对象的时候确定泛型。
 */
public class GenericsClassDemo<T> {
    //t这个成员变量的类型为T,T的类型由外部指定
    private T t;
    //泛型构造方法形参t的类型也为T，T的类型由外部指定
    public GenericsClassDemo(T t) {
        this.t = t;
    }
    //泛型方法getT的返回值类型为T，T的类型由外部指定
    public T getT() {
        return t;
    }
}

在使用泛型的时候如果传入泛型实参，则会根据传入的泛型实参做相应的限制，此时泛型才会到限制的作用。
如果不传入泛型类型实参的话，在泛型类中使用泛型的方法或成员变量定义的类型可以为任何的类型。
即跟之前的经典案例一样，没有写ArrayList的泛型类型，容易出现类型强转的问题

2.2 泛型方法

泛型方法，是在调用方法的时候指明泛型的具体类型

定义格式：

修饰符 <代表泛型的变量> 返回值类型方法名(参数){ }

/**
     *
     * @param t 传入泛型的参数
     * @param <T> 泛型的类型
     * @return T 返回值为T类型
     * 说明：
     *   1）public 与 返回值中间<T>非常重要，可以理解为声明此方法为泛型方法。
     *   2）只有声明了<T>的方法才是泛型方法，泛型类中的使用了泛型的成员方法并不是泛型方法。
     *   3）<T>表明该方法将使用泛型类型T，此时才可以在方法中使用泛型类型T。
     *   4）与泛型类的定义一样，此处T可以随便写为任意标识，常见的如T、E等形式的参数常用于表示泛型。
     */
    public <T> T genercMethod(T t){
        System.out.println(t.getClass());
        System.out.println(t);
        return t;
    }

调用方法时，确定泛型的类型

public static void main(String[] args) {
    //这里的泛型跟下面调用的泛型方法可以不一样。
    GenericsClassDemo<String> genericString  = 
        new GenericsClassDemo("helloGeneric"); 
    //传入的是String类型,返回的也是String类型
    String str = genericString.genercMethod("hello");
    //传入的是Integer类型,返回的也是Integer类型
    Integer i = genericString.genercMethod(123);
}

这里我们可以看下结果:

class java.lang.String
hello
class java.lang.Integer
123

这里可以看出，泛型方法随着我们的传入参数类型不同，他得到的类型也不同。泛型方法能使方法独立于类而产生变化。

2.3 泛型接口

泛型接口与泛型类的定义及使用基本相同。泛型接口常被用在各种类的生产器中

定义格式

修饰符 interface接口名<代表泛型的变量> { }

看一下下面的例子，定义一个泛型接口:

/**
 * 定义一个泛型接口
 */
public interface GenericsInteface<T> {
    public abstract void add(T t); 
}

使用场景

1、定义类时确定泛型的类型

public class GenericsImp implements GenericsInteface<String> {
  @Override
  public void add(String s) {
      System.out.println("设置了泛型为String类型");
  }
}

2、始终不确定泛型的类型，直到创建对象时，确定泛型的类型

public class GenericsImp<T> implements GenericsInteface<T> {
  @Override
  public void add(T t) {
      System.out.println("没有设置类型");
  }
}

实际调用才传类型

public class GenericsTest {
    public static void main(String[] args) {
        GenericsImp<Integer> gi = new GenericsImp<>();
        gi.add(66);
    }
}

3、泛型通配符

当使用泛型类或者接口时，传递的数据中，泛型类型不确定，可以通过通配符<?>表示。但是一旦使用泛型的通配符后，只能使用Object类中的共性方法，集合中元素自身方法无法使用。

3.1 通配符基本使用

泛型的通配符: 不知道使用什么类型来接收的时候, 此时可以使用?, ?表示未知通配符。
此时只能接受数据,不能往该集合中存储数据。

举个例子：

// ？代表可以接收任意类型
// 泛型不存在继承、多态关系,泛型左右两边要一样
//泛型通配符?:左边写<?> 右边的泛型可以是任意类型
ArrayList<?> list1 = new ArrayList<Object>();
ArrayList<?> list2 = new ArrayList<String>();
ArrayList<?> list3 = new ArrayList<Integer>();

//ArrayList<Object> list = new ArrayList<String>();这种是错误的

注意：泛型不存在继承、多态关系,泛型左右两边要一样，jdk1.7后右边的泛型可以省略而泛型通配符?，右边的泛型可以是任意类型。

泛型通配符? 主要应用在参数传递方面

public static void main(String[] args) {
    ArrayList<Integer> list1 = new ArrayList<Integer>();
    test(list1);
    ArrayList<String> list2 = new ArrayList<String>();
    test(list2);
}
public static void test(ArrayList<?> coll){
}

3.1 受限通配符

受限通配符描述几乎不知道是什么类型的未知类型的层次结构，其实想表达的是这种意思：“我不知道到底是什么类型，但我知道这种类型实现了 List 接口。同时指定一个泛型的上限和下限

泛型的类型上限：

格式： 类型名称 <? extends 类 > 对象名称
意义：只能接收该类型及其子类

泛型的类型下限：

格式： 类型名称 <? super 类 > 对象名称
意义：只能接收该类型及其父类型

比如：现已知Object类，Animal类，Dog类，Cat类，其中Animal是Dog，Cat的父类

public class Animal{}
public class Dog extends Animal{}
public class Cat extends Animal{}

List<？ super T>

super的<>里面是自身或父类，内部元素是自身或子类

ArrayList<? super Animal> list = new ArrayList<>();

1、<>限定的类型
new ArrayList<>()后面的<>只能是Animal本身或者它的父类比如Object，不填默认就是其本身

2、内部元素能存放的类型
而list 能添加的元素范围只能是super T中T本身或者T的子类

示例： T为 Animal, 所以子类以及本身都能被添加

List<? extends T>

extends的<>里面是自身或子类，只读不能写。
extends是被设计用来读取数据的泛型，并且只能读取类型为T的元素

ArrayList<? extends Animal> list = new ArrayList<>();

�
1、<>限定的类型
new ArrayList<>()后面的<>只能是Animal本身或者它的父类比如Object，不填默认就是其本身

2、extends时只能读取，不能插入任何有意义的元素，但可以插入null

这是因为，你不知道里面的元素具体是什么类型，当你add(new Animal())，它真实的类型有可能是Dog，而List<Dog>是不能添加new Animal()的

那为什么super就可以呢？因为定义的是父类，父类可以添加子类，不管是Dog、Animal都可以添加进List<Animal>