[Skip to content]

2.8.6. Braces

Controls the handling of curly braces (the Java block delimiters).

2.8.6.1. Layout

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).

Figure 2.34. Braces Layout settings page (Global view)

Braces Layout settings page (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

Figure 2.35. Braces Layout settings page (Details view)

Braces Layout settings page (Details view)

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

2.8.6.1.1. Line Wrapping

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.

Example 2.44. No line break before left brace

if(true){
    doSomething();
}

Example 2.45. Line break before left brace

if(true)
{
    doSomething();
}

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.

Example 2.46. No line break after right brace

try{
    doSomething();
}catch (Exception ex){
}

Example 2.47. Line break after right brace

try{
    doSomething();
}
catch (Exception ex){
}

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"
    };

2.8.6.1.2. White Space

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.

Example 2.54. No white space before left brace

if(true){
    doSomething();
}

Example 2.55. One space before left brace

if(true) {
    doSomething();
}

Before right brace

Defines the amount of blank space that should be printed before the right curly brace.

Example 2.56. No white space before right brace

if(true){
    doSomething();
}else{
    quit()();
}

Example 2.57. One space before right brace

if(true){
    doSomething();
}else {
    quit()();
}

After right brace

Defines the amount of blank space that should be printed after the right curly brace.

Example 2.58. No white space after right brace

if(true){
    doSomething();
}else{
    quit()();
}

Example 2.59. One space after right brace

if(true){
    doSomething();
} else{
    quit()();
}

2.8.6.2. Misc

Controls miscellaneous brace options.

Figure 2.36. Braces Misc settings page

Braces Misc settings page

2.8.6.2.1. Insert braces for

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.

2.8.6.2.2. Remove braces

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.

Example 2.75. Brace removal for blocks

{
    System.out.println();
}

would become

System.out.println();


2.8.6.2.3. Compact braces

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

Example 2.76. Standard method declaration

public int getMagicNumber() {                                |
    return 23;                                               |
}                                                            |

Example 2.77. Compact method declaration

public int getMagicNumber() { return 23; }                   |

Single if

When enabled, single if statement bodies will be printed in one line when possible.

Since 1.2

Example 2.78. Standard if block

if (cond) {                              |
    return getMagicNumber();             |
}                                        |

Example 2.79. Compact if block

if (cond) { return getMagicNumber(); }   |

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

Example 2.87. Array initializer

String[] s = {                            |
        "First"                           |
    };                                    |

Example 2.88. Compact array initializer

String[] s = { "First" };                 |

Enums

When enabled, enum declaration bodies will be printed in one line when possible.

Since 1.4

Example 2.89. Enum declaration

public enum Mode {                                         |
    OPEN, CLOSE                                            |
}                                                          |

Example 2.90. Compact enum declaration

public enum Mode { OPEN, CLOSE }                           |

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);                     |
}                                                                 |

Enable for

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

All statements

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(); }

Only throw and return

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(); }

2.8.6.2.4. Empty braces

Controls how empty braces should be printed.

Cuddle braces

Prints both braces on one line right after the declaration or statement.

Example 2.95. Cuddled empty braces

class Foo {

    public void foo() { }
}

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

Example 2.96. Cuddled braces, C brace style

class Foo
{

    public void foo() { }
}

Example 2.97. Cuddled braces, C brace style, obey brace style

class Foo
{

    public void foo()
    { }
}

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.

Example 2.98. Empty braces with empty statement

class Foo {

    public void foo() {
        ;
    }
}

2.8.6.3. Comments

Lets you control the insertion of trailing comments after a closing brace to assist matching corresponding braces. Such comments are called identifying comments.

Figure 2.37. Braces Comments settings page

Braces Comments settings page

2.8.6.3.1. Insert identifying comments for
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

Example 2.104. Identifying while comment

while (true) {
    ...
} // end while

for

Lets you enable the insertion of identifying comments for for statement blocks.

Since 1.3

Example 2.105. Identifying for comment

for (int i = 0; object.length; i++) {
    ...
} // end for

switch

Lets you enable the insertion of identifying comments for switch statement blocks.

Since 1.8

Example 2.106. Identifying switch comment

switch (state) {
    ...
} // end switch

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

Example 2.108. Identifying synchronized comment

synchronized (this) {
    ...
} // end synchronized

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