уборщик способ использования наследования, чтобы отделить «статический» код из «динамического» кода

Question

(со статическим и динамическим я имею в виду различие ли код восприимчива изменить)

У меня есть немного странная проблема у меня в настоящее время застрял. Я пишу приложение, которое связано с некоторыми сложными взаимодействиями между компонентами, в которых становится трудно отслеживать поток кода. Чтобы упростить это, я пытаюсь структурировать код, создавая «слои», где каждый уровень имеет увеличенную функциональность по сравнению со слоем над ним. Каждый слой содержится в пакете. У меня следующая проблема:

Рассмотрим следующие 2 классов и их подклассов с расширенной функциональностью:

Класс A:

package layer; 
class A { 
    B b; 

    A() { 
     b = new B(); 
    } 

    void foo() { 
     b.foo(); 
    } 

    /* More A-class methods here */ 
} 

Класс B:

package layer; 
class B { 
    void foo() { 
     // Do something 
    } 

    /* More B-class methods here */ 
} 

подклассы :

package sublayer; 
class ASub extends A { 

    ASub() { 
     super.b = new BSub(); // This needs a cast to compile 
    } 
} 

Подкласс B:

package sublayer; 
class BSub extends B { 
    @Override 
    void foo() { 
     // Do something with more functionality 
    } 
} 

В конце концов, я просто хочу, чтобы создать экземпляр и изменять классы Asub и BSub, будучи в состоянии использовать все методы суперклассов А и В, фактически необходимости изменять код в классах А и сам Б ,

Если я позвоню new ASub().foo(), я хочу переопределенное Foo() из BSub выполнить вместо того, что Б. Ofcourse я могу добавить переменную BSub bsub в Asub и переопределить Foo элементов а() метод для вызова bsub.foo(), но это оленья кожа избежать создание объекта b в конструкторе A, который кажется неаккуратным кодированием. Любые мысли по этому поводу? Любые комментарии приветствуются.

Answer 1

Ваш вопрос немного спорный. Создание объектов и инъекция зависимостей являются предметом большого обсуждения и основного фокуса различных структур и шаблонов проектирования.

Но вот, я надеюсь, один простой ответ на ваш вопрос, который не является общим «как создать объект в Java?»

В приведенном ниже коде я переношу ответственность за создание экземпляра B на метод (instantiateB()), который вызывается из конструктора A (суперкласс). Итак, если вы хотите подкласса A, вы переопределяете этот метод вместо переопределения конструктора.

package com.matt.tester; 

public class SE { 

    static class A { 
     B b; 

     A() { 
      instantiateB(); 
     } 

     void instantiateB() { 
      this.b = new B(); 
     } 

     void foo() { 
      b.foo(); 
     } 

     /* More A-class methods here */ 
    } 

    static class B { 
     void foo() { 
      System.out.println("Hellow from B.foo()!"); 
     } 

     /* More B-class methods here */ 
    } 
    static class ASub extends A { 

     @Override 
     void instantiateB() { 
      this.b = new BSub(); 
     } 
    } 
    static class BSub extends B { 
     @Override 
     void foo() { 
      System.out.println("Hellow from BSub.foo()!"); 
     } 
    } 

    public static void main(String[] args) { 
     A a = new ASub(); 
     a.foo(); 
    } 
} 

Answer 2

Использование наследования для содействия повторному использованию - действительно очень плохая идея. Наследование должно всегда определяться природой объектов, которые вы пытаетесь описать. Вам нужно научиться работать с терминами и абстракциями, чтобы спросить себя: «Какова природа того, что я пытаюсь описать». Мое предложение состоит в том, чтобы выучить книгу о Domain Driven Design, например, или Code Complete. Также подумайте о полиморфизме и шаблонах проектирования.