Controls the handling of curly braces (the Java block delimiters).
Lets you define how the enclosing block delimiters—open and closing curly brace—are printed. You can either choose from a predefined set of common styles or build one on your own. The brace style can either be configured individually for each block construct (details view) or one global style used (global view).
Use global style
Defines whether one brace style should be used for all block elements. When disabled, a combo box appears that lets you define the desired brace style for the different block elements individually.
Since 1.6
Configure style for
Lets you choose the block construct whose brace style should be configured. Select an item to display the available brace style options for the chosen block construct. This option is only available when the “Use global brace style” is disabled.
Since 1.6
Choose from common style
Lets you choose a pre-configured brace style. Choosing a style will adjust all individual brace style options accordingly. The available styles are:
C style.
Activates the C brace style. This style is sometimes called "Allman style" or "BSD style" named for Eric Allman, a Berkeley hacker who wrote a lot of the BSD utilities in it. The style puts the brace associated with a control statement on the next line, indented to the same level as the control statement. Statements within the braces are indented to the next level.
Example 2.41. C style
private void routine() { if (!done) { doSomething(); } else { System.out.println("Finished"); } }
Advantages of this style are that the indented code is clearly set apart from the containing statement by lines that are almost completely whitespace, improving readability and the ending brace lines up in the same column as the beginning brace, making it easy to find the matching brace. Additionally, the blocking style delineates the actual block of code associated from the control statement itself. Commenting out the control statement, removing the control statement entirely, refactoring, or removing of the block of code is less apt to introduce syntax errors because of dangling or missing brackets. Proponents of this style often cite its use by ANSI and in other standards as justification for its adoption. The motivation of this style is to promote code readability through visually separating blocks from their control statements, deeming screen real estate a secondary concern.
Sun Java style.
Activates the Sun brace style, a variant of the so called "K&R style" named after Kernighan & Ritchie, because the examples in their famous "The C Programming Language" [Kernighan88] reference are formatted this way. It keeps the first opening brace on the same line as the control statement, indents the statements within the braces, and puts the closing brace on the same indentation level as the control statement (on a line of its own). Most of the standard source code for the Java API is written in this style.
Example 2.42. Sun style
private void routine() { if (!done) { doSomething(); } else { System.out.println("Finished"); } }
Advantages of this style are that the beginning brace does not require an extra line by itself, and the ending brace lines up with the statement it conceptually belongs to. The big drawback here is that for block statements wrapped expressions require extra indentation because otherwise the block body is difficult to gather which violates symmetry.
GNU style.
Activates the GNU brace style. A brace style used throughout GNU EMACS and the Free Software Foundation code. Braces are put on a line by themselves. The braces are indented by 2 spaces, and the contained code is indented by a further 2 spaces.
Example 2.43. GNU style
private void routine() { if (!done) { doSomething(); } else { System.out.println("Finished"); } }
Synchronize with
Lets you synchronize the brace style of the currently selected block construct with the brace style of another one. Select an item in the list to have the brace style options updated accordingly. This option is only available when the global brace style check box is disabled.
Since 1.6
Lets you manually adjust the line wrapping behavior for braces. If one of the common brace styles does not satisfy your needs, you can manually adjust the appearance here.
Line break before left brace
Controls the line break behavior before the left curly brace. When enabled, a line break gets printed before the left curly brace.
Line break after right brace
Controls the line break behavior after the left curly brace. When enabled, a line break gets printed after the left curly brace whenever possible.
Treat class/method blocks different
It is common in the Java developer community to have the opening brace at the end of the line of the keyword for all types of blocks (Sun brace style). One may find the C++ convention of treating class/interface and method/constructor blocks different from other blocks useful (K&R style). With this option you can achieve exactly that: if enabled, class/interface and method/constructor blocks are then always printed in C brace style (line break before left brace).
Example 2.48. Sun brace style
class VolkswagenBeetle extends AbstractAutomobile { public void tootHorn() { if (isNull) { throwConstraintViolated(); } else { updateValue(); } } }
Example 2.49. Sun brace style, but class/method block treat different
class VolkswagenBeetle extends AbstractAutomobile { public void tootHorn() { if (isNull) { throwConstraintViolated(); } else { updateValue(); } } }
This option is only available when “Use global brace style” is enabled.
Treat class/method blocks different if wrapped
Enabling this option forces a line break before the left brace for
class/interface or method/constructor blocks (C style), if either the parameter
list spawns several lines and a throws clause follows, or one
of the possible clauses (extends,
implements, throws) was wrapped.
This option is only available when “Use global brace style” is enabled.
Treat statement blocks different if wrapped
Using the Sun brace style can make it hard to identify the start of the block body. The recommended workaround is to increase indentation for the expression statements during line wrap (see “Block continuation indentation”). But it may be easier to change the style of the block brace for such cases. Enabling this option does exactly that: It forces a line break before the opening brace for block statements (if/for/while etc.), if the statement expression could not be printed in just one line.
Since 1.7
Example 2.50. Wrapped block statement (Sun brace style)
if (((x > 0) && (y > 0)) || ((x < 0) && (y < 0))
&& ((x > y) || (x < -y))) {
reverseCourse();
}
Example 2.51. Wrapped block statement - left curly brace treated different
if (((x > 0) && (y > 0)) || ((x < 0) && (y < 0))
&& ((x > y) || (x < -y)))
{
reverseCourse();
}
This option is only available when “Use global brace style” is enabled or the style for Statements is currently configured.
Strictly obey brace style
When “Prefer wrap after assignments” and “Wrap before left curly brace” are enabled, a line break may be printed before the left curly brace of array initializers if the initializer does not fit into one line. But one might prefer to leave the curly brace in the same line as the variable declaration to obey the general brace style. With this option you can decide what you favor most: consistent brace style or consistent wrapping after assignments.
The option is only available, if line breaks should be printed before left curly braces (see “Wrap before left curly brace”) and either a global brace style (see “Use global brace style”) used or the brace style for arrays (see “Configure brace style”) is configured.
Since 1.8
Example 2.52. Favor consistent brace style
private String[] data = { "aaaaaaaaaaaaaaaaassssssssssssssssssssss", "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", "cccccccccccccccccccccccccccccccccccccccc", "dddddddddddddddddddddddddddddddddd", "eeeeeeeeeeeeeeeeeeeeeeeeeeee", "ffffffffffffffffffffffffffff" };
Example 2.53. Favor wrap after assignment
private String[] data = { "aaaaaaaaaaaaaaaaassssssssssssssssssssss", "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", "cccccccccccccccccccccccccccccccccccccccc", "dddddddddddddddddddddddddddddddddd", "eeeeeeeeeeeeeeeeeeeeeeeeeeee", "ffffffffffffffffffffffffffff" };
Lets you adjust the indentation white space for curly braces individually.
Before left brace
Defines the amount of blank space that should be printed before the left curly brace.
Before right brace
Defines the amount of blank space that should be printed before the right curly brace.
After right brace
Defines the amount of blank space that should be printed after the right curly brace.
Controls miscellaneous brace options.
Per definition braces are superfluous on single statements, but it is
a common recommendation that braces should be always used in such cases.
With this option, you can specify whether missing braces for single
statements should be inserted for the control statements if,
for, while and do-while
and labeled statements inside switch
blocks. Inserting and removing braces is mutually exclusive.
Single if
When enabled, braces are inserted around the body of
single if statements when necessary.
Since 1.9.1
Example 2.60. Brace insertion for if statement
if (condition) break;
would become
if (condition) { break; }
if...else
When enabled, braces are inserted around the body of
if...else statements when necessary.
Example 2.61. Brace insertion for if-else statement
if (true) break; else return;
would become
if (true) { break; } else { return; }
for
When enabled, braces are inserted around the body of
for statements when necessary.
Example 2.62. Brace insertion of for statements
for (int i = 0; i < count; i++) System.out.println(i);
would become
for (int i = 0; i < count; i++) { System.out.println(i); }
while
When enabled, braces are inserted around the body of
while statements when necessary.
Example 2.63. Brace insertion for while statements
while (!isDone)
doSomething();
would become
while (!isDone) {
doSomething();
}
do...while
When enabled, braces are inserted around the body of
do...while statements when necessary.
Example 2.64. Brace insertion for do...while statements
do something(); while (condition);
would become
do { something(); } while (condition);
switch
When enabled, braces are inserted around the body of
labeled statements inside switch blocks when necessary.
Braces are only inserted if the statement is not empty.
Since 1.4
Example 2.65. Brace insertion for labeled statements
switch (c) { case 'a': case 'b': System.out.println(); break; }
would become
switch (c) { case 'a': case 'b': { System.out.println(); break; } }
Only insert when statement takes more than one line
When enabled, brace insertion only happens when the block statement takes more than just one line to print.
Since 1.8
Example 2.66. Missing braces
if (arg == null) for (int i = 0; i < 10; i++) System.out.println("arg " + i);
Above you see an example with two block statements. Enabling brace insertion for if and for statements would yield:
Example 2.67. Inserted braces
if (arg == null) { for (int i = 0; i < 10; i++) { System.out.println("arg " + i); } }
You see braces inserted for both block statements. But when you’ve enabled the multi-line option, you will get:
Example 2.68. Inserted braces limited to multi-line statements
if (arg == null) { for (int i = 0; i < 10; i++) System.out.println("arg " + i); }
The statement of the if-block happens to be another block statement which is printed in two lines here, therefore the braces are inserted for the if-statement. The for-statement on the other hand does not have any braces inserted, because here the block can be printed in just one line.
It is permissible to remove braces in case they are superfluous. This not only
applies to the control statements if, for,
while and do-while,
but also to every block in general (remember a block is just a sequence of
statements, local class declarations and local variable declaration statements
within braces). Inserting and removing braces is mutually exclusive.
Single if
When enabled, braces around the body of single
if statements are removed when possible.
Since 1.9.1
Example 2.69. Brace removal for single if statements
if (true) { break; }
would become
if (true) break;
if..else
When enabled, braces around the body of
if...else statements are removed when possible.
Example 2.70. Brace removal for if statements
if (true) { break; } else { return; }
would become
if (true) break; else return;
for
When enabled, braces around the body of
for statements are removed when possible.
Example 2.71. Brace removal of for statements
for (int i = 0; i < count; i++) { System.out.println(i); }
would become
for (int i = 0; i < count; i++) System.out.println(i);
while
When enabled, braces around the body of
while statements are removed when possible.
Example 2.72. Brace removal for while statements
while (!isDone) {
doSomething();
}
would become
while (!isDone)
doSomething();
do...while
When enabled, braces around the body of
do...while statements are removed when possible.
Example 2.73. Brace removal for do...while statements
do { something(); } while (condition);
would become
do something(); while (condition);
switch
When enabled, braces are removed around the body of labeled statements inside switch blocks when possible.
Since 1.8
Example 2.74. Brace removal for switch
switch (c) { case 'a': case 'b': { System.out.println(); break; } }
would become
switch (c) { case 'a': case 'b': System.out.println(); break; }
Blocks
When enabled, arbitrary block braces are removed when possible.
Allows you to print statement blocks in just one line when possible, i.e. when the block only contains one statement and does not exceed the maximal line length. Please note that white space before a compacted block is not controlled by your general brace settings, but with the "Space before braces" option.
Methods
When enabled, method and constructor bodies will be printed in one line when possible.
Since 1.2
Single if
When enabled, single if statement bodies will be printed in
one line when possible.
Since 1.2
if
When enabled, statement bodies of the if the part of
if/else statement will be printed in one line when possible.
Since 1.2
Example 2.80. Standard if/else block
if (cond) { | return getMagicNumber(); | } else { | return -1 | }
Example 2.81. Compact if of if/else block
if (cond) { return getMagicNumber(); } | else { | return -1; | } |
Please note that when the if block has been compacted, the
following else if or else statement
always starts on a new line.
else if
When enabled, prints else if statement bodies of if/else
statements in one line when possible.
Example 2.82. Standard else of if/else block
if (cond1) { | return getMagicNumber(); | } else if (cond2) { | throw new IllegalStateException(); | } |
Example 2.83. Compact else if block
if (cond1) { | return getMagicNumber(); | } else if (cond2) { throw new IllegalStateException(); } |
Please note that when the else if block has been compacted,
the following else statement always starts on a new line.
Since 1.2
Example 2.84. Compact if block
if (cond1) { | return getMagicNumber(); | } else if (cond2) { throw new IllegalStateException(); } | else { | return 0; | } |
else
When enabled, prints else statement bodies in one line
when possible.
Since 1.2
Example 2.85. Standard else block
if (cond1) { | return getMagicNumber(); | } else if (cond2) { | throw new IllegalStateException(); | } else { | return 0 | } |
Example 2.86. Compact else block
if (cond1) { | return getMagicNumber(); | } else if (cond2) { | throw new IllegalStateException(); | } else { return 0; } |
Arrays
When enabled, array initializers will be printed in one line when possible.
Since 1.7
Enums
When enabled, enum declaration bodies will be printed in one line when possible.
Since 1.4
Enum constants
When enabled, enum constants will be printed in one line when possible. This option is only useful if you use constant-specific methods in your enums.
Since 1.4
Example 2.91. Enum constants with constant specific methods
public enum Operation { | PLUS { | double eval(double x, double y) { | return x + y; | } | }, | MINUS { | double eval(double x, double y) { | return x - y; } | }, | TIMES { | double eval(double x, double y) { | return x * y; | } | }, | | // Do arithmetic op represented by this constant | abstract double eval(double x, double y); | } |
Example 2.92. Compact enum constants with constant specific methods
public enum Operation { | PLUS { double eval(double x, double y) { return x + y; } }, | MINUS { double eval(double x, double y) { return x - y; } }, | TIMES { double eval(double x, double y) { return x * y; } }, | | // Do arithmetic op represented by this constant | abstract double eval(double x, double y); | } |
You can narrow the scope for the above mentioned options by selecting whether
all statements should be printed on one line when possible or
only throw and return statements.
Since 1.2
When enabled, all statements are compacted when possible.
Example 2.93. All statements on same line
if (true) { return result; } else if (false) { System.out.println("unexpected condition"); } else { throw new Error(); }
When enabled, only throw and return statements are compacted when possible. All other statements are printed in normal block style.
Example 2.94. Only throw and return statements on same line
if (true) { return result; } else if (false) { System.out.println("unexpected condition"); } else { throw new Error(); }
Controls how empty braces should be printed.
Cuddle braces
Prints both braces on one line right after the declaration or statement.
You can control the amount of white space that is printed before the left curly brace. See “Cuddled braces indent” for more information.
Obey brace style
Causes the left curly brace of the empty brace block to be positioned according to the current brace style settings. Depending on the style, the left brace is either printed directly after an element or will have a line break printed before. This option is only available when Section 2.8.6.2.4, “Cuddle braces” is enabled.
Since 1.7
Insert empty statement
Inserts an empty statement to make it obvious for the reader that the empty braces are intentional. Please note that this option does not apply for class/interface and method/constructor bodies, but is only used for control statements and blocks.
Lets you control the insertion of trailing comments after a closing brace to assist matching corresponding braces. Such comments are called identifying comments.
Class
Lets you insert identifying comments for class declarations.
Since 1.3
Example 2.99. Identifying class comment
public class Foo { public String getName() { return ...; } ... } // end class Foo
Interface
Lets you enable the insertion of identifying comments for interface declarations.
Since 1.3
Example 2.100. Identifying interface comment
public interface Fooable { public String getName(); ... } // end interface Fooable
Constructor
Lets you enable the insertion of identifying comments for constructor declarations.
Since 1.3
Example 2.101. Identifying constructor comment
public class Foo { public Foo() { super(); } // end ctor Foo ... }
Method
Lets you enable the insertion of identifying comments for method declarations.
Since 1.3
Example 2.102. Identifying method comment
public class Foo { public void getName() { return _name; } // end method getName ... }
if...else
Lets you enable the insertion of identifying comments for
if/else statement blocks.
Since 1.3
Example 2.103. Identifying if-else comment
if (true) { ... } // end if if (true) { ... } else if (false) { ... } // end if-else if (true) { ... } else if (false) { ... } else { ... } // end if-else
while
Lets you enable the insertion of identifying comments for
while statement blocks.
Since 1.3
for
Lets you enable the insertion of identifying comments for
for statement blocks.
Since 1.3
switch
Lets you enable the insertion of identifying comments for
switch statement blocks.
Since 1.8
try...catch...finally
Lets you enable the insertion of identifying comments for
try/catch/finally blocks.
Since 1.3
Example 2.107. Identifying try-catch comment
try { ... } catch (Throwable ex) { ... } // end try-catch try { ... } catch (IOException ex) { ... } finally { ... } // end try-catch-finally try { ... } finally { ... } // end try-finally
synchronized
Lets you enable the insertion of identifying comments for
synchronized statement blocks.
Since 1.3
Only add when brace body greater/equal than n lines
Lets you specify the size of a brace body that is necessary in order to see identifying comments inserted. For example, you might want to require identifying comments only on brace bodies that have at least 30 lines.
Since 1.3