Erste Schritte Probleme beim Verknüpfen von Methoden

[Marc14]

Hallo, ich bin erst ein Java Anfänger und habe mir selbst vorgenommen ein kleines eigenes Programm zu schreiben. Jedoch komme ich immer an der selben Stelle nicht weiter und ich hoffe sehr das ihr mir dort helfen könnt.



In Zeile 9 steht folgendes: String eingabe =JOptionPane.showInputDialog(null, "Nenne ein Element mit der Ordnungszahl "+augenzahl);
Und in Zeile 11 versuche ich das Programm so zu programmieren das wenn man in Zeile 9 dann das Element mit der Ordnungszahl eingibt, die davor Random ausgesucht wurde, dass das Eingegebene (also in dem Fall Gold) durch eine if Schleife erfasst wird und dann "Gut gemacht" ausgegeben wird. Und dann werde ich noch weitere Elemente hinzufügen und das gleiche mit ihnen machen.
Also noch mal als Beispiel: Wenn als Ordnungszahl 3 ausgelost wird, wäre das dazu passende Element Lithium. Und wenn jemand dann Lithium eingibt soll auf dem Bildschirm erscheinen "Gut gemacht". Aber das soll jeweils nur für 1 zutreffen also wenn man als Ordnungszahl 1 hat soll man Wasserstoff eingeben und wenn jemand dann zum Beispiel Lithium eingibt soll da stehen "Das war leider Falsch".
Aber ich habe leider keine Ahnung wie ich es machen soll und da es sehr speziefisch ist findet man dazu leider auch keine Lösung im Internet. Ich wäre sehr dankbar für eine Lösung meines Problems da dies schon bei mehrern Versuchen schief gegangen ist.
Entschuldigung falls ich irgendwo einen Schreibfehler oder Ausdrucksfehler gemacht habe.
LG Marc

 

[Bitfehler]

Hallo,

1. Bitte vergleiche deine Strings mit Hilfe von equals
2. Wenn ich das richtig verstanden habe, dann brauchst du erstmal eine Datenstruktur, in der du die Ordnungszahl einem Element zuordnest. Sonst wird es mit der Prüfung schwer, ob das eingegebene Elemente und die Ordnungszahl zusammenfassen. Wenn du diese Datenstruktur hast, kannst du sie durchsuchen, ob die beiden Elemente des Paars zusammenpassen und anschließend eine Nachricht ausgeben lassen.

 

[Marc14]

Vielen Dank für das schnelle Feedback ich habe nun erstmal eine kleine Datenbank erstellt.

public class Element {
String name;
int ordnungszahl;

public Element(String name, int ordnungszahl){ 
    Element element1 = new Element("Wasserstoff", 1);
    Element element2 = new Element("Helium", 2);
    Element element3=new Element("Lithium", 3);
}
}

1.Frage kann man das so machen?
2.Frage falls es so geht wie kann ich es dann hiermit verknüpfen: ?

    Random würfel = new Random();
    int augenzahl;
    for(int i = 0; i<1; i++){
    augenzahl = 1+ würfel.nextInt(3);
    String eingabe =JOptionPane.showInputDialog(null, "Nenne ein Element mit der Ordnungszahl "+augenzahl);
 
    if(eingabe==""){
    JOptionPane.showMessageDialog(null, "Gut gemacht");
    }
    }
}
}

Ich bedanke mich rechtherzlich für alle hilfreichen Antworten.
LG Marc

 

[Bitfehler]

Deine Elemente müsstest du dann noch in eine Liste, Set oder ähnliches werfen. Oder du verwendest eine HashMap. Eine Hashmap ist eine Datenstruktur besteht aus einem Schlüssel und einem Wert. Als Schlüssel könnte ich mir die Ordnungszahl vorstellen und der Werte wäre dann der Name des Elementes.
Beispiel:

HashMap<Integer, String> hmap = new HashMap<Integer, String>();

hmap.put(1, "Wasserstoff");

Mit String element= hmap.get(ordnungszahl); bekommst du dann den Namen eines Element aus der Map. Diesen kannst du mit deiner Eingabe vergleiche und etwas ausgeben:

if(element.equals(eingabe)){
//Übereinstimmung
} else{
//keine Übereinstimmung
}

 

[Blender3D]

