Java 泛型

泛型是JDK5.0的新特性。

我们需要知道：

1.为什么要引入泛型？

2.泛型语法如何实现？

3.泛型的优点和缺点？

我们之前学习过JDK5.0的新特性自动拆箱和自动装箱，是编译期的概念，泛型也是编译期的概念。

先来分析一下以下程序没有使用泛型，缺点是什么？

import java.util.*;
public class GenericTest01{
 public static void main(String args[]){
   //创建一个集合，用来存储A,B,C
   Set s=new HashSet();
   //创建对象
   A a=new A();
   B b=new B();
   C c=new C();
   
   s.add(a);
   s.add(b);
   s.add(c);
   
   //遍历，需求：如果是A类型调用m1方法，如果是B类型，调用m2方法，如果是C类型，调用m3方法。
    Iterator it=s.iterator();
   while(it.hasNext()){
     Object o=it.next();
     //只能做大量的强制类型转换
     if(o instanceof A){
       A a1=(A)o;
         a1.m1();
     }else if(o instanceof B){
       B b1=(B)o;
         b1.m2();
     }else if(o instanceof C){
       C c1=(C)o;
         c1.m3();
     }
   }
 }
}
class A{
 public static void m1(){
   System.out.println("A's m1 is...");
 }
}
class B{
 public static void m2(){
   System.out.println("B's m2 is...");
 }
}
class C{
 public static void m3(){
   System.out.println("C's m3 is...");
 }
}

编译运行后输出：

C's m3 is...
A's m1 is...
B's m2 is...

在上面程序中，

1.我们定义了三个类型A,B,C，并且各自定义了方法，m1( ),m2( ),m3( )。

2.主程序中，首先利用语句Set s=new HashSet();来创建集合s,用来存储A,B,C，接着创建对象,添加到集合s中去。

3.之后遍历，这里给出了需求，遍历集合，如果是A类型调用m1方法，如果是B类型，调用m2方法，如果是C类型，调用m3方法。iterator接口没有泛型则只能访问Object类型，即Object o=it.next();

4.根据需求，只能做大量的强制类型转换，A a1=(A)o; 然后调用各自类型的方法。

通过分析以上程序可以知道，如果集合不使用泛型，则集合中的元素类型不统一，在遍历集合的时候，只能拿出来Object类型，需要做大量的强制类型转换，操作起来很麻烦。

开头提出的三个问题：

1.为什么使用泛型？

①引入泛型可以统一集合中的数据类型；

②可以减少强制类型转换。

3.泛型的优点和缺点？

优点是统一类型，可以减少强制类型转换；缺点是只能存储一种数据类型。

接下来看看第二个问题，泛型语法如何实现？看以下程序,List使用泛型：

import java.util.*;
public class GenericTest02{
 public static void main(String args[]){
   //创建一个List集合，只能存储字符串类型
   List<String> strs=new ArrayList();
   //添加元素
   strs.add("JACK");
   strs.add("TOM");
   strs.add("LINDA");
   strs.add("LIMING");
   //遍历
   Iterator<String> it=strs.iterator();
   while(it.hasNext()){
     System.out.println(it.next());
   }
 }
}

接下来看Map使用泛型，看以下例子：

import java.util.*;
public class GenericTest03{
 public static void main(String[] args){
   Map<String,Integer> maps=new HashMap<String,Integer>();
   maps.put("西瓜",10);
   maps.put("桃子",5);
   maps.put("樱桃",20);
   
   Set<String> keys=maps.keySet();
   Iterator<String> it=keys.iterator();
   while(it.hasNext()){
     String k=it.next();
     Integer v=maps.get(k);
     System.out.println(k+"---->"+v);
   }
 }
}

编译后运行输出：

桃子---->5
西瓜---->10
樱桃---->20

其中用到的两个方法重温一下，一个是keySet();另一个是get()，分别用来得到Map中的键值对。

再来看SortedSet集合使用泛型。

