Variablen sind Container für Informationen, zum Beispiel für eine Zahl oder für einen Text. Der Inhalt einer Variable kann sich jederzeit ändern, ist also variabel.

Variablen können Daten speichern. Um dies sinnvoll zu tun, benötigen wir für jede Variable:

• einen Typ, der bestimmt, was man in der Variable speichern kann, z.B. eine ganze Zahl, eine Kommazahl oder einen Buchstaben.
• einen Namen (Bezeichner), damit man später darauf zurückgreifen kann und verschiedene Variablen auseinander halten kann.

Deklaration

Um eine Variable zu verwenden, muss man zunächst die Variable erstellen. Das nennt man deklarieren. Hier deklarieren wir eine Variable mit Namen foo vom Typ int (steht für integer, engl. für "ganze Zahl"):

int foo; // Deklaration

Allgemein sieht eine Deklaration wie folgt aus:

TYP NAME;

Die Deklaration reserviert Platz im Speicher, um den Wert einer Variablen zu abzulegen. Das ist auch einer der Gründe, warum ein Typ angegeben wird: unterschiedliche Typen verbrauchen unterschiedlichen Speicherplatz.

WICHTIG: Variablenamen am Anfang immer klein schreiben!

Zuweisung

Im nächsten Schritt legt man den Inhalt der Variable fest, das nennt man Zuweisung. Man kann einer Variablen immmer wieder verschiedene Werte zuweisen. Die Zuweisung des ersten Werts (in der Regel direkt nach der Deklaration) nennt man auch Initialisierung.

Um einer Variablen einen Wer zuzuweisen, verwendet man das Gleichheitszeichen, welches in diesem Fall als Zuweisungsoperator bezeichnet wird.

WICHTIG: Es handelt sich nicht um die Gleichheit aus der Mathematik!

Bei der Zuweisung steht links vom Zuweisungsoperator immer ein Variablenname und rechts steht z.B. eine Zahl oder ein mathematischer Ausdruck wie 3 + 2. Die rechte Seite wird ausgewertet und das Ergebnis in die Variable hineingeschrieben.

foo = 5; // einfache Zuweisung

Auf der rechten Seite kann ein beliebig komplexer arithmetischer Ausdruck stehen.

foo = 5 + 2 * (10 - 5);

Dieser wird zunächst gemäß der bekannten Regeln (Punkt vor Strich, Klammerung) ausgewertet.

foo = 15;

Erst wenn die rechte Seite fertig ausgewertet ist, wird der Variablen foo der Wert, hier also 15, zugewiesen.

Verwendung

Schließlich kann man die Variabe verwenden. Hier wird der Variablenname durch den Inhalt der Variable ersetzt, das nennt man auch Substitution.

println(foo); // Verwendung im Befehl println
rect(foo, 40, 30, 30); // Verwendung im Befehl rect

Stell dir vor, dass Processing vor der Verarbeitung einer Zeile zunächst alle Variablen durch den jeweils aktuellen Wert der Variable ersetzt.

In unserem Bespiel hat die Variable foo den Wert 5. Aus der Zeile

rect(foo, 40, 30, 30);

macht Processing also zunächst

rect(5, 40, 30, 30);

Jetzt wird die Zeile "normal" ausgewertet.

Wichtig: Die Verwendung von Variablen teilt sich in 3 Schritte auf:

1. Subsitution der Variable(n) mit dem tatsächlichen Wert
2. Verarbeitung/Auswertung der Variable(n), z.B. in Befehlen oder auch die Addition zweier Variablen.
3. Zuweisung des Ergebnis zu einer (anderen Variable).

Es kommen nicht immer zwingend alle Schritte vor. Manchmal gibt es auch keine Verarbeitung, z.B. wenn ich eine Variable einfach nur einer anderen Variable zuweise (z.B.  xNeu = xAlt ). Wenn die Schritt allerdings vorkommen, dann in dieser Reihenfolge.

Zuweisung mit Variablen

Variablen können auch auf der rechten Seite von Zuweisungen stehen:

boo = foo + 10;

Bevor die Addition (oder andere Operationen) ausgewertet wird, werden alle Variablen auf der rechten Seite ersetzt (substituiert) durch ihre jeweils aktuellen Werte.

boo = 5 + 10;

Im nächsten Schritt wird der arithmetische Ausdruck auf der rechten Seite ausgewertet:

boo = 15;

Jetzt kann die Zuweisung erfolgen: boo erhält den Wert 15.

Variablenwert erhöhen

Wie du später noch sehen wirst, kommt es sehr häufig vor, dass du den Wert einer Variablen um einen Betrag erhöhen möchtest. Zum Beispiel: Variable x speichert eine x-Koordinate und hat den Wert 10, diesen möchstes du um 1 erhöhen. Zunächst deklarieren wir die Variable:

int x;
x = 10;

Häufiger Fehler:

x + 1; // falsch

In diesem Code wird aber der Wert der Variable x nicht verändert. Stattdessen musst du schreiben:

x = x + 1; // richtig

Hier passiert folgendes. Im ersten Schritt wird der Wert von x eingesetzt:

