黑马程序员--枚举，增强for循环，可变参数，静态导入，自动拆箱和自动装箱

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

①静态导入：导入某个类下的静态方法。

代码：

　　import static java.lang.Math.*;//导入math下的静态方法
　　import static java.lang.System.out;//导入out字段
　　public class StaticImport {
　　
　　public static void main(String[] args) {
　　out.print(max(10,-9));//求最大值
　　out.print(abs(10-20));//求绝对值
　　}
　　}

 

②可变参数

一个方法接受的参数的个数不固定。

可变参数特点：

l 只能出现在可变参数列表之后

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

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

　　public class VariableParameter {

　　public static void main(String[] args) {
　　System.out.println(sum(1,2,6,7,20));
　　}
　　
　　public static int sum(int x,int...args){
　　int sum = x;
　　for(int i=0;i　　sum += args[i];
　　}
　　return sum;
　　}
　　}

 

③增强的for循环

for(type,变量名：集合变量名){...}

④自动装箱：把基本数据类型赋给对象的引用变量

如：Integer obj = 8;

⑤自动拆箱：将对象转为基本数据类型

如：System.out.println(obj+100);//Integer对象和基本数据类型运算

细节：

对于基本数据类型在装箱过程中，如果该数值在一个字节内(-128~127)之间，被包装起来之后，会被缓存到缓存池中，当下次这个基本数据类型要被再次包装成对象时，就会在缓存池中找，就直接使用。

　　                 int a = 5;
Integer i1 = 5;
Integer i2 = 5;
System.out.println(a==i2);//true;
System.out.println(i1==i2);//true;

int b = 128;
Integer i3 = 128;
Integer i4 = 128;
System.out.println(i3==i4);//false;
System.out.println(b==i4);//true;

　　                 Integer i5 = Integer.valueOf(10);
Integer i6 = Integer.valueOf(10);
System.out.println(i5==i6);//true;

Integer i7 = Integer.valueOf(128);
Integer i8 = Integer.valueOf(128);
　　                 System.out.println(i7==i8);//false;

 

由此变可衍生出一个模式：享元模式(flyweight)

对于很多小的对象的相同的属性，把他们变为一个对象，对于不同的属性可以作为方法的参数传递，称之为外部状态。相同的属性就称之为内部状态。

⑥枚举enumerate/ i'nju:məreit/

让某个类型的变量只能取若干个固定值中的一个。枚举可以让编译器在在编译时将程序中的错误控制，普遍变量在编译阶段无法实现该特性。

用普通类来实现枚举功能。

l 私有的方法

l 每个元素分别用一个共有的静态成员变量表示。

l 可以有若干共有方法或者抽象方法，如：nextDay方法必须是抽象方法。将nextDay方法定义为抽象方法，就可以将大量的else if 转为一个独立的类。

该代码演示未使用抽象方法nextDay方法

public class EnumerateDemo {


public static void main(String[] args) {

WeekDay  weekDay = WeekDay.Wednesday;
System.out.println(weekDay+"-->"+weekDay.nextDay());
}
}
class WeekDay {

//外部不能new对象
private WeekDay() {
}
//WeekDay 只可以取一下三个值，Monday，Tuesday，Wednesday，
public final static WeekDay MOnday= new WeekDay();
public final static WeekDay Tuesday = new WeekDay();
public final static WeekDay Wednesday = new WeekDay();

//求当天的下一天
public WeekDay nextDay() {
if(this== Monday)
return Tuesday;
else if(this==Tuesday)
return Wednesday;
else
return Monday; 
}
//重写toString方法
public String toString () {
if(this==Monday)
return "Monday";
else if(this==Tuesday)
return "Tuesday";
else 
return "Wednesday";

}
}
　　

 

以上代码中nextDay有许多else if{...}语句，比较繁琐，所以考虑对nextDay定义为抽象方法，然后编写匿名的内部类来实现nextDay的功能。

public class EnumerateDemo {


public static void main(String[] args) {

WeekDay  weekDay = WeekDay.Wednesday;
System.out.println(weekDay+"-->"+weekDay.nextDay());
}
}
abstract class WeekDay {

//外部不能new对象
private WeekDay() {}

public abstract WeekDay nextDay();

/*WeekDay 只可以取一下三个值，Monday，Tuesday，Wednesday，
使用内部匿名类作为子类创建WeekDay对象*/
public final static WeekDay MOnday= new WeekDay(){

public WeekDay nextDay() {
return Tuesday;
}
};
public final static WeekDay Tuesday = new WeekDay(){


public WeekDay nextDay() {

return Wednesday;
}
};
public final static WeekDay Wednesday = new WeekDay(){


public WeekDay nextDay() {

return Monday;
}
};

//重写toString方法
public String toString () {
if(this==Monday)
return "Monday";
else if(this==Tuesday)
return "Tuesday";
else 
return "Wednesday";

}
}

 

枚举的举例：

public class EnumertaeDemo2 {


public static void main(String[] args) {
WeekDay wd = WeekDay.FRI;
System.out.println(wd);//返回对象，toString方法已经被重写
System.out.println(wd.name());
System.out.println(wd.getClass());//class com.hncu.day1.EnumertaeDemo2$WeekDay
System.out.println(wd.ordinal());//在数组中的位置
System.out.println(WeekDay.valueOf("MON"));
WeekDay[] wed=WeekDay.values();
for(WeekDay i : wed) {
System.out.print(i+" ");
}
}

//枚举相当与一个内部类，其中的元素相当于一个对象，getClass()方法可查看
public enum WeekDay{
SUN,MON,TUE,WED,THU,FRI,SAT;
}

}

 

带构造方法打的枚举

构造方法要位于元素之后，为private，

public enum WeekDay{
SUN(),MON(1),TUE,WED,THU,FRI,SAT;
private WeekDay(){
System.out.println("first");
}
private WeekDay(int day) {
System.out.println("second:"+day);
}
}

 

当WeekDay被加载时就会调用相应打的构造方法。

如：sun（）调用无参数的构造方法

MON（1）调用带参数的构造方法

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

枚举举例：

public class EnumerateDemo3 {

public static void main(String[] args) {
TracfficLamp tl = TracfficLamp.GREEN;
System.out.println(tl.nextLamp());
}

public enum TracfficLamp{
RED(30){
publicTracfficLamp nextLamp(){
return GREEN;
}
},
GREEN(45){
publicTracfficLamp nextLamp(){
return YELLOW;
}
},
YELLOW(3){
publicTracfficLamp nextLamp(){
return RED;
}
};

private int time;
private TracfficLamp(int time) {
this.time = time;
}
public abstract TracfficLamp nextLamp();

}

}

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