java基础加强（JDK1.5新特性）

JDK1.5不同于以往的升级，他是里程碑式的升级，带来了许多新特性。“JDK1.5”的一个重要主题就是通过新增一些特性来简化开发，这些特性包括泛型，for-each 循环，自动装包/拆包，枚举，可变参数, 静态导入 。使用这些特性有助于我们编写更加清晰，精悍，安全的代码。

静态导入（import static）

import 与 import static的区别：
import语句可以导入一个类或某个包中的所有类
import static语句导入一个类中的某个静态成员或所有静态成员
二者都能使代码简洁，但一个导入的是包中所有的类，一个导入的是某个类中的静态成员（静态字段和方法）

import static java.lang.Math.*;import cn.itcast.day02.AnnotationTest;public class StaticImport { public static void main(String[] args) {  //静态成员如max() abs()等静态函数可直接使用，使代码简洁  System.out.println(max(2, 3));  System.out.println(abs(3 - 6));  //静态成员如PI等静态字段可直接使用，使代码简洁  System.out.println(PI);   }}

可变参数（Variable Parameter）

问题提出：一个方法接受的参数不固定（0个1个或多个），传入一个数组或容器都不太适合。JDK1.5之前可以通过重载去实现，但这样既麻烦，也不能彻底解决问题。如：

System.out.println(countScore(2,3,5));System.out.println(countScore(1,2,3,5)); 

为此引入了可变参数，其特点是：
只能出现在参数列表的最后，这个要记住；
...  位于变量类型和变量名之间，前后有无空格都可以；
调用可变参数的方法时，编译器为该可变参数隐含创建一个数组，在方法体中以数组的形式访问可变参。
示例：

public class VariableParameter { public static void main(String[] args) {  int sum = add(2);  System.out.println(sum); } public static int add(int x, int... args) {//可变参数的使用  System.out.println(args.length);  int sum = x;  for (int arg : args) {//下面要说的增强For循环   sum += arg;  }  return sum; }}

高级for循环（增强for循环或ForEach语句）

语法： for(Type-类型  变量名 ：集合变量名 ){。。。需要做的事情。。。。}
作用：对存储对象的容器进行迭代（只能获取并使用，但不能赋值改变元素本身的值）
注意事项：
迭代变量必须在( )中定义！
集合变量可以是数组或实现了Iterable接口的集合类（java有这样的限制是因为增强for循环内部是使用迭代器实现的）
在使用增强for循环时，不能为元素进行赋值操作。
示例：

public static int add(int x,int ...args) {  int sum = x;  for(int arg:args) {   sum += arg;  }  return sum; }

增强for循环迭代数组

String [] arr = {"a", "b", "c"}; //数组的静态定义方式，只试用于数组首次定义的时候// 传统方式for(int i=0; i<arr.length; i++) { // i依次表示数组的角标 String s = arr[i]; System.out.println(s);}System.out.println("-------------------------------------");// 在jdk5中我们可以使用增强for循环迭代// 增强for循环括号里写两个参数，第一个是声明一个变量，变量类型必须是数组元素的类型// 第二个就是需要迭代的容器// for循环会循环容器的length次, 每次都将容器的第n-1个元素赋值给声明的变量for(String s : arr) { // 循环体， 执行arr.length // 每次都将arr中的第n-1个元素给s System.out.println(s); //}注意：不能对元素进行赋值操作//在使用增强for循环时，不能对元素进行赋值int[] arr = {1,2,3};for(int num : arr) { num = 0;}System.out.println(arr[1]);//结果是2，不是0

基本数据类型的自动拆箱与装箱

为编程带来了很多的好处：之前容器类只能持有引用数据类型，不能持有基本类型，有了自动装箱与拆箱机制，语法上容器类依然不能持有基本数据类型，但看起来可以持有了。

List<Integer> list = new ArrayList<Integer>();list.add(5);//自动装箱，这样容器看上去可以持有基本数据类型了Integer num1 = 12;         //自动装箱System.out.println(num1 + 12);  //自动拆箱 为了优化，虚拟机为包装类提供了缓冲池， Integer池的大小 -128~127 一个字节的大小Integer num1 = 12;Integer num2 = 12;  System.out.println(num1 == num2);//true，在缓冲池中共享——>享元设计模式Integer num3 = 129;                Integer num4 = 129;System.out.println(num3 == num4);//false，因为是对象Integer num5 = Integer.valueOf(12);Integer num6 = Integer.valueOf(12);   System.out.println(num5 == num6);//true,

扩展：java为了优化字符串的操作，提供了String常量池：
Java为了优化字符串操作 提供了一个缓冲池
 面试题：

String s = “abc” 和 String s = new String(“abc”) 的区别String s = new String(“abc”) 创建了几个对象 String s = “a” + “b” + “c” + “d” 创建了几个对象String s1 = “a” String s2 = “b”  String s3 = s1 + s2;  s3==”ab”?/*1. String s = "abc"， 虚拟机首先会检查String池里有没有"abc"对象(通过equals方法) // 如果有，直接返回引用，如果没有，会在池里创建一个“abc”对象，并返回引用 String s1 = "abc"; String s2 = "abc"; System.out.println(s1==s2); // result: true */ /* 2. String str = new String("abc");  两个或一个，”xyz”对应一个对象，这个对象放在字符串常量缓冲区，常量”xyz”不管出现多少遍，都是缓冲区中的那 一个。New String每写一遍，就创建一个新的对象，它一句那个常量”xyz”对象的内容来创建出一个新String对象。如 果以前就用过’xyz’，这句代表就不会创建”xyz”自己了，直接从缓冲区拿。不管缓冲池是否有"abc", 都会在堆内存创建一个"abc"对象，返回引用同时也会对String池进行检查，如果String池中没有“abc”的话，也会在常量池中创建一个“abc”对象的 // 此时，负责检查并维护缓冲池，其实堆内存的对象是缓冲池中"abc"对象的一个拷贝 String s1 = new String("abc"); String s2 = new String("abc"); System.out.println(s1==s2); // result: false */   /* 3. String s = "a" + "b" + "c" + "d";  java编译器有个合并已知量的优化功能 // 在编译阶段就把"a" + "b" + "c" + "d" 合并为 ”abcd“ String s = "a" + "b" + "c" + "d";  //String s = "abcd";  System.out.println(s=="abcd");// result: true */   /* 4.  String s1 = "a"; String s2 = "b"; String s3 = s1 + s2; // String是常量，不能相加的，java如何实现的？  StringBuilder sb = new StringBuidler(s1); sb.append(s2); s3 = sb.toString(); 也就是说实际上s3是方法返回的String对象 凡是方法返回的字符串对象都是在堆内存的 */

枚举：

JDK1.5引入了新的类型——枚举。在 Java 中它虽然算个“小”功能，却给我的开发带来了“大”方便。
为什么要使用枚举：
枚举就是要让某个类型的变量的取值只能为若干个固定值中的一个，否则，编译器就会报错。
枚举可以让编译器在编译时就可以控制源程序中填写的非法值，普通变量的方式在开发阶段无法实现这一目标。
用普通类如何实现枚举功能，定义一个Weekday的类来模拟枚举功能。 这样的类有什么特点：
私有的构造方法
每个元素分别用一个公有的静态成员变量表示
可以有若干公有方法或抽象方法。采用抽象方法定义nextDay就将大量的if.else语句转移成了一个个独立的类

public abstract class WeekDay { private WeekDay() {};//私有的构造方法  public static final WeekDay SUN = new WeekDay() {//每个元素分别用一个公有的静态成员变量表示  @Override  public WeekDay nextDay() {   return MON;  } }; public static final WeekDay MON = new WeekDay() {   @Override  public WeekDay nextDay() {   return TUE;  } }; public static final WeekDay TUE = new WeekDay() {   @Override  public WeekDay nextDay() {   return WED;  } }; public static final WeekDay WED = new WeekDay() {   @Override  public WeekDay nextDay() {   return THU;  } }; public static final WeekDay THU = new WeekDay() {   @Override  public WeekDay nextDay() {   return FRI;  } }; public static final WeekDay FRI = new WeekDay() {   @Override  public WeekDay nextDay() {   return SAT;  } }; public static final WeekDay SAT = new WeekDay() {   @Override  public WeekDay nextDay() {   return SUN;  } }; public abstract WeekDay nextDay();//可以有若干公有方法或抽象方法。采用抽象方法定义nextDay就将大量的if.else语句转移成了一个个独立的类 /*public WeekDay nextDay(){  if(this == SUN)   return MON;  else if(this == MON)   return TUE;  else if(this == TUE)   return WED;  else if(this == WED)   return THU;  else if(this == THU)   return FRI;  else if(this == FRI)   return SAT;  else if(this == SAT)   return SUN;  return null;  }*/ @Override public String toString() {  return "WeekDay []"; }}

枚举的基本应用
举例：定义一个交通灯的枚举。
扩展：枚举类的values,valueOf,name,toString,ordinal等方法
总结：枚举是一种特殊的类，其中的每个元素都是该类的一个实例对象，例如可以调用WeekDay.SUN.getClass().getName和WeekDay.class.getName()。

public enum TrafficLamp{  RED(45) {   @Override   public TrafficLamp nextLamp() {    return GREEN;   }  },GREEN(30) {   @Override   public TrafficLamp nextLamp() {    return YELLOW;   }  },YELLOW(30) {   @Override   public TrafficLamp nextLamp() {    return RED;   }  };  private int time;  private TrafficLamp(int time) {   this.time = time;  };    public abstract TrafficLamp nextLamp(); }

用法一：常量

在JDK1.5 之前，我们定义常量都是： public static fianl.... 。现在好了，有了枚举，可以把相关的常量分组到一个枚举类型里，而且枚举提供了比常量更多的方法。

public enum Color{   red, green, blue, yellow}

用法二：switch

JDK1.6之前的switch语句只支持int,char,enum类型，使用枚举，能让我们的代码可读性更强

enum Signal { GREEN, YELLOW, RED}public class TrafficLight { Signal color = Signal.RED; public void change() {  switch (color) {  case RED:   color = Signal.GREEN;   break;  case YELLOW:   color = Signal.RED;   break;  case GREEN:   color = Signal.YELLOW;   break;  } }}

用法三：向枚举中添加新方法

如果打算自定义自己的方法，那么必须在enum实例序列的最后添加一个分号。而且 Java 要求必须先定义 enum 实例。

public enum Color { RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4); // 成员变量 private String name; private int index; // 构造方法 private Color(String name, int index) {  this.name = name;  this.index = index; } // 普通方法 public static String getName(int index) {  for (Color c : Color.values()) {   if (c.getIndex() == index) {    return c.name;   }  }  return null; } // get set 方法 public String getName() {  return name; } public void setName(String name) {  this.name = name; } public int getIndex() {  return index; } public void setIndex(int index) {  this.index = index; }}

用法四：覆盖枚举的方法

下面给出一个toString()方法覆盖的例子。

public enum Color { RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4); // 成员变量 private String name; private int index; // 构造方法 private Color(String name, int index) {  this.name = name;  this.index = index; } //覆盖方法 @Override public String toString() {  return this.index+"_"+this.name; }}

用法五：实现接口

所有的枚举都继承自java.lang.Enum类。由于Java 不支持多继承，所以枚举对象不能再继承其他类。

public interface Behaviour { void print(); String getInfo();}public enum Color implements Behaviour{ RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4); // 成员变量 private String name; private int index; // 构造方法 private Color(String name, int index) {  this.name = name;  this.index = index; }//接口方法 @Override<span style="font-size:12px;"> public String getInfo() {  return this.name; } //接口方法 @Override public void print() {  System.out.println(this.index+":"+this.name); }}</span>

用法六：使用接口组织枚举

<span style="font-size:18px;font-weight: normal;">public interface Food { enum Coffee implements Food{  BLACK_COFFEE,DECAF_COFFEE,LATTE,CAPPUCCINO } enum Dessert implements Food{  FRUIT, CAKE, GELATO }}</span>

用法七：关于枚举集合的使用

java.util.EnumSet和java.util.EnumMap是两个枚举集合。EnumSet保证集合中的元素不重复；EnumMap中的key是enum类型，而value则可以是任意类型。关于这个两个集合的使用就不在这里赘述，可以参考JDK文档。

关于枚举的实现细节和原理请参考：

用法八：单例设计的另一种方式

当枚举中只有一个元素时，可以作为单例的一种实现方式。