# Java Taschenrechner



## Gody1989 (20. April 2010)

Hallo zusammen ich hab irgendwie einen totalen Black-Out (5wochen keine schule gehabt ^^) und ich finde keinen guten code im  web

ich brauche ein tut oda nen übersichtlichen code für einen simplen Taschenrechner der brauch nur +, -, *, : können (Konsole)

meine aufgabe besteht eh nur in der darstellung im web und in einer erläuterung von wegen java im web

ne schnelle antwort wäre nett danke


----------



## ByeBye 154279 (20. April 2010)

KLICK ME

mfg

bo


----------



## Bexx (20. April 2010)

Du lernst Java in der Schule und bist nicht mal in der Lage einen einfachen Taschenrechner mit Konsoleneingabe zu erstellen 
Das ist echt krass... Ich würd mir da echt vielleicht mal Gedanken machen...

Hier die Logic für einen Taschenrecher...:


```
public class CalculatorLogic {
    

    private int _currentTotal;  .
    

    public CalculatorLogic() {
        _currentTotal = 0;
    }
    
    public String getTotalString() {
        return "" + _currentTotal;
    }
    
    public void setTotal(String n) {
        _currentTotal = convertToNumber(n);
    }
    
    public void add(String n) {
        _currentTotal += convertToNumber(n);
    }
    
    public void subtract(String n) {
        _currentTotal -= convertToNumber(n);
    }
    
    public void multiply(String n) {
        _currentTotal *= convertToNumber(n);
    }
    
    public void divide(String n) {
        _currentTotal /= convertToNumber(n);
    }
    
    private int convertToNumber(String n) {
        return Integer.parseInt(n);
    }
}
```

hat mich 1min gekostet diesen freien source zu finden... :-()


----------



## ByeBye 154279 (20. April 2010)

Hey



Bexx hat gesagt.:


> Das ist echt krass... Ich würd mir da echt vielleicht mal Gedanken machen...



das klingt hart 

Dein Code finde ich gut, aber ich bezweifele, dass Gody1989 damit etwas anfangen kann.

mfg
bo


----------



## mccae (20. April 2010)

Hallo!

Die Leute hier werden mit Sicherheit nicht deine Hausaufgaben erledigen...

Es scheint als ob du großen Nachholbedarf hättest.

Entsprechende Literatur findest du im Internet und beim Buchhändler deines Vertrauens.

mfg
Martin


----------



## Bexx (20. April 2010)

bergonline hat gesagt.:


> das klingt hart



Das Leben ist nunmal kein Ponyhof 



bergonline hat gesagt.:


> Dein Code finde ich gut, aber ich bezweifele, dass Gody1989 damit etwas anfangen kann.



Das glaube ich auch nicht ^^
Immenrhin wäre für eine Konsolenanwendung ja noch eine main - Klasse nötig in der man
die Logic zu benutzen wissen müsste lol ^^

lg


----------



## KaWi_Trine (20. April 2010)

Hier was mit BlueJ

```
/**
 * Die Hauptklasse eines simplen Rechners. Erzeugen Sie 
 * ein Exemplar dieser Klasse und der Rechner erscheint
 * auf dem Bildschirm.
 * 
 * @author David J. Barnes und Michael Kölling
 * @version 2008.03.30
 */
public class Rechner
{
    private Recheneinheit recheneinheit;
    private GrafischeSchnittstelle gui;

    /**
     * Erzeuge einen neuen Rechner und zeige ihn an.
     */
    public Rechner()
    {
        recheneinheit = new Recheneinheit();
        gui = new GrafischeSchnittstelle(recheneinheit);
    }

    /**
     * Erneut anzeigen, falls das Fenster geschlossen wurde.
     */
    public void anzeigen()
    {
        gui.setzeSichtbarkeit(true);
    }
}
```



