十、抽象类

10.1 概述

由来

父类中的方法，被它的子类们重写，子类各自的实现都不尽相同。那么父类的方法声明和方法主体，只有声明还有意义，而方法主体则没有存在的意义了。我们把没有方法主体的方法称为抽象方法。Java语法规定，包含抽象方法的类就是抽象类 。
定义

抽象方法：没有方法体的方法。
抽象类：包含抽象方法的类。

10.2 abstract使用格式

定义抽象类或者抽象方法的时候需要用到关键字 abstract，放在 class 关键字前或者方法返回类型前。

关于抽象类的命名，《阿里的 Java 开发手册》上有强调：“抽象类命名要使用 Abstract 或 Base 开头”，这条规约还是值得遵守的。

抽象方法

使用 abstract 关键字修饰方法，该方法就成了抽象方法，抽象方法只包含一个方法名，而没有方法体。

定义格式：
```
修饰符 abstract 返回值类型 方法名 (参数列表);
例：
public abstract void run();
```

抽象类

如果一个类包含抽象方法，那么该类必须是抽象类。(反之不成立)

定义格式：

abstract class 类名字 {     
}
例：
public abstract class Animal {     
	public abstract void run()； 
}

抽象的使用

继承抽象类的子类必须重写父类所有的抽象方法。否则，该子类也必须声明为抽象类时也可以。最终，必须有子类实现该父类的抽象方法，否则，从最初的父类到最终的子类都不能创建对象，失去意义。

10.3 抽象类的特征

抽象类是不能实例化的，尝试通过 new 关键字实例化的话，编译器会报错，提示 “类是抽象的，不能实例化”。
JavaSE基础之（十）抽象类-小白菜博客
虽然抽象类是不能实例化的，但是它可以有子类，子类通过 extends 关键字来继承抽象类：

/**
 * @author QHJ
 * @date 2022/8/30  17:57
 * @description: 继承抽象类
 */
public class BasketballPlayer extends AbstractPlayer{
}

如果一个类定义了一个或者多个抽象方法，那么这个类必须是抽象类。

当我们尝试在一个普通类中定义抽象方法的时候，编译器会有两处错误提示：

一处在类级别上，提示 “这个类必须通过 abstract 关键字定义”：
JavaSE基础之（十）抽象类-小白菜博客
第二处在尝试定义 abstract 的方法上，提示 “抽象方法所在的类不是抽象的”：

在这里插入图片描述

抽象类中既可以定义抽象方法，也可以定义普通方法：

/**
 * @author QHJ
 * @date 2022/8/30  17:54
 * @description: 抽象类
 */
abstract class AbstractPlayer {

    abstract void play();

    public void sleep() {
        System.out.println("好好休息");
    }
}

抽象类派生的子类必须实现父类中定义的抽象方法：

/**
 * @author QHJ
 * @date 2022/8/30  17:57
 * @description: 继承抽象类
 */
public class BasketballPlayer extends AbstractPlayer{
    @Override
    void play() {
        System.out.println("派生子类实现父类中定义的方法");
    }
}

如果子类没有实现父类的方法的话，编译器会提示 “子类必须实现抽象方法”：
在这里插入图片描述

10.4 抽象类的应用场景

01、第一种场景

当我们希望一些通用的功能被多个子类复用的时候，就可以使用抽象类。比如说，AbstractPlayer 抽象类中有一个普通的方法 sleep()，表明所有的运动员（排球运动员、篮球运动员…）都需要休息，那么这个方法就可以被子类复用。

/**
 * @author QHJ
 * @date 2022/8/30  17:54
 * @description: 抽象类
 */
abstract class AbstractPlayer {

    public void sleep() {
        System.out.println("运动员要休息");
    }
}

子类 BasketballPlyer 继承 AbstractPlayer 类，那么也就拥有了 sleep() 方法，BasketballPlayer 的对象可以直接调用父类的 sleep() 方法：

/**
 * @author QHJ
 * @date 2022/8/30  17:57
 * @description: 继承抽象类
 */
public class BasketballPlayer extends AbstractPlayer{

}


/**
 * @author QHJ
 * @date 2022/8/30  17:59
 * @description: 普通测试类
 */
public class PlayerTest {
    public static void main(String[] args) {
        BasketballPlayer basketballPlayer = new BasketballPlayer();
        basketballPlayer.sleep();
    }
}

子类 FootballPlayer继承 AbstractPlayer 类，那么也就拥有了 sleep() 方法，FootballPlayer的对象可以直接调用父类的 sleep() 方法：

/**
 * @author QHJ
 * @date 2022/8/30  18:19
 * @description: 继承抽象类
 */
public class FootballPlayer extends AbstractPlayer{
}


/**
 * @author QHJ
 * @date 2022/8/30  17:59
 * @description: 普通测试类
 */
public class PlayerTest {
    public static void main(String[] args) {
        FootballPlayer footballPlayer = new FootballPlayer();
        footballPlayer.sleep();
    }
}

这也的话就实现了代码的复用。

02、第二种场景

当我们需要在抽象类中定义好 API，然后在子类中扩展实现的时候就可以使用抽象类。

比如说，AbstractPlayer 抽象类中定义了一个抽象方法 play()，表明所有运动员都可以从事某项运动，但需要对应子类去扩展实现，表明篮球运动员打篮球，足球运动员踢足球：

/**
 * @author QHJ
 * @date 2022/8/30  17:54
 * @description: 抽象类
 */
abstract class AbstractPlayer {
    abstract void play();
}

BasketballPlayer 继承了 AbstractPlayer 类，扩展实现了自己的 play() 方法：

/**
 * @author QHJ
 * @date 2022/8/30  17:57
 * @description: 继承抽象类
 */
public class BasketballPlayer extends AbstractPlayer{

    @Override
    void play() {
        System.out.println("篮球运动员打篮球");
    }
}

FootballPlayer 继承了 AbstractPlayer 类，扩展实现了自己的 play() 方法：

/**
 * @author QHJ
 * @date 2022/8/30  18:19
 * @description: 继承抽象类
 */
public class FootballPlayer extends AbstractPlayer{

    @Override
    void play() {
        System.out.println("足球运动员踢足球");
    }
}

10.5 注意事项

抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。

理解：假设创建了抽象类的对象，调用抽象的方法，而抽象方法没有具体的方法体，没有意义。
Person p = new Student();
Person 是父类抽象类，Student 是子类非抽象类
抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。

理解：子类的构造方法中，有默认的 super()，需要访问父类构造方法。
抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。

理解：未包含抽象方法的抽象类，目的就是不想让调用者创建该类对象，通常用于某些特殊的类结构设计。
抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错。除非该子类也是抽象类。

理解：假设不重写所有抽象方法，则类中可能包含抽象方法。那么创建对象后，调用抽象的方法，没有意义。