您的位置：首页 > 编程语言 > Java开发

java高新技术【3】（枚举总结）

2012-04-03 15:00 411 查看

【1】枚举

·一：为什么要有枚举

(1)问题：定义星期几或性别的变量，该这么定义？

假设用1-7分别表示星期一到星期日，但有人可能会写成int weekday =0;

(2) 枚举就是要让某个类型的变量的取值只能为若干个固定值中的一个，否则，编译器就会报错。枚举可以让编译器在编译时.就可以控制源程序中填写的非法值，普通变量的方式在开发阶段无法实现这一目标。

二：用普通类如何实现枚举功能，定义一个Weekday的类来模拟枚举功能。

-私有的构造方法

-每个元素分别用一个公有的静态成员变量表示

-可以有若干公有方法或抽象方法

例如，要提供nextDay方法必须是抽象的。

采用抽象方法定义nextDay就将大量的if.else语句转移成了一个个独立的类。

（1）这个类所定义出来的值不是基本类型的而是对象类型，也只能是这里规定的那么几个值。不然会报错。

【2】java5的枚举

（1）枚举就相当于一个类，其中也可以定义构造方法、成员变量、普通方法和抽象方法。

（2）枚举元素必须位于枚举体重的最开始的部分，枚举元素列表的后要有分号与其他成员分隔。

把枚举中的成员方法和变量等放在枚举元素的前面，编译器报告错误。

【1】带构造方法的枚举

-构造方法必须定义成私有的

-如果有多个构造方法，该如何选择哪个构造方法？

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

【2】实现带有构造方法的枚举

（1）元素列表必须位于枚举中所有内容的之前，也就是元素列表必须在最前面

（2）构造方法必须是私有的private

（3）在枚举元素的后面加上()指定构造时候要调用的构造方法

【3】带方法的枚举

-定义枚举TrafficLamp

-实现普通的next方法

-实现抽象的next方法：每个元素分别是由枚举类的子类来生产的实例对象,

这些子类采用类似内部类的方式进行定义。

-增加上表示时间的构造方法

红灯过后就是绿灯，绿灯过后是黄灯，黄灯过后是红灯

·枚举只有一个成员时，就可以作为一种单例的实现方式。

【3】Enum

Enum作为Sun全新引进的一个关键字，看起来很象是特殊的class, 它也可以有自己的变量,

可以定义自己的方法，可以实现一个或者多个接口。

当我们在声明一个enum类型时，我们应该注意到enum类型有如下的一些特征。

　　1．它不能有public的构造函数，这样做可以保证客户代码没有办法新建一个enum的实例。

　　2．所有枚举值都是public , static, final的。

注意这一点只是针对于枚举值，我们可以和在普通类里面定义变量一样定义其它任何类型的非枚举变量,

这些变量可以用任何你想用的修饰符。

　　3．Enum默认实现了java.lang.Comparable接口。

　　4．Enum覆载了了toString方法，因此我们如果调用Color.Blue.toString()默认返回字符串”Blue”.

　　5．Enum提供了一个valueOf方法，这个方法和toString方法是相对应的。

调用valueOf(“Blue”)将返回Color.Blue.

因此我们在自己重写toString方法的时候就要注意到这一点,

一把来说应该相对应地重写valueOf方法。

　　6．Enum还提供了values方法，这个方法使你能够方便的遍历所有的枚举值。

　　7．Enum还有一个oridinal的方法.这个方法返回枚举值在枚举类种的顺序,

这个顺序根据枚举值声明的顺序而定，这里Color.Red.ordinal()返回0。

方法摘要

protected  Object

clone()

抛出 CloneNotSupportedException。

int

compareTo(E o)

比较此枚举与指定对象的顺序。

boolean

equals(Object other)

当指定对象等于此枚举常量时，返回 true。

protected  void

finalize()

枚举类不能有 finalize 方法。

Class<E>

getDeclaringClass()

返回与此枚举常量的枚举类型相对应的 Class 对象。

int

hashCode()

返回枚举常量的哈希码。

String

name()

返回此枚举常量的名称，在其枚举声明中对其进行声明。

int

ordinal()

返回枚举常量的序数（它在枚举声明中的位置，其中初始常量序数为零）。

String

toString()

