「java中的魔术常量」在java方法中定义一个常量

本篇文章给大家谈谈java中的魔术常量，以及在java方法中定义一个常量对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。

本文目录一览：

• 1、什么是常量？Java中，常量的定义规则有哪些？
• 2、enum在java中是什么意思
• 3、JAVA中的常量是指什么？
• 4、高分求解:JAVA中***hides a field警告怎么处理?
• 5、Java语言中的常量，变量，数据类型等都代表什么意思

什么是常量？Java中，常量的定义规则有哪些？

一、常量定义的基本注意事项。

在Java语言中，主要是利用final关键字（在Java类中灵活使用Static关键字）来定义常量。当常量被设定后，一般情况下就不允许再进行更改。如可以利用如下的形式来定义一个常量：final double PI=3.1315。在定义这个常量时，需要注意如下内容：

一是常量在定义的时候，就需要对常量进行初始化。也就是说，必须要在常量声明时对其进行初始化。都跟局部变量或者成员变量不同。当在常量定义的时候初始化过后，在应用程序中就无法再次对这个常量进行赋值。如果强行赋值的话，数据库会跳出错误信息，并拒绝接受这一个新的值。（接口中定义的常量的访问方法）

二是final关键字使用的范围。这个final关键字不仅可以用来修饰基本数据类型的常量，还可以用来修饰对象的引用或者方法。如数组就是一个对象引用。为此可以使用final关键字来定义一个常量的数组。这就是Java语言中一个很大的特色。一旦一个数组对象被final关键字设置为常量数组之后，它只能够恒定的指向一个数组对象，无法将其改变指向另外一个对象，也无法更改数组（有序数组的插入方法可使用的二分查找算法）中的值。

三是需要注意常量的命名规则。不同的语言，在定义变量或者常量的时候，都有自己一套编码规则。这主要是为了提高代码的共享程度与提高代码的易读性。在Java语言中，定义常量的时候，也有自己的一套规则。如在给常量取名的时候，一般都用大写字符。在Java语言中，大小写字符是敏感的。之所以采用大写字符，主要是跟变量进行区分。虽然说给常量取名时采用小写字符，也不会有语法上的错误。但是，为了在编写代码时能够一目了然的判断变量与常量，最好还是能够将常量设置为大写字符。另外，在常量中，往往通过下划线来分隔不同的字符。而不想对象名或者类名那样，通过首字符大写的方式来进行分隔。这些规则虽然不是强制性的规则，但是为了提高代码友好性，方便开发团队中的其他成员阅读，这些规则还是需要遵守的。没有规矩，不成方圆。

总之，Java开发人员需要注意，被定义为final的常量需要采用大写字母命名，并且中间最好使用下划线作为分隔符来进行连接多个单词。在定义final的数据不论是常量、对象引用还是数组，在主函数中都不可以改变。否则的话，会被编辑器拒绝并提示错误信息。

二、Final关键字与static关键字同时使用。

由于Javal是面向对象的语言，所以在定义常量的时候还有与其它编程语言不同的地方。如一段程序代码从编辑到最后执行，即使需要经过两个过程，分别为代码的装载与对象的建立。不同的过程对于常量的影响是不同的。现在假设有如下的代码：

Private static Random rd1=new Random(); //实例化一个随机数生成对象。

Private final int int1=rd1.nestInt(10); //生成随机数并赋值给常量int1

Private static final int int2=rd1.nestInt(10); //生成随机数并赋值给常量int2

这上面的语句的大致含义是，通过Java语言提供的随机数类对象，生成随机数。并把生成的随机数赋值给常量int1与int2。细心的读者会发现，虽然同样是赋值语句，但是以上两个语句中有一个细小的差别，即在第二条语句中多了一个关键字static。关于关键字的用途，笔者在以前的文章中也有谈到过。这个是一个静态的概念。即当利用这个关键字来修饰一个变量的时候，在创建对象之前就会为这个变量在内存中创建一个存储空间。以后创建对对象如果需要用到这个静态变量，那么就会共享这一个变量的存储空间。也就是说，在创建对象的时候，如果用到这个变量，那么系统不会为其再分配一个存储空间，而只是将这个内存存储空间的地址赋值给他。如此做的好处就是可以让多个对象采用相同的初始变量。当需要改变多个对象中变量值的时候，只需要改变一次即可。从这个特性上来说，其跟常量的作用比较类似。不过其并不能够取代常量的作用。

