Java中final类变量的初始化问题

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

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

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

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

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

不能别被改变的

一、final关键字的基本用法在Java中，final关键字可以用来修饰类、方法和变量（包括成员变量和局部变量）。下面就从这三个方面来了解一下final关键字的基本用法。1、修饰类　 当用final修饰一个类时，表明这个类不能被继承。也就是说，如果一个类你永远不会让他被继承，就可以用final进行修饰。final类中的成员变量可以根据需要设为final，但是要注意final类中的所有成员方法都会被隐式地指定为final方法。在使用final修饰类的时候，要注意谨慎选择，除非这个类真的在以后不会用来继承或者出于安全的考虑，尽量不要将类设计为final类。2/62、修饰方法 下面这段话摘自《Java编程思想》第四版第143页：　 “使用final方法的原因有两个。第一个原因是把方法锁定，以防任何继承类修改它的含义；第二个原因是效率。在早期的Java实现版本中，会将final方法转为内嵌调用。但是如果方法过于庞大，可能看不到内嵌调用带来的任何性能提升。在最近的Java版本中，不需要使用final方法进行这些优化了。“　　因此，如果只有在想明确禁止 该方法在子类中被覆盖的情况下才将方法设置为final的。即父类的final方法是不能被子类所覆盖的，也就是说子类是不能够存在和父类一模一样的方法的。 final修饰的方法表示此方法已经是“最后的、最终的”含义，亦即此方法不能被重写（可以重载多个final修饰的方法）。此处需要注意的一点是：因为重写的前提是子类可以从父类中继承此方法，如果父类中final修饰的方法同时访问控制权限为private，将会导致子类中不能直接继承到此方法，因此，此时可以在子类中定义相同的方法名和参数，此时不再产生重写与final的矛盾，而是在子类中重新定义了新的方法。（注：类的private方法会隐式地被指定为final方法。）3/63、修饰变量 修饰变量是final用得最多的地方，也是本文接下来要重点阐述的内容。 final成员变量表示常量，只能被赋值一次，赋值后值不再改变。　　当final修饰一个基本数据类型时，表示该基本数据类型的值一旦在初始化后便不能发生变化；如果final修饰一个引用类型时，则在对其初始化之后便不能再让其指向其他对象了，但该引用所指向的对象的内容是可以发生变化的。本质上是一回事，因为引用的值是一个地址，final要求值，即地址的值不发生变化。　　final修饰一个成员变量（属性），必须要显示初始化。这里有两种初始化方式，一种是在变量声明的时候初始化；第二种方法是在声明变量的时候不赋初值，但是要在这个变量所在的类的所有的构造函数中对这个变量赋初值。　　当函数的参数类型声明为final时，说明该参数是只读型的。即你可以读取使用该参数，但是无法改变该参数的值。4/6二、深入理解final关键字在了解了final关键字的基本用法之后，这一节我们来看一下final关键字容易混淆的地方。1、类的final变量和普通变量有什么区别？ 当用final作用于类的成员变量时，成员变量（注意是类的成员变量，局部变量只需要保证在使用之前被初始化赋值即可）必须在定义时或者构造器中进行初始化赋值，而且final变量一旦被初始化赋值之后，就不能再被赋值了。5/62、被final修饰的引用变量指向的对象内容可变吗？引用变量被final修饰之后，虽然不能再指向其他对象，但是它指向的对象的内容是可变的6/63、final参数的问题 在实际应用中，我们除了可以用final修饰成员变量、成员方法、类，还可以修饰参数、若某个参数被final修饰了，则代表了该参数是不可改变的。如果在方法中我们修改了该参数，则编译器会提示你：The final local variable i cannot be assigned. It must be blank and not using a compound assignment。java采用的是值传递，对于引用变量，传递的是引用的值，也就是说让实参和形参同时指向了同一个对象，因此让形参重新指向另一个对象对实参并没有任何影响。

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

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

那么内部类引用的变量就是非法的，则该变量必须被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的用法如下：（1）修饰变量用final关键字修饰的变量，只能进行一次赋值操作，并且在生存期内不可以改变它的值。final 修饰的变量可以先声明，后赋值。final修饰基本类型时，起到常量的作用，基本类型的值不可变。final修饰引用类型时，不能再指向其他的对象，但被引用的对象的值是可以改变的（引用变量的值实际上是它所引用的对象的地址）。当用final作用于类的成员变量时，成员变量（局部变量只需要保证在使用之前被初始化赋值即可）必须在定义时或者构造器中进行初始化赋值。（2）修饰方法参数编写方法时，可以在参数前面添加final关键字，它表示在整个方法中，不会（实际上是不能）改变参数的值，具体类似于修饰数据。即不能改变参数的值，但是可以改变引用类型参数的对象的值。同时，即使没有final的修饰，参数的改变也不会影响到方法外的变量。（3）修饰方法final关键字修饰方法，它表示该方法不能被覆盖（重写）。另外，类中所有的private方法都隐式地指定为是final的，由于无法在类外使用private方法，所以也就无法覆盖它。此时可以在子类中定义相同的方法名和参数，这种情况不再产生重写与final的矛盾，而是在子类中重新定义了新的方法。可以对private方法添加final修饰符，但并没有添加任何额外意义。（4） 修饰类用final修饰的类是无法被继承的。且final类中的所有成员方法都会被隐式地指定为final方法。

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

dui

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

final 定义常量，不能再被赋值，定义一些固定的值，但不以值的形式出现

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

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

