枚举与接口常量、类常量有什么区别？（枚举类实现接口）

2023-03-22 20:58:47 分类：java 阅读()

　　本篇文章为你整理了枚举与接口常量、类常量有什么区别？（枚举类实现接口）的详细内容，包含有枚举类和常量类的区别 枚举类实现接口 枚举常量类型 枚举接口定义了具有删除功能的方法 枚举与接口常量、类常量有什么区别？，希望能帮助你了解 枚举与接口常量、类常量有什么区别？。

　　目录一个简单的需求接口常量类常量枚举什么是枚举？枚举常量限制输入的类型枚举可以使用==来比较吗？枚举实现单例

　　作者：小牛呼噜噜 https://xiaoniuhululu.com
 

　　计算机内功、JAVA底层、面试相关资料等更多精彩文章在公众号「小牛呼噜噜 」

　　一个简单的需求

　　在我们实际开发java项目过程中，突然有一天"领导老王"给了个任务, 公司系统需要支持商品管理的需求
 

　　比如水果有：苹果，香蕉，葡萄等等，电子产品有：电脑，手机，摄像机等等

　　我们一般新建商品类Goods:

　　

public class Goods {

 

　　 * 商品名称

　　 private String name;

　　 * 商品类型

　　 private Integer type;

　　 public Goods(String name, Integer type) {

　　 this.name = name;

　　 this.type = type;

　　 public String getName() {

　　 return name;

　　 public void setName(String name) {

　　 this.name = name;

　　 public Integer getType() {

　　 return type;

　　 public void setType(Integer type) {

　　 this.type = type;

　　

 

　　然后我们就直接可以使用它：

　　

public class GoodsTest {

 

　　 public static void main(String[] args) throws InterruptedException {

　　 Goods goods = new Goods("水果",1);//1代表苹果，2：香蕉，3：葡萄

　　 System.out.println(goods.getName());

　　

 

　　但是有个问题，业务代码不清晰，有时候开发人员并不知道1、2、3代表什么意思，而且在业务代码层里面直接写数字或者字符串也是非常危险的时，我们需要一种方案，既能将相关的状态，类型放在一起，又可以限制类的输入值，提升项目的安全性

　　我们可以使用接口常量来解决上面的问题

　　

public interface StatusContentFace {

 

　　 public static final String fruit = "fruit";

　　 public static final Integer apple = 1;

　　 public static final Integer banana = 2;

　　 public static final Integer grape = 3;

　　 //==========================

　　 public static final String eleProduct = "eleProduct";

　　 public static final Integer computer = 101;

　　 public static final Integer phone = 102;

　　 public static final Integer camera = 103;

　　

 

　　我们再来看下测试类：

　　

public class GoodsTest1 {

 

　　 public static void main(String[] args) throws InterruptedException {

　　 Goods goods = new Goods(StatusContentFace.fruit,StatusContentFace.apple);

　　 Goods goods_2 = new Goods(StatusContentFace.eleProduct,StatusContentFace.computer);

　　 System.out.println(goods.getName());

　　 System.out.println(goods_2.getName());

　　

 

　　这样能够让相关的常量都在同一个接口文件中，接口常量，写起来比较简洁，但是为了让其他人知道每个常量的含义，最好写上注释。
 

　　但它同时有个问题，由于java中接口是支持多继承的

　　我们可以将内容深入到其实现类代码中，这样对于一个常量类接口来说显然是不合理。

　　我们还可以在其子接口里继续添加常量，这样在祖先接口中就无法控制所有常量，这样无疑是非常危险的。

　　一般不建议用的，但接口常量也不是一无是处的，可以通过内部接口来实现分组效果

　　

public class GoodsTest2 {

 

　　 public static void main(String[] args) throws InterruptedException {

　　 Goods goods = new Goods(Fruit.type,Fruit.banana);

　　 Goods goods_2 = new Goods(EleProduct.type,EleProduct.phone);

　　 System.out.println(goods.getName());

　　 System.out.println(goods_2.getName());

　　 //常量分组

　　 public interface Fruit {

　　 String type = "fruit";

　　 Integer apple = 1;

　　 Integer banana = 2;

　　 Integer grape = 3;

　　 public interface EleProduct {

　　 String type = "eleProduct";

　　 Integer computer = 101;

　　 Integer phone = 102;

　　 Integer camera = 103;

　　

 

　　这样我们可以把相关的常量都归为一类，更加简洁明了

　　我们一般常用的是类常量方式：

　　

public final class StatusConstant {

 

　　 private StatusConstant() {} //防止该类实例化

　　 public static final String fruit = "fruit";

　　 public static final Integer apple = 1;

　　 public static final Integer banana = 2;

　　 public static final Integer grape = 3;

　　 //==========================

　　 public static final String eleProduct = "eleProduct";

　　 public static final Integer computer = 101;

　　 public static final Integer phone = 102;

　　 public static final Integer camera = 103;

　　

 

　　注意：一般用final关键字修饰 class 防止其被继承，并将其构造函数 private 化，防止被实例化

　　测试类：

　　

public class GoodsTest3 {

 

　　 public static void main(String[] args) throws InterruptedException {

　　 Goods goods = new Goods(StatusConstant.fruit, StatusConstant.banana);

　　 Goods goods_2 = new Goods(StatusConstant.eleProduct, StatusConstant.phone);

　　 System.out.println(goods.getName());

　　 System.out.println(goods_2.getName());

　　

 

　　我们可以发现类常量的方式，的确很方便，也没有接口常量多继承的烦恼。但是她所能承接的信息，维度不够，只能一个字段的去承接信息，然而当项目复杂的话，我们希望往往其能承接更多维度的信息，类似于对象一样，拥有更多的属性

　　

{

 

　　 "name": ...,

　　 "type": ...,

　　 ...

　　

 

　　这时候，我们本文的主角，枚举就闪亮登场了！
 

　　什么是枚举？

　　枚举是一种特殊的类，所有的枚举类都是Enum类的子类,就类似Object类一样，由于java类是单继承的，所以不能在继承其他类或者枚举了。
 

　　枚举变量不能使用其他的数据，只能使用枚举中常量赋值。能提高程序的安全性。

　　格式：

　　

public enum 枚举名{

 

　　 //枚举的取值范围

　　

 

　　我们先定义一个枚举类,来定义常量：

　　

public enum ContentEnums {

 

　　 Apple(1,"苹果"),

　　 Banana(2,"香蕉"),

　　 Grape(3,"葡萄"),

　　 Computer(101,"电脑"),

　　 Phone(102,"手机"),

　　 Camera(103,"摄像机"),

　　


public class GoodsTest4 {

 

　　 public static void main(String[] args) throws InterruptedException {

　　 Goods goods = new Goods(ContentEnums.Fruit.getDesc(), ContentEnums.Apple.getCode());

　　 Goods goods_2 = new Goods(ContentEnums.EleProduct.getDesc(), ContentEnums.Phone.getCode());

　　 System.out.println(goods.getName());

　　 System.out.println(goods_2.getName());

　　

 

　　看到这大家可能就有疑问了，枚举和常量类相比，有什么优点吗？

　　枚举其实是一种特殊的类，可以承接对象的多维信息，但是常量类往往只能承接字段，信息比较单一

　　枚举可以搭配switch语句使用，来代替if/else

　　

ContentEnums content = ContentEnums.Apple;

 

　　switch (content) {

　　 case Apple:

　　 System.out.println("苹果");

　　 break;

　　 case Banana:

　　 System.out.println("香蕉");

　　 break;

　　 case Grape:

　　 System.out.println("葡萄");

　　 break;

　　 default:

　　 System.out.println("未找到匹配类型");

　　

 

　　enum 有一个非常有趣的特性，它可以为enum实例编写方法

　　

public enum MethodEnums {

 

　　 VERSION {

　　 @Override

　　 String getInfo() {

　　 return System.getProperty("java.version");

　　 DATE_TIME {

　　 @Override

　　 String getInfo() {

　　 return

　　 DateFormat.getDateInstance()

　　 .format(new Date());

　　 abstract String getInfo();

　　 public static void main(String[] args) {

　　 for(MethodEnums csm : values()) {

　　 System.out.println(csm.getInfo());

　　

 

　　结果：

　　1.8.0_271

　　2022-9-21

　　除了抽象方法，普通方法也是可以的，这里就不展示了

　　网上还有其他一些优点，感觉没啥特别值得说的

　　限制输入的类型

　　我们可以通过枚举来将相关的状态，类型放在一起，文章一开头，但我们怎么才能限制类的输入值呢？其实很简单，别被绕进去，我们只需将输入类型 改为指定的枚举即可
 

　　我们改造一下Goods类：

　　

public class Goods {

 

　　 * 商品名称

　　 private String name;

　　 * 商品类型

　　 private Integer type;

　　// public Goods(String name, Integer type) {

　　// this.name = name;

　　// this.type = type;

　　 public Goods() {//防止外部实例化

　　 public String getName() {

　　 return name;

　　 public void setName(String name) {

　　 this.name = name;

　　 public Integer getType() {

　　 return type;

　　 public void setType(Integer type) {

　　 this.type = type;

　　 public static Goods addGoods(ContentEnums enums){

　　 Goods goods = new Goods();

　　 goods.setName(enums.getDesc());

　　 goods.setType(enums.getCode());

　　 return goods;

　　

 

　　测试类：

　　

public class GoodsTest5 {

 

　　 public static void main(String[] args) throws InterruptedException {

　　 Goods goods = Goods.addGoods(ContentEnums.Apple);

　　 Goods goods_2 = Goods.addGoods(ContentEnums.Computer);

　　 System.out.println(goods.getName());

　　 System.out.println(goods_2.getName());

　　

 

　　这样，我们就可以限制创建对象时的输入值类型了

　　枚举可以使用==来比较吗？

　　可以使用==来比较 enum 实例，编译器会自动为你提供equals()和 hashCode() 方法。Enum 类实现了 Comparable 接口，所以它具有 compareTo() 方法。同时，它还实现了 Serializable 接口。

　　枚举实现单例

　　枚举类型是天生线程安全的，并且只会装载一次，我们可以利用了枚举的这个特性来实现单例

　　

public enum SingleInstance {

 

　　 INSTANCE;

　　 public void funDo() {

　　 System.out.println("doSomething");

　　

 

　　使用方式：SingleInstance.INSTANCE.funDo(）
 

　　这种方法充分 利用枚举的特性，让JVM来帮我们保证线程安全和单一实例的问题。写法也极其简洁。

　　参考：
 

　　《On Java 8》
 

　　《Effective java》第3版

　　本篇文章到这里就结束啦，很感谢你能看到最后，如果觉得文章对你有帮助，别忘记关注我！更多精彩的文章
 

　　以上就是枚举与接口常量、类常量有什么区别？（枚举类实现接口）的详细内容，想要了解更多 枚举与接口常量、类常量有什么区别？的内容，请持续关注盛行IT软件开发工作室。

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。

标签： java

相关文章阅读

  • java Springboot集成mybatis-plus的方法是什么
  • 浅谈几种Java自定义异常处理方式
  • Java Map所有的值转为String类型
  • java代码中格式化金额 java格式化小数
  • java计算器源代码资源 java计算器简单代码
  • 【java】（一）SpringBoot 源码解析——SpringApplication 初始化（）
  • Spring学习笔记（spring教程 csdn）
  • HDFS Architecture Guide（）
  • 哈工大软件构造Lab3（2022）（哈工大软件构造lab3）
  • nginx基础（nginx基础教程）
  • Java 中HashMap详解(含HashTable, ConcurrentHashMap)（java hashmap使用方法）
  • Java 线程池之Jetty 线程池学习总结（java线程池的使用方法）
  • java线程基础（java 线程教程）
  • 聊聊 Netty 那些事儿之 Reactor 在 Netty 中的实现(创建篇)（）
  • nginx（nginx负载均衡）
    • 留言与评论（共有 条评论）
       
    验证码：