关于泛型

泛型:

泛型是JDK1.5中一个最重要的特性,通过引入泛型,我们将获得编译时类型的安全,和运行时更小的抛出ClassCastexceptions的可能.在JDK1.5中,你可以声明一个集合接收或者返回的对象的类型.

 泛型之前:

类别定义时的逻辑完全一样,只是里面成员变量的类型不同.

如果需要多个相似的类,需要定义多个文件,不同的只是变量的类别,而逻辑是完全一样的.

IntergerFoo.java

public class IntegerFoo{
    private Integer foo;

    public Integer getFoo(){
        return foo;
    }

    public void setFoo(Integer foo){
        this.foo = foo;
    }
}

BooleanFoo.java

public class BooleanFoo{
    private Boolean foo;

    public Boolean getFoo()    {
        return foo;
    }

    public void setFoo(Boolean foo){
        this.foo = foo;
    }
}

如果有很多类型的话想用一个类型来替代以上等的类型怎么办,只能用Object类.

ObjectFoo.java

public class ObjectFoo{
    private Object foo;

    public Object getFoo(){
        return foo;
    }

    public void setFoo(Object foo){
        this.foo = foo;
    }
    
    public static void main(String[] args){
        ObjectFoo foo1 = new ObjectFoo();
        ObjectFoo foo2 = new ObjectFoo();
        
        foo1.setFoo(new Boolean(false));
        Boolean b = (Boolean)foo1.getFoo();
        
        foo2.setFoo(new Integer(10));
        Integer i = (Integer)foo2.getFoo();
        
        ObjectFoo foo3 = new ObjectFoo();
        foo3.setFoo(new Boolean(false));
        
        String str = (String)foo3.getFoo();
        //这个时候编译不会报错,但是运行的时候Object不能转换成String类型的,一定会出错
        //java.lang.ClassCastException: java.lang.Boolean cannot be caast to java.lang.String
    }
}

定义泛型类别:

如果使用泛型,只要代码在编译时没有出现警告,就不会遇到运行时ClassCastException

所谓泛型就是变量的类型参数化(不是变量本身,是变量的类型).

GenericFoo.java

public class GenericFoo<T>{
    private T foo;
    
    public T getFoo(){
        return foo;
    }

    public void setFoo(T foo){
        this.foo = foo;
    }

    public static void main(String[] args){
        GenericFoo<Boolean> foo1 = new GenericFoo<Boolean>();
        GenericFoo<Integer> foo2 = new GenericFoo<Integer>();
        
        foo1.setFoo(new Boolean(false));
        foo2.setFoo(new Integer(3));
        
        Boolean b = foo1.getFoo();
        Integer i = foo2.getFoo();
        
        System.out.println(b);//打印输出:false
        System.out.println(i);//打印输出:3
        
        //foo1 = foo2;
        //报错Type mismatch: cannot convert from GenericFoo<Integer> to GenericFoo<Boolean>
        
        GenericFoo a = new GenericFoo();
        a.setFoo("hello");
        
        String str = (String)a.getFoo();
        System.out.println(str);//输出:hello
    }
}

 Generic.java

public class Generic<T1, T2>{
    private T1 foo1;
    
    private T2 foo2;

    public T1 getFoo1(){
        return foo1;
    }

    public void setFoo1(T1 foo1){
        this.foo1 = foo1;
    }

    public T2 getFoo2(){
        return foo2;
    }

    public void setFoo2(T2 foo2){
        this.foo2 = foo2;
    }
    
    public static void main(String[] args){
        Generic<Integer, Boolean> foo = new Generic<Integer, Boolean>();
        
        foo.setFoo1(new Integer(-20));
        foo.setFoo2(new Boolean(false));
        
        System.out.println(foo.getFoo1());
        System.out.println(foo.getFoo2());
    }
}

打印输出:

-20
false

Generic2.java

public class Generic2<T>{
    private T[] fooArray;
    //泛型数组

    public T[] getFooArray(){
        return fooArray;
    }

    public void setFooArray(T[] fooArray){
        this.fooArray = fooArray;
    }
    
    public static void main(String[] args){
        Generic2<String> foo = new Generic2<String>();
        
        String[] str1 = {"hello", "world", "welcome"};
        String[] str2 = null;
        
        foo.setFooArray(str1);
        
        str2 = foo.getFooArray();
        
        for(int i = 0; i < str2.length; i++){
            System.out.println(str2[i]);
        }
    }
}

打印输出:

hello
world
welcome

