如何以及何时使用抽象类

Question

这是我用Java编写的测试程序。我想知道抽象类在这里有多重要以及为什么我们为此使用抽象类。

这是强制性的还是最好的方法；如果是这样怎么办？

class Shape1 {
    int i = 1;
    void draw() {
        System.out.println("this is shape:" + i);
    }
}

class Shape2 {
    int i = 4;
    void draw() {
        System.out.println("this is shape2:" + i);
    }
}


class Shape {
    public static void main(String args[]) {
        Shape1 s1 = new Shape1();
        s1.draw();

        Shape2 s2 = new Shape2();
        s2.draw();
    }
}

Answer 1

您可以在此处使用抽象类或接口，以便创建提供 void draw() 方法的公共基类/接口，例如

abstract class Shape() {
  void draw();
}

class Circle extends Shape {
   void draw() { ... }
}

...

Shape s = new Circle();
s.draw();

我通常会使用接口。但是，如果满足以下条件，您可以使用抽象类：

1. 您需要/想要提供通用功能或类成员（例如，您的情况下的 int i 成员）。
2. 您的抽象方法具有除公共访问（这是接口允许的唯一访问类型）之外的任何内容，例如，在我的示例中，void draw() 将具有包可见性。

Answer 2

抽象类是至少有一个未实现的方法或关键字abstract 的类。例如，一个抽象方法可能如下所示：

public abstract String myMethod(String input);

（注意该方法以分号结尾）。

以及一个类可能看起来像这样：

public abstract class MyClass {

    public abstract String myMethod(String input);

    public String anotherMethod(String input) {
        return intput + " additional text";
    }
}

抽象类无法实例化。抽象类需要一个子类来实现缺失的行为，以便可以实例化它。

抽象类的主要目标是提供公共行为的共享实现 - 促进代码的重用。

在 Java 中，通过使用类的组合而不是从广泛定义的抽象继承，可以实现相同的效果类。这允许更多模块化、功能特定的类促进代码重用，从而提高可维护性。

我的建议是仅在绝对必要时才使用抽象类，特别是避免将其用作充满各种功能的技巧包。

在 Scala 中，人们会使用特征，这是解决这个问题的一种优雅的方式。然而，它确实需要大量的关注才能顺利通过。

编辑：从 Java 8 开始，接口中的默认方法是添加常见行为的另一种方法。

Answer 3

抽象类与您的子类具有“is-a”类型关系。例如，您可以有一个抽象类 Shape，其中包含任何形状所具有的内容（如绘图函数），然后是一个类 SquareShape。每个正方形都是一个形状，但并非所有形状都是正方形。

在您的示例中，您有 2 个形状类型，以及一个具有 2 个实例的类。我认为这不是你应该用abstract定义的关系。

不过，您可能想对您的名字做一些事情，因为这是一个相当小的示例，很难看出这些文件的真正含义以及它们应该如何工作。

Answer 4

常见的东西+不常见的东西=抽象类

什么时候使用？

抽象类最适合有大量可重用代码的场景，您不想一次又一次地编写这些代码+每个类都有一些特定的内容。

例子？

仪式：

常见的事情：唱国歌、升旗等
具体内容：印度国旗、印度国歌（印度）、中国国旗、中国国歌（中国）等

如何使用？

1）创建抽象类
2）将所有内容放在常用的公共方法中
3）将所有内容放入特定于子类的抽象方法中

示例代码在哪里？

基类：

public abstract class BaseCeremony{

    Flag natonalFlag;
    Anthem anthem;

    //**** Common Task ******//
    public void startCeremony(){
        configure();
        hoistFlag();
        singAnthem();
    }

    public void hoistFlag(){
        natonalFlag.hoist();                       
    }

    public void singAnthem(){
        anthem.anthem();                       
    }

    private void configure(){
        natonalFlag = provideFlag();
        anthem = provideAnthem();
    }

    //**** Differs in all part ******//
    public abstract Flag provideFlag();
    public abstract Anthem provideAnthem();

}

在子类中，您只需提供不常见部分的实现即可。
ChildClass

public class IndianCeremony extends BaseCeremony{

       public Flag provideFlag(){
            return new IndianFlag();
       }

       public Anthem provideAnthem(){
            return new IndianAnthem();
       }
}

优点

• 抽象类是一个不完整的类，这就是为什么你不能创建它的对象。
• 抽象类应该至少有一个抽象方法才有资格成为抽象类
• Android

Answer 5

在 java 中使用抽象类的示例。

package use_of_abstract;

abstract class Shapes 
{
   int i=1;

   abstract void draw();
   abstract void color(String mycolor);

   //not an abstract method
   void fill()
   {
      System.out.println("Non-Abstract Method -> Fill"); 
   }

   //not an abstract method
   String anotherMethod(String input) 
   {
       return input + " additional text";
   }

}

---

package use_of_abstract;

public class Shape_One extends Shapes 
{
    int i=1;

    @Override
    void draw() 
    {
        System.out.println("This is Shape One:"+i);
    }

    @Override
    void color(String mycolor) 
    {
        System.out.println("This is Shape One:"+mycolor);

    }

    @Override
    String anotherMethod(String anotherMethod) 
    {
        System.out.println("This is Shape One:"+anotherMethod);
        return anotherMethod;

    }

}

---

package use_of_abstract;

public class Shape_Two extends Shapes
{
    int i=2;

    @Override
    void draw() 
    {
        System.out.println("This is Shape Two :"+i);
    }

    @Override
    void color(String mycolor) 
    {
        System.out.println("This is Shape Two Color:"+mycolor);
    }

    @Override
    String anotherMethod(String anotherMethod) 
    {
        System.out.println("This is Shape Two:"+anotherMethod);
        return anotherMethod;

    }

}

---

package use_of_abstract;

import java.awt.Color;

public class Shape_Main 
{

    public static void main(String args[])
    {
        Shape_One s1;
        Shape_Two s2;

        s1=new Shape_One();
        s2= new Shape_Two();

        s1.draw();
        s2.draw();

        s1.fill();
        s2.fill();

        s1.color("Blue");
        s2.color("Green");


        s1.anotherMethod("HELLO..............Its Another Method 1");
        s2.anotherMethod("HELLO..............Its Another Method 2");


    }   
}

Answer 6

抽象类，顾名思义就是抽象的。

抽象类不讲实现部分。事实上，我们扩展了抽象类以提供其抽象方法的实现。它也可以有非抽象方法。

检查此处：在 Java 中使用抽象类

编辑：

示例代码：

abstract class Shapes {

 int i=1;
 abstract void draw(); 

 // Remember : Non-abstract methods are also allowed 
 void fill() {
     System.out.println("Non abstract method - fill");
 }
}

class Shape1 extends Shapes {

 int i=1;
 void draw(){
 System.out.println("This is Shape 1:"+i);
 }
}

class Shape2 extends Shapes {
    int i=2;
    void draw() {
        System.out.println("This is Shape 2:"+i);
    }
}

class Shape {

public static void main(String args[])
       {
        Shape1 s1 = new Shape1();
        s1.draw();                     // Prints This is Shape 1:1

        Shape2 s2 = new Shape2();
        s2.draw();                     // Prints This is Shape 2:2
       }
  }