一.抽象类概述

当编写一个类时，我们往往会为该类定义一些方法，这些方法是用来描述该类的功能具回想前面我们的猫狗案例，提取出了一个动物类，这个时候我们是可以通过Animal a = new Animal();来创建动物对象的，其实这是不对的。为什么呢？因为，我说动物，你知道我说的是什么动物吗？只有看到了具体的动物，你才知道，这是什么动物。

所以说，动物本身并不是一个具体的事物，而是一个抽象的事物。只有真正的猫，狗才是具体的动物。

同理，我们也可以推想，不同的动物吃的东西应该是不一样的，所以，我们不应该在动物类中给出具体体现，而是应该给出一个声明即可。

在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类。

代码:
abstract1

package Java_study;

/**
 * 
 * @author   只是甲
 * @date     2021-06-28
 * @remark   动物抽象类   抽象类概述
 *
 */
public abstract class abstract1 {
	/* public void eat() {
		System.out.println("吃东西");
	}*/
	
	//抽象方法
	public abstract void eat();

}

abstract2

package Java_study;

/**
 * 
 * @author   只是甲
 * @date     2021-06-28
 * @remark   动物抽象测试类   抽象类概述
 *
 */
public class abstract2 {
	public static void main(String[] args) {
		//抽象类和抽象方法不能被实例化
		//abstract1 a = new abstract1();
	}

}

二. 抽象类的特点

抽象类和抽象方法必须用abstract关键字修饰
  格式:

public abstract class 类名 {}

public abstract void eat();

抽象类不一定有抽象方法，有抽象方法的类一定是抽象类
  抽象类不能实例化
    那么，抽象类如何实例化呢?
    按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。
  抽象类的子类
    要么是抽象类
    要么重写抽象类中的所有抽象方法

代码:
abstract_animal

package Java_study;

/**
 * 
 * @author 只是甲
 * @date   2021-06-28
 * @remark 动物抽象类   抽象类特点
 *
 */
public abstract class abstract_animal {
	//抽象方法
	public abstract void eat();
	
	public void sleep() {
		System.out.println("睡觉");
	}

}

abstract_cat

package Java_study;

/**
 * 
 * @author 只是甲
 * @date   2021-06-28
 * @remark 动物抽象类子类--猫类   抽象类特点
 *
 */
public class abstract_cat extends abstract_animal {
	@Override
	public void eat() {
		System.out.println("猫吃鱼");
	}
}

abstract_dog

package Java_study;

/**
 * 
 * @author 只是甲
 * @date   2021-06-28
 * @remark 动物抽象类子类--狗类   抽象类特点
 *
 */
public class abstract_dog extends abstract_animal {
	@Override
	public void eat() {
		System.out.println("狗吃骨头");
	}

}

abstract_test1

package Java_study;

/**
 * 
 * @author 只是甲
 * @date   2021-06-28
 * @remark 动物抽象类子类--测试类   抽象类特点
 *
 */
public class abstract_test1 {
	public static void main(String[] args) {
		// 创建对象(C: 抽象类不能实例化)
		// abstract_animal animal = new abstract_animal();
		
		// c1: 参照多态的方式，通过子类对象实例化
		abstract_animal cat = new abstract_cat();
		cat.eat();//猫吃鱼
		cat.sleep();//睡觉
	}

}

三. 抽象类的成员的特点

成员变量
  可以是变量
  也可以是常量

构造方法
  有构造方法，但是不能实例化
  那么，构造方法的作用是什么呢?
    用于子类访问父类数据的初始化

成员方法
  可以有抽象方法 限定子类必须完成某些动作
  也可以有非抽象方法 提高代码复用性

代码:
abstract_person

package Java_study;

/**
 * 
 * @author  只是甲
 * @date    2021-06-28
 * @remark  人抽象类 抽象类的成员的特点
 *
 */
public abstract class abstract_person {
	private int age = 20;
	private final String country = "中国";
	
	public abstract_person() {
		
	}
	
	public abstract_person(int age) {
		this.age = age;
	}
	
	public void show() {
		age = 30;
		System.out.println(age);
		//country = "美国"
		System.out.println(country);
	}
	
	public abstract void eat();

}

abstract_student

package Java_study;

/**
 * 
 * @author  只是甲
 * @date    2021-06-28
 * @remark  人抽像的子类-学生类 抽象类的成员的特点
 *
 */
public class abstract_student extends abstract_person {
	@Override
	public void eat() {
		System.out.println("学生吃土");
	}
}

abstract_test2

package Java_study;

/**
 * 
 * @author  只是甲
 * @date    2021-06-28
 * @remark  人抽像的测试类 抽象类的成员的特点
 *
 */
public class abstract_test2 {
	public static void main(String[] args) {
		abstract_person student = new abstract_student();
		student.show();//30
		               //中国
		student.eat();//学生吃土
	}

}

测试记录:

30
中国
学生吃土

参考:

1. https://blog.csdn.net/qq_43529621/article/details/115303081