# Methodenaufruf mit abgeleiteter Klasse als Arg...



## fluppe (28. Jul 2015)

Also,

nun stehe ich vor folgendem Problem:

Ich habe eine klasse "A" und eine abgeleitete Klasse "B". Außerdem habe ich ein Interface "IFC".
Das Interface sieht so aus:

```
public interface IFC
{
    void some(A xy );
}
```

Meine Frage ist: Was muss ich tuen, um die Methode "some" mit einem Argument vom Typ "B" aufrufen zu können ??

Ganz trivial scheint es nicht zu sein, muss ich dafür an den Interface was machen, oder wie kann das gehen ?

Besten Dank schonmal fürs lesen und einen schönen Abend noch,

...


----------



## theo_retiker (28. Jul 2015)

Also wenn ich das richtig verstehe, dann implementieren A und B das Interface NFC nicht. Dann erstellst du einfach ein neues Interface I, das irgendwie so aussieht:

```
public interface I
{
    public void methode();
}
```
Dann kannst du in IFC einfach statt A ein I übergeben:

```
void some(I xy );
```
An xy kannst du nun "methode()" aufrufen, von der es dann weiter geht.

Falls ich das falsch verstanden habe und A und B schon IFC implementieren, dann brauchst du einfach "public void some(IFC xy);" schreiben.

mfg


----------



## Tobse (28. Jul 2015)

Ich verstehe das eher so:


```
class A { }
class B extends A { }
class X implements IFC {  }
```

Dann kannst ganz simpel _some_ aufrufen:


```
B obj = new B();
X impl = new X();
impl.some(obj);
```


----------



## Enceladus271 (28. Jul 2015)

fluppe hat gesagt.:


> Ich habe eine klasse "A" und eine abgeleitete Klasse "B"


Wenn B von A abgeleitet ist brauchst du garnichts zu machen, da jedes Objekt vom Typ B dann auch schon automatisch vom Typ A ist. Du kannst die Methode "some" also auch mit jedem B als Parameter aufrufen.


----------



## fluppe (29. Jul 2015)

Naja,

ich bin hier der Anfänger.
@Enceladus271: Ich hatte das auch erstmal so verstanden, aber irgendwie ging es nicht ...

Es ist auch noch ein bisschen komplizierter: Die Methode "some" wird später überladen. Da steht dann also
sowas:

```
new IFC(){
@override
public void some(A xy){

.... was passieren soll ....

}
```

Das will ich jetzt ändern zu " ... some(B xy) ... " aber das scheint nicht zu gehen ...
Ich meine aber, daß das eigentlich nur komplizierter aussieht, aber prinzipiell nichts anderes ist als das beschriebene Vorgehen.
Ich muss nochmal schauen, ob da noch etwas anderes versaubeutelt habe.

Jedenfalls Danke erstmal und beste Grüße,
...


----------



## fluppe (29. Jul 2015)

Noch ein(e par) Frage(n), als Nachtrag sozusagen: Bei einer abgeleiteten Klasse ... gibt es sowas wie einen Konstruktor
abglKlasse( Klasse xy)
oder muss man den selber stricken ? Oder macht das gar keinen Sinn ? 
Und angenommen, ich will ein Objekt vom Typ "Klasse" jetzt in eines vom Typ ""abglKlasse" umwandeln/casten, welche Möglichkeiten gibt es da ??

Besten Dank,
...


----------



## VfL_Freak (29. Jul 2015)

Moin,



fluppe hat gesagt.:


> Noch ein(e par) Frage(n), als Nachtrag sozusagen: Bei einer abgeleiteten Klasse ... gibt es sowas wie einen Konstruktor
> abglKlasse( Klasse xy)
> oder muss man den selber stricken ? Oder macht das gar keinen Sinn ?


Sicher benötigt die abgeleitete Klasse ihren eigenen Konstruktor ....
http://openbook.rheinwerk-verlag.de...05_008.htm#mjf275cae4069cb07f60b602bcbea532c8



fluppe hat gesagt.:


> Und angenommen, ich will ein Objekt vom Typ "Klasse" jetzt in eines vom Typ ""abglKlasse" umwandeln/casten, welche Möglichkeiten gibt es da ??


Keine, warum solltest Du das wollen ?? 
Nimm an, Du hast die Klasse "Fahrzeug" und leitest jeweils "PKW" und "LKW" davon ab.
"PKW" und "LKW" sind jetzt spezieller als "Fahrzeug" (oder werden es beim Ausprogrammieren bspw. weiterer spezifischer Attribute).
"Fahrzeug" ist quasi nur eine Art Schablone, von der du vermutlich nie eigene Objekte erzeugen würdest !

