blocks|key|2513775|text|这是因为您在这里使用了闭包。这意味着内部类使用内界类的上下文。要使用它，变量应该被声明为final，这样才不会被更改。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2513776|请参阅更多here。|offset|length|2513777|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Closure_(computer_science))^0|0|5|4|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@$D|P|E|Q|1|R]]|A|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]]]

It is because you use closure here. It means that inner class uses the context of the inbounded one. To use it the variables should be declared final in order not to be changed.

See more <a href="http://en.wikipedia.org/wiki/Closure_(computer_science)" rel="noreferrer">here</a>.

blocks|key|1572249|text|Final本质上意味着变量et在任何时候都不会被重新赋值，并且会一直存在。这意味着内部类，就像你的监听器一样，可以相信它不会被其他线程重新分配，这可能会导致各种麻烦。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1572250|final还可以用来修改方法或类定义，这意味着方法不能被子类覆盖，或者类不能被扩展。|1572251|entityMap^0|D|2|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|M|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|N|8|@]|D|@]|E|$]]]|I|$]]

Final essentially means that the variable <code>et</code> will not be reassigned at any point and will remain around. This means that inner classes, like your listener, can trust that it wont be reassigned by some other thread which could cause all kinds of trouble.

final can also be used to modify a method or class definition, that would mean that the method can't be overriden by a subclass, or that the class cannot be extended.

blocks|key|2513987|text|JAVA中“final”关键字的用途可以定义为三个层次:类、方法、变量|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2513988|Java+final+variable:+If+you+make+any+variable+as+final,+you+cannot+change+the+value+of+final+variable+(It+will+be+constant).

Java+final+method:+If+you+make+any+method+as+final,+you+cannot+override+it.

Java+final+class:+If+you+make+any+class+as+final,+you+cannot+extend+it.|code-block|syntax|javascript|2513989|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

The purpose of “final” keyword in JAVA can be defined in three level are Class, Method, variable

<pre><code>Java final variable: If you make any variable as final, you cannot change the value of final variable (It will be constant).

Java final method: If you make any method as final, you cannot override it.

Java final class: If you make any class as final, you cannot extend it.
</code></pre>

blocks|key|1572242|text|Final使变量et只允许赋值一次。它还更改了变量的作用域，并允许函数onClick对et可见。如果没有最终结果，则在函数onClick中看不到et。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1572243|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Final makes the variable et only allowed to be assigned once. It also changes the scope of the variable and allows the function onClick visibility to et. Without the final, et is not visible within the function onClick.

