Java之泛型

1. 概述
          在引入泛型之前，Java类型分为原始类型、复杂类型，其中复杂类型分为数组和类。引入泛型后，一个复杂类型就可以在细分成更多的类型。
          例如原先的类型List，现在在细分成List<Object>, List<String>等更多的类型。
          注意，现在List<Object>, List<String>是两种不同的类型，他们之间没有继承关系，即使String继承了Object。下面的代码是非法的：

 List<String> ls = new ArrayList<String>();
 List<Object> lo = ls;

这样设计的原因在于，根据lo的声明，编译器允许你向lo中添加任意对象（例如Integer），但是此对象是List<String>，破坏了数据类型的完整性。
         在引入范型之前，要在类中的方法支持多个数据类型，就需要对方法进行重载，在引入范型后，可以解决此问题（多态），更进一步可以定义多个参数以及返回值之间的关系。例如：

 public void write(Integer i, Integer[] ia);
 public void write(Double  d, Double[] da);

的范型版本为：

 public <T> void write(T t, T[] ta);

在看下面代码：

 public class GenericTest {

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

         for (int i = 0; i < list.size(); i++) {
             String name = (String) list.get(i); //
             System.out.println("name:" + name);
         }
     }
 }

定义了一个List类型的集合，先向其中加入了两个字符串类型的值，随后加入一个Integer类型的值。这是完全允许的，因为此时list默认的类型为Object类型。在之后的循环中，由于忘记了之前在list中也加入了Integer类型的值或其他编码原因，很容易出现类似于//1中的错误。因为编译阶段正常，而运行时会出现“java.lang.ClassCastException”异常。因此，导致此类错误编码过程中不易发现。

通过使用泛型，解决上面异常，修改代码如下：

 public class GenericTest {

     public static void main(String[] args) {
         /*
         List list = new ArrayList();
         list.add("qqyumidi");
         list.add("corn");
         list.add(100);
         */

         List<String> list = new ArrayList<String>();
         list.add("qqyumidi");
         list.add("corn");
         //list.add(100);   // 1  提示编译错误

         for (int i = 0; i < list.size(); i++) {
             String name = list.get(i); //
             System.out.println("name:" + name);
         }
     }
 }

总结： 使用泛型可以指代任意对象类型，定义的容器所放的内容是一个统一的类型；   

java中泛型的引入主要是为了解决两个方面的问题：
1. 集合类型元素在运行期出现类型装换异常，引入泛型增加编译时类型的检查;(即：消除强制类型转换，提高 Java 程序的类型安全)
2. 解决开发时重复代码的编写，能够复用算法。(比如：在类中的方法支持多个数据类型，就需要对方法进行重载)

2. 定义泛型类

我们直接上代码：

 package com.learn.chap06.sec01;

 public class Fdemo<T> {  // 泛型类
     private T a;

     public Fdemo(T a) {
         super();
         this.a = a;
     }

     public T getA() {
         return a;
     }

     public void setA(T a) {
         this.a = a;
     }

     public void print(){
         System.out.println("Obeject类型为："+a.getClass().getName());
     }

 }

 package com.learn.chap06.sec01;
 /**
  * 定义泛型类    (使用泛型可以指代任意对象类型)
  * @author Administrator
  *
  */
 public class Fdemotest {

     public static void main(String[] args) {
         Fdemo<Integer> test = new Fdemo<Integer>(12);
         test.print();
         System.out.println("test="+test.getA());

         Fdemo<String> strFdemo = new Fdemo<String>("我是中国人");
         strFdemo.print();
         System.out.println("strFdemo="+strFdemo.getA());
     }
 }

运行结果：

Obeject类型为：java.lang.Integer
test=12
Obeject类型为：java.lang.String
strFdemo=我是中国人

3. 限制泛型：

我们直接上代码：

 package com.learn.chap06.sec02;

 public class Animal {
     public void say() {
         System.out.println("它是动物");
     }
 }

 package com.learn.chap06.sec02;

 public class Dog extends Animal{

     @Override
     public void say() {
         // TODO Auto-generated method stub
         System.out.println("它是一只狗");
     }

 }

 package com.learn.chap06.sec02;

 public class Cat extends Animal{

     @Override
     public void say() {
         // TODO Auto-generated method stub
         System.out.println("它是一只猫");
     }

 }

 package com.learn.chap06.sec02;

 public class Demo<T extends Animal>{
     private T ob;

     public Demo(T ob) {
         super();
         this.ob = ob;
     }

     public T getOb() {
         return ob;
     }

     public void setOb(T ob) {
         this.ob = ob;
     }

     public void print(){
         System.out.println("T的类型是："+ob.getClass().getName());
     }
 }

 package com.learn.chap06.sec02;
 /**
  * 限制泛型
  * @author Administrator
  *
  */
 public class Test {
     public static void main(String[] args) {
         Demo<Dog> demo = new Demo<Dog>(new Dog());
         //demo.say();
         demo.print();

         //Demo<Integer> demo = new Demo<Integer>(new Dog()); // 由于泛型定义Demo类的类型必须为Animal或其子类Dog和Cat,而Integer不是Animal的子类，所以类型被限制，即：限制泛型，导致编译报错
         Demo<Animal> demo2 = new Demo<Animal>(new Cat());
         demo2.print();

         Demo<Cat> demo3 = new Demo<Cat>(new Cat());
         demo3.print();

     }
 }

运行结果：

T的类型是：com.learn.chap06.sec02.Dog
T的类型是：com.learn.chap06.sec02.Cat
T的类型是：com.learn.chap06.sec02.Cat

4. 通配符泛型：

我们直接上代码：

 package com.learn.chap06.sec03;

 import com.learn.chap06.sec02.Animal;
 import com.learn.chap06.sec02.Cat;
 import com.learn.chap06.sec02.Demo;
 import com.learn.chap06.sec02.Dog;

 public class Test1 {
     /**
      * 通配符泛型
      * @param demo
      */
     public static void take(Demo<?> demo){ // <?> 即为：通配符泛型
         demo.print();
     }

     public static void main(String[] args) {
         Demo<Dog> demo1 = new Demo<Dog>(new Dog());
         take(demo1);

         Demo<Cat> demo2 = new Demo<Cat>(new Cat());
         take(demo2);

         Demo<Animal> demo3 = new Demo<Animal>(new Animal());
         take(demo3);
     }
 }

运行结果：

T的类型是：com.learn.chap06.sec02.Dog
T的类型是：com.learn.chap06.sec02.Cat
T的类型是：com.learn.chap06.sec02.Animal

5. 泛型方法：

 package com.learn.chap06.sec04;

 public class Test {

     /**
      * 泛型方法
      * @param t
      */
     public  static <T> void f(T t) {
         System.out.println("T的类型是："+t.getClass().getName());
     }

     public static void main(String[] args) {
         f(1);
         f("hello");
         f(1.0f);
         f(new Object());
     }
 }

运行结果：

T的类型是：java.lang.Integer
T的类型是：java.lang.String
T的类型是：java.lang.Float
T的类型是：java.lang.Object

现在使用泛型没问题了吧！呵呵