标签：
前言：为什么会出现新特性呢？
新的技术的出现就是为了解决老的问题，Java语言随着自身的不断发展，对那些不利于提高开发率的技术进行了改进。
1.静态导入
静态导入可以导入静态方法，这样就不必写类名而可以直接省略类名调用静态方法了。
语法：import static 包名.类名.静态方法;
也可以直接导入某个类中的所以静态方法。
语法：import static 包名.类名.*;
Java 5.0 代码示例：
1 package com.tolvgx.day01; 2 import static java.lang.Math.*; 3 import static java.lang.System.out; 4 5 public class StaticImport { 6 public static void main(String[] args) { 7 out.println("接近数最小值： "+floor(PI)); 8 out.println("接近数最大值： "+ceil(PI)); 9 out.println("2的3次幂："+pow(2, 3)); 10 out.println("四舍五入："+round(PI)); 11 } 12 }
好处：
使用静态导入可以简化程序对类静态属性和方法的调用，并且简化了程序代码的书写。
弊端：
虽然JDK中出现了这个新特性，但是如果我们在自己的类中定义 了一个方法，与导入的类中的静态方法一样。
那Java虚拟机怎么知道用的是那个类的方法呢？所以虽然出现了这个新特性，但是建议还是别使用。
注意：
如果将Javac设置为了Java 5.0以下，那么静态导入等JDK 1.5的特性都会报告错误。
2.可变参数
可变参数的出现解决了一个方法接受的参数个数不固定的问题。
例如：System.out.println(countScore(2,3,5));
System.out.println(countScore(1,2,3,5));
如果使用重载的方式解决需要写多个重载的方法，可是代码过于繁杂，而使用可变参数就可以避免这种情况。
Java 5.0 代码示例：
1 package com.tolvgx.day01; 2 3 public class VariableParameter { 4 public static void main(String[] args) { 5 System. out.println(add(1, 2)); 6 System. out.println(add(1, 2, 3)); 7 } 8 9 public static int add(int x,int... args){ 10 int sum = x; 11 for(int i = 0; i < args.length; i++){ 12 sum += args[i]; 13 } 14 return sum; 15 } 16 }
可变参数的原理：
调用可变参数的方法时, 编译器将自动创建一个数组保存传递给方法的可变参数。
因此，程序员可以在方法体中以数组的形式访问可变参数可变参数只能处于参数列表的最后。
所以一个方法最多只能有一个可变参数。
可变参数特点与注意事项：
1、可变参数只能出现在参数列表的最后。
2、可变参数只能在参数中只能有一个。
3、可变参数位于变量类型和变量名之间，前后有无空格都可以。
4、调用可变参数的方法时，编译器为该可变参数隐含创建一个数组，在方法体中以数组的形式访问可变参数。
3.增强for循环
引入增强for循环的原因：
在JDK 1.5 以前的版本中，遍历数组或集合中的元素，需先获得数组的长度或集合的迭代器，比较麻烦！
因此JDK 1.5 中定义了一种新的语法——增强for循环，以简化此类操作。
语法格式：
for(修饰符 变量类型 变量 ：需迭代的数组或集合){}
Java 5.0 代码示例：
1 package com.tolvgx.day01; 2 3 public classForeach { 4 public static void main(String[] args) { 5 int[] arr = {1, 2, 3}; 6 for(final int i : arr) { 7 System.out.println(i); 8 } 9 } 10 }
注意事项：
迭代变量必须在( )中定义！
集合变量可以是数组或实现了Iterable接口的集合类。
小细节：
向集合中取元素时同时加元素，需要使用迭代器来完成，即需要传统的for循环。
4.自动拆箱与装箱
JDK 1.5的语法允许开发人员把一个基本数据类型直接赋给对应的包装类变量, 或者赋给 Object 类型的变量，这个过程称之为自动装箱。
自动拆箱与自动装箱与之相反，即把包装类对象直接赋给一个对应的基本类型变量。
Java 5.0 代码示例：
1 package com.tolvgx.day01; 2 import java.util.List; 3 import java.util.ArrayList; 4 5 public class Test{ 6 public static void main(String[] args){ 7 List list = new ArrayList(); 8 //因为集合中不能存储基本数据类型数据。 9 list.add(1); 10 //会自动的装箱成(new Integer(1)); 11 int i = (Integer)list.get(0);//自动拆箱。 12 } 13 }
好处：
新特性的出现，程序员省去了很多不必要的麻烦，提高了开发效率。
1 package com.tolvgx.day01; 2 3 public class AutoBox { 4 public static void main(String[] args) { 5 Integer i1 = 127; 6 Integer i2 =Integer.parseInt("127"); 7 System.out.println(i1==i2); 8 9 Integer i3 = 128; 10 Integer i4 = 128; 11 System.out.println(i3==i4); 12 } 13 } 14
byte常量池:
对于这些基本数据整数要装箱成Integer对象的时候，如果这个数据在1字节(-128 ~ 127)之内的数字，就缓存在byte常量池，下次再用到的时候，先看池子里面有没有，如果有直接从池子里面拿来用。这样节省了内存空间。
这是一种设计模式叫做享元模式。(flyweight)
享元模式：
就是有很多个小的对象，他们有很多属性相同，把他们封装成一个对象，那些不同的属性，把它们变为方法的参数，称之为外部状态，那些相同的属性的称之为这个对象的内部状态。例如，示例中的Integer对象，在-128~127范围内的Integer对象，用的频率比较高，就会作为同一个对象，因此结果为true。超出这个范围的就不是同一个对象，因此结果为false。
享元应用：
1、Word中输入英文字母，可创建26对象。
每个对象值是出现的位置不同（坐标），所以可用一个对象调用位置的方法。
如，字母Q：Q.zuobiao(int x,int y)，将高度重复使用的char类型的字母Q封装成一个对象使用。
2、图标:Window下的文件夹图标，只是名称这个属性不同，包含了很多其他相同的属性，那么可以应用享元模式。
5.枚举
为什么需要枚举？
一些方法在运行时，它需要的数据不能是任意的，而必须是一定范围内的值。
此类问题在JDK 1.5 以前采用自定义带有枚举功能的类解决，Java 5.0以后可以直接使用枚举予以解决。
JDK 1.5 新增的Enum 关键字用于定义一个枚举类。
自定义类实现枚举功能：
1、私有的构造方法。
2、每个元素分别用一个公有的静态成员变量表示。
3、可以自定义若干个公有方法或抽象方法。
代码示例：
1 package com.tolvgx.day01; 2 3 public class WeekDay { 4 5 private WeekDay() {} 6 7 public static finalWeekDay SUN = new WeekDay(); 8 public static final WeekDay MON = new WeekDay(); 9 10 public WeekDay nextDay() { 11 12 if (this == SUN) { 13 return MON; 14 } else { 15 return SUN; 16 } 17 } 18 19 public String toString() { 20 21 return this == SUN ? "SUN" :"MON"; 22 } 23 }
注意：
可以采用抽象方法定义nextDay将大量的if...else语句转移到一个个独立的对象中实现。
代码示例：
1 package com.tolvgx.day01; 2 3 public abstract class WeekDay { 4 5 private WeekDay() {} 6 7 public static final WeekDay SUN = new WeekDay() { 8 9 public WeekDay nextDay() { 10 11 return MON; 12 } 13 }; 14 15 public static final WeekDay MON =new WeekDay() { 16 17 public WeekDay nextDay() { 18 19 return MON; 20 } 21 }; 22 23 public abstract WeekDay nextDay(); 24 25 public String toString() { 26 27 return this == SUN ? "SUN" :"MON"; 28 } 29 }
代码测试：
1 package com.tolvgx.day01; 2 3 public class WeekDayTest { 4 5 public static void main(String[] args) { 6 7 WeekDay Mon = WeekDay.MON; 8 System.out.println(Mon); 9 } 10 }
Java5枚举的定义：
代码示例：
1 package com.tolvgx.day01; 2 3 public enum WeekDay { 4 5 SUN,MON,TUE,WED,TUR,FRI,SAT; 6 7 }
注意：
最后一个枚举元素后面可以加分号，也可以不加分号。
代码测试：
1 package com.tolvgx.day01; 2 3 public class WeekDayTest { 4 public static void main(String[] args) { 5 WeekDay weekDay = WeekDay.SUN; 6 for(WeekDay weekday: weekDay.values()){ 7 System.out.println("第一个是："+weekday.ordinal()+" 星 期："+weekday.name()); 8 } 9 10 WeekDay weekday = WeekDay.valueOf("SUN"); 11 System.out.println(weekday); 12 System.out.println(WeekDay.values().length); 13 } 14 }
Java中声明的枚举类，均是java.lang.Enum类的子类，它继承了Enum类的所有方法。
常用方法：
name()
ordinal()
valueOf(String name)
values() 此方法虽然在JDK文档中查找不到，但每个枚举类都具有该方法。它遍历枚举类的所有枚举值非常方便。
实现带有构造方法的枚举
Java 5.0 代码示例：
1 package com.tolvgx.day01; 2 3 public classTrafficLampTest { 4 public static void main(String[] args) { 5 6 System.out.println(TrafficLamp.YELLOW); 7 } 8 9 public enum TrafficLamp{ 10 11 RED(60),YELLOW(5),GREEN(30); 12 13 private TrafficLamp(){ 14 15 System.out.println("First"); 16 System.out.println(this.name()); 17 } 18 19 private TrafficLamp(int time){ 20 21 System.out.println("Second"); 22 try { 23 Thread.sleep(time*1000); 24 } catch (InterruptedException e) { 25 e.printStackTrace(); 26 } 27 28 System.out.println("等待了"+time+"秒"+this.name()); 29 } 30 31 } 32 }
实现带有抽象方法的枚举：
定义枚举TrafficLamp。
实现抽象的nextTrafficLamp方法：每个元素分别是由枚举类的子类来生成的实例对象，这些子类采用类似内部类的方式进行定义。增加上表示时间的构造方法。
Java 5.0 代码示例：
1 package com.tolvgx.day01; 2 3 public class TrafficLampTest { 4 public static void main(String[] args) { 5 6 System.out.println(Lamp.YELLOW.nextLamp()); 7 } 8 9 public enum Lamp{ 10 11 RED(60){ 12 13 public Lamp nextLamp(){ 14 15 System.out.println("暂停60秒"); 16 17 return YELLOW; 18 } 19 20 },YELLOW(10){ 21 22 public Lamp nextLamp(){ 23 24 System.out.println("等待10秒"); 25 26 return GREEN; 27 } 28 29 },GREEN(30){ 30 31 public Lamp nextLamp(){ 32 33 System.out.println("放行30秒"); 34 35 return RED; 36 37 } 38 }; 39 40 private Lamp(int time){ 41 42 System.out.println("先把枚举所有元素加载进内存 "+this.name()); 43 44 } 45 46 public abstract Lamp nextLamp(); 47 48 } 49 } 50
枚举类总结：
1、枚举类是一种特殊形式的Java类。
2、枚举类中声明的每一个枚举值代表枚举类的一个实例对象。
3、枚举类与Java中的普通类一样，在声明枚举类时，也可以声明属性、方法和构造函数。
但枚举类的构造函数必须为私有的（这点不难理解）。
4、枚举类也可以实现接口、或继承抽象类。
5、JDK 1.5 中扩展了switch语句，它除了可以接收int, byte, char, short,String外，还可以接收一个枚举类型。
6、若枚举类只有一个枚举值，则可以当作单例设计模式使用。
7、枚举类的实例变量是把所以的枚举实例都加载一次的。
如果调用了某个枚举类，那么该枚举类先把枚举类里面的所有元素都先加载一次。
注意：
1、枚举只有一个成员时，就可以作为一种单例的实现方式。
2、查看生成的class文件，可以看到内部类对应的class文件。
也就是枚举的元素都是一个内部类实例对象。
标签：
原文地址：http://www.cnblogs.com/tolvgx/p/4345817.html
