JAVA - 两个对象之间的关系

Question

我对OOP和Java相当陌生，有一个可能微不足道的问题，但我无法在Web上找到答案。

我正在做Java中的标准银行账户程序 - 有客户的程序，每个客户都有银行账户（一个客户可能有多个银行账户！），我可以存入或取出资金。每个银行帐户都有唯一的编号（即使某人拥有多个银行帐户，每个银行帐户都有其唯一编号）

我的代码编译和操作存取都正常工作。

问题出在以下 - 我不能将多个银行账户归于客户，在我的程序中，客户可以只有一个银行并且不会超过一个银行账户。

我有3个类 - 帐户，客户端，BankMain。你可以看到他们下面

public class Account { 
    private int balance; 
    private String NumAccount; // each bank account has a unique number 

    public Account(int money, String num) { 
     balance = money; 
     NumAccount = num; 
    } 

    public String printAccountNumber() { 
     return NumAccount; 
    } 
    // below are the methods for withdraw,deposit- they are working properly 
} 

类客户端

public class Client { 
    private String name;// name of the client 
    private Account account; 

    // the account associated to the client. Probably I should change sth 
    // here 
    // but I don't know what 
    public Client(String nom, Compte c) { 
     name = nom; 
     account = c; 
    } 

    public void printName() { 
     System.out.println(
       "Name: " + name 
       + "\nAccount number: " + account.printAccountNumber() 
       + "\nSolde: " + account.printBalance() + "\n" 
     ); 
    } 
} 

而且BankMain

public class BankMain { 

    public static void main(String[] args) { 
     Account account1 = new Account(1000, "11223A"); 
     Account account2 = new Account(10000, "11111A"); 
     Client client1 = new Client("George", account1); 
     Client client2 = new Client("Oliver", account2); 
     // now this is working correctly 
     client1.printName(); 
     client2.ptintName(); 
     /* 
     * The problem is that I don't know what to do if I want account1 
     * and account2 to belong both to client1. I tried Client client1 = 
     * new Client("George",account1); Client client1 = new 
     * Client("Oliver", account2); but got compilation error 
     */ 
    } 
} 

你知道我怎么能解决这个问题？我应该怎么做才能让多个银行账户与同一客户关联？

在此先感谢 乔治

Answer 1

结帐验证码：

//Account 

public class Account 
{ 
    private int balance; 
    private String accNo; 

    public Account(int money,String num) { 
    balance = money; 
    accNo = num; 
} 

public int getBalance() { 
     return balance; 
    } 

public void setBalance(int balance) { 
    this.balance = balance; 
} 

public String getAccNo() { 
    return accNo; 
} 

public void setAccNo(String accNo) { 
    this.accNo = accNo; 
} 

}

//Client 

import java.util.ArrayList; 
import java.util.Collection; 

public class Client 
{ 
    private String clientName; 
    private HashSet<Account> accounts; 
public Client(String name) 
{ 
    this.clientName = name; 
    this.accounts = new HashSet<Account>(); 
} 

public void addAccount(Account account) { 

    accounts.add(account); 
} 

public String getClientName() { 
    return clientName; 
} 

public void setClientName(String clientName) { 
    this.clientName = clientName; 
} 

public Collection<Account> getAccounts() { 
    return accounts; 
} 

public void setAccounts(HashSet<Account> accounts) { 
    this.accounts = accounts; 
} 

public void printAccountDetails() { 

    System.out.println("Account details :"); 
    int counter= 0; 
    for(Account acc : accounts) { 
     counter ++; 
     System.out.println("Account details for Account '"+counter+"' :\n"); 
     System.out.println("Account Number : "+ acc.getAccNo() +" Balance :" + acc.getBalance()); 
    } 
} 

}

// Bank class 


public class BankMain { 

    public static void main(String[] args) 
    { 

     Account account1 = new Account(1000,"11223A"); 
     Account account2 = new Account(10000,"11111A"); 
     Client client = new Client("George"); 

     client.addAccount(account1); 
     client.addAccount(account2); 

     client.printAccountDetails(); 
    } 

} 

在这里您可以根据需要添加多个帐户。

Answer 2

而不是试图重新定义客户端1和2又像：

Client client1 = new Client("George",account1); 
Client client1 = new Client("Oliver", account2); 

重新定义这些对象：

client1 = new Client("George",account1); 
... 
client1 = new Client("Oliver", account2); 

但这样做，你可以操作在同一个账户上，即如果你现在做了client1.withdraw，你会退出奥利弗的账户，而不是乔治。

而不是这样做，你可以维护地图中的名称和账户对象，并给出名称，你可以随时获取该人的账户。像：

Map<String, Account> nameAccountMap = .. 

然后你相应的帐户添加到它想：

nameAccountMap.put("Oliver", account2); 
nameAccountMap.put("George",account1); 

现在，如果你希望在奥利弗自有账户进行操作，你可以通过这样做：

nameAccountMap.get("Oliver").withdraw... 

以及其他帐户持有人的类似操作。

如果您希望多个帐户与用户相关联，你可以保持地图的名称和等的用户持有的账户列表：

Map<String, List<Account>> nameAccountMap = .. 

Answer 3

你可以有多个帐户的一个客户端更改数据类型在Client类中。例如：

private Map<String, Account> accounts; 

其中地图的关键是帐号，而该值是帐号本身。通过这种方式，您可以通过其唯一号码访问每个帐户。

（如果你不知道的地图是什么，检查this）

这也意味着你需要进行修改的Client构造函数接受多个帐户或添加新的方法，以一个新的帐户添加到Client。

Answer 4

而不是在您的客户类中有一个Account，有一个Set<Account>，以便有一对多的关系。确保帐户类别已实施equals和hashcode。

public class Client 
{ 
    private String name;//name of the client 
    private Set<Account> accounts; 
//the account associated to the client. Probably I should change sth here 
// but I don't know what 
    public Client(String nom, Set<Account> c) 
    { 
     name = nom; 
     account = c; 
    } 
    public String getName() 
    { 
     return this.name; 
    } 

    public Set<Account> getAccounts() 
    { 
     return this.accounts; 
    } 
    public String toString() 
    { 
     ... 
     // Return description of the Object state 
    } 
} 





public class Account 
{ 
    private int balance; 
    private String NumAccount; //each bank account has a unique number 
    public Account(int money,String num) 
    { 
     balance = money; 
     NumAccount = num; 
    } 
    public String getAccountNumber() 
    { 
     return NumAccount; 
    } 
    public boolean equals(..) 
    { 
     ... 
    } 
    public int hashcode() 
    { 
     ... 
    } 
    public String toString() 
    { 
     ... 
     // Return description of the Object state 
    } 
    // below are the methods for withdraw,deposit- they are working properly 
} 

Answer 5

正如@ m0skit0建议的那样，使用地图或列表来保存客户端类下的Account对象。

public class Client 
{ 
    private String name;//name of the client 
    private List<Account> accounts = new ArrayList<Account>(); 

    public Client(String nom, Account c) 
    { 
     name = nom; 
     accounts.add (c); 
    } 

    public boolean addAccount (Account c) 
    { 
     return accounts.add (c); 
    } 
    public removeAccount (Account c) 
    { 
     final int accountIndex = accounts.indexOf (c); 
     if (accountIndex > 0) 
     { 
      accounts.remove (accountIndex); 
      return true; 
     } 
     return false; 
    } 

    public void printName() 
    { 
     System.out.println("Name: " + name); 
     System.out.println ("Total Accounts: " + accounts.size()); 
     for (int i=0; i<accounts.size(); i++) 
     { 
      final Account a = accounts.get(i); 
      System.out.println ("\tAccount Number: " + a.printAccountNumber()); 
      System.out.println ("\tAccount Balance: " + a.printBalance()); 
     }   
    } 
} 

，并使用它在你的BankMain.java

Account account1 = new Account(1000,"11223A"); 
Account account2 = new Account(10000,"11111A"); 
Client client1 = new Client("George", account1); 
client1.addAccount (account2); 

client1.printName();