Binäre Logik – Grundlagen für if, else und Schleifen

Worum geht´s?

In diesem Tutorial lernst du die Grundlagen der binären Logik. die Binäre Logik ist die Grundlage jeder Informatik. Du brauchst sie vor allem dort, wo du if und else sowie Schleifen sinnvoll einsetzen willst.

1. Was ist binäre Logik?

Im Grunde ist die binäre Logik eine Unterform der Mathematik. Gewissermaßen eine Art zu rechnen, ähnlich wie mit + oder -, nur mit etwas anderen Regeln.

Wenn du also Plus- und Malrechnungen in der Schule verstanden hast, dann kannst du mit etwas Geduld auch die binäre Logik lernen. Auch hier hast du Ausgangswerte, Rechenregeln und Ergebnis-Werte. Nur die Regeln sind etwas anders.

2. Mögliche Ergebnisse einer Rechnung der binären Logik

Der Name „binär“ sagt uns, dass wir als Ergebnis einer jeden Rechnung in der binären Logik nur 2 mögliche Endergebnisse haben können:

true
false

Falls dir die beiden Werte bekannt vorkommen: Ja, das sind boolean-Werte.

Deswegen ist der boolean-Datentyp in der Informatik so wichtig: Er speichert die Ergebnisse der Rechnungen binärer Logik.

2.1 Physikalisch/historische Grundlagen

