Question

我有一个班级帐户（摘要）。我有一个类SavingsAccount（继承帐户）。我有一个类CreditAccount（继承帐户）。

SavingsAccount和CreditAccount类似，但CreditAccount有信用额度（可变限额）。

我有以下问题：

我需要有关CreditAccount构造函数的帮助。如何向构造函数添加局部变量限制？
如果我在基类中有变量限制，那么它是否更好（更容易），并且让SavingsAccount始终将其设置为零，而CreditAccount让用户设置限制？
我的老师说，由于SavingsAccount和CreditAccount几乎相同，@ Override完全一样，他建议我在基类（Account）中实现这些方法。如果我这样做，代码将如何？

感谢您的帮助

班级帐户：

public abstract class Account {
    protected double balance = 0;
    protected String accountId;
    protected double interest = 0;

    public Account() {}  

    public Account(double bal, String id, double inte) {   
        if (balance >= 0) {
           balance = bal;
        }
        else {
            balance = 0;
        }
        accountId = id;
        interest = inte;
    }

    public abstract String getAccountId();

    public abstract double getBalance();

    public abstract double getInterest();  
}

class SavingsAccount：

public class SavingsAccount extends Account {

    public SavingsAccount() {     
        super();
    }

    public SavingsAccount(double bal, String id, double inte) {   
       super(bal, id, inte);
    }

    @Override
    public String getAccountId() {
        return accountId;
    }

    @Override
    public double getInterest() {
        return interest;
    }

    @Override
    public double getBalance() {
        return balance;
    }
}

Class CreditAccount：

class CreditAccount extends Account {
    private int limit;

    public CreditAccount() {      
        super();
    }

    public CreditAccount(double bal, String id, double inte) { //How can I add local variable limit to this???
       super(bal, id, inte);
    }

    public void setLimit(int limit) {
        this.limit = limit;
    }

    @Override
    public String getAccountId() {
        return accountId;
    }

    @Override
    public double getInterest(){
        return interest;
    }

    @Override
    public double getBalance() {
        return balance;
    }
}

在main中：

   System.out.print("Savings or Credit (S/C): ");
   answer = input.next();
   if (null != answer) switch (answer) {
       case "S":
       case "s":{
          System.out.print("Amount to deposit: ");
          double amount = input.nextDouble();
          System.out.print("Interest: ");
          double interest = input.nextDouble();
          SavingsAccount savingsAccount = new SavingsAccount(amount, accountId, interest);
          newCustomer.addAccount(savingsAccount);
          bank.addCustomer(newCustomer);  
          break;
       }
       case "C":
       case "c":{
          System.out.print("Amount to deposit: ");
          double amount = input.nextDouble();
          System.out.println("Interest: ");
          double interest = input.nextDouble();
          CreditAccount creditAccount = new CreditAccount(amount, accountId, interest); 
          newCustomer.addAccount(creditAccount);
          bank.addCustomer(newCustomer); 
          break;
       }
       default:
          System.out.println("invalid answer");
          break;
       }

Answer 1

在不给你的任务的情况下回答你的问题......

1）我需要有关CreditAccount中构造函数的帮助。如何向构造函数添加局部变量限制？

我认为你对“拥有”来实现基础的构造函数感到困惑。那么，这并不妨碍您提供一个特定的子需求。

public CreditAccount(..., double limit) {
    //call the super from this
    this.limit = limit;
}

如果我在基类中有变量限制，那么它是否更好（更容易），并且让SavingsAccount始终将其设置为零，而CreditAccount让用户设置限制？

更好;不。更轻松;这是主观的。设置无数个子类的“不必要的变量”比不包括它更容易吗？

更容易不是覆盖优秀设计的因素。所有这一切的重点在于提供漂亮的小数据持有者，没有杂乱。最重要的是，它似乎并不正确;可以;你的直觉是什么意思？

我的老师说，由于SavingsAccount和CreditAccount几乎相同，@ Override完全一样，他建议我在基类（Account）中实现这些方法。如果我这样做，代码将如何？

与未实现方法的抽象类相反，实现它们。将简单的getter放在抽象类中，然后从em中移除它们。结果代码看起来像......

public CreditAccount ... {
    protected double limit;
    //those constructors you need
    public double getLimit() { ... }
}

......对于初学者来说。

Java中的构造函数和类

1 个答案: