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

我有几个问题：

问题1： - 我应该在abstract课程中实施所有方法吗？

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

Answer 1

当您扩展Interface或Abstract课程时，您正在使用superclass创建合同。你在合同中说：

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

如果你没有，实施所有未实施的方法，那么你就违反了合同。一种不违反合同的方法是使您的子类Abstract以及一种说法

“我没有在合同中实施所有课程，我会去让我的子类实现它们“。

对于您的班级bar，您必须实施b()或bar Abstract课程，或者您未履行与MyAbstractClass <的合同/ p>

基本理念是：

界面：我的方法都没有实现。子类必须实现我的所有方法才能实现我。（注意：我相信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();
 }

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

示例：

 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

问题1： - 我应该在abstract班级实施所有方法吗？

是的，您必须实施所有abstract方法。

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

是的，您可以声明自己的（更具特色的）方法。

Answer 3

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

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

Answer 4

Ya肯定实现类也可以定义自己的方法，如果没有在派生类中实现抽象类的所有方法，那么也将此派生类标记为Abstract

但是在链的末尾你必须创建一个具体的类来实现所有未在抽象子父实现的方法

Answer 5

您不必实现抽象类的所有方法。 但是你必须实现它的所有抽象方法。

事实上，扩展一个抽象类与扩展普通类没有区别。这不像实现接口。由于您正在扩展，因此您可以创建一个子类，因此您可以根据需要添加任意数量的方法和属性。

Answer 6

    public interface I{
       public void m();
    }

    public abstract class A1 implements I{
         //No need to implement m() here - since this is abstract
    }

    public class B1 extends A1{
      public void m(){
            //This is required, since A1 did not implement m().
      }
    }

    public abstract class A11 extends A1{
          //Again No need to implement m() here - since this is abstract
         public abstract void newA11Method()
    }

   public class B11 extends A11{
        //This class needs to implement m() and newA11Method()
   }

Answer 7

是的，实现类只需要在抽象类中实现标记为abstract的方法。

Answer 8

是的，您必须实现抽象类中存在的所有方法。因为抽象类的目的纯粹是为函数的创建模板，这些函数的实现由实现它们的类决定。因此，如果不实现它们，那么就会破坏抽象类的概念。

要回答第二个问题，是的，无论您要扩展的抽象类如何，您都可以创建任意数量的自己的方法。

Answer 9

是的，当您实现接口时，您将实现其所有方法。这是定义接口的目的。是的，您可以在实现接口的类中拥有自己的方法。

Answer 10

是的，当您扩展摘要时，您应该为abstract methods中提供的所有abstract class提供实施。 Othrewise你应该把它作为abtract类实现类。

Answer 11

您必须实现抽象类中具有的所有抽象方法。但是您可以直接使用已实现的具体方法。

有关更多信息，请参阅： https://www.javatpoint.com/abstract-class-in-java

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

11 个答案: