# Was kann man unter implementieren so verstehen?



## math.iso@live.de (21. Dez 2008)

Hy java mitglieder ,ich hab Verstänidprobleme.

Was versteht ihr unter wenn ihr sagen wir mal aus dem i-net liest , die Klasse Rectangle implementiert die Klasse Shape , was heißt das für euch?


Oder die Klasse Rectangle implementiert das Interface Shape ?

implemenieren...????

oder ein anderes beispiel wäre dieser Kontext 


> public class KontoFrame extends Frame
> implements ActionListener, WindowListener





ich hoffe ihr könnt mir helfen ,und falls es geht sollte eure antwort auch nicht sehr knapp sein   [/quote]


----------



## foobar (21. Dez 2008)

Eine Klasse kann ein oder mehrere Interfaces implementieren dadurch wird sie zu einem Typ dieses Interfaces. D.h. du mußt jetzt alle Methoden dieses Interfaces in der Klasse implementieren.
Eine Klasse kann aber keine andere Klasse implementieren, weil eine Klasse bereits konkret ist ein Interface aber nur abstrakte Methoden enthält.


----------



## Landei (21. Dez 2008)

"extends" heißt, die Kasse erweitert ihre Elternklasse. Soll heißen, KontaFrame hat und kann alles, was Frame kann und fügt eventuell noch eigenes Verhalten hinzu.

"implements" heißt zwar "implementiert", aber das ist meiner Meinung nach etwas unglücklich ausgedrückt. Du kannst dir ein Interface wie einen "Vertrag" vorstellen: Wer den Vertrag "unterschreibt" (implementiert), muss bestimmte "Bedingungen" erfüllen (Methoden implementieren).
"implements ActionListener" heißt also nichts weiter als, "ich habe alle Methoden implementiert, die im ActionListener-Vertrag drinstehen (nämlich actionPerformed(ActionEvent) ), die könnt ihr ruhig aufrufen"


----------



## math.iso@live.de (21. Dez 2008)

wozu braucht man dann ein exstend von einer kleiner klasse , wenn ich sowieso alles übertragen kann von interface ,und warum müssen die methoden neu geschrieben werden..?


----------



## SirGecco (21. Dez 2008)

In den Interfaces sind die Methoden nur abstrakt definiert, d. h. in den Klassen, die das Interface implementieren, werden die Methoden mit "Leben" gefüllt. Alles was von Oberklassen geerbt wird (extends) ist bereits konkretisiert (mit "Leben" gefüllt). (Außnahme es handelt sich um abstrakte (Ober)Klassen, hier müssen dann die abstrakten Methoden konkretisiert werden)


----------



## Guest (21. Dez 2008)

Das Interface gibt vor, welche Methoden Du in den konkreten Klassen programmieren musst. In den Interfaces selbst steht überhaupt kein Code, sondern es werden nur die Methodennamen mit Rückgabewert und Parametern angegeben. 

Zu Deinem Beispiel mit Shape (Form) und Rectangle (Rechteck).

In einer Firma arbeiten 3 Mitarbeiter, die gemeinsam an einem Programm entwickeln. Mit diesem Programm sollen verschiedene mathematische Berechnungen und die Darstellung von Formen möglich sein.

Der 1 Mitarbeiter schreibt das Hauptprogramm, welches die verschiedene Formen benutzt, d.h. diese anzeigt und mit ihnen Berechnungen ausführt. Da er allerdings nicht auch noch die konkreten Klassen für die Formen Kreis, Rechteck, Quadrat, Raute, Dreieck programmieren kann (aus Zeitmangel), er aber bereits weiß, welche Funktionen/Methoden alle diese Klassen *gemeinsam* haben müssen, schreibt er für die beiden anderen Mitarbeiter eine Vereinbarung/Interface.


```
interface Form {

public double berechneUmfang(); 
public double berechneFlaeche();
public void formAnzeigen();
public void formAusmalen(Color color);
usw.
}
```

Anschließend gibt er dieses Interface an die beiden anderen weiter, mit der Bitte die noch fehlenden Klassen Kreis, Rechteck, Quadrat, Raute, Dreieck zu programmieren. Durch das Interface wissen jetzt beide Mitarbeiter, welche Methoden die konkreten Klassen unbedingt haben müssen. Und so programmieren sie die konkreten Klassen.


