[Arythya]

Da ich gerade mit Java begonnen habe, möchte ich ein paar Programme zum üben schreiben. An einer Stelle komme ich allerdings nicht weiter.
Wie kann ich eine Abfrage in etwa so gestalten:
Es wird eine Frage gestellt, bei der man per Tastatureingabe des Buchstabens j das Programm nochmal von vorne starten kann.
Was genau kommt denn jetzt zwischen dir Klammern von while bzw. if/else?

Scanner scan2=new Scanner(System.in);
String jaNein;
System.out.println("Programm nochmal starten? [J/N]");
jaNein=scan2.next();

while (jaNein=="j")
{
???
}

Meine Alternative war noch das ganze mit if/else zu machen und statt "String jaNein" "char jaNein" zu verwenden, das hat aber auch beides nicht funktioniert.
Hier mit if:

Scanner scan2=new Scanner(System.in);
char jaNein;
System.out.println("Programm nochmal starten? [J/N]");
jaNein=scan2.nextChar();

if (jaNein==(j|=J)){ //jaNein ist entweder j oder J
??
}
else{
??
}

[Ewige Finsternis]

Ich hab dir ein kleines Beispielprogramm geschrieben in dem ich versucht hab das Szenario das du beschreibst abzubilden. Hoffe ich habe dich richtig verstanden

import java.io.*;

public class Test
{
  BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
  
  public static void main(String args[])
  {
    Test t = new Test();
    
    while(true)
    {
      // -1-
      t.programm();
      // -6-
    }
  }  
  
  public void programm()
  {
    // -2-
    try
    {
      System.out.println("Programm wird gestartet...");
      
      while(true)
      {
        System.out.println("Programm neu starten?");
        System.out.println("j = JA, n = NEIN, x = BEENDEN");
        String eingabe = input.readLine(); // -3-
        
        switch(eingabe) // -4-
        {
          case "j":
            System.out.println("Sie haben sich für JA entschieden! :)\n");
            return; // -5-
          case "n":
            System.out.println("Sie haben sich für NEIN entschieden! :(\n");
            break;
          case "x":
            System.out.println("Sie haben sich entschieden keine Entscheidung zu treffen..\n");
            System.exit(0);
          break; 
          default:
            System.out.println("Ihre Eingabe '"+eingabe+"' ist ungueltig!\n");                    
        }
      }
    }      
    catch(Exception e)
    {
      System.out.println("Fehler aufgetreten");
    }    
  }  
}

Ausgabe sieht dann aus wie folgt:

[Bild: ausgabe.png]

Edit:

So, nochmal neu...

In der main-Methode läuft eine endlos-Schleife, die immer wieder die Funktion "programm()" (-1-) aufruft.

In der Funktion programm() läuft ebenfalls eine Endlosschleife (-2-). In dieser Schleife wirst du aufgefordert, eine Eingabe zu tätigen (-3-).

Die Switch-Case-Anweisung (-4-) prüft deine Eingabe, und handelt entsprechend. Ist die Eingabe "n", so passiert gar nichts und die Schleife läuft weiter.
Gibst du stattdessen "j" ein, dann wird die Funktion durch den "return"-Befehl verlassen (-5-) und das Programm springt zurück zu dem Punkt, an dem die
Methode aufgerufen wurde, bzw hinter den Aufruf (-6-). Da du dich in einer Endlosschleife befindest, geht das ganze wieder bei -1- los, also quasi der geforderte Neustart.

Hast du irgendwann die Schnauze voll, dann kannst du auch eifnach "x" eingeben, und das Programm wird ganz beendet.

[Kellendil]

Hier noch eine einfachere, primitive Lösung (bei einem offensichtlichen Anfänger mit Klassen zu arbeiten ist denke ich mehr verwirrend als hilfreich, und Rekursion ist deutlich einfacher zu verstehen in diesem Fall):

public static void main(String args[])
{
    programMethod();
}

public static void programMethod() {

    Scanner scan2=new Scanner(System.in);
    System.out.println("Programm nochmal starten? [J/N]");
    String jaNein = scan2.next();

    if (jaNein.equalsIgnoreCase("j"))
    {
        programMethod();
    }
}

