Indentation and spacing rules

The following are general guidelines; they do not constitute a complete or precise specification of formatting style. Exercise your judgment in resolving unclear issues.

1. Use four columns for each successive level of indentation.
2. Indent the bodies of
   • classes
   • methods
   • if statements
   • compound statements
   • loops
   • try and catch blocks
   For methods, place the opening brace on a new line, flush with the method's header. For structured statements, place the opening brace at the end of the opening line. An else should be placed on the same line as the right brace, if any, that ends the if block.
3. Indent the case arms of a switch statement. Note that this puts the actual code two levels in from the opening line.
4. Leave one blank line between adjacent class or method declarations.
5. Start a new line after each statement or declaration, whether terminated by a right brace or a semicolon. Do not start a new line after the internal parts of a for loop header, however.
6. Leave one blank space between adjacent tokens within the same line, with the following exceptions:
   • no space between a prefix or postfix operator and its operand (this includes array subscripts and the trailing portions of a qualified name)
   • no space between a method name and its argument list (but do leave space between an if or while and its condition, and between a catch and its parenthesized formal parameter)
   • no space immediately inside a parenthesis or bracket
   • no space before a semicolon
   • four spaces between code and an end-of-line comment

These rules are followed, for the most part, by the Sieve.java and BounceThread.java example programs made available during the previous assignment. They are also followed for the most part by the provided C code, to the extent it resembles Java. Note that the rules may not format programs the way you like to write them yourself. Feel free to use your own favorite style in the code you write, but make sure your code produces output that follows the rules described here.

Comments are a little tricky, and not particularly instructional, so I've given you code to handle them. This code enforces the following rules:

• If a comment is preceded by a newline (and maybe some other white space) in the input, it induces a preceding newline in the output. If an old-style comment is followed by a newline in the source, it induces a following newline in the output. These are the only cases in which your code should pay attention to white space or formatting in the input. A new-style (//) comment obviously induces a following newline at its end.
• If a comment of either type induces a preceding or following newline, and also comes at a point where there would be a newline anyway (right after the semicolon at the end of a statement, for example), then we refrain from adding an extra newline (so we don't actually end up with a blank line).
• Comments that are the first non-whitespace on their line are indented at the level appropriate to a statement in that position.
• Subsequent lines of multi-line old-style (/* */) comments are not indented; they have whatever formatting they had in the input.
• If a comment comes after some other (non-white-space) tokens in an input line, it is separated from the preceding token by four spaces.

Here is some useless code that may give you more sense of the formatting desired (and the already-existing formatting of comments):

  public class foo {    // Note 4 spaces before comment
      // Also note change in indentation, and blank line before method
  
      public void bar(int arg1, int[] arg2)
      {    // Note brace is on new line
          ;
      }
  
      /* Note blank line after method.  If the next "real" code is another
             method you probably don't want a second line, even if there is
             a comment (like this one) in-between:
       the comment is probably associated with the new method.
         Also, you probably don't want to worry about ugly
   indentation or other aspects of formatting within multi-line
         comments.  Just indent the *first* line of the comment
         appropriately and leave the rest alone. */
      public foo()    // constructor
      {
          for (i = 0; i < limit; i++) {
              if (A[i] > (n = foo(i))) {
                  A[i] = n;
              } else {
                  A[i]--;    // Note no newline before this comment.
              }
              // But there is a newline before this comment, because there
              // was one in the input.  In the previous case there was no
              // newline between the semicolon and the comment in the source.
          }
          switch (c) {
              case 'a':
              case 'b':
                  System.out.println    /* Note newline after this comment */
                  /* (There was one in the input.) */ ("a or b");
              case 'x':
                  System.out.println("x");
              default:
                  break;
          }
          while (true) {
              boolean done = check();
              if (done)
                  break;
              try {
                  try_again(++i);
              } catch (exc x) {
                  System.out.println("and again");
              } finally {
                  System.out.println("and again!");
              }
          }
      }    // end constructor, followed by blank line
  
  }    // end foo
  
  class little_struct {    // Note blank line between classes.
      int a;
      char b;
      float c;
  }
  

    Back to the grading page

    Back to the course home page