所有的枚举类都是java.lang.Enum的子类,所以自定义的枚举类无法继承其它类

枚举类的常用方法:

values():

是由编译器加入到自定义的enum类中的static方法

ordinal()

valueOf

package com.demo.enums;

/**
 * @author wobendiankun
 *2014-10-28 下午10:09:53
 */
public class EnumsTest {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		valueList();
		ordinal();
		valueOf("A");//A
		valueOf("F");//java.lang.IllegalArgumentException: No enum const class com.demo.enums.GradeType.F
	}

	private static void valueOf(String type) {
		System.out.println();
		System.out.println(GradeType.valueOf(type));
	}

	private static void ordinal() {
		System.out.println();
		//获取枚举常量的序数
		for(GradeType type:GradeType.values()){
			System.out.print(type.ordinal()+"\t");//0	1	2	3	4
		}
	}

	private static void valueList() {
		//获取枚举的所有值
		for(GradeType type:GradeType.values()){
			System.out.print(type+"\t");// A	B	C	D	E
		}
	}

}
enum GradeType {
	A,B,C,D,E
}

通过Class对象获取所有枚举常量

private static void getValuesByClass() {
		for(GradeType type:GradeType.class.getEnumConstants()){
			System.out.print(type+"\t");//A		B	C	D	E
		}
		System.out.println();
	}

为枚举类添加新方法

注意点：

1.不能继承除Enum之外，当作一个普通java类
2.必须先定义enum的实例，在实例序列最后面添加分号          
3.构造访问团限制为private或default

package com.demo.enums;

public class EnumMethodTest {
	enum GradeType {
		//枚举实例 
		A(85),B(75),C(65),D(59);
		private int score ;
		
		private GradeType(int score) {
			this.score = score;
		}

		public int getScore() {
			return score;
		}
		
	}
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		GradeType type=GradeType.valueOf("A");
		System.out.println("成绩:"+type.getScore());//成绩:85
	}

}

A():调用枚举的构造函数

利用接口来组织枚举

部门A中有两个项目组B、C,部门领导希望能够统一每个项目组所抛出的异常码与异常信息,做了统一的规划,各项目组可以扩展自己的异常码

类图:

DepAErrorCode:

package com.demo.enums.orga;

/**异常码接口
 * @author wobendiankun
 *2014-10-28 下午10:45:23
 */
public interface DepAErrorCode {
	/**获取错误码
	 * @return
	 */
	String getCode();
	/**获取错误信息
	 * @return
	 */
	String getDesc();
}

ProjectBErrorCode

package com.demo.enums.orga;

/**项目组B错误码接口
 * @author wobendiankun
 *2014-10-28 下午10:50:00
 */
public interface ProjectBErrorCode extends DepAErrorCode {

}

ProjectCErrorCode

package com.demo.enums.orga;

/**项目组C错误码接口
 * @author wobendiankun
 *2014-10-28 下午10:50:00
 */
public interface ProjectCErrorCode extends DepAErrorCode {

}

ProjectBCode

package com.demo.enums.orga;

/**
 * @author wobendiankun
 *2014-10-28 下午10:58:47
 */
public enum ProjectBCode implements ProjectBErrorCode{
	ADD_USER("10001","添加用户失败"),
	DELETE_USER("10002","删除用户失败");
	private String code;
	private String desc;
	
	private ProjectBCode(String code, String desc) {
		this.code = code;
		this.desc = desc;
	}

	@Override
	public String getCode() {
		return this.code;
	}

	@Override
	public String getDesc() {
		return this.desc;
	}

}

DepAException

package com.demo.enums.orga;

/**
 * @author wobendiankun
 *2014-10-28 下午10:45:43
 */
public class DepAException extends RuntimeException {
	public DepAException(DepAErrorCode depAErrorCode) {
		super(getMsg(depAErrorCode));
	}
	static String getMsg(DepAErrorCode depAErrorCode){
		return "错误码:"+depAErrorCode.getCode()+",错误信息:"+depAErrorCode.getDesc();
	}
	
}

ErrorCodeTest

package com.demo.enums.orga;

/**
 * @author wobendiankun
 *2014-10-28 下午10:58:40
 */
public class ErrorCodeTest {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		add();//com.demo.enums.orga.DepAException: 错误码:10001,错误信息:添加用户失败
	}

	private static void add() {
		new UserSerivce().add();
	}

}
class UserSerivce{
	void add(){
		throw new DepAException(ProjectBCode.ADD_USER);
	}
}

枚举定义抽象方法

package com.demo.enums;

/**
 * @author wobendiankun
 *2014-10-28 下午11:13:19
 */
public class EnumAbstractTest {
	enum GradeType {
		A(){

			@Override
			void print() {
				System.out.println("优秀");
			}
			
		},
		B(){
			
			@Override
			void print() {
				System.out.println("良");
			}
			
		};
		//定义一个抽象方法
		abstract void print();
	}
	public static void main(String[] args) {
		GradeType type=GradeType.B;
		type.print();//良
	}
}

EnumSet & EnumMap

public class EnumSetTest {

      /**
      * @param args
      */
      public static void main(String[] args) {
           EnumSet<Type > set= EnumSet.allOf( Type.class);
           print(set );
           set=EnumSet .noneOf( Type.class);
           print(set );
           set=EnumSet .of( Type.AA , Type. CC);
           print(set );
     }
      static void  print(EnumSet <Type> set){
           System.out .println(set);
     }
}
enum Type {
      AA,BB ,CC, DD,EE ,FF
     
}   

public class EnumMapTest {
      static EnumMap <Type, InvokeHandler> map = new EnumMap<Type , InvokeHandler>(
               Type.class);

      static void init() {
           map.put(Type .AA, new InvokeHandler() {

               @Override
               public void handle() {
                    System.out .println("处理了 AA...");
              }
          });
           map.put(Type .CC, new InvokeHandler() {

               @Override
               public void handle() {
                    System.out .println("处理了 CC...");
              }
          });
     }

      /**
      * @param args
      */
      public static void main(String[] args) {
           init();
           map.get(Type .CC). handle();
           map.get(Type .AA). handle();
           map.get(Type .DD). handle();
     }

}

interface InvokeHandler {
      void handle();
}

Thinking in Java 之 枚举篇