Unit1-Unit8java入门阶段项目

最新推荐文章于 2021-03-10 15:33:56 发布

金子砸死我吧

最新推荐文章于 2021-03-10 15:33:56 发布

阅读量420

点赞数

分类专栏： java基础

本文链接：https://blog.csdn.net/qq_24373587/article/details/56035690

版权

java基础专栏收录该内容

21 篇文章 0 订阅

订阅专栏

模拟收银系统

一共定义5个类

Boss类

Dao类

Vip类

Index类

DB类

Cashier类

三个模块：

1、管理员

收银员管理

积分管理

2、收银员

结账功能

3、会员

修改个人信息

兑换商品

1、编写入口类

根据不同业务，跳转不同页面（管理员、收银员、会员、会员注册）

2、编写管理员类

管理员登录

初始化管理员账号密码

收银员管理

对收银员数据进行增删改

查询流水

对当天售出流水查询

积分管理

对积分商品的增删改

3、收银员

收银员登录

收银结账

对会员进行积分

查看商品表

4、会员

个人信息管理

修改、查看会员数据

积分商品兑换

对会员积分、积分商品库存进行修改

入口类：

import service.*;
import dao.Dao;
import java.util.Scanner;
class Index
{
	static Scanner sc = new Scanner(System.in);
	public static void main(String[] args){
	//在程序运行时候，需要做一些初始化数据操作
	//初始化商品数据
	Dao.initGoods();
	//初始化兑换商品数据
	Dao.initConGoods();
	//插入收银员帐号
	Dao.insertCashier("aaa","ccc");
	//插入会员帐号
	Dao.register("qqq","www","123");
	Scanner sc = new Scanner(System.in);
		while(true){
			System.out.println("请输入您的操作");
			System.out.println("1：管理员");
			System.out.println("2：收银员");
			System.out.println("3：会员登录");
			System.out.println("4：会员注册");
			System.out.println("5：退出系统");
			int choose = sc.nextInt();
			switch(choose){
				case 1:
					Boss.login();
					break;
				case 2:
					Cashier.login();
					break;
				case 3:
					Vip.login();
					break;
				case 4:
					//Vip.register();
					break;
				case 5:
					System.out.println("-------------漂亮的分隔符---------------");
					return;
				default:
					System.out.println("您输入操作有误，请重新输入");
			}
		}
	}
}

Boss类：

package service;
import java.util.Scanner;
import dao.Dao;
import db.DB;
public class Boss{
		static Scanner sc = new Scanner(System.in);
		public static void login(){
		System.out.println("欢迎老板，请输入账号");
		String  bossZH = sc.next();
		System.out.println("欢迎老板，请输入密码");
		String  bossMM = sc.next();
		//System.out.println("登录成功");
		boolean boo1 =  Dao.bossLogin(bossZH ,bossMM);
		if(boo1){
			System.out.println("登录成功");
			next();
		}else{
			System.out.println("登录失败");
		}
	}
	public static void next(){
		//1:收银员管理， 2：积分平台管理 3：返回上级
		//while(true)语句是将代码块中的代码进行循环，当输入3的时候，执行return语句，结束这个方法。
		while(true){
			System.out.println("请输入您的操作");
			System.out.println("1:收银员管理");
			System.out.println("2：积分兑换平台管理");
			System.out.println("3：返回上级");
			int choose = sc.nextInt();
			switch(choose){
				case 1: 
					//因为代码太多，所以为了不影响阅读，在本类中封装一个方法，实现收银员管理功能。
					syygl();
					break;
				case 2: 
					//因为代码太多，所以为了不影响阅读，在本类中封装一个方法，实现积分兑换商品方法
					operationConGoods();
					break;
				case 3:
					//使用return语句结束这个方法
					System.out.println("-------------漂亮的分隔符---------------");
					return;
				default :
					System.out.println("您输入操作有误，请重新输入");
			}
		}	
	}
//收银员管理方法
public static void syygl(){
		//1：增加收银员
		//2：删除收银员
//3：查看收银员信息
//4：返回上级
//while(true)语句是将代码块中的代码进行循环，当输入4的时候，执行return语句，结束这个方法。
		while(true){
			System.out.println("请输入您的操作");
			System.out.println("1:	增加收银员");
			System.out.println("2：删除收银员");
			System.out.println("3：查看收银员信息");
			System.out.println("4：返回上级");
			int choose = sc.nextInt();
			switch(choose){
				case 1: 
					//增加收银员
					System.out.println("请输入收银员账号");
					String newName = sc.next();
					System.out.println("请输入收银员密码");
					String newPassword= sc.next();
					//调用Dao类中的插入收银员方法，传参帐户名和密码，插入成功返回true,否则返回false
					boolean boo1 = Dao.insertCashier(newName,newPassword);
					if(boo1){
						System.out.println("增加收银员成功");
					}else{
						System.out.println("增加收银员失败");
					}
					break;
				case 2:
					//删除收银员
					System.out.println("请输入被删除的收银员账号");
					String delName = sc.next();
					//调用Dao类中删除收银员方法，传参收银员帐号，返回成功为true、否则为false
					boolean boo2 = Dao.deleteCashier(delName);
					if(boo2){
						System.out.println("删除收银员成功");
					}else{
						System.out.println("删除收银员失败");
					}
					break;
					
				case 3:	
					//返回所有用户名信息，调用Dao类中的查询所有收银员方法，返回数组，包括所有收银员信息
					String[] userArr = Dao.selectCashier();
						System.out.println("查询成功，结果如下");	
					//使用超级for循环将数组中的数据遍历出来			
					for(String str : userArr){
						if(str != null){
							System.out.println("\t"+str);
						}
					}
					break;
				case 4:
					return;
				default :
					System.out.println("您输入操作有误，请重新输入");
			}
		}
	}

