Kleines Quiz Programm

[Schwupsi]

Hi Leute, ich hatte letzte Woche schon einen Thread bezüglich meines Programms eröffnet, wo ich Probleme mit einer int Variable hatte. Danke nochmal für die Hilfe!

Möchte an diesem kleinen Programm weiterarbeiten und es immer weiterentwickeln.
Ich habe eine Klasse "FragenUndAntworten" erstellt, in der ich ein "String[] Frage" Array erstellt habe, in dem ich alle Fragen abgespeichert habe. In der Klasse ist eine Methode, die mit Math.random() der Variablen "k" einen zufälligen Wert zuweist. Mit der Variablen "k" hole ich mir eine zufällige Frage aus dem Array raus -> Frage [k]. Anschließend gibt eine getFrage() Methode die Frage an die main zurück und ich gebe sie dort aus.

Bis hierhin läuft das Programm. Habe jetzt zwei Probleme: Wie mache ich das mit den Antworten? Wie kriege ich das so gecodet, dass für eine zufällige Frage dazu die dazugehörigen Antwortmöglichkeiten rauskommen? Und wie ist das mit der richtigen Antwort? Ein extra Array dafür oder? Komme irgendwie nicht weiter, hoffe auf nützliche Anregungen.

Code Hauptklasse:

import java.util.Scanner;

public class Quiz {

    static int Punktzahl;
    static Scanner s = new Scanner(System.in);

    public static void main(String[] args) {
     
        String Frage = "";
        String RichtigeAntwort = "";
        FragenUndAntworten Fragen = new FragenUndAntworten (Frage, RichtigeAntwort);
      
        System.out.println("Begrüßung"+ "BlaBla");
        int Eingabe = s.nextInt();
        if (Eingabe == 1) {
            Frage();
            System.out.println("Punktzahl: " + Punktzahl);
        } else {
            System.out.println("Falsche Eingabe! Neu starten!");
        }
    }

    public static void Frage() {
        FragenUndAntworten.Zufallsfrage();
        System.out.println(FragenUndAntworten.getFrage());
        /*    boolean RichtigFalsch;
        String Antwort = s.next();
        if (Antwort.equals(RichtigeAntwort)) {
            System.out.println("Richtige Antwort!");
            RichtigFalsch = true;
            Punktzahl(RichtigFalsch);
        } else {
            System.out.println("Falsche Antwort!");
            RichtigFalsch = false;
            Punktzahl(RichtigFalsch);
        }
        */
    }

    public static int Punktzahl(boolean RichtigFalsch) {
        if (RichtigFalsch) {
            Punktzahl = Punktzahl + 1;
        }
        return Punktzahl;
    }

}

Code der Klasse in der die Fragen und Antworten gespeichert werden sollen:

public class FragenUndAntworten {
    static String Question;
    static String[] Frage = {      "Frage1?",                     // Frage [0]
                                "Frage2?",                     // Frage [1]
                                "Frage3?",                     // Frage [2]
                                "Frage4?",                     // Frage [3]
                                "Frage5?",                     // Frage [4]
                                "Frage6?",                     // Frage [5]
                                "Frage7?",                     // Frage [6]
                                "Frage8?",                     // Frage [7]
                                "Frage9",                     // Frage [8]
                                "Frage10?"                     // Frage [9]
    };
    static String[] Antwort = {

    };

    public FragenUndAntworten(String Frage, String RichtigeAntwort) {

    }

    public static void Zufallsfrage() {
            int k;
            k = (int) (Math.random() * 10);
            Question = Frage[k];
    }

    static String getFrage() {
        return Question;
    }

}

 

[klauskarambulut]

Der übliche Weg ist die Fragen nicht als String[] abzulegen sondern als Fragen.

Eine Klasse Frage mit dem Fragetext als String, einer richtigen Antwort und mehreren Falschen Antwortmöglichkeiten.

public class Antwort {
  public String antwort;
  public Antwort(String antwort) {
    this.antwort = antwort;
  }
}

public class Frage {
  public String frageText;
  public Antwort richtigeAntwort;
  public Antwort[] falscheAntworten;
  public Frage(String frageText, Antwort richtigeAntwort, Antwort[] falscheAntworten) {
    this.frageText = frageText;
    this.richtigeAntwort = richtigeAntwort;
    this.falscheAntworten = falscheAntworten;
  }
}

public class Quiz {
  public Frage[] fragen;
  public Quiz(Frage[] fragen) {
    this.fragen = fragen;
  }

  public void frageStellen() {
    Frage frage = fragen[new Random().nextInt(fragen.length)];
    System.out.println(frage.frageText);
    int richtig = Math.random(frage.falscheAntworten.length+1);
    for(int i = 0; i <= frage.falscheAntworten.length; i++) {
      if(i < richtig) {
        System.out.println(frage.falscheAntworten[I].antwort);
      } else if(i == richtig){
        System.out.println(frage.richtigeAntwort.antwort);
      } else {
        System.out.println(frage.falscheAntworten[i-1].antwort);
      }
    }
  }
  int antwort = antwortEinlesen();
  if(antwort == richtig) {
    System.out.println("Antwort ist korrekt");
  } else {
    System.out.println("Antwort ist falsch");
  }
}

 

[Joose]

klauskarambulut hat dir schon einen guten Ansatz gezeit. Was ich daran nur bemängeln würde: Anstatt einen direkten Zugriff auf die Attribute zu haben würde ich hier mit gettern/settern arbeiten 😉
Aber das ist nur ein Schönheitsfehler. Außerdem kannst du dir die Klasse "Antwort" ersparen und stattdessen einfach String verwenden (die Klasse Antwort macht nichts anderes als den String in eine eigene Klasse zu verpacken)

 

[klauskarambulut]

Und warum?

Langeweile? Oder hat die IDE das Feature Generate-Getters and Setters?
Das Programm ist ein Monolith. Ein Programmierer der sich nur selbst sabotieren könnte. Da nützen auch keine Getter und Setter.

Geheimnisprinzip und dann doch den ganzen internen State mit Gettern und Settern nach aussen tragen ist Sinnbefreit?
Und wenn er sich doch einmal dazu entscheiden sollte Getter und Setter nutzen zu wollen, dann kann er es immer noch durch eine IDE refactern.

Kurzum Schönheitsfehler ist eine ziemlich weit aus dem Fenster herausgelehnte Anmassung.

Und wenn er mal ne GUI Baut und Bilder nutzen möchte, dann braucht er halt doch Antworten.

 

[Joose]

Und warum?
Das Programm ist ein Monolith. Ein Programmierer der sich nur selbst sabotieren könnte. Da nützen auch keine Getter und Setter.

Trotzdem sollte man es von Anfang lernen das man mit gettern/settern arbeiten sollte. Das man als erfahrener Programmierer diese mal weglässt für einen kurzen Test ist ja kein Problem.

Geheimnisprinzip und dann doch den ganzen internen State mit Gettern und Settern nach aussen tragen ist Sinnbefreit?

Nein, es erleichtert unter anderem auch die Fehlersuche 😉
Annahme: Es wird auf ein Attribut ein falscher Wert gesetzt. Ohne Setter hast du vielleicht >10 Stellen wo du einen Breakoint setzen musst damit du alles was gesetzt wird abgefangen wird.
Bei einer Setter Methode gibt es maximal eine Stelle wo der Wert auf das Attribut gesetzt werden kann.

Wenn du den Wert noch bearbeiten willst bevor du ihn setzt: Bei einer Setter Methode musst du nur eine Stelle bearbeiten, usw.

Auch gibt es so nur eine Stelle wo man eine Log-Message ausgeben muss wenn man das loggen will. Ansonsten hättest wie beim oberen Beispiel wieder 10+ Stellen wo du eine Log-Message hinzufügen musst (und dann auch immer wieder so viele anpassen).

Also wie oben schon gesagt für eine kleine Testklasse um etwas auszuprobieren ja warum nicht. In richtigen Programm mit gettern/settern arbeiten!

Und wenn er sich doch einmal dazu entscheiden sollte Getter und Setter nutzen zu wollen, dann kann er es immer noch durch eine IDE refactern.

Das stimmt natürlich.

Kurzum Schönheitsfehler ist eine ziemlich weit aus dem Fenster herausgelehnte Anmassung.

Darüber lässt sich natürlich streiten. Für mich ist es ein Schönheitsfehler (der Code funktioniert zwar, aber man kann es besser lösen).
Aber der Großteil der Java Programmierer würde trotzdem getter/setter verwenden.

Und wenn er mal ne GUI Baut und Bilder nutzen möchte, dann braucht er halt doch Antworten.

Klar wenn er es erweitert wäre vielleicht eine Antwort Klasse sicher praktisch (je nach Anforderung).