# Implements<-->extends und Interface



## lexx (27. Apr 2011)

Hallo, 

wer kann mir ganz einfach den Unterschied zwischen 
	
	
	
	





```
implements
```
 und 
	
	
	
	





```
extends
```
 erklaeren, sowie was ein Interface ist?


----------



## faetzminator (27. Apr 2011)

Da sollte dir folgendes weiterhelfen:
Galileo Computing :: Java ist auch eine Insel – 5.13 Schnittstellen

Da findest du antworten auf all deine Fragen. Wenn du anschliessend noch Unklarheiten hast, kannst du gerne Fragen stellen.


----------



## Guardi (27. Apr 2011)

extends (Vererbung)
Galileo Computing :: Java ist auch eine Insel – 5.8 Vererbung

implements (Schnittstelle implementieren)
Galileo Computing :: Java ist auch eine Insel – 5.13 Schnittstellen


----------



## Miness (27. Apr 2011)

Oder auch hier bei den offiziellen Java-Tutorials.
Erfordert zwar etwas Englischkenntnisse, finde ich persönlich aber auch ganz gut beschrieben:
Lesson: Interfaces and Inheritance (The Java™ Tutorials > Learning the Java Language)


----------



## lexx (28. Apr 2011)

Hallo und Danke fuer die Antworten!
Ich habe da einiges durchgelesen und bin zu folgendem Quellkode gekommen:


```
public class InterfaceMain extends Klasse implements Interface{
	@Override
	public void methodeA() {
		System.out.println("methodeInterface");	
	}
	
	@Override
	public void methodeDerKlasse(){
		System.out.println("methodeDerKlasse");
	}
	
	public static void main(String[] args) {
		InterfaceMain im=new InterfaceMain();
		im.methodeA();
		im.methodeDerKlasse();
	}
}
```


```
public interface Interface {
public void methodeA();
}
```


```
public class Klasse {
public void methodeDerKlasse(){
	System.out.println("methodeDerKlasse!!!");
}
}
```



D.h. zwischen 
	
	
	
	





```
extends Klasse
```

und 
	
	
	
	





```
implements Interface
```
 gibt's nur in der Schreibweise einen Unterschied, in beiden Faellen muessen die Methoden ueberschrieben werden + befuellt und in main() aufgerufen werden. Oder sehe ich etwas falsch?


----------



## Sym (28. Apr 2011)

Interface-Methoden müssen von Dir implementiert werden. Bei Vererbung musst Du das nicht tun.


----------



## ARadauer (28. Apr 2011)

Man kann nur von einer klasse erben, Interfaces kann man aber mehrer implementieren.


----------



## s4ke (28. Apr 2011)

abstrakte Klassen sind doch meines Wissens nach gut, wenn ein Teil der erbenden Klassen etwas gemeinsam haben (Eine Methode, Variablen, usw.). Interfaces sind wie der Name schon sagt nur Schnittstellen, mit denen Methoden und Verhaltensweisen vereinbart werden.

Sollte was nicht stimmen, her damit.


----------



## lexx (2. Mai 2011)

Und was macht es fuer einen Sinn (siehe mein Quelltext), wenn man selber ein Interface erzeugt und deren Methode man dann in einer anderen Klasse ueberschreibt und dann befuellt, man kann doch genauso und viel kuerzer die Methode direkt in gewuenschter Klasse erzeugen und befuellen, oder?


----------



## AmunRa (2. Mai 2011)

Dass hat etwas mit Vererbung, polimorphismus und Dynamschier bindung zu tun. Da hast du jetzt einige schöne Stichwörter zu denen du dich informieren musst um dies zu verstehen. 

Eine Sache ist in Java z.B. das Interface List, wenn du eine Liste verwenden möchtest, dann kannst du eine Variable vom Typ list anlegen. und mit dieser Arbeiten, wenn du nun eine ArrayList verwendets und später draufkommst du möchtest in deinem Programm doch lieber eine LinkedList verwenden musst du so nur an einer Stelle den Code ändern. wenn du aber nicht das Interface verwendet hast sondern direkt eine Variable vom Typ ArrayList, musst du das ganze Programm umcshreiben.


----------



## Michael... (2. Mai 2011)

Zum einen ist es oft so, dass Klassen bereits von anderen Klassen erben und da bleibt dann nur noch die Möglichkeit via Interface zu implementieren.

Zum anderen definiert ein Interface eine Schnittstelle nach aussen (s. z.B. ActionListener), d.h. ein Objektverwender muss die genaue Klasse eines Objektes nicht kennen bzw. kann Objekte unterschiedlichen Typs über ein Interface gemeinsam verwalten.

Dann gibt's noch die Variante Klassen/Objekte via Interface zu markieren (s. Serializable). Dabei werden allerdings keine Methoden implementiert.

In dem konkreten Bsp macht es nicht unbedingt Sinn ein Interface zu definieren.
Das Thema wird dann eher bei komplexeren Anwendungen relevant.


----------

