# Design Pattern für einen simple Rechenmaschine



## Kaffeebohne (27. Apr 2006)

Hallo Forenteilnehmer,

ich will einen kleine Rechnenmaschine programmieren. Ohne Lexer und großartige Beachtung der Ranges von Datentypen und nur die vier Grundrechenarten. Es geht mir nur um das/die Pattern.

Also stelle mir einmal ein Interface vor (Stragtegiepattern) das die Methode bereche, calcualte whatever hat. Dies müssen dann alle Rechenarten implementieren.

Desweitern, ich weiss aber noch nicht ob das Relevant ist, würde ich eine Abstrakte Klasse für die jeweiligen Rechenarten bauen. Also zb. abstractAdd als abstrakte Klasse mit dem implementierenten berechene. Die konkrete Klasse würde dann z.b. AddSimpleImpl heissen. Simple wegen den Ranges  

Später könnte ich dann alles Austauschen ohne die Eigentlichen Rechenablauf zu ändern.

Was haltet ihr davon?


----------



## byte (27. Apr 2006)

Mal abgesehen davon, dass sich die Addition seit hunderten von Jahren nicht verändert hat, klingt das ok. Abstrahieren ist selten verkehrt.


----------



## Kaffeebohne (27. Apr 2006)

Hallo byto,


nur gehen ja integer nicht z.b. über 32k. Ich habe noch nicht geschaut, aber vielleicht/wahrscheinlich gibt es in JAVA auch etwas um Mathematische Operationen beliebiger genauigekeit durchzuführen.


Ne andere Frage wie würdest du das machen, wenn der Wert übergeben wird mit dem etwas gemacht werden soll. Per Konstruktor oder mit beim berechnen. Etwas wirre Formulierung deshalb ein Beispiel:

Berechenet werden soll 1+1 (der Hammer :bae: )



```
AddSimpleImpl add = new AddSimpleImpl(1);
System.out.println(add.berechne(1));

//Oder
AddSimpleImpl add = new AddSimpleImpl();
System.out.println(add.berechne(1,1));
```


----------



## Murray (27. Apr 2006)

Ich würde den zweiten Weg bevorzugen: warum sollte der erste Operand Attribut der Klasse sein, während der zweite nur als Parameter einer Instanzmethode übergeben wird? Interessant wird das, wenn Du so ein AddSimpleImpl-Objekt wiederverwenden willst. Mit dem ersten Weg geht das nur dann, wenn Du zu einer Zahl nacheinander verschiedene andere addieren willst.
M.E. sollte so ein AddSimpleImpl-Objekt möglichst zustandslos sein; alle für die Berechnung notwendigen Informationen werden in dem Call mitgegeben, der auch das Ergebnis liefert.


----------



## Kaffeebohne (27. Apr 2006)

Hallo Murray,

hmm das ist eine gute Frage. Also ich dachte da man ja mit eine Zahl die ist mit der etwas passiert. Die also addiert wird.  (Anmerkung an mich selbst: Hätte wohl besser dividieren als Beispiel genommen.)


```
alle für die Berechnung notwendigen Informationen werden in dem Call mitgegeben, der auch das Ergebnis liefert.
```
Was meinst du damit genau? Es werden ja nur Zahlen || Zahler[] übergeben.


----------



## math66 (27. Apr 2006)

schonmal was von patternfever gehört? man sollte nicht für alles patterns nehmen, da dadurch oftmals ERSTMAL mehraufwand entsteht (mehr klassen etc). und bei grundrechenarten ist das sicher nicht nötig. hibts jetzt allerdings komplexe algorithmen zur berechnung von was weiss ich bildaten doer so, dann empfiehlt es sich. take out what varies...aber wie schon gesagt wurde... + * - / werden wohl bin in alle zeit gleich bleiben 

gruß


----------



## byte (27. Apr 2006)

Kann Murray nur recht geben. Ist halt ein etwas blödes Beispiel, dass Du Dir ausgesucht hast. Nicht ohne Grund sind die arithmetischen Funktionen aus Math alles statische zustandslose Methoden.


----------



## Kaffeebohne (27. Apr 2006)

Hy math66, 

jupp, auch von Antipattern. Nur will(naja muss) ich in diesem Fall zeigen wie man OO programmiert. Es soll eher als Beispiel dienen wie man Pattern und OO einsetzen kann.


@byto
Ich weiss    :roll:  :wink:  



Mal davon abgesehen, was haltet ihr vom "Prinzip"? (Ich mein nicht das ich jetzt das Patternfever hab)


----------



## Kaffeebohne (27. Apr 2006)

Noch ein kleiner Zusatz,

wie sieht es aus wenn ich eine Factory zum Erzeugen der Objekte benutzen würde, da ich die Objekte zur Laufzeit erzeugen möchte?


----------



## math66 (27. Apr 2006)

dann nimm doch was mit dateien und zeigs daran. also so:


```
abstract class FileReader{
    abstract String readFile(File f);

}
```


dann eben andere klassen, die diese methode implementieren:


