《Java架构筑基》从Java基础讲起——泛型的使用

一. 泛型的使用

1. 泛型类的概述及使用

• A:泛型类概述: 把泛型定义在类上
• B:定义格式: public class 类名<泛型类型1,…>
• C:注意事项: 泛型类型必须是引用类型

2. 泛型方法的概述和使用

• A:泛型方法概述: 把泛型定义在方法上
• B:定义格式: public <泛型类型> 返回类型 方法名(泛型类型 变量名)

public <T> void show(T t) {

}

所谓泛型方法，就是在声明方法时定义一个或多个类型形参。 泛型方法的用法格式以下：

修饰符<T, S> 返回值类型 方法名（形参列表）｛
   方法体
｝

注意要点：

• 方法声明中定义的形参只能在该方法里使用，而接口、类声明中定义的类型形参则能够在整个接口、类中使用。当调用fun()方法时，根据传入的实际对象，编译器就会判断出类型形参T所表明的实际类型。

class Demo{  
  public <T> T fun(T t){   // 能够接收任意类型的数据  
   return t ;     // 直接把参数返回  
  }  
};  
public class GenericsDemo26{  
  public static void main(String args[]){  
    Demo d = new Demo() ; // 实例化Demo对象  
    String str = d.fun("汤姆") ; // 传递字符串  
    int i = d.fun(30) ;  // 传递数字，自动装箱  
    System.out.println(str) ; // 输出内容  
    System.out.println(i) ;  // 输出内容  
  }  
};

3. 泛型接口的概述和使用

先来看一个案例

• A:泛型接口概述: 把泛型定义在接口上
• B:定义格式: public interface 接口名<泛型类型>

/**
 * 泛型接口的定义格式:        修饰符  interface 接口名<数据类型> {}
 */
public interface Inter<T> {
    public abstract void show(T t) ;
}

/**
 * 子类是泛型类
 */
public class InterImpl<E> implements Inter<E> {
    @Override
    public void show(E t) {
        System.out.println(t);
    }
}

Inter<String> inter = new InterImpl<String>() ;
inter.show("hello") ;

而后看看源码中泛型的使用，下面是JDK 1.5 之后，List接口，以及ArrayList类的代码片断。

//定义接口时指定了一个类型形参，该形参名为E
public interface List<E> extends Collection<E> {
   //在该接口里，E能够做为类型使用
   public E get(int index) {}
   public void add(E e) {} 
}

//定义类时指定了一个类型形参，该形参名为E
public class ArrayList<E> extends AbstractList<E> implements List<E> {
   //在该类里，E能够做为类型使用
   public void set(E e) {
   .......................
   }
}

这就是泛型的实质：容许在定义接口、类时声明类型形参，类型形参在整个接口、类体内可当成类型使用，几乎全部可以使用普通类型的地方均可以使用这种类型形参。

泛型类派生子类

• 当建立了带泛型声明的接口、父类以后，能够为该接口建立实现类，或者从该父类派生子类，须要注意：使用这些接口、父类派生子类时不能再包含类型形参，须要传入具体的类型。
• 错误的方式：

public class A extends Container<K, V>{}

• 正确的方式：

public class A extends Container<Integer, String>{}

• 也能够不指定具体的类型，此时系统会把K,V形参当成Object类型处理。以下：

public class A extends Container{}

4. 泛型类的概述和使用

定义一个容器类，存放键值对key-value，键值对的类型不肯定，可使用泛型来定义，分别指定为K和V。

public class Container<K, V> {

    private K key;
    private V value;

    public Container(K k, V v) {
        key = k;
        value = v;
    }

    public K getkey() {
        return key;
    }

    public V getValue() {
        return value;
    }

    public void setKey() {
        this.key = key;
    }

    public void setValue() {
        this.value = value;
    }

}

在使用Container类时，只须要指定K，V的具体类型便可，从而建立出逻辑上不一样的Container实例，用来存放不一样的数据类型。

public static void main(String[] args) {
    Container<String,String>  c1=new Container<String ,String>("name","hello");
    Container<String,Integer> c2=new Container<String,Integer>("age",22);
    Container<Double,Double>  c3=new Container<Double,Double>(1.1,1.3);
    System.out.println(c1.getKey() + " : " + c1.getValue());      
    System.out.println(c2.getKey() + " : " + c2.getValue());                                                               
    System.out.println(c3.getKey() + " : " + c3.getValue());
}