x = 10 + 1;

Im nächsten Schritt wird die Addition aufgelöst:

x = 11;

Erst jetzt wird das Gleichheitszeichen, also die Zuweisung, ausgeführt, und x erhält den neuen Wert 11.

Deklaration und Zuweisung auf einer Zeile

Du kannst Deklaration und Zuweisung auch verkürzt auf eine Zeile schreiben. Beachten Sie dennoch, dass hier zwei Dinge passieren:

int bla = 50; // zwei auf einen Streich

Die allererste Zuweisung bei einer Variable nennt man auch die Initialisierung der Variable.

Globale Variablen

Wo steht die Deklaration im Code? Wir beschäftigen uns hier mit sogenannten globalen Variablen. Dabei handelt es sich um Variablen, die du - nach der Deklaration - überall in deinem Programm verwenden kannst. Globale Variablen sollten im aktiven Modus immer ganz oben im Code stehen, außerhalb von setup, draw und anderen Funktionen.

// Alle Variablen ganz oben,
// also vor setup und draw
int x = 0;
int y = 0;

void setup() {}

void draw() {
   ellipse(x, y, 20, 20);
   x = x + 1;
   y = y + 1;
}

Welche Namen sind erlaubt?

Wenn du eigene Variablen definierst, musst du ein paar Regeln beachten, harte und weiche. Wichtig ist zunächst, dass Groß- und Kleinschreibung unterschieden wird, d.h. dass meineVariable und  meinevariable
zwei unterschiedliche Variablen sind, die auch gern im selben Code ko-existieren dürfen.

Harte Regeln (Syntax)

Die Verletzung einer harten Regel führt zu einer Fehlermeldung, d.h. diese Regeln sind Teil der Syntax von Processing bzw. Java:

• Groß- & Kleinschreibung beachten
• keine Schlüsselworte verwenden
• bestehen aus Ziffern (0-9), Buchstaben (a-z, A-Z), '_' und '$'
• nicht mit einer Ziffer beginnen
• keine Leerzeichen und auch keinen Bindestrich

Weiche Regeln (Konventionen)

Neben den harten Regeln gibt es einige Konventionen, die du einhalten solltest, um nicht direkt als Programmieranfänger ertappt zu werden.

Variablennamen...

• beginnen immer mit Kleinbuchstaben
• folgen der CamelCase-Regelung, wenn Einzelwörter verbunden sind (z.B. meineNeueVariable)
• sind möglichst aussagekräftig (z.B. hintergrundFarbe statt hg)

Beispiele:

// verletzt Konventionen (obwohl syntaktisch korrekt): 
int MeineVariable;    // groß geschrieben am Anfang 
int MEINEVARIABLE;    // GROSS GESCHRIEBEN! 
int meine_variable;   // kein CamelCase
int mv;               // nicht aussagekräftig

// entspricht Konventionen: 
int meineVariable;

Konstanten

Die Daten oder Werte, die in Variablen gespeichert sind, können jederzeit verändert werden - sie sind variabel. Soll der Wert einer Variable allerdings nicht veränderbar sein, dann kann sie als Konstante angelegt werden. Wichtig bei der Deklaration einer Konstanten ist zum einen, dass das Schlüsselwort final verwendet werden muss. Zum anderen müssen Konstanten bei der Deklaration auch direkt initialisiert werden, sprich es muss ihnen direkt ein Startwert zugewiesen werden, da der Wert einer Konstante später nicht verändert werden kann.

final int MEINE_HAUSNUMMER;  
MEINE_HAUSNUMMER = 34; // FALSCH

final int MEINE_SCHUHGROESSE = 41; // RICHTIG

Konstanten sind dann sehr hilreich , wenn Programme größer und komplexer werden. Da kann es schonmal passieren, dass man vergisst, dass der Wert Variable XY nicht verändert werden darf. Indem man die Variable als Konstante anlegt kann man diesen ungewollten Fehler vermeiden.

Außerdem ist dir wahrscheinlich aufgefallen, dass Konstantennamen anders geschrieben. Für sie gelten andere Konventionen:

• nur Großbuchstaben
• zwischen 2 Worten kommt ein Unterstrich ( _ )

Der Vorteil daran ist, dass man direkt an der Schreibweise des Namens erkennt, dass es sich hierbei um eine Konstante handelt.

Literale

Nun haben wir uns bereits die verschiedenen Elemente einer Variablen angeschaut. Da wäre der Typ (int, ...), der Bezeichner (der Name der Variablen), der Zuweisungsoperator (=) und das Schlüsselwort final. Das letzte Element sind Literale. Bei Literalen handelt es sich um feste Werte, die einer Variable zugewiesen werden. 

Beispiel:

int anzahlHaende = 2; // Literal = 2
int fingerProHand = 5; // Literal = 5
int anzahlFinger = anzahlHaende * fingerProHand; // KEIN Literal

