Supermarket/bin/config/jdbc.properties

@@ -1,4 +1,4 @@
 driver=com.mysql.cj.jdbc.Driver
 url=jdbc:mysql://localhost:3306/supermarket?serverTimezone=UTC
 user=root
-password=123456
+password=040820

Supermarket/bin/jdbc.properties

@@ -1,4 +1,4 @@
 driver=com.mysql.cj.jdbc.Driver
 url=jdbc:mysql://localhost:3306/supermarket?serverTimezone=UTC
 user=root
-password=123456
+password=040820

Supermarket/config/jdbc.properties

@@ -1,4 +1,4 @@
 driver=com.mysql.cj.jdbc.Driver
 url=jdbc:mysql://localhost:3306/supermarket?serverTimezone=UTC
 user=root
-password=123456
+password=040820

Supermarket/src/com/lingnan/supermarket/componet/BGPanel.java

@@ -8,16 +8,16 @@ public class BGPanel extends JPanel{
 	private Image image;
 
 	public BGPanel(Image image) {
-		// 定义构造方法
+		// 定义一个构造方法，接收一个Image类型的参数image，用于创建BGPanel对象时传入要显示的图像
 		this.image = image;
 		// 将传入的参数image赋值给类的成员变量image
 
 		int width = Toolkit.getDefaultToolkit().getScreenSize().width;
-		// 通过默认工具包（Toolkit）获取屏幕的宽度
+		// 通过默认工具包（Toolkit）获取屏幕的宽度，存储在局部变量width中
 		int height = Toolkit.getDefaultToolkit().getScreenSize().height;
-		// 通过默认工具包（Toolkit）获取屏幕的高度
+		// 通过默认工具包（Toolkit）获取屏幕的高度，存储在局部变量height中
 		this.setSize(width, height);
-		// 设置该面板的大小为整个屏幕的大小
+		// 设置该面板（BGPanel）的大小为整个屏幕的大小，即宽度和高度分别为获取到的屏幕宽高
 	}
 
 	public BGPanel(Image image, int width, int height) {
@@ -37,6 +37,7 @@ public class BGPanel extends JPanel{
 		// 调用父类（JPanel）的paintComponent方法，以确保完成一些默认的绘制操作，比如背景清除等
 
 		g.drawImage(image, 0, 0, getWidth(), getHeight(), this);
+		// 使用传入的Graphics对象g在面板上绘制图像，参数含义如下：
 		// image：要绘制的图像对象，就是之前保存的成员变量image
 		// 0, 0：表示在面板上绘制图像的起始坐标（x坐标和y坐标），这里从面板的左上角（0, 0）位置开始绘制
 		// getWidth(), getHeight()：获取当前面板的宽度和高度，用于指定绘制图像时按照面板的实际大小进行拉伸或缩放，确保图像填满整个面板

Supermarket/src/com/lingnan/supermarket/dao/impl/outOrderServiceImpl.java

@@ -13,29 +13,21 @@ import com.lingnan.supermarket.dto.InOrder;
 import com.lingnan.supermarket.dto.OutOrder;
 import com.lingnan.supermarket.utils.JDBCUtil;
 
-// 实现outOrderService接口--用于处理与出库订单相关的数据访问操作
-public class outOrderServiceImpl implements outOrderService {
+public class outOrderServiceImpl implements outOrderService{
 
-	// 查询所有出库订单信息，并按照日期降序排列返回
 	@Override
 	public Vector<OutOrder> findAllOutOrder() {
-		// 存储查询到的所有出库订单信息的向量集合
 		Vector<OutOrder> outOrders = new Vector<OutOrder>();
-		// 获取数据库连接
 		Connection conn = JDBCUtil.getConn();
 		PreparedStatement preparedStatement = null;
-		ResultSet resultSet = null;
-
-		// 从OutOrder表中查询所有记录，并按oDate字段降序排序
+		ResultSet resultSet=null;
+		
 		String SQL = "select * from OutOrder  order by oDate desc";
-
+		
 		try {
-			// 根据SQL语句创建预编译的Statement对象
 			preparedStatement = conn.prepareStatement(SQL);
-			// 执行查询操作
 			resultSet = preparedStatement.executeQuery();
-			// 遍历结果集，将每条记录封装成OutOrder对象，并添加到outOrders集合中
-			while (resultSet.next()) {
+			while(resultSet.next()) {
 				OutOrder outOrder = new OutOrder();
 				outOrder.setoNumber(resultSet.getString("oNumber"));
 				outOrder.setAllOutPrice(resultSet.getFloat("allOutPrice"));
@@ -43,147 +35,117 @@ public class outOrderServiceImpl implements outOrderService {
 				outOrder.setPrincipal(resultSet.getString("principal"));
 				outOrders.add(outOrder);
 			}
-
+			
 		} catch (SQLException e) {
 			e.printStackTrace();
 		} finally {
-			// 关闭结果集、预编译语句以及数据库连接，释放相关资源
 			JDBCUtil.close(resultSet, preparedStatement, conn);
 		}
 
 		return outOrders;
 	}
 
-	// 根据订单编号查询对应的出库订单信息
 	@Override
 	public OutOrder findByIdOutOrder(String oNumber) {
-		// 用于存储查询到的出库订单信息的对象
 		OutOrder outOrder = new OutOrder();
-		// 获取数据库连接
 		Connection conn = JDBCUtil.getConn();
 		PreparedStatement preparedStatement = null;
 		ResultSet resultSet = null;
 
 		try {
-			// 根据订单编号查询对应的出库订单记录
-			preparedStatement = conn.prepareStatement("select * from outOrder where oNumber =?");
-			// 设置查询的订单编号
+			preparedStatement = conn.prepareStatement("select * from outOrder where oNumber = ?");
 			preparedStatement.setString(1, oNumber);
-			// 执行查询操作
 			resultSet = preparedStatement.executeQuery();
-			// 如果结果集中有记录，说明找到了对应的订单，则将记录中的各字段值封装到outOrder对象中
 			if (resultSet.next()) {
 				outOrder.setoNumber(resultSet.getString("oNumber"));
 				outOrder.setAllOutPrice(resultSet.getFloat("allOutPrice"));
 				outOrder.setoDate(resultSet.getDate("oDate"));
 				outOrder.setPrincipal(resultSet.getString("principal"));
 			} else {
-				// 如果结果集中没有记录，说明没有找到该订单或订单不存在，返回null
-				return null;
-			}
+				return null; // 没有找到该订单或订单不存在，返回null
+			} 
 
 		} catch (SQLException e) {
 			e.printStackTrace();
 		} finally {
-			// 关闭结果集、预编译语句以及数据库连接，释放相关资源
 			JDBCUtil.close(resultSet, preparedStatement, conn);
 		}
 		return outOrder;
+	
 	}
 
-	// 向数据库中添加一条出库订单记录
 	@Override
 	public int addOutOrder(String oNumber, float allOutPrice) {
 		int flag = 0;
-		// 获取当前系统时间戳，用于作为出库订单的日期（oDate）字段值，表示订单创建时间
-		Timestamp oDate = new Timestamp(System.currentTimeMillis());
-
-		// 获取数据库连接
+		Timestamp oDate = new Timestamp(System.currentTimeMillis()); 
+		
 		Connection conn = JDBCUtil.getConn();
 		PreparedStatement preparedStatement = null;
-
+		
 		try {
-			// 创建预编译的SQL插入语句，向outOrder表中插入一条记录
-			preparedStatement = conn.prepareStatement("insert into outOrder values (?,?,?,?)");
-			// 设置预编译语句中的参数，依次为订单编号、总出库价格、订单日期、负责人（此处写死为"a1"，可能后续需要改进）
+			preparedStatement = conn.prepareStatement
+					("insert into outOrder values (?,?,?,?)");
 			preparedStatement.setString(1, oNumber);
 			preparedStatement.setFloat(2, allOutPrice);
 			preparedStatement.setTimestamp(3, oDate);
 			preparedStatement.setString(4, "a1");
-			// 执行插入操作
 			preparedStatement.executeUpdate();
-			// 如果插入成功，将标志位flag设置为1，表示操作成功
 			flag = 1;
 		} catch (SQLException e) {
-			// 如果插入出现异常，将标志位flag设置为 -1，表示操作失败
 			flag = -1;
 			e.printStackTrace();
 		} finally {
-			// 关闭预编译语句以及数据库连接，释放相关资源
-			JDBCUtil.close(null, preparedStatement, conn);
+			JDBCUtil.close(null,preparedStatement, conn);
 		}
-
+		
 		return flag;
 	}
 
-	// 根据订单编号从数据库中删除对应的出库订单记录
 	@Override
 	public int deleteOutOrder(String oNumber) {
 		int flag = 0;
-
-		// 获取数据库连接
+		
 		Connection conn = JDBCUtil.getConn();
 		PreparedStatement preparedStatement = null;
-
+		
 		try {
-			// 创建预编译的SQL删除语句，根据订单编号（oNumber）删除对应的出库订单记录
-			preparedStatement = conn.prepareStatement("delete from outOrder where oNumber =?");
-			// 设置预编译语句中的参数，即要删除的订单编号
+			preparedStatement = conn.prepareStatement
+					("delete from outOrder where oNumber = ?");
 			preparedStatement.setString(1, oNumber);
-			// 执行删除操作
 			preparedStatement.executeUpdate();
-			// 如果删除成功，将标志位flag设置为1，表示操作成功
 			flag = 1;
 		} catch (SQLException e) {
-			// 如果删除出现异常，将标志位flag设置为 -1，表示操作失败
 			flag = -1;
 			e.printStackTrace();
 		} finally {
-			// 关闭预编译语句以及数据库连接，释放相关资源
-			JDBCUtil.close(null, preparedStatement, conn);
+			JDBCUtil.close(null,preparedStatement, conn);
 		}
 		return flag;
 	}
 
-	// 获取指定日期的今日出库金额总和（此处方法名可能有点混淆，从代码逻辑看是获取指定日期的出库金额总和）
-	public Float TodayOutPrice(String date) {
-		// 创建一个InOrder对象
-		InOrder inOrder = new InOrder();
-		// 获取数据库连接
-		Connection conn = JDBCUtil.getConn();
-		PreparedStatement preparedStatement = null;
-		ResultSet resultSet = null;
-		// 用于存储查询到的今日出库金额总和，初始为0
-		Float allInPrice = (float) 0;
-
-		try {
-			// 通过求和函数查询指定日期范围内的总出库价格
-			preparedStatement = conn.prepareStatement("select sum(allOutPrice) from outOrder where oDate>=? and oDate<=date_add(?,interval 1 day)");
-			// 设置两个参数均为传入的日期值，用于限定查询的日期范围
-			preparedStatement.setString(1, date);
-			preparedStatement.setString(2, date);
-			// 执行查询操作
-			resultSet = preparedStatement.executeQuery();
-			// 如果结果集中有记录，说明查询到了对应的金额数据，则将其取出赋值给allInPrice变量
-			if (resultSet.next()) {
-				allInPrice = resultSet.getFloat("sum(allOutPrice)");
+	
+	//获取今日进货金额
+		public Float TodayOutPrice(String date) {
+
+			InOrder inOrder = new InOrder();
+			Connection conn = JDBCUtil.getConn();
+			PreparedStatement preparedStatement = null;
+			ResultSet resultSet = null;
+			Float allInPrice=(float) 0;
+
+			try {
+				preparedStatement = conn.prepareStatement("select sum(allOutPrice) from outOrder where oDate>=? and oDate<=date_add(?,interval 1 day)");
+				preparedStatement.setString(1, date);
+				preparedStatement.setString(2, date);
+				resultSet = preparedStatement.executeQuery();
+				if (resultSet.next()) {
+					allInPrice=resultSet.getFloat("sum(allOutPrice)");
+				} 
+			} catch (SQLException e) {
+				e.printStackTrace();
+			} finally {
+				JDBCUtil.close(resultSet, preparedStatement, conn);
 			}
-		} catch (SQLException e) {
-			e.printStackTrace();
-		} finally {
-			// 关闭结果集、预编译语句以及数据库连接，释放相关资源
-			JDBCUtil.close(resultSet, preparedStatement, conn);
+			return allInPrice;
 		}
-		return allInPrice;
-	}
-}
+}

Supermarket/src/com/lingnan/supermarket/dao/impl/outRecordServiceImpl.java

@@ -12,66 +12,49 @@ import com.lingnan.supermarket.dto.InRecord;
 import com.lingnan.supermarket.dto.OutRecord;
 import com.lingnan.supermarket.utils.JDBCUtil;
 
-// 实现了outRecordService接口--用于处理出库记录相关的数据操作逻辑
-public class outRecordServiceImpl implements outRecordService {
+public class outRecordServiceImpl implements outRecordService{
 
-	// 查询所有出库记录信息
 	@Override
 	public Vector<OutRecord> findAllOutRecord() {
-		// 用于存储查询到的所有出库记录信息的向量集合
 		Vector<OutRecord> outRecords = new Vector<OutRecord>();
-		// 通过JDBCUtil工具类的静态方法来获取数据库连接
 		Connection conn = JDBCUtil.getConn();
 		PreparedStatement preparedStatement = null;
-		ResultSet resultSet = null;
-
-		// 从outRecord表中获取所有记录
+		ResultSet resultSet=null;
+		
 		String SQL = "select * from outRecord";
-
+		
 		try {
-			// 根据SQL语句创建预编译的Statement对象
 			preparedStatement = conn.prepareStatement(SQL);
-			// 执行查询操作
 			resultSet = preparedStatement.executeQuery();
-			// 遍历结果集，将每条记录封装成OutRecord对象，并添加到outRecords集合中
-			while (resultSet.next()) {
+			while(resultSet.next()) {
 				OutRecord outRecord = new OutRecord();
 				outRecord.setoNumber(resultSet.getString("oNumber"));
 				outRecord.setSum(resultSet.getInt("sum"));
 				outRecord.setOutPrice(resultSet.getFloat("outPrice"));
 				outRecords.add(outRecord);
 			}
-
+			
 		} catch (SQLException e) {
 			e.printStackTrace();
 		} finally {
-			// 关闭结果集、预编译语句以及数据库连接，释放相关资源
 			JDBCUtil.close(resultSet, preparedStatement, conn);
 		}
 
 		return outRecords;
 	}
 
-	// 根据订单编号查询对应的出库记录信息，返回符合条件的多条记录
 	@Override
 	public Vector<OutRecord> findByIdOutRecordr(String oNumber) {
-		// 用于临时存储单个出库记录信息的对象
-		OutRecord outRecord;
-		// 获取数据库连接
+		OutRecord outRecord ;
 		Connection conn = JDBCUtil.getConn();
 		PreparedStatement preparedStatement = null;
 		ResultSet resultSet = null;
-		// 存储查询到的符合条件的所有出库记录信息的向量集合
 		Vector<OutRecord> v = new Vector<OutRecord>();
 
 		try {
-			//根据给定的订单编号查询outRecord表中对应的记录
-			preparedStatement = conn.prepareStatement("select * from outRecord where oNumber =?");
-			// 设置要查询的订单编号
+			preparedStatement = conn.prepareStatement("select * from outRecord where oNumber = ?");
 			preparedStatement.setString(1, oNumber);
-			// 执行查询操作，获取结果集
 			resultSet = preparedStatement.executeQuery();
-			// 遍历结果集，将每条符合条件的记录封装成OutRecord对象，并添加到向量集合v中
 			while (resultSet.next()) {
 				outRecord = new OutRecord();
 				outRecord.setoNumber(resultSet.getString("oNumber"));
@@ -79,83 +62,68 @@ public class outRecordServiceImpl implements outRecordService {
 				outRecord.setSum(resultSet.getInt("sum"));
 				outRecord.setOutPrice(resultSet.getFloat("Price"));
 				v.add(outRecord);
-			}
+			} 
 
 		} catch (SQLException e) {
 			e.printStackTrace();
 		} finally {
-			// 关闭结果集、预编译语句以及数据库连接，释放相关资源
 			JDBCUtil.close(resultSet, preparedStatement, conn);
 		}
 		return v;
 	}
 
-	// 向数据库中添加一条出库记录信息
 	@Override
 	public int addoutRecord(OutRecord or) {
+		
 		int flag = 0;
-
-		// 获取要添加的出库记录对象中的订单编号
+		
 		String oNumber = or.getoNumber();
-		// 获取要添加的出库记录对象中的数量
 		int sum = or.getSum();
-		// 获取要添加的出库记录对象中的出库价格
 		Float outPrice = or.getOutPrice();
-
-		// 获取数据库连接
+		
 		Connection conn = JDBCUtil.getConn();
 		PreparedStatement preparedStatement = null;
-
+		
 		try {
-			// 创建预编译的SQL插入语句，向outRecord表中插入一条记录，包含订单编号、数量、出库价格三个字段的值
-			preparedStatement = conn.prepareStatement("insert into outRecord values (?,?,?)");
-			// 设置预编译语句中的参数，依次为订单编号、数量、出库价格
+			preparedStatement = conn.prepareStatement
+					("insert into outRecord values (?,?,?)");
 			preparedStatement.setString(1, oNumber);
 			preparedStatement.setInt(2, sum);
 			preparedStatement.setFloat(3, outPrice);
-			// 执行插入操作
 			preparedStatement.executeUpdate();
-			// 如果插入成功，将标志位flag设置为1，表示操作成功
 			flag = 1;
 		} catch (SQLException e) {
-			// 如果插入出现异常，将标志位flag设置为 -1，表示操作失败
 			flag = -1;
 			e.printStackTrace();
 		} finally {
-			// 关闭预编译语句以及数据库连接，释放相关资源，此处结果集为null
-			JDBCUtil.close(null, preparedStatement, conn);
+			JDBCUtil.close(null,preparedStatement, conn);
 		}
-
+		
 		return flag;
 	}
 
-	// 根据订单编号从数据库中删除对应的出库记录信息
 	@Override
 	public int deleteOutOrder(String oNumber) {
 		int flag = 0;
-
-		// 获取数据库连接
+		
 		Connection conn = JDBCUtil.getConn();
 		PreparedStatement preparedStatement = null;
-
+		
 		try {
-			// 创建预编译的SQL删除语句，根据给定的订单编号删除outRecord表中对应的记录
-			preparedStatement = conn.prepareStatement("delete from outRecord where oNumber =?");
-			// 设置要删除的订单编号
+			preparedStatement = conn.prepareStatement
+					("delete from outRecord where oNumber = ?");
 			preparedStatement.setString(1, oNumber);
-			// 执行删除操作
 			preparedStatement.executeUpdate();
-			// 如果删除成功，将标志位flag设置为1，表示操作成功
 			flag = 1;
 		} catch (SQLException e) {
-			// 如果删除出现异常，将标志位flag设置为 -1，表示操作失败
 			flag = -1;
 			e.printStackTrace();
 		} finally {
-			// 关闭预编译语句以及数据库连接，释放相关资源，此处结果集为null
-			JDBCUtil.close(null, preparedStatement, conn);
+			JDBCUtil.close(null,preparedStatement, conn);
 		}
 		return flag;
 	}
 
-}
+	
+
+}

Supermarket/src/com/lingnan/supermarket/dao/impl/prodCatalogImpl.java

@@ -12,241 +12,214 @@ import com.lingnan.supermarket.dao.prodCatalogService;
 import com.lingnan.supermarket.dto.ProdCatalog;
 import com.lingnan.supermarket.utils.JDBCUtil;
 
-// 实现prodCatalogService接口--用于处理商品目录相关的数据持久化操作
-public class prodCatalogImpl implements prodCatalogService {
+public class prodCatalogImpl implements prodCatalogService{
 
-	// 将商品目录表和商品表联合查询，获取商品目录及相关商品信息
+	/*将商品目录表和商品表联合查询*/
 	@Override
 	public Vector<ProdCatalog> findProdCatalogAndProd() {
-		// 通过JDBCUtil工具类来获取已经配置好的连接对象
-		Connection conn = JDBCUtil.getConn();
-		// 创建一个Vector容器，存放查询到的ProdCatalog对象
+		Connection conn=JDBCUtil.getConn();
 		Vector<ProdCatalog> v = new Vector<ProdCatalog>();
 		ProdCatalog prodCatalog;
 		PreparedStatement pstmt = null;
-		ResultSet resultSet = null;
+		ResultSet resultSet=null;
 		try {
-			// 通过预编译语句准备调用存储过程allProdCatalog
 			pstmt = conn.prepareStatement("call allProdCatalog()");
-			// 执行查询操作
 			resultSet = pstmt.executeQuery();
-			// 遍历结果集，将每一条记录封装成ProdCatalog对象，并添加到Vector容器中
-			while (resultSet.next()) {
+			while(resultSet.next()){
 				prodCatalog = new ProdCatalog();
-				// 设置ProdCatalog对象的id属性
 				prodCatalog.setId(resultSet.getString("id"));
-				// 设置ProdCatalog对象的name属性
 				prodCatalog.setName(resultSet.getString("name"));
 				v.add(prodCatalog);
 			}
 		} catch (SQLException e) {
-			// 若出现SQL异常，打印异常栈信息
+			// TODO Auto-generated catch block
 			e.printStackTrace();
-		} finally {
-			// 通过JDBCUtil工具类提供的方法进行关闭操作
+		}finally{
 			JDBCUtil.close(resultSet, pstmt, conn);
 		}
-
+		
+		
 		return v;
-
+		
+	
 	}
-
-	// 根据给定的id1查找商品目录名称
+	
+	
 	@Override
-	public String findProdCatalog(String id1) {
-		// 获取数据库连接
-		Connection conn = JDBCUtil.getConn();
-
+	public String findProdCatalog(String id1 ) {
+		Connection conn=JDBCUtil.getConn();
+	
 		PreparedStatement pstmt = null;
-		ResultSet resultSet = null;
-		String catalog = null;
+		ResultSet resultSet=null;
+		String catalog=null;
 		try {
-			// 预编译SQL语句，用于根据给定的id2查询prodCatalog表中的记录
 			pstmt = conn.prepareStatement("select *from prodCatalog where id2 =?");
-			// 设置SQL语句中的参数，将传入的id1赋值给查询语句中的占位符
-			pstmt.setString(1, id1);
+			pstmt.setString(1,id1);
+			
 
-			// 执行查询操作
 			resultSet = pstmt.executeQuery();
-			// 如果结果集中有下一条记录，则获取对应记录中的name1字段值作为商品目录名称
-			if (resultSet.next()) {
-				catalog = resultSet.getString("name1");
+			if(resultSet.next()){
+				catalog=resultSet.getString("name1");
 			}
 		} catch (SQLException e) {
+			// TODO Auto-generated catch block
 			e.printStackTrace();
-		} finally {
-			// 关闭相关资源
+		}finally{
 			JDBCUtil.close(resultSet, pstmt, conn);
 		}
-
+		
+		
 		return catalog;
-
+		
+	
 	}
 
-	// 向商品目录表prodCatalog中添加一条记录
 	@Override
 	public int addProdCatalog(String id1, String id2) {
-		int flag = 0;
-		String name1 = null;
-		// 根据传入的id1判断商品类别名称，01对应食品，02对应电器，03对应生活用品，04对应其他
-		if (id1.equals("01"))
-			name1 = "食品";
-		else if (id1.equals("02"))
-			name1 = "电器";
-		else if (id1.equals("03"))
-			name1 = "生活用品";
-		else
-			name1 = "其他";
-
-		// 获取数据库连接
-		Connection conn = JDBCUtil.getConn();
+		int flag=0;
+		String name1=null;
+		//01 食品 02 电器 03 生活用品 04 其他 
+		if(id1.equals("01"))
+			name1="食品";
+		else if(id1.equals("02"))
+				name1="电器";
+		else if(id1.equals("03"))
+				name1="生活用品";
+		else 
+			name1="其他";
+	
+		//连接jdbc
+		Connection conn=JDBCUtil.getConn();
 		PreparedStatement pstmt = null;
-		ResultSet resultSet = null;
-
+		ResultSet resultSet=null;
+		
 		try {
-			// 预编译插入数据的SQL语句，向prodCatalog表中插入三条数据
 			pstmt = conn.prepareStatement("insert into prodCatalog values(?,?,?)");
-			// 设置SQL语句中的第一个参数
-			pstmt.setString(1, id1);
-			// 设置SQL语句中的第二个参数
-			pstmt.setString(2, name1);
-			// 设置SQL语句中的第三个参数
-			pstmt.setString(3, id2);
+			pstmt.setString(1,id1);
+			pstmt.setString(2,name1);
+			pstmt.setString(3,id2);
+			
 
-			// 执行插入操作，若插入成功，将flag置为1，表示添加成功
 			pstmt.executeUpdate();
-			flag = 1;
-
+			flag=1;
+		
 		} catch (SQLException e) {
 			e.printStackTrace();
-		} finally {
-			// 关闭相关资源
+		}finally{
 			JDBCUtil.close(resultSet, pstmt, conn);
 		}
-
+		
 		return flag;
 	}
+	
 
-	// 根据给定的id2删除商品目录表prodCatalog中的一条记录
 	@Override
 	public int deleteProdCatalog(String id2) {
-		int flag = 0;
-		// 获取数据库连接
-		Connection conn = JDBCUtil.getConn();
+		int flag=0;
+		//连接jdbc
+		Connection conn=JDBCUtil.getConn();
 		PreparedStatement pstmt = null;
-		ResultSet resultSet = null;
-
+		ResultSet resultSet=null;
+		
 		try {
-			// 预编译删除数据的SQL语句，根据传入的id2作为条件，从prodCatalog表中删除对应的记录
 			pstmt = conn.prepareStatement("delete from prodCatalog where id2=?");
-			// 设置SQL语句中的参数，将传入的id2赋值给查询语句中的占位符（?）
-			pstmt.setString(1, id2);
-			// 执行删除操作，若删除成功，将flag置为1，表示删除成功
+			pstmt.setString(1,id2);
 			pstmt.executeUpdate();
-			flag = 1;
-
+			flag=1;
+		
 		} catch (SQLException e) {
-			// 若出现SQL异常打印异常栈信息
+			// TODO Auto-generated catch block
 			e.printStackTrace();
-		} finally {
-			// 关闭相关资源
+		}finally{
 			JDBCUtil.close(resultSet, pstmt, conn);
 		}
-
+		
 		return flag;
 	}
 
-	// 根据商品类production的name查询并输出类别id，如果传入的name为"全部"，则直接返回默认的catalogid "0"
+
 	@Override
+	//根据商品类production的name查询并输出类别id
 	public String findProdCatalogByname(String name) {
-		Connection conn = JDBCUtil.getConn();
-
+		Connection conn=JDBCUtil.getConn();
+		
 		PreparedStatement pstmt = null;
-		ResultSet resultSet = null;
-
-		String catalogid = "0";
+		ResultSet resultSet=null;
+		
+		String catalogid="0";
 		try {
-			// 如果传入的商品名称为"全部"，则直接返回默认的catalogid
-			if (name.equals("全部")) {
+			if(name.equals("全部")){
 				return catalogid;
 			}
-			// 预编译SQL语句，用于根据给定的商品名称查询prodCatalog表中的记录，获取对应的类别id
 			pstmt = conn.prepareStatement("select * from prodCatalog where name =?");
-			// 设置SQL语句中的参数，将传入的name赋值给查询语句中的占位符
-			pstmt.setString(1, name);
+			pstmt.setString(1,name);
+			
 
-			// 执行查询操作，获取结果集
 			resultSet = pstmt.executeQuery();
-			// 如果结果集中有下一条记录，则获取对应记录中的id字段值作为类别id
-			if (resultSet.next()) {
-				catalogid = resultSet.getString("id");
+			if(resultSet.next()){
+				catalogid=resultSet.getString("id");
 			}
 		} catch (SQLException e) {
-			// 若出现SQL异常，打印异常栈信息
+			// TODO Auto-generated catch block
 			e.printStackTrace();
-		} finally {
-			// 关闭相关资源
+		}finally{
 			JDBCUtil.close(resultSet, pstmt, conn);
 		}
-
+		
+		
 		return catalogid;
 	}
-    /*
-    public static void main(String[] args) {
-        ProdCatalog p = new ProdCatalog();
-        prodCatalogImpl pi = new prodCatalogImpl();
-        p.setName("全部");
-        System.out.println(pi.findProdCatalogByname(p.getName()));
-    }
-    */
+/*	public static void main(String[] args) {
+		ProdCatalog p=new ProdCatalog();
+		prodCatalogImpl pi=new prodCatalogImpl();
+		p.setName("全部");
+		System.out.println(pi.findProdCatalogByname(p.getName()));
+	}*/
+
 
-	// 查询商品目录表prodCatalog中的所有商品类别名称，并添加"全部"作为第一个元素后返回
 	@Override
 	public ArrayList<String> findNameProdCatalog() {
-		Connection conn = JDBCUtil.getConn();
+		Connection conn=JDBCUtil.getConn();
 		ArrayList<String> v = new ArrayList<String>();
-		// 先添加"全部"作为默认的第一个类别名称
 		v.add("全部");
 		ProdCatalog prodCatalog;
 		PreparedStatement pstmt = null;
-		ResultSet resultSet = null;
+		ResultSet resultSet=null;
 		try {
-			// 预编译查询所有记录的SQL语句，用于获取prodCatalog表中的所有商品类别名称
 			pstmt = conn.prepareStatement("select * from prodCatalog");
-			// 执行查询操作
 			resultSet = pstmt.executeQuery();
-			// 遍历结果集，将每条记录中的商品类别名称添加到ArrayList容器中
-			while (resultSet.next()) {
-
+			while(resultSet.next()){
+				
 				v.add(resultSet.getString("name"));
 			}
 		} catch (SQLException e) {
-			// 若出现SQL异常，打印异常栈信息
+			// TODO Auto-generated catch block
 			e.printStackTrace();
-		} finally {
-			// 关闭相关资源
+		}finally{
 			JDBCUtil.close(resultSet, pstmt, conn);
 		}
-
+		
+		
 		return v;
 	}
-    /*
-    public static void main(String[] args) {
-        prodCatalogImpl pi = new prodCatalogImpl();
-        ArrayList<String> log = null;
-
-
-        log = pi.findNameProdCatalog();
-        String[] s = new String[log.size()];
-        for (int i = 0; i < log.size(); i++) {
-            s[i] = log.get(i);
-            System.out.println(log.get(i));
-        }
-        for (int i = 0; i < s.length; i++) {
-            System.out.println(s[i]);
-        }
+	/*public static void main(String[] args) {
+		prodCatalogImpl pi=new prodCatalogImpl();
+		ArrayList<String>log=null;
+		
+		
+		log=pi.findNameProdCatalog();
+		String []s=new String[log.size()];
+		for(int i=0;i<log.size();i++)
+		{s[i]=log.get(i);
+		System.out.println(log.get(i));
+		}
+		for(int i=0;i<s.length;i++)
+		{
+		System.out.println(s[i]);
+		}
+		
+		
+	}*/
 
 
-    }
-    */
-}
+}

Supermarket/src/com/lingnan/supermarket/dao/impl/productionImpl.java

@@ -19,73 +19,73 @@ public class productionImpl implements productionService {
 	public Vector<Production> findAllproduction() {
 		Vector<Production> productions = new Vector<Production>();
 
-		Connection conn = JDBCUtil.getConn(); // 获取数据库连接
+		Connection conn = JDBCUtil.getConn();
 
-		String SQL = "select * from production where delmark = 1"; // SQL查询语句，只查询未被删除的商品
+		String SQL = "select * from production where delmark = 1";
 
 		PreparedStatement preparedStatement = null;
 		ResultSet resultSet = null;
 		try {
-			preparedStatement = conn.prepareStatement(SQL); // 创建PreparedStatement对象
+			preparedStatement = conn.prepareStatement(SQL);
 
-			resultSet = preparedStatement.executeQuery(); // 执行查询，获取结果集
+			resultSet = preparedStatement.executeQuery();
 
-			while (resultSet.next()) { // 遍历结果集
+			while (resultSet.next()) {
 				Production production = new Production();
-				production.setId(resultSet.getString("id")); // 设置商品ID
-				production.setName(resultSet.getString("name")); // 设置商品名称
-				production.setInPrice(resultSet.getFloat("inPrice")); // 设置进价
-				production.setOutPrice(resultSet.getFloat("OutPrice")); // 设置售价
-				production.setLife(resultSet.getInt("life")); // 设置保质期
-				production.setSum(resultSet.getInt("sum")); // 设置库存数量
-				production.setSupplyId(resultSet.getInt("supplyId")); // 设置供应商ID
-				production.setId2(resultSet.getString("id2")); // 设置商品类别ID
-				production.setName2(resultSet.getString("name2")); // 设置商品类别名称
-				production.setDelmark(resultSet.getInt("delmark")); // 设置删除标记
-				productions.add(production); // 将商品信息添加到Vector中
+				production.setId(resultSet.getString("id"));
+				production.setName(resultSet.getString("name"));
+				production.setInPrice(resultSet.getFloat("inPrice"));
+				production.setOutPrice(resultSet.getFloat("OutPrice"));
+				production.setLife(resultSet.getInt("life"));
+				production.setSum(resultSet.getInt("sum"));
+				production.setSupplyId(resultSet.getInt("supplyId"));
+				production.setId2(resultSet.getString("id2"));
+				production.setName2(resultSet.getString("name2"));
+				production.setDelmark(resultSet.getInt("delmark"));
+				productions.add(production);
 			}
 		} catch (SQLException e) {
 			e.printStackTrace();
 		} finally {
-			JDBCUtil.close(resultSet, preparedStatement, conn); // 关闭数据库资源
+			JDBCUtil.close(resultSet, preparedStatement, conn);
 		}
-		return productions; // 返回所有商品信息
+		return productions;
 	}
 
 	/* 用于收银系统，通过商品id返回所有信息 */
 	public Production findByIdProduction(String id) {
 		Production production = new Production();
-		Connection conn = JDBCUtil.getConn(); // 获取数据库连接
+		Connection conn = JDBCUtil.getConn();
 		PreparedStatement preparedStatement = null;
 		ResultSet resultSet = null;
 		try {
 			preparedStatement = conn
-					.prepareStatement("select * from production where id=? and delmark = 1"); // 查询指定ID且未被删除的商品
-			preparedStatement.setString(1, id); // 设置查询参数
-			resultSet = preparedStatement.executeQuery(); // 执行查询
-
-			if (resultSet.next()) { // 如果找到商品
-				production.setId(resultSet.getString("id")); // 设置商品ID
-				production.setName(resultSet.getString("name")); // 设置商品名称
-				production.setInPrice(resultSet.getFloat("inPrice")); // 设置进价
-				production.setOutPrice(resultSet.getFloat("OutPrice")); // 设置售价
-				production.setLife(resultSet.getInt("life")); // 设置保质期
-				production.setSum(resultSet.getInt("sum")); // 设置库存数量
-				production.setSupplyId(resultSet.getInt("supplyId")); // 设置供应商ID
-				production.setId2(resultSet.getString("id2")); // 设置商品类别ID
-				production.setName2(resultSet.getString("name2")); // 设置商品类别名称
-				production.setDelmark(resultSet.getInt("delmark")); // 设置删除标记
+					.prepareStatement("select * from production where id=? and delmark = 1");
+			preparedStatement.setString(1, id);
+			resultSet = preparedStatement.executeQuery();
+
+			if (resultSet.next()) {
+				production.setId(resultSet.getString("id"));
+				production.setName(resultSet.getString("name"));
+				production.setInPrice(resultSet.getFloat("inPrice"));
+				production.setOutPrice(resultSet.getFloat("OutPrice"));
+				production.setLife(resultSet.getInt("life"));
+				production.setSum(resultSet.getInt("sum"));
+				production.setSupplyId(resultSet.getInt("supplyId"));
+				production.setId2(resultSet.getString("id2"));
+				production.setName2(resultSet.getString("name2"));
+				production.setDelmark(resultSet.getInt("delmark"));
 			} else {
 				System.out.println("未找到");
-				return null; // 如果未找到商品，返回null
+				return null;
 			}
 
 		} catch (SQLException e) {
 			e.printStackTrace();
 		} finally {
-			JDBCUtil.close(resultSet, preparedStatement, conn); // 关闭数据库资源
+			JDBCUtil.close(resultSet, preparedStatement, conn);
 		}
-		return production; // 返回商品信息
+		return production;
 	}
 
 	@Override
@@ -94,35 +94,35 @@ public class productionImpl implements productionService {
 		 * 由一个商品名查找并输出全部商品信息
 		 */
 		Vector<Production> productions = new Vector<Production>();
-		Connection conn = JDBCUtil.getConn(); // 获取数据库连接
+		Connection conn = JDBCUtil.getConn();
 		PreparedStatement preparedStatement = null;
 		ResultSet resultSet = null;
 		try {
-			preparedStatement = conn.prepareStatement("select * from production where name like ? and  delmark = 1"); // 模糊查询商品名称
-			String s = '%' + name + '%'; // 构造模糊查询字符串
-			preparedStatement.setString(1, s); // 设置查询参数
-			resultSet = preparedStatement.executeQuery(); // 执行查询
+			preparedStatement = conn.prepareStatement("select * from production where name like ? and  delmark = 1");
+			String s='%'+name+'%';
+			preparedStatement.setString(1, s);
+			resultSet = preparedStatement.executeQuery();
 
-			while (resultSet.next()) { // 遍历结果集
+			while (resultSet.next()) {
 				Production production = new Production();
-				production.setId(resultSet.getString("id")); // 设置商品ID
-				production.setName(resultSet.getString("name")); // 设置商品名称
-				production.setInPrice(resultSet.getFloat("inPrice")); // 设置进价
-				production.setOutPrice(resultSet.getFloat("OutPrice")); // 设置售价
-				production.setLife(resultSet.getInt("life")); // 设置保质期
-				production.setSum(resultSet.getInt("sum")); // 设置库存数量
-				production.setSupplyId(resultSet.getInt("supplyId")); // 设置供应商ID
-				production.setId2(resultSet.getString("id2")); // 设置商品类别ID
-				production.setName2(resultSet.getString("name2")); // 设置商品类别名称
-				production.setDelmark(resultSet.getInt("delmark")); // 设置删除标记
-				productions.add(production); // 将商品信息添加到Vector中
+				production.setId(resultSet.getString("id"));
+				production.setName(resultSet.getString("name"));
+				production.setInPrice(resultSet.getFloat("inPrice"));
+				production.setOutPrice(resultSet.getFloat("OutPrice"));
+				production.setLife(resultSet.getInt("life"));
+				production.setSum(resultSet.getInt("sum"));
+				production.setSupplyId(resultSet.getInt("supplyId"));
+				production.setId2(resultSet.getString("id2"));
+				production.setName2(resultSet.getString("name2"));
+				production.setDelmark(resultSet.getInt("delmark"));
+				productions.add(production);
 			}
 		} catch (SQLException e) {
 			e.printStackTrace();
 		} finally {
-			JDBCUtil.close(resultSet, preparedStatement, conn); // 关闭数据库资源
+			JDBCUtil.close(resultSet, preparedStatement, conn);
 		}
-		return productions; // 返回所有匹配的商品信息
+		return productions;
 	}
 
 	@Override
@@ -131,34 +131,34 @@ public class productionImpl implements productionService {
 	 */
 	public Production findByNameProduction(String name) {
 		Production production = new Production();
-		Connection conn = JDBCUtil.getConn(); // 获取数据库连接
+		Connection conn = JDBCUtil.getConn();
 		PreparedStatement preparedStatement = null;
 		ResultSet resultSet = null;
 		try {
 			preparedStatement = conn
-					.prepareStatement("select * from production where name=?"); // 精确查询商品名称
-			preparedStatement.setString(1, name); // 设置查询参数
-			resultSet = preparedStatement.executeQuery(); // 执行查询
-
-			if (resultSet.next()) { // 如果找到商品
-				production.setId(resultSet.getString("id")); // 设置商品ID
-				production.setName(resultSet.getString("name")); // 设置商品名称
-				production.setInPrice(resultSet.getFloat("inPrice")); // 设置进价
-				production.setOutPrice(resultSet.getFloat("OutPrice")); // 设置售价
-				production.setLife(resultSet.getInt("life")); // 设置保质期
-				production.setSum(resultSet.getInt("sum")); // 设置库存数量
-				production.setSupplyId(resultSet.getInt("supplyId")); // 设置供应商ID
-				production.setDelmark(resultSet.getInt("delmark")); // 设置删除标记
+					.prepareStatement("select * from production where name=?");
+			preparedStatement.setString(1, name);
+			resultSet = preparedStatement.executeQuery();
+
+			if (resultSet.next()) {
+				production.setId(resultSet.getString("id"));
+				production.setName(resultSet.getString("name"));
+				production.setInPrice(resultSet.getFloat("inPrice"));
+				production.setOutPrice(resultSet.getFloat("OutPrice"));
+				production.setLife(resultSet.getInt("life"));
+				production.setSum(resultSet.getInt("sum"));
+				production.setSupplyId(resultSet.getInt("supplyId"));
+				production.setDelmark(resultSet.getInt("delmark"));
 			} else {
-				return null; // 如果未找到商品，返回null
+				return null;
 			}
 
 		} catch (SQLException e) {
 			e.printStackTrace();
 		} finally {
-			JDBCUtil.close(resultSet, preparedStatement, conn); // 关闭数据库资源
+			JDBCUtil.close(resultSet, preparedStatement, conn);
 		}
-		return production; // 返回商品信息
+		return production;
 	}
 
 	@Override
@@ -167,39 +167,39 @@ public class productionImpl implements productionService {
 	 */
 	public int addProduction(Production p) {
 		int flag = 0;
-		Connection conn = JDBCUtil.getConn(); // 获取数据库连接
+		Connection conn = JDBCUtil.getConn();
 		PreparedStatement preparedStatement = null;
 		PreparedStatement preparedStatement1 = null;
-		ResultSet resultSet1 = null;
+		ResultSet resultSet1=null;
 		// 假设商品不存在
 		try {
-			preparedStatement1 = conn.prepareStatement("select * from production where id=?"); // 检查商品是否已存在
-			preparedStatement1.setString(1, p.getId()); // 设置查询参数
-			resultSet1 = preparedStatement1.executeQuery(); // 执行查询
-			if (resultSet1.next()) {
-				return flag = 2; // 如果商品已存在，返回2
+			preparedStatement1 = conn.prepareStatement("select * from production where id=?");
+			preparedStatement1.setString(1, p.getId());
+			resultSet1=preparedStatement1.executeQuery();
+			if(resultSet1.next()){
+				return flag=2;
 			}
-			preparedStatement = conn.prepareStatement("insert into production values(?,?,?,?,?,?,?,?,?,?,?)"); // 插入新商品
-			preparedStatement.setString(1, p.getId()); // 设置商品ID
-			preparedStatement.setString(2, p.getName()); // 设置商品名称
-			preparedStatement.setFloat(3, p.getInPrice()); // 设置进价
-			preparedStatement.setFloat(4, p.getOutPrice()); // 设置售价
-			preparedStatement.setInt(5, p.getLife()); // 设置保质期
-			preparedStatement.setInt(6, p.getSum()); // 设置库存数量
-			preparedStatement.setInt(7, p.getSupplyId()); // 设置供应商ID
-			preparedStatement.setString(8, p.getId2()); // 设置商品类别ID
-			preparedStatement.setString(9, p.getName2()); // 设置商品类别名称
-			preparedStatement.setFloat(10, 0); // 设置未知字段
-			preparedStatement.setInt(11, 1); // 设置删除标记为1（未删除）
-			preparedStatement.executeUpdate(); // 执行插入
-			flag = 1; // 插入成功，返回1
+			preparedStatement = conn.prepareStatement("insert into production values(?,?,?,?,?,?,?,?,?,?,?)");
+			preparedStatement.setString(1, p.getId());
+			preparedStatement.setString(2, p.getName());
+			preparedStatement.setFloat(3, p.getInPrice());
+			preparedStatement.setFloat(4, p.getOutPrice());
+			preparedStatement.setInt(5, p.getLife());
+			preparedStatement.setInt(6, p.getSum());
+			preparedStatement.setInt(7, p.getSupplyId());
+			preparedStatement.setString(8, p.getId2());
+			preparedStatement.setString(9, p.getName2());
+			preparedStatement.setFloat(10, 0);
+			preparedStatement.setInt(11, 1);
+			preparedStatement.executeUpdate();
+			flag=1;
 		} catch (SQLException e) {
 			e.printStackTrace();
 		} finally {
-			JDBCUtil.close(null, preparedStatement, conn); // 关闭数据库资源
+			JDBCUtil.close(null, preparedStatement, conn);
 		}
 
-		return flag; // 返回操作结果
+		return flag;
 	}
 
 	@Override
@@ -208,21 +208,22 @@ public class productionImpl implements productionService {
 	 */
 	public int deleteProduction(String id) {
 		int flag = 0;
-		Connection conn = JDBCUtil.getConn(); // 获取数据库连接
+		Connection conn = JDBCUtil.getConn();
 		PreparedStatement preparedStatement = null;
 
 		try {
 			preparedStatement = conn
-					.prepareStatement("delete from production where id = ?"); // 删除指定ID的商品
-			preparedStatement.setString(1, id); // 设置查询参数
-			preparedStatement.executeUpdate(); // 执行删除
-			flag = 1; // 删除成功，返回1
+					.prepareStatement("delete from production where id = ?");
+			preparedStatement.setString(1, id);
+			preparedStatement.executeUpdate();
+			flag = 1;
 		} catch (SQLException e) {
 			e.printStackTrace();
 		} finally {
-			JDBCUtil.close(null, preparedStatement, conn); // 关闭数据库资源
+			JDBCUtil.close(null, preparedStatement, conn);
 		}
-		return flag; // 返回操作结果
+		return flag;
+
 	}
 
 	@Override
@@ -231,99 +232,98 @@ public class productionImpl implements productionService {
 	 */
 	public int updateProduction(Production p) {
 		int flag = 0;
-		Connection conn = JDBCUtil.getConn(); // 获取数据库连接
+		Connection conn = JDBCUtil.getConn();
 		PreparedStatement preparedStatement = null;
 
 		try {
 			preparedStatement = conn
-					.prepareStatement("update production set name=?,inPrice=?,OutPrice=?,life=?,sum=?,delmark=? where id = ? and supplyId=?"); // 更新商品信息
+					.prepareStatement("update production set name=?,inPrice=?,OutPrice=?,life=?,sum=?,delmark=? where id = ? and supplyId=?");
 
-			preparedStatement.setString(1, p.getName()); // 设置商品名称
-			preparedStatement.setFloat(2, p.getInPrice()); // 设置进价
-			preparedStatement.setFloat(3, p.getOutPrice()); // 设置售价
-			preparedStatement.setInt(4, p.getLife()); // 设置保质期
-			preparedStatement.setInt(5, p.getSum()); // 设置库存数量
-			preparedStatement.setInt(6, p.getDelmark()); // 设置删除标记
-			preparedStatement.setString(7, p.getId()); // 设置商品ID
-			preparedStatement.setInt(8, p.getSupplyId()); // 设置供应商ID
+			preparedStatement.setString(1, p.getName());
+			preparedStatement.setFloat(2, p.getInPrice());
+			preparedStatement.setFloat(3, p.getOutPrice());
+			preparedStatement.setInt(4, p.getLife());
+			preparedStatement.setInt(5, p.getSum());
+			preparedStatement.setInt(6, p.getDelmark());
+			preparedStatement.setString(7, p.getId());
+			preparedStatement.setInt(8, p.getSupplyId());
 
-			preparedStatement.executeUpdate(); // 执行更新
-			flag = 1; // 更新成功，返回1
+			preparedStatement.executeUpdate();
+			flag = 1;
 
 		} catch (SQLException e) {
 			e.printStackTrace();
 		} finally {
-			JDBCUtil.close(null, preparedStatement, conn); // 关闭数据库资源
+			JDBCUtil.close(null, preparedStatement, conn);
 		}
-		return flag; // 返回操作结果
+		return flag;
 	}
 
 	@Override
 	public Vector<Production> findProductionById2(String id) {
 		/**
-		 * 由一个商品类别id2查找并输出全部商品
+		 * 由一个商品类别id2查找并输出全部商品		
 		 */
 
 		Vector<Production> productions = new Vector<Production>();
-		Connection conn = JDBCUtil.getConn(); // 获取数据库连接
+		Connection conn = JDBCUtil.getConn();
 		PreparedStatement preparedStatement = null;
 		ResultSet resultSet = null;
 		try {
-			if (id.equals("0"))
-				preparedStatement = conn.prepareStatement("select * from production where delmark = 1"); // 查询所有未删除的商品
-			else {
-				preparedStatement = conn.prepareStatement("select * from production where id2= ? and  delmark = 1"); // 查询指定类别ID且未删除的商品
-				preparedStatement.setString(1, id); // 设置查询参数
-			}
-			resultSet = preparedStatement.executeQuery(); // 执行查询
-
-			while (resultSet.next()) { // 遍历结果集
+			if(id.equals("0"))
+				preparedStatement = conn.prepareStatement("select * from production where delmark = 1");
+			else
+				{preparedStatement = conn.prepareStatement("select * from production where id2= ? and  delmark = 1");
+			preparedStatement.setString(1, id);}
+			resultSet = preparedStatement.executeQuery();
+
+			while (resultSet.next()) {
 				Production production = new Production();
-				production.setId(resultSet.getString("id")); // 设置商品ID
-				production.setName(resultSet.getString("name")); // 设置商品名称
-				production.setInPrice(resultSet.getFloat("inPrice")); // 设置进价
-				production.setOutPrice(resultSet.getFloat("OutPrice")); // 设置售价
-				production.setLife(resultSet.getInt("life")); // 设置保质期
-				production.setSum(resultSet.getInt("sum")); // 设置库存数量
-				production.setSupplyId(resultSet.getInt("supplyId")); // 设置供应商ID
-				production.setId2(resultSet.getString("id2")); // 设置商品类别ID
-				production.setName2(resultSet.getString("name2")); // 设置商品类别名称
-				production.setDelmark(resultSet.getInt("delmark")); // 设置删除标记
-				productions.add(production); // 将商品信息添加到Vector中
+				production.setId(resultSet.getString("id"));
+				production.setName(resultSet.getString("name"));
+				production.setInPrice(resultSet.getFloat("inPrice"));
+				production.setOutPrice(resultSet.getFloat("OutPrice"));
+				production.setLife(resultSet.getInt("life"));
+				production.setSum(resultSet.getInt("sum"));
+				production.setSupplyId(resultSet.getInt("supplyId"));
+				production.setId2(resultSet.getString("id2"));
+				production.setName2(resultSet.getString("name2"));
+				production.setDelmark(resultSet.getInt("delmark"));
+				productions.add(production);
 			}
 		} catch (SQLException e) {
 			e.printStackTrace();
 		} finally {
-			JDBCUtil.close(resultSet, preparedStatement, conn); // 关闭数据库资源
+			JDBCUtil.close(resultSet, preparedStatement, conn);
 		}
-		return productions; // 返回所有匹配的商品信息
+		return productions;
 	}
-
 	@Override
 	/**
 	 * 更新商品数量和价格
 	 */
-	public boolean updateProductionSum(String prodId, int sum) {
+	public boolean updateProductionSum(String prodId,int sum) {
 		boolean flag = false;
-		Connection conn = JDBCUtil.getConn(); // 获取数据库连接
+		Connection conn = JDBCUtil.getConn();
 		PreparedStatement preparedStatement = null;
 
 		try {
 			preparedStatement = conn
-					.prepareStatement("update production set sum=?+(select sum from(select sum from production where id = ? and delmark=1 ) p) where id = ? and delmark=1;"); // 更新商品库存数量
+					.prepareStatement("update production set sum=?+(select sum from(select sum from production where id = ? and delmark=1 ) p) where id = ? and delmark=1;");
 
-			preparedStatement.setInt(1, sum); // 设置新增库存数量
-			preparedStatement.setString(2, prodId); // 设置商品ID
-			preparedStatement.setString(3, prodId); // 设置商品ID
+			preparedStatement.setInt(1, sum);
+			preparedStatement.setString(2, prodId);
+			preparedStatement.setString(3, prodId);
 
-			if (preparedStatement.executeUpdate() == 1)
-				flag = true; // 更新成功，返回true
+			if(preparedStatement.executeUpdate()==1);
+				flag = true;
 
 		} catch (SQLException e) {
 			e.printStackTrace();
 		} finally {
-			JDBCUtil.close(null, preparedStatement, conn); // 关闭数据库资源
+			JDBCUtil.close(null, preparedStatement, conn);
 		}
-		return flag; // 返回操作结果
+		return flag;
 	}
-}
+
+}

Supermarket/src/com/lingnan/supermarket/dao/impl/storageRecordImpl.java

@@ -4,141 +4,121 @@ import java.sql.Connection;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.Iterator;
 import java.util.Vector;
 
-// 导入相关的业务逻辑接口、数据传输对象以及工具类，用于数据库操作和日期处理等功能
+
+
+
+
+
+
 import com.lingnan.supermarket.dao.storageRecordService;
 import com.lingnan.supermarket.dto.StorageRecord;
 import com.lingnan.supermarket.utils.DateUtil;
 import com.lingnan.supermarket.utils.JDBCUtil;
 
-// 实现storageRecordService接口--用于处理库存记录相关的数据持久化操作
 public class storageRecordImpl implements storageRecordService {
 
-	// 查询所有库存记录信息，并以Vector容器存储返回
 	@Override
 	public Vector<StorageRecord> findAllStorageRecord() {
-		// 创建一个Vector容器，用于存放查询到的StorageRecord对象
-		Vector<StorageRecord> v = new Vector<StorageRecord>();
-
-		// 获取数据库连接，通过JDBCUtil工具类来获取已经配置好的连接对象
-		Connection conn = JDBCUtil.getConn();
+		Vector<StorageRecord> v=new Vector<StorageRecord>();
+		
+		
+		Connection conn=JDBCUtil.getConn();
 		PreparedStatement pstmt = null;
-		ResultSet resultSet = null;
+		ResultSet resultSet=null;
 		try {
-			// 编写SQL查询语句，从storageRecord表中查询所有记录，并按照cDate字段降序排序
-			String sql = "select * from storageRecord  order by cDate desc";
-			// 使用获取到的数据库连接对象，预编译SQL语句
-			pstmt = conn.prepareStatement(sql);
 
-			// 执行查询操作
-			resultSet = pstmt.executeQuery();
-			// 遍历结果集，将每一条记录封装成StorageRecord对象，并添加到Vector容器中
-			while (resultSet.next()) {
-				StorageRecord sr = new StorageRecord();
-				// 设置StorageRecord对象的id属性
+			String sql="select * from storageRecord  order by cDate desc";
+			pstmt=conn.prepareStatement(sql);
+			 
+			resultSet=pstmt.executeQuery();
+			 while(resultSet.next()) {
+				 StorageRecord sr=new StorageRecord();
 				sr.setId(resultSet.getString("id"));
-				// 设置StorageRecord对象的库存编号属性
 				sr.setTheNumber(resultSet.getString("theNumber"));
-				// 设置StorageRecord对象的数量属性
 				sr.setNum(resultSet.getInt("num"));
-				// 设置StorageRecord对象的执行情况属性
 				sr.setExecute(resultSet.getString("execute"));
-				// 通过DateUtil工具类的dateToString方法将数据库中获取的时间戳类型的日期数据转换为字符串类型，方便后续使用（第二个参数为null可能表示使用默认的日期格式转换，具体看DateUtil实现）
-
 				sr.setcDate(DateUtil.dateToString(resultSet.getTimestamp("cDate"), null));
-
-				// 将StorageRecord对象添加到Vector中
 				v.add(sr);
-			}
+			 }
+		
+			
+		}
 
-		} catch (SQLException e) {
-			// 若出现SQL异常，打印异常栈信息
+		catch (SQLException e) {
 			e.printStackTrace();
-		} finally {
-			// 通过JDBCUtil工具类提供的方法进行关闭操作
+		}finally {
 			JDBCUtil.close(resultSet, pstmt, conn);
-
+			
 		}
 
-		return v;
+		
+		
+		return v;	
 	}
 
-	// 根据给定的库存编号（theNumber）查找对应的库存记录信息并返回
+
 	@Override
 	public StorageRecord findByIdStorageRecord(String theNumber) {
-		// 初始化一个StorageRecord对象为null，用于存放查询到的库存记录信息，如果没查到则返回null
-		StorageRecord sr = null;
-		// 获取数据库连接
-		Connection conn = JDBCUtil.getConn();
+		
+		StorageRecord sr=null;
+		Connection conn=JDBCUtil.getConn();	
 		PreparedStatement pstmt = null;
-		ResultSet resultSet = null;
+		ResultSet resultSet=null;
 
 		try {
-			// 创建一个新的StorageRecord对象，用于后续封装查询到的数据
-			sr = new StorageRecord();
-			// 预编译SQL语句，用于根据给定的库存编号（theNumber）查询storageRecord表中的记录
+			sr=new StorageRecord();
 			pstmt = conn.prepareStatement("select *from storageRecord where theNumber=?");
-			// 设置SQL语句中的参数，将传入的库存编号赋值给查询语句中的占位符
-			pstmt.setString(1, theNumber);
-			// 执行查询操作，获取结果集
+			pstmt.setString(1,theNumber);
 			resultSet = pstmt.executeQuery();
-			// 如果结果集中有下一条记录，则将对应记录中的各字段值封装到StorageRecord对象中
-			if (resultSet.next()) {
+			if(resultSet.next()){
 				sr.setTheNumber((resultSet.getString("theNumber")));
 				sr.setId((resultSet.getString("id")));
 				sr.setNum(resultSet.getInt("num"));
 				sr.setExecute(resultSet.getString("execute"));
-				// 设置存储记录的创建日期，并进行格式化
 				sr.setcDate(DateUtil.dateToString(resultSet.getTimestamp("cDate"), null));
 			}
-
+			
 		} catch (SQLException e) {
-			// 若出现SQL异常，打印异常栈信息
+			// TODO Auto-generated catch block
 			e.printStackTrace();
-		} finally {
-			// 关闭相关资源
+		}finally{
 			JDBCUtil.close(resultSet, pstmt, conn);
 		}
-
+		
+		
 		return sr;
 	}
 
-	// 向库存记录表storageRecord中插入一条新的库存记录信息
-	public boolean insertStorageRecord(String iNumber, String time, String prodId, String execute, int sum) {
-		// 定义一个布尔变量用于标记插入操作是否成功，初始化为false
+	public boolean insertStorageRecord(String iNumber,String time,String prodId,String execute,int sum) {
 		boolean flag = false;
-		// 获取数据库连接
-		Connection conn = JDBCUtil.getConn();
+		Connection conn=JDBCUtil.getConn();	
 		PreparedStatement pstmt = null;
-		ResultSet resultSet = null;
+		ResultSet resultSet=null;
 
 		try {
-			// 预编译插入数据的SQL语句，向storageRecord表中插入五条数据
 			pstmt = conn.prepareStatement("insert into storageRecord values(?,?,?,?,?) ");
-			// 设置SQL语句中的第一个参数
-			pstmt.setString(1, iNumber);
-			// 设置SQL语句中的第二个参数
-			pstmt.setString(2, time);
-			// 设置SQL语句中的第三个参数
-			pstmt.setString(3, prodId);
-			// 设置SQL语句中的第四个参数
-			pstmt.setString(4, execute);
-			// 设置SQL语句中的第五个参数
-			pstmt.setInt(5, sum);
-
-			// 执行插入操作，若受影响的行数为1，则将flag置为true，表示插入成功
-			if (pstmt.executeUpdate() == 1) {
-				flag = true;
+			pstmt.setString(1,iNumber);
+			pstmt.setString(2,time);
+			pstmt.setString(3,prodId);
+			pstmt.setString(4,execute);
+			pstmt.setInt(5,sum);
+
+			if(pstmt.executeUpdate()==1){
+					flag = true;
 			}
-
+			
 		} catch (SQLException e) {
-			// 若出现SQL异常，打印异常栈信息
+			// TODO Auto-generated catch block
 			e.printStackTrace();
-		} finally {
-			// 关闭相关资源
+		}finally{
 			JDBCUtil.close(resultSet, pstmt, conn);
 		}
+		
+		
 		return flag;
 	}
-}
+}

Supermarket/src/com/lingnan/supermarket/dialog/ChangeStatusDialog.java

@@ -1,7 +1,5 @@
-// 定义包名，表明该类属于com.lingnan.supermarket.dialog包
 package com.lingnan.supermarket.dialog;
 
-// 导入必要的Java和Swing类库
 import java.awt.Container;
 import java.awt.FlowLayout;
 import java.awt.event.ActionEvent;
@@ -20,7 +18,6 @@ import javax.swing.JPanel;
 import javax.swing.JTable;
 import javax.swing.JTextField;
 
-// 导入项目相关的类和接口
 import com.lingnan.supermarket.*;
 import com.lingnan.supermarket.dao.UserService;
 import com.lingnan.supermarket.dao.impl.BufferImpl;
@@ -40,128 +37,91 @@ import com.lingnan.supermarket.view.HomeView;
 import com.lingnan.supermarket.view.OutView;
 import com.lingnan.supermarket.view.ProdCatalogView.MyItemListener;
 
-// 定义ChangeStatusDialog类，继承JDialog并实现ActionListener接口
-public class ChangeStatusDialog extends JDialog implements ActionListener{
 
-	// 声明面板、标签、按钮等组件
+public class ChangeStatusDialog extends JDialog implements ActionListener{
+	
+	
 	private JPanel statusPanel,opePanel,titlePanel,comboPanel;
 	private JLabel titleLabel,statusLabel;
 	private JButton UpdateBtn,cancelBtn;
 
-	// 声明字符串变量，用于存储订单编号和状态
 	private String iNumber;
 	private String status;
-
-	// 声明一个Vector集合，用于存储InRecord对象
+	
 	private Vector<InRecord> InRecords;
-
-	// 声明一个JComboBox组件，用于显示订单状态选项
+	
 	private JComboBox<String> combo;
 
-	// 声明一个字符串数组，用于存储订单状态选项
 	private String[] log = { "待入库", "已入库", "取消订单" };
-
-	// 声明inRecordServiceImpl对象，用于操作入库记录
+	
 	private inRecordServiceImpl inRecordImpl;
-
-	// 声明一个整数变量，用于存储分类信息
+	
 	private int catalog;
+	
 
-	// 声明productionImpl对象，用于操作商品信息
 	private productionImpl productionImpl;
-
-
-
-
-
-	// 构造方法，接收父窗口、订单编号和状态作为参数
+	
+	
+	
+	
 	public ChangeStatusDialog(JFrame parent,String iNumber,String status) {
-		// 调用父类构造方法，设置对话框标题
 		super(parent,"修改进货订单状态");
-
-		// 设置对话框大小
-		setSize(400,200);
-		// 设置对话框在屏幕中央显示
-		setLocationRelativeTo(null);
-		// 设置对话框为模态
+		
+		setSize(400,200);	
+		setLocationRelativeTo(null);		
 		setModal(true);
-		// 设置对话框不可调整大小
-		setResizable(false);
-		// 设置对话框布局为FlowLayout
+		setResizable(false);		 
 		this.setLayout(new FlowLayout());
-
-		// 初始化成员变量
+		
 		this.iNumber=iNumber;
 		this.status=status;
-		// 初始化视图
 		initView();
 	}
+	
 
-	// 初始化视图的私有方法
+	
+	
 	private void initView() {
 
-		// 创建标题面板
 		titlePanel = new JPanel();
-		// 创建标题标签，显示订单编号
 		titleLabel = new JLabel("修改订单为"+iNumber+"的状态");
-		// 将标题标签添加到标题面板
 		titlePanel.add(titleLabel);
 
-		// 创建状态面板
+	
 		statusPanel = new JPanel();
-		// 创建状态标签，显示当前状态
 		statusLabel = new JLabel("当前状态:"+status);
-		// 将状态标签添加到状态面板
 		statusPanel.add(statusLabel);
+				
 
-
-		// 创建组合框面板
 		comboPanel = new JPanel();
-		// 创建组合框，用于选择订单状态
 		combo = new JComboBox<String>(log);/*下拉表*/
-		// 为组合框添加项目监听器
 		combo.addItemListener(new MyItemListener());
-		// 将组合框添加到组合框面板
 		comboPanel.add(combo);
-
-
-		// 创建操作面板
+		
+		
 		opePanel = new JPanel();
-		// 创建更新按钮
 		UpdateBtn = new JButton("更改");
-		// 创建取消按钮
 		cancelBtn = new JButton("取消");
-		// 为更新按钮添加动作监听器
 		UpdateBtn.addActionListener(this);
-		// 为取消按钮添加动作监听器
 		cancelBtn.addActionListener(this);
-		// 将按钮添加到操作面板
 		opePanel.add(UpdateBtn);
 		opePanel.add(cancelBtn);
-
-		// 获取内容面板
+		
 		Container container = getContentPane();
-		// 将标题面板添加到内容面板的北部
 		container.add(titlePanel,"North");
-		// 将状态面板添加到内容面板的中央
 		container.add(statusPanel,"Center");
-		// 将组合框面板添加到内容面板的南部
 		container.add(comboPanel,"South");
-		// 将操作面板添加到内容面板
 		container.add(opePanel);
-	}
+		
+
+	}	
 
-	// 内部类，实现ItemListener接口，用于监听组合框项目变化
 	public class MyItemListener implements ItemListener {
 
-		// 重写itemStateChanged方法，当组合框项目变化时调用
 		@Override
 		public void itemStateChanged(ItemEvent e) {
-			// 获取触发事件的组合框
 			JComboBox cb = (JComboBox) e.getSource();
-			// 获取选中的项目
 			String catalog1 = (String) cb.getSelectedItem();
-			// 根据选中的项目设置分类变量
 			if (catalog1.equals("已入库")) {
 				catalog = 1;
 			}
@@ -169,143 +129,56 @@ public class ChangeStatusDialog extends JDialog implements ActionListener{
 				catalog = 2;
 			} else if (catalog1.equals("取消订单")) {
 				catalog = 3;
-
 			} 
 
 		}
 
 	}
+	
 
-
-	// 公共方法，返回InRecords向量
 	public Vector<InRecord> getVector(){
-		// 返回InRecords向量
 		return InRecords;
 	}
 
-	// 重写ActionListener接口的actionPerformed方法，用于处理按钮点击事件
+	
 	@Override
 	public void actionPerformed(ActionEvent e) {
-		// 获取事件源对象
 		Object source = e.getSource();
-		// 如果事件源是更新按钮
 		if(source==UpdateBtn){
-			// 打印当前分类变量的值
 			System.out.println("此时此刻的catalog为"+catalog);
-			// 这里修改进货订单表的状态
+			//这里修改进货订单表的状态*/
 			inOrderServiceImpl inOrderImpl = new inOrderServiceImpl();
 			inRecordServiceImpl inRecordImpl = new inRecordServiceImpl();
 			storageRecordImpl storageRecordImpl = new storageRecordImpl();
 			productionImpl = new productionImpl();
 			Production p ;
-			// 获得订单信息
-
-			// 修改订单状态
+			//获得订单信息
+			
+			//修改状态
 			inOrderImpl.updateInOrderStatus(iNumber,catalog);
-			// 确认进货，修改状态并对库存和库存日志进行修改
+			//确认进货，修改状态并对库存和库存日志修改
 			if(catalog==1) {
-				// 获得订单详细信息
+				//获得订单详细信息
 				this.InRecords = inRecordImpl.findByIdinRecord(iNumber);
-				// 遍历订单详细信息，添加库存
+				//遍历添加库存
 				String s[]=TimeAndOrder.TimeAndOrder("");/*生成时间*/
 				for(InRecord i:InRecords) {
-					// 查找到原来的价格
-					// 更新库存表
-					productionImpl.updateProductionSum(i.getId(),i.getSum());
-					// 增加库存日志表记录
+					//查找到原来的价格
+					//更新库存表
+					productionImpl.updateProductionSum(i.getId(),i.getSum());	
+					//增加库存日志表
 					storageRecordImpl.insertStorageRecord(iNumber,s[1], i.getId(),"+", i.getSum());
 				}
-
-				// 弹出订单确认和库存更新成功的提示对话框
+				
 				JOptionPane.showMessageDialog(this,"订单已确认,库存更新成功","提示",JOptionPane.INFORMATION_MESSAGE);
-			}
-			// 刷新首页
+			}		
+			/*刷新首页*/
 			this.dispose();
 
 		}
-		// 如果事件源是取消按钮
 		else if(source == cancelBtn) {
-			// 关闭对话框
+			
 			this.dispose();
-
 		}
 	}
 }
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-

Supermarket/src/com/lingnan/supermarket/dialog/ChangeSumDialog.java

@@ -1,7 +1,5 @@
-// 定义包名，表示该类属于com.lingnan.supermarket.dialog包
 package com.lingnan.supermarket.dialog;
 
-// 导入所需的java.awt和javax.swing包中的类
 import java.awt.Container;
 import java.awt.FlowLayout;
 import java.awt.event.ActionEvent;
@@ -17,7 +15,6 @@ import javax.swing.JPanel;
 import javax.swing.JTable;
 import javax.swing.JTextField;
 
-// 导入项目中的其他包和类
 import com.lingnan.supermarket.*;
 import com.lingnan.supermarket.dao.UserService;
 import com.lingnan.supermarket.dao.impl.BufferImpl;
@@ -29,228 +26,160 @@ import com.lingnan.supermarket.dto.User;
 import com.lingnan.supermarket.table.OutTableModel;
 import com.lingnan.supermarket.view.OutView;
 
-// 定义ChangeSumDialog类，继承JDialog并实现ActionListener接口
-public class ChangeSumDialog extends JDialog implements ActionListener{
 
-	// 声明各种面板
+public class ChangeSumDialog extends JDialog implements ActionListener{
+	
+	
 	private JPanel prodIdPanel,sumPanel,phonePanel,opePanel,titlePanel;
-
-	// 声明标签和文本框
+	
 	private JLabel prodIdLabel,sumLabel,titleLabel;
 	private JTextField prodIdTF,sumTF;
-
-	// 声明按钮
+	
 	private JButton UpdateBtn,cancelBtn;
-
-
-	// 实例化OutTableModel对象
+	
+	
 	private OutTableModel outTableModel = new OutTableModel();
-
-	// 声明Buffer对象
+	
 	private Buffer buffer;
-
-	// 声明字符串变量，用于存储商品ID和标记
+	
 	private String prodId,mark;/*mark用来标记是进货还是出货系统*/
-
-	// 声明一个Vector集合，用于存储Production对象
+	
 	private Vector<Production> v;
-
-	// 带参数的构造方法，初始化对话框并设置属性
+	
 	public ChangeSumDialog(JFrame parent,String prodId,String mark,Vector<Production> v) {
 		super(parent,"更改商品数量");
-
-		// 设置对话框大小
-		setSize(350,200);
-		// 设置对话框相对于父窗口居中
-		setLocationRelativeTo(null);
-		// 设置对话框为模态
+		
+		setSize(350,200);	
+		setLocationRelativeTo(null);		
 		setModal(true);
-		// 设置对话框不可调整大小
-		setResizable(false);
-		// 设置对话框布局为FlowLayout
+		setResizable(false);		 
 		this.setLayout(new FlowLayout());
-
-		// 初始化成员变量
+		
 		this.prodId=prodId;
 		this.mark=mark;
 		this.v = v;
-		// 初始化视图
 		initView();
 	}
-
-	// 另一个带参数的构造方法，初始化对话框并设置属性
+	
 	public ChangeSumDialog(JFrame parent,String prodId,String mark) {
 		super(parent,"更改商品数量");
-
-		// 设置对话框大小
-		setSize(350,200);
-		// 设置对话框相对于父窗口居中
-		setLocationRelativeTo(null);
-		// 设置对话框为模态
+		
+		setSize(350,200);	
+		setLocationRelativeTo(null);		
 		setModal(true);
-		// 设置对话框不可调整大小
-		setResizable(false);
-		// 设置对话框布局为FlowLayout
+		setResizable(false);		 
 		this.setLayout(new FlowLayout());
-
-		// 初始化成员变量
+		
 		this.prodId=prodId;
 		this.mark=mark;
-		// 初始化视图
 		initView();
 	}
-
-
-
-
-
-
-	// 私有方法，用于初始化视图
+	
+	
+	
+	
+	
 	private void initView() {
 
-		// 创建标题面板
 		titlePanel = new JPanel();
-		// 创建标题标签，显示要修改的商品ID
 		titleLabel = new JLabel("修改商品id为"+prodId+"的数量");
-		// 将标题标签添加到标题面板
 		titlePanel.add(titleLabel);
 
-
-
-		// 创建数量输入面板
+		
+		
 		sumPanel = new JPanel();
-		// 创建数量标签
 		sumLabel = new JLabel("数量");
-		// 创建文本框，用于输入数量，宽度为15个字符
 		sumTF = new JTextField(15);
-		// 将数量标签和文本框添加到数量输入面板
 		sumPanel.add(sumLabel);
 		sumPanel.add(sumTF);
-
-
-		// 创建操作按钮面板
+		
+		
 		opePanel = new JPanel();
-		// 创建更新按钮
 		UpdateBtn = new JButton("更改");
-		// 创建取消按钮
 		cancelBtn = new JButton("取消");
-		// 为更新按钮添加事件监听器
 		UpdateBtn.addActionListener(this);
-		// 为取消按钮添加事件监听器
 		cancelBtn.addActionListener(this);
-		// 将更新和取消按钮添加到操作按钮面板
 		opePanel.add(UpdateBtn);
 		opePanel.add(cancelBtn);
-
-		// 获取内容面板
+		
 		Container container = getContentPane();
-		// 将标题面板、数量输入面板和操作按钮面板添加到内容面板
 		container.add(titlePanel);
 		container.add(sumPanel);
 		container.add(opePanel);
-	}
-
-	// 公共方法，用于获取Vector<Production>
+	}	
+	
 	public Vector<Production> getVector(){
 		return v;
 	}
 
-	// 实现ActionListener接口的actionPerformed方法
 	@Override
 	public void actionPerformed(ActionEvent e) {
-		// 获取事件源
 		Object source = e.getSource();
-		// 判断事件源是否为更新按钮
 		if(source==UpdateBtn){
-
+			
 			//TODO 参数校验
 			/*/返回这个记录的信息*/
-
-			// 从文本框中获取数量并转换为整数
+			
 			int sum = Integer.parseInt(sumTF.getText());/*获得数量*/
-			// 打印要修改的数量
 			System.out.println("所要修改的数量sum="+sum);
-
-			// 判断文本框是否为空
+			
 			if(sumTF.getText().equals("")) {
-				// 弹出错误提示对话框
 				JOptionPane.showMessageDialog(this,"请输入完整","提示",JOptionPane.ERROR_MESSAGE);
 				return;
 			}
 
-			// 判断输入的数量是否小于0
 			if(sum<0) {/*判断输入大于0*/
-				// 弹出错误提示对话框
 				JOptionPane.showMessageDialog(this,"请输入大于0的数量","提示",JOptionPane.ERROR_MESSAGE);
 				return;
 			}
-
-
-
-
-
-			// 实例化BufferImpl对象，用于操作缓冲区数据
+			
+			
+			
+			
 			BufferImpl bufferImpl = new BufferImpl();
-
-// 实例化productionImpl对象，用于操作商品数据
+			
 			productionImpl productionImpl = new productionImpl();
-// 创建一个新的Production对象
 			Production production = new Production();
-// 根据商品ID查找商品信息并赋值给production对象
 			production = productionImpl.findByIdProduction(prodId);
-
-// 创建一个新的Buffer对象
+			
 			Buffer buffer = new Buffer();
-// 标志变量，用于表示操作是否成功
 			boolean flag = false;
-
-// 如果标记为"进货"
-			if(mark=="In") {
-				// 遍历购物缓冲区中的商品
+			
+			if(mark=="In") {/*进货界面*/
 				for(Production p:v) {
-					// 如果找到对应ID的商品，则更新其数量
 					if(p.getId().equals(prodId))
 						p.setSum(sum);
 				}
-
+					
 			}
-
-// 如果标记为"出货"
-			else if(mark=="Out") {
-				// 根据商品ID查找缓冲区中的进货记录
+			
+			else if(mark=="Out") {/*出货界面*/
 				buffer = bufferImpl.findInBufferbyId(prodId);
-				// 如果找到了对应的记录
-				if(buffer!=null) {
-					// 如果修改的数量超过库存
-					if(sum>production.getSum())
-						// 弹出错误提示对话框
+				if(buffer!=null) {/*记录有这条数据*/
+					if(sum>production.getSum())/*修改数量超过库存*/
 						JOptionPane.showMessageDialog(this,"库存数量为:"+production.getSum()+",修改数量请勿超过库存","提示",JOptionPane.ERROR_MESSAGE);
 					else
-						// 更新缓冲区中的进货记录，并设置标志变量
 						flag = bufferImpl.UpdateInBufferById(prodId, sum);
-
+				
 				}
-
+	
 			}
+			
 
-// 如果操作成功
-			if(flag = true) {
-				// 弹出修改成功的提示对话框
+			if(flag = true) {/*如果修改成功*/
+									
 				JOptionPane.showMessageDialog(this,"修改成功","提示",JOptionPane.INFORMATION_MESSAGE);
-				// 关闭对话框
 				dispose();
-
+				
 			}else {
-				// 弹出修改失败的提示对话框
 				JOptionPane.showMessageDialog(this,"修改失败","提示",JOptionPane.ERROR_MESSAGE);
-				// 关闭对话框
 				dispose();
 			}
-// 如果事件源是取消按钮
-		}else if(source == cancelBtn) {
-			// 关闭对话框
+		}
+		
+		else if(source == cancelBtn) {
+			
 			this.dispose();
-
 		}
 	}
 }

Supermarket/src/com/lingnan/supermarket/dialog/CloseDialog.java

@@ -29,157 +29,91 @@ import com.lingnan.supermarket.table.OutTableModel;
 import com.lingnan.supermarket.view.MainView;
 import com.lingnan.supermarket.view.OutView;
 
-public class CloseDialog extends JDialog implements ActionListener {
 
-	// Panel用于显示不同的用户信息
-	private JPanel prodIdPanel, sumPanel, phonePanel, opePanel;
-
-	// JLabel组件，显示提示文本
-	private JLabel prodIdLabel, sumLabel;
-
-	// JTextField组件，允许用户输入或显示文本
-	private JTextField prodIdTF, sumTF;
-
-	// JButton组件，用户点击后触发保存、取消等操作
-	private JButton saveBtn, unSaveBtn, cancleBtn;
-
-	// 用于展示商品的表格模型
+public class CloseDialog extends JDialog implements ActionListener{
+	
+	
+	/**
+	 * 
+	 */
+	private JPanel prodIdPanel,sumPanel,phonePanel,opePanel;
+	
+	private JLabel prodIdLabel,sumLabel;
+	private JTextField prodIdTF,sumTF;
+	
+	private JButton saveBtn,unSaveBtn,cancleBtn;
+	
+	
 	private OutTableModel outTableModel = new OutTableModel();
-
-	// 缓冲区操作的实现类，用于处理商品的存储与删除
+	
 	private BufferImpl bufferImpl;
-
-	// 当前用户信息
+	
 	private User user;
-
-	// 购物车中的商品列表
 	private Vector<Production> v;
-
-	/**
-	 * 构造函数，初始化对话框窗口
-	 * @param parent 父窗口
-	 * @param v 购物车中所有的商品信息
-	 */
-	public CloseDialog(JFrame parent, Vector<Production> v) {
-		super(parent, "提示");  // 设置对话框标题
-		setSize(350, 130);  // 设置对话框窗口的大小
-		setLocationRelativeTo(null);  // 将窗口放置在屏幕中央
-		setModal(true);  // 设置对话框为模态，强制用户先处理此窗口才能继续操作其他窗口
-		setResizable(false);  // 不允许调整窗口大小
-		this.setLayout(new FlowLayout());  // 设置窗口的布局方式为流式布局
-
-		this.v = v;  // 将购物车中的商品列表传入此窗口
-
-		initView();  // 初始化界面组件
+	
+	public CloseDialog(JFrame parent,Vector<Production> v) {
+		super(parent,"提示");
+		setSize(350,130);	
+		setLocationRelativeTo(null);		
+		setModal(true);
+		setResizable(false);		 
+		this.setLayout(new FlowLayout());		
+		
+		this.v = v;
+		
+		initView();
 	}
-
-	/**
-	 * 初始化界面组件，设置用户界面元素
-	 */
+	
+	
+	
+	
+	
 	private void initView() {
-		// 创建并初始化显示产品ID的面板
 		prodIdPanel = new JPanel();
 		prodIdLabel = new JLabel("您还未结账，是否保存购物车");
 		prodIdPanel.add(prodIdLabel);
 
-		// 创建操作按钮的面板，并初始化按钮
+		
+		
 		opePanel = new JPanel();
 		saveBtn = new JButton("保存");
 		unSaveBtn = new JButton("不保存");
 		cancleBtn = new JButton("取消");
-
-		// 为按钮添加监听器，当按钮被点击时执行相应的操作
 		saveBtn.addActionListener(this);
 		unSaveBtn.addActionListener(this);
 		cancleBtn.addActionListener(this);
-
-		// 将按钮添加到面板中
 		opePanel.add(saveBtn);
 		opePanel.add(unSaveBtn);
 		opePanel.add(cancleBtn);
-
-		// 获取内容容器，并将各个面板添加到容器中
+		
 		Container container = getContentPane();
-		container.add(prodIdPanel);  // 添加显示提示文本的面板
-		container.add(opePanel);  // 添加操作按钮面板
-
-		debugLog("Initialized CloseDialog view.");  // 输出调试日志，表示界面已经初始化
+		container.add(prodIdPanel);
+		container.add(opePanel);
 	}
 
-	/**
-	 * 按钮点击事件处理方法
-	 * 该方法负责处理每个按钮点击后的相应逻辑
-	 */
 	@Override
 	public void actionPerformed(ActionEvent e) {
-		Object source = e.getSource();  // 获取事件源，判断点击的是哪个按钮
-		bufferImpl = new BufferImpl();  // 创建缓冲区操作实例
-
-		// 处理点击“保存”按钮的逻辑
-		if (source == saveBtn) {
-			debugLog("Save button clicked.");
-			// 遍历购物车中的所有商品，保存到缓冲区
-			for (Production p : v) {
-				debugLog("Saving product: " + p.getName());  // 打印调试信息，显示正在保存的商品
-				bufferImpl.insertInBuffer(p);  // 将商品保存到缓冲区
+		Object source = e.getSource();
+		bufferImpl = new BufferImpl();
+		if(source==saveBtn){/*吧vector数组加入到缓冲区中*/
+			for(Production p:v) {
+				System.out.println("保存数据");
+				bufferImpl.insertInBuffer(p);
 			}
-			// 结束程序
+			
 			System.exit(0);
-		}
-		// 处理点击“不保存”按钮的逻辑
-		else if (source == unSaveBtn) {
-			debugLog("Don't save button clicked.");
-			// 删除所有缓冲区中的商品数据
+		}else if(source==unSaveBtn) {
+			bufferImpl = new BufferImpl();
 			bufferImpl.DelAllOutBuffer();
-			// 结束程序
 			System.exit(0);
-		}
-		// 处理点击“取消”按钮的逻辑
-		else if (source == cancleBtn) {
-			debugLog("Cancel button clicked.");
-			// 关闭对话框，不做任何操作
+		}else if(source==cancleBtn) {
 			setVisible(false);
-		}
-	}
 
-	/**
-	 * 用于输出调试信息的日志方法，便于在控制台追踪程序执行情况
-	 * @param message 调试信息内容
-	 */
-	private void debugLog(String message) {
-		System.out.println("DEBUG: " + message);  // 将调试信息输出到控制台
+		}/*else if(source==WindowEvent)*/
 	}
 
-	/**
-	 * 在窗口关闭时的额外操作
-	 * 例如，用户点击关闭按钮时，执行一些清理操作
-	 * @param we 窗口事件
-	 */
-	public void windowClosing(WindowEvent we) {
-		debugLog("Window is closing.");
-	}
 
-	public void windowClosed(WindowEvent we) {
-		debugLog("Window closed.");
-	}
 
-	public void windowOpened(WindowEvent we) {
-		debugLog("Window opened.");
-	}
 
-	public void windowIconified(WindowEvent we) {
-		debugLog("Window minimized.");
-	}
 
-	public void windowDeiconified(WindowEvent we) {
-		debugLog("Window restored.");
-	}
-
-	public void windowActivated(WindowEvent we) {
-		debugLog("Window activated.");
-	}
-
-	public void windowDeactivated(WindowEvent we) {
-		debugLog("Window deactivated.");
-	}
 }

Supermarket/src/com/lingnan/supermarket/dialog/InDialog.java

@@ -29,158 +29,197 @@ import com.lingnan.supermarket.dto.User;
 import com.lingnan.supermarket.table.OutTableModel;
 import com.lingnan.supermarket.view.InView;
 import com.lingnan.supermarket.view.OutView;
-
-// 定义一个继承自JDialog的类InDialog，用于显示添加商品的对话框
-public class InDialog extends JDialog implements ActionListener {
-
-	// 定义面板、标签、文本框、按钮等组件
-	private JPanel prodIdPanel, sumPanel, phonePanel, opePanel;
-	private JLabel prodIdLabel, sumLabel;
-	private JTextField prodIdTF, sumTF;
-	private JButton addBtn, cancelBtn;
-
-	// 定义OutTableModel对象，用于表格数据模型
+import com.lingnan.supermarket.view.ProdCatalogView.MyItemListener;
+
+
+public class InDialog extends JDialog implements ActionListener{
+	
+	
+	private JPanel prodIdPanel,sumPanel,phonePanel,opePanel;
+	
+	private JLabel prodIdLabel,sumLabel;
+	private JTextField prodIdTF,sumTF;
+	
+	private JButton addBtn,cancelBtn;
+	
+	
 	private OutTableModel outTableModel = new OutTableModel();
-
-	// 定义Production对象和productionImpl对象，用于处理商品数据
+	
 	private Production production;
 	private productionImpl productionImpl;
-
-	// 定义Vector集合，用于存储商品数据
+	
 	private Vector<Production> v;
-
-	// 定义User对象，用于存储用户信息
+	
 	private User user;
-
-	// 定义JFrame对象，用于存储父窗口
+	
 	private JFrame JFramparent;
-
-	// 定义JComboBox对象和字符串数组，用于商品编号选择
+	
 	private JComboBox<String> combo;
 	private String allProdId[] = null;
 	private Vector<Production> vAll;
 	private static String catalog;
-
-	// 构造方法，初始化对话框并设置相关属性
-	public InDialog(JFrame parent, Vector<Production> v, User user) {
-		super(parent, "添加商品"); // 调用父类构造方法，设置对话框标题
-
-		setSize(250, 200); // 设置对话框大小
-		setLocationRelativeTo(null); // 设置对话框居中显示
-		setModal(true); // 设置对话框为模态对话框
-		setResizable(false); // 禁止调整对话框大小
-		this.setLayout(new FlowLayout()); // 设置布局为流式布局
-		JFramparent = parent; // 保存父窗口
-		this.v = v; // 保存商品数据集合
-		this.user = user; // 保存用户信息
-		initView(); // 初始化界面
+	
+	public InDialog(JFrame parent,Vector<Production> v,User user) {
+		super(parent,"添加商品");
+		
+		setSize(250,200);	
+		setLocationRelativeTo(null);		
+		setModal(true);
+		setResizable(false);		 
+		this.setLayout(new FlowLayout());
+		JFramparent=parent;
+		this.v=v;
+		this.user = user;
+		initView();
+		
+		
 	}
-
-	// 初始化界面方法
+	
+	
+	
+	
+	
 	private void initView() {
-		prodIdPanel = new JPanel(); // 创建商品编号面板
-		prodIdLabel = new JLabel("编号"); // 创建商品编号标签
-
-		productionImpl = new productionImpl(); // 创建productionImpl对象
-		vAll = productionImpl.findAllproduction(); // 获取所有商品数据
-		allProdId = new String[vAll.size()]; // 初始化商品编号数组
-		for (int i = 0; i < vAll.size(); i++) {
-			allProdId[i] = vAll.elementAt(i).getId(); // 将商品编号存入数组
+		prodIdPanel = new JPanel();
+		prodIdLabel = new JLabel("编号");
+		
+
+		productionImpl= new productionImpl();
+		vAll=productionImpl.findAllproduction();
+		allProdId = new String[vAll.size()];
+		for(int i=0;i<vAll.size();i++) {
+			allProdId[i]=vAll.elementAt(i).getId();
 		}
-		catalog = allProdId[0]; // 默认选择第一个商品编号
-		System.out.println(allProdId[0]); // 打印默认商品编号
-		combo = new JComboBox<String>(allProdId); // 创建商品编号下拉框
-		combo.addItemListener(new MyItemListener()); // 添加下拉框监听器
-
-		prodIdPanel.add(prodIdLabel); // 将商品编号标签添加到面板
-		prodIdPanel.add(combo); // 将商品编号下拉框添加到面板
-
-		sumPanel = new JPanel(); // 创建数量面板
-		sumLabel = new JLabel("数量"); // 创建数量标签
-		sumTF = new JTextField(10); // 创建数量文本框
-		sumPanel.add(sumLabel); // 将数量标签添加到面板
-		sumPanel.add(sumTF); // 将数量文本框添加到面板
-
-		opePanel = new JPanel(); // 创建操作面板
-		addBtn = new JButton("添加"); // 创建添加按钮
-		cancelBtn = new JButton("取消"); // 创建取消按钮
-		addBtn.addActionListener(this); // 为添加按钮添加事件监听器
-		cancelBtn.addActionListener(this); // 为取消按钮添加事件监听器
-		opePanel.add(addBtn); // 将添加按钮添加到面板
-		opePanel.add(cancelBtn); // 将取消按钮添加到面板
-
-		Container container = getContentPane(); // 获取内容面板
-		container.add(prodIdPanel); // 将商品编号面板添加到内容面板
-		container.add(sumPanel); // 将数量面板添加到内容面板
-		container.add(opePanel); // 将操作面板添加到内容面板
+		catalog = allProdId[0];
+		System.out.println(allProdId[0]);
+		combo = new JComboBox<String>(allProdId);
+		combo.addItemListener(new MyItemListener());
+		
+		prodIdPanel.add(prodIdLabel);
+		prodIdPanel.add(combo);
+		
+		
+		
+		sumPanel = new JPanel();
+		sumLabel = new JLabel("数量");
+		sumTF = new JTextField(10);
+		sumPanel.add(sumLabel);
+		sumPanel.add(sumTF);
+		
+		
+		opePanel = new JPanel();
+		addBtn = new JButton("添加");
+		cancelBtn = new JButton("取消");
+		addBtn.addActionListener(this);
+		cancelBtn.addActionListener(this);
+		opePanel.add(addBtn);
+		opePanel.add(cancelBtn);
+		
+		Container container = getContentPane();
+		container.add(prodIdPanel);
+		container.add(sumPanel);
+		container.add(opePanel);
 	}
-
-	// 获取商品数据集合的方法
-	public Vector<Production> getVector() {
-		return v; // 返回商品数据集合
+	
+	/*将数组传到inview的刷新方法里面再刷新*/
+	public Vector<Production> getVector(){
+		return v;
 	}
+	
+	
+	//下拉框监听
+	static class MyItemListener implements ItemListener{
 
-	// 下拉框监听器类
-	static class MyItemListener implements ItemListener {
 		@Override
 		public void itemStateChanged(ItemEvent e) {
-			JComboBox cb = (JComboBox) e.getSource(); // 获取事件源
-			String select = (String) cb.getSelectedItem(); // 获取选中的商品编号
-			catalog = select; // 更新当前选中的商品编号
+			JComboBox cb=(JComboBox)e.getSource();
+			String select=(String) cb.getSelectedItem();
+			catalog=select;
 		}
+		
 	}
+	
+	
+	
+	
+	
+	
+	
 
-	// 事件处理方法
 	@Override
 	public void actionPerformed(ActionEvent e) {
-		Object source = e.getSource(); // 获取事件源
-		if (source == addBtn) { // 如果事件源是添加按钮
-			String prodId = catalog; // 获取选中的商品编号
-			System.out.println("proId=" + prodId); // 打印商品编号
-			System.out.println("vatalog=" + catalog); // 打印当前选中的商品编号
-
-			if (sumTF.getText().equals("")) { // 如果数量文本框为空
-				JOptionPane.showMessageDialog(this, "请输入完整", "提示", JOptionPane.ERROR_MESSAGE); // 提示输入完整信息
+		Object source = e.getSource();
+		if(source==addBtn){
+			//1.判断是否存在这个商品
+			//2.如果存在就获取这条商品记录为一个对象
+			//3.判断购物缓冲区是否有这个记录
+				//3.1如果有update数量和price
+				//3.2如果没有就insert这条记录，把sum更新
+			//保存到数据库
+			//关闭对话框
+			//刷新table
+			
+
+			String prodId =catalog;
+			System.out.println("proId="+prodId);
+			System.out.println("vatalog="+catalog);
+			
+			if(sumTF.getText().equals("")) {
+				JOptionPane.showMessageDialog(this,"请输入完整","提示",JOptionPane.ERROR_MESSAGE);
 				return;
 			}
-			int sum = Integer.parseInt(sumTF.getText()); // 获取输入的数量
+			int sum =  Integer.parseInt(sumTF.getText()) ;
 
-			if (sum < 0) { // 如果数量小于0
-				JOptionPane.showMessageDialog(this, "请输入大于0的数量", "提示", JOptionPane.ERROR_MESSAGE); // 提示输入大于0的数量
+			if(sum<0) {/*判断输入大于0*/
+				JOptionPane.showMessageDialog(this,"请输入大于0的数量","提示",JOptionPane.ERROR_MESSAGE);
 				return;
 			}
+			
+			//TODO 参数校验
+			/*/判断是已添加,未添加还是不存在*/
+			productionImpl productionImpl = new productionImpl();
+			production = new Production();
+			production = productionImpl.findByIdProduction(prodId);
 
-			// 参数校验
-			productionImpl productionImpl = new productionImpl(); // 创建productionImpl对象
-			production = new Production(); // 创建Production对象
-			production = productionImpl.findByIdProduction(prodId); // 根据商品编号查找商品
 
-			if (production != null) { // 如果商品存在
+			if(production!=null) {/*商品库有这个商品存在*/
 				int mark = 0;
-				for (Production p : v) { // 遍历商品数据集合
-					if (p.getId().equals(prodId)) { // 如果集合中存在相同商品
-						sum = p.getSum() + sum; // 更新数量
-						p.setSum(sum); // 设置数量
-						p.setPrice(sum * p.getInPrice()); // 更新价格
-						mark = 1; // 标记为已存在
+				for(Production p:v) {
+					
+					if(p.getId().equals(prodId)){/*如果数组中存在相同商品就更新数量和价格*/
+						sum=p.getSum()+sum;/*数量*/
+						p.setSum(sum);
+						p.setPrice(sum*p.getInPrice());/*进货价格*/
+						mark = 1;
 						break;
 					}
+					
 				}
-				if (mark == 0) { // 如果集合中不存在相同商品
+				if(mark==0) {/*插入新的*/
 					System.out.println("缓存区不存在，插入新的数据");
-					production.setSum(sum); // 设置数量
-					production.setPrice(sum * production.getInPrice()); // 设置价格
-					v.add(production); // 将商品添加到集合
-				}
+					production.setSum(sum);/*更新价格和数量后插入心的*/
+					production.setPrice(sum*production.getInPrice());
+					v.add(production);
 
-				System.out.println("插入后v的大小" + v.size()); // 打印集合大小
-				this.dispose(); // 关闭对话框
-				JOptionPane.showMessageDialog(this, "添加成功", "提示", JOptionPane.ERROR_MESSAGE); // 提示添加成功
-			} else { // 如果商品不存在
-				JOptionPane.showMessageDialog(this, "商品不存在", "提示", JOptionPane.ERROR_MESSAGE); // 提示商品不存在
-			}
-		} else if (source == cancelBtn) { // 如果事件源是取消按钮
-			this.dispose(); // 关闭对话框
+					}
+				
+				System.out.println("插入后v的大小"+v.size());
+				this.dispose();
+				JOptionPane.showMessageDialog(this,"添加成功","提示",JOptionPane.ERROR_MESSAGE);
+		
+			
+		}
+
+			
+				else {/*商品库没有这个商品*/
+					JOptionPane.showMessageDialog(this,"商品不存在","提示",JOptionPane.ERROR_MESSAGE);
+				}
+		}
+		else if(source == cancelBtn) {
+			
+			this.dispose();
 		}
 	}
-}
+
+
+}

Supermarket/src/com/lingnan/supermarket/dialog/OutDialog.java

@@ -11,6 +11,7 @@ import javax.swing.JFrame;
 import javax.swing.JLabel;
 import javax.swing.JOptionPane;
 import javax.swing.JPanel;
+import javax.swing.JTable;
 import javax.swing.JTextField;
 
 import com.lingnan.supermarket.*;
@@ -25,134 +26,140 @@ import com.lingnan.supermarket.table.OutTableModel;
 import com.lingnan.supermarket.view.OutView;
 
 
-public class OutDialog extends JDialog implements ActionListener {
-
-	// 定义JPanel组件，用于组织界面元素
-	private JPanel prodIdPanel, sumPanel, phonePanel, opePanel;
-
-	// 定义JLabel用于显示文本
-	private JLabel prodIdLabel, sumLabel;
-
-	// 定义JTextField用于输入商品ID和数量
-	private JTextField prodIdTF, sumTF;
-
-	// 定义JButton按钮，用于添加商品和取消操作
-	private JButton addBtn, cancelBtn;
-
-	// 创建OutTableModel对象，用于管理表格数据
+public class OutDialog extends JDialog implements ActionListener{
+	
+	
+	private JPanel prodIdPanel,sumPanel,phonePanel,opePanel;
+	
+	private JLabel prodIdLabel,sumLabel;
+	private JTextField prodIdTF,sumTF;
+	
+	private JButton addBtn,cancelBtn;
+	
+	
 	private OutTableModel outTableModel = new OutTableModel();
-
-	// 创建Buffer对象，用于暂存添加的商品信息
+	
 	private Buffer buffer;
-
-	// 构造函数，初始化对话框，设置窗口属性
+	
 	public OutDialog(JFrame parent) {
-		super(parent, "添加商品");
-
-		setSize(350, 300);    // 设置窗口大小
-		setLocationRelativeTo(null); // 设置窗口居中
-		setModal(true);        // 设置为模态对话框，阻止父窗口操作
-		setResizable(false);   // 设置不可调整窗口大小
-		this.setLayout(new FlowLayout());  // 设置布局方式为流式布局
-
-		initView();  // 调用初始化界面方法
+		super(parent,"添加商品");
+		
+		setSize(350,300);	
+		setLocationRelativeTo(null);		
+		setModal(true);
+		setResizable(false);		 
+		this.setLayout(new FlowLayout());
+		
+		initView();
 	}
-
-	// 初始化界面方法
+	
+	
+	
+	
+	
 	private void initView() {
-		// 创建商品ID输入面板
 		prodIdPanel = new JPanel();
 		prodIdLabel = new JLabel("编号");
-		prodIdTF = new JTextField(15); // 设置商品ID的文本框长度为15
-		prodIdPanel.add(prodIdLabel);  // 将标签添加到面板
-		prodIdPanel.add(prodIdTF);     // 将文本框添加到面板
-
-		// 创建数量输入面板
+		prodIdTF = new JTextField(15);
+		prodIdPanel.add(prodIdLabel);
+		prodIdPanel.add(prodIdTF);
+		
+		
 		sumPanel = new JPanel();
 		sumLabel = new JLabel("数量");
-		sumTF = new JTextField(15);    // 设置数量的文本框长度为15
-		sumPanel.add(sumLabel);        // 将标签添加到面板
-		sumPanel.add(sumTF);           // 将文本框添加到面板
-
-		// 创建操作按钮面板
+		sumTF = new JTextField(15);
+		sumPanel.add(sumLabel);
+		sumPanel.add(sumTF);
+		
+		
 		opePanel = new JPanel();
 		addBtn = new JButton("添加");
 		cancelBtn = new JButton("取消");
-		addBtn.addActionListener(this); // 添加按钮的事件监听
-		cancelBtn.addActionListener(this); // 取消按钮的事件监听
-		opePanel.add(addBtn);      // 将添加按钮添加到面板
-		opePanel.add(cancelBtn);   // 将取消按钮添加到面板
-
-		// 将所有面板添加到容器中
+		addBtn.addActionListener(this);
+		cancelBtn.addActionListener(this);
+		opePanel.add(addBtn);
+		opePanel.add(cancelBtn);
+		
 		Container container = getContentPane();
-		container.add(prodIdPanel);  // 添加商品ID面板
-		container.add(sumPanel);     // 添加数量面板
-		container.add(opePanel);     // 添加操作按钮面板
+		container.add(prodIdPanel);
+		container.add(sumPanel);
+		container.add(opePanel);
 	}
 
-	// 实现ActionListener接口的actionPerformed方法，处理按钮点击事件
 	@Override
 	public void actionPerformed(ActionEvent e) {
-		Object source = e.getSource();  // 获取触发事件的源对象
-		if (source == addBtn) {  // 如果点击了"添加"按钮
-
-			// 获取商品ID和数量输入框的值
-			String prodId = prodIdTF.getText();
-			System.out.println("proId=" + prodId);
-
-			// 判断输入框是否为空
-			if (prodIdTF.getText().equals("") || sumTF.getText().equals("")) {
-				JOptionPane.showMessageDialog(this, "请输入完整", "提示", JOptionPane.ERROR_MESSAGE);
-				return; // 如果为空，弹出提示框并返回
+		Object source = e.getSource();
+		if(source==addBtn){
+			//1.判断是否存在这个商品
+			//2.如果存在就获取这条商品记录为一个对象
+			//3.判断购物缓冲区是否有这个记录
+				//3.1如果有update数量和price
+				//3.2如果没有就insert这条记录，把sum更新
+			//保存到数据库
+			//关闭对话框
+			//刷新table
+			
+			String prodId =prodIdTF.getText();
+			System.out.println("proId="+prodId);
+			if(prodIdTF.getText().equals("")||sumTF.getText().equals("")) {
+				JOptionPane.showMessageDialog(this,"请输入完整","提示",JOptionPane.ERROR_MESSAGE);
+				return;
 			}
-
-			// 获取数量并进行格式化转换
-			int sum = Integer.parseInt(sumTF.getText());
-
-			// 判断数量是否为负数
-			if (sum < 0) {
-				JOptionPane.showMessageDialog(this, "请输入大于0的数量", "提示", JOptionPane.ERROR_MESSAGE);
-				return; // 如果为负数，弹出提示框并返回
+			int sum =  Integer.parseInt(sumTF.getText()) ;
+			if(sum<0) {/*判断输入大于0*/
+				JOptionPane.showMessageDialog(this,"请输入大于0的数量","提示",JOptionPane.ERROR_MESSAGE);
+				return;
 			}
-
-			// 创建生产商品的实现对象，查询商品库
+			
+			//TODO 参数校验
+			/*/判断是已添加,未添加还是不存在*/
 			productionImpl productionImpl = new productionImpl();
 			Production production = new Production();
-			production = productionImpl.findByIdProduction(prodId);  // 根据商品ID查询商品
-
-			if (production != null) {  // 如果商品存在
-				buffer = new Buffer();  // 创建缓冲区对象
-				BufferImpl bufferImpl = new BufferImpl();
-				buffer = bufferImpl.findOutBufferbyId(prodId);  // 查找购物车是否已存在该商品
-
-				int allSum = production.getSum();  // 获取商品的库存数量
-
-				// 如果商品库存不足，弹出提示框并返回
-				if (sum > allSum) {
-					JOptionPane.showMessageDialog(this, "库存数量不够，库存数:" + allSum, "提示", JOptionPane.ERROR_MESSAGE);
+			production = productionImpl.findByIdProduction(prodId);
+
+
+			if(production!=null) {/*商品库有这个商品存在*/
+				
+				buffer =  new Buffer();
+				BufferImpl BufferImpl = new BufferImpl();			
+				buffer = BufferImpl.findOutBufferbyId(prodId);/*判断购物车是否有这个商品了,获得已添加的sum和价格*/
+				
+				int allSum = production.getSum();
+				
+				if(sum<0) {
+					JOptionPane.showMessageDialog(this,"请输入大于0的数量","提示",JOptionPane.ERROR_MESSAGE);
 					return;
 				}
-
-				// 如果购物车中已经有该商品，更新数量和价格
-				if (buffer != null) {
-					int exeistSum = buffer.getSum();  // 获取购物车中该商品已有的数量
-					if (sum + exeistSum > allSum) {  // 判断购物车中商品数量加起来是否超过库存
-						JOptionPane.showMessageDialog(this, "库存数量不够，库存数:" + allSum, "提示", JOptionPane.ERROR_MESSAGE);
-						return;  // 如果超过库存，弹出提示框并返回
-					} else {
-						bufferImpl.addOutBufferExeistProd(prodId, sum, buffer);  // 更新购物车中的商品数量
-					}
-				} else {  // 如果购物车中没有该商品
-					bufferImpl.addOutBufferNewProd(prodId, sum);  // 将商品添加到购物车
+				
+				if(buffer!=null)/*购物缓冲区已经有添加的商品*/{
+					int exeistSum = buffer.getSum();
+					if(sum+exeistSum>allSum)/*库存不够*/{
+						JOptionPane.showMessageDialog(this,"库存数量不够，库存数:"+allSum,"提示",JOptionPane.ERROR_MESSAGE);
+						return;
+					}else
+						BufferImpl.addOutBufferExeistProd(prodId, sum, buffer);
+					
+				}
+				else if(buffer==null){/*添加新的商品*/
+					if(sum>allSum)/*库存不够*/{
+						JOptionPane.showMessageDialog(this,"库存数量不够，库存数:"+allSum,"提示",JOptionPane.ERROR_MESSAGE);
+						return;
+					}else
+					BufferImpl.addOutBufferNewProd(prodId, sum);
 				}
 
-				this.dispose();  // 关闭当前对话框
-				JOptionPane.showMessageDialog(this, "添加成功", "提示", JOptionPane.INFORMATION_MESSAGE);  // 弹出添加成功提示
-			} else {  // 如果商品不存在
-				JOptionPane.showMessageDialog(this, "商品不存在", "提示", JOptionPane.ERROR_MESSAGE);  // 弹出商品不存在提示
+				this.dispose();
+				JOptionPane.showMessageDialog(this,"添加成功","提示",JOptionPane.ERROR_MESSAGE);
+
+			}
+			
+			else {
+				JOptionPane.showMessageDialog(this,"商品不存在","提示",JOptionPane.ERROR_MESSAGE);
 			}
-		} else if (source == cancelBtn) {  // 如果点击了"取消"按钮
-			this.dispose();  // 关闭当前对话框
+		}
+		else if(source == cancelBtn) {
+			
+			this.dispose();
 		}
 	}
 }

Supermarket/src/com/lingnan/supermarket/dialog/ProductionDialog.java

@@ -17,6 +17,7 @@ import javax.swing.JOptionPane;
 import javax.swing.JPanel;
 import javax.swing.JTextField;
 
+import com.lingnan.supermarket.*;
 import com.lingnan.supermarket.dao.SupplierInfService;
 import com.lingnan.supermarket.dao.productionService;
 import com.lingnan.supermarket.dao.impl.SupplierInfImpl;
@@ -27,179 +28,172 @@ import com.lingnan.supermarket.dto.Production;
 import com.lingnan.supermarket.dto.SupplierInf;
 import com.lingnan.supermarket.table.ProdCatalogTM;
 import com.lingnan.supermarket.view.StorageView;
+import com.lingnan.supermarket.view.SupplierView;
+import com.lingnan.supermarket.view.ProdCatalogView.MyItemListener;
 
-/**
- * 商品信息添加对话框类
- * 继承自JDialog，用于显示商品信息添加界面
- */
 public class ProductionDialog extends JDialog implements ActionListener {
 
-	// 定义各个面板，用于组织界面布局
 	private JPanel namePanel, addressPanel, contactPanel,
-			opePanel, idPanel, inpricePanel, outpricePanel, lifePanel,
-			sumPanel, supplyidPanel, id2Panel, name2Panel;
+	opePanel,idPanel,inpricePanel,outpricePanel,lifePanel,
+	sumPanel,supplyidPanel,id2Panel,name2Panel;
 
-	// 定义各个标签，用于显示提示信息
 	private JLabel nameLabel, addressLabel, contactLabel,
-			idLabel, inpriceLabel, outpriceLabel, lifeLabel, sumLabel,
-			supplyidLabel, id2Label, name2Label;
-
-	// 定义各个文本框，用于用户输入数据
+	idLabel,inpriceLabel,outpriceLabel,lifeLabel,sumLabel,
+	supplyidLabel,id2Label,name2Label;
 	private JTextField nameTF, addressTF, contactTF,
-			idTF, inpriceTF, outpriceTF, lifeTF, sumTF,
-			supplyidTF, id2TF, name2TF;
+	idTF,inpriceTF,outpriceTF,lifeTF,sumTF,
+	supplyidTF,id2TF,name2TF;
 
-	// 定义保存和取消按钮
 	private JButton saveBtn, cancelBtn;
 
-	// 商品服务接口的实现类，用于操作商品数据
 	private productionService productionService = new productionImpl();
+	
+	//下拉类别
+	private String log[]=null;
+	private ArrayList<String>alog=null;
+	private ProdCatalogTM prodCatalogTM;
+	private ProdCatalog pc;
+	private prodCatalogImpl pci;
+	private JComboBox<String> combo;
+	private String id2;
+	private String name2;
+	
+	//下拉供应商类别
+	private String superlier[]=null;
+	private ArrayList<String>asuperlier=null;
+	private SupplierInf si;
+	private SupplierInfImpl sii;
+	private JComboBox<String> combo1;
+	private int supplyid;
+
+	private StorageView storageView;
+
+	private Production production;
 
-	// 下拉类别相关变量
-	private String log[] = null; // 商品类别名称数组
-	private ArrayList<String> alog = null; // 商品类别名称列表
-	private ProdCatalogTM prodCatalogTM; // 商品类别表格模型
-	private ProdCatalog pc; // 商品类别对象
-	private prodCatalogImpl pci; // 商品类别服务实现类
-	private JComboBox<String> combo; // 商品类别下拉框
-	private String id2; // 商品类别ID
-	private String name2; // 商品类别名称
-
-	// 下拉供应商类别相关变量
-	private String superlier[] = null; // 供应商名称数组
-	private ArrayList<String> asuperlier = null; // 供应商名称列表
-	private SupplierInf si; // 供应商对象
-	private SupplierInfImpl sii; // 供应商服务实现类
-	private JComboBox<String> combo1; // 供应商下拉框
-	private int supplyid; // 供应商ID
-
-	private StorageView storageView; // 库存视图
-
-	private Production production; // 商品对象
-
-	/**
-	 * 构造函数，初始化对话框
-	 * @param parent 父窗口
-	 */
 	public ProductionDialog(JFrame parent) {
-		super(parent, "添加"); // 调用父类构造函数，设置标题为“添加”
+		super(parent, "添加");
+		
 
-		// 设置对话框大小
 		setSize(350, 500);
 
-		// 设置对话框居中显示
 		setLocationRelativeTo(null);
 
-		// 设置为模态对话框，即打开对话框时，父窗口不可操作
 		setModal(true);
-		setResizable(false); // 禁止调整对话框大小
+		setResizable(false);
 
-		// 设置布局为流式布局
 		this.setLayout(new FlowLayout());
 
-		// 初始化视图
 		initView();
 	}
 
-	/**
-	 * 初始化视图
-	 */
 	private void initView() {
-		// 商品编号面板
 		idPanel = new JPanel();
 		idLabel = new JLabel("商品编号");
 		idTF = new JTextField(15);
 		idPanel.add(idLabel);
 		idPanel.add(idTF);
 
-		// 商品名称面板
+		
 		namePanel = new JPanel();
 		nameLabel = new JLabel("名称");
 		nameTF = new JTextField(15);
 		namePanel.add(nameLabel);
 		namePanel.add(nameTF);
-
-		// 进货单价面板
+		
+		
 		inpricePanel = new JPanel();
 		inpriceLabel = new JLabel("进货单价");
 		inpriceTF = new JTextField(15);
 		inpricePanel.add(inpriceLabel);
 		inpricePanel.add(inpriceTF);
-
-		// 购买单价面板
+		
 		outpricePanel = new JPanel();
 		outpriceLabel = new JLabel("购买单价");
 		outpriceTF = new JTextField(15);
 		outpricePanel.add(outpriceLabel);
 		outpricePanel.add(outpriceTF);
-
-		// 保质期面板
+		
+		
 		lifePanel = new JPanel();
 		lifeLabel = new JLabel("保质期(月份数)");
 		lifeTF = new JTextField(15);
 		lifePanel.add(lifeLabel);
 		lifePanel.add(lifeTF);
-
-		// 库存面板
+		
+		
 		sumPanel = new JPanel();
 		sumLabel = new JLabel("库存");
 		sumTF = new JTextField(15);
 		sumPanel.add(sumLabel);
 		sumPanel.add(sumTF);
-
-		// 供应商名下拉框面板
+		
+		//供应商名下拉框 传递supplyid
 		supplyidPanel = new JPanel();
 		supplyidLabel = new JLabel("供应商");
-		sii = new SupplierInfImpl(); // 创建供应商服务实现类对象
-		this.asuperlier = sii.findNameSupplier(); // 获取所有供应商名称
-		this.superlier = new String[asuperlier.size()]; // 初始化供应商名称数组
-		for (int i = 0; i < asuperlier.size(); i++)
-			superlier[i] = asuperlier.get(i); // 将供应商名称存入数组
-
-		combo1 = new JComboBox<String>(superlier); // 创建供应商下拉框
-		combo1.addItemListener(new MyItemListener1()); // 添加下拉框监听器
-
+//		supplyidTF = new JTextField(15);
+		
+		sii=new SupplierInfImpl();
+		this.asuperlier=sii.findNameSupplier();
+		this.superlier=new String[asuperlier.size()];
+		for(int i=0;i<asuperlier.size();i++)
+			superlier[i]=asuperlier.get(i);
+		
+		for(int i=0;i<superlier.length;i++)
+		{
+		System.out.println(superlier[i]);
+		}
+		
+		combo1 = new JComboBox<String>(superlier);
+		combo1.addItemListener(new MyItemListener1());
+		
 		supplyidPanel.add(supplyidLabel);
 		supplyidPanel.add(combo1);
-
-		// 类名下拉框面板
+		
+		
+		
+		
+		
+	/*	id2Panel = new JPanel();
+		id2Label = new JLabel("分类id");
+		id2TF = new JTextField(id2,15);
+		id2Panel.add(id2Label);
+		id2Panel.add(id2TF);*/
+		//类名下拉框
 		name2Panel = new JPanel();
 		name2Label = new JLabel("类名");
-		pci = new prodCatalogImpl(); // 创建商品类别服务实现类对象
-		this.alog = pci.findNameProdCatalog(); // 获取所有商品类别名称
-		this.log = new String[alog.size()]; // 初始化商品类别名称数组
-		for (int i = 0; i < alog.size(); i++)
-			log[i] = alog.get(i); // 将商品类别名称存入数组
-
-		combo = new JComboBox<String>(log); // 创建商品类别下拉框
-		combo.addItemListener(new MyItemListener()); // 添加下拉框监听器
+		pci=new prodCatalogImpl();
+		this.alog=pci.findNameProdCatalog();
+		this.log=new String[alog.size()];
+		for(int i=0;i<alog.size();i++)
+		log[i]=alog.get(i);
+	
+		
+		combo = new JComboBox<String>(log);
+		combo.addItemListener(new MyItemListener());
 		name2Panel.add(name2Label);
 		name2Panel.add(combo);
 
-		// 地址面板
+		
 		addressPanel = new JPanel();
 		addressLabel = new JLabel("地址");
 		addressTF = new JTextField(15);
 		addressPanel.add(addressLabel);
 		addressPanel.add(addressTF);
 
-		// 电话面板
 		contactPanel = new JPanel();
 		contactLabel = new JLabel("电话");
 		contactTF = new JTextField(15);
 		contactPanel.add(contactLabel);
 		contactPanel.add(contactTF);
 
-		// 操作按钮面板
 		opePanel = new JPanel();
 		saveBtn = new JButton("保存");
 		cancelBtn = new JButton("取消");
-		saveBtn.addActionListener(this); // 添加保存按钮监听器
-		cancelBtn.addActionListener(this); // 添加取消按钮监听器
+		saveBtn.addActionListener(this);
+		cancelBtn.addActionListener(this);
 		opePanel.add(saveBtn);
 		opePanel.add(cancelBtn);
 
-		// 将所有面板添加到容器中
 		Container container = getContentPane();
 		container.add(idPanel);
 		container.add(namePanel);
@@ -208,45 +202,47 @@ public class ProductionDialog extends JDialog implements ActionListener {
 		container.add(lifePanel);
 		container.add(sumPanel);
 		container.add(supplyidPanel);
+//		container.add(id2Panel);
 		container.add(name2Panel);
 		container.add(opePanel);
 	}
 
-	/**
-	 * 按钮点击事件处理
-	 * @param e 事件对象
-	 */
 	@Override
 	public void actionPerformed(ActionEvent e) {
 		Object source = e.getSource();
 		if (source == saveBtn) {
-			// 获取输入的数据
+			// 思路获取数据
+			// 保存到数据库
+			// 关闭对话框
+			// 刷新table
+
 			String name = nameTF.getText();
 			String id = idTF.getText();
 			float inprice = Float.parseFloat((inpriceTF.getText()));
 			float outprice = Float.parseFloat(outpriceTF.getText());
 			int life = Integer.parseInt(lifeTF.getText());
 			int sum = Integer.parseInt(sumTF.getText());
+			
+			
 
-			// 参数校验
+			// TODO 参数校验
 			if (this.production == null) {
-				if (supplyid == -1) {
+				if(supplyid==-1){
 					JOptionPane.showMessageDialog(this, "商品检索出错", "提示",
 							JOptionPane.ERROR_MESSAGE);
 					return;
 				}
-				if (supplyid == 0) {
+				if(supplyid==0){
 					JOptionPane.showMessageDialog(this, "请选择商品名", "提示",
 							JOptionPane.ERROR_MESSAGE);
 					return;
 				}
-				if (id2.equals("0")) {
+				if(id2.equals("0")){
 					JOptionPane.showMessageDialog(this, "请选择商品类", "提示",
 							JOptionPane.ERROR_MESSAGE);
 					return;
 				}
-
-				// 创建商品对象并设置属性
+				
 				Production production = new Production();
 				production.setId(id);
 				production.setName(name);
@@ -256,59 +252,70 @@ public class ProductionDialog extends JDialog implements ActionListener {
 				production.setSum(sum);
 				production.setSupplyId(supplyid);
 				production.setId2(id2);
-				production.setName2(name2);
-
-				// 调用服务接口添加商品
+				production.setName2(name2);				
 				int result = productionService.addProduction(production);
+				// int result = 1;
 				if (result == 1) {
+
 					JOptionPane.showMessageDialog(this, "添加成功", "提示",
 							JOptionPane.INFORMATION_MESSAGE);
-					this.dispose(); // 关闭对话框
-				} else if (result == 2) {
+					this.dispose();
+				} else if(result == 2){
 					JOptionPane.showMessageDialog(this, "已存在该商品", "提示",
 							JOptionPane.ERROR_MESSAGE);
-				} else {
+				}
+				else {
 					JOptionPane.showMessageDialog(this, "出错！添加失败", "提示",
 							JOptionPane.ERROR_MESSAGE);
 				}
-			}
+			}/*else{
+				//更新
+				SupplierInf supplierInf= new SupplierInf();
+				supplierInf.setName(name);
+				supplierInf.setAddress(address);
+				supplierInf.setContact(contact);
+				supplierInf.setId(this.supplierInf.getId());
+				
+				int result = supplierInfService.updateSupplierInf(supplierInf);
+				if(result==1){
+					JOptionPane.showMessageDialog(this, "更新成功", "提示",
+							JOptionPane.INFORMATION_MESSAGE);
+				}
+			}*/
+
 		} else if (source == cancelBtn) {
-			// 关闭对话框
+
 			this.dispose();
 		}
 	}
-
-	/**
-	 * 商品类别下拉框监听器
-	 */
 	public class MyItemListener implements ItemListener {
 
 		@Override
 		public void itemStateChanged(ItemEvent e) {
 			JComboBox cb = (JComboBox) e.getSource();
-			name2 = (String) cb.getSelectedItem(); // 获取选中的商品类别名称
-			pci = new prodCatalogImpl();
-			for (int i = 0; i < log.length; i++) {
-				if (name2.equals(log[i]))
-					id2 = pci.findProdCatalogByname(name2); // 根据名称获取商品类别ID
+			name2 = (String) cb.getSelectedItem();
+			pci =new prodCatalogImpl();
+			for(int i=0;i<log.length;i++){
+				if(name2.equals(log[i]))
+				id2=pci.findProdCatalogByname(name2);
 			}
+		
 		}
-	}
 
-	/**
-	 * 供应商下拉框监听器
-	 */
+	}
+	
 	public class MyItemListener1 implements ItemListener {
-
+		
 		@Override
 		public void itemStateChanged(ItemEvent e) {
 			JComboBox cb = (JComboBox) e.getSource();
-			String suppliername = (String) cb.getSelectedItem(); // 获取选中的供应商名称
-			sii = new SupplierInfImpl();
-			for (int i = 0; i < superlier.length; i++) {
-				if (suppliername.equals(superlier[i]))
-					supplyid = sii.findIdSupplierByName(suppliername); // 根据名称获取供应商ID
+			String suppliername = (String) cb.getSelectedItem();
+			sii =new SupplierInfImpl();
+			for(int i=0;i<superlier.length;i++){
+				if(suppliername.equals(superlier[i]))
+					supplyid=sii.findIdSupplierByName(suppliername);
 			}
 		}
+		
 	}
-}
+}

Supermarket/src/com/lingnan/supermarket/dialog/SupplierInfDialog.java

@@ -13,6 +13,7 @@ import javax.swing.JOptionPane;
 import javax.swing.JPanel;
 import javax.swing.JTextField;
 
+import com.lingnan.supermarket.*;
 import com.lingnan.supermarket.dao.SupplierInfService;
 import com.lingnan.supermarket.dao.impl.SupplierInfImpl;
 import com.lingnan.supermarket.dto.SupplierInf;
@@ -20,78 +21,68 @@ import com.lingnan.supermarket.view.SupplierView;
 
 public class SupplierInfDialog extends JDialog implements ActionListener {
 
-	private JPanel namePanel, addressPanel, contactPanel, emailPanel, opePanel;
+	private JPanel namePanel, addressPanel, contactPanel,emailPanel, opePanel;
 
-	private JLabel nameLabel, addressLabel, contactLabel, emailLabel;
-	private JTextField nameTF, addressTF, contactTF, emailTF;
+	private JLabel nameLabel, addressLabel, contactLabel,emailLabel;
+	private JTextField nameTF, addressTF, contactTF,emailTF;
 
 	private JButton saveBtn, cancelBtn;
 
-	private SupplierInfService supplierInfService = new SupplierInfImpl(); // 供应商信息服务接口的实现类
+	private SupplierInfService supplierInfService = new SupplierInfImpl();
 
-	private SupplierView supplierView; // 供应商视图对象
+	private SupplierView supplierView;
 
-	private SupplierInf supplierInf; // 供应商信息对象
+	private SupplierInf supplierInf;
 
-	//构造函数，初始化对话框
 	public SupplierInfDialog(JFrame parent, SupplierView supplierView) {
-		super(parent, "添加"); // 调用父类构造函数，设置对话框标题为“添加”
-		this.supplierView = supplierView; // 保存供应商视图对象
+		super(parent, "添加");
+		this.supplierView = supplierView;
 
-		setSize(350, 300); // 设置对话框大小
+		setSize(350, 300);
 
-		setLocationRelativeTo(null); // 设置对话框居中显示
+		setLocationRelativeTo(null);
 
-		setModal(true); // 设置对话框为模态对话框
-		setResizable(false); // 禁止调整对话框大小
+		setModal(true);
+		setResizable(false);
 
-		this.setLayout(new FlowLayout()); // 设置对话框的布局为流式布局
+		this.setLayout(new FlowLayout());
 
-		initView(); // 初始化对话框界面
+		initView();
 	}
 
-	/**
-	 * 初始化对话框界面
-	 */
 	private void initView() {
-		// 名称面板
 		namePanel = new JPanel();
 		nameLabel = new JLabel("名称");
 		nameTF = new JTextField(15);
 		namePanel.add(nameLabel);
 		namePanel.add(nameTF);
 
-		// 地址面板
 		addressPanel = new JPanel();
 		addressLabel = new JLabel("地址");
 		addressTF = new JTextField(15);
 		addressPanel.add(addressLabel);
 		addressPanel.add(addressTF);
 
-		// 联系电话面板
 		contactPanel = new JPanel();
 		contactLabel = new JLabel("电话");
 		contactTF = new JTextField(15);
 		contactPanel.add(contactLabel);
 		contactPanel.add(contactTF);
-
-		// 邮箱面板
+		
 		emailPanel = new JPanel();
 		emailLabel = new JLabel("邮箱");
 		emailTF = new JTextField(15);
 		emailPanel.add(emailLabel);
 		emailPanel.add(emailTF);
 
-		// 操作面板
 		opePanel = new JPanel();
 		saveBtn = new JButton("保存");
 		cancelBtn = new JButton("取消");
-		saveBtn.addActionListener(this); // 为保存按钮添加事件监听器
-		cancelBtn.addActionListener(this); // 为取消按钮添加事件监听器
+		saveBtn.addActionListener(this);
+		cancelBtn.addActionListener(this);
 		opePanel.add(saveBtn);
 		opePanel.add(cancelBtn);
 
-		// 将各个面板添加到对话框的内容面板中
 		Container container = getContentPane();
 		container.add(namePanel);
 		container.add(addressPanel);
@@ -100,51 +91,56 @@ public class SupplierInfDialog extends JDialog implements ActionListener {
 		container.add(opePanel);
 	}
 
-	/**
-	 * 事件处理方法
-	 *
-	 * @param e 事件对象
-	 */
 	@Override
 	public void actionPerformed(ActionEvent e) {
-		Object source = e.getSource(); // 获取事件源
-		if (source == saveBtn) { // 如果事件源是保存按钮
-			// 获取用户输入的数据
+		Object source = e.getSource();
+		if (source == saveBtn) {
+			// 思路获取数据
+			// 保存到数据库
+			// 关闭对话框
+			// 刷新table
+
 			String name = nameTF.getText();
 			String address = addressTF.getText();
 			String contact = contactTF.getText();
 			String email = emailTF.getText();
 
 			// TODO 参数校验
-			if (this.supplierInf == null) { // 如果当前没有供应商信息对象（即新增操作）
+			if (this.supplierInf == null) {
 				SupplierInf supplierInf = new SupplierInf();
 				supplierInf.setName(name);
 				supplierInf.setAddress(address);
 				supplierInf.setContact(contact);
 				supplierInf.setEmail(email);
-				int result = supplierInfService.addSupplierInf(supplierInf); // 调用服务接口添加供应商信息
-				if (result == 1) { // 如果添加成功
-					JOptionPane.showMessageDialog(this, "添加成功", "提示", JOptionPane.INFORMATION_MESSAGE);
-					this.dispose(); // 关闭对话框
-				} else { // 如果添加失败
-					JOptionPane.showMessageDialog(this, "添加失败", "提示", JOptionPane.ERROR_MESSAGE);
+				int result = supplierInfService.addSupplierInf(supplierInf);
+				// int result = 1;
+				if (result == 1) {
+
+					JOptionPane.showMessageDialog(this, "添加成功", "提示",
+							JOptionPane.INFORMATION_MESSAGE);
+					this.dispose();
+				} else {
+					JOptionPane.showMessageDialog(this, "添加失败", "提示",
+							JOptionPane.ERROR_MESSAGE);
+				}
+			}/*else{
+				//更新
+				SupplierInf supplierInf= new SupplierInf();
+				supplierInf.setName(name);
+				supplierInf.setAddress(address);
+				supplierInf.setContact(contact);
+				supplierInf.setId(this.supplierInf.getId());
+				
+				int result = supplierInfService.updateSupplierInf(supplierInf);
+				if(result==1){
+					JOptionPane.showMessageDialog(this, "更新成功", "提示",
+							JOptionPane.INFORMATION_MESSAGE);
 				}
-			} /*else {
-                // 更新操作（当前代码被注释掉）
-                SupplierInf supplierInf = new SupplierInf();
-                supplierInf.setName(name);
-                supplierInf.setAddress(address);
-                supplierInf.setContact(contact);
-                supplierInf.setId(this.supplierInf.getId());
-
-                int result = supplierInfService.updateSupplierInf(supplierInf);
-                if (result == 1) {
-                    JOptionPane.showMessageDialog(this, "更新成功", "提示", JOptionPane.INFORMATION_MESSAGE);
-                }
-            }*/
-
-		} else if (source == cancelBtn) { // 如果事件源是取消按钮
-			this.dispose(); // 关闭对话框
+			}*/
+
+		} else if (source == cancelBtn) {
+
+			this.dispose();
 		}
 	}
-}
+}

Supermarket/src/com/lingnan/supermarket/dto/Buffer.java

@@ -2,7 +2,6 @@ package com.lingnan.supermarket.dto;
 
 import com.lingnan.supermarket.dto.base.BaseProduction;
 
-// 定义一个 Buffer 类，继承自 BaseProduction
-public class Buffer extends BaseProduction {
+public class Buffer extends BaseProduction{
 
-}
+}

Supermarket/src/com/lingnan/supermarket/dto/InOrder.java

@@ -1,189 +1,48 @@
-// 定义包名，表明该类属于com.lingnan.supermarket.dto包
 package com.lingnan.supermarket.dto;
 
-// 导入java.util.Date类，尽管在此类中没有直接使用，但可能用于其他相关类或方法
 import java.util.Date;
 
-// 定义一个公共类InOrder，用于表示入库订单的信息
 public class InOrder {
-	// 定义私有成员变量iNumber，用于存储订单编号
-	private String iNumber;
-	// 定义私有成员变量allInPrice，用于存储订单的总价
-	private Float allInPrice;
-	// 定义私有成员变量inDate，用于存储订单的日期
-	private String inDate;
-	// 定义私有成员变量principal，用于存储订单的负责人
-	private String principal;
-	// 定义私有成员变量status，用于存储订单的状态
-	private int status;
-	// 定义私有成员变量delmark，用于存储删除标记
-	private int delmark;
-
-	// 定义公共方法getiNumber，用于获取订单编号
+    private String iNumber;
+    private Float allInPrice;
+    private String inDate;
+    private String principal;
+    private int status;
+    private int delmark;
 	public String getiNumber() {
-		return iNumber; // 返回订单编号
+		return iNumber;
 	}
-	// 定义公共方法setiNumber，用于设置订单编号
 	public void setiNumber(String iNumber) {
-		this.iNumber = iNumber; // 将传入的参数赋值给成员变量iNumber
+		this.iNumber = iNumber;
 	}
-	// 定义公共方法getAllInPrice，用于获取订单的总价
 	public Float getAllInPrice() {
-		return allInPrice; // 返回订单的总价
+		return allInPrice;
 	}
-	// 定义公共方法setAllInPrice，用于设置订单的总价
 	public void setAllInPrice(Float allInPrice) {
-		this.allInPrice = allInPrice; // 将传入的参数赋值给成员变量allInPrice
+		this.allInPrice = allInPrice;
 	}
-	// 定义公共方法getInDate，用于获取订单的日期
 	public String getInDate() {
-		return inDate; // 返回订单的日期
+		return inDate;
 	}
-	// 定义公共方法setInDate，用于设置订单的日期
 	public void setInDate(String inDate) {
-		this.inDate = inDate; // 将传入的参数赋值给成员变量inDate
+		this.inDate = inDate;
 	}
-	// 定义公共方法getPrincipal，用于获取订单的负责人
 	public String getPrincipal() {
-		return principal; // 返回订单的负责人
+		return principal;
 	}
-	// 定义公共方法setPrincipal，用于设置订单的负责人
 	public void setPrincipal(String principal) {
-		this.principal = principal; // 将传入的参数赋值给成员变量principal
-	}
-	// 定义公共方法getStatus，用于获取订单的状态
-	public int getStatus() {
-		return status; // 返回订单的状态
-	}
-	// 定义公共方法setStatus，用于设置订单的状态
-	public void setStatus(int status) {
-		this.status = status; // 将传入的参数赋值给成员变量status
+		this.principal = principal;
 	}
-	// 定义公共方法getDelmark，用于获取删除标记
 	public int getDelmark() {
-		return delmark; // 返回删除标记
+		return delmark;
 	}
-	// 定义公共方法setDelmark，用于设置删除标记
 	public void setDelmark(int delmark) {
-		this.delmark = delmark; // 将传入的参数赋值给成员变量delmark
+		this.delmark = delmark;
+	}
+	public int getStatus() {
+		return status;
+	}
+	public void setStatus(int status) {
+		this.status = status;
 	}
 }
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-

Supermarket/src/com/lingnan/supermarket/dto/InRecord.java

@@ -1,161 +1,27 @@
-package com.lingnan.supermarket.dto; // 声明当前类所在的包
+package com.lingnan.supermarket.dto;
 
-import com.lingnan.supermarket.dto.base.BsDomain; // 导入基础域类BsDomain
+import com.lingnan.supermarket.dto.base.BsDomain;
 
-// 定义进货记录类InRecord，继承自BsDomain
 public class InRecord extends BsDomain{
-	private String iNumber; // 进货编号
-	private int sum; // 进货数量
-	private Float inPrice; // 进货单价
-
-	// getiNumber方法，用于获取进货编号
+	private String iNumber;
+	private int sum;
+    private Float inPrice;
 	public String getiNumber() {
-		return iNumber; // 返回进货编号
+		return iNumber;
 	}
-	// setiNumber方法，用于设置进货编号
 	public void setiNumber(String iNumber) {
-		this.iNumber = iNumber; // 将参数iNumber赋值给成员变量iNumber
+		this.iNumber = iNumber;
 	}
-	// getSum方法，用于获取进货数量
 	public int getSum() {
-		return sum; // 返回进货数量
+		return sum;
 	}
-	// setSum方法，用于设置进货数量
 	public void setSum(int sum) {
-		this.sum = sum; // 将参数sum赋值给成员变量sum
+		this.sum = sum;
 	}
-	// getInPrice方法，用于获取进货单价
 	public Float getInPrice() {
-		return inPrice; // 返回进货单价
+		return inPrice;
 	}
-	// setInPrice方法，用于设置进货单价
 	public void setInPrice(Float inPrice) {
-		this.inPrice = inPrice; // 将参数inPrice赋值给成员变量inPrice
+		this.inPrice = inPrice;
 	}
 }
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-

Supermarket/src/com/lingnan/supermarket/dto/OutOrder.java

@@ -2,71 +2,40 @@ package com.lingnan.supermarket.dto;
 
 import java.util.Date;
 
-//表示出库订单的相关信息
 public class OutOrder {
-
-	//出库订单编号
-	private String oNumber;
-
-	// 出库订单的总出库价格
-	private Float allOutPrice;
-
-	//出库日期
-	private Date oDate;
-
-	//负责人
-	private String principal;
-
-	//删除标记，用于标识该订单是否被删除（0：已删除，1：未删除）
-	private int delmark;
-
-	// 获取出库订单编号
+       private String oNumber;
+       private Float allOutPrice;
+       private Date oDate;
+       private String principal;
+       private int delmark;
 	public String getoNumber() {
 		return oNumber;
 	}
-
-	// 设置出库订单编号
 	public void setoNumber(String oNumber) {
 		this.oNumber = oNumber;
 	}
-
-	// 获取出库订单的总出库价格
 	public Float getAllOutPrice() {
 		return allOutPrice;
 	}
-
-	// 设置出库订单的总出库价格
 	public void setAllOutPrice(Float allOutPrice) {
 		this.allOutPrice = allOutPrice;
 	}
-
-	// 获取出库日期
 	public Date getoDate() {
 		return oDate;
 	}
-
-	// 设置出库日期
 	public void setoDate(Date oDate) {
 		this.oDate = oDate;
 	}
-
-	//获取负责人
 	public String getPrincipal() {
 		return principal;
 	}
-
-	//设置负责人
 	public void setPrincipal(String principal) {
 		this.principal = principal;
 	}
-
-	//获取删除标记
 	public int getDelmark() {
 		return delmark;
 	}
-
-	//设置删除标记
 	public void setDelmark(int delmark) {
 		this.delmark = delmark;
 	}
-}
+}

Supermarket/src/com/lingnan/supermarket/dto/OutRecord.java

@@ -2,46 +2,26 @@ package com.lingnan.supermarket.dto;
 
 import com.lingnan.supermarket.dto.base.BsDomain;
 
-// 出库记录类
-
-public class OutRecord extends BsDomain {
-
-	// 出库编号
-	private String oNumber;
-
-	// 出库数量
-	private int sum;
-
-	// 出库单价
-	private Float outPrice;
-
-	// 获取出库编号
+public class OutRecord extends BsDomain{
+     private String oNumber;
+     private int sum;
+     private Float outPrice;
 	public String getoNumber() {
 		return oNumber;
 	}
-
-	// 设置出库编号
 	public void setoNumber(String oNumber) {
 		this.oNumber = oNumber;
 	}
-
-	//获取出库数量
 	public int getSum() {
 		return sum;
 	}
-
-	//设置出库数量
 	public void setSum(int sum) {
 		this.sum = sum;
 	}
-
-	//获取出库单价
 	public Float getOutPrice() {
 		return outPrice;
 	}
-
-	//设置出库单价
 	public void setOutPrice(Float outPrice) {
 		this.outPrice = outPrice;
 	}
-}
+}

Supermarket/src/com/lingnan/supermarket/dto/ProdCatalog.java

@@ -1,130 +1,20 @@
-package com.lingnan.supermarket.dto; // 声明当前类所在的包
+package com.lingnan.supermarket.dto;
 
-// 定义产品目录类ProdCatalog
 public class ProdCatalog {
-	private String id; // 产品目录ID
-	private String name; // 产品目录名称
-
-	// getId方法，用于获取产品目录ID
+       private String id;
+       private String name;
+       
 	public String getId() {
-		return id; // 返回产品目录ID
+		return id;
 	}
-	// setId方法，用于设置产品目录ID
 	public void setId(String id) {
-		this.id = id; // 将参数id赋值给成员变量id
+		this.id = id;
 	}
-	// getName方法，用于获取产品目录名称
 	public String getName() {
-		return name; // 返回产品目录名称
+		return name;
 	}
-	// setName方法，用于设置产品目录名称
 	public void setName(String name) {
-		this.name = name; // 将参数name赋值给成员变量name
+		this.name = name;
 	}
-
+	
 }
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-

Supermarket/src/com/lingnan/supermarket/dto/StorageRecord.java

@@ -1,139 +1,36 @@
-// 定义包名，表明该类属于com.lingnan.supermarket.dto包
 package com.lingnan.supermarket.dto;
 
-// 导入java.util.Date类，用于处理日期
 import java.util.Date;
 
-// 导入com.lingnan.supermarket.dto.base.BsDomain类，表示StorageRecord类继承自BsDomain
 import com.lingnan.supermarket.dto.base.BsDomain;
 
-// 定义一个公共类StorageRecord，继承自BsDomain类
 public class StorageRecord extends BsDomain{
-	// 定义私有成员变量theNumber，用于存储记录编号
-	private String theNumber;
-	// 定义私有成员变量cDate，用于存储记录日期
-	private String cDate;
-	// 定义私有成员变量num，用于存储数量
-	private int num;
-	// 定义私有成员变量execute，用于存储执行操作
-	private String execute;
-
-	// 定义公共方法getTheNumber，用于获取记录编号
-	public String getTheNumber() {
-		return theNumber; // 返回记录编号
-	}
-	// 定义公共方法setTheNumber，用于设置记录编号
-	public void setTheNumber(String theNumber) {
-		this.theNumber = theNumber; // 将传入的参数赋值给成员变量theNumber
-	}
-	// 定义公共方法getcDate，用于获取记录日期
-	public String getcDate() {
-		return cDate; // 返回记录日期
-	}
-	// 定义公共方法setcDate，用于设置记录日期
-	public void setcDate(String cDate) {
-		this.cDate = cDate; // 将传入的参数赋值给成员变量cDate
-	}
-	// 定义公共方法getNum，用于获取数量
-	public int getNum() {
-		return num; // 返回数量
-	}
-	// 定义公共方法setNum，用于设置数量
-	public void setNum(int num) {
-		this.num = num; // 将传入的参数赋值给成员变量num
-	}
-	// 定义公共方法getExecute，用于获取执行操作
-	public String getExecute() {
-		return execute; // 返回执行操作
-	}
-	// 定义公共方法setExecute，用于设置执行操作
-	public void setExecute(String execute) {
-		this.execute = execute; // 将传入的参数赋值给成员变量execute
-	}
+         private String theNumber;
+         private String cDate;
+         private int num;
+         private String execute;
+		public String getTheNumber() {
+			return theNumber;
+		}
+		public void setTheNumber(String theNumber) {
+			this.theNumber = theNumber;
+		}
+		public String getcDate() {
+			return cDate;
+		}
+		public void setcDate(String cDate) {
+			this.cDate = cDate;
+		}
+		public int getNum() {
+			return num;
+		}
+		public void setNum(int num) {
+			this.num = num;
+		}
+		public String getExecute() {
+			return execute;
+		}
+		public void setExecute(String execute) {
+			this.execute = execute;
+		}
 }
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-

Supermarket/src/com/lingnan/supermarket/dto/SupplierInf.java

@@ -1,171 +1,45 @@
-package com.lingnan.supermarket.dto; // 声明当前类所在的包
+package com.lingnan.supermarket.dto;
+
+import com.lingnan.supermarket.dto.base.BaseDomain;
 
-import com.lingnan.supermarket.dto.base.BaseDomain; // 导入基础域类BaseDomain
 
-// 定义供应商信息类SupplierInf，继承自BaseDomain
 public class SupplierInf extends BaseDomain{
-	private String name; // 供应商名称
-	private String address; // 供应商地址
-	private String contact; // 供应商联系方式
-	private String email; // 供应商邮箱
-	// getEmail方法，用于获取供应商邮箱
+	private String name;
+	private String address;
+	private String contact;
+	private String email;
 	public String getEmail() {
-		return email; // 返回邮箱
+		return email;
 	}
-	// setEmail方法，用于设置供应商邮箱
 	public void setEmail(String email) {
-		this.email = email; // 将参数email赋值给成员变量email
+		this.email = email;
 	}
-	private int delmark; // 删除标记
-
-	// getDelmark方法，用于获取删除标记
+	private int delmark;
+	
+	
+	
 	public int getDelmark() {
-		return delmark; // 返回删除标记
+		return delmark;
 	}
-	// setDelmark方法，用于设置删除标记
 	public void setDelmark(int delmark) {
-		this.delmark = delmark; // 将参数delmark赋值给成员变量delmark
+		this.delmark = delmark;
 	}
-	// getName方法，用于获取供应商名称
 	public String getName() {
-		return name; // 返回供应商名称
+		return name;
 	}
-	// setName方法，用于设置供应商名称
 	public void setName(String name) {
-		this.name = name; // 将参数name赋值给成员变量name
+		this.name = name;
 	}
-	// getAddress方法，用于获取供应商地址
 	public String getAddress() {
-		return address; // 返回供应商地址
+		return address;
 	}
-	// setAddress方法，用于设置供应商地址
 	public void setAddress(String address) {
-		this.address = address; // 将参数address赋值给成员变量address
+		this.address = address;
 	}
-	// getContact方法，用于获取供应商联系方式
 	public String getContact() {
-		return contact; // 返回供应商联系方式
+		return contact;
 	}
-	// setContact方法，用于设置供应商联系方式
 	public void setContact(String contact) {
-		this.contact = contact; // 将参数contact赋值给成员变量contact
+		this.contact = contact;
+	}
 	}
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-

Supermarket/src/com/lingnan/supermarket/dto/base/BaseDomain.java

@@ -1,18 +1,15 @@
 package com.lingnan.supermarket.dto.base;
 
-// 封装对象的通用属性
 public class BaseDomain {
-
+	
 	private Integer id;
 
-	// 获取 id 属性的 getter 方法
 	public Integer getId() {
 		return id;
 	}
 
-	// 设置 id 属性的 setter 方法
 	public void setId(Integer id) {
 		this.id = id;
 	}
 
-}
+}

Supermarket/src/com/lingnan/supermarket/dto/base/BaseProduction.java

@@ -1,148 +1,86 @@
 package com.lingnan.supermarket.dto.base;
 
-// 封装商品相关的通用属性
 public class BaseProduction {
-
-	// 商品标识符
 	private String id;
-
-	// 商品的名称
 	private String name;
-
-	// 商品的进货价格
-	private float inPrice;
-
-	// 商品的出货价格
-	private float OutPrice;
-
-	// 商品的保质期
-	private int life;
-
-	// 商品的库存数量
-	private int sum;
-
-	// 供应商的唯一标识符
-	private int supplyId;
-
-	// 商品的辅助标识符
-	private String id2;
-
-	// 商品的辅助名称
-	private String name2;
-
-	// 商品的总价格，浮点数类型
-	private Float price;
-
-	// 商品的删除标记，用于标识商品是否被删除（0：未删除，1：已删除）
-	private int delmark;
-
-	// 获取商品唯一标识符的方法
-	public String getId() {
+    private float inPrice;
+    private float OutPrice;
+    private int life;
+    private int sum;
+    private int supplyId;
+    private String id2;
+    private String name2;
+    private Float price;
+    private int delmark;
+    
+    
+    public String getId() {
 		return id;
 	}
-
-	// 设置商品唯一标识符
 	public void setId(String id) {
 		this.id = id;
 	}
-
-	// 获取商品删除标记
 	public int getDelmark() {
 		return delmark;
 	}
-
-	// 设置商品删除标记
 	public void setDelmark(int delmark) {
 		this.delmark = delmark;
 	}
-
-	// 获取商品库存数量
 	public int getSum() {
 		return sum;
 	}
-
-	// 设置商品库存数量
 	public void setSum(int sum) {
 		this.sum = sum;
 	}
-
-	// 获取商品名称
 	public String getName() {
 		return name;
 	}
-
-	// 设置商品名称
 	public void setName(String name) {
 		this.name = name;
 	}
-
-	// 获取商品进货价格
 	public float getInPrice() {
 		return inPrice;
 	}
-
-	// 设置商品进货价格
 	public void setInPrice(float inPrice) {
 		this.inPrice = inPrice;
 	}
-
-	// 获取商品出货价格
 	public float getOutPrice() {
 		return OutPrice;
 	}
-
-	// 设置商品出货价格
 	public void setOutPrice(float outPrice) {
 		OutPrice = outPrice;
 	}
-
-	// 获取商品保质期
 	public int getLife() {
 		return life;
 	}
-
-	// 设置商品保质期
 	public void setLife(int life) {
 		this.life = life;
 	}
-
-	// 获取商品辅助标识符
+	
 	public String getId2() {
 		return id2;
 	}
-
-	// 设置商品辅助标识符
 	public void setId2(String id2) {
 		this.id2 = id2;
 	}
-
-	// 获取商品辅助名称
+	
 	public String getName2() {
 		return name2;
 	}
-
-	// 设置商品辅助名称
 	public void setName2(String name2) {
 		this.name2 = name2;
 	}
-
-	// 获取供应商唯一标识符
+	
 	public int getSupplyId() {
 		return supplyId;
 	}
-
-	// 设置供应商唯一标识符
 	public void setSupplyId(int supplyId) {
 		this.supplyId = supplyId;
 	}
-
-	// 获取商品总价格
 	public Float getPrice() {
 		return price;
 	}
-
-	// 设置商品总价格
 	public void setPrice(Float price) {
 		this.price = price;
 	}
-}
+}

Supermarket/src/com/lingnan/supermarket/dto/base/BsDomain.java

@@ -1,13 +1,13 @@
 package com.lingnan.supermarket.dto.base;
 
 public class BsDomain {
-	private String id;
-	// 获取 id 属性的 getter 方法
+       private String id;
+
 	public String getId() {
 		return id;
 	}
-	// 设置 id 属性的 setter 方法
+
 	public void setId(String id) {
 		this.id = id;
 	}
-}
+}

Supermarket/src/com/lingnan/supermarket/table/InOrderTM.java

@@ -15,102 +15,93 @@ import com.lingnan.supermarket.dao.UserService;
 import com.lingnan.supermarket.dao.impl.*;
 import com.lingnan.supermarket.dialog.InDialog;
 
-//用于管理入库订单的表格数据
 
-public class InOrderTM extends AbstractTableModel {
+public class InOrderTM extends AbstractTableModel{
+	
+	private String [] columnName = {"订单号","总价","时间","负责人","状态"};
 
-	// 表格列名
-	private String[] columnName = {"订单号", "总价", "时间", "负责人", "状态"};
-
-	// 商品服务实现类
 	private productionImpl prodDao = new productionImpl();
-
-	// 入库订单数据集合
-	private Vector<InOrder> InOrders;
-
-	// 入库订单服务实现类
-	private inOrderServiceImpl inOrderImpl = new inOrderServiceImpl();
-
-	// 当前操作的入库订单对象
-	private InOrder inOrder;
-
-	// 订单号
-	String iNumber;
-
-	//加载所有入库订单记录
+	
+	private  Vector<InOrder> InOrders;
+	private inOrderServiceImpl inOrderImpl= new inOrderServiceImpl();
+	private InOrder inOrder ;
+	
+	String iNumber ;/*订单号*/
+	
+	
 	public void allInOrderRecord() {
-		// 从数据库中获取所有入库订单记录
+		//将添加的商品加入到静态变量Vector数组中
+		/*prod = InDialog.getProduction();*/
 		InOrders = inOrderImpl.findAllInOrder();
 	}
-
-	//根据分类查找入库订单记录（0：全部，1：已入库，2：待入库，3：已取消）
+	
+	//查找分类结果
 	public void resultOfFind(int catalog) {
-		if (catalog == 0) {
-			// 加载所有入库订单记录
+		if(catalog==0)
 			InOrders = inOrderImpl.findAllInOrder();
-		} else {
-			// 根据状态查找入库订单记录
+		else
 			InOrders = inOrderImpl.FindStatus(catalog);
-		}
 	}
-
-	// 根据订单号查找入库订单记录
+	
+	//根据订单查找
 	public void resultOfNumber(String Number) {
-		InOrders = new Vector<InOrder>();
+		InOrders=new Vector<InOrder>();
 		inOrder = inOrderImpl.findByIdinOrder(Number);
 		InOrders.add(inOrder);
 	}
 
-	//获取表格行数
 	@Override
 	public int getRowCount() {
 		return InOrders.size();
 	}
-
-	// 获取表格列数
+	
+/*	public Float getAllPrice() {
+		return BufferImpl.InBufferAllPrice();
+	}
+*/
 	@Override
-	public int getColumnCount() {
+	public int getColumnCount() {  
 		return columnName.length;
 	}
 
-	//获取指定单元格的值
 	@Override
 	public Object getValueAt(int rowIndex, int columnIndex) {
 		inOrder = InOrders.get(rowIndex);
-		iNumber = inOrder.getiNumber();
-
-		// 根据列索引返回对应的数据
-		if (columnIndex == 0) {
-			return inOrder.getiNumber(); // 订单号
-		} else if (columnIndex == 1) {
-			return inOrder.getAllInPrice(); // 总价
-		} else if (columnIndex == 2) {
-			return inOrder.getInDate(); // 时间
-		} else if (columnIndex == 3) {
-			return inOrder.getPrincipal(); // 负责人
-		} else if (columnIndex == 4) {
-			// 根据状态返回对应的字符串
+/*		System.out.println( "id="+users.get(rowIndex).getId());
+		System.out.println("rowIndex"+rowIndex);
+		System.out.println("columnIndex"+columnIndex);*/
+		iNumber=inOrder.getiNumber();
+		if(columnIndex==0) {
+			return inOrder.getiNumber();
+		}else if(columnIndex==1) {
+			return inOrder.getAllInPrice();
+		}else if(columnIndex==2) {
+			return inOrder.getInDate();	
+		}else if(columnIndex==3) {
+			return  inOrder.getPrincipal();
+		}else if(columnIndex==4) {
 			String status = null;
-			if (inOrder.getStatus() == 1)
-				status = "已入库";
-			else if (inOrder.getStatus() == 2)
-				status = "待入库";
-			else if (inOrder.getStatus() == 3)
-				status = "已取消";
+			if(inOrder.getStatus()==1)
+				status= "已入库";
+			else if(inOrder.getStatus()==2)
+				status= "待入库";
+			else if(inOrder.getStatus()==3)
+				status= "已取消";
 			return status;
-		} else {
+		}else {
 			return null;
 		}
 	}
-
-	//获取当前操作的订单号
-	public String getINumber() {
+	 
+	public String getINumber() {  /*返回要修改或删除的记录*/
 		return iNumber;
 	}
-
-	//获取指定列的列名
+	
+	
 	@Override
 	public String getColumnName(int column) {
 		return columnName[column];
 	}
-}
+	
+	
+}

Supermarket/src/com/lingnan/supermarket/table/InRecordTM.java

@@ -9,83 +9,83 @@ import javax.swing.table.AbstractTableModel;
 import com.lingnan.supermarket.dto.Buffer;
 import com.lingnan.supermarket.dto.InOrder;
 import com.lingnan.supermarket.dto.InRecord;
+import com.lingnan.supermarket.dto.Buffer;
 import com.lingnan.supermarket.dto.Production;
 import com.lingnan.supermarket.dto.User;
 import com.lingnan.supermarket.dao.UserService;
 import com.lingnan.supermarket.dao.impl.*;
 import com.lingnan.supermarket.dialog.InDialog;
 
-//用于管理入库记录的表格数据
-public class InRecordTM extends AbstractTableModel {
 
-	// 表格列名数组
-	private String[] columnName = { "订单号", "id", "数量", "金额" };
+public class InRecordTM extends AbstractTableModel{
+	
+	private String [] columnName = {"订单号","id","数量","金额"};
 
-	// 商品数据访问对象
 	private productionImpl prodDao = new productionImpl();
-
-	// 入库记录数据集合
-	private Vector<InRecord> InRecords;
-
-	// 入库记录服务实现类
+	
+	private  Vector<InRecord> InRecords;
+	
 	private inRecordServiceImpl inRecordImpl = new inRecordServiceImpl();
+	private InRecord inRecord= new InRecord();
 
-	// 当前操作的入库记录对象
-	private InRecord inRecord = new InRecord();
-
-	// 订单号
-	private String iNumber;
-
-	//构造函数，初始化订单号
+	
+	private String iNumber ;/*订单号*/
+	
+	
 	public InRecordTM(String iNumber) {
-		this.iNumber = iNumber;
+		this.iNumber=iNumber;
 	}
-
-	//根据订单号查找入库记录
+	
 	public void findInRecordByINumber() {
-		// 将添加的商品加入到静态变量 Vector 数组中
-		// prod = InDialog.getProduction();
+		//将添加的商品加入到静态变量Vector数组中
+		/*prod = InDialog.getProduction();*/
 		InRecords = inRecordImpl.findByIdinRecord(iNumber);
 	}
-
-	//获取表格的行数
+	
+	
 	@Override
 	public int getRowCount() {
 		return InRecords.size();
 	}
-
-	//获取表格的列数
+	
+/*	public Float getAllPrice() {
+		return BufferImpl.InBufferAllPrice();
+	}
+*/
 	@Override
-	public int getColumnCount() {
+	public int getColumnCount() {  
 		return columnName.length;
 	}
 
-	//获取指定单元格的值
 	@Override
 	public Object getValueAt(int rowIndex, int columnIndex) {
 		inRecord = InRecords.get(rowIndex);
-		iNumber = inRecord.getiNumber();
-		if (columnIndex == 0) {
-			return inRecord.getiNumber(); // 返回订单号
-		} else if (columnIndex == 1) {
-			return inRecord.getId(); // 返回商品ID
-		} else if (columnIndex == 2) {
-			return inRecord.getSum(); // 返回数量
-		} else if (columnIndex == 3) {
-			return inRecord.getInPrice(); // 返回金额
-		} else {
+/*		System.out.println( "id="+users.get(rowIndex).getId());
+		System.out.println("rowIndex"+rowIndex);
+		System.out.println("columnIndex"+columnIndex);*/
+		iNumber=inRecord.getiNumber();
+		if(columnIndex==0) {
+			return inRecord.getiNumber();
+		}else if(columnIndex==1) {
+			return inRecord.getId();
+		}else if(columnIndex==2) {
+			return inRecord.getSum();	
+		}else if(columnIndex==3) {
+			return  inRecord.getInPrice();
+		}else {
 			return null;
 		}
 	}
-
-	//获取订单
-	public String getINumber() {
+	 
+	public String getINumber() {  /*返回要修改或删除的记录*/
 		return iNumber;
 	}
-
-	// 获取指定列的列名
+	
+	
 	@Override
 	public String getColumnName(int column) {
 		return columnName[column];
 	}
-}
+	
+	
+}

Supermarket/src/com/lingnan/supermarket/table/InTableModel.java

@@ -1,121 +1,99 @@
-package com.lingnan.supermarket.table; // 定义包名，表示这个类属于com.lingnan.supermarket.table包
+package com.lingnan.supermarket.table;
 
-import java.util.List; // 导入Java的List接口，用于存储集合数据
-import java.util.Vector; // 导入Java的Vector类，用于存储表格数据
+import java.util.List;
+import java.util.Vector;
 
-import javax.swing.JFrame; // 导入Swing库中的JFrame类，用于创建窗口框架
-import javax.swing.table.AbstractTableModel; // 导入Swing库中的AbstractTableModel类，用于创建表格模型
+import javax.swing.JFrame;
+import javax.swing.table.AbstractTableModel;
 
-import com.lingnan.supermarket.dto.InOrder; // 导入自定义的InOrder类，但在此代码中未使用
-import com.lingnan.supermarket.dto.Production; // 导入自定义的Production类，可能用于表示商品的数据传输对象
-import com.lingnan.supermarket.dto.User; // 导入自定义的User类，但在此代码中未使用
-import com.lingnan.supermarket.dao.UserService; // 导入UserService接口，但在此代码中未使用
-import com.lingnan.supermarket.dao.impl.*; // 导入impl包下的所有类，可能包含数据访问层的实现类
-import com.lingnan.supermarket.dialog.InDialog; // 导入自定义的InDialog类，但在此代码中未使用
 
-public class InTableModel extends AbstractTableModel{ // 定义一个名为InTableModel的类，该类继承自AbstractTableModel类，用于创建表格模型
+import com.lingnan.supermarket.dto.InOrder;
 
-	private String [] columnName = {"id","名称","数量","单价","价格","保质期","类别","供应商id"}; // 定义一个字符串数组，用于存储表格的列名
+import com.lingnan.supermarket.dto.Production;
+import com.lingnan.supermarket.dto.User;
+import com.lingnan.supermarket.dao.UserService;
+import com.lingnan.supermarket.dao.impl.*;
+import com.lingnan.supermarket.dialog.InDialog;
 
-	private productionImpl prodDao = new productionImpl(); // 创建productionImpl类的实例，用于访问商品数据
-
-	private  Vector<Production> v; // 声明一个Vector类型的变量，用于存储商品列表
-
-	String id ; // 声明一个String类型的变量，用于存储id，但未初始化和使用
-
-	public InTableModel(Vector<Production> v) { // 定义一个名为InTableModel的构造函数，接收Vector<Production>类型的参数
-		System.out.println("调用imtablemodel里面的构造函数"); // 打印信息，表示构造函数被调用
-		this.v=v; // 将传入的参数v赋值给成员变量v
-	}
 
 
+public class InTableModel extends AbstractTableModel{
+	
+	
+	private String [] columnName = {"id","名称","数量","单价","价格","保质期","类别","供应商id"};
 
+	private productionImpl prodDao = new productionImpl();
+	
+	private  Vector<Production> v;
 
-	// 定义一个方法getRowCount，用来获取集合v中的元素数量
+	
+	String id ;
+	
+	
+	public InTableModel(Vector<Production> v) {
+		System.out.println("调用imtablemodel里面的构造函数");
+		this.v=v;
+	}
+	
+	
+	
 	public int getRowCount() {
-		return v.size(); // 返回集合v的大小，即元素的数量
+		return v.size();
 	}
-
-
-
-
-	// 定义一个方法getAllPrice，用来计算集合v中所有Production对象的价格总和
+	
 	public Float getAllPrice() {
-
-		Float allPrice=(float) 0; // 初始化总价格为0.0
-
-		for(Production p:v) { // 遍历集合v中的每一个Production对象
-			allPrice+=p.getPrice(); // 将当前Production对象的价格加到总价格上
+		Float allPrice=(float) 0;
+		for(Production p:v) {
+			allPrice+=p.getPrice();
 		}
-
-		return allPrice; // 返回计算出的总价格
-
+		return allPrice;
 	}
 
-
-	// 重写getColumnCount方法，返回表格模型中的列数
 	@Override
-	public int getColumnCount() {
-		return columnName.length; // 返回列名数组的长度，即列的数量
+	public int getColumnCount() {  
+		return columnName.length;
 	}
 
-	// 重写getValueAt方法，根据行索引和列索引获取表格模型中的值
 	@Override
 	public Object getValueAt(int rowIndex, int columnIndex) {
-
-		Production p = v.get(rowIndex); // 根据行索引从集合v中获取对应的Production对象
-	/* 以下是注释掉的打印语句，用于调试，显示行索引、列索引和用户ID
-	System.out.println( "id="+users.get(rowIndex).getId());
-	System.out.println("rowIndex"+rowIndex);
-	System.out.println("columnIndex"+columnIndex); */
-
-		id=p.getId(); // 将Production对象的ID赋值给id变量
-
-		if(columnIndex==0) { // 如果列索引为0
-			return p.getId(); // 返回Production对象的ID
-		}else if(columnIndex==1) { // 如果列索引为1
-			return p.getName(); // 返回Production对象的名称
-		}else if(columnIndex==2) { // 如果列索引为2
-			return p.getSum(); // 返回Production对象的Sum属性
-		}else if(columnIndex==3) { // 如果列索引为3
-			return p.getInPrice(); // 返回Production对象的InPrice属性
-		}else if(columnIndex==4) { // 如果列索引为4
-			return p.getPrice(); // 返回Production对象的Price属性
-		}else if(columnIndex==5) { // 如果列索引为5
-			return p.getLife(); // 返回Production对象的Life属性
-		}else if(columnIndex==6) { // 如果列索引为6
-			return p.getName2()+p.getId2(); // 返回Production对象的Name2和Id2拼接的字符串
-		}else if(columnIndex==7) { // 如果列索引为7
-			return p.getSupplyId(); // 返回Production对象的SupplyId属性
-		}else { // 如果列索引不匹配上述任何情况
-			return null; // 返回null
-
+		Production p = v.get(rowIndex);
+/*		System.out.println( "id="+users.get(rowIndex).getId());
+		System.out.println("rowIndex"+rowIndex);
+		System.out.println("columnIndex"+columnIndex);*/
+		id=p.getId();
+		if(columnIndex==0) {
+			return p.getId();
+		}else if(columnIndex==1) {
+			return p.getName();			
+		}else if(columnIndex==2) {
+			return p.getSum();	
+		}else if(columnIndex==3) {
+			return  p.getInPrice() ; 
+		}else if(columnIndex==4) {
+			return  p.getPrice() ;
+		}else if(columnIndex==5) {
+			return p.getLife();
+		}else if(columnIndex==6) {
+			return p.getName2()+p.getId2();
+		}else if(columnIndex==7) {
+			return p.getSupplyId();
+		}else {
+			return null;
 		}
-
 	}
-
-
-
-	// 定义一个方法getId，用来获取当前对象的ID属性值
+	 
 	public String getId() {  /*返回要修改或删除的记录*/
-
-		return id; // 返回当前对象的id字段值
-
+		return id;
 	}
-
-
-
-	// 重写getColumnName方法，根据列索引返回对应的列名
+	
+	
 	@Override
 	public String getColumnName(int column) {
-
-		return columnName[column]; // 返回存储列名的数组中对应索引的列名
-
+		return columnName[column];
 	}
 
 
 
-
-
-
+	
+	
 }

Supermarket/src/com/lingnan/supermarket/table/OutOrderTM.java

@@ -18,128 +18,76 @@ import com.lingnan.supermarket.dao.impl.*;
 import com.lingnan.supermarket.dialog.InDialog;
 
 
-public class OutOrderTM extends AbstractTableModel {
+public class OutOrderTM extends AbstractTableModel{
+	
+	private String [] columnName = {"订单号","总价","时间","负责人"};
 
-	// 定义表格列名
-	private String[] columnName = {"订单号", "总价", "时间", "负责人"};
-
-	// 实现类对象，用于与数据库进行交互
 	private productionImpl prodDao = new productionImpl();
-
-	// 存储所有订单记录的Vector
-	private Vector<OutOrder> outOrders;
-
-	// 用于从数据库获取订单数据的服务实现类
-	private outOrderServiceImpl outOrderImpl = new outOrderServiceImpl();
-
-	// 当前订单对象
-	private OutOrder outOrder;
-
-	// 当前订单号
-	String oNumber;
-
-	/**
-	 * 获取所有出货订单记录
-	 */
+	
+	private  Vector<OutOrder> outOrders;
+	private outOrderServiceImpl outOrderImpl= new outOrderServiceImpl();
+	private OutOrder outOrder ;
+	
+	String oNumber ;/*订单号*/
+	
+	
 	public void allOutOrderRecord() {
-		// 调用服务层方法获取所有订单数据
+		//将添加的商品加入到静态变量Vector数组中
+		/*prod = InDialog.getProduction();*/
 		outOrders = outOrderImpl.findAllOutOrder();
-		logMethodCall("allOutOrderRecord");
-		debugLog("Fetched " + outOrders.size() + " out orders.");
 	}
-
-	/**
-	 * 根据订单号查询特定订单
-	 * @param oNumber 订单号
-	 */
+	
 	public void resultOfNumber(String oNumber) {
 		outOrders = new Vector<OutOrder>();
-		// 根据订单号查询订单
 		outOrder = outOrderImpl.findByIdOutOrder(oNumber);
 		outOrders.add(outOrder);
-		logMethodCall("resultOfNumber");
-		debugLog("Fetched order with oNumber: " + oNumber);
 	}
-
-	/**
-	 * 获取表格行数
-	 */
+	
+	
+	
 	@Override
 	public int getRowCount() {
 		return outOrders.size();
 	}
-
-	/**
-	 * 获取表格列数
-	 */
+	
+/*	public Float getAllPrice() {
+		return BufferImpl.InBufferAllPrice();
+	}
+*/
 	@Override
-	public int getColumnCount() {
+	public int getColumnCount() {  
 		return columnName.length;
 	}
 
-	/**
-	 * 获取单元格的值
-	 * @param rowIndex 行索引
-	 * @param columnIndex 列索引
-	 */
 	@Override
 	public Object getValueAt(int rowIndex, int columnIndex) {
-		// 获取指定行的订单对象
 		outOrder = outOrders.get(rowIndex);
-
-		// 根据列索引返回不同的订单属性
-		if (columnIndex == 0) {
+/*		System.out.println( "id="+users.get(rowIndex).getId());
+		System.out.println("rowIndex"+rowIndex);
+		System.out.println("columnIndex"+columnIndex);*/
+		oNumber=outOrder.getoNumber();
+		if(columnIndex==0) {
 			return outOrder.getoNumber();
-		} else if (columnIndex == 1) {
+		}else if(columnIndex==1) {
 			return outOrder.getAllOutPrice();
-		} else if (columnIndex == 2) {
+		}else if(columnIndex==2) {
 			return outOrder.getoDate();
-		} else if (columnIndex == 3) {
-			return outOrder.getPrincipal();
-		} else {
+		}else if(columnIndex==3) {
+			return  outOrder.getPrincipal();
+		}else {
 			return null;
 		}
 	}
-
-	/**
-	 * 获取订单号
-	 * @return 订单号
-	 */
-	public String getOutNumber() {
-		// 返回当前操作的订单号，用于修改或删除操作
+	 
+	public String getOutNumber() {  /*返回要修改或删除的记录*/
 		return oNumber;
 	}
-
-	/**
-	 * 获取列名
-	 * @param column 列索引
-	 * @return 列名
-	 */
+	
+	
 	@Override
 	public String getColumnName(int column) {
 		return columnName[column];
 	}
-
-	// 打印方法调用的日志信息
-	private void logMethodCall(String methodName) {
-		System.out.println("Method " + methodName + " was called.");
-	}
-
-	// 输出调试信息
-	private void debugLog(String message) {
-		System.out.println("DEBUG: " + message);
-	}
-
-	// 模拟查询订单的测试方法
-	public void testGetOutOrder() {
-		resultOfNumber("ORD12345");  // 使用一个示例订单号
-		debugLog("OutOrder with oNumber: " + oNumber + " fetched successfully.");
-	}
-
-	// 测试用例，模拟获取所有订单记录
-	public void testAllOutOrders() {
-		allOutOrderRecord();  // 获取所有订单
-		debugLog("Fetched " + outOrders.size() + " out orders.");
-	}
-
+	
+	
 }

Supermarket/src/com/lingnan/supermarket/table/OutRecordTM.java

@@ -17,127 +17,82 @@ import com.lingnan.supermarket.dao.impl.*;
 import com.lingnan.supermarket.dialog.InDialog;
 
 
-public class OutRecordTM extends AbstractTableModel {
+public class OutRecordTM extends AbstractTableModel{
+	
+	/**
+	 * 
+	 */
 
-	// 定义表格的列名
-	private String[] columnName = {"订单号", "id", "数量", "金额"};
+	private String [] columnName = {"订单号","id","数量","金额"};
 
-	// 用于从数据库获取商品数据的服务层对象
 	private productionImpl prodDao = new productionImpl();
-
-	// 存储所有出货记录的Vector
-	private Vector<OutRecord> OutRecords;
-
-	// 用于操作出货记录数据的服务实现类
+	
+	private  Vector<OutRecord> OutRecords;
+	
 	private outRecordServiceImpl outRecordImpl = new outRecordServiceImpl();
+	private OutRecord outRecord= new OutRecord();
 
-	// 当前的出货记录对象
-	private OutRecord outRecord = new OutRecord();
-
-	// 当前订单号
-	private String oNumber;
-
-	/**
-	 * 构造方法，根据订单号初始化
-	 * @param oNumber 订单号
-	 */
+	
+	private String oNumber ;/*订单号*/
+	
+	
 	public OutRecordTM(String oNumber) {
-		this.oNumber = oNumber;
-		logMethodCall("OutRecordTM Constructor");
-		debugLog("OutRecordTM initialized with oNumber: " + oNumber);
+		this.oNumber=oNumber;
 	}
-
-	/**
-	 * 根据订单号查询出货记录
-	 */
+	
 	public void findOutRecordByINumber() {
-		// 调用数据库服务获取出货记录数据
+		//将添加的商品加入到静态变量Vector数组中
+		/*prod = InDialog.getProduction();*/
 		OutRecords = outRecordImpl.findByIdOutRecordr(oNumber);
-		logMethodCall("findOutRecordByINumber");
-		debugLog("Fetched " + OutRecords.size() + " out records for oNumber: " + oNumber);
 	}
+	
+	
 
-	/**
-	 * 获取表格的行数
-	 * @return 行数
-	 */
+	
+	
 	@Override
 	public int getRowCount() {
 		return OutRecords.size();
 	}
-
-	/**
-	 * 获取表格的列数
-	 * @return 列数
-	 */
+	
+/*	public Float getAllPrice() {
+		return BufferImpl.InBufferAllPrice();
+	}
+*/
 	@Override
-	public int getColumnCount() {
+	public int getColumnCount() {  
 		return columnName.length;
 	}
 
-	/**
-	 * 获取单元格的值
-	 * @param rowIndex 行索引
-	 * @param columnIndex 列索引
-	 * @return 对应的值
-	 */
 	@Override
 	public Object getValueAt(int rowIndex, int columnIndex) {
 		outRecord = OutRecords.get(rowIndex);
-
-		// 根据列索引返回对应的出货记录属性
-		if (columnIndex == 0) {
+/*		System.out.println( "id="+users.get(rowIndex).getId());
+		System.out.println("rowIndex"+rowIndex);
+		System.out.println("columnIndex"+columnIndex);*/
+		oNumber=outRecord.getoNumber();
+		if(columnIndex==0) {
 			return outRecord.getoNumber();
-		} else if (columnIndex == 1) {
+		}else if(columnIndex==1) {
 			return outRecord.getId();
-		} else if (columnIndex == 2) {
-			return outRecord.getSum();
-		} else if (columnIndex == 3) {
-			return outRecord.getOutPrice();
-		} else {
+		}else if(columnIndex==2) {
+			return outRecord.getSum();	
+		}else if(columnIndex==3) {
+			return  outRecord.getOutPrice();
+		}else {
 			return null;
 		}
 	}
-
-	/**
-	 * 获取当前订单号
-	 * @return 订单号
-	 */
-	public String getONumber() {
-		// 返回当前操作的订单号，用于修改或删除操作
+	 
+	public String getONumber() {  /*返回要修改或删除的记录*/
 		return oNumber;
 	}
-
-	/**
-	 * 获取列名
-	 * @param column 列索引
-	 * @return 列名
-	 */
+	
+	
 	@Override
 	public String getColumnName(int column) {
 		return columnName[column];
 	}
-
-	// 打印方法调用的日志信息
-	private void logMethodCall(String methodName) {
-		System.out.println("Method " + methodName + " was called.");
-	}
-
-	// 输出调试信息
-	private void debugLog(String message) {
-		System.out.println("DEBUG: " + message);
-	}
-
-	// 模拟查询出货记录的测试方法
-	public void testFindOutRecord() {
-		findOutRecordByINumber();  // 查询指定订单号的出货记录
-		debugLog("OutRecord with oNumber: " + oNumber + " fetched successfully.");
-	}
-
-	// 测试用例，模拟获取所有出货记录
-	public void testAllOutRecords() {
-		findOutRecordByINumber();  // 获取指定订单号的出货记录
-		debugLog("Fetched " + OutRecords.size() + " out records for oNumber: " + oNumber);
-	}
-
+	
+	
 }

Supermarket/src/com/lingnan/supermarket/table/OutTableModel.java

@@ -14,114 +14,68 @@ import com.lingnan.supermarket.dao.impl.*;
 import com.lingnan.supermarket.dialog.OutDialog;
 
 
-public class OutTableModel extends AbstractTableModel {
+public class OutTableModel extends AbstractTableModel{
+	
+	private String [] columnName = {"id","名称","数量","单价","价格","保质期","类别","供应商id"};
 
-	// 定义列名，表示表格的各个列的名称
-	private String [] columnName = {"id", "名称", "数量", "单价", "价格", "保质期", "类别", "供应商id"};
-
-	// 创建生产商品的实现类对象
 	private productionImpl prodDao = new productionImpl();
-
-	// 定义一个Vector用于存储Buffer对象
-	private Vector<Buffer> Buffers;
-
-	// Buffer实现类对象，用于从数据库获取购物车中的商品数据
-	private BufferImpl BufferImpl  = new BufferImpl();
-
-	/**
-	 * 获取所有购物车商品数据
-	 */
+	
+	private  Vector<Buffer> Buffers;
+	private  BufferImpl BufferImpl  = new BufferImpl();
+	
+	
 	public void allOutBuffer() {
-		// 从数据库获取购物车中的商品信息，并将其存入Buffers
+		//将添加的商品加入到静态变量Vector数组中
+		/*prod = OutDialog.getProduction();*/
 		Buffers = BufferImpl.allOutBuffer();
-		// 打印调试信息，查看Buffer数据
-		System.out.println("Fetched " + Buffers.size() + " items from the buffer.");
 	}
-
-	/**
-	 * 获取表格行数
-	 */
+	
+	
 	@Override
 	public int getRowCount() {
-		// 返回购物车中商品的数量
 		return Buffers.size();
 	}
-
-	/**
-	 * 获取所有商品的总价
-	 * @return 总价
-	 */
+	
 	public Float getAllPrice() {
-		// 获取购物车中所有商品的总价格
 		return BufferImpl.OutBufferAllPrice();
 	}
 
-	/**
-	 * 获取表格的列数
-	 */
 	@Override
-	public int getColumnCount() {
-		// 返回表格列的数量
+	public int getColumnCount() {  
 		return columnName.length;
 	}
 
-	/**
-	 * 获取某行某列的数据
-	 * @param rowIndex 行索引
-	 * @param columnIndex 列索引
-	 */
 	@Override
 	public Object getValueAt(int rowIndex, int columnIndex) {
-		// 获取对应的Buffer对象
 		Buffer Buffer = Buffers.get(rowIndex);
-
-		// 根据列的索引返回对应的Buffer属性值
-		if(columnIndex == 0) {
+/*		System.out.println( "id="+users.get(rowIndex).getId());
+		System.out.println("rowIndex"+rowIndex);
+		System.out.println("columnIndex"+columnIndex);*/
+		if(columnIndex==0) {
 			return Buffer.getId();
-		} else if(columnIndex == 1) {
-			return Buffer.getName();
-		} else if(columnIndex == 2) {
-			return Buffer.getSum();
-		} else if(columnIndex == 3) {
-			return Buffer.getOutPrice();
-		} else if(columnIndex == 4) {
-			return Buffer.getPrice();
-		} else if(columnIndex == 5) {
+		}else if(columnIndex==1) {
+			return Buffer.getName();			
+		}else if(columnIndex==2) {
+			return Buffer.getSum();	
+		}else if(columnIndex==3) {
+			return  Buffer.getOutPrice() ; 
+		}else if(columnIndex==4) {
+			return  Buffer.getPrice() ;
+		}else if(columnIndex==5) {
 			return Buffer.getLife();
-		} else if(columnIndex == 6) {
-			return Buffer.getName2() + Buffer.getId2();  // 返回类别和供应商信息的组合
-		} else if(columnIndex == 7) {
-			return Buffer.getSupplyId();  // 供应商ID
-		} else {
-			return null;  // 如果列索引不在有效范围内，返回null
+		}else if(columnIndex==6) {
+			return Buffer.getName2()+Buffer.getId2();
+		}else if(columnIndex==7) {
+			return Buffer.getSupplyId();
+		}else {
+			return null;
 		}
 	}
-
-	/**
-	 * 获取列名
-	 * @param column 列索引
-	 */
+	 
 	@Override
 	public String getColumnName(int column) {
-		// 返回列名
 		return columnName[column];
 	}
-
-	// 打印日志，记录方法的调用
-	private void logMethodCall(String methodName) {
-		// 打印方法调用的日志信息
-		System.out.println("Method " + methodName + " was called.");
-	}
-
-	// 增加调试日志
-	public void debugLog(String message) {
-		System.out.println("DEBUG: " + message);
-	}
-
-	// 测试用例，模拟从购物车中获取所有商品的情况
-	public void testGetAllOutBuffer() {
-		allOutBuffer();  // 调用获取所有商品的方法
-		debugLog("OutBuffer contains " + Buffers.size() + " items.");
-	}
-
+	
+	
 }

Supermarket/src/com/lingnan/supermarket/table/ProdCatalogTM.java

@@ -1,76 +1,65 @@
-package com.lingnan.supermarket.table; // 定义包名，表示这个类属于com.lingnan.supermarket.table包
+package com.lingnan.supermarket.table;
 
-import java.util.List; // 导入Java的List接口，用于存储集合数据
-import java.util.Vector; // 导入Java的Vector类，用于存储表格数据
+import java.util.List;
+import java.util.Vector;
 
-import javax.swing.table.AbstractTableModel; // 导入Swing库中的AbstractTableModel类，用于创建表格模型
+import javax.swing.table.AbstractTableModel;
 
-import com.lingnan.supermarket.dto.Production; // 导入自定义的Production类，可能用于表示商品的数据传输对象
-import com.lingnan.supermarket.dto.User; // 导入自定义的User类，但在此代码中未使用
-import com.lingnan.supermarket.dao.UserService; // 导入UserService接口，但在此代码中未使用
-import com.lingnan.supermarket.dao.impl.*; // 导入impl包下的所有类，可能包含数据访问层的实现类
+import com.lingnan.supermarket.dto.Production;
+import com.lingnan.supermarket.dto.User;
+import com.lingnan.supermarket.dao.UserService;
+import com.lingnan.supermarket.dao.impl.*;
 
-public class ProdCatalogTM extends AbstractTableModel{ // 定义一个名为ProdCatalogTM的类，该类继承自AbstractTableModel类，用于创建表格模型
 
-	private String [] columnName = {"类别id","类别名称","商品id","商品名称"}; // 定义一个字符串数组，用于存储表格的列名
+public class ProdCatalogTM extends AbstractTableModel{
+	
+	private String [] columnName = {"类别id","类别名称","商品id","商品名称"};
 
-	private productionImpl prodDao = new productionImpl(); // 创建productionImpl类的实例，用于访问商品数据
-
-	private Vector<Production> prods; // 声明一个Vector类型的变量，用于存储商品列表
-
-
-	public void all() { // 定义一个名为all的方法，无参数
+	private productionImpl prodDao = new productionImpl();
+	
+	private Vector<Production> prods;
+	public void all() {
 		//查找全部数据
-		prods = prodDao.findAllproduction(); // 调用prodDao的findAllproduction方法，获取所有商品并赋值给prods变量
+		prods = prodDao.findAllproduction();
 	}
-
-
-	public void ById2(Production p) { // 定义一个名为ById2的方法，接收Production类型的参数
+	public void ById2(Production p) {
 		//查找全部数据
-		prods = prodDao.findProductionById2(p.getId2()); // 调用prodDao的findProductionById2方法，根据id2获取商品并赋值给prods变量
+		prods = prodDao.findProductionById2(p.getId2());
 	}
-
-
-	@Override // 标记该方法重写了父类的方法
-	public int getRowCount() { // 重写AbstractTableModel类的getRowCount方法，用于获取表格的行数
-		return prods.size(); // 返回prods的大小，即商品的数量
+	
+	@Override
+	public int getRowCount() {
+		return prods.size();
 	}
 
-
-	@Override // 标记该方法重写了父类的方法
-	public int getColumnCount() { // 重写AbstractTableModel类的getColumnCount方法，用于获取表格的列数
-		return columnName.length; // 返回列名数组的长度，即表格的列数
+	@Override
+	public int getColumnCount() {  
+		return columnName.length;
 	}
 
-
-	@Override // 标记该方法重写了父类的方法
-	public Object getValueAt(int rowIndex, int columnIndex) { // 重写AbstractTableModel类的getValueAt方法，用于获取表格中指定位置的值
-		Production prod = prods.get(rowIndex); // 从prods中获取指定行的商品
-		/* 以下三行代码被注释掉了，可能是用于调试打印信息
-		System.out.println( "id="+users.get(rowIndex).getId());
+	@Override
+	public Object getValueAt(int rowIndex, int columnIndex) {
+		Production prod = prods.get(rowIndex);
+/*		System.out.println( "id="+users.get(rowIndex).getId());
 		System.out.println("rowIndex"+rowIndex);
 		System.out.println("columnIndex"+columnIndex);*/
-		if(columnIndex==0) { // 如果列索引为0，即第一列
-			return prod.getId2(); // 返回类别id
-		}else if(columnIndex==1) { // 如果列索引为1，即第二列
-			return prod.getName2(); // 返回类别名称
-		}else if(columnIndex==2) { // 如果列索引为2，即第三列
-			return prod.getId(); // 返回商品id
-		}else if(columnIndex==3) { // 如果列索引为3，即第四列
-			return prod.getName(); // 返回商品名称
-		}else { // 如果列索引不匹配以上任何列
-			return null; // 返回null
+		if(columnIndex==0) {
+			return prod.getId2();
+		}else if(columnIndex==1) {
+			return prod.getName2();			
+		}else if(columnIndex==2) {
+			return prod.getId();	
+		}else if(columnIndex==3) {
+			return prod.getName();
+		}else {
+			return null;
 		}
-
 	}
-
-	@Override // 标记该方法重写了父类的方法
-	public String getColumnName(int column) { // 重写AbstractTableModel类的getColumnName方法，用于获取指定列的名称
-
-		return columnName[column]; // 返回columnName数组中指定索引的列名
-
-
+	 
+	@Override
+	public String getColumnName(int column) {
+		return columnName[column];
 	}
-
-
+	
+	
 }

Supermarket/src/com/lingnan/supermarket/table/StorageRecordTM.java

@@ -1,85 +1,75 @@
-package com.lingnan.supermarket.table; // 定义包名，表示这个类属于com.lingnan.supermarket.table包
+package com.lingnan.supermarket.table;
 
-import java.util.Vector; // 导入Java的Vector类，用于存储表格数据
-import javax.swing.table.AbstractTableModel; // 导入Swing库中的AbstractTableModel类，用于创建表格模型
+import java.util.Vector;
 
-import com.lingnan.supermarket.dao.impl.storageRecordImpl; // 导入自定义的storageRecordImpl类，可能用于处理存储记录的数据访问对象
-import com.lingnan.supermarket.dto.StorageRecord; // 导入自定义的StorageRecord类，可能用于表示存储记录的数据传输对象
+import javax.swing.table.AbstractTableModel;
 
+import com.lingnan.supermarket.dao.impl.storageRecordImpl;
+import com.lingnan.supermarket.dto.StorageRecord;
 
-public class StorageRecordTM extends AbstractTableModel{ // 定义一个名为StorageRecordTM的类，该类继承自AbstractTableModel类，用于创建表格模型
 
-	private String [] columnName = {"订单号","操作时间","商品编号","进货+/出货-","数量"}; // 定义一个字符串数组，用于存储表格的列名
+public class StorageRecordTM extends AbstractTableModel{
+	
+	private String [] columnName = {"订单号","操作时间","商品编号","进货+/出货-","数量"};
 
-	private storageRecordImpl srDao = new storageRecordImpl(); // 创建一个storageRecordImpl类的实例，用于操作存储记录的数据
-
-	private  Vector<StorageRecord> storageRecords; // 声明一个Vector类型的变量，用于存储多个StorageRecord对象
-	private StorageRecord storageRecord ; // 声明一个StorageRecord类型的变量，用于表示单个存储记录
-
-	String oNumber ;/*订单号*/ // 声明一个String类型的变量，用于存储订单号，并添加注释说明
-
-
-
-	public void allStoragrRecord() { // 定义一个公共方法，用于获取所有存储记录
+	private storageRecordImpl srDao = new storageRecordImpl();
+	
+	private  Vector<StorageRecord> storageRecords;
+	private StorageRecord storageRecord ;
+	
+	String oNumber ;/*订单号*/
+	
+	
+	public void allStoragrRecord() {
 		//将添加的商品加入到静态变量Vector数组中
-		/*prod = InDialog.getProduction();*/ // 这行代码被注释掉了，可能是用于从对话框获取商品信息
-		storageRecords = srDao.findAllStorageRecord(); // 调用srDao的findAllStorageRecord方法，获取所有存储记录并赋值给storageRecords变量
+		/*prod = InDialog.getProduction();*/
+		storageRecords = srDao.findAllStorageRecord();
 	}
-
-
-
-	@Override // 标记该方法重写了父类的方法
-	public int getRowCount() { // 重写AbstractTableModel类的getRowCount方法，用于获取表格的行数
-		return storageRecords.size(); // 返回storageRecords的大小，即存储记录的数量
+	
+	
+	@Override
+	public int getRowCount() {
+		return storageRecords.size();
 	}
-
-
-
+	
 /*	public Float getAllPrice() {
 		return BufferImpl.InBufferAllPrice();
 	}
 */
-
-
-	@Override // 标记该方法重写了父类的方法
-	public int getColumnCount() { // 重写AbstractTableModel类的getColumnCount方法，用于获取表格的列数
-		return columnName.length; // 返回列名数组的长度，即表格的列数
+	@Override
+	public int getColumnCount() {  
+		return columnName.length;
 	}
 
-	@Override // 标记该方法重写了父类的方法
-	public Object getValueAt(int rowIndex, int columnIndex) { // 重写AbstractTableModel类的getValueAt方法，用于获取表格中指定位置的值
-		storageRecord = storageRecords.get(rowIndex); // 从storageRecords中获取指定行的存储记录
-	/* 以下三行代码被注释掉了，可能是用于调试打印信息
-	System.out.println( "id="+users.get(rowIndex).getId());
-	System.out.println("rowIndex"+rowIndex);
-	System.out.println("columnIndex"+columnIndex);*/
-		oNumber=storageRecord.getTheNumber(); // 从存储记录中获取订单号并赋值给oNumber变量
-		if(columnIndex==0) { // 如果列索引为0，即第一列
-			return storageRecord.getTheNumber(); // 返回订单号
-		}else if(columnIndex==1) { // 如果列索引为1，即第二列
-			return storageRecord.getcDate(); // 返回操作时间
-		}else if(columnIndex==2) { // 如果列索引为2，即第三列
-			return storageRecord.getId(); // 返回商品编号
-		}else if(columnIndex==3) { // 如果列索引为3，即第四列
-			return storageRecord.getExecute(); // 返回进货或出货标识
-		}else if(columnIndex==4) { // 如果列索引为4，即第五列
-			return storageRecord.getNum(); // 返回数量
-		}else { // 如果列索引不匹配以上任何列
-			return null; // 返回null
+	@Override
+	public Object getValueAt(int rowIndex, int columnIndex) {
+		storageRecord = storageRecords.get(rowIndex);
+/*		System.out.println( "id="+users.get(rowIndex).getId());
+		System.out.println("rowIndex"+rowIndex);
+		System.out.println("columnIndex"+columnIndex);*/
+		oNumber=storageRecord.getTheNumber();
+		if(columnIndex==0) {
+			return storageRecord.getTheNumber();
+		}else if(columnIndex==1) {
+			return storageRecord.getcDate();
+		}else if(columnIndex==2) {
+			return storageRecord.getId();
+		}else if(columnIndex==3) {
+			return  storageRecord.getExecute();
+		}else if(columnIndex==4) {
+			return  storageRecord.getNum();
+		}else {
+			return null;
 		}
 	}
+	 
 
-
-
-	@Override // 标记该方法重写了父类的方法
-	public String getColumnName(int column) { // 重写AbstractTableModel类的getColumnName方法，用于获取指定列的名称
-
-		return columnName[column]; // 返回columnName数组中指定索引的列名
-
-
+	
+	
+	@Override
+	public String getColumnName(int column) {
+		return columnName[column];
 	}
-
-
-
-
+	
+	
 }