2.2 if- und if-else-Anweisungen

Extreme Belastungen einer Personenwaage
Autor: Ulrich Helmich mit Hilfe von ChatGPT 2025, Lizenz: Public domain

Dieses Bild soll Sie motivieren, darüber nachzudenken, ob man die Setter-Methoden der Klasse Waage nicht noch etwas anpassen müsste.

Inhalt dieser Seite

2.2.1 Die if-Anweisung und Flussdiagramme ↑

Beispiel setGewicht()

Eine Setter-Methode verändert den Wert einer Instanzvariable. Dabei sollte die Methode auch schon darauf achten, dass der Instanzvariablen nur vernünftige Werte zugewiesen werden. Eine Methode wie

public void setGewicht(double gewicht)
{
   this.gewicht = gewicht;
}

ist dafür nicht unbedingt die beste Wahl. Man kann die Methode problemlos auch mit einer negativen Zahl aufrufen oder mit einer viel zu großen positiven Zahl (siehe Bild 1).

Normale Personenwaagen können Gewichte von bis zu 130 kg messen. Umgekehrt kann eine normale Personenwaage auch nicht beliebig geringe Gewichte messen. Die meisten Waagen zeigen für Gewicht unter 4 kg den Wert 0 an - oder reagieren überhaupt nicht auf das Gewicht.

Für unsere Waage wollen wir als Messbereich einmal das Intervall von 4 bis 130 festlegen. Dazu müssen wir die Setter-Methode setGewicht() ergänzen:

Die neue Setter-Methode setGewicht()

Dieses Bild zeigt die "Neuerwerbungen" der Setter-Methode setGewicht(). Schauen Sie sich an, was hier alles verändert wurde. Vielleicht kommen Sie ja schon von selbst auf die Rolle der if-Anweisungen in Zeile 16 und Zeile 22.

Verbale Erklärung der beiden if-Anweisungen ↑

In Zeile 16 wird überprüft, ob der Parameter gewicht kleiner als 4 (kg) ist. Das geschieht mit der if-Anweisung

if (gewicht < 4)

Wenn das tatsächlich der Fall sein sollte, dann werden zwei neue Anweisungen ausgeführt. Die erste Anweisung ruft eine neue Ausgabe-Methode zeigeFehler() auf, die dann eine entsprechende Fehlermeldung auf die Konsole schreibt. Die zweite Anweisung - return - beendet die Methode setGewicht().

Der return-Befehl hat also eine Doppelfunktion. Einmal kann er einen Wert zurückliefern. Hier ist das nicht der Fall. Die zweite Funktion des return-Befehls ist die sofortige Beendigung einer Methode. Von dieser zweiten Funktion wird hier Gebrauch gemacht.

Falls die Bedingung (gewicht < 4) nicht zutrifft, das Gewicht also nicht kleiner als 4 ist, wird der Code innerhalb der if-Anweisung ignoriert und es wird einfach mit dem nächsten Befehl weitergemacht, der auf die if-Anweisung folgt.

In unserer Methode setGewicht() ist das aber kein normaler Befehl, sondern eine zweite if-Anweisung. Wenn das Gewicht größer als 130 kg ist, soll ebenfalls eine Fehlermeldung ausgegeben werden, danach soll die Methode beendet werden.

Wenn auch die zweite Bedingung (gewicht > 130) nicht erfüllt ist, dann muss der Wert des Parameters gewicht in dem vorgegebenen Rahmen sein - alle Werte, die nicht in diesen Rahmen passen, haben wir ja durch die beiden if-Bedingungen abgefangen und ausgeschlossen. Der Wert des Parameters gewicht kann jetzt also problemlos an die Instanzvariable gewicht zugewiesen werden.

Graphische Erklärung der beiden if-Anweisungen ↑

Statt mit vielen Worten kann man diese doppelte Überprüfung auch mit einem sogenannten Flussdiagramm graphisch darstellen. Vielleicht ist das für Sie anschaulicher als die verbale Darstellung.

Flussdiagramm zur doppelten Kontrolle des Gewichts
Autor: Ulrich Helmich 2025, Lizenz: Public domain

Dieses Bild zeigt ein Flussdiagramm mit dem sogenannten Programmfluss. Wichtig sind hier die Entscheidungsrauten. Jede Entscheidungsraute steht für eine Fallunterscheidung: Ist die Bedingung, die im Innern der Raute steht, wahr (true, 1) oder falsch (false, 0)?. Es führen nur zwei Wege aus der Raute heraus.

