Question

我已经定义了一个超类，如下所示;

 public class superClass{

        private superClass superObj;

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

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

我的子类就像;

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

在这里，我的子类实际上不是＆＃34;是-a＆＃34;与超类的关系。但是我希望像这样扩展，因为在超类中我做了一些处理输出（超类生成新线程并进行处理，所以我可以在超类中获取输出），这必须由子类访问。

这在理论上是对的吗？

Answer 1

我不会这样做。如果子类依赖于超类，那么在那里进行依赖注入。更清楚的是依赖关系是什么并维持单一责任原则。对不能代表超类的东西进行子类化最终会让人感到困惑，这意味着你正在紧密地结合实现。

Answer 2

您应该能够从子类中调用超类的任何方法。此外，每次实例化子类时，都会调用其超类默认构造函数。您可以使用super关键字调用另一个构造函数。

要直接回答这个问题，使用超类对象构造子类是不好的设计。

Answer 3

让我们假设您要在SuperClass：run（）方法中创建10个线程，每个线程调用一个SuperClass :: execute（）方法，该方法应该在最终实例（子类）上运行，而不是在SuperClass中运行：

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 :)
    }
}

Answer 4

正如你提到的那样

子类与超类
实际上不是“is-a”关系

所以我想你应该使用组合而不是继承，如下所示：

    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
       }

您的subclass就像：

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

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

将超类实例传递给它的构造函数是更好的做法吗？

4 个答案: