特点：
    （1）抽象类和抽象方法否需要使用abstract关键字修饰。

    • 抽象类：abstract class 类名 {}
    • 抽象方法：abstract public 返回值类型 方法名 （参数列表）{ }

    （2）抽象类和抽象方法的关系

    • 抽象方法必须存在于抽象类中
    • 抽象类中可以没有抽象方法

    （3）抽象类不可以创建对象

    • 可以由子类来继承抽象类，从而创建对象
    • 抽象类是用于被继承的类

    （4）抽象类和其子类的关系

    • 抽象类的子类只有在全部重写完抽象方法之后才是一个普通类
    • 如果子类没有重写完抽象方法，那么这个子类也是一个抽象类，需要用abstract修饰

    代码如下：

    1. package com.bxw.demo.abstract_;
    3. // 创建一个抽象类
    4. public class AbstractClassTest {
    5.     public static void main(String[] args) {
    6.         // 创建对象
    7. //        new AbstractClass() 抽象类是无法创建对象的（匿名内部类除外）
    8.         // 不完全重写的子类也是一个抽象类，因此也无法创建对象
    9.         // 完全继承的子类可以创建对象，并给抽象类的普通成员变量赋值
    10.         Zi2 zi2 = new Zi2("小白",23); // 直接赋值
    11.         // 输出
    12.         System.out.println(zi2);
    13.         // 单个输出
    14.         System.out.println(zi2.getName() + "-----" + zi2.getAge());
    15.     }
    16. }
    17. abstract class AbstractClass{
    18.     // 抽象类中可以定义成员变量
    19.     private int age;
    20.     private String name;
    21.     // 抽象类中的抽象方法必须使用abstract修饰
    22.     // 抽象类中的抽象方法不能有方法体
    23.     abstract public void test1();
    24.     abstract public void test2();
    26.     // 抽象类中也可以有构造方法
    27.     // 用于子类对父类的成员变量赋值
    28.     public AbstractClass(){}
    29.     public AbstractClass(String name, int age){
    30.         this.name = name;
    31.         this.age = age;
    32.     }
    33.     // 创建get、set公共访问方式
    35.     public int getAge() {
    36.         return age;
    37.     }
    39.     public void setAge(int age) {
    40.         this.age = age;
    41.     }
    43.     public String getName() {
    44.         return name;
    45.     }
    47.     public void setName(String name) {
    48.         this.name = name;
    49.     }
    50.     // 重写toString方法，用来输出对象
    52.     @Override
    53.     public String toString() {
    54.         return "AbstractClass{" +
    55.                 "age=" + age +
    56.                 ", name='" + name + '\'' +
    57.                 '}';
    58.     }
    59. }
    60. // 创建一个子类继承抽象类（不完全重写抽象方法）
    61. abstract class Zi extends AbstractClass { // 不完全重写抽象方法，那么这个子类还是一个抽象类
    62.     @Override
    63.     public void test1() {
    65.     }
    66. }
    67. // 创建一个子类继承抽象类（完全重写抽象方法）
    68. class Zi2 extends AbstractClass{
    70.     @Override
    71.     public void test1() {
    73.     }
    75.     @Override
    76.     public void test2() {
    78.     }
    80.     public Zi2() {
    81.     }
    82.     // 创建构造方法，为父类成员变量赋值
    83.     public Zi2(String name, int age) {
    84.         super(name, age);
    85.     }
    87. }

    总结：
    （1）抽象类中的抽象方法不可以有方法体
    （2）抽象类中可以创建普通方法
    （3）抽象类中可以有成员变量