Skip to main content

So funktioniert die Do while Schleife im Java Programm


do while schleife java programm

Es ist doch eigentlich so:
Immer wenn du die Anzahl der Schleifendurchläufe nicht kennst, nutzt du in deinen Java Programmen while Schleifen.

Doch Java bietet dir neben der While Schleife einen weiteren Schleifentyp an.
Diese nennt sich do while Schleife.

Was kann die?
Eigentlich genau das Gleiche, wie die while Schleife.
Mit einem kleinen aber sehr wichtigen Unterschied.

Die Do while Schleife führt auf jeden Fall einen Durchlauf durch.

Schau dir einmal diesen Java Code an.


public class DoWhileSchleifeDemo {
	
	static void AddiereEins(int summand){
		while (summand<=10){
			System.out.println(summand);
			summand++;
		}
	}

	public static void main(String[] args) {
		AddiereEins(1); //10 Durchläufe
		AddiereEins(11); //kein Durchlauf
	}
}

In diesem Beispiel soll die Methode eine Zahl um jeweils 1 erhöhen.
Und zwar soll das Ganze so lange gemacht werden, bis die Zahl 10 erreicht ist.

Wenn du jetzt diese Methode mit dem Argument 1 aufrufst, wird die while-Schleife 10-mal durchlaufen.
Wenn du allerdings der Methode eine 11 mitgibst, dann findet nicht ein einziger Schleifendurchlauf statt.

Und das ist mitunter etwas blöd.

Das Problem mit dem Startwert und der Schleifenbedingung.

Stell dir vor:
Du hast eine Schleife, welche Zahlen erwartet und diese analysiert.
Genau gesagt. Die Schleife nimmt Schulnoten entgegen.

Nun ist das Programm so konstruiert worden, dass es bei einer Eingabe von 0 abbricht und den Durchschnitt aller Schulnoten ausspuckt.

Du kannst somit:

  • Schön nacheinander Schulnoten eingeben
  • und nach der letzten Note gibst du nur noch eine Null ein.
  • Die Schleife bricht dadurch ab und gibt dir den Durchschnitt aller Noten zurück.

So könnte dieses Programm aussehen:


import java.util.Scanner;

public class DoWhileSchleifeDemo {
	
	static void errechneNotenDurchschnitt(){
		double durchschnitt=0; //Startwert 0 für den Durchschnitt
		Scanner eingabe=new Scanner(System.in);//Scanner-Objekt
		int note = 0;//Note mit Startwert 0
		
		int summeNote=0; //Summe aller Noten für den Durchschnitt
		int noteAnzahl =0;//Gesamtanzahl der Noten startet bei Null
		
		while(note!=0){
			System.out.println("Gib Note ein");//neue Aufforderung
			note = eingabe.nextInt();//Speichern der eingebenen Note
			noteAnzahl++;//Notenanzahl erhöht sich um jeweils 1
			summeNote=note+summeNote;//Summe der Note erhöht sich um die neue Note
		}
		durchschnitt=(double) summeNote/(double)noteAnzahl;//Ausrechnen des Durchschnittes
		System.out.println("Der Durchschnitt beträgt "+durchschnitt);//Durchschnitt wird ausgegeben
	}

	public static void main(String[] args) {
		errechneNotenDurchschnitt();//Methodenaufruf		
	}
}

Probiere dieses Programm einmal aus.
Was passiert?- Nichts wird berechnet.

Ganz kurz:
Die Methode hat vier Variablen.

  1. Die „note“ ist die, durch den Benutzer, eingebene Note.
  2. Die Summe aller Noten wird in der Variablen „summeNote“ gespeichert.
  3. Außerdem gibt es eine Variable, welche die angebene Anzahl an Noten speichert – „noteAnzahl“.
  4. Und optional gibt es eine Variable, welche den Durchschnitt aller Noten speichert. (Notensumme/Notenanzahl).

Was passiert mit der Schleife?

  • Der Startwert der Variablen „note“ ist Null.
  • Die Bedingung für die Schleife ist, dass Note nicht Null ist.
    Denn dann soll die Schleife abbrechen und den Durchschnitt aller Noten ausgeben.
  • Und das ist das Dilemma – Das Programm springt somit überhaupt nicht in die Schleife.

Klar kann man diese Schleife anders gestalten.
Indem du die erste Note ausserhalb der while Schleife speicherst.
Und dann startet die Summe der Gesamtnoten nicht bei Null, sondern bei der ersten Note.
So wie hier:


import java.util.Scanner;

public class DoWhileSchleifeDemo {
	
	static void errechneNotenDurchschnitt(){
		double durchschnitt=0; 
		System.out.println("Gib Note ein"); 
		Scanner eingabe=new Scanner(System.in);
		int note = eingabe.nextInt();//Speicherung bei der ersten Note
		
		int summeNote=note; //Summe der Note beginnt bei der ersten Note
		int noteAnzahl =0;
		
		while(note!=0){
			System.out.println("Gib Note ein");
			note = eingabe.nextInt();
			noteAnzahl++;
			summeNote=note+summeNote;
		}
		durchschnitt=(double) summeNote/(double)noteAnzahl;
		System.out.println("Der Durchschnitt beträgt "+durchschnitt);
	}

	public static void main(String[] args) {
		errechneNotenDurchschnitt();		
	}
}
  1. Starte einmal das Programm.
  2. Gib ein paar Noten ein.
  3. Und beende die Schleife durch Eingabe der Note Null.

Und läuft?

Okay, ein Problem bleibt.
Und zwar hast du doppelten Code.

Das Problem mit doppelten Code.

Hier nochmal das Programm mit dem Hinweis auf doppelten Code.


import java.util.Scanner;

public class DoWhileSchleifeDemo {
	
	static void errechneNotenDurchschnitt(){
		double durchschnitt=0; 
		System.out.println("Gib Note ein"); //Doppelter Code - siehe Schleifenrumpf
		Scanner eingabe=new Scanner(System.in);
		int note = eingabe.nextInt();//Doppelter Code -siehe  Schleifennrumpf
		
		int summeNote=note;
		int noteAnzahl =0;
		
		while(note!=0){
			System.out.println("Gib Note ein");//Doppelter Code
			note = eingabe.nextInt();//doppelter Code
			noteAnzahl++;
			summeNote=note+summeNote;
		}
		durchschnitt=(double) summeNote/(double)noteAnzahl;
		System.out.println("Der Durchschnitt beträgt "+durchschnitt);
	}

	public static void main(String[] args) {
		errechneNotenDurchschnitt();		
	}
}

Für ein kleines Projekt ist dies überschaubar.
Werden deine Projekte größer – wird es schwieriger.

Denn immer wenn du den Ablauf der Eingabe außerhalb der Schleife änderst – musst du diesen Code nochmal in der Schleife anpassen.

Was kannst du tun?
Cool wäre es doch, eine Schleife zu haben, welche für den ersten Durchlauf – die Abbruchbedingung ignoriert.


import java.util.Scanner;

public class DoWhileSchleifeDemo {
	
	static void errechneNotenDurchschnitt(){
		double durchschnitt=0;  
		Scanner eingabe=new Scanner(System.in);
		int note = 0;	
		int summeNote=0; 
		int noteAnzahl =0;
		
// bessere Schleife finden, welche den Startwert (0) der Note ignoriert
		while(note!=0){
			System.out.println("Gib Note ein");
			note = eingabe.nextInt();
			noteAnzahl++;
			summeNote=note+summeNote;
		}
		durchschnitt=(double) summeNote/(double)noteAnzahl;
		System.out.println("Der Durchschnitt beträgt "+durchschnitt);
	}

	public static void main(String[] args) {
		errechneNotenDurchschnitt();		
	}
}

Dann könntest du nämlich die erste Version des Schul-Noten-Durchschnittsprogrammes verwenden.
Diese hätte keinen doppelten Code.
Und das Programm würde einwandfrei funktionieren.

Und eine Schleife, welche die Schleifenbedingung beim ersten Durchlauf ignoriert ist: die do while Schleife.

Aufbau der Do While Schleife.

Ich wiederhole ganz kurz.
Wenn die Abbruchbedingung und der Startwert einer while-Schleife gleich sind, dann springt das Programm bzw. die Methode erst gar nicht in die Schleife.

Du brauchst in so einem speziellen Fall eine Schleife, welche immer einmal den Schleifenrumpf durchläuft und erst dann die Abbruchbedingung prüft.

Die while Schleife ist eine kopfgesteuerte Schleife.
Die Schleifenbedingung befindet sich im Schleifenkopf.
Man bezeichnet sie deshalb auch als Kopfschleife.

Die do while Schleife ist etwas anders aufgebaut.
Sie beginnt mit dem Keyword do.
Dann folgt der Schleifenrumpf mit allen Anweisungen.
Und erst dann kommt die Schleifenbedingung.

Da sich die Schleifenbedingung im Schleifenfuß befindet, ist die do-while-Schleife eine fußgesteuerte Schleife.
Oder ganz einfach Fußschleife.

Und so sieht die Schleife aus:


do {
//Rumpf mit Anweisungen
} 
while (true); //Abruchbedingung

Der Unterschied zwischen do while und while Schleife.

Lass es uns ausprobieren.

Die while Schleife und auch die do while Schleife werden solange durchlaufen, bis die Schleifenbedingung nicht mehr wahr bzw. true ist.

Wenn ich jetzt als Abbruchbedingung einer while-Schleife festlege:
Dass die Schleife solange durchlaufen werden soll, bis eine lokale Variable (zB. i) null ist.
Und ich dann dieser Variablen den Startwert Null zuweise.

Dann springt das Programm erst gar nicht in die while-Schleife.
Die do-while Schleife wird aber einmal ausgeführt und erst dann wird die Bedingung überprüft.


public class DoWhileSchleifeDemo {

	public static void main(String[] args) {
		int i = 0; //i zum Testen der Schleifen
		
		while (i != 0) {
			System.out.println("Du befindest dich in der While Schleife");
		} //Ende der while-Schleife
		
		
		do {
			System.out.println("Du befindest dich in der Do-While-Schleife.");
		}
		while (i != 0); //Ende der do-while Schleife
	}
}

Probiere es einmal aus.
Und was siehst du?
Die erste Schleife wird ignoriert.
Und die zweite wird einmal ausgeführt.

Aber da ist noch mehr….

Mit do while Schleifen lässt sich besserer Code schreiben.

Zurück zum Durchschnittsnoten-Beispiel.

Wenden wir jetzt so eine Java Do While Schleife für das Programm an.
So geht’s:


import java.util.Scanner;

public class DoWhileSchleifeDemo {
	
	static void errechneNotenDurchschnitt(){
		double durchschnitt=0; 
		Scanner eingabe=new Scanner(System.in);
		int note = 0; //Eingabe der Noten startet bei Null
		
		int summeNote=0; //Summe aller Noten startet bei Null
		int noteAnzahl =0; //Anzahl aller Noten startet bei Null
		
		do {
			System.out.println("Gib Note ein");//Einmaliger Code
			note = eingabe.nextInt();//Einmaliger Code
			noteAnzahl++;
			summeNote=note+summeNote;
		}
		while(note!=0);//Abbruchbedingung der Schleife im Rumpf
		
		durchschnitt=(double) summeNote/(double)noteAnzahl;
		System.out.println("Der Durchschnitt beträgt "+durchschnitt);
	}

	public static void main(String[] args) {
		errechneNotenDurchschnitt();		
	}
}

Alles gut?
Lass es uns checken:

  • Die Startwerte aller Variablen sind Null.
  • Die Nuller-Startwerte interessiert die Do While Schleife nicht.
    Der Schleifendurchlauf findet statt.
  • Doppelter Code wurde ebenfalls vermieden, da nur innerhalb des Rumpfes die Aufforderung zur Eingabe und die Speicherung der Variablen erfolgt.

Ein Problem bleibt.
Führe das Programm einmal aus.

  • Gib beispielsweise 2 und 3 ein.
  • Und dann beende die Schleife durch die Eingabe von Null.

Der Durchschnitt ist falsch.

Klar – denn…..

Die Zählvariable, welche im Schleifenrumpf einer Do While Schleife auftaucht, wird immer erhöht.

Ich sagte es schon:
Die Do While Schleife ist fußgesteuert.

Und das heißt:
Die Entscheidung für einen weiteren Schleifendurchlauf findet immer nachträglich statt.

Erst werden alle Anweisungen im Rumpf einmal ausgeführt und erst dann wird geprüft, ob ein weiterer Durchlauf notwendig ist.

Und für unser Beispiel bedeutet dies:
Wenn du eine Null eingibst, um die Schleife zu beenden – wird dennoch der komplette Rumpf durchlaufen.
Und somit wird auch die Zählvariable „anzahlNoten“ um eins erhöht.