Gruß Klaus


----------



## fluppe (29. Jul 2015)

Warum ich das wollen sollte ?? Keine Ahnung, aber ich meine sowas kann doch vorkommen.
Nehmen wir mal an ich habe da eine Klassenbibliothek und da sitzt "Fahrzeug" drin. Ich möchte nun dieses "Fahrzeug" erweitern, ohne die ganze Bibliothek auf links zu ziehen.
Da könnte sowas ganz praktisch sein...

Da gibt es zum Beispiel ein Objekt "Parkplatz" und das hat einen Haufen Methoden, die allesamt sowas machen wie "addFahrzeug" ...

Ich möchte nun aber "LKW" oder "PKW" adden ... macht die Methode nicht, sie erzeugt ein ein "Fahrzeug" und packt es auf den Parkplatz ...

Als abgeleitete Klasse muss ja nun auch "LKW" oder "Auto" auf den Parkplatz draufpassen, aber ich kann es nicht mit der "addFahrzeug" - Methode parken.

Also müßte ich sowas machen wie eine "addLKW" und eine "addAuto" methode, die den Konstruktor von "LKW" oder "Auto" aufrufen. 

Jetzt wird aber, damit es nicht zu einfach ist, das Fahrzeug gleichzeitig noch zu einer weiteren Klasse, sagen wir mal "ParkplatzkassenListe" hinzugefügt. Da möchte ich vielleicht nicht auch noch irgendwas extra machen ... also will ich das Ding einmal als "Fahrzeug" an der Kasse registrieren und einmal als "LKW" parken (ist so eine Art Betrug, weil LKWs bestimmt teurer sind).

Ich bin nicht ganz sicher was da nun das Beste wäre ... klar, wahrscheinlich hat Java super duper features, die das alles easy machen, aber die kenne ich blöderweise nicht. Daher die Idee mit dem casten, auch wenn die vielleicht ein wenig dem OO Stil zuwiderläuft.

Naja, Versuch macht kluch, ... oder doofe Fragen stellen ...
Ist wahrscheinlich das Beste, wenn ich die Bibliothek eben doch auf links ziehe ... dann weiß ich am Ende auch genau, was gespielt wird. 
Ich werde auch mal versuchen, mein Problem etwas praziser auf das Parkplatzbeispiel umzusetzen. Erfahrungsgemäß helfen mir solche Vereinfachungen immer sehr bei Verständnisproblemen.
Das Ergebnis kann ich ja dann mal hier posten.

Vielen Dank für die Antworten soweit und beste Grüße,
...


----------



## VfL_Freak (29. Jul 2015)

Hallo,

ich denke, Du solltest Dir das Prinzip der Vererbung mal genauer anschauen.
Das was Du vorhast klingt alles ein wenig konfus 

Hier mal ein paar Seiten, die Dir vielleicht dabei helfen werden:
http://www.java-tutorial.org/vererbung.html
https://www.teialehrbuch.de/Kostenlose-Kurse/JAVA/6622-Konstruktoren-und-Vererbung.html

Gruß Klaus


----------



## fluppe (30. Jul 2015)

Hi, das ist schon richtig.
Zu meiner Konfusion trägt außerdem die Tatsache bei, daß ich ja noch nicht einmal so genau weiss, was ich vorhabe ... und vorhaben werde.
Also werde ich wohl erstmal meinen Horizont ein wenig gerade ziehen müssen. Dabei können die Links da sicher nur helfen. Wie gesagt, ich werde das Ergebnis meiner Sinnsuche hier posten ...

Bis dahin fare well ( ... kann man ein Thema als "resolved" markieren ?? und wenn ja, wie ??),
... und alles Gute für die neue Saison.


----------



## JStein52 (30. Jul 2015)

Nur noch mal zu deinen Parkplatz- und Parkplatzkassenbeispielen:

1.) bei allen Methoden wo du ein Fahrzeug als Parameter angeben kannst kannst du auch einen LKW oder einen PKW als Parameter angeben.
2.) scheinen deine Klassen Parkplatz und Parkplatzkasse eben genau keine Unterschiede zu machen zwischen PKW und LKW sonst hätten sie ja spezifische Methoden und würden die Klasse PKW und LKW kennen. Wenn du also Parkplätze und Kassen haben willst die das unterscheiden musst du davon eben auch spezielle Klassen ableiten. Bei deinen Überlegungen ist ein Widerspruch drinnen.


----------