	//兑换商品管理功能
	public static void operationConGoods(){
			//使用while(true)语句死循环执行代码，然后使用手动控制方式结束死循环，输入6结束方法，使用return语句。
			while(true){
			System.out.println("请输入您的操作");
			System.out.println("1:	增加兑换商品");
			System.out.println("2：删除兑换商品");
			System.out.println("3：查找单个兑换商品");
			System.out.println("4：修改商品");
			System.out.println("5：查看所有兑换商品");
			System.out.println("6：返回上级");
			int choose = sc.nextInt();
			switch(choose){
				case 1: 
					//从控制台中输入兑换商品的信息，然后调用Dao类中的插入兑换商品方法保存商品
					System.out.println("请输入积分商品的id");
					String  conGoodsId = sc.next();
					System.out.println("请输入积分商品的名称");
					String  conGoodsName = sc.next();
					System.out.println("请输入积分商品的规格");
					String  conGoodsGG = sc.next();
					System.out.println("请输入积分商品的积分单价");
					String  conGoodsPrice = sc.next();
					System.out.println("请输入积分商品的库存");
					String  conGoodsNum = sc.next();
					//调用Dao类中的保存商品方法保存商品，将输入的商品信息作为参数传递给该方法，返回插入的结果，成功为true，失败为false
					boolean insertConGoodsBoo = Dao.insertConGoods(conGoodsId,conGoodsName,conGoodsGG ,conGoodsPrice,conGoodsNum);
					//判断插入兑换商品信息的结果
					if(insertConGoodsBoo){
						System.out.println("添加积分商品成功！");
					}else{
						System.out.println("添加积分商品失败！");
					}
					break;
				case 2:
					//删除兑换商品，根据商品id进行删除，调用Dao类中的删除兑换商品方法，传递商品id作为参数
					System.out.println("请输入积分商品的id");
					String  delConGoodsId = sc.next();
					boolean deleteConGoodsBoo = Dao.deleteConGoods(delConGoodsId);
					//根据返回的结果，打印插入结果
					if(deleteConGoodsBoo){
						System.out.println("删除积分商品成功！");
					}else{
						System.out.println("删除积分商品失败！");
					}
					break;
				case 3:	
					//根据conGoodsId查找商品，调用Dao类中的查找商品方法，返回数组，记录查找到的商品信息
					System.out.println("请输入积分商品的id");
					String  searchConGoodsId = sc.next();
					//0:商品id 1：商品名称 2：规格 3：积分，查找到数据后，如果值不为null（空）说明是有数据的，依次打印即可，否则就是空，提示查询失败
					String[] serachConGoods= Dao.searchConGoods(searchConGoodsId);
					if(serachConGoods != null){
						System.out.println("商品编号"+serachConGoods[0]);
						System.out.println("商品名称"+serachConGoods[1]);
						System.out.println("商品规格"+serachConGoods[2]);
						System.out.println("商品积分单价"+serachConGoods[3]);
						System.out.println("商品库存"+serachConGoods[4]);
					}else{
						System.out.println("查询商品失败！");
					}
					break;
				case 4:
					//修改商品，调用dao类中的修改兑换商品方法，传递被修改的商品id，然后依次传入修改的商品信息，返回boolean类型的结果，成功为true，失败为false
					System.out.println("请输入被修改的积分商品的id");
					String  oldConGoodsId = sc.next();
					System.out.println("请输入积分商品的id");
					String  newConGoodsId = sc.next();
					System.out.println("请输入积分商品的名称");
					String  newConGoodsName = sc.next();
					System.out.println("请输入积分商品的规格");
					String  newConGoodsGG = sc.next();
					System.out.println("请输入积分商品的积分单价");
					String  newConGoodsPrice = sc.next();
					System.out.println("请输入积分商品的库存");
					String  newConGoodsNum = sc.next();
					/*参数：
						1、旧的商品id
						2、新的商品id
						3、新的商品名
						4、新的商品规格
						5、新的商品积分单价
						将这些参数传递给重置方法中，返回结果
					*/
					boolean resetConGoodsBoo = Dao.resetConGoods(oldConGoodsId, newConGoodsId,newConGoodsName,newConGoodsGG,newConGoodsPrice,newConGoodsNum);
					//根据结果打印不同信息
					if(resetConGoodsBoo){
						System.out.println("重置积分商品成功！");
					}else{
						System.out.println("重置积分商品失败！");
					}
					break;
				case 5:
					//查看所有兑换商品，调用Dao中的查询所有商品方法，返回二维数组，记录所有的商品信息
					String[][] result = Dao.showConGoods();
					System.out.println("商品编号\t商品名称\t\t\t商品规格\t积分单价\t库存");
					//使用for循环遍历打印返回出来的数据即可。
					for(int i = 0 ; i <DB.conGoodsTag ;i++){
						//进行非空判断，如果有空值，那么就忽略掉下面的代码,重新开始循环
						if(result[0][i]==null){
							continue;
}	
						System.out.println(result[0][i]+"     \t"+result[1][i].substring(0,2)+"...\t\t\t"+result[2][i]+"\t"+result[3][i]+"\t"+result[4][i]);
					}
					break;
				case 6:
					return;
				default :
					System.out.println("您输入操作有误，请重新输入");
			}
		}
	
	}

}

收银员类：

package service;
import dao.Dao;
import java.util.Scanner;