Wenn du das Programm mit den Noten 2,3 und 0 testest – dann wurde die Schleife dreimal durchlaufen.
Und somit wurde die Anzahl der Noten dreimal erhöht – Es steckt dann der Wert 3 in dieser Variablen.

Was kannst du tun?
Du kannst den Startwert der Variablen „noteAnzahl“ auf -1 anstatt Null setzen.


import java.util.Scanner;

public class DoWhileSchleifeDemo {
	
	static void errechneNotenDurchschnitt(){
		double durchschnitt=0; 
		Scanner eingabe=new Scanner(System.in);
		int note = 0;
		
		int summeNote=0;
		int noteAnzahl =-1; //Anzahl aller Noten startet bei -1 
		
		do {
			System.out.println("Gib Note ein");
			note = eingabe.nextInt();
			noteAnzahl++;
			summeNote=note+summeNote;
		}
		while(note!=0);
		
		durchschnitt=(double) summeNote/(double)noteAnzahl;
		System.out.println("Der Durchschnitt beträgt "+durchschnitt);
	}

	public static void main(String[] args) {
		errechneNotenDurchschnitt();		
	}
}

Oder du belässt den Startwert bei Null.
Stattdessen ziehst du von dem ermittelten Wert eins ab.
So wie hier:


import java.util.Scanner;

public class DoWhileSchleifeDemo {
	
	static void errechneNotenDurchschnitt(){
		double durchschnitt=0; 
		Scanner eingabe=new Scanner(System.in);
		int note = 0;
		
		int summeNote=0;
		int noteAnzahl =0;//Startet bei Null
		
		do {
			System.out.println("Gib Note ein");
			note = eingabe.nextInt();
			noteAnzahl++;
			summeNote=note+summeNote;
		}
		while(note!=0);
		
		durchschnitt=(double) summeNote/(double)(noteAnzahl-1);//Anzahl wird um eins verringert
		System.out.println("Der Durchschnitt beträgt "+durchschnitt);
	}

	public static void main(String[] args) {
		errechneNotenDurchschnitt();		
	}
}

Oder eleganter ist es:
Du arbeitest mit zusätzlichen Blöcken und Verzweigungen im Do-Block.

Also lass uns dies tun.

So kannst du den Do Block um weitere Verzweigungen ergänzen.

Ziel ist es die Nuller-Eingabe abzufangen.
Und nur dann, wenn die Eingabe nicht Null ist, die Anzahl zu erhöhen.

Es ist eigentlich ganz einfach:
Platziere im Do-Block eine if-Struktur und fange mit dieser die Nuller-Eingabe ab.

Und so geht’s.


import java.util.Scanner;

public class DoWhileSchleifeDemo {
	
	static void errechneNotenDurchschnitt(){
		double durchschnitt=0; 
		Scanner eingabe=new Scanner(System.in);
		int note = 0; //Eingabe der Noten startet bei Null
		
		int summeNote=0; //Summe aller Noten startet bei Null
		int noteAnzahl =0; //Anzahl aller Noten startet bei Null
		
		do {
			System.out.println("Gib Note ein");
			note = eingabe.nextInt();
			
			//If Struktur fängt Nuller-Werte ab
			if (note !=0){
			noteAnzahl++;
			}//Ende des if-Blockes
			
			summeNote=note+summeNote;
			
		}//Ende des Do-Blockes
		while(note!=0);//Abbruchbedingung der Schleife im Rumpf
		
		durchschnitt=(double) summeNote/(double)noteAnzahl;
		System.out.println("Der Durchschnitt beträgt "+durchschnitt);
	}

	public static void main(String[] args) {
		errechneNotenDurchschnitt();		
	}
}

Zusammenfassung:

  • While Schleifen sind Kopfschleifen.
  • Beim Ablauf mit while-Schleifen wird zuerst die Abbruchbedingung überprüft.
    Wenn die Schleifenbedingung wahr ist, dann springt das Programm in die Schleife und führt die Anweisungen aus.
    Ansonsten ignoriert das Programm die Schleife und macht nach ihr weiter.
  • Die do while Schleife ist eine fußgesteuerte Schleife.
    Die Schleifenbedingung befindet sich daher im Fuß der Schleife.
  • Der Schleifenrumpf mit allen Anweisungen wird immer einmal durchlaufen und erst dann werden die Schleifenbedingungen geprüft.
  • Das bedeutet für dich. Wenn du in deinem Java Programm eine Struktur benötigst, welche mindestens einmal ausgeführt werden soll- dann setze das mit einer do while Schleife um.
    Ansonsten setze das Ganze mit while Schleife um.

Ähnliche Beiträge

So solltest du Kommentare im Java Programm einsetzen

java programmierung kommentare

Bei der Java Programmierung sind Kommentare mitunter genauso wichtig wie der eigentliche Code. Denn ein guter Kommentar zeigt dir sofort, was mit dem Code gemeint ist, was dieser bewirkt und was sich der Entwickler dabei dachte. Wie werden Kommentare in Java gesetzt? Die Kommentare werden in Eclipse immer grün dargestellt. […]

So kannst du Konstanten in Java Programmen anlegen und nutzen

java programmierung konstanten anlegen und nutzen

Java Konstanten – was kann man sich darunter vorstellen? Du kennst Konstanten in der Mathematik. Die Kreiszahl Pi ist so eine konstante Zahl. Diese Zahl ändert sich niemals. Sie beträgt immer rund 3,141592. In der Physik gelten die Lichtgeschwindigkeit, der Erdradius oder der absolute Nullpunkt als konstant. Selbst die Geschwindigkeit […]

Java Konsolenausgaben mit formatierten Zahlen

java programmierung konsolenausgabe mit formatierten zahlen

Java Konsolenausgaben erzeugst du mit der System.out.println()-Anweisung. Dies ist relativ einfach. Aber es ist mitunter nicht ganz praktisch. Und zwar immer dann, wenn Zahlen im Spiel sind. Die Zahlen welche dann auf deiner Java Konsole erscheinen, sind unformatiert. Sie haben zu viele Kommastellen. Oder für eine bessere Darstellung benötigst du […]

Syntax, Semantik und Lexikalik in der Java Programmierung

java programmierung lexikalik syntax semantik

Java ist eine Programmiersprache. Und wie jede andere Programmiersprache ist auch Java, lediglich eine künstliche Sprache.   Normalerweise bieten künstliche Projekte immer jede Menge Spielraum für Eigenkreationen. Bei der Programmierung ist dies nicht ganz so. Denn Programmiersprachen sind auch immer sehr exakt.   Jede Programmiersprache und auch jede gesprochene Sprache […]

So kannst du spielend Java Programmierung lernen

java programmierung lernen

Ich lernte die Java Programmierung auf die klassische Art. Ich kaufte mir das erste Buch und los ging es. „Jetzt wirst du Java lernen“ – sagte ich zu mir. Ich war relativ schnell ziemlich frustriert, denn irgendwie fehlten mir ein paar Zusammenhänge. Kennst du das? Du hast ein Wissensfetzen und […]

So funktioniert der Java Programmstart mit Argumenten-Übergabe

java programmierung programmstart argumente

Um ein Java Programm starten zu können, benötigst du immer die main-Methode. Das Programm startet immer genau an dieser Stelle. Alle lokalen Variablen, welche du in der Main Methode anlegst, kannst du dann im Programm nutzen. Auch alle Methoden, welche du innerhalb des Methodenrumpfes der main-Methode aufrust, werden ausgeführt. Was […]

Namenskonventionen bei der Java Programmierung

java-programmierung-namenskonvention-lowercasecamelcase

Beiderjavaprogrammierungsolltestduaufdierichtigenamensvergabeachten. indennnamengebendeinenjavaprogrammeinegrundlegendestruktur. Was sagen dir die beiden oberen Sätze? Häh? Da steht: Bei der Java Programmierung solltest du auf die richtige Namensvergabe achten. Denn Namen geben deinem Java Programm eine grundlegende Struktur. Jede Sprache braucht Regeln. Diese Regeln, wie Grammatik oder Rechtschreibung geben der Sprache eine Struktur. Jeder Leser, welcher […]

Java Anfänger Übung: Hello World

Java-Übung-Hello-World

Alles beginnt mit „Hello World“. Sämtliche Java Bücher beginnen mit diesem ersten Beispiel. Auch die Java Übungen sollen mit diesem ersten Programm starten. Definiere eine Klasse „Hello World“. Implementiere die Main Methode. Die Main Methode soll bei Programmaufruf die Bildschirmanzeige „Hallo Welt“ zurückgeben. Die Lösung zur Java Übung „Hallo Welt“ […]

