Prüfen ob ein Interface implementiert wird

[Dark Void]

Hallo Leute,
ich habe folgende Aufgabenstellung vorliegen:

So sieht das Interface aus:

interface Gewissen
{
    double wert(int entlassungen);
}

Versucht habe ich es so, innnerhalb einer Methode der abstrakten Klasse Angestellter:

        if (this instanceof Gewissen)
        {
            kosten = kosten - wert(entlassungen);
        }

Leider wird die Methode wert() nicht gefunden. Ich glaube auch, dass das Abprüfen mit "instanceof" falsch ist. Die Unterklassen Chef und Arbeiter von Angestellter implementieren beide das Interface Gewissen.

Danke für eure Hilfe

 

[Firephoenix]

Instanceof nicht mit casten verwechseln, mit instanceof weißt du, dass das Objekt dem Typ entspricht, aber nicht das Objekt selberr.

if(objekt instanceof Gewissen){
    ((Gewissen)objekt).wert();

    //oder

    Gewissen g= (Gewissen) objekt;
    g.wert();
}

Gruß

 

[Marcinek]

wenn man überpüfen muss, ob THIS ein Interface implementiert, dann läuft was richtig falsch.

 

[Noctarius]

[ot]

... richtig falsch

Hehe ich liebe diese Wortkombination
[/ot]

 

[Marco13]

[ot]

Hehe ich liebe diese Wortkombination

Das zweite Wort muss aber 'faslch' heißen, weil es sonst ja richtig wäre :joke:
[/ot]

@Dark Void: Wo stammt denn diese Aufgabenstellung und Vorgabe her? (Ich frag' nur, ... falls hier mal wieder jemand nach guten Kursen/Büchern fragt, will man ja auch sagen können: So nicht Vielleicht ist aber auch nur was falsch angekommen, weil nur ein Teil gepostet wurde ... ggf. wären die anderen Klassen auch relevant...).

 

[AndiE]

Ich hätte mir gedacht, dass von der abstrakten Klasse "Angestellter" zwei Klassen erben, eines mit dem Interface "Gewissen"-"Gewissenhafter Angetellter" und eines ohne" Gewissenloser Angestellter". Dann braucht man wirklich nur noch mit "instanceof" prüfen.

 

[Marcinek]

Das ist eben absolut falsch.

Die abstrakte klasse darf keine Implementierung der unterklassen kennen.

Dafür gibt es polymorphie.

 

[Noctarius]

Das ist eben absolut falsch.

Die abstrakte klasse darf keine Implementierung der unterklassen kennen.

Dafür gibt es polymorphie.

Full ACK

 

[AndiE]

@Marcinek. Das verstehe ich nicht. Was wäre an so einem Vorgehen, wie hier skizziert falsch?

public abstract class Angestellter{
...
}

public interface Gewissen{

}

public class Gewissenhaft extends Angestellter implements Gewissen{

}

public class Gewissenlos extends Angestellter{
}

...

public bool gewissensTest(Angestellter a){
return (a instanceof Gewissenhaft);
}

 

[Firephoenix]

Das von dir Skizzierte dürfte vermutlich sogar die grobe Idee der Aufgabenstellung sein,
vermutlich dient das ganze eher als Übung zum arbeiten mit unterschiedlichen Typen.

Eine saubere Lösung wäre vermutlich einfach ein boolean in Angestellter der angibt ob dieser ein Gewissen hat oder nicht
Zumindest falls die Methode zur Abfrage ebenfalls in der Klasse untergebracht wird.

Gruß

 

[Landei]

Man sollte jedenfalls vermeiden, in der Oberklasse in einer Methode Fallunterscheidungen einzuführen, wo separate Versionen der Methode in den Unterklassen ausreichen würden.

Also statt...

class Tier {
   String bewegung() {
       if (this instance Fisch) {
            return "schwimmt";
       }
       if (this instance Vogel) {
            return "fliegt";
       }
   }
}

...immer...

abstract class Tier {
   abstract String bewegung();
}

class Fisch extends Tier {
  String bewegung() {return "schwimmt"; }
}

class Vogel extends Tier {
  String bewegung() {return "fliegt"; }
}

Der Grund wird sofort klar, wenn eine neue Klasse "Säugetier" eingefügt wird: Man muss den Code der Oberklasse Tier nicht wie in der ersten Version anpassen.

 

[Marco13]

Du bist Deutschland.
Ich bin zwei Öltanks.
Der Angestellte ist ein Gewissen.
Klingt alles irgendwie blöd, oder? Falls das wirklich so gemeint ist, würde ich dem Aufgabensteller mal ganz unverbindlich empfehlen, sich zu überlegen, ob er nicht vielleicht berufliche Alternativen in Betracht ziehen sollte...

 

[dhalsim]

Der TO hat wohl eher die Aufgabenstellung völlig falsch verstanden. Dort steht nirgends, dass der Angestellte Gewissen implementieren soll, sondern "das Interface unterstützt" und was weit wichtiger ist "sein Gewissen". Am Ende soll also eher sowas hier rauskommen:

class Angestellter {
        Gewissen gewissen;
        ...
        int getKosten() {
                int kosten = ...;
                if (gewissen != null) {
                        kosten -= gewissen.wert(entlassungen);
                }
                return kosten;
        }
}

 

[Marco13]

Das würde dann schon eher Sinn machen. Man könnte dann noch hinterfragen, was "ein Gewissen unterstützen" heißen soll (es ist sehr schwer, sich klar auszudrücken...). Ich würde "getGewissen" dann in eine ziemlich weit oben liegende Klasse/Interface schreiben, und ggf. als Default-Wert eine Implementierung erstellen wie SchlechterMenschGewissen, die immer 0 zurückliefert (statt der 'null' als Rückgabe)

 

[tröööt]

alleine die aufgabenstellung lässt an der kompetenz des aufgabenstellers zweifeln ...
nicht nur das die wortwahl einfach saumäßig ist sondern auch das der aufgabensteller den sinn von interfaces scheinbar nicht so wirklich verstanden hat ...

selbst wenn man von einer "abstract class Angestellter" und nem "interface Gewissen" ausgeht ... irgendwo fehlt mir da der zusammenhang ...

klar gibt es sog. marker-interfaces ... aber wäre es nicht sinnvoller in "Angestellter" eine "abstract boolean hatGewissen()" zu deklarieren als ein interface dafür zu missbrauchen ? ...

nicht gerade seriös ... ich würde mir n anderen info-lehrer suchen

 

[Marco13]

Teilweise stimme ich da (wie selbst ja schon angedeutet) zu, aber FALLS das so gemeint war, wie dhalsim geschrieben hat, wäre "nur" noch das Wording fragwürdig.