Und Verküpfungen in Java Programmen anlegen und auswerten

Also….
Was erwartet dich in diesem Beitrag?

• Zuerst möchte ich dir die Aussagenlogik hinter dem Und-Operator zeigen.
  Also wann sind Aussagen wahr und wann sind diese falsch.
• Dann werde ich dir zeigen, wie du die Und-Verknüpfungen in Java einsetzt.
• Und ich werde dir zeigen, wie sich Methodenrückgaben auswerten und zusammenfügen lassen.

Also es wird spannend.

Was bedeutet der logische Ausdruck „Und“ – für deine Java Programme.

Wie du bereits weißt, ist mein Name Mathias.

Wenn ich jetzt sage: „Ich heiße Mathias.“
Dann ist diese Aussage wahr.

Wenn ich jetzt einen zweite Aussage mache:
„Mein Name ist Marcel.“
Dann ist diese Aussage falsch.

Und wenn ich jetzt beides kombiniere und sage:
„Mein Name ist Mathias“ und „Mein Name ist Marcel“
Dann ist der erste Ausdruck wahr und die zweite Aussage falsch.

Aber – Wie sieht die Gesamtaussage aus?
Ist diese nun richtig oder falsch?

„Mein Name ist Mathias und mein Name ist Marcel.“
Die Gesamtaussage ist falsch.
Immer wenn ein Teil der Aussage falsch ist, ist die Gesamtaussage falsch.

Probiere es aus.

• Elefanten sind klein und Berlin ist die Hauptstadt von Deutschland.
• Java ist eine Programmiersprache und Computer wurden noch nicht erfunden.

Du siehst, sobald eine Teilaussage falsch ist, ist auch immer der gesamte Ausdruck falsch.
Dabei ist die Reihenfolge völlig egal.

Und wenn beide Ausdrücke falsch sind- was dann?

Probiere es aus.

• Elefanten sind klein und Berlin war noch niemals die Hauptstadt von Deutschland.
• Java ist auf gar keinen Fall eine Programmiersprache und Computer wurden noch nicht erfunden.
• Ich heiße nicht Mathias und ich heiße Marcel.

Wenn beide Ausdrücke falsch sind, dann ist das Gesamtergebnis auch falsch.

Also merke.
Sobald zwei Ausdrücke durch ein „Und“ verknüpft werden, müssen beide Teilaussagen wahr sein – Damit der Gesamtausdruck wahr ist.
Sobald auch nur ein kleiner Teilausdruck falsch ist, ist die Gesamtausgabe immer falsch.

Und was bedeutet dies nun für Java Ausdrücke?

So setzt du das Und in deine Programmstrukturen ein.

Java stellt dir für Wahrheitswerte einen eigenen Datentyp zur Verfügung.
Und zwar den Datentyp boolean.

Dieser Datentyp kann genau zwei Werte speichern.
Wahr und Falsch. Oder besser gesagt true oder false.

Bleiben wir bei unseren Beispielen:

• Elefanten sind klein und Berlin ist die Hauptstadt von Deutschland.
  Dann heißt dies in Java: false und true
• Elefanten sind klein und Berlin war noch niemals die Hauptstadt von Deutschland.
  Und dies heißt für Java: False und false.

Aber selbst Java weiß nicht, ob Elefanten groß oder klein sind.
Und natürlich kennt Java auch nicht die Hauptstadt von Deutschland.

Das musst du deinem Programm schon selbst beibringen.

Aber wie?
Durch den Datentyp boolean.

Und zwar deklarierst du eine Variable vom Datentyp boolean.
Und dieser Variablen weißt du dann den Wert (true oder false) zu.

Und so geht’s.

public class JavaUndTest {
 
public static void main(String[] args) {
boolean bool = true; //Variable bool speichert den Wert true
boolean boolZwei =false; //Variable boolZwei speichert den Wert false
}
}

Ein paar Worte zu diesem Code.
Ich habe eine neue Klasse, namens „JavaUndTest“ angelegt.

• Diese beinhaltet die main-Methode.
  Diese benötigst du, um ein Java Programm auszuführen.
• Innerhalb der main-Methode wurden jetzt zwei Variablen vom Datentyp boolean angelegt.
• Variable bool hat den Wert true zugewiesen bekommen.
  Variable boolZwei hat den Wert false zugewiesen bekommen.

Beide Variablen stehen somit für eine Aussage.
Die erste Aussage ist wahr, also true.
Die zweite Aussage ist falsch, also false.