在JDK 1.7 增长了泛型的“菱形”语法：Java容许在构造器后不须要带完成的泛型信息，只要给出一对尖括号（<>）便可，Java能够推断尖括号里应该是什么泛型信息。 以下所示：

Container<String,String> c1=new Container<>("name","hello");
Container<String,Integer> c2=new Container<>("age",22);

5. 泛型构造器的概述

• 正如泛型方法容许在方法签名中声明类型形参同样，Java也容许在构造器签名中声明类型形参，这样就产生了所谓的泛型构造器。
• 和使用普通泛型方法同样没区别，一种是显式指定泛型参数，另外一种是隐式推断，若是是显式指定则以显式指定的类型参数为准，若是传入的参数的类型和指定的类型实参不符，将会编译报错。

  public class Person {
  public <T> Person(T t) {
      System.out.println(t);
  }
  }

• 如何使用

  public static void main(String[] args){
  //隐式
  new Person(22);
  //显示
  new<String> Person("hello");
  }

这里惟一须要特殊注明的就是：

若是构造器是泛型构造器，同时该类也是一个泛型类的状况下应该如何使用泛型构造器：由于泛型构造器能够显式指定本身的类型参数（须要用到菱形，放在构造器以前），而泛型类本身的类型实参也须要指定（菱形放在构造器以后），这就同时出现了两个菱形了，这就会有一些小问题，具体用法再这里总结一下。

如下面这个例子为表明

public class Person<E> {
    public <T> Person(T t) {
        System.out.println(t);
    }
}

这种用法：Person<String> a = new <Integer>Person<>(15);这种语法不容许，会直接编译报错！

二. 泛型高级之通配符

1. 为何要使用通配符

通配符的设计存在必定的场景，例如在使用泛型后，首先声明了一个Animal的类，然后声明了一个继承Animal类的Cat类，显然Cat类是Animal类的子类，可是List却不是List的子类型，而在程序中每每须要表达这样的逻辑关系。为了解决这种相似的场景，在泛型的参数类型的基础上新增了通配符的用法。

2. <? extends T> 上界通配符

上界通配符顾名思义，<? extends T>表示的是类型的上界【包含自身】，所以通配的参数化类型多是T或T的子类。

• 正由于没法肯定具体的类型是什么，add方法受限（能够添加null，由于null表示任何类型），但能够从列表中获取元素后赋值给父类型。如上图中的第一个例子，第三个add()操做会受限，缘由在于List和List是List<? extends Animal>的子类型。

它表示集合中的全部元素都是Animal类型或者其子类
List<? extends Animal>

这就是所谓的上限通配符，使用关键字extends来实现，实例化时，指定类型实参只能是extends后类型的子类或其自己。

• 例如：
• 这样就肯定集合中元素的类型，虽然不肯定具体的类型，但最起码知道其父类。而后进行其余操做。

//Cat是其子类
List<? extends Animal> list = new ArrayList<Cat>();

3. <? super T> 下界通配符

下界通配符<? super T>表示的是参数化类型是T的超类型（包含自身），层层至上，直至Object

• 编译器无从判断get()返回的对象的类型是什么，所以get()方法受限。可是能够进行add()方法，add()方法能够添加T类型和T类型的子类型，如第二个例子中首先添加了一个Cat类型对象，而后添加了两个Cat子类类型的对象，这种方法是可行的，可是若是添加一个Animal类型的对象，显然将继承的关系弄反了，是不可行的。

它表示集合中的全部元素都是Cat类型或者其父类
List <? super Cat>

这就是所谓的下限通配符，使用关键字super来实现，实例化时，指定类型实参只能是extends后类型的子类或其自己。

例如：

//Shape是其父类
List<? super Cat> list = new ArrayList<Animal>();

4. <?> ***通配符

• 任意类型，若是没有明确，那么就是Object以及任意的Java类了
• ***通配符用<?>表示，?表明了任何的一种类型，能表明任何一种类型的只有null（Object自己也算是一种类型，但却不能表明任何一种类型，因此List和List的含义是不一样的，前者类型是Object，也就是继承树的最上层，然后者的类型彻底是未知的）。

三. 泛型只能使用引用类型

当声明泛型类的实例时，传递的类型参数必须是引用类型，不能使用基本类型

• 例如，对于 User 泛型类来讲，如下声明是非法的

  User<int,double> user=new User<>(1,10,0);

如何解决

• 可使用类型的包装类来解决该问题