Codekonventionen

Eine Codekonvention ist eine Übereinkunft unter Programmierern, beim Schreiben ihrer Programme einen gewissen Stil einzuhalten. Über die Jahre hinweg haben sich in fast allen Programmiersprachen eine oder mehrere solcher Standards gebildet.

Verständlichkeit eines Algorithmus

Erläuterung

Ein wichtiges Merkmal eines Algorithmus ist, dass ein menschlicher Leser ihn verstehen kann, obwohl er nicht in umgangssprachlicher Form vorliegt.

Beispiel

Als Beispiel sei folgender Algorithmus gegeben, der zwei Zahlen miteinander multipliziert, ohne explizit einen Multiplikationsoperator zu verwenden.

1. In Pseudocode sieht das ganze so aus:

Eingabe: Zwei ganze Zahlen a und b
Ausgabe: Produkt aus a und b
Vorgehensweise:
    Initialisiere das Ergebnis mit 0
    Addiere a mal b auf das Ergebnis
    Gebe das Ergebnis zurück

2. Beispiel für eine schwer verständliche Formulierung des Algorithmus:

  public static int berechnen2(int a, int b){int erg=0;for(int i=0;i<a;i++){erg+=b;}return erg;}
  

3. Das gleiche Beispiel, lesbarer und mit Syntaxhighlighting:

public static int berechnen(int a, int b)
  {
    int erg = 0;
    for(int i = 0; i<a ; i++)
    {
        erg += b;
    }
    return erg;
  }

Beide Programme führen dasselbe aus. Beide berechnen das Produkt von a und b, ohne eine Multiplikation durchzuführen. Sie addieren b a-mal auf eine Ergebnisvariablen erg auf. Diese Variable wird zum Schluss zurückgegeben.

Genaueres zur Funktionsweise des Algorithmus: siehe Schleife

Bezeichner und Leerzeichen

Da in Programmiersprachen der Text maschinell analysiert werden muss, um später vom Compiler übersetzt werden zu können, gilt es immer folgendes zu beachten:

Eine Zeichenkette, die als Bezeichner für ein Programmelement genutzt wird, darf keine Leerzeichen (engl. whitespaces) beinhalten.

Mit Leerzeichen versehen werden Beginn und Ende des Bezeichners uneindeutig deklariert. Daher ist dies in fast allen Programmiersprachen verboten. Um trotzdem einen Bezeichner aus mehr als einem Wort bestehen zu lassen, verwenden Programmierer verschiedene Formen der Notation, die im Folgenden erklärt werden.

Notationsbegriffe

Im Zusammenhang mit Codekonventionen haben sich verschiedene Begriffe etabliert:

Lower-Case (engl. für "Kleinbuchstaben"): Bezeichner werden als eine zusammenhängende Zeichenkette hintereinander geschrieben, während alle Buchstaben klein geschrieben werden.

• z.B.: nanosecondsinsecond, valueineuro, positionx, positiony

Upper-Case (engl. für "Großbuchstaben"): Bezeichner werden als eine zusammenhängende Zeichenkette hintereinander geschrieben, während alle Buchstaben groß geschrieben werden.

• z.B.: NANOSECONDSINSECOND, VALUEINEURO, POSITIONX, POSITIONY

Camel-Case: Bezeichner werden als eine zusammenhängende Zeichenkette hintereinander geschrieben, während jeder Anfangsbuchstabe eines Wortes groß geschrieben wird.

• z.B.: NanosecondsInSecond, ValueInEuro, PositionX, PositionY

Mixed-Camel-Case: Bezeichner werden als eine zusammenhängende Zeichenkette hintereinander geschrieben, während jeder Anfangsbuchstabe eines Wortes groß geschrieben wird, bis auf der erste.

• z.B.: nanosecondsInSecond, valueInEuro, positionX, positionY

Underscored: Wörter in Bezeichnern werden durch einen Unterstrich _ voneinander getrennt.

• z.B.: nanoseconds_in_sekunde, value_in_euro, position_X, position_Y.

Underscored kann in Kombination mit anderen Begriffen verwendet werden. Die ersten beiden Beispiele sind in der in C für Variablen verwendeten lower-case-underscored Schreibweise gehalten.

Konventionen in Java

Folgende Konventionen sind beim Programmieren von Java zwingend einzuhalten:

Konventionen für Bezeichner in Java

1. Paketnamen werden im Lower-Case notiert und haben die Form einer "umgekehrten URL".

• z.B.: de.tu-do.eini.blatt01, org.apache, com.jogamp.opengl, myproject.directory

2. Klassennamen werden im Camel-Case notiert.

• z.B.: String, MeinProgramm, AbstractSingletonFactoryBean

3. Variablen- und Attributsnamen werden im Mixed-Camel-Case notiert.

• z.B.: x, result, processRunning

4. Methodennamen werden im 'Mixed-Camel-Case notiert.

• z.B.: calculate(int x, int y), doSomething(), cleanupAtShutdown(String message)

5. Klassenweite Konstanten werden im Underscored-Upper-Case notiert.

• z.B.: PI, NANOSECONDS_IN_SECOND, ARRAY_SIZE

Alles was einen Wert besitzt, kann so schnell durch den Kleinbuchstaben am Anfang erkannt werden kann, während von Typen mit Großbuchstaben unterschieden werden kann. Konstanten fallen schnell ins Auge.

Bei Paketnamen kann durch die Form der Notation bei Großprojekten insbesondere erkannt werden, in welcher Sprache das Projekt dokumentiert ist (Ländercode der "URL"). Für das Anlegen von Klassen zu den Übungsblättern reicht jedoch etwas wie eini.blatt01 vollkommen aus.

Konventionen für Einrückung und geschweifte Klammern in Java

In Java wird, wie auch in vielen anderen Programmiersprachen, blockebenenweise eingerückt. Eine Ebene wird dabei meist mit vier Leerzeichen oder einem Tab eingerückt. Das bedeutet, dass die Anzahl an umgebenden Blöcken die Anzahl an Leerzeichen oder Tabs vor dem Beginn einer Zeile vorgibt. So stehen z.B. die Deklarationen von Attributen und Methoden immer im Block der sie beinhaltenden Klasse und werden deswegen um eine Ebene eingerückt:

public class Cube {
    private int x,y,z; //Umgeben vom Block der Klasse: Einrückung um eine Ebene.
    
    private int calculateVolume(){
        /* Berechnung umgeben vom Block der Klasse und der Methode: Einrückung um zwei Ebenen. */
    }
}

Es gibt zwei Möglichkeiten die öffnenden Klammern eines Blockes zu notieren. Zum einen können sie in der gleichen Zeile wie der öffnende Ausdruck stehen (siehe vorheriges Beispiel), zum anderen können sie in einer eigenen Zeile aber auf der gleichen Ebene wie besagter Ausdruck notiert werden (siehe Verständlichkeit, Beispiel 3).

Welche Schreibweise Sie verwenden ist Ihnen überlassen, Hauptsache Sie ziehen sie durch.

Beispiele

public class Classname {
    private int variable;
    private int another;
}

public class Cube {
private int x,y,z;
private int calculateVolume(){
/* Berechnung */
}
}

public class Cube {
    private int x,y,z;
    private int calculateVolume(){
        /* Berechnung */
    }}

public class Cube {
    private     int x,y,z;
    
        private int calculateVolume(){
        /* Berechnung */
    }
}

public class Calculator {
    private int calculate(int x, int y){
        for(int i = 0; i < y; i++)
        {
            /* Berechung */
        }
    }
}

public class Cube
{
    private int x,y,z;
    
    private int calculateVolume()
    {
        /* Berechnung */
    }
}