Version vom 13. Juni 2016, 22:35 Uhr

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. 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. Das bedeutet, dass die Anzahl an umgebenden Blöcken von geschweiften Klammern die Anzahl an Leerzeichen oder Tabs vor dem Beginn einer Zeile angibt. 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;
    
    private int calculateVolume(){
        /* Berechnung */
    }
}

Ob Sie die öffnenden Klammern eines Blockes in die Zeile des ihn öffnenden Ausdruckes schreiben (wie im vorherigen Beispiel), oder die öffnende Klammer in die gleiche Ebene wie der den Block öffnende Ausdruck in einer einzelnen Zeile notieren (wie im lesbareren Beispiel unter Verständlichkeit eines Algorithmus) ist Ihnen überlassen. Sie sollten dabei aber auf jeden Fall konstant bleiben.

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 */
    }
}