13

there are the following classes:

public abstract class Super
{
    public abstract void run();
}

public class Sub1 extends Super
{
    @Override
    public void run ()
    {
        System.out.println("Method called");
        System.out.println("Sub1 called");
    }
}

public class Sub2 extends Super
{
    @Override
    public void run ()
    {
        System.out.println("Method called");
        System.out.println("Sub2 called");
    }
}

how can I avoid that I have to write the "System.out.println("Method called");" two times?

Thank you for answers

CalibeR.50

4

6 回答 6

16

将通用功能引入超类，并定义另一个抽象方法，子类将为其定义自己的实现。

public abstract class Super {
    public void run() {
        System.out.println("Method called");
        printMessage();
    }
    abstract void printMessage ();
}

public class Sub1 extends Super {
    @Override
    void printMessage() {
        System.out.println("Sub1 called");
    }
}

public class Sub2 extends Super {
    @Override
    void printMessage () {
        System.out.println("Sub2 called");
    }
}

这样可以避免重复调用超类的公共方法两次。

于 2013-07-06T19:49:32.083 回答
4

您可以将 run() 实现放入抽象类中：

// Super is still an abstract class
public abstract class Super
{
    // While method run is not an abstract method:
    public void run() 
    {
        System.out.println("Method called");
    }
}

public class Sub1 extends Super
{
  // There's no need of declaring run() here unless you want to change its behaviour
}

public class Sub2 extends Super
{
}

在您的问题的编辑版本中，您可以只使用继承的运行实现

// Super is still abstract
public abstract class Super
{
    // But method run is not abstract
    public void run() 
    {
        System.out.println("Method called");
    }
}

public class Sub1 extends Super
{
  @Override
  public void run()
  {
      super.run(); // <- call Super.run() that prints "Method called"
      System.out.println("Sub1 called");
  }
}

public class Sub2 extends Super
{
  @Override
  public void run()
  {
      super.run();
      System.out.println("Sub2 called");
  }
}
于 2013-07-06T19:44:44.463 回答
3

如果 Sub1 和 Sub2 的部分实现run()是通用的，我建议您只需在子类中使用继承和覆盖运行。这是代码示例：

public abstract class Super
{
    public void run() {
        // Code shared by all subclasses
        System.out.println("Method called");
    }

}

public class Sub1 extends Super
{
    @Override
    public void run ()
    {
        super.run();
        System.out.println("Sub1 called");
    }
}

public class Sub2 extends Super
{
    @Override
    public void run ()
    {
        super.run();
        System.out.println("Sub2 called");
    }
}

这里的技巧是Super可以abstract在实现方法时定义类。如果您有不需要共享代码的子类，您可以run()在没有super.run()代码的情况下覆盖并全部更改。

于 2013-07-06T19:58:38.833 回答
3

使用“模板方法模式”：

public class Super
{
    public void template() {
        System.out.println("Method called");
        run();
    }

    public abstract void run();
}

public class Sub1 extends Super
{
    @Override
    public void run () // out called before run
    {

    }
}

public class Sub2 extends Super
{
    @Override
    public void run () // out called before run
    {

    }
}

此外，您可以使运行受保护。

于 2013-07-06T19:55:24.790 回答
2

您可以将公共代码放在超类方法中并从子类方法中调用它。

public abstract class Super
{
   public abstract void run();
   // code common to both the sub classes implemented
   public void print() {
     System.out.println("Method called");
   }
}

public class Sub1 extends Super
{
   @Override
   public void run ()
   {
     print();
     System.out.println("Sub1 called");
     // sub class specific code here
   }
}

public class Sub2 extends Super
{
   @Override
   public void run ()
   {
      print();
      System.out.println("Sub2 called");
      // sub class specific code here
   }
}
于 2013-07-06T19:48:42.323 回答
1

如果您希望所有子类具有相同的行为，那么正确的技术是仅在超类中编写方法，允许子类继承它。但这将消除在这种情况下您的超类是抽象的需要，因为它将实现它唯一的方法。

于 2013-07-06T19:44:23.180 回答