Java泛型全解析【接口、类、封装类型】

泛型

    泛型是Java SE 1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。Generic有“类的，属性的”之意，在Java中代表泛型。泛型作为一种安全机制而产生。

为何需要泛型？

   我们知道集合(Collection、Map之类的容器)是用来存储任意对象(Object)的一系列“容器类或者接口”，注意这里的“任意对象”,就是指我们可以在这些类或接口中存放任意类型的对象，但这些对象在存储之前都需要统一向上转型为Object类型(因为Object类是所以类的的父类)，比如类ArrayList就属于“集合类”，我们可以用这个类来存储任意对象：

package bean;

import java.util.ArrayList;

public class ArrayListDemo {
    public static void main(String[] args) {
        
        //首先我们创建一个ArrayList对象
        ArrayList al = new ArrayList();
        
        //往"容器"添加元素：我们添加了字符串"哈哈",数字2,boolean类型true，最后我们甚至添加了自己。
        al.add("哈哈");
        al.add(2);
        al.add(true);
        al.addAll(al);
        //由于ArrayList类覆盖了toString()，这里我们可以直接打印查看效果：
        System.out.println(al);
    }
}

        最后打印出来的字符串是：[哈哈, 2, true, 哈哈, 2, true]

值得注意的是：这里的2不是int而是Integer，因为ArrayList只能存对象，而“添加它自己”addAll(al)的实质是将al中的所有元素再存入al中，正如打印效果显示的一样，我们成功添加了类型不一样的对象：有String，有Integer、还有Boolean。当然，你可以添加任意你想要添加的对象。因为这些对象在存入“容器”al中时会全部转型为Object类型，有没有觉得这样的“容器”用起来会很爽，什么东西都能往里放。但是，便捷往往会付出相应代价。

我们将各种类型的元素存入“容器”中当然不是让它睡上一觉，我们需要将存储的元素取出使用。对于这些“容器”，我们一般使用迭代器Iterator来获取每一个元素。(这里不进行迭代器使用说明，只需理解迭代器是取出"容器"中元素的工具就行).

    假设现在我们需要对我们上面创建的“容器”al中的元素进行操作：打印容器中字符串的长度，即“哈哈”的长度。

  package bean;
  
  import java.util.ArrayList;
  import java.util.Iterator;
  
  public class ArrayListDemo {
      public static void main(String[] args) {
          //首先我们创建一个ArrayList对象,并添加对象
          ArrayList al = new ArrayList();
         al.add("哈哈");
         al.add(2);
         al.add(true);
         
         //使用迭代器Iterator进行遍历，并打印容器中字符串的长度：
        //注：next()方法是按照容器的存储顺序，逐一取出第一个到最后一个对象。
        Iterator i = al.iterator();
         while(i.hasNext()){
             String s = (String) i.next();
             System.out.println(s.length());
        }
     }
    
 }

我们来进行代码分析：while循环中，先用i.next()方法取出第一个元素"哈哈"，然后装换为String类型(因为存进去的时候是Object类型，使用的使用要向下转型)，所以接下来打印了“哈哈”的长度=2。接着循环：迭代器取出第二个元素：2，但这是Integer类型不能强制装换为String类型，所以抛出异常：ClassCastException：类型转换异常。

这就是“能存万物”所带来的代价：我们在使用“容器”存储对象并调用时就换存在“类型转换异常”的安全隐患，但这需要在运行后才能得知，编译时无法发现。所以我们该如何解决这个问题呢？我们发现问题在于“类型转换异常”，所以我们只要保证“容器”中存储的是同一类型的元素就不会出现这个异常了。类似数组的定义一样：如 int[] 就表示专门用来存储int类型数据的数组，String[] 就是用来存储String类型数据的数组。我们只要将“容器”标上相应类型的标签就可以了。看到这里，你应该已经理解了泛型的由来，这就是泛型的设计：引入类型参数的概念，即对对象类型进行申明。

3、泛型的定义格式
格式为：类名<类型名>，如：

package bean;
  
  import java.util.ArrayList;
  import java.util.Iterator;
 
 public class ArrayListDemo {
      public static void main(String[] args) {
          //首先我们创建一个ArrayList对象,并申明泛型类型为String类型：只能存储String类型的对象
          ArrayList<String> al = new ArrayList<String>();
         al.add("哈哈");
        al.add("asdafa");
         al.add("tobeyourself");
         
         //使用迭代器Iterator进行遍历，并打印容器中字符串的长度：这里迭代器也使用了泛型
         Iterator<String> i = al.iterator();
         while(i.hasNext()){
             String s = (String) i.next();
             System.out.println(s+"的长度为="+s.length());
         }
     }
     
 }

泛型的好处

    除了解决上面的安全隐患即抛出异常问题，泛型的类或接口在取出对象时将不需要再进行向下类型转换，因为存储的时候就是该类型 。

   另外，泛型的使用让安全问题在编译时就报错而不是运行后抛出异常，这样便于程序员及时准确地发现问题。

什么时候使用泛型？

一般类或接口在api文档中的定义中带有<E>标识的，在使用的时候都需要使用泛型机制。如ArrayList<E>、Iterator<E>。

泛型的擦除

    泛型是运用在编译时期的技术：编译时编译器会按照<类型名>的类型对容器中的元素进行检查，检查不匹配，就编译失败。如果全部检查成功，则编译通过，但，编译通过后产生的.class文件中并没有<类型名>这个标识，即类文件中没有泛型，这就是泛型的擦除。

     一句话总结就是：在.java文件运用泛型技术时，编译器在文件编译通过后自动擦除泛型标识。

     由于泛型的擦除，类文件中没有泛型机制，同时也没有使用向下类型转换，那么为何运行时无异常？