public class Cashier{
	static Scanner sc = new Scanner(System.in);
//1、登录
	public static void login(){
		System.out.println("欢迎收银员，请输入账号");
		String  casZH = sc.next();
		System.out.println("欢迎收银员，请输入密码");
		String  casMM = sc.next();
//调用Dao中收银员登录方法，传参 收银员帐号、收银员密码
		boolean boo = Dao.casLogin(casZH,casMM);
		if(boo){
			System.out.println("登录成功");
			//如果登录成功后，就执行下一步操作，因为这里代码较多，所以封装到本类中的next()方法
			next();
		}else{
			System.out.println("登录失败");
		}
	}
	//执行的下一步方法，收银员的主要功能在next()方法中实现
	public static void next(){
		//1:收银结账 ，记录会员消费信息 2:增加会员 3：返回上级，使用while（true）死循环执行代码，其中使用手动输入3 执行return语句结束
		while(true){
			System.out.println("请输入您的操作");
			System.out.println("1:收银结账");
			System.out.println("2：查看商品表");
			System.out.println("3：返回上级");
			int choose = sc.nextInt();
			switch(choose){
				case 1: 
					//收银结账，同样因为代码较多缘故，为了便于阅读，将代码封装到本类一个方法中，进行收银管理
					syjz();
					break;
				case 2:		
					//查看商品表，同样因为代码较多缘故，为了便于阅读，将代码封装到本类一个方法中，进行察看商品表操作
					show();
					System.out.println("-------------漂亮的分隔符---------------");
					break;
				case 3:
					System.out.println("-------------漂亮的分隔符---------------");
					return;
				default :
					System.out.println("您输入操作有误，请重新输入");
			}
		}
	}
		//察看所有商品
	public static void show(){
		//调用Dao中的察看所有商品方法，返回所有商品数据
		String[][] goodsArr = Dao.showGoods();
		System.out.println("编号\t\t\t\t商品名\t\t规格\t\t单价");
		//使用for循环将所有商品数据打印出来
		for(int i = 0 ;i <goodsArr[0].length;i++){
			if(goodsArr[0][i] !=null){
				System.out.println(goodsArr[0][i] +"\t\t"+goodsArr[1][i].substring(0,10)+"...\t\t"+goodsArr[2][i]+"\t\t"+goodsArr[3][i] );
			}
		}
	}
	//收银结账
	public static void syjz(){
		//先显示一下所有商品信息
		show();
		//是否继续输入标记，在下面的while循环中，当决定不循环了，就将该标记改为false就可以跳出循环
		boolean tag = true;
		//定义二维数组，长度为2的数组中，每个成员是长度为100的数组，记录本次购买的商品编号和购买数量,info[0][100]是存储编号，info[1][100]是存储数量
		String[][] info = new String[2][100];
		//定义一个标记，表示要往购买商品的数组中添加信息时，应该从哪里添加，每次添加商品后，infoTag++操作就可以保证添加的数据不会被覆盖
		int infoTag = 0;
		while(tag){
			//	１、输入要购买的商品编号
			System.out.println("请输入商品编号");
			String goodsId = sc.next();
			//	２、根据商品id查询商品信息
			String[] result = Dao.selectById(goodsId);

			//如果输入的商品编号不存在，返回null
			if(result ==null){
				System.out.println("没有该商品，请重新输入");
				continue;
			}
			//到这里说明商品是存在的，返回的商品信息中：result[0]商品编号、result[1]商品名称、result[2]规格、result[3]单价
			System.out.println("编号          商品名                              规格          单价");
			//	打印商品信息
			System.out.println(result[0]+"          "+result[1].substring(0,5)+"                    "+result[2]+"          "+result[3]);
			//３、	输入购买数量
			System.out.println("请输入购买数量：");
			int goodsNum = sc.nextInt();
			//4、打印小计
			System.out.println("编号          商品名          规格          单价          数量          小计");
			/*因为查询出的结果都是string类型，里面存的
			   单价也是string类型，所以需要将这个String
			   类型转为double类型才可进行运算，这里
			   使用一个new Double()方式，将String类型
			   的数字转为double类型。
			*/
			double d = new Double(result[3]);
			//每次输入一个购买的商品后，打印小计的结果
			System.out.println(result[0]+"          "+result[1].substring(0,5)+"          "+result[2]+"          "+result[3]+"          "+goodsNum +"          "+goodsNum * d);
			//记录商品编号和数量，供结账的时候使用
			info[0][infoTag] = goodsId;
			//因为goodsNum是int类型，info数组是String
			//类型，所以存储的时候，需要转为String类型
			info[1][infoTag] = goodsNum+"";
			//使用infoTag标签记录下次新增商品的位置
			infoTag++;
			/*
			５、循环输入所有商品信息,是否还有商品，
			没有就输入0进行结账，在外层嵌套一个while(tag)死
			循环，通过手动输入的方式结束该循环,一旦输入0，tag就会
			改为false，那么外层while循环也就会被结束了
			*/
			System.out.println("是否继续输入,1:继续输入，0：结账");
			int temp = sc.nextInt();//1:继续输入 0：结账
			//判断输入的信息是否为0，如果为0，更改tag标记，结束循环
			if(temp == 0){
				tag = false;
			}
		}
		//当上面录入商品数据信息的循环操作结束后，就可以结账：打印购物小票
		//先获取商品信息和数量
		System.out.println("编号          商品名          规格          单价          数量          小计");
		//定义总价，double类型
		double total = 0;
		//使用for循环遍历刚才在上面录入的所有商品信息，进行统计
		for(int i = 0 ; i<infoTag ; i++){
			//info[0][i] 商品编号，通过商品编号找商品
			String[] result = Dao.selectById(info[0][i]);
			//找到商品单价，转为double类型，使用new Double()方式转换一下数据，将字符串转为double类型
			double d = new Double(result[3]);
			//购买数量也需要转为int类型，使用new Integer()方式转换
			int x = new Integer(info[1][i] );
			//计算小计的价格
			double xiaoji =x * d;
			//同时把这次小计的价格添加到总价里
			 total += xiaoji;
			 //打印小计的结果
			System.out.println(result[0]+"          "+result[1].substring(0,5)+"...       "+result[2]+"          "+result[3]+"          "+info[1][i]+"          "+xiaoji);
		}
		//打印总共的消费
		System.out.println("一共消费了："+total);
		//计算出总价后，询问顾客是否具有会员卡.
		System.out.println("是否有会员卡 0：没有 1：有");
		int isVip = sc.nextInt();
		//顾客没有会员卡，就直接结束方法
		//有会员卡，就不可能执行下面if语句中的代码
		if(isVip == 0){
			System.out.println("感谢惠顾，欢迎下次再来！");
			return;
		}
		//顾客不可能无数次输入账户，那么我们定义个cishu，就是说当你输入的次数超过3次了，那就结账，下次结账再试
		int cishu = 0;
		while(true){
			//有会员卡就出示会员卡
			System.out.println("请输入您的会员账号");
			String vipUser = sc.next();
			//验证输入账号是否存在
			boolean boo2 = Dao.vipSearch(vipUser);
			//如果存在，就进行积分操作，否则就提示会员帐号输入错误
			if(boo2){
				//调用Dao.vipJifen方法进行积分操作
				Dao.vipJifen(vipUser,(int)total);
				System.out.println("感谢惠顾，欢迎下次光临");
				return;
			}else{
				//如果输入的次数太多了，那就强制结束购物
				if(cishu >2){
					System.out.println("输入次数超过限制，请明天再试");
					System.out.println("感谢惠顾，欢迎下次光临");
					return;
				}
				//输入错误，提示用户重新输入，并且记录下这次操作
				System.out.println("该账号不存在，请重新输入");
				cishu++;
			}
		}
	
	}

}

