抽象类、模板方法模式

抽象类概述

在Java中abstract是抽象的意思，如果一个类中的某个方法的具体实现不能确定，就可以申明成abstract修饰的抽象方法（不能写方法体了），这个类必须用abstract修饰，被称为抽象类。

抽象方法定义：修饰符 abstract 返回值类型 方法名称(形参列表);，只有方法签名，没有方法体，使用了abstract修饰。

抽象类定义：修饰符 abstract class 类名{  }

抽象类可以理解成类的不完整设计图，是用来被子类继承的。

抽象类的作用： 可以被子类继承、充当模板的、同时也可以提高代码复用。

怎么理解模板？相当于以一篇缺少中间内容的作文作为模板，结构都不用变，我只要充实下中间的内容，那么子类以抽象类作为模板，只要实现下抽象方法即可。

示例：

public abstract class Animal {
    private String name;
 
    public abstract void run();
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
}

抽象类的案例

系统需求

某加油站推出了2种支付卡，一种是预存10000的金卡，后续加油享受8折优惠，另一种是预存5000的银卡 ,后续加油享受8.5折优惠。

请分别实现2种卡片进入收银系统后的逻辑，卡片需要包含主人名称，余额，支付功能。

分析实现

创建一张卡片父类：定义属性包括主人名称、余额、支付功能（具体实现交给子类）

创建一张白金卡类：重写支付功能，按照原价的8折计算输出。 创建一张银卡类：重写支付功能，按照原价的8.5折计算输出。

代码

/**
     抽象父类
 */
public abstract class Card {
    private String name; // 主人名称
    private double money;
 
    /**
      子类一定要支付的，但是每个子类支付的情况不一样，所以父类把支付定义成抽象方法，交给具体子类实现
     */
    public abstract void pay(double money);
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public double getMoney() {
        return money;
    }
 
    public void setMoney(double money) {
        this.money = money;
    }
}

/**
   金卡
 */
public class GoldCard extends Card{
    @Override
    public void pay(double money) {
        // 优惠后的金额算出来：
        double rs = money * 0.8;
        double lastMoney = getMoney() - rs;
        System.out.println(getName() + "当前账户总金额："
                + getMoney() +",当前消费了：" + rs +",消费后余额剩余：" +
                lastMoney);
 
        setMoney(lastMoney); // 更新账户对象余额
    }
}

 银卡差不多

抽象类的特征、注意事项

1、有得有失: 得到了抽象方法，失去了创建对象的能力。

2、抽象类为什么不能创建对象？  反证法。

3、类有的成员（成员变量、方法、构造器）抽象类都具备

4、抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类

5、一个类继承了抽象类必须重写完抽象类的全部抽象方法，否则这个类也必须定义成抽象类。

6、不能用abstract修饰变量、代码块、构造器。

final和abstract是什么关系？

互斥关系

abstract定义的抽象类作为模板让子类继承，final定义的类不能被继承。

抽象方法定义通用功能让子类重写，final定义的方法子类不能重写。

抽象类的应用知识：模板方法模式

概述

模板方法模式（Template Method Pattern）是一种行为设计模式，它在一个方法中定义一个算法的骨架，允许子类在不改变算法结构的情况下重新定义某些步骤的具体内容。换句话说，模板方法模式封装了不变的部分，而将可变的部分留给子类来实现。

在模板方法模式中，通常有一个抽象类（或称为模板类），它定义了算法的骨架和步骤的顺序。这个抽象类还包含一些抽象方法或钩子方法（hook methods），这些方法是抽象的，需要在子类中具体实现。子类通过实现这些抽象方法，可以重新定义算法中的某些步骤，以满足特定的需求。

使用模板方法模式的好处有以下几点：

1. 代码复用：模板方法模式将算法的不变部分封装在父类中，而可变部分则留给子类来实现。这样，子类可以在不改变算法结构的情况下，通过覆盖父类的方法来实现自己的逻辑，从而实现了代码的复用。
2. 扩展性：由于算法的可变部分被抽象出来，子类可以通过扩展父类来实现新的功能。这符合开闭原则，即对扩展开放，对修改封闭。
3. 控制子类行为：模板方法模式通过定义算法的骨架和步骤顺序，可以控制子类的行为。父类中的模板方法规定了算法的整体流程，而子类则通过实现抽象方法来参与这个流程。

