【Java SE：抽象类】抽象类的引出与深入理解

抽象类的引出与深入理解

1. 引出抽象类：

我们首先来看这样一段代码：Animal是父类，我们需要一些子类来继承父类

package com.haut.iot.assassin;

public class Animal {
    private String name; //名字
    private int age; //年龄

    public Animal(String name, int age) {//构造方法
        this.name = name;
        this.age = age;
    }
    
    //动物都有的eat行为
    //思考：这里eat是实现了，其实并没有什么意义
    //即：父类方法不确定性的问题
    //====> 考虑将该方法设计为抽象方法（abstract）
    //====> 所谓抽象方法就是没有实现的方法，所谓没有实现就是没有方法体，只有声明
    //====> 当一个类中存在抽象方法时，需要将该类声明成为抽象类
    public void eat() {
        System.out.println("这是一个动物，但是目前来说不知道吃什么~");
    }
    
}

通过上述代码我们可以发现，父类方法存在不确定性

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

like this：

package com.haut.iot.assassin;

public abstract class Animal { //抽象类
    private String name; //名字
    private int age; //年龄

    public Animal(String name, int age) {//构造方法
        this.name = name;
        this.age = age;
    }

    //动物都有的eat行为
//    public void eat() {
//        System.out.println("这是一个动物，但是目前来说不知道吃什么~");
//    }
    public abstract void eat(); //抽象方法

}

一般来说，抽象类会被继承，由其子类来实现抽象方法

2. 抽象类细节：

2.1 抽象类的介绍：

• 用abstract关键字来修饰一个类时，这个类就叫做抽象类，具体语法是：访问修饰符 abstract 类名 {}
• 用abstract关键字来修饰一个方法时，这个方法就是抽象方法，具体语法是：访问修饰符 abstract 返回类型 方法名(参数列表)； //没有方法体
• 抽象类的价值更多是体现在于设计，是设计者设计好后，让子类继承并实现抽象类
• 这里插一句，抽象类是面试时经常被问到的知识点，在框架和设计模式中使用较多

2.2 抽象类注意事项和细节讨论：

8个细节如下：

• 抽象类不能被实例化，这里待会儿会举例说明
• 抽象类不一定要包含abstract方法，也就是说，抽象类可以没有abstract方法，下面也会举例说明
• 一旦类包含了abstract方法，则这个类必须声明为abstract
• abstract只能修饰类和方法，不能修饰属性和其他的，这里也会举例说明
• 抽象类可以拥有任意成员（抽象类的本质还是一个类），比如：非抽象方法，构造方法，静态属性等
• 抽象方法不能拥有方法体，即不能实现
• 如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法，除非它自己也声明为abstract类，下面会进行举例~
• 抽象方法不能用private，final以及static来修饰，因为这些关键字和重写是相违背的，这个很重要，下面会举例说明

抽象类不能被实例化：

抽象类可以没有abstract方法：

可以看到 IDEA 并没有报错~

abstract只能修饰类和方法，不能修饰属性和其他的：

如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法，除非它自己也声明为abstract类：

当子类不实现父类的抽象方法时，会报错~，如下图所示：

当子类也声明为abstract类时，可以不实现父类的abstract方法：

这里再深入探讨一哈，当再有一个C类继承了B类时，A类中的抽象方法还是需要被实现，出来混总是要还的[doge]~

抽象方法不能用private，final以及static来修饰：
我们反推一哈：如果private修饰abstract语法上通过了，那子类也没有机会去重写或者实现此抽象方法，所以private不能修饰抽象方法

final的本意就是最终的，不想改变的意思，也就是说不希望子类来重写此方法，所以final也不能修饰抽象方法

static可以通过类名来调用，所以是需要有方法体的，而抽象方法没有方法体，自然也就不能使用static修饰抽象方法

3. 实现一个抽象类：

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

实现代码：
父类Employee类：

//父类Employee类
package com.haut.iot.assassin;

public 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 abstract void work();//抽象方法

    public String getName() {
        return name;
    }

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

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }
}

子类Manager类：

//子类Manager类
package com.haut.iot.assassin;

public class Manager extends Employee {
    private double bonus; //奖金

    public Manager(String name, int id, double salary) {
        super(name, id, salary);
    }

    public double getBonus() {
        return bonus;
    }

    public void setBonus(double bonus) {
        this.bonus = bonus;
    }

    @Override
    public void work() {
        System.out.println("经理 " + getName() + " 工作中...");
    }



}

子类CommonEmployee类：

//子类CommonEmployee类
package com.haut.iot.assassin;

public class CommonEmployee extends Employee{

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

    @Override
    public void work() {
        System.out.println("普通员工 " + getName() + " 工作中...");
    }
}

测试类AbstractExercise类：

//测试类AbstractExercise类
package com.haut.iot.assassin;

public class AbstractExercise {
    public static void main(String[] args) {
        //测试
        Manager assassin = new Manager("assassin", 1000, 20000);
        assassin.setBonus(8000);
        assassin.work();

        CommonEmployee ninghai = new CommonEmployee("ninghai", 999, 5000);
        ninghai.work();
    }
}

运行结果：

4. 抽象类作用：

抽象类存在的最大意义就是为了被继承。 抽象类本身不能被实例化, 要想使用，只能创建该抽象类的子类，然后让子类重写抽象类中的抽象方法。

有些小伙伴可能会说了, 普通的类也可以被继承呀, 普通的方法也可以被重写呀, 为啥非得用抽象类和抽象方法呢?
确实如此，但是使用抽象类相当于多了一重编译器的校验。

使用抽象类的场景就如上面的代码，实际工作不应该由父类完成，而应由子类完成，那么此时如果不小心误用成父类了，使用普通类的话编译器是不会报错的。 但是父类是抽象类就会在实例化的时候提示错误，让我们尽早发现问题。
很多语法存在的意义都是为了 " 预防出错 " , 例如 final 也是类似的作用。创建的变量用户不去修改，不就相当于常量嘛? 但是加上 final 能够在不小心误修改的时候, 让编译器及时提醒我们，充分利用编译器的校验，在实际开发中是非常有意义的。