一、父类方法的不确定性

引入：对于一个动物，不知道它吃什么，比如猫吃鱼，兔子吃萝卜。动物类中的 eat 方法往往由它的子类去具体实现。

class Animal {
	public void eat() {
		System.out.println("我不是具体的动物，目前不知道吃什么。");
	}
}

父类方法的不确定性：
当父类的某些方法，需要声明，但是又不确定如何实现时，可以将其声明为抽象方法，那么这个类就是抽象类。

=> 所谓抽象方法就是没有实现的方法
=> 所谓没有实现就是指，没有方法体
=> 当一个类中存在抽象方法时，需要将该类声明为abstract类
=> 一般来说，抽象类会被继承，有其子类来实现抽象方法

二、抽象类介绍

1. 用abstract关键字来修饰一个类时，这个类就叫抽象类。

访问修饰符 abstract 类名{
}

2. 用abstract关键字来修饰一个方法时，这个方法就是抽象方法。
   抽象方法没有方法体

访问修饰符 abstract 返回类型 方法名(参数列表);  

3. 抽象类的价值更多作用是在于设计，是设计者设计好后，让子类继承并实现抽象类。
4. 抽象类，是考官比较爱问的知识点，在框架和设计模式使用较多。

三、抽象类细节

AbstractDetail01.java

1. 抽象类不能被实例化。[举例a. 见后文]
2. 抽象类不一定要包含abstract方法。也就是说，抽象类可以没有abstract方法。[举例b. 见后文]
3. 一旦类包含了abstract方法，则这个类必须声明为abstract。
4. abstract 只能修饰类和方法，不能修饰属性和其它的。
5. 抽象类可以有任意成员【因为抽象类还是类】，比如：非抽象方法、构造器、静态属性等等。[举例c.]
6. 抽象方法不能有主体，即不能实现。
7. 如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法，除非它自己也声明为abstract类。[举例d.]
8. 抽象方法不能使用 private、final 和 static 来修饰，因为这些关键字都是和重写相违背的。
   说明：
   ①父类的属性&成员为private，子类无法访问。
   ②final本意就是不希望子类来继承。
   ③static修饰的方法是静态方法，可以直接被类调用。而abstract修饰的方法是抽象方法，即无方法体的方法，不能被直接调用，需要在子类或实现类中去编写完整的方法处理逻辑后才能使用。

• 举例

a.

b.

abstract class A {
    //抽象类不一定要包含abstract方法。
    // 也就是说,抽象类可以没有abstract方法
    // 还可以有实现的方法。
    String name;
    public void hi() {
        System.out.println("hi");
    }
}

c.
抽象类的本质还是类，所以可以有类的各种成员

abstract class C {
    public int num;
    public static String name = "haha";
    public void hi() {
        System.out.println("hi~");
    }
    public static void hello() {
        System.out.println("hello!");
    }
    public abstract void eat();
}

d.
这里相等于Mama子类实现了父类GrandMa的抽象方法，所谓实现方法，就是有方法体（方法体内具体实现不关心）。

abstract class GrandMa {
    public abstract void hi();
    public abstract void hello();
}
class Mama extends GrandMa{
    public void hi() {
        System.out.println("hi");
    }
    public void hello() {
        System.out.println("hello");
    }
}

四、练习题

1. 题1，思考: abstract final class A()能编译通过吗，why?
2. 题2，思考: abstract public static void test2();能编译通过吗，why?
3. 题3，思考: abstract private void test3(); 能编译通过吗， why?

我的回答：
三个都不能
正确。

4. 编写一个Employee类，声明为抽象类，包含如下三个属性：name，id，salary。提供必要的构造器和抽象方法：work()。对于Manager类来说，他既是员工，还具有奖金(bonus)的属性。请使用继承的思想，设计CommonEmployee类和Manager类，要求类中提供必要的方法进行属性访问，实现work()，提示"经理/普通员工名字工作中.……"

public class AbstractExercise01 {
    public static void main(String[] args) {
        Manager sb = new Manager("sb", 38, 6000.5,100.0);
        CommonEmployee poor = new CommonEmployee("poor", 66, 5000.1);
        sb.work();
        poor.work();
    }
}

abstract class Employee {
    private String name;
    private int id;
    private double salary;

    public Employee(String name, int id, double salary) {
        this.name = name;
        this.id = id;
        this.salary = salary;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    abstract public void work();
}

class Manager extends Employee {
    public double bonus;
    public Manager(String name, int id, double salary,double bonus) {
        super(name,id,salary);
        this.bonus = bonus;
    }
    public void work() {
        System.out.println("Manager "+ this.getName() +" is sleeping···");
    }
}

class CommonEmployee extends Employee {
    public CommonEmployee(String name, int id, double salary) {
        super(name,id,salary);
    }

    public void work() {
        System.out.println("CommonEmployee "+this.getName()+" is working···");
    }
}

和韩老师视频中的代码核对之后，改进的点：
CommonEmployee和Manager的work()方法上面写上 Override

 @Override

本笔记是对韩顺平老师的Java课程做出的梳理。方便本人和观看者进行复习。
课程请见： https://www.bilibili.com/video/BV1fh411y7R8/?spm_id_from=333.999.0.0&vd_source=ceab44fb5c1365a19cb488ab650bab03