Die Fehlermeldungen stehen in Symbolen, die aussehen wie ein abgerissenes Blatt Druckerpapier. Diese Symbole kann man auch für Konsolenausgaben verwenden - allerdings gibt es heute bestimmt bessere Symbole für solche Ausgaben, das müsste ich erst mal recherchieren.

In Rechtecken stehen schließlich die normalen Anweisungen (Zuweisungen, Methodenaufrufe etc.). Wenn man das Flussdiagramm ganz richtig darstellen will, sollte man auch den Start und das Ende des Programms mit einzeichnen - oft wird das aber auch nicht gemacht, wenn aus dem Kontext hervorgeht, wo der Programmfluss startet und endet.

Schritt 15

Schritt 16

Syntax der if-Anweisung, Beispiele ↑

Syntaxdiagramm einer if-Anweisung
Autor: Ulrich Helmich 2025, Lizenz: Public domain

Ein Syntaxdiagramm besteht aus Terminalsymbolen (kurz: Terminalen) und Nichtterminalsymbolen (kurz: Nichtterminalen), die durch Pfeile miteinander verbunden sind. Wir wollen das obige Syntaxdiagramm einmal gemeinsam lesen:

Analyse des Syntaxdiagramms ↑

Die if-Bedingung fängt stets mit dem Schlüsselwort "if" an. Schlüsselworte wie "if", "while", "for" etc. gehören zu den Terminalsymbolen - sie sind endgültig, man kann sie nicht mehr auflösen und in kleinere Einheiten zerlegen.

Nach dem "if" folgt eine logische Bedingung, die von runden Klammern "(" und ")" eingeschlossen ist. Die runden Klammern sind ebenfalls Terminale, die Bedingung allerdings ist ein Nichtterminal.

Was eine logische Bedingung ist, muss durch ein weiteres Syntaxdiagramm definiert werden. Eine einfache logische Bedingung ist beispielsweise geschlecht == 'w' oder x <= 10. Auch komplexere Bedingungen wie geschlecht == 'm' && alter >= 18 sind möglich, hier werden zwei einfache Bedingungen durch den UND-Operator && miteinander verknüpft.

Nach dem Terminal ")" kommt eine Anweisung - ebenfalls ein Nichtterminal, das durch ein Syntaxdiagramm definiert werden muss. Das wollen wir jetzt hier nicht machen, aber wir wollen an dieser Stelle schon einmal festhalten, dass es zwei Typen von Anweisungen gibt:

1. einfache Anweisungen (zum Beispiel eine Zuweisung wie geschlecht = 'm') oder einen Methodenaufruf (wie ideal = getIdealgewicht()). Auch eine if-Anweisung oder eine while-Anweisung gehört zu den "einfachen Anweisungen" (was die Sache interessant macht, wie wir später noch sehen werden).
2. Anweisungsblöcke, das sind mehrere einfache Anweisungen, die von geschweiften Klammern zu einem Block zusammengeschlossen werden.

{
   gewicht = 77;
   groesse = 180;
   ideal   = getIdealgewicht();
   diff    = getDifferenz();
}

Übung 2.2.1 #2

Betrachten Sie folgendes Flussdiagramm:

Ein Flussdiagramm
Autor: Ulrich Helmich 2025, Lizenz: Public domain

Verändern Sie Ihre Methode getIdealgewicht() entsprechend! Vergessen Sie nicht eine passende Instanzvariable für das Geschlecht sowie eine Setter- und Getter-Methode für dieses neue Attribut.

2.2.2 Die if-else-Anweisung ↑

Syntaxdiagramm

Eine if-Anweisung führt Anweisungen nur dann aus, wenn die Bedingung erfüllt ist, sonst passiert nichts, und die Anweisungen, die auf die if-Anweisung folgen, werden ausgeführt.

Eine if-else-Anweisung dagegen ergänzt die if-Anweisung mit einem Alternativzweig, der ausgeführt wird, wenn die Bedingung nicht erfüllt ist. Erst danach werden die Anweisungen ausgeführt, die auf die if-else-Anweisung folgen.

Betrachten Sie folgendes Syntaxdiagramm:

Graphische Darstellung einer if-Anweisung durch ein Syntaxdiagramm
Autor: Ulrich Helmich 2025, Lizenz: Public domain

Dieses Syntaxdiagramm ähnelt dem Syntaxdiagramm einer if-Anweisung und enthält auch die einfache if-Anweisung (obere Zeile des Diagramms).

