1.5新特性静态导入、增强for、可变参数、自动装箱拆箱、枚举

第一  静态导入

一、概述：

1、import语句：是导入一个类或某个包中的所有类。

2、import static语句：导入一个类中的某个静态方法或所有静态方法。

3、特点：简化了书写，但是代码的阅读性较差。

import static java.lang.Math.*;/* * 1.5新特性 * 静态导入 */public class StaticImport {public static void main(String[] args) {System.out.println(abs(3 - 6));}}

第二  增强for循环

一、概述

1、语法：for(可加修饰符 type 变量名 : 集合){statement}

2、注意：迭代变量必须定义在()中，集合必须是实现Iterable接口的集合类，变量类型前可加修饰符，如final（可被局部内部类访问到）。

/* * 1.5新特性 *  * 增强for循环 * 格式：for(可以添加修饰符 type 变量名 ：集合){} * 这里的集合必须是实现了Iterable */public class EnhanceFor {public static void main(String[] args) {System.out.println(variableParameter(1, 2, 5, 8, 6));}/* * 可变参数的方法 可变参数只能放与最后 */public static int variableParameter(int x, int... arr) {int sum = 0;// 可变参数其实内部封装了数组，按照数组方式取值for (int num : arr) {sum += num;}return sum;}}

第三  可变参数

一、概述：

所谓的可变参数就是参数个数不固定，就是方法的重载。

二、特点：

1、只能出现在参数列表的最后。

2、用…这三个点表示参数可以有很多，且这三个点位于变量类型和变量名之间，前后有无空格皆可。

3、调用可变参数的方法时，编译器为该可变参数隐含创建一个数组，在方法体中以数组的形式访问可变参数。

/* * 1.5新特性 *  * 可变参数 */public class VariableParameter {public static void main(String[] args) {System.out.println(variableParameter(1, 2, 5, 8, 6));}/* * 可变参数的方法 * 可变参数只能放与最后 */public static int variableParameter(int x, int... arr){int sum = 0;//可变参数其实内部封装了数组，按照数组方式取值for(int i=0; i<arr.length; i++){sum += arr[i];}return sum;}}

四  自动装箱拆箱

一、概述：

1、自动装箱：Integer i = 3;

2、自动拆箱：i + 2;

3、对于基本数据类型的说明：整数在-128 ~ 127之间的数，包装成Integer类型对象，会存入常量池中的缓存，再创建同一个对象的时候，会直接使用前一个已有的值，因为这些小数值使用的频率很高，所以这些数值需要如此的使用以优化内存。

/* * 1.5新特性： * 自动装箱和拆箱 */public class AutoBox {public static void main(String[] args) {Integer i = 123;//自动装箱System.out.println(i);//自动拆箱Integer i1 = 127;Integer i2 = 127;System.out.println(i1 == i2);Integer i3 = 128;Integer i4 = 128;System.out.println(i3 == i4);/* * 享元模式： * 就是将小的，经常用的放在常量池中，可供分享，这样就不用建立那么多对象，优化内存 * 如正数的-128~127 */Integer i5 = Integer.valueOf(50);Integer i6 = Integer.valueOf(50);System.out.println(i5 == i6);Integer i7 = Integer.valueOf(-158);Integer i8 = Integer.valueOf(-158);System.out.println(i7 == i8);}}

4、享元模式（flyweight）：

1）概述：如果很多很小的对象，他们有很多相同的属性，那么就可变为一个对象使用，这些属性称为内部状态，还有些不同的属性，作为方法参数植入，这些称为外部状态。这种优化内存，只创建一个对象的模式，称之为享元模式。

2）应用：

①、word中输入英文字母，可创建26对象，每个对象值是出现的位置不同（坐标），所以可用一个对象调用位置的方法：如，字母i：i.display(intx,int y)，将高度重复使用的char类型的字母i封装成一个对象使用。

②、图标：window下的文件夹图标，只哟名称这个属性不同，包含了很多其他相同的属性，那么可以应用享元模式。

第五  枚举

一、概述：

1、在实际编程中，往往存在着这样的“数据集”，它们的数值在程序中是稳定的，而且“数据集”中的元素是有限的。例如星期一到星期日七个数据元素组成了一周的“数据集”，春夏秋冬四个数据元素组成了四季的“数据集”。而在java中就是通过枚举对特定的"数据集"进行限定的。

2、枚举的作用：一些程序在运行时，它需要的数据不是任意的，而是必须在一定范围内的值

举例说明，没有枚举的时候，就是通过自定义类来实现限定的，类似下面打印成绩的程序，但是成绩只有ABCDE五个等级，所以需要对其进行限定。

//没有枚举的时候：class Demo{public void test(){print(Gread.B);}public void print(Gread g){//打印成绩，只能接收ABCDE}}class Gread{private Gread(){}public static final Gread A = new Gread();public static final Gread B = new Gread();public static final Gread C = new Gread();public static final Gread D = new Gread();public static final Gread E = new Gread();}

有了枚举：

enum Gread{A,B,C,D,E;}

首先不明白不要紧，但是直观的效果就是简化了书写，让代码更加简单了。其实枚举简单的说就是限定条件，让特定的“数据集”不会超出预定的范围。

enum很像特殊的class，实际上enum声明定义的类型就是一个类，而且是一个不可被继承的final类，其中的元素都是类静态常量。而这些类都是类库中Enum类的子类(java.lang.Enum<E>)。它们继承了这个Enum中的许多有用的方法 
二、枚举的特征及用法：

public class EnumTest {/** * @param args */public static void main(String[] args) {WeekDay2 weekday2 = WeekDay2.MON;System.out.println(weekday2.nextDay());WeekDay weekday = WeekDay.FRI;System.out.println(weekday);System.out.println(weekday.name());System.out.println(weekday.ordinal());System.out.println(WeekDay.valueOf("SUN"));System.out.println(WeekDay.values().length);// WeekDay.values(),返回数组TrafficLamp tf = TrafficLamp.GREEN;System.out.println(tf);}// （内部类）定义星期public enum WeekDay {SUN(1), MON(1, 1), TUE, WED, THL, FRI, SAT;// 元素列表// 其他成员只能放于元素列表之后private WeekDay() {System.out.println("first");}private WeekDay(int day) {System.out.println("second");}private WeekDay(int day, int d) {System.out.println("third");}}// 定义交通灯public enum TrafficLamp {// RED,GREEN,YELLOW;// 子类实现父类的抽象方法RED(30) {//调用构造函数，并覆盖父类中的抽象方法@Overridepublic TrafficLamp nextLamp() {return GREEN;}},GREEN(40) {@Overridepublic TrafficLamp nextLamp() {return YELLOW;}},YELLOW(5) {@Overridepublic TrafficLamp nextLamp() {return RED;}};private int time;// 构造方法private TrafficLamp(int time) {this.time = time;}//抽象方法，子类必须实现public abstract TrafficLamp nextLamp();}}

1、构造器：

1）构造器只是在构造枚举值的时候被调用。

2）构造器只有私有private，绝不允许有public构造器。这样可以保证外部代码无法重新构造枚举类的实例，因为枚举值是public static final的常量，但是枚举类的方法和数据域是可以被外部访问的。

3）构造器可以有多个，调用哪个即初始化相应的值。

2、所有的枚举类都继承了Enum方法，方法如下：

1）toString() ---> 返回枚举量的名称

2）ordina() ---> 返回枚举值在枚举类中的顺序，按定义的顺序排

3）getClass() ---> 获取对应的类名

静态方法：

1）valueOf(String e) ---> 转为类中对应的对象，即将字符串转为对象

2）values() ---> 获取数组，将元素放入一个数组中。

三、注意：

1、元素列表即所有的元素项目，必须放在整个类的最前面。

2、元素列表后要可有可无分号，但是元素后面还有其他项目时，必须加上分号。

3、枚举类中的方法为private

4、在元素后跟上()，就可指定要使用的构造方法，含参数。

5、枚举类中的每个元素都是它的一个子类对象，当枚举类中存在abstract方法，须在子类后加{}，并在其中实现此方法。

四、总结：

1、匿名内部类比较常用

2、类的方法返回的类型可以是类的类型

3、类中可定义静态常量，常量的结果就是自己这个类型的实例对象

4、如果枚举只有一个成员，就可以作为一种单例的实现方式，对象只有一个。