黑马程序员-----------JdK1.5新特性（一）---可变参数，增强for循环，自动装箱与拆箱，静态导入，枚举

------- android培训、java培训、期待与您交流！ ----------

1.可变参数

2.增强的“for”循环（Enhanced For loop）

3.基本数据类型的自动拆箱与装箱。（Autoboxing/unboxing）

4.静态导入（Static import）

5.类型安全的枚举（Typesafeenums）

 

1.可变参数：

可变参数就是指一个方法接受的参数个数不固定。

例：

Public Static int add(int x , int ....args){
    int sum = x;
For(int i=0 ;  i < args.length; i++){
Sum += args[i];
}
Return sum;
}
public static void main(String[] args){
System.out.println(add(2,3));
System.out.println(add(2,3,5));
}

可变参数的特点：

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

...位于变量类型和变量名之间，前后有无空格都可以；

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

访问可变参数。

2.增强的For循环： 

格式：For(type 变量名 ： 集合变量名){......}

增强的For循环比原来的for循环的优势：

在增强的for循环中,我们不需要去检查数组的边界,不必担心数组下标越界,这些都由增强的for循环替我们代劳了。

注意事项：

迭代变量必须在()中定义。

集合变量可以是数组或实现了Iterable接口的集合类。

element的类型一定要和array数组的元素的类型保持一致.我想这一点不用我太费口舌,因为在array数组中取出每一 个元素后,要存在element中,所以,两者的类型一定要保持一致。

例：

Public Static int add(int x , int ....args){
    	int sum = x;
For(int i=0 ;  i < args.length; i++){
Sum += args[i];
}
Return sum;
}

　　现在，用增强的For语句实现相同方法： 

Public Static int add(int x , int ....args){
    int sum = x;
For(int arg : args){
Sum += args[i];
}
Return sum;
}<span style="font-family: Verdana; color: rgb(57, 57, 57); background-color: rgb(250, 247, 239);"> </span>

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

自动装箱：

     Integer  num1 = 12;

自动把一个基本数据类型，装成一个Integer对象，再赋给引用变量num1。

自动拆箱：

System.out.println(num1 + 12);

自动把引用num1，也就是integer对象拆成基本类型整数在进行加法。

 

自动装箱与自动拆箱知识细节。

为了优化，虚拟机为包装类提供了缓冲池，Integer池的大小 -128~127 一个字节的大小；

例：

Integer i1 = 13;

Integer i2 = 13;

Sostem.out.println(i1 == i2 );//结果为：true.

Integer i1 = 137;

Integer i2 = 137;

Sostem.out.println(i1 == i2 );//结果为：false.

String池：Java为了优化字符串操作 提供了一个缓冲池；

享元模式（flyweight）

例如：

    Int的字节数是-128~127之间。

    Java运行时每次运行Integer  num1 = 137;称为integer对象的时候，数字在一个字节之内（-128~127）的数字，

一旦被装成Integer对象以后，java就会缓存起来放在一个池里面，如果下次在把该数字装成Integer对象的时候，先检查

池里面是否有该数字有则直接使用，这样可以节省内存空间。因为数字很小，不可能每次都因为这么小的数字而创建对象，这

样浪费内存空间了。但这些小的整数使用的频率会很高并且会反复的出现，由于对象本来不容易改变，所以就出现了多个数字

用同一个对象的模式。而这个模式就是享元模式（flyweight）。

一句话总结享元模式：就是有很多个小的对象，他们有狠多属性相同，把他们变成一个对象。那些不同的属性把他们变成方法的参数。称之为外部状态。那些相同的属性称之为内部状态。

4、静态导入（Static import）

import语句可以导入一个类或者某个包中的所有类。

语法：
Import static 包名.类名.静态属性|静态方法|*

Import static 语句导入一个类中的某个静态方法或所有静态方法。

导入指定类的单个静态属性:                              
     import static java.lang.System.out
    导入指定类静态方法

import static java.lang.Math.max
导入指定类全部静态属性和方法                                   
        import static java.lang.Math.* 

5、类型安全的枚举（Typesafeenums） 

枚举： 就是要让某个类型的变量的取值只能为若干个固定值中的一个，否则，编译器就会报错。枚举可以让编译器在编译

时就可以控制源程序中填写的非法值，普通变量的方式在开发阶段无法实现这一目标。

用普通方式创建枚举

方式一：用if else方式

package meiju;
public class WeekDay1 {
//阻止创建方法
private WeekDay1(){}
public final static WeekDay1 SUN1 = new WeekDay1();
public final static WeekDay1 MON1 = new WeekDay1();
//用普通方法实现枚举方式一：找到下一天星期几
public WeekDay1 nextDay(){
if(this == SUN1){
return MON1;
}else{
return SUN1;
}
}
public String toString(){
return this == SUN1?"SUN1":"MON1";
}
}

方式二：用抽象方法把if else语句分别装换成一个个独立类。

package meiju;
//用抽象方法把if else语句分别装换成一个个独立类。
public abstract class WeekDay2 {
//阻止创建方法
private WeekDay2(){}
//用子类创建实例对象。
public final static WeekDay2 SUN2 = new WeekDay2(){
public WeekDay2 nextDay(){
return MON2;
}
};
public final static WeekDay2 MON2 = new WeekDay2(){
public WeekDay2 nextDay(){
return SUN2;
}
};
//用抽象方法实现枚举方式二：找到下一天星期几
public abstract WeekDay2 nextDay();
public String toString(){
return this == SUN2?"SUN2":"MON2";
}
}

枚举的一般应用：

package meiju;
public class EnumTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
//枚举的基本应用
WeekDay weekDay = WeekDay.FRI;//这里的FRI是WeekDay类弄出来的实例对象。
System.out.println(weekDay);
//获取枚举名字
System.out.println(weekDay.name());
//获取枚举排行，从0开始。
System.out.println(weekDay.ordinal());
//枚举的静态方法,把字符串变成枚举元素
System.out.println(WeekDay.valueOf("SUN").toString());
//把枚举装进数组里面
System.out.println(WeekDay.values().length);//这里的length不是方法，而是属性。
}
public enum WeekDay{
SUN,MON,TUE,WED,THI,FRI,SAT
}
}

带有构造方法的枚举：

注意事项：

构造方法必须私有的。

枚举元素MON和MON()的效果一样，都是调用默认的否则方法。

package meiju;
public class ConstructEnum {
public enum WeekDay{
//元素列表必须在所有成分之前
SUN(1),MON(),TUE,WED,THI,FRI,SAT;//注意；
//创建构造方法并且必须是private
private WeekDay(){System.out.println("first");}
private WeekDay(int day){System.out.println("second");}
}
}

带抽象方法的枚举：

package meiju;
//带抽象的枚举
public class AbstractEnum {
public static void main(String[] args) {
//子类的构造父类的有参的构造方法
}
public enum TrafficLamp{
//这里特殊在三个抽象类都是生成java后缀的文件则说明每个元素都生成一个类一个类
RED(30) {
@Override
public TrafficLamp nextLamp() {
// TODO Auto-generated method stub
return GREEN;
}
},GREEN(45){
@Override
public TrafficLamp nextLamp() {
// TODO Auto-generated method stub
return YELLOW;
}
},YELLOW(5) {
@Override
public TrafficLamp nextLamp() {
// TODO Auto-generated method stub
return RED;
}
};
public abstract TrafficLamp nextLamp();
private int time;
private TrafficLamp(int time){this.time = time;}
}
}