0
点赞
收藏
分享

微信扫一扫

【SLAM论文笔记】PL-EVIO笔记(下)

素锦时年_1b00 03-05 17:30 阅读 4

抽象类概述

在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修饰的,这样会更专业,那么为什么呢?

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

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

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

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

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

举报

相关推荐

0 条评论