有finalb原因：final修饰的变量,整个应用程序中只能赋值一次。它会使你在调用final方法时，直接将方法主体插入到调用处，而不是进行例行的方法调用，例如保存断点，压栈等。这样可能会使你的程序效率有所提高，然而当你的方法主体非常庞大时，或你在多处调用此方法，那么你的调用主体代码便会迅速膨胀，可能反而会影响效率，所以你要慎用final进行方法定义。inal变量（常量）：用final修饰的成员变量表示常量，只能被赋值一次，赋值后值无法改变！final修饰的变量有三种：静态变量、实例变量和局部变量，分别表示三种类型的常量。从下面的例子中可以看出，一旦给final变量初值后，值就不能再改变了。另外，final变量定义的时候，可以先声明，而不给初值，这种变量也称为final空白，无论什么情况，编译器都确保空白final在使用之前必须被初始化。但是，final空白在final关键字final的使用上提供了更大的灵活性，为此，一个类中的final数据成员就可以实现依对象而有所不同，却有保持其恒定不变的特征。

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

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

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

下面的代码展示了final变量的特性，它只能够赋值一次，一旦赋值无法再修改。但是，final变量指向的对象的值却是可以修改的，如下面的owner的name和age属性都可以修改，但是owner本身指向的对象在初始化之后不能修改了。classPerson{Stringname;intage;}publicclassTestFinal{privatefinalPersonowner;TestFinal(){owner=newPerson();}publicvoidmodifyOwner(Personp){//下面一行代码是修改final变量，将提示错误，无法修改owner.//owner=p;//下面两行是修改owner对象的值，这是可以的。owner.name=p.name;owner.age=p.age;}}

final修饰的 是不可改变的

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

今天看到一段代码，大意如下： 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型变量是不能被修改的

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

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

问题提的很好，搜了一把终于知道了大概的原因，首先纠正提问者的提问，贴出来的第一段代码属于匿名内部类，第二端代码不属于匿名内部类。回答你的问题，为什么在匿名内部类中引用外部对象要加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修饰的变量有三种：静态变量、实例变量和局部变量，分别表示三种类型的常量。　　从下面的例子中可以看出，一旦给final变量初值后，值就不能再改变了。　　另外，final变量定义的时候，可以先声明，而不给初值，这中变量也称为final空白，无论什么情况，编译器都确保空白final在使用之前必须被初始化。但是，final空白在final关键字final的使用上提供了更大的灵活性，为此，一个类中的final数据成员就可以实现依对象而有所不同，却有保持其恒定不变的特征。

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

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

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

final作用在类上，类不可以有子类final作用在方法上，方法不能被重写final作用在引用上，引用地址不可改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变量，访问时候直接用 类名.变量名，存在的意义是可以让本类或其他类的多个对象共享该变量，值是可以改变的。final是常量，存在意义是说明该变量的值是不可改变的。

关于final的重要知识点final关键字可以用于成员变量、本地变量、方法以及类。final成员变量必须在声明的时候初始化或者在构造器中初始化，否则就会报编译错误。你不能够对final变量再次赋值。本地变量必须在声明时赋值。在匿名类中所有变量都必须是final变量。final方法不能被重写。final类不能被继承。final关键字不同于finally关键字，后者用于异常处理。final关键字容易与finalize()方法搞混，后者是在Object类中定义的方法，是在垃圾回收之前被JVM调用的方法。接口中声明的所有变量本身是final的。final和abstract这两个关键字是反相关的，final类就不可能是abstract的。final方法在编译阶段绑定，称为静态绑定(static binding)。没有在声明时初始化final变量的称为空白final变量(blank final variable)，它们必须在构造器中初始化，或者调用this()初始化。不这么做的话，编译器会报错“final变量(变量名)需要进行初始化”。将类、方法、变量声明为final能够提高性能，这样JVM就有机会进行估计，然后优化。按照Java代码惯例，final变量就是常量，而且通常常量名要大写：private final int COUNT = 10;

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

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

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

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

int 是在heap区

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

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

程序退出时

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

final类不能被继承，因此final类的成员方法没有机会被覆盖，默认都是final的。在设计类时候，如果这个类不需要有子类，类的实现细节不允许改变，并且确信这个类不会再被扩展，那么就设计为final类。 final方法不能被子类的方法覆盖，但可以被继承。 2、final方法 如果一个类不允许其子类覆盖某个方法，则可以把这个方法声明为final方法。 使用final方法的原因有二： 第一、把方法锁定，防止任何继承类修改它的意义和实现。 第二、高效。编译器在遇到调用final方法时候会转入内嵌机制，大大提高执行效率。 3、final变量（常量） 用final修饰的成员变量表示常量，只能被赋值一次，赋值后值无法改变！ final修饰的变量有三种：静态变量、实例变量和局部变量，分别表示三种类型的常量。 从下面的例子中可以看出，一旦给final变量初值后，值就不能再改变了。 另外，final变量定义的时候，可以先声明，而不给初值，这种变量也称为final空白，无论什么情况，编译器都确保空白final在使用之前必须被初始化。但是，final空白在final关键字final的使用上提供了更大的灵活性，为此，一个类中的final数据成员就可以实现依对象而有所不同，却有保持其恒定不变的特征。 4、final参数 当函数参数为final类型时，你可以读取使用该参数，但是无法改变该参数的值。 注：父类的private成员方法是不能被子类方法覆盖的，因此private类型的方法默认是final类型的。 final不能用于修饰构造方法。

补充一下最佳答案，final修饰值变量不能改，在修饰路标变量时不能改引用，但可以改实例

static是静态的意思,可以直接通过实例类访问fina是最终,如果加上这个申明,变量和函数等将无法修