变量

今天编写一个多线程程序，发现在方法内定义内部类时，如果内部类调用了方法中的变量，那么该变量必须申明为final类型，百思不得其解，后来想到应该是生命周期的原因，因为方法内定义的变量是局部变量，离开该方法，变量就失去了作用，也就会自动被消除，而内部类却不会离开它所在方法就失去作用，它有更广的生命周期，下面通过一个实例加以说明：如例中所示，在外部类Outer中声明了一个内部类TimerPrint,这个类中的方法引用了方法start中的一个局部变量testTxt逻辑上：因为该内部类出现在一个方法的内部，但实际编译时，内部类编译为Outer$1TimerPrint.class，这说明，外部类的这个方法和内部类是处于同一级别的。换句话说是非final变量和内部类的生命周期不一样！start被调用后，非final变量也会随之消失，就会出现内部类引用非法！实际做法：java编译器的行为是这样的(前提条件是该变量在内部类中被引用)：若定义为final，则java编译器则会在内部类TimerPrint内生成一个外部变量的拷贝，而且可以既可以保证内部类可以引用外部属性，又能保证值的唯一性。若不定义为final，则无法通过编译!(jdk1.6测试过)。因为编译器不会给非final变量进行拷贝，那么内部类引用的变量就是非法的！下面看经过编译以后的字节码：外部类编译后的字节码：内部类编译后的字节码：如果外部类中的变量d没有被内部类引用，则final为可选的，而且java编译器将不做特殊处理！！加一个参数d 并且把它定义为非final类型，编译以后文件如下：编译后的外部类class：编译后的内部类class：由上可以看出，在方法内部定义内部类时，内部类如果调用了方法内的变量，则该变量必须被final修饰，否则就会因为在调用内部类时因为找不到所用的变量而报错！

简单点说只是一种写代码的约定俗成的约定罢了,如果真正要说原因的话,估计已经很难查证了.

是可以的，用final修饰的变量的值或者引用就不能再改变了。比如你要把一个新开一个线程要用到一个局部变量，那这个变量就必须用final修饰。

程序退出时

这样写没问题，因为你是在for循环的内部定义的，如果你在外面定义了final的button，再想在for循环里初始化，那就会报错了

这是因为你的listener实际上是使用了内部类，内部类当然不知道外部方法的变量了。但是外部类的变量是可以看到的，如果要在方法内让其内部类看见该方法的变量就要加上final来保证在改方法中只有一个ll，包括它的内部类。不知道你明白没有~~

因为你的jdk版本可能比较高jdk8版本是不需要final修饰就可以访问的查看下你的jdk版本吧c:windowssystem32>java -versionjava version "1.8.0_60"cmd命令java-version 看下你的jdk版本

int 是在heap区

final修饰符对变量来说，深层次的理解就是保障变量值的一致性。为什么这么说呢？因为引用类型变量其本质是存入的是一个引用地址，说白了还是一个值（可以理解为内存中的地址值）。用final修饰后，这个这个引用变量的地址值不能改变，所以这个引用变量就无法再指向其它对象了。回到正题，为什么需要用final保护数据的一致性呢？因为将数据拷贝完成后，如果不用final修饰，则原先的局部变量可以发生变化。这里到了问题的核心了，如果局部变量发生变化后，匿名内部类是不知道的（因为他只是拷贝了局不变量的值，并不是直接使用的局部变量）。这里举个栗子：原先局部变量指向的是对象A，在创建匿名内部类后，匿名内部类中的成员变量也指向A对象。但过了一段时间局部变量的值指向另外一个B对象，但此时匿名内部类中还是指向原先的A对象。那么程序再接着运行下去，可能就会导致程序运行的结果与预期不同。

您好，提问者： final是最终的，不可修改的。 final可以说是一个常量，而不是变量。必须将其赋值！！！！

static变量，访问时候直接用 类名.变量名，存在的意义是可以让本类或其他类的多个对象共享该变量，值是可以改变的。final是常量，存在意义是说明该变量的值是不可改变的。

