# Frage zu update Methode von Observer!



## michaelb (5. Aug 2006)

Hi,
ich hab da mal ne Frage:
wenn im Laufe des Programm notifyObservers aufrufe und übergeb das Objekt das ich verändert hab!
Woher weiß jetzt meine Update Methode welches Objekt übergeben wurde? Wenn ich jetzt zum Besipiel zwei Arten von Objekten habe? Soll ich jedem Objekttyp ne ID zuordnen so in einer Variable gespeichert und die dann abfragen? Wie löst ihr das? Wie macht ihr das bei großen Programmen bei denen es bestimmt sehr viele verschiedene Objekte gibt mit der zuordnung? Und eine hab ich noch: Mit addObserver trägt man ja die "Zielobjekte" ein. Wenn ich jetzt die Methode notify Observers aufrufe werden ja alle eingetragenen Klassen aufgerufen was ist, wenn ich nur bestimmte Klassen benachrichtigen will?
Gruß Michi


----------



## Anmeldeboykotierer (5. Aug 2006)

Hi,
schau dir mal das Observer Pattern etwas genauer an, dann erübrigt sich deine Frage nahezu.
Natürlich kann man dieses Pattern völlig falsch verwenden, aber es geht ja um die eigentliche Lösung (und dazu muss man dieses Pattern kennen).
Das Observer Pattern sagt aus, dass du eine Anzahl x, beliebiger Objekte immer synchron halten möchtest. Alle sollen die Veränderung an einem Beobachteten Objekt mitbekommen. 
Damit dies der Fall ist, registrieren sich die Beobachter beim beobachteten Objekt. Tritt hier ein Ereignis ein, so werden alle Beobachter über eben dieses Auftreten informiert. 
Die benachrichtigung sollte dabei über eine Methode stattfinden, die Informationen über das jeweilige Ereignis enthält. Hat also ein Beobachter 10 Ereignisse, die beobachtet werden sollen, so kann er auch 10 solche Methoden benötigen, die er registrieren muss. Für jede Methode ist damit eine eindeutige Zuordnung zu einem Ereignis möglich. 
Natürlich kann es auch sein, dass ein Beobachter 3 Ereignisse beobachtet, von denen aber 2 das gleiche Ereignis auf Unterschiedlichen Instanzen ist. Hier kannst du dann den selben Listener nehmen und bei den beiden Instanzen registrieren. Die Vorraussetzung dazu ist nur, dass die Benachritung all die Infos liefert, die der Beobachter benötigt. Ein Beobachter muss nicht immer wissen welche exakte Instanz das Ereignis ausgelöst hat. 

Wichtig ist jedenfalls, dass du nur gleiche Ereignisse mit dem gleichen Listener behandeln sollst. Damit kannst du an jedem Listener nur zugehörige Objekte (eines Typs) bekommen. Wenn du ein sauberes (abstraktes) Modell hast, dann reicht es dir hier den Typ zu kennen (bzw. sogar die Schnittstellen). Mit diesen Informationen kannst du ganz unabhängig von einem konkreten Objekt die Information über das Ereignis (und den Auslöser) abfragen und reagieren.


----------



## michaelb (5. Aug 2006)

Hi,
danke für die ausführliche Antwort!
Kannst du mir ein kurzes Beispiel geben damit ihc mir das besser vorstellen kann?
Gruß Michi


----------



## Wildcard (5. Aug 2006)

Sieh dir einfach mal die überall in Swing verwendeten Listener an. Die funktionieren nach dem Observer Prinzip.


----------



## michaelb (5. Aug 2006)

Hi,
ok werd ich machen! Bei Fragen werde ich sie hier stellen!
Gruß Michi


----------



## michaelb (5. Aug 2006)

Hi,
gibt es irgendwelche gute Standartwerke darüber? Weil ich dass mal richtig anwenden will damit meine Programme nicht immer so im Chaos enden!
Gruß Michi


----------



## Wildcard (5. Aug 2006)

Die Design Bibel:
http://www.amazon.de/gp/product/3827321999/028-4575287-9485356?v=glance&n=299956


----------



## michaelb (5. Aug 2006)

Hi,
danke für Antwort!
Bringt des Buch was? Des werd ich mir mal ansehen!
Gruß Michi


----------



## Wildcard (5. Aug 2006)

