Syntax

Mit einfachen Worten erklärt beschreibt der Syntax einer Sprache, wie diese aufgebaut ist, welche Konstruktionen oder Verbindungen es gibt, wie (Satz-)Zeichen gesetzt werden, usw. Damit der Compiler deinen Code (richtig) übersetzen kann, musst du dich an die Syntaxvorgaben der jeweiligen Sprache halten. In diesem Fall ist das Java & Processing (welches auf Java aufbaut).

Grundlegendes

Groß- und Kleinschreibung

Die Groß- und Kleinschreibung muss beachtet werden.

Background(150); // FALSCH
background(150); // RICHTIG

Die beiden oberen Zeilen sind nicht identisch. Die Obere Zeile wirft einen Fehler aus!

Kommentare

Du kannst - und solltest auch - deinen Code mit Kommentaren versehen. Das ist Text, der vom Compiler und dem Computer ignoriert wird. Du kannst Kommentare verwenden, um zu erklären, was du an welcher Stelle im Code machst. Das hilft anderen und dir selber deinen Code zu verstehen.

background(0); // Hintergrund auf schwarz setzen

/* Du kannst auch Kommentare über
mehrere Zeilen machen, wenn du
mehr zu erklären hast. */
background(255); // Hintergrund auf weiß setzen

Bezeichner

Bezeichner sind die "Namen" von Funktionen, Befehlen, Variablen, etc. Sie sind im besten Fall so gewählt, dass sie klar ausdrücken, was der Befehl macht bzw. wozu die Variable da ist. Bei der Wahl des Bezeichners gibt es Regeln zu beachten.

Bezeichner ...

dürfen nicht mit einem Schlüsselwort der Sprache Java identisch sein, z.B. dürfen Sie nicht int oder float als Variablenname verwenden
bestehen aus Ziffern (0-9), Buchstaben (a-z, A-Z) und zwei weiteren Zeichen (Unterstrich und $)
dürfen nicht mit einer Ziffer beginnen
dürfen keine Leerzeichen enthalten und auch keinen Bindestrich (würde als Minus interpretiert werden)

// Syntaktisch falsch: 
007 
meine variable 
float 
meine-variable

// Syntaktisch korrekt: 
take5 
this_is_for_you 
iam007 
MEINEVARIABLE

Befehle, Funktionen und Variablen

Befehle

Programmieren besteht zu einem großen Teil aus dem Schreiben von Befehlen. Befehle bestehen immer aus dem Bezeichner für den jeweilgen Befehl, gefolgt von 2 Klammern, gefolgt von einem Semikolon am Ende der Zeile. In den Klammern können je nach Befehl einer oder mehrere Werte mit Kommata getrennt stehen.

size(400, 400);
background(192, 64, 0);
stroke(255);
line(150, 25, 270, 350);

Befehle können auch verschiedene Werte aufnehmen, zum Beispiel der Befehl stroke:

stroke(255); // setzt die Linienfarbe auf weiß
stroke(255, 255, 255); // dasselbe, wie die obere Zeile
stroke(255, 128, 0); // hell orange (rot 255, grün 128, blau 0)
stroke(255, 128, 0, 128); // hell orange mit 50% Transparenz

Funktionen

Funktionen sind sozusagen die Blaupause von Befehlen. Jeder Befehl ist irgendwo als Funktion einmal festgelegt worden. Funktionen bestehen aus dem Datentyp oder dem Schlüsselwort void, wenn die Funktion keinen Datentyp zurückgibt, gefolgt von dem Bezeichner, gefolgt von 2 Klammern (welche eine oder mehrere Variablennamen mit Datentyp enthalten können), gefolgt von 2 geschweiften Klammern. Innerhalb dieser geschweiften Klammern können Codezeilen geschrieben werden, welche die Funktion ausführen soll. WICHTIG: Am Ende von einer Funktion steht kein Semikolon!

Zu Beginn dieses Projekts werdert ihr zunächst nur bereits vorhandene Funktionen bzw. Befehle verwenden. Später werdet ihr auch eure eigenen Funktionen erstellen. 2 Funktionen, die euch direkt am Anfange immer wieder begegnen werden sind setup und draw.

void setup() {
   // Hier wird der Code geschrieben
   size(400, 400);
   stroke(255);
}

void draw() {
   line(150, 25, mouseX, mouseY);
}

Variablen

Variablen (dazu gehören auch Konstanten) sind Objekte, in den Daten gespeichert werden können, ähnlich wie Register. Die Deklaration einer Variable besteht aus dem Datentyp gefolgt von dem Bezeichner gefolgt von einem Semikolon. Deklaration bedeutet, dass die Variable zunächst nur "angelegt" wird, ihr aber noch keine Wert zugewiesen wird. Das Zuweisen des ersten Wertes für eine Variable wird als Initialisierung bezeichnet. Variablen können innerhalb einer Zeile deklariert und initialisiert werden. In disem Fall besteht die Zeile aus dem Datentyp, gefolgt von dem Bezeichner, gefolgt von dem Zuweisungsoperator "=", gefolgt von dem Wert für die Variable, gefolgt von einem Semikolon.

int myAge; // Diese Variable ist nur deklariert
int yourAge = 21; // Diese Variable ist deklariert und initialisiert

Konventionen

Wie bereits erwähnt, hat jede Programmiersprache ihre eigene Syntax-Vorgaben, an die sich jeder Programmierer halten muss, damit der Compiler bzw. der Interpreter den Code lesen und übersetzen kann. Darüber hinaus gibt es noch sowas wie Programmierstil. Das ist die Art und Weise wie jeder Programmierer - oder auch jedes Team aus Programmierern - seinen Code schreibt. Hier gibt es natürlich guten Stil und schlechten Stil. Natürlich kann jeder selberentscheiden, wie er seinen Code schreibt, allerdings haben sich in den letzten Jahren sogenannte Konventionen gebildet, wie Programmcode zu schreiben ist, damit ihn möglichst jeder versteht und der Code immer ähnlich aussieht.

Konvetionen beschreiben einen guten Programmierstil, der sich in der Regel seit Jahren etabliert hat und somit als eine Art "Standard" gilt. Anders als beim Syntax, müssen Konventionen nicht eingehalten werden, da sie nicht dazu beitragen, dass der Compiler oder Interpreter den Code lesen kann, sondern die EntwicklerInnen. Also du selber und auch andere Personen, die deinen Code lesen und verstehen möchten.

Konventionen für Programmcode sind häufig universell - sprich unabhängig von der Programmiersprache. Allerdings gibt es auch einige Konventionen, die nur auf bestimmte Programmiersprachen zutreffen. Hier findest du zum Beispiel den Java Styleguide von Google. Das ist ein ziemlich langes Dokument mit sehr vielen Vorgaben. Die muss man aber nicht alle kennen. Für den Anfang reichen ein paar wenige:

Einrückungen

Ein wichtige Konvention, die dafür sorgt, dass dein Code übersichtlicher wird, ist es Code in geschweiften Klammern einzurücken.

void setup() {
   size(200, 200); // schlechter Stil
}
void draw() {
   background(100); // guter Stil
}

Tip: Processing liefert hierfür eine Funktion, die es dir einfacher macht deine Code einzurücken: Die Autoformatierung. Du findest sie in Processing unter Bearbeiten → Autoformatierung oder unter dem Tastaturkürzel STR + T.

Sprechende Namen

Namensgebung ist ein wichtiges Thema in der Programmierung. Wichtig ist, das die Namen von Variablen, Konstanten, etc. möglichs klar vermitteln, was das jeweilige Element macht. Funktionen sind dabei häufig in Verbform

int a = 21; // SCHLECHT
int b = 170; // SCHLECHT

int myAge = 21; // GUT
int heightInCentimeters = 170; // GUT

void draw() { // diese Funktion Zeichnet etwas
}

Schreibweise

Ebenfalls wichtig ist, dass dein Code gut lesbar ist. Gerade, wenn Variablennamen etwas länger werden, kann das schwierig sein. Hierfür gibt es auch ein paar Vorgaben:

Variablen werden am Anfang klein geschrieben und jedes neue Wort innerhalb des Variablennamens beginnt mit einem Großbuchstaben. Das wird auch als CamelCase bezeichnet.

