Taschenrechner mit mehr als 2 Zahlen.

Johannes73

Mitglied
Hallo. Es soll ein Taschenrechner für die Konsole programmiert werden, der mit mehr als 2 Zahlen rechnet. Ein bsp. für die Eingabe wäre: 6 + 3 * 8 - 2
Ich habe mir überlegt die Eingabe mittels eines Scanners in einer ArrayList zu speichern. Es soll überprüft werden wann ein Operator vorhanden ist. Dann sollen die Zahlen vor und nach dem Operator entsprechend gerechnet werden. Ich möchte danach die Zahlen aus meiner Liste entfernen, da ich sie ja nicht mehr brauche und stattdessen mein Zwischenergebnis wieder einfügen. Nur irgendwie klappt das so nicht ganz. Gebe ich z.B. 6 + 3 + 5 + 5 = ein, erhalte ich 9 + 19. irgendwie stimmt da was nicht. Davon mal abgesehen habe ich Punkt vor Strich nicht beachtet, auch hier weiß ich nicht weiter. Bitte flamed mich nicht, dass alles in der Main Methode steht. Ich möchte das ganze objektorientiert angehen, jedoch erst, wenn mein Taschenrechner an sich funktioniert. Ich lerne Java jetzt erst seit einem Monat, bitte berücksichtigt das.

Code:
import java.util.ArrayList;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

        double ergebnis = 0;

        Scanner sc = new Scanner(System.in);

        ArrayList<String> zahlen = new ArrayList<String>();

        while (true) {
            String eingabe = sc.next();
            if (eingabe.equalsIgnoreCase("=")) {
                break;
            }
            zahlen.add(eingabe);
        }

        for (int i = 0; i < zahlen.size(); i++) {

                switch(zahlen.get(i)){
                    case "+":
                        double x = Double.parseDouble(zahlen.get(i-1));
                        double y = Double.parseDouble(zahlen.get(i+1));
                        ergebnis = ergebnis + x + y;
                        zahlen.remove(i+1);
                        zahlen.remove(i);
                        zahlen.remove(i-1);
                        // Methode in Utils
                        String stringErgebnis = String.valueOf(ergebnis);
                        zahlen.add(i-1, stringErgebnis);

                        break;
                    case "-":
                         x = Double.parseDouble(zahlen.get(i-1));
                         y = Double.parseDouble(zahlen.get(i+1));
                        ergebnis = ergebnis + x - y;
                        zahlen.remove(i+1);
                        zahlen.remove(i);
                        zahlen.remove(i-1);
                        // Methode in Utils
                        stringErgebnis = String.valueOf(ergebnis);
                        zahlen.add(i-1, stringErgebnis);
                        break;
                    case "*":
                         x = Double.parseDouble(zahlen.get(i-1));
                         y = Double.parseDouble(zahlen.get(i+1));
                        ergebnis = ergebnis + x * y;
                        zahlen.remove(i+1);
                        zahlen.remove(i);
                        zahlen.remove(i-1);
                        // Methode in Utils
                         stringErgebnis = String.valueOf(ergebnis);
                        zahlen.add(i-1, stringErgebnis);
                    case "/":
                         x = Double.parseDouble(zahlen.get(i-1));
                         y = Double.parseDouble(zahlen.get(i+1));
                        ergebnis = ergebnis + x / y;
                        zahlen.remove(i+1);
                        zahlen.remove(i);
                        zahlen.remove(i-1);
                        // Methode in Utils
                         stringErgebnis = String.valueOf(ergebnis);
                        zahlen.add(i-1, stringErgebnis);

                }
            }
        System.out.println(zahlen);
        }
    }
 

KonradN

Super-Moderator
Mitarbeiter
Dein Vorgehen mit der äußeren Schleife ist etwas dubios.

a) Du gehst von 0 durch .... also erst nimmst Du die Zahl, die ist aber dann keine Rechenart. Daher machst Du nichts ... Das ist erst einmal vom Ablauf her unschön, aber würde prinzipiell funktionieren

