Du verwendest einen veralteten Browser. Es ist möglich, dass diese oder andere Websites nicht korrekt angezeigt werden. Du solltest ein Upgrade durchführen oder ein alternativer Browser verwenden.
Ich möcht ein bissl das Handhaben mit Interfaces üben!
Hat jemand ein ganz einfaches Beispiel für mich, damit ich die Funktionalität eines Interfaces kennen lerne!??!
Das wär spitze!
Danke!
ciao,Tommy
Eine typische Anwendung: Schreibe einen Frame und implementiere das WindowListener-Interface und überschreibe die Methoden.
Aber wirklich interessant und lehrreich sind die Klassen des Java Collection Frameworks. Dort wird reger Gebrauch von Interfaces gemacht, die die Leistungsfähigkeit einer Klasse enorm steigern bzw. verändern können.
Wichtig zu wissen ist dabei, dass jede Interface-Implementierung in einer Klasse, diese automatisch auch zu einem Typ des Interfaces werden lässt.
mein lieblingsbeispiel ist das gute alte Comparable Interface... Sobald du eine Klasse sortieren lassen willst (von einem SortedSet oder z.b. über das Collections Framework, Arrays oder was auch immer) - stehen die Sortier vor dem problem:
"Mhm - wir bekommen irgendein Objekt, das kann alles sein... Woher soll ich wissen wann eins von den Dingern größer ist als das andere ?"
und da kommt das interface im spiel. Alle Sortierer ist es gelinde gesagt sch*** egal was für ein Objekt sie bekommen, solange es das Comparable interface implementiert. Denn dann können sie die methode compareTo aufrufen und wissen dann ob ein Objekt kleiner ist als ein anderes...
Interfaces sind Schnittstellen die deiner Klasse ein ganz bestimmtes Verhalten verleihen
Also, das stimmt ja nicht so ganz! Ein Interface ist viel mehr eine Schnittstelle (so steht es auch in jedem Wörterbuch).
Der Vorteil eines Interfaces ist, dass Du wirklich nur die Schnittstelle kennen musst und Dir die eigentliche Klasse, die dahinter steckt egal sein kann.
Das "Comparable"-Interface ist dafür auch wirklich ein sehr gutes Beispiel: Es ist wirklich vollkommen egal, um welche Klassen es sich handelt, mit Hilfe des Interface kann man immer über die gleiche Methode (nämlich "compareTo") zwei Objekte miteinander vergleichen.
ok..ich werd jetzt mal was mit compareTo programmieren
leider hab ich da immer ein bissl wenig Phantasie...
kann mir jemand ein kónkretes Beispiel geben...von mir aus auch mit compareTo..!??..oder was anderes mit Interfaces! Ihr habt damit einfach um Welten mehr Erfahrung als ich!
Das wär super!
Danke!
public class MyClass implements Comparable<MyClass> {
private String aString;
private int whatEver;
// methoden und konstruktoren
// compareTo methode aus dem interface Comparable
public int compareTo(MyClass otherClass) {
return aString.compareTo(otherClass.aString):
}
}
das ist java5 syntax... vor java5 heißt es implements Comparable und die methode compareTo hat als Argument den Typ Object.
Die Klasse MyClass ist nun "comparable", d.h. man kann sie mit anderen objekten der klasse vergleichen. der vergleich beruht auf der instanzvarible aString, einem String, der ebenso das interface implementiert.... also kann man auch dort compareTo aufrufen...
nun kannst du das alles z.b. in einem TreeSet einbringen
Code:
Set<MyClass> sortedSet = new TreeSet<MyClass>();
sortedSet.add(new MyClass("derString", 2));
// und noch andere add operationen
das TreeSet sortiert dir deinen Objekte nun anhand der compareTo methode der klasse... das geht ohne probleme, da deine Klasse Comparable implementiert....
die zahl ist für den vergleich unwichtig.. sollte nur ein bsp sein, dass du jegliches objekt (egal was für infos es hat) "missbrauchen" kannst.
Beim MyClass Beispiel sortiert er nach dem namen. Das Sortieren basiert auf der compareTo methode. diese liefert ja einen int wert zurück (negativ - objekt ist kleiner als parameter, 0 - beide sind gleich, positiv - objekt ist größer).
das mit der contains ist ne andere Sache, die basiert auf der equals methode. D.h. wenn dieser Vgl wichtig ist sollte diese Methode (und am besten die Methode hashCode) überschrieben werden....
compareTo sagt dir größer, kleiner. equals sagt gleich oder nicht gleich
public class MyClass implements Comparable<MyClass> {
private String aString;
private int whatEver;
// methoden und konstruktoren
// compareTo methode aus dem interface Comparable
public int compareTo(MyClass otherClass) {
return aString.compareTo(otherClass.aString):
}
}
Um das mal zu verdeutlichen: Du kannst die 'compareTo' ganz nach deinen Bedürfnissen anpassen. So könntest Du z.B. auch nach Länge der Strings (oder nach ganz anderen Kriterien...) sortieren (bitte nicht nach der Sinnhaftigkeit fragen... :wink: ):
Code:
// compareTo methode aus dem interface Comparable
public int compareTo(MyClass otherClass) {
int iMyLen = aString.length();
int iOtherLen = otherClass.aString.length();
return ( iMyLen - iOtherLen );
}
class Person implements Comparable{
String name;
public Person(String name){
this.name=name;
}
public int compareTo(Object obj){
Person other=(Person) obj;
int result=name.compareTo(other.name);
return result;
}
}
Code:
import java.util.*;
class InterfaceTest{
public static void main(String [] args){
Set list=new TreeSet();
list.add(new Person("Roland"));
list.add(new Person("Thomas"));
System.out.println(list);
}
}
Brauch ich da jetzt wieder ne toString-Methode? oder hab ich wiedermal einen anderen Denkfehler drin? :autsch:
ist das der einzige Fehler, den ich drinnen hab?
Gehts dann mit einer toString-Methode?
aber trotzdem versteh ich das nicht, denn mit return result wird ja eh die Zahl zurückgegeben, oder?
War gar nicht so schwer! :###
Wie immer im nachhinein!
die toString-Methode :applaus:
Code:
class Person implements Comparable{
String name;
int result;
public Person(String name){
this.name=name;
}
void print(){
System.out.println(name);
}
public int compareTo(Object obj){
Person other=(Person) obj;
int result=name.compareTo(other.name);
return result;
}
public String toString(){
return this. name;
}
}
Code:
public class InterfaceTest{
public static void main(String [] args){
List list=new ArrayList();
Person a=new Person("Roland");
Person b=new Person("Hannes");
Person c=new Person("Franz");
list.add(a);
list.add(b);
list.add(c);
System.out.println(a.compareTo(b));
System.out.println("Anzahl der Elemente in Set: "+list.size());
Iterator it=list.iterator();
while(it.hasNext()){
System.out.println((Person)it.next());
}
}
}
um weiter die Sinnhaftigkeit ad absurdum zu führen *g
