精华内容
下载资源
问答
  • 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;
       }
    }
    
    
    展开全文
  • Java常量类的几种实现方式

    千次阅读 2020-11-27 17:52:05
    实现常量的三种方式接口常量直接在接口中定义常量接口中定义静态内部类常量类枚举类枚举类列举常量在类里面创建枚举类 接口常量 直接在接口中定义常量 public interface Constants { /** * 中心 */ public ...

    接口常量

    直接在接口中定义常量

    public interface Constants {
    
            /** 
             * 中心
             */
            public static final int CENTER = 0;
    
            /** 
             * 顶部
             */
            public static final int TOP = 1;
            /** 
             * 左边
             */
            public static final int LEFT = 2;
           
           //。。。省略其他代码
       }
    

    接口中定义静态内部类

    public interface Constants {
    
           /**
         * 
         * 公共常量
         *
         */
        public static class Public {
            public static final String ID = "TESTID";
        }
        
        /**
         * 颜色类型
         */
        public static class ColorType {
            public static final String RED = "red"; 
            public static final String GREEN = "green"; 
        }
           
           //。。。省略其他代码
       }
    

    不能在接口中定义静态代码快。

    常量类

    public class ResponseCode {
    
        /** 系统处理正常 */
        public static final int SUCCESS_HEAD = 0;
    
        /** 系统处理未知异常 */
        public static final int EXCEPTION_HEAD = 1;
    
        /** JSON解析错误 */
        public static final int JSON_RESOLVE = 2;
    
        /** 类型不匹配 */
        public static final int TRANSTYPE_NO = 3;
    
        /** Head - messageID未赋值 */
        public static final int HEAD_messageID = 4;
    
        /** Head - timeStamp未赋值 */
        public static final int HEAD_timeStamp = 5;
    
        /** Head - messengerID未赋值 */
        public static final int HEAD_messengerID = 6;
    
        /** Head - transactionType 未赋值 */
        public static final int HEAD_transactionType = 7;
    
        /** digest校验不通过 */
        public static final int HEAD_DIGEST = 8;
        
        /** src校验不通过 */
        public static final int HEAD_SRC_NULL = 10;
        
        /** 协议包含非法字符 */
        public static final int ILLEGAL_MESSAGE = 11;
    
        /** 数据库异常 */
        public static final int DATABASE_EXCEPTION = 9;
        public static final Map<Integer, String> RESP_INFO = new HashMap<Integer, String>();
    
        static {
            // Head 相关
            RESP_INFO.put(SUCCESS_HEAD, "系统处理正常");
            RESP_INFO.put(EXCEPTION_HEAD, "系统处理未知异常");
            RESP_INFO.put(JSON_RESOLVE, "JSON解析错误");
            RESP_INFO.put(TRANSTYPE_NO, "类型不匹配");
            RESP_INFO.put(HEAD_messageID, "messageID未赋值");
            RESP_INFO.put(HEAD_timeStamp, "timeStamp未赋值");
            RESP_INFO.put(HEAD_messengerID, "messengerID未赋值");
            RESP_INFO.put(HEAD_transactionType, "transactionType未赋值");
            RESP_INFO.put(HEAD_DIGEST, "digest校验不通过");
            RESP_INFO.put(DATABASE_EXCEPTION, "数据库异常");
            RESP_INFO.put(HEAD_SRC_NULL, "src未赋值");
            RESP_INFO.put(ILLEGAL_MESSAGE, "协议包含非法字符");
            
        }
    }
    

    这种方法可以在类里面定义静态代码快。

    枚举类

    枚举类列举常量

    ublic enum Size {
        SMALL("S"),
        MEDIUM("M"),
        LARGE("L"),
        EXTRA_LARGE("XL");
    }
    

    在类里面创建枚举类

    public class Constants {
    
        /**
         * 订单状态
         */
        public static enum OrderStats{
            
            DELETE(0,"删除"),RESERVE(1,"订单预定"),CONFIRM(2,"订单确认"),COMPLETE(3,"订单完成"),CLOSE(4,"订单关闭");
            
            private final Integer value;
            private final String name;
            
            private OrderStats(Integer value,String name){
                this.value = value;
                this.name = name;
            }
            
            public Integer getValue() {
                return value;
            }
    
            public String getName() {
                return name;
            }
            
        }
        /**
         * 性别
         * <p>Company:rayootech</p>
         * @author zhangxueshen
         * @date 2016-6-14
         */
        public static enum sex{
            
            MAN("1","男"),FEMAN("2","女");
            
            private sex(String value,String name){
                this.value = value;
                this.name = name;
            }
            private final String value;
            private final String name;
            
            public String getValue() {
                return value;
            }
    
            public String getName() {
                return name;
            }
            
        }
    }
    

    这种方式可以将很多的字典枚举放到同一个类里面。推荐使用这种方式

    展开全文
  • java类中定义常量的三中方法

    千次阅读 2018-07-15 00:00:16
    主要讲解如何在java类中定义常量:/** * Method One */ interface ConstantInterface { String SUNDAY = "SUNDAY"; String MONDAY = "MONDAY"; String TUESDAY = "TUESDAY"; ...

    主要讲解如何在java类中定义常量:

    /**
     * Method One
     */
    interface ConstantInterface {
        String SUNDAY = "SUNDAY";
        String MONDAY = "MONDAY";
        String TUESDAY = "TUESDAY";
        String WEDNESDAY = "WEDNESDAY";
        String THURSDAY = "THURSDAY";
        String FRIDAY = "FRIDAY";
        String SATURDAY = "SATURDAY";
    }
    /**
     * Method Two 
     */
    enum ConstantEnum {
        SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY
    }
    /**
     * Method Three
     */
    class ConstantClassField {
        public static final String SUNDAY = "SUNDAY";
        public static final String MONDAY = "MONDAY";
        public static final String TUESDAY = "TUESDAY";
        public static final String WEDNESDAY = "WEDNESDAY";
        public static final String THURSDAY = "THURSDAY";
        public static final String FRIDAY = "FRIDAY";
        public static final String SATURDAY = "SATURDAY";
    }
    /**
     * Method Four
     * http://www.ibm.com/developerworks/cn/<a href="http://lib.csdn.net/base/17" class='replace_word' title="Java EE知识库" target='_blank' style='color:#df3434; font-weight:bold;'>Java</a>/l-java-interface/index.html
     */
    class ConstantClassFunction {
        private static final String SUNDAY = "SUNDAY";
        private static final String MONDAY = "MONDAY";
        private static final String TUESDAY = "TUESDAY";
        private static final String WEDNESDAY = "WEDNESDAY";
        private static final String THURSDAY = "THURSDAY";
        private static final String FRIDAY = "FRIDAY";
        private static final String SATURDAY = "SATURDAY";
        public static String getSunday() {
            return SUNDAY;
        }
        public static String getMonday() {
            return MONDAY;
        }
        public static String getTuesday() {
            return TUESDAY;
        }
        public static String getWednesday() {
            return WEDNESDAY;
        }
        public static String getThursday() {
            return THURSDAY;
        }
        public static String getFirday() {
            return FRIDAY;
        }
        public static String getSaturday() {
            return SATURDAY;
        }
    }
    public class TestConstant {
        static final String day = "saturday";
        public static void main(String[] args) {
            System.out.println("Is today Saturday?");
            System.out.println(day.equalsIgnoreCase(ConstantInterface.SATURDAY));
            System.out.println(day.equalsIgnoreCase(ConstantEnum.SATURDAY.name()));
            System.out.println(day.equalsIgnoreCase(ConstantClassField.SATURDAY));
            System.out.println(day.equalsIgnoreCase(ConstantClassFunction
                    .getSaturday()));
        }
    }
    参考文章: https://www.cnblogs.com/DreamDrive/p/5413255.html
    展开全文
  • 1、接口定义常量 public interface Constants{ public String USER_NAME = "WPO1462"; public String SECRET_ID = "wx_25sdl586sam02...2、常量类 public final class Constans{ public static final String...

    1、接口定义常量

    public interface Constants{
        public String USER_NAME = "WPO1462";
        public String SECRET_ID = "wx_25sdl586sam02";
    }

    2、常量类

    public final class Constans{
        public static final String USER_NAME = "WPO1462";
        public static final String SECRET_ID = "wx_25sdl586sam02";
    }

    3、枚举

    public enum Constans{
        public enum reportStatus(){
            已报工,未报工;
        }
    	
        public enum productType(){
            常规(0),返工(1),样品(2);
    		
            private Integer value;
    		
    		productType(Integer value){
                this.value = value;
            }
    
            public Integer getValue() {
                return value;
            }
    
            public static String getNameByValue(Integer value){
                for (productType one : productType.values()) {
                    if(value.equals(one.value)){
                        return one.name();
                    }
                }
                return null;
            }
        }
    	
        public enum equipmentType(){
            press(0,"压机"),mold(1,"模具"),kiln(2,"烧结窑");
        }
    }
    public static void main(String[] args) {
    	//将字符串转为枚举
    	System.out.println(EnumModel.productType.valueOf("样品").getValue());
    	System.out.println(EnumModel.productType.getNameByValue(1));
    	//获取枚举的顺序
    	System.out.println(EnumModel.productType.valueOf("样品").ordinal());
    }

    展开全文
  • 1)枚举型可以直接与数据库打交道,我通常使用varchar类型存储,对应的是枚举的常量名。(数据库中好像也有枚举类型,不过也没用过)  2) switch语句支持枚举型,当switch使用int、String类型时,由于值的不稳定性...
  • 有用常量类的、有用接口的、有用枚举的,因此本文针对于常量的管理做一些讨论 2、栗子 第一种使用接口: public interface Constants{ int AUDIT_STATUS_PASS = 1; int AUDIT_STATUS_NOT_PASS = 2; } 第二.....
  • Java基础知识面试题(2020最新版)

    万次阅读 多人点赞 2020-02-19 12:11:27
    文章目录Java概述何为编程什么是Javajdk1.5之后的三大版本JVM、JRE和JDK的关系什么是跨平台性?原理是什么Java语言有哪些特点什么是字节码?采用字节码的最大好处是什么什么是Java程序的主类?应用程序和小程序的...
  • 最近在看一本书 Java与模式,里面提了一句不建议使用常量接口,甚至举了个java源码的反例,...常量类应该是final,不变的,而接口里的参数是final,也是不变的。 那么,看起来接口是放常量没有一定问题,还省去了fi...
  • java枚举与常量类的区别

    万次阅读 2016-12-19 11:06:02
    如果常量类的构造器不私有,无法限制开发员继承/实现接口,开发员能够在子接口里继续添加常量.而这些常量可能得不到祖先层的支持。 枚举常量类 public class Constant { private String name; ...
  • 常量池存在于字节码文件中, 也就是.class文件. 要注意的是, 常量池并不在内存中, 而是字节码文件的一段内容 常量池中主要存放两大类常量: 字面量(Literal)和符号引用(Symbolic References) 字面量比较接近于...
  • * @Description java中定义常量的最佳方法 */ public final class Contants{ /** * @Description 私有化构造方法 */ private Contants(){}; public static final int contants1 = 1&...
  • 转载来源:最近在熟悉小组的代码时看见常量声明的不同方式就看了看这几种方式的不同之处。。 来源:https://segmentfault.com/q/1010000007620581?_ea=1406439 第一种使用接口: public interface Constants{ ...
  • public class FieldReflactTest{ public static final String a="test"; protected int b; private int c; String d; public static void main(String[] args){ Field[] fields=FieldReflactTest.class....
  • Java常量写到接口中还是

    千次阅读 2017-05-29 14:42:45
    最近发现我们公司的项目常量往往被写到了接口中,这让我很郁闷,于是就百度了下,最终的结果是建议写到class中 具体原因引用大牛的说法吧 ...
  • 《Effective Java》第19条:接口只用于定义类型 当实现接口时,接口就充当可以引用这个的实例的类型(type)。因此,实现了接口,就表明客户端可以对这个的实例实施某些动作(接口中定义的方法)。为了任何...
  • Java 使用枚举定义常量

    千次阅读 2020-02-10 10:07:22
    枚举比较常用的场景就是用于常量的定义,但是相比于使用“static final”,枚举类型会增加内存的消耗,这个就是枚举的缺点,但是对于目前的硬件来说,这点还是可以忽略的。 使用枚举定义常量 packa...
  • 关于整数常量池: 测试代码: public class Test06 { public static void main(String[] args) { //我们再来看一段很有意思的代码,猜想一下为什么 Integer a1 = 127; Integer a2 = 127; System.out.println(a1...
  • 用内部定义java常量

    千次阅读 2013-03-06 16:06:12
    public class DataServiceConstant { /** * 数据推送类型 * * */ public static final class PushDataType{ /** * 附件 */ public static final String DATA_FILE = "file... * 列表
  • 如何在Java中定义常量

    千次阅读 2020-03-11 10:30:28
    我还遇到了在它们自己的接口中定义的常量–其中使用常量必须实现接口。此策略通常称为接口常量设计模式。 在本文中,我们将查看在Java中存储常量的两种最常见的策略:整数和枚举。 首先,无论何时决定使用常量,...
  • Java面试题大全(2020版)

    万次阅读 多人点赞 2019-11-26 11:59:06
    发现网上很多Java面试题都没有答案,所以花了很长时间搜集整理出来了这套Java面试题大全,希望对大家有帮助哈~ 本套Java面试题大全,全的不能再全,哈哈~ 一、Java 基础 1. JDK 和 JRE 有什么区别? JDK: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 ...
  • java中的常量与变量

    千次阅读 2019-04-27 12:21:05
    常量 常量:在程序运行期间,固定不变的量。 常量的分类: 1.字符串常量:凡是用双引号引起来的部分,叫做字符串常量。例如:“abc”、“Hello”、“123”。 2.整数常量:直接写上数字,没有小数点。例如:100,...
  • 我看到java中有.常量,那么有对象.常量吗 这里的常量的本质应该是一个对象吧
  • Java是一种强类型语言,每一个变量都必须声明其类型 Java变量是程序中最基本的储存单元,其要素包括变量名,变量类型,和作用域 注意: 每个变量都有类型,类型可以是基本类型,也可以是引用类型 变量名必须是...
  • 修改一个常量类中的静态常量值,然后把常量类的class文件上传到服务器后并没有生效,多次重启服务,最后查询了相关资料,使用GUI反编译工具反编译查看编译后源码,终于找到问题所在: 单纯的修改静态常量是没用的,...
  • 这几天在看Java虚拟机方面的知识时,看到了有几种不同常量池的说法,然后我就去CSDN、博客园等上找资料,里面说的内容真是百花齐放,各自争艳,因此,我好好整理了一下,将我自认为对的理解写下来与大家共同探讨: ...
  • java - 使用其他定义的常量

    千次阅读 2018-09-28 11:40:59
    java-cm中看到使用了魔法数,发现这些魔法数是其他定义的常量. 重构代码,将这些魔法数,更新为其他常量定义。 如果是c++,是使用域作用符. e.g. class_A::MY_CONST 在java中,没有域作用符, 用的是’.'...
  • Java中定义常量的几种方法

    千次阅读 2019-05-02 14:52:43
    Class定义常量方法(推荐方法) //final修饰符 public final class Constants { //私有构造方法 private Constants() {} public static final int ConstantA = 100; public static final int ConstantB = 100...
  • 转自:... 在mybatis的映射xml文件调用java类的方法: 1. SELECT * FROM EC_CORE_USER WHERE (user_name=#{userName} or mail =#{userName} or mobile_phon...
  • java的内存分配中,经常听到很多关于常量池的描述,我开始看的时候也是看的很模糊,网上五花八门的说法简直太多了,最后查阅各种资料,终于算是差不多理清了,很多网上说法都有问题,笔者尝试着来区分一下这几个...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 149,127
精华内容 59,650
关键字:

java类里面的常量

java 订阅