泛型的补偿

      编译器在擦除泛型后，会自动将类型转换为原定义的"泛型"，这样就不必再做向下类型转换了。

     泛型的擦除和补偿 这两个机制都是编译器内部自动完成的，了解其原理即可。

泛型的应用

7.1【泛型类】

所谓的泛型类就是运用到泛型技术的类，如上面讲到的ArrayList，Iterator等都是java中的泛型类，这些类都是Java已经定义好的泛型类，直接使用就可以了。但有时候我们会遇到这样的问题：

假设我们现在有两个自定义类：Worker类和Student类，现在我们需要一个工具类Tool来获取Worker对象和Student对象，并能对对象进行操作。

分析：

我们可能会想到将Worker和Student类作为Tool类的成员变量，以此来实现对这两个类的操作。但这样有一个问题，就是如果这不是两个类而是很多类，甚至说无数个类，即Tool类可以操作任意类，这种通过添加成员变量来实现调用对象的方法显然不可行。注意这个“添加任意对象”，这不就是上面说的ArrrayList这些类所具有的特点吗？泛型类就是为了解决“添加任意对象”而产生的，这里提到的ArrayList属于已定义泛型类(Java中自带的)，这里我们要用到Tool类来“存储任意对象”，所以要将Tool类定义为泛型类，这就是根据需求自己设计的自定义泛型类：

首先我们先简单的定义一下:Worker类和Student类：

Worker类：

package bean;
  
  public class Worker {
      private String name;
      private int age;
      Worker(){
          
      }
      Worker(String name,int age){
         this.name = name;
         this.age = age;
     }
     public String getName() {
         return name;
     }
     public void setName(String name) {
         this.name = name;
     }
     public int getAge() {
         return age;
     }
     public void setAge(int age) {
         this.age = age;
     }
    
 }

Student类：

 1 package bean;
 2 
 3 public class Student {
 4     private String name;
 5     private String sex;
 6     Student(){
 7         
 8     }
 9     Student(String name,String sex){
10         this.name = name;
11         this.sex = sex;
12     }
13     public String getName() {
14         return name;
15     }
16     public void setName(String name) {
17         this.name = name;
18     }
19     public String getSex() {
20         return sex;
21     }
22     public void setSex(String sex) {
23         this.sex = sex;
24     }
25     
26 }

现在我们需要将Tool类定义为泛型类：(注意格式)

 1 package bean;
 2 
 3 public class Tool<E> {
 4     private E e;
 5     
 6     public Tool(E e1){
 7         this.e = e1;
 8     }
 9 
10     public E getE() {
11         return e;
12     }
13     public void setE(E e) {
14         this.e = e;
15     }
16     
17 }

这里我们写的很简单，但已经满足需求了，重点在于泛型类的写法：Tool，这里的E字母可以写你自己喜欢的代码，这也就是类型参数的应用，E相当于一个类型参数，代表了Tool可以传入任意对象，下面我们具体使用来看看效果：

1 package bean;
 2 
 3 class Tooltest{
 4     public static void main(String[] args) {
 5         //假设有两个对象：一个学生，一个工人
 6         Student t1 = new Student("张三","男");
 7         Worker w1 = new Worker("李四",20);
 8         
 9         //现在我们使用Tool类来调用t1和w1
10         Tool<Student> ts = new Tool<Student>(t1);
11         Tool<Worker> tw = new Tool<Worker>(w1);
12         
13         //打印查看效果
14         System.out.println("使用ts调用t1中的数据："+ts.getE().getName()+":"+ts.getE().getSex());
15         System.out.println("使用tw调用w1中的数据："+tw.getE().getName()+":"+tw.getE().getAge());
16     }
17 }

打印结果为：
使用ts调用t1中的数据：张三:男
使用tw调用w1中的数据：李四:20

7.2【泛型方法】

泛型方法类似于静态类的设计，一般的方法传入的参数是固定类型的，如public void show(int i){}这个方法的参数类型固定为int，但是泛型方法可以传入指定的参数类型。一般泛型定义有两种形式：

    1)使用泛型类的参数类型来定义(常用)：

     如泛型类Tool<QQ>，它的泛型参数即为QQ。那么泛型方法可以这样写：public void show(QQ qq){}.

     2)使用自定义的参数类型来定义：

     如果我们需要自定义参数类型，那么我们把泛型参数放在方法上就可以了(放在返回值类型之前)：public <AA> void show(AA aa){}。

     注：静态方法不能访问类的泛型，如果需要泛型，我们只能使用方法2)，在方法上使用泛型即可：public static <AA> void show(AA aa){}

【泛型接口】

    和上面一样的道理，当我们不确定使用对象的类型时，运用泛型就可以解决问题，泛型接口和泛型类的使用是一样一样的。

   我们只需要注意，在实现泛型接口时有两种情况：这里假设有泛型接口interf<AA>，它的实现类是Tool。

   1)确定实现的泛型接口的参数类型：

    假设Tool类需要String类型的参数，那么实现可以直接写：class Tool implements interf<String>{}即可。

   2)不确定实现的泛型接口的参数类型：

   这时候我们需要泛型类来实现classTool<BB> implements interf<BB>{}.

泛型の通配符：？

    当我们不确定传入的对象类型时我们就可以使用？来代替。“？”即泛型通配符。

泛型的限定

    我们知道使用泛型类时：如果明确参数类型，那么泛型就代表一种类型；如果使用通配符？，那么泛型就代表任意类型。但有时候我们希望指定某些类型(不是一个，也不要所有)能作为参数类型，这应该怎么办呢？

    Java中利用泛型的限定解决了这个问题，即泛型的限定。我们只需要按这样的格式书写：

   上限：<？ extends E>表示参数类型是E及其所有子类。

   下限：<? super E>表示参数类型是E及其所有超类(即父类)。

​