# Verwendung von Interface



## unknown (5. Dez 2011)

Hallo

Könnt ihr mir vielleicht erklären wozu man eigentlich Interfaces verwendet und wie sie genau funktionieren?
Ein einfaches, aber sinnvolles Beispiel wäre gut 
und was sind abstarkte Methoden und Klassen?


----------



## darekkay (5. Dez 2011)

Java ist auch eine Insel - Interfaces

(einen Kapitel vorher werden abstrakte Klassen erklärt)


----------



## faetzminator (5. Dez 2011)

Das wird in jedem Javabuch sehr gut beschrieben, lies doch mal folgendes:
Interfaces: Galileo Computing :: Java ist auch eine Insel - 5 Eigene Klassen schreiben
Abstrakte Klassen: Galileo Computing :: Java ist auch eine Insel - 5 Eigene Klassen schreiben


----------



## ARadauer (5. Dez 2011)

Man beschreibt von Etwas nur was es kann und somit muss derjenige der damit etwas macht nicht das Ding genau kennen...

Beispiel: KundenSpeicherer: Methode ... speicher(Kunde kunde); wie und was und wohin.. mir egal...


----------



## Andi_CH (5. Dez 2011)

Ein Beispiel, dass mir zu abstrakten Klassen einfällt sind Menschen.

Banalisieren wir die Menschheit mal ein wenig, also bitte nicht kommen das Sprechen liesse sich auch über Attribute steuern und es gäbe auch noch Trans-Menschen, sonst stimmt mein Beispiel nicht mehr 

Es gibt männliche und weibliche Menschen / die Klassen nennen wir mal "Frau" und "Mann" - die gemeinsamen Attribute und Methoden lagern wir aus in die Klasse "Mensch".

Da es aber in diesem Sinne keine Menschen sondern eben nur Männer und Frauen gibt, deklarieren wir die Klasse Mensch abstrakt

Die Meethode gehen könne wir schon in der Klasse Mensch implementieren, da alle Menschen exakt gleich gehen.

Wenn wir das Sprechen untersuchen, stellen wir fest, dass zwar alle Menschen sprechen können, Männer und Frauen das aber auf unterschiedliche Art (Tonhöhe, Rythmus etc.) machen, also deklarieren wir in der Klasse Mensch nur die Methode 
	
	
	
	





```
public abstract void sprich(String text);
```
 und wie es gemacht wird, muss in der Klasse Mann und Frau jeweils implementiert werden.


----------



## bygones (5. Dez 2011)

Andi_CH hat gesagt.:


> Da es aber in diesem Sinne keine Menschen sondern eben nur Männer und Frauen gibt, deklarieren wir die Klasse Mensch abstrakt


nur am rande: abstrakte Klassen sollten nur existieren, wenn man einen template implementierung eines Interfaces braucht, nicht zur Verhinderung von instanziierung.


----------



## Andi_CH (5. Dez 2011)

... oder wenn sie abstrakte und konkrete Methoden beinhalten - ein Interface lässt ja nicht zu, dass man Methoden bereits implementiert.

Ausserdem ist meine Sicht die von UML und Java-Interfaces werden dort IMO als abstrakte Klassen dargestellt.


----------



## bygones (5. Dez 2011)

Andi_CH hat gesagt.:


> ... oder wenn sie abstrakte und konkrete Methoden beinhalten - ein Interface lässt ja nicht zu, dass man Methoden bereits implementiert.


genau, deswegen ja meine Aussage bzgl der Template implementierung. Ich sagte, dass der einzige Grund einer abstrakten Klasse ist, dass sie als template eines Interfaces existiert. D.h. dass man dort Implementierungen drinnen hat, die allgemein gueltig sind und nicht von jeder Implementierung des interfaces erneut geschrieben werden soll.



Andi_CH hat gesagt.:


> Ausserdem ist meine Sicht die von UML und Java-Interfaces werden dort IMO als abstrakte Klassen dargestellt.


interfaces sind auch nix anderes als spezielle abstrakte Klassen.


----------



## Andi_CH (5. Dez 2011)

bygones hat gesagt.:


> ... als template eines Interfaces ...



Was meinst du damit? Es gibt hunderte von abstrakten Klassen zu denen KEIN Interface existiert.
Ein Interface im Java Sinn ist ja nur ein Mechanimus um die Mehrfachvererbung auf eine sinvolle Art zu ermöglichen.

Ein Interface zeigt was eine Klasse kann, eine Superklasse sagt was eine Klasse ist (Das ist ein Zitat mit dem ich aber auch nicht zu 100% glücklich bin)


