如何使 2 个 object 实例使用银行帐号属性进行通信？

Question

I am a beginner tinkering with classes.

I am trying to create 2 separate bank instances and have them communicate using one of their properties. The property is a bank account number.

One bank instance is meant to be able to transfer a set amount of money to another bank instance using its bank account number as a form of verification.

Before showing the code, please understand that I am experimenting and learning here. I am aware that the Bank Class should not be extending the BankAccount class.

Have a look at this code:

class BankAccount{
        constructor(balance)
        {
                this.balance;
        }
        withdraw(amount)
        {
                this.balance -= amount;
        }
        deposit(amount)
        {
                this.balance += amount;
        }
}

class Bank extends BankAccount{
        constructor(balance,accNum)
        {
                super(balance);
                this.accNum = accNum;
        }
        transfer(fromAccNum,toAccNum,amount)
        {
                if(this.accNum === fromAccNum)
                        super.withdraw(amount);
                toAccNum.BankAccount.deposit(amount);
        }
}

The BankAccount class simply has a balance and two methods that update the balance should a withdrawal or deposit be made.

The Bank class adds in one extra property to the mix, the bank account number and this is what makes this challenge interesting.

Let us say I am to create two instances of the Bank class like this:

var acc01 = new Bank(10000,12345); // a balance of 10 000 and account number 12345
var acc02 = new Bank(1000,54321); // a balance of 1000 and a account number 54321

Using these two separate account I would like to make a call to the transfer method and have it send money from acc01 to acc02.

Something like this:

acc01.transfer(acc01.accNum,acc02.accNum,1000);

The above line simply passes in the accNum 12345 as the first argument, this is the account number we would like to withdraw from and send to the other account number 54321. The second argument 54321 is the account number we would like to send money to. The third argument is the amount that we would like to send.

Results expected after calling the transfer method on acc01:

console.log(acc01.balance); // balance should be updated to 9000
console.log(acc02.balance); // balance should be updated to 2000

I can't seem to figure out how to make this work? Can someone please come to my rescue here??

Answer 1

You can have a BankManager class that holds the Bank instances and manages the transactions.

class BankManager{
    constructor()
    {
       this.accounts = [
           new Bank(10000, 12345),
           new Bank(1000, 54321)
       ];
    }
    transfer(toAcc, fromAcc, amount)
    {
       if (fromAcc.balance >= amount) {
           fromAcc.withdraw(amount);
           toAcc.deposit(amount);
       }
    }
    transferByNum(toAccNum, fromAccNum, amount)
    {
       const toAcc = this.accounts.find(acc => acc.accNum === toAccNum);
       const fromAcc = this.accounts.find(acc => acc.fromAcc === fromAccNum);
       this.transfer(toAcc, fromAcc, amount);
    }
}

Answer 2

I think your problem is that transfer method accepts 'from' and 'to', in addition to having its own acct number. This means that there are cases where transfer method is called on completely unrelated acct.

You want to refactor it to

    transfer(toAcc,amount)
        {
                super.withdraw(amount);
                toAcc.deposit(amount);
        }

Also notice that you need the actual instance of acct, not just acct number, since you don't have a mechanism to retrieve the bank account object based on acct number.