Der Grund, warum es nur 2 Werte gibt und nicht z.B. 3 (das wäre dann die „tertiäre“ Logik, kommt aus der Physik.

Ein Wert von „true“ besagt, dass Strom fließt, ein Wert von „false“, dass kein Strom fließt.

Weil gerade am Anfang des Computer-Zeitalters die Menge an Strom, die durch die einzelnen Bauteile geflossen ist, nicht gerade verlässlich vorhersehbar war, hätte es wenig Sinn gemacht, z.B. zwischen „kein Strom“, „wenig Strom“, „viel Strom“ und „sauviel Strom“ zu unterscheiden. Aber ob Strom fließt (egal wie viel) oder ob keiner fließt (wirklich gar keiner), das war vergleichsweise gut zu unterscheiden.

Die Basis von dem allen sind sogenannte Transistoren. Das sind kleine Bauteile, in die Strom reinfließt und Strom rausfließen kann. Ob wieder Strom rauskommt, wird dadurch bestimmt, ob an einem zweiten Zugang auch Strom fließt. Wenn ja, wird der Strom weitergeleitet. Wenn nicht, dann wird er „blockiert“.

Später wurde es dann möglich, diese Transistoren gewissermaßen mit Hilfe von Software „nachzubauen“. Du findest diese „Transistoren“ auch heute noch in jeder Programmiersprache: als if und else.

3. Welche „Rechen-Arten“ es gibt

3.1 Einfache Bedingungen

Die einfachen Bedingungen kennst du bereits aus den Tutorials über if und else:

a > 5
a < 5
a == 5 (Achtung: 2x Gleichheitszeichen !)
a != 5 (a ist ungleich 5)
a >= 5
a <= 5

Eine jede dieser Bedingungen enthält eigentlich eine Rechnung der binären Logik, die als Ergebnis true oder false ergibt.

Falls das Ergebnis der Rechnung true ist und sich die Bedingung in einem if befindet, so wird der if-Block ausgeführt. Kommt false raus, wird der if-Block übersprungen und (falls vorhanden) der else-Block ausgeführt.

Da die einzelnen Bedingungen für die meisten Menschen selbsterklärend sind, werde ich hier nicht weiter darauf eingehen.

Was aber, wenn wir z.B. herausfinden wollen, ob eine Zahl zwischen 1 und 3 ist? Dann reicht ein > oder ein < alleine nicht aus.

Wir müssen also unsere einfachen Bedingungen auch verknüpfen können.

3.2 Einfache Bedingungen verknüpfen

Unsere einfachen Bedingungen können wir auf folgende Arten verknüpfen:

&&: „und“, alle müssen true sein, sonst false
||: „oder“, mindestens 1 muss true sein, sonst false
^: „entweder-oder“, „xor“, genau 1 muss true sein, sonst false
!: „not“, kehre das bisherige Ergebnis um
(): Klammern, gleich wie aus der Mathematik bekannt

3.2.1 Die und-Verknüpfung mit &&

Der folgende Programm-Code würde z.B. dann ausgeführt werden, wenn die Zahl zwischen 1 und 3 ist:

import java.util.Random;

public class HelloWorld {
    public static void main(String[] args) {
        Random r = new Random();
        // erstelle zahl zwischen 1 und 6
        int a = r.nextInt(10);

        if ((a >= 1) && (a <= 3)) {
            System.out.println("Glückszahl!");
        }
    }
}

Durch das && müssen beide Bedingungen erfüllt sein, sonst kommt als Endergebnis der Rechnung false heraus.

Es werden also immer zuerst die „kleinen“ Bedingungen berechnet, und deren Ergebnisse werden verknüpft, um ein Endergebnis zu bekommen.

3.2.2 Die oder-Verknüpfung mit ||

Der folgende Code würde z.B. dann in den if-Block gehen, wenn die Zahl 3 oder 7 ist:

import java.util.Random;

public class HelloWorld {
    public static void main(String[] args) {
        Random r = new Random();
        // erstelle zahl zwischen 1 und 6
        int a = r.nextInt(10);

        if ((a == 3) || (a == 7)) {
            System.out.println("Glückszahl!");
        }
    }
}

Sobald mindestens einer der beiden „kleinen“ Bedingungen true ergibt, reicht das, um als Endergebnis true zu bekommen.

Auf den meisten deutschen Tastaturen findest du den senkrechen Schrägstrich übrigens mit ALTGR+<

3.2.3 Die xor-Verknüpfung mit ^

Diese Verknüpfung braucht man nur sehr, sehr selten.

Sie funktioniert ähnlich wie die oder-Verknüfung, nur mit dem Unterschied, dass hier nur genau 1 kleine Bedingung true sein darf. Sind es also mehr als 1, wird das Endergebnis auch false.

3.2.4 Das not-Zeichen !

Das Rufzeichen dreht den boolean-Wert, vor dem er steht, um.

Du kannst dir das in etwa so vorstellen, als hättest du eine Münze, und „Kopf“ entspricht true, während „Zahl“ false entspricht.

Drehst du die Münze um, so wird aus Kopf dann Zahl, und umgekehrt.

Das !-Zeichen macht dasselbe mit true und false.

Wenn wir unser &&-Beispiel nehmen und es umkehren wollen (alles außer 1-3), so können wir das mit einem ! tun:

import java.util.Random;

public class HelloWorld {
    public static void main(String[] args) {
        Random r = new Random();
        // erstelle zahl zwischen 1 und 6
        int a = r.nextInt(10);

        if (!((a >= 1) && (a <= 3))) {
            System.out.println("Glückszahl!");
        }
    }
}

Wichtig ist dabei die Klammer um die beiden kleinen Bedingungen, da sonst das Rufzeichen nur die erste der beiden kleinen Bedingungen umkehren würde.

3.2.5 Die Klammern

Die Klammern funktionieren in der binären Logik exakt gleich wie in der „normalen“ Mathematik. Sie vergeben „Vorrang“.

3.3 „Vorrang-Regeln“ beim Verknüpfen mehrerer Bedingungen

Was aber, wenn wir z.B. folgenden Code haben:

import java.util.Random;

public class HelloWorld {
    public static void main(String[] args) {
        Random r = new Random();
        // erstelle zahl zwischen 1 und 6
        int a = r.nextInt(10);

        if ((a >= 1) && (a <= 3) || (a == 7)) {
            System.out.println("Glückszahl!");
        }
    }
}

Woher weiß Java, ob er zuerst die &&-Verknüpfung errechnen soll oder zuerst die || Verknüpfung?

3.3.1 Vorrang-Regeln zwischen verschiedenen Verknüpfungs-Arten

Dazu gibt es „Vorrang-Regeln“:

1. ()–Klammern
2. ! not
3. && und
4. || oder, ^ xor

Was aber, wenn z.B. mehrere &&-Verknüpfungen hintereinander stehen? Welche kommt dann zuerst?

Vorrang-Regeln zwischen gleichrangigen Verknüpfungs-Arten

Haben wir lauter gleiche oder zumindest gleichrangige (oder, xor) Verknüpfungs-Arten, so verknüpft Java sie von links nach rechts.

Dies kann man sich manchmal auch zur Programm-Optimierung zunutze machen.

Habe ich zum Beispiel mehrere &&-Verknüpfungen, ist das Endergebnis auf jeden Fall false, falss eine der Bedingungen false ist (weil ja alle true sein müssen, damit das Endergebnis true sein kann). Java überprüft daher die restlichen gar nicht mehr, sobald es eine false-Bedingung gefunden hat.

Umgekehrt kann ich es auch mit ||-Verknüpfungen nutzen, weil da der Endwert sofort als true angenommen wird, sobald ein einziges true gefunden wurde (weil ja mindestens 1 schon reicht).

Das war eigentlich schon das wichtigste zur binären Logik.

Du brauchst sie vor allem, wenn du if und else verwendest. Aber auch bei Schleifen, denn die Bedingungen, die du dort verwendest, funktionieren genau gleich wie bei if und else.

Die schlechte Nachricht ist: Wenn du die binäre Logik nicht kapierst, wird alles was noch kommt für dich bedeutend schwieriger werden.

ABer die gute Nachricht ist: Wenn du sie kapiert hast und ein wenig Übung hast, ist der Rest der noch kommt ab hier auch bedeutend einfacher.

Sie ist gewissermaßen der Knackpunkt am Programmieren lernen. Man muss sie (ähnlich wie „normales“ Rechnen auch einfach eine Weile üben.

In dem Sinne: hoffentlich dir noch viel Freude damit 🙂

Diskussion zum Tutorial