那么以上两条语句有什么差别吗?我们首先来看Private final int int1=rd1.nestInt(10)这条语句。虽然int1也是一个常量，但是其是在对象建立的时候初始化的。如现在需要创建两个对象，那么需要对这个变量初始化两次。而在两次对象初始化的过程中，由于生成的随机数不同，所以常量初始化的值也不同。最后导致的结果就是，虽然int1是常量，但是在不同对象中，其值有可能是不同的。可见，定义为final的常量并不是恒定不变的。因为默认情况下，定义的常量是在对象建立的时候被初始化。如果在建立常量时，直接赋一个固定的值，而不是通过其他对象或者函数来赋值，那么这个常量的值就是恒定不变的，即在多个对象中值也使相同的。但是如果在给常量赋值的时候，采用的是一些函数或者对象(如生成随机数的Random对象)，那么每次建立对象时其给常量的初始化值就有可能不同。这往往是程序开发人员不原意看到的。有时候程序开发人员希望建立再多的对象，其在多个对象中引用常量的值都是相同的。

要是现这个需求的话，有两个方法。一是在给常量赋值的时候，直接赋予一个固定的值，如abcd等等。而不是一个会根据环境变化的函数或者对象。像生成随机数的对象，每次运行时其结果都有可能不能。利用这个对象来对常量进行初始化的时候，那么结果可能每次创建对象时这个结果都有可能不同。最后这个常量只能够做到在一个对象内是恒定不变的，而无法做到在一个应用程序内是恒定不变的。另外一个方法就是将关键字static与关键字final同时使用。一个被定义为final的对象引用或者常量只能够指向唯一的一个对象，不可以将他再指向其他对象。但是，正如上面举的一个随机数的例子，对象本身的内容的值是可以改变的。为了做到一个常量在一个应用程序内真的不被更改，就需要将常量声明为staitc final的常量。这是什么意思呢?正如上面笔者所说的，当执行一个应用程序的时候，可以分为两个步骤，分别为代码装载与对象创建。为了确保在所有情况下(即创建多个对象情况下)应用程序还能够得到一个相同值的常量，那么就最好告诉编译器，在代码装载的时候就初始化常量的值。然后在后续创建对象的时候，只引用这个常量对象的地址，而不对其再进行再次初始化。就如同Private static final int int2=rd1.nestInt(10)这种形式来定义常量。如此，在后续多次创建对象后，这个常量int2的值都是相同的。因为在创建对象时，其只是引用这个常量，而不会对这个常量再次进行初始化。

由于加上这个static关键字之后，相当于改变了常量的作用范围。为此程序开发人员需要了解自己的需求，然后选择是否需要使用这个关键字。在初始化常量的时候，如果采用函数(如系统当前时间)或者对象(如生成随机数的对象)来初始化常量，可以预见到在每次初始化这个常量时可能得到不同的值，就需要考虑是否要采用这个static关键字。一般情况下，如果只需要保证在对象内部采用这个常量的话，那么这个关键字就可有可无的。但是反过来，如果需要在多个对象中引用这个常量，并且需要其值相同，那么就必须要采用static这个关键字了。以确保不同对象中都只有一个常量的值。或者说，不同对象中引用的常量其实指向的是内存中的同一块区域。

enum在java中是什么意思

Enum 类型的介绍

枚举类型（Enumerated Type） 很早就出现在编程语言中，它被用来将一组类似的值包含到一种类型当中。而这种枚举类型的名称则会被定义成独一无二的类型描述符，在这一点上和常量的定义相似。不过相比较常量类型，枚举类型可以为申明的变量提供更大的取值范围。

举个例子来说明一下，如果希望为彩虹描绘出七种颜色，你可以在 Java 程序中通过常量定义方式来实现。

清单 1. 常量定义

Public static class RainbowColor { 

    // 红橙黄绿青蓝紫七种颜色的常量定义

    public static final int RED = 0; 

    public static final int ORANGE = 1; 

    public static final int YELLOW = 2; 

    public static final int GREEN = 3; 

    public static final int CYAN = 4; 

    public static final int BLUE = 5; 

    public static final int PURPLE = 6; 

 }

使用的时候，你可以在程序中直接引用这些常量。但是，这种方式还是存在着一些问题。

类型不安全

由于颜色常量的对应值是整数形，所以程序执行过程中很有可能给颜色变量传入一个任意的整数值，导致出现错误。

