Java泛型

一、泛型简介

1.引入泛型的目的

了解引入泛型的动机,就先从语法糖开始了解。

语法糖

语法糖(Syntactic Sugar),也称糖衣语法,是由英国计算机学家Peter.J.Landin发明的一个术语,指在计算机语言中添加的某种语法,这种语法对语言的功能并没有影响,但是更方便程序员使用。Java中最常用的语法糖主要有泛型、变长参数、条件编译、自动拆装箱、内部类等。虚拟机并不支持这些语法,它们在编译阶段就被还原回了简单的基础语法结构,这个过程成为解语法糖。

泛型的目的: Java 泛型就是把一种语法糖,通过泛型使得在编译阶段完成一些类型转换的工作,避免在运行时强制类型转换而出现ClassCastException,即类型转换异常。

2.泛型初探

JDK 1.5 时才增加了泛型,并在很大程度上都是方便集合的使用,使其能够记住其元素的数据类型。

在泛型(Generic type或Generics)出现之前,是这么写代码的:

public static void main(String[] args)
{
    List list = new ArrayList();
    list.add("123");
    list.add("456");

    System.out.println((String)list.get(0));
}

当然这是完全允许的,因为List里面的内容是Object类型的,自然任何对象类型都可以放入、都可以取出,但是这么写会有两个问题:

1、当一个对象放入集合时,集合不会记住此对象的类型,当再次从集合中取出此对象时,该对象的编译类型变成了Object。

2、运行时需要人为地强制转换类型到具体目标,实际的程序绝不会这么简单,一个不小心就会出现java.lang.ClassCastException。

所以,泛型出现之后,上面的代码就改成了大家都熟知的写法:

public static void main(String[] args)
{
    List<String>
    list = new ArrayList<String>();
    list.add("123");
    list.add("456");

    System.out.println(list.get(0));
}

这就是泛型。泛型是对Java语言类型系统的一种扩展,有点类似于C++的模板,可以把类型参数看作是使用参数化类型时指定的类型的一个占位符。引入泛型,是对Java语言一个较大的功能增强,带来了很多的好处。

3.泛型的好处

①类型安全。类型错误现在在编译期间就被捕获到了,而不是在运行时当作java.lang.ClassCastException展示出来,将类型检查从运行时挪到编译时有助于开发者更容易找到错误,并提高程序的可靠性。

②消除了代码中许多的强制类型转换,增强了代码的可读性。

③为较大的优化带来了可能。

二、泛型的使用

1.泛型类和泛型接口

下面是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) {
   .......................
   }
}

这就是泛型的实质:允许在定义接口、类时声明类型形参,类型形参在整个接口、类体内可当成类型使用,几乎所有可使用普通类型的地方都可以使用这种类型形参。

下面具体讲解泛型类的使用。泛型接口的使用与泛型类几乎相同,可以比对自行学习。

泛型类

定义一个容器类,存放键值对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);

泛型类派生子类

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

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

正确的方式:

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

也可以不指定具体的类型,如下:

public class A extends Container{}

此时系统会把K,V形参当成Object类型处理。

2.泛型的方法

前面在介绍泛型类和泛型接口中提到,可以在泛型类、泛型接口的方法中,把泛型中声明的类型形参当成普通类型使用。 如下面的方式:

public class Container<K, V>
 {
........................
    public K getkey() {
        return key;
    }
    public void setKey() {
        this.key = key;
    }
....................
}

但在另外一些情况下,在类、接口中没有使用泛型时,定义方法时想定义类型形参,就会使用泛型方法。如下方式:

public class Main{
  public static <T> void out(T t){
       System.out.println(t);
  }
  public static void main(String[] args){
       out("hansheng");
       out(123);
  }
}

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

修饰符<T, S> 返回值类型 方法名(形参列表){
   方法体
}

注意: 方法声明中定义的形参只能在该方法里使用,而接口、类声明中定义的类型形参则可以在整个接口、类中使用。

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) ;  // 输出内容  
  }  
};

当调用fun()方法时,根据传入的实际对象,编译器就会判断出类型形参T所代表的实际类型。

3.泛型构造器

正如泛型方法允许在方法签名中声明类型形参一样,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);这种语法不允许,会直接编译报错!

三、类型通配符

顾名思义就是匹配任意类型的类型实参。

类型通配符是一个问号(?),将一个问号作为类型实参传给List集合,写作:List<?>(意思是元素类型未知的List)。这个问号(?)被成为通配符,它的元素类型可以匹配任何类型。

public void test(List<?> c){
  for(int i =0;i<c.size();i++){
    System.out.println(c.get(i));
  }
}

现在可以传入任何类型的List来调用test()方法,程序依然可以访问集合c中的元素,其类型是Object。

List<?> c = new ArrayList<String>();
//编译器报错
c.add(new Object());

但是并不能把元素加入到其中。因为程序无法确定c集合中元素的类型,所以不能向其添加对象。
下面就该引入带限通配符,来确定集合元素中的类型。

带限通配符

简单来讲,使用通配符的目的是来限制泛型的类型参数的类型,使其满足某种条件,固定为某些类。

主要分为两类即:上限通配符下限通配符

1.上限通配符

如果想限制使用泛型类别时,只能用某个特定类型或者是其子类型才能实例化该类型时,可以在定义类型时,使用extends关键字指定这个类型必须是继承某个类,或者实现某个接口,也可以是这个类或接口本身。

它表示集合中的所有元素都是Shape类型或者其子类
List<? extends Shape>

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

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

这样就确定集合中元素的类型,虽然不确定具体的类型,但最起码知道其父类。然后进行其他操作。

2.下限通配符

如果想限制使用泛型类别时,只能用某个特定类型或者是其父类型才能实例化该类型时,可以在定义类型时,使用super关键字指定这个类型必须是是某个类的父类,或者是某个接口的父接口,也可以是这个类或接口本身。

它表示集合中的所有元素都是Circle类型或者其父类
List <? super Circle>

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

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

四、类型擦除

Class c1=new ArrayList<Integer>().getClass();
Class c2=new ArrayList<String>().getClass();
System.out.println(c1==c2);

程序输出:

true。

这是因为不管为泛型的类型形参传入哪一种类型实参,对于Java来说,它们依然被当成同一类处理,在内存中也只占用一块内存空间。从Java泛型这一概念提出的目的来看,其只是作用于代码编译阶段,在编译过程中,对于正确检验泛型结果后,会将泛型的相关信息擦出,也就是说,成功编译过后的class文件中是不包含任何泛型信息的。泛型信息不会进入到运行时阶段。

在静态方法、静态初始化块或者静态变量的声明和初始化中不允许使用类型形参。由于系统中并不会真正生成泛型类,所以instanceof运算符后不能使用泛型类。