精华内容
下载资源
问答
  • 如果后台一般使用可以使用枚举里面自定义静态方法,当然一般情况下使用不到,如果需要最好各自将需用枚举类里面自定义方法使用。保证一定效率性。如果不想使用反射小伙伴,可将所有状态类加入一个枚举类;也...

    枚举作为常量类使用多种方式、前后端分离使用;为了前端 统一调用,特别使用了接口以及枚举反射,将枚举工具类作为标签开放于前端;保证多个枚举常量类,不用建立一个枚举类处理。

    如果后台一般使用可以使用枚举里面自定义静态方法,当然一般情况下使用不到,如果需要最好各自将需用的枚举类里面自定义方法使用。保证一定的效率性。

    如果不想使用反射的小伙伴,可将所有的状态类加入一个枚举类;也可使用多个枚举类;将枚举类作为标签提供于前端使用。

    /*

    * @Description TODO 枚举接口类

    * @return

    * @Date 2020/6/3 10:59

    * @Author yangtao

    */

    public interface IStatusEnum {

    Object getValue();

    int getIntValue();

    String getDesc();

    Object getType();

    }

    /**

    * @ClassName OrderStatus

    * @Description 订单相关状态枚举

    * @Author yangtao

    * @Date 2020/5/28 14:58

    * @Version V1.0

    **/

    public enum OrderStatus implements IStatusEnum{

    //订单状态

    Status,

    Status0(0,"待付款",Status),

    Status1(1,"待发货",Status),

    Status2(2,"待收货",Status),

    private Object value;//值

    private String desc;//描述

    private OrderStatus type;//类型

    OrderStatus() {

    }

    OrderStatus(Object value, String desc, OrderStatus type) {

    this.value = value;

    this.desc = desc;

    this.type = type;

    }

    public String getDesc() {

    return desc;

    }

    public Object getValue() {

    return value;

    }

    public int getIntValue() {

    return Integer.parseInt(value.toString());

    }

    public String getStrValue() {

    return value.toString();

    }

    public OrderStatus getType() {

    return type;

    }

    /*

    * @Description TODO 根据枚举常量类型 获取枚举值集合

    * @param typeName 枚举类型名称

    * @return java.util.Map

    * @Date 2020/6/3 11:09

    * @Author yangtao

    */

    public static Map findEnumList(OrderStatus type) {

    Map map = new HashMap<>();

    for (OrderStatus ts : OrderStatus.values()) {

    if (type.equals(ts.getType())) {

    map.put(ts.getValue().toString(), ts.getDesc());

    }

    }

    //第二种使用EnumSet

    // EnumSet currEnumSet = EnumSet.allOf(OrderStatus.class);

    // for (OrderStatus ts : currEnumSet) {

    // if (type.equals(ts.getType())) {

    // map.put(ts.getValue().toString(), ts.getDesc());

    // }

    // }

    return map;

    }

    /*

    * @Description TODO 根据类型和值获取描述

    * @param type 类型

    * @param value 值

    * @return String

    * @Date 2020/6/3 14:01

    * @Author yangtao

    */

    public static String findEnumDescByValue(OrderStatus type, Object value){

    String desc = "";

    for (OrderStatus ts : OrderStatus.values()) {

    if(type.equals(ts.getType())&&ts.getValue().toString().equals(value.toString())){

    desc = ts.getDesc();

    break;

    }

    }

    return desc;

    }

    }

    import java.lang.annotation.RetentionPolicy;

    import java.lang.reflect.Method;

    import java.util.HashMap;

    import java.util.Map;

    /*

    * @Description TODO 订单相关状态静态工具类

    * @return

    * @Date 2020/5/28 15:27

    * @Author yangtao

    */

    public class StatusEnumUtil {

    private static final String packageName = "com.enums.";

    /*

    * @Description TODO 反射获取枚举接口

    * @param className 枚举名称

    * @return IStatusEnum[]

    * @Date 2020/6/3 11:04

    * @Author yangtao

    */

    private static IStatusEnum[] getEnumValues(String className){

    try {

    //这里的typeName就是枚举对象的名称,是需要写全路径的,注意小数点别少写了

    Class> c = Class.forName(packageName+ className);

    //Class.getEnumConstants() 返回类中声明的枚举实例 即:枚举对象.values();

    return (IStatusEnum[]) c.getEnumConstants();

    //第二种通过method获得枚举的遍历方法 即:枚举对象.values()

    // Method method = c.getMethod("values");

    // return (IStatusEnum[]) method.invoke(null);

    } catch (Exception e) {

    e.printStackTrace();

    System.out.println("枚举类不存在");

    }

    return null;

    }

    /*

    * @Description TODO 根据枚举常量类型 获取枚举值集合

    * @param className 枚举类名

    * @param typeName 枚举类型名称

    * @return java.util.Map

    * @Date 2020/6/3 11:09

    * @Author yangtao

    */

    public static Map findEnumList(String className,String typeName) {

    Map map = new HashMap<>();

    IStatusEnum inter[] = getEnumValues(className);

    if(inter!=null && inter.length>0){

    for (IStatusEnum o : inter) {

    if(o.getType()!=null && typeName.equals(o.getType().toString())) {

    map.put(o.getValue(), o.getDesc());

    System.out.println(o.getDesc()+o.getValue()+o.getType());

    }

    }

    }

    return map;

    }

    /*

    * @Description TODO 根据枚举常量类型和枚举值 获取描述

    * @param className 枚举类名

    * @param typeName 枚举类型名称

    * @param value 枚举值

    * @Date 2020/6/3 11:16

    * @Author yangtao

    */

    public static String findEnumDescByValue(String className,String typeName,Object value){

    String desc = "";

    IStatusEnum inter[] = getEnumValues(className);

    if(inter!=null && inter.length>0 && typeName!=null && value!=null){

    for (IStatusEnum o : inter) {

    if(o.getType()!=null && typeName.equals(o.getType().toString())) {

    if(value.toString().equals(o.getValue().toString())) {

    desc = o.getDesc();

    }

    }

    }

    }

    return desc;

    }

    public static void main(String[] args) {

    findEnumList("OrderStatus","Status");

    System.out.println(findEnumDescByValue("OrderStatus","Status",3));

    // OrderStatus.findEnumList(OrderStatus.Status);

    // System.out.println(OrderStatus.findEnumDescByValue(OrderStatus.Status,3));

    }

    }

    展开全文
  • Java常量的分类

    2019-12-16 20:13:20
    c:字符串常量:必须使用英文双引号括起来内容(重点:英文双引号,在输入法里面可以设置) 举例: “helloword”,“100”,… d:字符常量:必须使用单引号括起来单个内容(注意) 举例:‘A’,‘a’,‘0’… e:布尔常量:...

    常量的分类:
    A:字面值常量:
    a:整数常量;
    举例:100 ,1000, 11,-2,…
    b:小数常量:
    举例:3.14,-1.50…
    c:字符串常量:必须使用英文双引号括起来的内容(重点:英文双引号,在输入法里面可以设置)
    举例: “helloword”,“100”,“1111”…
    d:字符常量:必须使用单引号括起来的单个内容(注意)
    举例:‘A’,‘a’,‘0’…
    e:布尔常量:只用true和false
    举例:下面用代码演示
    f: 空常量:(属于引用数据类型,数组中引用)

        B:自定义常量(在面向对象中有这里先说说基础的)
    

    class Constant{
    public static void main(String[] args){
    //整数常量
    System.out.println(100);
    System.out.println(-10);
    System.out.println("---------------");
    //小数常量
    System.out.println(-1.50);
    System.out.println(3.1415926);
    System.out.println("------");
    //字符串常量
    System.out.println(“111”);
    System.out.println("-------------");
    //字符常量
    System.out.println(‘A’);
    System.out.println(‘a’);
    System.out.println("-----------");
    //布尔常量
    System.out.println(true);
    System.out.println(false);
    System.out.println("----------");
    //空常量(引用数据类型,在数组那块详细解释)
    }
    }

    展开全文
  • 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编程基础——常量变量和数据类型摘要:本文介绍了Java编程语言的常量变量和数据类型。常量变量常量的定义一块内存中的数据存储空间,里面的数据不可以更改。变量的定义一块内存中的数据存储空间,因为里面的数据...

    Java编程基础——常量变量和数据类型

    摘要:本文介绍了Java编程语言的常量变量和数据类型。

    常量变量

    常量的定义

    一块内存中的数据存储空间,里面的数据不可以更改。

    变量的定义

    一块内存中的数据存储空间,因为里面的数据可以更改,所以称为变量。

    变量的分类

    局部变量:方法或语句块内部定义的变量,作用域是当前方法或当前语句块,需要在初始化时赋值,存在占内存中。

    成员变量:方法外部或类的内部定义的变量,作用域是整个类,有默认值,存在堆内存中。

    数据类型

    说明

    Java语言是一种强类型语言。通俗点说,在Java中存储的数据都是有类型的,而且必须在编译时就确定其类型。

    基本类型变量:保存原始值,它代表的值就是数值本身。通过值传递进行赋值。

    引用类型变量:保存引用值,指向内存空间的地址,代表了某个对象的引用,对象本身存放在这个引用值所表示的地址的位置。通过引用传递进行赋值。

    7f32eb241877ff3672f46f5be6f474d6.png

    基本数据类型

    0f6b1474aa1b7a1fa17e8c902a665149.png

    布尔型

    boolean数据类型表示1位的信息,只有true和false两个取值,这种类型只作为一种标志来记录true/false情况。

    默认值是false。

    字符型

    char类型是一个单一的16位Unicode字符,单引号括起来的单个字符表达,通常用16进制表示。

    最小值是’\u0000’(即为0),最大值是’\uffff’(即为65,535)。可以当整数来用,它的每一个字符都对应一个数字。

    字符常量指用单引号括起来的单个字符,如'a','A',请特别注意,字符的定界符是单引号,而非双引号。

    除了以上所述形式的字符常量值之外,Java还允许使用一种特殊形式的字符常量值,这通常用于表示难以用一般字符来表示的字符,这种特殊形式的字符是以一个“\”开头的字符序列,称为转义字符。

    Java中的常用转义字符见下图:

    6cf39661da92985f9f9a2ed9b0ce8ecc.png

    整数类型

    byte

    byte数据类型是8位的有符号的以二进制补码表示的整数,占1字节。

    最小值是-128(-2^7),最大值是127(2^7-1),默认值是0。

    short

    short数据类型是16位的有符号的以二进制补码表示的整数,占2字节。

    最小值是-32768(-2^15),最大值是32767(2^15-1),默认值是0。

    int

    int数据类型是32位的有符号的以二进制补码表示的整数,占3字节。

    最小值是-2,147,483,648(-2^31),最大值是2,147,485,647(2^31-1),默认值是0。

    long

    long数据类型是64位的有符号的以二进制补码表示的整数,占4字节。

    最小值是-9,223,372,036,854,775,808(-2^63),最大值是9,223,372,036,854,775,807(2^63-1),默认值是0L。

    浮点类型

    float

    float数据类型是32位的单精度的符合IEEE 754标准的浮点数,占4字节。

    默认值是0.0F。

    double

    double数据类型是64位的双精度的符合IEEE 754标准的浮点数,占8字节。

    默认值是0.0D,浮点数的默认类型为double类型。

    数据类型转换

    字符型、整形、浮点型的数据在混合运算中相互转换,遵循以下规则:

    ◆ boolean类型不可以转换为其他的数据类型。

    ◆ 容量小的类型自动转换为容量大的类型,顺序为:

    byte/short/char→int→long→float→double

    byte/short/char之间不会相互转换,他们在计算时会首先转为int类型。

    ◆ 容量大的数据类型转为容量小的数据类型时,要加上强制转换符,但可能造成精度降低或溢出。

    ◆ 有多种类型的数据类型混合运算时,首先自动将所有的数据转换成容量最大的数据类型,然后在进行计算。

    展开全文
  • if(state==1){//1代表未操作//操作}else{//......}将状态标识直接写在代码里面(硬编码),只图一时方便,却是后患无穷,如果有一天你需要修改状态标识,用0代表未审核而不是1,你不得不将所有与该标识相关代码都找...
  • 那么我们在Java接口中怎样访问定义的常量呢?今天我们就来学习一个这个访问方法,详细请参考下文。一、定义变量一般情况下,我们在Java中进行定义常量时,通常可以将常量定义在接口里面去。为了方便大家的理解,小编...
  • Java中常量池在java中用于保存编译期已经确定的,它包括了关于,方法,接口中的常量,也包括字符串常量。例如 String s = “Java” 这种声明的方式。产生的这种"常量"就会被放到常量池,常量池是JVM的一块特殊的...
  • 下面要给大家带来java枚举类型与常量的相关内容,一起来看看,如何使用枚举类型设置常量吧!枚举类型能够取代之前常量的定义方式。也就是说,将常量封装在或者是接口当中,除此之外,枚举类型还提供了安全检查...
  • "> java类的static块会在java类被加载时候执行,java会在使用到一个用户定义类时候才动态加载它,这两句话对吧?</span></span>   <p><span style="font-size: medium;">;"> 我定义了一个类如下</span></...
  • 02.01_Java语言基础(常量的概述和使用)(掌握) A:什么是常量 在程序执行过程中其值不可以发生改变 B:Java常量的分类 ...字符常量 用单引号括起来内容,里面只能放单个数字,单个字母或单个符号 布尔常量
  • Java常量类静态变量值修改需要注意事项作为一名Java的搬砖工,一般项目工程都会使用到Constants.java作为常量工具类,喜欢在常量类里面定义各种静态内部类,使用各种静态变量,如:public class Constants{...
  • Java中几种常量区分 1、(全局)字符串常量池(String Pool) 在加载过程中,经过验证、准备阶段后: 在堆中生成字符串对象实例 将该字符串对象实例引用值存到String Pool中 在HotSpot VM里实现String ...
  • java常量池_java 常量

    2021-02-12 09:25:40
    首先,我们简单了解一下运行时数据区,这里是java虚拟机运行程序时的内存区域。有方法区,堆,虚拟机栈,本地方法栈,程序计数器。...在class文件中就存有常量池的信息,运行时就把class文件里面的常理池...
  • Java的常量

    2020-11-15 21:06:30
    Java中有三个常量池:字符串常量池、运行时常量池、class常量池 一、常量定义 ... 在 HotSpot VM 里实现 string pool 功能是一个 StringTable ,它是一个哈希表,里面是驻留字符串 (也就是我们常
  • Java的常量池分为两种型态:静态常量池运行时常量池静态常量池所谓静态常量池是指class文件中的常量池,存在于文件中而非内存里面,包括字面量和符号引用量。字面量:是Java语言层面的常量的概念,比如字符串和...
  • ###02.01_Java语言基础(常量的概述和使用)(掌握) * A:什么是常量 * 在程序执行过程中其值不可以发生改变  * B:Java常量的分类 ...* 字符常量 用单引号括起来内容,里面只能放单个数字,单个字母或单个符号 *...
  • 上一篇文章《Java虚拟机原理图解》 1、class文件基本组织结构中已经提到了class文件结构,在class文件里魔数、副版本号号、主版本号之后,紧接着就是常量数据区域了,例如以下图用红线包含位置:知道...
  • java实现字节码解析1(常量解析) 大体思路就是按照之前写那篇字节码解析里面所描述方式。 https://blog.csdn.net/qq_43147121/article/details/108035464 这里面有几个要我们用到位运算来处理基本类型...
  • java的常量介绍

    2020-10-20 08:28:30
    /*常量:在程序运行期间,固定不变量。 常量的分类: 1.字符串常量:凡是用双引号引起来部分,叫做字符串常量。...但要记住字符常量里面只能有一个,就是单个字符。 5.布尔常量:只有量中取值:true、false。
  • 上一篇文章《Java虚拟机原理图解》 1、class文件基本组织结构中已经提到了class文件结构,在class文件中魔数、副版本号、主版本之后,紧接着就是常量数据区域了,如下图用红线包括位置:知道了常量池...
  • 最近在看一本书 Java与模式,里面提了一句不建议使用常量接口,甚至举了个java源码反例, 蛋疼是没有说为什么? 查了网上一圈发现他们也是知道怎么做而不知道为什么这么做。 然后我只能找谷歌了,翻译后...
  • 那么我们在Java接口中怎样访问定义的常量呢?今天我们就来学习一个这个访问方法,详细请参考下文。一、定义变量一般情况下,我们在Java中进行定义常量时,通常可以将常量定义在接口里面去。为了方便大家的理解,小编...
  • 2.java 常量的分类 字面值常量 自定义常量 3.字面值常量的分类 A;字符串常量 用双引号括起来内容 B; 整数常量 所有整数 C; 小数常量 所有小数 D; 字符常量 用单引号 括起来内容,里面只能放单个数字,单个...
  • java方法区和常量

    千次阅读 2018-07-04 17:55:11
     class文件中除了包含类的版本,类名,字段,方法,接口等信息,还包含了常量池,这里面存放了编译期产生各种 字面量以及符号引用,在加载后进入方法区运行时常量池中,运行时常量池相对于class常...
  • 摘要:本文介绍了Java编程语言的常量变量和数据类型。 常量变量 常量的定义 一块内存中的数据存储空间,里面的数据不可以更改。 变量的定义 一块内存中的数据存储空间,因为里面的数据可以更改,所以称为变量。...
  • 在程序执行过程中其值不可以发生改变java常量的分类字面量常量自定义常量字面值常量的分类字面值常量的分类 字符串常量 用双引号括起来内容 整数常量 所有整数 小数常量 所有小数 字符常量 用单引号括...
  • 如果定义类的时候没有使用package(包),那么java就认为我们所定义的类位于默认包里面(default package) 2. 首字母大写,如果一个由多个单词构成,那么每个单词首字母都大写,而且中间不使用任何连接符...
  • 这几天在看Java虚拟机方面知识时,看到了有几种不同常量说法,然后我就去CSDN、博客园等上找资料,里面内容真是百花齐放,各自争艳,因此,我好好整理了一下,将我自认为对理解写下来与大家共同探讨: ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,345
精华内容 538
关键字:

java类里面的常量

java 订阅