Nach dem abschließenden Semikolon der if-Anweisung kann jedoch der oben genannte Alternativzweig kommen. Dieser wird von dem Schlüsselwort "else" eingeleitet (einem Terminalsymbol) , gefolgt von der alternativen Anweisung. Auch der else-Zweig wird dann von einem Semikolon abgeschlossen (einem weiteren Terminal).

Denken Sie daran, dass auch die alternative Anweisung im else-Zweig eine einfache Anweisung oder ein Anweisungsblock sein kann.

Beispiele für syntaktisch korrekte if-else-Anweisungen ↑

if (alter < 12) 
   macheDies(); 
else 
   macheDas();

	
if (bmi > 50)
{
  System.out.println("Sie haben starkes Übergewicht!");
  System.out.println("Suchen Sie einen Ernährungsberater auf");
}
else if (bmi > 35)
   System.out.println("Sie haben Übergewicht");

Interessant ist die zweite if-else-Bedingung, weil hier ein neuer Sachverhalt gezeigt wird: Eine Anweisung kann auch eine weitere if- oder if-else-Anweisung sein. Auf diese Weise ist es möglich, neben den Zweifach-Auswahlen (entweder-oder bzw. if-else) auch Dreifach-, Vierfach- und Mehrfach-Auswahlen zu realisieren. Die folgende Abbildung zeigt eine Dreifach-Auswahl in einem Java-Programm.

Eine Dreifach-Auswahl, die durch zwei if-else-Anweisungen realisiert wird
Autor: Ulrich Helmich 2025, Lizenz: Public domain

if (alter< 18)
   status = jugendlicher;
else if (alter < 14)
   status = kind;
else if (alter < 6)
   status = kleinkind;
else
   status = erwachsener;

if (monat < 12);
   macheDies();
else 
   fehlermeldung("Falscher Monat");
	
if (geschlecht == 'w')
   anrede = "Frau";
	faktor = 0.85;
else 
   anrede = "Herr";
	faktor = 0.90;

1. if (alter >= 18)
   {
      System.out.println("Du bist volljährig.");
   }
   else
   {
      System.out.println("Du bist noch nicht volljährig.");
   }

2. if alter > 65
   {
      System.out.println("Du bist im Ruhestand.");
   }
   else
   {
      System.out.println("Du arbeitest noch.");
   }

3. if (punktzahl >= 50)
   {
      System.out.println("Bestanden!");
   }
   else
   {
      System.out.println("Nicht bestanden!");
   }

4. if (temperatur > 30);
   {
      System.out.println("Es ist heiß.");
   }
   else
   {
      System.out.println("Es ist angenehm.");
   }

5. if (zahl % 2 == 0)
   {
      System.out.println("Die Zahl ist gerade.");
   }
   else
   {
      System.out.println("Die Zahl ist ungerade.");
   }

6. if (name = "Anna")
   {
      System.out.println("Hallo Anna!");
   }
   else
   {
      System.out.println("Du bist nicht Anna.");
   }
   

2.2.3 Klausurvorbereitung ↑

Am Ende des Semesters schreiben Sie eine Klausur, von deren Ergebnis Einiges abhängt. Die hier folgenden Aufgaben sollen Sie schon einmal auf diese Klausur vorbereiten. Nicht alle Aufgaben sind für eine Klausur geeignet, aber eine oder zwei davon könnten in abgewandelter Form durchaus in der Klausur auftauchen. Aufgaben wie #7, bei denen Sie vorher recherchieren müssen, sind natürlich keine geeigneten Klausuraufgaben. In diesem Fall würden Sie als Material eine entsprechende Tabelle oder einen Text zur Verfügung gestellt bekommen.

if (gewicht == getIdealgewicht())
   System.out.println("Sie haben Idealgewicht");

Nun noch ein paar kleine Aufgaben zur Klausurvorbereitung

Und hier noch einmal eine kleine Ergänzung der Klasse Waage

2.2.4 Der ternäre Operator ↑

Der ternäre Operator (manchmal auch Bedingungsoperator genannt) ist im Grunde eine Abkürzung für eine if-else-Anweisung. Er wird "ternär" genannt, weil er der einzige Operator in Java ist, der drei Operanden benötigt. Seine Syntax ist sehr einfach und kann Code lesbarer und kompakter machen.

Syntax

Betrachten wir zunächst ein Syntaxdiagramm:

Syntaxdiagramm des ternären Operators
Autor: Ulrich Helmich 2025, Lizenz: Public domain

Erläuterung

• Nichtterminal Bedingung: Das ist wie bei einer klassischen if-else-Bedingung die logische Bedingung, von der abhängt, ob der Ausdruck im if-Zweig oder der alternative Ausdruck im else-Zweig gewählt wird.
• Terminal Fragezeichen: Hinter dem Fragezeichen steht der Ausdruck, der gültig ist, wenn die Bedingung erfüllt ist. Man bezeichnet diesen Ausdruck auch gern als true-Ausdruck.
• Nichtterminal true-Ausdruck: Dieser Ausdruck muss einen Wert liefern. Dieser Wert wird dann von dem ternären Operator zurückgeliefert, wenn die Bedingung wahr ist. Eine simple Anweisung wie System.out.println() darf hier nicht stehen, weil diese Anweisung keinen Wert zurückliefert.
• Terminal Doppelpunkt: Dieses Terminal trennt die beiden Ausdrücke.
• Nichtterminal false-Ausdruck: Auch dieser Ausdruck muss einen Wert zurückliefern. Dieser Wert wird zurückgegeben, wenn die Bedingung nicht erfüllt ist.

Syntaxdiagramm des ternären Operators
Autor: Ulrich Helmich 2025, Lizenz: Public domain

Das Ergebnis des ternären Operators kann dann einer Variablen zugewiesen werden, die den gleichen Datentyp haben muss wie die beiden Ausdrücke.

Eine Anweisung wie

(zahl > 0) ? System.out.println("positiv") : System.out.println("negativ"); 

ist daher nicht erlaubt.

Beispiele

Und nun einige Beispiele. Dazu vergleichen wir eine "klassische" if-else-Anweisung mit der if-else-Anweisung unter Verwendung des ternären Operators.

Klassische if-else-Anweisung:

if (alter >= 18)
   status = volljaehrig;
else
   status = minderjaehrig;

Unter Verwendung des ternären Operators:

status = (alter >= 18) ? volljaehrig : minderjaehrig;

Hier noch drei weitere Beispiele:

int zahl = -5;
String ergebnis = (zahl > 0) ? "Die Zahl ist positiv." : "Die Zahl ist nicht positiv.";

int a = 15;
int b = 10;
int max = (a > b) ? a : b;

int zahl = -3;
String text = (zahl >= 0) ? "positiv" : "negativ";

Und hier noch ein Beispiel, direkt bezogen auf die Klasse Waage und die Berechnung des Idealgewichts. Angenommen, in der Klasse existiert eine Instanzvariable geschlecht sowie entsprechende Setter- und Getter-Methoden. Dann kann man die Methode getIdealgewicht() auch so schreiben:

double getIdealgewicht()
{
   double faktor = (geschlecht == 'm') ? 0.90 : 0.85;
   return (groesse-100) * faktor;
}

Man sollte es nicht glauben, aber sogar folgende Methode wird fehlerfrei kompiliert und ausgeführt:

double getIdealgewicht()
{
   return (groesse-100) * ( (geschlecht == 'm') ? 0.90 : 0.85 );
}

Der ternäre Operator (geschlecht == 'm') ? 0.90 : 0.85 liefert einen Ausdruck, der einer double-Variable zugewiesen werden kann - ist also selbst eine double-Zahl. Diese double-Zahl kann dann auch als Faktor für die Berechnung des Idealgewichts eingesetzt werden.

Ob das Ganze die Lesbarkeit und Wartbarkeit der Methode verbessert, ist natürlich eine andere Frage.

Fünf Aufgaben zum Einüben

Die folgenden Aufgaben dienen zum Einüben des Umgangs mit dem ternären Operator. Kopieren Sie sich den Quelltext am Ende dieser Aufgaben mit fünf leeren sondierenden Methoden. Ergänzen Sie die Methoden dann so, wie es in den fünf folgenden Aufgaben beschrieben ist.

Testen Sie die vervollständigte Klasse TernaererOperator dann mit Hilfe des Testprogramms, dass sie am Ende dieses Abschnitts finden.

Hier finden Sie eine Java-Klasse zu den Aufgaben 2.2.4#1 bis #5 mit vorgefertigten sondierenden Methoden. Sie müssen nur noch die Methodenrümpfe vervollständigen, um die fünf Aufgaben zu lösen:

public class TernaererOperator
{
    public int minimum(int x, int y)
    {
       return 
    }
    
    public char vorzeichen(int x)
    {
       return 
    }
    
    public double rabatt(double betrag)
    {
       return 
    }
    