问题提的很好，搜了一把终于知道了大概的原因，首先纠正提问者的提问，贴出来的第一段代码属于匿名内部类，第二端代码不属于匿名内部类。回答你的问题，为什么在匿名内部类中引用外部对象要加final修饰符呢，因为，在匿名内部类中引用的外部对象受到外部线程的作用域的制约有其特定的生命周期，以线程为例，当外部的变量生命周期已经完结之后，内部的线程还在运行，怎么样解决这个外部生命周期已经结束而在内部却需要继续使用呢，这个时候就需要在外部变量中添加final修饰符，其实内部匿名类使用的这个变量就是外部变量的一个“复制品”，即使外部变量生命周期已经结束，内部的“复制品“依然可用。网络搜索的答案如下：为什么匿名内部类参数必须为final类型 1) 从程序设计语言的理论上:局部内部类(即:定义在方法中的内部类),由于本身就是在方法内部(可出现在形式参数定义处或者方法体处),因而访问方法中的局部变量(形式参数或局部变量)是天经地义的.是很自然的 2) 为什么JAVA中要加上一条限制:只能访问final型的局部变量? 3) JAVA语言的编译程序的设计者当然全实现:局部内部类能访问方法中的所有的局部变量(因为:从理论上这是很自然的要求),但是:编译技术是无法实现的或代价极高. 4) 困难在何处?到底难在哪儿?局部变量的生命周期与局部内部类的对象的生命周期的不一致性! 5) 设方法f被调用,从而在它的调用栈中生成了变量i,此时产生了一个局部内部类对象inner_object,它访问了该局部变量i .当方法f()运行结束后,局部变量i就已死亡了,不存在了.但:局部内部类对象inner_object还可能 一直存在(只能没有人再引用该对象时,它才会死亡),它不会随着方法f()运行结束死亡.这时:出现了一个"荒唐"结果:局部内部类对象 inner_object要访问一个已不存在的局部变量i! 6) 如何才能实现?当变量是final时,通过将final局部变量"复制"一份,复制品直接作为局部内部中的数据成员.这样:当局部内部类访问局部变量 时,其实真正访问的是这个局部变量的"复制品"(即:这个复制品就代表了那个局部变量).因此:当运行栈中的真正的局部变量死亡时,局部内部类对象仍可以 访问局部变量(其实访问的是"复制品"),给人的感觉:好像是局部变量的"生命期"延长了. 那么:核心的问题是:怎么才能使得:访问"复制品"与访问真正的原始的局部变量,其语义效果是一样的呢?当变量是final时,若是基本数据类型,由于其值不变,因而:其复制品与原始的量是一样.语义效果相同.(若:不是final,就无法保证:复制品与原始变量保持一致了,因为:在方法中改的是原始变量,而局部内部类中改的是复制品)当 变量是final时,若是引用类型,由于其引用值不变(即:永远指向同一个对象),因而:其复制品与原始的引用变量一样,永远指向同一个对象(由于是 final,从而保证:只能指向这个对象,再不能指向其它对象),达到:局部内部类中访问的复制品与方法代码中访问的原始对象,永远都是同一个即:语义效 果是一样的.否则:当方法中改原始变量,而局部内部类中改复制品时,就无法保证:复制品与原始变量保持一致了(因此:它们原本就应该是同一个变量.)一句话:这个规定是一种无可奈何.也说明:程序设计语言的设计是受到实现技术的限制的.这就是一例. 因为:我就看到不少人都持这种观点:设计与想法是最重要的,实现的技术是无关紧要的,只要你作出设计与规定,都能实现.

【答案】：使用final 关键字修饰一个变量时，是指引用变量不能变，引用变量所指向的对象中的内容还是可以改变的。例如，对于如下语句：final StringBuffer a=new StringBuffer("immutable");执行如下语句将报告编译期错误：a=new StringBuffer("");但是，执行如下语句则可以通过编译：a.append(" broken!");有人在定义方法的参数时，可能想采用如下形式来阻止方法内部修改传进来的参数对象：public void method(final StringBuffer param){}实际上，这是办不到的，在该方法内部仍然可以增加如下代码来修改参数对象：param.append("a");

static修饰的变量可以是线程安全的，也可以是非线程安全的，这取决于具体的实现方式和并发访问的场景。如果一个static变量被多个线程同时访问，而且没有采取任何线程同步机制（比如锁、原子操作等），那么它就是非线程安全的，可能会导致数据竞争和并发访问问题。但是，如果一个static变量被设计成只读（即不可变的），那么它就是线程安全的，因为它不会发生并发访问问题。final修饰的变量是线程安全的，因为final变量在初始化之后就不能再被修改，不存在并发访问问题。final变量在多线程环境下可以被同时访问，不需要额外的线程同步机制。需要注意的是，如果final变量引用了一个可变对象，那么该对象本身并不是线程安全的，需要采取相应的线程同步措施来保证其线程安全。

有上来提问的时间，你还不如自己写个代码验证一下

final 是终级的 不可修改和继承的 static是静态的 可以直接调用的

能 不解释 自己在程序里试一下不就知道了

问题提的很好，搜了一把终于知道了大概的原因，首先纠正提问者的提问，贴出来的第一段代码属于匿名内部类，第二端代码不属于匿名内部类。回答你的问题，为什么在匿名内部类中引用外部对象要加final修饰符呢，因为，在匿名内部类中引用的外部对象受到外部线程的作用域的制约有其特定的生命周期，以线程为例，当外部的变量生命周期已经完结之后，内部的线程还在运行，怎么样解决这个外部生命周期已经结束而在内部却需要继续使用呢，这个时候就需要在外部变量中添加final修饰符，其实内部匿名类使用的这个变量就是外部变量的一个“复制品”，即使外部变量生命周期已经结束，内部的“复制品“依然可用。网络搜索的答案如下：为什么匿名内部类参数必须为final类型 1) 从程序设计语言的理论上:局部内部类(即:定义在方法中的内部类),由于本身就是在方法内部(可出现在形式参数定义处或者方法体处),因而访问方法中的局部变量(形式参数或局部变量)是天经地义的.是很自然的 2) 为什么JAVA中要加上一条限制:只能访问final型的局部变量? 3) JAVA语言的编译程序的设计者当然全实现:局部内部类能访问方法中的所有的局部变量(因为:从理论上这是很自然的要求),但是:编译技术是无法实现的或代价极高. 4) 困难在何处?到底难在哪儿?局部变量的生命周期与局部内部类的对象的生命周期的不一致性! 5) 设方法f被调用,从而在它的调用栈中生成了变量i,此时产生了一个局部内部类对象inner_object,它访问了该局部变量i .当方法f()运行结束后,局部变量i就已死亡了,不存在了.但:局部内部类对象inner_object还可能 一直存在(只能没有人再引用该对象时,它才会死亡),它不会随着方法f()运行结束死亡.这时:出现了一个"荒唐"结果:局部内部类对象 inner_object要访问一个已不存在的局部变量i! 6) 如何才能实现?当变量是final时,通过将final局部变量"复制"一份,复制品直接作为局部内部中的数据成员.这样:当局部内部类访问局部变量 时,其实真正访问的是这个局部变量的"复制品"(即:这个复制品就代表了那个局部变量).因此:当运行栈中的真正的局部变量死亡时,局部内部类对象仍可以 访问局部变量(其实访问的是"复制品"),给人的感觉:好像是局部变量的"生命期"延长了. 那么:核心的问题是:怎么才能使得:访问"复制品"与访问真正的原始的局部变量,其语义效果是一样的呢?当变量是final时,若是基本数据类型,由于其值不变,因而:其复制品与原始的量是一样.语义效果相同.(若:不是final,就无法保证:复制品与原始变量保持一致了,因为:在方法中改的是原始变量,而局部内部类中改的是复制品)当 变量是final时,若是引用类型,由于其引用值不变(即:永远指向同一个对象),因而:其复制品与原始的引用变量一样,永远指向同一个对象(由于是 final,从而保证:只能指向这个对象,再不能指向其它对象),达到:局部内部类中访问的复制品与方法代码中访问的原始对象,永远都是同一个即:语义效 果是一样的.否则:当方法中改原始变量,而局部内部类中改复制品时,就无法保证:复制品与原始变量保持一致了(因此:它们原本就应该是同一个变量.)一句话:这个规定是一种无可奈何.也说明:程序设计语言的设计是受到实现技术的限制的.这就是一例. 因为:我就看到不少人都持这种观点:设计与想法是最重要的,实现的技术是无关紧要的,只要你作出设计与规定,都能实现.

是的，final型变量是不能被修改的

final意义：最终的，不可改变的。　　1、修饰变量，为常量,值不可变；　　2、修饰对象，值可变,引用不变；　　3、修饰方法，方法不可重写；　　4、修饰类，无子类，不可以被继承,更不可能被重写。

今天看到一段代码，大意如下： import java.util.ArrayList; import java.util.List; public class FinalTest { private final List list; FinalTest(List list) { this.list = list; } public List appendList(List list) { this.list.addAll(list); // 使用final修饰的this.list，还可以修改其内容么？ return this.list; } public void showList() { for (String s : this.list) { System.out.println(s); } } public static void main(String[] args) { List list1 = new ArrayList(1); list1.add("s1"); FinalTest test = new FinalTest(list1); test.showList(); List list2 = new ArrayList(1); list2.add("s2"); test.appendList(list2); test.showList(); } } 主要的疑问在注释行那里：使用final修饰的this.list，还可以修改其内容么？经查证，发现final关键字修饰的变量，如果为值型，则其值除了初始化之外，不可以被再次赋值；如果为引用型，则表示该引用不能指向其他的对象，但是该引用指向的对象本身是可以改变其值的。

用final static是常量不可改变的只有一份,好像用类名就可直接调用

final修饰的变量不能变，是指引用变量这个对象不能变（如该变量不能等于重新new的一个新的对象），并不指这个变量中的内容不能变。

final修饰的 是不可改变的

不可以，final本省含义就是最后的

final 定义变量 相当于把变量变成常量....

区别就在于是不是static的变量前一种是类变量，不需要实例就可以访问的 第二种静态初始化块的是在类第一次访问时运行，且只在第一次访问时运行，应该说没什么区别后一种是成员变量，需要建立实例，在每次实例的时候运行还有你注释写错了，最后面的是普通的初始化块不是静态的静态初始化块在构造方法运行前运行普通的初始化块在super（）方法调用后运行

在java中final的意思是钟态、说白了，凡是被final修饰过的类不能被其他类继承、修饰方法该方法不能被重写、修饰变量、变量自动转为常量，不可修改

dui

8: iconst_3 javap -c -l -v FinalClassVaribleTester 现在看输出的内容

使用final修饰的变量在对象生成前就定义好了.....

那么内部类引用的变量就是非法的，则该变量必须被final修饰，否则就会因为在调用内部类时因为找不到所用的变量而报错：如果外部类中的变量d没有被内部类引用，则final为可选的，也就会自动被消除，而内部类却不会离开它所在方法就失去作用，它有更广的生命周期，下面通过一个实例加以说明。若不定义为final，则无法通过编译!(jdk1.6测试过)。因为编译器不会给非final变量进行拷贝：java编译器的行为是这样的(前提条件是该变量在内部类中被引用)：若定义为final，则java编译器则会在内部类TimerPrint内生成一个外部变量的拷贝：由上可以看出，在方法内部定义内部类时，内部类如果调用了方法内的变量，但实际编译时，内部类编译为Outer$1TimerPrint.class，这说明，外部类的这个方法和内部类是处于同一级别的：编译后的外部类class：编译后的内部类class！start被调用后！加一个参数d 并且把它定义为非final类型，编译以后文件如下，后来想到应该是生命周期的原因，因为方法内定义的变量是局部变量，离开该方法，变量就失去了作用，非final变量也会随之消失，就会出现内部类引用非法！实际做法：如例中所示，而且java编译器将不做特殊处理！：外部类编译后的字节码：内部类编译后的字节码！下面看经过编译以后的字节码今天编写一个多线程程序，发现在方法内定义内部类时，在外部类Outer中声明了一个内部类TimerPrint,这个类中的方法引用了方法start中的一个局部变量testTxt逻辑上：因为该内部类出现在一个方法的内部，如果内部类调用了方法中的变量，那么该变量必须申明为final类型，百思不得其解。换句话说是非final变量和内部类的生命周期不一样，而且可以既可以保证内部类可以引用外部属性，又能保证值的唯一性

你是在线程中操作此变量吧，线程中必须是final 类型

是的，如果一个变量用 "final" 修饰，它就成为了一个常量。常量是在编译时就已经确定值的变量。常量有时也称为符号常量。在 Java 中，一个变量用 "final" 修饰之后它的值就不能再次被改变。常量的值需要在定义时被初始化，或者在构造函数中初始化。使用常量可以保证程序中的某些值不会被意外更改，这可以提高程序的安全性和可靠性。例如:final int PI = 3.14;final int SIZE = 10;常量名称通常大写，使用常量可以保证程序中的某些值不会被意外更改，这可以提高程序的安全性和可靠性

final定义变量的不可变，是引用的不可变。不管你counter变量本身的值如何变，customerID这个变量始终指向counter变量这点是始终不会变的。

final 类，无法被继承final方法，无法被覆盖，重写final变量，无法被修改

不能别被改变的

所有数据都是占用内存的，只是看内存结构而已。

final：变量的值不可修改，也就是说是常量static：变量的值可以用类名.变量名来引用，在类加载时，就加载了这个变量，常驻内存

final类型的变量只能被赋值一次，赋值以后就不能再修改了。但可以在声明变量时一同完成赋值（即定义变量的同时进行初始化），也可以先声明变量，以后再赋值。如：final int i=1;final int j;j=2;但如果接着有以下语句，就都是错的：i=666;j=888;但普通变量就不会有这种限制。

其实没有变好吧，只是把0,1,2这个三个值分别赋值了三个apple对象的id中

全局变量具有全局作用域。全局变量只需在一个源文件中定义，就可以作用于所有的源文件。当然，其他不包括全局变量定义的源文件需要用extern关键字再次声明这个全局变量。　　局部变量也只有局部作用域，他是自动对象，他在程序运行期间不是一直存在，而是只在函数执行期间存在，函数的一次调用结束后，变量就被撤销，其所占用的内存也被收回。　　从分配内存空间看：　　全局变量、静态局部变量、静态全局变量都在静态存储区分配空间，而局部变量在栈分配空间。　　TIPS：　　1、若全局变量仅在单个文件中访问，则可以讲这个变量修改为静态全局变量。　　2、若全局变量仅在单个函数中使用，则可以将这个变量修改为该函数的静态局部变量。　　3、全局变量、静态局部变量、静态全局变量都存放在静态数据存储区。　　4、函数中必须要使用static变量的情况：当某函数的返回值为指针类型时，则必须是static的局部变量的地址作为返回值，若为auto类型，则返回为错指针。

全局变量就是在函数外面定义的变量。不能在函数中直接使用。因为它的作用域不会到函数内部。所以在函数内部使用的时候常常看到类似global $a;超全局变量作用域在所有脚本都有效。所以，在函数可直接使用。比如 $_GET，$_SERVER都是超全局变量。除$_GET，$_POST,$_SERVER，$_COOKIE等之外的超全局变量保存在$GLOBALS数组中。注意，不要误写成$_GLOBALS。有点受到$_POST的影响了。$GLOBAL是一个特殊的php自定义的数组。超级全局变量。跟$_SERVER一样，都属于超全局变量

全局变量的说明之前再加以static 就构成了静态的全局变量。全局变量本身就是静态存储方式，静态全局变量当然也是静态存储方式。这两者在存储方式上并无不同。这两者的区别虽在于非静态全局变量的作用域是整个源程序，当一个源程序由多个源文件组成时，非静态的全局变量在各个源文件中都是有效的。而静态全局变量则限制了其作用域，即只在定义该变量的源文件内有效，在同一源程序的其它源文件中不能使用它。由于静态全局变量的作用域局限于一个源文件内，只能为该源文件内的函数公用，因此可以避免在其它源文件中引起错误。从以上分析可以看出，把局部变量改变为静态变量后是改变了它的存储方式即改变了它的生存期。把全局变量改变为静态变量后是改变了它的作用域， 限制了它的使用范围。

局部静态变量具有文件作用域，全局变量（公用变量）具有全局作用域文件作用域：从局部静态变量的定义处开始，一直到变量所在的文件结束都是存在的

全局变量(外部变量)的说明之前再冠以static就构成了静态的全局变量。全局变量本身就是静态存储方式，静态全局变量当然也是静态存储方式。这两者在存储方式上并无不同。这两者的区别虽在于非静态全局变量的作用域是整个源程序，当一个源程序由多个源文件组成时，非静态的全局变量在各个源文件中都是有效的。而静态全局变量则限制了其作用域，即只在定义该变量的源文件内有效，在同一源程序的其它源文件中不能使用它。由于静态全局变量的作用域局限于一个源文件内，只能为该源文件内的函数公用，因此可以避免在其它源文件中引起错误。从以上分析可以看出，把局部变量改变为静态变量后是改变了它的存储方式即改变了它的生存期。把全局变量改变为静态变量后是改变了它的作用域，限制了它的使用范围。static函数与普通函数有什么区别？只在当前源文件中使用的函数应该说明为内部函数(static)，内部函数应该在当前源文件中说明和定义。对于可在当前源文件以外使用的函数，应该在一个头文件中说明，要使用这些函数的源文件要包含这个头文件。

const修饰符修饰的变量为常量.只可以对其赋一次值.也就是说一旦赋值了以后将不能改变.通常写在通用模块中表示特定意义.比如const string user="userofsys";则可直接使用user代替userofsys

栈上，堆和栈的第一个区别就是申请方式不同：栈（英文名称是stack）是系统自动分配空间的。而堆（英文名称是heap）则是程序员根据需要自己申请的空间

#define是宏定义 一般时候最好不要用

开头定义的是全局变量，莫一函数中的是局部变量 要理清两者之间的关系

起初我也不是很理解，一个变量怎么可能既是恒定又是易变的呢？这不是矛盾吗？直到我了解了多线程，恍然大悟，这他娘就是为了多线程准备的关键字

你可以尝试引用。

而常量更普通的意义在于它不是变量。不同的系统约定也不一样。es5之后又细分出了let（变量）const（常量）这两种类型。但是const的出现也表示js脚本开始走向类如java，c#那种重型语言的编写方式，明确细分了常量和变量。let对比var都是变量(var没有变量常量一说，但ES5之后其行为与let类似)，但是，var和let有很大区别，简单理解就是作用域变了，使用变量需要先声明在赋值后使用的流程。let继承了这种流程，而var没有，在代码里的体现就是，let只在定义它的上一个大括号内及其所有子方法体起作用，比如方法中定义let则出了这个方法就没法使用到这个let，同级别的两个方法，可以各自定义一个同名let变量。变量是程序中数据的临时存放场所。在代码中可以只使用一个变量，也可以使用多个变量，变量中可以存放单词、数值、日期以及属性。由于变量让你能够把程序中准备使用的每一段数据都赋给一个简短、易于记忆的名字，因此它们十分有用。变量可以保存程序运行时用户输入的数据（如使用InputBox函数在屏幕上显示一个对话框，然后把用户键入的文本保存到变量中）、特定运算的结果以及要在窗体上显示的一段数据等。简而言之，变量是用于跟踪几乎所有类型信息的简单工具。

因为X和Y值是不确定的，在不支持变长数组的编译器上就会报错，如果你的编译器支持变成数组就没问题。而第一张图中因为A值确定是9，所以在不支持变成数组的编译器中也不会报错。

定义const 只读变量，具有不可变性。 例如： const int Max=100; int Array[Max]; //数组大小Max应该 是常量 这里请在Visual C++6.0 里分别创建.c 文件和.cpp 文件测试一下。会发现在.c 文件中，编译器会提示出错，而在.cpp 文件中则顺利运行。定义一个数组必须指定其元素的个数。这也从侧面证实在C 语言中，const 修饰的Max 仍然是变量，只不过是只读属性罢了；而在C++里，扩展了const 的含义。在定义的时候就把它的内存空间给限制死了，要是不初始化，那块区域永远就是那个样子了~~~~C语言标准规定的。。。如果不在声明的时候初始化而在其他地方修改,岂不违背了“只读”的意思

00

Const应该是定义 静态变量的，定义之后的变量只能拿来用，而不能修改其值

而常量更普通的意义在于它不是变量。 不同的系统约定也不一样，比如简单常量，有的系统可能就当“立即数”处理，存在于代码段；字符串、结构体常量，就和静态变量一样，存在于静态储存区（数据段）。 另外，DELPHI里还存在一种“静态变量”，也是以const修饰，它实际上等同于C里的static修饰。 左值是一个动态概念。常量可以作左值，左值很显然可以是变量，表达式。

好像没区别哦。都可以习惯写后者

不应该对用const或volatile说明了的对象进行类型强制转换，否则程序就不能正确运行。 不应该用类型强制转换把指向一种结构类型或数据类型的指针转换成指向另一种结构类型或数据类型的指针。在极少数需要进行这种类型强制转换的情况下，用共用体(union)来存放有关数据能更清楚地表达程序员的意图

无区别

vue3.0 中const定义的变量的值为什么可以改变？ let和const的区别

他们看起来一样，实质是不一样的。A (int a,int b): num(a), total(b)是在预编译时就告诉了编译器的，属于初始化。num = a;total = b;另一个就不用说了。

看你的程序需要了你是做什么

怎么算都不是13啊，9吧

我记得在指针里，const的使用方法有三种，他们代表的意义也不同。（如果没有记错的话^_^）一种是这样的，const type *name=...;它的意义是，定义了一个常量指针，常量指针就是指针里面的值（就是地址）是不能被改变的。还有一种是这样的，type const *name;它的意义是，定义了一个变量指针，但是他是指向一个常量的地址的。还有一种更加丧心病狂的，const type const *name=...;它的意义是，定义了一个常量指针，指针指向一个常量。如果有错的话，还请更正。

1、在函数之外定义的变量称为外部变量,外部变量是全局变量(也称全程变量)。 全局变量可以为本函数和其他函数所共用。2、const(常类型)是指使用类型修饰符const说明的类型，用常类型定义的变量或对象的值是不能被改变的。3、全局变量和const没有必然的联系，当然你可定义全局const类型，是否为全局变量决定于变量出现的位置。

const是用来声明一个常量的，当你不想让一个值被改变时就用const,const int max && int const max 是没有区别的，都可以。不涉及到指针const很好理解。涉及到指针的情况：int b=100;const int * a=&b [1];int const *a=&b; [2] int* const a=&b; [3] const int* const a =&b; [4]如果const位于星号的左侧，则const就是用来修饰指针所指向的变量，即指针指向为常量；如果const位于星号的右侧，const就是修饰指针本身，即指针本身是常量。因此，[1]和[2]的情况相同，都是指针所指向的内容为常量（const放在变量声明符的位置无关），这种情况下不允许对内容进行更改操作，如不能*a = 3 ；[3]为指针本身是常量，而指针所指向的内容不是常量，这种情况下不能对指针本身进行更改操作，如a++是错误的；[4]为指针本身和指向的内容均为常量。

关于C的关键字——const的理解和用法const在C中的用法很灵活（相信C++中也一样），个人感觉对之既爱又恨，有时候感觉const很好用，同时又经常会因为它的优点而犯错，犯错的原因除了粗心之外，另一个更重要的，就是以前对const理解不到位。于是今天自己写成一篇小总结。如果是初学者，建议好好看一下，相信帮助比较大；如果是高手，请不吝赐教！上面写了一段废话，就算是小序吧：）接下来就是正文；一、关于const的具体定义：——个人感觉很难对它下一个标准的定义，因为的用法很灵活，似乎对它定义后总无法让人能够明白它的意思，而且容易让人产生误解（也许是偶水平太菜了）。例如，把它有定义：一个能够让变量变成无法修改的常量的关键字。那么，这样的话，就可能让人误解为只要有const在定义变量里面，那变量就无论怎样都无法修改。这样的理解是很片面的（下面用法方面将对这问题做探讨）。因此，本人在此不敢对它下定义，其他参考书好象也没有下定义。

按说是不行的，可下面的代码输出结果是可以的。//#include "stdafx.h"//vc++6.0加上这一行.#include "stdio.h"#include "string.h"void main(void){ const int a[3]={1,2,3}; printf("%d %d %d ",a[0],a[1],a[2]); memset((void*)a,0,12); printf("%d %d %d ",a[0],a[1],a[2]);}这说明memset函数不涉及变量，而只对内存操作。无论什么性质的变量，只要找到存放它的内存单元，改变其中的内容是无法抵挡的，除非系统保护的空间。

这个。。。。。Const是定义常数时用的保留字- -```Public Const MB_OK=&H0...似曾相识否?

常量是不允许赋值的，所以要在定义的时候赋值否则出错

不可以，可以编写函数代替，比如a=add(5,3);也可以将+预定义为一个标识符，如 #define add + 就可以写成 a= 5 add 3; 了因为预定义是由预处理器在编译之前将定义的标识符替换，也就是说在编译时a= 5 add 3;已经变成a= 5 + 3; 了，对于编译器来说，a= 5 add 3; 和 a= 5 + 3; 是相同的。而C不支持 5变量名3 这样由变量的值运行时决定动作的语法。不过有办法实现运行时动态决定函数动作，可以定义一个函数指针，比如 int (*pFunc)(int, int); 可以将任何原型符合的函数赋给这个指针，这样就可以实现通过同一个指针调用不同的函数，代码相同而动作可变，这也就是多态。

const修饰的翻译期标识符具有常量语义，对于编译期（源代码）而言，必须在定义时同时被初始化，且一旦被定义即无法修改，否则产生编译错误。对于编译器而言，如果用于初始化const对象的值在编译期即能被确定，则可以把这个const对象优化掉，即通过类型检查后用这个值代替这个对象本身（这点效果和宏定义替换类似，但更安全），这被称为编译期const对象。编译期const对象在编译期完全确定，对于运行期而言相当于不存在。由于内嵌至数据段中，只是直接复制到内存，无所谓“初始化”（但是这点行为上和基本类型数据的初始化类似）。对于无法在编译期确定的运行期常量，一旦通过编译链接，在运行期的初始化行为，和对象本身被创建的时机相同——例如全局/静态对象在进程初始化时被初始化，作为函数参数的const对象（包括任何引用类型）在参数传递生成参数时同时初始化。====[原创回答团]

这么长的程序，你有疑问在哪一行代码也不指出，真想让人从头到尾的看你的程序啊？？？

const int aa的值是不可以改变的，常变量在常量区分配，必须初始化

const定义的是常量，运行中不能改，再间接的方式也不能改，这不符合规定。想改的话就不要定义成const常量“我指的是如何用一种间接的方式使得用const定义的变量在程序运行中可以被修改”，不知道你用的是何种间接的方式，贴出来分离一下？？

C语言中const修饰的量是常变量，它与普通变量的编译方式一样，唯一的区别是常变量定义后不能做左值。C++中const修饰的才是常量。1、 const修饰的变量是常量还是变量对于这个问题，很多同学认为const修饰的变量是不能改变，结果就误认为该变量变成了常量。那么对于const修饰的变量该如何理解那？下面我们来看一个例子：int main{char buf[4];const int a = 0;a = 10;}这个比较容易理解，编译器直接报错，原因在于“a = 10；”这句话，对const修饰的变量，后面进行赋值操作。这好像说明了const修饰的变量是不能被修改的，那究竟是不是那，那么下面我们把这个例子修改下：int main{char buf[4];const int a = 0;buf[4] = 97;printf(“the a is %d ”,a);}其中最后一句printf的目的是看下变量a的值是否改变，根据const的理解，如果const修饰的是变量是不能被修改的话，那么a的值一定不会改变，肯定还是0。但是在实际运行的结果中，我们发现a的值已经变为97了。这说明const修饰的变量a，已经被我们程序修改了。那综合这两个例子，我们来分析下，对于第二例子，修改的原因是buf[4]的赋值操作，我们知道buf[4]这个变量已经造成了buf这个数组变量的越界访问。buf数组的成员本身只有0,1,2,3，那么buf[4]访问的是谁那，根据局部变量的地址分配，可以知道buf[4]的地址和int a的地址是一样，那么buf[4]实际上就是访问了const int a；那么对buf[4]的修改，自然也修改了const int a的空间，这也是为什么我们在最后打印a的值的时候看到了97这个结果。那么我们现在可以知道了，const修饰的变量是不具备不允许修改的特性的，那么对于第一个例子的现象我们又如何解释那。第一个例子，错误是在程序编译的时候给出的，注意这里，这个时候并没有生成可执行文件，说明const修饰的变量可否修改是由编译器来帮我们保护了。而第二个例子里，变量的修改是在可执行程序执行的时候修改的，说明a还是一个变量。综上所述，我们可以得出一个结论，那就是const修饰的变量，其实质是告诉程序员或编译器该变量为只读，如果程序员在程序中显示的修改一个只读变量，编译器会毫不留情的给出一个error。而对于由于像数组溢出，隐式修改等程序不规范书写造成的运行过程中的修改，编译器是无能为力的，也说明const修饰的变量仍然是具备变量属性的。2、 被const修饰的变量，会被操作系统保护，防止修改如果对于第一个问题，有了理解的话，那么这个问题，就非常容易知道答案了。Const修饰的变量是不会被操作系统保护的。其原因是操作系统只保护常量，而不会保护变量的读写。那么什么是常量？比如“hello world”这个字符串就是被称为字符串常量。对于这个问题的另一种证明方法，可以看下面这个程序：int main{const int a;char *buf = “hello world”;printf(“the &a is %p, the buf is %p ”,&a, buf);}可以发现buf保存的地址是在0x08048000这个地址附近的，而a的地址是在0xbf000000这个地址附近的，而0x08048000附近的地址在我们linux操作系统上是代码段。这也说明了常量和变量是存放在不同区域的，自然操作系统是会保护常量的。

不是的，在对象生存期内是不可以改变的，过了生存期就是普通变量了。在C++中，const成员变量也不能在类定义处初始化，只能通过构造函数初始化列表进行，并且必须有构造函数。const数据成员只在某个对象生存期内是常量，而对于整个类而言却是可变的。因为类可以创建多个对象，不同的对象其const数据成员的值可以不同。所以不能在类的声明中初始化const数据成员，因为类的对象没被创建时，编译器不知道const数据成员的值是什么。const数据成员的初始化只能在类的构造函数的初始化列表中进行。要想建立在整个类中都恒定的常量，应该用类中的枚举常量来实现，或者static cosnt。class Test{public:Test():a(0){}enum {size1=100,size2=200};private:const int a;//只能在构造函数初始化列表中初始化static int b;//在类的实现文件中定义并初始化const static int c;//与 static const int c;相同。};int Test::b=0;//static成员变量不能在构造函数初始化列表中初始化，因为它不属于某个对象。cosnt int Test::c=0;//注意：给静态成员变量赋值时，不需要加static修饰符。但要加cosnt

全局变量的定义为本函数和其他函数所共用。const定义是指使用类型修饰符const说明的类型。一、全局变量全局变量是编程术语中的一种，源自于变量之分。变量分为局部与全局，局部变量又可称之为内部变量。变量由某对象或某个函数所创建的变量通常都是局部变量，只能被内部引用，而无法被其它对象或函数引用。全局变量既可以是某对象函数创建，也可以是在本程序任何地方创建。全局变量是可以被本程序所有对象或函数引用。二、CONST（C中的CONST）const是一个C语言（ANSI C）的关键字，具有着举足轻重的地位。const它限定一个变量不允许被改变，产生静态作用。使用const在一定程度上可以提高程序的安全性和可靠性。清晰理解const所起的作用，对理解对方的程序也有一定帮助。CONST在其它编程语言中也有出现，例如Pascal、C++、PHP5、B#.net、HC08 C、C#等。