抽象类是在面向对象编程中，一种特殊的类，它不能被实例化，只能作为其他类的基类来使用。
抽象类和普通类的主要区别在于它包含一个或多个抽象方法。
抽象类是面向对象编程中的一个概念，它是一种特殊的类，不能被实例化，只能被用作其他类的基类来继承并实现其抽象方法。
定义格式：
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;
}
@Override
public 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;
}
@Override
public 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() 方法来进行绘制。由于抽象类不能被实例化，我们只能创建其子类的实例，并通过多态性来使用抽象类。
抽象类（Abstract Class）是一种特殊的类，它不能被实例化，只能被继承。
它主要的特点包括：
抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。
理解：假设创建了抽象类的对象，调用抽象的方法，而抽象方法没有具体的方法体，没有意义。
抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。
理解：子类的构造方法中，有默认的super()，需要访问父类构造方法。
抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。
理解：未包含抽象方法的抽象类，目的就是不想让调用者创建该类对象，通常用于某些特殊的类结构设计。
抽象类的子类，必须重写抽象父类中所有的抽象方法，否则子类也必须定义成抽象类，编译无法通过而报错。
理解：假设不重写所有抽象方法，则类中可能包含抽象方法。那么创建对象后，调用抽象的方法，没有意义。
抽象类存在的意义是为了被子类继承。
理解：抽象类中已经实现的是模板中确定的成员，抽象类不确定如何实现的定义成抽象方法，交给具体的子类去实现。
抽象类不能用 final 声明。
理解：因为抽象类必须被子类继承。
非抽象方法包含方法体，可以直接使用或重写（Override）。
理解：抽象类中可以包含非抽象方法，这些方法拥有方法体，可以直接调用使用。同时，子类也可以通过继承抽象类来继承这些非抽象方法，并且可以在子类中重写这些方法，从而实现子类对象对这些方法的调用。
抽象类主要的作用是用来设计和组织一个类的具体子类，它定义了一个抽象的概念，而不是一个具体的实现。当需要实现该概念时，可以继承抽象类并实现它的抽象方法。
抽象方法是在抽象类中声明但没有具体实现的方法。
它只有方法签名，没有方法体。抽象类中可以包含一个或多个抽象方法。
抽象方法通过使用关键字 abstract 来声明，在方法签名中只指定方法的名称、参数列表和返回类型，不包含具体的方法实现。具体的方法实现由继承抽象类的子类来提供。
使用abstract 关键字修饰方法，该方法就成了抽象方法，抽象方法只包含一个方法名，而没有方法体。
定义格式：
修饰符 abstract 返回值类型 方法名 (参数列表)；
例如：
public abstract void run()；
抽象方法的主要特点包括：
抽象方法没有具体的实现，继承抽象类的子类必须实现这些抽象方法，并提供具体的实现逻辑。
抽象方法不能被声明为 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() 方法不是抽象方法，它有具体的实现。
abstract关键字抽象类 (Abstract Class) ：使用 abstract 关键字声明的类就是抽象类，它不能被实例化，只能被继承。
声明抽象类：
abstract class ClassName {
// 抽象类的成员
}
使用 abstract 关键字来修饰类名，表示该类是一个抽象类。
抽象类可以包含成员变量、非抽象方法和抽象方法。
抽象方法 (Abstract Method) ：使用 abstract 关键字声明的方法就是抽象方法，它只有方法头（签名），没有方法体。
声明抽象方法：
abstract returnType methodName(parameters);
使用 abstract 关键字来修饰方法，表示该方法是一个抽象方法。
在方法的声明中只有方法的返回类型、方法名和参数列表，没有方法体（即没有具体的实现）。
抽象方法必须被声明在抽象类中。
【注意】：
对于抽象类来说，它可以包含非抽象方法和抽象方法，但一个类只有包含至少一个抽象方法时才需要被声明为抽象类。
对于抽象方法来说，它不能被声明为 private 或 final，因为私有方法无法被继承和重写，而 final 方法无法被重写。
抽象类和抽象方法都不能被实例化或直接调用，抽象类只能被继承。
抽象方法只有方法头，没有方法体。抽象方法相当于一个约定，必须在子类中实现具体的方法体。
如果一个类继承了抽象类，那么它必须实现抽象类中的所有抽象方法，除非它自己也是抽象类。
如果一个子类继承了抽象类，可以选择性地重写非抽象方法。