jdk1.5新特性

1、静态导入
   示例：
       package cn.zuxia.test;
       /**
        * 这里就是静态导入
        */
       import static java.lang.Math.*;  //通过静态导入导入Math类的所有静态方法

       public class Test01 {

             public static void main(String[] args) {
    
                   System.out.println(max(3, 6)); //这里直接使用的max方法，而不是Math.max()
             }
       }
 
2、可变参数
   作用：一个方法接受的参数个数不固定
   特点：
       * 只能出现在参数列表的最后
       * ...位于变量类型和变量名之间，前后有无空格都可以
       * 调用可变参数的方法时，编译器为该可变参数隐含创建一个数组，在方法体中以数组的形式访问可变参数
   示例：
       public static void main(String[] args) {
             add(2, 3, 5, 6);
       }
 
       public static void add(int ... args) {
             System.out.println(args[0]);
             for (int j = 0; j < args.length; j++) {
                   System.out.println(args[j]);
            }
        }

 

3、for循环加强
   语法：for([final] Type 变量名 : 集合变量名) {......}
   注意事项：
       * 迭代变量变量必须在()中定义
       * 集合变量名可以是数组或实现了Iterable接口的集合类
   示例：
       public static void main(String[] args) {
             add(2, 3, 5, 6);
       }
 
       public static void add(int ... args) {
             System.out.println(args[0]);
             for (int arg : args) {
                  System.out.println(arg);
             }
       }
    大家可以去下载sun公司的语言规范

 

4、基本类型的自动装箱与拆箱
      Integer obj1 = 3;  //自动装箱
      System.out.println(obj1 + 3);  //自动拆箱

      Integer s1 = 3;
      Integer s2 = 3;
      System.out.println(s1 == s2);  //true

      Integer s3 = 223;
      Integer s4 = 223;
      System.out.println(s3 == s4);  //false
      问题在于Interger在-128~127时是一个对象，大于127就是另一个对象，这就是享元模式

      * 享元模式:当对象很小，而且很多地方都要使用，这时我们就可以把这些对象用一个对象来表示，如abcacd如果每个字母都是一个对象，那么这时的对象就很多了(6个)，我们可以把a作为一个对象，当再次使用a时，我们就把这些对象作为一个对象(4个：串中有两个a、c我们把他们看做一个对象)。--->个人理解，详情请看：http://yangchao890.blog.163.com/blog/static/2185791120090221257225/

 

5、枚举
   作用：枚举就是让某个类型的变量的取值为若干个固定值的一个否则，编译器就会报错。枚举可以让编译器在编译时就可以控制程序中的非法值，普通变量的方式在开发阶段无法实现这一目标。

   *用普通类如何实现枚举功能，定义一个Weekday的类来模拟枚举功能
       1)、私有的构造方法
       2)、每个元素分别用一个公有的静态成员表示
       3)、可以有若干公有方法或抽象方法, 例如：要提供nextDay必须是抽象的。采用抽象方法定义nextDay就将大量的if.else语句转移成了一个个独立的类。
    示例：
        EnumTest.java

        WeekDay weekday = WeekDay.MON;
        System.out.println(weekday.nextDay());
        System.out.println(weekday.toString());
 
        WeekDay.java

        public abstract class WeekDay {
        private WeekDay() {
  
        }
 
        public final static WeekDay SUN = new WeekDay() {

               @Override
               public WeekDay nextDay() {
                       return MON;
               }
  
         };
 
        public final static WeekDay MON = new WeekDay() {
  
              @Override
               public WeekDay nextDay() {
                     return SUN;
              }
         };
 
       public abstract WeekDay nextDay();
 
           /*public WeekDay nextDay() {
                    if (this == SUN) {
                         return MON;
                   } else {
                         return SUN;
                   }
              }*/
 
            public String toString() {
                   return this == SUN ? "SUN" : "MON";
            }
 
   *枚举的基本应用
    语法：public enum enum_name {
                   enum_value1,enum_value2,enum_value3......
            }

    常用静态方法:name、ordinal、valueof、values、toString
    总结：枚举是一个特殊的类，其中枚举中的每一个元素都是该类的一个实例对象。

   *枚举中的构造方法
    示例:
 public enum Number {
  one(1),  //调用的是第二个构造方法
  two(),  //调用的是第一个构造方法
  three,four;
  
  private Number() {}
  
  private Number(int order) {}
 }  
     注意：枚举中的构造方法必须是私有的 

   *带有抽象方法的枚举  
    示例:
 public enum TrafficLamp {
  RED(30){
   public TrafficLamp nextLamp() {
    return GREEN;
   }
  },
  
  GREEN(45){
   public TrafficLamp nextLamp() {
    return YELLOW;
   }
  },
  
  YELLOW(5){
   public TrafficLamp nextLamp() {
    return RED;
   }
  };
  
  public abstract TrafficLamp nextLamp();
  private int time;
  
  private TrafficLamp(int time) {
   this.time = time;
  }
 }  

   *枚举只有一个成员时，就可以作为一种单例的实现方式