Lets you specify the number of blank lines that should appear before, after and between different Java source elements.

Figure 2.46. Blank Lines settings page

Declaration section

Lets you control how many blank lines should be printed before a new declaration section. A declaration section means an arbitary amount of similar declarations, like e.g. instance initializers, or methods or enum declarations. This option is only meaningful when code sorting is enabled for declarations. Refer to the section called “Declarations” for more information about the code sorting feature.

Since 1.4

private Foo aFoo;
¶
¶
Constructor(Foo rFoo) {
}
¶
¶
public static void method(Foo rFoo) {
}

Package statement

Lets you control how many blank lines should be printed after the package statement.

package com.triemax.jalopy.printer;
¶
¶
¶
import antlr.collections.AST;

import com.triemax.jalopy.parser.JavaAST;
import com.triemax.jalopy.parser.JavaTokenTypes;

...

Imports

Lets you control how many blank lines should be printed after the last import statement.

package com.triemax.jalopy.printer;

import antlr.collections.AST;

import com.triemax.jalopy.parser.JavaAST;
import com.triemax.jalopy.parser.JavaTokenTypes;
¶
¶
¶
¶
public class Printer {
}

Classes

Lets you control how many blank lines should be printed before the first top level class declaration of a compilation unit and between two class declarations.

¶
class Foo {
}

The blank lines before setting is only meaningful if the class declaration is the first top level declaration of a compilation unit and not preceded by a package or import statement.

class One {
}
¶
¶
class Two {
}

Interfaces

Lets you control how many blank lines should be printed before the first top level interface declaration of a compilation unit and between two interface declarations.

¶
¶
interface Fooable {
}

The blank lines before setting is only meaningful if the interface declaration is the first top level declaration of a compilation unit and not preceded by a package or import statement.

interface One {
}
¶
¶
¶
interface Two {
}

Enums

Lets you control how many blank lines should be printed before the first top level enum declaration of a compilation unit and between two enum declarations. The blank lines before setting is only meaningful if the enum declaration is the first top level declaration of a compilation unit and not preceded by a package or import statement.

Since 1.1

public enum Season {
    WINTER, SPRING, SUMMER, FALL
}
¶
¶
¶
public enum Day {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}

Annotations

Lets you control how many blank lines should be printed before the first top level annotation declaration of a compilation unit and between two annotation declarations. The blank lines before setting is only meaningful if the annotation declaration is the first top level declaration of a compilation unit and not preceded by a package or import statement.

Since 1.1

public @interface Name {
    String first();
    String last();
}
¶
¶
public @interface Endorsers {
    String[] value();
}

Methods

Lets you control how many blank lines should be printed between two method/constructor declarations.

public static Printer getInstance() {
    return INSTANCE;
}
¶
¶
¶
public void print(AST node, ASTWriter out)
           throws IOException {
}

Variables

Lets you control how many blank lines should be printed before and after variable declarations.

System.out.println();
¶
int a = 1;
int b = 2;

int a = 1;
int b = 2;
¶
¶
System.out.println();

Left curly brace class

Forces the given number of blank lines after left curly braces of class, interface and enum declarations. You need to explicitly enable the option to take effect. When enabled, this option takes highest precedence and overrides all other blank line settings.

Please note that you need to set this option only if you want different left curly blank lines behavior for class level blocks. Otherwise, the corresponding options for left curly brace endline/newline would be enough to enforce consistent behavior.

Since 1.9.1

class Demo {

    /** Demo method */
    public void foo() {
    }
}

class Demo {
    /** Demo method */
    public void foo() {
    }
}

Left curly brace method

Forces the given number of blank lines after left curly braces of method and constructor declarations. You need to explicitly enable the option to take effect. When enabled, this option takes highest precedence and overrides all other blank line settings.

Please note that you need to set this option only if you want different left curly blank lines behavior for method level blocks. Otherwise, the corresponding options for left curly brace endline/newline would be enough to force consistent behavior.

Since 1.9.1

public void foo {

    // do something
}

public void foo {
    // do something
}

Left curly brace endline

Forces the given number of blank lines after left curly braces that are printed at the end of the line beginning the compound statement (a.k.a. Sun brace style). You need to explicitly enable the option to take effect. When enabled, this option overrides all other blank line settings other than Left curly brace class and Left curly brace method.

public void foo() {
¶
    if (condition()) {
¶
        if (anotherCondition()) {
            doSomething();
        }
    }
}

public void foo() {
    if (condition()) {
        if (anotherCondition()) {
            doSomething();
        }
    }
}

Left curly brace endline newline

Forces the given number of blank lines after left curly braces that are printed at the beginning of lines (a.k.a. C brace style). When enabled, this option overrides all other blank line settings.

Since 1.7

public void foo()
{
¶
    if (condition())
    {
¶
        if (anotherCondition())
        {
            doSomething();
        }
    }
}

public void foo()
{
    if (condition())
    {
        if (anotherCondition())
        {
            doSomething();
        }
    }
}

Right curly brace

Forces the given number of blank lines before closing curly braces, no matter what other blank lines settings dictate.

public void foo() {
    if (condititon()) {
        if (anotherCondition()) {
            doSomething();
¶
        }
¶
    }
¶
}

Blocks

Lets you control how many blank lines should be printed before and after statement blocks (if-else , for, while, do-while, switch, try-catch-finally, synchronized). Note that the “Blank Lines After” setting also applies for anonymous inner classes.

AST type = null;
¶
¶
switch (next.getType()) {
    case JavaTokenTypes.LPAREN :
        type = PrinterUtils.advanceToFirstNonParen(next);
        break;
    default :
        type = next;
        break;
}
¶
¶
AST ident = type.getFirstChild();

Case blocks

Lets you control how many blank lines should be printed before each case block of a switch expression.

switch (next.getType()) {
¶
¶
¶
    case JavaTokenTypes.LPAREN :
        type = PrinterUtils.advanceToFirstNonParen(next);
        break;
¶
¶
¶
    default :
        type = next;
        break;
}

Control statements

Lets you control how many blank lines should be printed before the statements return, break and continue.

switch (next.getType()) {
    case JavaTokenTypes.LPAREN :
        type = PrinterUtils.advanceToFirstNonParen(next);
¶
¶
        break;

    default :
        type = next;
¶
¶
        break;
}

Note that this setting does not apply when a control statement appears directly after the case or default keyword or when the statement is the single member of a statement block without curly braces.

switch (next.getType()) {
    case JavaTokenTypes.LPAREN :
        break;

    default :
        continue;
}

if (isClean())
    return;

Single-line comments

Lets you control how many blank lines should be printed before single-line comments.

System.out.println("ERROR");
¶
// XXX use log4j logger
ex.printStackTrace();

Multi-line comments

Lets you control how many blank lines should be printed before multi-line comments.

System.out.println("ERROR");
¶
¶
/* XXX use log4j logger */
ex.printStackTrace();

Javadoc comments

Lets you control how many blank lines should be printed before Javadoc comments.

Separator comments

Lets you control how many blank lines should be printed before and after separator comments.

Since 1.7

protected Foo instance;
¶
¶
//~ Constructors -----------------------------------------------------------
¶
¶
public Demo ( ) {}
public Demo (  Foo anotherFoo ) {}

Header

Lets you control how many blank lines should be printed before and after headers.

// Copyright 1998-2000, Foo, Inc. All Rights Reserved.
// Confidential and Proprietary Information of Foo, Inc.
// Protected by or for use under one or more of the following patents:
// U.S. Patent Nos. X,XXX,XXX. Other Patents Pending.
package com.foobar;

...

// Copyright 1998-2000, Foo, Inc. All Rights Reserved.
// Confidential and Proprietary Information of Foo, Inc.
// Protected by or for use under one or more of the following patents:
// U.S. Patent Nos. X,XXX,XXX. Other Patents Pending.
¶
¶
package com.foobar;

...

Footer

Lets you control how many blank lines should be printed before and after footers.

SQLJ clauses

Lets you control how many blank lines should be printed before and after SQLJ clauses.

Integer salesRepID   = new Integer(358);
String  salesRepName = "Jouni Seppanen";
Date    dateSold     = new Date(97,11,6);
¶
¶
#sql { INSERT INTO SALES VALUES( :itemID,:itemName,:dateSold,:totalCost,
      :salesRepID,:salesRepName) };
¶
¶
SalesRecs sales;

Assignment section

Lets you control how many blank lines are printed after a section with several (at least two) consecutive assignment expressions.

Since 1.4

c.fill = GridBagConstraints.HORIZONTAL;
c.insets = new Insets(0, 0, 0, 0);
¶
middlePanel.add(buttonsPanel, c);