返回枚举常量的名称，它包含在声明中。

static

<T extends 
Enum<T>> 

T

valueOf(Class<T> enumType,String name)

返回带指定名称的指定枚举类型的枚举常量。

别忘了：枚举定义为静态的只要一加载类就会调用构造方法。

public class EnumTest {
	
	public staticvoid main(String[] args) {
		
		
		WeekDay1 weekDay = WeekDay1.MON;
		System.out.println(weekDay.nextDay());
		
		System.out.println("----------上面是 星期天-----------------");
		
		WeekDay weekDay2 = WeekDay.FRI;
		
		System.out.println("+++++++++     最后执行               ++++++++++++");
		System.out.println(weekDay2);
		
		System.out.println("---------------又来了一个---------------------");
		
		System.out.println(weekDay2.name());
		System.out.println(weekDay2.ordinal());	
		System.out.println(WeekDay.valueOf("SUN").toString());
		System.out.println(WeekDay.values().length);

	}
	
	public enum WeekDay{
		 /*
		  
		  SUN() 代表的是一个构造方法,也就是 默认的构造方法：  
		  private WeekDay(){
			System.out.println("frist");
		  }

		  * */   
		// 谨记：  -枚举元素MON和MON()的效果一样，都是调用默认构造方法。
		SUN(),MON(1),TUE,WED,THI,FRI,SAT;
		private WeekDay(){
			System.out.println("frist");
		}
		
		private WeekDay(int day){
			System.out.println("second");
		}
	}

}

注意：利用 abstract 抽象方法，可以避免使用大量的if，else 语句，是程序更加的健壮与美观，和灵活，便于扩展（具有扩展性）

这样让 nextDay()方法分别由子类来完成，而不是由父类去逐一的实现。

如果想在一个类中编写完各种枚举类和测试用类，那么可以将枚举类定义成调用类的内部类。

public abstract class WeekDay1 {
	private WeekDay1() {
	}

	public final staticWeekDay1 SUN = new WeekDay1() {

		@Override
		public WeekDay1 nextDay() {
			// TODO Auto-generated method stub
			return MON;
		}

	};
	public final staticWeekDay1 MON = new WeekDay1() {

		@Override
		public WeekDay1 nextDay() {
			// TODO Auto-generated method stub
			return SUN;
		}

	};

	public abstract WeekDay1 nextDay();

	/*
	 * public WeekDay nextDay(){ if(this == SUN){ return MON; }else{ return SUN;
	 * } }
	 */

	publicString toString() {
		return this == SUN ? "SUN" : "MON";
	}
}

SUN

----------上面是星期天-----------------

frist

second -------->（调用带参数的构造方法）

frist

frist

frist

frist

frist

+++++++++ 最后执行 ++++++++++++

FRI

---------------又来了一个---------------------

FRI

5

SUN

7

实现带有抽象方法的枚举：

实现抽象的next()方法：每个元素分别是由枚举类的子类来生成的实例对象，这些子类采用类似内部类的方式进行定义。

每个元素是这个类的实例对象，这个实例对象现在不能拿着这个类TrafficLamp 直接去new 了。

只能拿这个类的子类对象去new 并且把这个对象的名字叫为：REN,GREEN,YELLOW.

应该在哪里定义子类的实现代码呢？？？

REN 是 TrafficLamp类的子类的实例对象。

枚举只有一个成员时，就可以作为一种单例的实现方式。

public class EnumTest {
	
	public staticvoid main(String[] args) {
		
		// 表明是 new java.util 的子类。既可以调用父类的有参的构造方法，也可以调用父类无参的构造方法。
		new Date(){};
	}
	
	public enum TrafficLamp{
		
		// new 子类的实例对象，并且调用 父类的  构造方法。 
		RED(33) {
			@Override
			public TrafficLamp nextLamp() {
				return GREEN;
			}
		},
		GREEN(50){
			@Override
			public TrafficLamp nextLamp() {
				return YELLOW;
			}
		},
		YELLOW(6){
			@Override
			public TrafficLamp nextLamp() {
				return RED;
			}
		};
		public abstract TrafficLamp nextLamp();
		privateint time;
		private TrafficLamp(int time){
			this.time = time;
		}
	}

}

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签：

相关文章推荐

新的分享

章节导航