精华内容
下载资源
问答
  • 常量类

    千次阅读 2018-10-23 11:30:45
    常量类 /** * 常量类 * public static final * 用接口封装 * 用枚举封装 */ public class Constant { public static final String CURRENT_USER = "currentUser"; public static final String ...

    常量类

        /**
         * 常量类
        * public static final
        * 用接口封装
        * 用枚举封装
        */
    public class Constant {
    
    public static final String CURRENT_USER = "currentUser";
    
    public static final String EMAIL = "email";
    public static final String USERNAME = "username";
    
    //接口中的属性默认是final
    public interface Cart{
        int CHECKED=1;//购物车选中状态
        int UNCHECK=0;//购物车中未选中状态
    
        String LIMIT_NUM_FAIL="LIMIT_NUM_FAIL";
        String LIMIT_NUM_SUCCESS="LIMIT_NUM_SUCCESS";
    }
    public enum ProductStatusEnum {
        ON_SALE(1,"在售");
    
        private String value;
        private int code;
    
        ProductStatusEnum(int code, String value) {
            this.code = code;
            this.value = value;
        }
    
        public int getCode() {
            return code;
        }
    
        public String getValue() {
            return value;
        }
    }
    
    public static void main(String[] args) {
        System.out.println(Cart.CHECKED);
        System.out.println(Constant.CURRENT_USER);
        ProductStatusEnum.ON_SALE.getCode();
    }
    }
    
    展开全文
  • Kotlin常量类的定义

    2021-10-21 13:31:49
    // 1、创建类 // 2、创建companion object {} // 3、创建常量类 class ConstantUtil { companion object { val constant = 1 } }
    // 1、创建类
    // 2、创建companion object {}
    // 3、创建常量类
    
    class ConstantUtil {
        companion object {
            val constant = 1
        }
    }
    
    展开全文
  • Java常量、常量类和常量方法 Java中实现常量类和常量方法是通过关键字final实现。通常分为两种情况 编译时一种不可变的常量 运行时初始化,但不希望被改变的变量 编译时的常量,编译器可以将它的值代入用到它的...

    Java常量、常量类和常量方法

    Java中实现常量类和常量方法是通过关键字final实现。通常分为两种情况

    1. 编译时一种不可变的常量
    2. 运行时初始化,但不希望被改变的变量

    编译时的常量,编译器可以将它的值代入用到它的任何地方,也就是说在编译时就已经执行了计算式,减少了运行时的负担,优化了性能。在Java这些常量必须为基本类型,并且必须赋值。

    final关键字修饰的特点

    • 静态常量一般以大写字母和下划线命名。
    • 当final关键字修饰类时,标明该类为常量类,常量类不能被继承。
    • 当final关键字修饰方法时,标明该方法为常量方法,常量方法不能被重写。
    • 常量类里面的成员方法隐式为常量方法,因为常量类无法被继承,成员方法也无法被重写。
    • 当final关键字修饰基本类型的成员属性时,标明该成员属性为常量,属性的值不能被改变,而且只能赋值一次。
    • 当final关键字修饰引用类型的成员属性时,标明该成员属性为常量,属性的引用不能被改变,只能指向一次引用,但该属性指向的对象里面的值可以被改变。
    • 常量属性必须要赋值,可以在初始化时赋值,也可以在类的构造方法里面赋值。
    • 类的构造方法不能被final修饰为常量方法,包括常量类。
    • 一个既被static关键字修饰 又被final修饰的域,是一个不可改变的内存空间。

    代码示例如下:

    //常量类 不能被继承
    public final class FinalPerson{
    
     //编译时常量,基本类型,初始化时赋值
     private final int eyes=2;
     
     //静态常量,以大写字母加下划线命名,一般对外可见
     public static final int MAX_VALUE=200;
    
     //常量,在构造方法里面赋值
     public final int watches;
     
     //引用类型的常量,包括类、数组、集合。
     private final Worker worker=new Worker("david");
     private final int[] intarray={1,2,3,4,5};
     private final ArrayList<String> lists=new ArrayList();
     
     //构造方法,不能被final修饰,常量可在构造方法中赋值
     public FinalPerson(int watches){
     	//常量赋值
        this.watches=watches;
        //引用常量,对象添加值。
        lists.add("a");
        lists.add("b");
     }
    
     //常量方法,不能被重写
     public final void change(){
     	//错误用法
      	//引用常量不能再次指向新的引用
       	//woker=new Worker();
       	//intArray=new int[1];
       	//lists=new ArrayList();
    
    	//如下使用是正确的
       	//可以改变引用常量里面的属性值,如
       	worker.setName("Jack");
       	//数组操作 变为{1,3,3,4,5}
       	intarray[1]=3;
       	//list下标值改变
       	list.set(0,"b");
     }
    
     
    }
    
    //普通类
    public class Worker{
       private String name;
       
       public Worker(String name){
       		this.name=name;
       }
    
       public void setName(String name){
       		this.name=name;
       }
    }
    
    
    展开全文
  • 这个时候就比较纠结,常量到底是封装到哪里比较好呢,因为以前写的很多代码不怎么规范,而且有时候常量用到的不算太多太集中,所以就哪里用到哪个上去声明一个出来,这样虽然很方便,但是统一维护起来,项目做大了...

    前言

    之前项目中响应前台的接口中会用到一些公共常量。这个时候就比较纠结,常量到底是封装到哪里比较好呢,因为以前写的很多代码不怎么规范,而且有时候常量用到的不算太多太集中,所以就哪里用到哪个类上去声明一个出来,这样虽然很方便,但是统一维护起来,项目做大了,有些时候你要引用一个你记得你明明声明过的常量,却找半天都找不到,而且后期需要对常量中的内容进行一些修改的时候,维护起来也十分不方便,代码整体结构也不优雅。所以自己决定研究一下到底常量应该封装到哪里比较好呢。因为题目所说的三种自己也都见过,但是具体的区别以及优劣却没有细细钻研。今天这里简单的记录整理一下,以防自己以后忘记。

    示例代码

    第一种使用接口:

    public interface Constants{
      
        int AUDIT_STATUS_PASS = 1;
        int AUDIT_STATUS_NOT_PASS = 2;
    }
    
    

    第二种使用类:

    public final class Constans{
      
        private Constans() {
        }
      
        public static final int AUDIT_STATUS_PASS = 1;
        public static final int AUDIT_STATUS_NOT_PASS = 2;
    }
    
    

    使用枚举

    public enum Constants {
     
        AUDIT_STATUS_PASS(1),
        AUDIT_STATUS_NOT_PASS(2);
        
        private int status;
        
        private Constants(int status){
            this.setStatus(status);
        }
     
        public int getStatus() {
            return status;
        }
    }
    

    首先,前两种可以看成是一样的。第一种写起来更方便一些吧,省去了public static final字段。但是如果从细想,接口可以被继承,可以将内容深入到其实现类代码中。这样对于一个常量类接口来说显然是不合理,但是你确实无法规避这个问题。唯一可以解决的办法就是弃用常量接口,选用常量类的方式。以final字段修饰,防止其被继承。并将其构造函数private化,防止被实例化。这显然在硬性上可以很好地解决这个问题。

    但即便如此枚举任然是首选,但是如果不使用枚举的话,在《Effective Java》一书中,作者建议使用一般类加私有构造函数的方式。但是参考了 StackOverFlow 上大牛的讲解,我认为一般类上也应该再加上final字段。这样可以更好的避免一些不必要的麻烦。
    参考:https://stackoverflow.com/questions/320588/interfaces-with-static-fields-in-java-for-sharing-constants

    常量接口

    你可能会问常量接口就真的一无是处吗?

    也不是,但是和是也差不多。但是我还是会用,贴一段自己的代码

    public final class Const {
     
        private Const() {
        }
     
        public static final String CURRENT_USER = "currentUser";
     
        // 这里没有使用interface进行分组是因为 这两个对象不好分组。
        public static final String EMAIL = "email";
        public static final String USERNAME = "username";
     
        // 普通用户和管理员是一个组,枚举过于繁重
        // 内部接口类 把常量进行分组。没有枚举重,但还可以分组,而且里面还是常量
        public interface Role {
            int ROLE_CUSTOMER = 0; // 普通用户
            int ROLE_ADMIN = 1; // 管理员
        }
    }
    

    具体常量接口的作用注释中已经写得很清楚了。总结下来就是前提你是内部接口,那么你可以直观分组,还简洁。

    总结

    综上:优先枚举,常量类,接口(不建议)。

    展开全文
  • Java常量类的几种实现方式

    千次阅读 2020-11-27 17:52:05
    实现常量的三种方式接口常量直接在接口中定义常量接口中定义静态内部类常量类枚举类枚举类列举常量在类里面创建枚举类 接口常量 直接在接口中定义常量 public interface Constants { /** * 中心 */ public ...
  • 1、构建常量类 @Component public class ConnectionFactory { @Value("参数不能为空") public String notNull; @Value("数据源名称错误") public String dbNameError; @Value("${returnResponse.code.failure}...
  • StandardCharsets字符编码常量类

    千次阅读 2020-01-03 14:15:34
    password = Base64.encodeBase64String(password.getBytes...jdk1.7自带的字符编码常量字段。 源码: package java.nio.charset; /** * Constant definitions for the standard {@link Charset Char...
  • 1、接口定义常量 public interface Constants{ public String USER_NAME = "WPO1462"; public String SECRET_ID = "wx_25sdl586sam02...2、常量类 public final class Constans{ public static final String...
  • 创建java常量类

    千次阅读 2018-07-09 14:20:43
    /** * Method One */ interface ConstantInterface { String SUNDAY = "SUNDAY"; String MONDAY = "MONDAY"; String TUESDAY = "TUESDAY"; String WEDNESDAY = "WEDNESDAY";...创建java常量类
  • 常量和枚举、常量类的区别

    万次阅读 2018-07-21 22:50:42
    一、实体常量类 /** * 实体常量类 * @author Administrator * @date 2018/7/21 */ public class ConstClass { private static final String Success = "成功"; private static final String Fail ...
  • 1.配置文件 application.properties #本地测试路径 ... # Windows 写入磁盘路径 win.file.disk.path=C://upload/img/ #本地测试路径 #win.file.disk.path=E://upload/images/ ...# linux 写入磁盘路径 ...2.定义常量类 注意
  • 定义常量类

    千次阅读 2017-10-13 20:42:11
    在项目中经常用到的常量类的定义方法 有 interface emun class 等 下面说一下 常量类的定义方法: 1. 用final 修饰类名 不可继承 2.定义了一个私有的构造函数,避免实例化该类; 3. public static fianl ...
  • Java基础学习笔记:静态常量类

    千次阅读 2019-08-02 10:58:33
    中用public static final 修饰的变量 说明: public是为了方便访问 static是为了让其成为的成员,而不是对象的成员。...final 修饰变量多用于声明一个常量 在变量被第一次赋值了之后,这个...
  • 修改一个常量类中的静态常量值,然后把常量类的class文件上传到服务器后并没有生效,多次重启服务,最后查询了相关资料,使用GUI反编译工具反编译查看编译后源码,终于找到问题所在: 单纯的修改静态常量是没用的,...
  • 在mybatis中引入常量的规则:'${@路径的全名称@常量值}' 例如:id = ${@com.cts.common.constant.Constant@ADMIN_ACCOUNT} 注:这是注重讲的Mybatis引入常量方法,其他都是举例说明而已 ...
  • 有用常量类的、有用接口的、有用枚举的,因此本文针对于常量的管理做一些讨论 2、栗子 第一种使用接口: public interface Constants{ int AUDIT_STATUS_PASS = 1; int AUDIT_STATUS_NOT_PASS = 2; } 第二.....
  • 为什么要写常量类

    千次阅读 2019-03-02 21:22:08
    我原先也不懂为什么要用常量类,后来当我查询一个数据状态是在哪里更新的时候,我明白了。。。 使用常量类能更快更准确的定位到数据比较、更新、set属性值等操作是在哪里进行的。如果使用“魔法值”,对后期的维护...
  • http返回状态码 -java的常量类

    千次阅读 2020-12-16 15:09:45
    package com.ruoyi.common.constant; /** * 返回状态码 * * @author dz * @Date 2020-12-16 */ public class HttpStatus { ... public static final int SUCCESS = 200;... public static final int CREATED =
  • java枚举与常量类区别

    千次阅读 2018-09-20 16:15:30
    枚举相对于常量类来说定义更简单,其不需要定义枚举值,而常量类中的每个常量必须要手动添加值。 枚举作为参数使用时可以在编译时避免弱类型错误,而常量类中的常量作为参数使用时在编译时无法避免弱类型错误(譬如...
  • 静态因为编译成字节码,直接在虚拟机上运行,少了读取-从字符串读数据等一系列步骤。速度上肯定占有绝对优势。 但设立properties文件的目的,是为了不改动程序而实现配置数据的变化,特设的使 配置数据 和 程序 ...
  • JAVA 定义常量类和枚举

    千次阅读 2018-04-13 10:32:53
    1:定义常量类/** * @Author:Starry * @Description:常量类定义 * @Date:Created in 10:08 2018/4/13 * Modified By: */ public interface ServiceConst { /** 逻辑删除标记 **/ interface DELETE_FLAG{ /*...
  • 【记录】mybatis中获取常量类中数据

    千次阅读 2018-04-10 16:54:59
    部分转载,已注明来源:1、mybatis中获取常量类中数据&lt;update id="refuseDebt"&gt; UPDATE dt_debt a SET a.debt_status = ${@com.debtm.common.STATUS$DEBT_STATUS@DEBT_RETURNED}, a....
  • java常量类声明的小技巧

    千次阅读 2018-04-29 14:21:57
    在实际项目开发中,有时需要在常量类中或者在枚举类中声明常用的常量。但是有一些常量使用枚举有点过重,直接使用常量又不太符合java抽象的开发思想。此时可以在其中声明一个接口,将常量放入接口中,使用时直接调用...
  • java中的枚举类和常量类的区别

    千次阅读 2017-12-06 14:26:01
    于是我们用枚举来代替常量。 publicenum AuditState { UNAUDIT (1), AUDITING (2), AUDIT_SUCCESS (3), AUDIT_FAIL (4); privatefinalint statenum; AuditState( int statenum){ this ...
  • idea:设置Java中的常量类,等号对齐

    万次阅读 2018-01-09 11:29:18
    setting——&gt;code style——&gt;Java——&gt;Wrapping and baces——&gt;Group declarations ——&gt;Align fields in columns 和 Align variables in columns((勾上)--点击右下角Apply...
  • 转载来源:最近在熟悉小组的代码时看见常量声明的不同方式就看了看这几种方式的不同之处。。 来源:https://segmentfault.com/q/1010000007620581?_ea=1406439 第一种使用接口: public interface Constants{ ...
  • 常量接口 vs 枚举常量类

    千次阅读 2015-03-25 15:00:42
    常量定义在接口里与里都能通过编译,那2者到底有什么区别呢?那个更合理?  1. 常量接口  Java代码  public interface ConstInterfaceA {   public static final String CONST_A...
  • java常量类的一种定义方式

    千次阅读 2017-03-13 14:20:28
    package ... public final class Constant { private Constant() { super(); } /*************************************** Common常量列表 ************************************************
  • Java:能够用常量类代替枚举类?

    千次阅读 2018-06-05 07:09:52
    我的回答: 理论上能,实际应用中不能!! 不能的原因: ...1.枚举声明简单,使用简单...枚举虽然是 JDK1.5 增加的特性,但反编译之后,底层还是以继承Enum并且以常量的方式实现.,也就是说,枚举只不过是一个...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 712,780
精华内容 285,112
关键字:

常量类