我应该实现抽象类中的所有方法吗？

Question

我应该实现抽象类中的所有方法吗？

以下是代码段:

public abstract class MyAbstractClass {

    public abstract void a();
    public abstract void b();
}


public class Foo extends MyAbstractClass {

    public void a() {
        System.out.println("hello");
    }

    public void b(){
        System.out.println("bye");
    }
}


public class Bar extends MyAbstractClass {

    public void a() {
        System.out.println("hello");
    }

    public void delta() {
        System.out.println("gamma");
    }
}

Run Code Online (Sandbox Code Playgroud)

我有几个问题:

问题1: - 我应该在abstract课堂上实现所有方法吗？

问题2: - 实现类可以有自己的方法吗？

Answer 1

mde*_*itt 44

当你扩展一个Interface或一个Abstract类时,你正在创建一个与之类似的合同superclass.你在合同中说:

"我将在我的超类中实现所有未实现的方法"

如果不这样做,实施所有未实现的方法,那么你就违反了合同.一种不违反合同的方法是使你的子类Abstract以及一种说法

"我没有在合同中实现所有类,我将让我的子类实现它们".

为了您的类bar现在,你必须执行b()或作出bar一个Abstract类或者你没有履行与您的合同MyAbstractClass

基本思路是:

接口:我的方法都没有实现.子类必须实现我的所有方法才能实现我.(注意:我相信Java 8中已经添加了默认接口,这可能会稍微改变一下)

例:

 public interface myInterface
 { 
     //My subclasses must implement this to fulfill their contract with me
     public void methodA();

     //My subclasses must implement this to fulfill their contract with me
     public void methodB();
 }

Run Code Online (Sandbox Code Playgroud)

摘要:我可能会实现一些方法,但我也会将方法保留为抽象,以便我的子类必须实现,因为它们可以实现这些类,以便更好地满足它们的需求.

例:

 public abstract class myAbstractClass
 {
     //My subclasses must implement this to fulfill their contract with me
     public abstract void methodC();

     public void helloWorld()
     {
         System.out.println("Hello World");
     }
 }

Run Code Online (Sandbox Code Playgroud)

Abstract类还可以扩展接口,以便它们可以实现一些方法.但是它们也可以保留一些未实现的方法,因此子类可以实现它们.如果保留未实现的接口方法,则不需要将其声明为抽象,它已经在合同中.

例:

  public abstract class myAbstractClass2 implement myInterface
  {
      @Override
      public void methodA()
      {
          // this fulfills part of the contract with myInterface.
          // my subclasses will not need to implement this unless they want to override
          // my implementation.
      }

      //My subclasses must implement this to fulfill their contract with me
      public abstract void methodD();
  }

Run Code Online (Sandbox Code Playgroud)

所以从本质上讲,抽象类与它的超类没有严格的契约,因为它可以将其方法委托给它的子类.

常规类 :(我使用常规表示非接口,非抽象).我必须从我的所有超类中实现所有未实现的方法.这些类具有约束力的合同.

例:

 public class mySubClass extends myAbstractClass2
 {
     @Override
     public void methodB()
     {
         //must be implemented to fulfill contract with myInterface
     }

     @Override
     public void methodD()
     {
         //must be implemented to fulfill contract with myAbstractClass2
     }

     public void myMethod()
     {
        //This is a method specifically for mySubClass. 
     }
 }

Run Code Online (Sandbox Code Playgroud)