Variablen

Definition: Variable

Mit einer Variable wird in einer Programmiersprache eine Speicherzelle verwaltet. Variablen müssen deklariert werden.
G. Büchel, Praktische Informatik

In der Speicherzelle wird ein Wert (value) abgelegt

Bisher haben wir die Mathematik bemüht, um das Konzept der Variable zu erläutern. Da sich aber Variablen in Computerprogrammen von denen in der Mathematik unterscheiden, soll hier noch einmal eine eigenständige Definition gegeben werden, die sich an der technischen Implementierung orientiert.

Prinzipiell dienen Variablen der Verwaltung von Speicherzellen im Hauptspeicher des Computers. Obwohl man theoretisch die Speicherzellen auch direkt ansprechen könnte, ist es deutlich komfortabler mit Variablen anstatt mit Speicherzellen zu arbeiten. Assemblerprogramme sind hier eine Ausnahme, da sie direkt über die Adressen auf den Speicher zugreifen und deswegen keine Variablen kennen. In allen Hochsprachen werden aber Variablen eingesetzt und in vielen Hochsprachen (so auch Java) ist ein direkter Zugriff auf den Speicher über Adressen nicht möglich. Sprachen wie C und C++ kennen aber tatsächlich beide Möglichkeiten: man kann mit Variablen arbeiten, hat aber auch die Möglichkeit direkt auf den Speicher zuzugreifen. Variablen sind also nichts anderes als eine Repräsentation einer Speicherstelle des Hauptspeichers im Programm.

Damit der Compiler (oder Interpreter) weiß, welche Speicherstellen ein Programm benötigt, müssen Variablen deklariert (d. h. bekannt gemacht) werden.

Was ist eine Variable?

Variablen sind Platzhalter für konkreten Wert (analog zur Variable in der Mathematik)

  • Programm funktioniert für beliebige Werte. Beispiel:
    • bruttoPreis = nettoPreis * ( 1.0 + ustSatz / 100.0)
    • bruttoPreis, nettoPreis und ustSatz sind Variablen
  • Variablen können ihren Wert beliebig oft ändern
    • Gegensatz zur Mathematik!
    • Variable als temporärer Datenspeicher, z. B. für Zwischenergebnisse
      Beispiel: i = i + 1;

Aus Sicht der Programmierer:innen sind Variablen Platzhalter für Werte, die erst später (also nachdem das Programm fertiggestellt wurde) bestimmt werden. Mit Variablen kann man dann – wieder ähnlich zur Mathematik – mit den Platzhaltern anstatt mit den konkreten Werten arbeiten.

Ein wichtiger Unterschied zur Mathematik besteht darin, dass Variablen ihren Wert beliebig oft ändern können. Eine Variable kann also mehr als einmal zugewiesen werden. Dies ist in der Mathematik nicht möglich. Das Konstrukt i = i + 1 wäre in einer mathematischen Formel nicht zulässig. Hier müsste man für jede Veränderung eine neue Variable einführen.

Variablennamen sind Bezeichner

Variablennamen sind Bezeichner. Es gelten die Regeln für Bezeichner

  • entspricht nicht einem Schlüsselwort
  • enthält beliebige Unicode-Buchstaben, Zahlen, $ oder _
  • beginnt mit _, $ oder einem Buchstaben
  • kann beliebig lang werden
  • Gültige Bezeichner:
    _hugo, peter__$$, antwort_42, meine7suenden, $rich$, haenselUndGretel
  • Ungültige Bezeichner:
    7zwerge, goto, km/h, -strich, haensel&gretel

Da jede Variable einen Namen bekommen muss (→ Deklaration), stellt sich die Frage, welche Namen zulässig sind. Variablennamen sind Bezeichner, sodass alle gültigen Bezeichner nach den o.g. Regeln als Variablennamen dienen können, um einen syntaktisch korrekten Variablennamen zu erhalten.

Definition von Variablen

Variablen

  • Festlegung eines Namens (→ Variablendeklaration)
  • Reservierung von Speicherplatz (→ Variablendefinition)
  • Festlegung des Typs der Daten (→ Datentypen)
  • Initialen Wert festlegen (→ Initialisierung)
  • Beispiel: int anzahl = 0;