SimpleCollection.java

public class SimpleCollection<T>{
    private T[] objArr;
    
    private int index = 0;
    
    public SimpleCollection(){
        objArr = (T[])new Object[10];
        //这个时候编译器会有一个警告:
        //Type safety: Unchecked cast from Object[] to T[]
        //这个时候老师领着看的ArrayList的源码中的get()方法
        
        //objArr = new T[10];
        //报错:Cannot create a generic array of T
        //语法上不允许这样创建一个泛型数组.这个时候怎么办?
        //只能用Object类型.
        
    }
    
    public SimpleCollection(int capacity){
        objArr = (T[])new Object[capacity];
    }
    
    public void add(T t){
        objArr[index++] = t;
    }
    
    public int getLength(){
        return this.index;
    }
    
    public T get(int i){
        return objArr[i];
    }
    
    public static void main(String[] args){
        SimpleCollection<Integer> c = new SimpleCollection<Integer>();
        
        for(int i = 0; i < 10; i++){
            c.add(new Integer(i));
        }
        
        for(int i = 0; i < 10; i++){
            Integer in = c.get(i);
            
            System.out.println(in);
        }
    }
}

打印输出:1~9

ArrayListTest.java

public class ArrayListTest{
    public static void main(String[] args){
        List<String> list = new ArrayList<String>();
        
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        //第一种遍历
        for(int i = 0; i < list.size(); i++){
            String value = list.get(i);
            System.out.println(value);
        }
        
        //第二种:使用迭代器
        for(Iterator<String> iter = list.iterator(); iter.hasNext();){
            String value = iter.next();
            System.out.println(value);
        }
    }
}

打印输出:两次a b c d

SetTest.java

package cn.shengsiyuan.jdk5;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class SetTest{
    public static void main(String[] args){
        Set<String> set = new HashSet<String>();

        set.add("aa");
        set.add("bb");
        set.add("cc");

        for (Iterator<String> iter = set.iterator(); iter.hasNext();){
            String value = iter.next();
            System.out.println(value);
        }
        
        System.out.println("----------------");
        
        Set<People> set2 = new HashSet<People>();
        
        set2.add(new People("zhangsan", 20, "beijing"));
        set2.add(new People("lisi", 30, "shanghai"));
        set2.add(new People("wangwu", 40, "tianjin"));
        
        for(Iterator<People> iter = set2.iterator(); iter.hasNext();){
            People people = iter.next();
            
            String name = people.getName();
            int age = people.getAge();
            String address = people.getAddress();
            
            System.out.println(name + "," + age + "," + address);
        }
    }
}

class People{
    private String name;

    private int age;

    private String address;

    public People(String name, int age, String address){
        this.name = name;
        this.age = age;
        this.address = address;

    }

    public int hashCode(){
        final int prime = 31;
        int result = 1;
        result = prime * result + ((address == null) ? 0 : address.hashCode());
        result = prime * result + age;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }

    public boolean equals(Object obj){
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        People other = (People) obj;
        if (address == null){
            if (other.address != null)
                return false;
        }
        else if (!address.equals(other.address)){
            return false;
        }
        if (age != other.age){
            return false;
        }
        if (name == null){
            if (other.name != null){
                return false;
            }
        }
        else if (!name.equals(other.name)){
            return false;
        }
        return true;
    }

    public String getName(){
        return name;
    }

    public void setName(String name){
        this.name = name;
    }

    public int getAge(){
        return age;
    }

    public void setAge(int age){
        this.age = age;
    }

    public String getAddress(){
        return address;
    }

    public void setAddress(String address){
        this.address = address;
    }
}

aa
bb
cc
----------------
wangwu,40,tianjin
zhangsan,20,beijing
lisi,30,shanghai

MapTest.java

public class MapTest{
    public static void main(String[] args){
        Map<String, String> map = new HashMap<String, String>();

        map.put("a", "aa");
        map.put("b", "bb");
        map.put("c", "cc");
        map.put("d", "dd");

        Set<String> set = map.keySet();

        for (Iterator<String> iter = set.iterator(); iter.hasNext();){
            String key = iter.next();
            String value = map.get(key);

            System.out.println(key + ":" + value);
        }

        System.out.println("----------------------------------");

        Set<Map.Entry<String, String>> set2 = map.entrySet();

        for (Iterator<Map.Entry<String, String>> iter = set2.iterator(); iter
                .hasNext();){
            Map.Entry<String, String> entry = iter.next();

            String key = entry.getKey();
            String value = entry.getValue();

            System.out.println(key + ":" + value);
        }
    }
}

