JDK5.0的新特性

泛型

泛型是JDK5.0新特性比较突出的一大升级，我之前有写过一篇与泛型相关的文章，这里就不唠叨了，附上链接地址：Java的泛型

枚举 — enum

什么是枚举，比如我们需要在某个特定的范围内取值，这个值只能是在这个范围已规定了的。就拿现实中的交通信号灯来说，里面有红、绿、黄三色灯，但信号灯每次是从这三种颜色取出，不会去除其他的颜色，这就是枚举，对取出的值（内容）进行了规定限制。

枚举相关的类

• 传统方式

public class YouXin01 {
    private int light01;                //传统方式
    public void test() {
        //缺陷：可以直接使用this.color=10进行复制，绕开了只取Light类里的值
        this.color = Light01.RED;
    }
}
class Light01 {
    public static final int RED = 1;
    public static final int GREEN = 2;
    public static final int YELLOW = 3;
}

• 改进版

public class YouXin02 {
    private Light light;            //改进版
    public void test() {
        this.light = 
    }
}
class Light02 {
    //可以在此处进行对象的构建进行设置
    private Light02(){}
    public static final Light02 RED = new Light02();
    public static final Light02 GREEN = new Light02();
    public static final Light02 YELLOW = new Light02();
}

• 枚举方法 — 替代改进版的方式

enum Light03 {
    RED,GREEN,YELLOW;       //这些枚举元素等价于Light03的对象
}

特殊的枚举操作

• 在枚举里面有构造方法时：

enum Light04 {
    //当枚举构造方法里面有参数
    private Light04(String name){}
    RED("RED"){},
    GREEN("GREEN"){},
    YELLOW("YELLOW"){};
}

• 在枚举里面有抽象方法时：

enum Light05 {                      //Light05在这我称之为枚举类,Light05.class我称之为枚举类类对象
    RED("RED"){                     //RED在这我称之为枚举对象
        public void print1() {}     //实现抽象方法
    },
    GREEN("GREEN"){
        public void print1() {}
    },YELLOW("YELLOW"){
        public void print1() {}
    };
    public abstract void print1();
}

枚举相关的API操作

• name()：返回枚举对象的名称
• ordinal()：枚举变量在枚举类中的下标，下标从0开始
• valueOf(Class<T> enumType,String name)：根据,枚举类类对象，和枚举变量名称来获取对应的枚举变量

还有两个方法，这两个方法不在API中，是在编译的时候生成的两个方法

• 
  
• valueOf(String name)：转换枚举对象
• values()：获取所有枚举对象数组
  

下面就枚举API的使用举几个案例：

• 公共枚举类

enum Light {
    RED,GREEN,YELLOW;
}

• 知道枚举对象，获取该枚举对象，得到枚举名和下标

public void youXinExample01() {
    Light light = Light.RED;    //已知条件
    String name = light.name(); //枚举对象名字
    int idx = light.ordinal();  //枚举对象下标
    System.out.println(name + " " + idx);
}

• 知道枚举的名称，得到枚举的对象和下标

public void youXinExample02() {
    String name1 = "GREEN";
    Light green = Light.valueOf(name1); //得到枚举对象
    int idx1 = green.ordinal();         //得到枚举下标
    System.out.println(idx1);
}

• 知道枚举的下标，得到枚举的对象和名称

public void youXinExample3() {
    int idx2 = 2;
    Light[] cs = Light.values();    //得到枚举对象集合
    Light c12 = cs[idx2];           //根据下标得到枚举对象
    String name = c12.name();       //得到枚举对象的名字
    System.out.println(name);
}

静态导入

静态导入就是导入静态方法和常量，但是此方法的实用性不是很高，因为这样做会引起代码冲突

• 静态导入代码案例：

import static java.lang.System.out;
public class YouXin03 {
    public static void main(String[] args) {
        out.println("hello");           //使用System类的静态out方法
    }
}

自动拆装箱

装箱：把基本的数据类型转换成包装类
拆箱：把包装类转换成基本的数据类型

//JDK5.0的拆装箱
public void youXinTest01() {
    Integer m = 10;                 //装箱
    int m = i;                      //拆箱
}
//JDK1.4的拆装箱
public void youXinTest02() {
    Integer m = new Integer(10);    //装箱
    int a = m.intValue();           //拆箱
}

• JDK向下兼容问题

public class YouXin04 {
    public static void main(String[] args) {
        //因为JDK1.4不能实现自动拆装箱，所以进入的是doSomething(double m);因为变量自动向上转型
        doSomething(10);
    }
    public static void doSomething(double m) {
        System.out.println("double....");
    }
    public static void doSomething(Integer a) {
        System.out.println("Integer....");
    }
}

增强for循环

增强for就是对普通for(int a=0;a<10;a++){}循环的一种简便写法，同时目的也是为了替代迭代器，因为增强for底层就是迭代器的实现，但增强for循环有个使用场景限制就是：只能是数组或者是实现 Iterable 接口的集合，可以使用增强for循环，特别注意的是集合中List和Set集合实现了 Iterable接口，但Map没有实现，所以Map不能使用增强for循环，下面举个例子来说下使用增强for。

public class YouXin04 {
    public static void main(String[] args) {
        //创建List
        List<String> list = new ArrayList<String>();
        list.add("111");
        list.add("222");
        list.add("333");
        //增强for遍历list集合
        for(String item : list) {
            System.out.println(item);
        }
        System.out.println("================");
        //迭代器遍历list集合
        Iterator<String> it = list.iterator();
        while(it.hasNext()) {
            System.out.pringln(it.next());
        }
    }
}

可变参数

可变参数顾名思义就是参数的个数可变的，下面举个例先来看看什么是可变参数。

public class YouXin05 {
    public static void main(String[] args) {
        //调用同一个方法，但传递过去的参数却不同
        add(10, 20);
        add(10, 20 ,30);
        add(10, 20 ,30 ,40);
    }
    public static void add(int...nums) {
        //以上调用都会进入到此方法
        int sum = 0;
        for(int i=0; i< nums.length; i++) {
            sum += nums[i];
        }
        System.out.println(sum);
    }
}

以上是可变参数的应用，但可变参数有些是需要注意的，比如：

• 可变参数需要写在方法的参数列表中，不能单独定义
• 在方法的参数列表中只能有一个可变参数
• 方法的参数列表中的可变参数，必须放在参数最后