Aus der Mathematik ist das Konzept einer Variable bereits bekannt. Eine Variable kann in einer mathematischen Gleichung (z. B. \( x^2 + 7x = 0 \)) für einen oder mehrere gesuchte Werte stehen oder in einer Funktion (z. B. \( f(x) = x^3 + 2x^2 \)) einen beliebigen Wert (innerhalb des Definitionsbereiches der Funktion) annehmen.

Für fast alle Programmier-Probleme benötigt man Variablen. Wir müssen der Variable einen Namen geben (Deklaration) und sie im Hauptspeicher ablegen (Definition). Variablen in Computerprogrammen brauchen zusätzlich einen ersten Startwert (Initialisierung) und haben einen sogenannten Datentyp, damit klar ist, wie der Computer mit der Variable umgehen soll.

Konvention für Variablennamen

Namenskonvention für Variablennamen werden nicht vom Compiler erzwungen aber freiwillig von allen entwickelnden Personen eingehalten

Variablennamen

  • beginnen mit Kleinbuchstabe
  • weiter mit Kleinbuchstaben
  • wenn ein neues Wort beginnt, wird ein Großbuchstabe verwendet (Camel-Notation)

Gut: anzahlDatensaetze, limit, eingabeWert

Schlecht: anzahl_datensaetze, LIMIT

Vernünftigerweise hält man sich an die folgenden Regeln, wenn man Variablennamen festlegt

  • Namen aussagekräftig wählen
  • Bedeutung sollte sofort klar werden
  • Namen hinreichend lang wählen (ein und zwei Buchstaben vermeiden)
    Ausnahme: Schleifenzähler
    • bruttoPreis statt b
    • ustSatz statt m
  • entweder alle Variablennamen auf Deutsch oder alle auf Englisch

Syntaktisch korrekte Variablennamen können trotzdem sehr schlecht zu lesen sein, z. B. __$__$__ oder $GaRGelK_arXXX__. Daher haben sich Konventionen etabliert, wie man Variablen sinnvollerweise benennt. Diese Regeln werden nicht vom Compiler durchgesetzt und es obliegt daher Programmierer:innen, sie einzuhalten.

Eine übersichtliche Benennung von Variablen und eine gute Formatierung des Quelltextes kann ganz erheblich zum Verständnis eines Programms beitragen.

Verwendung von Variablen

  • Ein Programm kann beliebig viele Variablen haben
    • für Eingabeparameter (nettoPreis)
    • für Konstanten (ustSatz)
    • für Zwischenwerte (ustFaktor)
    • für Ergebnisse (bruttoPreis)

Berechnung von Werten

Um mit den Variablen rechnen zu können, verwenden wir Ausdrücke. Mit ihnen können wir aus bekannten Werten neue Werte berechnen.

  • Ausdrücke (expressions) erlauben die Berechnung von neuen Werten aus alten Werten
    z. B. 8 + 3 * 12 oder (x + y) + 3 * x
  • Sie bestehen aus
    • Operationen (→ Mathematik)
    • Operatoren (→ Mathematik)
    • Operanden (→ Mathematik)

Auch dieses Konzept ist bereits aus der Mathematik bekannt, so ist z. B. \( x + 8 \) ein Ausdruck, der aus einem beliebigen Wert x einen neuen Wert, der um 8 größer ist berechnet. Ein Ausdruck besteht aus Operatoren und Operanden. Die Operatoren werden auf die Operanden angewendet, um ein neues Ergebnis zu erhalten. Im Ausdruck \( x + 8 \) ist + der Operator und x und 8 sind die Operanden.

Wenn in einem Ausdruck eine Variable vorkommt (z. B. x), so wird die Variable durch ihren Wert ersetzt, bevor der Ausdruck ausgerechnet wird. Sei z. B. der folgende Ausdruck gegeben (x + y) + 3 * x mit x = 5 und y = 7, so rechnet der Computer \( (5 + 7) + 3 \cdot 5 = 12 + 15 = 27 \).

