Java中的抽象类介绍
抽象类可以包含普通类的成员，它可以包含普通的属性、方法和内部类等成员。这些成员既可以被抽象类的子类继承和使用，也可以被抽象类自身使用。抽象类中的非抽象方法必须要有具体实现，否则无法通过编译。抽象类中也可以拥有构造方法，但是抽象类不能被直接实例化，因此对于抽象类而言，构造方法主要用于其子类的初始化。而抽象类除了含有普通类的成员，必须含有抽象方法。
那么什么叫抽象方法呢？在所有的普通方法上面都会有一个"{}"，这个表示方法体，有方法体的方法一定可以被对象直接使用。而抽象方法，是指，没有方法体的方法，且抽象方法必须被abstract关键字所修饰。
Java中的抽象类不能被直接实例化的原因是，它是一种不完整的类，只定义了一部分方法的声明而没有提供具体的实现，因此无法创建对象。
抽象类的主要作用是为其子类提供一个公共的接口和方法，以便子类可以继承并实现其中的抽象方法。由于抽象类中包含抽象方法，而抽象方法没有具体的实现，因此在抽象类中创建对象时，系统无法确定如何正确地执行抽象方法的调用。因此，Java中的抽象类只能用作其他类的基类，被继承和实现抽象方法。
Java中的抽象类是一种特殊的类，不能被实例化，只能被继承。
抽象方法是一种没有具体实现的方法，必须在子类中被实现。抽象方法的定义使用abstract关键字，例如：
public abstract void draw();
上面的代码定义了一个抽象方法draw()，它没有具体的实现。任何继承了该抽象类的子类都必须实现这个方法。
除了抽象方法，抽象类还可以包含非抽象方法，这些方法有具体的实现。子类可以继承这些方法，也可以重写这些方法。
抽象类的作用主要有两点：
强制规范子类的行为，避免出现不符合预期的情况。
提供抽象级别的通用功能，降低编程复杂度。
需要注意的是，如果一个类继承了抽象类，则必须实现所有抽象方法，否则该类必须也声明为抽象类。同时，抽象类也可以实现接口，这样就可以将接口中的一些方法的实现放在抽象类中，方便子类直接继承。
在Java中，抽象类是一种特殊的类，它不能直接实例化，只能被其他类继承。抽象类通常用于作为一个基类，封装一些共性的代码和行为，并且定义了一些抽象方法，这些抽象方法没有具体的实现，需要子类去实现。
抽象类的定义使用abstract关键字，抽象方法也使用abstract关键字进行修饰。如果一个类包含抽象方法，则该类必须声明为抽象类。
在Java中，抽象类和包含抽象方法的子类可以保存在同一个文件中，只需要注意，在一个源文件中，最多只能有一个public类，而且这个public类的名称必须与文件名相同。因此，如果你想在同一个源文件中定义多个类，那么只有其中一个类可以被声明为public类。但是，通常为了提高代码的可读性和可维护性，我们建议将它们分别保存到不同的文件中。
如果你有一个抽象类和其对应的子类，通常会将抽象类定义在一个文件中，并将其子类定义在另一个文件中。这样做可以使程序更易于阅读和维护，因为它使得每个类都有自己的单独文件来描述它的实现。
以下是一个抽象类的例子：
源码由两个文件构成
Animal.java内容如下：
public abstract class Animal {
protected String name;
public Animal(String name) {
this.name = name;
}
public abstract void eat();
public void sleep() {
System.out.println(name + " is sleeping...");
}
public String getName() {
return name;
}
}
Cat.java内容如下：
public class Cat extends Animal {
public Cat(String name) {
super(name);
}
public void eat() {
System.out.println(getName() + " is eating fish...");
}
public static void main(String[] args) {
Cat cat = new Cat("Tom");
cat.eat(); // Tom is eating fish...
cat.sleep(); // Tom is sleeping...
}
}
上述例子中，Animal类是一个抽象类，其中定义了一个抽象方法eat()和一个非抽象方法sleep()，Cat类继承了Animal类并实现了eat()方法，同时还可以调用父类的sleep()方法。
抽象类与普通类的区别在于，抽象类不能被实例化，只能被继承，而其子类必须实现所有的抽象方法。使用抽象类可以提高代码的可复用性和拓展性。
抽象方法是一种没有实现的方法，必须在子类中实现。
构造方法和类方法都有具体的实现。构造方法用于创建对象，并初始化其状态，它们不能被声明为抽象方法，因为对象必须有一个确切的构造方法来进行实例化。类方法是与类相关联的方法，而不是与对象相关联的方法。它们也不能被声明为抽象方法，因为它们必须有一个具体的实现，以便在类加载时调用它们。
抽象类可以包含属性，方法，构造方法。
抽象类的构造方法不能用来new实例，只能被子类调用。抽象类不能被实例化，因为它是一种不完整的类，没有完整的实现。
抽象类中不一定包含抽象方法，但是有抽象方法的类一定是抽象类，不包含抽象方法的抽象类，目的就是不想让调用者实例化该对象，通常用于某些特殊的类的结构设计。
抽象类的子类，必须重写抽象父类的所有抽象方法，否则会出现编译报错，除非该子类也是抽象类（假设不重写父类中所有的抽象方法，那么调用抽象方法毫无意义）。
抽象类中的构造方法，用于初始化自身的成员变量或调用父类的构造方法。子类在创建对象时，会自动调用父类的构造方法来完成对父类的初始化。
举个完整的实验代码：
假设我们有一个抽象类Animal，其子类Dog和Cat都需要初始化一些共同的属性，比如体重weight和年龄age。那么我们就可以在Animal类中定义一个构造方法，在其中初始化这些属性。
抽象类文件Animal.Java内容如下：
public abstract class Animal {
private int weight;
private int age;
public Animal(int weight, int age) {
this.weight = weight;
this.age = age;
}
public int getWeight() {
return weight;
}
public int getAge() {
return age;
}
}
这样，Dog和Cat就可以通过调用super关键字来调用父类的构造方法完成对基本属性的初始化：
Dog.java文件内容如下：
// Dog类
public class Dog extends Animal {
public Dog(int weight, int age) {
super(weight, age);
// 子类自己的初始化逻辑
}
}
Cat.java文件内容如下：
// Cat类
public class Cat extends Animal {
public Cat(int weight, int age) {
super(weight, age);
// 子类自己的初始化逻辑
}
}
说明，Animal类作为抽象类被设计出来，它里面包含了一些基础的属性和方法，在子类中被继承和实现。而构造方法则是用来初始化这些属性，在子类中可直接使用。
Test.java文件内容如下：
//调用测试
public class Test {
public static void main(String[] args) {
Dog dog = new Dog(5, 2);
System.out.println("Dog's weight is " + dog.getWeight());
System.out.println("Dog's age is " + dog.getAge());
Cat cat = new Cat(3, 1);
System.out.println("Cat's weight is " + cat.getWeight());
System.out.println("Cat's age is " + cat.getAge());
}
}
说明，子类通过调用父类的构造方法完成了对基本属性的初始化，对本例而言，父类Animal的构造方法是 public Animal(int weight, int age)，在子类中通过 super(weight, age) 调用父类的构造方法来完成对基本属性的初始化。
编译运行输出结果为：
Dog's weight is 5
Dog's age is 2
Cat's weight is 3
Cat's age is 1
Java中的抽象类是一种不能被实例化的类，它只能作为其他类的父类来使用。抽象类通常用于定义一个类的基本框架，而具体的实现则由其子类来完成。以下是Java中抽象类的一些主要特点：
1.抽象类不能被实例化：虽然抽象类可以提供构造方法，但这个构造方法不能用来创建对象（如果硬要创建，会出现编译报错）。
2.抽象类可以包含抽象方法和非抽象方法：抽象方法是没有具体实现的方法，必须由其子类来实现；非抽象方法则已经有了具体的实现，可以直接在抽象类中使用。
3.子类必须实现所有抽象方法：如果一个子类继承了一个抽象类，那么它必须实现该抽象类中所有的抽象方法，否则该子类也必须声明为抽象类。
4.构造方法，类方法（用 static 修饰的方法）不能声明为抽象方法。
5.抽象类可以实现接口：抽象类可以实现多个接口，并且可以在该抽象类中提供接口中定义的方法的默认实现。
6.抽象类可以被继承：抽象类可以被其他类继承，被继承的子类可以使用抽象类中定义的非抽象方法，并且必须实现其中的所有抽象方法。
附录