```
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.border.*;

/**
 * Eine grafische Schnittstelle für den Rechner. Hier wird keine
 * Berechnung durchgeführt. Diese Klasse ist ausschließlich für
 * die Anzeige auf dem Bildschirm zuständig. Sie lässt die
 * Recheneinheit alle Berechnungen ausführen.
 * 
 * @author David J. Barnes and Michael Kolling
 * @version 2008.03.30
 */
public class GrafischeSchnittstelle
    implements ActionListener
{
    private Recheneinheit rechner;
    private boolean autorAnzeigen;

    private JFrame fenster;
    private JTextField anzeige;
    private JLabel status;

    /**
     * Erzeuge eine grafische Benutzungsschnittstelle für 
     * eine Recheneinheit.
     * @param recheneinheit die Recheneinheit
     */
    public GrafischeSchnittstelle(Recheneinheit recheneinheit)
    {
        rechner = recheneinheit;
        autorAnzeigen = true;
        fensterAufbauen();
        fenster.setVisible(true);
    }

    /**
     * Setze die Sichtbarkeit dieser grafischen Schnittstelle.
     * @param sichtbar
     *        true, wenn die Schnittstelle sichtbar sein soll, false sonst.
     * 
     */
    public void setzeSichtbarkeit(boolean sichtbar)
    {
        fenster.setVisible(sichtbar);
    }

    /**
     * Baue das Fenster für diese grafische Oberfläche auf.
     */
    private void fensterAufbauen()
    {
        fenster = new JFrame(rechner.gibTitel());
        
        JPanel fensterflaeche = (JPanel)fenster.getContentPane();
        fensterflaeche.setLayout(new BorderLayout(8, 8));
        fensterflaeche.setBorder(new EmptyBorder( 10, 10, 10, 10));

        anzeige = new JTextField();
        fensterflaeche.add(anzeige, BorderLayout.NORTH);

        JPanel tastenfeld = new JPanel(new GridLayout(4, 4));
            tasteHinzufuegen(tastenfeld, "7");
            tasteHinzufuegen(tastenfeld, "8");
            tasteHinzufuegen(tastenfeld, "9");
            tasteHinzufuegen(tastenfeld, "C");
            
            tasteHinzufuegen(tastenfeld, "4");
            tasteHinzufuegen(tastenfeld, "5");
            tasteHinzufuegen(tastenfeld, "6");
            tasteHinzufuegen(tastenfeld, "?");
            
            tasteHinzufuegen(tastenfeld, "1");
            tasteHinzufuegen(tastenfeld, "2");
            tasteHinzufuegen(tastenfeld, "3");
            tastenfeld.add(new JLabel(" "));
            
            tasteHinzufuegen(tastenfeld, "0");
            tasteHinzufuegen(tastenfeld, "+");
            tasteHinzufuegen(tastenfeld, "-");
            tasteHinzufuegen(tastenfeld, "=");
            
        fensterflaeche.add(tastenfeld, BorderLayout.CENTER);

        status = new JLabel(rechner.gibAutor());
        fensterflaeche.add(status, BorderLayout.SOUTH);

        fenster.pack();
    }

    /**
     * Füge dem Tastenfeld eine Taste hinzu.
     * @param panel der Panel, der die Taste aufnehmen soll
     * @param tastentext der Text für die Taste
     */
    private void tasteHinzufuegen(Container panel, String tastentext)
    {
        JButton taste = new JButton(tastentext);
        taste.addActionListener(this);
        panel.add(taste);
    }

    /**
     * Eine Aktion an der Schnittstelle wurde ausgeführt.
     * Finde heraus, welche es war und behandle sie.
     * @param event die Beschreibung der Aktion
     */
    public void actionPerformed(ActionEvent event)
    {
        String taste = event.getActionCommand();

        if(taste.equals("0") ||
           taste.equals("1") ||
           taste.equals("2") ||
           taste.equals("3") ||
           taste.equals("4") ||
           taste.equals("5") ||
           taste.equals("6") ||
           taste.equals("7") ||
           taste.equals("8") ||
           taste.equals("9")) {
            int number = Integer.parseInt(taste);
            rechner.zifferGetippt(number);
        }
        else if(taste.equals("+")) {
            rechner.plus();
        }
        else if(taste.equals("-")) {
            rechner.minus();
        }
        else if(taste.equals("=")) {
            rechner.gleich();
        }
        else if(taste.equals("C")) {
            rechner.clear();
        }
        else if(taste.equals("?")) {
            infoZeigen();
        }
        // ansonsten: Unbekannter Befehl

        auffrischen();
    }

    /**
     * Frische die grafische Anzeige mit dem aktuellen Wert der
     * Recheneinheit auf.
     */
    private void auffrischen()
    {
        anzeige.setText("" + rechner.gibAnzeigewert());
    }

    /**
     * Wechsle die Informationsausgabe in der Statuszeile zwischen
     * der Autoren- und der Versionsinformation.
     */
    private void infoZeigen()
    {
        if(autorAnzeigen)
            status.setText(rechner.gibVersion());
        else
            status.setText(rechner.gibAutor());

        autorAnzeigen = !autorAnzeigen;
    }
}
```