```
class XMLFileReader extends FileReader{

     public String readFile(File f){
          //XML file auslesen und parsen oder was weiss ich
     }
}

class ZIPFileReader extends FileReader{

     public String readFile(File f){
          //ZIP file auslesen  was weiss ich
     }
}
```

und dann je nach endung machst du sowas:


```
if(f.toString().endsWith(".zip")){
        FileReader fr = new ZIPFileReader()
        String content = fr.readFile(f);
}
```

wäre ein beispiel. oder du machst was mit tieren. oberklasse Ente, und unterklassen GummiEnte, HolzEnde, StcokEnte und so weiter. die erben vond er abstrakten klasse duck gewisse gleiche dinge, wie swim(). aber sie unterscheiden sich im flugverhalten. also nimmst du das raus per stragedy....war mal in nem buch, weiss aber nicht mehr in welchem :-/

viele grüße


----------



## math66 (27. Apr 2006)

hi, noch ein beispiel. man kann textfeldeingaben damit kontrollieren. so:


```
abstract class AbstractChecker //oder interface {
	abstract boolean checkContent(String mail);
}

class EmailChecker extends AbstractChecker{

    boolean checkContent(String mail){
		return mail.matches(".+@.+\\.[a-z]+"); 
	}
}

class MyJTextFiled extends JTextField{
	AbstractChecker a;

	public MYJTextField(AbstractChecker a){
		this.a=a;
	}

	FocusListener listener = new FocusListener() {
      public void focusGained(FocusEvent e) {
        //nix machen
      }

      public void focusLost(FocusEvent e) {
        if(a.checkContent(this.getText())){ //a ist hier ein EMailChecker
			//ok
		}else{
			this.setText("Fehler in der Eingabe!");
		}
      }

      
    };

}

class Tester{
	MyJTextField mjtf = new MyJTextField(new EMailChecker());
	//mjtf in das GUI packen und fertig

}
```

ist mal so schnell hingeschrieben...weiss nicht, obs gleich geht, aber so in der art

gruß


----------



## Kaffeebohne (27. Apr 2006)

Hmm,

leider lässt sich daran nix drehen. Enten wären mir auch lieber   


btw

Ich würd ne Factory noch machen:




```
class FileReaderFactory {
....
	public FileReader getInstance{File f)  throws Exception{
        if(f.toString().endsWith(".zip")){
            return new ZIPFileReader();
           
        }else f(f.toString().endsWith(".xml")) {
        	return new XMLFileReader();
    	}
	} else { throw new Exception("blub")}
}
```


----------



## math66 (27. Apr 2006)

gute idee....wie würde man die jetzt einsetzen? factory method hab ich noch nicht genutzt....

gruß


----------



## Kaffeebohne (27. Apr 2006)

Achso der Konstruktor muss natürlich private oder protected sein und getInstance static


```
FileReader fr = FileReaderFactory.getInstance(new File("xmlfile.xml"));
```


----------



## math66 (27. Apr 2006)

also ein singleton als fabrikmethode....genau! 

bis denne


----------



## math66 (27. Apr 2006)

hi, nocmal, kannste den code nochmal komplett posten, also die factotry? so wies richtig ist?

gruß und danke :lol:


----------



## Murray (27. Apr 2006)

In manchen Frameworks wird der Factory-Gedanke auch noch weitergetrieben, indem man die Factory(-Instanz) wiederum indirekt über eine Factory-Methode erhält; siehe z.B.:


```
javax.xml.tranform.TransformerFactory transFac = javax.xml.tranform.TransformerFactory.newInstance();
javax.xml.tranform.Transformer trans = transFac.newTransformer());
```

Analog funktioniert das z.B. auch mit javax.xml.xpath.XPathFactory und javax.xml.xpath.XPath oder mit javax.xml.parsers.DocumentBuilderFactory und javax.xml.parsers.DocumentBuilder, wobei man im letzten Fall den DocumentBuilder eigetnlich auch wieder als eine Art Factory ansehen könnte.


----------



## math66 (27. Apr 2006)

ich nochmal, ich dneke mal, ich habs jetzt. was sind die vorteile? ich würde sagen:

- also erstmal ist die implementierung der filereader gekapselt, man kann sie veränder, ohne jeweils eine andere klasse anfassen zu müssen

- mann kann schnell neue reader hinzufügen

- man kann collections/methoden machen, die FileReader objekte aufnehem, also mehere spezielle reader wie zip oder jar oder.... (polymorphismus)

- durch die factory ist man flexibel, was wann passiert. wenn man anstelle von XMLFileReader  doch was anderesr erzeugen will, muss man das nur an einer stelle, nämlich in der factory machen. anders müsste man an jeder stelle in jeder klasse änderungen vornehmen

was noch?

grüße


----------



## Kaffeebohne (27. Apr 2006)

Hy math66,

also mir fällt da auch nichts mehr großartiges ein. Denke du hast alle wichtigen Punkte aufgezählt. 


Wenn ich mirs so überlege ist die Factory aufjedenfall eine gute Idee für meine Rechnenmaschine.


@all

Was meint ihr was für ein Pattern könnte ich noch verwenden?


----------

