Java面向对象设计最佳实践 - 枚举设计

最新推荐文章于 2024-08-16 10:29:55 发布
最新推荐文章于 2024-08-16 10:29:55 发布
阅读量1.3k 收藏 2
点赞数
分类专栏： Java程序设计基础 文章标签： java integer 游戏 语言 javadoc class

对枚举类型印象大多来自于C 语言，在 C 语言中，枚举类型是一个 HardCode （硬编码）类型，其使用价值并不大。因此，在 Java 5 之前，枚举是被抛弃的。然而 Java 5 以后的发现版本开始对枚举进行支持，枚举的引入给 Java 世界带来了争议。

笔者比较赞同引入枚举，作为一门通用的静态编程语言，应该是海纳百川的（因此笔者赞成闭包进入Java 7 ），多途径实现功能。

如果您不了解枚举的用法，建议参考笔者以前网络资源，了解基本的用法。地址为： http://mercyblitz.blog.ccidnet.com/blog-htm-do-showone-uid-45914-type-blog-itemid-189396.html

枚举是一种特殊的（受限制的）类，它具有以下特点：

  1. 可列性
  2. 常量性
  3. 强类型
  4. 类的特性

留下一个问题-怎么利用这些枚举特点，更好为设计服务呢？根据这些特点，下面向大家分别得介绍设计技巧。

一、 可列性

在设计中，必须搞清楚枚举 使用场景 。 枚举内部成员都是可列的，或者说固定的。这种硬编码的形式，看上去令人觉得不自在，不过这就是枚举。如果需要动态（不可列）的成员话，请不好使用枚举。

JDK提供不少良好的可列性设计枚举。比如时间单位 java.util.concurrent.TimeUnit 和线程状态枚举 java.lang.Thread.State 。

 

假设有一个游戏难度枚举，有三种难度NORMAL , MEDIUM, HARD

Java代码 复制代码
  1. /**  
  2.  
  3.  * 游戏中的难度枚举：NORMAL , MEDIUM, HARD  
  4.  
  5.  *   
  6.  
  7.  * @author mercyblitz  
  8.  
  9.  */  
  10.   
  11. public enum Difficulty {   
  12.   
  13. NORMAL, MEDIUM, HARD //注意：枚举成员命名，请使用英文大写形式   
  14.   
  15. }  
/**

 * 游戏中的难度枚举：NORMAL , MEDIUM, HARD

 * 

 * @author mercyblitz

 */

public enum Difficulty {

NORMAL, MEDIUM, HARD //注意：枚举成员命名，请使用英文大写形式

}

 

 

如果要添加其他成员，只能通过硬编码的方法添加到枚举类。回到枚举Difficulty，低版本的必定会影响二进制兼容性。对于静态语言来说，是无法避免的，不能认为是枚举的短处。

 

二、 常量性

之所以定性为常量性，是因为枚举是不能改变，怎么证明成员其不变呢？利用上面的Difficulty枚举为例，一段简单的代码得到其原型，如下：