Das Standartwerk für jeden der sich für DesignPatterns interesiert.
Die Autoren haben diese Patterns selbst entwickelt, insofern sollte das Buch schon 'was bringen'  :wink:


----------



## michaelb (5. Aug 2006)

Hi,
kannst du mir anschaulich erklären was Anmeldeboykotierer mir versucht hat zu erklären?
Ich habs noch nicht so richtig verstanden mit den Methoden und so! Wäre nett!
Gruß Michi


----------



## Wildcard (5. Aug 2006)

Ich bin schreibfaul:
de.wikipedia.org/wiki/Beobachter_%28Entwurfsmuster%29


----------



## michaelb (6. Aug 2006)

Hi,
cooler Artikel!
Was ich jetzt immer noch net verstanden hab bei deinem Link die verschiedenen Aufgaben und Unterschiede der vier Komponenten des UML Diagramms.... ich glaub ich sollte mir das Buch kaufen!
Gruß Michi


----------



## byte (6. Aug 2006)

michaelb hat gesagt.:
			
		

> Mit addObserver trägt man ja die "Zielobjekte" ein. Wenn ich jetzt die Methode notify Observers aufrufe werden ja alle eingetragenen Klassen aufgerufen was ist, wenn ich nur bestimmte Klassen benachrichtigen will?



Es werden immer automatisch alle angemeldeten Observer benachrichtigt. Du solltest also nur diejenigen anmelden, die auch wirklich Interesse an dem Observable haben. Wenn ich Dich richtig verstanden habe, dann hast Du einen Observer bei mehreren Observables angemeldet? Dann kannst Du ja immernoch in der update() Methode das übergebene Observable mit instanceof prüfen und dann für jeden Observable etwas anderes machen.

Schöner ist es aber sicherlich, wenn ein Observer sich auch nur bei einem Observable anmeldet und Du bei Dir lieber mehrere Observer machst, die dann jeweils ihre eigene update() Methode ohne instanceof implementieren.


----------



## michaelb (6. Aug 2006)

Hi,
danke für die Antwort!!
Gut so werd ich es machen! Aber ich denk mal um das Buch werde ich nicht rumkommen!
Gruß Michi


----------



## byte (6. Aug 2006)

Das Buch hab ich auch. Eine bessere Geldanlage gibts fast nicht.  Wenn Du Englisch kannst, solltest Du Dir aber lieber nicht die deutsche Übersetzung holen. :roll:


----------



## michaelb (6. Aug 2006)

Hi,
so hab ich es bis jetzt:

*View*


```
package view;

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import java.util.Observable;
import java.util.Observer;

import control.*;
import model.*;

/**
 * 
 * @author Michael
 *
 */


public class robotview extends JFrame implements Observer{
	private JTextField eingabe;
	private JLabel anzeige;
	private robotcontrol controller;
	
	public robotview(robotcontrol controller){
		super("Roboter -> MVC Test");
		setSize(300,100);
		this.controller = controller;
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		init();
		setVisible(true);
	}
	
	public void init(){
		JPanel Bupanel = new JPanel(new BorderLayout());
		eingabe = new JTextField();
		eingabe.setText("123456789");
		JButton enter = new JButton("übertrage");
		enter.addActionListener( new ActionListener(){
			public void actionPerformed(ActionEvent e){
				controller.übertrage(eingabe.getText());		
			}
		});
		anzeige = new JLabel("Hier wird mal angezeigt ^^");
		Bupanel.add(eingabe, BorderLayout.WEST);
		Bupanel.add(enter, BorderLayout.EAST);
		Bupanel.add(anzeige, BorderLayout.SOUTH);
		getContentPane().add(Bupanel);
	}
	
	
	public void update(Observable arg0, Object arg1){
		robotmodel model = (robotmodel) arg1;
		anzeige.setText(String.valueOf(model.getSensorlinks()));
	}
}
```

*Controller*


```
package control;

import model.*;
import view.*;

import java.util.Observable; 
import java.util.Observer; 


public class robotcontrol extends Observable{
	private robotmodel robot;
	
	public robotcontrol(){
		robotview viewer = new robotview(this);
		addObserver(viewer);
		robot = new robotmodel();
	}
	
	public void übertrage(String text){
		robot.setSensorlinks(Integer.parseInt(text));
		setChanged();
		notifyObservers(robot);
	}
	
	public static void main(String[] args){
		new robotcontrol();
	}
}
```

*Model*


```
package model;

/**
 * @author Michael
 */

public class robotmodel {
	private int sensorlinks = 0;
	private int sensorrechts = 0;
	
	/**
	 * 
	 * @param wert The value of the sensor on the left
	 */
	public void setSensorlinks(int wert){
		this.sensorlinks = wert;
	}
	
	/**
	 * 
	 * @param wert The value of the sensor on the right
	 */
	public void setSensorrechts(int wert){
		this.sensorrechts = wert;
	}
	
	/**
	 * 
	 * @return sensorlinks the value of the sensor on the left
	 */
	public int getSensorlinks(){
		return sensorlinks;
	}
	
	/**
	 * 
	 * @return sensorrechts the value oft the sensor on the right
	 */
	public int getSensorrechts(){
		return sensorrechts;
	}
	
}
```

ist das nach dem MVC Prinzip korrekt? Was kann daran verbessern bzw. was muss man? Setze ich die Methoden richtig ein?

Gruß Michi


----------



## byte (6. Aug 2006)

Also ich hätte das etwas anders gemacht. Der Controller soll ja laut MVC als Brücke zwischen Model und View dienen, so dass diese beiden Subsysteme mehr oder weniger unabhängig voneinander sind. Demnach würde es in meinen Augen mehr Sinn machen, wenn das Model (RobotModel) das Observable ist und der Controller (RobotControl) der Observer. Demnach gehört die Methode übertrage() ins Model. Denn das ist ja offenbar die Methode, die Manipulationen am Model ermöglicht. Und Methoden, die ein Objekt manipulieren können, gehören i.d.R. nach OOP dann auch in dieses Objekt. RobotControl wäre dann die Brücke zwischen RobotView und RobotModel. Es hält also Referenzen auf beide Objekte und ist als Observer beim RobotModel angemeldet. Sobald sich das Model ändert, erfährt es der Controller und kann in der update() Methode diese Veränderungen des Models in der ebenfalls bekannten View sichtbar machen.


----------



## michaelb (6. Aug 2006)

Hi,
danke für die Antwort! 
Stimmt mir ist es gerade aufgefallen nachdem ich UML Diagramme gezeichnet habe, dass meine Lösung mehr oder weniger Quatsch ist, da ja dann die View der Observer ist was eigentlich der Controller sein sollte! Jetzt muss ich es nur noch umändern!
Gruß Michi


----------



## byte (6. Aug 2006)

So doller Quatsch ist das nun auch nicht.  View und Controller können schonmal verschmelzen. Aber der Controller sollte halt keine Funktionalität des Models implementieren (übertrage() bei Dir).

Man muss sich halt immer vor Augen halten, was der Sinn von MVC ist, also die Kapselung der Subsysteme, um somit potentiell die Wiederverwendung von Code zu ermöglichen. Das Model sollte demnach immer strikt getrennt werden von der View. Dann könnte man das gleiche Model später auch mit einer anderen View wiederverwenden, falls das mal gewünscht ist. Die andere Seite - also die Wiederverwendung der View für ein anderes Model - finde ich meistens eher etwas fraglich. Denn die View wird ja in den meisten Fällen auch für ein ganz bestimmtes Model implementiert. Also finde ich es nicht so schlimm, wenn sich View und Controller mal vermischen.


----------



## michaelb (6. Aug 2006)

Hi,
so ich habs umgeändert! Puuh da musste ich ja paar Sachen ändern Getter Methoden für meine Privaten Dinger und so weiter...
So hab ich's bis jetzt:

*View*


```
package view;

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import java.util.Observable;
import java.util.Observer;

import control.*;
import model.*;

/**
 * 
 * @author Michael
 *
 */


public class robotview extends JFrame{
	private JTextField eingabe;
	private JLabel anzeige;
	private robotcontrol controller;
	private robotmodel model;
	
	public robotview(robotcontrol controller, robotmodel model){
		super("Roboter -> MVC Test");
		setSize(300,100);
		this.controller = controller;
		this.model = model;
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		init();
		setVisible(true);
	}
	
	public void init(){
		JPanel Bupanel = new JPanel(new BorderLayout());
		eingabe = new JTextField();
		eingabe.setText("123456789");
		JButton enter = new JButton("übertrage");
		enter.addActionListener( new ActionListener(){
			public void actionPerformed(ActionEvent e){
				model.übertrage(eingabe.getText());		
			}
		});
		anzeige = new JLabel("Hier wird mal angezeigt ^^");
		Bupanel.add(eingabe, BorderLayout.WEST);
		Bupanel.add(enter, BorderLayout.EAST);
		Bupanel.add(anzeige, BorderLayout.SOUTH);
		getContentPane().add(Bupanel);
	}
	
	public void setTextField(String text){
		anzeige.setText(text);
	}
	
}
```