d:dd
b:bb
c:cc
a:aa
----------------------------------
d:dd
b:bb
c:cc
a:aa

限制泛型可用类型:

在定义泛型类别时,预设可以使用任何的类型来实例化泛型类型中的类型,但是如果想要限制使用泛型类别时,只能用某个特定类型或者是其子类才能实例化该类型时,可以再定义类型时,使用extends关键字指定这个类型必须是继承某个类,或者实现某个接口.

当没有指定泛型继承的类型或接口时,默认使用T extends Object,所以默认情况下任何类型都可以作为参数传入.

 ListGenericFoo.java

public class ListGenericFoo<T extends List> {
    // 虽然这个地方List也是一个接口,但是在泛型中仍然要用extends.不能用implements.
    // 不管面是类还是接口都要用extends
    private T[] fooArray;

    public T[] getFooArray() {
        return fooArray;
    }

    public void setFooArray(T[] fooArray) {
        this.fooArray = fooArray;
    }

    public static void main(String[] args) {
        ListGenericFoo<LinkedList> foo1 = new ListGenericFoo<LinkedList>();
        ListGenericFoo<ArrayList> foo2 = new ListGenericFoo<ArrayList>();

        LinkedList[] linkedList = new LinkedList[10];

        foo1.setFooArray(linkedList);

        ArrayList[] arrayList = new ArrayList[10];

        foo2.setFooArray(arrayList);

        // ListGenericFoo<HashMap> foo3 = new ListGenericFoo<HashMap>();
        // 报错,HashMap和List没有关系.
        // Bound mismatch: The type HashMap is not a valid substitute for
        // the bounded parameter <T extends List> of the type ListGenericFoo<T>
    }
}

类型通配声明:

现在有这么一个需求,你希望哟u一个参考名称foo可以接受所有下面的实例:

foo = new Generic Foo<ArrayList>();
foo = new Generic Foo<LinkedList>();

简单的说,实例化类型持有者时,它必须是实现List的类别或其子类别,要定义这样一个名称,你可以使用"?"通配字符,并使用extends关键字限定类型持有者的形态.

GenericFoo<? extends List> foo = null;
foo = new GenericFoo<ArrayList>();
foo = new GenericFoo<LinkedList>();

GenericTest.java

public class GenericTest<T>{
    private T foo;

    public T getFoo(){
        return foo;
    }

    public void setFoo(T foo){
        this.foo = foo;
    }
    
    public static void main(String[] args){
        GenericTest<? extends List> ge = null;
        
        ge = new GenericTest<ArrayList>();
        ge = new GenericTest<LinkedList>();
        
        //ge = new GenericTest<HashMap>();
        
        GenericTest<? super List> ge2 = null;
        //这种super的非常少用,传递的值的类型必须是List的父类....
        ge2 = new GenericTest<Object>();
        
        //ge2 = new GenericTest<ArrayList>();
        //Type mismatch: cannot convert from GenericTest<ArrayList> to GenericTest<? super List>
        
        GenericTest<String> ge3 = new GenericTest<String>();
        ge3.setFoo("hello world");
        //GenericTest<? extends Object> ge4 = ge3;
        //如果后面是Object的话可以简写成一个问号"?"
        GenericTest<?> ge4 = ge3;
        System.out.println(ge4.getFoo());//打印输出:null
        
        
        ge4.setFoo(null);
        System.out.println(ge4.getFoo());//打印输出:null
        //ge4.setFoo("welcome");
        //eclipse的提示错误信息:The method setFoo(capture#7-of ?) 
        //in the type GenericTest<capture#7-of ?> is not applicable for the arguments (String)
        //这个错误信息不好理解.老师的解释是,当你上面GenericTest<? extends Object> ge4 的时候,编译器知道ge4的类型是
        //Object或者其子类.但是当你进行ge4.setFoo("welcome");时候,当进行get的时候必须是一个String类型的,这个和泛型的
        //的初衷想违背,所以是错误的.
        

使用<?>或是<? extends SomeClass>的声明方式，意味著您只能通过该名称來取得所参考实例的信息，或者是移除某些信息，但不能增加它的信息，因为只知道当中放置的是SomeClass的子类，但不确定是什么类的实例，编译器不让您加入信息，理由是，如果可以加入信息的話，那么您就得記得取回的实例是什么类型，然后转换为原來的类型方可进行操作，这就失去了使用泛型的意义。