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

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

我有几个问题:

Q-1 :- 我应该实现abstract 类中的所有方法吗？

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

Answer 1

当您扩展一个Interface 或一个Abstract 类时，您正在与该父类(super class) 创建某种契约。在契约(Contract)中你说:

"I will implement all unimplemented methods in my superclass"

如果您不这样做，请实现所有未实现的方法，那么您就是在违约。一种不违约的方法是让你的子类抽象以及一种表达方式

"I have not implemented all the classes in my contract, I am going to have my subclasses implement them".

对于您现在的 bar 类，您必须实现 b() 或使 bar 成为一个 Abstract 类或者您没有履行与 MyAbstractClass

的契约(Contract)

基本思路是:

接口(interface): 我的方法都没有实现。子类必须实现我的所有方法才能实现我。 (注意:我相信默认接口(interface)已经添加到 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();
 }

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

例子:

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

抽象 类也可以扩展接口(interface)，这样它们就可以实现它们的一些方法。但是他们也可以保留一些未实现的方法，以便子类可以实现它们。如果您未实现接口(interface)方法，则无需将其声明为抽象的，它已经在契约中。

例子:

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

所以本质上，抽象类与其父类(super class)没有严格的契约，因为它可以将其方法委托(delegate)给其子类。

Regular Class:(我用regular来表示非接口(interface)，非抽象)。我必须从我的所有父类(super class)中实现所有 未实现的方法。这些类具有约束力契约。

示例:

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