Clean Code

Clean Code ist ein Prinzip, nachdem Code grundsätzlich gestaltet werden soll. In der Schule werden Code-Beispiele oft für eine Abgabe geschrieben und dann wieder vergessen. In der Praxis kann ein Programmcode über Jahre hinweg immer wieder wichtig sein. Dieser Programmcode wird oft auch von mehreren Personen bearbeitet und angepasst, weil der/die ursprüngliche Programmierer*in schon längst auf einem anderen Posten in der Firma sitzt. Daher ist es wichtig, dass Code gut für andere Menschen lesbar und verständlich ist. Die folgenden Abschnitte weisen noch einmal auf ein paar diesbezügliche Punkte hin, die schon besprochen wurden. Außerdem werden ein paar Punkte thematisiert, die bis jetzt verwendet wurden, weil sie für das Lernen und Erklären einfacher waren, aber dem Clean Code - Prinzip wiedersprochen haben. Das Thema wird auch immer wieder in regelmäßigen Abständen aufgegriffen werden und um neue Aspekte erweitert werden.

Einrückungen

Einer der wichtigsten Punkte, um Code lesbar zu gestalten, liegt in den Einrückungen. Durch sie werden Programmstruktur und Ablauf besser sichtbar.

Gleichzeitig ist es auch wichtig, dass Zeilen nicht zu lange werden. Lange Zeilen können von unseren Augen nicht so gut auf einen Blick erfasst werden. Es gibt verschiedene Quellen, aber die meisten schlagen einen Bereich von 50-70 Zeichen vor, manche gehen bis maximal 80 Zeichen.

Seht einmal den folgenden Code an

 1
 2
 3
 4

void main() { int a; int b; int c; int d; a = 1; b = 1; c = 0; d = 0;
while(vornFrei() == true) { vor(); a = a + 1; if(kornDa() == false) {
b = b + 1; } else { c = c + 1; while(kornDa() == true) { nimm(); d = d + 1;
}}} schreib("Körner: " + d + ", Felder gesamt: " + a + ", Felder mit Körnern: " + c + ", leere Felder " + b);}

Was dieser Code macht, kann man vielleicht noch an der Ausgabe-Anweisung erraten, aber es wird sehr schwer, etwas auszubessern, Fehler zu finden oder zu ergänzen. Durch Einrückungen erst wird der Code übersichtlicher, man kann Strukturen und Verschachtelungen erkennen und dadurch leichter mit diesem Programm weiter arbeiten. Außerdem wurde die lange Ausgabezeile bei einem Verkettungsoperator (+) in die nächste Zeile umgebrochen, um besonders lange Zeilen zu vermeiden.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

void main() {
    int a;
    int b;
    int c;
    int d;
    a = 1;
    b = 1;
    c = 0;
    d = 0;
    while(vornFrei() == true) {
        vor();
        a = a + 1;
        if(kornDa() == false) {
            b = b + 1;
        }
        else {
            c = c + 1;
            while(kornDa() == true) {
                nimm();
                d = d + 1;
            }
        }
    }
    schreib("Körner: " + d + ", Felder gesamt: " + a + 
        ", Felder mit Körnern: " + c + ", leere Felder " + b);
}

Die Standard-Größe bei Einrückungen ist 4 Leerzeichen bzw. 1 Tabulatur und sollte auch nicht verändert werden. Ausnahmen kann man machen, wenn man z.B. für einen Ausdruck nicht so viel Platz für eine Zeile hat.

Die Einrückungsregeln sind wie folgt:

1. Die Kopfzeile der Klasse oder beim Hamster die Kopfzeile der main-Methode beginnt ganz links
2. Nach jeder öffnenden geschwungenen Klammer wird 1 Tab / 4 Leerzeichen weiter eingerückt.
3. Alle nachfolgenden Anweisungen bleiben grundsätzlich auf der Höhe, außer es wird eine geschwungene Klammer aufgemacht, dann gilt Regel 2. Wenn eine geschwungene Klammer zugemacht wird, gilt Regel 4.
4. Eine geschwungene Klammer ist immer genau unter dem ersten Buchstaben der Zeile, wo die geschwungene Klammer aufgemacht wird (z.B. unter dem w von der while-Anweisung, oder unter dem i von der if-Anweisung).
5. Wenn eine Anweisung zu lange ist und auf mehrere Zeilen aufgeteilt wird, sind die nachfolgenden Teile der Zeile auch eingerückt.

Ergänze folgende Zusammenfassung und beantworte die Fragen:

• Clean Code beschäftigt sich mit dem Thema, wie Quellcode

  effizienter und schneller am Prozessor ausgeführt werden kann

  für einen Menschen besser lesbar wird

  für den Computer besser lesbar wird

  am Bildschirm weniger Zeilen benötigt
  .

• Dieses Thema ist wichtig, weil in der Arbeitswelt Quellcode

  nur für kurze Zeit

  über mehrere Jahre hinweg

  nur einmal
  verwendet und auch verändert wird. Außerdem
  arbeitet immer nur die selbe Person

  arbeiten unterschiedliche Menschen

  arbeitet niemand
  mit einem Programm.

• Einrückungen helfen in diesen Bereichen, weil ... (kreuze die zutreffenden Antworten an, mehrere Antworten möglich)

  sichtbar ist, ob alle geschwungenen Klammern auch richtig wieder geschlossen sind
  weniger Codezeilen im Quellcode vorhanden sind
  Logische Abläufe besser sichtbar sind
  Die Zeilen nicht so viele Zeichen enthalten und damit nicht so weit nach rechts ragen
  erkennbar ist, wo ein Block beginnt und wieder aufhört
  Strukturen besser erkennbar sind

• Die Kopfzeile der main-Methode im Hamster ist immer um

  2

  0

  4

  8

  1
  Leerzeichen eingerückt.

• Die Anweisung in Programmzeile 2 steht nach 1 geschwungen öffnenden Klammer. Daher ist sie um Leerzeichen eingerückt, genauso wie die nächsten Anweisungen in den Programmzeilen 3-9. Diese Anweisungen befinden sich also alle auf einer Ebene.

• Erst am Ende der Kopfzeile der while-Schleife in Zeile 10 wird eine geschwungende Klammer aufgemacht. Daher ist diese Kopfzeile noch genau Leerzeichen eingerückt.

• In der nächsten Anweisung in Zeile 11 sind schon 2 offene geschwungene Klammern wirksam (die von Zeile 1 und von Zeile 10). Deshalb ist diese Zeile schon um Leerzeichen eingerückt. Das gilt genauso für die Anweisung in Zeile 12.

• Erst am Ende der Kopfzeile der if-Verzweigung in Zeile 13 wird eine geschwungende Klammer aufgemacht. Daher ist diese Kopfzeile noch genau Leerzeichen eingerückt.

• Danach sind für die Anweisung in Zeile 14 bereits 3 offene geschwungene Klammern wirksam (die von Zeile 1, von Zeile 10 und von Zeile 13). Deshalb ist diese Zeile schon um Leerzeichen eingerückt.

• In Zeile 15 wird der Block, der in Zeile 13 mit der if-Verzweigung aufgemacht wurde, wieder geschlossen. Daher ist er genauso weit eingerückt, wie die Kopfzeile dieser if-Anweisung nämlich Leerzeichen.

• Um schließende geschwungene Klammern gut zuordnen zu könnnen, muss man sich einfach eine Linie senkrecht nach oben von der Klammer denken (wenn man die Einrückungen richtig gemacht hat). Die nächste Zeile, auf die man von unten nach oben stößt, enthält die zugehörige öffnende Klammer. So ist z.B. die Klammer in Zeile 22 um Leerzeichen eingerückt. Wenn man von dieser Zeile nach oben geht, ist die nächste Anweisung, auf die man mit 8 Leerzeichen Einrückung stößt, die Anweisung, die in der Zeile mit der Nummer steht. Daraus sieht man, dass genau dieser Block geschlossen wird.

• Die schreib-Anweisung in Zeile 24 ist auf 2 Teile aufgeteilt. Der erste Teil in Zeile 24 ist um 4 Leerzeichen eingerückt. Deshalb ist der zweite Teil der schreib-Anweisung in Zeile 25 um Leerzeichen eingerückt.

Ist folgender Ausdruck eine gültige Bedingung (d.h. sie lässt sich in Java compilieren)? Die Variable zaehler wurde zuvor deklariert und initialisiert.

if( !(zaehler == 0 || zaehler > 0) ) {

Wie oft wird der Schleifenkörper zu folgender Kopfzeile ausgeführt (zaehler wurde zuvor als int deklariert):

for(zaehler = 0; zaehler != 10; zaehler = zaehler + 2) {

Ist folgender Ausdruck eine gültige Bedingung (d.h. sie lässt sich in Java compilieren)? Die Variable zaehler wurde zuvor deklariert und initialisiert.

if(zaehler < 0 || 0 ) {

Was kommt bei folgender Bedingung als Gesamtergebnis (true oder false) heraus, wenn der Hamster ein Korn im Maul hat und der Weg vor ihm frei ist:

if( (maulLeer() == true) || (vornFrei() == false) ) {

Was kommt bei folgender Bedingung als Gesamtergebnis (true oder false) heraus, wenn der Hamster ein Korn im Maul hat und der Weg vor ihm blockiert ist:

if( (maulLeer() == true) && (vornFrei() == false) ) {

Schreibe den Operator (das Symbol) auf, um den logischen ODER-Operator in Java anzugeben. 

Wie oft wird der Schleifenkörper zu folgender Kopfzeile ausgeführt (zaehler wurde zuvor als int deklariert):

for(zaehler = 10; zaehler >= 0; zaehler = zaehler - 2) {

Wie oft wird der Schleifenkörper zu folgender Kopfzeile ausgeführt (zaehler wurde zuvor als int deklariert):

for(zaehler = 0; zaehler == 5; zaehler = zaehler + 1) {

Wie oft wird der Schleifenkörper zu folgender Kopfzeile ausgeführt (zaehler wurde zuvor als int deklariert):

for(zaehler = 5; zaehler >= 0; zaehler = zaehler + 1) {