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

Posted 2023-04-20

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

　　在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这个关键字了。以确保不同对象中都只有一个常量的值。或者说，不同对象中引用的常量其实指向的是内存中的同一块区域。 参考技术A

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

常量被设定后，一般情况下就不允许再进行更改。如可以利用如下的形式来定义一个常量：final double PI=3.1315。在定义这个常量时，需要注意如下内容：

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

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

三、是需要注意常量的命名规则。不同的语言，在定义变量或者常量的时候，都有自己一套编码规则。这主要是为了提高代码的共享程度与提高代码的易读性。在Java语言中，定义常量的时候，也有自己的一套规则。如在给常量取名的时候，一般都用大写字符。在Java语言中，大小写字符是敏感的。之所以采用大写字符，主要是跟变量进行区分。虽然说给常量取名时采用小写字符，也不会有语法上的错误。

但是，为了在编写代码时能够一目了然的判断变量与常量，最好还是能够将常量设置为大写字符。另外，在常量中，往往通过下划线来分隔不同的字符。而不想对象名或者类名那样，通过首字符大写的方式来进行分隔。这些规则虽然不是强制性的规则，但是为了提高代码友好性，方便开发团队中的其他成员阅读，这些规则还是需要遵守的。没有规矩，不成方圆。

参考技术B 变量就是你的类中的用来暂时存储数据的东西
定义方式为： 修饰符+变量类型+变量名= new 变量类型（）；
如：private String a = new String();
或直接赋值 private String a = "abc";
但是a的值在你不断赋值的过程中是可以变化的。

常量就是值不会发生变化的量，和变量是相对的，
比如一个常量a
private final String a = "abc";
那么这个a只是不会改变的，这就是常量 参考技术C java常量很简单就是一个固定值，比如说1，2,3,4都属于常量就是一个固定值，变量是比如我们说的X我们可以任意的赋值 在java中常量比如定义a为常量 那么a就是一个固定的值 参考技术D 这些知识点翻下书就行了。做为一个程序员，良好的编码习惯很重要，给楼主推荐下java的命名规范：
1、 package的命名：
package 的名字由全部小写的字母组成，例如：cn.mybole。
2、class和interface的命名：
class和interface的名字由大写字母开头而其他字母都小写的单词组成。例如： Person，RuntimeException。
3、class变量的命名 ：
变量的名字用一个小写字母开头，后面的单词用大写字母开头, 例如：index，currentImage。
4、class方法的命名
方法的名字用一个小写字母开头，后面的单词用大写字母开头,例如：run()，getBalance()。
5、static final变量的命名：
static final变量的名字所有字母都大写，并且能表示完整含义。例如：PI，PASSWORD。
6、参数的命名 参数的名字和变量的命名规范一致。
7、数组的命名 数组应该总是用这样的方式来命名：byte[] buffer。

把东西留着吧，命名的时候有不认识的英文单词，就用词霸翻。

参考资料：http://blog.sina.com.cn/17learning

常量池

       在jvm规范中，每个类型都有自己的常量池。常量池是某类型所用常量的一个有序集合，包括直接常量（基本类型，String）和对其他类型、字段、方法的符号引用。之所以是符号引用而不是像c语言那样，编译时直接指定其他类型，是因为java是动态绑定的，只有在运行时根据某些规则才能确定具体依赖的类型实例，这正是java实现多态的基础。

 

为了对常量池有更具体的认识，下面引用几个例子：

1,常量池中对象和堆中的对象

public class Test{

Integer i1=new Integer(1);    Integer i2=new Integer(1); //i1,i2分别位于堆中不同的内存空间

   System.out.println(i1==i2);//输出false

   Integer i3=1;    Integer i4=1; //i3,i4指向常量池中同一个内存空间

   System.out.println(i3==i4);//输出true

//很显然，i1,i3位于不同的内存空间

System.out.println(i1==i3);//输出false

}

2，8种基本类型的包装类和对象池

java中基本类型的包装类的大部分都实现了常量池技术，这些类是Byte,Short,Integer,Long,Character,Boolean,另外两种浮点数类型的包装类则没有实现。另外Byte,Short,Integer,Long,Character这5种整型的包装类也只是在对应值小于等于127时才可使用对象池，也即对象不负责创建和管理大于127的这些类的对象。以下是一些对应的测试代码：

public class Test{

public static void main(String[] args){

   //5种整形的包装类Byte,Short,Integer,Long,Character的对象，

   //在值小于127时可以使用常量池

   Integer i1=127;

   Integer i2=127;

   System.out.println(i1==i2)//输出true

   //值大于127时，不会从常量池中取对象

   Integer i3=128;

   Integer i4=128;

   System.out.println(i3==i4)//输出false

   //Boolean类也实现了常量池技术

   Boolean bool1=true;

   Boolean bool2=true;

   System.out.println(bool1==bool2);//输出true

   //浮点类型的包装类没有实现常量池技术

   Double d1=1.0;

   Double d2=1.0;

   System.out.println(d1==d2)//输出false

  

}

}

3,String也实现了常量池技术

String类也是java中用得多的类，同样为了创建String对象的方便，也实现了常量池的技术,测试代码如下:

public class Test{

public static void main(String[] args){

//s1,s2分别位于堆中不同空间

String s1=new String("hello");

String s2=new String("hello");

System.out.println(s1==s2)//输出false

//s3,s4位于池中同一空间

String s3="hello";

String s4="hello";

System.out.println(s3==s4);//输出true

}

}

 

4.字符串比较更丰富的一个例子

package testPackage;

class Test {

 public static void main(String[] args) {

  String hello = "Hello", lo = "lo";

  System.out.print((hello == "Hello") + " ");

  System.out.print((Other.hello == hello) + " ");

  System.out.print((other.Other.hello == hello) + " ");

  System.out.print((hello == ("Hel"+"lo")) + " ");

  System.out.print((hello == ("Hel"+lo)) + " ");

  System.out.println(hello == ("Hel"+lo).intern());

 }

}

class Other { static String hello = "Hello"; }

and the compilation unit:

package other;

public class Other { static String hello = "Hello"; }

produces the output:

true true true true false true

 

输出结果的分别解释如下：

在同包同类下,引用自同一String对象.

在同包不同类下,引用自同一String对象.

在不同包不同类下,依然引用自同一String对象

在编译成.class时能够识别为同一字符串的,自动优化成常量,所以也引用自同一String对象

在运行时创建的字符串具有独立的内存地址,所以不引用自同一String对象

String的intern()方法会查找在常量池中是否存在一份equal相等的字符串,如果有则返回一个引用,没有则添加自己的字符串进进入常量池,

注意,只是字符串部分,

所以这时会存在2份拷贝,常量池的部分被String类私有持有并管理,自己的那份按对象生命周期继续使用.