一、抽象类不能被实例化
在Java中，抽象类（abstract类）不能被实例化，这听起来可能有些抽象，但其实理解起来并不困难。
（一）抽象类的定义
抽象类是用abstract关键字修饰的类，它可能包含抽象方法（没有方法体的方法），也可能包含具体方法（有方法体的方法）。抽象类不能被实例化，即不能用new关键字直接创建抽象类的对象。
（二）为什么不能被实例化
抽象类的抽象性
- 抽象类代表的是一种抽象的概念，它可能定义了一些通用的属性和行为，但没有具体实现所有方法。例如，Vehicle（车辆）这个抽象类，它可能有start()（启动）方法，但没有具体实现，因为不同类型的车辆（如汽车、自行车）启动的方式不同。如果能实例化Vehicle，那么在调用start()方法时，就不知道具体是按照哪种车辆的启动方式来执行，这就没有意义了。就像字幕中提到的“你也不知道怎么驾驶，那我实例化你有什么用啊？是不是意思我现在连什么车都不知道，也不知道他是自行车，然后那我具体生成这辆车当然不可能。”
- 抽象类的存在是为了被继承，它为子类提供了一个通用的模板。子类在继承抽象类时，必须实现抽象类中的抽象方法（除非子类也是抽象类）。例如：
`java
// 抽象类
abstract class Animal {
// 抽象方法
abstract void makeSound();
// 具体方法
void eat() {
System.out.println("The animal is eating.");
}
}
// 子类
class Dog extends Animal {
// 实现抽象方法
void makeSound() {
System.out.println("Woof woof");
}
}
// 不能实例化抽象类
// Animal animal = new Animal(); // 错误
// 但可以实例化子类
Dog dog = new Dog();
`
语法规定
- Java语法明确规定，抽象类只要加了abstract关键字就不能被实例化。这是一条基本的语法条，就像字幕中所说的“抽象类只要加阿慈善就不能被实例化啊”。这种语法规定确保了抽象类的抽象性，避免了在程序中出现没有意义的对象实例。
二、抽象方法的语法限制
抽象方法是抽象类中的一种特殊方法，它没有方法体，只包含方法的声明。在定义抽象方法时，有一些语法限制，如不能为private、final、static和native。
（一）抽象方法不能为private
private的含义
- private修饰的方法只能在本类中被访问。抽象方法是定义在抽象类中的，它的目的是被子类继承并实现。如果抽象方法是private的，那么子类就无法访问和实现这个方法了。因为抽象方法本身是一个空方法，它没有具体实现，子类需要根据自己的需求来实现它。如果子类不能访问这个方法，那么就无法实现它，这就违背了抽象方法存在的意义。就像字幕中提到的“Private的实际在于其他方法本类其他方法调是吧。你自己是个空方法，别人掉你有什么用呢？说private本类当中都要调你，可是呢你呢又是一空的掉，你的空方法有什么用啊”。例如：
`java
// 错误的抽象方法定义
abstract class Example {
// 抽象方法不能为private
// private abstract void doSomething(); // 错误
}
`
避免无意义的实现
- 抽象方法是专门等待子类覆盖实现的。如果它是private的，就无法被子类覆盖，这就使得抽象方法的存在变得毫无意义。子类无法继承和实现这个方法，就无法根据抽象类的模板来定义自己的行为。
（二）抽象方法不能为final
final的含义
- final修饰的方法不能被子类覆盖。抽象方法的目的是被子类覆盖实现的，它本身是一个空方法，等待子类根据自己的需求来实现。如果抽象方法是final的，那么子类就无法覆盖它，这就违背了抽象方法的初衷。就像字幕中所说的“你本来就是空的，就希望别人继承你的这个呃实现你的，你到最后的时候你还final一下，那不是是不是毫无意义？”。例如：
`java
// 错误的抽象方法定义
abstract class Example {
// 抽象方法不能为final
// final abstract void doSomething(); // 错误
}
`
抽象方法的覆盖需求
- 抽象方法是为了被子类覆盖实现的，它提供了一个通用的接口，子类可以根据自己的特性来实现这个接口。如果抽象方法是final的，就无法实现这个需求，子类只能按照抽象类中定义的方法行为来执行，这限制了子类的灵活性。
（三）抽象方法不能为static
static的含义
- static修饰的方法是类方法，它属于类本身，而不是类的实例。抽象方法是定义在抽象类中的，它需要被子类实例化后调用。如果抽象方法是static的，那么它就无法根据子类的实例来调用，这违背了抽象方法的调用方式。例如：
`java
// 错误的抽象方法定义
abstract class Example {
// 抽象方法不能为static
// static abstract void doSomething(); // 错误
}
`
实例化与调用
- 抽象方法是等待子类实现后，通过子类的实例来调用的。如果它是static的，就无法根据子类的实例来调用，这就使得抽象方法的调用变得不明确。例如，子类Dog继承了抽象类Animal，Animal中的抽象方法makeSound()是static的，那么在调用Dog dog = new Dog(); dog.makeSound();时，就不知道是调用Animal类中的makeSound()方法还是Dog类中实现的makeSound()方法。
（四）抽象方法不能为native
native的含义
- native修饰的方法是本地方法，它表示该方法的实现不是用Java语言编写的，而是用其他语言（如C、C++）编写的。抽象方法是等待子类用Java语言来实现的，它没有具体实现，如果它是native的，那么子类就无法用Java语言来实现它，这就违背了抽象方法的实现方式。例如：
`java
// 错误的抽象方法定义
abstract class Example {
// 抽象方法不能为native
// native abstract void doSomething(); // 错误
}
`
实现语言的差异
- 抽象方法的实现语言是Java，而native方法的实现语言是其他语言，这就使得抽象方法无法被正确实现。子类在继承抽象类时，需要根据Java语言的语法和逻辑来实现抽象方法，如果抽象方法是native的，就无法实现这个需求。
三、FAQ
问题 答案
抽象类可以实例化吗？ 抽象类不能被实例化，它只能被继承。因为抽象类代表的是一个抽象的概念，没有具体实现所有方法，如果实例化它，那么在调用抽象方法时就不知道具体执行什么操作。
抽象方法可以为private吗？ 抽象方法不能为private，因为private修饰的方法只能在本类中访问，而抽象方法是等待子类继承并实现的。如果抽象方法是private的，子类就无法访问和实现它，这违背了抽象方法存在的意义。
抽象方法可以为final吗？ 抽象方法不能为final，因为final修饰的方法不能被子类覆盖。而抽象方法的目的是被子类覆盖实现的，如果它是final的，子类就无法覆盖它，这违背了抽象方法的初衷。
抽象方法可以为static吗？ 抽象方法不能为static，因为static修饰的方法是类方法，它属于类本身，而不是类的实例。抽象方法是等待子类实例化后调用的，如果它是static的，就无法根据子类的实例来调用。
抽象方法可以为native吗？ 抽象方法不能为native，因为native修饰的方法是本地方法，表示该方法的实现不是用Java语言编写的。而抽象方法是等待子类用Java语言来实现的，如果它是native的，子类就无法用Java语言来实现它。
四、相似概念对比
概念 抽象类 抽象方法
定义 用abstract关键字修饰的类，可能包含抽象方法和具体方法 抽象类中没有方法体的方法
实例化 不能被实例化 不能被直接调用，需要子类实现后通过子类实例调用
子类继承 子类必须实现抽象类中的抽象方法（除非子类也是抽象类） 子类必须实现抽象方法
语法限制 不能实例化 不能为private、final、static和native
五、其他示例代码
（一）抽象类的继承示例
// 抽象类
abstract class Shape {
// 抽象方法
abstract double getArea();
// 具体方法
void display() {
System.out.println("This is a shape.");
}
}
// 子类
class Circle extends Shape {
private double radius;
// 构造方法
public Circle(double radius) {
this.radius = radius;
}
// 实现抽象方法
double getArea() {
return Math.PI * radius * radius;
}
}
// 测试
public class Test {
public static void main(String[] args) {
// 不能实例化抽象类
// Shape shape = new Shape(); // 错误
// 实例化子类
Circle circle = new Circle(5);
circle.display();
System.out.println("The area of the circle is: " + circle.getArea());
}
}
（二）抽象类中的具体方法示例
// 抽象类
abstract class Animal {
// 抽象方法
abstract void makeSound();
// 具体方法
void eat() {
System.out.println("The animal is eating.");
}
}
// 子类
class Dog extends Animal {
// 实现抽象方法
void makeSound() {
System.out.println("Woof woof");
}
}
// 测试
public class Test {
public static void main(String[] args) {
Dog dog = new Dog();
dog.makeSound();
dog.eat();
}
}
（三）抽象类中抽象方法的实现示例
// 抽象类
abstract class Vehicle {
// 抽象方法
abstract void start();
abstract void stop();
}
// 子类
class Car extends Vehicle {
// 实现抽象方法
void start() {
System.out.println("The car is starting.");
}
void stop() {
System.out.println("The car is stopping.");
}
}
// 测试
public class Test {
public static void main(String[] args) {
Car car = new Car();
car.start();
car.stop();
}
}