[Tutorial] Java #3 - Kontrolle ist wichtig

[makenshi]

Einleitung
Da DFYX das Java Tutorial nicht vollständig allein schreiben soll, dachte ich mir ich schreibe
mal den dritten Teil. Der letzte Teil beschäftigte sich mit Variablen und ihrer grundlegenden Verwendung.
Daher ist es nun sinnvoll sich mit den sogenannten Kontrollstrukturen zu beschäftigen.

Quellcodebeispiele werden ohne die Main Methode und ohne die Klasse drumherum gezeigt. Ich gehe nach den letzten Tutorials davon
aus das man als Leser weiß, das der gezeigte Beispielcode in eine solche gehört damit er überhaupt ausgeführt wird.

Code (JAVA):

 
1.	public class Uebung{
2.		public static void main(String[] args) {
3.			// Hier kommt der ausfuehrbare Code hinein
4.		}
5.	}
 

Entscheidungen sind nötig...
In unserem Alltag sind Entscheidungen an allen Ecken und Enden nötig. Simples Beispiel aus dem Alltag
was nun jeder kennt: eine Ampel. Man steht vor einer Straße und anderen Straßenseite ist eine Ampel.
Man hat zum einen die Information das man nur über die Straße gehen soll wenn die Ampel auf grün steht,
ansonsten soll man warten.
Je nachdem ob die Ampel auf Rot oder auf Grün ist, überquert man die Straße oder wartet bis sie auf grün schaltet.
Anhand von diesem Beispiel kann man nun gut unsere erste Kontrollstruktur vorstellen, die Bedingung.

Zuerst einmal brauchen wir etwas in das wir abspeichern können ob unsere Ampel auf rot oder grün steht.
Wir haben also zwei Zustände die sie erreichen kann. Da bietet sich ein boolean an, da dieser
die zwei Zustände true(Ampel grün) und false(Ampel rot) speichern kann.

Code (JAVA):

1.    boolean ampelstatus = false;

Wir deklarieren uns also eine Boolean Variable und initialisieren sie direkt mit dem Wert "false". Unsere Ampel
steht also von Anfang an erstmal auf rot.

Nun brauchen wir etwas um zu überprüfen auf welchen Status unsere Variable gerade ist. Dafür bietet
Java uns die Bedingung an.

Code (JAVA):

 
1.	// Syntax einer Bedingung
2.	if(bedingung){
3.	  // Code hier drin wird nur ausgeführt wenn die Bedingung erfüllt(wahr) ist
4.	}
 

Nur wenn die Bedingung die im Kopf steht erfüllt ist, wird der dahinter liegende Anweisungsblock ausgeführt.
Der Anfang eines Blockes wird durch eine einleitende { angezeigt und durch
ein abschließendes } beendet.

Die Bedingung muss in unserem Fall sein ob die Ampel Grün ist. Also setzen wir es um:

Code (JAVA):

 
1.	if(ampelstatus == true){ // Ampel ist gruen
2.	    System.out.println("Die Ampel ist gruen!");
3.	}
 

Mit dem == Operatoren führt man in Java Vergleiche durch.
Verwechsele das nicht mit dem = Operator, der ist dazu da einer Variable einen Wert zuzuweisen.

Nun haben wir allerdings noch das Problem das wir ja auch anzeigen wollen ob die Ampel auf rot steht.
Gut, also noch eine Bedingung.

Code (JAVA):

 
1.	if(ampelstatus == true){ // Ampel ist gruen
2.	    System.out.println("Die Ampel ist gruen!");
3.	}
4.	if(ampelstatus == false){ // Ampel ist rot
5.	    System.out.println("Die Ampel ist rot!");
6.	}
 

Soweit so gut. Aber irgendwie ist die Lösung nicht ganz das wahre. Jetzt muss Java ja beide
Bedingungen durchlaufen, obwohl immer nur eine wahr sein kann. Immerhin ist eine Ampel nur rot oder grün.
Nie beides gleichzeitig. Aber kein Problem, dafür hat die Bedingung etwas parat.

Code (JAVA):

 
1.	if(ampelstatus == true){ // Ampel ist gruen
2.	    System.out.println("Die Ampel ist gruen!");
3.	}else{ 			 // Ampel ist rot
4.	    System.out.println("Die Ampel ist rot!");
5.	}
 

Was ist hier neu? Richtig, das else. Dieser sogenannte "Else-Zweig" wird nun immer dann ausgeführt
wenn die Bedingung nicht erfüllt ist. Da unsere boolean Variable aber nur true oder false sein kann,
stört uns das in diesem Fall nicht weiter und ist damit genau das was wir brauchen. In anderen Fällen sollte man darauf
jedoch achten.

Unsere komplette Ampel:

Code (JAVA):

 
1.	boolean ampelstatus = false;
2.        
3.	if(ampelstatus == true){ // Ampel ist gruen
4.	    System.out.println("Die Ampel ist gruen!");
5.	}else{ 			 // Ampel ist rot
6.	    System.out.println("Die Ampel ist rot!");
7.	}
 

Ausgabe wenn ampelstatus auf true steht

Code:

Die Ampel ist gruen!

Ausgabe wenn ampelstatus auf false steht

Code:

Die Ampel ist rot!