b) Du gehst von 0 bis Size - aber die size ändert sich. Das ist der Grund, wieso er dann auch abbricht.

Daher ist immer wichtig, dass man genau beschreibt, was Du überhaupt implementieren willst.

Nehmen wir einfach eine Ausführung von Links nach Rechts (also kein Punkt vor Strich) - dann wäre erst einmal die Frage: Wie lange musst Du rechnen? Die Antwort ist doch einfach: So lange, wie da nicht einfach eine Zahl steht. So in der Art.

Und dann das Vorgehen genau beschreiben. Was machst Du?
  • Du entnimmst die ersten drei elemente
  • Du berechnest
  • Das Ergebnis packst Du ganz an den Anfang.

Und wenn man es so beschrieben hat, dann kann man dies auch umsetzen.

Mit Punkt vor Strich Rechnung wird es etwas schwerer. Der Vorrang wird deutlich, wenn man es als Baumstruktur darstellt. Nehmen wir einfach einmal eine Berechnung a.la. 1 + 2 * 3.

Zuerst kommt das * dann das +. Als Baum wäre das also erst ein Teilbaum mit * in dem Knoten aund 2 bzw. 3 in den Blättern. Und der ganze Baum hat als root das + im Knoten und die 1 bzw den Teilbaum mit dem * als Abzweige.

Die Berechnung wäre dann also einfach immer Wert linker Knoten Operation Wert rechter Knoten.

Da kannst Du Dir dann ja mal überlegen, wie Du so einen Baum aufbauen kannst.
 

Neumi5694

Top Contributor
Perfektes Beispiel, um per Debugger das Ganze durchzusteppen und dir die jeweilige Liste anzeigen zu lassen,
Vorweg, dein i sollte bei 1 starten, sonst kriegst du für i = 0 und einem Operator an der ersten Stelle eine IndexOutOfBounds Exception.
Zweitens, anstatt
Code:
zahlen.remove(i-1);
zahlen.add(i-1,...);

geht auch
Java:
zahlen.set(i-1, ...);
in einem Schritt, liest sich etwas besser und die Liste wird weniger oft rumgeschoben

Dein Problem: Du nimmst immer vorne Zahlen weg, zählst aber trotzdem weiter.
Du solltest Index immer auf 1 lassen.
 

Neumi5694

Top Contributor
Damit das hier funktioniert, musst du immer den Operator an Index 1 auswerten.
6+3+5+5=
9+5+5=
14+5=
19=


Punkt vor Strich ist nochmal ein anderes Thema. Hier ignorierst du erst mal alle + und -.
Dafür brauchst du tatsächlich einen Zähler, der sich ändert, wenn ein + oder ein - gefunden wurde und gleich bleibt, falls ein / oder * gefunden wurde.

Richtig wäre hier ein ordentlicher Parser, aber da bist du noch lange nicht so weit.
 

KonradN

Super-Moderator
Mitarbeiter
Richtig wäre hier ein ordentlicher Parser, aber da bist du noch lange nicht so weit.
Das ist ja noch nicht wirklich kompliziert - das kann man über einen einfachen Baum abhandeln. Das Vorgehen hätte ich fast beschrieben, aber das kann man sich ja selbst überlegen daher hatte ich es weggelassen. Aber wie gesagt: Vom Aufbau sehr simpel und gradlinig.
 

Neumi5694

Top Contributor
Kleiner Tip zum Debuggen. Da du ja weißt, dass deine Eingabe funktioniert, kannst du die Eingabe auch simulieren, etwa so (ist natürlich nur für einstellige Zahlen geeignet):
Java:
        var list = new ArrayList<String>();
        for (var c : "6+3+5+5=".toCharArray()) {
            list.add("" + c);
        }
Das spart etwas Zeit und du musst nicht jedesmal alles neu eingeben.
 

Johannes73

Mitglied
Damit das hier funktioniert, musst du immer den Operator an Index 1 auswerten.
6+3+5+5=
9+5+5=
14+5=
19=


Punkt vor Strich ist nochmal ein anderes Thema. Hier ignorierst du erst mal alle + und -.
Dafür brauchst du tatsächlich einen Zähler, der sich ändert, wenn ein + oder ein - gefunden wurde und gleich bleibt, falls ein / oder * gefunden wurde.

Richtig wäre hier ein ordentlicher Parser, aber da bist du noch lange nicht so weit.
Okay das macht wirklich Sinn und ist mir noch nicht aufgefallen, dass ich jedes Mal die Liste in ihrer Länge kürze und somit nicht alles berechnen kann. Immer die ersten 3 Stellen der Liste zu nehmen erscheint logisch. Also ich habe meine for Schleife jetzt folgender Maßen umgeändert.
Java:
for (int i = 1; i < zahlen.size();)
Da erhalte ich jetzt 51 als Ergebnis. Schlussfolgerung, meine Schleife ist falsch
 

KonradN

Super-Moderator
Mitarbeiter
Ich verstehe ja, dass man gerne direkt Code schreiben will, aber die Erklärungen wurden ja gegeben und ich habe in WOrten auch beschrieben, wie es gehen würde. Es ist wirklich wichtig, dass man sich Algorithmen immer erst überlegt. Gerade am Anfang!

Die Schleife kann einfach sein: while (zahlen.size() > 1)

Und dann greifst Du immer aud die Elemente 0, 1 und 2 zu.
Diese löschst Du dann alle raus und packst an Stelle 0 das Ergebnis.

Bezüglich des Baums - das habe ich mal auf die Schnelle auch einmal aufgebaut: https://github.com/kneitzel/java-forum-algorithms/tree/master/src/main/java/de/kneitzel/rechner
(Da es eh nicht erarbeitet wird kann ich das für Andere auch direkt einmal posten)
 

Johannes73

Mitglied
Ich verstehe ja, dass man gerne direkt Code schreiben will, aber die Erklärungen wurden ja gegeben und ich habe in WOrten auch beschrieben, wie es gehen würde. Es ist wirklich wichtig, dass man sich Algorithmen immer erst überlegt. Gerade am Anfang!

Die Schleife kann einfach sein: while (zahlen.size() > 1)

Und dann greifst Du immer aud die Elemente 0, 1 und 2 zu.
Diese löschst Du dann alle raus und packst an Stelle 0 das Ergebnis.

Bezüglich des Baums - das habe ich mal auf die Schnelle auch einmal aufgebaut: https://github.com/kneitzel/java-forum-algorithms/tree/master/src/main/java/de/kneitzel/rechner
(Da es eh nicht erarbeitet wird kann ich das für Andere auch direkt einmal posten)
Es war wirklich nicht mein Ziel einen fertigen Taschenrechner gecodet zu bekommen. Ich muss es ja verstehen können. Trotzdem danke ich euch vielmals für die Hilfe
 

KonradN

Super-Moderator
Mitarbeiter
Es war wirklich nicht mein Ziel einen fertigen Taschenrechner gecodet zu bekommen. Ich muss es ja verstehen können. Trotzdem danke ich euch vielmals für die Hilfe
Das wollte ich Dir auch nicht unterstellen. Versuche erst einmal, dass Du das mit der Schleife hin bekommst. Da gab es ja sowohl von mir als auch von Neumi Hinweise zu.

Wenn Du schon etwas mit Klassen Interfaces gearbeitet hast und dir ein Baum als Datenstruktur etwas sagt, dann kannst Du im Anschluß als zweiten Schritt einmal überlegen, wie das laufen müsste, so einen Ausdruck in einen Baum zu überführen. Aber vermutlich hatte Neumi Recht, dass dies noch zu viel auf einmal war. (Dann wäre es evtl. eine schöne Übung, wenn Du später etwas weiter bist.)

Das Schöne ist, dass man sowas noch deutlich ausbauen könnte. Man könnte die Fakultät hinzu fügen. Oder die Möglichkeit, Klammern zu erlauben... Da kommt man aber ggf. dann doch in einen Bereich, bei dem es Sinn machen könnte, da einen separaten Parser einzuführen.

Das sind dann übrigens auch Dinge, bei denen wir gerne behilflich sind und Dinge erklären.
 

Johannes73

Mitglied
Das wollte ich Dir auch nicht unterstellen. Versuche erst einmal, dass Du das mit der Schleife hin bekommst. Da gab es ja sowohl von mir als auch von Neumi Hinweise zu.

Wenn Du schon etwas mit Klassen Interfaces gearbeitet hast und dir ein Baum als Datenstruktur etwas sagt, dann kannst Du im Anschluß als zweiten Schritt einmal überlegen, wie das laufen müsste, so einen Ausdruck in einen Baum zu überführen. Aber vermutlich hatte Neumi Recht, dass dies noch zu viel auf einmal war. (Dann wäre es evtl. eine schöne Übung, wenn Du später etwas weiter bist.)

Das Schöne ist, dass man sowas noch deutlich ausbauen könnte. Man könnte die Fakultät hinzu fügen. Oder die Möglichkeit, Klammern zu erlauben... Da kommt man aber ggf. dann doch in einen Bereich, bei dem es Sinn machen könnte, da einen separaten Parser einzuführen.

Das sind dann übrigens auch Dinge, bei denen wir gerne behilflich sind und Dinge erklären.
Also ich habe mich jetzt etwas in das Thema Bäume eingelesen, merke jedoch, dass ich da noch nicht ganz durchblicke. Schätze es ist einfach noch zu früh mit meinem Wissensstand. Gibt es denn noch andere Möglichkeiten diesen Taschenrechner mit den "Basics" zu realisieren?
 

KonradN

Super-Moderator
Mitarbeiter
Ja, Du kannst es auch ohne Bäume machen. Überlege Dir einfach, wie das Vorgehen ist.

Du hast z.B. "3 + 4 / 2 * 7 - 5"

Du hast Punkt vor Strich Rechnung - und bei mehreren Operatoren auf einer Ebene wird von links nach rechts berechnet.

Also schaust Du nach dem ersten Index von den Punkt-Rechenarten - also / und * hast Du den index.
Dann kannst Du den kleineren Index nehmen um die Rechnung zu machen ... also 4 / 2 -> 2 und du hast 3 + 2 * 7 - 5
Dann kommt das 2*7 so dass Du 3 + 14 - 5 hast
u.s.w.

Du hast ja alles schön in einer Liste, d.h. Du kannst da in der Liste nach den Operatoren gut suchen um dann den index mit -1 und +1 zu nutzen um die Zahlen zu bekommen ...
 

Johannes73

Mitglied
Ja, Du kannst es auch ohne Bäume machen. Überlege Dir einfach, wie das Vorgehen ist.

Du hast z.B. "3 + 4 / 2 * 7 - 5"

Du hast Punkt vor Strich Rechnung - und bei mehreren Operatoren auf einer Ebene wird von links nach rechts berechnet.

Also schaust Du nach dem ersten Index von den Punkt-Rechenarten - also / und * hast Du den index.
Dann kannst Du den kleineren Index nehmen um die Rechnung zu machen ... also 4 / 2 -> 2 und du hast 3 + 2 * 7 - 5
Dann kommt das 2*7 so dass Du 3 + 14 - 5 hast
u.s.w.

Du hast ja alles schön in einer Liste, d.h. Du kannst da in der Liste nach den Operatoren gut suchen um dann den index mit -1 und +1 zu nutzen um die Zahlen zu bekommen ...
Das klingt absolut logisch, nur leider habe ich keinen richtigen Ansatz, wie ich das als Code umsetzten kann. Ich hab es ja nicht mal hinbekommen meine Liste zusammen zu rechnen, ohne Punkt vor Strich zu beachten. Ich verzweifel gerade ehrlich gesagt ein wenig
 

Johannes73

