JRechner und Model sollen in ihrer jeweiligen Arbeitsweise unabhängig voneinander funktionieren. Bei Bedarf muss es möglich sein, dem JRechner ein anderes Model zuzuordnen, z.B. um eine höhere Rechengenauigkeit zu erzielen. Das einzige, was die Komponenten des Programms voneinander wissen ist, dass sie sich gegenseitig mit bestimmten Methoden ansprechen. Sie verkehren also über interfaces miteinander.
Die Anzeige der Zahlen an der Benutzeroberfläche erfolgt wahlweise in Dual, Dezimal oder Hex. Die Anzeige ist Aufgabe des JRechner und das Model weiss nichts davon, denn die Zahlen werden von JRechner in Dezimal umgewandelt, bevor sie dem Model geschickt werden; das Model arbeitet immer mit Dezimalzahlen. Das Model schickt auch die Ergebnisse immer als Dezimalzahlen zurück an die Application. Sie werden der Einfachheit halber immer als Dezimal angezeigt. Der Benutzer kann das Zahlensystem für die Anzeige jederzeit wechseln, er kann also bei Bedarf die Anzeige des Ergebnisses in Dual oder Hex umstellen, nachdem es zuerst als Dezimal gezeigt wurde.
Die Abb. zeigt 3 Exemplare des Rechners mit den 3 Zahlensystemen:
ergAnzeigen(RechnerEvent re)
Die Klasse JRechner ist die eigentliche Application. Es handelt sich um 1 JFrame, auf dem 2 JPanels befestigt sind: links das anzeigePanel mit 1 JTextField zum Anzeigen von Zahlen, einigen JButtons zum Eingeben der Rechenoperation und JRadioButtons zum Wählen der Zahlensystems; rechts das tastenPanel, siehe Abb. oben.
Die Reaktion auf Benutzereingaben erfolgt über 5 Listener, die als innere Klassen implementiert sind:
Der Listener SystListener regelt die Umstellung: Er ruft die Methode
zeichneTasten()
zwecks Gestaltung des tastenPanel und die Methode
ziffernAnpassen()
um die Ziffern im JRextField an das gewählte Zahlensystem anzupassen.
Die Zahl wird immer als Dezimalzahl an das Model geliefert. Die Methode
ziffernDezimal()
regelt die Umwandlung in Dezimal.
Bei Vorliegen eines Ergebnisses im Model ruft dieses die Methode
ergAnzeigen( RechnerEvent re )
Der solcherart angesprochene JRechner zieht dann aus dem RechnerEvent den Wert des Ergebnis heraus und zeigt ihn an. Weil das Model Dezimalzahlen liefert, wird die Benutzeroberfläche auf dezimal umgestellt.
zahlAnnehmen( double )
opAnnehmen( String).
Das RechnerModel leistet die eigentliche Arbeit: es bekommt vom JRechner Zahlen und Rechenoperationen geliefert und schickt Ergebnisse an den JRechner zurück.
Um Rundungsfehler beim Rechnen mit Datentyp double zu vermeiden, werden alle Zahlen als Long behandelt.
Quellcode Klasse RechnerModelrechnerBenachrichtigen()
/*
* interface rechner.Rechner
*
* Version 1.0
*
* 30.7.01
*
* www.AndreasGoedel.de
*
*/
package rechner;
/**
* Interface des Rechners zur Benutzung durch das RechnerModel.
*
*/
public interface Rechner
{
/**
* Das Erg anzeigen.
* Das Ergebnis ist im Model. Auf das Model wird über das RechnerEvent
* zugegriffen.
*/
public void ergAnzeigen( RechnerEvent re );
}
/*
* class rechner.JRechner
*
* Version 1.0
*
* 30.7.01
*
* www.AndreasGoedel.de
*
*/
package rechner;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JButton;
import javax.swing.JTextField;
import javax.swing.JRadioButton;
import javax.swing.ButtonGroup;
import javax.swing.border.BevelBorder;
import java.awt.event.*;
import java.awt.Container;
import java.awt.GridLayout;
import java.awt.Font;
import java.awt.Color;
/**
* Rechner mit Model.
* Das anzeigePanel links und das tastenPanel rechts.
*
* Eingabe der Zahlen in Dual, Dezimal oder Hex.
* Interne Darstellung immer dezimal.
*
* Model liegt drunter. Ergebnisse kommen dezimal,
* für den Fall, dass Dezimalstellen angefallen sind.
* Beim Anzeigen eines Ergebnisses wird das tastenPanel auf Dezimal umgeschaltet,
* damit das Aussehen zur Zahl passt.
* Der Benutzer kann jederzeit ein anderes Zahlensystem wählen.
*
*/
public class JRechner extends JFrame implements Rechner
{
private RModel model;
private JPanel anzeigePanel;
private JPanel tastenPanel;
private Container container; // getContentPane()
private ButtonGroup buttonGroup;
private JRadioButton dualButton;
private JRadioButton dezimalButton;
private JRadioButton hexButton;
private JTextField jTextField;
private String ziffern = "0";
private static int DUAL = 2;
private static int DEZIMAL = 10;
private static int HEX = 16;
private int syst = DEZIMAL; // Voreinstellung
private JButton ZifferButton[] = {
new JButton( "0" ),
new JButton( "1" ),
new JButton( "2" ),
new JButton( "3" ),
new JButton( "4" ),
new JButton( "5" ),
new JButton( "6" ),
new JButton( "7" ),
new JButton( "8" ),
new JButton( "9" ),
new JButton( "A" ),
new JButton( "B" ),
new JButton( "C" ),
new JButton( "D" ),
new JButton( "E" ),
new JButton( "F" ),
new JButton( " " ),
new JButton( "." )
};
private JButton PlusButton = new JButton( "+" );
private JButton MinusButton = new JButton( "-" );
private JButton MalButton = new JButton( "*" );
private JButton GeteiltButton = new JButton( "/" );
private JButton GleichButton = new JButton( "=" );
private JButton LoeschButton = new JButton( "C" );
private double doubleWert = 0.0; // Dezimalwert der Eingabe, egal welches System
private boolean punktGesetzt = false; // noch kein Dezimalpunkt
private boolean neueZahl = true; // Eingabe einer neuen Zahl: Anzeige leer
private boolean zuletztZiffer = true; // gerade Ziffern eingegeben
/**
* Model bekommt Eingaben und bearbeitet sie.
*/
public void setModel( RModel m ){
model = m;
}
/**
* Das Model.
*/
public RModel getModel(){
return model;
}
/**
* Das ZahlenSystem wechseln.
* Er nimmt nur 2, 10, 16.
* Das tastenPanel wird angepasst und die Darstellung der Ziffern.
*
*@see rechner.JRechner#zeichneTasten()
*@see rechner.JRechner#ziffernAnpassen()
*@param s das Zahlensystem wird eingeschaltet
*/
public void anderesSyst( int s ){
if( s == DUAL || s == DEZIMAL || s == HEX ){
setSyst( s );
zeichneTasten();
ziffernAnpassen();
punktGesetzt = false; // Dezimalpunkt ignorieren
}
}
/**
* Das aktuell eingestellte Zahlensystem
*/
public void setSyst( int s ){
syst = s;
}
/**
* Das Zahlensystem einstellten
*/
public int getSyst(){
return syst;
}
/**
* Die interne Repräsentation der Ziffern der Eingabe abfragen.
*/
public String getZiffern(){
return ziffern;
}
/**
* Die interne Repräsentation der Ziffern der Eingabe festlegen.
*
*@param z der String von Ziffern
*/
public void setZiffern( String z ){
ziffern = z;
}
/**
* Der dezimale Zahlenwert der angezeigten Zahl.
*/
public double getDoubleWert(){
return doubleWert;
}
/**
* Den dezimalen Zahlenwert setzen.
*/
public void setDoubleWert( double d ){
doubleWert = d;
}
/**
* Zuletzt kam Eingabe Ziffer und nicht Operator.
* Jede Zahleingabe setzt das auf true,
* jede Eingabe eines Operators auf false.
*/
public void setZuletztZiffer( boolean t ){
zuletztZiffer = t;
}
/**
* Zuletzt kam Eingabe Ziffer und nicht Operator.
*
*@return true wenn zuletzt Zahleingabe und nicht Operator.
*/
public boolean getZuletztZiffer(){
return zuletztZiffer;
}
/**
* ZifferAnnehmen.
* Der Benutzer klickt 1 Zifferntaste. Sie wird als String und
* als Dezimaler ZahlenWert gespeichert.
* Der String wird im Panel angezeigt.
*
*@param z diese Ziffer ist geklickt worden.
*/
public void zifferAnnehmen( String z ){
if( neueZahl == true ){
setZiffern( "" );
neueZahl = false; //folgende Ziffern zur selben Zahl
}
setZiffern( getZiffern() + z );
zuletztZiffer = true; // Das war Zahl und nicht Op
ziffernDezimal( getSyst()); // Zahlenwert dezimal
jTextField.setText( getZiffern() );
}
/**
* Die Ziffern als Dezimalzahl speichern.
*
*@param s Das Ziffernsystem Dual, Dezimal, oder Hex.
*/
public void ziffernDezimal( int s ){
try{
if( s == DEZIMAL ){
doubleWert = Double.parseDouble( ziffern );
}else{
doubleWert = (double)Integer.parseInt( ziffern, s );
}
}catch( NumberFormatException nfe ){
ziffern = "0";
jTextField.setText( ziffern );
doubleWert = 0;
}
}
/**
* Den dezimalen ZahlenWert als Ziffern im aktuellen Zahlenystem anzeigen.
* Der Dezimalzahlen geht ggf. verloren.
*/
public void ziffernAnpassen(){
try{
doubleWert = (long)doubleWert;
ziffern = Long.toString( (long)doubleWert, getSyst() );
}
catch( NumberFormatException nfe ){
doubleWert = 0;
ziffern = "0";
}
jTextField.setText( getZiffern() );
}
/**
* Löschen mit C.
* Danach kann neue Zahl oder Op eingegeben werden.
*/
public void loeschen(){
doubleWert = 0;
ziffern = "0";
punktGesetzt = false;
neueZahl = true;
jTextField.setText( getZiffern());
getModel().loeschen();
}
/**
* Einen Dezimalpunkt annehmen.
* Jede Dezimalzahl hat nur einen.
* Führende Null kann weggelassen werden.
*/
public void dezPunkt(){
if( neueZahl == true ){ //ohne führende Null
setZiffern( "0." );
neueZahl = false;
punktGesetzt = true;
}else if( punktGesetzt == false ){ //Normalfall
setZiffern( getZiffern() + "." );
punktGesetzt = true;
}
jTextField.setText( getZiffern() );
}
/**
* Operator annehmen: + - * / =.
* Wenn zuvor 1 Zahl eingegeben worden war, wird die Zahl und der
* Operator an das Model geschickt.
*
*@param o der Operator wurde geklickt.
*/
public void opAnnehmen( String o ){
if( o.equals( "+" )
|| o.equals( "-" )
|| o.equals( "*" )
|| o.equals( "/" )
|| o.equals( "=" )){
//Zahl 1 mal an Model:
if( getZuletztZiffer() == true ){
getModel().zahlAnnehmen( doubleWert );
}
//Op an Model immer:
getModel().opAnnehmen( o );
//Vorbereiten auf nächste Benutzer-Eingabe:
neueZahl = true;
punktGesetzt = false;
zuletztZiffer = false;
}
}
/**
* Das RechnerEvent auswerten und Ergebnis anzeigen.
* Diese Methode wird vom Model aus immer dann aufgerufen,
* wenn dort ein frisches Ergebnis vorliegt.
*
* Da vom Model immer Dezimalzahlen geliefert werden,
* wird hier das tastenPanel auf Dezimal umgestellt.
* Falls im Model ein error aufgetreten ist, wird dieser
* hier angezeigt.
*
*@see rechner.RechnerModel#rechnerBenachrichtigen()
*@param re Das RechnerEvent wird im RechnerModel erzeugt
*/
public void ergAnzeigen( RechnerEvent re ){
if( re.getErr() == true ){
jTextField.setText( "ERROR" );
setZiffern( "" );
setDoubleWert( 0 );
}else{
doubleWert = re.getWert();
setZiffern( Double.toString( doubleWert ));
jTextField.setText( ziffern );
setSyst( DEZIMAL ); // kommt immer dezimal
zeichneTasten();
dezimalButton.getModel().setSelected( true );
}
}
/**
* Panels befestigen und Model initialisieren.
* Das anzeigePanel links: Anzeige, RadioButtons für ZahlSystem, Rechentasten.
* tastenPanel rechts: 2, 10 plus Dezimalpunkt oder 16 Zifferntasten.
*/
public JRechner(){
//graf. Gestaltung und addListener() :
container = getContentPane();
container.setLayout( new GridLayout( 1, 2 ));
setFont( new Font( "TimesRoman", Font.BOLD, 16 )); // ???
//anzeigePanel mit Anzeige, JRadioButtons und Operatortasten
anzeigePanel = new JPanel();
anzeigePanel.setBorder( new javax.swing.border.BevelBorder( 0 ));
jTextField = new JTextField( 17 );
jTextField.setEditable( false );
jTextField.setBackground( Color.white );
anzeigePanel.add( jTextField );
buttonGroup = new ButtonGroup();
dualButton = new JRadioButton( "dual" );
dualButton.addActionListener( new SystListener() );
dezimalButton = new JRadioButton( "dezimal" );
dezimalButton.addActionListener( new SystListener() );
hexButton = new JRadioButton( "hex" );
hexButton.addActionListener( new SystListener() );
buttonGroup.add( dualButton );
buttonGroup.add( dezimalButton );
buttonGroup.add( hexButton );
anzeigePanel.add( dualButton );
anzeigePanel.add( dezimalButton );
anzeigePanel.add( hexButton );
//OperatorTasten obere Reihe:
anzeigePanel.add( PlusButton );
anzeigePanel.add( MinusButton );
anzeigePanel.add( MalButton );
anzeigePanel.add( GeteiltButton );
PlusButton.addActionListener( new OpListener());
MinusButton.addActionListener( new OpListener());
MalButton.addActionListener( new OpListener());
GeteiltButton.addActionListener( new OpListener());
//OperatorTasten untere Reihe:
anzeigePanel.add( new JButton());
anzeigePanel.add( GleichButton );
GleichButton.addActionListener( new OpListener());
anzeigePanel.add( LoeschButton );
LoeschButton.addActionListener( new LoeschListener());
anzeigePanel.add( new JButton());
jTextField.setText( getZiffern() );
container.add( anzeigePanel );
//TastenPanel mit max. 16 Zifferntasten und 1 DezimalpunktTaste:
tastenPanel = new JPanel();
tastenPanel.setBorder( new BevelBorder( 0 ));
for( int i = 0; i <= HEX; i++ ){
ZifferButton[i].addActionListener( new ZifferListener());
}
ZifferButton[HEX+1].addActionListener( new DezimalpunktListener());
zeichneTasten();
container.add( tastenPanel );
//Model erzeugen und initialisieren:
setModel( new RechnerModel());
getModel().setRechner( this );
dezimalButton.getModel().setSelected( true ); //Voreinstellung
}
/**
* JFrame erzeugen mit WindowAdapter.
*/
public static void main( String [] args ){
JRechner jrechner = new JRechner();
jrechner.addWindowListener( new WindowAdapter(){
public void windowClosing( WindowEvent e ){
System.exit( 0 );
}
});
jrechner.setSize( 444, 199 );
jrechner.setVisible( true );
}
/**
* TastenButtons zeichnen.
* Je nach Zahlenystem 2, 10 plus 1 oder 16.
*/
public void zeichneTasten(){
tastenPanel.removeAll(); //vorhandene ZiffernTasten entfernen
int s = getSyst();
setTitle( "Basis " + s );
for( int i = 0; i < s; i++ ){ // neue ZiffernTasten befestigen
tastenPanel.add( ZifferButton[i] );
}
if( s == DEZIMAL ){ //DezimalpunktTaste nur bei Dezimalzahlen
tastenPanel.add( ZifferButton[ 16 ]);
tastenPanel.add( ZifferButton[ 17 ]);
}
//ZiffernTastenButtons neu zeichnen
try{
paintComponents( getGraphics());
}
catch( NullPointerException npe ){}
repaint();
}
/**
* Für JRadioButtons.
* Auswahl des Zahlensystems Dual, Dezimal oder Hex
* durch Benutzer-Klick auf JRadioButton.
*/
class SystListener implements ActionListener{
/**
* JRadioButton anklicken wegen ZahlenSystem.
*
*@see rechner.JRechner#anderesSyst( int )
*/
public void actionPerformed( ActionEvent e ){
if( buttonGroup.isSelected( dualButton.getModel())){
anderesSyst( DUAL );
}else if( buttonGroup.isSelected( dezimalButton.getModel())){
anderesSyst( DEZIMAL );
}else if( buttonGroup.isSelected( hexButton.getModel())){
anderesSyst( HEX );
}
}
}
/**
* Für ZiffernButtons.
*/
class ZifferListener implements ActionListener{
/**
* ZiffernButton anklicken.
*
*@see rechner.JRechner#zifferAnnehmen(String );
*@param e ActionEvent liefert Beschriftung des geklickten Button
*/
public void actionPerformed( ActionEvent e ){
zifferAnnehmen( e.getActionCommand());
}
}
/**
* Loesch-Listener.
* Clear-Button klicken.
*/
class LoeschListener implements ActionListener{
/**
* ClearButton anklicken.
*
*@see rechner.JRechner#loeschen()
*/
public void actionPerformed( ActionEvent e ){
loeschen();
}
}
/**
* Für Dezimalpunkttaste.
*/
class DezimalpunktListener implements ActionListener{
/**
* Dezimalpunkt nur in Dezimalzahl,falls nicht schon vorhanden.
*
*@see rechner.JRechner#dezPunkt()
*/
public void actionPerformed( ActionEvent e ){
dezPunkt();
}
}
/**
* OperatorTasten-Listener.
* Plus, Minus, Mal, Geteilt und Gleich.
* Diese Tasten markieren das Ende der bis Dato aktuellen Zahl,
* die nächste Zifferntaste beginnt also eine neue Zahl.
*/
class OpListener implements ActionListener{
/**
* Plus-, Minus-, Mal- Gleich- oder Geteilt-Button anklicken.
*
*@see rechner.JRechner#opAnnehmen( String )
*@param e ActionEvent liefert Beschriftung des geklickten Button
*/
public void actionPerformed( ActionEvent e ){
opAnnehmen( e.getActionCommand());
}
}
}
/*
* interface rechner.RModel
*
* Version 1.0
*
* 30.7.01
*
* www.AndreasGoedel.de
*
*/
package rechner;
/**
* Interface des Models des Rechners.
*
*/
public interface RModel
{
/**
* Das RModel teilt dem Rechner mit, dass 1 Ergebnis vorliegt.
*/
public void rechnerBenachrichtigen();
/**
* Der lauschende Rechner wird festgelegt.
*/
public void setRechner( Rechner ri );
/**
* Loeschen der/der Speicher(s).
*/
public void loeschen();
/**
* Das RModel bekommt eine Zahl vom Rechner.
*/
public void zahlAnnehmen( double zahl );
/**
* Das RModel bekommt einen Operator vom Rechner.
* Plus, Minus, Mal, Geteilt oder Gleich.
*/
public void opAnnehmen( String op );
}
/*
* class rechner.RechnerModel
*
* Version 1.0
*
* 30.7.01
*
* www.AndreasGoedel.de
*
*/
package rechner;
/**
* Im Model wird gerechnet.
* Zahlen und Rechenoperatoren werden vom Rechner geliefert und
* lösen im Model entsprechende Zustände und Methodenaufrufe aus.
* Bei Vorliegen eines Ergebnisses wird der Rechner benachrichtigt.
* Die Benachrichtigung erfolgt mit stateful notification.
*
*@see rechner.RechnerEvent
*@see rechner.JRechner
*/
public class RechnerModel implements RModel
{
private Long speicher1, speicher2;
private static int genau; // Genauigkeit der Dezimalstellen
private String op;
private int loesch;
private boolean err;
private boolean neueRechnung;
private Rechner rechner;
/**
* Das Model bekommt eine Zahl vom Rechner.
* Eine 1te Zahl landet in Speicher1, eine 2te in Speicher2.
*
*@param zahl der JRechner hat 1 Zahl geschickt
*/
public void zahlAnnehmen( double zahl ){
err = false;
loesch = 0;
if( getNeueRechnung() == true ){
speicher1 = new Long( (long)(zahl * genau) );
}else{
speicher2 = new Long( (long)(zahl * genau) );
}
}
/**
* Der Wert in speicher1.
*/
public double getSpeicher1Wert(){
return (double)speicher1.longValue()/(double)genau;
}
/**
* Ein neuer Rechenvorgang.
*/
public boolean getNeueRechnung(){
return neueRechnung;
}
/**
* Rechnen in den Grundrechenarten.
* Der Input kommt vom JRechner, der auch nach dem Rechnen
* benachrichtigt wird.
*
*@see RechnerModel#rechnerBenachrichtigen()
*/
public void rechnen(){
long x = speicher1.longValue();
long y = speicher2.longValue();
long erg = 0;
if( op.equals( "+" )){
erg = x + y;
}else if( op.equals( "-" )){
erg = x - y;
}else if( op.equals( "*" )){
erg = x * y / genau;
}else if( op.equals( "/" )){
if ( y == 0 ){
err = true;
loeschen();
loeschen();
}else{
erg = genau * x / y;
}
}
speicher1 = new Long( erg );
rechnerBenachrichtigen();
}
/**
* Das RModel bekommt einen Operator vom Rechner.
* Plus, Minus, Mal, Geteilt oder Gleich.
* Gleich heisst: rechnen und danach beginnt neue Rechnung.
* Die anderen Operatoren: Wenn nicht neue Rechnung, dann rechnen
* und neue Rechnung auf false setzen.
*
*@param o Operator kam vom JRechner + - * / =
*/
public void opAnnehmen( String o ){
if( o.equals( "=" )){
rechnen();
neueRechnung = true;
}else if( !o.equals( "=" )){
if( getNeueRechnung() == false ){
rechnen();
}
op = o;
neueRechnung = false;
}
}
/**
* Loeschen der/der Speicher(s).
* Ein mal löscht speicher2, 2 mal löscht alles.
*/
public void loeschen(){
if( loesch == 0 ){
speicher2 = new Long( 0 );
loesch = 1;
}else if( loesch == 1 ){
speicher1 = new Long( 0 );
speicher2 = new Long( 0 );
loesch = 0;
}
}
/**
* Den Rechner benachrichtigen.
* Ein Ergebnis liegt vor und soll vom Rechner angefordert werden,
* damit er es dem Benutzer zeigen kann.
public void rechnerBenachrichtigen(){
getRechner().ergAnzeigen( new RechnerEvent(
this, getError(), speicher1.longValue()/genau ) );
}
*/
public void rechnerBenachrichtigen(){
getRechner().ergAnzeigen( new RechnerEvent( this,
getError(),
getSpeicher1Wert() ));
}
/**
* Den Rechner festlegen, zu dem das Model gehört.
*/
public void setRechner( Rechner r ){
rechner = r;
}
/**
* Der Rechner, zu dem das Model gehört.
*/
public Rechner getRechner(){
return rechner;
}
/**
* Error ist aufgetreten.
* div/0 oder Zahl zu gross.
*/
public boolean getError(){
return err;
}
/**
* Konstruktor.
* Initialisieren der privaten Variablen.
*/
public RechnerModel(){
genau = 1000;
loesch = 0;
op = "+";
err = false;
neueRechnung = true;
speicher1 = new Long( 0 );
speicher2 = new Long( 0 );
}
}
/*
* Klasse mvc.RechenEvent
*
* Version 1.0
*
* getestet mit rechner.TestRechenEvent
*
* 6.7.01
*
* www.AndreasGoedel.de
*
*/
package rechner;
import java.util.EventObject;
/**
* Bei Vorliegen eines Ergebnisses oder Error im Model.
* Ein RechnerEvent-Objekt wird im Model immer dann erzeugt,
* wenn ein frisches Rechenergebnis oder ein Error anfällt.
* Das RechnerEvent wird mit den fraglichen Werten erzeugt:
* stateful notification.
*/
public class RechnerEvent extends EventObject
{
private RModel m;
private boolean err;
private double wert;
/**
* Konstruiert Event mit Model als EventQuelle. Aus diesem Event-Objekt
* zieht der JRechner hauptsächlich das Ergebnis der Berechnung.
*
*@param m das Model, welches dieses Event erzeugt.
*@param e Error im Model, normalerweise false.
*@param val das Ergebnis der Rechnung im Model
*/
public RechnerEvent( RModel m, boolean e, double val )
{
super( m );
err = e;
wert = val;
}
/**
* Im Model ist ein Error aufgetreten.
* Das Event-Objekt meldet diesen Error weiter an JRechner.
*
*@return Error-Zustand im Model.
*/
public boolean getErr(){
return err;
}
/**
* Der Wert, der im Model errechnet wurde.
* Das Event-Objekt meldet dieses Ergebnis weiter an JRechner.
*
*@return das Ergebnis im Model.
*/
public double getWert(){
return wert;
}
}