java新特性之JDK1.5

java新特性（自1.5开始）

java1.5

java 1.5 被称为跨时代的更新

1. 引入泛型；
2. 增强循环，可以使用迭代方式（也称foreach语句）；
3. 自动装箱与自动拆箱；
4. 枚举；
5. 可变参数；
6. 静态导入；
7. 元数据；
8. Instrumentation。

详解：

• 泛型
  泛型之前已经整理过了，传送门

• 增强for循环
  格式：for(ElementType element:arrayName){};
  ElementType可以是数组或者实现了Iterable接口的集合类， 使用增强for循环的时候会忽略角标信息，所以在需要角标的时候最好还是使用传统的方式。

public class Demo {
    public static void main(String[] args) {
        int[] ints = {1, 2, 4, 7, 8};
        String showInts = "[ ";
        for (int i : ints){
            showInts += i + " ";
        }
        showInts += "]";
        System.out.println(showInts);
    }
       /*
    结果： [ 1 2 4 7 8 ]

    */
}

• 自动装箱与自动装箱
  java为了效率，定义了8中基本数据类型： byte short int long
  char float double boolean 但是他们不是对象，没有指定的方法，所以他们有对应的封装类，而且内部定义了一些方法（定义泛型的时候用到基本数据类型的时候只能用其封装类）

      基本数据类型 -------------------  封装类
            byte --------------------  Byte
           short --------------------  Short
            int  --------------------  Integer
            long --------------------  Long
            char --------------------  Character
           float --------------------  Float
          double --------------------  Double
         boolean -------------------- Boolean
    Integer intNum = 13; //自动装箱
    int intNum2 = new Integer(13);//自动拆箱
    //你可能会觉得没什么作用 但是在之前必须手动装箱拆箱
    Integer intNum3 = new Integer(13); //手动装箱
    int intNum4 = intNum3.intValue();//手动拆箱
    //就问你恶心不恶心 多麻烦

• 枚举

枚举：一些方法在运行时，它需要的数据不能是任意的，而必须是一定范围内的值，可以直接使用枚举予以解决。
枚举类的定义格式：

enum 类名{
    //枚举值
}

有些方法在运行时，它需要的数据不能是任意的，而必须是一定范围内的
值,有了枚举之后可以直接使用枚举解决。比如： 方向 , 性别 , 季节 ,星期等

枚举要注意的细节：

1. 枚举类也是一个特殊的类。
2. 枚举值默认的修饰符是public static final。
3. 枚举值就是是枚举值所属的类的类型， 然后枚举值是指向了本类的对象的。
4. 枚举类的构造方法默认的修饰符是private的。
5. 枚举类可以定义自己的成员变量与成员函数。
6. 枚举类可以自定义构造函数，但是构造函数的修饰符必须是private。
7. 枚举类可以存在抽象的方法，但是枚举值必须要实现抽象的方法。
8. 枚举值必须要位置枚举类的第一个语句。
9. 枚举值可以用于switch语句

enum Sex{
    man("男"){
        @Override
        public void run() {
            System.out.println("男人在跑...");
        }
        
    },woman("女"){

        @Override
        public void run() {
            System.out.println("女人在跑...");
        }
        
        
    }; //枚举值
    
    String value; //成员变量
    

    //    public static final Sex man = new Sex();
    
    
    //构造函数
    private Sex(String  value){
        this.value = value;
    }
    
    //成员函数
    public void getValue(){
        System.out.println("value :"+ value);
    }
    
    public abstract void run();
    
}

public class Demo {
    
    public static void main(String[] args) {
        Sex sex = Sex.man; //获取到了枚举类的对象
        sex.value = "男";
        sex.getValue();
        sex.run();
    //结果 ：value :男
            男人在跑...
    }    
}

• 可变参数之前也使用过，比如我们要写一个方法来计算两个数的和：

    public void add(int a, int b){
        System.out.println("和是： " + (a+b));
    }

但是呢，我们要求好几个数的和，但是不知道有几个，一种思路就是将函数形参声明为一个数组，传递数组，来求数组元素的和。可变参数其实就是维护了一个数组，此时可以使用可变参数，格式 类型... 变量名

    public void add(int... nums){
        int sum = 0;
        for (int i : nums){
            sum+=i;
        }
        System.out.println("和是： " + sum);
    }    

• 静态导入

静态导入的作用： 简化书写。
静态导入可以作用一个类的所有静态成员。

静态导入的格式：
import static 包名.类名.静态的成员；

静态导入要注意：
如果静态导入的成员与本类的成员存在同名的情况下，那么默认使用本类的静态成员，如果需要指定使用静态导入的成员，那么需要在静态成员前面加上类名。个人感觉静态导入还是少用比较好，包的机制有个重要的作用就是避免命名的问题。
import static java.lang.System.out;

public class Demo1 {
    public static void main(String[] args) {
        out.println("haha...");
    }
}

• 元数据和Instrumentation

这个暂时可以不用理解，在此就先不详解。

未完。。。