JDK5.0的主要新特征(1)

Question

1  泛型(Generic)
　　1.1 说明　　增强了java的类型安全，可以在编译期间对容器内的对象进行类型检查，在运行期不必进行类型的转换。而在j2se5之前必须在运行期动态进行容器内对象的检查及转换　　减少含糊的容器，可以定义什么类型的数据放入容器ArrayList<Integer> listOfIntegers; // <TYPE_NAME> is new to the syntax
Integer integerObject;
listOfIntegers = new ArrayList<Integer>(); // <TYPE_NAME> is new to the syntax
listOfIntegers.add(new Integer(10)); // 只能是Integer类型
integerObject = listOfIntegers.get(0); // 取出对象不需要转换　　1.2   用法　　声明及实例化泛型类：HashMap<String,Float> hm = new HashMap<String,Float>();
file://不能使用原始类型
GenList<int> nList = new GenList<int>();  file://编译错误　　J2SE 5.0目前不支持原始类型作为类型参数(type parameter)　　定义泛型接口：public interface GenInterface<T> {    void func(T t);
}　　定义泛型类：public class ArrayList<ItemType> { ... }public class GenMap<T, V> { ... }　　例1：public class MyList<Element> extends LinkedList<Element>{
       public void swap(int i, int j)
       {
              Element temp = this.get(i);
              this.set(i, this.get(j));
              this.set(j, temp);
       }       public static void main(String[] args)
       {
              MyList<String> list = new MyList<String>();
              list.add("hi");
              list.add("andy");
              System.out.println(list.get(0) + " " + list.get(1));
              list.swap(0,1);
              System.out.println(list.get(0) + " " + list.get(1));
       }
}　　例2：public class GenList <T>{       private T[] elements;
       private int size = 0;
       private int length = 0;       public GenList(int size) {
              elements = (T[])new Object[size];
              this.size = size;
       }       public T get(int i) {
              if (i < length) {
                     return elements[i];
              }
              return null;
       }       public void add(T e) {
              if (length < size - 1)
                     elements[length++] = e;
       }
}　　泛型方法：public class TestGenerics{       public <T> String getString(T obj) { file://实现了一个泛型方法
              return obj.toString();
       }       public static void main(String [] args){
              TestGenerics t = new TestGenerics();
              String s = "Hello";
              Integer i = 100;
              System.out.println(t.getString(s));
              System.out.println(t.getString(i));
              }
}　　1.3 受限泛型　　受限泛型是指类型参数的取值范围是受到限制的. extends关键字不仅仅可以用来声明类的继承关系, 也可以用来声明类型参数(type parameter)的受限关系.例如, 我们只需要一个存放数字的列表, 包括整数(Long, Integer, Short), 实数(Double, Float), 不能用来存放其他类型, 例如字符串(String), 也就是说, 要把类型参数T的取值泛型限制在Number极其子类中.在这种情况下, 我们就可以使用extends关键字把类型参数(type parameter)限制为数字　　示例public class Limited<T extends Number> {       public static void main(String[] args) {
              Limited<Integer> number;   file://正确
              Limited<String> str;       file://编译错误
       }
}　　1.4  泛型与异常　　类型参数在catch块中不允许出现，但是能用在方法的throws之后。例：import java.io.*;interface Executor<E extends Exception> {
       void execute() throws E;
}public class GenericExceptionTest {
       public static void main(String args[]) {
              try {
                     Executor<IOException> e = new Executor<IOException>() {
                            public void execute() throws IOException{
                                   // code here that may throw an
                                   // IOException or a subtype of
                                   // IOException
                            }
                            };
                     e.execute();
              } catch(IOException ioe) {
                     System.out.println("IOException: " + ioe);
                     ioe.printStackTrace();
              }
       }
}　　1.5 泛型的通配符"?"　　"?"可以用来代替任何类型, 例如使用通配符来实现print方法。public static void print(GenList<?> list) {})　　1.6  泛型的一些局限型　　不能实例化泛型T t = new T(); file://error　　不能实例化泛型类型的数组T[] ts= new T[10];   file://编译错误　　不能实例化泛型参数数Pair<String>[] table = new Pair<String>(10); // ERROR　　类的静态变量不能声明为类型参数类型public class GenClass<T> {     private static T t;    file://编译错误
}　　泛型类不能继承自Throwable以及其子类public GenExpection<T> extends Exception{}    file://编译错误 　　不能用于基础类型int等Pair<double> file://errorPair<Double> file://right2 增强循环(Enhanced for Loop)
　　旧的循环LinkedList list = new LinkedList(); list.add("Hi");
list.add("everyone!");
list.add("Was");
list.add("the");
list.add("pizza");
list.add("good?");
for (int i = 0; i < list.size(); i++)
       System.out.println((String) list.get(i));
file://或者用以下循环
file://for(Iterator iter = list.iterator(); iter.hasNext(); ) {
file://Integer stringObject = (String)iter.next();
// ... more statements to use stringObject... 
file://}　　新的循环LinkedList<String> list = new LinkedList<String>(); list.add("Hi");
list.add("everyone!");
list.add("Was");
list.add("the");
list.add("pizza");
list.add("good?"); 
for (String s : list)
       System.out.println(s);　　很清晰、方便，一看便知其用法