Klasse Design: abgeleitete Klasse zu einer Hierarchie legacy Erbschaft hinzufügen

Question

Sagen, ich habe

Class Base 
{ 
    public void foo() //a public interface to user 
    { 
     doA(); 
     doB(); 
    } 
    protected void doA(){...} //common implementation 
    protected void doB(){} //type specific implementation 
} 
Class Derived1 extends Base 
{ 
    int a,b,c,d,e,f,g; //bulky, clumsy implementation details specific to Derived1 
    @Override 
    protected void doB(){...} //implementation for Derived1 
} 
Class Derived2 extends Base 
{ 
    @Override 
    protected void doB(){...} //a different implementation for Derived2 
} 

korrigiert mich wenn ich falsch bin, ist dies bevorzugt über:

Class Derived1 extends Base 
{ 
    int a,b,c,d,e,f,g; //bulky, clumsy implementation details specific to Derived1 
    @Override 
    protected void doA(){...} //move the common implementation to Derived1 
    @Override 
    protected void doB(){...} //implementation for Derived1 
} 
Class Derived2 extends Derived1 
{ 
    @Override 
    protected void doB(){...} //a different implementation for Derived2 
} 

Da letztere macht Derived1 internen zu Derived2.

Meine Frage ist, angenommen, Derived1 und Base stammen aus einer bestehenden Vererbungshierarchie und Derived1 hat sowohl doA() als auch doB() überschrieben. Was wäre der beste Weg, um einen neuen Derived2 hinzuzufügen, ohne den Legacy-Code zu ändern?

Da Derived2 die gleiche Implementierung von doA() wie Derived1 hat, muss ich die minderwertige zweite Option akzeptieren. Ich dachte über Komposition nach und habe Derived1 als Mitglied von Derived2, aber doA() ist geschützt, so dass wir nicht von Derived2 darauf zugreifen können.

Vielen Dank für die Antwort!

Answer 1

Zuerst denke ich, dass es einen Fehler in Ihrer Frage gibt: die Methoden doA und doB werden als private deklariert. Die untergeordneten Klassen können nicht auf die privaten Methoden ihrer Eltern zugreifen, und ein Überschreiben der Methode ist nicht möglich. Wenn Sie Derived1.foo() aufrufen, wird nur Base.doA() aufgerufen.

Sie sollten diese als protected deklarieren, damit Methoden überschrieben werden können.

In diesem Fall ist die zweite Option meiner Meinung nach akzeptabel, aber es hängt vom tatsächlichen Code ab.

Class Base 
{ 
    public void foo() //a public interface to user 
    { 
     doA(); 
     doB(); 
    } 
    protected void doA(){...} //common implementation 
    protected void doB(){} //type specific implementation 
} 
Class Derived1 extends Base 
{ 
    @Override 
    protected void doB(){...} //implementation for Derived1 
} 
Class Derived2 extends Base 
{ 
    @Override 
    protected void doB(){...} //a different implementation for Derived2 
}