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 hab jetzt im Rahmen meines studiums auch die Bekanntschaft mit "interfaces" gemacht. wie sie benutze hab ich im groben verstanden. (funktionen halt definieren, in den klassen die implements <interface> benutze)
Aber wo liegt die Daseinsberechtigungen dieser interfaces, normalerweise sind ja die Methoden meiner Klasse die Schnittstellen nach außen, warum der zusätzliche weg über ein interface?.
auch hab ich gesehen, das ich das beispiel hatte, wo eine methode/funktion ein Interface als rückgabewert wert hatte. wie funktioniert das? ein interface ist doch nur eine leere hülle die aus methoden besteht.
Ein Interface dient als Gerüst bzw. Vorgabe für den Programmierer. Damit kannst du festlegen, dass ein Objekt bestimmte Methoden implementiert haben muss. Das heißt, du kannst Methoden erstellen, die als Argument ein Objekt vom Typ eines Interfaces erwartet. Die Methode weiß lediglich dass dieses Objekt die Methode foo1 und foo2 implementiert hat. Wie sie implementiert sind, ist der Methode aber egal.
Das einfachste Beispiel sind dafür die Listener-Interfaces bei Buttons. Du fügst dem Button eine Implementierung des Interfaces ActionListener hinzu. Beim Klick auf den Button werden alle registrierten ActionListener durchgelaufen und von jedem die Methode actionPerformed ausgeführt. Was genau die einzelnen actionPerformed Methoden machen ist der aufrufenden Methode egal.
Mit Interfaces kannst du auch sauber zwischen Komponenten trennen. Die eine Komponenten braucht nur die Schnittstelle kennen, nicht jedoch die Implementierung.
nicht das interface als rückgabe, sondern eine klasse die das interface implementiert.
ich bin zb ein informierer, ich informiere klassen über änderungen an meinem zustand.... ich ruf dazu die methode public inform(String message), der anderen klassen auf, die können sich alle bei mir registrieren....
wie mach ich das jetzt, dass ich, den logger, die gui und vielleicht eine andere datenklasse informieren kann? ich muss nicht alle typen kennen, die müssen nur alle das selbe interface implementieren und ich hab einfach eine Liste mit zb Informable...
nur ein beispiel von vielen, die zeigen, das interfaces ein sehr wichtiges konzept sind...
Eine Unterklasse ist immer auch vom Typ ihrer Oberklasse - so wie eine Meise auch ein Vogel ist. Durch die Rückgabe eines Interfaces schaffe ich also die Möglichkeit hier eine beliebige Implementierung dieses Interfaces zurückzugeben.
public IAddress getAddress(String name)
{
return (Address)addresses.get(name);
}
hab das objekt da gecastet zu einem objekt der klasse das dieses interface benutzt. das is das was du meintest? aber wieso gibt man als return-value hier ein Interface an, wenn man doch ein objekt angeben muss.
oder is damit gemeint, das rückgabe objekt muss irgendein objekt sein, dessen klasse das interface implementiert?
hab meine "übungsaufgaben" mittlerweile auch alle geschaft, da haben sich mir ein paar fragen ergeben bzgl. stil und methodik meinerseits (es funktioniert zwar alles, aber teilweise find ich das was ich gemacht hab um die Junit-tests zu bestehen idiotisch)
kurz worum es in der Aufgabe ging:
Man sollte ein kleines Adressbuch basteln, wobei ein eintrag aus 2 objekten(Object) besteht. ein objekt war der key, ein anderers die eigentliche werte. eine andere klasse hält dein ein array von diesen "eintrags" objekten
Code:
class Entry {
private final Object key;
private Object value;
........
}
es gibt auch eine Mehthode um nachzusehen ob ein bestimmter schlüssel bzw eintrag schon im array zu finden ist, hab ich so gelöst:
Code:
/* der übergebende key darf prinzipell null sein, weswegen ich einmal prüfen muss ob ich den sonderfall eines null-keys hab oder ob ich einen key hab der ungleich null ist */
public boolean containsKey(Object key)
{
if (size > 0)
for (int i=0; i < size ; i++)
{
if (data[i].getKey() == key) //null key ist gültiger wert, prüfen ob null
return true;
else if ((data[i].getKey()).equals(key)) //prüfen ob wert existiert
return true;
}
return false;
}
bevor ich einen neuen eintrag wegschreibe, prüfe ich erst ob es das objekt mit dem angegebenen schlüssel schon gibt um ggf. den alten eintrag zu überschreiben.
Code:
public Object put(Object key, Object value)
{
/* Vorhandenen Eintrag mit neuem Wert überschreiben */
if (containsKey(key))
for (int i=0; i < size; i++)
if (data[i].getKey() == key)
{
Object old=null;
old = data[i].getValue();
data[i].setValue(value);
return old;
}
else if (data[i].getKey().equals(key))
{
Object old=null;
old = data[i].getValue();
data[i].setValue(value);
return old;
}
/* Groesse des Arrays prüfen und ggf. vergroessern(verdoppeln) */
if (size + 1 == data.length)
{
/* Aktuellen Inhalt des Arrays in temporären Zwischenspeicher umkopieren */
Entry old_data[] = new Entry[size];
for (int i =0; i < size; i++)
old_data[i] = data[i];
/* Array in der doppelten, der bisherigen Größe erzeugen */
data = new Entry[size*2];
/* Inhalt des Arrays aus temp. Objekt wiederherstellen */
for (int i=0; i < size; i++)
data[i] = old_data[i];
}
/* Neuen Eintrag erstellen */
data[size] = new Entry(key, value);
size++;
return null;
}
so, nun zu meiner stil-frage.
ich finds idiotisch containsKey aufzurufen, wo dann das ganze array durchlaufen wird um zu prüfen ob es schon einen eintrag gibt, wenn ich das 3 zeilen weiter unten ohnehin machen würde(anders komme ich ja nicht an die position des objektes im array). deswegen dir frage, kann man es besser machen?
auch andere hinweise nehm ich gerne an
danke im voraus für hilfe und fürs zeitnehmen diesen roman zu lesen ;-)