没有命名空间

由于颜色常量只是类的属性，当你使用的时候不得不通过类来访问。

一致性差

因为整形枚举属于编译期常量，所以编译过程完成后，所有客户端和服务器端引用的地方，会直接将整数值写入。这样，当你修改旧的枚举整数值后或者增加新的枚举值后，所有引用地方代码都需要重新编译，否则运行时刻就会出现错误。

类型无指意性

由于颜色枚举值仅仅是一些无任何含义的整数值，如果在运行期调试时候，你就会发现日志中有很多魔术数字，但除了程序员本身，其他人很难明白其奥秘。

如何定义 Enum 类型

为了改进 Java 语言在这方面的不足弥补缺陷，5.0 版本 SDK 发布时候，在语言层面上增加了枚举类型。枚举类型的定义也非常的简单，用 enum 关键字加上名称和大括号包含起来的枚举值体即可，例如上面提到的彩虹颜色就可以用新的 enum 方式来重新定义：

enum RainbowColor { RED, ORANGE, YELLOW, GREEN, CYAN, BLUE, PURPLE }

从上面的定义形式来看，似乎 Java 中的枚举类型很简单，但实际上 Java 语言规范赋予枚举类型的功能非常的强大，它不仅是简单地将整形数值转换成对象，而是将枚举类型定义转变成一个完整功能的类定义。这种类型定义的扩展允许开发者给枚举类型增加任何方法和属性，也可以实现任意的接口。另外，Java 平台也为 Enum 类型提供了高质量的实现，比如默认实现 Comparable 和 Serializable 接口，让开发者一般情况下不用关心这些细节。

回到本文的主题上来，引入枚举类型到底能够给我们开发带来什么样好处呢？一个最直接的益处就是扩大 switch 语句使用范围。5.0 之前，Java 中 switch 的值只能够是简单类型，比如 int、byte、short、char, 有了枚举类型之后，就可以使用对象了。这样一来，程序的控制选择就变得更加的方便，看下面的例子：

清单 2. 定义 Enum 类型

// 定义一周七天的枚举类型

 public enum WeekDayEnum { Mon, Tue, Wed, Thu, Fri, Sat, Sun } 

 // 读取当天的信息

 WeekDayEnum today = readToday(); 

 // 根据日期来选择进行活动

 switch(today) { 

  Mon: do something; break; 

  Tue: do something; break; 

  Wed: do something; break; 

  Thu: do something; break; 

  Fri: do something; break; 

  Sat: play sports game; break; 

  Sun: have a rest; break; 

 }

对于这些枚举的日期，JVM 都会在运行期构造成出一个简单的对象实例一一对应。这些对象都有唯一的 identity，类似整形数值一样，switch 语句就根据此来进行执行跳转。

如何定制 Enum 类型

除了以上这种最常见的枚举定义形式外，如果需要给枚举类型增加一些复杂功能，也可以通过类似 class 的定义来给枚举进行定制。比如要给 enum 类型增加属性，可以像下面这样定义：

清单 3. 定制枚举类型

// 定义 RSS(Really Simple Syndication) 种子的枚举类型

 public enum NewsRSSFeedEnum { 

    // 雅虎头条新闻 RSS 种子

    YAHOO_TOP_STORIES(""), 

    //CBS 头条新闻 RSS 种子

    CBS_TOP_STORIES(""), 

    // 洛杉矶时报头条新闻 RSS 种子

    LATIMES_TOP_STORIES(""); 

    // 枚举对象的 RSS 地址的属性

    private String rss_url; 

    // 枚举对象构造函数

    private NewsRSSFeedEnum(String rss) { 

        this.rss_url = rss; 

    } 

    // 枚举对象获取 RSS 地址的方法

    public String getRssURL() { 

        return this.rss_url; 

    } 

 }

上面头条新闻的枚举类型增加了一个 RSS 地址的属性 , 记录头条新闻的访问地址。同时，需要外部传入 RSS 访问地址的值，因而需要定义一个构造函数来初始化此属性。另外，还需要向外提供方法来读取 RSS 地址。

如何避免错误使用 Enum

不过在使用 Enum 时候有几个地方需要注意：

enum 类型不支持 public 和 protected 修饰符的构造方法，因此构造函数一定要是 private 或 friendly 的。也正因为如此，所以枚举对象是无法在程序中通过直接调用其构造方法来初始化的。