会员类：

package service;
import dao.Dao;
import db.DB;
import java.util.Scanner;
public class Vip{
	static Scanner sc = new Scanner(System.in);
//注册会员
	public static void register(){
		System.out.println("请输入账号");
		String user = sc.next();
		System.out.println("请输入密码");
		String password = sc.next();
		System.out.println("请输入手机号");
		String phoneNum = sc.next();
		//调用dao中的注册方法，传递会员帐号、密码、手机号
		boolean boo = Dao.register(user,password,phoneNum);
		if(boo){
			System.out.println("注册成功");
		}else{
			System.out.println("注册失败");		
		}
	}
//外部定义userId属性，目的是当登录后，将他的值保存在外面，在别的方法中需要用到的时候就可以使用这个值了
public static String userId = null;
public static void login(){
		System.out.println("欢迎会员，请输入账号");
		String user = sc.next();
		System.out.println("欢迎会员，请输入密码");
		String password = sc.next();
		//0代表等级，1代表成长值
		String[] result = Dao.vipLogin(user,password);
		//如果登录失败，则会返回null值，这里使用if语句判断是否为null，如果为null说明登录失败。
		if(result == null){
			System.out.println("登录失败");
			return ;
		}
		System.out.println("登录成功，欢饮您，尊贵的："+result[0]+"您的当前成长值为："+result[1]);
		userId = user;
		next();
	}

	//执行会员登录后的功能
	static void next(){
	//使用while(true)循环语句循环代码，使用手动控制方式结束方法，输入3，执行return语句结束方法，方法都结束了，循环语句自然也跳出了
	while(true){
			System.out.println("请输入操作");		
			System.out.println("0：查看个人信息");		
			System.out.println("1：兑换商品");		
			System.out.println("2：修改密码");				
			System.out.println("3：返回上级");	
			int choose = sc.nextInt();
			switch(choose){
				case 0:
					//察看个人信息，调用Dao类中察看vip信息方法，返回数组信息，0：帐号 1：密码 2：手机号 3：级别 4：积分 5：成长值，查找出来后依次打印即可。
					//System.out.println("查看个人信息");		
					String[] info = Dao.searchVipInfo(userId);
					System.out.println("       个人信息");
					System.out.println("账号：" + info[0]);
					System.out.println("密码"+ info[1]);
					System.out.println("手机号："+ info[2]);
					System.out.println("级别："+ info[3]);
					System.out.println("积分："+ info[4]);
					System.out.println("成长值："+ info[5]);
					break;
				case 1:
					//兑换商品
					System.out.println("兑换商品");		
					//这里因为代码太多了，所以在本类中编写方法，将代码写到方法中，这里调用即可。便于代码的阅读。
					conGoods();
					break;
				case 2:
					//修改密码操作，从控制台中获取输入的信息，然后调用Dao类中的修改密码方法，将帐号和新密码传递进入即可
					System.out.println("请输入新密码");
					String password = sc.next();
					//调用修改密码方法，传参新的密码，返回修改的结果，是否修改成功，成功为true，失败为false
					boolean boo1 = Dao.vipResetPassword(userId,password);
					if(boo1){
						System.out.println("重置密码成功");					
					}else{
						System.out.println("重置密码失败");		
					}
					
					break;
				case 3:
					//结束方法
					System.out.println("--------------漂亮的分隔符-----------------");		
					return;
				default:
						System.out.println("输入操作错误，请重新输入");		
			}
		}
	} 
		//这个方法代码有点多，这是执行会员兑换商品功能。
		public static void conGoods(){
			//0：查询所有兑换商品
			//1:兑换商品
			//2:返回上级
			System.out.println("请输入操作");		
			System.out.println("0：查询所有兑换商品");		
			System.out.println("1：兑换商品");		
			System.out.println("2：返回上级");		
			int choose = sc.nextInt();
			switch(choose){
   					//查询所有商品，调用dao类中显示兑换商品的信息，返回所有兑换商品的数据。
					case 0:
						//查询到了商品，，返回二维数组类型数据
						String[][] result = Dao.showConGoods();
						//使用循环语句，将这些数据进行打印出来
						System.out.println("商品编号\t商品名称\t\t\t商品规格\t积分单价\t库存");
						for(int i = 0 ; i < DB.conGoodsTag ;i++){
						//进行非空判断，如果有空值，那么就忽略掉下面的代码,重新开始循环
						if(result[0][i]==null){
							continue;
						}	
						System.out.println(result[0][i]+"\t\t"+result[1][i].substring(0,2)+"...\t\t\t\t"+result[2][i]+"\t\t"+result[3][i]+"\t\t"+result[4][i]);
						}
						break;
					case 1:
						/*兑换商品
						1、查询积分
						2、输入兑换商品编号
						3、调用dao的兑换方法conGoods()
						*/
						//首先需要调用dao类中的查找会员信息方法，察看一下会员积分，并且打印出来 返回数组中：0：帐号 1：密码 2：手机号 3：级别 4：积分 5：成长值
						String[] resultVipInfo = Dao.searchVipInfo(userId);
						System.out.println("尊贵的"+resultVipInfo[3]+":"+userId+"您的当前积分为"+resultVipInfo[4]+"分！");
						System.out.println("请输入商品编号！");
						String conGoodsId = sc.next();
						System.out.println("请输入兑换数量");
						int conGoodsNum = sc.nextInt();
						//调用兑换商品方法 将上面从控制台数据的数据 vip帐号、 商品编号、兑换数量传递给Dao类中的兑换方法，返回兑换结果String类型数据
						String conResult = Dao.conGoods(userId,conGoodsId,conGoodsNum);
						System.out.println(conResult);
						break;
					case 2:
						System.out.println("————————————漂亮的分隔符——————————————");
						return;
					default:
						System.out.println("输入操作错误，请重新输入");		
			}
		}
	

}

操作数据类：

