GNU Smalltalk - 继承和多参数方法/构造函数

Question

假设我正在尝试将以下 Java 类转换为 GNU Smalltalk：

public abstract class Account {

    protected String number;
    protected Customer customer;
    protected double balance;

    public abstract void accrue(double rate);

    public double balance() {
        return balance;
    }

    public void deposit(double amount) {
        balance += amount;
    }

    public void withdraw(double amount) {
        balance -= amount;
    }

    public String toString() {
        return number + ":" + customer + ":" + balance;
    }
}

public class SavingsAccount extends Account {

    private double interest = 0;

    public SavingsAccount(String number, Customer customer, double balance) {
        this.number = number;
        this.customer = customer;
        this.balance = balance;
    }

    public void accrue(double rate) {
        balance += balance * rate;
        interest += interest * rate;
    }

}

我很难理解如何编写采用多个参数的方法/构造函数。到目前为止，这是我所得到的：

Object subclass: Account [

    |number customer balance|

    balance [
        ^balance
    ]

    deposit: amount [
         balance := balance + amount
    ]

    withdraw: amount [
        balance := balance - amount
    ]

    asString [
        ^number asString, ':', customer asString, ':', balance asString
    ]

]

Account subclass: SavingsAccount [

    |interest|

    SavingsAccount class [
        new [ "add some sort of support for multiple arguments?"
           "call init"
        ]
    ]

    init [ "add some sort of support for multiple arguments?"
         interest := 0.
         balance := accountBalance.
         customer := accountCustomer.
         number := accountNumber
    ]

    accrue: rate [
        balance := balance + (balance * rate).
        interest := interest + (interest * rate)
    ]

]

几个问题：

1. 如何使 Account 成为 Smalltalk 中的抽象类？
2. 我是否正确假设所有 Account 实例变量都可以通过 SavingsAccount 类中的名称访问？
3. 如何在 Java SavingsAccount 类中实现模拟多参数构造函数的东西？

Answer 1

1. 您不应该为某种“使类抽象”而烦恼:)。但最接近您的问题的解决方案是

   abstractMethod [
       self subclassResponsibility
   ]
   

   现在，当有人向您的类发送消息时，他会收到一个错误，指出应该实现此方法，您必须在子类中重写它。

2. 是的。子类可以访问所有实例变量。

3. 好的，所以像withdraw: amount 这样的关键字消息实际上可以有多个参数，例如：withdraw: amount becauseOf: reason。所以首先你做一个初始化器：

   initWithBalance: aBalance customer: aCustomer number: aNumber [ 
       self init.
       balance := aBalance.
       customer := aCustomer.
       number := aNumber
   ]
   

   您可以将interest := 0. 保留在主init 中。 然后，为了让你的生活更美好，你创建一个参数化的new 并从那里调用参数化的init。

   SavingsAccount class [
       newWithBalance: aBalance customer: aCustomer number: aNumber [
          ^ self new initWithBalance: aBalance customer: aCustomer number: aNumber
       ]
   ]