=====Korrektes Einrücken=====
Es wird ja von vielen Anfängern als unnötig pingelig betrachtet, wenn das Einrücken des Quellcodes so wichtig genommen wird. Aber wenn es drauf ankommt, ist man immer froh, wenn man gewissenhaft vorgegangen ist, weil das genau den Unterschied macht zwischen Fehler finden oder aufgeben müssen.

Außerdem verlangt es der Anstand, dass man sein Programm dem Leser ordentlich darbietet. Der Inhalt ist meist schwer genug zu verstehen, das muss man nicht noch durch schweinische Darstellung verschlimmern. Wenn jemand freundlicherweise meinen Teller spült, dann bemühe ich mich ja auch, wenigstens ordentlich aufzuessen, um es dem anderen möglichst wenig unangenehm zu machen.

====Grundregeln====
  * Ein- und wieder ausgerückt wird in Stufen von zwei Leerzeichen. Wem das optisch zu unauffällig ist, der kann auch vier Leerzeichen verwenden. Auf jeden Fall verwendet man immer die gleiche Anzahl.
  * Zum Einrücken verwenden wir keine Tabulatoren, weil die in verschiedenen Editoren verschieden weit angezeigt werden.
  * Eingerückt wird, wenn nach dem Öffnen einer Klammer eine neue Zeile begonnen wird, weil das, was man da schreibt das Innere des Vorhergehenden ist. Diese Regel wird hauptsächlich auf geschweifte und manchmal auch runde Klammern angewandt, seltener auf eckige (weil man nach dem Öffnen einer solchen nur selten eine neue Zeile beginnt).
  * Die schließende Klammer wird genau so weit ausgerückt, wie die Zeile mit der zugehörigen öffnenden Klammer.
  * Bekommt man einen Befehl nicht in eine Zeile, so rückt man nachfolgende Zeilen ein, die noch zu diesem Befehl gehören. Wenn der Befehl zu Ende ist, geht man wieder raus auf die vorherige Stufe. 

<code java>
public class Beispiel{
  public static void main(String[] args){
    System.out.println("Hallo");
    if(args.length>0)
      System.out.println(args[0]);
  }
}
</code>





====Blöcke====
Will man mehrere Befehle zu einem einzigen zusammenfassen, so schreibt man sie in geschweifte Klammern. Das ganze nennt man dann einen //Block//. Blöcke sind sehr wichtig überall, wo es um Strukturen geht, z.B. in ''if''-''else''.

Wenn ich abends hungrig bin, esse ich ein Käsebrot und eine Sahnetorte, danach gehe ich ins Bett. Bin ich nicht hungrig, esse ich nichts und gehe einfach so ins Bett. Folgendes ist ganz falsch!
<code java>
if(hungrig)
  iss(käsebrot);
  iss(sahnetorte);
gehezu(bett);
</code>
Nur weil ''iss(sahnetorte)'' eingerückt ist, gehört es noch lange nicht zu dem ''if''-Teil. Der Compiler schaut sich die Einrückungen gar nicht an. Er geht davon aus, dass zum ''if'' genau ein Befehl gehört und das ist der ''iss(käsebrot)''. Wenn ich also nicht hungrig bin, wird nur das Käsebrot nicht gegessen. Alles, was nach dem ''if'' kommt, wird auf jeden Fall durchgeführt und nach dem ''if'' ist die Stelle ''iss(sahnetorte)''. Ich werde also mit einer Sahnetorte zuviel im Bauch ins Bett gehen und schlecht schlafen.

Damit es vom Compiler so verstanden wird, wie ich es gemeint habe, muss ich schreiben
<code java>
if(hungrig){
  iss(käsebrot);
  iss(sahnetorte);
}
gehezu(bett);
</code>
Mit den geschweiften Klammern ist aus den beiden ''iss(...)'' ein Block geworden, was einem einzigen Befehl entspricht. Passen Sie immer auf, dass die Klammern stimmen, damit das Programm richtig funktioniert und dass die Einrückungen stimmen, damit man als Mensch gleich sieht, wie es gemeint ist.

====if-else Langversion====
Wenn man eine Weile drüber nachdenkt, bemerkt man, dass ''if'' mit ''else'' gesondert behandelt werden muss. Wir halten uns an die einfache Regel:

  * ''else'' bekommt die gleiche Einrücktiefe wie das zugehörige ''if''.

<code java>
public class Beispiel{
  public static void main(String[] args){
    System.out.print("Hallo ");
    if(args.length<1)
      System.out.println("Leute");
    else{
      System.out.println(args[0]);
      if(args[0].equals("Hans")){
        System.out.println("Mein Meister!");
        System.out.println("Endlich bist du da.");
      }
      else{
        System.out.println("Ich kenne dich nicht.");
        System.out.println("Geh fort!");
      }
    }
  }
}
</code>

====if-else Kurzversion====
  * Passt der Befehl nach ''if'' noch gut in die Zeile, so darf er nahtlos angefügt werden. Bei ''else'' gilt das gleiche.
  * Sind auch noch Blocks in geschweiften Klammern beteiligt, kann man das else zwischen diese schreiben.

<code java>
public class Beispiel{
  public static void main(String[] args){
    System.out.print("Hallo ");
    if(args.length<1) System.out.println("Leute");
    else{
      System.out.println(args[0]);
      if(args[0].equals("Hans")){
        System.out.println("Mein Meister!");
        System.out.println("Endlich bist du da.");
      } else{
        System.out.println("Ich kenne dich nicht.");
        System.out.println("Geh fort!");
      }
    }
  }
}
</code>

====if-else-Ketten====
Manchmal hat man eine längere Kette von ''if''s, von denen das jeweils nächste im inneren des vorher gehenden ''else'' steht. Neben der gewissenhaften Version mit immer weiter voranschreitender Einrückung …
<code java>
  if(x<10) System.out.println("klein");
  else
    if(x<50) System.out.println("nicht mehr so klein");
    else
      if(x<100) System.out.println("größer");
      else
        System.out.println("ziemlich groß");
  System.out.println("ist diese Zahl, nämlich "+x);
</code>
… erlauben wir auch eine gedrungenere Fassung. In anderen Sprachen gibt es dafür sogar den Befehl ''elseif'', den aber Java nicht kennt. Wir schreiben:
<code java>
  if(x<10)
    System.out.println("klein");
  else if(x<50)
    System.out.println("nicht mehr so klein");
  else if(x<100)
    System.out.println("größer");
  else
    System.out.println("ziemlich groß");
  System.out.println("ist diese Zahl, nämlich "+x);
</code>
Die zweite Darstellung ist inhaltlich völlig identisch mit der ersten. Sie ist jedoch im strengen Sinne nicht korrekt eingerückt, weil ein ''else'' nicht die gleiche Einrückungstiefe hat, wie das zugehörige ''if''. In diesem besonderen Fall ist das Verständnis dadurch aber eher verbessert als gestört.

Um sicher zu gehen, dass Sie alles verstanden haben, sollten Sie sich überlegen, was das Fragment ausgibt, wenn ''x'' den Werte 0 hat (oder 20 oder 60 oder 150).

====Anderer Geschmack====
Es gibt noch eine andere Art, korrekt einzurücken, die ich nicht mag aber toleriere, wenn sie ordentlich angewandt wird. Manche Leute fangen nämlich gern mit einer öffnenden Klammer auch eine neue Zeile an. Das sieht dann so aus:

<code java>
public class Beispiel
{
  public static void main(String[] args)
  {
    System.out.println("Hallo");
    if(args.length>0)
      System.out.println(args[0]);
  }
}
</code>

====Leerzeilen====
Zwischen zwei Methoden lässt man übrigens immer eine Zeile frei. Das ist zwar keine Aussage zu Einrückungen, aber trotzdem hier zu nennen!