Und jetzt verknüpfen wir das Ganze über ein „Und“.

Und so eine „Java Und Verknüpfung“ machst du über einen &.
Jetzt kannst du diese Verknüpfung einmal im Java Code einfügen.

Am besten ist es, du lässt dir das Ergebnis an der Konsole ausgeben.
Also bettest die Verknüpfung in eine System.out.println()-Anweisung ein.
Dies ist nämlich die Anweisung um dir das Ergebnisse als Konsolenausgabe anzeigen zu lassen.

public class JavaUndTest {
 
public static void main(String[] args) {
boolean bool = true; //Wert ist wahr
boolean boolZwei =false; //Aussage ist falsch
 
System.out.println(bool & boolZwei); //Wahr und falsch ist falsch
}
}

Klicke einmal auf „Run“.
Und das Ergebnis false wird zurückgeben.

Jetzt probiere einmal verschiedene Variationen aus.

• Bool ist true und boolZwei ist ebenfalls true
• Bool ist false und boolZwei ist ebenfalls falsch.

Na, was passiert dann?
Am Anfang des Artikels sagte ich:
„Wenn zwei Aussagen über ein Und verknüpft werden, müssen beide Aussagen wahr (true) sein – Damit der Gesamtausdruck wahr oder true ist.“

Also hast du Variationen ausprobiert.
Stimmt meine Aussage?

Lass uns das Ganze um eine dritte Variable erweitern.

Hier ist die Und-Verknüpfung mit drei Variablen:

public class JavaUndTest {
 
public static void main(String[] args) {
boolean bool = true; //Wert ist wahr
boolean boolZwei =false; //Aussage ist falsch
boolean rosaElefanten = false; //Aussage ist falsch
 
System.out.println(bool & boolZwei & rosaElefanten); //Wahr und falsch ist falsch
}
}

Du siehst die Variable „rosaElefanten“?
Diese hat den Wert falsch oder false.

Auch eine Verknüpfung mit drei Wahrheitswerten ist erst dann wahr, wenn alle drei Werte wahr bzw. true sind.

Alles klar?

Wozu brauchst du das?
Du benötigst diese „Und Verknüpfungen“ in Programmstrukturen.
Also immer wenn du etwas auswerten möchtest.

Und genau solche Programmstrukturen möchte ich mir jetzt mit dir noch anschauen.

Die logischen Aussagen kannst du in Verknüpfungen und Verweisen nutzen.

Eine solcher Verweis wäre eine if Bedingung.

public class JavaUndTest {
 
public static void main(String[] args) {
boolean bool = true; //Wert ist wahr
boolean boolZwei =false; //Aussage ist falsch
boolean rosaElefanten = false; //Aussage ist falsch
 
 
if (bool & boolZwei & rosaElefanten == true){
System.out.println("Alle Ausdrücke sind wahr");
}
else {
System.out.println("Mindestens ein Ausdruck ist falsch");
}
}
}

Schreibe den Code einmal ab und klicke auf „Run“.

Was passiert hier?

• Das Programm prüft die if-Bedingung.
• Und diese lautet bool & boolZwei & rosaElefanten == true.
  Und du weißt schon, dass diese Bedingung eben nicht true, sondern false ist.
• Wenn diese nun true wäre, würde das Programm bzw. die Methode den ersten Block ausführen.
  Es würde somit die Bildschirmausgabe „“Alle Ausdrücke sind wahr“ erfolgen.
• Da diese aber nun einmal false ist, wird der zweite Block ausgeführt.
  Es erscheint somit die Bildschirmausgabe „“Mindestens ein Ausdruck ist falsch“.

Setze doch Werte auf true und probiere es noch einmal.
Und….?
Was ist passiert?

Jetzt erscheint die erste Ausgabe.
Cool oder

Du benötigst also diese logischen Ausdrücke und deren Verknüpfungen um Werte prüfen zu lassen.
Und dann lässt du dir abhängig von den Werten bestimmte Befehle ausführen.

Natürlich kannst du auch Methodenrückgaben mit dem Und Operator verknüpfen.

So kannst du logische „Und Verknüpfungen“ im Zusammenspiel mit Java Methoden nutzen.

Schau dir diesen Java Code einmal an.

