JDK5.0的11个主要新特征一览

    1           泛型(Generic)
    1.1          说明
    增强了java的类型，可以在编译期间对容器内的对象进行类型检查，在运行期不必进行类型的转换。而在j2se5之前必须在运行期动态进行容器内对象的检查及转换
    减少含糊的容器，可以定义什么类型的数据放入容器

    ArrayList listOfIntegers; // is new to the syntax
    Integer integerObject;
    listOfIntegers = new ArrayList(); // is new to the syntax
    listOfIntegers.add(new Integer(10)); // 只能是Integer类型
    integerObject = listOfIntegers.get(0); // 取出对象不需要转换

    1.2          用法

    声明及实例化泛型类：
    HashMap hm = new HashMap();
    //不能使用原始类型
    GenList nList = new GenList();  //编译错误

    J2SE 5.0目前不支持原始类型作为类型参数(type parameter)

    定义泛型接口：
    public interface GenInterface {
        void func(T t);
    }

    定义泛型类：
    public class ArrayList { ... }
    public class GenMap { ... }
    例1：
    public class MyList extends LinkedList
    {
           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 list = new MyList();
                  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 {
           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 String getString(T obj) { //实现了一个泛型方法
                  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 {
           public static void main(String[] args) {
                  Limited number;   //正确
                  Limited str;       //编译错误
           }
    }

    1.4          泛型与异常

    类型参数在catch块中不允许出现，但是能用在方法的throws之后。例：
    import java.io.*;
    interface Executor {
           void execute() throws E;
    }

    public class GenericExceptionTest {
           public static void main(String args[]) {
                  try {
                         Executor e = new Executor() {
                                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(); //error
    不能实例化泛型类型的数组
    T[] ts= new T[10];   //编译错误
    不能实例化泛型参数数
    Pair[] table = new Pair(10); // ERROR
    类的静态变量不能声明为类型参数类型
    public class GenClass {
         private static T t;    //编译错误
    }
    泛型类不能继承自Throwable以及其子类
    public GenExpection extends Exception{}    //编译错误
    不能用于基础类型int等
    Pair //error
    Pair //right
    2           增强循环(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));
    //或者用以下循环
    //for(Iterator iter = list.iterator(); iter.hasNext(); ) {
    //Integer stringObject = (String)iter.next();
    // ... more statements to use stringObject...
    //}
    新的循环
    LinkedList list = new LinkedList();
    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);

 

[1]   

【责编:landy】

--------------------next---------------------