• Werte und Ausdrücke auf den Bildschirm ausgeben
• Werte merken
• Wie merkt sich ein Computer Werte?

Nachdem wir in der letzten Lektion eher theoretisch betrachtet haben, wie man Werte und Datentypen unterscheidet, wollen wir in dieser Lektion wieder etwas praktischer am Computer arbeiten.

Wir kennen bisher nur die Funktion System.out.println() und wissen, wie man einfache Ausdrücke formulieren kann. Weiterhin können wir Werte und Datentypen unterscheiden.

In unserem 1. Beispiel haben wir eine einfache Zeichenkette ausgegeben:

System.out.println("Hello World!");

Wir können damit aber noch viel mehr erreichen. Die Funktion System.out.println() erlaubt es uns nicht nur Zeichenketten auszugeben, sondern auch Werte sowie Ergebnisse von Ausdrücken:

public class PrintValues {
    public static void main(String[] args) {
        System.out.println("4 + 3 ist:");
        System.out.println(4 + 3);
        System.out.println("4.0 + 3.0 ist:");
        System.out.println(4.0 + 3.0);
    }
}

Zur Erinnerung: Das Programm muss unter dem Namen jener Klasse gespeichert werden, von der main() eingeschlossen wird. In diesem Fall wird das Programm also in die Datei „PrintValues.java“ gespeichert.

Für obiges Programm erhalten wir folgende Ausgabe:

4 + 3 ist:
7
4.0 + 3.0 ist:
7.0

Wir sehen hier also auch, dass in unserer Ausgabe der Ergebnistyp der Ausdrücke berücksichtigt wird.

Unsere Ausgabe enthält aber noch einen Schönheitsfehler: Wir hätten das Ergebnis gerne in der gleichen Zeile wie den Text davor. Da es aber - wie der Name schon sagt - in der Natur von println() liegt einen Zeilenumbruch an die Ausgabe anzuhängen, kommen wir mit 2 Aufrufen nicht weiter.

Eine Alternative wäre es, die Funktion System.out.print() zu verwenden, die eben jene Eigenschaft nicht enthält:

public class PrintValues {
    public static void main(String[] args) {
        System.out.print("4 + 3 ist: ");
        System.out.println(4 + 3);
        System.out.print("4.0 + 3.0 ist: ");
        System.out.println(4.0 + 3.0);
    }
}

Der Code liefert das von uns erwünschte Ergebnis:

4 + 3 ist: 7
4.0 + 3.0 ist: 7.0

Diese Lösung ist natürlich etwas unschön, da wir pro Ausgabe eine zusätzliche Codezeile brauchen. Abhilfe schafft die Verkettung von Strings und Ausdrücken.

Ähnlich wie wir im vorhergehenden Kapitel Operatoren für numerische Datentypen verwendet haben, können wir den + Operator dazu verwenden Zeichenketten zu verknüpfen:

public class StringAdd {
    public static void main(String[] args) {
        System.out.println("Hello" + " " + "World!");
    }
}

Als Ausgabe erhalten wir eine Verknüpfung aller angegebener Zeichenketten:

Hello World!

Alles klar, nun zurück zu dem Beispiel mit Berechnungen:

public class PrintValues {
    public static void main(String[] args) {
        System.out.println("4 + 3 ist: " + 4 + 3);
        System.out.println("4.0 + 3.0 ist: " + 4.0 + 3.0);
    }
}

Die Ausgabe fällt aber eher enttäuschend aus:

4 + 3 ist: 43
4.0 + 3.0 ist: 4.03.0

Das ist nicht wirklich das, was wir uns erhofft hatten. Der + Operator besitzt sowohl zwischen Zeichenketten als auch Zahlen die gleiche Priorität. Dementsprechend erfolgt die Auswertung von Links nach Rechts. Es wird also zuerst der Text mit „4“ bzw. „4.0“ verkettet, erst danach wird das Ergebnis auch noch mit „3“ bzw. „3.0“ verbunden.

Glücklicherweise haben wir ja bereits ein Mittel kennengelernt, um die Auswertungsreihenfolge zu verändern: Klammern!

public class PrintValues {
    public static void main(String[] args) {
        System.out.println("4 + 3 ist: " + (4 + 3));
        System.out.println("4.0 + 3.0 ist: " + (4.0 + 3.0));
    }
}

Endlich erhalten wir die lang ersehnte Ausgabe:

4 + 3 ist: 7
4.0 + 3.0 ist: 7.0

Dieses Kapitel über Ausgaben und Zeichenverkettung ist recht kurz gehalten und soll nur die wichtigsten Kenntnisse darüber vermitteln. Eine detailliertere Beschreibung folgt in einem späteren Kapitel.