Langfristig, wenn du verstehst wie Methoden und Klassen funktionieren (und was Rekursion ist und wieso man es vorsichtig verwenden muss), ist dann aber die Lösung von Ewige Finsternis besser, auch wenn ich den Beenden case weggelassen hätte.

[Ewige Finsternis]

Hier noch eine einfachere, primitive Lösung (bei einem offensichtlichen Anfänger mit Klassen zu arbeiten ist denke ich mehr verwirrend als hilfreich, und Rekursion ist deutlich einfacher zu verstehen in diesem Fall):

Ja, stimmt. Ist immer ein wenig blöd, wenn man nicht weiß was jemand bereits kann. Bei mir waren Klassen damals eines der ersten Dinge die ich gelernt hab, aber jeder hat seine eigene Herangehensweise. In der Schule lernt man halt erst die grundlegenden Konzepte, bevor man zu interaktiven Programmen übergeht, das sieht beim Selbststudium natürlich ganz anders aus.

[...] auch wenn ich den Beenden case weggelassen hätte.

Naja, keine halben Sachen. Wenn man eine Endlosschleife verwendet sollte man aufpassen das man auch wieder rauskommt, sollte es nötig sein.

[Kellendil]

Ich denke, dass dein "Beenden" case das ist, was "Nein" bewirken sollte. Was genau Sinn macht hängt aber letztendlich vom Programminhalt/-ziel ab.

[Arythya]

Danke an euch zwei für die Antworten Hat mir sehr geholfen.
In meinem kleinen Programm, das ich geschrieben habe ging es darum eine zufällige Zahl zwischen 1 und 10 zu erraten, danach sollte man sich entscheiden können, ob man es noch mal versuchen möchte.
Hier der Code mit Kalendils Variante:

import java.util.Scanner;
class RatenJaNein
{

    public static void main(String [] args)
    {
    programMethod();
    }
        public static void programMethod() {

        int versuch;
        int zahl=(int)((Math.random())*10+1); 
        String jaNein; //char oder String??
        Scanner scan=new Scanner(System.in);

        System.out.println("Ich denke mir eine zufällige Zahl zwischen 1 und 10, versuche zu erraten, welche");
        versuch=scan.nextInt(); 
             if (versuch==zahl)
            {
            System.out.println("Du hast richtig geraten!");
            }
            else
            {
            System.out.println("Falsch geraten. Die Zahl an die ich dachte war :"+zahl);
            }

        System.out.println("Möchtest du es nochmal probieren? [J/N]");
        Scanner scan2=new Scanner(System.in);
        jaNein=scan2.next();

            if (jaNein.equalsIgnoreCase("j"))        
            {                                                    
            programMethod();
            }
    }
}

@Ewige Finsternis: Da ich noch ein kompletter Neuling bin, konnte ich die Hälfte deines Codes zwar nicht verstehen, ich habe aber trotzdem versucht mein Programm da irgendwie reinzubekommen. Hoffentlich ist das alles richtig, zumindest macht das Programm das, was es soll.
Hier der Code:

import java.io.*;
import java.util.Scanner;

public class Test
{
  BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
  
  public static void main(String args[])
  {
    Test t = new Test();
    
    while(true)
    {
      // -1-
      t.programm();
      // -6-
    }
  }  
  
  public void programm()
  {
    // -2-
    try
    {
        int versuch;
        int zahl=(int)((Math.random())*10+1);
        System.out.println("Programm wird gestartet...");
        Scanner scan=new Scanner(System.in);

        System.out.println("Ich denke mir eine zufällige Zahl zwischen 1 und 10, versuche zu erraten, welche");
        versuch=scan.nextInt();    
                                            
        if (versuch==zahl)
            {
            System.out.println("Du hast richtig geraten!");
            }
        else
            {
            System.out.println("Falsch geraten. Die Zahl an die ich dachte war :"+zahl);
            }

      while(true)
      {
        System.out.println("Programm neu starten?");
        System.out.println("j = JA, n = NEIN, x = BEENDEN");
        String eingabe = input.readLine(); // -3-
        
        switch(eingabe) // -4-
        {
          case "j":
            System.out.println("Sie haben sich für JA entschieden! :)\n");
            return; // -5-
          case "n":
            System.out.println("Sie haben sich für NEIN entschieden! :(\n");
            break;
          case "x":
            System.out.println("Sie haben sich entschieden keine Entscheidung zu treffen..\n");
            System.exit(0);
          break; 
          default:
            System.out.println("Ihre Eingabe '"+eingabe+"' ist ungueltig!\n");                    
        }
      }
    }      
    catch(Exception e)
    {
      System.out.println("Fehler aufgetreten");
    }    
  }  
}