Mitglied
Ich habe jetzt folgendes
Java:
while (zahlen.size() > 1){

   if (zahlen.contains("*") || zahlen.contains("/")){
Damit sag ich ja solange die Liste größer als 0 ist und wenn * bzw. / vorhanden sind. Ich weiß nur nicht, wie ich jetzt an die Stelle von dem Operator kommen soll.
 

KonradN

Super-Moderator
Mitarbeiter
Damit sag ich ja solange die Liste größer als 0 ist und wenn * bzw. / vorhanden sind. Ich weiß nur nicht, wie ich jetzt an die Stelle von dem Operator kommen soll.
Den Index kann man mit indexOf bekommen. Du kannst also zahlen.indexOf verwenden um den index von "*" und "/" zu bekommen.
-1 bedeutet dabei "nicht gefunden".

 

Johannes73

Mitglied
Den Index kann man mit indexOf bekommen. Du kannst also zahlen.indexOf verwenden um den index von "*" und "/" zu bekommen.
-1 bedeutet dabei "nicht gefunden".

Java:
 while (zahlen.size() > 1){

            if (zahlen.contains("*") || zahlen.contains("/")){
                int i = zahlen.indexOf("*");
                double x = Double.parseDouble(zahlen.get(i-1));
                double y = Double.parseDouble(zahlen.get(i+1));
                ergebnis = ergebnis + x * y;
                zahlen.remove(i+1);
                zahlen.remove(i);
                zahlen.remove(i-1);
                String stringErgebnis = String.valueOf(ergebnis);
                zahlen.add(i-1, stringErgebnis);
Also könnte man das o machen oder nicht? Wie würde ich es dann für / machen? Denn i hat ja nur den Index von *. Müsste ich dann einer neuen Variable den Index von / zuweisen und dasselbe auf mein Beispiel für 7 anwednen? Wobei mir da einfällt, dass es auch mehrere * Zeichen geben kann. Dann hätte ich ja nur den Index von dem ersten * Zeichen
 

KonradN

Super-Moderator
Mitarbeiter
Ja, die Bestandteile sind schon gut. Du musst nur aufpassen, denn es muss nicht sein, dass es ein * gibt. Du hast ja gefragt, ob es ein * oder / gibt um dann zu entscheiden, was zu tun ist.

Daher würde ich es etwas aufteilen in mehrere Methoden:

a) Was Du hast ist eine Methode die für einen Index eine Berechnung durchführt. Das wäre also schon fast komplett durch Deinen Code abgedeckt:

  • Du holst Dir die Zahlen
  • Neu: Du holst den Operator
  • Du berechnest das Ergebnis - Neu: in einem Switch ist das Abhängig vom Operator
  • Du entfernst die Elemente und packst das Ergebnis in die Liste.

b) Nun brauchst Du eine Methode, die nur den Index für die nächste Operation ermittelt. Das kann eine Methode sein, die eien Liste von möglichen Operatoren entgegen nimmt (Varargs).
  • Das Ergebnis ist erst einmal -1 (Operator nicht gefunden)
  • Dann gehst Du die Liste der Operatoren durch: Was ist der erste Index?
--> Wenn der gefundene Index nicht -1 ist (Es wurde ein Argument gefunden)
-----> Das Ergebnis wird auf den gefundenen Index gesetzt , wenn das bisherige Ergebnis -1 war oder der neue Index kleiner ist als der neu gefundene.
--> Am Ende gibst Du dann einfach das Ergebnis zurück
War das vom Ablauf her verständlich?

So lange Du beim suchen nach Punkt-Operationen kein -1 zurück bekommst.
==> bei dem gefundenen Index führst Du die Berechnung durch.
So lange Du beim suchen nach Strich-Operationen kein -1 zurück bekommst.
==> bei dem gefundenen Index führst Du die Berechnung durch.
Danach ist das Ergebnis in der Liste.

Du kannst es auch gerne in der bisherigen Schleife abspielen:

So lange Du mehr wie 1 Element in der Liste hast:
--> Ist der Index von einer Punkt Operation != 0
--> Ja: Gefundene Punkt Operation durchführen
--> Nein: Ist der Index von einer Strich Operation != 0
--> Ja: Gefundene Strich Operation durchführen
--> Nein: Fehler - Wir haben mehr wie ein Element aber keine unterstützte Operation!

(Hier ist wichtig - das ist ein if else if else Konstrukt. Es wird also bei jedem Durchlauf genau eine Operation gemacht. Entweder eine Punkt Operation oder eine Strich Operation oder es gibt eben den Fehler. Nach der Durchführung der Punkt Operation wird also nicht nach einer Strich Operation geschaut! Klar: Es könnte ja mehrere Punkt Operationen geben wie in: 1 + 2 * 3 / 4 - 5
 

Johannes73

Mitglied
Okay das war jetzt erstmal sehr viel Input, danke. Wie genau hole ich denn den Operator aus der Liste. Theoretisch befindet sich ja an jeder 2. Stelle ein Operator und der Index davon ist ungerade. Also befinden sich an Stelle 1, 3, 5 usw. Operatoren. Das erreiche ich ja über i % != 0, richtig? Oder habe ich jetzt einen Denkfehler?
 

KonradN

Super-Moderator
Mitarbeiter
Das %2 != 0 wäre der Test, ob ein index zu einem Operator gehört - das ist richtig. Aber das brauchst Du nicht, denn Du willst ja keinen index prüfen sondern nur gezielt abfragen.

Aber das ist natürlich auch richtig - Du kannst statt mit der Methode indexOf auch einfach durch die Liste gehen und in einer Schleife ab 1 die Elemente auf die gesuchten Operatoren prüfen - Schrittweite 2 würde dann nur die möglichen Operatoren prüfen.
Das wäre dann eine Alternative zu dem oben beschriebenen Algorithmus:
b) Nun brauchst Du eine Methode, die nur den Index für die nächste Operation ermittelt. Das kann eine Methode sein, die eien Liste von möglichen Operatoren entgegen nimmt (Varargs).
Da kannst Du einfach in einer Schleife durchgehen ab 1, Schrittweite 2. Ist das Element ein möglicher Operator, dann gib die Zählvariable zurück. Wenn die Schleife ohne Treffer durchlaufen wurde, dann hast Du da ein return -1.

Das ist evtl. ein einfacher zu verstehender Algorithmus als die erste Idee, die ich skizziert habe.
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
L Mein Taschenrechner lässt sich plötzlich nicht mehr öffnen Java Basics - Anfänger-Themen 5
N Java Taschenrechner hat Jemand vlt einen Tipp dafür wie ich jetzt die buttons verbinden kann und das Ergebnis auf dem textfield anzeigen lassen kann Java Basics - Anfänger-Themen 13
L Taschenrechner Problem Java Basics - Anfänger-Themen 4
J Frage zu einem "Taschenrechner" code Java Basics - Anfänger-Themen 9
R Operatoren Rechenoperation verwenden für Taschenrechner. Java Basics - Anfänger-Themen 32
S while Schleife Taschenrechner Java Basics - Anfänger-Themen 1
R Einfacher Taschenrechner mit Eclipse Java Basics - Anfänger-Themen 3
M Einfacher Taschenrechner Java Basics - Anfänger-Themen 2
Fiedelbambu Prüfen von Komma stelle beim Taschenrechner Java Basics - Anfänger-Themen 5
JordenJost Taschenrechner problem Java Basics - Anfänger-Themen 5
Y Taschenrechner programmieren Java Basics - Anfänger-Themen 3
G Taschenrechner ergibt Fehler in if-Abfrage Java Basics - Anfänger-Themen 6
K Erste Schritte "Taschenrechner" zeigt keine Komma Zahlen an. Java Basics - Anfänger-Themen 8
C Potenzberechnung über switch case. Taschenrechner mit Eingabe über einen grafischen Dialog Java Basics - Anfänger-Themen 22
E JavaFX Taschenrechner Eingabe im Textfield beschränken Java Basics - Anfänger-Themen 2
E Taschenrechner GUI Problem mit Fehlerhandling Java Basics - Anfänger-Themen 6
C Taschenrechner (switch) in Taschenrechner mit Methoden umwandeln Java Basics - Anfänger-Themen 115
W Taschenrechner mit Switch case Java Basics - Anfänger-Themen 4
W Taschenrechner Java Basics - Anfänger-Themen 11
A Taschenrechner mit Gui erstellen Java Basics - Anfänger-Themen 9
2 Taschenrechner mit GUI Problem bei der Berechnung Java Basics - Anfänger-Themen 8
P Taschenrechner mit unendlich vielen Eingabemöglichkeiten Java Basics - Anfänger-Themen 1
V Erste Schritte Taschenrechner mit beliebig vielen Zahlen Java Basics - Anfänger-Themen 5
S Taschenrechner Java Basics - Anfänger-Themen 13
P Taschenrechner Text übertragung Java Basics - Anfänger-Themen 3
S Compiler-Fehler Basic- Taschenrechner/ Fehler Java Basics - Anfänger-Themen 8
S Basic- Taschenrechner? Java Basics - Anfänger-Themen 7
P Hilfe bei Java Taschenrechner Java Basics - Anfänger-Themen 25
F Erste Schritte Frage zu simplem Taschenrechner(switch) Java Basics - Anfänger-Themen 16
S Taschenrechner hilfe! Java Basics - Anfänger-Themen 17
H Java Taschenrechner Java Basics - Anfänger-Themen 4
R Variablen Taschenrechner mit Komfortfunktionen Java Basics - Anfänger-Themen 2
J RPN Taschenrechner - keine Lösung!! Java Basics - Anfänger-Themen 84
M Java Taschenrechner (if-else) Java Basics - Anfänger-Themen 11
L Taschenrechner mit switch und while funktioniert noch nicht richtig Java Basics - Anfänger-Themen 22
Q simpler Taschenrechner Java Basics - Anfänger-Themen 34
R Taschenrechner NullPointerException Java Basics - Anfänger-Themen 1
R Variablen Weitergehenderr Taschenrechner Java Basics - Anfänger-Themen 4
F Taschenrechner "Error loading class..." Java Basics - Anfänger-Themen 5
M Java Taschenrechner Programmieren Java Basics - Anfänger-Themen 12
P Erste Schritte Taschenrechner mit if-else Anweisung Java Basics - Anfänger-Themen 6
G Taschenrechner gibt nur 0.0 aus Java Basics - Anfänger-Themen 8
A Taschenrechner programmieren Java Basics - Anfänger-Themen 21
Z Java Taschenrechner Java Basics - Anfänger-Themen 6
J Kleiner Taschenrechner! Anfänger braucht Hilfe :( Java Basics - Anfänger-Themen 2
C Taschenrechner in Java Java Basics - Anfänger-Themen 6
J Erste Schritte Java CMD Taschenrechner mit Parametern! Java Basics - Anfänger-Themen 16
J Taschenrechner: Probleme Java Basics - Anfänger-Themen 5
E Taschenrechner problem! Ich komme nicht voran Java Basics - Anfänger-Themen 18
R Erste Schritte Taschenrechner mit Schleife Java Basics - Anfänger-Themen 24
Lord.Djerun (Taschenrechner Netbeans) Komma nur einmal schreiben & 0 ersetzen Java Basics - Anfänger-Themen 1
Z Taschenrechner - Additions/Substraktions/Multiplikations/Divionsketten! Java Basics - Anfänger-Themen 4
D Taschenrechner Frage Java Basics - Anfänger-Themen 12
Z Sehr simpler Taschenrechner - Hilfe! Java Basics - Anfänger-Themen 10
Z Taschenrechner - Wie addiere,multipliziere und subtrahiere ich? Java Basics - Anfänger-Themen 6
D kleiner Taschenrechner mit switch fehlerhaft Java Basics - Anfänger-Themen 1
K Taschenrechner im GUI Java Basics - Anfänger-Themen 2
P Taschenrechner, operatoren Java Basics - Anfänger-Themen 4
D Simpler Taschenrechner Java Basics - Anfänger-Themen 6
A Anfänger Taschenrechner Frage Java Basics - Anfänger-Themen 14
R Erste Schritte Taschenrechner - Punkt-vor-Strich Rechnung Java Basics - Anfänger-Themen 1
S Operatoren Taschenrechner Ergebnis ausgeben Java Basics - Anfänger-Themen 7
A Taschenrechner zeigt Error Java Basics - Anfänger-Themen 7
J Taschenrechner Funktion Java Basics - Anfänger-Themen 18
M Taschenrechner fertigstellung Java Basics - Anfänger-Themen 1
N Methoden Taschenrechner Java Basics - Anfänger-Themen 2
F z = input.nextChar(); PROBLEM Taschenrechner Java Basics - Anfänger-Themen 7
J Scanner Taschenrechner? Java Basics - Anfänger-Themen 7
J Variablen Rechenzeichen und Zahlen verknüpfen für einen Taschenrechner Java Basics - Anfänger-Themen 17
B Klassen Java Taschenrechner mit Klassen und Methoden Java Basics - Anfänger-Themen 12
B Erste Schritte Brauche Hilfe bei einem Java-Taschenrechner Java Basics - Anfänger-Themen 11
R Methoden Taschenrechner Java Basics - Anfänger-Themen 4
P Taschenrechner , IF-Abfrage Java Basics - Anfänger-Themen 12
I Taschenrechner - Methoden implementieren Java Basics - Anfänger-Themen 5
I Java Starthilfe (Taschenrechner) Java Basics - Anfänger-Themen 7
J Taschenrechner Problemchen Java Basics - Anfänger-Themen 3
D Erste Schritte Taschenrechner Java Basics - Anfänger-Themen 11
K taschenrechner - Fehler beim Kürzen eines Bruches finden Java Basics - Anfänger-Themen 20
J Taschenrechner Punkt vor Strich Java Basics - Anfänger-Themen 9
A Taschenrechner programmieren Java Basics - Anfänger-Themen 5
M Ausklappbares Fenster bei grafischem Taschenrechner Java Basics - Anfänger-Themen 2
M Dividieren bei Grafischem Taschenrechner klappt nicht Java Basics - Anfänger-Themen 2
N Taschenrechner mit Unterprogra Java Basics - Anfänger-Themen 6
C Taschenrechner Java Basics - Anfänger-Themen 12
Z Taschenrechner programmieren Java Basics - Anfänger-Themen 5
E Erste Schritte Taschenrechner Java Basics - Anfänger-Themen 8
K Taschenrechner Java Basics - Anfänger-Themen 25
J Textfeld für Taschenrechner Java Basics - Anfänger-Themen 3
D Taschenrechner Java Basics - Anfänger-Themen 28
A Taschenrechner-GUI mit BorderLayout? Java Basics - Anfänger-Themen 6
W [PROJEKT] Simpler grafischer Taschenrechner Java Basics - Anfänger-Themen 8
M Taschenrechner mit JApplet Java Basics - Anfänger-Themen 26
J Grafischen Taschenrechner programmieren - Frage dazu Java Basics - Anfänger-Themen 12
W Taschenrechner Java Basics - Anfänger-Themen 2
T Tasten vom Taschenrechner? Java Basics - Anfänger-Themen 3
S Datentypen Taschenrechner Java Basics - Anfänger-Themen 13
J Taschenrechner Java Basics - Anfänger-Themen 5
J Taschenrechner Java Basics - Anfänger-Themen 9
M While bei einem Taschenrechner Java Basics - Anfänger-Themen 5
F Datentypen Ganz simpler Taschenrechner mit switch Java Basics - Anfänger-Themen 10

Ähnliche Java Themen

Neue Themen


Oben