可变参数与枚举

一、可变参数

       1）参数的个数不确定的
       2）可变参数只能放置在参数的最后，即最右边
       3）可变参数最少0个，最多1个
       4）编译器将可变参数当作一个一维数组来对待

      JDK中具有可变参数的类Arrays.asList()方法

//可变参数
public class Demo2 {
	public static void main(String[] args) {
		 show2("jack","marry","sisi","soso","berry");
	}
	
	public static void show2(String... arr) {
		for (String a : arr) {
			System.out.print(a + "\t");
		}
	}
}

//可变参数
public class Demo2 {
	public static void main(String[] args) {
		show3("qq", "jack", "marry", "sisi", "soso", "berry");
	}
	public static void show3(String qq, String... arr) {
		System.out.println("第一个参数是：" + qq);
		for (String a : arr) {
			System.out.print(a + "\t");
		}
	}
}

二、枚举

     1）当取值是某范围中的之一，这时可以使用枚举。这类问题在JDK5以前采用自定义带有枚举功能的类解决，

         JAVA5以后可以直接使用枚举予以解决。在JDK5中使用关键字enum来定义一个枚举类。枚举有运行验证

         和编译验证

         (1) 自定义算法解决学员分数等级ABCDE(运行验证)

public class Student {
	private String name;
	private String grade;// 等级是能是{A,B,C,D,E取值之一}

	public Student() {
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getGrade() {
		return grade;
	}

	public void setGrade(String grade) throws Exception {
		if (grade != null && grade.matches("A|B|C|D|E")) {//匹配正则表达式
			this.grade = grade;
		} else {
			throw new Exception();
		}
	}
}

public static void main(String[] args) throws Exception {
		Student student = new Student();
		student.setName("jack");
		student.setGrade("E");
		System.out.println("姓名：" + student.getName());
		System.out.println("等级：" + student.getGrade());
}

输出结果：
                 

          (2) 使用模拟枚举类表示学员分数等级ABCDE（编译验证）                 

public class Student {
	private String name;
	private Grade grade;//将分数用分数类表示
	public Student(){}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Grade getGrade() {
		return grade;
	}
	public void setGrade(Grade grade) {
		this.grade = grade;
	}
}

//分数类
public class Grade {
	public static Grade A = new Grade("A","90-100");
	public static Grade B = new Grade("B","80-89");
	public static Grade C = new Grade("C","70-79");
	public static Grade D = new Grade("D","60-69");
	public static Grade E = new Grade("E","<60");
	private String tip;
	private String desc;
	//必须私有的构造方法
	private Grade(String tip,String desc){
		this.tip = tip;
		this.desc = desc;
	}
	//只提供GET方法
	public String getTip() {
		return tip;
	}
	public String getDesc() {
		return desc;
	}
}

public static void main(String[] args) throws Exception {
		Student student = new Student();
		student.setName("jack");
		student.setGrade(Grade.B);
		System.out.println("姓名：" + student.getName());
		System.out.println("等级：" + student.getGrade().getTip());
		System.out.println("分数区间：" + student.getGrade().getDesc());
	}

运行结果：

               
     2）使用枚举类enum。学生类和main方法不变

//分数枚举类
public enum Grade {
	A("A","90-100"),//枚举值相当于实例变量 枚举变量一般使用大写 
	B("B","80-89"),
	C("C","70-79"),
	D("D","60-69"),
	E("E","<60");
	private String tip;
	private String desc;
	private Grade(String tip,String desc){
		this.tip = tip;
		this.desc = desc;
	}
	public String getTip() {
		return tip;
	}
	public String getDesc() {
		return desc;
	}
}

     3）枚举类与普通一致，可以继承或实现，如果有抽像方法的话，可以利用每个枚举值以匿名内部类的方式去实现

/**
 * 星期枚举类
 * @author Administrator
 */
public enum WeekDay {
	Mon {
		//枚举值相当于实例变量，通过匿名内部类去实现抽象方法
		public void show() {
			System.out.println("星期一");
		}
	},
	Tue {
		public void show() {
			System.out.println("星期二");
		}
	},
	Wed {
		public void show() {
			System.out.println("星期三");
		}
	},
	Thu {
		public void show() {
			System.out.println("星期四");
		}
	},
	Fri {
		public void show() {
			System.out.println("星期五");
		}
	},
	Sat {
		public void show() {
			System.out.println("星期六");
		}
	},
	Sun {
		public void show() {
			System.out.println("星期天");
		}
	};
	public abstract void show();//抽象方法
}

public static void main(String[] args) throws Exception {
		WeekDay s =WeekDay.Fri;
		s.show();
}

     4）枚举值可以用在switch()语句中

//季节枚举类
public enum Season{
	SPRING{
		public void show(){
			System.out.println("春天");
		}
	},SUMMER{
		public void show(){
			System.out.println("夏天");
		}
	},AUTOMN{
		public void show(){
			System.out.println("秋天");
		}
	},WINNTER{
		public void show(){
			System.out.println("冬天");
		}
	};
	//抽像方法
	public abstract void show();
}

public static void main(String[] args) {
		Season season = Season.SPRING;
		String msg = null;
		switch(season){
			case SPRING:
				msg = "1";break;	
			case SUMMER:
				msg = "2";break;	
			case AUTOMN:
				msg = "3";break;	
			case WINNTER:
				msg = "4";break; 	
		}
		System.out.println(msg); //动态获取msg的值    
 	}

     5）若枚举类只有一个枚举值，则可以当作单态设计模式使用（即单例模式）    

//单例/态/值设计模式[单线程情况下]-->
//单例模式有两种情况：一种是单线程一种是多线程
public class Singleton {
	//NO1 私有构造器，不能被外界访问，只能在本类中使用
	private Singleton(){}
	//NO2 提供一个公开的静态方法供外界使用
	public static Singleton getInstance(){
		if(instance==null){
			instance = new Singleton();
		}
		return instance;
	} 
	//NO3 instance就相当于一个静态枚举变量
	private static Singleton instance;
}

     6）枚举类常用方法如下：
           a)name()：显示枚举变量值。如季节枚举类中的SPRING,星期枚举类中的Mon
           b)ordinal()：显示枚举变量值对应的索引，从0开始
           c)values()：取得该枚举类对应的所有枚举值，是一个数组
           d)valueOf()：判段某个字符串是否属性枚举值之一

public static void main(String[] args) {
		Season season = Season.SPRING;
		System.out.println(season.name());//SPRING(枚举值)
		
		System.out.println(season.ordinal());//0(索引值从0开始)
		
		Season[] seasons = Season.values();
		for(Season s : seasons){//遍历枚举值
			System.out.println(s.name());
		}
		
		Season.valueOf(Season.class,"SPRING");//正确
		Season.valueOf(Season.class,"Mon");//错误
	}

 

转载于:https://my.oschina.net/weslie/blog/471972