超市管理系统
第1章 系统描述
1.1系统概述
本次面向对象编程课程设计，我设计了一个超市管理系统，该系统可以实现商品信息的查询，增添、修改和删除。系统连接数据库，用户可以通过登录界面进行账号密码登录，账户密码存放在数据库的表中，匹配到正确的账户密码才能登入。
然后根据界面指示选择要执行的操作，设置了增删改查四个功能按钮，点击之后执行对应操作，执行成功之后数据库内的数据也会发生对应的增删改查过后的变化，此系统基本可以模拟出正常超市管理系统的功能。
1.2选题说明
此次课程设计使用Java语言编写一个管理系统，其实大部分的管理系统的功能都大致相同，都是最基础的增删改查。我选择超市管理系统，也比较贴合实际生活。而如今进入互联网与大数据时代，万物互联，庞大的数据量已经离不开计算机的高速处理能力和简便实用的功能。对于超市来说，货物信息无疑是一个庞大的数据，所以需要一个超市管理系统去对商品信息进行一些基本操作，方便去管理信息。
我设计的管理系统功能非常实用，切合实际操作简单。对于管理员来说，信息的添加，删除，修改和查询都是比较常用的功能。我这个系统是一个对商品整体信息的一个统计和操作，对于管理员来说，当库里增加了一批新的物品时候需要对库里的进行信息添加，有人购买商品之后，需要对数据库里的信息进行删除，管理员还可以查询商品信息，然后在对商品信息进行修改。基本所以说，我设计的这个超市管理系统可以基本完成这些功能，能够迅速实时地对数据库信息进行更新。该系统的登录页面简洁明了，用户需要进行身份验证，输入自己的账号密码，只有正确之后才能进入系统。
第2章 系统设计
2.1 概要设计
首先一个管理系统要保证安全是必须要有登陆界面的。登陆界面设置可以输入账号密码，账号密码存在表中，然后进入管理账户表判断账号密码是否正确，正确就可以进入功能界面。如果账号不存在，或者密码错误，就需要提示对应的错误信息。
首先进入商店的界面，就是展示这个商店的一些风格，比如说展示一张图片来吸引预览者，并且可以输入一些提示语之类的话，就相当于欢迎界面，然后呢，就是可以设置这些字体的形状，比如说字体变成斜体或者变成加粗的字体，然后加上登录按钮就展示登陆输入密码的界面
功能界面是整个系统的核心，首先图形界面，需要设计各种按钮组件，然后用户可以点击不同按钮执行不同的功能。增删改查四个按钮进行不同的操作。新调出的增删改查成功或者失败的页面，再这些新的页面上也需要设置一些按钮组件，用于确定操作或者返回。
系统需要连接数据库，无论是用户登录注册还是执行对货物的增删改查，都是直接对数据库进行操作的，所以需要设置一个连接数据库的方法，在需要实用数据库的时候，就调用构造方法带入相关的参数，进行连接数据库，还有在返回查询信息时候用于接收返回的信息。
然后创建一些小组件，例如菜单栏和弹出式菜单，来为使用者提供帮助，展示作者和使用方法，在这些菜单中我运用了关闭和刷新的方式，增加使用软件的方便性，便于快速操作。
2.2 详细设计
2.2.1 登录界面设计
1. package com.company;
2.
3. import javax.swing.*;
4. import java.awt.*;
5. import java.awt.event.ActionEvent;
6. import java.awt.event.ActionListener;
7. import java.awt.event.KeyAdapter;
8. import java.awt.event.KeyEvent;
9. import java.sql.*;
10.
11. //interface 和尚{
12. // void 打坐();
13. // void 撞钟();
14. // void 习武();
15. // void 念经();
16. //}
17. //abstract class 天罡星 implements 和尚{//在这里调用空方法没意义，所以多做一步创建一个抽象类，不让别人调用就行
18. //
19. // @Override
20. // public void 打坐() {
21. //
22. // }
23. //
24. // @Override
25. // public void 撞钟() {
26. //
27. // }
28. //
29. // @Override
30. // public void 习武() {
31. //
32. // }
33. //
34. // @Override
35. // public void 念经() {
36. //
37. // }
38. //}
39. //class 鲁智深 extends 天罡星{//只用重写一部分，
40. // @Override
41. // public void 习武() {
42. // System.out.println(“倒把垂杨柳”);
43. // }
44. //}
45.
46.
47.
48. public class Main {
49.
50. private static String driverName = “com.mysql.cj.jdbc.Driver”;
51.
52.
53. public static void main(String[] args) {
54.
55. //可以用lambda
56. //就选定new Runnable()就可以看到
57. SwingUtilities.invokeLater(() -> {//捕捉异常
58. try {
59. createAndshowGUI();
60. } catch (ClassNotFoundException e) {
61. e.printStackTrace();
62. } catch (SQLException e) {
63. e.printStackTrace();
64. }
65. });
66.
67. // SwingUtilities.invokeLater(new Runnable() {//可以用lambda
68. // //就选定new Runnable()就可以看到上面的类型
69. // @Override
70. // public void run() {
71. // createAndshowGUI();//这种方式更安全一点，因为主线程不能更新ui用户接口
72. // }
73. // });
74.
75.
76.
77. }
78.
79. private static void createAndshowGUI() throws ClassNotFoundException, SQLException {
80.
81. //1.创建JFrame窗体对象
82. JFrame jf = new JFrame();//括号内标题可以直接直接输入汉字
83.
84. jf.setTitle(“欢迎光临”);//也可以改变这样
85. //设置关闭窗口时，一同结束后台的java程序
86. // 2.创建指定当前窗体布局创建对象边界布局管理器
87. jf.setLayout(new BorderLayout());
88. jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
89.
90. jf.setResizable(true);//设置窗体大小是否可重置
91.
92. //设置窗口大小 像素
93. jf.setSize(1000,700);//可以运用jf.setBounds();完成完成这两句
94. //位置
95. //jf.setLocation(460,190);
96. jf.setLocationRelativeTo(null);
97.
98. //创建组件(按钮组件)
99. //JButton button_1=new JButton(“1234”);
100. //将组件添加到容器中
101. //jf.add(button_1,BorderLayout.PAGE_START);//PAGE_END LINE_START LINE_END CENTER\
102.
103.
104.
105. //设置窗体可见
106. // // jf.setVisible(true);
107. // //3.创建JDialog对话框
108. // JDialog dialog= new JDialog(jf,”abc”,true);
109. // //构造方法中传入true的话，那就是设置模式为模态对话框
110. // dialog.setDefaultCloseOperation(dialog.HIDE_ON_CLOSE);
111. // dialog.setSize(300,200);
112. // dialog.setLocation(850,400);//设置位置
113. // dialog.setVisible(true);
114.
115. //设置窗体可见放在这里，就能做出来出来先关闭这个然后才展示那个的界面，可以在这个小的上面做个密码。
116. jf.setVisible(true);
117. // //4.创建流式布局管理器
118. // jf.setLayout(new FlowLayout(FlowLayout.LEFT,100,100));//RIGHT CENTER
119. // //指定当前窗体布局创建对象流式布局管理器
120. // //创建按钮组件并添加到容器当中
121. // jf.add(new JButton(“qwe”));
122. // jf.add(new JButton(“qwe”));
123. // jf.add(new JButton(“qwe”));
124. // jf.add(new JButton(“qwe”));
125. // jf.add(new JButton(“qwe”));
126.
127.
128. // //设计窗体事件，为窗体注册监听
129. // jf.addWindowListener(new WindowListener() {
130. // @Override
131. // public void windowOpened(WindowEvent e) {
132. // System.out.println(“窗体打开事件”);
133. // }
134. //
135. // @Override
136. // public void windowClosing(WindowEvent e) {
137. // System.out.println(“窗体正在关闭事件”);
138. //
139. // }
140. //
141. // @Override
142. // public void windowClosed(WindowEvent e) {
143. // System.out.println(“窗体打开事件”);
144. //
145. // }
146. //
147. // @Override
148. // public void windowIconified(WindowEvent e) {
149. // System.out.println(“窗体图表化，最小化事件”);
150. //
151. // }
152. //
153. // @Override
154. // public void windowDeiconified(WindowEvent e) {
155. // System.out.println(“窗体取消图表化，取消最小化事件”);
156. // }
157. //
158. // @Override
159. // public void windowActivated(WindowEvent e) {
160. // System.out.println(“窗体激活事件”);
161. // }
162. //
163. // @Override
164. // public void windowDeactivated(WindowEvent e) {
165. // System.out.println(“窗体停用事件”);
166. // }
167. // });
168. //
169.
170.
171.
172. // //创建组件，并添加到容器中
173. // JButton button_3=new JButton(“按钮3”);//jf.add(new JButton(“按钮”));
174. // //为事件源注册鼠标监听器
175. // button_3.addMouseListener(new MouseListener() {
176. // @Override
177. // public void mouseClicked(MouseEvent e) {//重要
178. // //System.out.println(“鼠标完成单击事件”);
179. // }
180. //
181. // @Override
182. // public void mousePressed(MouseEvent e) {
183. // System.out.println(“鼠标被按下事件”);
184. //
185. // int button=e.getButton();//1为左键2为滚轮3为右键
186. // System.out.println(button);
187. // if(button==MouseEvent.BUTTON1)
188. // System.out.println(“鼠标左键被点击”);
189. // else if(button==MouseEvent.BUTTON2)
190. // System.out.println(“鼠标滑轮被点击”);
191. // else if(button==MouseEvent.BUTTON3)
192. // System.out.println(“鼠标右键被点击”);
193. // }
194. //
195. // @Override
196. // public void mouseReleased(MouseEvent e) {
197. // //System.out.println(“鼠标放开事件”);
198. // }
199. //
200. // @Override
201. // public void mouseEntered(MouseEvent e) {
202. // //System.out.println(“鼠标进入按钮区域事件”);
203. //
204. // }
205. //
206. // @Override
207. // public void mouseExited(MouseEvent e) {
208. // //System.out.println(“鼠标移出按钮区域事件”);
209. //
210. // }
211. // });
212. // jf.add(button_3);
213. //
214.
215.
216. // JButton button_4=new JButton(“按钮4”);
217. // button_4.addMouseListener(new MouseAdapter() {
218. // @Override
219. // public void mouseClicked(MouseEvent e) {
220. // System.out.println(“我被点了！！！”);
221. // }
222. // });
223. // jf.add(button_4);
224. // button_4.addActionListener(new ActionListener() {//ActionListener用于监听动作事件
225. // //单独点击就用这个，别的就用别的就行
226. // @Override
227. // public void actionPerformed(ActionEvent e) {
228. // System.out.println(“我是ActionListener，我也能够监听点击的动作：我被点了！！！”);
229. // }
230. // });
231. //
232.
233.
234.
235. // //创建带有滚动条的空面板 JScrollPane带有滚动条，只能存放一个组件
236. // JScrollPane jScrollPane =new JScrollPane();
237. // //设置水平滚动条，当组件超过了窗体大小，显示滚动条
238. // jScrollPane.setHorizontalScrollBarPolicy(ScrollPaneConstants.HORIZONTAL_SCROLLBAR_AS_NEEDED);//需要时展示
239. // //设置垂直滚动条策略 设置滚动条一直存在
240. // jScrollPane.setVerticalScrollBarPolicy(ScrollPaneConstants.VERTICAL_SCROLLBAR_ALWAYS);//接口.存在方式；一直存在
241. //
242. // //创建JPanel存储多个组件 无滚动条，可以存放多个组件
243. // JPanel panel=new JPanel();
244. // panel.add(new JButton(“1”));
245. // panel.add(new JButton(“2”));
246. // panel.add(new JButton(“3”));
247. // panel.add(new JButton(“4”));
248. // panel.add(new JButton(“4”));
249. // panel.add(new JButton(“4”));
250. // panel.add(new JButton(“4”));
251. // panel.add(new JButton(“4”));
252. // panel.add(new JButton(“4”));
253. //
254. // //将组织好的一个panel组件，整个添加都添加到带有滚动条的面板当中
255. // jScrollPane.setViewportView(panel);
256. // jf.add(jScrollPane,BorderLayout.CENTER);
257.
258.
259.
260.
261. //
262. // //设置为边界布局
263. // jf.setLayout(new BorderLayout());
264. // //创建聊天记录的JTextArea，因为是聊天记录，所以不能改
265. // JTextArea showArea = new JTextArea(25,45);
266. // //因为是聊天记录，所以不能修改里面内容
267. // showArea.setEditable(false);
268. // //创建滚动条的面板组件
269. // JScrollPane jScrollPane =new JScrollPane(showArea);
270. // //放在下面
271. // jf.add(jScrollPane,BorderLayout.PAGE_END);
272. //
273. // //创建文本框JTextField
274. // JTextField text = new JTextField(35);
275. // //创建发送按钮
276. // //按钮与键盘结合
277. // JButton but =new JButton(“发送”);
278. // but.addActionListener(new ActionListener() {
279. // @Override
280. // public void actionPerformed(ActionEvent e) {
281. // //获取文本框中的数据，
282. // String content =text.getText();
283. // if (content!=null && content.length()!=0){
284. // showArea.append(“发送信息为：”+content+”\r\n”);//追加
285. // }else {
286. // showArea.append(“发送内容不得为空\r\n”);
287. // }
288. // text.setText(“”);//输入完之后就清空掉
289. // }
290. // });
291. // //创建提示标签‘
292. // JLabel label = new JLabel(“留言信息”);
293. //
294. // JPanel panel=new JPanel();
295. // panel.add(label);
296. // panel.add(text);
297. // panel.add(but);
298. // jf.add(panel,BorderLayout.PAGE_START);
299.
300. // //5.创建网格布局管理器3
301. // //设置当前窗口布局
302. // jf.setLayout(new GridLayout(3,3,100,100));
303. // for(int i =1 ;i<=9;i++)
304. // jf.add(new JButton(“asd”+i));
305.
306.
307. //事件
308. //创建组件，并添加到容器中
309.
310. JButton button_2=new JButton(“登陆”);//jf.add(new JButton(“按钮”));
311.
312. //为事件源注册监听器
313. button_2.addActionListener(new ActionListener() {//ActionListener用于监听动作事件
314. @Override
315. public void actionPerformed(ActionEvent e) {
316. jf.setVisible(false);
317. new DengLu().setVisible(false);
318. }
319. });
320. //将组件添加到窗体中
321.
322.
323.
324. //JLabel可以展现文字和图片
325. //创建图片JLabel
326. JLabel label1 = new JLabel();
327. //ImageIcon画布
328. ImageIcon icon =new ImageIcon(“src/com/company/p/7E620D805FF95D30D933F86CC6D34048.jpg”);
329.
330. //Image画布中的图片内容
331. Image image= icon.getImage();
332. image=image.getScaledInstance(1000,550,Image.SCALE_DEFAULT);//图片大小为默认
333.
334. icon.setImage(image);
335. label1.setIcon(icon);//放入画布中
336. jf.add(label1,BorderLayout.PAGE_START);//居中
337.
338. //创建文本JLabel
339. JLabel label2 = new JLabel(“欢迎光临 “,JLabel.CENTER);
340. label2.setFont(new Font(“宋体”,Font.PLAIN,40));//改大小
341.
342. //创建两个复选按钮
343. JCheckBox cb1=new JCheckBox(“加粗”);//可以直接替换为单选按钮,JRadioButton
344. JCheckBox cb2=new JCheckBox(“斜体”);//下面注释掉的是单选按钮只能点一个。
345. // ButtonGroup group=new ButtonGroup();
346. // group.add(cb1);
347. // group.add(cb2);
348.
349. //创建事件监听器
350. ActionListener listener = new ActionListener() {
351. @Override
352. public void actionPerformed(ActionEvent e) {
353. int mode =0;
354. if (cb1.isSelected()){
355. mode+=Font.BOLD;
356.
357. }
358. if (cb2.isSelected()){
359. mode+=Font.ITALIC;
360.
361. }
362. label2.setFont(new Font(“宋体”,mode,40));//改大小
363.
364. }
365. };
366. cb1.addActionListener(listener);
367. cb2.addActionListener(listener);
368. //创建面板组件
369.
370. JPanel panel = new JPanel();
371. JPanel panel1 = new JPanel();
372. panel.add(cb1);
373. panel.add(cb2);
374. panel1.add(label2);
375. panel1.add(button_2);
376.
377. jf.add(panel1,BorderLayout.CENTER);
378.
379. jf.add(panel,BorderLayout.PAGE_END);
380.
381.
382. }
383. /*
384.
385. //适配器设计模式，场景当发现需要使用接口中的部分功能时候，可以考虑设计一个适配器
386. //这样使用，就不需要重写接口中所有的抽象方法
387.
388. 例子如下
389. //相当于中间的实现了，但是为空
390. 又一次用只重写其中一部分·····································································································································································································
391. 鲁智深等于说直接面向中间类不直接面向接口，如上
392. */
393.
394. //从这里注释直到接口位置，解除下面注释就能实现适配器方法原理
395. // 鲁智深 鲁智深1 = new 鲁智深();
396. // 鲁智深1.习武();}
397.
398.
399.
400. }
401.
402.
403.
404. package com.company;
405. import java.sql.*;
406. import javax.swing.*;
407. import java.awt.*;
408. import java.awt.event.ActionEvent;
409. import java.awt.event.ActionListener;
410. import java.awt.event.KeyAdapter;
411. import java.awt.event.KeyEvent;
412.
413. public class DengLu extends JFrame {
414. private static String driverName = “com.mysql.cj.jdbc.Driver”;
415. private static boolean flag =false;
416. static Connection conn=null;
417. static PreparedStatement pstmt=null;
418. static ResultSet rs=null;//作用域不够
419. static String zhanghu;
420. static String mima;
421.
422. public void panduanmima(){
423. try {
424.
425.
426. Class.forName(driverName);//private static String driverName = “com.mysql.cj.jdbc.Driver”;
427. //加载这个类的字节码文件，就运行了那个方法，就注册驱动了，因为那个会注册两次
428.
429. //获取数据库连接对象
430. conn = DriverManager.getConnection(“jdbc:mysql://127.0.0.1:3306/test01”, “root”, “123456”);
431. //System.out.println(conn);
432.
433.
434. pstmt = conn.prepareStatement(“select * from 管理账户 where 账号 = ? and 密码 = ?”);//获取sql语句的执行对象
435. pstmt.setObject(1,zhanghu );
436. pstmt.setObject(2,mima );
437.
438. rs = pstmt.executeQuery();//执行sql语句
439. //next()将指针向后移动 如果还有数据，该方法返回boole ture，如果没有就返回false
440.
441. flag = rs.next();
442.
443.
444. }catch(Exception e){
445. e.printStackTrace();//如果错误，查看完整错误信息
446. }finally {//关闭释放资源
447. try {
448. rs.close();
449. } catch (SQLException e) {
450. e.printStackTrace();
451. }
452. try {
453. pstmt.close();
454. } catch (SQLException e) {
455. e.printStackTrace();
456. }
457. try {
458. conn.close();
459. } catch (SQLException e) {
460. e.printStackTrace();
461. }
462. }
463.
464. }
465.
466. public DengLu() {
467. //1.创建JFrame窗体对象
468. JFrame jf = new JFrame();//括号内标题可以直接直接输入汉字
469. jf.setTitle(“登陆”);//也可以改变这样
470. //设置关闭窗口时，一同结束后台的java程序
471. // 2.创建指定当前窗体布局创建对象网格布局管理器
472. jf.setLayout(new GridLayout(3,1));
473. jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
474.
475. jf.setResizable(true);//设置窗体大小是否可重置
476.
477. //设置窗口大小 像素
478. jf.setSize(400,350);//可以运用jf.setBounds();完成完成这两句
479. //位置
480. //jf.setLocation(460,190);
481. jf.setLocationRelativeTo(null);
482.
483. jf.setVisible(true);
484.
485.
486. //文本输入框
487. JTextField text=new JTextField(10);
488. JPasswordField text1= new JPasswordField(10);
489.
490. //按钮与键盘结合
491. JButton but =new JButton(“登陆”);
492.
493. JLabel label1 = new JLabel(“账号”,JLabel.CENTER);
494. JLabel label2 = new JLabel(“密码”,JLabel.CENTER);
495. JPanel panel1 = new JPanel();
496. JPanel panel2 = new JPanel();
497. JPanel panel3 = new JPanel();
498.
499. panel1.add(label1);
500. panel1.add(text);
501.
502. panel2.add(label2);
503. panel2.add(text1);
504.
505. panel3.add(but);
506. jf.add(panel1);
507. jf.add(panel2);
508. jf.add(panel3);
509.
510. JFrame d= new JFrame(” 错误！”);
511.
512.
513. but.addActionListener(new ActionListener() {//增加监听动作
514. @Override
515. public void actionPerformed(ActionEvent e) {
516. zhanghu=text.getText();
517. mima=text1.getText();
518. panduanmima();
519. if(flag)
520. //if((text.getText().equals(“root”))&&(text1.getText().equals(“123”)))
521. {
522.
523. jf.setVisible(false);
524. d.setVisible(false);
525. new ZhuTi().setVisible(false);
526. }
527. else{
528. d.setDefaultCloseOperation(d.HIDE_ON_CLOSE);
529. d.setSize(300,200);
530. d.setLocation(850,400);//设置位置
531. d.setVisible(true);
532. JLabel label123 = new JLabel(“用户名或密码错误!请重新输入”);
533. label123.setFont(new Font(“宋体”,Font.PLAIN,20));//改大小
534. JPanel panel = new JPanel();
535. panel.add(label123);
536. d.add(panel);
537. }
538. }
539.
540.
541.
542.
543. });
544.
545.
546.
547.
548.
549.
550.
551. }
552.
553. }
554.
555. package com.company;
556.
557. import org.omg.CORBA.PRIVATE_MEMBER;
558.
559. import javax.swing.*;
560. import javax.swing.table.DefaultTableCellRenderer;
561. import javax.swing.table.DefaultTableModel;
562. import java.awt.*;
563. import java.awt.event.*;
564. import java.sql.*;
565. import java.util.Vector;
566.
567. public class ZhuTi extends Frame{
568. private static String driverName = “com.mysql.cj.jdbc.Driver”;
569. private static boolean flag1 =false;
570. public static Connection conn1=null;
571. public static PreparedStatement pstmt1=null;
572. public static ResultSet rs=null;//作用域不够
573. public static int id;
574. public static String name;
575. public static double Cp;
576. public static double Xp;
577. private DefaultTableModel tableModel;//实实在在的数据
578. private JTable dataTable;//声明的样式
579. private JScrollPane scrollPane;//滚动面板，用于放入表格
580.
581.
582.
583. private JScrollPane body(){
584. dataTable=new JTable(10,4){
585.
586. public boolean isCellEditable (int row,int column){//这个函数控制可以编辑
587. if (column!=0)
588. return true;
589. else
590. return false;
591. }
592. };
593.
594. //单元格渲染器
595. DefaultTableCellRenderer tcr=new DefaultTableCellRenderer();
596. tcr.setHorizontalAlignment(JLabel.CENTER);//居中显示
597. dataTable.setDefaultRenderer(Object.class,tcr);//设置渲染器
598.
599. tableModel=(DefaultTableModel)dataTable.getModel();//上面声明的两个东西就是getModel()来操作的
600. //这个类来操作数据
601.
602. tableModel.setColumnIdentifiers(new Object[]{“商品编码”,”商品名称”,”成本价”,”销售价”});
603.
604. JScrollPane bodyPanel =new JScrollPane(dataTable);//有可能超过，就会有滚动框
605. refresh();
606. return bodyPanel;
607. }
608.
609.
610. private void refresh() {
611. try {
612. Class.forName(driverName);//private static String driverName = “com.mysql.cj.jdbc.Driver”;
613. //加载这个类的字节码文件，就运行了那个方法，就注册驱动了，因为那个会注册两次
614. }catch(Exception e){
615. System.out.println(“连接出错”);
616. }
617. try {
618. //获取数据库连接对象
619. conn1 = DriverManager.getConnection(“jdbc:mysql://127.0.0.1:3306/test01”, “root”, “123456”);
620. //System.out.println(conn);
621. }catch(SQLException e){
622. System.out.println(“连接对象出错”);
623. }
624.
625. tableModel.setRowCount(0);//每一次执行的时候清除数据
626. try {
627. pstmt1 = conn1.prepareStatement(“select * from good”);//获取sql语句的执行对象
628. }catch(SQLException e){
629. System.out.println(“查询sql语句出错”);
630. }
631.
632. try{
633. ResultSet rs = pstmt1.executeQuery();
634. while (rs.next()){
635. int id1;
636. String name1;
637. double Cp1,Xp1;
638. id1=rs.getInt(“goodId”);
639. name1=rs.getString(“goodName”);
640. Cp1= rs.getDouble(“Cprice”);
641. Xp1=rs.getDouble(“Xprice”);
642. tableModel.addRow(new Object[]{id1,name1,Cp1,Xp1});//添加了一行数据
643. }
644. }catch (Exception e){
645. System.out.println(“7808″+e);
646. e.printStackTrace();
647. }
648.
649. }
650.
651. public void chaxun(){
652. try {
653. Class.forName(driverName);//private static String driverName = “com.mysql.cj.jdbc.Driver”;
654. //加载这个类的字节码文件，就运行了那个方法，就注册驱动了，因为那个会注册两次
655.
656. //获取数据库连接对象
657. conn1 = DriverManager.getConnection(“jdbc:mysql://127.0.0.1:3306/test01”, “root”, “123456”);
658. //System.out.println(conn);
659.
660. pstmt1 = conn1.prepareStatement(“select * from good where goodId = ? and goodName = ?”);//获取sql语句的执行对象
661. pstmt1.setObject(1,id);
662. pstmt1.setObject(2,name);
663.
664. rs = pstmt1.executeQuery();//执行sql语句
665. //next()将指针向后移动 如果还有数据，该方法返回boole ture，如果没有就返回false
666.
667. if(flag1= rs.next()){//返回ture并且指针下移
668. // System.out.println(rs.getInt(“Cprice”));
669. // System.out.println(rs.getInt(“Xprice”));
670. id=rs.getInt(“goodId”);
671. name=rs.getString(“goodName”);
672. Cp= rs.getDouble(“Cprice”);
673. Xp=rs.getDouble(“Xprice”);
674.
675. }
676.
677.
678.
679. }catch(Exception e){
680. e.printStackTrace();//如果错误，查看完整错误信息
681. }finally {//关闭释放资源
682. try {
683. rs.close();
684. } catch (SQLException e) {
685. e.printStackTrace();
686. }
687. try {
688. pstmt1.close();
689. } catch (SQLException e) {
690. e.printStackTrace();
691. }
692. try {
693. conn1.close();
694. } catch (SQLException e) {
695. e.printStackTrace();
696. }
697. }
698.
699. }
700. public int xiugai() {
701. int i = 0;
702. try {
703.
704.
705. Class.forName(driverName);//private static String driverName = “com.mysql.cj.jdbc.Driver”;
706. //加载这个类的字节码文件，就运行了那个方法，就注册驱动了，因为那个会注册两次
707.
708. //获取数据库连接对象
709. conn1 = DriverManager.getConnection(“jdbc:mysql://127.0.0.1:3306/test01”, “root”, “123456”);
710. //System.out.println(conn);
711.
712. pstmt1 = conn1.prepareStatement(“UPDATE good SET goodName=?where goodID=?”);//给占位符进行填充数据
713.
714. pstmt1.setObject(1, name);
715. pstmt1.setObject(2, id);
716. i = 0;
717. i = pstmt1.executeUpdate();//执行sql语句
718. //next()将指针向后移动 如果还有数据，该方法返回boole ture，如果没有就返回false
719.
720. } catch (Exception e) {
721. e.printStackTrace();//如果错误，查看完整错误信息
722. } finally {//关闭释放资源
723.
724. try {
725. pstmt1.close();
726. } catch (SQLException e) {
727. e.printStackTrace();
728. }
729. try {
730. conn1.close();
731. } catch (SQLException e) {
732. e.printStackTrace();
733. }
734. return i;
735. }
736.
737. }
738.
739.
740.
741. //对数据库的增加操作//
742.
743.
744. public int add()
745. {
746. int i = 0;
747. try {
748. Class.forName(driverName);//private static String driverName = “com.mysql.cj.jdbc.Driver”;
749. //加载这个类的字节码文件，就运行了那个方法，就注册驱动了，因为那个会注册两次
750.
751. //获取数据库连接对象
752. conn1 = DriverManager.getConnection(“jdbc:mysql://127.0.0.1:3306/test01”, “root”, “123456”);
753. //System.out.println(conn);
754.
755. pstmt1=conn1.prepareStatement(“insert into good values(?,?,?,?)”);
756. pstmt1.setObject(1,id);
757. pstmt1.setObject(2,name);
758. pstmt1.setObject(3,Cp);
759. pstmt1.setObject(4,Xp);
760. i = pstmt1.executeUpdate();//执行sql语句
761.
762.
763. } catch (Exception e){
764. e.printStackTrace();
765.
766. }finally {//关闭释放资源
767.
768. try {
769. pstmt1.close();
770. } catch (SQLException e) {
771. e.printStackTrace();
772. }
773. try {
774. conn1.close();
775. } catch (SQLException e) {
776. e.printStackTrace();
777. }
778. return i;
779. }
780.
781. }
782.
783.
784. //对数据库的删除操作
785.
786. public int del(){
787. int i=0;
788. try {
789. Class.forName(driverName);//private static String driverName = “com.mysql.cj.jdbc.Driver”;
790. //加载这个类的字节码文件，就运行了那个方法，就注册驱动了，因为那个会注册两次
791.
792. //获取数据库连接对象
793. conn1 = DriverManager.getConnection(“jdbc:mysql://127.0.0.1:3306/test01”, “root”, “123456”);
794. //System.out.println(conn);
795.
796. pstmt1=conn1.prepareStatement(“delete from good where goodName = ?”);
797.
798. pstmt1.setObject(1,name);
799. i=pstmt1.executeUpdate();//执行sql语句
800.
801. } catch (Exception e){
802. e.printStackTrace();
803. }
804. finally {//关闭释放资源
805.
806. try {
807. pstmt1.close();
808. } catch (SQLException e) {
809. e.printStackTrace();
810. }
811. try {
812. conn1.close();
813. } catch (SQLException e) {
814. e.printStackTrace();
815. }
816. return i;
817. }
818. }
819.
820.
821. public ZhuTi(){
822.
823.
824. //1.创建JFrame窗体对象
825. JFrame jf = new JFrame();//括号内标题可以直接直接输入汉字
826. jf.setTitle(“商店”);//也可以改变这样
827. //设置关闭窗口时，一同结束后台的java程序
828. // 2.创建指定当前窗体布局创建对象边界布局管理器
829. jf.setLayout(new BorderLayout());
830. jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
831.
832. jf.setResizable(true);//设置窗体大小是否可重置
833.
834. //设置窗口大小 像素
835. jf.setSize(1000,700);//可以运用jf.setBounds();完成完成这两句
836. //位置
837. //jf.setLocation(460,190);
838. jf.setLocationRelativeTo(null);
839.
840. //创建组件(按钮组件)
841. //JButton button_1=new JButton(“1234”);
842. //将组件添加到容器中
843. //jf.add(button_1,BorderLayout.PAGE_START);//PAGE_END LINE_START LINE_END CENTER\
844.
845. //设置窗体可见放在这里，就能做出来出来先关闭这个然后才展示那个的界面，可以在这个小的上面做个密码。
846. jf.setVisible(true);
847. //创建文本JLabel
848. JLabel label2 = new JLabel(“查询商品名称”,JLabel.CENTER);
849. label2.setFont(new Font(“宋体”,Font.PLAIN,20));//改大小
850. //下拉框组件
851. //创建面板容器，中间容器JPanel
852. JPanel panel = new JPanel();
853. //创建下拉框组件
854. JComboBox<String> box= new JComboBox<String>();
855. //创建文本输入框
856. JTextField field= new JTextField(20);
857. //创建文本输入框
858. JTextField field1= new JTextField(20);
859. //向下拉框添加项目选项
860.
861. JLabel label1 = new JLabel(“选择专区”,JLabel.CENTER);
862. label1.setFont(new Font(“宋体”,Font.PLAIN,20));//改大小
863.
864. box.addItem(“请选择专区”);
865. box.addItem(“洗簌专区”);
866. box.addItem(“零食专区”);
867. box.addItem(“电子专区”);
868. box.addItem(“蔬菜专区”);
869. box.addItem(“粮油专区”);
870. box.addItem(“衣服专区”);
871. //为下拉框创建监听
872. box.addActionListener(new ActionListener() {
873. @Override
874. public void actionPerformed(ActionEvent e) {//动作事件
875. String text= (String)box.getSelectedItem();
876. if (“请选择专区”.equals(text)){//如果选着不是专区，然后就弄成刷新，为空字符就行
877. field1.setText(“”);
878. }else{
879. field1.setText(text);
880. }
881. }
882. });
883.
884. panel.add(label2);
885. panel.add(field);
886. panel.add(label1);
887. panel.add(box);
888. panel.add(field1);
889.
890. jf.add(panel,BorderLayout.PAGE_START);
891.
892.
893.
894.
895.
896. //创建菜单栏在这几个中为最大的容器
897. JMenuBar jMenuBar= new JMenuBar();
898. //创建菜单对象
899. JMenu menu1 = new JMenu(“文件”);
900. JMenu menu2 = new JMenu(“帮助”);
901. //创建菜单项
902. JMenuItem item1= new JMenuItem(“作者”);
903. JMenuItem item2= new JMenuItem(“退出”);
904. JMenuItem item10= new JMenuItem(“步骤”);
905. //将菜单项添加到菜单对象当中
906. menu1.add(item1);
907. menu1.addSeparator();//加上分隔符
908. menu1.add(item2);
909. menu2.add(item10);
910. //将菜单栏添加到菜单栏当中
911. jMenuBar.add(menu1);
912. jMenuBar.add(menu2);
913.
914.
915. //创建一个JDialog对话框
916. item1.addActionListener(new ActionListener() {
917. @Override
918. public void actionPerformed(ActionEvent e) {
919. JFrame dialog= new JFrame(“作者”);
920. //构造方法中传入true的话，那就是设置模式为模态对话框
921. dialog.setDefaultCloseOperation(dialog.HIDE_ON_CLOSE);
922. dialog.setSize(300,200);
923. dialog.setLocation(850,400);//设置位置
924. dialog.setVisible(true);
925.
926. JLabel label123 = new JLabel(“左嘉庆”);
927. label123.setFont(new Font(“宋体”,Font.PLAIN,20));//改大小
928. JPanel panel = new JPanel();
929. panel.add(label123);
930.
931. dialog.add(panel);
932. }
933. });
934. item10.addActionListener(new ActionListener() {
935. @Override
936. public void actionPerformed(ActionEvent e) {
937. JFrame dialog= new JFrame(“执行步骤”);
938. //构造方法中传入true的话，那就是设置模式为模态对话框
939. dialog.setDefaultCloseOperation(dialog.HIDE_ON_CLOSE);
940. dialog.setSize(1500,200);
941. dialog.setLocation(850,400);//设置位置
942. dialog.setVisible(true);
943.
944. JLabel label123 = new JLabel(“查找需要输入商品编码和商品名称,添加需要全部都输入,删除的时候需要输入要删除商品名称,修改时候需要输入商品编码和需要输入修改后商品名称”);
945. label123.setFont(new Font(“宋体”,Font.PLAIN,20));//改大小
946. JPanel panel = new JPanel();
947. panel.add(label123);
948.
949. dialog.add(panel);
950. }
951. });
952.
953.
954. //如果点击退出，退出当前程序
955. item2.addActionListener(new ActionListener() {
956. @Override
957. public void actionPerformed(ActionEvent e) {
958. System.exit(0);
959. }
960. });
961.
962. jf.setJMenuBar(jMenuBar);//放置在顶部setJMenuBar
963.
964.
965. //创建弹出式菜单对象
966. JPopupMenu popupMenu= new JPopupMenu();
967. //创建两个菜单项
968. JMenuItem item3 =new JMenuItem(“作者”);
969. JMenuItem item4 =new JMenuItem(“刷新”);
970. JMenuItem item5 =new JMenuItem(“关闭”);
971. //将菜单项添加到菜单当中，并且加入分隔符
972. popupMenu.add(item3);
973. popupMenu.addSeparator();
974. popupMenu.add(item4);
975. popupMenu.addSeparator();
976. popupMenu.add(item5);
977. //为JFrame窗体添加鼠标事件
978. jf.addMouseListener(new MouseAdapter() {
979. @Override
980. public void mouseClicked(MouseEvent e) {
981. if (e.getButton()==MouseEvent.BUTTON3){//设置只能右键点击
982. popupMenu.show(e.getComponent(),e.getX(),e.getY());//首先就是固定写法得到这个事件，后面这俩是获取当前鼠标在哪的位置
983. }
984.
985. }
986. });
987.
988. //如果点击退出，退出当前程序
989. item5.addActionListener(new ActionListener() {
990. @Override
991. public void actionPerformed(ActionEvent e) {
992. System.exit(0);
993. }
994. });
995.
996. item3.addActionListener(new ActionListener() {
997. @Override
998. public void actionPerformed(ActionEvent e) {
999. JFrame dialog= new JFrame(“作者”);
1000. //构造方法中传入true的话，那就是设置模式为模态对话框
1001. dialog.setDefaultCloseOperation(dialog.HIDE_ON_CLOSE);
1002. dialog.setSize(300,200);
1003. dialog.setLocation(850,400);//设置位置
1004. dialog.setVisible(true);
1005.
1006. JLabel label123 = new JLabel(“左嘉庆”);
1007. label123.setFont(new Font(“宋体”,Font.PLAIN,20));//改大小
1008. JPanel panel = new JPanel();
1009. panel.add(label123);
1010.
1011. dialog.add(panel);
1012. }
1013. });
1014.
1015.
1016.
1017. //所有的创建文本输入框
1018. JTextField goodId=new JTextField(10);
1019. JTextField goodName=new JTextField(10);
1020. JTextField Cprice=new JTextField(10);
1021. JTextField Xprice=new JTextField(10);
1022. //所有的中间容器，默认是流式
1023. JPanel namePanel=new JPanel();
1024.
1025. JButton addButton=new JButton(“添加”);
1026.
1027. JButton deleteButton=new JButton(“删除”);
1028.
1029. JButton selectButton=new JButton(“刷新”);
1030. JButton queryButton=new JButton(“查询”);
1031. JButton modifyButton=new JButton(“修改”);
1032. JButton button1=new JButton(“申请服务”);
1033. JButton button2=new JButton(“建议”);
1034. JLabel usernameLabel1=new JLabel(“商品编码：”);
1035. JLabel usernameLabel2=new JLabel(“商品名称：”);
1036.
1037. JLabel usernameLabel3=new JLabel(“成本价：”);
1038.
1039. JLabel usernameLabel4=new JLabel(“销售价：”);
1040.
1041. button1.addActionListener(new ActionListener() {//ActionListener用于监听动作事件
1042. @Override
1043. public void actionPerformed(ActionEvent e) {
1044. new LiaoTian().setVisible(false);
1045. }
1046. });
1047. button2.addActionListener(new ActionListener() {//ActionListener用于监听动作事件
1048. @Override
1049. public void actionPerformed(ActionEvent e) {
1050. new JianYi().setVisible(false);
1051. }
1052. });
1053.
1054. namePanel.add(usernameLabel1);
1055. namePanel.add(goodId);
1056. namePanel.add(usernameLabel2);
1057. namePanel.add(goodName);
1058. namePanel.add(usernameLabel3);
1059. namePanel.add(Cprice);
1060. namePanel.add(usernameLabel4);
1061. namePanel.add(Xprice);
1062. namePanel.add(addButton);
1063. namePanel.add(deleteButton);
1064. namePanel.add(selectButton);
1065. namePanel.add(queryButton);
1066. namePanel.add(modifyButton);
1067.
1068. namePanel.add(button1);
1069. namePanel.add(button2);
1070. jf.add(namePanel,BorderLayout.CENTER);
1071.
1072.
1073. jf.add(body(),BorderLayout.PAGE_END);
1074.
1075.
1076.
1077.
1078.
1079.
1080. class Myjframe extends JFrame{
1081. public Myjframe(String type){
1082. this.setBounds(300,300,200,220);
1083. this.setVisible(true);
1084. //网格布局管理器
1085. this.setLayout(new GridLayout(2,1));
1086. JPanel panel1=new JPanel();
1087. JPanel panel2=new JPanel();
1088. panel1.add(new JLabel(type));
1089.
1090.
1091. JButton button=new JButton(“确认”);
1092. button.addActionListener(new ActionListener() {
1093. public void actionPerformed(ActionEvent e) {
1094.
1095. Myjframe.this.dispatchEvent(new WindowEvent(Myjframe.this,WindowEvent.WINDOW_CLOSING));
1096. //窗口绑定一个事件，这个事件是窗体事件，为窗体注册监听，窗体正在关闭事件
1097.
1098. }
1099. });
1100.
1101. panel2.add(button);
1102. this.add(panel1);
1103. this.add(panel2);
1104. }
1105. }
1106.
1107.
1108. addButton.addActionListener(new ActionListener() {
1109. @Override
1110. public void actionPerformed(ActionEvent e) {
1111. id= Integer.parseInt(goodId.getText());//id=goodId.getText();被封装
1112. name=goodName.getText();
1113. Cp= Double.parseDouble(Cprice.getText());
1114.
1115. Xp= Double.parseDouble(Xprice.getText());
1116.
1117. if(add()>0)
1118. new Myjframe(“添加成功”);
1119. else
1120. new Myjframe(“添加失败”);
1121.
1122. goodId.setText(“”);
1123. goodName.setText(“”);
1124. Cprice.setText(“”);
1125. Xprice.setText(“”);
1126.
1127. }
1128. });
1129.
1130.
1131.
1132. deleteButton.addActionListener(new ActionListener() {
1133. @Override
1134. public void actionPerformed(ActionEvent e) {
1135. String name=goodName.getText();
1136.
1137. if(del()>0)
1138. new Myjframe(“删除成功”);
1139. else
1140. new Myjframe(“删除失败”);
1141. goodName.setText(“”);
1142.
1143.
1144. }
1145. });
1146.
1147.
1148.
1149. selectButton.addActionListener(new ActionListener() {
1150. @Override
1151. public void actionPerformed(ActionEvent e) {
1152. //打印整张表
1153.
1154. refresh();
1155. new Myjframe(“刷新成功”);
1156.
1157. }
1158. });
1159.
1160.
1161. queryButton.addActionListener(new ActionListener() {//增加监听动作
1162. @Override
1163. public void actionPerformed(ActionEvent e) {
1164. id= Integer.parseInt(goodId.getText());
1165. name=goodName.getText();
1166. chaxun();
1167. if(flag1)
1168. {
1169. jf.setVisible(false);
1170. new ZhuTi().setVisible(false);
1171. Myjframe myjframe1=new Myjframe(“查询成功”);
1172.
1173. JLabel usernameLabel8=new JLabel(“商品编码：”+id);
1174. JLabel usernameLabel9=new JLabel(“商品名称：”+name);
1175. JLabel usernameLabel10=new JLabel(“成本价：”+Cp);
1176. JLabel usernameLabel11=new JLabel(“销售价：”+Xp);
1177.
1178. JPanel namePanel=new JPanel();
1179. namePanel.add(usernameLabel8);
1180. namePanel.add(usernameLabel9);
1181. namePanel.add(usernameLabel10);
1182. namePanel.add(usernameLabel11);
1183. myjframe1.add(namePanel,BorderLayout.PAGE_END);
1184.
1185.
1186. }
1187. else{
1188. Myjframe myjframenew1= new Myjframe(“查询不成功”);
1189. }
1190. }
1191.
1192. });
1193.
1194.
1195.
1196. modifyButton.addActionListener(new ActionListener() {
1197. @Override
1198. public void actionPerformed(ActionEvent e) {
1199. id= Integer.parseInt(goodId.getText());
1200. name=goodName.getText();
1201.
1202. if(xiugai()>0)
1203. new Myjframe(“修改成功”);
1204. else
1205. new Myjframe(“修改失败”);
1206.
1207. goodId.setText(“”);
1208. goodName.setText(“”);
1209.
1210. }
1211. });
1212. }
1213. }
1214.
1215.
1216.
1217. package com.company;
1218.
1219. import javax.swing.*;
1220. import java.awt.*;
1221. import java.awt.event.ActionEvent;
1222. import java.awt.event.ActionListener;
1223.
1224. public class LiaoTian extends JFrame {
1225.
1226. public LiaoTian(){
1227.
1228. //1.创建JFrame窗体对象
1229. JFrame jf = new JFrame();//括号内标题可以直接直接输入汉字
1230. jf.setTitle(“与服务员谈话申请服务要求”);//也可以改变这样
1231. //设置关闭窗口时，一同结束后台的java程序
1232. // 2.创建指定当前窗体布局创建对象边界布局管理器
1233. jf.setLayout(new BorderLayout());
1234. jf.setDefaultCloseOperation(JFrame.HIDE_ON_CLOSE);//EXIT_ON_CLOSE为关闭退出所以不能用
1235.
1236. jf.setResizable(true);//设置窗体大小是否可重置
1237.
1238. //设置窗口大小 像素
1239. jf.setSize(500,350);//可以运用jf.setBounds();完成完成这两句
1240. //位置
1241. //jf.setLocation(460,190);
1242. jf.setLocationRelativeTo(null);
1243.
1244. //创建组件(按钮组件)
1245. //JButton button_1=new JButton(“1234”);
1246. //将组件添加到容器中
1247. //jf.add(button_1,BorderLayout.PAGE_START);//PAGE_END LINE_START LINE_END CENTER\
1248.
1249. //设置窗体可见放在这里，就能做出来出来先关闭这个然后才展示那个的界面，可以在这个小的上面做个密码。
1250. jf.setVisible(true);
1251. //
1252. //创建聊天记录的JTextArea，因为是聊天记录，所以不能改
1253. JTextArea showArea = new JTextArea(15,25);
1254. //因为是聊天记录，所以不能修改里面内容
1255. showArea.setEditable(false);
1256. //创建滚动条的面板组件
1257. JScrollPane jScrollPane =new JScrollPane(showArea);
1258. //放在下面
1259. jf.add(jScrollPane,BorderLayout.PAGE_START);
1260.
1261. //创建文本框JTextField
1262. JTextField text = new JTextField(15);
1263. //创建发送按钮
1264. //按钮与键盘结合
1265. JButton but =new JButton(“发送”);
1266. but.addActionListener(new ActionListener() {
1267. @Override
1268. public void actionPerformed(ActionEvent e) {
1269. //获取文本框中的数据，
1270. String content =text.getText();
1271. if (content!=null && content.length()!=0){
1272. showArea.append(“申请服务要求为：”+content+”\r\n”);//追加
1273. }else {
1274. showArea.append(“发送内容不得为空\r\n”);
1275. }
1276. text.setText(“”);//输入完之后就清空掉
1277. }
1278. });
1279. //创建提示标签‘
1280. JLabel label = new JLabel(“客户留言”);
1281.
1282. JPanel panel=new JPanel();
1283. panel.add(label);
1284. panel.add(text);
1285. panel.add(but);
1286. jf.add(panel,BorderLayout.PAGE_END);
1287. }
1288. }
1289. package com.company;
1290.
1291. import javax.swing.*;
1292. import java.awt.*;
1293. import java.awt.event.ActionEvent;
1294. import java.awt.event.ActionListener;
1295. import java.awt.event.KeyAdapter;
1296. import java.awt.event.KeyEvent;
1297.
1298. public class JianYi extends JFrame{
1299. public JianYi (){
1300. //1.创建JFrame窗体对象
1301. JFrame jf = new JFrame();//括号内标题可以直接直接输入汉字
1302. jf.setTitle(“建议”);//也可以改变这样
1303. //设置关闭窗口时，一同结束后台的java程序
1304. // 2.创建指定当前窗体布局创建对象边界布局管理器
1305. jf.setLayout(new BorderLayout());
1306. jf.setDefaultCloseOperation(JFrame.HIDE_ON_CLOSE);
1307.
1308. jf.setResizable(true);//设置窗体大小是否可重置
1309.
1310. //设置窗口大小 像素
1311. jf.setSize(500,350);//可以运用jf.setBounds();完成完成这两句
1312. //位置
1313. //jf.setLocation(460,190);
1314. jf.setLocationRelativeTo(null);
1315.
1316. //创建组件(按钮组件)
1317. //JButton button_1=new JButton(“1234”);
1318. //将组件添加到容器中
1319. //jf.add(button_1,BorderLayout.PAGE_START);//PAGE_END LINE_START LINE_END CENTER\
1320.
1321. //设置窗体可见放在这里，就能做出来出来先关闭这个然后才展示那个的界面，可以在这个小的上面做个密码。
1322. jf.setVisible(true);
1323. //
1324. //创建聊天记录的JTextArea，因为是聊天记录，所以不能改
1325. JTextArea showArea = new JTextArea(15,25);
1326. //因为是聊天记录，所以不能修改里面内容
1327. showArea.setEditable(false);
1328. //创建滚动条的面板组件
1329. JScrollPane jScrollPane =new JScrollPane(showArea);
1330. //放在下面
1331. jf.add(jScrollPane,BorderLayout.PAGE_START);
1332.
1333. //创建文本框JTextField
1334. JTextField text = new JTextField(15);
1335. //创建发送按钮
1336. //按钮与键盘结合
1337. JButton but =new JButton(“发送”);
1338. but.addActionListener(new ActionListener() {
1339. @Override
1340. public void actionPerformed(ActionEvent e) {
1341. //获取文本框中的数据，
1342. String content =text.getText();
1343. if (content!=null && content.length()!=0){
1344. showArea.append(“客户发送建议信息为：”+content+”\r\n”);//追加
1345. }else {
1346. showArea.append(“发送内容不得为空\r\n”);
1347. }
1348. text.setText(“”);//输入完之后就清空掉
1349. }
1350. });
1351. JLabel label = new JLabel(“客户留言”);
1352.
1353. JPanel panel=new JPanel();
1354. panel.add(label);
1355. panel.add(text);
1356. panel.add(but);
1357. jf.add(panel,BorderLayout.PAGE_END);
1358.
1359.
1360.
1361. }
1362.
1363.
1364. }
1365. package com.company;
1366.
1367. import java.sql.*;
1368.
1369. public class ceShi {
1370. private static String driverName = “com.mysql.cj.jdbc.Driver”;
1371. //private final static String dbURL = “jdbc:mysql://127.0.0.1:3306/warehouse?useUnicode=true&characterEncoding=utf8mb4&serverTimezone=GMT”;
1372. private static String dbURL = “jdbc:mysql://127.0.0.1:3306/test01?useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC”;
1373. private static String userName = “root”;
1374. private static String userPwd = “123456”;
1375. private static Connection conn;
1376. private static Statement stmt;//Statement 并不安全用 所以用PreparedStatement
1377. private static ResultSet rs=null;
1378. private static PreparedStatement pstmt;
1379.
1380.
1381.
1382.
1383. /*
1384. 先注册驱动，加载驱动，连接对象，执行sql
1385.
1386. 对数据库的查找操作
1387. jdbc 就是用java语言连接数据的技术，是Java公司提供给开发人员操作数据库的一套编程接口
1388. 数据库厂商就是给了数据库驱动然后适配java，jdbe就是应用程序和数据库之间的一个桥梁作用
1389.
1390. Driver接口是所有jdbc驱动程序必须实现的接口，该接口专门提供给数据库厂商使用。
1391. 用于加载驱动，一次程序的运行中，只需要加载一次即可。
1392.
1393. DriverManager :使用该类注册驱动。
1394.
1395. Connection:连接对象 ，跟数据库的连接对象
1396.
1397. Statement接口（使用时候不推荐，因为不安全） 用于执行静态SQL语句，并返回一个结果对象。 SQL语句的执行者，通过Connection进行获取
1398. 因为Statement比较繁琐，而且存在安全方面的问题（注入攻击）。用PreparedStatement就解决了
1399. PreparedStatement接口是Statement接口的子接口，用于执行预编译的SQL语句
1400.
1401. ResultSet 结果集对象，封装了查询结果的数据。很多方法
1402. */
1403.
1404. public static void main(String[] args) {
1405.
1406. /*
1407. * 1。注册函数
1408. * 2获取数据库连接
1409. * 3.获取sql语句的执行对象
1410. * 4.执行sql函数
1411. * DML()（增删改）executeUpdate
1412. * DQL()(查询) executeQuery
1413. * 5.处理结果集
1414. * 6.关闭流释放资源。
1415. */
1416.
1417.
1418. // private static String driverName = “com.mysql.cj.jdbc.Driver”;
1419. // //private final static String dbURL = “jdbc:mysql://127.0.0.1:3306/warehouse?useUnicode=true&characterEncoding=utf8mb4&serverTimezone=GMT”;
1420. // private static String dbURL = “jdbc:mysql://127.0.0.1:3306/test01?useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC”;
1421. // private static String userName = “root”;
1422. // private static String userPwd = “123456”;
1423. // private static Connection conn;
1424. // private static Statement stmt;//Statement 并不安全用 所以用PreparedStatement
1425. //
1426. // private static PreparedStatement pstmt;
1427. // 1、加载数据库驱动
1428. try {
1429. Class.forName(driverName);//private static String driverName = “com.mysql.cj.jdbc.Driver”;
1430. //加载这个类的字节码文件，就运行了那个方法，就注册驱动了，因为那个会注册两次
1431. } catch (ClassNotFoundException e) {
1432. System.out.println(“数据库驱动程序加载失败！”);
1433. System.exit(0);
1434. }
1435. // 2、获取数据库连接
1436. try {
1437. conn = DriverManager.getConnection(dbURL, userName, userPwd);
1438. System.out.println(“数据库连接创建成功！”);
1439. } catch (SQLException e) {
1440. System.out.println(“数据库连接创建失败！”);
1441. }
1442.
1443. // 3、获取数据库连接对象
1444. try {
1445. stmt = conn.createStatement();
1446. } catch (SQLException e) {
1447. //e.printStackTrace();
1448. System.out.println(“获取Statement对象失败!”);
1449. }
1450.
1451. }
1452. }
1453. package com.company;
1454.
1455. /*一个数据表对应一个java类
1456. 表中的一条记录对应java类的一个对象
1457. 表中的一个字段对应java类的一个属性
1458.
1459. * */
1460. public class rslinshi {//可以直接用结果集来赋值到一个对象中，来处理对象，但是我运用了全集变量，调用就行
1461.
1462. private int goodId;
1463. private String goodName;
1464. private double Cprice;
1465. private double Xprice;
1466.
1467. public int getGoodId() {
1468. return goodId;
1469. }
1470.
1471. public void setGoodId(int goodId) {
1472. this.goodId = goodId;
1473. }
1474.
1475. public String getGoodName() {
1476. return goodName;
1477. }
1478.
1479. public void setGoodName(String goodName) {
1480. this.goodName = goodName;
1481. }
1482.
1483. public double getCprice() {
1484. return Cprice;
1485. }
1486.
1487. public void setCprice(double cprice) {
1488. Cprice = cprice;
1489. }
1490.
1491. public double getXprice() {
1492. return Xprice;
1493. }
1494.
1495. public void setXprice(double xprice) {
1496. Xprice = xprice;
1497. }
1498. }