Java; Casting-Basisklasse in abgeleitete Klasse

Question

Warum kann ich eine Basisklasseninstanz nicht in eine abgeleitete Klasse umwandeln?

Zum Beispiel, wenn ich eine Klasse B habe, die eine Klasse C erweitert, warum kann ich das nicht tun?

B b=(B)(new C()); 

oder das?

C c=new C(); 
B b=(B)c; 

---

Okay lassen Sie mich genauer sein, was ich versuche zu tun. Hier ist, was ich habe:

public class Base(){ 
    protected BaseNode n; 
    public void foo(BaseNode x){ 
     n.foo(x); 
    } 
} 


public class BaseNode(){ 
    public void foo(BaseNode x){...} 
} 

Jetzt habe ich einen neuen Satz von Klassen erstellen möchten, die Basis und Basenode verlängern, wie folgt aus:

public class Derived extends Base(){ 
    public void bar(DerivedNode x){ 
     n.bar(x);//problem is here - n doesn't have bar 
    } 
} 

public class DerivedNode extends BaseNode(){ 
    public void bar(BaseNode){ 
     ... 
    } 
} 

So im Wesentlichen ich neue Funktionalität zur Basis und BaseNode hinzufügen möchten indem Sie beide erweitern und beiden eine Funktion hinzufügen. Darüber hinaus sollten Base und BaseNode für sich alleine verwendet werden können.

Ich würde wirklich gerne dies ohne Generika tun, wenn möglich.

---

In Ordnung, also habe ich es herausgefunden, zum Teil dank Maruice Perry's Antwort.

In meinem Konstruktor für Base wird n instanziiert als BaseNode. Alles, was ich zu tun hatte, war wieder instanziieren n als DerivedNode in meiner abgeleiteten Klasse im Konstruktor, und es funktioniert perfekt.

Answer 1

Sie benötigen die Instanceof verwenden Stichwort die Art des Objekts durch n und Typumwandlung des Objekts referenziert zu überprüfen und rufen die bar() Methode. Kasse Derived.bar() Methode unten

public class Test{ 
    public static void main(String[] args){ 
     DerivedNode dn = new DerivedNode(); 
     Derived d = new Derived(dn); 
     d.bar(dn); 
    } 
} 

class Base{ 
    protected BaseNode n; 
    public Base(BaseNode _n){ 
     this.n = _n; 
    } 

    public void foo(BaseNode x){ 
     n.foo(x); 
    } 
} 


class BaseNode{ 
    public void foo(BaseNode x){ 
     System.out.println("BaseNode foo"); 
    } 
} 

class Derived extends Base{ 
    public Derived(BaseNode n){ 
     super(n); 
    } 

    public void bar(DerivedNode x){ 
     if(n instanceof DerivedNode){ 
      // Type cast to DerivedNode to access bar 
      ((DerivedNode)n).bar(x); 
     } 
     else { 
      // Throw exception or what ever 
      throw new RuntimeException("Invalid Object Type"); 
     } 
    } 
} 

class DerivedNode extends BaseNode{ 
    public void bar(BaseNode b){ 
     System.out.println("DerivedNode bar"); 
    } 
} 

Answer 2

denn wenn B C erstreckt, bedeutet dies, B eine C und nicht C ist ein B.

überdenken, was Sie zu tun versuchen.

Answer 3

Sie können das nicht tun, weil C implementieren nicht unbedingt die Verhaltensweisen, die Sie erstellt, wenn Sie es in B.

So

erweitert, sagen C foo() ein Verfahren hat. Dann weißt du, dass du foo() auf einem B anrufst, da B C ausdehnt, so dass du entsprechend ein Leckerbissen a B wie ein C mit (C)(new B()) wirken kannst.

Jedoch - wenn B eine Methode bar() hat, sagt nichts in der Unterklassenbeziehung, dass Sie bar() auf C auch anrufen können. Daher kann man ein C nicht so behandeln, als wäre es ein B, und deshalb kann man nicht casten.

Answer 4

Denn wenn B extends C, dann B vielleicht Sachen, die nicht in C (wie Instanzvariablen initialisieren Sie im Konstruktor, die nicht in neue C())

Answer 5

Sie einen Konstruktor für B erstellen können, dauert C als Parameter. Siehe this post für Ideen zu tun, was Sie versuchen zu tun.

Answer 6

Die vorhandenen Antworten sind gut in Bezug auf eine abstrakte Argumentation, aber ich möchte eine konkretere machen. Angenommen, Sie könnten tun.Dann würde dieser Code muss kompilieren und ausführen:

// Hypothetical code 
Object object = new Object(); 
InputStream stream = (InputStream) object; // No exception allowed? 
int firstByte = stream.read(); 

Wo genau würde die Umsetzung des read Verfahren kommen? Es ist abstrakt in InputStream. Woher würde es die Daten bekommen? Es ist einfach ist nicht geeignet, um eine bare java.lang.Object als InputStream zu behandeln. Es ist viel besser für die Besetzung, eine Ausnahme zu werfen.

Nach meiner Erfahrung ist es schwierig, "parallele Klassenhierarchien" wie die, die Sie beschreiben, zu arbeiten. Sie können finden, dass Generika helfen, aber es kann haarig sehr schnell bekommen.

Answer 7

In Ihrem exemple, können Sie n in eine DerivedNode werfen, wenn Sie sicher sind, dass n eine Instanz von DerivedNode ist, oder Sie verwenden können Generika:

public class Base<N extends BaseNode> { 
    protected N n; 
    public void foo(BaseNode x){ 
     n.foo(x); 
    } 
} 


public class BaseNode { 
    public void foo(BaseNode x){...} 
} 

public class Derived extends Base<DerivedNode> { 
    public void bar(DerivedNode x){ 
     n.bar(x); // no problem here - n DOES have bar 
    } 
} 

public class DerivedNode extends BaseNode { 
    public void bar(BaseNode){ 
     ... 
    } 
} 

Answer 8

Basisklassen sollten nichts über Klassen wissen von ihnen abgeleiteten, sonst markiert die oben genannten Probleme auftreten werden. Downcasting ist ein "Code-Geruch", und Downcasting in der Basisklasse in eine abgeleitete Klasse ist besonders "stinkend". Solche Designs können auch zu schwer auflösbaren zirkulären Abhängigkeiten führen.

Wenn Sie möchten, dass eine Basisklasse abgeleitete Klassenimplementierungen verwendet, verwenden Sie das Vorlagenmethodenmuster, d. H. Fügen Sie eine virtuelle oder abstrakte Methode in Ihre Basisklasse ein und überschreiben und implementieren Sie sie in der abgeleiteten Klasse. Sie können dies dann sicher von der Basisklasse aus aufrufen.