----------



## bygones (5. Dez 2011)

Andi_CH hat gesagt.:


> Was meinst du damit? Es gibt hunderte von abstrakten Klassen zu denen KEIN Interface existiert.


die reine Existenz einer Sache ist nicht gleichzusetzen mit seiner Berechtigung. Am Bsp von Swing sieht man was man fuer Probleme man hat wenn man keine Interfaces nutzt und einfach nur abstrakte Klassen. Und da man nicht einfach etwas nachmachen soll, nur weil es schon gibt, sollte man nur abstrakte Klassen einsetzen, wenn man eben eine Template Klasse eines Interfaces braucht.



Andi_CH hat gesagt.:


> Ein Interface im Java Sinn ist ja nur ein Mechanimus um die Mehrfachvererbung auf eine sinvolle Art zu ermöglichen.


Interfaces haben an sich nichts mit Mehrfachvererbung zu tun und warum das immer gesagt wird hat sich mir noch nie erschlossen. Nur weil versch. Klassen das selbe Interface implementieren sind sie nicht in einer Vererbungshierarchie.


----------



## unknown (5. Dez 2011)

Danke für die Erklärungen und Links.
Könnte jemand trotzdem ein einfaches Beispiel mit Interface machen?


----------



## faetzminator (5. Dez 2011)

```
public interface Named {
     public String getName();
}
```
Nun kann folgende Methode implementiert werden:

```
public static void printName(Named n) {
    System.out.println(n.getName());
}
```
Ob das nun ein Auto ist, welches [c]Named[/c] implementiert (und z.B. "Audi" zurückgibt) oder ein Mensch (welcher z.B. "Peter" zurückgibt), ist völlig egal.


----------



## unknown (5. Dez 2011)

und wo wird beschrieben, was die Method getName() machen soll?
Sprich was für einen Namen sie returnieren soll?


----------



## faetzminator (5. Dez 2011)

Wenn du ein Interface [c]Named[/c] schreibst, dann wird das von dir auch irgendwo verwendet werden. Somit musst du auch sagen, was dort erscheinen (bzw. zurückgegeben werden) soll.
Mir fällt hier keine klarere Bezeichnung als "common name" ein... Beim Menschen wär das vielleicht der Rufname, könnte aber auch der Vorname sein. Dies ist vielleicht ein "ungenaues" Beispiel, da dieses nur für ein Sysout verwendet wird und wohl lediglich dem User bei der Identifikation eines Objektes behilflich sein soll.

Edit: Eine Anmerkung noch. Es gibt eine Methode [c]public String toString()[/c], welche von [c]Object[/c] implementiert wurde. Somit kann jedes beliebige Objekt diese Methode überschreiben. Die Beschreibung zu dieser Methode ist auch nicht genauer, als meine:


> *Returns a string representation of the object.* In general, the toString method returns a string that "textually represents" this object. The result should be a concise but informative representation that is easy for a person to read. It is recommended that all subclasses override this method.
> 
> The toString method for class Object returns a string consisting of the name of the class of which the object is an instance, the at-sign character `@', and the unsigned hexadecimal representation of the hash code of the object. In other words, this method returns a string equal to the value of:
> 
> [Java]getClass().getName() + '@' + Integer.toHexString(hashCode())[/code]


----------



## SlaterB (5. Dez 2011)

bygones hat gesagt.:


> Interfaces haben an sich nichts mit Mehrfachvererbung zu tun und warum das immer gesagt wird hat sich mir noch nie erschlossen. Nur weil versch. Klassen das selbe Interface implementieren sind sie nicht in einer Vererbungshierarchie.


wie definierst du Mehrfachvererbung/ Vererbungshierarchie?
durch die Java-Einschränkungen gibt es da eine gewisse Eingrenzung, als Polymorphie allgemein betrachtet stehen die implementierenden Klassen ja nun doch in irgendeiner Hierarchie zusammen, das ist ja gerade das Ziel


----------



## unknown (5. Dez 2011)

hmm.. kannst du kein konkretes Beispiel machen bei dem man sieht wo diese Methode getName definiert wird?


----------



## GUI-Programmer (5. Dez 2011)

Ein etwas komplexeres Programm: Figuren Zeichner.zip vom Thread Beliebig viele Objekte auf einer Zeichenfläche zeichnen


----------



## pro2 (5. Dez 2011)

```
public Class Auto implements Named{
    @Override
    public String getName(){
         //mach irgendwas
    }
}
```


----------



## bandy (5. Dez 2011)

just hat gesagt.:


> hmm.. kannst du kein konkretes Beispiel machen bei dem man sieht wo diese Methode getName definiert wird?



Genau, das will ich auch sehen, ich habe das gleiche Problem, das Buch Java ist auch eine Insel habe ich vor mir liegen und lese diese Kapiteln seit Tagen durch, aber den Sinn konnte ich bis jetzt nicht verstehen, nur das abstrakte Klassen von sich nicht erben lassen, aber selbst erben koennen. Ein praktischer Beispiel soll her und nicht nur einer


----------



## unknown (5. Dez 2011)

und was ist der Sinn der Sache? 
man kann doch die Methode "getName" gleich in der Klasse "Auto" definieren, anstatt ein Interface zu generieren und dann die Methode zu überschreiben..


----------



## faetzminator (5. Dez 2011)

just hat gesagt.:


> und was ist der Sinn der Sache?
> man kann doch die Methode "getName" gleich in der Klasse "Auto" definieren, anstatt ein Interface zu generieren und dann die Methode zu überschreiben..



Dann kann ich aber nirgens in gemeinsamen Code alle Namen aller Autos *und* alle Namen aller Menschen ausgeben, da ich dann eine Methode [c]printName(Car c)[/c] und eine Methode [c]printName(Human h)[/c] erstellen müsste. Beide Objekte haben aber die Methode [c]getName()[/c] und beide [c]printName()[/c] Methoden machen exakt das gleiche.


----------



## unknown (5. Dez 2011)

faetzminator hat gesagt.:


> Dann kann ich aber nirgens in gemeinsamen Code alle Namen aller Autos *und* alle Namen aller Menschen ausgeben


könntest du dafür ein Beispiel machen?


----------



## faetzminator (5. Dez 2011)

```
public Car extends Named {

    private String name;

    public Car(String name) {
        this.name = name;
    }
    
    public String getName() {
        return name;
    }
}
```


```
public Human extends Named {

    private String nickName;

    public Car(String nickName) {
        this.nickName= nickName;
    }
    
    public String getName() {
        return nickName;
    }
}
```

Und hier verwenden wir das:

```
List<Car> cars = new ArrayList<Car>();
cars.add(new Car("Audi"));
cars.add(new Car("BMW"));
// ...

List<Human> humans = new ArrayList<Human>();
humans.add(new Human("faetzminator"));
humans.add(new Human("just"));
// ...

for (Car c : cars) { // durch alle Cars iterieren
    printName(c);
}

for (Human h : humans) { // das gleiche mit den Menschen
    printName(h);
}
```

Wenn du nun das Interface implementiert hast, kannst du *eine* solche Methode schreiben:

```
public static void printName(Named n) {
    System.out.println(n.getName());
}
```
Wenn du das nicht hast, dann schreibst du folgende *zwei* Methoden:

```
public static void printName(Car c) {
    System.out.println(c.getName());
}

public static void printName(Human h) {
    System.out.println(h.getName());
}
```


----------



## Gast2 (5. Dez 2011)

Ohne Interface:

```
public class InterfaceExample {

	public static void main(String[] args) {
		Person p1 = new Person("Hans");
		Person p2 = new Person("Peter");
		Car c = new Car("Audi");
		
		printName(p1);
		printName(p2);
		printName(c);
	}
	
	public static void printName(Person p) {
		System.out.println(p.getName());
	}
	
	public static void printName(Car c) {
		System.out.println(c.getName());
	}
	
	private static class Person {
		private String name;

		public Person(String name) {
			this.name = name;
		}
		
		public String getName() {
			return name;
		}
	}
	
	private static class Car {
		private String name;
		
		public Car(String name) {
			this.name = name;
		}
		
		public String getName() {
			return name;
		}
	}
}
```

Mit Interface:

```
public class InterfaceExample {

	public static void main(String[] args) {
		Person p1 = new Person("Hans");
		Person p2 = new Person("Peter");
		Car c = new Car("Audi");
		
		printName(p1);
		printName(p2);
		printName(c);
	}
	
	public static void printName(Named n) {
		System.out.println(n.getName());
	}
	
	private static class Person implements Named {
		private String name;

		public Person(String name) {
			this.name = name;
		}
		
		public String getName() {
			return name;
		}
	}
	
	private static class Car implements Named {
		private String name;
		
		public Car(String name) {
			this.name = name;
		}
		
		public String getName() {
			return name;
		}
	}
	
