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文档。

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

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

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