定义 enum 类型时候，如果是简单类型，那么最后一个枚举值后不用跟任何一个符号；但如果有定制方法，那么最后一个枚举值与后面代码要用分号';'隔开，不能用逗号或空格。

由于 enum 类型的值实际上是通过运行期构造出对象来表示的，所以在 cluster 环境下，每个虚拟机都会构造出一个同义的枚举对象。因而在做比较操作时候就需要注意，如果直接通过使用等号 ( ‘ == ’ ) 操作符，这些看似一样的枚举值一定不相等，因为这不是同一个对象实例。

看下面的这个例子：

清单 4. 避免错误使用 Enum 示例

// 定义一个一周七天的枚举类型

 package example.enumeration.codes; 

 public enum WeekDayEnum { 

    Mon(1), Tue(2), Wed(3), Thu(4), Fri(5), Sat(6), Sun(7); 

    private int index; 

    WeekDayEnum(int idx) { 

        this.index = idx; 

    } 

    public int getIndex() { 

        return index; 

    } 

 }

// 客户端程序，将一个枚举值通过网络传递给服务器端

 package example.enumeration.codes; 

 import java.io.IOException; 

 import java.io.ObjectOutputStream; 

 import java.io.OutputStream; 

 import java.net.InetSocketAddress; 

 import java.net.Socket; 

 import java.net.UnknownHostException; 

 public class EnumerationClient { 

    public static void main(String... args) throws UnknownHostException, IOException { 

        Socket socket = new Socket(); 

  // 建立到服务器端的连接

        socket.connect(new InetSocketAddress("127.0.0.1", 8999)); 

    // 从连接中得到输出流

        OutputStream os = socket.getOutputStream(); 

        ObjectOutputStream oos = new ObjectOutputStream(os); 

  // 将星期五这个枚举值传递给服务器端

        oos.writeObject(WeekDayEnum.Fri); 

        oos.close(); 

        os.close(); 

        socket.close(); 

    } 

 } 

 // 服务器端程序，将从客户端收到的枚举值应用到逻辑处理中

 package example.enumeration.codes; 

 import java.io.*; 

 import java.net.ServerSocket; 

 import java.net.Socket; 

 public class EnumerationServer { 

    public static void main(String... args) throws IOException, ClassNotFoundException { 

        ServerSocket server = new ServerSocket(8999); 

  // 建立服务器端的网络连接侦听

        Socket socket = server.accept(); 

  // 从连接中获取输入流

        InputStream is = socket.getInputStream(); 

        ObjectInputStream ois = new ObjectInputStream(is); 

  // 读出客户端传递来的枚举值

        WeekDayEnum day = (WeekDayEnum) ois.readObject(); 

  // 用值比较方式来对比枚举对象

        if (day == WeekDayEnum.Fri) { 

            System.out.println("client Friday enum value is same as server's"); 

        } else if (day.equals(WeekDayEnum.Fri)) { 

            System.out.println("client Friday enum value is equal to server's"); 

        } else { 

            System.out.println("client Friday enum value is not same as server's"); 

        } 

  // 用 switch 方式来比较枚举对象

        switch (day) { 

            case Mon: 

                System.out.println("Do Monday work"); 

                break; 

            case Tue: 

                System.out.println("Do Tuesday work"); 

                break; 

            case Wed: 

                System.out.println("Do Wednesday work"); 

                break; 

            case Thu: 

                System.out.println("Do Thursday work"); 

                break; 

            case Fri: 

                System.out.println("Do Friday work"); 

                break; 

            case Sat: 

                System.out.println("Do Saturday work"); 

                break; 

            case Sun: 

                System.out.println("Do Sunday work"); 

                break; 

            default: 

                System.out.println("I don't know which is day"); 

                break; 

        } 

        ois.close(); 

        is.close(); 

        socket.close(); 

    } 

 }

打印结果如下：

client Friday enum value is same as server's

Do Friday work

通过程序执行结果，我们能够发现在分布式条件下客户端和服务端的虚拟机上都生成了一个枚举对象，即使看起来一样的 Fri 枚举值，如果使用等号‘ == ’进行比较的话会出现不等的情况。而 switch 语句则是通过 equal 方法来比较枚举对象的值，因此当你的枚举对象较复杂时候，你就需要小心 override 与比较相关的方法，防止出现值比较方面的错误。

Enum 相关工具类