	private static interface Named {
		public String getName();
	}
}
```
Es wird nur noch eine Methode printName gebraucht.


----------



## bygones (6. Dez 2011)

SlaterB hat gesagt.:


> wie definierst du Mehrfachvererbung/ Vererbungshierarchie?
> durch die Java-Einschränkungen gibt es da eine gewisse Eingrenzung, als Polymorphie allgemein betrachtet stehen die implementierenden Klassen ja nun doch in irgendeiner Hierarchie zusammen, das ist ja gerade das Ziel


weil String und Integer Comparable sind, stehen die beiden nicht im direkten Zusammenhang und somit nicht in einer Vererbungshierarchie. Number und Integer hingegen schon. 

Ueber ein Interface koennen voellig verschiedene Domains verbunden werden, die logisch nix miteinander zu tun haben, daher sehe ich das nicht als Vererbung an. Vererbung bindet Klassen zusammen und sollte nur eben bei zusammengehoerigen Elementen genutzt werden.

Natuerlich stehen bei einem gemeinsamen Interface die Klassen in eine Hierarchie, aber ich finde eben Vererbung ist ein anderes Konzept und sollte auch anders behandelt werden. Wahrscheinlich eine Kleinigkeit


----------



## unknown (23. Jan 2012)

hey ich hätte eine Frage, wenn man beispielsweise geometrische Figuren hat und dabei gerne das Interface verwenden möchte, dann gibt es bei den Figuren Methode, die immer das gleiche tun.

[Java] getX(); 
getY();  
getMaxX(); 
getMaxY(); 
[/code]

gibt es da eine Möglichkeit ein Interface zu verwenden, ohne dass man Methoden, die Bereits von Java zugeliefert werden, nochmals definieren muss?


----------



## irgendjemand (23. Jan 2012)

wenn du das ganze mit interfaces machen willst dann musst du in jeder klasse die dies implementieren soll die entsprechende methode aus-implemenieren ...
das was du sicher meinst ist von basis-klassen der SE-api ableiten und dann deren methoden verwenden ...
das nennt sich dann vererbung und hat so nichts mit interfaces zu tun ..

auch dazu findest du in der java-insel genug material


----------



## bygones (23. Jan 2012)

irgendjemand hat gesagt.:


> wenn du das ganze mit interfaces machen willst dann musst du in jeder klasse die dies implementieren soll die entsprechende methode aus-implemenieren ...
> das was du sicher meinst ist von basis-klassen der SE-api ableiten und dann deren methoden verwenden ...
> das nennt sich dann vererbung und hat so nichts mit interfaces zu tun ..
> 
> auch dazu findest du in der java-insel genug material


ich glaube eher er meint, ob es in JAva schon ein solches Interface gibt, so dass er bei "Figuren" Interfaces nicht nochmal all diese Methoden definieren muss, sondern einfach ueber [c]interface Figur extends JavaInterfaceFigur[/c] das ganze regelt.

AFAIK gibt es kein Java Interface aber das solche methoden definiert


----------



## parabool (23. Jan 2012)

Ich denke, er meint eine Abstrakte Klasse in welcher die Methoden (getX..), die in allen geom. Fig. gleich sind, implementiert sind und die speziellen abstract.


```
public abstract class GeometrischeFigur
{
	int x;	
	public int getX()
	{
		return x;
	}	
	// Berechnung ist bei (fast) jeder Figur anders
	public abstract int getUmfang();	
}
```

Edit: besseres Beispiel: Berechnung der Fläche.


----------



## unknown (23. Jan 2012)

parabool hat gesagt.:


> Ich denke, er meint eine Abstrakte Klasse in welcher die Methoden (getX..), die in allen geom. Fig. gleich sind, implementiert sind und die speziellen abstract.
> 
> 
> ```
> ...



Aber dann reden wir da von der Vererbung und nicht mehr vom Interface, oder?


----------



## langhaar! (23. Jan 2012)

Ja.


----------



## parabool (23. Jan 2012)

Ja , schon. Die abstrakte Klasse gibt der erbenden Klasse aber auch ein Interface, also zu implementierende öffentliche Methoden, vor.

Nicht mehr zu differenzierende Methoden (public und protected) können hier schon ausimplementiert werden.


----------



## diggaa1984 (23. Jan 2012)

edit: zu langsam


----------



## bygones (23. Jan 2012)

diggaa1984 hat gesagt.:


> Der Vorteil beim Verwenden des Interfaces ist es aber, dass du die Implementierung austauschen kannst ohne den Rest vom Code (welcher sich nur auf das Interface bezieht) verändern zu müssen.


da Interfaces nix anderes als (besondere) abstrakte Klassen sind, gilt das natuerlich auch bei abstrakten Klassen....


----------