*Controller*


```
package control;

import model.*;
import view.*;

import java.util.Observable; 
import java.util.Observer; 


public class robotcontrol implements Observer{
	private robotmodel robot;
	private robotview viewer;
	
	public robotcontrol(){
		robot = new robotmodel(this);
		viewer = new robotview(this, robot);
		
	}
	
	
	
	public void update(Observable arg0, Object arg1){
		robotmodel model = (robotmodel) arg1;
		viewer.setTextField(String.valueOf(model.getSensorlinks()));
	}
	
	public static void main(String[] args){
		new robotcontrol();
	}
}
```

*Model*


```
package model;

import java.util.Observable;
import java.util.Observer;

import control.*;

/**
 * @author Michael
 */

public class robotmodel extends Observable {
	private int sensorlinks = 0;
	private int sensorrechts = 0;
	private robotcontrol control;
	
	public robotmodel(robotcontrol control){
		this.control = control;
		addObserver(control);
	}
	
	/**
	 * 
	 * @param wert The value of the sensor on the left
	 */
	public void setSensorlinks(int wert){
		this.sensorlinks = wert;
	}
	
	/**
	 * 
	 * @param wert The value of the sensor on the right
	 */
	public void setSensorrechts(int wert){
		this.sensorrechts = wert;
	}
	
	/**
	 * 
	 * @return sensorlinks the value of the sensor on the left
	 */
	public int getSensorlinks(){
		return sensorlinks;
	}
	
	/**
	 * 
	 * @return sensorrechts the value oft the sensor on the right
	 */
	public int getSensorrechts(){
		return sensorrechts;
	}
	
	public void übertrage(String text){
		setSensorlinks(Integer.parseInt(text));
		setChanged();
		notifyObservers(this);
	}
	
}
```

....so. Ist das jetzt besser bzw. sinnvoller? Hab ich das jetzt richtig umgeändert? Ist das richtig dass die View den Controller und das Model kennt? Und das der Controller auch die View und das Model kennt? Und das Model nur den Controller? Was kann man sont noch besser umstrukturieren?

Gruß Michi


----------



## byte (6. Aug 2006)

Du hast es fast, aber nur fast. 

Das Model braucht den Controller nicht zu kennen. Wenn der Controller das Model kennt, kann er sich doch selbst dort als Observer hinzufügen, ohne dass das Model davon etwas mitkriegen braucht.

Die View braucht das Model auch nicht zu kennen. Die View sollte für alle seine Komponenten (z.B. Buttons etc.) getter bereitstellen, so dass der Controller darauf zugreifen kann. Dann reicht es nämlich, wenn der Controller das Model kennt. Dann kann er, wenn sich dieses ändert, auf die einzelnen Komponenten der View zugreifen und diese verändern.


----------



## michaelb (6. Aug 2006)

Hi,
die View muss aberauf das Model zugreifen können! Sonst kann sie nicht im ActionListener auf die Methode übertragen im Model zugreifen!
Gruß Michi


----------



## michaelb (6. Aug 2006)

Hi,
also muss ich dem Konstruktor des Model nix übergeben also nen leeren Konstruktor machen:


```
public robotmodel(){
}
```

und dann im Konstruktor des Controllers dieses machen:


```
robot.addObserver(this);
```

und dann muss ich im Controller noch ne Update Methode hinzufügen!

Gruß Michi


----------



## byte (6. Aug 2006)

michaelb hat gesagt.:
			
		

> Hi,
> die View muss aberauf das Model zugreifen können! Sonst kann sie nicht im ActionListener auf die Methode übertragen im Model zugreifen!
> Gruß Michi



Doch, Du kannst den JButton als Klassenvariable deklarieren mit getter. Dann kann der Controller dem Button den ActionListener hinzufügen.

Also so in der Art:


```
view.getEnterButton().addActionListener( new ActionListener(){
         public void actionPerformed(ActionEvent e){
            model.übertrage(view.getEingabeFeld().getText());      
         }
      });
```


----------



