详解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,"摄像机"),

    Fruit(10010,"fruit"),
    EleProduct(10020,"eleProduct");

    private Integer code;
    private String desc;

    ContentEnums(Integer code, String desc) {
        this.code = code;
        this.desc = desc;
    }

    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

    public String getDesc() {
        return desc;
    }

    public void setDesc(String desc) {
        this.desc = desc;
    }
}

测试类:

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());
    }
}

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

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

2.枚举可以搭配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("未找到匹配类型");
}

3.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

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

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

限制输入的类型

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

我们改造一下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来帮我们保证线程安全和单一实例的问题。写法也极其简洁。

以上就是详解Java枚举与接口常量和类常量的区别的详细内容,更多关于Java枚举 接口常量 类常量的资料请关注我们其它相关文章!

(0)

相关推荐

  • Java BeanDefination接口详细讲解

    目录 功能作用 为什么这样设计 假设没有BeanDefinition 有BeanDefinition BeanDefinition 属性介绍 示例 功能作用 BeanDefinition 是定义 Bean 的配置元信息接口,包含: Bean 的类名 设置父 bean 名称.是否为 primary. Bean 行为配置信息,作用域.自动绑定模式.生命周期回调.延迟加载.初始方法.销毁方法等 Bean 之间的依赖设置,dependencies 构造参数.属性设置 BeanDefinition 子类方

  • Java 内置接口 Serializable示例详解

    目录 引言 Serializable 接口 Serializable 是一个标记型接口 serializable Version UID Java 序列化与JSON序列化的区别 Java序列化相较于 JSON 的优势 Java 类对象的序列化代码演示 总结 引言 上一部分我们着重讲了 Java 集合框架中在开发项目时经常会被用到的数据容器,在讲解.演示使用实践的同时,把这个过程中遇到的各种相关知识点:泛型.Lambada.Stream 操作,一并给大家做了梳理. 从这篇开始我们进入下一部分,用三

  • Java 数据结构算法Collection接口迭代器示例详解

    目录 Java合集框架 Collection接口 迭代器 Java合集框架 数据结构是以某种形式将数据组织在一起的合集(collection).数据结构不仅存储数据,还支持访问和处理数据的操作 在面向对象的思想里,一种数据结构也被认为是一个容器(container)或者容器对象(container object),它是一个能存储其他对象的对象,这里的其他对象常被称为数据或者元素 定义一种数据结构从实质上讲就是定义一个类.数据结构类应该使用数据域存储数据,并提供方法支持查找.插入和删除等操作 Ja

  • Java Map接口概述和常用方法详解

    目录 概述 Map常用子类 Map接口中的常用方法 Map集合遍历键找值方式 Entry键值对对象 Map集合遍历键值对方式 概述 现实生活中,我们常会看到这样的一种集合:IP地址与主机名,身份证号与个人,系统用户名与系统用户对象等,这种一一对应的关系,就叫做映射.Java提供了专门的集合类用来存放这种对象关系的对象,即java.util.Map接口. 我们通过查看Map接口描述,发现Map接口下的集合与Collection接口下的集合,它们存储数据的形式不同,如下图. Collection中的

  • java中如何使用HttpClient调用接口

    目录 java使用HttpClient调用接口 HttpClient 提供的主要的功能 直接言归正传了!!!!上代码 java的HttpClient调用远程接口 使用方法 实例 java使用HttpClient调用接口 HttpClient 提供的主要的功能 (1)实现了所有 HTTP 的方法(GET,POST,PUT,DELETE 等) (2)支持自动转向 (3)支持 HTTPS 协议 (4)支持代理服务器等 直接言归正传了!!!!上代码 public static String sendPu

  • Java ServletContext与ServletConfig接口使用教程

    目录 ServletContext接口 1.概念 2.功能 1.获取Web应用程序的初始化参数 2.实现多个Servlet对象共享数据 3.读取Web应用下的资源文件 ServletConfig接口 1.概念 2.ServletConfig的常用方法 ServletContext接口 1.概念 当Servlet容器启动时,会为每个Web应用创建一个唯一的ServletContext对象代表当前Web应用,可以和程序的容器(服务器)来通信. 两种获取方式: 通过request对象获取 Servle

  • Java基础学习之接口详解

    目录 概述 定义格式 含有抽象方法 含有默认方法和静态方法 含有私有方法和私有静态方法 基本的实现 实现的概述 抽象方法的使用 默认方法的使用 静态方法的使用 私有方法的使用 接口的多实现 抽象方法 默认方法 静态方法 优先级的问题 接口的多继承 其他成员特点 概述 接口,是Java语言中一种引用类型,是方法的集合,如果说类的内部封装了成员变量.构造方法和成员方法,那么接口的内部主要就是封装了方法,包含抽象方法(JDK 7及以前),默认方法和静态方法(JDK 8),私有方法 (JDK 9). 接

  • Java中的Comparable和Comparator接口

    目录 一. Comparable接口 1. Comparable简介 2. 为什么要实现Comparable接口 3. Comparable的实际应用 二. Comparator接口 1. Comparator简介 2. Comparator接口的实际运用 三. Comparable和Comparator的比较 一. Comparable接口 1. Comparable简介 Comparable是排序接口. 若一个类实现了Comparable接口,就意味着该类支持排序. 实现了Comparabl

  • 详解Java枚举与接口常量和类常量的区别

    目录 一个简单的需求 接口常量 类常量 枚举 什么是枚举 枚举常量 限制输入的类型 枚举可以使用==来比较吗 枚举实现单例 一个简单的需求 在我们实际开发java项目过程中,突然有一天"领导老王"给了个任务, 公司系统需要支持商品管理的需求 比如水果有:苹果,香蕉,葡萄等等,电子产品有:电脑,手机,摄像机等等 我们一般新建商品类Goods: public class Goods { /** * 商品名称 */ private String name; /** * 商品类型 */ pri

  • 详解Java中Collector接口的组成

    一.Collector常常出现的地方 java8引入了stream,Collector是与stream一起出现的,配合stream使用的好帮手,如果用过stream,我们应该都有写过这样的代码 例子1: lists.stream()....collect(Collectors.toList()); 例子2: lists.stream().collect(groupingBy(String::length)); 这两个例子中,toList()和groupingBy()返回的都是一个Collecto

  • 详解Java枚举类在生产环境中的使用方式

    目录 前言 使用 1.确定业务场景状态 2.定义枚举类 3.自定义查询方法 4.测试效果 总结 前言   Java枚举在项目中使用非常普遍,许多人在做项目时,一定会遇到要维护某些业务场景状态的时候,往往会定义一个常量类,然后添加业务场景相关的状态常量.但实际上,生产环境的项目中业务状态的定义大部分是由枚举类来完成的,因为更加清晰明确,还能自定义不同的方法来获取对应的业务状态值,十分方便. 以下代码均为生产环境已上线项目的代码片段,仅供参考. 使用 大体分为确定业务场景状态.定义枚举类.自定义查询

  • 详解JAVA使用Comparator接口实现自定义排序

    1.原则 Comparator接口可以实现自定义排序,实现Comparator接口时,要重写compare方法: int compare(Object o1, Object o2) 返回一个基本类型的整型 如果要按照升序排序,则o1 小于o2,返回-1(负数),相等返回0,01大于02返回1(正数) 如果要按照降序排序,则o1 小于o2,返回1(正数),相等返回0,01大于02返回-1(负数) import java.util.ArrayList; import java.util.Compar

  • 详解Java编程规约(命名风格、常量定义、代码格式)

    命名风格 1.[强制]代码中的命名均不能以下划线或美元符号开始,也不能以下划线或美元符号结束. 反例: _name / __name / $name / name_ / name$ / name__ 2.[强制]代码中的命名严禁使用拼音与英文混合的方式,更不允许直接使用中文的方式. 说明:正确的英文拼写和语法可以让阅读者易于理解,避免歧义.注意,纯拼音命名方式更要避免采用. 正例:renminbi / alibaba / taobao / youku / hangzhou 等国际通用的名称,可视

  • 实例详解Java调用第三方接口方法

    目录 一. 通过JDK网络类Java.net.HttpURLConnection 1.java.net包下的原生java api提供的http请求 2.HttpClientUtil工具类 3.第三方api接口 4.测试类 二.通过Apache common封装好的HttpClient 1.引入依赖 2.httpClientUtil 3.第三方api接口 4.测试类 三.通过Spring的RestTemplate 1.引入依赖 2.RestTemplate配置类 3.RestTemplate实现类

  • 详解java枚举用法及实例

    一.枚举类型作为常量 package myenum; /** * @author zzl * 简单的枚举作为常量 */ public enum Color { GREEN,RED,YELLOW; public static void main(String[] args) { for (Color c : values()) { System.out.println("color:"+c); } } } //输出 /** color:GREEN color:RED color:YELL

  • 详解Java中用于国际化的locale类

    1. Locale 介绍 Locale 表示地区.每一个Locale对象都代表了一个特定的地理.政治和文化地区. 在操作 Date, Calendar等表示日期/时间的对象时,经常会用到:因为不同的区域,时间表示方式都不同. 下面说说Locale对象的3种常用创建方式. (1)获取默认的Locale 使用方法: Locale locale = Locale.getDefault() (2) 直接使用Locale的静态对象 Locale.java中提供了以下静态对象 public static f

  • 详解Java中使用externds关键字继承类的用法

    理解继承是理解面向对象程序设计的关键.在Java中,通过关键字extends继承一个已有的类,被继承的类称为父类(超类,基类),新的类称为子类(派生类).在Java中不允许多继承. (1)继承 class Animal{ void eat(){ System.out.println("Animal eat"); } void sleep(){ System.out.println("Animal sleep"); } void breathe(){ System.o

  • 详解Java中AbstractMap抽象类

    jdk1.8.0_144 下载地址:http://www.jb51.net/softs/551512.html AbstractMap抽象类实现了一些简单且通用的方法,本身并不难.但在这个抽象类中有两个方法非常值得关注,keySet和values方法源码的实现可以说是教科书式的典范. 抽象类通常作为一种骨架实现,为各自子类实现公共的方法.上一篇我们讲解了Map接口,此篇对AbstractMap抽象类进行剖析研究. Java中Map类型的数据结构有相当多,AbstractMap作为它们的骨架实现实

随机推荐