在超类中为子类定义方法

Question

人们将如何在超类中定义方法，而将实现留给子类呢？

Answer 1

将方法保留为abstract ：

abstract class A {
    abstract void doStuff();
}

class B extends A {
    void doStuff() {
        // stuff
    }
}

注意...

如果类包含抽象方法，则必须将类本身声明为abstract

无法构造抽象类（因此， new A()将是一个错误，但new B()将是可以的），并且子类需要实现所有抽象方法，除非它们也是抽象的。

abstract class A {
    abstract void doStuff();
}

abstract class B extends A {
    // This is fine since B is abstract
}

class C extends A {
    // This is an error since doStuff() isn't implemented
}

使用抽象类，可以混合使用抽象方法和普通方法：

abstract class A {
    abstract void doStuff();

    void doOtherStuff() {
        // Subclasses don't need to implement this
    }
}

如果所有方法都是抽象的，则使用interface可能更有意义，因为类实现了多个接口：

interface DoesStuff {
    void doStuff();
}

interface DoesOtherStuff {
    void doOtherStuff();
}

class B implements DoesStuff, DoesOtherStuff {
    void doStuff() {
        // stuff
    }

    void doOtherStuff() {
        // other stuff
    }
}

注意：与类中的方法不同，接口中的方法是自动abstract和public ，而类中的方法默认情况下是私有的而不是抽象的。

Answer 2

将超类作为abstract类，并将方法定义为abstract方法，该方法强制子类提供实现（或使自己成为abstract 。

例：

abstract class Super {
    abstract void absMethod();
}

class Sub extends Super {
    void absMethod() {
        // implementation
    }
}

Answer 3

您将在超类中创建一个抽象方法。

abstract class SuperClass {
   public abstract void mustImplement();
}

class SubClass extends SuperClass {
   public void mustImplement() {
       // Do stuff here
   }
}

Answer 4

它应该声明为抽象。 例如

abstract class MyBaseClass
{
  protected abstract void myMethod();
}


class MyChildClass extends MyBaseClass
{
  protected void myMethod()
  {
    // here is my implementation!
  }
}