201871010102-常龙龙《面向对象程序设计（java）》第十六周学习总结
|
项目 |
内容 |
|
这个作业属于哪个课程 |
https://www.cnblogs.com/nwnu-daizh/ |
|
这个作业的要求在哪里 |
https://www.cnblogs.com/nwnu-daizh/p/12031970.html |
|
作业学习目标 |
(1) 掌握Java应用程序的打包操作； (2) 掌握线程概念； (3) 掌握线程创建的两种技术。 |
第一部分：总结第十二章本周理论知识（25分）
14.1 什么是线程
1.程序、进程与线程
● 程序是一段静态的代码，它是应用程序执行的蓝本。
● 进程是程序的一次动态执行，它对应了从代码加载、执行至执行完毕的一个完整过程。
● 线程是进程执行过程中产生的多条执行线索。 线程是比进程执行更小的单位。
2.Java中实现多线程应用有两种途径：
● 创建Thread类的子类
● 在程序中实现Runnable接口
14.1.1 用Thread类的子类创建线程
只需从Thread类派生出一个子类，在类中一定要实现run()。
例： class hand extends Thread {
public void run() {…….}
}
class Lefthand extends Thread {
public void run() {
for(int i=0;i<=5;i++)
{ System.out.println("You are Students!");
try{ sleep(500); }
catch(InterruptedException e) {… }
}
}
class Righthand extends Thread {
public void run() {
for(int i=0;i<=5;i++) {
System.out.println("I am a Teacher!");
try{ sleep(300); }
catch(InterruptedException e) {…. } }
}
}
● 然后用该类创建一个对象
Lefthand left=new Lefthand();
Righthand right=new Righthand();
● 用start()方法启动线程
left.start();
right.start();
● 在程序中实现多线程，关键性操作：
-定义用户线程操作，即run()方法的实现。
-在适当的时候启动线程。
public class ThreadTest {
static Lefthand left;
static Righthand right;
public static void main(String[] args) {
left=new Lefthand();
right=new Righthand();
left.start();
right.start();
}
}
例：ThreadTest.java 执行结果：
You are Students!
I am a Teacher!
I am a Teacher!
You are Students!
I am a Teacher!
I am a Teacher!
You are Students!
I am a Teacher!
You are Students!
I am a Teacher!
You are Students!
You are Students!
14.1.2 用Runnable()接口创建线程
●用Runnable()接口实现多线程时，也必须必须实现run()方法，也需用start()启动 线程。
●用Runnable()接口实现多线程时，常用Thread类的构造方法来创建线程对象。
class BallRunnable implements Runnable {
public void run() {
try { for (int i = 1; i <= STEPS; i++) {
ball.move(component.getBounds());
component.repaint();
Thread.sleep(DELAY);
}
}catch (InterruptedException e) { }
}
●API:java.lang.Thread
Thread(Runnable r)
Runnable r = new BallRunnable(b, comp);
Thread t = new Thread(r);
创建一个新线程，它调用r的run(), r是一个实现了Runnable接口的类的实例。
● 例14-1 Bounce.java p625
● 例14-4 BounceThread.java p631
14.2 中断线程
●当线程的run方法执行方法体中最后一条语句后，并经由执行return语句返回时，或者出现了在方法中没有捕获的异常时，线程将终止。
●在程序中常常调用interrupt()来终止线程，interrupt()不仅可中断正在运行的线程，而且也能中断处于blocked状态的线程，此时interrupt()会抛出一个InterruptedException异常。
●Java提供了几个用于测试线程是否被中断的方法。
●void interrupt() 向一个线程发送一个中断请求，同时把这个线程的“interrupted”状态置为true。 若该线程处于blocked状态，会抛出InterruptedException。
●static boolean interrupted() 检测当前线程是否已被中断，并重置状态“interrupted”值为false。
●boolean isInterrupted() 检测当前线程是否已被中断，不改变状态“interrupted”值 。
14.3 线程状态
线程一共有如下6种状态：
●New (新建)
●Runnable (可运行)
●Blocked (被阻塞)
●Waiting (等待)
●Timed waiting (计时等待)
●Terminated (被终止)
14.3.1 新创建线程
●new（新建）
线程对象刚刚创建，还没有启动，此时还处于不可运行状态。
●Thread thread=new Thread(“test”)
此时线程thread处于新建状态，但已有了相应的内存空间以及其它资源。
14.3.2 被终止的线程
●Terminated (被终止)
线程被终止的原因有二：
一是run()方法中最后一个语句执行完毕，因而自然死亡。
二是因为一个没有捕获的异常终止了run方法，从而意外死亡。
●thread.stop() 可以调用线程的stop方法杀死一个线程，但是，stop方法已过时，不要在自己的代码中调用它。
第二部分：实验部分
实验1： 导入第13章示例程序，测试程序并进行代码注释。
测试程序1
● 在elipse IDE中调试运行教材585页程序13-1，结合程序运行结果理解程序；
● 将所生成的JAR文件移到另外一个不同的目录中，再运行该归档文件，以便确认程序是从JAR文件中，而不是从当前目录中读取的资源。
● 掌握创建JAR文件的方法；
代码如下：
package resource; import java.awt.*;
import java.io.*;
import java.net.*;
import java.util.*;
import javax.swing.*; /**
* @version 1.41 2015-06-12
* @author Cay Horstmann
*/
public class ResourceTest
{
public static void main(String[] args)
{
EventQueue.invokeLater(() -> {
JFrame frame = new ResourceTestFrame();
frame.setTitle("ResourceTest");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(true);
});
}
} /**
* 一个加载图像和文本资源的框架。
*/
class ResourceTestFrame extends JFrame
{
private static final int DEFAULT_WIDTH = 300;
private static final int DEFAULT_HEIGHT = 300; public ResourceTestFrame()
{
setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT); //在找到ResourceTest类的地方查找about.gif文件
URL aboutURL = getClass().getResource("about.gif"); //将此图像设置为框架的图标
Image img = new ImageIcon(aboutURL).getImage();
setIconImage(img); JTextArea textArea = new JTextArea(); //getResourceAsStream方法的作用是找到与类位于同一位置的资源，返回一个可以加载资源的URL或者输入流
InputStream stream = getClass().getResourceAsStream("about.txt"); //在读取文本时使用同一编码UTF-8
try (Scanner in = new Scanner(stream, "UTF-8"))
{
while (in.hasNext())
textArea.append(in.nextLine() + "\n");
}
add(textArea);
}
}
生成jar文件的过程：通过Eclipse中的功能 File->Export->Java->JAR File->选择需要生成jar文件的包->选择jar文件存储位置JAR file->next->next->main class->finish
生成的文件归档后使用压缩包打开：
双击运行结果如下：
测试程序2：
● 在elipse IDE中调试运行ThreadTest，结合程序运行结果理解程序；
● 掌握线程概念；
● 掌握用Thread的扩展类实现线程的方法；
● 利用Runnable接口改造程序，掌握用Runnable接口创建线程的方法。
代码如下：
package ThreadTest;
class Lefthand extends Thread {
public void run()
{
for(int i=0;i<=5;i++)
{ System.out.println("You are Students!");
//调用Thread的sleep方法不会创建一个新线程，
//sleep是Thread的静态方法，用于暂停当前线程的活动
try{
sleep(500);
}
catch(InterruptedException e)
{
System.out.println("Lefthand error.");
}
}
}
}
class Righthand extends Thread {
public void run()
{
for(int i=0;i<=5;i++)
{ System.out.println("I am a Teacher!");
try{
sleep(300);
}
catch(InterruptedException e)
{
System.out.println("Righthand error.");
}
}
}
}
public class ThreadTest
{
static Lefthand left;
static Righthand right;
public static void main(String[] args)
{ left=new Lefthand();
right=new Righthand();
//同时启动两个线程
left.start();
right.start();
}
}
运行结果如下：
测试程序3：
● 在Elipse环境下调试教材625页程序14-1、14-2 、14-3，结合程序运行结果理解程序；
● 在Elipse环境下调试教材631页程序14-4，结合程序运行结果理解程序；
● 对比两个程序，理解线程的概念和用途；
● 掌握线程创建的两种技术。
代码一：
Ball类：
package bounce; import java.awt.geom.*; /**
* 在长方形边缘上移动和反弹的球
* @version 1.33 2007-05-17
* @author Cay Horstmann
*/
public class Ball
{
private static final int XSIZE = 15;
private static final int YSIZE = 15;
private double x = 0;
private double y = 0;
private double dx = 1;
private double dy = 1; /**
* 将球移动到下一个位置，如果碰到其中一个边，则反转方向
*/
public void move(Rectangle2D bounds)
{
x += dx;
y += dy;
//宽度上的最小位置
if (x < bounds.getMinX())
{
x = bounds.getMinX();
dx = -dx;
}
//宽度上的最大位置
if (x + XSIZE >= bounds.getMaxX())
{
x = bounds.getMaxX() - XSIZE;
dx = -dx;
}
//高度上的最小位置
if (y < bounds.getMinY())
{
y = bounds.getMinY();
dy = -dy;
}
//宽度上的最大位置
if (y + YSIZE >= bounds.getMaxY())
{
y = bounds.getMaxY() - YSIZE;
dy = -dy;
}
} /**
* 获取球在其当前位置的形状
*/
public Ellipse2D getShape()
{
return new Ellipse2D.Double(x, y, XSIZE, YSIZE);
}
}
BallComponent类：
package bounce; import java.awt.*;
import java.util.*;
import javax.swing.*; /**
* 画弹力球的部件.
* @version 1.34 2012-01-26
* @author Cay Horstmann
*/
public class BallComponent extends JPanel
{
private static final int DEFAULT_WIDTH = 450;
private static final int DEFAULT_HEIGHT = 350; private java.util.List<Ball> balls = new ArrayList<>(); /**
* 增加一个球到组件上。
* @param b the ball to add
*/ //创建add方法，在add方法中使用球类型集合的add方法向集合中添加球
public void add(Ball b)
{
balls.add(b);
} //paintComponent方法中有一个Graphics类型的参数，这个参数保留着用于绘制图像和文本的设置。
//在Java中，所有的绘制都必须使用Graphics对象，其中包含了绘制图案，图像和文本的方法。
public void paintComponent(Graphics g)
{
super.paintComponent(g); // 使用背景色绘制面板
Graphics2D g2 = (Graphics2D) g; //获取每一个球的位置和形状并使用默认颜色进行填充
for (Ball b : balls)
{
g2.fill(b.getShape());
}
} public Dimension getPreferredSize() { return new Dimension(DEFAULT_WIDTH, DEFAULT_HEIGHT); }
}
Bounce类：
package bounce; import java.awt.*;
import java.awt.event.*;
import javax.swing.*; /**
* 显示动画弹跳球。
* @version 1.34 2015-06-21
* @author Cay Horstmann
*/
public class Bounce
{
public static void main(String[] args)
{
EventQueue.invokeLater(() -> {
JFrame frame = new BounceFrame();
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(true);
});
}
} /**
* 有球部件和按钮的框架。
*/
class BounceFrame extends JFrame
{
private BallComponent comp;
public static final int STEPS = 1000;
public static final int DELAY = 3; /**
* 构造包含用于显示弹跳球和启动和关闭按钮的框架
*/
public BounceFrame()
{
setTitle("Bounce");
comp = new BallComponent();
add(comp, BorderLayout.CENTER);
JPanel buttonPanel = new JPanel(); //使用addBuuton方法为按钮添加标题，监听器，并且将按钮添加至面板中
addButton(buttonPanel, "Start", event -> addBall());
addButton(buttonPanel, "Close", event -> System.exit(0)); //将按钮面板添加至框架的南部
add(buttonPanel, BorderLayout.SOUTH);
pack();
} /**
*向容器添加按钮
* @param c the container
* @param 为按钮设置标题
* @param 为按钮设置监听器
*/
public void addButton(Container c, String title, ActionListener listener)
{
JButton button = new JButton(title);
c.add(button);
button.addActionListener(listener);
} /**
* 在面板中添加一个弹跳球，使其弹跳1000次。
*/
public void addBall()
{
try
{
Ball ball = new Ball();
comp.add(ball); for (int i = 1; i <= STEPS; i++)
{
//这样设置的话所有球的移动都处于一个线程当中
ball.move(comp.getBounds());
comp.paint(comp.getGraphics());
Thread.sleep(DELAY);
}
}
//中断异常
catch (InterruptedException e)
{
}
}
}
运行结果如下：
代码二：
Ball类：
package bounce; import java.awt.geom.*; /**
* 在长方形边缘上移动和反弹的球
* @version 1.33 2007-05-17
* @author Cay Horstmann
*/
public class Ball
{
private static final int XSIZE = 15;
private static final int YSIZE = 15;
private double x = 0;
private double y = 0;
private double dx = 1;
private double dy = 1; /**
* 将球移动到下一个位置，如果碰到其中一个边，则反转方向
*/
public void move(Rectangle2D bounds)
{
x += dx;
y += dy;
//宽度上的最小位置
if (x < bounds.getMinX())
{
x = bounds.getMinX();
dx = -dx;
}
//宽度上的最大位置
if (x + XSIZE >= bounds.getMaxX())
{
x = bounds.getMaxX() - XSIZE;
dx = -dx;
}
//高度上的最小位置
if (y < bounds.getMinY())
{
y = bounds.getMinY();
dy = -dy;
}
//宽度上的最大位置
if (y + YSIZE >= bounds.getMaxY())
{
y = bounds.getMaxY() - YSIZE;
dy = -dy;
}
} /**
* 获取球在其当前位置的形状
*/
public Ellipse2D getShape()
{
return new Ellipse2D.Double(x, y, XSIZE, YSIZE);
}
}
BallComponent类：
package bounce; import java.awt.*;
import java.util.*;
import javax.swing.*; /**
* 画弹力球的部件.
* @version 1.34 2012-01-26
* @author Cay Horstmann
*/
public class BallComponent extends JPanel
{
private static final int DEFAULT_WIDTH = 450;
private static final int DEFAULT_HEIGHT = 350; private java.util.List<Ball> balls = new ArrayList<>(); /**
* 增加一个球到组件上。
* @param b the ball to add
*/ //创建add方法，在add方法中使用球类型集合的add方法向集合中添加球
public void add(Ball b)
{
balls.add(b);
} //paintComponent方法中有一个Graphics类型的参数，这个参数保留着用于绘制图像和文本的设置。
//在Java中，所有的绘制都必须使用Graphics对象，其中包含了绘制图案，图像和文本的方法。
public void paintComponent(Graphics g)
{
super.paintComponent(g); // 使用背景色绘制面板
Graphics2D g2 = (Graphics2D) g; //获取每一个球的位置和形状并使用默认颜色进行填充
for (Ball b : balls)
{
g2.fill(b.getShape());
}
} public Dimension getPreferredSize() { return new Dimension(DEFAULT_WIDTH, DEFAULT_HEIGHT); }
}
BounceThread类：
package bounceThread; import java.awt.*;
import java.awt.event.*; import javax.swing.*; /**
* 显示动画弹跳球。
* @version 1.34 2015-06-21
* @author Cay Horstmann
*/
public class BounceThread
{
public static void main(String[] args)
{
EventQueue.invokeLater(() -> {
JFrame frame = new BounceFrame();
frame.setTitle("BounceThread");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(true);
});
}
} /**
* 有面板和按钮的框架。
*/
class BounceFrame extends JFrame
{
private BallComponent comp;
public static final int STEPS = 1000;
public static final int DELAY = 5; /**
* 构造包含用于显示弹跳球和开始和关闭按钮的组件的框架
*/
public BounceFrame()
{
comp = new BallComponent();
add(comp, BorderLayout.CENTER);
JPanel buttonPanel = new JPanel();
addButton(buttonPanel, "Start", event -> addBall());
addButton(buttonPanel, "Close", event -> System.exit(0));
add(buttonPanel, BorderLayout.SOUTH);
pack();
} /**
* 添加一个按钮到框架中.
* @param c the container
* @param 为按钮设置标题
* @param 为按钮设置监听器
*/
public void addButton(Container c, String title, ActionListener listener)
{
JButton button = new JButton(title);
c.add(button);
button.addActionListener(listener);
} /**
* 在画布上添加一个弹跳球并开始一条线使其弹跳
*/
public void addBall()
{
Ball ball = new Ball();
comp.add(ball); //将移动球的代码放置在一个独立的线程中，运行这段代码可以提高弹跳球的相应性能
//实现一个BallRunnable类，然后，将动画代码放在run方法中，这样就即将动画代码放在了一个单独的线程中
Runnable r = () -> {
try
{
for (int i = 1; i <= STEPS; i++)
{
ball.move(comp.getBounds());
//调用组件的repaint方法，重新绘制组件
comp.repaint();
Thread.sleep(DELAY);
}
}
catch (InterruptedException e)
{
}
}; //将Runnable对象作为入口参数传入Thread的构造函数，再调用start方法就可以启动线程
Thread t = new Thread(r);
t.start();
}
}
运行结果如下：
可以同时运行一个以上线程的程序叫多线程程序。
实验2：结对编程练习：采用GUI界面设计以下程序，并创建程序归档文件。
● 设计一个100以内整数小学生四则运算练习程序，由计算机随机产生10道加减乘除练习题，
学生输入答案，由程序检查答案是否正确，每道题正确计10分，错误不计分，10道题测试结束后给出测试总分；
● 将程序中测试练习题及学生答题结果输出到文件，文件名为test.txt。
1) 程序设计思路简述；
GUI界面设计思路：
我在框架北部加了一个title(JLabel),在中部加了一个problemPanel面板，problemPanel面板布局为10行一列的网格布局，每一行又是一个contentPanel面板，在contentPanel面板中添加了显示题号的orderLabel，显示题目的problemLabel，用于作答的answer，显示对错的judgeLabel组件。在框架南部加了一个用于放置按钮的buttonPanel面板，里面分别放置makeProblemButton,submitbutton,reset
Button和checkButton。另外还有一个用于显示txt文本的框架，其中只放置了一个display(JTextArea)，最后，我加了一个计时器来限制作答时间（额外补充的）。这样，就完成了整个小学生四则运算练习程序的GUI页面布局。
动作事件设计思路：我为出题按钮设置了一个problemAction监听器，监听器中又有一个makeOperation方法，用于生成题目，makeOperation方法中使用随机数产生两个操作数（第二个操作数过滤掉0），然后再产生一个1-4的随机数用于设置题目的类型，将生成的题目设置为problemLabel的标题，再将每个题的结果存在result数组中。同时为提交按钮设置了一个judgeAction监听器，将answer中输入的内容与result所存的结果相比较，想同judgeLabel则显示√，否则显示×。并为重置按钮设置resetAction监听器，将answer中输入的内容全部清空，但是不能在提交之后清空。最后为check按钮设置checkAction监听器，将所有信息读入txt文件，并且创建新框架，在新框架中显示出最后的信息。在倒计时动作事件中，我使用time类中的schedule方法实现了倒计时的功能，并且在时间剩余10秒时，字体会放大以用于强调，当时间到0时，会弹出信息对话框，并且当用户提交时，计时也会停止。
2) 符合编程规范的程序代码；
ArithmeticExercisesFrame类：
package demo; import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.EventQueue;
import java.awt.FlowLayout;
import java.awt.Font;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Random;
import java.util.Timer;
import java.util.TimerTask; import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JTextArea;
import javax.swing.JTextField; public class ArithmeticExercisesFrame extends JFrame { private JPanel[] contentPanel=new JPanel[10];
private JLabel[] orderLabel=new JLabel[10];
private JLabel[] problemLabel=new JLabel[10];
private JTextField[] answer=new JTextField[10];
private JLabel[] judge=new JLabel[10];
private JPanel problemPanel;
private JButton submitButton;
private JButton resetButton;
private JPanel buttonPanel;
private JLabel title;
private JButton makeproblemButton;
private int operands1;
private int operands2;
private int[] result=new int[10];
private JButton checkButton;
//private static int i=1;
private File file=new File("小学生四则运算答案结果");
private JTextArea textarea=new JTextArea(10,20);
private JPanel timeLimitPanel;
private JLabel sumTime;
private JLabel timeLabel;
private JLabel timechange;
private JLabel s;
private Timer time;
private JOptionPane message; public ArithmeticExercisesFrame()
{
setSize(400,630);
//添加标题
JPanel titlePanel=new JPanel();
title = new JLabel("小学生四则运算练习程序");
title.setFont(new Font("宋体",Font.ROMAN_BASELINE,25));
titlePanel.add(title);
add(titlePanel,BorderLayout.NORTH);
problemPanel = new JPanel();
problemPanel.setLayout(new GridLayout(11,1));
time();
createQuestionBoard();
addQuestionBoard();
makeButtonPanel();
add(problemPanel,BorderLayout.CENTER); } public void time()
{
timeLimitPanel = new JPanel();
sumTime = new JLabel("总时间：180s");
timeLabel = new JLabel(" 倒计时：");
timechange = new JLabel("180");
s = new JLabel("s"); sumTime.setFont(new Font("宋体",Font.ROMAN_BASELINE,20));
sumTime.setForeground(Color.green);
timeLabel.setFont(new Font("宋体",Font.ROMAN_BASELINE,20));
timeLabel.setForeground(Color.red);
timechange.setFont(new Font("宋体",Font.ROMAN_BASELINE,20));
timechange.setForeground(Color.red);
s.setFont(new Font("宋体",Font.ROMAN_BASELINE,20));
s.setForeground(Color.red); timeLimitPanel.add(sumTime);
timeLimitPanel.add(timeLabel);
timeLimitPanel.add(timechange);
timeLimitPanel.add(s);
problemPanel.add(timeLimitPanel); }
public void createQuestionBoard()
{
//为每一行创建一个面板
for(int i=0;i<10;i++)
{
contentPanel[i]=new JPanel();
contentPanel[i].setLayout(new FlowLayout(FlowLayout.CENTER,15,0));
}
orderLabel = new JLabel[] {
new JLabel("第一题："),
new JLabel("第二题："),
new JLabel("第三题："),
new JLabel("第四题："),
new JLabel("第五题："),
new JLabel("第六题："),
new JLabel("第七题："),
new JLabel("第八题："),
new JLabel("第九题："),
new JLabel("第十题：")
};
for(int i=0;i<10;i++)
{
problemLabel[i]=new JLabel("请出题");
answer[i]=new JTextField(8);
judge[i]=new JLabel("待定");
judge[i].setFont(new Font("宋体",Font.ROMAN_BASELINE,30));
}
} public void addQuestionBoard()
{
for(int i=0;i<contentPanel.length;i++)
{
contentPanel[i].add(orderLabel[i]);
contentPanel[i].add(problemLabel[i]);
contentPanel[i].add(answer[i]);
contentPanel[i].add(judge[i]);
problemPanel.add(contentPanel[i]);
}
} public void makeButtonPanel() {
buttonPanel = new JPanel();
buttonPanel.setLayout(new FlowLayout(FlowLayout.CENTER,10,0));
makeproblemButton = new JButton("出题");
submitButton=new JButton("提交");
resetButton=new JButton("重置");
checkButton = new JButton("查看");
buttonPanel.add(makeproblemButton);
buttonPanel.add(submitButton);
buttonPanel.add(resetButton);
buttonPanel.add(checkButton); ActionListener problem=new problemAction();
ActionListener countDown=new timeAction();
makeproblemButton.addActionListener(problem);
makeproblemButton.addActionListener(countDown); ActionListener judge=new judgeAction();
submitButton.addActionListener(judge); ActionListener reset=new resetAction();
resetButton.addActionListener(reset); ActionListener check=new checkAction();
checkButton.addActionListener(check); add(buttonPanel,BorderLayout.SOUTH);
} //产生加减乘除运算的方法
public void makeOperation()
{
for(int i=0;i<10;i++)
{
Random rand=new Random();
int temp;
operands1 = rand.nextInt(100) +1;
operands2=rand.nextInt(100) +1;
while(operands2==0)
{
operands2=rand.nextInt(100) +1;
}
int index=rand.nextInt(4) +1;
switch(index)
{
case 1:problemLabel[i].setText(operands1+"+"+operands2);
result[i] = operands1+operands2;
break;
case 2:problemLabel[i].setText(operands1+"-"+operands2);
result[i]=operands1-operands2;
break;
case 3:problemLabel[i].setText(operands1+"*"+operands2);
result[i]=operands1*operands2;
break;
case 4:problemLabel[i].setText(operands1+"/"+operands2);
result[i]=operands1/operands2;
break;
default:System.out.println("error!");
}
}
}
//判断对错的方法
public void judgeProblem()
{
int score=0;
for(int i=0;i<10;i++)
{
//System.out.println(result[i]);
int res=Integer.parseInt(answer[i].getText());
//System.out.println(res);
if(res==result[i])
{
judge[i].setText("√");
judge[i].setForeground(Color.green);
score+=10;
}
else {
judge[i].setText("×");
judge[i].setForeground(Color.red);
score+=0;
}
textarea.append(orderLabel[i].getText()+" "+problemLabel[i].getText()+" "+"你的答案："+answer[i].getText()+" 正确答案："+result[i]+"\n");
}
textarea.append("你的总得分是："+score+"\n");
} public void savefile() {
try {
FileWriter fw=new FileWriter(file);
//System.out.println(textarea.getText());
fw.write(textarea.getText());
fw.close();
}catch (FileNotFoundException e) {
System.out.println("信息文件找不到");
e.printStackTrace();
} catch (IOException e) {
System.out.println("信息文件读取错误");
e.printStackTrace();
}
} //出题监听器
class problemAction implements ActionListener{
@Override
public void actionPerformed(ActionEvent e) {
makeOperation();
for(int i=0;i<10;i++)
{
judge[i].setVisible(false);
answer[i].setText(null);
} } }
//判断正误监听器
class judgeAction implements ActionListener {
@Override
public void actionPerformed(ActionEvent e) {
judgeProblem();
savefile();
for(int i=0;i<10;i++)
{
judge[i].setVisible(true);
}
time.cancel();
}
} //查看结果监听器
class checkAction implements ActionListener {
@Override
public void actionPerformed(ActionEvent e) {
EventQueue.invokeLater(() -> {
var frame = new checkFrame();
frame.setTitle("小学生四则运算答案结果");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(true);
});
}
} //重置监听器
class resetAction implements ActionListener {
@Override
public void actionPerformed(ActionEvent e) {
for(int i=0;i<10;i++)
{
if(!judge[i].isVisible())
{
answer[i].setText(null);
}
}
}
} //倒计时监听器
class timeAction implements ActionListener{ private int i=180;
@Override
public void actionPerformed(ActionEvent e) {
time = new Timer(); time.schedule(new TimerTask() {
public void run() {
timechange.setText(""+(i--));
if(i<=10)
{
timechange.setFont(new Font("宋体",Font.ROMAN_BASELINE,30));
}
if(i<0)
{
time.cancel();
message.showMessageDialog(ArithmeticExercisesFrame.this,"同学，考试时间已结束，请立即停止作答！");
for(int i=0;i<10;i++)
{
answer[i].setEditable(false);
}
}
}
}, 0, 20);
}
}
}
checkFrame类：
package demo; import java.awt.BorderLayout;
import java.awt.Font;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader; import javax.swing.JFrame;
import javax.swing.JTextArea; public class checkFrame extends JFrame {
private JTextArea display;
private File file;
//private static int i=1;
public checkFrame()
{
setSize(400,600); display = new JTextArea(10,20);
add(display,BorderLayout.CENTER);
loadfile();
}
public void loadfile() {
try {
file=new File("小学生四则运算答案结果");
FileInputStream fis = new FileInputStream(file);
BufferedReader in = new BufferedReader(new InputStreamReader(fis));
String temp = null;
display.append(" 小学生四则运算答案结果"+"\n");
while((temp=in.readLine())!=null)
{
display.append(temp+"\n");
}
display.setFont(new Font("宋体",Font.ROMAN_BASELINE,15));
in.close(); }catch (FileNotFoundException e) {
System.out.println("信息文件找不到");
e.printStackTrace();
} catch (IOException e) {
System.out.println("信息文件读取错误");
e.printStackTrace();
}
}
}
ArithmeticExercisesFrameTest类：
package demo; import java.awt.*;
import javax.swing.*; /**
* @version 1.35 2018-04-10
* @author Cay Horstmann
*/
public class ArithmeticExercisesFrameTest
{
public static void main(String[] args)
{
EventQueue.invokeLater(() -> {
var frame = new ArithmeticExercisesFrame();
frame.setTitle("小学生四则运算练习程序");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(true);
});
}
}
3) 程序运行功能界面截图；
4) 结对过程描述，提供两人在讨论、细化和编程时的结对照片(非摆拍)。
5)程序归档文件
实验总结：（15分）
通过本章的第一个测试程序，我掌握了Java应用程序的打包操作，按我的理解是，如果将Java应用程序打包之后就可以直接发给其他人，而那个人就可以在安装了java虚拟机的计算机上直接运行此应用程序，大大加大了应用程序的可移植性。通过第三个测试程序，我掌握了线程创建的两种技术。在结对编程中，一些不懂的知识点我也通过上网查询慢慢掌握了，最终的编程效果我还是比较满意的，但是程序还是有可提高的余地，我会继续努力，将此程序不断完善，并在此过程中掌握更多的API以及编程技巧。
最新文章
- [Keras] Develop Neural Network With Keras Step-By-Step
- linux安全运维之谁动了chattr
- 【mysql中myisam和innodb的区别】
- 手机web站点和手机app 技术选型的困惑于思考
- js-初步了解
- 32-语言入门-32-Triangular Sums
- 下载服务器dll文件并动态加载
- C#中类的默认访问是私有的
- BZOJ 1061 志愿者招募
- poj1935（树形dp）
- Object-C 新手教程
- 编码器芯片MLX90363的使用
- Elasticsearch【快速入门】
- 百度TTS的来由
- jar包通过exe4j打包成exe可执行文件
- HBase RegionServer Splitting 流程
- Python静态方法（staticmethod）和类方法（classmthod）
- postman(七)：运行集合，看所有请求执行结果
- mfc标题栏 菜单 退出 关机 重启
- 为什么你学不会递归？告别递归，谈谈我的一些经验 关于集合中一些常考的知识点总结 .net辗转java系列（一）视野 彻底理解cookie，session，token