13. 抽象类（abstract关键字）

抽象类

抽象类
- 1. 抽象类
- - 1.1 定义格式
  - 1.2 特点
- 2. 抽象方法
- - 2.1 定义格式
  - 2.2 特点
- 3. `abstract`关键字

抽象类

抽象类是在面向对象编程中，一种特殊的类，它不能被实例化，只能作为其他类的基类来使用。

抽象类和普通类的主要区别在于它包含一个或多个抽象方法。

1. 抽象类

抽象类是面向对象编程中的一个概念，它是一种特殊的类，不能被实例化，只能被用作其他类的基类来继承并实现其抽象方法。

1.1 定义格式

定义格式：

abstract class 类名字 { }

代码举例：

public abstract class Animal {public abstract void run()；
}

抽象类的定义包括：

抽象类通过关键字 abstract 进行声明。
抽象类可以包含抽象方法和具体方法。
抽象方法是一种只有声明而没有实现的方法，需要被子类重写来实现具体的逻辑。
抽象类可以包含成员变量和成员方法，这些成员变量和成员方法可以被子类继承。

注意：抽象类不一定有抽象方法，但是有抽象方法的类必须定义成抽象类。

示例：

abstract class Shape {protected String color; // 颜色属性public Shape(String color) {this.color = color;}public abstract void draw(); // 抽象方法，用于绘制形状public void setColor(String color) {this.color = color;}
}class Circle extends Shape {private double radius; // 半径属性public Circle(String color, double radius) {super(color);this.radius = radius;}@Overridepublic void draw() {System.out.println("Drawing a circle with radius " + radius + " and color " + color); // 绘制圆形}
}class Rectangle extends Shape {private double width; // 宽度属性private double height; // 高度属性public Rectangle(String color, double width, double height) {super(color);this.width = width;this.height = height;}@Overridepublic void draw() {System.out.println("Drawing a rectangle with width " + width + ", height " + height + " and color " + color); // 绘制矩形}
}public class Main {public static void main(String[] args) {Shape circle = new Circle("Red", 5.0); // 创建一个红色的半径为5的圆形对象circle.draw();Shape rectangle = new Rectangle("Blue", 3.0, 4.0); // 创建一个蓝色的宽度为3，高度为4的矩形对象rectangle.draw();}
}

在上述示例中，Shape 是一个抽象类，它包含一个抽象方法 draw()，并具有一个成员变量 color 和一个具体方法 setColor()。Circle 和 Rectangle 都是 Shape 的子类，它们都必须实现抽象方法 draw()。在 Main 类中，我们可以创建 Circle 和 Rectangle 的对象，并调用它们的 draw() 方法来进行绘制。由于抽象类不能被实例化，我们只能创建其子类的实例，并通过多态性来使用抽象类。

1.2 特点

抽象类（Abstract Class）是一种特殊的类，它不能被实例化，只能被继承。

它主要的特点包括：

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

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

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

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

理解：假设不重写所有抽象方法，则类中可能包含抽象方法。那么创建对象后，调用抽象的方法，没有意义。
抽象类存在的意义是为了被子类继承。

理解：抽象类中已经实现的是模板中确定的成员，抽象类不确定如何实现的定义成抽象方法，交给具体的子类去实现。
抽象类不能用 final 声明。

理解：因为抽象类必须被子类继承。
非抽象方法包含方法体，可以直接使用或重写（Override）。

理解：抽象类中可以包含非抽象方法，这些方法拥有方法体，可以直接调用使用。同时，子类也可以通过继承抽象类来继承这些非抽象方法，并且可以在子类中重写这些方法，从而实现子类对象对这些方法的调用。

抽象类主要的作用是用来设计和组织一个类的具体子类，它定义了一个抽象的概念，而不是一个具体的实现。当需要实现该概念时，可以继承抽象类并实现它的抽象方法。

2. 抽象方法

抽象方法是在抽象类中声明但没有具体实现的方法。

它只有方法签名，没有方法体。抽象类中可以包含一个或多个抽象方法。

抽象方法通过使用关键字 abstract 来声明，在方法签名中只指定方法的名称、参数列表和返回类型，不包含具体的方法实现。具体的方法实现由继承抽象类的子类来提供。

2.1 定义格式

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

定义格式：

修饰符 abstract 返回值类型 方法名 (参数列表)；

例如：

public abstract void run()；

2.2 特点

抽象方法的主要特点包括：

抽象方法没有具体的实现，继承抽象类的子类必须实现这些抽象方法，并提供具体的实现逻辑。
抽象方法不能被声明为 private，final，static 或 strictfp，因为这些关键字会和抽象方法的特性相冲突。

下面是一个示例，展示了一个抽象类 Animal 和它的子类 Cat 和 Dog 的使用：

abstract class Animal {public abstract void makeSound();  // 抽象方法，动物发出声音public void sleep() {System.out.println("Animal is sleeping");  // 非抽象方法，动物睡觉}
}class Cat extends Animal {public void makeSound() {System.out.println("Meow");  // 实现抽象方法，猫发出声音}
}class Dog extends Animal {public void makeSound() {System.out.println("Woof");  // 实现抽象方法，狗发出声音}
}public class Main {public static void main(String[] args) {Cat cat = new Cat();cat.makeSound();  // 输出 "Meow"cat.sleep();  // 输出 "Animal is sleeping"Dog dog = new Dog();dog.makeSound();  // 输出 "Woof"dog.sleep();  // 输出 "Animal is sleeping"}
}

在上面的例子中，Animal 抽象类声明了一个抽象方法 makeSound()，所有继承 Animal 抽象类的子类都必须实现 makeSound() 方法。在 Cat 子类和 Dog 子类中分别实现了 makeSound() 方法，提供了具体的猫和狗发出声音的逻辑。通过创建 Cat 和 Dog 对象来调用 makeSound() 方法来输出相应的声音。抽象类 Animal 中的 sleep() 方法不是抽象方法，它有具体的实现。

3. `abstract`关键字

抽象类 (Abstract Class) ：使用 abstract 关键字声明的类就是抽象类，它不能被实例化，只能被继承。

声明抽象类：
```
abstract class ClassName {// 抽象类的成员
}
```
- 使用 abstract 关键字来修饰类名，表示该类是一个抽象类。
- 抽象类可以包含成员变量、非抽象方法和抽象方法。
抽象方法 (Abstract Method) ：使用 abstract 关键字声明的方法就是抽象方法，它只有方法头（签名），没有方法体。

声明抽象方法：
```
abstract returnType methodName(parameters);
```
- 使用 abstract 关键字来修饰方法，表示该方法是一个抽象方法。
- 在方法的声明中只有方法的返回类型、方法名和参数列表，没有方法体（即没有具体的实现）。
- 抽象方法必须被声明在抽象类中。