Taschenrechner (switch) in Taschenrechner mit Methoden umwandeln

C

Codix

Bekanntes Mitglied
dieser Taschenrechner soll nicht mit switch, sondern mit Methoden funktionieren. Hat jemand Lösungsvorschläge?


Code: 
import javax.swing.JOptionPane;

public class Taschenrechner {
//Klassenvariable potenz, die 2 Parameter ( int basis & int expoWert hat)


public static long potenz(int basis, int expoWert)
    {
        long result = 1;
        while(expoWert > 0)
        {
            result *= basis;
            expoWert--;
        }
        return result;
    }
   
    public static void main(String[] args) {
        // TODO Automatisch generierter Methodenstub
        int zahl1, zahl2;
        String eingabe;
     
     
        zahl1 = Integer.parseInt(JOptionPane.showInputDialog("Tippen Sie Ihre erste Zahl ein:"));
        zahl2 = Integer.parseInt(JOptionPane.showInputDialog("Tippen Sie Ihre zweite Zahl ein:"));
     

        eingabe = JOptionPane.showInputDialog("Tippen Sie das Rechenzeichen ein (+, -, *, /,^):");
     
        switch(eingabe)
        {
          case "+":
              System.out.println("Resultat = " + (zahl1 + zahl2));
              break;
           
          case "-":
              System.out.println("Resultat = " + (zahl1 - zahl2));
              break;
           
          case "*":
              System.out.println("Resultat = " + (zahl1 * zahl2));
              break;
           
          case "/":
              System.out.println("Resultat = " + (zahl1 / zahl2));
              break;
       
          case "^":
              System.out.println("Resultat = " + potenz(zahl1, zahl2));
              break;  
        }
    }
}

ich dachte erstmal an so etwas, aber wie bekomme ich das mit Rechenzeichen hin?

& bei der "eingabe-zeile" bekomme ich Syntaxfehler angezeigt. Weiss jemand wie ich das korregieren kann?

Code: 
        eingabe = JOptionPane.showInputDialog("Tippen Sie das Rechenzeichen ein (addiere, substrahiere, multipliziere, dividiere ):)")";"
       
            static void addiere(int summandEins, int summandZwei){
            System.out.println("Die Summe aus "+summandEins+" und "+summandZwei+" ist "+(summandEins+summandZwei));
            }


            static void subtrahiere (int minuent, int subtrahent){
            System.out.println("Die Differenz aus "+minuent+" minus "+subtrahent+" ist "+(minuent-subtrahent));
            }


            static void multipliziere (int faktorEins, int faktorZwei){
            System.out.println("Das Produkt aus "+faktorEins+" und "+faktorZwei+" ist "+(faktorEins*faktorZwei));
            }


            static void dividiere (double divident, double devisor){
            System.out.println("Der Quotient aus "+divident+" und "+devisor+" ist "+(divident/devisor));
            }
    }

danke
 
Java: 
import java.util.*;
import java.util.function.*;

public class Calculator {
    static Map<String, BiConsumer<Number, Number>> operations = new HashMap<>();

    static {
        operations.put("+", (a,b) ->
                System.out.printf("Summe von %d und %d ist %d\n",
                                  a.intValue(), b.intValue(),
                                  a.intValue() + b.intValue()));
        operations.put("-", (a,b) ->
                System.out.printf("Differenz zwischen %d und %d ist %d\n",
                                  a.intValue(), b.intValue(),
                                  a.intValue() + b.intValue()));
    }

    static void calculate(String op, Number n1, Number n2) {
        operations.getOrDefault(op,
                                (a,b) -> System.out.println(op + ": WTF?!?"))
                  .accept(n1, n2);
    }

    public static void main(String[] args) {
        int a = 4;
        int b = 3;
        calculate("+", a, b);
        calculate("-", a, b);
        calculate("*", a, b);
    }
}
 
Codix hat gesagt.:
dieser Taschenrechner soll nicht mit switch, sondern mit Methoden funktionieren.
Zum Vergrößern anklicken....

Das ist eine sehr schwammige Aussage, keine Ahnung was damit gemeint ist. Hast du die Formulierung eventuell leicht verdreht?

