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); // 1
            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); // 2
            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

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