GNU Smalltalk - Inheritance and Multiple Parameter

Question

Say I'm trying to translate the below Java classes to 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;
    }

}

I'm struggling to understand how I can write methods/constructors that take multiple parameters. Here's what I've got so far:

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)
    ]

]

A few questions:

1. How can I make Account an abstract class in Smalltalk?
2. Am I correct in assuming all the Account instance variables are just accessible by name in the SavingsAccount Class?
3. How can I implement something that mimics the multiple parameter constructor in the Java SavingsAccount Class?

Answer 1

1. You shouldn't bother with some kind of "making class abstract" :). But the closest solution to your question is

   abstractMethod [
       self subclassResponsibility
   ]
   

   Now when someone sends a message to your class he'll get an error that this method should be implemented, and you must override it in subclasses.

2. Yes. All instance vars can be accessed by a subclass.

3. Ok, so the keyword messages like withdraw: amount can actually have multiple parameters like: withdraw: amount becauseOf: reason. So first of all you make an initialiser:

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

   You can keep interest := 0. in main init. Then, to make your life better, you make a parameterised new and call parameterised init from there.

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