int thisIsMyAge= 34;

Konstanten werden nur in Großbuchstaben geschrieben und neue Wörter werden durch einen Unterstrich markiert.

final int THIS_IS_MY_SCHOESIZE = 41;

Funktionen, werden genauso geschrieben, wie Variablen, sind aber meistens in Verbform.

void sayHello () { // richtig
}

Kommentare

Kommentare sind ein wichtiges Element in der Programmierung. Spare nicht mit Kommenaren. Was für dich zum aktuellen Zeitpunkt sonnenklar ist, kannst du vielleicht zu einem späteren Zeitpunkt nicht mehr nachvollziehen. Also schreibe in deinen Code ruhig rein, was du warum machst. Einzeilige Kommentare können entweder oberhalb der Codezeile stehen oder hinter der Codezeile. Hier ist beides richtig:

// change background color - RICHTIG
background(255);
stroke(0); //change stroke color - AUCH RICHTIG

Code Qualität

Wenn du bzw. ihr als Team einen guten Programmierstil habt, dann sorgt das dafür, dass euer Code eine gute Qualität hat. Eine gute Code Qualität zeichnet sich folgendermaßen aus:

Der Code ist übersichtlich und gut strukturiert.
Auch andere - fremde - ProgrammiererInnen können deinen Code (schnell) verstehen.
Du selber kannst deinen Code auch noch verstehen, wenn du mal länger nicht draufgeschaut hast.
Fehler können leicht gefunden werden.

Welchen Programmierstil du oder ihr euch als Team aussucht, ist relativ egal. Wichtig ist nur, dass die Regeln, für die ihr euch entscheidet sinnvoll sind und, dass sich jeder konsistent daran hält.

Zusammenfassung

Syntax

Der Syntax einer Programmiersprache legt fest, wie diese geschrieben werden muss und welche Regeln beachtet werden müssen. Die wichtigsten Syntax-Regel für Java sind:

Groß- & Kleinschreibung beachten
Kommentare: Einzeilige Kommentare werden mit // begonnen, mehrzeilige r von /* ... */ eingeschlossen
Bezeichner:
- Dürfen nicht mit einem Schlüsselwort der Sprache Java identisch sein
- bestehen aus Ziffern (0-9), Buchstaben (a-z, A-Z) und zwei weiteren Zeichen (Unterstrich und $)
- dürfen nicht mit einer Ziffer beginnen
- dürfen keine Leerzeichen enthalten und auch keinen Bindestrich
Befehle bestehen aus einem Bezeichner, zwei runden Klammern () und einem Semikolon am Ende der Zeile: z.B. noStroke();
Funktionen bestehen aus dem Datentyp oder dem Schlüsselwort void, dem Bezeichner, 2 runden Klammern (ggf. inkl. Parameter), 2 geschweiften Klammern.
Variablen können entweder nur zunächst nur deklariert oder auch direkt auch initialisiert werden.
- Nur Deklaration: Besteht aus dem Datentyp, dem Bezeichner und einem Semikolon (z.B. int myAge;).
- Deklaration & Initialisierung: Besteht aus dem Datentyp, dem Bezeichner, dem Zuweisungsoperator, einem Wert und einem Semikolon (z.B. int myAge = 21;).

Konventionen

Konventionen sind weiche Regeln, wie Programmcode zu schreiben ist. Es ist nicht zwingend notwendig sich an Konventionen zu halten, damit der Prgrammcode funktioniert. Allerdings steigert das Einhalten der Konventionen die Qualität des Codes, da

er leichter zu lesen und zu verstehen ist - auch nach langer Zeit.
Fehler im Code schneller zu finden sind
auch andere ProgrammiererInnen den Code lesen und verstehen können

Wichtige Konventionen sind:

Einrücken von Codeblöcken
Sprechende Namen wählen
Einhalten von Schreibweisen
- Variablen: Am Anfang klein und in CamelCase
- Konstanten: in Großbuchstaben und mit Unterstrichen
- Funktionen: Am Anfang klein, in CamelCase und in Verbform
Kommentare verwenden