Habe einst vor Jahren auf der Uni auch ein Programm zum einlesen der Elemente geschrieben.
Vielleicht kannst Du damit etwas anfangen.
Das Programm liest aus einer Datei alle Elemente mit dein Eigenschaften:
Elementname, Symbol, Ordnungszahl, atomare Masse, Dichte, Schmelzpunkt, Siedepunk, entdeckt im Jahr und Entdecker ein.

benötigte Klassen: ElementReader und Element. und die Datei Elemente.txt

public class Element implements Comparable<Element> {
    private String name;// Elementname
    private String symbol;// Symbol
    private int atomicNumber;// Ordnungszahl
    private double atomicMass;// atomare Masse
    private double density;// Dichte
    private double meltingPoint;// Schmelzpunkt
    private double boilingPoint;// Siedepunkt
    private String discovered;// entdeckt im Jahr
    private String discoverer;// Entdecker

    public Element(String name, String symbol, int atomicNumber) {
        this.atomicNumber = atomicNumber;
        this.name = name;
        this.symbol = symbol;
    }

    @Override
    public int compareTo(Element o) {
        // TODO Auto-generated method stub
        return 0;
    }

    public double getAtomicMass() {
        return atomicMass;
    }

    public int getAtomicNumber() {
        return atomicNumber;
    }

    public double getBoilingPoint() {
        return boilingPoint;
    }

    public double getDensity() {
        return density;
    }

    public String getDiscovered() {
        return discovered;
    }

    public String getDiscoverer() {
        return discoverer;
    }

    public double getMeltingPoint() {
        return meltingPoint;
    }

    public String getName() {
        return name;
    }

    public String getSymbol() {
        return symbol;
    }

    public void setAtomicMass(double atomicMass) {
        this.atomicMass = atomicMass;
    }

    public void setBoilingPoint(double boilingPoint) {
        this.boilingPoint = boilingPoint;
    }

    public void setDensity(double density) {
        this.density = density;
    }

    public void setDiscoverer(String discoverer) {
        this.discoverer = discoverer;
    }

    public void setDiscovered(String dicovered) {
        this.discovered = dicovered;
    }

    public void setMeltingPoint(double meltingPoint) {
        this.meltingPoint = meltingPoint;
    }

    @Override
    public String toString() {
        return atomicNumber + "\t(" + symbol + ")\t" + name;
    }

}

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Vector;

public class ElementReader {
    private static Element builtElement(String line) {
        Element ret = null;
        if (line == null || line.length() < 10 || line.startsWith("#"))
            return null;
        line = line.trim();
        String[] values = line.split("\t");
        try {
            ret = new Element(values[0], values[1], Integer.parseInt(values[2].trim()));
        } catch (NumberFormatException e) {
            return null;
        }      
        for (int i = 3; i < 7; i++)
            ret.setAtomicMass(toDoubleValue(values[i]));
        ret.setDiscovered(values[7].trim());
        ret.setDiscoverer(values[8].trim());
        return ret;
    }

    public static Vector<Element> readElements(String file) {
        Vector<Element> elements = new Vector<Element>();
        FileInputStream fin = null;
        InputStreamReader in = null;
        BufferedReader br = null;
        try {
            fin = new FileInputStream(file);
            in = new InputStreamReader(fin);
            br = new BufferedReader(in);
            String line = null;
            while ((line = br.readLine()) != null) {
                Element e = builtElement(line);
                if (e != null)
                    elements.add(e);
            }
            br.close();
            in.close();
            fin.close();

        } catch (IOException e) {
            System.err.println("error at reading elements from " + file);
        }
        return elements;
    }

    private static double toDoubleValue(String value) {
        double ret = 0;
        try {
            ret = Double.parseDouble(value.trim().replace(',', '.'));
        } catch (NumberFormatException e) {
        }
        return ret;
    }

}

Mit diesem Code kannst Du die Klassen in der main ausprobieren.

    Vector< Element> elements = ElementReader.readElements("./elemente.txt");
        Iterator<Element> it = elements.iterator();
        while( it.hasNext() )
            System.out.println(it.next());

Vielleicht hilft es Dir

 

[Blender3D]

for (int i = 3; i < 7; i++)
ret.setAtomicMass(toDoubleValue(values));

Sehe gerade, da hatte sich damals ein Fehler eingeschlichen. Die Schleife passt da nicht, da die Setter Methoden explizit aufgerufen werden müssen. Sollte für Dich aber kein Problem sein, das zu ändern.

 

[kneitzel]

Da es noch keine wirkliche Rückmeldung zu Deiner Element Klasse gab:

public class Element {

  // Das ist soweit ok, aber Du solltest diese entweder public machen (schlecht) oder private und dafür dann Getter und ggf. Setter hinzufügen. 
  String name;
  int ordnungszahl;

  // Ein Construktor - das ist gut!
  public Element(String name, int ordnungszahl){
    // Hier wird eine neue Instanz initialisiert. Also den Instanzvariablen musst Du die Parameter zuweisen:
    this.name = name;
    this.ordnungszahl = ordnungszahl;

    // Die folgenden Aufrufe erstellen lokale Variablen, die Du ausserhalb der Funktion nicht hättest.
    // Schlimmer ist aber noch die Rekursion. Sobald Du einen Konstruktor von Element aufrufst, wird hier wieder ein Element erzeugt, das den Konstruktor aufruft u.s.w. - Also eine Endlosschleife, die dann abbricht, weil irgendwann der Stack voll ist oder der Speicher verbraucht ist.
//    Element element1 = new Element("Wasserstoff", 1);
//    Element element2 = new Element("Helium", 2);
//    Element element3=new Element("Lithium", 3);
  }

  // Hier fügen wir mal eine Funktion zu, die ein Array mit Elementen erstellt und zurück gibt um zu zeigen, wie dies aussehen könnte.
  public Element[] getElements() {
    Element[] elements = new Element[3];
    elements[0] = new Element("Wasserstoff", 1);
    elements[1] = new Element("Helium", 2);
    elements[2]=new Element("Lithium", 3);
    return elements;
  }

}

 

[Marc14]

Ich danke euch allen das ihr euch so viel Zeit genommen habt. Ich habe eine HashMap erstellt und in ihr die Elemente sowie die Ordnungszahl gespeichert. Und sie dann später mithilfe von equals getestet und es klappt perfekt.
1 Problem habe ich aber noch undzwar gibt er immer etwas aus wenn man das richtige Element eingegeben habe aber danach ist Schluss und ich hatte die Idee mit einem Return Befehl zurück an die Stelle

String eingabe =JOptionPane.showInputDialog(null, "Nenne ein Element mit der Ordnungszahl " +augenzahl);

zu kommen damit das Programm wieder erneut fragt und man dann wieder das Element eingibt und wieder Das ist korrekt oder das ist richtig usw. da steht .
So sieht der Code bist jetzt aus :

LG Marc

 

[Joose]

Bei deiner Überprüfung auf die richtige Antwort machst du es wieder unnötig kompliziert
Anstatt für jedes Element eine eigene "richtig" Antwort zu verwenden solltest du bei einer bleiben und fertig. Und statt "hmap.get(1)" verwendest du einfach "hmap.get(augenzahl)".

Und damit sich der Code wiederholen kann solltest du eine Schleife verwenden.

 

[Marc14]

OK danke sehr, das ist sehr hilfreich.
Du sagtest ich solle eine Schleife verwenden aber ich habe keine Ahnung wie diese Schleife aufgebaut werden soll. Entschuldigung aber ich habe wirklich lange daran gesessen und bei den Tutorials oder Büchern wird nur angezeigt wie man eine Schleife macht, das kann ich aber wie ich sie in diesem Fall machen soll damit sie sich wiederholt habe ich wirklich keine Ahnung.
Kannst du da vielleicht helfen oder einen Tipp geben?
LG Marc

 

[mrBrown]

Du hast die Schleife doch schon drin, nur läuft sie aktuell nur einmal durch.

for(int i=0; i<1;i++ ) {
...
}

änder da mal die 1 in etwas anderes

 

[Joose]

Kannst du da vielleicht helfen oder einen Tipp geben?

Tatsächlich hast du schon eine Schleife in Verwendung. Glatt übersehen ... hierzu gleich ein Hinweis: Achte bei deinem Code auf eine korrekte Einrückung Das erleichert dir und anderen das Code lesen
Und statt Screenshots von deinem Code zu posten verwende doch einfach die Code-Tags um schön formatierten Code zu posten: [java] .. dein code .. [/java]

 

[Marc14]

Hallo vielen Dank erstmal an alle die mir geholfen haben, ich habe allerdings noch eine kleine Frage. Undzwar

import java.util.*;
import java.lang.*;
import javax.swing.JOptionPane;

public class Element {
   public static void main(String[] args) {
     HashMap<Integer, String> hmap = new HashMap<Integer, String>();
     hmap.put(1, "Wasserstoff");
     hmap.put(2, "Helium");
     hmap.put(3, "Lithium");
     hmap.put(4, "Beryllium");
     
     Random würfel = new Random();
     int augenzahl;
     for(int i = 0; i<1;i++ ) {
       augenzahl = 1+ würfel.nextInt(4);
       String eingabe =JOptionPane.showInputDialog(null, "Nenne ein Element mit der Ordnungszahl "+augenzahl);
       if(hmap.get(1).equals(eingabe)) {
         JOptionPane.showMessageDialog(null, "Das ist korrekt");
       } else if(hmap.get(2).equals(eingabe)) {
         JOptionPane.showMessageDialog(null, "Das ist richtig");
       } else if(hmap.get(3).equals(eingabe)) {
         JOptionPane.showMessageDialog(null, "Sehr gut");
       } else if(hmap.get(4).equals(eingabe)) {
         JOptionPane.showMessageDialog(null, "Ultra gut");
       } else {
         JOptionPane.showMessageDialog(null, "Starte bitte eine neue Runde");
       }
     }
   }
}

Meine Frage ist ob es möglich ist das Programm so einzustellen, dass das Programm nur dann wieder von neuem beginnt wenn etwas richtiges eingegeben wurde. Und wenn etwas falsches eingegeben wurde wird nur die else Anweisung aufgerufen und es wird ausgegeben "Starte bitte eine neue Runde" und dann ist die Schleife vorbei. Und bei einer richtigen Antwort geht das Programm so lange bis etwas falsches eingegeben wurde.

Entschuldigung das ich so viel Fragen habe aber ich bin erst 14 und zu manchen Fragen gibt es einfach keine Antwort im Internet.Und damit bedanke ich mich an alle die mir trotzdem helfen. Das Programm ist nur für mich damit ich besser Java verstehe und lerne.

LG Marc

 

[mrBrown]

Meine Frage ist ob es möglich ist das Programm so einzustellen, dass das Programm nur dann wieder von neuem beginnt wenn etwas richtiges eingegeben wurde. Und wenn etwas falsches eingegeben wurde wird nur die else Anweisung aufgerufen und es wird ausgegeben "Starte bitte eine neue Runde" und dann ist die Schleife vorbei. Und bei einer richtigen Antwort geht das Programm so lange bis etwas falsches eingegeben wurde.

Ja, ist möglich. Allerdings wäre es besser, wenn du erstmal die bis jetzt schon genannten Vorschläge umsetzt. Die jetzige Codebasis funktioniert so noch gar nicht, wie sie sollte, es wir einmal nach dem Namen gefragt, und egal welches der 4 man dann eingibt, es ist immer richtig.

 

[Joose]

Bei deinem jetztigen Code ist es egal ob man richtig oder falsch antwortet. Laut dem Code soll die Schleife nur 1x durchlaufen werden.
Wenn du die Schleife solange laufen lassen willst wie eine richtige Antwort gegeben wird, dann musst du dafür sorgen das bei einer richtigen Antwort die Bedingung beim nächsten Schleifendurchlauf passt. (in deinem Fall wäre da die Bedingung "i<1")

Anmerkung: Da du hier eine Schleife haben willst die eine unbekannte Anzahl an Durchläufen hat würde ich zu einer while-Schleife (bzw. do-while Schleife raten).

 

[Marc14]

Oh danke du hast Recht das ist mir noch garnicht aufgefallen.
Ich habe nun folgendes gemacht:

import java.util.*;
import java.lang.*;
import javax.swing.JOptionPane;
public class Element {
public static void main(String[] args) {
        int score = 0;
HashMap<Integer, String> hmap = new HashMap<Integer, String>();
hmap.put(1, "Wasserstoff");
hmap.put(2, "Helium");
hmap.put(3, "Lithium");
hmap.put(4, "Beryllium");
Random würfel = new Random();
int augenzahl;
for(int i = 0; i<4;i++,score++ ){
    System.out.println("Du hast : "+score+ " Punkte");
augenzahl = 1+ würfel.nextInt(4);
String eingabe =JOptionPane.showInputDialog(null, "Nenne ein Element mit der Ordnungszahl "+augenzahl);
if(hmap.get(augenzahl).equals(eingabe)){
    JOptionPane.showMessageDialog(null, "Das ist korrekt");
}else{
    JOptionPane.showMessageDialog(null, "Starte bitte eine neue Runde");
    break;

}
}
}
}

So habe alles was ich wollte, Danke schön an das ganze Forum.