Question

我对＃34;数据结构和算法＆＃34;中的这个问题感到非常难过。由古德里奇和塔玛西亚。本书介绍了以下两个类：

public class CreditCard {
private String customer;
private String bank;
private String account;
private int limit;
protected double balance;

public CreditCard(String customer, String bank, String account, int limit, double balance) {
    this.customer = customer;
    this.bank = bank;
    this.account = account;
    this.limit = limit;
    this.balance = balance;

}

public CreditCard(String customer, String bank, String account, int limit) {
    this(customer, bank, account, limit, 0.0);
}

public String getCustomer() { return this.customer; }
public String getBank() { return this.bank; }
public String getAccount() { return this.account; }
public int getLimit() { return this.limit; }
public double getBalance() { return this.balance; }

public boolean charge(double price) {
    if(price + this.balance > this.limit)
        return false;

    this.balance += price;
    return true;
}

public void makePayment(double amount) {
   if( amount < 0)
      System.out.println("Cannot process negative payment");
   else
      this.balance -= amount;
}

public void updateCreditLimit() {
    this.limit -= balance;
}

public static void printSummary(CreditCard card) {
    System.out.println("Customer = " + card.customer);
    System.out.println("Bank = " + card.bank);
    System.out.println("Account = " + card.account);
    System.out.println("Balance = " + card.balance);
    System.out.println("Limit = " + card.limit);
}

}

子类

public class PredatoryCreditCard extends CreditCard {
private double apr;

public PredatoryCreditCard(String customer, String bank, String account,
                           int limit, double balance, double apr) {
                               super(customer, bank, account, limit, balance);
                               this.apr = apr;
                           }

public void processMonth() {
    if(this.balance > 0) {
        double monthlyFactor = Math.pow(1 + apr, 1F/12);
        this.balance *= monthlyFactor;
    }
}

public boolean charge(double price) {
    boolean isSuccess = super.charge(price);
    if(!isSuccess)
        this.balance += 5;
    return isSuccess;
}

}

问题：

假设我们更改了CreditCard类，以便实例变量balance具有私有可见性。为什么PredatoryCreditCard.charge方法的以下两个实现存在缺陷？

public boolean charge(double price) {
    boolean isSuccess = super.charge(price);
    if(!isSuccess)
       charge(5); //penalty for late fee
     return isSuccess;
 }

第二个：

public boolean charge(double price) {
    boolean isSuccess = super.charge(price);
    if(!isSuccess)
       super.charge(5); //penalty for late fee
     return isSuccess;
 }

我理解的是，子类不能直接操作它的超类的私有字段。该领域必须受到保护或公开。这允许我们在子类this.balance += 5中说。我对这些原则的理解不是问题，我的问题是我要回答的问题。从实现的角度来看，我在PredatoryCreditCard.charge方法中没有明显的缺陷，因为在问题提供的新实现的两种情况下，我们都在改变类的平衡字段，因为调用超。除非我认为我的继承知识存在漏洞，否则我无法在新实施中找到缺陷。

提前谢谢你。

Answer 1

在任何一种情况下，如果您足够接近余额（价值5）超过您的限额，您将无法收取费用。在第一种情况下：

public boolean charge(double price) {
    boolean isSuccess = super.charge(price);
    if(!isSuccess)
       charge(5); //penalty for late fee
     return isSuccess;
 }

isSuccess失败时会发生什么？我们陷入无限递归调用this.charge(...)

Answer 2

两种实现中都没有语法错误。两者都有（或可能有）逻辑错误。

首次实施

public boolean charge(double price) {
    boolean isSuccess = super.charge(price);
    if(!isSuccess)
       charge(5);  //penalty for late fee
     return isSuccess;
 }

我们开始深入一层。

第一个陈述是super.charge(price) 如果该语句返回false，那么我们会调用this.charge(5) 我们现在处于两个层面。

第一个陈述是super.charge(5) 如果该语句返回false，那么我们会调用this.charge(5) 我们现在处于三个层面。

第一个陈述是super.charge(5) 如果该语句返回false，那么我们会调用this.charge(5) 我们现在有四个层次 ...

你明白了。第一个实现可能会导致无限递归，从而导致堆栈溢出。见What methods are there to avoid a stack overflow in a recursive algorithm?

第二次实施

public boolean charge(double price) {
    boolean isSuccess = super.charge(price);
    if(!isSuccess)
       super.charge(5); //penalty for late fee
     return isSuccess;
 }

我们尝试向price收取费用。我们记录交易是否成功如果交易失败，我们会收取滞纳金。我们不记录交易是否成功如果延迟收费，我们不在乎。

我不确定这里的错误是什么。它当然不能模仿我的银行如何运作，但这不一定是个问题。我认为避免滞纳金是件坏事，但这实际上取决于你的要求。

java

2 个答案: