Die Beispiele in den letzten Abschnitten wiesen einen gravierenden Nachteil auf: es waren keine Eingaben durch „User“ (so genannte Benutzereingaben) möglich. Dies ist aber für die Steuerung eines Programmes oder für die Dateneingabe unerlässlich. Die Eingabe von Daten „auf der Konsole“ soll in diesem Abschnitt behandelt werden.

Ein- und Ausgabe werden also über die Text-Kommandozeile des Terminalfenster abgewickelt. Da Java ursprünglich in erster Linie für grafische Benutzeroberflächen entwickelt wurde, erscheinen die Ein- und Ausgabeprozeduren auf der Kommandozeile reichlich kompliziert. Zunächst werden wir die Ausgabe zusammenfassen und dann die wichtigsten Klassen und Methoden zur Eingabe kennen lernen:

Verwendung von System.out.print
Verwendung von InputStreamReader
Verwendung von BufferedReader
Vorgegebene Methoden verwenden: readLine(), parseInt()
Fehlerbehandlung mittels throws IOException

Ausgabe

Die Methoden System.out.print() und System.out.println() geben die enthaltenen Strings und Variablen auf der Kommandozeile aus. Die Zeichenketten können zusätzlich Steuerzeichen (\n, \t, etc.) enthalten. Mehrere Zeichenketten werden mit dem Operator + verkettet. Variable und Rechenausdrücke werden vor der Ausgabe evaluiert.

Beispiel: Ausgabe mehrerer Zeilen

public class ausgabe1 {
 
    public static void main (String [] args) {
        for (int i=1;i<10;i++) {
            System.out.print(i);
            System.out.print(" zum Quadrat ergibt ");
            System.out.println(i*i);
        }
    }
}

Mehrere Strings verketten

public class ausgabe1b {
 
    public static void main (String [] args) {
        for (int i=1;i<10;i++) {
            System.out.println(i + " zum Quadrat ergibt " + i*i);
        }
    }
}

In Methodenaufruf von System.out.println wird grundsätzlich eine Zeichenkette übergeben. Kommt eine Variable oder ein mathematischer Ausdruck vor, so wird zunächst der Zeichenkettenwert ermittelt und dieser mit den anderen Strings verkettet ¹⁾.

Steuerzeichen verwenden

ine Ausgabe mit System.out.print() beginnt am Anfang einer Zeile. Mit Hilfe so genannter Steuerzeichen können z.B. Tabulatoren und Zeilenschaltungen in den Ausgabestring eingebettet werden.

public class ausgabe2 {
    public static void main (String [] args) {
        System.out.print("\tEinrückung\nZeilenschaltung\n\tZeilenschaltung und Einrückung
\n\t\tZeilenschaltung und mehrere Einrückungen");
    }
}

Die Steuerzeichen (escape character) werden durch einen vorangestellten „Backslash“ \ gekennzeichnet und in den String eingebettet. Im Beispiel wurden \t für einen Tabulator und \n für eine neue Zeile verwendet. Wir erhalten damit:

        Einrückung
Zeilenschaltung
        Zeilenschaltung und Einrückung
                Zeilenschaltung und mehrere Einrückungen

Einfach formatierte Ausgabe

Für die schnelle Textausgabe, wie sie beispielsweise über Netzwerkdienste erfordert wird, kann man die Ausgabe mit Hilfe von Text- und Steuerzeichen effizient formatieren11. Dazu verwenden wir einfache Linien, die aus Minuszeichen - gebildet werden. Vertikale Linien entstehen durch das „Oder“-Zeichen |; „Kreuzungspunkte“ werden durch das Pluszeichen + realisiert. Tabulatoren ermöglichen die einfache und genaue Positionierung der Zeichen:

public class ausgabe2b {
    public static void linie() {
        System.out.println("+-------+-------+");        
    }
    public static void main (String [] args) {
        linie();
        System.out.println("|  i"+"\t|  i*i"+"\t|");
        linie();
        for (int i=0;i<5;i++) {
            System.out.println("|  "+ i + "\t|  " + (i*i) + "\t|");
        }
        linie();
    }
}

Beachte die Verwendung der einfachen Methode linie() - für anspruchsvollere Projekte lassen sich hier verschiedene „Bausteine“ (Überschriften, Summenzeilen, etc.) erfinden. Die Ausgabe ist jedenfalls überraschend übersichtlich:

+-------+-------+
|  i    |  i*i  |
+-------+-------+
|  0    |  0    |
|  1    |  1    |
|  2    |  4    |
|  3    |  9    |
|  4    |  16   |
+-------+-------+

Eingabe

Einfache Eingabe

Grundsätzlich sind Byte-Stream-Klassen und Character-Stream-Klassen zu unterscheiden. Obwohl die Ein- und Ausgabe auf der untersten Ebene byteorientiert gehandhabt wird, werden wir in den folgenden Beispielen ausschließlich die zeichenorientierte Eingabe mit Hilfe der Character-Stream-Klassen besprechen.

Für die Eingabe muss ein so genanntes „Package“ geladen werden, das alle Klassen und Methoden für die Ein- und Ausgabe enthält. Dies geschieht mit dem import - Befehl zu Beginn des Programmcodes.

Zeichen eingeben

Die Methode read liest zeichenweise aus dem Datenpuffer aus.

import java.io.*;
 
public class eingabe1 {
        public static void main (String [] args) throws IOException {
                InputStreamReader datenstrom = new InputStreamReader(System.in);
                BufferedReader dateneingabe = new BufferedReader(datenstrom);
                char zeichen;
                do {
                    zeichen = (char) dateneingabe.read();
                    System.out.println(zeichen + " ");
                } while (zeichen != 'X');
        }
}

Zunächst wird ein InputStreamReader gebildet, der die Eingaben von der Standardeingabe (Konsole) entgegennimmt. Der BufferedReader übernimmt das Zwischenspeichern der Eingabe - aus diesem Datenpuffer werden die Zeichen mit Hilfe der Methode read() ausgelesen. Der TypeCast (char) stellt die notwendige Typenkompatibilität sicher.

Die Dateneingabe (und die zeichenweise Ausgabe) wird abgebrochen, sobald der Großbuchstabe X eingegeben wurde.

Informatik ist schön X
I n f o r m a t i k   i s t   s c h ö n   X

Zeilenweise Eingabe

Zuerst muss ein Objekt vom Typ InputStreamReader() erzeugt werden, das das Objekt BufferedReader verwenden kann. Dieses enthält schließlich die Eingabe, aus der die Methode readLine() zeilenweise ausliest…

import java.io.*;
 
public class eingabe {
 
    public static void main (String args[]) throws IOException{
        InputStreamReader datenstrom = new InputStreamReader(System.in);
        BufferedReader dateneingabe = new BufferedReader(datenstrom);
        int i = Integer.parseInt(dateneingabe.readLine());
        System.out.println("Die Zahl " + i + " wurde eingegeben ;-)");
    }
}

Beachte, dass die Methode readLine() verwendet werden muss, um eine Zeile aus der Eingabe zu lesen! Diese Zeile muss schließlich noch mit der Methode parseInt() der Klasse Integer in eine ganze Zahl umgewandelt werden. Dieses Ergebnis wird schließlich der Variablen i (vom Typ einer ganzen Zahl) zugewiesen. Erst dann steht die Eingabe beispielsweise für Berechnungen zur Verfügung.

Die Eingabe der ganzen Zeile (hier eine mehrziffrige ganze Zahl) wird ausgegeben:

3142
3142 wurde eingegeben ...

Wiederholte Eingabe

Im folgenden Beispiel ist die Abbruchbedingung erreicht, wenn die Zahl 0 eingegeben wurde:

import java.io.*;
 
public class eingabe2 {
 