Bei meinem Programm reicht es aber auch aus, wenn "n" das Programm beendet

[Kellendil]

char vs String:
char ist ein primitiver/nativer Datentyp, String ist hingegen ein Objekttyp, weil "String" eine ganz normale Klasse ist.
Vorteil von char (bzw. prim. Datentypen im allgemeinen): möglicherweise etwas bessere performance, weniger Speicherverbrauch
Vorteil von String: Du kannst das Program besser umstellen, wenn du später mal nicht einzelne Buchstaben verwenden willst, sondern z.B. Wörter. Außerdem gibt es eine ganze Reihe nützlicher Funktionen wie "equalsIgnoreCase()" (vergleicht 2 Strings, ignoriert aber Groß-/Kleinschreibung) sowie Bibltiotheken für String.

Bei einer Aufgabe wie deiner würde ich persönlich immer String nehmen, char geht aber theoretisch auch. Mit "scanner.nextChar()" müsstest du einen char auslesen können glaube ich.


Nachteile meiner Implementierung:

Wenn ein Methodenaufruf in deinem Code steht, wird die aufgerufene (=innere) Methode ausgeführt, bis sie fertig ist, und dann wird (falls vorhanden), der restliche Code nach dem Methodenaufruf in der aüßeren Methode ausgeführt.
z.B folgender Code (die Zahlen sind irgendwelcher anderer code):

public void outerMethod() {
    //1
    innerMethod();
    //5
}
public void innerMethod() {
    //2
    innerMethod2();
    //4
}
public void innerMethod2() {
    //3
}

wird so ausgeführt, die Zahlen beschreiben die Reihenfolge:

outerMethod {
    //1
    innerMethod {
        //2
        innerMethod2 {
            //3
       }
        //4
    }
    //5
}

D.h.
Immer wenn eine Methode sich selbst aufruft (= Rekursive Lösung), geht die Ausführung quasi eine Level nach innen, und wenn die innerste Ausführung fertig ist, wieder bis zur äußersten. Es gibt eine maximale Verschachtelung (wenn der callstack voll ist), und dann stürzt das Programm ab. Das passiert glaub ich nach ein paar hunderttausend Aufrufen. Man könnte also nicht beliebig oft "nochmal probieren".
Außerdem belegen die Variablen der Methode auf jedem Level erneut Speicher, d.h, wenn du das Programm 10 mal wiederholst, gibt es bei der letzen Wiederholung 10 mal "new Scanner" im Speicher. Deswegen sollte man bei Rekursion die Variable außerhalb der Wiederholung anlegen und wiederbenutzen (mit Methodenargumenten).
Mit einer while-Schleife kannst du dieses Problem auch umgehen (= Iterative Lösung)...



Eine einfache iterative Lösung:

public static void main(String args[])
{
    boolean nochmal = true;
    while (nochmal) {
        //programm
        Scanner scan2=new Scanner(System.in);
        System.out.println("Programm nochmal starten? [J/N]");
        String jaNein = scan2.next();
        nochmal = jaNein.equalsIgnoreCase("j");
    }
}

[Drachentöter]

Die Codes sehen soweit schonmal richtig aus, ich hätte dabei noch eine Anmerkung, die das Arbeiten mit Zufallszahlen in Java erheblich erleichtern sollte. Die Bibliotheksklasse java.util.Random stellt uA die Funktion nextInt zur Verfügung, die zufällige Integer zwischen 0 (inklusive) und einer festen Zahl exklusive ausgibt

import java.util.Scanner;
import java.util.Random;

class RatenJaNein
{

private static Random zufall; //Damit nicht immer neues Randomobjekt erzeugt werden muss

    public static void main(String [] args)
    {
zufall = new Random();
    programMethod();
    }
        public static void programMethod() {

        int versuch;
        int zahl= zufall.nextInt(10) + 1; 
        String jaNein; //char oder String??
        Scanner scan=new Scanner(System.in);

        System.out.println("Ich denke mir eine zufällige Zahl zwischen 1 und 10, versuche zu erraten, welche");
        versuch=scan.nextInt(); 
             if (versuch==zahl)
            {
            System.out.println("Du hast richtig geraten!");
            }
            else
            {
            System.out.println("Falsch geraten. Die Zahl an die ich dachte war :"+zahl);
            }

        System.out.println("Möchtest du es nochmal probieren? [J/N]");
        Scanner scan2=new Scanner(System.in);
        jaNein=scan2.next();

            if (jaNein.equalsIgnoreCase("j"))        
            {                                                    
            programMethod();
            }
    } }

Das Ganze ist zwar noch nicht so schön gelöst, statische Objekte sollten nach Möglichkeit vermieden werden, aber als Anfänger musst du dies wohl nicht beachten.

[Arythya]

Bei einer Aufgabe wie deiner würde ich persönlich immer String nehmen, char geht aber theoretisch auch. Mit "scanner.nextChar()" müsstest du einen char auslesen können glaube ich.

Danke für diese ausführliche Erklärung!
Leider ist das nicht möglich es gibt nämlich keinen Befehl, um einen einzelnen Char auszulesen (zumindest habe ich keinen finden können), stattdessen habe ich es so versucht:

String eingabe;
char jaNein;

Scanner scan2=new Scanner(System.in);
eingabe=scan2.next();
jaNein=eingabe.charAt(0);

Nachteil dabei ist jetzt, dass wir statt einem String zusätzlich noch ein Char haben, also wird noch mehr Speicher verbraucht. Die Lösung mit String ist also wohl die beste (für mich realisierbare).

D.h.
Eine einfache iterative Lösung:

public static void main(String args[])
{
    boolean nochmal = true;
    while (nochmal) {
        //programm
        Scanner scan2=new Scanner(System.in);
        System.out.println("Programm nochmal starten? [J/N]");
        String jaNein = scan2.next();
        nochmal = jaNein.equalsIgnoreCase("j");
    }
}

Die Codes sehen soweit schonmal richtig aus, ich hätte dabei noch eine Anmerkung, die das Arbeiten mit Zufallszahlen in Java erheblich erleichtern sollte. Die Bibliotheksklasse java.util.Random stellt uA die Funktion nextInt zur Verfügung, die zufällige Integer zwischen 0 (inklusive) und einer festen Zahl exklusive ausgibt

import java.util.Scanner;
import java.util.Random;

class RatenJaNein
{

private static Random zufall; //Damit nicht immer neues Randomobjekt erzeugt werden muss

    public static void main(String [] args)
    {
zufall = new Random();
    programMethod();
    }
        public static void programMethod() {

        int versuch;
        int zahl= zufall.nextInt(10) + 1; 
        String jaNein; //char oder String??
        Scanner scan=new Scanner(System.in);

        System.out.println("Ich denke mir eine zufällige Zahl zwischen 1 und 10, versuche zu erraten, welche");
        versuch=scan.nextInt(); 
             if (versuch==zahl)
            {
            System.out.println("Du hast richtig geraten!");
            }
            else
            {
            System.out.println("Falsch geraten. Die Zahl an die ich dachte war :"+zahl);
            }

        System.out.println("Möchtest du es nochmal probieren? [J/N]");
        Scanner scan2=new Scanner(System.in);
        jaNein=scan2.next();

            if (jaNein.equalsIgnoreCase("j"))        
            {                                                    
            programMethod();
            }
    } }

Das Ganze ist zwar noch nicht so schön gelöst, statische Objekte sollten nach Möglichkeit vermieden werden, aber als Anfänger musst du dies wohl nicht beachten.

Ich habe die beiden Lösungsvorschläge mal kombiniert und bin dazu gekommen:

import java.util.Scanner;
import java.util.Random;

