java模拟账户存储

Ⅰ 利用java线程技术模拟银行中用户的存取款的设计

肯定是可视化程序，不然怎么可以有用户数据，每个用户银行数据。
就跟用银行卡取钱一样，你把你的磁卡插入了，读取你的信息，才可以查询自己信息，取钱
即你用户登陆后就可以查看自己的信息什么的。具体怎么实现 就需要看你用什么技术了

Ⅱ 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邮箱，我再回给你。

Ⅲ 用JAVA编程设计一个银行账户类，其中包括以下内容，并用字符界面模拟存款和取款过程。

import java.util.Scanner;

public class ZH {

private String zh;//账户
private String password;//密码
private String openTime;//开户时间
private String sfz;//身份证号
private double je;//存款金额
public String getZh() {
return zh;
}
public void setZh(String zh) {
this.zh = zh;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getOpenTime() {
return openTime;
}
public void setOpenTime(String openTime) {
this.openTime = openTime;
}
public String getSfz() {
return sfz;
}
public void setSfz(String sfz) {
this.sfz = sfz;
}
public double getJe() {
return je;
}
public void setJe(double je) {
this.je = je;
}

//存款方法
public void ck(double je){
this.je=this.je+je;//存入的金额加上原有的金额
}

//取款方法
public void qk(double je){
if(je>this.je){//取款金额大于余额
System.out.println("存款余额不足");
}else{
this.je=this.je-je;//原有的金额减去取出的金额
}
}
public static void main(String[] args) {
ZH zh = new ZH();//初始化一个账户信息
zh.setJe(10000.0);//向zh账户添加余额
zh.setOpenTime("2013.12.3");//向zh账户添加开发时间
zh.setPassword("123456");//向zh账户添加密码
zh.setSfz("123456789");//向zh账户添加身份证
zh.setZh("zhangsan");//向zh账户添加账号
System.out.println("欢迎光临模拟银行");
Scanner scan = new Scanner(System.in);
int count=0;//记录输入错误的次数
while(1==1){//循环
System.out.println("请输入账号");
String zhm=scan.next();
System.out.println("请输入密码");
String mm=scan.next();
if(zhm.equals(zh.getZh()) && mm.equals(zh.getPassword())){//输入的信息与zh账户信息的密码和账号一致
while(1==1){
System.out.println("当前余额为："+zh.getJe()+"元。请选择操作：1.存款；2.取款；3.退出（只能输入数字）");
String cz=scan.next();
switch (Integer.parseInt(cz)) {
case 1:
System.out.println("请输入存款金额（输入小数）");
double ckje=scan.nextDouble();
zh.ck(ckje);
System.out.println("实施存款："+ckje+"元，当前余额为"+zh.getJe()+"元");
break;
case 2:
System.out.println("请输入取款金额（输入小数）");
double qkje=scan.nextDouble();
zh.qk(qkje);
System.out.println("实施取款："+qkje+"元，当前余额为"+zh.getJe()+"元");
break;
case 3:
break;
default:
System.out.println("暂无此功能");//输入1或者2、3以外的操作
break;
}
if("3".equals(cz)){
break;
}
}
System.out.println("退出操作");
break;
}else{

if(count>=3){
System.out.println("已输入错误三次，账号被锁");
break;//结束循环
}else{
System.out.println("账号或密码错误，请重新输入");
count++;//错误一次count+1
continue;//进入下次循环
}
}
}

}
}

Ⅳ JAVA编写银行账户程序摸拟银行账户的存\取款操作

public class ATM {
public static void main(String[] args) {
// 开立帐号
Account account = new Account();
// 在 account 中存 10,000 元
account.setBalance(10000);
// 检查 account 中的存款
System.out.println("帐户原始金额 : " + account.getBalance() + " 元");

// 小明, 小华与小英一起对 account 进行提款的动作
WithDraw s1 = new WithDraw("小明", account, 5000); // 小明 在 account 中提 5000 元
WithDraw s2 = new WithDraw("小华", account, 2000); // 小华 在 account 中提 2000 元
WithDraw s3 = new WithDraw("小英", account, 4000); // 小英 在 account 中提 4000 元
s1.start();
s2.start();
s3.start();

}
}

//帐户
class Account {
private int balance; // 帐户馀额

public int getBalance() { // 取得帐户馀额
return balance;
}

public void setBalance(int money) { // 设定帐户馀额
balance = money;
}

// 提款方法
public void withDraw(Account account, int withdrawMoney) {

String tName = Thread.currentThread().getName(); // tName=提款人

System.out.println(tName + " 开始提款 ... ");

boolean withDrawStatus; // 提款状态 说明:false=提款失败, true=提款成功

synchronized(ATM.class) {
int tmpBalabce = account.getBalance(); // 取得最新帐户馀额

//用 for-loop 模拟提款时系统所花的时间
for(double delay=0;delay<99999999;delay++) {
// ... 提款进行中 ...
}

tmpBalabce = tmpBalabce - withdrawMoney; // 最新帐户馀额 - 欲提款金额 (用来判断是否馀额足够的依据)

if (tmpBalabce < 0) { // 判断是否馀额足够
withDrawStatus = false;
System.out.println("....................");
System.out.println(" 帐户馀额不足！");
System.out.println("....................");
} else {
withDrawStatus = true;
account.setBalance(tmpBalabce); // 回存account最後剩馀金额
}
}

System.out.println(tName + "的交易单:");
System.out.println("\t欲提款金额：" + withdrawMoney + "元");
System.out.println("\t帐户馀额：" + account.getBalance());

if(withDrawStatus == true){
System.out.println(tName + " 完成提款 ... ");
} else {
System.out.println(tName + " 提款失败 ... ");
}

System.out.println("-------------------------------");

}
}

// 提款类别
class WithDraw extends Thread {
private Account account; // 帐号
private int withdrawMoney; // 欲提款的金额

// tName:执行绪名称, account:Account物件名称, withdrawMoney:欲提款金额
public WithDraw(String tName, Account account, int withdrawMoney) {
setName(tName);
this.account = account;
this.withdrawMoney= withdrawMoney;
}

public void run() {
// 执行提款动作(account:帐号, withdrawMoney 欲提款金额)
account.withDraw(account, withdrawMoney); // 执行提款动作
}
}

Ⅳ java 模拟实现银行自动存取一体机~~求程序指导~~

1.创建数据库test，在test中创建一张表，用户id,用户名，登录密码，用户状态（0为普通用户，大于0则为vip），用户余额（BigDecimal简单点就用int类型）
2.写一个用户的javaBean
3.封装用户的存，取，查询功能（存取，取出用户余额做加减，再把值更新回去）
4.编译用户的登录界面，获取用户输入的id和密码，把这个值会传入所写的查询方法的参量中去，如果id和密码都符合，那么再判断一下用户状态，进入到相应的管理界面
5.编译管理界面，先编译普通用户的管理界面
6.编译vip用户的管理界面可以继承普通用户的管理界面，在面板上再加两个按钮就可以了。
7.至于透支和转账的功能，转账，可以要求vip用户输入所要转账用户的id,并显示所转入用户的相应信息，确认后，把原用户的用户余额取出来减去后，更新到数据库，在输入用户的相应的加数据，这个就可以直接调用之前写的存取方法，最后提示成功后返回原用户的管理界面中

Ⅵ 用Java编写银行账户存取款业务，急求！！

publicclassAccount{
	
	protectedStringaccId;
	protectedStringname;
	protecteddoublemoney;
	
	publicAccount(StringaccId,Stringname){
		(accId,name,0);
	}
	
	publicAccount(StringaccId,Stringname,doublemoney){
		this.accId=accId;
		this.name=name;
		this.money=money;
	}
	
	publicvoidsaveMoney(doublemoney){
		if(money<=0){
			System.out.println("存款金额必须大于0");
		}
		this.money+=money;
		System.out.println("存款成功");
	}
	
	publicdoublegetMoney(doublemoney){
		if(money<=0){
			System.out.println("取款金额必须大于0");
			return0;
		}
		if(this.money<=money){
			System.out.println("余额不足，无法取款");
			return0;
		}
		this.money-=money;
		System.out.println("取款成功");
		returnmoney;
	}
	
	publicdoublegetBalance(){
		returnthis.money;
	}
	
	protecteddoublegetOverdraft(){
		return0;
	}
	
	//实现了equals方法，list比较时才能正确
	@Override
	publicbooleanequals(Objectobj){
		if(obj==null){
			returnfalse;
		}
		if(this==obj){
			returntrue;
		}
		if(objinstanceofAccount){
			returnthis.accId.equals(((Account)obj).accId);
		}
		returnfalse;
	}
	
	@Override
	publicStringtoString(){
		return"账户="+accId+",名字="+name+",余额="+money;
	}
	
}
publicclassBank{

	//Account实现了equals方法，list查找时才能正确
	privateList<Account>usersAccounts;

	publicBank(){
		usersAccounts=newArrayList<Account>();
	}

	publicvoidaddAccount(Accountaccount){
		if(usersAccounts.contains(account)){
			System.out.println("添加失败，不能添加同样的账户");
			return;
		}
		usersAccounts.add(account);
	}

	publicbooleandelAccount(Accountaccount){
		returnusersAccounts.remove(account);
	}

	publicbooleandelAccount(StringaccId){
		returndelAccount(newAccount(accId,null));
	}

	publicbooleanexistAccount(Accountaccount){
		returnusersAccounts.contains(account);
	}

	publicbooleanexistAccount(StringaccId){
		returnexistAccount(newAccount(accId,null));
	}
	
	publicAccountgetAccount(StringaccId){
		returnusersAccounts.get(usersAccounts.indexOf(newAccount(accId,null)));
	}

	publicdoublegetAllMoney(){
		//不考虑是否溢出，只是把所有用户余额相加
		doubleresult=0;
		for(Accountaccount:usersAccounts){
			result+=account.getBalance();
		}
		returnresult;
	}

	publicdoublegetAllOverdraft(){
		//不考虑是否溢出
		doubleresult=0;
		for(Accountaccount:usersAccounts){
			result+=account.getOverdraft();
		}
		returnresult;
	}

	publicintgetAccountNum(){
		returnusersAccounts.size();
	}

	publicintgetCreditAccountNum(){
		intnum=0;
		for(Accountaccount:usersAccounts){
			//instanceof性能没有简单的方法快。
			if(){
				num++;
			}
		}
		returnnum;
	}

	publicintgetSavingAccountNum(){
		intnum=0;
		for(Accountaccount:usersAccounts){
			if(){
				num++;
			}
		}
		returnnum;
	}

	publicList<Account>getAllAccount(){
		returnusersAccounts;
	}
}
{
	
	privatedoubleoverdraft;
	
	publicCreditAccount(StringaccId,Stringname){
		super(accId,name);
		this.overdraft=1000;
	}
	
	publicCreditAccount(StringaccId,Stringname,doublemoney){
		this(accId,name,money,1000);
	}
	
	publicCreditAccount(StringaccId,Stringname,doublemoney,doubleoverdraft){
		super(accId,name,money);
		this.overdraft=overdraft;
	}
	
	@Override
	publicdoublegetMoney(doublemoney){
		if(money<=0){
			System.out.println("取款金额必须大于0");
			return0;
		}
		if(this.money+overdraft<=money){
			System.out.println("余额不足，无法取款");
			return0;
		}
		this.money-=money;
		System.out.println("取款成功");
		returnmoney;
	}
	
	@Override
	publicdoublegetOverdraft(){
		returnoverdraft;
	}
	
	@Override
	publicStringtoString(){
		return"账户="+accId+",名字="+name+",余额="+money+",透支="+overdraft;
	}
}
{

	publicSavingAccount(StringaccId,Stringname){
		super(accId,name);
	}

	publicSavingAccount(StringaccId,Stringname,doublemoney){
		super(accId,name,money);
	}

	@Override
	publicdoublegetMoney(doublemoney){
		returnsuper.getMoney(money);
	}

	@Override
	publicdoublegetOverdraft(){
		returnsuper.getOverdraft();
	}
	
}
publicclassTest{
	
	privatestaticBankbank=newBank();
	publicstaticvoidmain(String[]args){
		Test.genAccount();
		//开户
		Accounta1=newCreditAccount("1","1",200,2000);
		Accounta2=newSavingAccount("2","2",300);
		Accounta3=newSavingAccount("3","3",400);
		Accounta4=newCreditAccount("4","4",500,2000);
		Accounta5=newCreditAccount("4","5",600,2000);//帐号4重
		bank.addAccount(a1);
		bank.addAccount(a2);
		bank.addAccount(a3);
		bank.addAccount(a4);
		bank.addAccount(a5);
		showNowAccount();
		//销户
		bank.delAccount("1");
		bank.delAccount("2");
		showNowAccount();
		//存款
		if(bank.existAccount("3")){
			Accountacc=bank.getAccount("3");
			acc.saveMoney(100);
		}
		showNowAccount();
		//取款
		if(bank.existAccount("3")){
			Accountacc=bank.getAccount("3");
			System.out.println("余额="+acc.getBalance());
			acc.getMoney(100);
			System.out.println("余额="+acc.getBalance());
			acc.getMoney(1000);
			System.out.println("余额="+acc.getBalance());
		}
		if(bank.existAccount("4")){
			Accountacc=bank.getAccount("4");
			System.out.println("余额="+acc.getBalance());
			acc.getMoney(100);
			System.out.println("余额="+acc.getBalance());
			acc.getMoney(1000);
			System.out.println("余额="+acc.getBalance());
			acc.getMoney(10000);
			System.out.println("余额="+acc.getBalance());
		}
		System.out.println(bank.getAccountNum());
		System.out.println(bank.getAllMoney());
		System.out.println(bank.getAllOverdraft());
		System.out.println(bank.getCreditAccountNum());
		System.out.println(bank.getSavingAccountNum());
	}
	
	publicstaticvoidgenAccount(){
		Strings="100000000000000";
		Accounta=null;
		for(inti=1;i<11;i++){
			if((i&2)==0){
				a=newCreditAccount(s+String.valueOf(i),"账户"+String.valueOf(i));
			}else{
				a=newSavingAccount(s+String.valueOf(i),"账户"+String.valueOf(i));
			}
			bank.addAccount(a);
		}
	}
	
	(){
		for(Accountaccount:bank.getAllAccount()){
			System.out.println(account);
		}
	}
}

// 面向对象，看多写多了就会了，简单的随便写的，有错误先不用太纠结。

Ⅶ Java课程设计，模拟银行存取业务，按照这个流程图去做，其实最主要的是求画圈的部分怎么写和它的方法。

请点击输入图片描述

package com.greatwall.business.controller;

import java.math.BigDecimal;

import java.util.Scanner;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

/**

* @author xysddjyt

* @since 2020/6/16 15:06

*/

public class BankTest {

public static void main(String[] args) {

Scanner scan = new Scanner(System.in);

// 余额（单位：分）

Long BALANCE = 10000000L;

// 卡号

String card = "001";

// 密码

String password = "123456";

String inputCard = new String();

String inputPassword = new String();

String quit = new String();

while (true) {

System.out.println(" 欢迎来到网上银行办理存取款业务！");

System.out.println("请输入银行卡号和银行卡密码进行登录！");

while (true) {

System.out.print("请输入银行卡号(按q退出): ");

inputCard = scan.nextLine();

quit = inputCard;

if (inputCard.equals("q")) {

break;

}

if (!inputCard.equals(card)) {

System.out.print("您输入银行卡号不正确，请重新输入 ");

continue;

}

break;

}

if (quit.equals("q")) {

continue;

}

while (true) {

System.out.print("请输入银行卡密码(按q退出): ");

inputPassword = scan.nextLine();

quit = inputPassword;

if (inputPassword.equals("q")) {

break;

}

if (!inputPassword.equals(password)) {

System.out.print("您输入银行卡密码不正确，请重新输入 ");

continue;

}

break;

}

if (quit.equals("q")) {

continue;

}

System.out.print("登录成功，当前登录的账户名:" + inputCard);

String type = "4";

while (!type.equals("0")) {

System.out.print(" 您当前的余额为：" + money(BALANCE) + "元");

System.out.print(" 请选择操作类型。（存款：1；取款：2 ；余额：3；退出：0） ");

type = scan.nextLine();

switch (type) {

case "1": {

System.out.print("请输入您的存款金额(元)：");

String chageNumber = scan.nextLine();

if (!isPositiveInteger(chageNumber)) {

System.out.print("请输入正确的存款金额！");

continue;

}

BALANCE = Long.valueOf(chageNumber) * 100 + BALANCE;

continue;

}

case "2": {

System.out.print("请输入您的取款金额(元)：");

String chageNumber = scan.nextLine();

if (!isPositiveInteger(chageNumber)) {

System.out.print("请输入正确取款金额！");

continue;

}

BALANCE = BALANCE - Long.valueOf(chageNumber) * 100;

continue;

}

case "3": {

System.out.print("您当前的余额为：" + money(BALANCE) + "元 ");

continue;

}

default: {

continue;

}

}

}

}

}

private static boolean isMatch(String regex, String orginal) {

if (orginal == null || orginal.trim().equals("")) {

return false;

}

Pattern pattern = Pattern.compile(regex);

Matcher isNum = pattern.matcher(orginal);

return isNum.matches();

}

// 判断数据是否为正整数

public static boolean isPositiveInteger(String orginal) {

return isMatch("^\+{0,1}[1-9]\d*", orginal);

}

// 分转元，转换为bigDecimal在toString

public static String money(Long money) {

return BigDecimal.valueOf(money).divide(new BigDecimal(100)).toString();

}

}

Ⅷ 银行运行模拟 设计一个Java应用程序，模拟顾客到银行存取款的现象。 谢谢

使用的生产者和消费者模型具有如下特点：

(1)本实验的多个缓冲区不是环形循环的，也不要求按顺序访问。生产者可以把产品放到目前某一个空缓冲区中。

(2)消费者只消费指定生产者的产品。

(3)在测试用例文件中指定了所有的生产和消费的需求，只有当共享缓冲区的数据满足了所有关于它的消费需求后，此共享缓冲区才可以作为空闲空间允许新的生产者使用。

(4)本实验在为生产者分配缓冲区时各生产者间必须互斥，此后各个生产者的具体生产活动可以并发。而消费者之间只有在对同一产品进行消费时才需要互斥，同时它们在消费过程结束时需要判断该消费对象是否已经消费完毕并清除该产品。

Windows 用来实现同步和互斥的实体。在Windows 中，常见的同步对象有：信号量(Semaphore)、

互斥量(Mutex)、临界段(CriticalSection)和事件(Event)等。本程序中用到了前三个。使用这些对象都分

为三个步骤，一是创建或者初始化：接着请求该同步对象，随即进入临界区，这一步对应于互斥量的

上锁；最后释放该同步对象，这对应于互斥量的解锁。这些同步对象在一个线程中创建，在其他线程

中都可以使用，从而实现同步互斥。当然，在进程间使用这些同步对象实现同步的方法是类似的。

1．用锁操作原语实现互斥

为解决进程互斥进人临界区的问题，可为每类临界区设置一把锁，该锁有打开和关闭两种状态，进程执行临界区程序的操作按下列步骤进行：

①关锁。先检查锁的状态，如为关闭状态，则等待其打开；如已打开了，则将其关闭，继续执行步骤②的操作。

②执行临界区程序。

③开锁。将锁打开，退出临界区。

2．信号量及WAIT，SIGNAL操作原语

信号量的初值可以由系统根据资源情况和使用需要来确定。在初始条件下信号量的指针项可以置为0，表示队列为空。信号量在使用过程中它的值是可变的，但只能由WAIT，SIGNAL操作来改变。设信号量为S，对S的WAIT操作记为WAIT（S），对它的SIGNAL操作记为SIGNAL（S）。

WAIT（S）：顺序执行以下两个动作：

①信号量的值减1，即S=S－1；

②如果S≥0，则该进程继续执行；

如果 S（0，则把该进程的状态置为阻塞态，把相应的WAITCB连人该信号量队列的末尾，并放弃处理机，进行等待（直至其它进程在S上执行SIGNAL操作，把它释放出来为止）。

SIGNAL（S）：顺序执行以下两个动作

①S值加 1，即 S=S＋1；

②如果S）0，则该进程继续运行；

如果S（0则释放信号量队列上的第一个PCB（既信号量指针项所指向的PCB）所对应的进程（把阻塞态改为就绪态），执行SIGNAL操作的进程继续运行。

在具体实现时注意，WAIT，SIGNAL操作都应作为一个整体实施，不允许分割或相互穿插执行。也就是说，WAIT，SIGNAL操作各自都好像对应一条指令，需要不间断地做下去，否则会造成混乱。

从物理概念上讲，信号量S）时，S值表示可用资源的数量。执行一次WAIT操作意味着请求分配一个单位资源，因此S值减1；当S<0时，表示已无可用资源，请求者必须等待别的进程释放了该类资源，它才能运行下去。所以它要排队。而执行一次SIGNAL操作意味着释放一个单位资源，因此S值加1；若S（0时，表示有某些进程正在等待该资源，因而要把队列头上的进程唤醒，释放资源的进程总是可以运行下去的。

---------------
/**
* 生产者
*
*/
public class Procer implements Runnable{
private Semaphore mutex,full,empty;
private Buffer buf;
String name;
public Procer(String name,Semaphore mutex,Semaphore full,Semaphore empty,Buffer buf){
this.mutex = mutex;
this.full = full;
this.empty = empty;
this.buf = buf;
this.name = name;
}
public void run(){
while(true){
empty.p();
mutex.p();
System.out.println(name+" inserts a new proct into "+buf.nextEmptyIndex);
buf.nextEmptyIndex = (buf.nextEmptyIndex+1)%buf.size;
mutex.v();
full.v();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}

---------------
/**
* 消费者
*
*/
public class Customer implements Runnable{
private Semaphore mutex,full,empty;
private Buffer buf;
String name;
public Customer(String name,Semaphore mutex,Semaphore full,Semaphore empty,Buffer buf){
this.mutex = mutex;
this.full = full;
this.empty = empty;
this.buf = buf;
this.name = name;
}
public void run(){
while(true){
full.p();
mutex.p();
System.out.println(name+" gets a proct from "+buf.nextFullIndex);
buf.nextFullIndex = (buf.nextFullIndex+1)%buf.size;
mutex.v();
empty.v();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
-------------------------
/**
* 缓冲区
*
*/
public class Buffer{
public Buffer(int size,int nextEmpty,int nextFull){
this.nextEmptyIndex = nextEmpty;
this.nextFullIndex = nextFull;
this.size = size;
}
public int size;
public int nextEmptyIndex;
public int nextFullIndex;
}
-----------------
/**
* 此类用来模拟信号量
*
*/
public class Semaphore{
private int semValue;
public Semaphore(int semValue){
this.semValue = semValue;
}
public synchronized void p(){
semValue--;
if(semValue<0){
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public synchronized void v(){
semValue++;
if(semValue<=0){
this.notify();
}
}
}
------------------------
public class Test extends Thread
{
public static void main(String[] args)
{
Buffer bf=new Buffer(10,0,0);
Semaphore mutex=new Semaphore(1);
Semaphore full=new Semaphore(0);
Semaphore empty=new Semaphore(10);
//new Thread(new Procer("p001",mutex,full,empty,bf)).start();
Procer p=new Procer("p001",mutex,full,empty,bf);
new Thread(new Procer("p002",mutex,full,empty,bf)).start();
new Thread(new Procer("p003",mutex,full,empty,bf)).start();
new Thread(new Procer("p004",mutex,full,empty,bf)).start();
new Thread(new Procer("p005",mutex,full,empty,bf)).start();
try{
sleep(3000);
}
catch(Exception ex)
{
ex.printStackTrace();
}
new Thread(new Customer("c001",mutex,full,empty,bf)).start();
new Thread(new Customer("c002",mutex,full,empty,bf)).start();
new Thread(new Customer("c003",mutex,full,empty,bf)).start();
new Thread(new Customer("c004",mutex,full,empty,bf)).start();
new Thread(new Customer("c005",mutex,full,empty,bf)).start();
}
}
--------------------------------------------

Ⅸ 用JAVA语言编写程序，模拟银行账户功能。要有： 属性：账号、储户姓名、地址、存款余额、最小余额。 方法

很明显你缺少main方法啊。java程序的主入口是main方法。
你应该在main里面写
public static void main(String args[]){
//请选择你需要的服务
1 查询
2 存款
3 取款
//根据选择的服务调用你的方法
}
调用你的业务方法