    public static void main (String args[]) throws IOException {
        InputStreamReader eingabedatenstrom = new InputStreamReader(System.in);
        BufferedReader eingabe = new BufferedReader(eingabedatenstrom);
        int i=1;
        while (i!=0) {
            System.out.print (">? ");
            i = Integer.parseInt(eingabe.readLine());
            System.out.println("Das Quadrat von " + i + " = " + i*i);
        }
    }
}

Damit wird zuletzt die Quadratzahl von 0 ausgegeben, anschließend bricht das Programm ab:

>? 1
Das Quadrat von 1 = 1
>? 6
Das Quadrat von 6 = 36
>? 0
Das Quadrat von 0 = 0

Durch Verwendung geeigneter Programmstrukturen und entsprechender Bedingungen lassen sich komplexe Dialoge realisieren…

"Sternreihen" ausgeben

m folgenden Beispiel werden Reihen von * nach einigen Mustern („trapezförmig“) ausgegeben, wobei die einzelnen Muster durch eine Linie getrennt werden sollen. Die maximale Anzahl der * wird eingegeben; die Ausgabe bricht ab, wenn 0 eingegeben wurde:

5
*
**
***
****
*****
*****
****
***
**
*
------
    *
   **
  ***
 ****
*****
*****
 ****
  ***
   **
    *
------
*****
 ****
  ***
   **
    *
    *
   **
  ***
 ****
*****
------
*****
****
***
**
*
*
**
***
****
*****

Die „Programmsteuerung“ wurde im Hauptprogramm mit Hilfe einer do - while Schleife realisiert: Solange keine 0 eingegeben wurde, werden die einzelnen „Dreiecksteile“ ausgegeben. Beachte die korrekte Übergabe der eingegebenen Zahl!

import java.io.*;
 
public class trapez {
    public static void main (String [] args) throws IOException {
        int zahl;
        do {
            BufferedReader zahlenpuffer = new BufferedReader(new InputStreamReader(System.in));
            zahl = Integer.parseInt(zahlenpuffer.readLine());
            dreieck1(zahl, true);
            dreieck1(zahl, false);
            linie(zahl);
            dreieck2(zahl, false);
            dreieck2(zahl, true);
            linie(zahl);
            dreieck3(zahl);
            linie(zahl);
            dreieck4(zahl);
        } while (zahl != 0);
    }
 
    public static void linie(int reihe) {
        for (int i=0; i<=reihe; i++)
            System.out.print("-");
        System.out.print("\n");
    }
 
    public static void dreieck1(int zahl, boolean modus) {
        if (modus) 
            for (int i = 0; i<zahl; i++) ausgabe1(i);
        else 
            for (int i = zahl-1; i>=0; i--) ausgabe1(i);
    }
 
    public static void ausgabe1(int reihe) {
        for (int j = 0; j <= reihe; j++) {
            System.out.print("*");
        }
        System.out.print("\n"); 
    }
 
    public static void dreieck2(int zahl, boolean modus) {
        if (modus) 
            for (int i = 0; i<zahl; i++) ausgabe2(i, zahl);
        else 
            for (int i = zahl-1; i>=0; i--) ausgabe2(i, zahl);
    }
 
    public static void ausgabe2(int reihe, int rest) {
        for (int j = 0; j < reihe; j++) 
            System.out.print(" ");
        for (int j = 0; j < rest-reihe; j++)
            System.out.print("*");
        System.out.print("\n");
    }
 
    public static void dreieck3(int zahl) {
        dreieck2(zahl, true);
        dreieck2(zahl, false);
    }
 
    public static void dreieck4(int zahl) {
        dreieck1(zahl,false);
        dreieck1(zahl,true);
    }
}

Das obige Programm könnte noch komprimierter formuliert werden. Wie?

Häufigkeitsanalyse

Zunächst sollen eine bestimmte Anzahl (umfang) gauss-verteilte Zufallszahlen ermittelt werden. Anschließend wird die Häufigkeitsverteilung dieser Zahlen ermittelt und am Bildschirm mit entsprechend langen * - Reihen ausgegeben.

import java.io.*;
import java.util.Random;
 
public class gauss {
    public static void main (String[] args) throws IOException {
        int zahl;
        do {
            BufferedReader zahlenpuffer = new BufferedReader(new InputStreamReader(System.in));
            zahl = Integer.parseInt(zahlenpuffer.readLine());
            if (zahl>0) analyse(zahl);
        } while (zahl > 0);
    }
 
    public static void analyse(int anzahl) {
        int erg[] = new int[21];
        double gausszahl;
        Random r = new Random();
 
        for (int i=0; i<21; i++) erg[i]=0;
 
        for (int i = 0; i<anzahl; i++) {
            gausszahl = r.nextGaussian()*2;
            if ((gausszahl <= 10) && (gausszahl) >= (-10)) erg[(int) (gausszahl+10)]++;
        }
        for (int i=0; i<21; i++) ausgabe(i-10, erg[i]);
    }
 
    public static void ausgabe(int wert, int reihe) {
        System.out.print("   " + wert + ":\t");
        for (int i=0; i<reihe; i++) System.out.print("*");
        System.out.print("\n");
    }
}

Für 300 gewählte Zufallszahlen erhalten wir beispielsweise:

300
   -10:
   -9:
   -8:
   -7:
   -6:  *
   -5:  ******
   -4:  ***************
   -3:  ********************
   -2:  *****************************************
   -1:  ***************************************************************
   0:   **************************************************************
   1:   ********************************************
   2:   *****************************
   3:   **************
   4:   ****
   5:   *
   6:
   7:
   8:
   9:
   10:

Gauss'sche Zufallszahlen sind um den Mittelwert 0 verteilt - und zwar haben die meisten Zahlen einen Wert nahe Null. Symmetrisch dazu fallen die Häufigkeiten nach beiden Seiten sehr stark ab; beispielsweise treten nur mehr sehr wenige Gauss'sche Zufallszahlen mit einem Wert von beispielsweise -3 oder 5 auf. Der Ausdruck gausszahl = r.nextGaussian()*2; verdoppelt die gefundenen Zufallszahlen, sodass der Bereich um 0 herum etwas breiter wird… Liegt eine Zahl zwischen -10 und 10 (was den möglichen Indizes des Zählfeldes erg[] entspricht), so wird das der Größe dieser Zahl entsprechende Zählfeld inkrementiert (dabei muss der Zahlenwert mittels Type-Castings in eine Ganzzahl umgeformt werden). Schließlich werden die Zählergebnisse an Hand entsprechend langer * - Reihen ausgegeben.

Der „Vergrößerungsfaktor“ (im Beispiel der Faktor 2) könnte auch als Befehlszeilenargument übergeben werden. Beachte, dass einzelne Werte auch außerhalb des Zählintervalles liegen könnten.

Das Pascal'sche Dreieck

Das so genannten Pascal'sche Dreieck wird bei der Berechnung der Binomialkoeffizienten (also bei Berechnungen von `(a + b)^n` ) eine Rolle. Für „beliebig hohes“ `n` sollen diese Koeffizienten berechnet werden:

n = 4

0:                              1
1:                          1       1       
2:                      1       2       1
3:                  1       3       3       1       
4:              1       4       6       4       1
==========================---------------------------------
n = 11

0:                                                      1
1:                                                  1       1       
2:                                              1       2       1
3:                                          1       3       3       1       
4:                                      1       4       6       4       1
5:                                  1       5       10      10      5       1       
6:                              1       6       15      20      15      6       1
7:                          1       7       21      35      35      21      7       1       
8:                      1       8       28      56      70      56      28      8       1
9:                  1       9       36      84      126     126     84      36      9       1       
10:             1       10      45      120     210     252     210     120     45      10      1
11:         1       11      55      165     330     462     462     330     165     55      11      1       
==========================---------------------------------
n =

Zur Berechnung der einzelnen Koeffizienten kann man die Eigenschaft verwenden, dass ein Koeffizient die Summe der beiden unmittelbar über ihn stehenden Zahlen ist. Dann kann beispielsweise der folgende Algorithmus für ein zweidimensionales Array verwendet werden:

    public static void berechnen (int zahl) {
        int dreieck[][] = new int[zahl+2][zahl+1];
        dreieck[0][0]=1;
        for (int i=1;i<=zahl+1;i++) {
            dreieck[i][0]=1;
            for (int j=1;j<i;j++) {
                dreieck[i][j]=dreieck[i-1][j-1]+dreieck[i-1][j];
            }
        }
    }

Damit auch verschieden große Zahlen gut formattiert ausgegeben werden können, verwendet man neben Zeilenschaltungen (Steuerzeichen \n) Tabulatoren (Steuerzeichen \t) und Leerzeichen.

Eingabefehler abfangen

IOException

Die Methode readLine() wirft eine IOException. Im vorigen Abschnitt wurde diese Exception an die main - Methode weitergereicht. Grundsätzlich kann diese Exception aber auch mit Hilfe eines so genannten try - catch Blockes abgefangen werden:

import java.io.*;
 
public class exception1 {
 
    static int i;
    public static void main (String args[]) {
        try {
            InputStreamReader datenstrom = new InputStreamReader(System.in);
            BufferedReader dateneingabe = new BufferedReader(datenstrom);
            i = Integer.parseInt(dateneingabe.readLine());
        }
 
        catch (IOException e) {
            System.err.println(e.toString());
        }
        System.out.println("Die Zahl " + i + " wurde eingegeben ;-)");
    }
}

Eigene Exceptions werfen

Eigene Exceptions werden von der Klasse Exception abgeleitet. Dazu wird das Java-Schlüsselwort extend verwendet²⁾ . Tritt innerhalb des try - Blockes eine Exception auf, so wird sie mit dem Schlüsselwort throw „geworfen“ - ein geeigneter catch - Block liefert die entsprechende Fehlermeldung:

import java.io.*;
 
class Eingabe extends Exception {
    public Eingabe(String fehlermeldung) {
        super(fehlermeldung);
    }
}
 
public class exception2 {
    static int i;
 
