抽象类

抽象类【框架 + 设计模式】

1. 引入

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

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

package com.abstract_;

public class Abstract01 {
    //这是一个main方法，是程序的入口
    public static void main(String[] args) {

    }
}

abstract class Animal{
    private String name;

    public Animal(String name) {
        this.name = name;
    }
    //  思考:这里eat 你实现了，其实没有什么意义
    //  即：父类方法不确定性的问题
    // ==> 考虑将该方法设计为抽象（abstract）方法
    public abstract void eat();
}

2. 抽象类细节

a. 不能被实例化

b. 抽象类不一定包含 abstract 方法

c. 一旦包含了 abstract 方法，这个类必须声明为 abstract 类

d. abstract 只能修饰 类 和 方法

e. 抽象类本质还是类

可以有任意成员，比如：

• 非抽象方法
• 构造器
• 静态属性

f. 抽象方法不能有主体，即不能实现

g. 如果一个类继承了抽象类

• 则它必须实现抽象类的所有抽象方法

• 除非它自己也声明为 abstract 类

k. 抽象方法不能用 private、final 和 static 修饰

因为这些关键字和重写相违背

3. 练习

package com.abstract_;

public class Abstract02 {
    //这是一个main方法，是程序的入口
    public static void main(String[] args) {
        CommonEmployee bai = new CommonEmployee("bai", 11, 5000);
        bai.work();

        Manager meme = new Manager("meme", 11, 9000, 1000);
        meme.work();
    }
}

abstract class employee{	//	抽象类
    public String name;
    public int id;
    public double salary;

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

    public abstract void work();	//	抽象方法
}

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

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


class Manager extends employee{
    public double bounus;

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

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

4. 模板设计模式

需求：

1. 有多个类，完成不同的 job
2. 要求统计得到各自完成任务的时间

public class AA extends Template{

    //  计算任务
    //  1 + ... + 10000
    @Override
    public void job(){  //  实现Template的抽象方法 job
        long num = 0;
        for (long i = 1; i <= 100000; i++) {
            num += i;
        }
    }
}

package com.abstract_;
 
public class BB extends Template {

    @Override
    public void job(){  //  这里也重写了Template的job方法
        long num = 2;
        for (long i = 1; i <= 8; i++) {
            num *= i;
        }
    }
}

package com.abstract_;

abstract public class Template { //  抽象类 --> 模板设计模式

    public abstract void job(); //  抽象方法

    public void calculateTime() {   //  实现方法，调用job方法
        //  得到开始的时间
        long start = System.currentTimeMillis();
        job();  //  动态绑定
        //  得到结束的时间
        long end = System.currentTimeMillis();
        System.out.println("任务执行时间 " + (end - start));
    }
}

测试

package com.abstract_;

public class TestTemplate {
    //这是一个main方法，是程序的入口
    public static void main(String[] args) {
        AA aa = new AA();
        aa.calculateTime();     //  这里还是需要有良好的OOP基础，尤其是对多态的理解
        BB bb = new BB();
        bb.calculateTime();
    }
}