```
/**
 * Die Haupteinheit eines Rechners, die die Berechnungen
 * durchführt.
 * 
 * @author  David J. Barnes und Michael Kölling 
 * @version 2008.03.30
 */
public class Recheneinheit
{
    // Der Zustand der Recheneinheit wird in drei Datenfeldern
    // gehalten:
    // anzeigewertImAufbau, linkerOperandGegeben, letzterOperator

	// Setzen wir gerade einen Wert in der Anzeige zusammen oder
	// wird die nächste Ziffer einen neuen beginnen?
    private boolean anzeigewertImAufbau;
    // Wurde bereits ein linker Operand eingegeben (oder berechnet)?
    private boolean linkerOperandGegeben;
    // Der zuletzt eingebene Operator.
    private char letzterOperator;

    // Der aktuelle Wert, der in der Anzeige gezeigt wird
    // (bzw. gezeigt werden soll)
    private int anzeigewert;
    // Der Wert des linken Operanden, falls gegeben.
    private int linkerOperand;

    /**
     * Erzeuge eine Recheneinheit.
     */
    public Recheneinheit()
    {
        clear();
    }

    /**
     * @return den Wert, der aktuell in der Anzeige gezeigt
     * werden soll.
     */
    public int gibAnzeigewert()
    {
        return anzeigewert;
    }

    /**
     * Eine Zifferntaste wurde getippt. Entweder einen neuen
     * Operanden starten oder diese Ziffer als Einerstelle
     * in einen bereits gegebenen Operanden einarbeiten.
     * @param ziffer die getippte Ziffer
     */
    public void zifferGetippt(int ziffer)
    {
        if(anzeigewertImAufbau) {
            // Diese Ziffer einarbeiten.
            anzeigewert = anzeigewert*10 + ziffer;
        }
        else {
            // Einen neuen Operanden beginnen.
            anzeigewert = ziffer;
            anzeigewertImAufbau = true;
        }
    }

    /**
     * Die Plus-Taste wurde getippt.
     */
    public void plus()
    {
        operatorAnwenden('+');
    }

    /**
     * Die Minus-Taste wurde getippt.
     */
    public void minus()
    {
        operatorAnwenden('-');
    }
    
    /**
     * Die Gleich-Taste wurde getippt.
     */
    public void gleich()
    {
        // Dies sollte den Aufbau eines zweiten Operanden abschließen,
        // also prüfen wir, ob ein linker Operand, ein Operator und
        // ein rechter Operand gegeben sind.
        if(linkerOperandGegeben &&
                letzterOperator != '?' &&
                anzeigewertImAufbau) {
            berechneErgebnis();
            letzterOperator = '?';
            anzeigewertImAufbau = false;
        }
        else {
            tippfehlerMelden();
        }
    }

    /**
     * Die C-Taste (für 'Clear') wurde getippt.
     * Versetze diese Recheneinheit in den Anfangszustand.
     */
    public void clear()
    {
        letzterOperator = '?';
        linkerOperandGegeben = false;
        anzeigewertImAufbau = false;
        anzeigewert = 0;
    }

    /**
     * @return den Titel dieser Recheneinheit.
     */
    public String gibTitel()
    {
        return "Java-Rechner";
    }

    /**
     * @return den Autor dieser Recheneinheit.
     */
    public String gibAutor()
    {
        return "David J. Barnes and Michael Kolling";
    }

    /**
     * @return die Versionsnummer dieser Recheneinheit.
     */
    public String gibVersion()
    {
       return "Version 1.0";
    }

    /**
     * Kombiniere linkerOperand, letzterOperator und den
     * aktuellen Anzeigewert.
     * Das Ergebnis wird sowohl zum linken Operand als auch
     * zum neuen Anzeigewert.
     */
    private void berechneErgebnis()
    {
        switch(letzterOperator) {
            case '+':
                anzeigewert = linkerOperand + anzeigewert;
                linkerOperandGegeben = true;
                linkerOperand = anzeigewert;
                break;
            case '-':
                anzeigewert = linkerOperand - anzeigewert;
                linkerOperandGegeben = true;
                linkerOperand = anzeigewert;
                break;
            default:
                tippfehlerMelden();
                break;
        }
    }
    
    /**
     * Wende den gegebenen Operator an.
     * @param operator der anzuwendende Operator
     */
    private void operatorAnwenden(char operator)
    {
        // Wenn wir nicht gerade einen neuen Operanden bauen,
        // dann ist dies ein Fehler, es sei denn, dass wir
        // gerade ein Ergebnis mit '=' berechnet haben.
        if(!anzeigewertImAufbau &&
                    !(linkerOperandGegeben && letzterOperator == '?')) {
            tippfehlerMelden();
            return;
        }

        if(letzterOperator != '?') {
            // Zuerst den vorherigen Operator anwenden.
            berechneErgebnis();
        }
        else {
            // Der anzeigewert wird zum linken Operanden dieses
            // neuen Operators.
            linkerOperandGegeben = true;
            linkerOperand = anzeigewert;
        }
        letzterOperator = operator;
        anzeigewertImAufbau = false;
    }

    /**
     * Melde, dass ein Tippfehler aufgetreten ist.
     */
    private void tippfehlerMelden()
    {
        System.out.println("Ein Tippfehler ist aufgetreten.");
        // Alles zurück setzen.
        clear();
    }
}
```


----------



## ByeBye 154279 (20. April 2010)

Bexx hat gesagt.:


> Das Leben ist nunmal kein Ponyhof
> 
> 
> 
> ...



:-D
Das stimmt 


@KaWi_Trine: Dein Code ist hübsch, aber leider war die Anforderung: "Taschenrechner der brauch nur +, -, *, : können (Konsole)"

mfg

bo


----------



## Gody1989 (21. April 2010)

ich danke euch erstmal und zu dem das ich mir sorgen machen sollte ich hatte bis jetzt  ca 4 stunden java xD


----------



## ByeBye 154279 (21. April 2010)

Gody1989 hat gesagt.:


> ich danke euch erstmal und zu dem das ich mir sorgen machen sollte ich hatte bis jetzt  ca 4 stunden java xD



Ja das Unterrichtsfach "Deutsch - Grammatik" kommt wohl auch zu kurz...

Wenn das Thema erledigt ist, dann kannst du es unten "Schließen"/"Frage geklärt" oder so ähnlich,

mfg
bo


----------