Verwendung von Variablen

  • Jede Variable muss einen Datentyp (data type) haben
    • Wahrheitswert (boolean), z. B. true
    • ganze Zahl (byte, short, int, long), z. B. 42
    • Fließkommazahl (float, double), z. B. 23.312
    • einzelnes Zeichen (char), z. B. 'a'
    • Zeichenkette (String), z. B. "Hallo Welt!"
    • …
  • Variable wird im Hauptspeicher des Computers abgelegt

Die Anzahl von Variablen, die man in einem Programm verwenden kann, wird prinzipiell nur durch den Hauptspeicher des Computers begrenzt. Man kann also so viele Variablen anlegen, wie man für die Lösung seines Problems braucht. Da die Lesbarkeit eines Quelltextes auch ganz erheblich von der sinnvollen Verwendung von Variablen abhängt, sollte man auf keinen Fall Variablen für verschiedenen Zwecke wiederverwenden, um Speicherplatz zu sparen. Moderne Computer haben genug Speicher und die Klarheit des Quelltextes hat hier Vorrang.

Variablen haben im Computer immer einen sogenannten Datentyp (data type), der festlegt, welche Art von Daten in einer Variable gespeichert werden können. Diese Festlegung ist nötig, da der Compiler wissen muss, wie viele Bytes er für die Speicherung der Daten im Hauptspeicher reservieren muss und wie er die Bitmuster im Speicher interpretieren soll. Ein weiterer Vorteil von Datentypen besteht darin, dass der Compiler Fehler im Programm besser erkennen kann, die entstehen, wenn man versucht, Variablen mit falschen Daten zu befüllen.

Beispiel: Verwendung von Variablen 

double ustSatz = 19.0;
double ustFaktor = 1.0 + ustSatz / 100.0;

Scanner scanner = new Scanner(System.in);
System.out.println("Bitte Nettopreis eingeben:");
double nettoPreis = scanner.nextDouble();

double bruttoPreis = nettoPreis * ustFaktor;

System.out.println("Der Bruttopreis ist: " + bruttoPreis);

Der Quelltext im Beispiel verwendet eine ganze Reihe von Variablen, um den Bruttopreis (also den Preis inklusive Umsatzsteuer) zu einem gegebenen Nettopreis zu berechnen. Die Syntax der verschiedenen Kommandos werden wir später noch behandelt. Hierzu wird eine Reihe von Variablen verwendet:

  • ustSatz speichert den aktuellen Umsatzsteuersatz. Obwohl dieser Wert fix ist, wird er in einer Variable gehalten, damit man in späteren Schritten besser erkennen kann, wo der Wert eingeht.
  • ustFaktor stellt den Multiplikationsfaktor dar, mit dem man den Nettopreis multiplizieren muss, um auf den Bruttopreis zu kommen.
  • scanner ist Teil der Eingabeanweisung.
  • nettoPreis ist der von den Benutzer:innen eingelesene Nettopreis.
  • bruttoPreis ist der berechnete Bruttopreis.

Man hätte das Programm auch mit viel weniger Variablen schreiben können, die Lesbarkeit hätte aber erheblich darunter gelitten. 

// Schlechtes Beispiel!
Scanner scanner = new Scanner(System.in);
System.out.println("Bitte Nettopreis eingeben:");
double nettoPreis = scanner.nextDouble();

System.out.println("Der Bruttopreis ist: "
        + nettoPreis * (1.0 + 19.0 / 100.0));

Deklaration einer Variable

  • Deklaration: Name und Datentyp einer Variable muss vor der ersten Verwendung dem Compiler bekannt gemacht werden
    Syntax: DATENTYP variablenname;
  • Defintion: Für die Variable wird Speicher reserviert
    • in Java erfolgen Deklaration und Definition immer gleichzeitig und sind daher nicht zu unterscheiden
    • manche Programmiersprachen erlauben Trennung von Deklaration und Definition (z. B. C und C++)

Es gibt Programmiersprachen, in denen die Trennung von Deklaration und Definition wichtig für die Semantik des Programms ist. So ist es in C z. B. manchmal nötig, eine globale Variable an mehreren Stellen zu deklarieren, damit die Programmteile Zugriff darauf erhalten, sie darf aber nur an einer einzigen Stelle definiert werden. Da Java vollständig auf das Konzept der globalen Variablen verzichtet, wird diese Unterscheidung nicht benötigt und Deklaration und Definition erfolgen immer in einem Schritt.

  • Variablennamen müssen eindeutig sein
  • mehrere Variablen können auf einmal deklariert werden (schlechter Stil)
