抽象类、模板方法模式-编程知识

抽象类概述

在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{@Overridepublic 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），这些方法是抽象的，需要在子类中具体实现。子类通过实现这些抽象方法，可以重新定义算法中的某些步骤，以满足特定的需求。

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

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

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

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

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

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

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

模板方法模式实现步骤

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

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

案例：银行利息结算系统

需求：

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

活期是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);}@Overridepublic 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");}
}