Ich selbst würde es etwa so lösen, geht aber vermutlich über dein Anfängerniveau hinaus und ist daher vermutlich nicht gemeint: (quick&dirty)

Java: 
public static int potenz(int basis, int expoWert) {
    int result = 1;
    for (int i = 0; i < expoWert; i++) {
        result *= basis;
    }
    return result;
}

public static void main(String[] args) {
    Map<String, IntBinaryOperator> operations = new HashMap<>();
    operations.put("+", Math::addExact);
    operations.put("-", Math::subtractExact);
    operations.put("*", Math::multiplyExact);
    operations.put("/", Math::floorDiv);
    operations.put("^", Calculator::potenz);

    int zahl1 = Integer.parseInt(JOptionPane.showInputDialog("Tippen Sie Ihre erste Zahl ein:"));
    int zahl2 = Integer.parseInt(JOptionPane.showInputDialog("Tippen Sie Ihre zweite Zahl ein:"));
    String eingabe = JOptionPane.showInputDialog("Tippen Sie das Rechenzeichen ein (+, -, *, /,^):");

    IntBinaryOperator operation = operations.get(eingabe);
    if (eingabe != null) {
        System.out.println("Resultat = " + operation.applyAsInt(zahl1, zahl2));
    } else {
        System.out.println("Keine gültige Operation.");
    }
}
 
MoxxiManagarm hat gesagt.:
Das ist eine sehr schwammige Aussage, keine Ahnung was damit gemeint ist. Hast du die Formulierung eventuell leicht verdreht?

Ich selbst würde es etwa so lösen, geht aber vermutlich über dein Anfängerniveau hinaus und ist daher vermutlich nicht gemeint: (quick&dirty)

Java: 
public static int potenz(int basis, int expoWert) {
    int result = 1;
    for (int i = 0; i < expoWert; i++) {
        result *= basis;
    }
    return result;
}

public static void main(String[] args) {
    Map<String, IntBinaryOperator> operations = new HashMap<>();
    operations.put("+", Math::addExact);
    operations.put("-", Math::subtractExact);
    operations.put("*", Math::multiplyExact);
    operations.put("/", Math::floorDiv);
    operations.put("^", Calculator::potenz);

    int zahl1 = Integer.parseInt(JOptionPane.showInputDialog("Tippen Sie Ihre erste Zahl ein:"));
    int zahl2 = Integer.parseInt(JOptionPane.showInputDialog("Tippen Sie Ihre zweite Zahl ein:"));
    String eingabe = JOptionPane.showInputDialog("Tippen Sie das Rechenzeichen ein (+, -, *, /,^):");

    IntBinaryOperator operation = operations.get(eingabe);
    if (eingabe != null) {
        System.out.println("Resultat = " + operation.applyAsInt(zahl1, zahl2));
    } else {
        System.out.println("Keine gültige Operation.");
    }
}
Zum Vergrößern anklicken....

@ Das ist eine sehr schwammige Aussage, keine Ahnung was damit gemeint ist. Hast du die Formulierung eventuell leicht verdreht?
==> es sollen Methoden für die Berechnung verwendet werden, nicht switch/case.

===

Danke für die tollen Antworten, allerdings sind die Antworten zu gehoben für mein jetztiges Niveau. Könntet ihr vllt eine Antwort mit einfacheren Methoden posten? Danke nochmals, ihr seid Klasse.
 
Was für ein Stoff steckt denn thematisch hinter der Fragestellung?

