Thinking in Java 之 枚舉篇

所有的枚舉類都是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();
}