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

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

我有几个问题：

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

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

Answer 1

当您扩展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();
 }

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

示例：

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

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

因此，从本质上说，抽象类与它的超类没有那么严格的约定，因为它可以将其方法委托给它的子类。

正则类：(我使用正则类来表示非接口和非抽象)。我必须从我的所有超类中实现所有未实现的方法。这些类有一个具有约束力的契约。

示例：

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

Answer 2

abstract q-1：-我应该在类中实现所有方法吗？

• 是的，必须实现所有abstract方法。

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

• 是的，您可以声明自己的(更具体的)方法。

Answer 3

不仅应该这样，而且必须实现所有抽象方法(如果子类是非抽象的)。否则，如果调用该方法，子类的对象将不知道该做什么！

防止这种情况的唯一方法是，如果子类也被声明为abstract，那么首先不能实例化它。