In diesem Fall sind 2 und 5 jeweils Literale. Literale sind feste Werte - warum? Weil diese fest in deinen Quellcode eingetragen sind und somit unveränderlich sind. In den Zeilen oben wird immer 2 und 5 stehen und das wird sich auch nicht verändern. Auch, wenn die Variable später einen anderen Wert hat. In der dritten Zeile steht allerings kein fester Wert, sondern die Multiplikation zweier Variabeln. Somit handelt es sich hier nicht um ein Literal.

Wichtig ist, dass es verschiedene Arten von Literalen gibt. Welche Arten von Literalen eine Variable verwenden kann, hängt vom Datentyp der Variablen ab. Mehr zum Thema Datentypen findest du im Abschnitt Datentypen. 

Systemvariablen

Processing ist so freundlich, dir eine Handvoll Variablen zu "schenken". Das bedeutet: diese Variablen sind immer vorhanden, du brauchst sie nicht deklarieren oder setzen, sondern du verwendest sie nur. Zum Beispiel, um die aktuelle Position der Maus rauszukriegen oder um die Bildschirmbreite zu erfahren.

Achte darauf, dass du deine Variablen nicht so benennst wie Systemvariablen und dass du Systemvariablen nie selbst einen Wert zuweist.

Größe des Grafikfensters

Hier ein Beispiel, wo du ein Rechteck malst, das das linke obere Viertel des Bildschirms besetzt. Benutze die Systemvariablen width und height, welche die Breite und Höhe deines Grafikfensters beinhalten:

rect(0, 0, width/2, height/2);

Achte darauf, dass die Systemvariablen width und height erst ab setup() zur Verfügung stehen und auch dort sinnvollerweise erst nach dem Kommando size() abgegriffen werden sollten. Das heißt, dass dieser Code nicht funktionieren wird:

int w = width; // Problem! width noch nicht gesetzt!
int h = height; // Problem! height noch nicht gesetzt!

void setup() {
}

void draw() {
   ellipse(w/2, h/2, 40, 40);
}

Position der Maus

Anderes typisches Beispiel: Ein Kreis soll an deiner Maus kleben. Dazu verwendest du mouseX und mouseY:

void setup() {
}

void draw() {
   background(255); // wir wollen ja keine Schlieren
   ellipse(mouseX, mouseY, 20, 20);
}

Refresh-Geschwindigkeit

Einen Aufruf von draw() nennt man auch einen Frame. Das kommt aus der Filmbranche, ein Frame ist ein Einzelbild eines Films. Normalerweise wird draw() 60 Mal pro Sekunde aufgerufen. Diese 60 nennt man auch die frame rate. Dies ist allerdings nur das Idealverhalten. Wenn du viele Programme laufen hast, die viel Rechenzeit benötigen, wird dieser Wert unterschritten. In der Variable frameRate steht der derzeit erreichte Wert. Den kann man sich ruhig mal anzeigen lassen:

void setup() {
}

void draw() {
   println(frameRate);
}

Überfordere auch mal den Rechner und sieh, wo die Grenzen liegen:

void setup() {
   frameRate(100000); // setze meine gewünschte frame rate
}

void draw() {
   println(frameRate); // zeige echte frame rate
}

Übersicht: Nützliche Systemvariablen

Hier eine Liste nützlicher Systemvariablen. Jede dieser Variablen hat auch einen Datentyp.

Zusammenfassung

• Variable als Container (Speicher): Eine Variable speichert etwas, z.B. einen Wert zur späteren Verwendung. Was genau sie speichern kann, sagt ihr Datentyp (kurz: Typ).
• Erzeugen: Eine neue Variable erzeugt man mit TYP NAME;
• Zuweisung: Hat man eine Variable foo, so kann man mit foo = 5 den Wert 5 dort hinein tun.
• Verwendung: Steht eine Variable wie foo im Code - z.B. in dem Befehl rect(foo, foo, 10, 10) - so wird "foo" durch den aktuellen Wert von foo ersetzt (Substitution).
• Konstanten: Konstanten sind Variablen, deren Wert nicht mehr verändert werden kann. Sie müssen bei der Deklaration auch direkt initialisiert werden.
• Literale: Literale sind die fest in den Quellecode eingetragenen Werte, die einer Variablen zugewiesen werden.
• Syntax: Beschreibt sie harten Regeln, an die man sich bei dem Wählen eines Variablennamens halten muss:
  • Groß- & Kleinschreibung beachten
  • keine Schlüsselworte verwenden
  • bestehen aus Ziffern (0-9), Buchstaben (a-z, A-Z), '_' und '$'
  • nicht mit einer Ziffer beginnen
  • keine Leerzeichen und auch keinen Bindestrich
• Konventionen: Beschreiben weiche Regeln, also Regeln an die es sinnvoll ist sich zu halten.
  • kleiner Anfangsbuchstabe
  • verwenden CamelCase
  • sind möglichst aussagekräftig gewählt
• Systemvariablen sind Variablen, die vom System (in unserem Fall Processing) zur Verfügung gestellt und berechnet werden.
• Systemvariablen sollten nur verwendet und niemals selber gesetzt werden.
• Eigene Variablen sollten niemals den selben Namen wie eine Systemvariable haben.