blocks|key|446828|text|请阅读this+article以了解所涉及的实现细节：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|446829|446830|如果我们了解一些本地类是如何实现的，那么这个限制的原因就会变得显而易见。匿名局部类可以使用局部变量，因为编译器会自动为该类提供一个私有实例字段，以保存该类使用的每个局部变量的副本。编译器还向每个构造函数添加隐藏参数，以初始化这些自动创建的私有字段。因此，局部类实际上并不访问局部变量，而仅仅是它自己的私有副本。唯一可以正确工作的方法是将局部变量声明为final，这样就可以保证它们不会更改。有了这个保证，局部类就可以确保其变量的内部副本准确地反映了实际的局部变量。|blockquote|446831|446832|446833|编辑：|446834|446835|柏林·布朗说：“我发布了一个匿名内部类的反编译版本。但老实说，我仍然不明白为什么编译器必须拥有这些信息。即使字段被声明为final...because，该字段仍然可以为空。我认为这是那些Java语言的怪癖之一，你必须声明该字段的最终方式。没有明确的原因。”|446836|446837|446838|原因是要确保用户意识到闭包“关闭”了变量，而不是值。让我们假设不需要有最终的局部变量。然后我们可以编写如下代码：|446839|public+void+doIt()+{
++++for(int+i+=+0;+i+<+3;+%2B%2Bi)+{
++++++++runnables.add(new+Runnable()+{
++++++++++++@Override
++++++++++++public+void+run()+{
++++++++++++++++System.out.println(i);
++++++++++++}
++++++++});
++++}
++++run(runnables);+//+run+each+runnable
}|code-block|syntax|javascript|446840|你认为输出会是什么？如果你认为它是"0+1+2“，那你就大错特错了，因为Runnable在那个时刻关闭了”变量“i，而不是i的”值“，因此输出应该是"2+2+2”。在这里可以做些什么来实现预期的行为？有两种解决方案:要么依靠用户理解闭包是如何工作的，要么以某种方式在语言级别强制执行闭包。这是语言设计者已经采用的第二种选择。|446841|public+void+doIt()+{
++++for(int+i+=+0;+i+<+3;+%2B%2Bi)+{
++++++++final+int+j+=+i;+//+notice+the+final+local+variable
++++++++runnables.add(new+Runnable()+{
++++++++++++@Override
++++++++++++public+void+run()+{
++++++++++++++++System.out.println(j);
++++++++++++}
++++++++});
++++}
++++run(runnables);
}|446842|JFTR，我并不是说第二种选择是“最好的”方法，只是在匿名内部类中使用之前将局部变量标记为final对我来说是一个很大的问题。当然，YMMV。:-)|446843|entityMap|0|LINK|mutability|MUTABLE|url|http://renaud.waldura.com/doc/java/final-keyword.shtml^0|3|C|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1B|8|@]|9|@$A|1C|B|1D|1|1E]]|C|$]]|$1|D|3|-4|5|6|7|1F|8|@]|9|@]|C|$]]|$1|E|3|F|5|G|7|1G|8|@]|9|@]|C|$]]|$1|H|3|-4|5|6|7|1H|8|@]|9|@]|C|$]]|$1|I|3|-4|5|6|7|1I|8|@]|9|@]|C|$]]|$1|J|3|K|5|6|7|1J|8|@]|9|@]|C|$]]|$1|L|3|-4|5|6|7|1K|8|@]|9|@]|C|$]]|$1|M|3|N|5|G|7|1L|8|@]|9|@]|C|$]]|$1|O|3|-4|5|6|7|1M|8|@]|9|@]|C|$]]|$1|P|3|-4|5|6|7|1N|8|@]|9|@]|C|$]]|$1|Q|3|R|5|6|7|1O|8|@]|9|@]|C|$]]|$1|S|3|T|5|U|7|1P|8|@]|9|@]|C|$V|W]]|$1|X|3|Y|5|6|7|1Q|8|@]|9|@]|C|$]]|$1|Z|3|10|5|U|7|1R|8|@]|9|@]|C|$V|W]]|$1|11|3|12|5|6|7|1S|8|@]|9|@]|C|$]]|$1|13|3|-4|5|6|7|1T|8|@]|9|@]|C|$]]]|14|$15|$5|16|17|18|C|$19|1A]]]]

Read <a href="http://renaud.waldura.com/doc/java/final-keyword.shtml" rel="nofollow">this article</a> to understand the implementation details involved:

<blockquote>
 The reason for this restriction
 becomes apparent if we shed some light
 on how local classes are implemented.
 An anonymous local class can use local
 variables because the compiler
 automatically gives the class a
 private instance field to hold a copy
 of each local variable the class uses.
 The compiler also adds hidden
 parameters to each constructor to
 initialize these automatically created
 private fields. Thus, a local class
 does not actually access local
 variables, but merely its own private
 copies of them. The only way this can
 work correctly is if the local
 variables are declared final, so that
 they are guaranteed not to change.
 With this guarantee in place, the
 local class is assured that its
 internal copies of the variables
 accurately reflect the actual local
 variables.
</blockquote>

EDIT:

<blockquote>
 Berlin Brown says: "I posted a decompiled version of an
 anonymous inner class. But to be
 honest, I still don't see why the
 compiler has to have that information.
 Even if the field is declared final,
 the field can still be null. I think
 this is one of those Java quirks, you
 have to declare that field
 final...because that is the way it is.
 There isn't a clear reason why"
</blockquote>

The reason is to make sure that users realize that closures "close over" variables and not values. Let's suppose that there was no requirement of having final local variables. Then we could write code like:

<pre><code>public void doIt() {
 for(int i = 0; i &lt; 3; ++i) {
 runnables.add(new Runnable() {
 @Override
 public void run() {
 System.out.println(i);
 }
 });
 }
 run(runnables); // run each runnable
}
</code></pre>

What do you think would be the output? If you think it would be "0 1 2" you would be mistaken since the Runnable closes over the "variable" i and not the "value" of i at that point in time and hence the output would be "2 2 2". What can be done to achieve the expected behaviour here? Two solutions: either rely on the users to have an understanding of how closures work or somehow enforce it at the language level. And it is the second option with which the language designers have gone with.

<pre><code>public void doIt() {
 for(int i = 0; i &lt; 3; ++i) {
 final int j = i; // notice the final local variable
 runnables.add(new Runnable() {
 @Override
 public void run() {
 System.out.println(j);
 }
 });
 }
 run(runnables);
}
</code></pre>

JFTR, I'm not saying that the second option is "the" way to go, it's just that having local variables marked as final before being used in anonymous inner classes is a big deal breaker for me. Of course, YMMV. :-)

blocks|key|1574363|text|讨论final关键字的Here+is+a+link。根据the+specification+(第4.12.4节)：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1574364|1574365|可以将变量声明为final。最后一个变量只能赋值一次。如果最后一个变量被赋值，除非它在赋值之前被明确取消赋值(§16)，否则这是一个编译时错误。|blockquote|1574366|1574367|entityMap|0|LINK|mutability|MUTABLE|url|http://javapapers.com/core-java/explain-the-final-keyword-in-java/|1|http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html^0|2|5|B|E|0|S|H|1|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@$9|X|A|Y|1|Z]|$9|10|A|11|1|12]]|E|$]]|$1|F|3|-4|5|6|7|13|8|@]|D|@]|E|$]]|$1|G|3|H|5|I|7|14|8|@]|D|@]|E|$]]|$1|J|3|-4|5|6|7|15|8|@]|D|@]|E|$]]|$1|K|3|-4|5|6|7|16|8|@]|D|@]|E|$]]]|L|$M|$5|N|O|P|E|$Q|R]]|S|$5|N|O|P|E|$Q|T]]]]

<a href="http://javapapers.com/core-java/explain-the-final-keyword-in-java/" rel="nofollow">Here is a link</a> which discusses the <code>final</code> keyword. According to <a href="http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html" rel="nofollow">the specification</a> (section 4.12.4):

<blockquote>
 A variable can be declared final. A final variable may only be assigned to once. It is a compile time error if a final variable is assigned to unless it is definitely unassigned (§16) immediately prior to the assignment.
</blockquote>

blocks|key|1572306|text|它还有助于理解Java如何创建匿名内部类。Java如何实现那个特定的类。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1572307|Java需要该变量为final，因为编译器必须在编译时知道该对象的类型。然后，编译器将在匿名内部类实现中生成一个字段(在本例中为'et')。|1572308|如果类型不是final，编译器将如何确定如何构建内部类实现。基本上，通过声明字段final，可以为Java编译器提供更多信息。|1572309|不能帮助编译器的代码不会编译匿名内部类：|offset|length|style|BOLD|1572310|Object+et;
et+=+a+?+new+Object()+:+new+EditText();|code-block|syntax|javascript|1572311|..。|1572312|使用上面的代码，Java编译器不能真正构建匿名内部类。|1572313|你的代码：|1572314|final+EditText+et=(EditText)findViewById(R.id.t)；|1572315|1572316|new+Button.OnClickListener$1(){
++++++++++++public+void+onClick(View+v) 
++++++++++++{
++++++++++++Intent+on=new+Intent(Intent.ACTION_CALL,Uri.parse("tel:"%2Bet.getText()));
++++++++++++startActivity(on);
++++++++++++}
++++++++});|1572317|..。java编译器将创建一个字节码类，这是您提供内部类块的一个实现，可能如下所示。|1572318|public+class+OnClickListener$1+{

+private+final+EditText+et+;+<----+this+is+important
+public+OnClickListener$1(final+et)+{
++++this.et+=+et;
+}
+public+void+onClick(View+v) 
++++++++++++++++{
++++++++++++++++Intent+on=new+Intent(Intent.ACTION_CALL,Uri.parse("tel:"%2Bet.getText()));
++++++++++++++++startActivity(on);
++++++++++++++++}
}|1572319|您可以通过找到匿名字节码类$1并反编译该字节码文件来测试我提供的伪代码。|1572320|entityMap^0|0|0|0|8|C|0|0|0|0|0|5|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|19|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1A|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1B|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|1C|8|@$H|1D|I|1E|J|K]]|9|@]|A|$]]|$1|L|3|M|5|N|7|1F|8|@]|9|@]|A|$O|P]]|$1|Q|3|R|5|6|7|1G|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|1H|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|1I|8|@$H|1J|I|1K|J|K]]|9|@]|A|$]]|$1|W|3|X|5|6|7|1L|8|@]|9|@]|A|$]]|$1|Y|3|R|5|6|7|1M|8|@]|9|@]|A|$]]|$1|Z|3|10|5|N|7|1N|8|@]|9|@]|A|$O|P]]|$1|11|3|12|5|6|7|1O|8|@]|9|@]|A|$]]|$1|13|3|14|5|N|7|1P|8|@]|9|@]|A|$O|P]]|$1|15|3|16|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|17|3|-4|5|6|7|1R|8|@]|9|@]|A|$]]]|18|$]]

It also helps to understand how Java creates an anonymous inner class. How Java implements that particular class.

Java needs for that variable to be final because the compiler must know the type of that object at compile time. The compiler will then generate a field within the anonymous inner class implementation (in this case 'et').

If the type is not final, how would the compiler determine how to build the inner class implementation. Basically, by declaring the field final, you are giving the Java compiler more information. 

Code that doesn't help the compiler, won't compile your anonymous inner class:

<pre><code>Object et;
et = a ? new Object() : new EditText();
</code></pre>

...

With the code above, the Java compiler cannot really build the anonymous inner class. 

Your code:

final EditText et=(EditText)findViewById(R.id.t);

...

<pre><code>new Button.OnClickListener$1(){
 public void onClick(View v)&lt;br&gt;
 {
 Intent on=new Intent(Intent.ACTION_CALL,Uri.parse("tel:"+et.getText()));
 startActivity(on);
 }
 });
</code></pre>

...
The java compiler will create a bytecode class, an implementation of that inner class block that you provided that might look like this.

<pre><code>public class OnClickListener$1 {

 private final EditText et ; &lt;---- this is important
 public OnClickListener$1(final et) {
 this.et = et;
 }
 public void onClick(View v)&lt;br&gt;
 {
 Intent on=new Intent(Intent.ACTION_CALL,Uri.parse("tel:"+et.getText()));
 startActivity(on);
 }
}
</code></pre>

You can test the pseudo code I provided by finding the anonymous bytecode class $1 and decompile that bytecode file.

In the below code if i remove the keyword final from EditText i am an getting error in the line (6) where i pass EditText object (et) to the intent...I have to knw the significance of final keyword here...

<pre><code>final EditText et=(EditText)findViewById(R.id.t);
 Button b=(Button)findViewById(R.id.b1);
 b.setOnClickListener(new Button.OnClickListener(){
 public void onClick(View v)&lt;br&gt;
 {
 Intent on=new Intent(Intent.ACTION_CALL,Uri.parse("tel:"+et.getText()));
 startActivity(on);
 }
 });
</code></pre>

what is the use of keyword final?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

EdgeOne AI 安全实战专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

在下面的代码中，如果我从EditText中删除了关键字final，我在将EditText对象(et)传递给intent的第(6)行中出现错误...我必须在这里知道final关键字的意义……final EditText et=(EditText)findViewById(R.id.t);        Button b=(Button)findViewById(R.id.b1);        b.

问关键字final的用途是什么？
EN

回答 7

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问关键字final的用途是什么？EN

回答 7

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问关键字final的用途是什么？
EN