Bedingungen sind also dafür gut um je nachdem auf welchem Wert eine Variable eine andere Folge von Befehlen auszuführen.
Sie lassen sich im übrigen auch schachteln:

Code (JAVA):

 
1.  int zahl = 2;
2.  int zahl2 = 2;
3.  
4.  if(zahl == 1){
5.      System.out.println("zahl ist auf 1!");
6.  }else if(zahl == zahl2){
7.      System.out.print("zahl und zahl2 stehen beide auf demselben Wert ! zahl: ");
8.      System.out.print(zahl);
9.  }else{
10.     System.out.println("zahl steht auf irgendeinem anderen Wert als gedacht.");
11. }
 

Erklärung:
In Zeile 1 und 2 werden nur zwei integer Variablen deklariert und mit dem Wert 2 initalisiert.
in Zeile 4 wird dann auf die Bedingung geprüft ob die Variable zahl auf 1 steht, wenn sie das tut
wird der Text "zahl ist auf 1!" ausgegeben. (Zeile 5)
Wenn zahl nicht auf 1 steht, wird der Alternative else Zweig in Zeile 6 abgearbeitet der dann die Bedingung prüft
ob zahl denselben Inhalt hat wie zahl2. Wenn ja, dann wird in Zeile 7 erstmal der Text "zahl und zahl2 stehen beide auf demselben Wert ! zahl: "
ausgegeben und in Zeile 8 der Inhalt der Variable zahl.
Falls nun beide Bedingung nun nicht erfüllt worden sind, wird der letzte mögliche Zweig in Zeile 9 ausgeführt,
wodurch die Ausgabe "zahl steht auf irgendeinem anderen Wert als gedacht." in Zeile 10 ausgelöst wird.

Wir haben ja nun zwei Werte bei unseren Variablen voreingestellt. Wie sieht denn die Ausgabe des erklärten Programmes aus?
Denk kurz darüber nach und öffnet dann den Spoiler.

Code:

zahl und zahl2 stehen beide auf demselben Wert ! zahl: 2

Was bei zuvielen Entscheidungen?
Bedingungen sind nützliche Mittel um Verzweigungen im Quellcode umzusetzen. Was aber nun tun wenn man viele Entscheidungen abfragen muss? Ein IF-Else Konstrukt kann dabei schnell unübersichtlich werden. Zu diesem Zweck existiert die Anweisung "Switch".

Code (JAVA):

 
// Syntax eines Switches
switch(variable){
	case [wert]: [Anweisungen]
}
 

Der Switch ist dabei so angelegt das man eine Reihe von Fällen prüft.
Hinter dem "case"(Fall) wird auf einen Wert geprüft, der in der Variable die wir in den runden Klammern
hinter dem "switch" Schlüssel angegeben haben, stehen könnte. Falls ein Fall zutrifft, werden die Anweisungen
ausgeführt die hinter dem Doppelpunkt stehen. Klingt kompliziert? Ist es an sich nicht, das kleine Praxisbeispiel
macht es denke ich klarer:

Code (JAVA):

 
1.        int monat = 12;
2.
3.        switch(monat){
4.            case 1: System.out.println("Januar"); break;
5.            case 2: System.out.println("Februar"); break;
6.            case 3: System.out.println("Maerz"); break;
7.            case 4: System.out.println("April"); break;
8.            case 5: System.out.println("Mai"); break;
9.            case 6: System.out.println("Juni"); break;
10.           case 7: System.out.println("Juli"); break;
11.           case 8: System.out.println("August"); break;
12.           case 9: System.out.println("September"); break;
13.           case 10: System.out.println("Oktober"); break;
14.           case 11: System.out.println("November"); break;
15.           case 12: System.out.println("Dezember"); break;
16.           default: System.out.println("Kein Monat fuer diese Zahl!");
17.       }
 

Je nachdem welche Zahl im Integer "monat" steht, wird ein anderer Fall ausgeführt. Im Beispiel steht eine 12 in unserer Variable,
also wird man als Ausgabe erhalten:

Code:

Dezember

Das "break;" hinter der letzten Anweisung in einem Fall ist wichtig, damit der Switch an dieser Stelle abgebrochen wird.
Ohne diesen Befehl, würden dann noch weitere Fälle durchgegangen werden, bis der Switch zuende ist oder bis ein break auftritt.
Der abschließende "Default"-Fall ist die Ausnahmebedingung die ausgeführt wird, falls keiner der vorangegangen Fälle erfüllt worden ist.
Das wäre in unserem Beispiel der Fall wenn man z.B. eine 13 in unsere Variable speichert.

Schlusswort
Damit haben wir zwei wichtige Kontrollstrukturen abgedeckt. Es fehlen natürlich noch welche, nur soll das Tutorial erstmal nicht zu lang werden. Als nächstes wären Schleifen eine gute Fortsetzung. Diese Tutorial ist vom Code her absichtlich meist etwas ausführlicher geschrieben als nötig, da es ja der Erklärung dienen soll. Sicherlich lässt sich so mancher Code hier kürzer schreiben. Eine Aufgabe stelle ich (noch) nicht, da dafür in meinen Augen erstmal noch etwas Wissen vorhanden sein sollte. Ich hoffe das Tutorial hilft ein wenig und es schreiben noch mehr mit.

~ Makenshi