常见事物+罕见事物=抽象类

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

我通常使用界面。但是，您可以在以下情况下使用抽象类：

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

Answer 2

抽象类与您的子类具有“is-a”类型关系。例如，你可以有一个抽象类Shape，它有任何形状的东西（比如绘制函数），然后是类SquareShape。每个方形都是一个形状，但并非所有形状都是方形。

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

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

Answer 3

在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 4

抽象类是一个类，至少有一个未实现的方法或关键字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中，人们会使用traits，这是解决这个问题的一种优雅方式。但是，它确实需要很多关注才能完成它。

Answer 5

常见事物+罕见事物=抽象类

何时使用？

抽象类最适合您有很多可重复使用的代码而又不想一次又一次地编写的情况+每个类都有很少的特定内容。

示例？

仪式：

常见问题：唱国歌，吊旗等
具体内容：印度国旗，印度国歌（印度），中国国旗，中国国歌（中国）等。

如何使用它？

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 6

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

抽象类没有谈到实现部分。实际上，我们扩展抽象类以提供其抽象方法的实现。它也可以有非抽象的方法。

点击此处：Use of Abstract Class in 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
       }
  }

如何以及何时使用抽象类

6 个答案:

常见事物+罕见事物=抽象类

仪式：

奖金