JDK5.0 中在增加 Enum 类的同时，也增加了两个工具类 EnumSet 和 EnumMap，这两个类都放在 java.util 包中。EnumSet 是一个针对枚举类型的高性能的 Set 接口实现。EnumSet 中装入的所有枚举对象都必须是同一种类型，在其内部，是通过 bit-vector 来实现，也就是通过一个 long 型数。EnumSet 支持在枚举类型的所有值的某个范围中进行迭代。回到上面日期枚举的例子上：

enum WeekDayEnum { Mon, Tue, Wed, Thu, Fri, Sat, Sun }

你能够在每周七天日期中进行迭代，EnumSet 类提供一个静态方法 range 让迭代很容易完成：

for(WeekDayEnum day : EnumSet.range(WeekDayEnum.Mon, WeekDayEnum.Fri)) { 

     System.out.println(day); 

 }

打印结果如下：

Mon 

 Tue 

 Wed 

 Thu 

 Fri

EnumSet 还提供了很多个类型安全的获取子集的 of 方法，使你很容易取得子集：

EnumSetWeekDayEnum subset = EnumSet.of(WeekDayEnum.Mon, WeekDayEnum.Wed); 

      for (WeekDayEnum day : subset) { 

          System.out.println(day);  

      }

打印结果如下：

Mon 

 Wed

与 EnumSet 类似，EnumMap 也是一个高性能的 Map 接口实现，用来管理使用枚举类型作为 keys 的映射表，内部是通过数组方式来实现。EnumMap 将丰富的和安全的 Map 接口与数组快速访问结合到一起，如果你希望要将一个枚举类型映射到一个值，你应该使用 EnumMap。看下面的例子：

清单 5. EnumMap 示例

// 定义一个 EnumMap 对象，映射表主键是日期枚举类型，值是颜色枚举类型

 private static MapWeekDayEnum, RainbowColor schema = 

            new EnumMapWeekDayEnum, RainbowColor(WeekDayEnum.class); 

 static{ 

    // 将一周的每一天与彩虹的某一种色彩映射起来

    for (int i = 0; i  WeekDayEnum.values().length; i++) { 

        schema.put(WeekDayEnum.values()[i], RainbowColor.values()[i]); 

    } 

 } 

 System.out.println("What is the lucky color today?"); 

 System.out.println("It's " + schema.get(WeekDayEnum.Sat));

当你询问周六的幸运色彩时候，会得到蓝色：

清单 6. 运行结果

What is the lucky color today?

It's BLUE

结束语

Enum 类型提出给 JAVA 编程带了了极大的便利，让程序的控制更加的容易，也不容易出现错误。所以在遇到需要控制程序流程时候，可以多想想是否可以利用 enum 来实现。

JAVA中的常量是指什么？

在Java语言中，主要是利用final关键字（在Java类中灵活使用final关键字）来定义常量。

Java的基本数据类型也叫做内置类型是java语言本身提供的数据类型，是引用其他类型的基础。Java的基本数据类型分为：整数类型、浮点类型、字符类型、布尔类型这四个类型。

final关键字使用的范围。这个final关键字不仅可以用来修饰基本数据类型的常量，还可以用来修饰对象的引用或者方法。

扩展资料

Java的基本数据类型分为：

1、整数类型

整数类型变量用来表示整数的数据类型。整数类型又分为字节型（byte）、短整型（short）、整型（int）、长整型（long）这四种。

2、浮点类型

浮点类型用来表示小数的数据类型。浮点类型分为float（单精度型）和double（双精度类型）这两种。float（单精度型）一般在精度要求不高的时候使用。double（双精度类型）一般在数值精度高的时候使用。

3、字符类型

字符类型的关键字是“char”。

4、布尔类型

布尔类型是表示逻辑值的基本数据类型。boolean常量有“真”和“假”这两个状态。一般用true表示“真”、false表示“假”。它的定义方法是在变量名前加上类型关键字boolean。

高分求解:JAVA中***hides a field警告怎么处理?

编程的初期可以把checkStyle、findBugs这些都disable掉。因为检查代码都是后期的工作，首先要让程序能够跑起来，然后再考虑效率问题，最后才考虑代码格式等次重要的东西。

一般来说checkStyle的警告都是可以不予理睬的，比如说name hides a field、magic number，对你编程没有影响。但是对开发软件产品来说，这个是最后必须要消除的。因为这将影响你写的代码的可读性，进而影响到将来代码优化和维护。

