Question

如何在超类中定义方法，但将实现留给子类？

Answer 1

离开method 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，与类中的方法不同，默认情况下为package private而非抽象。

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

它应该声明为抽象。 e.g。

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


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

在子类的超类中定义方法

4 个答案: