Java的抽象方法和抽象类

古城微笑少年丶 2021-09-19 22:54 519阅读 0赞

**一 点睛**

抽象方法是只有方法签名，没有方法实现的方法。

抽象方法和抽象类必须使用abstract修饰符来定义，有抽象方法的类只能被定义为抽象类，抽象类里可以没有抽象方法。

抽象类和抽象方法的规则：

抽象类必须使用abstract修饰符来修饰，抽象方法必须使用abstract修饰符来修饰，抽象方法不能有方法体。

*  抽象类不定被实例化。即使抽象类里不包含抽象方法，这个抽象类也不能创建实例。
 *  抽象类可以包含成员变量、方法（普通方法和抽象方法）、构造器、初始化块、内部类（接口、枚举）5种成分。抽象类的构造器不能用于创建实例，主要用于被其子类调用。
 *  含有抽象方法的类（包括直接定义一个抽象方法；或继承了一个抽象父类，但没有完全实现父类包含的抽象方法；或实现了一个接口，但没有完全实现接口包含的抽象方法三种情况）只能定义为抽象类。

**二 代码**

1 抽象类

public abstract class Shape
    {
       {
          System.out.println("执行Shape的初始化块...");
       }
       private String color;
       // 定义一个计算周长的抽象方法
       public abstract double calPerimeter();
       // 定义一个返回形状的抽象方法
       public abstract String getType();
       // 定义Shape的构造器，该构造器并不是用于创建Shape对象，
       // 而是用于被子类调用
       public Shape(){}
       public Shape(String color)
       {
          System.out.println("执行Shape的构造器...");
          this.color = color;
       }
       // 省略color的setter和getter方法
       public void setColor(String color)
       {
          this.color = color;
       }
       public String getColor()
       {
          return this.color;
       }
    }

2 Triangle类

public class Triangle extends Shape
    {
       // 定义三角形的三边
       private double a;
       private double b;
       private double c;
       public Triangle(String color , double a
          , double b , double c)
       {
          super(color);
          this.setSides(a , b , c);
       }
       public void setSides(double a , double b , double c)
       {
          if (a >= b + c || b >= a + c || c >= a + b)
          {
             System.out.println("三角形两边之和必须大于第三边");
             return;
          }
          this.a = a;
          this.b = b;
          this.c = c;
       }
       // 重写Shape类的的计算周长的抽象方法
       public double calPerimeter()
       {
          return a + b + c;
       }
       // 重写Shape类的的返回形状的抽象方法
       public String getType()
       {
          return "三角形";
       }
    }

3 Circle类

public class Circle extends Shape
    {
       private double radius;
       public Circle(String color , double radius)
       {
          super(color);
          this.radius = radius;
       }
       public void setRadius(double radius)
       {
          this.radius = radius;
       }
       // 重写Shape类的的计算周长的抽象方法
       public double calPerimeter()
       {
          return 2 * Math.PI * radius;
       }
       // 重写Shape类的的返回形状的抽象方法
       public String getType()
       {
          return getColor() + "圆形";
       }
       public static void main(String[] args)
       {
          Shape s1 = new Triangle("黑色" , 3 , 4, 5);
          Shape s2 = new Circle("黄色" , 3);
          System.out.println(s1.getType());
          System.out.println(s1.calPerimeter());
          System.out.println(s2.getType());
          System.out.println(s2.calPerimeter());
       }
    }

**三 运行**

执行Shape的初始化块...
    执行Shape的构造器...
    执行Shape的初始化块...
    执行Shape的构造器...
    三角形
    12.0
    黄色圆形
    18.84955592153876

**四 注意**

abstract不能用于修饰成员变量，不能用于修饰局部变量，即没有抽象变量、没有抽象成员变量等说法；abstract也不能用于修饰构造器、没有抽象构造器，抽象类里定义的构造器只能是普通构造器。

static和abstract不能同时修饰某个方法，但它们可以同时修饰内部类。

abstract关键字修饰的方法必须被子类重写才有意义，否则这个方法永远不会有方法体，因此abstract方法不能定义为private访问权限，即private和abstract不能同时修饰方法。