10.6-7 Java.抽象类与其最佳实践-模板设计模式.课堂笔记

10.6 抽象类

10.6.1 问题引入

10.6.2 解决之道-抽象类快速入门

要点：

1、当一个类中存在抽象方法时，需要将该类声明为 abstract 类

2、一般来说，抽象类会被继承，有其子类来实现抽象方法.

package SeniorJava.Abstract;

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

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

10.6.3 抽象类的介绍

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

==访问修饰符 abstract 类名｛ }==

2）用abstract 关键字来修饰一个方法时，这个方法就是抽象方法

==访问修饰符 abstract 返回类型 方法名（参数列表）；==／／注意，是没有方法体的！！

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

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

10.6.4 -5 抽象类使用的注意事项和细节讨论

1）抽象类不能被实例化

2） ==抽象类不一定要包含abstract方法。== 也就是说，抽象类可以没有abstract方法

3） 一旦类包含了abstract方法，则这个类必须声明为abstract

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

package SeniorJava.Abstract;

public class AbstractDetail02 {
    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;
}

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

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

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

package SeniorJava.Abstract;
public class AbstractDetail03 
{
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");
	}
}

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

10.6.6 课堂练习题

1）题1，思考：abstract final class A() 能编译通过吗，why？

==错误,final是不能继承==

2)题2，思考：abstract public static void test2()；能编译通过吗，why?

==错误，static关键字和方法重写无关．==

3)题3，思考:abstract private void test3();能编译通过吗,why?

==错误，private的方法不能重写==

4)编写一个Employee类，声明为抽象类，包含如下三个属性：name，id，salary。

提供必要的构造器和抽象方法：work （）。对于Manager类来说，他既是员工，还

具有奖金(bonus)的属性。请使用继承的思想，设计Common Employee类和

Manager类，要求类中提供必要的方法进行属性访问,实现work（），提示“经理/普通员工名字工作中

一：Employee类

package SeniorJava.Abstract;

abstract public 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;
    }

    //将 work 做成一个抽象方法
    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_Employee类

package SeniorJava.Abstract;

public class Manager_Employee extends Employee
{
    private double bonus;

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

    public double getBonus() {
        return bonus;
    }

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

    @Override//work方法要去重写，而且会把默认无参构造器给盖了，因此要再加一个构造器
    public void work() {
        System.out.println(" 经理 "+getName()+" 工作中 ");
    }
}

三：Common_Employee类

package SeniorJava.Abstract;

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

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

四：测试类

package SeniorJava.Abstract;

public class AbstractExercise01
{
    public static void main(String[] args) {
        Manager_Employee jack = new Manager_Employee("Jack", 999, 40000);
        jack.setBonus(5000);
        jack.work();

        Common_Employee peak = new Common_Employee("Peak", 600, 12345);
        peak.work();
    }

}

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

10.7.1 基本介绍

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

10.7.2 模板设计模式能解决的问题

1）当功能内部一部分实现是确定，一部分实现是不确定的。这时可以把不确定的部分暴露出去，让子类去实现。

2）编写一个抽象父类，父类提供了多个子类的通用方法，并把一个或多个方法留给其子类实现，就是一种模板模式．

10.7.3 最佳实践

需求

1）有多个类，完成不同的任务job

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

3）请编程实现 TestTemplate.java

感情的自然流露

1.先用最容易想到的方法-》代码实现

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

一、TestTemplate 类（测试类）

package SeniorJava.Abstract;

public class TestTemplate
{
    public static void main(String[] args) {
        Test_AA aa = new Test_AA();
        aa.job();

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

二、Test_AA 类

package SeniorJava.Abstract;

public class Test_AA
{
    //计算任务
    //1+....+ 99980000
    public void job()
    {
        //得到开始的时间
        long start = System.currentTimeMillis();
        long num = 0;
        for (int i = 1; i <= 99980000; i++) {
            num += i;
        }
        //得到结束的时间
        long end = System.currentTimeMillis();
        System.out.println("执行时间："+(end-start));
    }
}

三、Test_BB 类

package SeniorJava.Abstract;

public class Test_BB
{
    public void calculateTime()
    {
        //得到开始的时间
        long start = System.currentTimeMillis();
        job();//动态绑定机制
        //得到结束的时间
        long end = System.currentTimeMillis();
        System.out.println("执行时间："+(end-start));
    }
    //计算任务
    //1+....+ 99980000
    public void job()
    {
        long num = 0;
        for (int i = 1; i <= 99980000; i++) {
            num *= i ;
        }
    }
}

将方法中重复出现的代码放在一起，在引用不一样数据的方法，动态地得出最后结果。

//得到开始的时间
long start = System.currentTimeMillis();
job();//动态绑定机制
//得到结束的时间
ong end = System.currentTimeMillis();
System.out.println("执行时间："+(end-start));

10.7.4 模板设计

一、Template 类（模板类）

package SeniorJava.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));
    }
}

二、TestTemplate 类（测试类）

package SeniorJava.Abstract;

public class TestTemplate
{
    public static void main(String[] args) {
        Test_AA aa = new Test_AA();
        aa.calculateTime();

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

三、Test_AA 类

package SeniorJava.Abstract;

public class Test_AA extends Template
{
    //计算任务
    //1+....+ 99980000

    @Override
    public void job() {
        //实现 Template 的抽象方法 job
        long num = 0;
        for (long i = 1; i <= 99980000; i++) {
            num += i;
        }
    }

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

四、Test_BB 类

package SeniorJava.Abstract;

public class Test_BB extends Template
{
    //计算任务
    //1+....+ 99980000
    public void job()//这里也去，重写了 Template 的 job 方法
    {
        long num = 0;
        for (int i = 1; i <= 99980000; i++) {
            num *= i ;
        }
    }
}