Man könnte die beiden Antworten in so fern abwandeln/mixen, dass du eigene Methoden für Division und so hast und dann Methodenreferenzen dazu verwendest. (Methodenreferenzen hatte Moxxi ja schon benutzt, das ginge 1:1 auch in der Lösung von mihe7.

Eine Alternative könnte Reflection sein, aber das würde ich nicht benutzen. Wäre halt vom Prinzip her ähnlich aufgebaut, nur das man dann halt eine Method Instanz hätte, auf der man invoke aufrufen könnte ....

Daher wäre es einmal interessant, bezüglich welches Themas diese Aufgabe gestellt wurde bzw eas für Stoff vorher behandelt wurde.

Oder ist ggf gar kein Ersatz des switch Statements gemeint und es soll nur ein Refactoring in mehrere Methoden gemacht werden?
 
Codix hat gesagt.:
es sollen Methoden für die Berechnung verwendet werden, nicht switch/case.
Zum Vergrößern anklicken....
Damit ist vermutlich einfach nur gemeint, dass du die Berechnung nicht innerhalb des switch-case machen sollst, sondern diese in den Methoden durchführst. Das wäre auch das bessere Vorgehen in Hinblick auf Testbarkeit. Ab Java 13? glaube ich, gibt es zudem noch die Möglichkeit einer switch Expression. Diese Switch Expression sähe dann etwa so aus:

Java: 
int ergebnis = switch (eingabe) {
  case "+" -> addiere(zahl1, zahl2);
  case "-" -> subtrahiere(zahl1, zahl2);
  // ...
};
System.out.println("Ergebnis: " + ergebnis);
 
JustNobody hat gesagt.:
Was für ein Stoff steckt denn thematisch hinter der Fragestellung?

Man könnte die beiden Antworten in so fern abwandeln/mixen, dass du eigene Methoden für Division und so hast und dann Methodenreferenzen dazu verwendest. (Methodenreferenzen hatte Moxxi ja schon benutzt, das ginge 1:1 auch in der Lösung von mihe7.

Eine Alternative könnte Reflection sein, aber das würde ich nicht benutzen. Wäre halt vom Prinzip her ähnlich aufgebaut, nur das man dann halt eine Method Instanz hätte, auf der man invoke aufrufen könnte ....

Daher wäre es einmal interessant, bezüglich welches Themas diese Aufgabe gestellt wurde bzw eas für Stoff vorher behandelt wurde.

Oder ist ggf gar kein Ersatz des switch Statements gemeint und es soll nur ein Refactoring in mehrere Methoden gemacht werden?
Zum Vergrößern anklicken....

refactoring wahrscheinlich.

Stoff: Kontrollstrukturen & Schleifen, Methoden
 
Ich bezog mich auf den ersten Teil von Moxxis Beitrag und der Teil mit der Switch Expression wäre zu ignorieren:
Damit ist vermutlich einfach nur gemeint, dass du die Berechnung nicht innerhalb des switch-case machen sollst, sondern diese in den Methoden durchführst. Das wäre auch das bessere Vorgehen in Hinblick auf Testbarkeit.
Zum Vergrößern anklicken....

Also unter dem Strich heisst es, dass du das Switch bei behältst aber du nur noch Methodenaufrufe hast:
Code: 
case "+":
  addiere(zahl1,zahl2);
  break;

Also kein Code im Switch außer dem Funktionsaufruf.
 
JustNobody hat gesagt.:
Ich bezog mich auf den ersten Teil von Moxxis Beitrag und der Teil mit der Switch Expression wäre zu ignorieren:


Also unter dem Strich heisst es, dass du das Switch bei behältst aber du nur noch Methodenaufrufe hast:
Code: 
case "+":
  addiere(zahl1,zahl2);
  break;

Also kein Code im Switch außer dem Funktionsaufruf.
Zum Vergrößern anklicken....

ja es soll nicht switch sein, sondern nur Methoden. 🙂
 
Du kannst switch nicht einfach durch Methoden ersetzen. Du brauchst weiterhin irgendeine Möglichkeit, die passende Methode auszuwählen, und das ist entweder ein if oder eben ein switch.

Zeig doch mal die genaue Aufgabenstellung, vermutlich hast du die etwas missverstanden.
 
Du hast schon ein paar erste Möglichkeiten genannt bekommen. Wenn es ohne diese funktionalen Elemente gehen soll, dann würde mir noch eine rein objektorientierte Lösung einfallen. Da wird dann halt einfach ein Interface Operation oder so gebaut, das eine Methode wie Number calculate(Number, Number) vorgibt.

Dann hat man halt die Map statt mit BiConsumer oder so halt mit Operation Elementen.

Aber da ist dann auch einfach die Idee, dass man eben über eine Map zu der Operation die Aktion selbst holt.

Die Map ließe sich ersetzen durch eine Enumeration. Dann müsste jedes Enumeration Element halt die entsprechende Methodenimplementation kennen und man würde lediglich vom String her das Enum Element besorgen....
 
Kann man/frau so einen Taschenrechner mit Methoden machen?

Die addierten Methoden würde ich gern beibehalten, die switch Konstruktion kann verändert werden.

Kann mir eine/r bitte helfen? Wo sind die Fehler?

Vielen Vielen Dank im Voraus

Code: 
import javax.swing.JOptionPane;

public class Taschenrechner {
//Klassenvariable potenz, die 2 Parameter ( int basis & int expoWert hat)


public static long potenz(int basis, int expoWert)
    {
        long result = 1;
        while(expoWert > 0)
        {
            result *= basis;
            expoWert--;
        }
        return result;
    }
  
    public static void main(String[] args) {
        // TODO Automatisch generierter Methodenstub
        int zahl1, zahl2;
      
    
        public static int addiere(int Zahl1, int Zahl2)
        {
            int Zahl3 = Zahl1 + Zahl2;
            return Zahl3;
        }
        
        public static int subtrahiere(int Zahl1, int Zahl2)
        {
            int Zahl3 = Zahl1 - Zahl2;
            return Zahl3;
        }
        
        public static int multipliziere(int Zahl1, int Zahl2)
        {
            int Zahl3 = Zahl1 * Zahl2;
            return Zahl3;
        }
        
        public static int dividiere(int Zahl1, int Zahl2)
        {
            int Zahl3 = Zahl1 / Zahl2;
            return Zahl3;
        }
    

        zahl1 = Integer.parseInt(JOptionPane.showInputDialog("Tippen Sie Ihre erste Zahl ein:"));
        zahl2 = Integer.parseInt(JOptionPane.showInputDialog("Tippen Sie Ihre zweite Zahl ein:"));
    

        eingabe = JOptionPane.showInputDialog("Tippen Sie das Rechenzeichen ein (+, -, *, /,^):");
    
        switch(eingabe)
        {
          case "+":
              System.out.println("Resultat = " + (zahl1 + zahl2));
              break;
          
          case "-":
              System.out.println("Resultat = " + (zahl1 - zahl2));
              break;
          
          case "*":
              System.out.println("Resultat = " + (zahl1 * zahl2));
              break;
          
          case "/":
              System.out.println("Resultat = " + (zahl1 / zahl2));
              break;
      
          case "^":
              System.out.println("Resultat = " + potenz(zahl1, zahl2));
              break; 
        }
    }
}
 
Mach es einfach so wie es bei potenz() schon der Fall ist.

Aber: Hältst du es tatsächlich für sinnvoll ständig neue Probleme zu bearbeiten, wo die ersten noch nicht gelöst sind? Wie z.B. "Datenkapselung".
 
temi hat gesagt.:
Mach es einfach so wie es bei potenz() schon der Fall ist.

aber die anderen Methoden sind doch schon wie die Potenz Methode.

Aber: Hältst du es tatsächlich für sinnvoll ständig neue Probleme zu bearbeiten, wo die ersten noch nicht gelöst sind? Wie z.B. "Datenkapselung".
Zum Vergrößern anklicken....

ich arbeite gern im multiple tasking Modus. Danke für den Hinweis. Datenkapselung werde ich noch anschauen. Danke für alles @temi. Reskept an dich für die Unterstützung. 😉
 
Puh, wo soll man da anfangen...

Ich würde dir raten, dass du noch mal mit dem Code startest, den du im Eingangspost hattest. Alles danach hat den nur kaputt gemacht.
 
mrBrown hat gesagt.:
Puh, wo soll man da anfangen...

Ich würde dir raten, dass du noch mal mit dem Code startest, den du im Eingangspost hattest. Alles danach hat den nur kaputt gemacht.
Zum Vergrößern anklicken....
Naja, wenn er die anderen Methoden nach dem Beispiel "potenz()" erstellt und verwendet, dann klappt das schon.

Ich fürchte nur, dass es in seinem Fall sehr an Verständnis fehlt.
Codix hat gesagt.:
ich arbeite gern im multiple tasking Modus.
Zum Vergrößern anklicken....
Es geht nicht darum, am Ende eine funktionierende Lösung zu haben. Viel wichtiger ist, dass du die Lösung auch verstehst. In irgend einem Thema hast du geschrieben, dass du die Grundlagen schon gut kannst. Davon ist im letzten Code nicht viel zu sehen. Das sind Grundlagen, die da gefordert sind.

EDIT: Das ist auch der Grund, warum ich (und viele andere) keine fertige Lösung liefere. Es geht darum, dass es bei dir "Klick" macht und du selbst auf die Lösung kommst.
 
Stammt der Kommentar von dir?
Java: 
public class Taschenrechner {

//Klassenvariable potenz, die 2 Parameter ( int basis & int expoWert hat)
public static long potenz(int basis, int expoWert)
    {
        long result = 1;
        while(expoWert > 0)
        {
            result *= basis;
            expoWert--;
        }
        return result;
    }
Bei Potenz handelt es sich nämlich nicht um eine Klassenvariable, sondern um eine Klassenmethode!

Lerne und verwende die Begrifflichkeiten korrekt!
Stelle Fragen, wenn du irgend etwas nicht verstehst!
Stelle keine Fragen in der Art "gebt mir bitte die richtige Lösung".
 
temi hat gesagt.:
Stammt der Kommentar von dir?
Java: 
public class Taschenrechner {

//Klassenvariable potenz, die 2 Parameter ( int basis & int expoWert hat)
public static long potenz(int basis, int expoWert)
    {
        long result = 1;
        while(expoWert > 0)
        {
            result *= basis;
            expoWert--;
        }
        return result;
    }
Bei Potenz handelt es sich nämlich nicht um eine Klassenvariable, sondern um eine Klassenmethode!

Lerne und verwende die Begrifflichkeiten korrekt!
Stelle Fragen, wenn du irgend etwas nicht verstehst!
Stelle keine Fragen in der Art "gebt mir bitte die richtige Lösung".
Zum Vergrößern anklicken....

danke @ temi. Ja soll ich Klassenmethoden für jede Rechenart anwenden?
 
Die Methoden addiere, subtrahiere, ... sind innerhalb der main Methode. Das wird dann wohl so nicht gehen 🙂
 
temi hat gesagt.:
Mir geht es eher um das "static" 😉

Aber vielleicht habe ich oben ja fett angegeben und verwende den Begriff jetzt selbst falsch?
Zum Vergrößern anklicken....
Ne, du hast alles richtig verwendet 🙂

Ich würde hier nur bei static bleiben, alles andere dürfte grad nur verwirrend sein und der Mehrweit bleibt aus. Den Mehrwert hätte man dann, wenn in Richtung Strategie-Pattern und zb die von @mihe7 gezeigte Variante geht. Bisher sind das ja aber wirklich reine Funktionen ohne Zustand und Identität.
 
mrBrown hat gesagt.:
Ich würde hier nur bei static bleiben, alles andere dürfte grad nur verwirrend sein und der Mehrweit bleibt aus.
Zum Vergrößern anklicken....
Wie schon oben geschrieben, hat er ja auch Themen ("Datenkapselung"), die über dieses Einsteigerstadium hinaus gehen. Meiner Ansicht nach sollte man schon relativ frühzeitig "static" möglichst nur noch für die main()-Methode einsetzen oder dort, wo es funktional erforderlich ist.
 
mrBrown hat gesagt.:
Bisher sind das ja aber wirklich reine Funktionen ohne Zustand und Identität.
Zum Vergrößern anklicken....

Das wäre aber der erste wichtige Ansatz - unabhängig ob man Strategy Pattern verwendet oder nicht: Klassen von denen man Instanzen erzeugt in denen dann Daten enthalten sind auf denen man etwas ausführt und dann eben kein static mehr hat ...

Das wäre wohl ein wichtiger Schritt, den Codix gehen möchte, den spätestens mit GUI und so wird er mit sowas ja auch umgehen müssen ....
 
temi hat gesagt.:
Wie schon oben geschrieben, hat er ja auch Themen ("Datenkapselung"), die über dieses Einsteigerstadium hinaus gehen. Meiner Ansicht nach sollte man schon relativ frühzeitig "static" möglichst nur noch für die main()-Methode einsetzen oder dort, wo es funktional erforderlich ist.
Zum Vergrößern anklicken....
JustNobody hat gesagt.:
Das wäre aber der erste wichtige Ansatz - unabhängig ob man Strategy Pattern verwendet oder nicht: Klassen von denen man Instanzen erzeugt in denen dann Daten enthalten sind auf denen man etwas ausführt und dann eben kein static mehr hat ...

Das wäre wohl ein wichtiger Schritt, den Codix gehen möchte, den spätestens mit GUI und so wird er mit sowas ja auch umgehen müssen ....
Zum Vergrößern anklicken....

Grundsätzlich bin ich da voll bei euch – in diesem Fall allerdings scheitert es ja schon daran, überhaupt eine Methode zu schreiben, da dann Instanzmethoden zu verwenden, nur damit Instanzmethoden verwendet werden, halte ich deshalb für verfrüht. In diesem Fall würd das ja nur "Mehraufwand" ohne sichtbaren Nutzen bedeuten, von daher würde es dabei wohl nicht mal einen Lerneffekt geben.

In anderen Fällen (und auch wenn man das hier sinnvoll refactored) bin ich aber voll dafür 🙂
 
temi hat gesagt.:
Stammt der Kommentar von dir?
Java: 
public class Taschenrechner {

//Klassenvariable potenz, die 2 Parameter ( int basis & int expoWert hat)
public static long potenz(int basis, int expoWert)
    {
        long result = 1;
        while(expoWert > 0)
        {
            result *= basis;
            expoWert--;
        }
        return result;
    }
Bei Potenz handelt es sich nämlich nicht um eine Klassenvariable, sondern um eine Klassenmethode!

Lerne und verwende die Begrifflichkeiten korrekt!
Stelle Fragen, wenn du irgend etwas nicht verstehst!
Stelle keine Fragen in der Art "gebt mir bitte die richtige Lösung".
Zum Vergrößern anklicken....

wird korregiert. Dank und Respekt für die gute Java-Erziehung. 😉
 
temi hat gesagt.:
Bei Potenz handelt es sich nämlich nicht um eine Klassenvariable, sondern um eine Klassenmethode!
Zum Vergrößern anklicken....
Ich würde nicht so streng unterscheiden:
Java: 
	static BiFunction<Integer, Integer, Long> pot = (basis, expo) -> IntStream.range(0, expo).mapToObj(i -> (long) basis).reduce(1L, (s, i) -> s * i);
Ist das für euch Klassenvariable oder -Methode?
 
osmane hat gesagt.:
Ich würde nicht so streng unterscheiden:
Java: 
    static BiFunction<Integer, Integer, Long> pot = (basis, expo) -> IntStream.range(0, expo).mapToObj(i -> (long) basis).reduce(1L, (s, i) -> s * i);
Ist das für euch Klassenvariable oder -Methode?
Zum Vergrößern anklicken....
Ganz offensichtlich ist pot eine Klassenvariable, oder klappt pot(2, 2)?
 
In
Java: 
class X {
    public static Runnable worker;
}
wird worker zunächst eindeutig (per Definition) als Klassenvariable deklariert.

Nun könnte man auf die Idee kommen, "worker" als Namensraum für Klassenmethoden zu betrachten, nach dem Motto: wenn worker Klassenvariable von X ist, dann müssen die Methoden von worker auch Klassenmethoden von X sein, die lediglich unter Zuhilfenahme des Namensraums "worker" angesprochen werden. Somit wäre worker.run() eine Klassenmethode von X.

Mal abgesehen davon, dass die JLS es anders definiert, ist ein weiteres Problem dabei, dass X.worker eine Klassenvariable ist, die lediglich auf eine Instanz von Runnable verweisen kann. Die vermeintliche "Klassenmethode" X.worker.run() kann zur Laufzeit geändert werden, insbesondere kann sie "nicht definiert" sein, wenn worker == null gilt, was erst zur Laufzeit zu einer NPE führt. Die Methode "X.worker.run()" ist damit gerade kein Verhalten, das der Klasse X zugeschrieben werden kann.
 
osmane hat gesagt.:
Gegenfrage, klappt pot.apply(3, 30) bei einer Nicht-Methode?
Zum Vergrößern anklicken....
Das belegt es doch auch. pot muss eine Variable sein, denn ansonsten könnte da keine Referenz zu einer Instanz drin sein, die die apply Methode bereit stellt.

Wäre pot eine Methode, müsste es ja etwas sein wie pot().apply(3,30);
Sprich: Die Methode pot müsste dann eine Referenz zurück geben, die das apply anbietet.
 
temi hat gesagt.:
Mach es einfach so wie es bei potenz() schon der Fall ist.

Aber: Hältst du es tatsächlich für sinnvoll ständig neue Probleme zu bearbeiten, wo die ersten noch nicht gelöst sind? Wie z.B. "Datenkapselung".
Zum Vergrößern anklicken....

===

was hälst du von dem Ansatz?

Code: 
public static void main(String[] args) {
        // TODO Automatisch generierter Methodenstub
        int zahl1, zahl2;
      
    
        public static int addiere(int Zahl1, int Zahl2)
        {
            int Zahl3 = Zahl1 + Zahl2;
   // vllt ohne return machen
         return Zahl3;
        }
if (eingabe =  +)
        System.out.println("Resultat = " + (zahl1 + zahl2));
else
        System.out.println("kein Ergebnis".);
 
was haltet ihr von dem Ansatz?
natürlich gibt es Fehler in dem code, er lässt sich nicht kompilieren (aber was sagst du zum Ansatz?).

Kann man: if (eingabe = +) coden?

Code: 
public static void main(String[] args) {
        // TODO Automatisch generierter Methodenstub
        int zahl1, zahl2;
     
   
        public static int addiere(int Zahl1, int Zahl2)
        {
            int Zahl3 = Zahl1 + Zahl2;
   // vllt ohne return machen
         return Zahl3;
        }
if (eingabe =  +)
        System.out.println("Resultat = " + (zahl1 + zahl2));
else
        System.out.println("kein Ergebnis".);

 zahl1 = Integer.parseInt(JOptionPane.showInputDialog("Tippen Sie Ihre erste Zahl ein:"));
 zahl2 = Integer.parseInt(JOptionPane.showInputDialog("Tippen Sie Ihre zweite Zahl ein:"));
 eingabe = JOptionPane.showInputDialog("Tippen Sie das Rechenzeichen ein (+, -, *, /,^):");
 
Von dem Ansatz halte ich nichts:
- Methoden können nicht in Methoden geschrieben werden wie du es machst. Darauf wurdest du schon hingewiesen.
- was ist eingabe für eine Variable? Wenn es ein String ist, dann musst du auch entsprechend Strings vergleichen, d.h. du musst gegen eine Zeichenkette prüfen.
 
Also der Taschenrechner sollte mit Methoden funken. Mir wurde geraten mit Klassenmethoden zu arbeiten.

Hat jmd. einen konkreten Quellcodevorschlag?
 
das ist z.B. ein einfacher Additionstaschenrechner mit statischer Methode:

Code: 
import javax.swing.*;

public class Ad-TaRe {

static int summe(int x, int y) {

return (x + y);

}

public static void main(String[] args) {

int einVariable1, einVariable2;

einVariable1 = Integer.parseInt(JOptionPane.showInputDialog ("Geben Sie die erste Zahl ein:"));

einVariable2 = Integer.parseInt(JOptionPane.showInputDialog ("Geben Sie die zweite Zahl ein:"));

System.out.println("Die Summe der beiden Zahlen ist " + summe(einVariable1, einVariable2));

System.exit(0);

}
}

dann muss es doch möglich sein nach dem Vorbild einen komplexeren TaRe zu codieren.




Soll ich etwas alle Kalkulationsmethoden so durchgehen nach diesem Vorbild und dann in der anderen Klasse die Ein/Ausgabe machen?

Code: 
import javax.swing.*;
public class Multi {
static int produkt(int x, int y) {
return (x * y);
}
public static void main(String[] args) {

int einVariable1, einVariable2;

einVariable1 = Integer.parseInt(JOptionPane.showInputDialog("Geben Sie den Wert für Zahl 1 ein:"));

einVariable2 = Integer.parseInt(JOptionPane.showInputDialog("Geben Sie den Wert für Zahl 2 ein:"));

System.out.println("Das Produkt der Zahlen ist " + produkt(einVariable1, einVariable2));

System.exit(0);
}
}
 
Zuletzt bearbeitet:
die Methoden an sich habe ich ja verstanden, aber wie man die Methoden komplex unterbringt in einem TaRe-Code, das kapiere ich noch nicht.
 
Vor einiger Zeit hatte ich mal einen Taschenrechner in Swing geschrieben, vielleicht kann dieser eine Inspiration sein:
Java: 
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JTextField;

public class Taschenrechner implements ActionListener {

	private int in = 0;
	private JTextField field1 = new JTextField();
	private JTextField field2 = new JTextField();
	private JTextField field3 = new JTextField();
	private JButton[] buttons = {
																  new JButton("/"),
			new JButton("1"), new JButton("2"), new JButton("3"), new JButton("*"),
			new JButton("4"), new JButton("5"), new JButton("6"), new JButton("-"),
			new JButton("7"), new JButton("8"), new JButton("9"), new JButton("+"),
		  new JButton("Del"), new JButton("0"), new JButton(","), new JButton("=")
	};

	public Taschenrechner() {
		JFrame frame = new JFrame("Taschenrechner");
		frame.setLayout(new GridLayout(5, 4, 5, 5));
		frame.add(field1);
		frame.add(field2);
		frame.add(field3);
		for (JButton button : buttons) {
			frame.add(button);
			button.addActionListener(this);
		}
		frame.setSize(400, 200);
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		frame.setVisible(true);
	}

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

	@Override
	public void actionPerformed(ActionEvent e) {
		char c = e.getActionCommand().charAt(0);
		if (c == 'D') {
			field1.setText("");
			field2.setText("");
			field3.setText("");
			in = 0;
		}
		switch (in) {
		case 0:
			if (c == '+' || c == '-' || c == '*' || c == '/') {
				field2.setText(field2.getText() + c);
				in++;
			}
			if (c >= '0' && c <= '9') {
				field1.setText(field1.getText() + c);
			}
			if (c == ',') {
				field1.setText(field1.getText() + '.');
			}
			break;
		case 1:
			if (c == '=') {
				double d1 = Double.parseDouble(field1.getText());
				double d2 = Double.parseDouble(field3.getText());
				switch (field2.getText().charAt(0)) {
				case '+':
					field1.setText(d1 + d2 + "");
					break;
				case '-':
					field1.setText(d1 - d2 + "");
					break;
				case '*':
					field1.setText(d1 * d2 + "");
					break;
				case '/':
					field1.setText(d1 / d2 + "");
					break;
				default:
					break;
				}
				field1.setText((float) Double.parseDouble(field1.getText()) + "");
				field2.setText("");
				field3.setText("");
				in = 0;
			}
			if (c >= '0' && c <= '9') {
				field3.setText(field3.getText() + c);
			}
			if (c == ',') {
				field3.setText(field3.getText() + '.');
			}
			break;
		default:
			break;
		}
	}

}
 

Aktuelle Jobs

Neue Themen

Ähnliche Themen

kleiner Taschenrechner mit switch fehlerhaft
Antworten: 1
Taschenrechner mit switch und while funktioniert noch nicht richtig
Antworten: 22
Taschenrechner mit Switch case
Antworten: 4
Potenzberechnung über switch case. Taschenrechner mit Eingabe über einen grafischen Dialog
Antworten: 22
Ganz simpler Taschenrechner mit switch
Antworten: 10

Zurück
Oben