从另一个抽象 class 扩展而来的抽象 class 的重要性是什么

Question

我大约两个月前才开始学习 java，现在我正在尝试更多地理解抽象的 classes。我了解抽象的基本思想及其实现，但我不明白为什么抽象 class 扩展了另一个抽象 class 以及它添加了哪些功能。另外，我看到一个抽象class扩展了另一个抽象class，但它只实现了另一个抽象class的一个功能。

我确实查找了示例代码，但它们只显示了实现而没有对它们进行解释：

public abstract class Beverage {

   String description = "Beverage";

   public String getDescription(){
      return description;
   }
     public abstract double cost();

 }

// abstract class CondimentDecorator 
   public abstract class CondimentDecorator extends Beverage {

       @Override
       public abstract String getDescription();
 }

如您所见，摘要classCondimentDecorator并没有实现Beverage摘要class中的所有功能。它只实现了 getDescription() 功能。但是，如果 CondimentDecorator 是具体的，那么就需要实现 Beverage 抽象 class.

中的所有功能

Answer 1

抽象 class 不需要实现任何东西。可以，但是没有这个要求。唯一需要做的就是在具体 classes 中提供接口和抽象 classes 的抽象方法的实现。在复杂的层次结构中，您可以在中间抽象 class 中实现一些抽象方法，但并非所有内容都必须具体 class.

Answer 2

当一个抽象 class 扩展另一个抽象 class 时完全没问题。这只是意味着它 详细说明 新 class 的行为基于旧 class 的行为。但它仍然不是一个完整的对象，因为它的一些行为仍然未知。

类比现实世界。
假设您有一个 class Vehicle。它可以是任何交通工具：汽车、飞机、公共汽车、自行车等等。这是您的摘要 class。现在可以用了吗？不是，因为你不知道是踩踏板还是转动方向盘。
现在你创建另一个 class，比如说 Car extends Vehicle。现在可以用了吗？可能，但您仍然不知道它是卡车还是乘用车。但是你知道它有方向盘。
最后，当您再创建一个 class，比如说 MySuperPassengerCar extends Car 时，您就会确切地知道这是什么对象，它可以如何使用以及它有哪些方法。

Answer 3

Abstract class 定义抽象方法。任何 class 扩展另一个 class 通过添加更多行为来增强超级 class。如果 child class 是抽象的，它可以添加一些抽象行为。

抽象方法就像契约。其他代码可以使用现有代码并可以依赖它。具体 class 必须通过提供实施来遵守合同。

让我们看下面的例子。

public abstract class SuperAbstract {
      public void nonAbstract(){
            // some code
      }
      public abstract void contract();
}

public abstract class SubAbstract extends SuperAbstract{
       public void additionalNonAbstract()
             // some code
        }
        public abstract void additionalContract();
 }

public class Concrete extends SubAbstract{
       public void contract(){
             // implementation
       }
       public void additionalContract(){
               //implementation
       }
}

// although below is allowed and sometimes when we use an external library then this is one of the way but still this is not a good practice. 
// dependencies should be on abstractions only and not on concrete implementation
public abstract class AnotherAbstract extends Concrete{
       public void someMethod(){
             //some code
       }
       public abstract void oneMoreContract();
}

public class ConcreteA extends AnotherAbstract{
        public void oneMoreContract(){
               //some implementation
        }
}

现在请注意，我们总共定义了 3 个合约，并且 ConcreteA 具有所有实现。另请注意，由于 Concrete 为方法 contract 和 additionalContract 提供了实现，因此这些实现由 ConcreteA

继承

消费者代码可以很容易地依赖于抽象。让我们在用户代码（消费者代码）中看到它

  public class Consumer{
      public void m1(SuperAbstract c)
             c.contract();
             c.nonAbstract();
     }
     public void m2(AnotherAbstract c){
          c.contract();
          c.nonAbstract();
          c.oneMoreContract();
          c.additionalContract();
    }
 }

现在让我们看看提供依赖关系的接线代码

 public class Main{
       public static void main(String[] args){
            Consumer c = new Consumer();
             c.m1(new Concrete());
             c.m1(new ConcreteA());
             c.m2(new ConcreteA());
     }
}

从另一个抽象 class 扩展而来的抽象 class 的重要性是什么

What is the importance of abstract class that extends from another abstract class

java

oop

inheritance

abstract-class