[Skip to content]

2.8.10. Separation

Lets you control the insertion of blank lines to separate statements or declarations with different functions or meanings. Just as related statements should be grouped together, unrelated statements should be separated from each other. In English, the start of a new paragraph is identified with indentation or a blank line. This greatly aids reading ease and helps to improve comprehension and reading speed. When coding, you should strive for a similar goal and always give the reader hints as to how the program is organized.

With Jalopy you are able to enforce consistent blank lines behavior and divide groups of related statements into paragraphs, separate routines from one another and highlight comments. You can give Jalopy complete control over the blank lines handling, or use a more relaxed style and keep existing blank lines up to a given number.

2.8.10.1. General

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

Blank Lines settings page

Package statement

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

Example 2.672. 3 blank lines after 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.

Example 2.673. 4 blank lines after 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 {
}

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 Section 2.8.11.1, “Declarations” for more information about the code sorting feature.

Since 1.4

Example 2.674. 2 blank lines before code sections

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

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.

Example 2.675. 1 blank line before class declaration

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.

Example 2.676. 2 blank lines between two class declarations

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.

Example 2.677. 2 blank lines before first 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.

Example 2.678. 3 blank lines between two interface declarations

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

Example 2.679. 3 blank lines between two enum declarations

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

Example 2.680. 2 blank lines between two enum declarations

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.

Example 2.681. 3 blank lines between two method 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.

Example 2.682. 1 blank line before variable declarations

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

Example 2.683. 2 blank lines after variable declarations

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

Example 2.684. Blank lines before Javadoc=1

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

Example 2.685. Blank lines before Javadoc=1, Blank lines after left curly braces=0

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

Example 2.686. Keep blank lines=1

private final void loadVersion() {
¶
    check();
}

Example 2.687. Keep blank lines=1, Blank lines after left curly braces methods=0

private final void loadVersion() {
    check();
}

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.

Example 2.688. Blank lines before blocks=1

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

Example 2.689. Blank lines before blocks=1, Blank lines after left curly braces=0

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

Example 2.690. Blank lines before blocks=1

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

Example 2.691. Blank lines before blocks=1, Blank lines after left curly braces=0

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.

Example 2.692. Blank lines before blocks=1

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.

Example 2.693. 2 blank lines before and after blocks

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.

Example 2.694. 3 blank lines before case blocks

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.

Example 2.695. 2 blank lines before case control statements

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.

Example 2.696. Setting takes no effect before case control statements

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

    default :
        continue;
}

Example 2.697. Setting takes no effect for single statements in blocks

if (isClean())
    return;

Single-line comments

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

Example 2.698. 1 blank line before single-line comment

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.

Example 2.699. 2 blank lines before multi-line comment

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

Example 2.700. 2 blank lines before/after separator comment

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.

Example 2.701. No blank lines after header

// 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;

...

Example 2.702. 2 blank lines after header

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

Example 2.703. 2 blank lines before/after SQLJ clause

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

Example 2.704. 1 blank line after assignment section

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

2.8.10.2. Misc

Lets you control miscellaneous separation settings.

Figure 2.47. Blank Lines Misc settings page

Blank Lines Misc settings page

Keep blank lines up to

When enabled, retains up to the given number of blank lines found in the original source. Note that Jalopy still takes your other blank lines settings into account. If you disable this option, all original blank lines will be ignored!

Example 2.705. Source code with blank lines to separate declaration sections

aMVString = new MultiValueString("abc");
¶
System.out.println("MV = "+aMVString);
¶
System.out.println("MV0 = "+aMVString.extract(0));
System.out.println("MV1 = "+aMVString.extract(1));
System.out.println("MV2 = "+aMVString.extract(2));
System.out.println("");

If this feature is left disabled, Jalopy will print the individual lines according to the current blank lines settings but won’t try to keep any blank lines.

Keep blank lines in headers up to

When enabled, retains up to the given number of blank lines found in the original source file between header (and footer) comments. This option is only signficant when you enable the header/footer feature and specify a multi-header template, without enabling the override mode.

Since 1.7

Example 2.706. Source code with blank lines to separate headers

/*
 * Foo.java
 * 
 * $Header: //depot/foo/src/main/com/foo/Foo.java#13 $
 *//*
 * Copyright (c) 2002 FooBar, Inc. All rights reserved.
 *
 * This software is the confidential and proprietary information
 * of FooBar, Inc. ("Confidential Information"). You shall not
 * disclose such Confidential Information and shall use it only
 * in accordance with the terms of the license agreement you
 * entered into with FooBar, Inc.
 */
package com.foobar.lemon;

2.8.10.2.1. Chunks

Lets you define what makes a chunk: a section of associated statements. With "Variable identifiers" and/or "Align assignments" enabled, Jalopy determines what statements can be aligned using these options. With “Align endline comments” enabled, Jalopy determines what comments should be aligned together.

By comments

When enabled, a statement with a comment before is recognized as the start of a new chunk.

Example 2.707. Aligned assignments/identifiers

String        text  = "text";
int           a     = -1;
// create a new entry
History.Entry entry = new History.Entry(text);

Example 2.708. Aligned assignments/identifiers, chunks by comments

String text  = "text";
int    a     = -1;
// create a new entry
History.Entry entry = new History.Entry(text);

By blank lines

When enabled, a statement which has one or more blank lines before is recognized as the start of a new chunk.

Example 2.709. Aligned assignments/identifiers

String        text  = "text";
int           a     = -1;
¶
History.Entry entry = new History.Entry(text);

Example 2.710. Aligned assignments/identifiers, chunks by blank lines

String text  = "text";
int    a     = -1;
¶
History.Entry entry = new History.Entry(text);

By line wrap

When enabled, a statement that takes more than just one line to print is recognized as the start of a new chunk. With standard indentation, it is recommended to have this option enabled, because otherwise wrapped expressions might obscure aligned assignments. Please note that this option does not affect endline comments!

Since 1.3

Example 2.711. Aligned assignments

int labelR_x      = Math_min(iconR.x, textR.x);
int labelR_with   = Math_max(iconR.x + iconR.width, textRrr.x) -
    labelR_x;
int labelR_width  = Math_max(iconR.x + iconR.width, textRrr.x) -
    labelR_x;
int labelR_y      = Math_min(iconR.y, textR.y);
int labelR_height = Math_max(iconR.y + iconR.height,
        textR.y + textR.height);
int labelR_x      = Math_min(iconR.x, textR.x);
int lab           = Math_min(iconR.x, textR.x);

Example 2.712. Aligned assignments, chunks by line wrap, prefer wrap after assign

int labelR_x = Math_min(iconR.x, textR.x);
int labelR_with =
    Math_max(iconR.x + iconR.width, textRrr.x) - labelR_x;
int labelR_width =
    Math_max(iconR.x + iconR.width, textRrr.x) - labelR_x;
int labelR_y = Math_min(iconR.y, textR.y);
int labelR_height =
    Math_max(iconR.y + iconR.height, textR.y + textR.height);
int labelR_x = Math_min(iconR.x, textR.x);
int lab      = Math_min(iconR.x, textR.x);

Remove blank lines for method prototypes

When enabled, blank lines around abstract method declarations are removed. This includes all methods in interfaces (which are implicitly abstract). And all methods explicitely declared abstract in classes. If left disabled, blank lines will be printed according to the blank lines settings for methods (see “Blank lines after methods”).

Since 1.2

Example 2.713. Method prototypes

interface foo {

    public void method1();

    public void method2();

    public void method3();
}

Example 2.714. Method prototypes without blank lines

interface foo {
    public void method1();
    public void method2();
    public void method3();
}

Ignore control statements option for break in switch

When enabled, the “Blank Lines before control statements” option is ignored for break statements within switch blocks.

Since 1.3

Example 2.715. 1 blank lines before control statements

switch (number) {
    case 1:
        System.out.println();

        break;

    default:
        System.out.println();

        break;
}

Example 2.716. 1 blank lines before control statements, but option ignored

switch (number) {
    case 1:
        System.out.println();
        break;

    default:
        System.out.println();
        break;
}

Ignore blocks option in switch

When enabled, the “Blank lines for blocks” option is ignored within switch blocks.

Since 1.3

Example 2.717. 1 blank lines before blocks

switch (number) {
    case 1:

        if (DEBUG)
            System.out.println("FIRST NUMBER");

        break;

    default:

        while (true)
            perform();

        break;
}

Example 2.718. 1 blank lines before blocks, but option ignored

switch (number) {
    case 1:
        if (DEBUG)
            System.out.println("FIRST NUMBER");

        break;

    default:
        while (true)
            perform();

        break;
}