Question

如果我有一个超类BaseClass和一个子类SubClass，并且我希望某些子类的函数略有不同，那么覆盖原始函数，调用super，并稍微修改是不好的做法额外的功能？

例如:(伪代码）

public class BaseClass{
   int fooA();
   int fooB();
   int fooC();
}

public class SubClass extends BaseClass{
   @Override
   int fooB(){
      int temp = super.fooB();
      temp += 1;
      return temp;
   }

   @Override
   int fooC(){
      System.out.println("I'm doing something extra in fooC!");
      return super.fooC();
   }
}

我试图阻止代码重复，但我觉得我做错了什么或忘记了一些基本的OOP内容，所以我想我会问这是不是很糟糕的做法。我做了遗产已经有一段时间了;感谢任何见解。

Answer 1

您可以执行以下操作，而不是继承：

public class SubClass implements MyInterface {
   private MyInterfaceBasicImpl base;

   int fooB(){
      int temp = base.fooB();
      temp += 1;
      return temp;
   }

   int fooC(){
      System.out.println("I'm doing something using in fooC in base object!");
      return base.fooC();
   }
}

这是Composition模式的一个简单示例。由于Java中没有多重继承，因此请将代码保持打开以进行改进。

Answer 2

子类覆盖方法的能力允许类继承自行为“足够接近”的超类，然后继承根据需要修改行为。覆盖方法具有相同的名称，参数的数量和类型，以及返回类型作为它的方法覆盖。重写方法也可以返回该类型的子类型由重写方法返回。该子类型称为协变返回类型。

希望这能为您的问题提供答案。

https://docs.oracle.com/javase/tutorial/java/IandI/override.html

Answer 3

你可以做你的建议，是一个选择。但是，如果你有3个类做同样的事情会发生什么？你仍然在重复代码和逻辑，因为在每个代码和逻辑中你都会调用super。在这种情况下你可以做的是实现模板方法模式。如果你还没有读过它，那就意味着将超类中的方法定义为抽象，在那里使用它然后在子类中定义它。按照你的例子，它可能看起来像这样：

public class BaseClass{
   int fooA();
   int fooB();
   int fooC(){
     //here goes the common logic;
     this.printWhatItHasToPrint();
   }
   void printWhatItHasToPrint() {}; //if the class is abstract you may define it as abstract
}

public class SubClass1 extends BaseClass{
   @Override
   int fooB(){
      int temp = super.fooB();
      temp += 1;
      return temp;
   }

   @Override
   void printWhatItHasToPrint(){
        System.out.println("I'm doing something extra in fooC!");
   }
}

public class SubClass2 extends BaseClass{

   @Override
   void printWhatItHasToPrint(){
        System.out.println("I'm doing something extra in fooC, and I'm another class!");
   }
}

Answer 4

我认为这可能是正确的方法，但根据我的经验，制作一个具有公共函数的抽象类更具可读性和方便性，然后有两个子类来扩展它以实现不同的功能，如：

public abstract class BaseClass {
    public void fooA() {
        System.out.println("Some common function");
    }

    public void fooB() {
        System.out.println("Another common function");
    }

    public abstract int fooC();
}  

public class SubClass1 extends BaseClass {
    @Override
    public int fooC() {
        return 0;
    }
} 

public class SubClass1 extends BaseClass {
    @Override
    public int fooC() {
        return 1;
    }
}

通过这种方式，可以更轻松地浏览更大的项目并感觉更自然

通过调用super来覆盖函数只是为了增加一些功能是不好的做法吗？

4 个答案: