我是OOP和Java的新手，有一个问题可能很琐碎，但我在网上找不到答案。
我正在用Java做标准的银行账户程序——一个有客户的程序，每个客户都有银行账户（一个客户可能有多个银行账户！），我可以存款或取款。每个银行账户都有一个唯一的号码（即使某人有多个银行账户，每个银行账户也有其唯一的号码）
我的代码编译以及存款和取款操作都正常工作。
问题如下-我不能将多个银行账户归因于一个客户，在我的程序中，一个客户只能有一个银行，不能有多个银行帐户。
我有三个类-账户，客户，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
*/
}
}
你知道我该怎么解决这个问题吗？我应该怎么做才能让多个银行账户与同一客户关联？
提前感谢George
签出此代码：
//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();
}
}
在这里，您可以添加任意数量的帐户。
一个客户端可以有多个帐户来更改Client类中的数据类型。例如：
private Map<String, Account> accounts;
其中映射的键是帐号，值是帐号本身。通过这种方式，您可以通过其唯一的号码访问每个帐户。
（如果你不知道什么是地图，请查看此）
这也意味着您需要修改Client构造函数以接受多个帐户，或者添加一个新方法以将一个新帐户添加到Client。
按照@m0skit0的建议，使用映射或列表将Account对象保存在Client类下。
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();
而不是像那样再次尝试重新定义客户端1和2
Client client1 = new Client("George",account1);
Client client1 = new Client("Oliver", account2);
将这些对象重新定义为：
client1 = new Client("George",account1);
...
client1 = new Client("Oliver", account2);
但这样做，你可以在同一个账户上操作，即如果你现在进行客户1提款，你将从奥利弗的账户提款，而不是从乔治的账户提款。
与其这样做，您可以在地图中维护名称和帐户对象，并给定名称，您总是可以为该人获取帐户。类似：
Map<String, Account> nameAccountMap = ..
然后你添加相应的账户，比如：
nameAccountMap.put("Oliver", account2);
nameAccountMap.put("George",account1);
现在，如果您希望在Oliver拥有的账户上进行操作，您可以通过以下方式进行操作：
nameAccountMap.get("Oliver").withdraw...
以及对其他账户持有人的类似操作。
如果你想将多个账户与一个用户关联，你可以维护一个用户持有的账户名称和列表的地图，比如：
Map<String, List<Account>> nameAccountMap = ..
不要在Client类中有一个Account，而是要有一个Set<Account>，以便具有一对多关系。确保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
}