Java代码 复制代码
  1. package org.mercy.design.enumeration;   
  2.   
  3. import java.lang.reflect.Field;   
  4.   
  5. /**  
  6.  * Difficulty 元信息  
  7.  * @author mercy  
  8.  */  
  9. public class MetaDifficulty {   
  10.   
  11.     public static void main(String[] args) {   
  12.         MetaDifficulty instance = new MetaDifficulty();   
  13.         // 利用反射连接其成员的特性   
  14.         Class<Difficulty> classDifficulty = Difficulty.class;   
  15.         for (Field field : classDifficulty.getFields()) {   
  16.             instance.printFieldSignature(field);   
  17.             System.out.println();   
  18.         }   
  19.     }   
  20.   
  21.     /**  
  22.      * 打印字段 签名(signature)  
  23.      *   
  24.      * @param field  
  25.      */  
  26.     private void printFieldSignature(Field field) {   
  27.         StringBuilder message = new StringBuilder("字段  ")   
  28.                                 .append(field.getName())   
  29.                                 .append(" 的签名：")   
  30.                                 .append(field.toString())   
  31.                                 .append("/t");   
  32.         System.out.print(message);   
  33.     }   
	package org.mercy.design.enumeration;
	
	import java.lang.reflect.Field;
	
	/**
	 * Difficulty 元信息
	 * @author mercy
	 */
	public class MetaDifficulty {
	
		public static void main(String[] args) {
			MetaDifficulty instance = new MetaDifficulty();
			// 利用反射连接其成员的特性
			Class<Difficulty> classDifficulty = Difficulty.class;
			for (Field field : classDifficulty.getFields()) {
				instance.printFieldSignature(field);
				System.out.println();
			}
		}
	
		/**
		 * 打印字段 签名(signature)
		 * 
		 * @param field
		 */
		private void printFieldSignature(Field field) {
			StringBuilder message = new StringBuilder("字段  ")
									.append(field.getName())
									.append(" 的签名：")
									.append(field.toString())
									.append("/t");
			System.out.print(message);
		}

}

 

 

printFieldSignature 方法输出枚举 Difficulty的字段，其结果为：

字段  NORMAL 的签名：public static final org.mercy.design.enumeration.Difficulty org.mercy.design.enumeration.Difficulty.NORMAL

字段  MEDIUM 的签名：public static final org.mercy.design.enumeration.Difficulty org.mercy.design.enumeration.Difficulty.MEDIUM

字段  HARD 的签名：public static final org.mercy.design.enumeration.Difficulty org.mercy.design.enumeration.Difficulty.HARD

 

这个结果得出了两个结论，其一，每个枚举成员是枚举的字段。其二，每个成员都被 public static final。凡是 static final  变量都是 Java 中的“常量”，其保存在常量池中。根据其常量性和命名规则，建议全大写命名每个枚举的成员（前面提到）。

常量性提供了数据一致性，不必担心被被其他地方修改，同时保证了线程安全。因此在设计过程中，不必担心线程安全问题。

枚举类型是常量，那么在判断是可以使用== 符号来做比较。可是如果枚举成员能够克隆 (Clone) 的话 , 那么 == 比较会失效，从而一致性不能得到保证。如果按照类的定义方法，考虑枚举的话，那么枚举类是集成了 java.lang.Object 类，因此，它继承了 protected java.lang.Object clone() 方法，也就是说支持 clone ，虽然需要通过反射的手段去调用。 Java 语言规范提到，每个枚举继承了 java.lang.Enum<E> 抽象基类。

提供一段测试代码来验明真伪：

Java代码 复制代码
  1. /**  
  2.  * 指定的类是枚举java.lang.Enum<E>的子类吗？  
  3.  *   
  4.  * @param klass  
  5.  * @return  
  6.  */  
  7. private boolean isEnum(Class<?> klass) {   
  8.     Class<?> superClass = klass.getSuperclass();   
  9.     while (true) { // 递归查找   
  10.         if (superClass != null) {   
  11.             if (Enum.class.equals(superClass))   
  12.                 return true;   
  13.         } else {   
  14.             break;   
  15.         }   
  16.         superClass = superClass.getSuperclass();   
  17.     }   
  18.     return false;   
  19. }  
	/**
	 * 指定的类是枚举java.lang.Enum<E>的子类吗？
	 * 
	 * @param klass
	 * @return
	 */
	private boolean isEnum(Class<?> klass) {
		Class<?> superClass = klass.getSuperclass();
		while (true) { // 递归查找
			if (superClass != null) {
				if (Enum.class.equals(superClass))
					return true;
			} else {
				break;
			}
			superClass = superClass.getSuperclass();
		}
		return false;
	}

 

    客户端代码调用： instance.isEnum(Difficulty. class ) ;  结果返回true ，那么证明了 Difficulty 枚举继承了java.lang.Enum<E> 抽象基类。

那么java.lang.Enum<E> 有没有覆盖 clone 方法呢？查看一下源代码：

Java代码 复制代码
  1. /**  
  2.  
  3.      * Throws CloneNotSupportedException.  This guarantees that enums  
  4.  
  5.      * are never cloned, which is necessary to preserve their "singleton"  
  6.  
  7.      * status.  
  8.  
  9.      *  
  10.  
  11.      * @return (never returns)  
  12.  
  13.      */  
  14.   
  15.     protected final Object clone() throws CloneNotSupportedException{   
  16.   
  17. throw new CloneNotSupportedException();   
  18.   
  19. }  
/**

     * Throws CloneNotSupportedException.  This guarantees that enums

     * are never cloned, which is necessary to preserve their "singleton"

     * status.

     *

     * @return (never returns)

     */

    protected final Object clone() throws CloneNotSupportedException{

throw new CloneNotSupportedException();

}

 

 

 

 

很明显，java.lang.Enum<E> 基类 final 定义了 clone 方法，即枚举不支持克隆，并且 Java doc 提到要保持单体性。那么这也是面向对象设计的原则之一 - 对于保持单态性的对象而言，尽可能不支持或者不暴露clone 方法。

 

三、 强类型

前面的两个特性，在前Java 5 时代，利用了常量字段也可以完成需要。比如可以这么设计Difficulty类的字段，

 

Java代码 复制代码
  1. public static final int NORMAL = 1;   
  2.   
  3. public static final int MEDIUM = 2;   
  4.   
  5. public static final int HARD = 3;  
public static final int NORMAL = 1;

public static final int MEDIUM = 2;

public static final int HARD = 3;

 

 

这么设计有一个缺点-弱类型，因为三个字段都是int原生型。

比如有一个方法用于设置游戏难度，定义如下：

 

Java代码 复制代码
  1. public void setDifficulty(int difficulty)  
public void setDifficulty(int difficulty)

   

  利用int类型作为参数，可能会有问题-如果参数在NORMAL，MEDIUM，HARD之外int数是可以接受的。利用规约的方法可以避免这个问题，比如设计范围检查：

Java代码 复制代码
  1. /**  
  2.  
  3.  * 设置游戏难度  
  4.  
  5.  * @param difficulty 难度数  
  6.  
  7.  * @throws IllegalArgumentException  
  8.  
  9.  *             如果参数不是 NORMAL、MEDIUM和Hard其中一个，那么报出IllegalArgumentException  
  10.  
  11.  */  
  12.   
  13. public void setDifficulty(int difficulty)   
  14.   
  15.  throws IllegalArgumentException   
/**

 * 设置游戏难度

 * @param difficulty 难度数

 * @throws IllegalArgumentException

 *             如果参数不是 NORMAL、MEDIUM和Hard其中一个，那么报出IllegalArgumentException

 */

public void setDifficulty(int difficulty)

 throws IllegalArgumentException

 

 

在可能实现方法中，通过三次成员比较，这样比较笨拙和憋足。

如果您在使用Java 5以前版本的话，作者提供一个较好的实现方法:

Java代码 复制代码
  1. package org.mercy.design.enumeration;   
  2.   
  3. import java.util.Collections;   
  4. import java.util.HashSet;   
  5. import java.util.Set;   
  6. /**  
  7.  * Difficulty JDK1.4实现　Difficulty枚举  
  8.  * @author mercy  
  9.  */  
  10. public class Difficulty14 {   
  11.     //枚举字段   
  12.     public static final int NORMAL = 1;   
  13.     public static final int MEDIUM = 2;   
  14.     public static final int HARD = 3;   
  15.        
  16.     private final static Set difficulties;   
  17.   
  18.     static {   
  19.         // Hash 提供快速查找   
  20.         HashSet difficultySet = new HashSet();   
  21.         difficultySet.add(Integer.valueOf(NORMAL));   
  22.         difficultySet.add(Integer.valueOf(MEDIUM));   
  23.         difficultySet.add(Integer.valueOf(HARD));   
  24.         //利用不变的对象是一个好的设计实践   
  25.         difficulties= Collections.unmodifiableSet(difficultySet);   
  26.     }   
  27.        
  28.     /**  
  29.      * 设置游戏难度  
  30.      * @param difficulty 难度数  
  31.      * @throws IllegalArgumentException  
  32.      *             如果参数不是NORMAL、MEDIUM和Hard其中一个，那么报出IllegalArgumentException  
  33.      */  
  34.     public void setDifficulty(int difficulty)    
  35.     throws IllegalArgumentException {   
  36.         if(!difficulties.contains(Integer.valueOf(difficulty)))   
  37.             throw new IllegalArgumentException("参数错误");   
  38.         //设置难度...   
  39.     }   
  40. }  
package org.mercy.design.enumeration;

import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
/**
 * Difficulty JDK1.4实现　Difficulty枚举
 * @author mercy
 */
public class Difficulty14 {
	//枚举字段
	public static final int NORMAL = 1;
	public static final int MEDIUM = 2;
	public static final int HARD = 3;
	
	private final static Set difficulties;

	static {
		// Hash 提供快速查找
		HashSet difficultySet = new HashSet();
		difficultySet.add(Integer.valueOf(NORMAL));
		difficultySet.add(Integer.valueOf(MEDIUM));
		difficultySet.add(Integer.valueOf(HARD));
		//利用不变的对象是一个好的设计实践
		difficulties= Collections.unmodifiableSet(difficultySet);
	}
	
	/**
	 * 设置游戏难度
	 * @param difficulty 难度数
	 * @throws IllegalArgumentException
	 *             如果参数不是NORMAL、MEDIUM和Hard其中一个，那么报出IllegalArgumentException
	 */
	public void setDifficulty(int difficulty) 
	throws IllegalArgumentException {
		if(!difficulties.contains(Integer.valueOf(difficulty)))
			throw new IllegalArgumentException("参数错误");
		//设置难度...
	}
}

 

 

在上面的代码中，尽管提供了范围检查，不过参数范围还是巨大（可以说是无数），并且是运行时检查。因为 setDifficulty 的参数是 int的，客户端调用时候，编译器可以接受 int 以及范围更小的 short 、 byte 等类型。那么违反了 一个良好的实践 -在面向对象设计中，类型范围最好在编译时确定而非运行时。

另一个良好的面向对象实践 -利用对象类型，而不是原生型（如果编程语言支持的话）。 那么，如果使用java.lang.Integer 取代 int 类型，并且 Integer 是 final 类，没有必要担心多态的情况下，不就可以提供强类型吗？的确，提供了强类型约束，并且更好的锁定类型范围（因为是 final 的）。可是， Integer 的范围在一定程度上，认为是无限的，同时不支持 swtich 语句（ 仅支持 int  、 short 、 byte 和 Java 5  枚举类型）。因此 Integer 还是不合适的。

枚举的常量性和可列性，在Difficulty 场景中尤其适合。

 

四、 类的特性

已知每个枚举都继承了java.lang.Enun<E>基类，其既有常量性，同时也有类的特点。尽管它是一种被限制的类，比如name和ordinal字段状态都是有JVM处理的。不过开发人员可以充分的利用类的特点，作出优美的设计。

枚举既然也是类，那么也遵循类的设计。通过扩张 Difficulty 类，面向对象的方式来设计枚举。

1.  封装设计

如果有一个需求 - Difficulty 持久化，把其存入 d ifficult ies数据库表中，并且提供一个唯一的 id 整型值。面向对象的封装，枚举也适用。示例如下：

Java代码 复制代码
  1. public enum Difficulty {   
  2.     // 注意：枚举成员命名，请使用英文大写形式   
  3.     NORMAL(1), MEDIUM(2), HARD(3);    
  4.     /**  
  5.      * final修饰字段是一个良好的实践。  
  6.      */  
  7.     final private int id;   
  8.        
  9.     Difficulty(final int id){   
  10.         this.id=id;   
  11.     }   
  12.     /**  
  13.      * 获得ID  
  14.      * @return  
  15.      */  
  16.     public int getId() {   
  17.         return id;   
  18.     }   
  19. }  
public enum Difficulty {
	// 注意：枚举成员命名，请使用英文大写形式
	NORMAL(1), MEDIUM(2), HARD(3); 
	/**
	 * final修饰字段是一个良好的实践。
	 */
	final private int id;
	
	Difficulty(final int id){
		this.id=id;
	}
	/**
	 * 获得ID
	 * @return
	 */
	public int getId() {
		return id;
	}
}

 

 

通过调用getId 方法可以获取枚举成员的 ID 值。

2.  抽象设计

在不同的游戏难度级别中，不同任务的难度值不同（大多数情况是通过值来表示，而非枚举对象本身）。以Difficulty为例，定义一个抽象的方法，计算难度值。

Java代码 复制代码
  1. /**  
  2.  * 获取不同任务的难度值  
  3.  *   
  4.  * @param mission  
  5.  * @return  
  6.  * @throws IllegalArgumentException  
  7.  *             如果<code>mission</code> 为负数时。  
  8.  */  
  9. public abstract int getValue(int mission) throws IllegalArgumentException;  
	/**
	 * 获取不同任务的难度值
	 * 
	 * @param mission
	 * @return
	 * @throws IllegalArgumentException
	 *             如果<code>mission</code> 为负数时。
	 */
	public abstract int getValue(int mission) throws IllegalArgumentException;

 

3.  多态设计

Difficulty枚举中定义抽象方法getValue，那么其子类必须实现这个方法。不过枚举不能被继承，也不能继承其他类，除了默认额java.lang.Enum<E>类以外。因此枚举是一个final的版本，不能实现抽象方法？

枚举的特殊在此，枚举虽然不能显示地利用extends关键字继承，不过它的每个成员都是自己的子类。那么以Difficulty为例，其类层次关系为：java.lang.Enum<E> -> Difficulty -> HARD。这么看来，每个枚举成员相当于定了一个final的类内置类。

回到Difficulty枚举，实现抽象方法如下：

 

 

Java代码 复制代码
  1. NORMAL(1) {   
  2.         @Override  
  3.         public int getValue(int mission)    
  4.     throws IllegalArgumentException {   
  5.             return mission + this.getId();   
  6.         }   
  7.     },   
  8.     MEDIUM(2) {   
  9.         @Override  
  10.         public int getValue(int mission)    
  11.     throws IllegalArgumentException {   
  12.             return mission * this.getId();   
  13.         }   
  14.     },   
  15.     HARD(3) {   
  16.         @Override  
  17.         public int getValue(int mission)    
  18.     throws IllegalArgumentException {   
  19.             return mission << this.getId();   
  20.         }   
  21.     };  
NORMAL(1) {
		@Override
		public int getValue(int mission) 
	throws IllegalArgumentException {
			return mission + this.getId();
		}
	},
	MEDIUM(2) {
		@Override
		public int getValue(int mission) 
	throws IllegalArgumentException {
			return mission * this.getId();
		}
	},
	HARD(3) {
		@Override
		public int getValue(int mission) 
	throws IllegalArgumentException {
			return mission << this.getId();
		}
	};

 

4.  继承设计

在上述实现中，可以观察到一点，每个实现getValue 的方法都利用的 getId() 方法。那么再次说明了枚举类本身也是一个特殊基类，可以定义模板方法。

5.  串行化设计

在某些设计中，需要把枚举通过串行化。回到 Difficulty14 的示例中，三个成员变量都是常量，那么 static的变量是不可能被串行化的。如果去掉 static 修饰，那么语义将会被改变。而枚举不同，所有自定义枚举都是 java.lang.Enum<E> 的子类，因此所有的枚举都是可序列化的（ java.lang.Enum<E>  实现了java.io.Serializable ） 。这也是枚举相对于常量的优势之一。

实现中可以提供类似这样的方法：

Java代码 复制代码
  1. private void readObject(ObjectInputStream in) throws IOException   
  2.   
  3. private void readObjectNoData() throws ObjectStreamException   
private void readObject(ObjectInputStream in) throws IOException

private void readObjectNoData() throws ObjectStreamException

 

 

总之，枚举也可以像类那样，实现面向对象的特点，不过值得一提的是， 枚举中应该保持尽量可能少的状态，职责单一的设计。

总结：Java中的枚举本质上也是类，只是类结构上比较特殊,Java5之前叫做实例受控类型安全的类型，Java5把这种类的设计语法化了，并且功能上更强大.

有一点是枚举类型并没有final修饰符修饰,如果有final修饰符修饰了，那么将禁止它在任何地方的子类化，不管是类外还是类内部，
枚举类型的构造方法受private修饰,这样可以在类内部子类化,以提供不同枚举值的行为上的差别.

 

孙定涛
关注
专栏目录
java枚举最佳实践
码蹄疾
04-16 1712
背景场景是这样的，客户端要发送JSON数据到达服务端解析，由于客户端的不同版本更新，打过来的数据有差异，服务端要兼容这种差异对不同的处理这些数据，因为客户端升级是由用户决定的。思路实现的方式肯定很多种，恰好学到《effective java》中的枚举，枚举可以加一个方法，我们这个场景每一种日志格式就对应于一种解析的方法。public enum LogVersion { OLD(0),NEW(
Java语言与面向对象程序设计-印旻ppt
01-24
5. **设计模式**：面向对象设计模式是解决特定问题的最佳实践，如单例模式、工厂模式、观察者模式等，这些模式在Java编程中广泛应用。 印旻的PPT将详细解释这些概念，并通过实例和练习帮助学习者理解和应用。通过...
java枚举存储数据库
最新发布
weixin_30313409的博客
08-16 29
我整理的一些关于【Java,数据库】的项目学习资料（附讲解～～）和大家一起分享、学习一下：https://d.51cto.com/f2PFnNJava枚举存储数据库：如何将Java枚举存储到数据库中 在Java编程中，枚举（Enum）是一种特殊的类，用于定义固定的常量集合。许多项目在数据库中需要存储这些枚举值，由于枚举的...
Java面向对象设计最佳实践 - 概述
Mercy Blog
04-16 167
根据笔者的经验，计划编写 “Java 面向对象设计最佳实践” 专题，通过 用理论和实战的方法，试图介绍Java 面向对象设计，希望大家喜欢。本文是开章概述，由于经验和精力有限，欢迎大家指正和共同交流学习。 言归正传，Java 语言作为一门“ 全面 ”面向对象的编程语言，提供了面向对象的四种基本性质： 抽象性 、 封装...
Java面向对象设计最佳实践——内置类设计
u012038649的专栏
03-01 591
。，内置类（Local Class）类内置类（Nested Class)，其定义在java.util.Map.Entry&lt;K, V&gt;private final static是通用的设计。外层类对其是完全可视的，因此private 是没有问题的。至于final的修饰，要谈到笔者设计经验中的一个原则，尽量使用final修饰可修饰的。其中有几个好处，比如线程安全、拒绝子类、标准化（在后面的设...
javaweb系统的枚举设计
愤怒的coder
09-24 305
  /* 组件目的： 在java-web程序的研发过程中，经常使用枚举（譬如人物性别，审核状态等），枚举库存的值多半是英文或者是数字， 而前台在给用户展示的时候 ，需要对英文或者数字进行转译，就是翻译成对应的文本内容。 很多时候都是这种模式：后台java编写constant.java枚举类，统一管理枚举；而前台则要参考constant.java的内容， 将枚举的内容写死在jsp页面...
Java面向对象程序设计语言课程设计指导书.pdf
09-30
根据提供的文件内容，“Java面向对象程序设计语言课程设计指导书.pdf”这份文档可能是一份关于Java编程语言的实践课程设计教材。内容中提及了很多关于Java编程的重要知识点和概念，虽然内容显得有些混乱，部分文字...
《面向对象程序设计——Java语言》电子课件(程细柱PPT)
07-15
通过这个电子课件，学习者不仅可以掌握Java语言的面向对象编程技术，还能了解到实际项目开发中的一些最佳实践。程细柱的讲解方式通常深入浅出，结合实例，有助于学习者快速理解和掌握知识要点。
面向对象程序设计（Java）教学课件
09-19
15. 设计模式：设计模式是解决常见编程问题的最佳实践，例如工厂模式、单例模式、观察者模式等，它们在Java编程中广泛使用。 通过学习这些Java面向对象编程的核心概念，学习者可以更好地理解和应用Java语言，从而...
Java-Zen-of-Design.rar_zen_设计模式之禅
09-20
设计模式是面向对象编程中的一种最佳实践，是解决常见问题的经验总结，它使得开发者能够用一种标准化的方式去思考和解决问题，从而提高软件开发效率和团队协作能力。 1. **单例模式**：在Java中，单例模式是一种...
Java枚举与设计模式
09-27
本文详尽地论述了Java枚举与设计模式的关系
DesignPattern:经验丰富的面向对象软件开发人员使用的最佳实践
07-05
设计模式 经验丰富的面向对象软件开发人员使用的最佳实践。
Java枚举类-行为模式最佳实践
dotedy的博客
12-20 460
博客分类： 下面的主要内容是读了《Effective Java》第二版第30条之后的一些看法和总结。        在面对一大篇的叙述性的知识点介绍时，往往觉得太过乏味，抓不住重点甚至有些力不从心。而采用对比的学习方式，可以明了孰优孰劣，关键特性是什么。第30条关于枚举的介绍，带给我一些感触。 曾和同事讨论如何使用常量，说就用过public st
枚举的设计
Sean.Pu的专栏
09-20 847
大部分人在设计枚举时或者同我一样：public enum StateRecord...{    Default,    Block,    Delete,    Top,    Modify,    Locked,}其实这种设计是有很大缺陷的：当枚举内容有新增和插入时就是前浪死在沙滩上了。合理的设计应该是这样：public enum StateRecord...{ 
[干货]--枚举最佳实践
weixin_33755649的博客
03-28 228
导语： java世界数据分两种类型，基本数据类型和引用数据类型。引用数据类型分为类和接口。枚举是一种特殊的类，注解是一种特殊的接口。 基于以上可知，枚举是一种特殊的类，所谓的enum关键字其实是编译器语法糖。每一个枚举类编译之后反编译得到的依然是class。这个class继承了java.lang.Enum类，顶层父类依然是Object 。只不过这个类的构造方法是私有的，只是通过类里面的静态域持...
Java面向对象设计最佳实践 - 方法设计（一）
Mercy Blog
05-17 306
在《类的设计基础知识》文章中提到， 方法作为 命名的控制类或者对象的有状态或无状态的执行模块，可称作类或者对象的“行为”。 方法在类中的地位相当重要，利用面向对象的多态性能够设计更为优雅的结构，同时巧妙地使用继承能够更好地减少冗余，因此其设计是重重之重。方 法的设计实践会按照下列的议程安排： 名称和注释设计 注释即规约 ...
Java枚举
tragfarmer的博客
08-21 380
1- 什么是Java枚举 2- 可以使用==操作符来比较枚举的元素 3- 枚举在Java可以被用来作switch语句的参数 4- 获取枚举的元素 5- 枚举可以有构造函数和方法 6- 覆盖枚举方法 7- 枚举抽象方法 1- Java枚举(Enum)是什么？ 枚举(enum)是Java的一个关键字，它用于表示在Java中公知的值的固定个数的特征，例如一周的天数，太阳系中
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值