```
public class Kreis implements Form {

//Konstruktor
public Kreis(){}

public double berechneUmfang() {

    //Hier steht der Code zur Berechnung des Umfanges
   return umfang;

} 

public double berechneFlaeche() {

    //Hier steht der Code zur Berechnung der Fläche
   return flaeche;

}

public void formAnzeigen() {

    //Hier steht der Code zum Anzeigen
   return umfang;

}

public void formAusmalen(Color color) {

    //Hier steht der Code zum Ausmalen
   return umfang;

}

... entsprechend die weiteren Klassen
```

Interfaces helfen außerdem Deinen Code von konkreten Implementierungen zu entkoppeln. D.h. Der Mitarbeiter, der das Hauptprogramm schreibt, verwendet in seinem Programm einfach das Interface und lässt sich eine konkrete Klasse z.B. durch eine Factory erzeugen bzw. injezieren (Stichpunkte Dependency Injection und Spring). 


```
//irgendwo im Programm
Form meineForm = Factory.erzeugekonkreteForm();
```

Das aber nur so am Rande.


----------



## Guest (21. Dez 2008)

Korrektur:


```
public void formAnzeigen() { 

    //Hier steht der Code zum Anzeigen 

} 

public void formAusmalen(Color color) { 

    //Hier steht der Code zum Ausmalen

}
```


----------



## L-ectron-X (21. Dez 2008)

http://de.wiktionary.org/wiki/implementieren


----------



## math.iso@live.de (21. Dez 2008)

Hätte jetzt dazu 2 weiteren fragen   


1)Muss man wenn man eine Klasse implementiert ,dass man alle methoden dann mit "leben" füllen muss?könnte man auch nur einige methoden mit leben füllen...

2)Eigentlich wenn man sich recht überlegt ,kommt mir eine implementierung sinnlos vor , denn ich muss ja die abstracten methoden von interface nochmal bei der implementierte klasse nochmal neuschreiben oder ?hab ich eine wichtige eigenschaft übersehen ?






```
public class KontoFrame extends Frame 
implements ActionListener, WindowListener
```


----------



## Ice-Tea (21. Dez 2008)

zu 1) nein du musst nicht alle methoden implementieren. Aber du musst diejenigen Methoden , die kein "leben" beinhalten als abstract definieren. Das hat allerdings den Nachteil, das du auch die Klasse die als abstract definieren musst.

Bsp:

```
abstract interface Namen{
public String getVorname();
abstract String getNachname();
}

abstract class TierImpl implements Namen{
public String getVorname(){
   return "Wuffel";
}
public abstract String getNachname();
}

class MenschImpl implements Namen{
public String getVorname(){
   return "Hans";
}
public String getNachname(){
   return "Wurst"
}
}
```

das Tier hat zwar einen Vornamen, jedoch keinen Nachnamen. Daher brauchst du auch keinen Methodenrumpf zu implementieren. Java aber erwartet aber, dass alle Methoden überschrieben werden.


zu 2) das kommt auf den Anwendungfall an.

Für ein Programm, dass nur aus einer Klasse besteht mach ein Interface wenig sinn.

EDIT: du kannst das abstract auch weglassen, dann musst du aber der Methode sagen was es die zu tun hat.
etwas so:

```
nterface Namen{
public String getVorname();
abstract String getNachname();
}

lass TierImpl implements Namen{
public String getVorname(){
   return "Wuffel";
}
public String getNachname(){
   return null;
}
}

class MenschImpl implements Namen{
public String getVorname(){
   return "Hans";
}
public String getNachname(){
   return "Wurst"
}
}
```


----------



## math.iso@live.de (21. Dez 2008)

@Ice-Tea:

Was wäre an  der 4 Zeile deines Programms wenn da stehen würde
	
	
	
	





```
public String getNachname
```

wie  müsste man die Klasse die Tierimp verändern ,damit man die methode getNachname nicht mit leben füllt.

"müsste es in dem fall 
	
	
	
	





```
public String getNachname
```
 heißen ? "

oder 
	
	
	
	





```
abstract String getNachname
```
 ?


----------



## Ice-Tea (21. Dez 2008)

dann könnteat du 

abstract public String getNachname();

verwenden

EDIT:
Wichtig ist das die Klasse,  die methoden vom interface erbt, abstract ist. Denn nur so kannst du bestimmte methoden als abstract 'markieren' und musst ihr kein leben einhauchen

Sorry, ich hatte das public in der klasse vergessen, habs grad mal korrigiert. (methoden aus einem interface sind immer public)


----------