package dao;
import db.DB;
public class Dao{
	//这里先做一些初始化数据操作，如商品信息和兑换商品信息，便于日后的使用
		//初始化兑换商品数据
			//商品初始化操作
		public static void initConGoods(){
			//给商品信息里面添加数据 DB.conGoods[4][10];
			//0编号、1商品名、2规格、3兑换积分
			DB.conGoods[0][0] = "001";
			DB.conGoods[0][1] = "002";
			DB.conGoods[0][2] = "003";
			DB.conGoods[0][3] = "004";
			DB.conGoods[0][4] = "005";
			DB.conGoods[0][5] = "006";
			DB.conGoods[0][6] = "007";
			//商品名称
			DB.conGoods[1][0] = "营养快线 550ml";
			DB.conGoods[1][1] = "安慕希 150ml";
			DB.conGoods[1][2] = "特仑苏 不是每一滴奶都叫特仑苏 300ml";
			DB.conGoods[1][3] = "银鹭花生牛奶 450ml";
			DB.conGoods[1][4] = "蒙牛金典纯奶 送长辈 300ml*12瓶";
			DB.conGoods[1][5] = "旺仔O泡果奶 200ml";
			DB.conGoods[1][6] = "六个核桃 经常用脑多喝六个核桃 200ml";
			//规格
			DB.conGoods[2][0] = "瓶";
			DB.conGoods[2][1] = "瓶";
			DB.conGoods[2][2] = "瓶";
			DB.conGoods[2][3] = "瓶";
			DB.conGoods[2][4] = "箱";
			DB.conGoods[2][5] = "瓶";
			DB.conGoods[2][6] = "瓶";
			//积分单价  1块钱 = 1积分=2分钱
			DB.conGoods[3][0] = "250";
			DB.conGoods[3][1] = "300";
			DB.conGoods[3][2] = "200";
			DB.conGoods[3][3] = "200";
			DB.conGoods[3][4] = "2500";
			DB.conGoods[3][5] = "300";
			DB.conGoods[3][6] = "250";
			//库存
			DB.conGoods[4][0] = "11";
			DB.conGoods[4][1] = "31";
			DB.conGoods[4][2] = "20";
			DB.conGoods[4][3] = "5";
			DB.conGoods[4][4] = "11";
			DB.conGoods[4][5] = "8";
			DB.conGoods[4][6] = "9";
			//初始化一下标记
			DB.conGoodsTag = 7;
		}
		//商品初始化操作
		public static void initGoods(){
			//给商品信息里面添加数据 DB.goods[4][10];
			//0编号、1商品名、2规格、3单价
			DB.goods[0][0] = "001";
			DB.goods[0][1] = "002";
			DB.goods[0][2] = "003";
			DB.goods[0][3] = "004";
			DB.goods[0][4] = "005";
			DB.goods[0][5] = "006";
			DB.goods[0][6] = "007";
			//指定商品名
			DB.goods[1][0] = "五粮液黄金酒 400ml*2";
			DB.goods[1][1] = "三只松鼠 大礼包 1300g装";
			DB.goods[1][2] = "卫龙 辣条（土豪专供）100g装";
			DB.goods[1][3] = "盼盼法式小面包 1500g装";
			DB.goods[1][4] = "旺旺大礼包 1000g 装";
			DB.goods[1][5] = "统一老坛酸菜面  120g";
			DB.goods[1][6] = "喜之郎果冻 100g";

			//规格
			DB.goods[2][0] = "件";
			DB.goods[2][1] = "件";
			DB.goods[2][2] = "袋";
			DB.goods[2][3] = "件";
			DB.goods[2][4] = "袋";
			DB.goods[2][5] = "桶";
			DB.goods[2][6] = "杯";
			//单价
			DB.goods[3][0] = "150";
			DB.goods[3][1] = "79";
			DB.goods[3][2] = "88";
			DB.goods[3][3] = "45";
			DB.goods[3][4] = "50";
			DB.goods[3][5] = "4";
			DB.goods[3][6] = "5";
			//初始化一下标记，当再次添加商品，就会从角标为DB.goodTag的位置开始添加，防止数据覆盖
			DB.goodsTag+=7;
		}
		//管理员登录
	//管理员登录，成功返回true，失败返回false
	public static boolean bossLogin(String user , String password){
		if(user.equals(DB.bossInfo[0])&&password.equals(DB.bossInfo[1])){
			return true;
		}
		return false;
	}


//以上boss类中对收银员的操作涉及到Dao类中的如下方法
//增加收银员
	public static boolean insertCashier(String name , String password){
		//存储账号
		DB.cashierInfo[0][DB.tag] = name;
		//存储密码
		DB.cashierInfo[1][DB.tag] = password;
		DB.tag++;
		return true;
		//完善重命名操作
	}
	//删除收银员，通过收银员帐号找到存储的位置，然后将这个内容清空就可以了。
	public static boolean deleteCashier(String name ){
		for(int i = 0;i < DB.cashierInfo[0].length;i++){
			if(name.equals(DB.cashierInfo[0][i]) ){
			//将账号密码清空
				DB.cashierInfo[0][i] = null;
				DB.cashierInfo[1][i] = null;
				return true;
			}
		}
				return false;
	}
	//查看收银员，直接返回保存收银员信息的那个数组，就可以了
	public static String[] selectCashier(){
		return DB.cashierInfo[0];
	}

	
	//积分商品兑换管理：
	//增加兑换商品
	public static boolean insertConGoods(String goodsId,String goodsName,String goodsGG ,String conGoodsPrice,String num){
		//遍历所有的编号，判断编号是否重复
		for(int i = 0 ; i <DB.conGoodsTag ;i++){
			//如果有存在兑换商品的id与传入的商品id相等，说明重复了，那么就返回false代表插入失败。使用.equals()方法来比较字符串是否相等，返回boolean类型。
			if(DB.conGoods[0][i].equals(goodsId)){
				return false;
			}
		}
		//如果走到这一步，说明id没有被占用，就添加商品
		DB.conGoods[0][DB.conGoodsTag] = goodsId;
		DB.conGoods[1][DB.conGoodsTag] = goodsName;
		DB.conGoods[2][DB.conGoodsTag] = goodsGG;
		DB.conGoods[3][DB.conGoodsTag] = conGoodsPrice;
		DB.conGoods[4][DB.conGoodsTag] = num;
		//这里使用tag标记，功能就是防止下一次插入的数据，将本次插入数据覆盖，将该[DB.conGoodsTag]数据进行自增，那么下一次插入就会从下一个角标开始。
		DB.conGoodsTag++;
		return true;
	}
	//删除兑换商品，根据兑换商品的id删除
	public static boolean deleteConGoods(String goodId){
		//先用for循环遍历所有商品id，找到要被删除的商品
		for(int i = 0 ; i <DB.conGoodsTag ;i++){
			//如果这一次循环到的数据与传入方法中欲被删除的id一样，那么说明找到了，将该商品的其他属性置空，这个商品就不存在了。
			if(DB.conGoods[0][i].equals(goodId)){
				DB.conGoods[0][i] = null;
				DB.conGoods[1][i] = null;
				DB.conGoods[2][i] = null;
				DB.conGoods[3][i] = null;
				DB.conGoods[4][i] = null;
				//清空完数据后，使用return结束方法，返回true
				return true; 
			}
		}
		//走到这一步，就说明没有找到要被删除的商品，那就返回false表示删除失败。
		return false;
	}
	//查找单个兑换商品功能，传入参数：兑换商品id
	public static String[] searchConGoods(String goodsId){
		//定义数组，0：编号1：商品名 2：规格 3：单价 4:库存
		String[] result = new String[5];
		//遍历所有商品，查找欲被修改的商品 
		for(int i = 0 ; i <DB.conGoodsTag ;i++){
			//判断该商品是否存在，如果存在，则将这个商品的所有信息放在之前定义好的数组里面
			if(DB.conGoods[0][i].equals(goodsId)){
				result[0] = DB.conGoods[0][i];
				result[1] = DB.conGoods[1][i];
				result[2] = DB.conGoods[2][i];
				result[3] = DB.conGoods[3][i];
				result[4] = DB.conGoods[4][i];
				//放好以后，使用return语句结束方法，返回result结果
				return result;
			}
		}
		//走到这一步，说明没有找到这个商品，那么就返回null代表没有找到
		return null;
	}
	//修改商品，传入欲被修改兑换商品id，以及被修改后的数据
	public static boolean resetConGoods(String oldGoodsId,String newGoodsId,String goodsName,String goodsGG ,String conGoodsPrice,String num){
		//使用for循环遍历所有商品id，判断该商品是否存在
		for(int i = 0 ; i <DB.conGoodsTag ;i++){
			//如果这个商品存在，那么就将对应的数据进行赋值操作，将新的数据赋值给数组中的成员，就完成了数据的更改。
			if(DB.conGoods[0][i].equals(oldGoodsId)){
				DB.conGoods[0][i] = newGoodsId;
				DB.conGoods[1][i] =goodsName;
				DB.conGoods[2][i] =goodsGG;
				DB.conGoods[3][i] =conGoodsPrice;
				DB.conGoods[4][i] =num;
				//赋值完成后，return结束方法，返回true
				return true;
			}
		}
		//走到这一步，说明没找到商品，就是说赋值失败了，返回false
		return false;
	}
	//查看所有兑换商品
		public static String[][] showConGoods(){
			//直接返回所有兑换商品数据即可
			return DB.conGoods;
		}
	//Dao中编写注册会员方法，其中级别默认为空、积分、成长值默认为0
	public static boolean register(String user,String password,String phoneNum){
		DB.vip[0][DB.vipTag] = user;
		DB.vip[1][DB.vipTag] = password;
		DB.vip[2][DB.vipTag] = phoneNum;
		DB.vip[3][DB.vipTag] = "";
		DB.vip[4][DB.vipTag] = "0";
		DB.vip[5][DB.vipTag] = "0";
		//这里vipTag++，因为存储数据是以该标记为角标，只要每次新增会员后将该数据进行自增，则下一次新增会员，就不会将这次添加的数据覆盖
		DB.vipTag++;
		return true;
	}
//登录会员 返回值 String[0]代表会员级别，String[1]代表成长值
	public static  String[] vipLogin(String user, String password){
		for(int i = 0 ; i < DB.vipTag ;i++){
				if(DB.vip[0][i].equals(user)){
					//找到用户了，验证密码
					if(DB.vip[1][i].equals(password)){
						String[] str = new String[2];
						str[0] = DB.vip[3][i];
						str[1] = DB.vip[5][i];
						//返回数据，会员级别+成长值
						return str;
					}
				}
			}
		//当走到这一步就说明没有找到会员，返回null代表登录失败
			return null;
	}
//编写Dao类中针对兑换积分商品功能的代码

	/*查询会员个人信息，返回结果，参数user：帐号名
		0：账号
		1：密码
		2：手机号
		3：级别
		4：积分
		5：成长值
	*/
	public static String[] searchVipInfo(String user){
			//使用for循环遍历所有的用户
			for(int i = 0 ; i < DB.vipTag ;i++){
			//判断当前帐号名与传递进来的帐号名是否相等， 
			if(DB.vip[0][i].equals(user)){
//如果相当说明找到了要找的会员信息，将这些信息保存在一个一维数组中返回。
				String[] info = new String[6];
				info[0] = DB.vip[0][i];
				info[1] = DB.vip[1][i];
				info[2] = DB.vip[2][i];
				info[3] = DB.vip[3][i];
				info[4] = DB.vip[4][i];
				info[5] = DB.vip[5][i];
				return info;
			}	
		}
		//当走到这一步就说明，没有找到用户，返回null说明查找失败
		return null;		
	}
	//修改会员密码
	public static  boolean  vipResetPassword(String user, String password){
		for(int i = 0 ; i < DB.vipTag ;i++){
				if(DB.vip[0][i].equals(user)){
					//找到用户了，修改密码，返回成功true
					DB.vip[1][i] = password;
					//返回成功
					return true;
				}
		}
		//走到这一步说明没找到会员名，返回失败
		return false;
	}
	//兑换积分商品功能，传参 会员帐号、兑换商品的id、兑换商品数量
	//conResult:0:兑换结果，1：剩余积分或者差多少积分
	public static String conGoods(String vipId,String conGoodsId,int conGoodsNum){
	/*步骤：
		1、根据id找到会员
		2、找到该会员的积分
		3、计算兑换商品的需要的积分
		4、对商品进行减少、对会员积分进行减少
		5、返回信息和积分
	*/
		//定义返回的结果
		String result = new String();
		//首先找到会员的信息
		String[] vipInfo = searchVipInfo(vipId);  
		//根据兑换商品id找到商品信息 
		String[] conGoods = searchConGoods(conGoodsId);
		//判断商品库存是否大于或者等于兑换数量，使用new Integer(String数据)方式将商品库存字符串信息转为int类型数字，可以进行运算
		int kucun = new Integer(conGoods[4]);
		//如果传入的兑换数量大于库存，那肯定不能兑换，返回库存不足信息
		if(conGoodsNum > kucun){
			result = "库存不足，请重新输入";
			return result;
		}
			
		//计算总计需要的积分，使用new Integer(String数据)方式将商品库存字符串信息转为int类型数字，可以进行运算
		//总供需要的积分 = 兑换商品所需的积分 * 兑换的数量
		int total = new Integer(conGoods[3])*conGoodsNum;
		//4、判断，会员积分是否足够，不够返回信息
		int vipJifen = new Integer(vipInfo[4]);
		int chazhi = total - vipJifen;
		if(chazhi>0){
			//会员积分不足
			result = "会员积分不够还差："+(total-vipJifen);
			return result;
		}
		//5、对商品库存进行减少，对会员积分进行减少，因为代码较多，为了方便阅读，将代码封装到本类中的一个方法中
		String jfye =subVipJifen(vipId,chazhi);
		String spkc =subConGoods(conGoodsId,conGoodsNum);
		
		//6、返回兑换商品的信息，和会员剩余积分，因为代码较多，为了方便阅读，将代码封装到本类中的一个方法中
		result = "兑换成功,剩余库存 "+spkc +"剩余积分为："+jfye;
		return result;
	}
	//对会员积分进行减少，返回剩余积分，传参会员id和要减少的积分
	public static String subVipJifen(String vipId,int jifen){
		//使用for循环遍历所有会员信息，找到会员，将他的积分属性更改就可以了
		for(int i = 0 ; i < DB.vipTag ;i ++){
			if(DB.vip[0][i].equals(vipId)){
				//这里使用new Integer()的方式将字符串数据转为int类型数字
				int jiuJifen = new Integer(DB.vip[4][i]);
				//找到该会员了，将他的积分减少
				int xinJifen = jiuJifen - jifen;
				//将减少的积分赋值给这个会员的积分属性，完成扣分操作
				DB.vip[4][i] = xinJifen+"";
				//返回剩余积分
				return 	DB.vip[4][i] ;
			}
		}
		//如果找不到该会员，就返回空字符串
		return "";
	}
	//对积分商品进行减少，返回剩余库存
	public static String subConGoods(String conGoodsId,int num){
		for(int i = 0 ; i < DB.conGoodsTag ;i ++){
			if(DB.conGoods[0][i].equals(conGoodsId)){
				//找到商品了，修改他的库存，这里使用new Integer()的方式将字符串数据转为int类型数字
				int jiukucun = new Integer(DB.conGoods[4][i]);
				//生成新的库存
				int xinkucun = jiukucun - num;
				//将减少后的新的库存，重新赋值给该商品的库存数据，就完成了修改库存操作
				DB.conGoods[4][i] = xinkucun+"";
				return DB.conGoods[4][i] ;
			}
		}	
		//如果找不到商品，就返回空字符串
		return "";
	}
//编写Dao类中的与会员类业务相关方法
	//收银员登录操作
	public static boolean casLogin(String user , String password){
		/*
			收银员登录操作
			1、获取收银员账号所在的位置（角标）
			2、获取密码，判断输入的信息是否正确
			正确返回 true，否则返回false
		*/
		//获取用户名
		for(int i = 0 ; i < DB.cashierInfo[0].length ;i++){
			System.out.println(DB.cashierInfo[0][i]);
			if(DB.cashierInfo[0][i].equals(user)){
				//找到用户了，验证密码
				if(DB.cashierInfo[1][i].equals(password)){
					return true;
				}
			}
		}
		//没找到用户，返回失败false
		return false;
	}
	
	//查询所有商品信息
	public static String[][] showGoods(){	
		//直接返回商品信息即可
		return DB.goods;
	}
	/*通过商品编号查找商品信息，传入参数商品编号，返回商品信息数组
		返回结果String[]长度为4
		String[0]：编号  
		String[1]：商品名
		String[2]：规格
		String[3]：单价 
	*/
	public static String[] selectById(String num){
		//返回的数据
		String[] result = new String[4];
		//使用循环遍历编号数组，找到对应数据返回
		for(int i = 0 ; i < DB.goodsTag; i++){ 
			if(DB.goods[0][i].equals(num)){ 
				//将找到的数据依次添加到结果
				result[0] = DB.goods[0][i];
				result[1] = DB.goods[1][i];
				result[2] = DB.goods[2][i];
				result[3] = DB.goods[3][i];
				//返回结果
				return result;
			}
		}
		//如果找不到，返回空
		return null;
	}
	//查找会员，积分时候使用
	public static boolean vipSearch(String user){
		for(int i = 0 ; i < DB.vipTag ;i++){
				if(DB.vip[0][i].equals(user)){
					return true;
				}	
			}
			return false;
	}
	//定义会员积分功能 1元= 1积分,当会员消费后，进行积分操作
	public static boolean vipJifen(String user,int jifen){
		for(int i = 0 ; i < DB.vipTag ;i++){
			if(DB.vip[0][i].equals(user)){
				//找到用户了，积分
				DB.vip[4][i]  =new Integer(DB.vip[4][i]) + jifen +""; 
				//累计消费
				DB.vip[5][i]  =new Integer(DB.vip[5][i]) + jifen +""; 
				//判断是否达到升级要求
				int temp = new Integer(DB.vip[5][i]);
				if(temp >= 1000000){
					DB.vip[3][i] = "荣耀会员";
				}else if(temp >= 500000){
					DB.vip[3][i] = "钻石会员";
				}else if(temp >= 100000){
					DB.vip[3][i] = "白金会员";				
				}else if(temp >= 10000){
					DB.vip[3][i] = "黄金会员";				
				}else if(temp >= 1000){
					DB.vip[3][i] = "白银会员";				
				}else if(temp >= 100){
					DB.vip[3][i] = "青铜会员";				
				}else if(temp >= 1){
					DB.vip[3][i] = "铁牌会员";				
				}
				return true;
			}	
		}
		return false;
	}



}

数据存储类：

package db;
public class DB{
	//存储管理员 帐号、密码
	public static String[] bossInfo = { "aaa","123"};
	//存储收银员 帐号、密码
	public static String[][] cashierInfo = new String[2][10];
	public static int  tag  = 0;
	//存储商品 商品编号、商品名称、商品规格、商品单价
	public static String[][] goods = new String[4][100];
	public static int goodsTag  = 0;
	/*定义存储会员信息
	0：账号
	1：密码
	2：手机号
	3：级别 ：
	     		累计消费 
			铁牌会员：1
			铜牌会员：100
			银牌会员：1000
			金牌会员：10000
			白金会员：100000
			钻石会员：500000
			荣耀会员：1000000
	4：积分
	5：累计消费,成长值
	*/
	public static String[][] vip = new String[6][100]; 
	public static int vipTag = 0;
	/*定义兑换商品列表
		0、编号
		1、商品名
		2、规格
		3、兑换积分
		4、库存
	*/

	public static String[][] conGoods = new String[5][100]; 
	public static int conGoodsTag = 0;

}