    public String zustand(double temperatur)
    {
       return 
    }
    
    public int note(int punkte)
    {
       return
    }
}

Hier können Sie sich eine Testklasse kopieren, mit denen Sie die fünf sondierenden Methoden testen können:

public class TestTernaer
{
    TernaererOperator testklasse;
    
    public TestTernaer()
    {
        testklasse = new TernaererOperator();
        
        System.out.println("Teste minimum");
        System.out.println("Minium von 3 und 7 ist " + testklasse.minimum(3,7));
        System.out.println("---------------------------------");      
        
        System.out.println("Teste vorzeichen");
        System.out.println("Vorzeichen von  3 ist " + testklasse.vorzeichen(3));
        System.out.println("Vorzeichen von -3 ist " + testklasse.vorzeichen(-3));
        System.out.println("---------------------------------");        
        
        System.out.println("Teste rabatt");
        System.out.println("Rabatt auf 120 Euro ist " + testklasse.rabatt(120) + " Prozent");
        System.out.println("Rabatt auf  80 Euro ist " + testklasse.rabatt( 80) + " Prozent");
        System.out.println("---------------------------------");      
        
        System.out.println("Teste zustand");
        System.out.println("Aggregatzustand bei -20 Grad Celsius ist " + testklasse.zustand(-20));
        System.out.println("Aggregatzustand bei   0 Grad Celsius ist " + testklasse.zustand(  0));
        System.out.println("Aggregatzustand bei  30 Grad Celsius ist " + testklasse.zustand( 30));
        System.out.println("Aggregatzustand bei 110 Grad Celsius ist " + testklasse.zustand(110));
        System.out.println("---------------------------------");         
        
        
        System.out.println("Teste note");
        System.out.println("Note bei  30 Punkten ist " + testklasse.note( 30));
        System.out.println("Note bei  40 Punkten ist " + testklasse.note( 40));
        System.out.println("Note bei  50 Punkten ist " + testklasse.note( 50));
        System.out.println("Note bei  60 Punkten ist " + testklasse.note( 60));
        System.out.println("Note bei  70 Punkten ist " + testklasse.note( 70));
        System.out.println("Note bei  80 Punkten ist " + testklasse.note( 80));
        System.out.println("Note bei  90 Punkten ist " + testklasse.note( 90));
        System.out.println("Note bei 100 Punkten ist " + testklasse.note(100));
        System.out.println("---------------------------------");         
    }
}

Viel Erfolg beim Üben. Ein Aufgabentyp für die Klausur könnte ähnliche Beispiele präsentieren, oder es könnte sein, dass Sie eine vorgegebene geschachtelte if-else-Anweisung in eine Anweisung mit ternären Operatoren umwandeln müssen oder umgekehrt.

Und noch zwei größere Aufgaben

1. Fahrpreise einer Regionalbahn

Die Gestaltung dieser Aufgabe war zu aufwendig für eine Webseite, laden Sie sich daher bitte das entsprechende PDF-Dokument herunter.

Zum Testen Ihrer Klasse habe ich eine Testklasse geschrieben, die vier der möglichen Fälle durchspielt und das Ergebnis Ihrer Berechnungen mit den erwarteten Resultaten vergleicht. Hier der Quelltext dieser Testklasse zum Kopieren in die Zwischenablage:

public class TesteFahrpreise
{
    Fahrpreise kunde;
    
    public TesteFahrpreise()
    {
        kunde = new Fahrpreise();
        test1();
        test2();
        test3();
        test4();
    }

    private boolean testOK(double sollwert, double istwert)
    {
       return (istwert > sollwert * 0.98) && (istwert < sollwert * 1.02);
    }
    
    public void test1()
    {
        // Montags 5:30 Uhr, Alter 12 Jahre, Strecke 20 km, kein Fahrrad, kein Sozialrabatt
        // Berechneter Preis: 3,20 + 4 (20 km) = 7,20.
        // Alter 12 ⟹ 3,60 (die Hälfte)
        kunde.nimmtFahrrad(false);
        kunde.bekommtSozialrabatt(false);
        kunde.kauftKarte(1,5,30,12,20);
        double ergebnis = kunde.preis();
        System.out.println("Preis : " + ergebnis);
        if (testOK(7.20, ergebnis) )
           System.out.println("Berechnung ist wie erwartet");
    }
    
    public void test2()
    // wie test1(), aber jetzt in Spitzenzeit
    {
        // Montags 6:30 Uhr, Alter 12 Jahre, Strecke 20 km, kein Fahrrad, kein Sozialrabatt
        // Berechneter Preis: 3,20 + 0,80 + 4 (20 km) = 8,00.
        // Alter 12 ⟹ 3,60 (die Hälfte)
        kunde.nimmtFahrrad(false);
        kunde.bekommtSozialrabatt(false);
        kunde.kauftKarte(1,6,30,12,20);
        double ergebnis = kunde.preis();
        System.out.println("Preis : " + ergebnis);
        if (testOK(8.00, ergebnis) )
           System.out.println("Berechnung ist wie erwartet");
    }    
    
    public void test3()
    // wie test2, aber jetzt mit Fahrrad
    {
        // Montags 6:30 Uhr, Alter 12 Jahre, Strecke 20 km, kein Fahrrad, kein Sozialrabatt
        // Berechneter Preis: 3,20 + 0,80 + 1,50 + 4 (20 km) = 9,50.
        // Alter 12 ⟹ 3,60 (die Hälfte)
        kunde.nimmtFahrrad(true);
        kunde.bekommtSozialrabatt(false);
        kunde.kauftKarte(1,6,30,12,20);
        double ergebnis = kunde.preis();
        System.out.println("Preis : " + ergebnis);
        if (testOK(9.50, ergebnis) )
           System.out.println("Berechnung ist wie erwartet");
    }    
    
    public void test4()
    // wie test4, aber jetzt mit Fahrrad und Sozialrabatt
    {
        // Montags 6:30 Uhr, Alter 12 Jahre, Strecke 20 km, kein Fahrrad, kein Sozialrabatt
        // Berechneter Preis: 3,20 + 0,80 + 1,50 + 4 (20 km) = 9,50 * 0,70 = 6,65
        // Alter 12 ⟹ 3,60 (die Hälfte)
        kunde.nimmtFahrrad(true);
        kunde.bekommtSozialrabatt(true);
        kunde.kauftKarte(1,6,30,12,20);
        double ergebnis = kunde.preis();
        System.out.println("Preis : " + ergebnis);
        if (testOK(6.65, ergebnis) )
           System.out.println("Berechnung ist wie erwartet");
    }        

}

Sie können diese Testklasse gern um weitere Tests erweitern.

2. Handytarife

Ein Mobilfunkanbieter möchte einen automatischen Tarifberateer für seine Webseite erstellen. Erstellen Sie eine Klasse Tarifberater mit den notwendigen Instanzvariablen und den entsprechenden Setter- und Getter-Methoden.

Die öffentliche Hauptmethode dieser Klasse ist:

public String getTarifEmpfehlung()

Zurückgegeben werden soll ein String mit dem Namen des empfohlenen Tarifs.

Die Tarif-Regeln habe ich mir von Google Gemini erstellen lassen, weil ich mich in diesem Bereich zu wenig auskenne.

Tarifregeln für Kunden unter 28 Jahre:

Wenn der Kunde Student ist, erhält er bei einem gewünschten Datenvolumen von unter 20 GB den Tarif "Young Student Plus", bei einem größeren Datenvolumen den Tarif "Young Student Premium".

Wenn der Kunde unter 28 Jahre kein Student ist: Bei einem Datenvolumen unter 10 GB wird der Tarif "Young Starter" empfohlen, bei einem Datenvolumen >= 10 GB dagegen der Tarif "Young Unlimited".

Tarifregeln für Kunden ab 28 Jahren:

Wenn der Kunde eine Flatrate für Telefonie wünscht und das Datenvolumen unter 5 GB ist, wird der Tarif "Comfort S" empfohlen, bei einem Datenvolumen zwischen 5 und 25 GB (einschließlich) der Tarif "Comfort L".
Wenn der Kunde keine Telefonie-Flatrate wünscht und das Datenvolumen kleiner als 10 GB ist, wird "Data Basic" vorgeschlagen, und bei einem Datenvolumen von 10 GB oder mehr "Data Pro".

Wenn ein Kunde ein Datenvolumen von 0 GB angibt UND keine Telefonie-Flatrate wünscht, soll der String "Kein passender Tarif gefunden" ausgegeben werden. Dieser Fall muss als Erstes geprüft werden.

Zum Testen der Klasse müssen Sie sich diesmal eine eigene Testklasse schreiben. Hier eine von Google Gemini erstellte Tabelle mit ein paar Testfällen:

Ein paar Testfälle
Autor: Google Gemini 2025, Lizenz: Public domain