Ist es besser, Superklasseninstanzen an den Konstruktor zu übergeben?

Question

Ich habe eine Oberklasse wie folgt definiert;

public class superClass{ 

     private superClass superObj; 

     public superClass() { 
     } 
     public superClass(superClass superObj) { 
      this.superObj = superObj; 
     } 

     public start()... 
     public receive().. 

Und meine Unterklasse ist wie;

public class subclass extends superclass { 
@Override 
public receive(){ 
........ 
    } 
public static void main(String args[]){ 
    Superclass superTst = new Superclass(new subclass()); 
    superTst.start(); 
... 
} 

Hier ist meine Unterklasse nicht wirklich „ist-a“ Beziehung mit Super. Aber ich möchte so erweitern, weil ich in der Oberklasse eine Verarbeitungsausgabe mache (Oberklasse erzeugt einen neuen Thread und führt eine Verarbeitung durch, so dass ich die Ausgabe an der Oberklasse erhalten kann), auf die von Unterklasse zugegriffen werden muss.

Ist das theoretisch richtig?

Answer 1

Wie Sie erwähnt, dass

Unterklasse ist nicht wirklich "ist-a" Beziehung mit Super

Also nehme ich an Sie c verwenden sollten usammensetzung statt Vererbung wie unten dargestellt:

public class superClass{ 

     private subclass subclassObj; 

     public superClass() { 
     } 
     public superClass(subclass subclassObj) { 
      this.subclassObj = subclassObj; 
     } 

     public start(){ 
      //some code 
     } 

     public receive(){ 
      subclassObj.receive(); // call subclass' receive() method 
     } 

Und Ihre subclass können wie:

public class subclass { 
public receive(){ 
    //some code 
} 

public static void main(String args[]){ 
    Superclass superTst = new Superclass(new subclass()); 
    superTst.start(); 
    // ... 
} 
} 

Answer 2

Ich würde es nicht tun. Wenn die Unterklasse eine Abhängigkeit von der Oberklasse hat, dann injiziere dort die Abhängigkeit. Es wird klarer werden, was die Abhängigkeiten sind und das Prinzip der einheitlichen Verantwortung beibehalten. Das Subklassifizieren von etwas, das nicht für seine Oberklasse stehen kann, wird letztlich nur verwirrend sein und bedeutet, dass Sie Implementierungen eng miteinander verbinden.

Answer 3

Sie sollten in der Lage sein, jede Methode Ihrer Superklasse aus Ihrer Unterklasse aufzurufen. Wann immer eine Unterklasse instanziiert wird, wird auch ihr Superklassen-Standardkonstruktor aufgerufen. Sie können einen anderen Konstruktor mit dem Schlüsselwort super aufrufen.

Um die Frage direkt zu beantworten, ist es nicht gut, eine Unterklasse mit einem Superklassenobjekt zu konstruieren.

Answer 4

Lets nehme an, dass Sie 10 Threads in der übergeordneten Klasse erstellen möchten: run() Methode, jeder Thread eine übergeordnete Klasse :: execute() -Methode aufrufen, die auf der letzten Instanz (Unterklasse) und nicht in Oberklasse ausgeführt werden soll:

abstract class SuperClass { 

    protected abstract function getClass(); 
    protected abstract function exec($thread_id, $data); 

    public function run(){ 
     for($i=0;$i<10;$i++){ 
      // create a new instance of the very top sub class 
      $child_instance = new $this->getClass(); 
      $this->createChildThread($child_instance, $this->someData); 
      // suppose that each thread will call: $child_inst->exec(); 
     } 
    } 
} 

class SubClass extends SuperClass { 
    public function getClass(){ return __CLASS__; } 
    public function exec($thread_id, $data){ 
     // hi...i'm executing inside a thread_id 
     // this instance, is a new instance of class Subclass and 
     // not a SuperClass instance :) 
    } 
}