黑马程序员--枚举，增强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<args.length;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){
		public	TracfficLamp nextLamp(){
				return GREEN;
			}
		},
		GREEN(45){
		public	TracfficLamp nextLamp(){
				return YELLOW;
			}
		},
		YELLOW(3){
		public	TracfficLamp nextLamp(){
				return RED;
			}
		};
		
		private int time;
		private TracfficLamp(int time) {
			this.time = time;
		}
		public abstract TracfficLamp nextLamp();
		
	}

}

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