Incremental Java
Style: Indenting if, if-else, and method bodies

That's certainly true. But it's more than that. Programs are often evolving, changing. New features are added. Functionality is changing. Different people work on the programs.

There's a need for people to read programs and understand it, and one way to do this is to write programs with good style. Good style helps you understand a program by removing distractions.

• methods, variables Don't use underscores. Variable names and methods should be one or more "words" concatenated together, where the first character of each word is capitalized (except the first word). Example: count, numApples, numActiveThreads.
• class Don't use underscores. Class names also concatenate words. The first character of each word should be capitalized. Examples: Triangle, SortedList, ServerLoggingRequest

Indentation allows the physical layout (how the code appears on the screen) to match the logical layout (what the code means).

Let's look at some indentation.

public class Foo
{
  // CODE
}

public class Foo
{
   private int count ;
   private boolean isValid ;

   public static void main( String [] args )
   {
      // CODE
   }
}

As you can see, main() also has its own block (i.e., the method body). So anything in main() should be indented 3 more spaces in (for a total of 6 spaces).

public class Foo
{
   private int count ;
   private boolean isValid ;

   public static void main( String [] args )
   {
      // Indented 6 spaces in
      int val = 3, x = 2 ;
      System.out.println( "val is " + val ) ;
   }
}

Let's see an example with an if statement that has a block.

public class Foo
{
   private int count ;
   private boolean isValid ;

   public static void main( String [] args )
   {
      // Indented 6 spaces in
      int val = 3, x = 2 ;
      if ( val == x )
      {
         // Indented 6 spaces in
         x++ ;
         System.out.println( "Incrementing x" ) ;
      }
      System.out.println( "val is " + val ) ;
   }
}

The open/close brace in the if body lines up with the letter 'i' of the if statement.

Look at the last println() (which prints "val is.."). It's not in the if body so it is not indented in 9 spaces. It's indented to the same position as the if statement itself.

public class Foo
{
   private int count ;
   private boolean isValid ;

   public static void main( String [] args )
   {
      // Indented 6 spaces in
      int val = 3, x = 2 ;
      if ( val == x )
      {
         x++ ;
         System.out.println( "Incrementing x" ) ;
      }
      else
         x-- ;
      System.out.println( "val is " + val ) ;
   }
}

foo.bar() ;
foo.bar( 10 ) ;
foo.bar( 10, 20 ) ;
foo.bar( 10, x + y ) ;
foo.bar( 10, x + ( y - z ) ) ;

On the first line, I show an example where the argument list is empty. I write an open and close parentheses.

On the second line, I have a single argument. I add one space after the open parenthesis and one before the close parenthesis. I'll admit this is uncommon, but I like the way it looks.

On the third line, I have two arguments. As on the second line, I have the one space after the open parenthesis and one space before the close parenthesis. I also put one space after the comma, separating the arguments. Putting a single space after the comma is a widely accepted style.

On the fourth line, I have an expression for the second argument. I use a space before and after the + operator. Some people don't like doing this because it adds too much space.

Some use no space at all, and write:

foo.bar(10, x+y) ;

foo.bar(10, x+ y) ;

The fifth line has a more complex expression for the second argument. It looks like:x + ( y - z ). It uses all the rules from before. Add a space before and after operators. Add a space after left parenthesis and before right parenthesis.

Parameter Lists

public int computeCost( int cost, int tax ) ;