然而，模板方法模式也有一些潜在的缺点：

1. 类个数增加：对于每个不同的实现，都需要定义一个子类，这可能会导致类的个数增加，系统更加庞大和复杂。
2. 反向控制结构：父类中的抽象方法由子类实现，子类执行的结果会影响父类的结果，这导致一种反向的控制结构。这可能会增加代码阅读的难度和维护的复杂性。

在实际应用中，模板方法模式通常用于实现一些具有固定流程的操作，如文件操作、数据库操作、网络通信等。在这些场景中，通过使用模板方法模式，可以将不变的部分封装起来，而将可变的部分留给子类来实现，从而提高代码的复用性和可维护性。

什么时候使用模板方法模式

使用场景说明：当系统中出现同一个功能多处在开发，而该功能中大部分代码是一样的，只有其中部分可能不同的时候。

模板方法模式实现步骤

把功能定义成一个所谓的模板方法，放在抽象类中，模板方法中只定义通用且能确定的代码。

模板方法中不能确定的功能定义成抽象方法让具体子类去实现。

案例：银行利息结算系统

需求：

某软件公司要为某银行的业务支撑系统开发一个利息结算系统，账户有活期和定期账户两种。

活期是0.35%，定期是 1.75%，定期如果满10万额外给予3%的收益。

结算利息要先进行用户名、密码验证，验证失败直接提示，登录成功进行结算。

分析：

实现步骤：

创建一个抽象的账户类Account作为父类模板，提供属性（卡号，余额）。

在父类Account中提供一个模板方法实现登录验证，利息结算、利息输出。

具体的利息结算定义成抽象方法，交给子类实现。

定义活期账户类，让子类重写实现具体的结算方法。

定义定期账户类，让子类重写实现具体的结算方法。

创建账户对象，完成相关功能。

代码：

public abstract class Account {
    private String cardId;
    private double money;
 
    public Account() {
    }
 
    public Account(String cardId, double money) {
        this.cardId = cardId;
        this.money = money;
    }
 
    /**
      模板方法
     */
    public final void handle(String loginName , String passWord ){
        // a.判断登录是否成功
        if("itheima".equals(loginName) && "123456".equals(passWord)){
            System.out.println("登录成功。。");
            // b.正式结算利息
            // 当前模板方法知道所有子类账户都要结算利息，但是具体怎么结算，模板不清楚，交给具体的子类来计算
            double result = calc();
            // c.输出利息详情
            System.out.println("本账户利息是："+ result);
        }else{
            System.out.println("用户名或者密码错误了");
        }
    }
 
    public abstract double calc();
 
 
    public String getCardId() {
        return cardId;
    }
 
    public void setCardId(String cardId) {
        this.cardId = cardId;
    }
 
    public double getMoney() {
        return money;
    }
 
    public void setMoney(double money) {
        this.money = money;
    }
}

/**
  活期账户
 */
public class CurrentAccount extends Account {
 
    public CurrentAccount(String cardId,  double money) {
        super(cardId, money);
    }
 
    @Override
    public double calc() {
        // b.正式结算利息
        double result =  getMoney() * 0.0175; // 结算利息了
        return result;
    }
 
}

public class Test {
    public static void main(String[] args) {
        CurrentAccount acc = new CurrentAccount("ICBC-111", 100000);
        acc.handle("itheima", "123456");
    }
}

模板方法我们是建议使用final修饰的，这样会更专业，那么为什么呢？

答：模板方法是给子类直接使用的，不是让子类重写的， 一旦子类重写了模板方法就失效了。

模板方法模式解决了什么问题？  

极大的提高了代码的复用性。

模板方法已经定义了通用结构，模板不能确定的定义成抽象方法。  

使用者只需要关心自己需要实现的功能即可。