Question

有以下类：

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");
    }
}

我怎样才能避免我必须编写“System.out.println（”方法称为“）”;“两次？

感谢您的回答

CalibeR.50

Answer 1

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

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");
    }
}

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

Answer 2

您可以将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");
  }
}

Answer 3

使用＆＃34;模板方法模式＆＃34;：

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
    {

    }
}

您可以使运行受到保护。

Answer 4

如果run()的部分实现对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()并更改所有内容。

Answer 5

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

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

Answer 6

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

Java“抽象喜欢”方法与body

6 个答案: