java中account是什么意思，JAVA 编程创建Account 类模拟银行账户。
大家好，感谢邀请，今天来为大家分享一下java中account是什么意思的问题，以及和JAVA 编程创建Account 类模拟银行账户。的一些困惑，大家要是还不太明白的话，也没有关系，因为接下来将为大家分享，希望可以帮助到大家，解决大家的问题，下面就开始吧！
java的一道作业题,麻烦高手做下先谢了
真是麻烦，这里居然不能上传附件。
说明：
1、为了清晰回答你的问题，我共写了五个类。先分别说明一下各自的作用。
baidu.zhidao.anser.model.Account
不用讲了，这个类自然是代表银行帐户的DomainModel了。
baidu.zhidao.answer.util.DatabaseUtil
这个类负责获取数据库连接，以及关闭数据库资源(connection, preparedStatement, ResultSet)，一个非常简单的工具类。
baidu.zhidao.answer.AccountManager
这是个interface，对外部暴露了操作account的方法。可以作为一个facade来使用。
baidu.zhidao.answer.AccountManagerImpl
这个类实现了AccountManager interface，内部操作数据库采用DatabaseUtil，是对account进行实际操作的实现类。
baidu.zhidao.answer.AccountManagerTest
这是一个Junit testcase，具体测试了AccountManager的各个方法，可以参照此类查看AccountManager的具体用法。
2.需要注意的地方
a.我看了你的题目要求，尤其是数据表的schema，猜测你是使用的sql server，也不知对不对？如果对的话，你需要拷贝sql server的jdbc driver，也就是msbase.jar,mssqlserver.jar,msutil.jar这三个jar到你的project library里面。
b.为简便期间，我没有把配置数据库参数以配置文件的方式写在外面，而是在DatabaseUtil里面预先设置的，你可能需要根据你的实际环境更改url，user，password。如果你真要改为配置文件方式也很简单，我这里就不多废话了。
3、这些仅仅是个toy，如果要用在实际项目中还有很多待改进的地方。不过足以应付你的需要了。
局限1：未实现批量增加/删除用户（你的问题里没要求）
局限2：事务无法跨越方法，总是在方法内部完成。其实要实现方法跨事务也不难，只需要将connection用ThreadLocal封装即可。(你的问题里也没要求，嘿嘿)
局限3：未采用数据库连接池，对每个客户端请求都是新开connection，系统开销大，不能应付过多的客户端同时调用。(未实现的理由同上)
局限4：对于数据库操作的异常未做良好的封装，为不影响用户界面的简单调用采用runtimeException抛出。所以在用户界面(web界面或者具体java application界面)中你需要对AccountManager的方法调用显示try/catch并处理异常，以提供给用户格式良好的出错信息。
PS:不要怪我未实现上述所说的局限之处，光写代码、说明加贴上来也花了我一个小时左右的时间，这些地方就留待你自己完善吧。
4、具体使用
你具体使用只要关心AccountManager即可，调用方法如下：
//实例化manager
AccountManager manager= AccountManagerImpl();
//增加或修改帐号
manager.saveAccount(account);
//通过account id查找
Account account= manager.findAccountById(id);
//通过account Name模糊查找
List accounts= manager.findAccountByName(account);
//删除帐号
manager.removeAccount(id);
具体可查看AccountManagerTest的代码
5、代码
------------------------------------------------------
package baidu.zhidao.answer.model;
import java.io.Serializable;
import java.math.BigDecimal;
public class Account implements Serializable
{
private String id;
private String name;
private BigDecimal balance= new BigDecimal(0);
public Account()
{
}
public Account(String id, String name)
{
this.id= id;
this.name= name;
}
public Account(String id, String name, BigDecimal balance)
{
this.id= id;
this.name= name;
this.balance= balance;
}
public BigDecimal getBalance()
{
return balance;
}
public void setBalance(BigDecimal balance)
{
this.balance= balance;
}
public String getId()
{
return id;
}
public void setId(String id)
{
this.id= id;
}
public String getName()
{
return name;
}
public void setName(String name)
{
this.name= name;
}
}
------------------------------------------------------
package baidu.zhidao.answer.util;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class DatabaseUtil
{
private static final String DEFAULT_DRIVER="com.microsoft.jdbc.sqlserver.SQLServerDriver";
private static final String DEFAULT_URL="jdbc:microsoft:sqlserver://yourDatabaseIp:yourDatabasePort;DatabaseName=yourDatabase";
private static final String DEFAULT_USER="yourDatabaseUser";
private static final String DEFAULT_PASSWORD="password";
private DatabaseUtil()
{
}
public static Connection getConnection(String driver, String url,
String user, String password) throws Exception
{
driver=(driver== null|| driver.length()== 0)? DEFAULT_DRIVER: driver;
url=(url== null|| url.length()== 0)? DEFAULT_URL: url;
user=(user== null|| user.length()== 0)? DEFAULT_USER: user;
password=(password== null|| password.length()== 0)? DEFAULT_PASSWORD
: password;
Class.forName(driver).newInstance();
return DriverManager.getConnection(url, user, password);
}
public static Connection getConnection() throws Exception
{
return getConnection(null, null, null, null);
}
public static void close(Connection conn)
{
if(conn!= null)
{
try
{
conn.close();
}
catch(SQLException ignore)
{
ignore.printStackTrace();
}
finally
{
conn= null;
}
}
}
public static void close(Statement stmt)
{
if(stmt!= null)
{
try
{
stmt.close();
}
catch(SQLException ignore)
{
ignore.printStackTrace();
}
finally
{
stmt= null;
}
}
}
public static void close(PreparedStatement pstmt)
{
if(pstmt!= null)
{
try
{
pstmt.close();
}
catch(SQLException ignore)
{
ignore.printStackTrace();
}
finally
{
pstmt= null;
}
}
}
public static void close(ResultSet rs)
{
if(rs!= null)
{
try
{
rs.close();
}
catch(SQLException ignore)
{
ignore.printStackTrace();
}
finally
{
rs= null;
}
}
}
}
------------------------------------------------------
package baidu.zhidao.answer;
import java.util.List;
import baidu.zhidao.answer.model.Account;
public interface AccountManager
{
public abstract Account findAccountById(String accountId);
public abstract List findAccountByName(String accountName);
public abstract void saveAccount(Account account);
public abstract void removeAccount(String id);
public List findAll();
}
------------------------------------------------------
package baidu.zhidao.answer;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import baidu.zhidao.answer.model.Account;
import baidu.zhidao.answer.util.DatabaseUtil;
public class AccountManagerImpl implements AccountManager
{
/*
*(non-Javadoc)
*
*@see baidu.zhidao.answer.AccountManager#findAccountById()
*/
public Account findAccountById(String accountId)
{
if(accountId== null|| accountId.length()== 0)
{
throw new IllegalArgumentException("accountId must be specified.");
}
String querySql="SELECT* FROM Account WHERE accountId=?";
List results= query(querySql, new Object[]{ accountId});
if(results.size()> 0)
{
return(Account) results.get(0);
}
else
{
return null;
}
}
public List findAccountByName(String accountName)
{
if(accountName== null|| accountName.length()== 0)
{
throw new IllegalArgumentException("accountName must be specified.");
}
String querySql="SELECT* FROM Account WHERE accountName LIKE?";
return query(querySql, new Object[]{"%"+ accountName+"%"});
}
public List findAll()
{
return query("SELECT* FROM Account");
}
public void saveAccount(Account account)
{
//TODO need to implements update method
Account alreadyExist= findAccountById(account.getId());
String saveSql;
if(alreadyExist!= null)
{
saveSql="UPDATE Account SET accountName=?, balance=? WHERE accountId=?";
}
else
{
saveSql="INSERT INTO Account(accountId, accountName, balance) VALUES(?,?,?)";
}
Object[] parameters= new Object[3];
if(alreadyExist== null)
{
parameters[0]= account.getId();
parameters[1]= account.getName();
parameters[2]= account.getBalance();
}
else
{
parameters[0]= account.getName();
parameters[1]= account.getBalance();
parameters[2]= account.getId();
}
executeSQL(saveSql, parameters);
}
public void removeAccount(String id)
{
if(id== null|| id.length()== 0)
{
throw new IllegalArgumentException("accountId must be specified.");
}
String deleteSql="DELETE FROM Account WHERE accountId=?";
executeSQL(deleteSql, new Object[]{ id});
}
protected List query(String queryString)
{
return query(queryString, null);
}
protected List query(String queryString, Object[] parameters)
{
List results= new ArrayList();
Connection conn= null;
PreparedStatement psmt= null;
ResultSet rs= null;
try
{
conn= DatabaseUtil.getConnection();
psmt= conn.prepareStatement(queryString);
if(parameters!= null&& parameters.length> 0)
{
for(int i= 0; i< parameters.length; i++)
{
psmt.setObject(i+ 1, parameters[i]);
}
}
rs= psmt.executeQuery();
while(rs.next())
{
Account account= new Account(rs.getString("accountId"), rs
.getString("accountName"), rs.getBigDecimal("balance"));
results.add(account);
}
return results;
}
catch(Exception e)
{
throw new RuntimeException(e);
}
finally
{
DatabaseUtil.close(rs);
DatabaseUtil.close(psmt);
DatabaseUtil.close(conn);
}
}
protected void executeSQL(String sql, Object[] parameters)
{
Connection conn= null;
PreparedStatement psmt= null;
ResultSet rs= null;
try
{
conn= DatabaseUtil.getConnection();
conn.setAutoCommit(false);
psmt= conn.prepareStatement(sql);
for(int i= 0; i< parameters.length; i++)
{
psmt.setObject(i+ 1, parameters[i]);
}
psmt.execute();
conn.commit();
}
catch(Exception e)
{
try
{
conn.rollback();
}
catch(SQLException e1)
{
throw new RuntimeException(e1);
}
throw new RuntimeException(e);
}
finally
{
DatabaseUtil.close(rs);
DatabaseUtil.close(psmt);
DatabaseUtil.close(conn);
}
}
}
------------------------------------------------------
package baidu.zhidao.answer;
import java.math.BigDecimal;
import java.util.List;
import baidu.zhidao.answer.model.Account;
import junit.framework.TestCase;
public class AccountManagerTest extends TestCase
{
private AccountManager manager= new AccountManagerImpl();
private Account a1= new Account("denis","Denis Wang", new BigDecimal("10"));
private Account a2= new Account("denis2","Denis Wang2", new BigDecimal(
"11.22"));
private Account a3= new Account("denis3","Denis Wang3", new BigDecimal(
"14.00"));
private Account a4= new Account("denis4","Denis Wang4", new BigDecimal(
"15.21"));
protected void setUp() throws Exception
{
manager.saveAccount(a1);
manager.saveAccount(a2);
manager.saveAccount(a3);
manager.saveAccount(a4);
}
protected void tearDown() throws Exception
{
manager.removeAccount(a1.getId());
manager.removeAccount(a2.getId());
manager.removeAccount(a3.getId());
manager.removeAccount(a4.getId());
}
public void testFindAccountById()
{
Account denis= manager.findAccountById("denis");
assertEquals(a1.getId(), denis.getId());
assertEquals(a1.getName(), denis.getName());
assertTrue(a1.getBalance().compareTo(denis.getBalance())== 0);
}
public void testFindAccountByName()
{
List results= manager.findAccountByName("Denis");
assertEquals(4, results.size());
}
public void testSaveOrUpdateAccount()
{
// test save new account action
manager.saveAccount(new Account("tempId","tempName", new BigDecimal(
"11.22")));
assertEquals(5, manager.findAll().size());
manager.removeAccount("tempId");
assertEquals(4, manager.findAll().size());
// test update exist account action
Account denis2= manager.findAccountById("denis2");
denis2.setBalance(denis2.getBalance().add(new BigDecimal("2")));
manager.saveAccount(denis2);
Account denis2LoadAgain= manager.findAccountById("denis2");
assertEquals(0, denis2.getBalance().compareTo(denis2LoadAgain.getBalance()));
assertEquals(4, manager.findAll().size());
}
public void testRemoveAccount()
{
manager.saveAccount(new Account("tempId","tempName", new BigDecimal(
"11.22")));
assertEquals(5, manager.findAll().size());
manager.removeAccount("tempId");
assertEquals(4, manager.findAll().size());
}
}
------------------------------------------------------
JAVA 编程创建Account 类模拟银行账户。
我帮你一共写了四个类，一个账户Account类，两个账户类的子类（信用卡账户CreditCardAccount类和借记卡DebitCardAccount类），另外再加上一个演示透支效果测试Test类。代码贴在下面：
/**
*账户类。
*
*@author CodingMouse
*@version 1.0
*/
public abstract class Account{ protected String accountNumber;//账号
protected double overage;//余额
protected double annualInterestRate;//年利率
/**
*参数化构造器方法。
*
*用于开户。
*@param accountNumber预设账号
*@param overage初始余额
*@param annualInterestRate预设年利率
*/
public Account(String accountNumber, double overage, double annualInterestRate){
super();
//设定账号。
this.accountNumber= accountNumber;
//设定初始余额，至少为零。
this.overage= overage>= 0? overage: 0;
//设定年利率，至少为零。
this.annualInterestRate= annualInterestRate>= 0? annualInterestRate: 0;
}
/**
*查询账号。
*@return返回账号。
*/
public String getAccountNumber(){
return this.accountNumber;
}
/**
*设置账号。
*@param accountNumber新账号。
*/
public void setAccountNumber(String accountNumber){
this.accountNumber= accountNumber;
}/**
*查询余额方法。
*@return返回账户余额。
*/
public double getOverage(){
return this.overage;
}/**
*存款方法。
*@param money要存入的金额。
*@return返回true时存款成功，否则存款失败。
*/
public boolean depositMoney(double money){
//如果金额小于零，则不能存款
if(money<= 0)
return false;
//否则将相应的金额累加到账户余额中
this.overage+= money;
return true;
}
/**
*取款方法。
*
*默认不能透支。
*@param money要取出的金额。
*@return返回true时取款成功，否则取款失败。
*/
public boolean drawMoney(double money){
//如果账户余额不足，则不能取款
if(this.overage< money)
return false;
//否则从账户余额中扣除相应的金额
this.overage-= money;
return true;
}/**
*查询年利率。
*@return返回年利率。
*/
public double getAnnualInterestRate(){
return this.annualInterestRate;
}/**
*设置年利率。
*@param annualInterestRate新的年利率。
*/
public void setAnnualInterestRate(double annualInterestRate){
this.annualInterestRate= annualInterestRate;
}
}
--------------------------------------------------
/**
*借记卡账户。
*
*不能透支。
*@author CodingMouse
*@version 1.0
*/
public class DebitCardAccount extends Account{/**
*重写父类构造器。
*@param accountNumber预设账号
*@param overage初始余额
*@param annualInterestRate预设年利率
*/
public DebitCardAccount(String accountNumber, double overage,
double annualInterestRate){
super(accountNumber, overage, annualInterestRate);
}}
-------------------------------------------------
/**
*信用卡账户。
*
*可以透支。
*@author CodingMouse
*@version 1.0
*/
public class CreditCardAccount extends Account{ private double overdraftLimit;//透支限度
/**
*重载构造器。
*
*便于构建可透支的信用卡账户实例。
*@param accountNumber预设账号
*@param overage初始余额
*@param annualInterestRate预设年利率
*@param overdraftLimit透支限度
*/
public CreditCardAccount(String accountNumber, double overage,
double annualInterestRate, double overdraftLimit){
super(accountNumber, overage, annualInterestRate);
this.overdraftLimit= overdraftLimit;
}/**
*查询透支限度的方法。
*@return透支限度金额。
*/
public double getOverdraftLimit(){
return this.overdraftLimit;
}/**
*设置透支限度的方法。
*@param overdraftLimit新的透支限度金额。
*/
public void setOverdraftLimit(double overdraftLimit){
//透支限度必须为零和正数，否则为零。
this.overdraftLimit= overdraftLimit>= 0? overdraftLimit: 0;
}/**
*重写父类构造器。
*@param accountNumber预设账号
*@param overage初始余额
*@param annualInterestRate预设年利率
*/
public CreditCardAccount(String accountNumber, double overage,
double annualInterestRate){
super(accountNumber, overage, annualInterestRate);
}/**
*重写父类取款方法。
*
*将默认不能透支的取款改为可以透支的取款。
*@param money要取出的金额。
*@return返回true时取款成功，否则取款失败。
*/
@Override
public boolean drawMoney(double money){
//如果账户余额+透支限度的总金额仍不足，则不能取款
if(this.overage+ this.overdraftLimit< money)
return false;
//否则从账户余额中扣除相应的金额
this.overage-= money;
return true;
}}
------------------------------------------
/**
*测试账户使用。
*
*@author CodingMouse
*@version 1.0
*/
public class Test{/**
*主程序方法。
*@param args入口参数。
*/
public static void main(String[] args){
//创建一个不能透支的借记卡账户。
System.out.println("------------借记卡账户------------");
DebitCardAccount debitCardAccount= new DebitCardAccount("CHK20100117001", 100, 0.02);
//初始余额有100元，调用并打印取90元和取120元的结果。
System.out.println("取90元的结果："+ debitCardAccount.drawMoney(90));
//重新存入90元
debitCardAccount.depositMoney(90);
System.out.println("取120元的结果："+ debitCardAccount.drawMoney(120));
//创建一个可以透支的信用卡账户。
System.out.println("------------信用卡账户------------");
CreditCardAccount crebitCardAccount= new CreditCardAccount("CHK20100117002", 100, 0.03, 50);
//初始余额有100元，并且透支限度为50元，调用并打印取90元、取120元和取160元的结果。
System.out.println("取90元的结果："+ crebitCardAccount.drawMoney(90));
//重新存入90元
crebitCardAccount.depositMoney(90);
System.out.println("取120元的结果："+ crebitCardAccount.drawMoney(120));
//重新存入120元
crebitCardAccount.depositMoney(120);
System.out.println("取160元的结果："+ crebitCardAccount.drawMoney(160));
}
}
--------------------------------------在我机器上的测试打印结果为：------------借记卡账户------------
取90元的结果：true
取120元的结果：false
------------信用卡账户------------
取90元的结果：true
取120元的结果：true
取160元的结果：false-----------------------------------------这个题目只是简单考查了下封装、继承、多态三大面向对象特性，我提供的代码仅作参考。如果你懒得复制，想要程序源代码文件或有不明白的地方，可以发邮件到我QQ邮箱，我再回给你。
domain是什么意思
domain释义：
n.(知识、活动的)领域，范围，范畴；(尤指旧时个人、国家等所拥有或统治的)领土，领地，势力范围；域；定义域
读音：英 [dəˈmeɪn]美 [doʊˈmeɪn]
复数： domains
单词记忆技巧：dom控制+ ain表物→统治的地方→领土
双语例句：
The kitchen is my wife's domain, and she doesn't like me going into it.
厨房是我妻子的领地,她不愿让我进去。
扩展资料：
近义词
1、sphere
读音：英 [sfɪə(r)]美 [sfɪr]
n.范围；领域；球；球体；天体
vt.形成球体；包围；围绕
The scientist is distinguished in many spheres of knowledge.
这位科学家在许多知识领域中都是杰出的。
2、field
读音：英 [fiːld]美 [fiːld]
n.田地；领域；运动场；场地；田野；JAVA中的范畴
vt.接球；派……上场；顺利处理
vi.担任外场员
adj.田间的；野外的
He has become famous in his own field.
他在自己的领域里已经出名了。
好了，本文到此结束，如果可以帮助到大家，还望关注本站哦！