    public static void main (String args[]) throws IOException {
 
        try {
            InputStreamReader datenstrom = new InputStreamReader(System.in);
            BufferedReader dateneingabe = new BufferedReader(datenstrom);
            i = Integer.parseInt(dateneingabe.readLine());
            if (i < 0) throw new Eingabe("negative Zahl!");
        }
 
        catch (Eingabe e) {
            System.out.println(e.toString());
        }
 
        System.out.println("Die Zahl " + i + " wurde eingegeben ;-)");
    }
}

Beachte das Schlüsselwort super im Konstruktor Eingabe(). Damit wird der Konstruktor der Superklasse (konkret der Klasse Exception) aufgerufen und die Parameterliste übergeben. Im Beispiel kann damit die als Parameter übergebene Fehlermeldung fehlermeldung als Ausgabe beim Auffangen der Exception verwendet werden.

Wird eine negative Zahl eingegeben erhalten wir somit:

-123
Eingabe: negative Zahl!
Die Zahl -123 wurde eingegeben ;-)

Mehrere catch - Blöcke verwenden

Es können auch mehrere catch - Blöcke verwendet werden:

import java.io.*;
 
class Eingabe extends Exception {
    public Eingabe(String fehlermeldung) {
        super(fehlermeldung);
    }
}
 
public class exception3 {
    static int i;
 
    public static void main (String args[]) {
 
        try {
            InputStreamReader datenstrom = new InputStreamReader(System.in);
            BufferedReader dateneingabe = new BufferedReader(datenstrom);
            i = Integer.parseInt(dateneingabe.readLine());
            if (i < 0) throw new Eingabe("negative Zahl!");
        }
 
        catch (IOException e) {
            System.out.println(e);
        }
 
        catch (Eingabe e) {
            System.out.println(e);
        }
 
        System.out.println("Die Zahl " + i + " wurde eingegeben ;-)");
    }
}

Programmcode auf jeden Fall ausführen

Bisweilen möchte man, dass bestimmte Programmteile auch dann ausgeführt werden sollen, wenn eine Exception geworfen werden musste. Dazu dient der so genannte finally - Block:

import java.io.*;
 
class Eingabe extends Exception {
    public Eingabe(String fehlermeldung) {
        super(fehlermeldung);
    }
}
 
public class exception4 {
    static int i;
 
    public static void main (String args[]) {
 
        try {
            InputStreamReader datenstrom = new InputStreamReader(System.in);
            BufferedReader dateneingabe = new BufferedReader(datenstrom);
            i = Integer.parseInt(dateneingabe.readLine());
            if (i < 0) throw new Eingabe("negative Zahl!");
        }
 
        catch (IOException e) {
            System.out.println(e);
        }
 
        catch (Eingabe e) {
            System.out.println(e);
        }
        finally {
            System.out.println("Die Zahl " + i + " wurde eingegeben ;-)");
        }
    }
}

Damit erhalten wir jedenfalls die im finally - Block angegebene Ausgabe:

x
Die Zahl 0 wurde eingegeben ;-)
java.lang.NumberFormatException: x
        at java.lang.Integer.parseInt(Integer.java)
        at java.lang.Integer.parseInt(Integer.java)
        at exception4.main(exception4.java:17)

Zusammenfassung

Exception ist die Basisklasse aller Ausnahmen - so wird beispielsweise IOExeption von Exception abgeleitet. Aus diesem Grund kann das Beispielprogramm auch folgendermaßen codiert werden:

import java.io.*;
 
public class exception5 {
 
    static int i;
    public static void main (String args[]) throws Exception {
 
        InputStreamReader datenstrom = new InputStreamReader(System.in);
        BufferedReader dateneingabe = new BufferedReader(datenstrom);
        i = Integer.parseInt(dateneingabe.readLine());
 
        System.out.println("Die Zahl " + i + " wurde eingegeben ;-)");
    }
}