import java.util.*;
public class GenericTest04{
 public static void main(String[] args){
                                //创建集合
   SortedSet<Manager> ss=new TreeSet<Manager>();
   //添加元素
   Manager m1=new   Manager(1000.0);
   Manager m2=new   Manager(1500.0);
   Manager m3=new   Manager(3000.0);
   
   ss.add(m1);
   ss.add(m2);
   ss.add(m3);
   
   //遍历
   Iterator<Manager> it=ss.iterator();
   while(it.hasNext()){
     Manager m=it.next();
     System.out.println(m);
   }
 }
}
class Manager implements Comparable<Manager>{
double sal;
Manager(double sal){
 this.sal=sal;
}
public String toString(){
 return sal+"";
}
//实现接口中的方法
public int compareTo(Manager m){
 double sal1=this.sal;
 double sal2=m.sal;
 if(sal1>sal2){
   return 1;
 }else if(sal1<sal2){
   return -1;
 }
 return 0;
}
}

在上面的例子中，Manager类继承了 Comparable接口，并重写了该接口中的compareTo()方法。

在深入了解泛型之前需要回忆一下向上转型和向下转型，结合以下代码来看：

public class TestF{
 private Object b;
 public Object getB(){
   return b;
 }
 public void setB(Object b){
   this.b=b;
 }
 public static void main(String[] args){
   TestF t=new TestF();
   //向上转型
   t.setB(new Boolean(true));
   //向下转型:getB()方法返回的是Object类型的，却以Boolean类型返回;
   System.out.println(t.getB());
   t.setB(new Float(12.4));
   Float f=(Float)(t.getB());
   System.out.println(f);
 }
}

编译运行后输出：

true
12.4

在上述代码中，TestF类定义了私有的成员变量b,类型为Object类，同时为其定义了getB()和setB()方法。在主方法中，将new Boolean(true)对象作为setB()方法的参数，由于setB()方法的参数类型为Object类型，而new Boolean(true)对象为Boolean类型，因此就实现了向上转型操作。同时在调用getB()方法时，将getB()方法返回的Object对象以相应的Boolean类型返回，因此实现了向下转型操作。向上转型是安全的，但是向下转型如果用错了类型，或没有执行该操作，通常会报异常，如下将上面的代码修改一下：

public class TestF{
 private Object b;
 public Object getB(){
   return b;
 }
 public void setB(Object b){
   this.b=b;
 }
 public static void main(String[] args){
   TestF t=new TestF();
   //向上转型
   t.setB(new Boolean(true));
   //向下转型:getB()方法返回的是Object类型的，却以Boolean类型返回;
   System.out.println(t.getB());
   t.setB(new Float(12.4));
   Integer f=(Integer)(t.getB());
   System.out.println(f);
 }
}

编译运行后输出：

true
Exception in thread "main" java.lang.ClassCastException: java.lang.Float cannot be cast to java.lang.Integer

 at TestF.main(TestF.java:16)

Object类为最上层的父类，很多程序员为了使程序更为通用，通常程序传入的值与返回的值都为Object类型，但在需要使用这些实例时，必须正确地将该实例转换为原来的类型，否则就会报ClassCastException异常。

接下来使用泛型对第一个代码进行修改，代码如下：

public class OverClass<T>{
 private T over;
 public T get(){
   return over;
 }
 public void set(T over){
   this.over=over;
 }
 public static void main(String[] args){
   OverClass<Boolean> over1=new OverClass<Boolean>();
   OverClass<Float> over2=new OverClass<Float>();
   over1.set(true);
   System.out.println(over1.get());
   over2.set(12.3f);
   System.out.println(over2.get());
 }
 
}

在上述代码中，定义OverClass类时，后面加了一个<T>,这里便引用了泛型机制，OverClass<T>便称为泛型类，同时返回和接受的参数使用T这个类型。最后在主方法中使用OverClass<Boolean>形式返回一个Boolean类型的对象，使用OverClass<Float>形式返回一个Float类型的对象，不需要进行向上转型和向下转型操作。

搜索微信公众号“程序员考拉”，欢迎关注！