Jindent - Java Source Code Formatter http://www.jindent.com
 

previous topic  Previous:  Braces Style Next:  Lambda   next topic

title
5.6.1.3.2 Method/Constructor

Brace style for constructor/method declarations

Brace style for constructor/method declarations

Left brace { new line


Controls whether the left brace of a method/constructor declaration appears in the same line as the method/constructor head or in a new line.


Setting left brace to a new line:

public void method()                    
{                                       
    ...                                 


Do not set left brace to a new line:

public void method() {                  
    ...                                 



Right brace } new line


Since right braces of method/constructor declarations always appear in a new line this setting has no effect in this case.



Indent left brace {


Specifies the indentation size of left braces.


Setting left brace to a new line and using an indentation size of 4:

public·void·method()                    
····{                                   
····...                                 


Setting left brace to a new line and using an indentation size of 0:

public·void·method()                    
{                                       
    ...                                 


Do not set left brace to a new line and use indentation size of 1:

public·void·method()·{                  
    ...                                 


Do not set left brace to a new line and use indentation size of 0:

public·void·method(){                   
    ...                                 



Indent right brace }


Specifies the indentation size of right braces.


Left brace is on a new line and set indentation size of 4 for left and right braces:

public·void·method()                    
····{                                   
····...                                 
····}                                   


Left brace is on a new line and set indentation size of 0 for left and right braces:

public·void·method()                    
{                                       
····...                                 
}                                       



Indent after right brace }


Since no tokens (except comments) can appear directly after right braces of method/constructor declarations this setting has no effect in this case.



Cuddle braces of empty blocks {}


Specifies how to format braces of empty method/constructor blocks.


Cuddle braces of empty blocks:

public void method() {}                 


Do not cuddle braces of empty blocks:

public void method() {                  
}                                       



Indent cuddled braces {}


Controls the indentation size of cuddled braces.


Cuddle braces of empty blocks and use an indentation of 0:

public·void·method(){}                  


Cuddle braces of empty blocks and use an indentation of 1:

public·void·method()·{}                 



Prohibit blank lines after left brace {


Prohibits blank lines directly after a left brace of method/constructor blocks.

Some code conventions require a blank line before each comment.
Such a formatting looks proper if the comment, for instance, appears between two statements.
But if a comment follows directly after a left brace of method or constructor blocks an unecessary gap can appear.


Left brace of method block is set to a new line using an indentation size of 0.
Additionally a blank line shall be inserted before comments:

public void method()                    
{                                       
                                       
    // comment with a preceding blank line
    callAnotherMethod();                
                                       
    // another comment                  
    ...                                 
}                                       


In the example above the left brace and blank line before the comment seem to create an unnecessary gap.
To avoid such a gap just prohibit blank lines after left braces:

public void method()                    
{                                       
    // comment with a preceding blank line
    callAnotherMethod();                
                                       
    // another comment                  
    ...                                 
}                                       

Now the blank line before the first comment disappeared and closed the gap, but all other comments still contain the expected blank line as usual.
Of course this works for all kind of blank lines and not only for blank lines before comments.

See also... See also: Jindent - Settings - Formatter - Java / SQLJ - Blank Lines - Comments , Jindent - Settings - Formatter - Java / SQLJ - Blank Lines




If number of lines in body is at least ... then insert blank line after {


Inserts an extra blank line after left braces of methods/constructors containing a certain number of lines in their bodies.

Code conventions which prefer the K&R brace style (also known as Kernal, Java or Sun Style: do NOT put left brace to a new line) can run into a specific issue regarding readability of source code.


Let's assume the following source code example is formatted in a typical K&R brace style:

public int getCentimeters() {           
    return measure;                     
}                                       
                                       
public int getMeters() {                
    int meters = measure / 100;         
    return meters;                      
}                                       
                                       
public void doSomething(int n) {        
    callMethodA(n);                     
    for (int i = 0; i < n; i++) {       
        callMethodB(i);                 
        callMethodC(i);                 
    }                                   
    callMethodD(i);                     
}                                       

In this case formatting of method getCentimeters() looks fine, but method doSomething(int) seems to be formatted too close: The method head public void doSomething(int n) { and the first block statement callMethodA(n); are connected too close and could cause confusion.
To avoid a too close formatting for specific methods/constructors use setting "If number of lines in body is at least ... then insert blank line after {" to insert an extra blank line before the first block statement.


The same example as above, but now using setting "If number of lines in body is at least ... then insert blank line after {" with a value of 2.


public int getCentimeters() {           
    return measure;                     
}                                       
                                       
public int getMeters() {                
                                       
    int meters = measure / 100;         
    return meters;                      
}                                       
                                       
public void doSomething(int n) {        
                                       
    callMethodA(n);                     
    for (int i = 0; i < n; i++) {       
        callMethodB(i);                 
        callMethodC(i);                 
    }                                   
    callMethodD(i);                     
}                                       

Now formatting of method doSomething(int) seems to be much clearer and methodgetMeters() is still formatted as before.
This setting counts the lines of code in every method/constructor body and if at least 2 lines are counted then an extra blank line is inserted after the left brace of method/constructor head.
With this setting typical small getter/setter methods can be kept compact, but methods/constructors with an extended body are formatted more spacious and clearer.


The same example again, but ""If number of lines in body is at least ... then insert blank line after {"" is set to value 3.


public int getCentimeters() {           
    return measure;                     
}                                       
                                       
public int getMeters() {                
    int meters = measure / 100;         
    return meters;                      
}                                       
                                       
public void doSomething(int n) {        
                                       
    callMethodA(n);                     
    for (int i = 0; i < n; i++) {       
        callMethodB(i);                 
        callMethodC(i);                 
    }                                   
    callMethodD(i);                     
}                                       

Now method getMeters() is formatted in the same way as getCentimeters().


Using value 0:

public int getCentimeters() {           
                                       
    return measure;                     
}                                       
                                       
public int getMeters() {                
                                       
    int meters = measure / 100;         
    return meters;                      
}                                       
                                       
public void doSomething(int n) {        
                                       
    callMethodA(n);                     
    for (int i = 0; i < n; i++) {       
        callMethodB(i);                 
        callMethodC(i);                 
    }                                   
    callMethodD(i);                     
}                                       

And all methods are formatted more spacious.

To turn this setting completely off just choose value infinite.



If number of lines in body is at least ... then insert blank line before }


Inserts an extra blank line before right braces of methods/constructors containing a certain number of lines in their bodies.

This setting works exactly in the same way as "If number of lines in body is at least ... then insert blank line after {", but now the extra blank line will be inserted at the end of method/constructor bodies.


Let's assume "If number of lines in body is at least ... then insert blank line after {" is set to 2 and "If number of lines in body is at least ... then insert blank line before }" is set to 2 too:

public int getCentimeters() {           
    return measure;                     
}                                       
                                       
public int getMeters() {                
                                       
    int meters = measure / 100;         
    return meters;                      
                                       
}                                       
                                       
public void doSomething(int n) {        
                                       
    callMethodA(n);                     
    for (int i = 0; i < n; i++) {       
        callMethodB(i);                 
        callMethodC(i);                 
    }                                   
    callMethodD(i);                     
                                       
}                                       

This setting creates an even more spacious formatting style.



Do not insert blank line before single left brace


Since right braces of method/constructor declarations always appear in a single way (in a new line) this setting should be unchecked to avoid confusion.



See also... See also: Jindent - Settings - Formatter - Java / SQLJ - Braces Style - Presets