Die Verwendung einer nicht übergeordneten Exception ist (sinnvollerweise) nicht möglich. Im folgenden Beispiel würde deshalb eine Ein-/Ausgabe-Ausnahme der Klasse java.io.* nicht abgefangen.

import java.io.*;
 
public class exception5 {
 
    static int i;
    public static void main (String args[]) throws FileNotFoundException {
 
        InputStreamReader datenstrom = new InputStreamReader(System.in);
        BufferedReader dateneingabe = new BufferedReader(datenstrom);
        i = Integer.parseInt(dateneingabe.readLine());
 
        System.out.println("Die Zahl " + i + " wurde eingegeben ;-)");
    }
}

Da die Methode readLine() eine IOException wirft, meldet der Compiler meldet bei der Übersetzung, dass sie nicht aufgefangen würde:

javac  exception5.java
exception5.java:10: Exception java.io.IOException must be caught, or it must be
 declared in the throws clause of this method.
        i = Integer.parseInt(dateneingabe.readLine());
                                                  ^
1 error

Compilation exited abnormally with code 1 at Tue Dec 31 13:28:04

Das Konzept der Exceptions ermöglicht eine umfassende Fehlerbehandlung. Da das Werfen und Auffangen der Exceptions über die angegebenen Klassen hinweg oder mit Hilfe der übergeordneten Klassen erfolgt, besteht jedenfalls die Gefahr, dass der Programmcode sehr schnell unübersichtlich wird. Um die Programmlogik möglichst klar zu halten, sollten eigene Exceptions daher äußerst sparsam verwendet werden.

Eingabe über Scanner-Klasse

Eine alternative Eingabemöglichkeit besteht in der Möglichkeit die Scanner-Klasse zu benutzen.

import java.util.Scanner;
import java.util.*;
 
 
public class einscannen {
 
  /*
  *  Dieses Programm sortiert Temperaturen
  *
  */
 
  public static void main(String[] args) {
    // TODO Auto-generated method stub
    int k,l;
    float summe;
    float[] t = new float[7];
    float[] sortiert = new float[7];
    String[] tage ={"Montag","Dienstag","Mittwoch","Donnerstag","Freitag","Samstag","Sonntag"};
    Scanner sc = new Scanner(System.in);
    summe =0;
    for(int i=0;i<7;i++)
    {
      System.out.print("Temperaturwert für " + tage[i] + " eingeben" );
      t[i] = sc.nextFloat();
      sortiert[i]=t[i];
      summe = summe + t[i];
    }
    Arrays.sort(sortiert);
    System.out.println("\nUnsortiert\n");
    for(int i=0;i<7;i++)
    {
      k= (int)t[i];
      System.out.println(k + " \t-> " + tage[i]);
    }
    System.out.println("\nSortiert\n");
    for (int i=0;i<7;i++)
    {
      // Zur Temperatur zugehörigen Tag ermitteln, Index l
      l=0;
      while (sortiert[i]!=t[l])
      {   l++;
      // In l steht jetzt der Index des auszugebenden Tages
      }
      k = (int)sortiert[i];
      System.out.println(k + " \t-> " + tage[l]);
 
    }
    //Minimale und Maximale temperatur ermitteln, Durchschnittberechnen
    float min, max, mw;
    min = sortiert[0];
    // Zur Temperatur zugehörigen Tag ermitteln, Index l
    l=0;
    while (sortiert[0]!=t[l])
    {   l++;
    // In l steht jetzt der Index des auszugebenden Tages
    }
    System.out.println("Minimale Temperatur war am "+ tage[l]+ " und sie betrug " + min + " Grad");
    max = sortiert[6];
    // Zur Temperatur zugehörigen Tag ermitteln, Index l
    l=0;
    while (sortiert[6]!=t[l])
    {   l++;
    // In l steht jetzt der Index des auszugebenden Tages
    }
    System.out.println("Maximale Temperatur war am "+ tage[l]+ " und sie betrug " + max + " Grad");
    mw = summe/7;
    System.out.println("Durchschnittliche Temperatur war "+ mw);
 
  }
}

¹⁾ Vorsicht ist geboten, wenn ein Ausdruck eine Addition (und somit den Additionsoperator + enthält - in diesem Fall helfen runde Klammern: Damit wird zunächst die Addition ausgeführt, der Zeichenkettenwert des Ergebnisses ermittelt und dieser verkettet…

²⁾ vgl. Abschnitt „„Objektorientierte Programmierung“