name hides a field警告指方法的参数和类里面定义的域（或者说是成员变量，数据成员）重名了，换个其他名字就行了，比如说name改为n。

magic number就是指程序里那些不用取变量名，直接把常量值写在使用它的地方的那种数字。这种数字往往让人摸不着头脑，也不知道那是什么意义，就像毫无原因，突然被变出来的一样，所以被称为“魔术数字”。

解决magic number的方法就是把所有用到的常量都声明为public static final，

注释是相当重要的，即使是自己开发的，时间久了也许都会忘记某个变量是用来干什么的……汗，

养成好的编程习惯利己利人！编程的初期可以把checkStyle、findBugs这些都disable掉。因为检查代码都是后期的工作，首先要让程序能够跑起来，然后再考虑效率问题，最后才考虑代码格式等次重要的东西。

一般来说checkStyle的警告都是可以不予理睬的，比如说name hides a field、magic number，对你编程没有影响。但是对开发软件产品来说，这个是最后必须要消除的。因为这将影响你写的代码的可读性，进而影响到将来代码优化和维护。

name hides a field警告指方法的参数和类里面定义的域（或者说是成员变量，数据成员）重名了，换个其他名字就行了，比如说name改为n。

magic number就是指程序里那些不用取变量名，直接把常量值写在使用它的地方的那种数字。这种数字往往让人摸不着头脑，也不知道那是什么意义，就像毫无原因，突然被变出来的一样，所以被称为“魔术数字”。

解决magic number的方法就是把所有用到的常量都声明为public static final，

注释是相当重要的，即使是自己开发的，时间久了也许都会忘记某个变量是用来干什么的……汗，

养成好的编程习惯利己利人！编程的初期可以把checkStyle、findBugs这些都disable掉。因为检查代码都是后期的工作，首先要让程序能够跑起来，然后再考虑效率问题，最后才考虑代码格式等次重要的东西。

一般来说checkStyle的警告都是可以不予理睬的，比如说name hides a field、magic number，对你编程没有影响。但是对开发软件产品来说，这个是最后必须要消除的。因为这将影响你写的代码的可读性，进而影响到将来代码优化和维护。

name hides a field警告指方法的参数和类里面定义的域（或者说是成员变量，数据成员）重名了，换个其他名字就行了，比如说name改为n。

magic number就是指程序里那些不用取变量名，直接把常量值写在使用它的地方的那种数字。这种数字往往让人摸不着头脑，也不知道那是什么意义，就像毫无原因，突然被变出来的一样，所以被称为“魔术数字”。

解决magic number的方法就是把所有用到的常量都声明为public static final，

注释是相当重要的，即使是自己开发的，时间久了也许都会忘记某个变量是用来干什么的……汗，

养成好的编程习惯利己利人！

Java语言中的常量，变量，数据类型等都代表什么意思

数据类型:表示变量保存的数据所属的类型

int x表示x存储的是一个整数(1,2,3这样的)

double x表示x存储的是一个小数(1.1 , 0.5这样的)

之所以要有数据类型是因为不同类型的数据有不同的操作，比如质数只能是整数，就是为了把它们分开所以有数据类型，再来就是每种数据类型所占用的系统资源不尽相同，分类可以更合理的分配有限的资源。

打个比方:我计算整数只需要整数部分的内容，那么如果我用double来定义就会多出小数部分的计算，这样资源就浪费掉了，因为根本不需要用到(这只是个比方)

变量:用来记录数据的符号

数学里的方程知道把，假设某某为x，某某为y，方程里x假设代表一件商品的价格，那么我要用到这件商品的价格的时候就直接用x就行了。

变量就是这样的东西，比如 double π=3.14，这里定义了一个变量π，后面所有用到这个π的时候就会去找到这个3.14，这样就不用每次都去找这个值到底是多少来写个3.14

常量:不能改变的变量,定义变量前用const修饰

对于变量

int x=0; //定义一个变量x，值为0

x=1; //修改x的值，现在x值为1

变量顾名思义，是可以变的，常量，或者说恒量(没有这个名字)，是不可变的

const double π=3.14; //定义一个常量π，值为3.14

π=3.14159; //报错，常量的值不可变，不能给他赋值

常量是用于记录那些不会改变的变量的存在，比如一个计算圆面积的程序中，π永远是3.14不能改变，这样可以防止有人恶意修改

关于java中的魔术常量和在java方法中定义一个常量的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。