【Java 学习】Java抽象类详解：从理论到实践，带你迈向面向对象的深度思考！

💬 欢迎讨论：如对文章内容有疑问或见解，欢迎在评论区留言，我需要您的帮助！

👍 点赞、收藏与分享：如果这篇文章对您有所帮助，请不吝点赞、收藏或分享，谢谢您的支持！

🚀 传播技术之美：期待您将这篇文章推荐给更多对需要学习Java语言、低代码开发感兴趣的朋友，让我们共同学习、成长！

1. 什么是抽象类？

举一个Animal类、Cat类和Dog类的例子：

```java
class Animal{

    public void eat(){
        System.out.println("吃饭~");
    }
}

class Dog extends Animal{
    public void eat(){
        System.out.println("吃骨头~");
    }

    public void bark(){
        System.out.println("汪汪~");
    }
}

class Cat extends Animal {

    // 构造器

    public void eat(){
        System.out.println("吃鱼~");
    }

    public void mimi() {
        System.out.println("喵喵~~");
    }

}


public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat();

        Cat cat = new Cat();
        cat.eat();

    }
}

```

关系图如下：

这三个类之间：Dog类继承Animal类，Cat类继承Animal类

当使用时，实例化Dog类和Cat类，但是不实例化Animal类，并且，Animal中的方法都会被Dog类和Cat类重写，似乎Animal中不需要定义方法，只需要写方法名字即可！

在上述的描述中，我们发现Animal这种类，也就是父类（基类）中的方法不需要定义，只需要设置一些名字即可，定义的内容让继承父类的类去实现 。

为了满足这个需求，Java设计了一个抽象类（abstract），这种类是一个不能被直接实例化的类，用来作为其他类的模板。它可以包含抽象方法（没有方法体的方法）和非抽象方法（普通的方法，有方法体）。

抽象类本质上是“不能直接使用的类”。它的主要作用是 定义一种规范或基类，让子类去实现具体的功能。

2. 抽象类的语法及特性

2.1 抽象类语法

在Java中，一个类如果被abstract 修饰称为抽象类 ，抽象类中被给出具体的实现体。

```java
// 抽象类：被abstract修饰的类
public abstract class Shape {

    protected double area;    // 面积


    // 抽象方法：被abstract修饰的方法，没有方法体
    abstract public void draw();
    abstract void calcArea();

    // 抽象类也是类，也可以增加普通方法和属性
    public double getArea(){
        return area;
    }
 }

//abstract 修饰的方法称为抽象方法，抽象方法不用定义实体


```

注意：抽象类也是类，内部可以包含普通方法和属性，甚至构造方法

2.2 抽象类特性

1. 抽象类不能直接实例化对象

   ```java
   

   Shape shape = new Shape();

   // 编译出错
   Shape是抽象的; 无法实例化

   ```

2. 抽象方法不能使用private访问限定符

   ```java
   

   abstract public class Shape {
   protected double area;

   // 不合法的使用规则
   // 抽象方法需要被重写，使用private后子类就不能重写
   abstract private void draw();
   
   public double getArea(){
       return area;
   }
   

   }

   ```

3. 抽象方法不能被final和static修饰，因为抽象方法要被子类重写

   ```java
   

   public abstract class Shape {
   abstract final void methodA();
   abstract public static void methodB();
   }

   // 编译报错：
   //非法的修饰符组合: abstract和final
   //非法的修饰符组合: abstract和static

   ```

4. 抽象类必须被继承，并且继承后子类要重写父类中所有的抽象方法。（下述的三个代码放在不同的文件中）

   ```java
   

   //文件 Rect.java
   // 矩形类
   public class Rect extends Shape {
   private double length;
   private double width;

   Rect(double length, double width){
       this.length = length;
       this.width = width;
   }
   
   // 实现所有的抽象类
   public void draw(){
       System.out.println("矩形: length= "+length+" width= " + width);
   }
   
   public void calcArea(){
       area = length * width;
   }
   

   }

   //文件 Circle.java
   // 圆类
   public class Circle extends Shape{
   private double r;
   final private static double PI = 3.14;

   public Circle(double r){
       this.r = r;
   }
   
    // 实现所有的抽象类
   public void draw(){
       System.out.println("圆：r = "+r);
   }
   
   public void calcArea(){
       area = PI * r * r;
   }
   

   }

   //文件 Triangle.java
   // 三角形类：
   public class Triangle extends Shape {
   private double a;
   private double b;
   private double c;

   // 实现一个抽象类
   public void draw() {
       System.out.println("三角形：a = "+a + " b = "+b+" c = "+c);
   }
   

   //double calcArea(); // 编译失败，解决方法：要么实现该抽象方法，要么将三角形设计为抽象类
   }

   ```

5. 抽象类必须被继承，并且继承后子类要重写父类中的抽象方法，否则子类也是抽象类，必须要使用abstract修
   饰

   ```java
   

   // 三角形类：
   public abstract class Triangle extends Shape {
   private double a;
   private double b;
   private double c;

   public void draw() {
       System.out.println("三角形：a = "+a + " b = "+b+" c = "+c);
   }
   

   //double calcArea(); 将三角形设计为抽象类，继承该 Triangle类的类需要实现该方法
   }

   ```

6. 抽象类中不一定包含抽象方法，但是有抽象方法的类一定是抽象类

7. 抽象类中可以有构造方法，供子类创建对象时，初始化父类的成员变量

3. 抽象类的作用

抽象类本身不能被实例化，要想使用，只能创建该抽象类的子类。然后让子类重写抽象类中的抽象方法。

有些同学可能会说了, 普通的类也可以被继承呀, 普通的方法也可以被重写呀, 为啥非得用抽象类和抽象方法
呢?
确实如此。但是使用抽象类相当于多了一重编译器的校验。

使用抽象类的场景就如上面的代码, 实际工作不应该由父类完成，而应由子类完成。那么此时如果不小心误用成父类
了，使用普通类编译器是不会报错的。 但是父类是抽象类就会在实例化的时候提示错误， 让我们尽早发现问题。

很多语法存在的意义都是为了 “预防出错”, 例如我们曾经用过的 final 也是类似。 创建的变量用户不去修改, 不
就相当于常量嘛? 但是加上 final 能够在不小心误修改的时候, 让编译器及时提醒我们。

充分利用编译器的校验, 在实际开发中是非常有意义的。