0
0

Java swing+Mysql商品销售管理系统

前言

临近期末做了一个商品销售管理系统，分享下，全部源码在码云，需要自取，博客只分享部分代码（太多了）。

数据库的建立

我们使用Navicat Premium 15连接mysql，建立如下九张表。

得到如下视图（看上去似乎有点乱了）

因为register是一个注册表，所以不参与视图里的连接。

各种表的情况如上所示，当然你也可以用sql语句写。

这个是我导出来的sql语句，由于我也没试过，所以不保证对错，如果错了只能老老实实自己差数据了。

  1. /*
  2.  Navicat Premium Data Transfer
  4.  Source Server         : 123
  5.  Source Server Type    : MySQL
  6.  Source Server Version : 80027
  7.  Source Host           : localhost:3306
  8.  Source Schema         : user
  10.  Target Server Type    : MySQL
  11.  Target Server Version : 80027
  12.  File Encoding         : 65001
  14.  Date: 27/12/2021 21:08:30
  15. */
  17. SET NAMES utf8mb4;
  18. SET FOREIGN_KEY_CHECKS = 0;
  20. -- ----------------------------
  21. -- Table structure for comminfo
  22. -- ----------------------------
  23. DROP TABLE IF EXISTS `comminfo`;
  24. CREATE TABLE `comminfo`  (
  25.   `itemNo` varchar(20) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '商品编号',
  26.   `itemName` varchar(20) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '商品名称',
  27.   `brand` varchar(20) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '品牌',
  28.   `model` varchar(20) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '型号',
  29.   `salePrice` int NOT NULL COMMENT '售价',
  30.   PRIMARY KEY (`itemNo`) USING BTREE,
  31.   INDEX `pk10`(`salePrice`) USING BTREE,
  32.   CONSTRAINT `comminfo_pk` FOREIGN KEY (`itemNo`) REFERENCES `inventory` (`itemNo`) ON DELETE RESTRICT ON UPDATE CASCADE
  33. ) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;
  35. -- ----------------------------
  36. -- Records of comminfo
  37. -- ----------------------------
  38. INSERT INTO `comminfo` VALUES ('i001', '大航海时代', '海贼王', '其他', 10000);
  39. INSERT INTO `comminfo` VALUES ('i002', '红发四皇', '海贼王', '其他', 5000);
  40. INSERT INTO `comminfo` VALUES ('i003', '白胡子之死', '海贼王', '其他', 1000);
  41. INSERT INTO `comminfo` VALUES ('i004', '路飞出海', '海贼王', '其他', 500);
  42. INSERT INTO `comminfo` VALUES ('i005', '艾斯之死', '海贼王', '其他', 1000);
  43. INSERT INTO `comminfo` VALUES ('i006', '克洛克达尔', '海贼王', '其他', 3000);
  44. INSERT INTO `comminfo` VALUES ('i007', '汉库克逃脱', '海贼王', '其他', 2000);
  45. INSERT INTO `comminfo` VALUES ('i008', '海绵宝宝的小窝', '其他', '其他', 10000);
  46. INSERT INTO `comminfo` VALUES ('i009', '海星', '食品', 'min', 1000);
  48. -- ----------------------------
  49. -- Table structure for employee
  50. -- ----------------------------
  51. DROP TABLE IF EXISTS `employee`;
  52. CREATE TABLE `employee`  (
  53.   `employeeNo` varchar(20) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '员工号',
  54.   `employeeName` varchar(20) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '员工姓名',
  55.   `sex` char(2) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '性别',
  56.   `basePay` int NOT NULL COMMENT '基本工资',
  57.   `post` varchar(20) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '职务',
  58.   `password` varchar(20) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '密码',
  59.   PRIMARY KEY (`employeeNo`) USING BTREE,
  60.   INDEX `员工编号`(`employeeNo`) USING BTREE
  61. ) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;
  63. -- ----------------------------
  64. -- Records of employee
  65. -- ----------------------------
  66. INSERT INTO `employee` VALUES ('e001', '香克斯', '男', 4000, '四皇', '123456');
  67. INSERT INTO `employee` VALUES ('e002', '路飞', '男', 500, '新星', '000111');
  68. INSERT INTO `employee` VALUES ('e003', '索隆', '男', 500, '新星', '000222');
  69. INSERT INTO `employee` VALUES ('e004', '娜美', '女', 500, '新星', '000333');
  70. INSERT INTO `employee` VALUES ('e005', '山治', '男', 500, '新星', '000444');
  71. INSERT INTO `employee` VALUES ('e006', '乌索普', '男', 500, '新星', '000555');
  72. INSERT INTO `employee` VALUES ('e007', '罗杰', '男', 10000, '海贼王', '666666');
  73. INSERT INTO `employee` VALUES ('e008', '爱德华', '男', 4000, '四皇', '888888');
  74. INSERT INTO `employee` VALUES ('e009', '艾斯', '男', 600, '新星', '111111');
  75. INSERT INTO `employee` VALUES ('e010', '克洛克达尔', '男', 800, '七武海', '222222');
  76. INSERT INTO `employee` VALUES ('e011', '汉库克', '女', 800, '七武海', '333333');
  78. -- ----------------------------
  79. -- Table structure for employeeifom
  80. -- ----------------------------
  81. DROP TABLE IF EXISTS `employeeifom`;
  82. CREATE TABLE `employeeifom`  (
  83.   `employeeNo` varchar(20) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '员工号',
  84.   `employeeName` varchar(20) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '员工姓名',
  85.   `ispartyMember` varchar(2) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '是否党员',
  86.   `Resume` varchar(100) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '简介',
  87.   `photo` blob NULL COMMENT '照片',
  88.   PRIMARY KEY (`employeeNo`) USING BTREE,
  89.   CONSTRAINT `pk6` FOREIGN KEY (`employeeNo`) REFERENCES `employee` (`employeeNo`) ON DELETE RESTRICT ON UPDATE CASCADE
  90. ) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;
  92. -- ----------------------------
  93. -- Records of employeeifom
  94. -- ----------------------------
  95. INSERT INTO `employeeifom` VALUES ('e001', '香克斯', '否', '红发香克斯四皇之一', NULL);
  96. INSERT INTO `employeeifom` VALUES ('e002', '路飞', '否', '草帽小子', NULL);
  97. INSERT INTO `employeeifom` VALUES ('e003', '索隆', '否', '绿毛，努力，自律', NULL);
  98. INSERT INTO `employeeifom` VALUES ('e004', '娜美', '是', '航海士', NULL);
  99. INSERT INTO `employeeifom` VALUES ('e005', '山治', '否', '厨师', NULL);
  100. INSERT INTO `employeeifom` VALUES ('e006', '乌索普', '否', '绝境乌索普', NULL);
  102. -- ----------------------------
  103. -- Table structure for inventory
  104. -- ----------------------------
  105. DROP TABLE IF EXISTS `inventory`;
  106. CREATE TABLE `inventory`  (
  107.   `itemNo` varchar(20) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '商品编号',
  108.   `purchaseDate` datetime NOT NULL COMMENT '进货日期',
  109.   `buyingPrice` int NOT NULL COMMENT '进货价',
  110.   `itemQuantity` int NOT NULL COMMENT '进货数量',
  111.   `supplierNo` char(6) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '供应商编号',
  112.   PRIMARY KEY (`itemNo`) USING BTREE,
  113.   INDEX `supplierNo`(`supplierNo`) USING BTREE,
  114.   INDEX `itemNo`(`itemNo`) USING BTREE,
  115.   CONSTRAINT `inventory_pk` FOREIGN KEY (`supplierNo`) REFERENCES `supplier` (`supplierNo`) ON DELETE RESTRICT ON UPDATE CASCADE
  116. ) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;
  118. -- ----------------------------
  119. -- Records of inventory
  120. -- ----------------------------
  121. INSERT INTO `inventory` VALUES ('i001', '1497-02-24 00:00:00', 10000, 1, 's004');
  122. INSERT INTO `inventory` VALUES ('i002', '1517-01-01 00:00:00', 4000, 1, 's001');
  123. INSERT INTO `inventory` VALUES ('i003', '1520-03-24 00:00:00', 4000, 1, 's002');
  124. INSERT INTO `inventory` VALUES ('i004', '1520-01-01 00:00:00', 1000, 5, 's003');
  125. INSERT INTO `inventory` VALUES ('i005', '1520-08-10 00:00:00', 2000, 1, 's007');
  126. INSERT INTO `inventory` VALUES ('i006', '1515-01-13 00:00:00', 1000, 1, 's005');
  127. INSERT INTO `inventory` VALUES ('i007', '1506-01-18 00:00:00', 3000, 1, 's006');
  128. INSERT INTO `inventory` VALUES ('i008', '2021-09-09 00:00:00', 1000, 10, 's008');
  129. INSERT INTO `inventory` VALUES ('i009', '2021-09-09 00:00:00', 500, 100, 's009');
  130. INSERT INTO `inventory` VALUES ('i010', '1520-03-24 00:00:00', 500, 1010, 's010');
  132. -- ----------------------------
  133. -- Table structure for register
  134. -- ----------------------------
  135. DROP TABLE IF EXISTS `register`;
  136. CREATE TABLE `register`  (
  137.   `id` char(11) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL,
  138.   `password` char(10) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL,
  139.   PRIMARY KEY (`id`) USING BTREE
  140. ) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;
  142. -- ----------------------------
  143. -- Records of register
  144. -- ----------------------------
  145. INSERT INTO `register` VALUES ('012', '123');
  146. INSERT INTO `register` VALUES ('0123', '0123');
  147. INSERT INTO `register` VALUES ('123', '123');
  148. INSERT INTO `register` VALUES ('123456', '123');
  150. -- ----------------------------
  151. -- Table structure for returnit
  152. -- ----------------------------
  153. DROP TABLE IF EXISTS `returnit`;
  154. CREATE TABLE `returnit`  (
  155.   `price` int NOT NULL COMMENT '价格',
  156.   `returnNo` varchar(20) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '退货号',
  157.   `transactionNo` varchar(20) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '销售号',
  158.   `itemNo` varchar(20) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '商品编号',
  159.   `supplierNo` char(6) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '供应商编号',
  160.   `reason` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '退货原因',
  161.   PRIMARY KEY (`returnNo`) USING BTREE,
  162.   INDEX `supplierNo`(`supplierNo`) USING BTREE,
  163.   INDEX `transactionNo`(`transactionNo`) USING BTREE,
  164.   INDEX `itemNo`(`itemNo`) USING BTREE,
  165.   INDEX `price`(`price`) USING BTREE,
  166.   CONSTRAINT `returnit_pk1` FOREIGN KEY (`itemNo`) REFERENCES `inventory` (`itemNo`) ON DELETE RESTRICT ON UPDATE CASCADE,
  167.   CONSTRAINT `returnit_pk2` FOREIGN KEY (`transactionNo`) REFERENCES `salefact` (`transactionNo`) ON DELETE RESTRICT ON UPDATE CASCADE
  168. ) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;
  170. -- ----------------------------
  171. -- Records of returnit
  172. -- ----------------------------
  174. -- ----------------------------
  175. -- Table structure for salefact
  176. -- ----------------------------
  177. DROP TABLE IF EXISTS `salefact`;
  178. CREATE TABLE `salefact`  (
  179.   `transactionNo` varchar(20) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '销售号',
  180.   `itemNo` varchar(20) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '商品编号',
  181.   `saleQuantity` int NOT NULL COMMENT '销售数量',
  182.   `saleSumPrice` int NOT NULL COMMENT '销售总金额',
  183.   `saleDate` datetime NOT NULL COMMENT '销售日期',
  184.   `employeeNo` varchar(20) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '员工号',
  185.   PRIMARY KEY (`transactionNo`) USING BTREE,
  186.   INDEX `商品编号`(`itemNo`) USING BTREE,
  187.   INDEX `员工编号`(`employeeNo`) USING BTREE,
  188.   CONSTRAINT `salefact_pk1` FOREIGN KEY (`itemNo`) REFERENCES `inventory` (`itemNo`) ON DELETE RESTRICT ON UPDATE CASCADE,
  189.   CONSTRAINT `salefact_pk2` FOREIGN KEY (`employeeNo`) REFERENCES `employee` (`employeeNo`) ON DELETE RESTRICT ON UPDATE CASCADE
  190. ) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;
  192. -- ----------------------------
  193. -- Records of salefact
  194. -- ----------------------------
  195. INSERT INTO `salefact` VALUES ('t001', 'i001', 1, 20000, '1497-12-31 00:00:00', 'e007');
  196. INSERT INTO `salefact` VALUES ('t002', 'i002', 1, 10000, '1520-02-21 00:00:00', 'e001');
  197. INSERT INTO `salefact` VALUES ('t003', 'i003', 1, 12000, '1521-03-24 00:00:00', 'e008');
  198. INSERT INTO `salefact` VALUES ('t004', 'i004', 5, 1000, '1521-08-21 00:00:00', 'e002');
  199. INSERT INTO `salefact` VALUES ('t005', 'i005', 1, 1000, '1521-05-21 00:00:00', 'e009');
  200. INSERT INTO `salefact` VALUES ('t006', 'i006', 1, 2000, '1520-02-01 00:00:00', 'e010');
  201. INSERT INTO `salefact` VALUES ('t007', 'i007', 1, 6000, '1521-03-05 00:00:00', 'e011');
  203. -- ----------------------------
  204. -- Table structure for stock
  205. -- ----------------------------
  206. DROP TABLE IF EXISTS `stock`;
  207. CREATE TABLE `stock`  (
  208.   `buyingPrice` int NOT NULL COMMENT '进货价',
  209.   `entryNo` varchar(20) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '进货号',
  210.   `itemNo` varchar(20) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '商品编号',
  211.   `quantity` int NOT NULL COMMENT '数量',
  212.   PRIMARY KEY (`entryNo`) USING BTREE,
  213.   INDEX `stock_pk`(`itemNo`) USING BTREE,
  214.   CONSTRAINT `stock_pk` FOREIGN KEY (`itemNo`) REFERENCES `inventory` (`itemNo`) ON DELETE RESTRICT ON UPDATE CASCADE
  215. ) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;
  217. -- ----------------------------
  218. -- Records of stock
  219. -- ----------------------------
  220. INSERT INTO `stock` VALUES (10000, 'e001', 'i001', 1);
  221. INSERT INTO `stock` VALUES (4000, 'e002', 'i002', 1);
  222. INSERT INTO `stock` VALUES (4000, 'e003', 'i003', 1);
  223. INSERT INTO `stock` VALUES (1000, 'e004', 'i004', 5);
  224. INSERT INTO `stock` VALUES (2000, 'e005', 'i005', 1);
  225. INSERT INTO `stock` VALUES (1000, 'e006', 'i006', 1);
  226. INSERT INTO `stock` VALUES (3000, 'e007', 'i007', 1);
  227. INSERT INTO `stock` VALUES (1000, 'e008', 'i008', 10);
  228. INSERT INTO `stock` VALUES (500, 'e009', 'i009', 100);
  229. INSERT INTO `stock` VALUES (500, 'e010', 'i010', 10);
  231. -- ----------------------------
  232. -- Table structure for supplier
  233. -- ----------------------------
  234. DROP TABLE IF EXISTS `supplier`;
  235. CREATE TABLE `supplier`  (
  236.   `supplierName` varchar(20) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '供应商名称',
  237.   `supplierNo` char(6) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '供应商编号',
  238.   `address` varchar(20) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '供应商地址',
  239.   `teleNumber` char(11) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '联系电话',
  240.   PRIMARY KEY (`supplierNo`) USING BTREE
  241. ) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;
  243. -- ----------------------------
  244. -- Records of supplier
  245. -- ----------------------------
  246. INSERT INTO `supplier` VALUES ('红发海贼团', 's001', '雷德>佛斯号', '13245672386');
  247. INSERT INTO `supplier` VALUES ('白胡子海贼团', 's002', '莫比迪克号', '19046575123');
  248. INSERT INTO `supplier` VALUES ('草帽海贼团', 's003', '黄金梅利号', '12300230989');
  249. INSERT INTO `supplier` VALUES ('罗杰海贼团', 's004', '奥尔>杰克森号', '11109998888');
  250. INSERT INTO `supplier` VALUES ('巴洛克工作社', 's005', '下大雨', '10010020003');
  251. INSERT INTO `supplier` VALUES ('九蛇海贼团', 's006', '九蛇岛', '10020030004');
  252. INSERT INTO `supplier` VALUES ('黑桃海贼团', 's007', '没提到', '12340056007');
  253. INSERT INTO `supplier` VALUES ('海绵宝宝', 's008', '菠萝屋', '12345678910');
  254. INSERT INTO `supplier` VALUES ('派大星的石头屋', 's009', '深海石头屋', '10010010201');
  255. INSERT INTO `supplier` VALUES ('广西药业', 's010', '广西柳州', '11100001011');
  257. SET FOREIGN_KEY_CHECKS = 1;

Java系统

entity包

实体集包，你有多少张表就需要在底下建多少个类

里面写各种属性、方法，只要不是int型，其余全定义为string型。

data包

连接数据库更新的包，里面写入各种sql语句，同样有多少个表需要更新就要写多少个类

里面写入各种更新的语句及成员 。

一个employeeDao类

  2. package data;
  4. import entity.Employee;
  6. import java.sql.ResultSet;
  7. import java.sql.SQLException;
  8. import java.util.ArrayList;
  9. import java.util.List;
  11. public class EmployeeDao {
  12.     /** 成员方法1：通过员工编号，获取一个员工对象 */
  13.     public static Employee getEmployeeByEmployeeNo(String employeeNo) {
  14.         Employee employee = null;
  15.         if (employeeNo != null) {
  16.             // 构造按照员工编号查询员工的sql查询语句
  17.             String sql = "select * from employee where employeeNo='" + employeeNo + "'";
  18.             ResultSet rs = BaseDao1.executeQuery(sql);// 执行查询语句，并返回结果集
  19.             // 处理查询结果
  20.             try {
  21.                 if (rs.next()) {
  22.                     // 创建员工对象，保存员工信息
  23.                     employee = new Employee();
  24.                     employee.setEmployeeNo(rs.getString("employeeNo"));
  25.                     employee.setEmployeeName(rs.getString("employeeName"));
  26.                     employee.setSex(rs.getString("sex"));
  27.                     employee.setBasePay(rs.getInt("basePay"));
  28.                     employee.setPost(rs.getString("post"));
  29.                     employee.setPassword(rs.getString("password"));
  30.                 }
  31.             } catch (SQLException e) {
  32.                 e.printStackTrace();
  33.             }
  34.         }
  35.         return employee;// 返回员工对象
  36.     }
  38.     /** 成员方法2：通过sql查询语句，获取员工对象列表 */
  39.     public static List<Employee> selectEmployeeList(String sql) {
  40.         List<Employee> list = new ArrayList<Employee>();// 创建列表
  41.         if (sql != null) {
  42.             Employee employee = null;
  43.             ResultSet rs = BaseDao1.executeQuery(sql);// 执行查询语句，并返回结果集
  44.             try {
  45.                 while (rs.next()) {
  46.                     // 创建员工对象，保存员工信息
  47.                     employee = new Employee();
  48.                     employee.setEmployeeNo(rs.getString("employeeNo"));
  49.                     employee.setEmployeeName(rs.getString("employeeName"));
  50.                     employee.setSex(rs.getString("sex"));
  51.                     employee.setBasePay(rs.getInt("basePay"));
  52.                     employee.setPost(rs.getString("post"));
  53.                     employee.setPassword(rs.getString("password"));
  54.                     list.add(employee);
  55.                 }
  56.             } catch (Exception e) {
  57.                 e.printStackTrace();
  58.             }
  59.         }
  60.         return list;// 返回员工列表
  61.     }
  63.     /** 成员方法3：获取所有员工对象列表 */
  64.     public static List<Employee> selectEmployeeList() {
  65.         // 构造查询所有员工的sql查询语句
  66.         String sql = "select * from employee";
  67.         return selectEmployeeList(sql);// 返回员工列表
  68.     }
  70.     /** 成员方法4：按照字符属性查询条件，获取员工对象列表，重载方法 */
  71.     public static List<Employee> selectEmployeeList(String field, String value) {
  72.         // 构造默认的sql查询语句
  73.         String sql = "select * from employee";
  74.         if ((value != null & value.length() > 0) && field != null) {
  75.             // 构造按照字符属性查询员工的sql查询语句，采用模糊查询
  76.             sql = "select * from employee where " + field + " like '%" + value + "%'";
  77.         }
  78.         return selectEmployeeList(sql);// 返回员工列表
  79.     }
  81.     /** 成员方法5：按照整型查询条件，获取员工对象列表，重载方法 */
  82.     public static List<Employee> selectEmployeeList(String field, int value) {
  83.         // 构造默认的sql查询语句
  84.         String sql = "select * from employee";
  85.         if (field != null && value != 0) {
  86.             // 构造按照整型属性查询员工的sql查询语句，采用区间查询
  87.             sql = "select * from employee where " + field + "=" +value;
  88.         }
  89.         return selectEmployeeList(sql);// 返回员工列表
  90.     }
  92.     /** 成员方法6：添加新员工 */
  93.     public static int insertEmployee(Employee Employee) {
  94.         if (Employee != null) {
  95.             // 获取员工信息
  96.             String EmployeeNo = Employee.getEmployeeNo();
  97.             String EmployeeName = Employee.getEmployeeName();
  98.             String sex = Employee.getSex();
  99.             String post = Employee.getPost();
  100.             String password = Employee.getPassword();
  101.             int basePay = Employee.getBasePay();
  102.             // 构造添加员工的sql更新语句
  103.             String sql = "insert into employee values('" + EmployeeNo + "','" + EmployeeName + "','" + sex + "'," +basePay+
  104.                     ", '"+ post + "','"+ password + "' )";
  105.             return BaseDao1.executeUpdate(sql);// 执行更新语句
  106.         } else {
  107.             return -1;
  108.         }
  109.     }
  111.     /** 成员方法7：修改指定员工信息 */
  112.     public static int upDateEmployee(Employee Employee) {
  113.         if (Employee != null) {
  114.             // 获取员工信息
  115.             String EmployeeNo = Employee.getEmployeeNo();
  116.             String EmployeeName = Employee.getEmployeeName();
  117.             String sex = Employee.getSex();
  118.             String post = Employee.getPost();
  119.             String password = Employee.getPassword();
  120.             int basePay = Employee.getBasePay();
  121.             // 构造修改员工的sql更新语句
  122.             String sql = "update  employee set employeeName='" + EmployeeName + "',sex='" + sex + "', post='" + post
  123.                     +"',password ='"+password + "',basePay=" + basePay + " where employeeNo='" + EmployeeNo + "'";
  124.             return BaseDao1.executeUpdate(sql);// 执行更新语句
  125.         } else {
  126.             return -1;
  127.         }
  128.     }
  130.     /** 成员方法8：删除指定员工信息 */
  131.     public static int deleteEmployee(String EmployeeNo) {
  132.         // 构造删除员工的sql更新语句
  133.         String sql = "delete from employee  where employeeNo='" + EmployeeNo + "'";
  134.         return BaseDao1.executeUpdate(sql);// 执行更新语句
  135.     }
  137.     /** 成员方法9：清空所有员工信息 */
  138.     public static void emptyEmployee() {
  139.         // 构造清空员工的sql更新语句
  140.         String sql = "delete from employee";
  141.         BaseDao1.executeUpdate(sql);// 执行更新语句
  142.     }
  143. }

Login包

里面写入java swing登录窗口的方法和连接数据库的方法

**一个handleLogin类 **

  1. package Login;
  3. import windows.MainFrame;
  5. import java.sql.*;
  6. import javax.swing.JOptionPane;
  7. public class HandleLogin {
  8.    Connection con;//与特定数据库的连接（会话）。
  9.    PreparedStatement preSql;//PreparedStatement是一个接口，preSql是一个接口引用，接口不能new对象，所以借用下方prepareStatement方法
  10.    ResultSet rs;//表示数据库结果集的数据表，通常通过执行查询数据库的语句生成。
  11.    public HandleLogin(){
  12.       con = GetDBConnection.connectDB("user","root","123456");//链接数据库
  13.    }
  14.    public Login queryVerify(Login loginModel) {
  15.       String id = loginModel.getID();
  16.       String pw = loginModel.getPassword();
  17.       String sqlStr ="select id,password from register where "+
  18.                       "id = ? and password = ?";
  19.       try { 
  20.           preSql = con.prepareStatement(sqlStr);//创建一个 PreparedStatement对象，用于将参数化的SQL语句发送到数据库
  21.           preSql.setString(1,id);//将指定的参数设置为给定的Java String值。1代表sql语句中第一个？号，后面的参数代表给？赋的值
  22.           preSql.setString(2,pw);//同上
  23.           rs = preSql.executeQuery(); 
  24.           if(rs.next()==true) {//最初，光标位于第一行之前，next方法将光标移动到下一行，并且由于在ResultSet对象中没有更多行时返回false
  25.              loginModel.setLoginSuccess(true);//第一行有数据代表该ID和密码都存在，因此登录成功，并将loginSuccess设为true
  26.              JOptionPane.showMessageDialog(null,"登录成功",//弹出一个标准对话框，提示用户获取值或通知他们某些东西。
  27.                              "恭喜",JOptionPane.WARNING_MESSAGE);
  28.               MainFrame mainFrame = new MainFrame();
  29.           }
  30.           else {
  31.              loginModel.setLoginSuccess(false);//第一行不存在代表ID或密码错误，并将loginSuccess设为false
  32.              JOptionPane.showMessageDialog(null,"登录失败",//弹出一个标准对话框，提示用户获取值或通知他们某些东西。
  33.                 "登录失败，重新登录",JOptionPane.WARNING_MESSAGE);
  34.           }
  35.           con.close();
  36.       }
  37.       catch(SQLException e) {}
  38.       return loginModel;
  39.    }
  40. }

这个包建完后已经可以实现登录和注册了

windows包

这个包最复杂了，包含了查询和更新调用sql语句的方法，query是查询，upkeep是更新

** 一个employeeQuery类**

  1. package windows;
  3. import data.EmployeeDao;
  4. import entity.Employee;
  5. import java.awt.BorderLayout;
  6. import java.awt.GridBagConstraints;
  7. import java.awt.GridBagLayout;
  8. import java.awt.Insets;
  9. import java.awt.event.ActionEvent;
  10. import java.awt.event.ActionListener;
  11. import java.awt.event.ItemEvent;
  12. import java.awt.event.ItemListener;
  13. import java.awt.event.KeyAdapter;
  14. import java.util.List;
  15. import java.awt.event.KeyEvent;
  16. import javax.swing.JButton;
  17. import javax.swing.JComboBox;
  18. import javax.swing.JLabel;
  19. import javax.swing.JPanel;
  20. import javax.swing.JScrollPane;
  21. import javax.swing.JTable;
  22. import javax.swing.JTextField;
  23. import javax.swing.table.DefaultTableModel;
  25. public class EmployeeQuery extends PublicJFrame{
  26.     /** 成员变量： */
  27.     JLabel lb_query;// 声明查询标签
  28.     JTextField tf_query;// 声明查询条件文本框
  29.     JComboBox<String> cb_query;// 声明查询栏目组合框
  30.     JButton bt_query;// 声明查询按钮
  31.     private JTable table;// 声明表格
  32.     // 调用方法，获取所有员工列表，并保存
  33.     private List<Employee> list = EmployeeDao.selectEmployeeList();
  34.     // 创建员工表栏目名称字符串
  35.     private String[] tb_heads = { "员工编号 ", "员工名称 ", "性别", "职务", "基本工资" };
  36.     // 员工表栏目名称对应的表字段
  37.     private String[] fields = { "EmployeeNo", "EmployeeName", "sex", "post","basePay" };
  38.     // 创建员工表格模型
  39.     private DefaultTableModel model = new DefaultTableModel(
  40.             new Object[][] {}, tb_heads);
  41.     private String field = "EmployeeNo";// 设置默认的当前的查询字段
  42.     String valueStr = " ";// 设置字符串类型查询字段的初始值
  43.     int valueInt = 0;// 设置整型类型查询字段的初始值
  44.     double valueDouble = 0.0;// 设置实型数据查询字段的初始值
  46.     /** 构造方法：初始化界面 */
  47.     EmployeeQuery() {
  48.         this.setTitle("--员工查询-- ");
  49.         this.setSize(1200, 500);
  50.         JPanel queryPanel = createQueryPanel();
  51.         this.add(queryPanel, BorderLayout.NORTH);
  52.         JPanel tablePanel = createTablePanel();
  53.         this.add(tablePanel, BorderLayout.CENTER);
  54.         this.setLocationRelativeTo(null);
  55.         this.setVisible(true);
  56.     }
  58.     /** 成员方法1：创建查询面板的方法 */
  59.     private JPanel createQueryPanel() {
  60.         JPanel queryPanel = new JPanel();
  61.         queryPanel.setOpaque(false);//允许底层像素出现
  62.         queryPanel.setLayout(new GridBagLayout());
  63.         ((GridBagLayout) queryPanel
  64.                 .getLayout()).columnWidths = new int[] { 0, 100, 200,
  65.                 120, 80, 80, 0 };
  66.         ((GridBagLayout) queryPanel
  67.                 .getLayout()).columnWeights = new double[] { 0.5, 0.0,
  68.                 0.0, 0.0, 0.0, 0.0, 0.5 };
  70.         lb_query = new JLabel("请输入员工编号");
  71.         queryPanel.add(lb_query,
  72.                 new GridBagConstraints(1, 0, 1, 1, 0.0, 0.0,
  73.                         GridBagConstraints.EAST,
  74.                         GridBagConstraints.BOTH,
  75.                         new Insets(10, 10, 10, 10), 0, 0));
  77.         tf_query = new JTextField();
  78.         tf_query.requestFocus();
  79.         // 为查询条件文本框，添加回车键事件监听器
  80.         tf_query.addKeyListener(new KeyAdapter() {
  81.             @Override
  82.             public void keyTyped(KeyEvent arg0) {
  83.                 if (arg0.getKeyChar() == '\n') {
  84.                     // 调用“查询”按钮事件响应方法
  85.                     bn_query_actionPerformed();
  86.                 }
  87.             }
  88.         });
  89.         queryPanel.add(tf_query,
  90.                 new GridBagConstraints(2, 0, 1, 1, 0.0, 0.0,
  91.                         GridBagConstraints.CENTER,
  92.                         GridBagConstraints.BOTH,
  93.                         new Insets(10, 0, 10, 10), 0, 0));
  95.         cb_query = new JComboBox<String>(tb_heads);
  96.         // 为查询栏目组合框，添加条目事件监听器
  97.         cb_query.addItemListener(new ItemListener() {
  98.             @Override
  99.             public void itemStateChanged(ItemEvent arg0) {
  100.                 // 调用“查询栏目”组合框栏目状态被改变事件响应方法
  101.                 cb_query_itemStateChanged(arg0);
  102.             }
  103.         });
  104.         queryPanel.add(cb_query,
  105.                 new GridBagConstraints(3, 0, 1, 1, 0.0, 0.0,
  106.                         GridBagConstraints.CENTER,
  107.                         GridBagConstraints.BOTH,
  108.                         new Insets(10, 0, 10, 10), 0, 0));
  110.         bt_query = new JButton("查询 ");
  111.         // 为“查询”按钮，添加单击事件监听器
  112.         bt_query.addActionListener(new ActionListener() {
  113.             @Override
  114.             public void actionPerformed(ActionEvent arg0) {
  115.                 // 调用“查询”按钮事件响应方法
  116.                 bn_query_actionPerformed();
  117.             }
  118.         });
  119.         queryPanel.add(bt_query,
  120.                 new GridBagConstraints(4, 0, 1, 1, 0.0, 0.0,
  121.                         GridBagConstraints.CENTER,
  122.                         GridBagConstraints.BOTH,
  123.                         new Insets(10, 0, 10, 10), 0, 0));
  125.         JButton bn_close = new JButton("关闭");
  126.         // 为“关闭”按钮，添加单击事件监听器
  127.         bn_close.addActionListener(new ActionListener() {
  128.             @Override
  129.             public void actionPerformed(ActionEvent arg0) {
  130.                 dispose();// 关闭界面
  131.             }
  132.         });
  134.         queryPanel.add(bn_close,
  135.                 new GridBagConstraints(5, 0, 1, 1, 0.0, 0.0,
  136.                         GridBagConstraints.CENTER,
  137.                         GridBagConstraints.BOTH,
  138.                         new Insets(10, 0, 10, 10), 0, 0));
  139.         return queryPanel;// 返回“查询面板”
  140.     }
  142.     /** 成员方法2：创建表格面板的方法 */
  143.     private JPanel createTablePanel() {
  144.         // 创建表格面板，采用边界布局
  145.         JPanel tablePanel = new JPanel(new BorderLayout(5, 5));
  146.         JScrollPane scrollPane = new JScrollPane();// 创建滚动面板
  147.         tablePanel.add(scrollPane);// 将表格面板添加到滚动面板上
  148.         table = new JTable(model);// 创建表格，并采用指定的表格模型
  149.         addRowToModel(list);
  150.         scrollPane.setViewportView(table);
  151.         return tablePanel;
  152.     }
  154.     /** 成员方法3：向表格模型，添加员工列表 */
  155.     private void addRowToModel(List<Employee> list) {
  156.         model.setRowCount(0);// 清除表格模型中的数据
  157.         for (int i = 0; i < list.size(); i++) {
  158.             Employee Employee = list.get(i);
  159.             model.addRow(new Object[] { Employee.getEmployeeNo(),
  160.             Employee.getEmployeeName(),
  161.             Employee.getSex(),
  162.             Employee.getPost(),
  163.             Employee.getBasePay()});
  164.         }
  165.     }
  167.     /** 成员方法4：查询栏目组合框状态被改变的事件响应方法 */
  168.     private void cb_query_itemStateChanged(ItemEvent arg0) {
  169.         if (arg0.getStateChange() == ItemEvent.SELECTED) {
  170.             // 根据选择改变标签显示内容
  171.             lb_query.setText("请输入" + (String) arg0.getItem() + ":");
  172.             tf_query.setText("");
  173.             // 获取组合框中选定的栏目名称
  174.             for (int i = 0; i < tb_heads.length; i++) {
  175.                 if (arg0.getItem().equals(tb_heads[i])) {
  176.                     field = fields[i];// 保存对应的字段，作为当前被选定的字段
  177.                 }
  178.             }
  179.             list = EmployeeDao.selectEmployeeList();// 调用方法，获取所有商品列表
  180.             addRowToModel(list);// 调用方法：将商品列表，添加到表格模型中
  181.             tf_query.requestFocus();// 设置查询条件文本框，获得焦点
  182.         }
  183.     }
  185.     /** 成员方法5：“修改”按钮单击事件响应方法 */
  186.     private void bt_modify_actionPerformed() {
  188.         switch (field) {
  189.             case "EmployeeNo":
  190.             case "EmployeeName":
  191.             case "sex":
  192.             case "post":
  193.                 // 获取字符串类型的查询条件
  194.                 valueStr = tf_query.getText();
  195.                 // 调用按照（字段名、字符串字段值）查询员工列表的方法，查询员工信息
  196.                 list = EmployeeDao.selectEmployeeList(field, valueStr);
  197.                 break;
  198.             case "basePay":
  199.                 // 获取整型类型的查询条件
  200.                 if (tf_query.getText().equals("")) {
  201.                     tf_query.setText("0");
  202.                 }
  203.                 valueInt = new Integer(tf_query.getText()).intValue();
  204.                 // 调用按照（字段名、整型字段值）查询员工列表的方法，查询员工信息
  205.                 list = EmployeeDao.selectEmployeeList(field, valueInt);
  206.                 break;
  207.         }
  208.         addRowToModel(list);// 将查询获取的员工列表，添加到表格模型中
  210.     }
  212.     /**
  213.      * 成员方法6“查询”按钮单击事件响应方法
  214.      */
  215.     private void bn_query_actionPerformed() {
  217.         switch (field) {
  218.             case "EmployeeNo":
  219.             case "EmployeeName":
  220.             case "sex":
  221.             case "post":
  222.             case "password":
  223.                 // 获取字符串类型的查询条件
  224.                 valueStr = tf_query.getText();
  225.                 // 调用按照（字段名、字符串字段值）查询员工列表的方法，查询员工信息
  226.                 list = EmployeeDao.selectEmployeeList(field, valueStr);
  227.                 break;
  228.             case "basePay":
  229.                 // 获取整型类型的查询条件
  230.                 if (tf_query.getText().equals("")) {
  231.                     tf_query.setText("0");
  232.                 }
  233.                 valueInt = new Integer(tf_query.getText()).intValue();
  234.                 // 调用按照（字段名、整型字段值）查询员工列表的方法，查询员工信息
  235.                 list = EmployeeDao.selectEmployeeList(field, valueInt);
  236.                 break;
  237.         }
  238.         addRowToModel(list);// 将查询获取的员工列表，添加到表格模型中
  240.     }
  242.     /** 测试方法： */
  243.     public static void main(String[] args) {
  244.         new EmployeeQuery();
  245.     }
  246. }

测试下

一个employeeUpkeep类

  1. package windows;
  3. import java.awt.BorderLayout;
  4. import java.awt.Color;
  5. import java.awt.Font;
  6. import java.awt.GridBagConstraints;
  7. import java.awt.GridBagLayout;
  8. import java.awt.Insets;
  9. import java.awt.event.ActionEvent;
  10. import java.awt.event.ActionListener;
  11. import java.awt.event.FocusAdapter;
  12. import java.awt.event.FocusEvent;
  13. import java.awt.event.MouseAdapter;
  14. import java.awt.event.MouseEvent;
  15. import java.util.List;
  16. import javax.swing.JButton;
  17. import javax.swing.JComboBox;
  18. import javax.swing.JLabel;
  19. import javax.swing.JOptionPane;
  20. import javax.swing.JPanel;
  21. import javax.swing.JScrollPane;
  22. import javax.swing.JSplitPane;
  23. import javax.swing.JTable;
  24. import javax.swing.JTextField;
  25. import javax.swing.border.EmptyBorder;
  26. import javax.swing.border.EtchedBorder;
  27. import javax.swing.border.TitledBorder;
  28. import javax.swing.table.DefaultTableModel;
  30. import CommoditySales.Constant;
  31. import data.EmployeeDao;
  32. import entity.Employee;
  34. public class EmployeeUpKeep extends PublicJFrame {
  35.     /** 成员变量 */
  36.     private JTextField tf_id;// 声明员工编号文本框
  37.     private JTextField tf_name;// 声明员工名文本框
  38.     private JComboBox<String> cb_type;// 声明员工类型组合框
  39.     private JTextField tf_basePay;// 声明基本工资文本框
  40.     private JTextField tf_post;// 声明职务文本框
  41.     private JTextField tf_password;// 声明密码文本框
  43.     // 声明添加、修改、取消、关闭、删除、清空按钮
  44.     private JButton jb_insert, jb_update, jb_cancel, jb_close,
  45.             jb_delete, jb_empty;
  46.     private JTable table;// 声明表格
  47.     // 创建员工表格模型
  48.     private DefaultTableModel model = new DefaultTableModel(
  49.             new Object[][] {}, new String[] { "员工编号", "员工姓名", "性别", "职务","基本工资","密码"});
  50.     private List<Employee> list = EmployeeDao.selectEmployeeList();// 创建所有员工列表，并保存员工对象
  52.     /** 构造方法：用于初始化界面 */
  53.     EmployeeUpKeep() {
  54.         // 界面设置
  55.         this.setTitle("--员工信息维护--");
  56.         setBounds(220, 100, 1300, 650);
  57.         this.setResizable(false);
  58.         this.setLocationRelativeTo(null);
  60.         // 创建一个对话面板,其上放置一个外部分割面板，并将它设置为框架的内容面板
  61.         JPanel dialogPane = new JPanel();
  62.         dialogPane.setBorder(new EmptyBorder(5, 5, 5, 5));
  63.         dialogPane.setBackground(new Color(198, 236, 253));
  64.         dialogPane.setLayout(new BorderLayout());
  65.         setContentPane(dialogPane);
  67.         // 创建一个外部分割面板，水平左右放置组件。其中，左测放置一个内部分割面板，右测放置一个表格面板
  68.         JSplitPane outerPane = new JSplitPane();// 创建外部分割面板
  69.         outerPane.setOpaque(false);// 设置外部分割面板透明
  70.         outerPane.setResizeWeight(0.1);// 设置外部分割面板宽度分配权限
  71.         outerPane.setOrientation(JSplitPane.HORIZONTAL_SPLIT);//设置外部分割面板水平分配
  72.         outerPane.setOneTouchExpandable(true);//设置外部分割面板可以有一个触发扩展
  73.         dialogPane.add(outerPane, BorderLayout.CENTER);
  74.         // 创建一个内部分割面板，垂直上下放置组件。其中，上方放置一个数据面板，下方放置一个按钮面板
  75.         JSplitPane innerPane = new JSplitPane();// 创建内部分割面板
  76.         innerPane.setOpaque(false);
  77.         // 为一个内部分割面板设置边框说明
  78.         innerPane.setBorder(new TitledBorder(
  79.                 new EtchedBorder(EtchedBorder.LOWERED, null, null),
  80.                 "员工信息维护", TitledBorder.LEADING, TitledBorder.TOP,
  81.                 new Font("微软雅黑", Font.PLAIN, 14),
  82.                 new Color(59, 59, 59)));
  83.         innerPane.setResizeWeight(0.8);
  84.         innerPane.setOrientation(JSplitPane.VERTICAL_SPLIT);//设置内部分割面板为垂直分配
  85.         outerPane.setLeftComponent(innerPane);// 将内部分割面板设置在外部分割面板的左侧
  86.         JPanel dataPanel = createDataPanel();// 调用创建数据面板方法，创建数据面板
  87.         innerPane.setLeftComponent(dataPanel);// 将数据面板，设置在内部分割面板的左侧
  88.         JPanel buttonPanel = createButtonPanel();// 调用创建按钮面板方法，创建按钮面板
  89.         innerPane.setRightComponent(buttonPanel);// 将按钮面板设置在内部分割面板的下方
  90.         JPanel tablePanel = createTablePanel();// 调用创建表格面板方法，创建表格面板
  91.         outerPane.setRightComponent(tablePanel);// 将表格面板，设置在外部分割面板的右侧
  92.     }
  94.     /** 成员方法1：用于创建“数据面板"的方法 */
  95.     private JPanel createDataPanel() {
  96.         JPanel dataPanel = new JPanel(null);
  97.         dataPanel.setBorder(new EmptyBorder(5, 5, 5, 10));
  98.         dataPanel.setOpaque(false);
  100.         JLabel jl_id = new JLabel("员工编号:");
  101.         jl_id.setBounds(50, 20, 100, 25);
  102.         dataPanel.add(jl_id);
  104.         tf_id = new JTextField();
  105.         tf_id.setBounds(140, 20, 170, 25);
  107.         tf_id.setToolTipText("必须输入员工编号");
  108.         tf_id.addFocusListener(new FocusAdapter() {
  109.             @Override
  110.             public void focusLost(FocusEvent e) {
  111.                 tf_id_focusLost();// 调用员工编号文本框加失去焦点事件响应方法
  112.             }
  113.         });
  114.         dataPanel.add(tf_id);
  116.         JLabel jl_name = new JLabel("员工姓名:");
  117.         jl_name.setBounds(50, 60, 100, 25);
  118.         dataPanel.add(jl_name);
  120.         tf_name = new JTextField(10);
  121.         tf_name.setBounds(140, 60, 170, 25);
  122.         tf_name.setToolTipText("必须输入员工姓名");
  123.         dataPanel.add(tf_name);
  124.         tf_name.addFocusListener(new FocusAdapter() {//为员工名文本框添加失去焦点监听器
  125.             @Override
  126.             public void focusLost(FocusEvent e) {
  127.                 tf_name_focusLost();// 调用员工名文本框加失去焦点事件响应方法
  128.             }
  129.         });
  131.         JLabel jl_type = new JLabel("性别:");
  132.         jl_type.setBounds(50, 100, 150, 25);
  133.         dataPanel.add(jl_type);
  135.         cb_type = new JComboBox<String>(Constant.SEX);
  136.         cb_type.setBounds(140, 100, 170, 25);
  137.         dataPanel.add(cb_type);
  139.         JLabel jl_author = new JLabel("基本工资：");
  140.         jl_author.setBounds(50, 140, 150, 25);
  141.         dataPanel.add(jl_author);
  143.         tf_basePay = new JTextField(10);
  144.         tf_basePay.setBounds(140, 140, 170, 25);
  145.         dataPanel.add(tf_basePay);
  147.         JLabel jl_translator = new JLabel("职务:");
  148.         jl_translator.setBounds(50, 180, 150, 25);
  149.         dataPanel.add(jl_translator);
  151.         tf_post = new JTextField(10);
  152.         tf_post.setBounds(140, 180, 170, 25);
  153.         dataPanel.add(tf_post);
  155.         JLabel jl_publisher = new JLabel("密码:");
  156.         jl_publisher.setBounds(50, 220, 150, 25);
  157.         dataPanel.add(jl_publisher);
  159.         tf_password = new JTextField(10);
  160.         tf_password.setBounds(140, 220, 170, 25);
  161.         dataPanel.add(tf_password);
  163.         return dataPanel;
  164.     }
  166.     /** 成员方法2：用于创建"按钮面板"的方法 */
  167.     private JPanel createButtonPanel() {
  168.         JPanel buttonPanel = new JPanel(new GridBagLayout());//创建按钮面板，用网格包布局
  169.         buttonPanel.setOpaque(false);
  170.         ((GridBagLayout) buttonPanel
  171.                 .getLayout()).columnWidths = new int[] { 0, 60, 60,
  172.                 60, 60, 60, 0 };// 设置网格包布局各列宽度
  173.         ((GridBagLayout) buttonPanel
  174.                 .getLayout()).columnWeights = new double[] { 0.5, 0.0,
  175.                 0.0, 0.0, 0.0, 0.0, 0.5 };// 设置网格包布局各列的宽度权限
  177.         jb_insert = new JButton("添加");
  178.         jb_insert.addActionListener(new ActionListener() {//为添加按钮添加单击事件监听器
  179.             @Override
  180.             public void actionPerformed(ActionEvent e) {
  181.                 sb_insert_actionPerformed();// 调用添加按钮事件响应方法，添加员工
  182.             }
  183.         });
  184.         buttonPanel.add(jb_insert,
  185.                 new GridBagConstraints(1, 0, 1, 1, 0.0, 0.0,
  186.                         GridBagConstraints.CENTER,
  187.                         GridBagConstraints.BOTH,
  188.                         new Insets(0, 0, 0, 5), 0, 0));
  190.         jb_update = new JButton("修改");
  191.         jb_update.addActionListener(new ActionListener() {//为修改按钮添加单击事件监听器
  192.             @Override
  193.             public void actionPerformed(ActionEvent e) {
  194.                 jb_update_actionPerformed();// 调用修改按钮事件响应方法，修改员工信息
  195.             }
  196.         });
  197.         buttonPanel.add(jb_update,
  198.                 new GridBagConstraints(2, 0, 1, 1, 0.0, 0.0,
  199.                         GridBagConstraints.CENTER,
  200.                         GridBagConstraints.BOTH,
  201.                         new Insets(0, 0, 0, 5), 0, 0));
  203.         jb_delete = new JButton("删除");
  204.         jb_delete.addActionListener(new ActionListener() {// 为删除按钮添加单击事件监听器
  205.             @Override
  206.             public void actionPerformed(ActionEvent e) {
  207.                 jb_delete_actionPerformed();// 调用删除按钮事件响应方法，删除员工对象
  208.             }
  209.         });
  210.         buttonPanel.add(jb_delete,
  211.                 new GridBagConstraints(3, 0, 1, 1, 0.0, 0.0,
  212.                         GridBagConstraints.CENTER,
  213.                         GridBagConstraints.BOTH,
  214.                         new Insets(0, 0, 0, 5), 0, 0));
  216.         jb_cancel = new JButton("取消");
  217.         jb_cancel.addActionListener(new ActionListener() {//为取消按钮添加单击事件监听器
  218.             @Override
  219.             public void actionPerformed(ActionEvent e) {
  220.                 del_content();// 调用删除内容方法，清除数据面板中的数据
  221.             }
  222.         });
  223.         buttonPanel.add(jb_cancel,
  224.                 new GridBagConstraints(4, 0, 1, 1, 0.0, 0.0,
  225.                         GridBagConstraints.CENTER,
  226.                         GridBagConstraints.BOTH,
  227.                         new Insets(0, 0, 0, 5), 0, 0));
  229.         jb_close = new JButton("关闭");
  230.         jb_close.addActionListener(new ActionListener() {//为关闭按钮添加单击事件监听器
  231.             @Override
  232.             public void actionPerformed(ActionEvent e) {
  233.                 dispose();// 关闭员工维护界面
  234.             }
  235.         });
  236.         buttonPanel.add(jb_close,
  237.                 new GridBagConstraints(5, 0, 1, 1, 0.0, 0.0,
  238.                         GridBagConstraints.CENTER,
  239.                         GridBagConstraints.BOTH,
  240.                         new Insets(0, 0, 0, 5), 0, 0));
  242.         jb_empty = new JButton("清空所有员工");
  243.         jb_empty.addActionListener(new ActionListener() {//为清空按钮添加单击事件监听器
  244.             @Override
  245.             public void actionPerformed(ActionEvent e) {
  246.                 jb_empty_actionPerformed();// 调用清空按钮事件响应方法，清空所有员工
  247.             }
  248.         });
  249.         buttonPanel.add(jb_empty,
  250.                 new GridBagConstraints(2, 1, 3, 1, 0.0, 0.0,
  251.                         GridBagConstraints.CENTER,
  252.                         GridBagConstraints.BOTH,
  253.                         new Insets(25, 0, 0, 0), 0, 0));
  254.         return buttonPanel;
  255.     }
  257.     /** 成员方法3：用于创建表格面板的方法 */
  258.     private JPanel createTablePanel() {
  259.         // 创建表格面板，采用边界布局
  260.         JPanel tablePanel = new JPanel(new BorderLayout(5, 5));
  261.         JScrollPane scrollPane = new JScrollPane();// 创建滚动面板
  262.         tablePanel.add(scrollPane);// 将表格面板添加到滚动面板上
  263.         table = new JTable(model);// 创建表格，并采用指定的表格模型
  265.         for (int i = 0; i < list.size(); i++) {
  266.             Employee Employee = list.get(i);
  267.             model.addRow(new Object[] { Employee.getEmployeeNo(),
  268.                     Employee.getEmployeeName(),
  269.                     Employee.getSex(),
  270.                     Employee.getPost(),
  271.                     Employee.getBasePay(),
  272.                     Employee.getPassword()
  273.             });
  274.         }
  275.         table.addMouseListener(new MouseAdapter() {// 为表格添加鼠标事件监听器
  276.             @Override
  277.             public void mouseClicked(MouseEvent e) {
  278.                 // 调用表格鼠标单击事件响应方法，向左侧数据面板显示选中员工
  279.                 table_mouseClicked();
  280.             }
  281.         });
  282.         scrollPane.setViewportView(table);
  283.         return tablePanel;
  284.     }
  286.     /** 成员方法4：用于清除数据面板中的数据 */
  287.     public void del_content() {
  288.         tf_id.setText("");
  289.         tf_name.setText("");
  290.         cb_type.setSelectedIndex(0);
  291.         tf_basePay.setText("");
  292.         tf_post.setText("");
  293.         tf_password.setText("");
  294.         tf_id.setEditable(true);
  295.     }
  297.     /** 成员方法5：员工编号文本框失去焦点事件响应具体方法 */
  298.     public void tf_id_focusLost() {
  299.         // 通过员工编号，获取员工对象
  300.         Employee Employee = EmployeeDao.getEmployeeByEmployeeNo(tf_id.getText().trim());
  301.         if (Employee != null) {// 判断员工对象是否存在，若存在，清除数据，重新输入员工编号
  302.             JOptionPane.showMessageDialog(null,
  303.                     "员工编号已经存在，请重新输入员工编号！");
  304.             del_content(); // 清除数据面板中的数据
  305.         }
  306.     }
  308.     /** 成员方法6：员工名文本框失去焦点事件响应具体方法 */
  309.     public void tf_name_focusLost() {
  310.         Employee Employee = EmployeeDao.getEmployeeByEmployeeNo(tf_name.getText().trim());
  311.         if (Employee != null) {
  312.             JOptionPane.showMessageDialog(null, "员工名已经存在，请重新输入员工名！");
  313.             tf_name.setText("");
  314.         }
  315.     }
  317.     /** 成员方法7：用于更新表格数据 */
  318.     public void refresh() {
  319.         model.setRowCount(0);// 清除表格模型中的数据
  320.         list = EmployeeDao.selectEmployeeList();// 获取员工对象列表
  321.         for (int i = 0; i < list.size(); i++) {// 重新项表格模型中添加数据
  322.             Employee Employee = list.get(i);
  323.             model.addRow(new Object[] { Employee.getEmployeeNo(),
  324.                     Employee.getEmployeeName(),
  325.                     Employee.getSex(),
  326.                     Employee.getPost(),
  327.                     Employee.getBasePay(),
  328.                     Employee.getPassword()
  329.             });
  330.         }
  331.         del_content();// 清除数据面板中的数据
  333.     }
  335.     /** 成员方法8：表格鼠标单击事件响应方法 */
  336.     public void table_mouseClicked() {
  337.         // 获取选中员工的信息
  338.         Employee Employee_old = list.get(table.getSelectedRow());
  339.         // 在数据面板中设置对应的员工数据
  340.         tf_id.setText(Employee_old.getEmployeeNo());
  341.         tf_name.setText(Employee_old.getEmployeeName());
  342.         cb_type.setSelectedItem(Employee_old.getSex());
  343.         tf_basePay.setText(String.valueOf(Employee_old.getBasePay()));
  344.         tf_password.setText(Employee_old.getPassword());
  345.         tf_post.setText(Employee_old.getPost());
  346.         tf_id.setEditable(false);// 设置读者员工文本框不可编辑
  347.     }
  349.     /** 成员方法9：添加新员工方法 */
  350.     public void sb_insert_actionPerformed() {
  351.         Employee Employee = new Employee();// 创建一个员工对象
  352.         // 设置员工对象的属性值
  353.         Employee.setEmployeeNo(tf_id.getText().trim());
  354.         Employee.setEmployeeName(tf_name.getText().trim());
  355.         Employee.setSex(cb_type.getSelectedItem().toString());
  356.         Employee.setBasePay(new Integer(tf_basePay.getText().trim()));
  357.         Employee.setPassword(tf_password.getText().trim());
  358.         Employee.setPost(tf_post.getText().trim());
  360.         // 判断员工名或员工编号不允许为空？若空，则给出提示，并返回
  361.         if (tf_name.getText().trim().equals("")
  362.                 || tf_id.getText().trim().equals("")) {
  363.             JOptionPane.showMessageDialog(null, "员工信息不能为空！");
  364.             return;
  365.         } else {// 若不空，则执行添加员工对象操作
  366.             int i = EmployeeDao.insertEmployee(Employee);// 执行添加操作
  367.             if (i == 1) {// 判断添加操作是否成功？若成功，则向表格模型添加这条数据
  368.                 model.addRow(new Object[] { Employee.getEmployeeNo(),
  369.                         Employee.getEmployeeName(),
  370.                         Employee.getSex(),
  371.                         Employee.getPost(),
  372.                         Employee.getBasePay(),
  373.                         Employee.getPassword()
  374.                 });
  375.                 refresh();
  376.             }
  377.             del_content();
  378.         }
  379.     }
  381.     /** 成员方法10：修改员工信息按钮事件响应方法 */
  382.     public void jb_update_actionPerformed() {
  383.         Employee Employee = new Employee();// 创建一个员工对象
  384.         Employee.setEmployeeNo(tf_id.getText().trim());
  385.         Employee.setEmployeeName(tf_name.getText().trim());
  386.         Employee.setSex(cb_type.getSelectedItem().toString());
  387.         Employee.setBasePay(new Integer(tf_basePay.getText().trim()));
  388.         Employee.setPassword(tf_password.getText().trim());
  389.         Employee.setPost(tf_post.getText().trim());
  391.         if (tf_name.getText().trim().equals("")
  392.                 || tf_id.getText().trim().equals("")) {
  393.             JOptionPane.showMessageDialog(null, "员工信息不能为空！");
  394.             return;
  395.         } else {// 若不空，则执行添加员工对象操作
  396.             int i = EmployeeDao.upDateEmployee(Employee);
  397.             if (i == 1) {
  398.                 JOptionPane.showMessageDialog(null, "员工信息修改成功！");
  399.             }
  401.             refresh();// 更新表格内容
  402.             del_content();
  403.         }
  404.     }
  406.     /** 成员方法11：删除员工 信息 */
  407.     public void jb_delete_actionPerformed() {
  408.         String id = tf_id.getText().trim(); // 获取用户编号
  409.         // 调用确认对话框，询问是否删除员工？
  410.         int m = JOptionPane.showConfirmDialog(null, "你确认要删除这条员工信息吗?",
  411.                 "删除员工信息", JOptionPane.YES_NO_OPTION);
  412.         if (m == JOptionPane.YES_OPTION) {// 如果确定，则执行删除操作
  413.             if (EmployeeDao.deleteEmployee(id) == 1) {// 执行用户删除操作
  414.                 refresh();// 更新表格内容
  415.                 JOptionPane.showMessageDialog(null, "员工信息删除成功！");
  416.             }
  417.             del_content();// 清除数据面板内容
  418.         }
  419.     }
  421.     /** 成员方法12：删除所有员工信息 */
  422.     public void jb_empty_actionPerformed() {
  423.         int m = JOptionPane.showConfirmDialog(null, "你确认要删除所有员工信息吗?",
  424.                 "清空员工信息", JOptionPane.YES_NO_OPTION);
  425.         if (m == JOptionPane.YES_OPTION) {
  426.             int n = JOptionPane.showConfirmDialog(null,
  427.                     "真的确认清空所有员工数据吗?", "清空员工信息再次确认",
  428.                     JOptionPane.YES_NO_OPTION);
  429.             if (n == JOptionPane.YES_OPTION) {
  430.                 EmployeeDao.emptyEmployee();
  431.                 refresh();// 更新表格内容
  432.                 del_content();// 清除数据面板内容
  433.             }
  434.         }
  435.     }
  437.     // 测试方法：用于员工维护的测试
  438.     public static void main(String[] args) {
  439.         new EmployeeUpKeep();
  440.     }
  441. }

