【Java基础】22.抽象类、抽象方法

---

前言

在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。

抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。

由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。也是因为这个原因，通常在设计阶段决定要不要设计抽象类。

父类包含了子类集合的常见的方法，但是由于父类本身是抽象的，所以不能使用这些方法。

在 Java 中抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口。

一、抽象类

在 Java 语言中使用 abstract class 来定义抽象类。

如下实例：

/**
 * @ClassName: Animal
 * @Description: 抽象类，抽象父类Animal（被子类继承，充当模板，提高代码复用）
 * 知道子类需要完成的功能，但每个子类完成的情况不一样，抽象父类只定义该功能基本要求
 * @author: Zh
 * @date: 2024/4/20 17:11
 */
// 使用 abstract class 来定义抽象类
public abstract class Animal {
    private String name; // 成员方法

    private int age; // 成员方法

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    /*
        abstract 关键字声明是抽象方法
        抽象方法只包含一个方法名，而没有方法体。
         */
    public abstract void run();

    // 非抽象方法
    public void info() {
        System.out.println(this.name + "已经" + this.age + "岁了");
    }

    // 无参构造器
    public Animal() {}

    // 有参构造器，快捷键 Alt + Insert (Constructor)
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

}

注意到该 Animal 类没有什么不同，尽管该类是抽象类，但是它仍然有 2 个成员变量，2个成员方法（1个抽象方法和1个非抽象方法）和 2 个构造方法（1个无参构造方法和1个有参构造方法）。

二、继承抽象类

使用 extends 关键字来继承抽象类。

子类 Tiger：

public class Tiger extends Animal {
    private String address; // 子类的成员变量

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    // 有参构造器
    public Tiger(String name, int age, String address) {
        super(name, age);
        this.address = address;
    }

    // 无参构造器
    public Tiger() {
    }

    // 重写抽象类的抽象方法
    @Override
    public void run() {
        System.out.println("老虎跑的贼溜~~~~");
    }

    @Override
    public void info() {
        super.info();
        System.out.println(getName() + "叫得很大声！！！");
    }
}

子类 Dog：

public class Dog extends Animal {
    private double price; // 子类的成员变量

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    // 有参构造器
    public Dog(String name, int age, double price) {
        super(name, age);
        this.price = price;
    }

    // 无参构造器
    public Dog() {}

    // 重写抽象类的抽象方法
    @Override
    public void run() {
        System.out.println("狗跑的很快~~~~");
    }

    @Override
    public void info() {
        super.info();
        System.out.println(getName() + "汪汪叫！！！");
    }
}

尽管我们不能实例化一个 Animal 抽象类的对象，但是如果我们实例化继承抽象类的 Dog 类和 Tiger 类对象，该对象将从 Animal 类继承 2 个成员方法和 2 个成员变量。

public class Test {
    public static void main(String[] args) {
        // Animal animal = new Animal(); // 报错，因为抽象类不能实例化
        System.out.println("----Tiger类----");
        Tiger t = new Tiger();
        t.setName("跳跳虎");
        t.setAge(5);
        t.run();
        t.info();
        Tiger tiger = new Tiger("东北虎",12,"东北");
        tiger.info();
        System.out.println(tiger.getName() + "生活在" + tiger.getAddress());

        System.out.println("----Dog类----");
        Dog t1 = new Dog();
        t1.setName("大黄");
        t1.setAge(8);
        t1.run();
        t1.info();
        Dog dog = new Dog("小白",2,52.1);
        dog.info();
        System.out.println(dog.getName() + "售价" + dog.getPrice());
    }
}

编译运行结果如下：

----Tiger类----
老虎跑的贼溜~~~~
跳跳虎已经5岁了
跳跳虎叫得很大声！！！
东北虎已经12岁了
东北虎叫得很大声！！！
东北虎生活在东北
----Dog类----
狗跑的很快~~~~
大黄已经8岁了
大黄汪汪叫！！！
小白已经2岁了
小白汪汪叫！！！
小白售价52.1

三、抽象方法

如果你想设计这样一个类，该类包含一个特别的成员方法，该方法的具体实现由它的子类确定，那么你可以在父类中声明该方法为抽象方法。

Abstract 关键字同样可以用来声明抽象方法，抽象方法只包含一个方法名，而没有方法体。

抽象方法没有定义，方法名后面直接跟一个分号，而不是花括号。

public abstract class Employee
{
   private String name;
   private String address;
   private int number;
   
   public abstract double computePay();
   
   //其余代码
}

声明抽象方法会造成以下两个结果：

• 如果一个类包含抽象方法，那么该类必须是抽象类。
• 任何子类必须重写父类的抽象方法，或者声明自身为抽象类。

继承抽象方法的子类必须重写该方法。否则，该子类也必须声明为抽象类。最终，必须有子类实现该抽象方法，否则，从最初的父类到最终的子类都不能用来实例化对象。

如果Salary类继承了Employee类，那么它必须实现computePay()方法：

/* 文件名 : Salary.java */
public class Salary extends Employee
{
   private double salary; // Annual salary
  
   public double computePay()
   {
      System.out.println("Computing salary pay for " + getName());
      return salary/52;
   }
 
   //其余代码
}

四、抽象类总结规定

1. 抽象类不能被实例化(初学者很容易犯的错)，如果被实例化，就会报错，编译无法通过。只有抽象类的非抽象子类可以创建对象。

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

3. 抽象类中的抽象方法只是声明，不包含方法体，就是不给出方法的具体实现也就是方法的具体功能。

4. 构造方法，类方法（用 static 修饰的方法）不能声明为抽象方法。

5. 抽象类的子类必须给出抽象类中的抽象方法的具体实现，除非该子类也是抽象类。