blocks|key|2036981|text|它们限制变量的作用域。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2036982|public+void+foo()
{
++++{
++++++++int+i+=+10;
++++}
++++System.out.println(i);+//+Won't+compile.
}|code-block|syntax|javascript|2036983|但在实践中，如果您发现自己在使用这样的代码块，这可能是您想要将该块重构为一个方法的信号。|2036984|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

They restrict variable scope.

<pre><code>public void foo()
{
 {
 int i = 10;
 }
 System.out.println(i); // Won't compile.
}
</code></pre>

In practice, though, if you find yourself using such a code block that's probably a sign that you want to refactor that block out to a method.

blocks|key|2037121|text|您可以将其用作匿名内部类的构造函数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2037122|如下所示：|2037123|​|2037124|📷|atomic|offset|length|2037125|通过这种方式，您可以初始化对象，因为空闲块是在对象构造过程中执行的。|2037126|它不限于匿名内部类，它也适用于常规类。|2037127|public+class+SomeClass+{
++++public+List+data;{
++++++++data+=+new+ArrayList();
++++++++data.add(1);
++++++++data.add(1);
++++++++data.add(1);
++++}
}|code-block|syntax|javascript|2037128|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/264f720930748e4584c30f3018c8989c.png|imageAlt^0|0|0|0|0|1|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|13|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|14|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|15|8|@]|9|@$I|16|J|17|1|18]]|A|$]]|$1|K|3|L|5|6|7|19|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|1A|8|@]|9|@]|A|$]]|$1|O|3|P|5|Q|7|1B|8|@]|9|@]|A|$R|S]]|$1|T|3|-4|5|6|7|1C|8|@]|9|@]|A|$]]]|U|$V|$5|W|X|Y|A|$Z|10|11|-4]]]]

You may use it as constructor for anonymous inner classes.

Like this:

<a href="https://i.stack.imgur.com/b9Jda.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/b9Jda.png" alt="alt text"></a>


This way you can initialize your object, since the free block is executed during the object construction.

It is not restricted to anonymous inner classes, it applies to regular classes too. 

<pre><code>public class SomeClass {
 public List data;{
 data = new ArrayList();
 data.add(1);
 data.add(1);
 data.add(1);
 }
}
</code></pre>

blocks|key|2037179|text|匿名块对于限制变量和double+brace+initialization的作用域都很有用。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2037180|比较|2037181|Set<String>+validCodes+=+new+HashSet<String>();
validCodes.add("XZ13s");
validCodes.add("AB21/X");
validCodes.add("YYLEX");
validCodes.add("AR2D");|code-block|syntax|javascript|2037182|使用|2037183|Set<String>+validCodes+=+new+HashSet<String>()+{{
++add("XZ13s");
++add("AB21/X");
++add("YYLEX");
++add("AR5E");
}};|2037184|entityMap|0|LINK|mutability|MUTABLE|url|http://c2.com/cgi/wiki?DoubleBraceInitialization^0|A|R|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@$A|X|B|Y|1|Z]]|C|$]]|$1|D|3|E|5|6|7|10|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|11|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|12|8|@]|9|@]|C|$]]|$1|M|3|N|5|H|7|13|8|@]|9|@]|C|$I|J]]|$1|O|3|-4|5|6|7|14|8|@]|9|@]|C|$]]]|P|$Q|$5|R|S|T|C|$U|V]]]]

Anonymous blocks are useful for limiting the scope of a variable as well as for <a href="http://c2.com/cgi/wiki?DoubleBraceInitialization" rel="nofollow noreferrer">double brace initialization</a>. 

Compare

<pre><code>Set&lt;String&gt; validCodes = new HashSet&lt;String&gt;();
validCodes.add("XZ13s");
validCodes.add("AB21/X");
validCodes.add("YYLEX");
validCodes.add("AR2D");
</code></pre>

with

<pre><code>Set&lt;String&gt; validCodes = new HashSet&lt;String&gt;() {{
 add("XZ13s");
 add("AB21/X");
 add("YYLEX");
 add("AR5E");
}};
</code></pre>

blocks|key|1823648|text|我认为你和/或其他答案混淆了两个不同的语法结构；即实例初始化器和块。(顺便说一句，“命名块”实际上是一个带标签的语句，其中的语句恰好是一个块。)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1823649|实例初始化器在类成员的语法级别上使用；|1823650|public+class+Test+{
++++final+int+foo;

++++{
+++++++++//+Some+complicated+initialization+sequence;+e.g.
+++++++++int+tmp;
+++++++++if+(...)+{
+++++++++++++...
+++++++++++++tmp+=+...
+++++++++}+else+{
+++++++++++++...
+++++++++++++tmp+=+...
+++++++++}
+++++++++foo+=+tmp;
++++}
}|code-block|syntax|javascript|1823651|根据@dfa的示例，Initializer构造最常用于匿名类。另一个用例是对'final‘属性进行复杂的初始化；例如，参见上面的示例。(但是，更常见的做法是使用常规构造函数。上面的模式更常用于静态初始化器。)|1823652|另一个结构是一个普通的块，出现在一个代码块中，比如method；|1823653|public+void+test()+{
++++int+i+=+1;
++++{
+++++++int+j+=+2;
+++++++...
++++}
++++{
+++++++int+j+=+3;
+++++++...
++++}
}|1823654|块最常用作控制语句的一部分，用于对一系列语句进行分组。但是当你在上面使用它们时，它们(只是)允许你限制声明的可见性；例如上面的j。|offset|length|style|CODE|1823655|这通常意味着你需要重构你的代码，但它并不总是清晰的。例如，您有时会在用Java编写的解释器中看到这种事情。切换臂中的语句可以分解到单独的方法中，但这可能会对解释器的“内部循环”造成显著的性能影响；|1823656|++++switch+(op)+{
++++case+OP1:+{
+++++++++++++int+tmp+=+...;
+++++++++++++//+do+something
+++++++++++++break;
+++++++++}
++++case+OP2:+{
+++++++++++++int+tmp+=+...;
+++++++++++++//+do+something+else
+++++++++++++break;
+++++++++}
++++...
++++};|1823657|entityMap^0|0|0|0|0|0|0|1R|1|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|11|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|12|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|13|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|14|8|@]|9|@]|A|$]]|$1|M|3|N|5|F|7|15|8|@]|9|@]|A|$G|H]]|$1|O|3|P|5|6|7|16|8|@$Q|17|R|18|S|T]]|9|@]|A|$]]|$1|U|3|V|5|6|7|19|8|@]|9|@]|A|$]]|$1|W|3|X|5|F|7|1A|8|@]|9|@]|A|$G|H]]|$1|Y|3|-4|5|6|7|1B|8|@]|9|@]|A|$]]]|Z|$]]

I think you and/or the other answers are confusing two distinct syntactic constructs; namely Instance Initializers and Blocks. (And by the way, a "named block" is really a Labeled Statement, where the Statement happens to be a Block.)

An Instance Initializer is used at the syntactic level of a class member; e.g.

<pre><code>public class Test {
 final int foo;

 {
 // Some complicated initialization sequence; e.g.
 int tmp;
 if (...) {
 ...
 tmp = ...
 } else {
 ...
 tmp = ...
 }
 foo = tmp;
 }
}
</code></pre>

The Initializer construct is most commonly used with anonymous classes as per @dfa's example. Another use-case is for doing complicated initialization of 'final' attributes; e.g. see the example above. (However, it is more common to do this using a regular constructor. The pattern above is more commonly used with Static Initializers.)

The other construct is an ordinary block and appears within a code block such as method; e.g.

<pre><code>public void test() {
 int i = 1;
 {
 int j = 2;
 ...
 }
 {
 int j = 3;
 ...
 }
}
</code></pre>

Blocks are most commonly used as part of control statements to group a sequence of statements. But when you use them above, they (just) allow you to restrict the visibility of declarations; e.g. <code>j</code> in the above.

This usually indicates that you need to refactor your code, but it is not always clear cut. For example, you sometimes see this sort of thing in interpreters coded in Java. The statements in the switch arms could be factored into separate methods, but this may result in a significant performance hit for the "inner loop" of an interpreter; e.g.

<pre><code> switch (op) {
 case OP1: {
 int tmp = ...;
 // do something
 break;
 }
 case OP2: {
 int tmp = ...;
 // do something else
 break;
 }
 ...
 };
</code></pre>

blocks|key|1823886|text|通常最好的方法是使用make+the+scope+of+local+variables+as+small+as+possible。匿名代码块可以帮助实现这一点。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1823887|我发现这对switch语句特别有用。考虑下面的示例，不使用匿名代码块：|style|CODE|1823888|public+String+manipulate(Mode+mode)+{
++++switch(mode)+{
++++case+FOO:+
++++++++String+result+=+foo();
++++++++tweak(result);
++++++++return+result;
++++case+BAR:+
++++++++String+result+=+bar();++//+Compiler+error
++++++++twiddle(result);
++++++++return+result;
++++case+BAZ:+
++++++++String+rsult+=+bar();+++//+Whoops,+typo!
++++++++twang(result);++//+No+compiler+error
++++++++return+result;
++++}
}|code-block|syntax|javascript|1823889|和匿名代码块：|1823890|public+String+manipulate(Mode+mode)+{
++++switch(mode)+{
++++++++case+FOO:+{
++++++++++++String+result+=+foo();
++++++++++++tweak(result);
++++++++++++return+result;
++++++++}
++++++++case+BAR:+{
++++++++++++String+result+=+bar();++//+No+compiler+error
++++++++++++twiddle(result);
++++++++++++return+result;
++++++++}
++++++++case+BAZ:+{
++++++++++++String+rsult+=+bar();+++//+Whoops,+typo!
++++++++++++twang(result);++//+Compiler+error
++++++++++++return+result;
++++++++}
++++}
}|1823891|我认为第二个版本更干净，更容易阅读。而且，它将在switch中声明的变量的范围缩小到它们声明时的情况，根据我的经验，这是99%25的情况下您想要的。|1823892|但是请注意，这不会改变失败的行为-您仍然需要记住包括一个break或return来防止它！|1823893|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/8803806/292728^0|A|1I|0|0|5|6|0|0|0|0|0|S|5|Y|6|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@$A|13|B|14|1|15]]|C|$]]|$1|D|3|E|5|6|7|16|8|@$A|17|B|18|F|G]]|9|@]|C|$]]|$1|H|3|I|5|J|7|19|8|@]|9|@]|C|$K|L]]|$1|M|3|N|5|6|7|1A|8|@]|9|@]|C|$]]|$1|O|3|P|5|J|7|1B|8|@]|9|@]|C|$K|L]]|$1|Q|3|R|5|6|7|1C|8|@]|9|@]|C|$]]|$1|S|3|T|5|6|7|1D|8|@$A|1E|B|1F|F|G]|$A|1G|B|1H|F|G]]|9|@]|C|$]]|$1|U|3|-4|5|6|7|1I|8|@]|9|@]|C|$]]]|V|$W|$5|X|Y|Z|C|$10|11]]]]

It's usually best to <a href="https://stackoverflow.com/a/8803806/292728">make the scope of local variables as small as possible</a>. Anonymous code blocks can help with this.

I find this especially useful with <code>switch</code> statements. Consider the following example, without anonymous code blocks:

<pre><code>public String manipulate(Mode mode) {
 switch(mode) {
 case FOO: 
 String result = foo();
 tweak(result);
 return result;
 case BAR: 
 String result = bar(); // Compiler error
 twiddle(result);
 return result;
 case BAZ: 
 String rsult = bar(); // Whoops, typo!
 twang(result); // No compiler error
 return result;
 }
}
</code></pre>

And with anonymous code blocks:

<pre><code>public String manipulate(Mode mode) {
 switch(mode) {
 case FOO: {
 String result = foo();
 tweak(result);
 return result;
 }
 case BAR: {
 String result = bar(); // No compiler error
 twiddle(result);
 return result;
 }
 case BAZ: {
 String rsult = bar(); // Whoops, typo!
 twang(result); // Compiler error
 return result;
 }
 }
}
</code></pre>

I consider the second version to be cleaner and easier to read. And, it reduces the scope of variables declared within the switch to the case to which they were declared, which in my experience is what you want 99% of the time anyways.

Be warned however, it does not change the behavior for case fall-through - you'll still need to remember to include a <code>break</code> or <code>return</code> to prevent it!

blocks|key|1823942|text|可以使用块来初始化父作用域中的最终变量。这是一个很好的方法来限制一些变量的作用域，这些变量只用于初始化单个变量。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1823943|public+void+test(final+int+x)+{
++++final+ClassA+a;
++++final+ClassB+b;
++++{
++++++++final+ClassC+parmC+=+getC(x);
++++++++a+=+parmC.getA();
++++++++b+=+parmC.getB();
++++}
++++//...+a+and+b+are+initialized
}|code-block|syntax|javascript|1823944|一般来说，最好是将块移动到一个方法中，但这种语法适用于需要返回多个变量并且您不想创建包装类的一次性情况。|1823945|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

You can use a block to initialize a final variable from the parent scope. This a nice way to limit the scope of some variables only used to initialize the single variable.

<pre><code>public void test(final int x) {
 final ClassA a;
 final ClassB b;
 {
 final ClassC parmC = getC(x);
 a = parmC.getA();
 b = parmC.getB();
 }
 //... a and b are initialized
}
</code></pre>

In general it's preferable to move the block into a method, but this syntax can be nice for one-off cases when multiple variables need to be returned and you don't want to create a wrapper class.

blocks|key|2037741|text|描述一个任务，可以使用注释，也可以根据代码的结构和所选的标识符进行描述，然后使用代码块在语言本身不强制执行的情况下创建层次关系。例如：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2037742|public+void+sendAdminMessage(String+msg)+throws+IOException+{
++++MessageService+service;+{
++++++++String+senderKey+=+properties.get("admin-message-server");
++++++++service+=+MessageService.of(senderKey);
++++++++if+(!ms.available())+{
++++++++++throw+new+MessageServiceException("Not+available:+"+%2B+senderKey);
++++++++}
++++}

++++/*+workaround+for+issue+1298:+Stop+sending+passwords.+*/+{
++++++++final+Pattern+p+=+Pattern.compile("%5E(.*?)\"pass\":.*(\"stamp\".*)$");
++++++++Matcher+m+=+p.matcher(msg);
++++++++if+(m.matches())+msg+=+m.group(1)+%2B+m.group(2);
++++}
++++...
}|code-block|syntax|javascript|2037743|上面只是一些示例代码来解释这个概念。第一个代码块由紧接其前的代码块“记录”：该代码块用于初始化service变量。第二个代码块通过注释进行了说明。在这两种情况下，块都为注释/变量声明提供了“作用域”：它们解释了特定过程的结束位置。它是对这种更常见的风格的替代：|offset|length|style|CODE|2037744|public+void+sendAdminMessage(String+msg)+throws+IOException+{
++++//+START:+initialize+service
++++String+senderKey+=+properties.get("admin-message-server");
++++MessageService+service+=+MessageService.of(senderKey);
++++if+(!ms.available())+{
++++++throw+new+MessageServiceException("Not+available:+"+%2B+senderKey);
++++}
++++//+END:+initialize+service

++++//+START:+workaround+for+issue+1298:+Stop+sending+passwords.
++++final+Pattern+p+=+Pattern.compile("%5E(.*?)\"pass\":.*(\"stamp\".*)$");
++++Matcher+m+=+p.matcher(msg);
++++if+(m.matches())+msg+=+m.group(1)+%2B+m.group(2);
++++//+END:+workaround+for+issue+1298:+Stop+sending+passwords.

++++...
}|2037745|不过，代码块更好:它们让你使用编辑器工具更有效地导航(“转到块的末尾”)，它们限定了块中使用的局部变量的范围，这样它们就无法转义，最重要的是，它们符合包容的概念:作为java程序员，你已经熟悉了包容的概念:对于块，如果是块，方法块:它们都是代码流中层次结构的表达式。出于文档原因而不是技术原因的代码遏制仍然是遏制。为什么要使用不同的机制呢？一致性是有用的。更少的精神负担。|2037746|注意:最好的设计是将MessageService对象的初始化隔离到一个单独的方法中。然而，这确实会导致面条化:在某种程度上，将一个简单且易于理解的任务与一个方法隔离开来，会使您更难推断方法结构:通过隔离它，您已经将初始化消息服务的工作变成了一个黑盒(至少在您查看helper方法之前是这样)，并且为了按照代码的流动顺序完全阅读代码，您需要遍历源文件。这通常是更好的选择(另一种选择是很难测试的非常长的方法，或者重用其中的一部分)，但有时不是这样。例如，如果您的块包含对大量局部变量的引用:如果您创建一个helper方法，则必须传递所有这些变量。方法也不是控制流和局部变量透明的(辅助方法不能脱离主方法的循环，辅助方法不能看到或修改主方法的局部变量)。有时，这是一种障碍。|2037747|entityMap^0|0|0|1B|7|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@$I|X|J|Y|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|10|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|11|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

Describe a task, either with a comment or inherently due to the structure of your code and the identifiers chosen, and then use code blocks to create a hierarchical relationship there where the language itself doesn't enforce one. For example:
<pre><code>public void sendAdminMessage(String msg) throws IOException {
 MessageService service; {
 String senderKey = properties.get(&quot;admin-message-server&quot;);
 service = MessageService.of(senderKey);
 if (!ms.available()) {
 throw new MessageServiceException(&quot;Not available: &quot; + senderKey);
 }
 }

 /* workaround for issue 1298: Stop sending passwords. */ {
 final Pattern p = Pattern.compile(&quot;^(.*?)\&quot;pass\&quot;:.*(\&quot;stamp\&quot;.*)$&quot;);
 Matcher m = p.matcher(msg);
 if (m.matches()) msg = m.group(1) + m.group(2);
 }
 ...
}
</code></pre>
The above is just some sample code to explain the concept. The first block is 'documented' by what is immediately preceding it: That block serves to initialize the <code>service</code> variable. The second block is documented by a comment. In both cases, the block provide 'scope' for the comment/variable declaration: They explain where that particular process ends. It's an alternative to this much more common style:
<pre><code>public void sendAdminMessage(String msg) throws IOException {
 // START: initialize service
 String senderKey = properties.get(&quot;admin-message-server&quot;);
 MessageService service = MessageService.of(senderKey);
 if (!ms.available()) {
 throw new MessageServiceException(&quot;Not available: &quot; + senderKey);
 }
 // END: initialize service

 // START: workaround for issue 1298: Stop sending passwords.
 final Pattern p = Pattern.compile(&quot;^(.*?)\&quot;pass\&quot;:.*(\&quot;stamp\&quot;.*)$&quot;);
 Matcher m = p.matcher(msg);
 if (m.matches()) msg = m.group(1) + m.group(2);
 // END: workaround for issue 1298: Stop sending passwords.

 ...
}
</code></pre>
The blocks are better, though: They let you use your editor tooling to navigate more efficiently ('go to end of block'), they scope the local variables used within the block so that they cannot escape, and most of all, they align the concept of containment: You are already familiar, as java programmer, with the concept of containment: for blocks, if blocks, method blocks: They are all expressions of hierarchy in code flow. Containment for code for documentary reasons instead of technical is still containment. Why use a different mechanism? Consistency is useful. Less mental load.
NB: Most likely the best design is to isolate the initialisation of the MessageService object to a separate method. However, this does lead to spaghettification: At some point isolating a simple and easily understood task to a method makes it harder to reason about method structure: By isolating it, you've turned the job of initializing the messageservice into a black box (at least, until you look at the helper method), and to fully read the code in order of how it flows, you need to hop around all over your source files. That's usually the better choice (the alternative is very long methods that are hard to test, or reuse parts of), but there are times when it's not. For example, if your block contains references to a significant number of local variables: If you make a helper method you'd have to pass all those variables. A method is also not control flow and local variable transparent (a helper method cannot break out of the loop from the main method, and a helper method cannot see or modify the local variables from the main method). Sometimes that's an impediment.

Are there any practical uses of anonymous code blocks in Java?

<pre><code>public static void main(String[] args) {
 // in
 {
 // out
 }
}
</code></pre>

Please note that this is not about named blocks, i.e.

<pre><code>name: { 
 if ( /* something */ ) 
 break name;
}
</code></pre>

.

Anonymous code blocks in Java

解释器

Java

在Java中匿名代码块有什么实际用途吗？public static void main(String[] args) {    // in    {        // out    }}请注意，这不是关于命名块，即name: {      if ( /* something */ )          break n...

问Java中的匿名代码块
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Java中的匿名代码块EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Java中的匿名代码块
EN