抽象类及模板设计模式

1 基本介绍

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

当父类的一些方法不能确定时,可以用abstract关键字来修饰该方法，这个方法就是抽象方法,用abstract 来修饰该类就是抽象类。

当一个类中存在抽象方法时，需要将该类声明为abstract类
一般来说，抽象类会被继承，有其子类来实现抽象方法.

abstract class Animal {
    private String name;

    public Animal(String name) {
        this.name = name;
    }

    //思考：这里eat 这里你实现了，其实没有什么意义
    //即： 父类方法不确定性的问题
    //===> 考虑将该方法设计为抽象(abstract)方法
    //===> 所谓抽象方法就是没有实现的方法
    //===> 所谓没有实现就是指，没有方法体
    //===> 当一个类中存在抽象方法时，需要将该类声明为abstract类
    //===> 一般来说，抽象类会被继承，有其子类来实现抽象方法.
//    public void eat() {
//        System.out.println("这是一个动物，但是不知道吃什么..");
//    }
    public abstract void eat()  ;
}

1)用abstract关键字来修饰一个类时,这个类就叫抽象类;

访问修饰符 abstract 类名 {

​ }

2)用abstract关键字来修饰一个方法时,这个方法就是抽象方法;

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

3)抽象类的价值更多作用是在于设计,是设计者设计好后，让子类继承并实现抽象类;

4)抽象类,是考官比较爱问的知识点,在框架和设计模式使用较多.

2 抽象类的使用细节

1)抽象类不能被实例化；

2)抽象类不一定要包含abstract方法。也就是说,抽象类可以没有abstract方法；

3)一旦类包含了abstract方法,则这个类必须声明为abstract；

4. abstract 只能修饰类和方法，不能修饰属性和其它的。

5)抽象类可以有任意成员【抽象类本质还是类】，比如:非抽象方法、构造器、静态属性等等;

6)抽象方法不能有主体，即不能实现.如图所示

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

8)抽象方法不能使用private、final(不希望子类重写)和 static修饰，因为这些关键字都是和重写相违背的。

public class AbstractDetail01 {
    public static void main(String[] args) {
        //抽象类，不能被实例化
        //new A();
    }
}
//抽象类不一定要包含abstract方法。也就是说,抽象类可以没有abstract方法
//，还可以有实现的方法。
abstract class A {
    public void hi() {
        System.out.println("hi");
    }
}
//一旦类包含了abstract方法,则这个类必须声明为abstract
abstract class B {
    public abstract void hi();
}
//abstract 只能修饰类和方法，不能修饰属性和其它的
class C {
   // public abstract int n1 = 1;
}

public class AbstractDetail02 {
    public static void main(String[] args) {
        System.out.println("hello");
    }
}
//抽象方法不能使用private、final 和 static来修饰，因为这些关键字都是和重写相违背的
abstract class H {
    public   abstract void hi();//抽象方法
}

//如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法，除非它自己也声明为abstract类
abstract class E {
    public abstract void hi();
}
abstract class F extends E {

}
class G extends E {
    @Override
    public void hi() { //这里相等于G子类实现了父类E的抽象方法，所谓实现方法，就是有方法体

    }
}

//抽象类的本质还是类，所以可以有类的各种成员
abstract class D {
    public int n1 = 10;
    public static  String name = "韩顺平教育";
    public void hi() {
        System.out.println("hi");
    }
    public abstract void hello();
    public static void ok() {
        System.out.println("ok");
    }
}

3 练习

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

package com.yt.abstract_;

public class Test01 {
    public static void main(String[] args) {
        Manager jack = new Manager("jack", 99, 10000.0,20000);
        jack.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 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;
    }
}

class Manager extends Employee {
    private double bonus;

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

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

    public double getBonus() {
        return bonus;
    }

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

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

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

4 抽象类最佳实践-模板设计模式

4.1 基本介绍

抽象类体现的就是一种模板模式的设计，抽象类作为多个子类的通用模板，子类在抽象类的基础上进行扩展、改造，但子类总体上会保留抽象类的行为方式。

1)当功能内部一部分实现是确定，一部分实现是不确定的。这时可以把不确定的部分暴露出去，让子类去实现。
2)编写一个抽象父类，父类提供了多个子类的通用方法，并把一个或多个方法留给其子类实现，就是一种模板模式。

4.2 需求

1.有多个类,完成不同的任务job

2.要求统计得到各自完成任务的时间

3.请编程实现

感情的自然流露
1.先用最容易想到的方法-》代码实现

2.分析问题,提出使用模板设计模式

编写父类，写成抽象类，并编写一个抽象方法；

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));
    }
}

子类，必须重写分类抽象方法；

public class AA extends Template {

    //计算任务
    //1+....+ 800000
    //存在动态绑定机制，运行类型会先找该方法AA类
    @Override
    public void job() { //实现Template的抽象方法job

        long num = 0;
        for (long i = 1; i <= 800000; i++) {
            num += i;
        }
    }

//    public void job2() {
//        //得到开始的时间
//        long start = System.currentTimeMillis();
//        long num = 0;
//        for (long i = 1; i <= 200000; i++) {
//            num += i;
//        }
//        //得的结束的时间
//        long end = System.currentTimeMillis();
//        System.out.println("AA 执行时间 " + (end - start));
//    }
}

public class BB extends Template{

    public void job() {//这里也去，重写了Template的job方法

        long num = 0;
        for (long i = 1; i <= 80000; i++) {
            num *= i;
        }

    }
}

public class TestTemplate {
    public static void main(String[] args) {

        AA aa = new AA();//编译类型AA ;运行内存是AA;先找运行类型中的方法
        aa.calculateTime(); //这里还是需要有良好的OOP基础，对多态

        BB bb = new BB();
        bb.calculateTime();
    }
}