## michaelb (7. Aug 2006)

Hi,
so jetzt hab ich alles umgeändert dass nur noch der Controller die view und das Model kennt und die View und das Model kennt niemanden!

*View*


```
package view;

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;

import control.*;
import model.*;

/**
 * 
 * @author Michael
 *
 */


public class robotview extends JFrame{
	private JTextField eingabe;
	private JLabel anzeige;
	private JButton enter;
	
	public robotview(){
		super("Roboter -> MVC Test");
		setSize(300,100);
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		init();
		setVisible(true);
	}
	
	public void init(){
		JPanel Bupanel = new JPanel(new BorderLayout());
		eingabe = new JTextField();
		eingabe.setText("123456789");
		enter = new JButton("übertrage");
		anzeige = new JLabel("Hier wird mal angezeigt ^^");
		Bupanel.add(eingabe, BorderLayout.WEST);
		Bupanel.add(enter, BorderLayout.EAST);
		Bupanel.add(anzeige, BorderLayout.SOUTH);
		getContentPane().add(Bupanel);
	}
	
	public void setTextField(String text){
		anzeige.setText(text);
	}
	
	public JButton getEnterButton(){
		return enter;
	}
	
	public JTextField getEingabeFeld(){
		return eingabe;
	}
	
	
}
```

*Controller*


```
package control;

import model.*;
import view.*;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Observable; 
import java.util.Observer; 


public class robotcontrol implements Observer{
	private robotmodel robot;
	private robotview viewer;
	
	public robotcontrol(){
		robot = new robotmodel();
		viewer = new robotview();
		robot.addObserver(this);
		viewer.getEnterButton().addActionListener( new ActionListener(){
			public void actionPerformed(ActionEvent e){
				robot.übertrage(viewer.getEingabeFeld().getText());
			}
		});
		
	}
	
	public void update(Observable arg0, Object arg1){
		robotmodel model = (robotmodel) arg1;
		viewer.setTextField(String.valueOf(model.getSensorlinks()));
	}
	
	public static void main(String[] args){
		new robotcontrol();
	}
}
```

*Model*


```
package model;

import java.util.Observable;
import java.util.Observer;

import control.*;

/**
 * @author Michael
 */

public class robotmodel extends Observable {
	private int sensorlinks = 0;
	private int sensorrechts = 0;
	
	public robotmodel(){
	}
	
	/**
	 * 
	 * @param wert The value of the sensor on the left
	 */
	public void setSensorlinks(int wert){
		this.sensorlinks = wert;
	}
	
	/**
	 * 
	 * @param wert The value of the sensor on the right
	 */
	public void setSensorrechts(int wert){
		this.sensorrechts = wert;
	}
	
	/**
	 * 
	 * @return sensorlinks the value of the sensor on the left
	 */
	public int getSensorlinks(){
		return sensorlinks;
	}
	
	/**
	 * 
	 * @return sensorrechts the value oft the sensor on the right
	 */
	public int getSensorrechts(){
		return sensorrechts;
	}
	
	public void übertrage(String text){
		setSensorlinks(Integer.parseInt(text));
		setChanged();
		notifyObservers(this);
	}
	
}
```

ich denk mal jetzt ist alles nach dem MVC Prinzip korrekt! Eigentlich kann ich ja in der View dann die Imports des ActionListeners und des ActionEvents weglassen sowie im View und im Model die Imports der Packages control und model bzw. der Control. Jetzt versteh ich wenigstens schon viel besser das ganze System! Gibt's sonst noch was zum ändern?

Gruß Michi


----------



## byte (7. Aug 2006)

Jetzt siehts imo gut aus. Die Imports können natürlich auch angepasst werden. Welche IDE benutzt Du denn zum programmieren? Eine gute IDE wie Eclipse kümmert sich automatisch um die Imports.


----------



## michaelb (7. Aug 2006)

Hi,
ja ich benutze Eclipse. Aber wenn ich im Controller die Imports weglasse dann meckert Eclipse! Ich hab die verschiedenen Komponenten in verschiedenen Packages. Die Import brauche ich ja nur im Controller da ich ja nur da von denen instanziere.
Gruß Michi


----------



## byte (7. Aug 2006)

Dann drück einfach mal STRG + SHIFT + O.


----------



## michaelb (7. Aug 2006)