So kannst du in Java eine Binärzahl in eine Dezimalzahl umwandeln

java programmierung binärzahl in dezimalzahl umwandeln

Erinnerst du dich? In einer der letzten Beiträge haben wir uns die Zusammenhänge zwischen dem dualen und dem dezimalen Zahlensystem angeschaut. Aber wir haben noch keine Java Binärzahl in eine Dezimalzahl verwandelt. Zumindestens nicht praktisch…. Stattdessen…. Haben wir festgestellt, dass beide Zahlensysteme im Grunde genommen sehr ähnlich sind. Beim Dezimalsystem […]

Unterschied zwischen Klassenvariable und Instanzvariable im Java Programm

unterschied klassenvariable instanzvariable java programmierung

Bei der Java Programmierung unterscheidet man drei Arten von Variablen. Als erste Gruppe sind die lokalen Variablen zu nennen. Auf diese gehe ich in einem separaten Artikel ein. Mich interessieren die zwei anderen Variablentypen. Zum einen existieren Klassenvariablen. Und dann sind da noch die Instanzvariablen. Wo liegt der Unterschied zwischen […]

So sorgt Java Polymorphie für besseren Code und mehr Möglichkeiten

java programmierung polymorphie code möglichkeiten

Polymorphie ist das Herzstück jeder objektorientierten Sprache. Nicht nur in Java – auch in Python, Javascript und in anderen Sprachen. Aber was bedeutet Polymorphie eigentlich? Polymorphie oder auch Polymorphismus genannt, kommt aus dem Griechischen. Es bedeutet Vielgestaltigkeit. Etwas freier übersetzt, kannst du es auch als Facettenreichtum bezeichnen. Im Grunde genommen […]

Lokale Variablen im Java Programm: Lebensdauer und Nutzung

lokale variablen im java programm

Lass uns über die Lebensdauer einer lokalen Variablen sprechen. Warum ausgerechnet die Lebensdauer? Alle Java Variablen, unterscheiden sich in folgenden Punkten: wo diese deklariert werden können, wie du diese aufrufen kannst, welchen Bereich diese abdecken, und Ihre Lebensdauer Und eine lokale Java Variable hat eine relativ kurze Lebensdauer. Schauen wir […]

So kannst du Java installieren

java-installieren

Bevor du loslegst und deine ersten Java Programme schreibst, benötigst du die entsprechende Arbeitsumgebung. Du solltest also Java installieren. Und diese Arbeitsumgebung beinhaltet dann Bibliotheken für die einzelnen Java-Standard-Klassen, Dateien um deine Programme auszuführen. Dateien um deine Programme zu packen, Logische Verzeichnisstrukturen

Zwei smarte Möglichkeiten eine Java Zufallszahl zu erzeugen

java zufallszahl anlegen erzeugen

Java Zufallszahl – Wieso? In der Java Programmierung benötigst du immer wieder einmal Zufallszahlen. Du möchtest deine Software mit Daten testen und dir keine Zahlen ausdenken. Du benötigst Stichproben, welche ein reales Verhalten simulieren. Du hast ein Spiel entworfen und die Akteure sollen mit zufälligen aber unterschiedlichen Größen, Rüstungsleveln usw. […]

Die 5 verschiedenen Zahlensysteme in der Java Programmierung

java programmierung zahlensysteme

Java Zahlensysteme – Was soll das? In sämtlichen Programmiersprachen werden Zahlen in Variablen abgespeichert. Wenn du dir die einzelnen primitiven Datentypen in Java einmal anschaust – wirst du feststellen – dass die Masse der Datentypen Zahlen annehmen und speichern können. Zahlen und die Mathematik dahinter spielen in der Programmierung eine […]

So funktioniert die Java Konsoleneingabe über den Scanner

java programmierung konsoleneingabe scanner

Es wird Zeit für die erste Java Konsoleneingabe. Und diese Eingaben machst du über den Java Scanner. Was ist das? Der Scanner ist eine vorgefertigte Java Klasse, welche Java mit seiner API anbietet. Das heißt du musst nichts selbst erschaffen. Du musst nur wissen, wie du darauf zugreifst. Erst einmal […]