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.
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.
"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"
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..?
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)
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.
Code:
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.
Code:
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).
Code:
//irgendwo im Programm
Form meineForm = Factory.erzeugekonkreteForm();
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 ?
Code:
public class KontoFrame extends Frame
implements ActionListener, WindowListener
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:
Code:
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:
Code:
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"
}
}
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)
[/quote]
