Java常量不能二次赋值与常量不能修改值意思一样吗？
 
结论：不一样，Java常量不能二次赋值这种说法是对的，常量不能修改值这种说法是错误的
 
代码说明：
 
 
如图所示，在AGE = 12;处报错，假设常量不能修改值这种说法是正确的，那代码中只是给AGE的值并没有改变还是12，就不应该报错，但是报错了，因此常量不能修改值这种说法是错误的，只能说常量不能够二次赋值，二者的意思是不一样的

 let a = 1; const b = 1;

 a = 2;

 b = 2;
 
 console.log(a,b);

 //使用const命名 重新赋值会报错(常量变量赋值) 因为const命名为常量


//定义一个对象时
 let obj = {
     user:'1',
     name:'2'
 };

 const obj2 = {
     user:'3',
     name:'4'
 };

 obj2.name = 5;

 obj = 6;

 console.log(obj,obj2)

 //使用const命名一个对象 可以修改其内部的属性(此时对象的地址没有改变) 但如果直接重新赋值(指向一个新的对象) 会报错(const为常量无法更改对象地址)

 //使用let命名是变量可以修改 所以要根据具体的场景需求合理使用

1、指针的赋值
	当声明一个指针后没有对其赋初值，指针变量没有存储确定的地址，而是一个随机整数。如果这时引用它所指的值可能会发生意想不到的问题（如修改了它指向系统重要数据）。所以我们要先赋值再引用。
	需要注意的是：赋值给指针变量的值必须是地址常量（如数组名），地址变量 。但一定不能是非0整数。
当赋值为0时表示该指针是一个空指针。因此在未确定赋值给某指针时，我们一般将其设为空指针（避免其随机值访问到了重要数据）。
 

1、指向常量的指针。（常量指针）即指针指向（即存储地址）可以改变，但所指内内容不能修改。
const char* p=”abcd”;
char c[]=”defg”;
*p=’a’; //错误 不能改变p所指对象
p=c; //正确

2、指针常量（指针本身值不能改变）
int i=3,j=4;
int* const p=&i;
p=&j; //错误，不能改变指针常量的值
3、void指针。特殊指针，可以任意对象为其赋值。
void* p;
int a;
int *p1;
p=&a; //void类型指针指向整型变量a
p1=(int*)p; //强制转换将void类型赋值给int型指针p1
这里对于常量指针和指针常量总有点模糊不清的概念。。。用一个比较死板的方法，避免多次的描述混淆。
常量指针（指向常量的指针，修饰的是常量对象）。指针常量（显然修饰重点在指针）
对应关系如下
常量------const
指针-------int* cha*  等等只要带*符号的
 

于是常量指针表示为
const-----------int*-------     //谁在前重点就是谁，不能改变，如这里常量对象不能变
 

指针常量
int*---------const--------      //指针描述符在前，指针是重点，指针本身不能改变
 
2、指针运算
因为指针也是一种数据类型。也可以参加一些运算。包括赋值运算、算术运算和关系运算。
如 int*p;
p+3;  //表示p所指地址后第三个数据地址。
++，--表示所指地址下一个或前一个地址。
指针的关系运算指同类型的关系运算，不同类型指针之间关系运算没有任何意义。

首先明白一个事，java存在一个常量池，可以用来存储字符串常量。
 
字符串常量池(String类型为什么可以直接赋值？就和它有关)
 

 String类是我们平常项目中使用频率非常高的一种对象类型，jvm为了提升性能和减少内存开销，避免字符的重复创建，其维护了一块特殊的内存空间，即字符串池，当需要使用字符串时，先去字符串池中查看该字符串是否已经存在，如果存在，则可以直接使用，如果不存在，初始化，并将该字符串放入字符创常量池中。
 
使用new String赋值不可以吗？可以，但是我们不开发中不建议用new String()的方式去创建字符串，原因如下：
 
两种创建方法的区别：
 
1. String str1= “abc”； 在编译期，JVM会去常量池来查找是否存在“abc”，如果不存在，就在常量池中开辟一个空间来存储“abc”；如果存在，就不用新开辟空间。然后在栈内存中开辟一个名字为str1的空间，来存储“abc”在常量池中的地址值。
 
2. String str2 = new String("abc") ;在编译阶段JVM先去常量池中查找是否存在“abc”，如果过不存在，则在常量池中开辟一个空间存储“abc”。在运行时期，通过String类的构造器在堆内存中new了一个空间，然后将String池中的“abc”复制一份存放到该堆空间中，在栈中开辟名字为str2的空间，存放堆中new出来的这个String对象的地址值。
 
也就是说，前者在初始化的时候可能创建了一个对象，也可能一个对象也没有创建；后者因为new关键字，至少在内存中创建了一个对象，也有可能是两个对象。
  
 
分别举例：
 
1.使用String直接赋值
 
String str = “abc”;可能创建一个或者不创建对象，如果”abc”在字符串池中不存在，会在java字符串池中创建一个String对象（”abc”），然后str指向这个内存地址，无论以后用这种方式创建多少个值为”abc”的字符串对象，始终只有一个内存地址被分配。==判断的是对象的内存地址，而equals判断的是对象内容。通过以下代码测试：
 
 
 
String str = "abc";
String str1 = "abc";
String str2 = "abc";
System.out.println(str==str1);//true
System.out.println(str==str2);//true
 
 
也就是str、str1、str2都是指向同一个内存地址。
 
2.使用new String()赋值
 
String str = new String(“abc”);至少会创建一个对象，也有可能创建两个。因为用到new关键字，肯定会在堆中创建一个String对象，如果字符池中已经存在”abc”,则不会在字符串池中创建一个String对象，如果不存在，则会在字符串常量池中也创建一个对象。
 
 
 