int antwort;
int tick, trick, track; // schlecht!
long vermoegenVonBillGates;

double steuerSatz;

String lieblingsEssen;
String heimatOrt;

Da eine Variable eine Speicherstelle bezeichnet ist klar, dass man den Namen nicht mehrfach verwenden darf. Insofern muss der Name einer Variable eindeutig sein. Wir werden später noch sehen, dass diese Regel nur für bestimmte Teile eines Programms gilt und es durchaus möglich ist, an verschiedenen Stellen gleichnamige Variablen zu benutzten.

Die Deklaration von mehreren Variablen in einer Zeile gilt als schlechter Stil, weil sie unübersichtlich ist.

Zuweisung

  • Variablen erhalten ihren Wert durch eine Zuweisung (assignment)
  • Zuweisungsoperator (asignment operator) = wird benutzt.
    Nicht mit dem Gleichheitszeichen der Mathematik zu verwechseln!
  • Syntax: Variablenname = Ausdruck;
antwort = 42;
vermoegenVonBillGates = 7000000000L;
lieblingsEssen = "Spaghetti";

Damit eine Variable einen Wert speichern kann, muss ihr ein solcher zugewiesen werden. Hierzu gibt es einen Operator (Operatoren werden im nächsten Kapitel noch detailliert behandelt), der der Variable einen Wert zuweist also den Wert in die Variable hineinschreibt.

Ein häufiger Fehler von Programmierneulingen ist es, den Zuweisungsoperator = mit dem Gleichheitszeichen = aus der Mathematik zu verwechseln. Damit der Compiler die Zuweisung und den Vergleich unterscheiden kann, gibt es für den Vergleich einen anderen Operator ==, der schon eher dem Gleichheitszeichen der Mathematik entspricht. Die Operatoren werden später noch genauer behandelt.

  • Zuweisung a = b: Variable a nach der Zuweisung den Wert von b.
  • Vergleich a == b: Liefert einen booleschen Wert zurück, der true ist, wenn a denselben Wert wie b hat, andernfalls false.

Undefinierte Variablen

  • Neu deklarierte Variablen sind uninitialisiert
    • würden zu Fehlern im Programm führen
    • werden vom Java-Compiler nicht akzeptiert
  • Variable muss durch Zuweisung einen ersten Wert bekommen: Initialisierung
Fehlerhaftes Programm
int hatKeinenWert;
System.out.println(hatKeinenWert); // Fehler
Fehlermeldung des Compilers
error: variable hatKeinenWert might not have been initialized
        System.out.println(hatKeinenWert);

Bei der Deklaration der Variable wird Speicher entsprechend dem Datentyp der Variable reserviert. Der Inhalt des Speichers wird aber nicht verändert, d. h. es können beliebige Daten aus vorhergehenden Verwendungen des Speichers an dieser Stelle stehen. Damit ist der Inhalt der Variable nach der Deklaration nicht bekannt bzw. undefiniert. Der Begriff undefiniert wird bei Programmiersprachen immer dann verwendet, wenn für eine bestimmte Konstruktion die Semantik nicht im Rahmen der Programmiersprache definiert ist. Abhängig von der Programmiersprache kann dies bedeuten, dass das Programm einfach abstürzt oder mit falschen Werten rechnet. In Java hat man sich dafür entschieden, dass bereits der Compiler solche undefinierten Zustände entdeckt und die Übersetzung abbricht. Das hat den Vorteil, dass die Fehler bereits recht früh erkannt werden und nicht erst zur Laufzeit des Programms.

Die Variable muss also vor der ersten Verwendung durch eine Zuweisung einen Wert bekommen. Diese besondere Form der Zuweisung nennt man Initialisierung.

Initialisierung von Variablen

  • Variablen werden durch eine Zuweisung initialisiert
    Syntax: variablenname = AUSDRUCK;
  • Deklaration und Zuweisung können kombiniert werden
    Syntax: DATENTYP variablenname = AUSDRUCK;