class RatenJaNeinNeu {

private static Random zufall;

public static void main(String args[])
{
     zufall = new Random();
     int versuch;
    
    boolean nochmal = true;
    while (nochmal) {
          
        System.out.println("Programm wird gestartet...");
        Scanner scan=new Scanner(System.in);
          int zahl = zufall.nextInt(10)+1;
        System.out.println("Ich denke mir eine zufällige Zahl zwischen 1 und 10, versuche zu erraten, welche");
        versuch=scan.nextInt();    
                                            
        if (versuch==zahl)
            {
            System.out.println("Du hast richtig geraten!");
            }
        else
            {
            System.out.println("Falsch geraten. Die Zahl an die ich dachte war :"+zahl);
            }
        Scanner scan2=new Scanner(System.in);
        System.out.println("Programm nochmal starten? [J/N]");
        String jaNein = scan2.next();
        nochmal = jaNein.equalsIgnoreCase("j");
        }
    }
}

[Kellendil]

Also ein einzelner char ist für den Speicherverbrauch egal (da gibts erst messbare Unterschiede, wenn du tausende Strings/chars im Speicher liegen), aber es stimmt, dass char dann unsinnig ist, wenn du ehh schon nen String hast.

Deine Lösung sieht doch schon ganz gut aus (habs aber nicht getestet), folgendes könnte man noch ändern: Du kannst immer das gleiche Scanner Objekt nehmen fürs Auslesen. Die Objekterzeugung ("new Scanner(...)") könntest du auch außerhalb der while Schleife machen für mehr Performance, dann muss nicht jedesmal ein neuer Scanner erstellt werden, wenn das Programm neu gestartet wird.

[Arythya]

Habe das ganze nocheinmal etwas verbessert, alles läuft genauso wie es soll.

Spoiler:(zum lesen bitte Text markieren)

import java.util.Scanner;
import java.util.Random;

class RatenJaNeinNeu {

private static Random zufall;

public static void main(String args[])
{
     zufall = new Random();
     int versuch;
    Scanner scan=new Scanner(System.in);
    
    boolean nochmal = true;
    while (nochmal) {
          
        System.out.println("Programm wird gestartet...");

          int zahl = zufall.nextInt(10)+1;
        System.out.println("Ich denke mir eine zufällige Zahl zwischen 1 und 10, versuche zu erraten, welche");
        versuch=scan.nextInt();    
                                            
        if (versuch==zahl)
            {
            System.out.println("Du hast richtig geraten!");
            }
        else
            {
            System.out.println("Falsch geraten. Die Zahl an die ich dachte war :"+zahl);
            }
        System.out.println("Programm nochmal starten? [J/N]");
        String jaNein = scan.next();
        nochmal = jaNein.equalsIgnoreCase("j");
        }
    }
}

Ich habe mich mal an etwas komplizierteres herangewagt und zwar an ein Programm, das die Lösung von quadratischen Gleichungen berechnen kann (auch mit der Möglichkeit das Programm erneut zu starten)

Spoiler:(zum lesen bitte Text markieren)

import java.util.Scanner;

class QuadrGleichung{

 public static void main(String[] args)
    {
     boolean nochmal = true;
     while (nochmal) {

        Scanner scan1=new Scanner(System.in);
        float a, b, c, diskriminante, n1, n2;
        System.out.println("Gib zuerst a an: ");
        a=scan1.nextFloat();
        System.out.println("b=");
        b=scan1.nextFloat();
        System.out.println("c=");
        c=scan1.nextFloat();
        diskriminante=b*b-4*a*c;

            if (diskriminante>0)
                {
                System.out.println("Es gibt 2 Nullstellen N1 = " + ((-b+(Math.sqrt(diskriminante)))/(2*a)) + " und N2 = " + ((-b-(Math.sqrt(diskriminante)))/(2*a)));
                }            
            else if (diskriminante==0)
                {                
                System.out.println("Es gibt eine Nullstelle N1 = " + (2*(-b)/(2*a)));
                }
            else
                {                
                System.out.println("Es gibt keine Nullstellen");
                }

        System.out.println("Möchtest du noch eine Quadratische Gleichung berechnen lassen? [J/N]");
        String jaNein = scan1.next();
        nochmal = jaNein.equalsIgnoreCase("j");
        
        }
        
    }
}