String str = new String("abc");
String str1 = new String("abc");
String str2 = new String("abc");
System.out.println(str==str1);//false
System.out.println(str==str2);//false
 
 
可以看出来，str、str1、str2指向的是不同的内存地址。
 
原因归纳：
 
上文可以归纳出：直接赋值产生1或0个对象，使用new String()赋值时产生2或1对象，赋值时先看字符串常量池，如果字符串常量池中没有，就在常量池中创建一个，如果有，前者直接引用，后者在堆内存中还需创建一个“abc”实例对象（此时引用变量指向的是堆内存中创建的实例对象，而不是常量池中的实例对象）。
 
String类被设计成不可变（immutable）类，所以它的所有对象都是不可变对象。例如：       
 
String str = “hello";
 
str = str + "world“；
 
当上文str指向了一个String对象（内容为“hello”），然后对str进行 “+” 操作，str原来指向的对象并没有变（依然存在在常量池中），而是str此时又指向了另外一个对象（“hello world”），原来的对象还在内存中。
 
由此可以看出，频繁的对String对象进行修改，会造成很大的内存开销。此时应该用StringBuffer或StringBuilder来代替String。
 
所以使用new String() 方式赋值更不适合，因为每一次创建对象都会调用构造器在堆中产生新的对象，性能低下且内存更加浪费。
 
额外说明（字很多，但这是知识的丰富）：
 
使用String拼接字符串
 
项目中除了直接使用=赋值，也会用到字符串拼接，字符串拼接又分为变量拼接和已知字符串拼接。
 
 
 
String str = "abc";//在常量池中创建abc
String str1 = "abcd";//在常量池中创建abcd
String str2 = str+"d";//拼接字符串，此时会在堆中新建一个abcd的对象，因为str2编译之前是未知的
String str3 = "abc"+"d";//拼接之后str3还是abcd，所以还是会指向字符串常量池的内存地址
System.out.println(str1==str2);//false
System.out.println(str1==str3);//true
 
 
解答问题：为什么给str3赋值时不会在堆中创建一个对象，而给str2赋值时却会在堆中创建一个对象？
 
首先你要明白java编译器和运行期和String原理。
 

 编译期:   是指把源码交给编译器编译成计算机可以执行的文件的过程。在Java中也就是把Java代码编成class文件的过程.编译期只是做了一些翻译功能，并没有把代码放在内存中运行起来，而只是把代码当成文本进行操作,比如检查错误。
 

  
 
 
 
运行期:  是把编译后的文件交给计算机执行.直到程序运行结束。所谓运行期就把在磁盘中的代码放到内存中执行起来。在Java中把磁盘中的代码放到内存中就是类加载过程。
 
 
比如通过String str = "aaa"赋值，字面量形式创建的字符串对象 "aaa" 存进了字符串常量池，而通过String str = String("bbb") 赋值，new 创建的 "bbb" 则是存进了堆中。这两种方式我们在代码编写时都经常使用，尤其是字面量的方式。然而这两种实现其实存在着一些性能和内存占用的差别。这一切都是源于JVM为了减少字符串对象的重复创建，其维护了一个特殊的内存，这段内存被成为字符串常量池或者字符串字面量池。
 
 
String工作原理：当代码中出现字面量形式创建字符串对象时，JVM首先会对这个字面量进行检查。如果字符串常量池中存在相同内容的字符串对象的引用，则将这个引用返回。如果没有则创建新的字符串对象，然后将这个引用放入字符串常量池，并返回该引用。
 
 
上面的概念比较笼统，其实就是啥意思呢？在编译时，如果碰到了String s = "hello"; 这样的赋值方式，就是字面量形式赋值，编译时就直接编译成 String s = "hello"; ，然后拿到内存中时就按照上述所说的直接赋值的那种方式去赋值，str3 = "abc" + "d"其实就等同于字面量赋值（即等同于str3 = "abcd"）。但是，如果是str2这种赋值方式String str2 = str + "d"; ，虽然str在上面已经定义了，但是在编译时认为str仍是一个引用类型变量，所以此时就会把str2认为是以new String()方式来创建的，等来到内存中呢，就按照new String()这种方式去创建str2，自然堆内存中就会开辟空间，然后创建对象，接着再把空间的地址值返回给str2。所以str1和str2并没有指向同一个对象，地址值自然不同，这同时也解释了提出的问题。
 
 
下面在附上一个测试的例子，来更好的帮助你理解String和new String()：
 
 
public class StringBy

{

    public static void main(String[] args){

    //情况一

    String a = "a2";

    String a2 = "a"+2;

    //在编译期值是确定的就是a2。只有编译期变量a与变量a2值相等他们才相等

    System.out.println(a==a2);

    //情况二

    String b = "b2";

    int bb = 2;

    String b2="b"+bb;

   //在编译期变量b2的值不是确定的，因为bb是变量，变量在运行期才能确定值.所以b与b2不等

    System.out.println(b==b2);

    //情况三

    String c="c2";

    final int cc=2;

    String c2="c"+cc;//在编译期c2的值是确定的，因为cc是个常量，值为2

    System.out.println(c==c2);

    //情况四

    String d="d2";

    final int dd=getZ();

    String d2="d"+dd;

    //在编译器d2的值是不确定的，因为dd还没有确定，因为dd的值是靠方法返回来的，但是方法的结果是在            
    //运行期才能得到的

    System.out.println(d==d2);//(对于两个对象，==的作用是比较他们的地址。)

    }

    public static int getZ(){

        return 2;

    }

}
 
 
参考链接：
 
 
https://www.cnblogs.com/lgg20/p/12521117.html
 
 
https://blog.csdn.net/weixin_41098980/article/details/80060200
 
 
https://jingyan.baidu.com/article/17bd8e521583f985ab2bb88a.html