Häufig kombiniert man die Deklaration mit der Initialisierung, da sowieso jede Variable einen Wert bekommen muss und vorher nicht verwendet werden kann. 

int antwort; // Deklaration
antwort = 42; // Zuweisung

 // Kombinierte Deklaration und Zuweisung
long vermoegenVonBillGates = 7000000000L;
double steuerSatz = 19.0;

// berechneter Ausdruck
double ustFaktor = 1.0 + (steuerSatz / 100.0);

Wozu Konstanten?

  • Es gibt fixe Werte, die sich während des Programmablaufs nie ändern
    • pi, e, NA
    • Umsatzsteuersatz
  • Diese Werte werden oft mehrmals verwendet
  • Man möchte
    • sie an einer Stelle festlegen, sodass Änderungen zentral möglich sind
    • ihnen einen sprechenden Namen geben
double radius = 10.0;
double flaeche = 3.14169265 * radius * radius;
double umfang = 2.0 * 3.14169265 * radius;

Es gibt in jedem Programm Werte, die innerhalb des Programms nicht geändert werden, d. h. sie bleiben während des Programmablaufs konstant. Einige dieser Werte ändern sich nie, wie z. B. mathematische oder physikalische Konstanten. Andere können sich schon ändern (z. B. Umsatzsteuersatz), die Änderungen sind aber sehr selten und geschehen nicht während der Programmlaufzeit.

Diese konstanten Werte werden normalerweise an mehreren Stellen des Programms verwendet. Setzt man die Zahlenwerte direkt in das Programm ein (so wie im vorliegenden Beispiel), so muss man sie bei einer Änderung auch an mehreren Stellen anpassen. Dabei können leicht Fehler passieren. Im Beispiel ist der Wert von PI falsch angegeben. Entdeckt man den Fehler an einer Stelle, muss man ihn an allen anderen Stellen ebenfalls korrigieren. Hierbei übersieht man schnell eine Stelle.

Ein weiterer Vorteil von Konstanten ist, dass man anstatt einer Zahl einen sprechenden Namen verwenden kann. Wenn im Quelltext nicht 0.19, sondern UST_SATZ steht, ist es für einen Leser viel schneller zu erkennen, was gemeint ist.

Konstanten

  • Eine Konstante (constant) ist ein Wert, der im Programm einmal deklariert wird und sich danach nicht mehr ändern kann
  • Konstanten haben einen Datentyp wie Variablen
  • Deklaration innerhalb einer Methode
    final TYP NAME = WERT;
  • Deklaration außerhalb einer Methode
    static final TYP NAME = WERT;
  • Namensschema
    • Großbuchstaben, Zahlen (A–Z, 0–9)
    • Worttrennung mit Unterstrich (_)
    • Beispiel: UST_SATZ, MAX_ANZAHL
  • Programm kann beliebig viele Konstanten haben
  • Wert der Konstante kann auch berechnet werden

Konstanten verhalten sich ähnlich zu Variablen, d. h. sie haben einen Datentyp und müssen vor der Verwendung deklariert werden. Anders als bei Variablen müssen sie direkt bei der Deklaration mit einem Wert belegt werden und können nachträglich nicht mehr geändert werden.

Die Namenskonvention für Java sieht vor, dass man Konstanten nur mit Großbuchstaben benennt. Da hierdurch keine Camel-Notation mehr möglich ist, trennt man Wörter durch den Unterstrich.

Konstante innerhalb einer Methode
class Kreis {
    public static void main(String[] args) {

        final double PI = 3.14159265;

        double radius = 10.0;
        double flaeche = PI * radius * radius;
        double umfang = 2.0 * PI * radius;
    }
}
Konstante außerhalb einer Methode
class Physik {

    static final double PI = 3.14159265;
    static final double H = 6.62606957e-34;
    static final double H_QUER = H / (2 * PI);

    public static void main(String[] args) {
        double frequenz = 120e12;
        double energie = frequenz * H_QUER;
    }
}

Das Beispiel zeigt, dass eine Konstante auch berechnet werden kann, wie hier H_QUER. Voraussetzung ist, dass die Werte, die in die Berechnung eingehen, selbst wieder konstant sind.

Copyright © 2025 Thomas Smits