// правильно
if (true) {
// неправильно
if (true)
{

// правильно
while (true) {
  // code
// неправильно
while (true) { // code

// правильно
for () {
  // code
}
// неправильно
while (true) { /* code */ }
// неправильно
if (true) {
  /* code */ }

return () -> {
  while (condition()) {
    method();
  }
};
return new MyClass() {
  @Override public void method() {
    if (condition()) {
      try {
        something();
      } catch (ProblemException e) {
        recover();
      }
    } else if (otherCondition()) {
      somethingElse();
    } else {
      lastThing();
    }
  }
};

// Приемлемо
void doNothing() {}
// Также приемлемо
void doNothingElse() {
}
// Неприемлемо: нельзя использовать пустые блоки в многоблочном выражении
try {
  doSomething();
} catch (Exception e) {}

MyLambda<String, Long, Object> lambda =
    (String label, Long value, Object obj) -> {
        ...
    };
Predicate<String> predicate = str ->
    longExpressionInvolving(str);

List<String> list

private int x; // хорошо
private Color color; // и это тоже
private int   x;      // разрешено, но при редактировании в будущем
private Color color;  // можно оставить без выравнивания

private enum Answer {
  YES {
    @Override public String toString() {
      return "yes";
    }
  },
  NO,
  MAYBE
}

private enum Suit { CLUBS, HEARTS, SPADES, DIAMONDS }

new int[] {
  0, 1, 2, 3
}
new int[] {
  0, 1,
  2, 3
}
new int[]
    {0, 1, 2, 3}
new int[] {
  0,
  1,
  2,
  3
}

switch (input) {
  case 1:
  case 2:
    prepareOneOrTwo();
    // fall through
  case 3:
    handleOneTwoOrThree();
    break;
  default:
    handleLargeNumber(input);
}

@Override
@Nullable
public String getNameIfPresent() { ... }

@Override public int hashCode() { ... }

@Partial @Mock DataLoader loader;

/*
* This is          // And so           /* Or you can
* okay.            // is this.          * even do this. */
*/

public protected private abstract default static final transient volatile synchronized native strictfp

<methodUnderTest>_<state>, например, pop_emptyStack

// Константы
static final int NUMBER = 5;
static final ImmutableList<String> NAMES = ImmutableList.of("Ed", "Ann");
static final ImmutableMap<String, Integer> AGES = ImmutableMap.of("Ed", 35, "Ann", 32);
static final Joiner COMMA_JOINER = Joiner.on(','); // because Joiner is immutable
static final SomeMutableType[] EMPTY_ARRAY = {};
enum SomeEnum { ENUM_CONSTANT }
// Не константы
static String nonFinal = "non-final";
final String nonStatic = "non-static";
static final Set<String> mutableCollection = new HashSet<String>();
static final ImmutableSet<SomeMutableType> mutableElements = ImmutableSet.of(mutable);
static final ImmutableMap<String, SomeMutableType> mutableValues =
    ImmutableMap.of("Ed", mutableInstance, "Ann", mutableInstance2);
static final Logger logger = Logger.getLogger(MyClass.getName());
static final String[] nonEmptyArray = {"these", "can", "change"};

try {
  int i = Integer.parseInt(response);
  return handleNumericResponse(i);
} catch (NumberFormatException ok) {
  // it's not numeric; that's fine, just continue
}
return handleTextResponse(response);

try {
  emptyStack.pop();
  fail();
} catch (NoSuchElementException expected) {
}

Foo aFoo = ...;
Foo.aStaticMethod(); // хорошо
aFoo.aStaticMethod(); // плохо
somethingThatYieldsAFoo().aStaticMethod(); // очень плохо

/**
* Multiple lines of Javadoc text are written here,
* wrapped normally...
*/
public int method(String p1) { ... }

/** An especially short bit of Javadoc. */