Hi,
schönes Tastenkürzel!!
Ich hab noch ne Frage:
Da ich mit meinem Progrämmchen die Serielle Schnittstelle abfragen muss ich ja entsprechend ein Model bauen das die ganzen Methoden enthält wie einlesen oder senden usw. Kommt das dann auch in den Model Teil? Ist das schlimm wenn sich die Models untereinander kennen?
Gruß Michi


----------



## AlArenal (7. Aug 2006)

Da ich ein Kleinkrämer bin, sag ich mal, dass der Zugriff auf die ser. Schnittstelle nichts im Model zu suchen hat. Ein Model besorgt sich seine Daten nicht aktiv selbst, sondern bietet ein Schnittstelle, diese einzufügen und zu ändern und benachrichtigt dann die registrierten Views über diese Änderungen.


----------



## michaelb (7. Aug 2006)

Hi,
ich hab eher gedacht dass da halt solche Methoden liegen wie writedata und so und diese werden dann vom Controller aufgerufen! Und und wenn halt ein Event passiert (wenn Daten angekommen sind) dann werden halt die Daten im Model ausgewertet oder soll ich das Event an den Controller weiterleiten und dann den InputStream per Getter bereitstellen zum auslesen?
Gruß Michi


----------



## Wildcard (7. Aug 2006)

Du solltest einen Export und einen Import bereitstellen der in deinem Fall zB Daten von der Seriellen Schnittstelle liest und dann (evtl. mit einer Factory) ein Model zusammenbaut.


----------



## michaelb (7. Aug 2006)

Hi,
wie meinst du des?
Also soll ich ne Klasse erstellen die die serielle ausliest und auf diese schreibt(Import und Export)? Wie meinst du das mit Factory?
Gruß Michi


----------



## Wildcard (7. Aug 2006)

Ja genau. Eine Klasse für den Import, eine für den Export.
Das mit der Factory hängt im wesentlichen von deinem Model ab.
Das üblich Weg ist für jede Model Klasse ein Interface zu erstellen das nur die benötigten Methoden bereitstellt.
Die konkreten Instanzen werden dann über eine Factory ertstellt, die allerdings nur Objekte vom Typ des Interfaces zurückliefert. Das hat den Vorteil das man eventuel nötige Konfigurationen am Model in der Factory erledigen kann und dass die Model-Implementierung nur der Factory bekannt ist, und das Model somit austauschbar ist.


----------



## michaelb (7. Aug 2006)

Hi,
soll ich also zweimal mal vom SerialPort instanzieren? Dann hab ich aber zwei verschiedene Objekte! Wenn ich dann da mal die Parameter umstellen muss... bis jetzt hab ichs mit Methoden gemacht also eine fürs lesen und eine fürs schreiben. Was könnte es bringen wenn ich Klassen verwende?
Was bringen eigentlich Interfaces nochmal genau? Und was bringt mir die Factory?
Gruß Michi


----------



## Wildcard (7. Aug 2006)

Was hindert dich statische Methoden für In- und Export zu verwenden?
Ich weiß natürlich nicht wie kompliziert die Daten sind die du verwaltest, und davon hängt letztlich der Sinn des ganzen ab.
Sowohl die Factory als auch die Interfaces haben den Nutzen das du die konkrete Implementierung vor dem Rest deines Programms verstecken kannst, womit es insgesamt flexibler wird.


----------



## michaelb (7. Aug 2006)

Hi,
warum statische Methoden?
Gruß Michi


----------



## Wildcard (7. Aug 2006)

Warum denn nicht? Der Ex-, Import eines Models ist in der Regel nicht Objektgebunden.


----------



## michaelb (7. Aug 2006)

Hi,
ich hab dass noch nicht verstanden! Ich lese ja nur Zahlenwerte ein und keine Models! Was bringen statische Methoden?
Gruß Michi


----------



## Wildcard (7. Aug 2006)

Und die Zahlenwerte benutzt du doch um ein Model zu füllen, oder?
Was statische Methoden bringen? Was ist denn das für ne Frage?  ???:L


----------



## michaelb (7. Aug 2006)

Hi,
mir es gerade eingefallen wie du des mit den statischen Methoden gemeint hast!  
Ich soll die als statisch deklarieren damit es nur eine Implementierung dieser Methoden gibt und somit auch nur immer diese zwei Methoden verwendet werden. Und die Sachen wie den InputStream und OutputStream usw. soll ich die auch als static kennzeichnen?
Gruß Michi


----------