测试

最后一个删除所有员工就不试了哈，好难重新插回去的。。

主系统类

一个mainfram类

  1. package windows;
  3. import java.awt.*;
  4. import java.awt.event.*;
  5. import javax.swing.*;
  6. import javax.swing.border.BevelBorder;
  7. import Login.LoginView;
  8. import data.BaseDao1;
  10. public class MainFrame extends PublicJFrame {
  11.     /** 成员变量 */
  12.     private JMenuItem mi_inventory_upkeep;// 声明库存维护菜单项
  13.     private JMenuItem mi_stock_upkeep;// 声明进货维护菜单项
  14.     private JMenuItem mi_supplier_upkeep;// 声明员工维护菜单项
  15.     private JMenuItem mi_item_upkeep;// 声明商品维护菜单项
  16.     private JMenuItem mi_employee_upkeep;//声明员工维护菜单
  17.     private JMenuItem mi_item_query;// 声明商品查询菜单项
  18.     private JMenuItem mi_employee_query;// 声明员工查询菜单项
  19.     private JMenuItem mi_inventory_query;// 声明库存查询菜单项
  20.     private JMenuItem mi_sale_query;// 声明销售查询菜单项
  21.     private JMenuItem mi_stock_query;// 声明进货查询菜单项
  22.     private JMenuItem mi_supplier_query;// 声明供货商查询菜单项
  23.     private JMenuItem mi_exit;// 声明退出系统菜单项
  25.     private JButton bt_employee_upkeep;// 声明读者维护按钮
  26.     private JButton bt_book_upkeep;// 声明商品维护按钮
  27.     private JButton bt_reader_query;// 声明读者查询按钮
  28.     private JButton bt_book_query;// 声明商品查询按钮
  29.     private JButton bt_exit;// 声明退出系统按钮
  31.     /** 构造方法：系统主界面初始化方法 */
  32.     public MainFrame() {
  33.         //第1步：系统主界面设置
  34.         this.setTitle("商品销售管理系统");// 设置主界面标题
  35.         this.setBounds(520,0,1000,1050);
  36.         //this.setExtendedState(Frame.MAXIMIZED_BOTH);// 设置主界面窗口最大化
  37.         this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  38.         JPanel contentPane = new JPanel(){//设置背景图片
  39.             @Override
  40.             public void paint(Graphics g){
  41.                 ImageIcon icon = new ImageIcon("images/5.png");
  42.                 Image image = icon.getImage();
  43.                 g.drawImage(image,0,0,null);
  44.             }
  45.         };
  46.         this.add(contentPane);
  47.         this.setVisible(true);
  48.         //第2步：创建、设置菜单栏。先调用创建系统菜单栏方法，创建系统菜单栏,再在主界面设置菜单栏
  49.         this.setJMenuBar(createMenuBar());
  50.         //第3步： 创建、设置工具栏。先调用创建系统工具栏方法，创建系统工具栏，再将工具栏添加到界面的上方
  51.         this.add(createToolBar(),BorderLayout.NORTH);
  52.         this.setVisible(true);
  53.         this.setPurView(LoginView.a);
  54.     }
  56.     /** 成员方法1：创建系统菜单栏方法 */
  57.     private JMenuBar createMenuBar() {
  58.         // 第1步：创建菜单栏对象
  59.         JMenuBar menuBar = new JMenuBar();
  60.         //第2步：创建菜单。如基础维护菜单，又包含用户维护、读者维护、商品维护菜单项
  61.         JMenu menu_upkeep = new JMenu("基础维护"); // 创建"基础维护"菜单
  62.         //第3步：创建菜单项，并为菜单项设置单击事件监听器
  63.         mi_supplier_upkeep = new JMenuItem("供应商信息维护"); // 创建“用户维护”菜单项
  64.         mi_supplier_upkeep.addActionListener(new ActionListener() {//添加单击事件监听器
  65.             @Override
  66.             public void actionPerformed(ActionEvent e) {
  67.                 supplier_upkeep_actionPerformed();// 调用“供应商信息维护”响应方法
  68.             }
  69.         });
  70.         //第4步：将菜单项添加到菜单上
  71.         menu_upkeep.add(mi_supplier_upkeep);// 将“供应商信息维护”菜单项添加到“基础维护”菜单
  73.         mi_item_upkeep = new JMenuItem("商品信息维护"); // 创建"商品维护"菜单项
  74.         mi_item_upkeep.addActionListener(new ActionListener() {
  75.             @Override
  76.             public void actionPerformed(ActionEvent e) {
  77.                 item_upkeep_actionPerformed();// 调用"商品维护"响应方法
  78.             }
  79.         });
  80.         menu_upkeep.add(mi_item_upkeep);
  82.         mi_stock_upkeep = new JMenuItem("进货信息维护"); // 创建"商品维护"菜单项
  83.         mi_stock_upkeep.addActionListener(new ActionListener() {
  84.             @Override
  85.             public void actionPerformed(ActionEvent e) {
  86.                 stock_upkeep_actionPerformed();// 调用"商品维护"响应方法
  87.             }
  88.         });
  89.         menu_upkeep.add(mi_stock_upkeep);
  91.         mi_inventory_upkeep = new JMenuItem("库存信息维护"); // 创建"商品维护"菜单项
  92.         mi_inventory_upkeep.addActionListener(new ActionListener() {
  93.             @Override
  94.             public void actionPerformed(ActionEvent e) {
  95.                 inventory_upkeep_actionPerformed();// 调用"商品维护"响应方法
  96.             }
  97.         });
  98.         menu_upkeep.add(mi_inventory_upkeep);
  99.         mi_employee_upkeep = new JMenuItem("员工信息维护"); // 创建"商品维护"菜单项
  100.         mi_employee_upkeep.addActionListener(new ActionListener() {
  101.             @Override
  102.             public void actionPerformed(ActionEvent e) {
  103.                 employee_upkeep_actionPerformed();// 调用"商品维护"响应方法
  104.             }
  105.         });
  106.         menu_upkeep.add(mi_employee_upkeep);
  107.         //第5步：将菜单添加到菜单栏上
  108.         menuBar.add(menu_upkeep);// 将"基础维护"菜单添加到系统菜单栏
  110.         JMenu menu_query = new JMenu("查询统计"); // 创建"查询统计"菜单
  111.         mi_item_query = new JMenuItem("商品查询"); // 创建"商品查询"菜单项
  112.         mi_item_query.addActionListener(new ActionListener() {
  113.             @Override
  114.             public void actionPerformed(ActionEvent e) {
  115.                 item_query_actionPerformed();// 调用"商品查询"响应方法
  116.             }
  117.         });
  118.         menu_query.add(mi_item_query);
  119.         mi_employee_query = new JMenuItem("员工查询"); // 创建"读者查询"菜单项
  120.         mi_employee_query.addActionListener(new ActionListener() {
  121.             @Override
  122.             public void actionPerformed(ActionEvent e) {
  123.                 employee_query_actionPerformed();// 调用"读者查询"响应方法
  124.             }
  125.         });
  126.         menu_query.add(mi_employee_query);
  127.         mi_inventory_query = new JMenuItem("库存查询"); // 创建"读者查询"菜单项
  128.         mi_inventory_query.addActionListener(new ActionListener() {
  129.             @Override
  130.             public void actionPerformed(ActionEvent e) {
  131.                 inventory_query_actionPerformed();// 调用"读者查询"响应方法
  132.             }
  133.         });
  134.         menu_query.add(mi_inventory_query);
  136.         mi_sale_query = new JMenuItem("销售查询"); // 创建"销售查询"菜单项
  137.         mi_sale_query.addActionListener(new ActionListener() {
  138.             @Override
  139.             public void actionPerformed(ActionEvent e) {
  140.                 sale_query_actionPerformed();// 调用"读者查询"响应方法
  141.             }
  142.         });
  143.         menu_query.add(mi_sale_query);
  145.         mi_stock_query = new JMenuItem("进货查询"); // 创建"进货查询"菜单项
  146.         mi_stock_query.addActionListener(new ActionListener() {
  147.             @Override
  148.             public void actionPerformed(ActionEvent e) {
  149.                 stock_query_actionPerformed();// 调用"读者查询"响应方法
  150.             }
  151.         });
  152.         menu_query.add(mi_stock_query);
  154.         mi_supplier_query = new JMenuItem("供货商查询"); // 创建"供货商查询"菜单项
  155.         mi_supplier_query.addActionListener(new ActionListener() {
  156.             @Override
  157.             public void actionPerformed(ActionEvent e) {
  158.                 supplier_query_actionPerformed();// 调用"读者查询"响应方法
  159.             }
  160.         });
  161.         menu_query.add(mi_supplier_query);
  162.         menuBar.add(menu_query);//查询菜单栏
  164.         JMenu menu_management = new JMenu("系统管理");// 创建"系统管理"菜单
  165.         mi_exit = new JMenuItem("退出系统"); // 创建"退出系统"菜单项
  166.         mi_exit.addActionListener(new ActionListener() {
  167.             @Override
  168.             public void actionPerformed(ActionEvent e) {
  169.                 exit_actionPerformed();// 调用"退出系统"响应方法
  170.             }
  171.         });
  172.         menu_management.add(mi_exit);
  173.         menuBar.add(menu_management);
  174.         //第6步：返回菜单栏。
  175.         return menuBar;
  176.     }
  178.     /** 成员方法2： 创建工具栏方法 */
  179.     private JToolBar createToolBar() {
  180.         //第1步：创建、设置工具栏
  181.         JToolBar toolBar = new JToolBar("商品管理系统工具栏");// 创建工具栏对象
  182.         toolBar.setFloatable(false); // 设置工具栏不可浮动
  183.         // 设置工具栏边框导角方式
  184.         toolBar.setBorder(new BevelBorder(BevelBorder.LOWERED));
  185.         //第2步： 创建、设置工具栏上的快捷按钮
  186.         bt_employee_upkeep = new JButton("员工维护");// 创建"读者维护"按钮
  187.         // 创建"读者维护"图标
  188.         ImageIcon icon_reader_upkeep = new ImageIcon("images/reader_upkeep.png");
  189.         bt_employee_upkeep.setIcon(icon_reader_upkeep);// 为"读者维护"按钮设置图标
  190.         bt_employee_upkeep.setToolTipText("员工维护");// 为"读者维护"按钮设置提示
  191.         // 将"读者维护"按钮注册单击事件监听器
  192.         bt_employee_upkeep.addActionListener(new ActionListener() {
  193.             @Override
  194.             public void actionPerformed(ActionEvent e) {
  195.                 employee_upkeep_actionPerformed();// 调用"读者维护’响应方法
  196.             }
  197.         });
  198.         //第3步：将按钮添加到工具栏上
  199.         toolBar.add(bt_employee_upkeep);// 将“读者维护”按钮添加到工具栏
  201.         bt_book_upkeep = new JButton("商品信息维护");
  202.         ImageIcon icon_book_upkeep = new ImageIcon("images/book_upkeep.png");
  203.         bt_book_upkeep.setIcon(icon_book_upkeep);
  204.         toolBar.add(bt_book_upkeep);
  205.         bt_book_upkeep.addActionListener(new ActionListener() {
  206.             @Override
  207.             public void actionPerformed(ActionEvent e) {
  208.                 item_upkeep_actionPerformed();// 调用“商品维护”响应方法
  209.             }
  210.         });
  212.         bt_reader_query = new JButton("员工查询");
  213.         ImageIcon icon_reader_query = new ImageIcon("images/reader_query.png");
  214.         bt_reader_query.setIcon(icon_reader_query);
  215.         toolBar.add(bt_reader_query);
  216.         bt_reader_query.addActionListener(new ActionListener() {
  217.             @Override
  218.             public void actionPerformed(ActionEvent e) {
  219.                 employee_query_actionPerformed();// 调用“读者查询”响应方法
  220.             }
  221.         });
  223.         bt_book_query = new JButton("商品查询");
  224.         ImageIcon icon_book_query = new ImageIcon("images/book_query.png");
  225.         bt_book_query.setIcon(icon_book_query);
  226.         toolBar.add(bt_book_query);
  227.         bt_book_query.addActionListener(new ActionListener() {
  228.             @Override
  229.             public void actionPerformed(ActionEvent e) {
  230.                 item_query_actionPerformed();// 调用“商品查询”响应方法
  231.             }
  232.         });
  234.         bt_exit = new JButton("退出系统");
  235.         ImageIcon icon_exit = new ImageIcon("images/exit.png");
  236.         bt_exit.setIcon(icon_exit);
  237.         toolBar.add(bt_exit);
  238.         bt_exit.addActionListener(new ActionListener() {
  239.             @Override
  240.             public void actionPerformed(ActionEvent e) {
  241.                 exit_actionPerformed();// 调用“退出系统"响应方法
  242.             }
  243.         });
  245.         //第4步：返回工具栏
  246.         return toolBar;
  247.     }
  249.     /** 成员方法3：设置系统功能使用权限的方法 */
  250.     void setPurView(String purView) {
  251.         switch (purView) {
  252.             case "0"://用户权限为0，为操作员
  253.                 mi_supplier_upkeep.setEnabled(false);//设置“用户维护”菜单项不可用
  254.                 mi_item_upkeep.setEnabled(false);//设置“用户维护”菜单项不可用
  255.                 mi_stock_upkeep.setEnabled(false);//设置“用户维护”菜单项不可用
  256.                 mi_inventory_upkeep.setEnabled(false);//设置“用户维护”菜单项不可用
  257.                 mi_item_query.setEnabled(false);// 声明商品查询菜单项
  258.                 mi_employee_query.setEnabled(false);// 声明员工查询菜单项
  259.                 mi_inventory_query.setEnabled(false);// 声明库存查询菜单项
  260.                 mi_sale_query.setEnabled(false);// 声明销售查询菜单项
  261.                 mi_stock_query.setEnabled(false);// 声明进货查询菜单项
  262.                 mi_supplier_query.setEnabled(false);// 声明供货商查询菜单项
  263.                 bt_book_upkeep.setEnabled(false);
  264.                 bt_employee_upkeep.setEnabled(false);
  265.                 mi_employee_upkeep.setEnabled(false);
  266.                 break;
  267.             case "1"://用户权限为1，为管理员
  268.                 break;
  269.             default://用户权限为其他，为一般访客
  270.                 bt_reader_query.setEnabled(false);
  271.                 mi_supplier_upkeep.setEnabled(false);//设置“用户维护”菜单项不可用
  272.                 mi_item_upkeep.setEnabled(false);//设置“用户维护”菜单项不可用
  273.                 mi_stock_upkeep.setEnabled(false);//设置“用户维护”菜单项不可用
  274.                 mi_inventory_upkeep.setEnabled(false);//设置“用户维护”菜单项不可用
  275.                 mi_item_query.setEnabled(false);// 声明商品查询菜单项
  276.                 mi_employee_query.setEnabled(false);// 声明员工查询菜单项
  277.                 mi_inventory_query.setEnabled(false);// 声明库存查询菜单项
  278.                 mi_sale_query.setEnabled(false);// 声明销售查询菜单项
  279.                 mi_stock_query.setEnabled(false);// 声明进货查询菜单项
  280.                 mi_supplier_query.setEnabled(false);// 声明供货商查询菜单项
  281.                 bt_book_upkeep.setEnabled(false);
  282.                 bt_employee_upkeep.setEnabled(false);
  283.                 mi_employee_upkeep.setEnabled(false);
  284.         }
  285.     }
  287.    /** 成员方法4：供应商信息维护响应方法 */
  288.     private void supplier_upkeep_actionPerformed() {
  289.         new SupplierUpKeep();// 创建“供应商信息维护”界面
  290.     }
  292.     /** 成员方法5：进货信息响应方法 */
  293.     private void stock_upkeep_actionPerformed() {
  294.         new StockUpKeep();// 创建“进货信息维护”界面
  295.     }
  297.     /** 成员方法6：库存信息响应方法 */
  298.     private void inventory_upkeep_actionPerformed() {
  299.         new InventoryUpKeep();// 创建“进货信息维护”界面
  300.     }
  302.     /** 成员方法7：员工信息响应方法 */
  303.     private void employee_upkeep_actionPerformed() {
  304.         new EmployeeUpKeep();// 创建“进货信息维护”界面
  305.     }
  307.     /** 成员方法8：商品维护响应方法 */
  308.     private void item_upkeep_actionPerformed() {
  309.         new ItemUpKeep();// 创建“商品维护”界面
  310.     }
  312.     /** 成员方法9：商品查询响应方法 */
  313.     private void item_query_actionPerformed() {
  314.         new ItemQuery();// 创建“商品查询”界面
  315.     }
  317.     /** 成员方法10：员工查询响应方法 */
  318.     private void employee_query_actionPerformed() {
  319.         new EmployeeQuery();// 创建“员工查询”界面
  320.     }
  322.     /** 成员方法11：库存查询响应方法 */
  323.     private void inventory_query_actionPerformed() {
  324.         new InventoryQuery();// 创建“员工查询”界面
  325.     }
  326.     
  327.     /** 成员方法12：销售查询响应方法 */
  328.     private void sale_query_actionPerformed() {
  329.         new SaleQuery();// 创建“员工查询”界面
  330.     }
  332.     /** 成员方法13：进货查询响应方法 */
  333.     private void stock_query_actionPerformed() {
  334.         new StockQuery();// 创建“员工查询”界面
  335.     }
  336.     
  337.     /** 成员方法14：供货商查询响应方法 */
  338.     private void supplier_query_actionPerformed() {
  339.         new SupplierQuery();// 创建“员工查询”界面
  340.     }
  341.     
  342.     /** 成员方法15：退出系统响应方法 */
  343.     private void exit_actionPerformed() {
  344.         BaseDao1.close();// 关闭与数据库的连接
  345.         System.exit(0);// 退出系统
  346.     }
  348.     // 测试方法：用于主界面的测试
  349.     public static void main(String args[]) {
  350.         new MainFrame();// 创建系统主界面匿名对象
  351.     }
  352. }

**测试 **

因为赶时间做出来的，许多窗口不是很好看，图片很单一，以后有时间再美化下，或者感兴趣的你们也可以试着美化下。

有任何问题可以问我哦。

标签： java mysql 开发语言
本文转载自: https://blog.csdn.net/qq_59689127/article/details/122180381
版权归原作者 海绵宝宝养的的小窝 所有， 如有侵权，请联系我们删除。
登录后发布评论

“Java swing+Mysql商品销售管理系统”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？