public class JavaUndTest {
 
static boolean vierGleichSechs(){
boolean wahrOderFalsch = 4 == 6; //vergleicht 4 und sechs und speichert falsch
return wahrOderFalsch; //gibt false zurück
}
 
static boolean fuenfGleichAcht(){
boolean wahrOderFalsch = 5 == 8; //vergleicht 5 und 8 und speichert das Ergebnis
return wahrOderFalsch; //gibt Ergebnis zurück
}
 
public static void main(String[] args) {
boolean bool = vierGleichSechs(); //speichert die Rückgabe der Methode
boolean boolZwei =fuenfGleichAcht(); //speichert die Rückgabe der Methode
 
//1. verknüpft beide Werte über den Und Operator
System.out.println(bool & boolZwei); //Das Ergebnis ist false
 
//2. Oder so. Du lässt dir das Ergebnis der Methoden zurückgeben und verknüpfst diese.
System.out.println(vierGleichSechs()& fuenfGleichAcht()); //liefert false
}
}

Was passiert hier?
Erst einmal besitzt die Klasse jetzt drei Java Methoden.

Die Methode „vierGleichSechs“ prüft ob vier gleich sechs ist und speichert dann den Wahrheitswert false in die Variable „wahrOderFalsch“.
Und dann gibt diese Methode den Wahrheitswert false zurück.

Die zweite Methode „fuenfGleichAcht“ macht das Gleiche mit anderen Zahlen.
Sie prüft ob 5 gleich 8 ist, speichert das Ergebnis false in die Variable und gibt den Wert letztlich auch zurück.

Die dritte Methode ist die main-Methode.

• Und diese führt zwei Variablen „bool“ und „boolZwei“.
• Diese beiden Variablen speichern die Rückgabewerte der Methoden.
• Und dann werden beide Werte mit einer Und-Verknüpfung verknüpft und zurückgeben.
• Dies geschieht mit der ersten System.out.println()-Anweisung.

Alternativ kannst du dir die Speicherung der Rückgabewerte sparen und die Methodenaufrufe direkt mit dem „Und“ verknüpfen. Und das Ergebnis kannst du dir ebenfalls zurückgeben lassen.
Dies setzt die zweite System.out.println()-Anweisung um.

Beide Bildschirmausgaben sind false.

An dieser Stelle versuch doch einmal dir zwei true – Werte zurückgeben zu lassen.
Die Methoden musst du nicht umbenennen.

public class JavaUndTest {

	static boolean vierGleichSechs() {
		boolean wahrOderFalsch = 6 == 6;
		return wahrOderFalsch; // Rückgabewert ist jetzt true
	}

	static boolean fuenfGleichAcht() {
		boolean wahrOderFalsch = 8 == 8;
		return wahrOderFalsch; // auch dieser Wert ist jetzt true
	}

	public static void main(String[] args) {
		boolean bool = vierGleichSechs(); // speichert die Rückgabe der Methode
		boolean boolZwei = fuenfGleichAcht(); // speichert die Rückgabe der Methode

		// 1. verknüpft beide Werte über den Und Operator
		System.out.println(bool & boolZwei); // Das Ergebnis ist true

		// 2. Oder so. Du lässt dir das Ergebnis der Methoden zurückgeben und
		// verknüpfst diese.
		System.out.println(vierGleichSechs() & fuenfGleichAcht()); // liefert true
	}
}

Jetzt wird zweimal true zurückgegeben.
Und die „Und Verknüpfung“ ergibt dadurch ebenfalls true.

Cool, oder?

Du kannst auch Berechnungen über ein „Und“ verknüpfen und auswerten.

Du musst natürlich keine Methoden nutzen.
Auch das geht.

public class JavaUndTest {        
 
public static void main(String[] args) {
boolean boolEins = 17+4 ==24; //speichert false
boolean boolZwei = 17+4 ==21; //speichert true
 
System.out.println(boolEins & boolZwei);
 
// Oder so 
 
System.out.println(17+4==21 & 17+4 ==23);
}
}

In beiden Bildschirmausgaben wird ein false zurückgegeben.

Zusammenfassung:

• In Java kannst du logische Aussagen mit einem „und“ verknüpfen.
  Dazu nutzt du den Und-Operator (&).
• Damit der Gesamtausdruck einer „Und-Verknüpfung“ wahr bzw. true ist, müssen alle Teilaussagen ebenfalls true sein.
• Der Rückgabewert einer „Und-Verknüpfung“ ist immer ein boolean.

Über den Autor

Folge Sciodoo und bleibe stets auf dem Laufenden. Schließ dich uns an und abonniere unseren Instagram-Kanal ein. Wir stellen täglich neue Artikel für dich rein. Weiter zum Kanal>>>