25、jdk1.5新特性之泛型

jdk5.0（jdk1.5）中出现的新特性有：

泛型（Generics）、增强的“for”循环（Enhanced For Loop）、自动装箱/自动拆箱（Autoboxing/unboxing）、类型安全的枚举（Type safe enums）、静态导入（Static import）、可变参数（Var args）

1、泛型

泛型是JDK1.5中一个最重要的特征。通过引入泛型，我们将获得编译时类型的安全和运行时更小地抛出ClassCastExceptions的可能。

2、IDE的调整，将myeclipse的 window——>Proferences——>java——>compiler 的compiler compliance level改为 1.6

3、所谓泛型：就是变量类型的参数化

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(2));

        Boolean b = foo1.getFoo();
        Integer i = foo2.getFoo();
    }
}

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(2));
		
		Boolean b = foo1.getFoo();
		Integer i = foo2.getFoo();
	}
}

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

5、使用泛型因为：

      类别定义时的逻辑完全一样，只是里面成员变量的类型不同
      如果需要多个相似的类，需要定义多个文件，不同的只是变量的类别，而逻辑是完全一样的

6、T不能是原生数据类型，如果：GenericFoo<int> i = new GenericFoo<int>();是错误的

7、类定义时使用了泛型，但是使用时可以不使用泛型，如上例可以这样：GenericFoo a = new GenericFoo（）；编译只会给出警告。

8、泛型可以定义多个类型：

public class Generic1<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)
    {
        Generic1<Integer,Boolean> foo = new Generic1<Integer,Boolean>();

        foo.setFoo1(new Integer(2));
        foo.setFoo2(new Boolean(true));

    }
}

public class Generic1<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)
	{
		Generic1<Integer,Boolean> foo = new Generic1<Integer,Boolean>();
		
		foo.setFoo1(new Integer(2));
		foo.setFoo2(new Boolean(true));
		
	}
}

9、泛型的泛型

public class WrapperFoo<T>
{
    private GenericFoo4<T> foo;

    public GenericFoo4<T> getFoo()
    {
        return foo;
    }

    public void setFoo(GenericFoo4<T> foo)
    {
        this.foo = foo;
    }
    public static void main(String[] args)
    {
        GenericFoo4<Integer> foo = new GenericFoo4<Integer>();
        foo.setFoo(new Integer(-10));

        WrapperFoo<Integer> wrapper =  new WrapperFoo<Integer>();
        wrapper.setFoo(foo);

        GenericFoo4<Integer> g = wrapper.getFoo();
        System.out.println(g.getFoo());
    }
}
class GenericFoo4<T>
{
    private T foo;

    public T getFoo()
    {
        return foo;
    }

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

}

public class WrapperFoo<T>
{
	private GenericFoo4<T> foo;

	public GenericFoo4<T> getFoo()
	{
		return foo;
	}

	public void setFoo(GenericFoo4<T> foo)
	{
		this.foo = foo;
	}
	public static void main(String[] args)
	{
		GenericFoo4<Integer> foo = new GenericFoo4<Integer>();
		foo.setFoo(new Integer(-10));
		
		WrapperFoo<Integer> wrapper = new WrapperFoo<Integer>();
		wrapper.setFoo(foo);
		
		GenericFoo4<Integer> g = wrapper.getFoo();
		System.out.println(g.getFoo());
	}
}
class GenericFoo4<T>
{
	private T foo;

	public T getFoo()
	{
		return foo;
	}

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

10、Set泛型举例：

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

public class SetTest<T>
{
    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 s = iter.next();
            System.out.println(s);
        }
    }
}

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

public class SetTest<T>
{
	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 s = iter.next();
			System.out.println(s);
		}
	}
}

11、Map泛型举例：

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

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");

        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);
        }

        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);
        }
    }
}

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

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");
		
		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);			
		}
		
		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);	
		}
	}
}

12、限制泛型可用类型

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

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class ListGeneric<T extends List>
{
    private T[] fooArray;

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

    public void setFooArray(T[] fooArray)
    {
        this.fooArray = fooArray;
    }
    public static void main(String[] args)
    {
        ListGeneric<LinkedList> foo1 = new ListGeneric<LinkedList>();
        ListGeneric<ArrayList> foo2 =  new ListGeneric<ArrayList>();

        LinkedList[] linkedList = new LinkedList[10];
        foo1.setFooArray(linkedList);
        ArrayList[] arrayList = new ArrayList[10];
        foo2.setFooArray(arrayList);

    }
}

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class ListGeneric<T extends List>
{
	private T[] fooArray;

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

	public void setFooArray(T[] fooArray)
	{
		this.fooArray = fooArray;
	}
	public static void main(String[] args)
	{
		ListGeneric<LinkedList> foo1 = new ListGeneric<LinkedList>();
		ListGeneric<ArrayList> foo2 = new ListGeneric<ArrayList>();
		
		LinkedList[] linkedList = new LinkedList[10];
		foo1.setFooArray(linkedList);
		ArrayList[] arrayList = new ArrayList[10];
		foo2.setFooArray(arrayList);
		
	}
}

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

13、类型通配声明：

GenericFoo<Integer> foo1 = null;
GenericFoo<Boolean> foo2 = null;
那么 foo1 就只接受GenericFoo<Integer>的实例，而foo2只接受GenericFoo<Boolean>的实例。

如果现在有这样一种要求，一个变量可以同时接受下面的实例：

foo = new GenericFoo<ArrayList>();          foo = new GenericFoo<LinkedList>();
简单的说，实例化类型持有者时，它必須是实现List的类别或其子类别，要定义这样一个名称，您可以使用 ‘?’ 通配字元，并使用“extends”关键字限定类型持有者的型态

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

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