Wenn wir den Computer Aufgaben wie 4+3 lösen lassen, so lösen wir nur dieses absolute und unveränderliche Problem (eben 4+3). Computer sollen jedoch meistens Probleme lösen, die sich in einer Rechenvorschrift beschreiben lassen, einem sogenannten Algorithmus - man möchte die Zahlen auswechseln können, um auch andere Aufgaben rechnen zu können.

Hierfür benötigen wir einen Identifikator für Werte, ohne zu wissen, welchen Wert des Identifikators hat - wie in der Mathematik, wo Werte durch Buchstaben gekennzeichnet werden.

Genauso machen wir es beim Programmieren. Die Buchstaben sind die Identifikatoren, zusätzlich müssen wir dem Computer jedoch sagen, um welchen Datentyp es sich handelt, also wie er die Daten verarbeiten soll. Wir verwenden vorerst den Typ int für alle ganzen Zahlen und double für alle Gleitkommazahlen, Details zu den Typen kommen im nächsten Kapitel. Schauen wir uns aber zuerst an, wie man sich in Java eine Zahl merkt und sie anschließend auf dem Bildschirm ausgibt.

public class Variables {
    public static void main(String[] args) {
        int natuerlicheZahl = 4711;      // Neuen Variable bekanntgeben
                                         //   und gleich initialisieren
        double reelleZahl;               // Variable bekanntgeben 
                                         //   ohne einen Wert zuzuweisen
 
        reelleZahl = 3.1415;             // Variable einen neuen Wert zuweisen
 
        System.out.println("Ich habe mir folgende Zahlen gemerkt:");
        System.out.println("natürliche Zahl: " + natuerlicheZahl);
        System.out.println("reelle Zahl: " + reelleZahl);
    }
}

Im obigen Programm haben wir Variablen verwendet um uns Werte zu merken. Selten werden wir jedoch immer mit Werten arbeiten, die sich nie ändern bzw. für jede Kleinigkeit eine eigene Variable erstellen. Viel praktischer wäre es bestehende Variablen zu überschreiben. Glücklicherweise verwenden wir hier Variablen - Wie der Name schon sagt können wir diese Werte permanent beliebig verändern.

public class OverwriteVariables {
    public static void main(String[] args) {
        int natuerlicheZahl;
        int andereZahl = 2;
 
        natuerlicheZahl = 4711;
        System.out.println("Ich habe mir folgende Zahlen gemerkt:");
        System.out.println("natürliche Zahl: " + natuerlicheZahl);  // 4711
 
        natuerlicheZahl = andereZahl;
        System.out.println("Ich habe mir folgende Zahlen gemerkt:");
        System.out.println("natürliche Zahl: " + natuerlicheZahl);  // 2
 
        natuerlicheZahl = natuerlicheZahl + 3;
        System.out.println("Ich habe mir folgende Zahlen gemerkt:");
        System.out.println("natürliche Zahl: " + natuerlicheZahl);  // 5
    }
}

Im obigen Programm sehen wir schön, dass auch bereits initialisierte Variablen noch verändert werden können. Dabei kann auf der rechten Seite der Zuweisung sowohl eine Konstante (z.B. 4711), eine Variable (z.B. andereZahl) als auch ein ganzer Ausdruck stehen (z.B. natuerlicheZahl + 2).

Du solltest nun in der Lage sein, einfache Aufgaben mit Variablen berechnen zu können und Dir das Ergebnis anzeigen zu lassen.

Übungsaufgabe: Definiere zwei Variablen a und b und weise ihnen Werte zu und berechne die Summe vom a zum Quadrat und b zum Quadrat und lass Dir das Ergebnis auf dem Bildschirm ausgeben. Beginne damit, das Ergebnis erst in einer Variablen c zwischen zu speichern und optimiere dann die Variable c aus dem Programm hinaus, in dem du die den Ausdruck, um c zu bestimmen, direkt in die println-Anweisung überträgst.

Eine schöne Übung ist einen Budgetplaner zu schreiben. Berechne Deine monatlichen Einnahmen und monatlichen Ausgaben und ziehe Dein Gehalt davon ab. Multipliziere das Ergebnis mit 12. Addiere jährliche Einnahmen (Steuerrückzahlung, Weihnachtsgeld) und subtrahiere jährliche Kosten (Versicherung, KFZ-Steuer).

Bisher haben wir die Typen int (Ganzzahlen) und double (Gleitkommazahlen) verwendet, ohne auf die Details einzugehen. In der kommenden Lektion werden wir uns genau ansehen welche Typen uns Java standardmäßig anbietet und welche Werte sie annehmen können.