java课程设计报告_五子棋

目录
第一章软件平台……………………………
游戏设计思路…………………………第二章小游戏五子棋的开发过程………………
第一节JAVA基础知识………………………
第二节启动程序的分析……………………
第三节游戏设计过程………………………第三章总结…………………………………………第四章参考文献……………………………………第五章附录…………………………………………
游戏设计思路：
第一节 java程序基础知识
本系统有4个程序每个程序都导入了不同的包和类运用了不同的所学知识。

不同的类和包提供的方法、类型等都不同，本程序还使用了继承。

以至使其能够完成不同的功能。

本节主要讲述本系统所使用的基础知识。

1、类的基础
<1、类的定义
JAVA中的类实质上是一种对象类型，它是对具有相同属性和相同行为对象的一种抽象。

类是java程序中最小的组成单位。

<2、 Java中类定义的格式为：
[类修饰符] class 类名 [extends 基类] [implements 接口]
{// 成员变量声明（Member variable declaration）
// 成员方法声明（Member method declaration）}
其中，class、extends和implements都是Java的关键字。

类修饰符、extends和implements是关于修饰符、继承和接口的容。

2、继承
继承性是面向对象程序设计语言的一个重要特征，通过继承可以实现代码的复用。

Java语言中，所有的类都是直接或间接的继承 ng.object类而得到的。

被继承的类称为基类或父类，继承而的来的类成为子类。

子类继承基类的方法和属性，同时也可以修改基类的方法和属性，并增加自己新的属性和方法。

Java不支持多重继承。

即一个子类不能拥有两个或以上的父类。

3、包
<1、包的定义
在Java中，把相关的代码组织到一起，称为“包”。

包市一种将相关类、接口或其他包组织起来的集合体，目的是为了将包含类代码的文件组织起来，易于查找和使用。

<2、包的语法及导入：
Package PackageName; //包的定义
Import java.awt.Color //导入包关键字Import
4、接口
<1、接口的定义
Java中的接口可以看成是一种抽象类，它是一些抽象方法和常量的集合，其主要作用是使得处于不同层次上以至于互不相干的类能够执行相同的操作，引用相同的值，而且在一个类中可以同时实现来自不同接口中的多种方法。

<2、接口的定义和实现
Interface 接口名{//抽象方法} //定义接口
Class 类名 implements 接口名称{// 类体} 实现接口
5、线程
<1、线程的定义
即同时执行多个程序段，每个程序段都是一个线程。

<2、线程的周期
线程的周期包括新建（new）、就绪（start()）、执行（run()）、阻塞（sleep()、wait()、suspend()、输入/输出流中发生线程阻塞）、死亡（stop()、destroy()）。

创建线程的方法：
一种是创建Thread类的子类。

另一种是实现Runnable接口.而本系统采用的是接口的方式。

6.Applet小应用程序
<1、小应用程序与应用程序的区别：
小应用程序没有主方法不能单独运行。

而应用程序是拥有主方法的是可以单独运行的。

<2、Applet 的执行方式
它有两种：一种是浏览器中执行，另一种是使用Appletviewer()命令执行。

本系统的两个小应用程序都是采用编制html以浏览器形式执行。

<3、Applet主类的一般框架结构图
Import java.awt.*;
Import java.applet.*;
Public class 类名 extends Applet{
Public void init(){//初始化变量、设置字体、装载图片}
Public void start(){//启动程序执行或恢复程序执行}
Public void stop(){//挂起正在执行的程序，暂停程序}
Public viod destroy(){终止程序的执行释放资源}
Public viod paint(Graphics g){// 完成绘制图形等操作}}
7、异常处理
<1、异常处理概念
异常是Java程序运行出现的错误。

<2、异常处理机制
异常处理机制：当try子句中抛出的异常属于某个catch子句的异常类时，该catch子句捕获到异常，并且系统自动将异常类的实例传递给catch子句的异常类对象。

在catch子句中，可以从异常类对象中获取异常细节，并可通过该对象使用异常类中的方法，对异常进行相应的处理。

第二节启动程序的分析
本程序主要是为了启动主程序所使用。

让使用者有个等待时间。

本程序运用了多线程机制使其能同时进行多个任务。

导入的各包详细见后附录。

public class Exec { //测试类
public static void main(String[] args) {// 显示带有启动进度条的欢迎窗体
new DemoWindow(); //实例化一个对象}
}
class DemoWindow extends JWindow implements Runnable { // 带有启动进度条的欢迎窗体类
private JProgressBar progress = new JProgressBar(1, 100); // 进度条ImagePanel ip = new ImagePanel(); // 图片面板
public DemoWindow() { // 构造函数
add(ip, BorderLayout.CENTER); // 窗体布局
add(progress, BorderLayout.SOUTH); //将进度条放在边界布局管理器南边
progress.setStringPainted(true); // 设置进度条
progress.setBorderPainted(false);
progress.setString("正在启动应用程序...");
progress.setForeground(Color.blue);
progress.setBackground(Color.white);
setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR)); // 设置窗体光标
// 设置窗体正好显示整个图片
pack();
// 设置窗体居中显示
Toolkit theKit = getToolkit();
Dimension wndSize = theKit.getScreenSize();
setLocation((wndSize.width - ip.getWidth()) / 2, (wndSize.height - ip
.getHeight()) / 2);
setVisible(true); // 设置窗体为可见
this.toFront();// 将当前窗体置于屏幕所有窗体的前面
Thread splashThread = new Thread(this); //新建线程
splashThread.start(); // 启动改变进度条的线程}
public void run() { // 改变进度条的线程方法
try { //异常处理机制
for (int i = 0; i < 100; i++) { // 循环100次
Thread.sleep(100); // 暂停0.1秒
progress.setValue(progress.getValue() + 1); // 累加进度条的进度
}
if (progress.getValue()==100) 判断进度条的值是否是100
{ jsb dd=new jsb("我的记事本"); 若是则实例化jsb对象即启动主程序
}}
catch (Exception e) { 若出现异常则打印出相应的消息
System.out.println(e.getMessage());}
this.dispose(); // 释放窗体资源
}}
class ImagePanel extends JPanel { // 图片面板
Image image = null; // 图片容
public ImagePanel() { // 构造函数
MediaTracker tracker = new MediaTracker(this); // 创建MediaTracker类变量，以加载图片，它可以保证图片加载完毕后才会进行下一步操作
try { //异常处理
image = Toolkit.getDefaultToolkit().getImage("images/tl.jpg"); // 加载图片tracker.addImage(image, 0); // 等待图片加载完毕
tracker.waitForID(0);}
catch (Exception e) { //若出现异常则打印出消息
System.out.println(e.getMessage());}
setPreferredSize(new Dimension(image.getWidth(this), image
.getHeight(this))); // 设置图片面板的大小正好容纳整个图片}
public void paintComponent(Graphics g) { // 重载的绘图函数，绘制指定图片super.paintComponent(g); //调用基类的方法
g.drawImage(image, 0, 0, this);}}
第三节游戏设计过程
本程序是根据小游戏五子棋开发出来的，从游戏开始到结束，此下为小部分代码分析：
1．新建一个java文件：
2. 编写代码
3.运行
4.总分析：
设计了游戏按照棋子的二维数组进行绘制棋子，玩家下棋后，程序修改数组相应位置，设置isPlayer1值，然后重新绘制(repaint)，就更新了棋盘界面。

由于游戏的功能简单，也为了使游戏的操作尽可能的简便，我不在游戏进入时设计菜单，而是直接开始对战，在对战界面，设置了重新开始和退出的按钮。

即运行即玩，可以悔档，存档，取档，重开
总结
1.Java发展到现在，按应用来分主要分为三大块：J2SE,J2ME和J2EE,这也就是Sun ONE(Open NetEnvironment)体系。

2.Java语法:I/O包，Util包，Lang包.
3.Servlet:就是服务器端小程序，他负责生成发送给客户端的HTML 文件。

JSP在执行时，也是先转换成Servlet再运行的。

虽说JSP理论上可以完全取代Servlet，这也是SUN推出JSP的本意，可是Servlet 用来控制流程跳转还是挺方便的，也令程序更清晰。

4.Javabean:可以把你的JSP中的Java代码封装起来，便于调用也便于重用
参考文献
1、Java语言程序设计主编：贾振华副主编：黄荣盛贾振旺
2、.baidu. 查询相关资料
3、王克宏.Java技术及其应用北京：高等教育，1994
4、林邦杰，彻底研究Java2。

北京：电子工业，2002
5、温平进、威等。

Instant Java2 实例解析。

北京：北京希望电子，2002
6、林建铭.精通Java2.北京：科学，2001
7、王胜捷.Java程序设计。

北京：中国铁道，2002
8、东方华人.Java2入门与提高.北京：清华大学，2000
9、洪威恩.Java2面向对象程序设计.北京：中国铁道 2002
10、杜江、应逵。

Java2实例教程.北京：清华大学，2003
11、金勇化、曲俊生等.Java网络高级教程.北京：北京希望电子，2002
12、利国.Java实用案例教程。

北京：清华大学， 2003
13、一林.Java语言程序设计.北京：清华大学，2001
14、殷兆麟.Java语言程序设计.北京：高等教育，2002
15、殷兆麟..Java网络编程基础.北京大学，2004
16、教育部考试中心.全国计算机等级考试大纲（2004年）版.北京：高等教育，2004
17、燕.Java程序设计培训教程.北京：清华大学，2002
附录（代码）
import java.util.*;
import java.io.*;
import java.awt.*;
import java.awt.event.*;
import java.applet.*;
import javax.swing.*;
class Gobang extends JFrame implements Runnable, ActionListener{
final static int Player=1;
final static int AI =-1;
ClassLoader cl = this.getClass().getClassLoader();
Toolkit tk = Toolkit.getDefaultToolkit();
int length=14, game_state, winner, check, step;
int grid[][] = new int[length][length];
int locX, locY /* 囱竚 */, count /* 硈囱计 */, x, y /* 既竚 */,
displace_x=0, displace_y=0 /* 簿秖 */, direction;
ArrayList steps = new ArrayList(); /* 癘魁囱˙ */
JPopupMenu control_menu = new JPopupMenu(); /* 龄匡虫 */
JMenuItem[] command = new JMenuItem[4];
String[] command_str={"囱", "郎", "弄郎", "秨"};
int[][] dir = { {-1, -1}, {-1, 0}, {-1, 1}, {0, -1}, {0, 1}, {1, -1}, {1, 0}, {1, 1} };
boolean[] dir2 = new boolean[8];
boolean turn;
String message;
final JDialog dialog = new JDialog(this, "叫匡", true);
Font font=new Font("new_font", Font.BOLD, 20);
Grid grids[][] = new Grid[length][length];
Image
white= tk.getImage(cl.getResource("res/white.png"));
Image
black= tk.getImage(cl.getResource("res/black.png"));
Image title= tk.getImage(cl.getResource("res/title.png"));
Image temp;
JPanel boardPanel, bigpanel;
JRadioButton[] choice = new JRadioButton[2];
final static int Start =0;
final static int Select =1;
final static int Playing =2;
final static int End =3;
final static int nil=-1; /* 礚よ */
final static int oblique_1 =0; /* オ */
final static int oblique_2 =1; /* オ */
final static int horizontal =2; /* 绢 */
final static int vertical=3; /* */
Gobang ( ){
super("き囱");
boardPanel = new JPanel();
boardPanel.setLayout(new GridLayout(length, length, 0, 0)); boardPanel.setComponentOrientation(ComponentOrientation.RIGHT_TO_LEF T);
for(int i=0; i<length; i++)
for(int j=0; j<length; j++) {
grids[i][j] = new Grid(i, j);
boardPanel.add(grids[i][j]);
}
bigpanel = new JPanel();
bigpanel.add(boardPanel, BorderLayout.CENTER);
getContentPane().add(bigpanel, BorderLayout.SOUTH);
game_state=Start;
ThreadStart();
dialog.setSize(160, 100);
dialog.setResizable(false);
dialog.setLocationRelativeTo(null);
ButtonGroup choice_group = new ButtonGroup();
JPanel choice_menu = new JPanel();
choice[0] = new JRadioButton("堵", new ImageIcon(black), true);
choice[1] = new JRadioButton("フ", new ImageIcon(white));
for(int i=0; i<choice.length; i++) {
choice_menu.add(choice[i]);
choice_group.add(choice[i]); }
for(int i=0; i<command.length; i++){
command[i] =new JMenuItem(command_str[i]);
command[i].addActionListener(this);
control_menu.add(command[i]);}
JButton select = new JButton("絋﹚");
JPanel select_menu = new JPanel();
select_menu.add(select);
select.addActionListener(this);
dialog.getContentPane().add(choice_menu, BorderLayout.NORTH);
dialog.getContentPane().add(select_menu, BorderLayout.CENTER);
setIconImage(title);
setResizable(false);
setSize(300, 335);
setVisible(true);
setLocationRelativeTo(null); }
public static void main(String[] arg) {
Gobang application = new Gobang(); application.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); }
public void actionPerformed(ActionEvent event) {
if( event.getSource().equals(command[0]) ) {
if(steps.size()!=0)
undo();
}
else if(event.getSource().equals(command[1]) )
Save();
else if(event.getSource().equals(command[2]) )
Load();
else if(event.getSource().equals(command[3]) )
ReStart();
else
{
if(choice[1].isSelected())
{
temp=white; white=black; black=temp; }
dialog.dispose(); } }
public void WinCheck() {
check = turn? Player: AI;
direction=oblique_1;
WinCheck2(); }
public void WinCheck2() {
count=1;
switch(direction) {
case oblique_1: displace_x=1;
displace_y=-1;
direction=oblique_2;
break;
case oblique_2: displace_x=displace_y=1;
direction=horizontal;
break;
case horizontal: displace_x=1;
displace_y=0;
direction=vertical;
break;
case vertical: displace_x=0;
displace_y=1;
direction=nil;
break; }
x=locX+displace_x;
y=locY+displace_y;
while(x>=0 && x<length && y>=0 && y<length && grid[x][y]==check) { count=count+1;
x=x+displace_x;
y=y+displace_y; }
x=locX-displace_x;
y=locY-displace_y;
while(x>=0 && x<length && y>=0 && y<length && grid[x][y]==check) { count=count+1;
x=x-displace_x;
y=y-displace_y; }
if(count>=5) {
game_state=End;
winner=check;
ThreadStart();
}
else if(direction!=nil)
WinCheck2(); }
public void ReStart() {
for(int i=0; i<length; i++)
for(int j=0; j<length; j++)
grids[i][j].Initial();
winner=0;
steps.clear();
game_state=Playing; }
public void gobangRandom() {
displace_y=0;
do
{ displace_x=(int)(Math.random()*8);
x =locX+dir[displace_x][0];
y =locY+dir[displace_x][1];
if(!dir2[displace_x])
{
displace_y=displace_y+1;
dir2[displace_x]=true;
}
}while((x<0 || x>=length || y<0 || y>=length || grid[x][y]!=0) && displace_y<8);
for(int i=0; i<8; i++)
dir2[i]=false;
if(x>=0 && x<length && y>=0 && y<length && grid[x][y]==0)
setMark(x, y);
else
gobangRandom2(); }
private void gobangRandom2() {
do {
x=(int)(Math.random()*length);
y=(int)(Math.random()*length);
}while(grid[x][y]!=0);
setMark(x, y);
}
private void gobangAI()
{
boolean play=true;
for(int i=2; i>0; i--) {
play=!play;
gobangAI4(play);
if(turn)
return;
}
for(int i=7; i>=4; i--)
{
play=!play;
step=i/2;
gobangAI2(play);
if(turn)
return;
}
gobangAI5();
if(!turn)
gobangRandom();
}
private void gobangAI2(boolean player) {
check = player? Player: AI;
for(int i=0; i<length; i++)
for(int j=0; j<length; j++) {
if(turn)
break;
if(grid[i][j] == check)
{
count=1;
direction=oblique_1;
gobangAI3(i, j);
} } }
private void gobangAI3(int x, int y)
{ if(count==1) {
locX=x;
locY=y;
}
switch(direction)
{
case oblique_1: displace_x=1;
displace_y=-1;
break;
case oblique_2: displace_x=displace_y=1;
break;
case horizontal: displace_x=1;
displace_y=0;
break;
case vertical: displace_x=0;
displace_y=1;
break;
}
x=x+displace_x;
y=y+displace_y;
if(x>=0 && x<length && y>=0 && y<length && grid[x][y]==check)
{
count=count+1;
if(count==step)
{
if(x+displace_x>=0 && x+displace_x<length && y+displace_y>=0 && y+displace_y<length && grid[x+displace_x][y+displace_y]==0)
{
if(x-step*displace_x<0 || x-step*displace_x>=length || y-step*displace_y<0 || y-step*displace_y>=length || !gobang_SpaceAI(x+displace_x, y+displace_y) || (grid[x-step*displace_x][y-step*displace_y]!=0 && step<3) ) /* 癸翴
猵 */
gobangAI3_2();
else
setMark2(x+displace_x, y+displace_y); }
else
gobangAI3_2(); }
else
gobangAI3(x, y); }
else
gobangAI3_2(); }
private void gobangAI3_2() {
if(direction!=vertical) {
count=1;
direction=direction+1;
gobangAI3(locX, locY); } }
private void gobangAI4(boolean player) {
check = player? Player: AI;
for(int i=0; i<length; i++)
for(int j=0; j<length; j++) {
if(turn)
break;
if(grid[i][j]==0) {
direction=oblique_1;
locX=i;
locY=j;
gobangAI4();
}
}
}
private void gobangAI4() {
count=0;
switch(direction) {
case oblique_1: displace_x=1;
displace_y=-1;
direction=oblique_2;
break;
case oblique_2: displace_x=displace_y=1;
direction=horizontal; break;
case horizontal: displace_x=1;
displace_y=0;
direction=vertical;
break;
case vertical: displace_x=0;
displace_y=1;
direction=nil;
break; }
x=locX+displace_x;
y=locY+displace_y;
while(x>=0 && x<length && y>=0 && y<length && grid[x][y]==check) { count=count+1;
x=x+displace_x;
y=y+displace_y;
}
x=locX-displace_x;
y=locY-displace_y;
while(x>=0 && x<length && y>=0 && y<length && grid[x][y]==check) { count=count+1;
x=x-displace_x;
y=y-displace_y; }
if(count>=4)
setMark(locX, locY);
else if(direction!=nil)
gobangAI4(); }
private void gobangAI5() {
for(int i=0; i<length; i++)
for(int j=0; j<length; j++) {
if(turn)
break;
if(grid[i][j]==-1) {
direction=oblique_1;
locX=i;
locY=j; gobangAI5_2(); } }}
private void gobangAI5_2() {
count=0;
switch(direction){
case oblique_1: displace_x=1;
displace_y=-1;
direction=oblique_2;
break;
case oblique_2: displace_x=displace_y=1;
direction=horizontal;
break;
case horizontal: displace_x=1;
displace_y=0;
direction=vertical;
break;
case vertical: displace_x=0;
displace_y=1;
direction=nil;
break; }
x=locX+displace_x;
y=locY+displace_y;
while(x>=0 && x<length && y>=0 && y<length && grid[x][y]==0 && count<4) {
count=count+1;
x=x+displace_x;
y=y+displace_y;
}
x=locX-displace_x;
y=locY-displace_y;
if(count==4 && x>=0 && x<length && y>=0 && y<length && grid[x][y]==0) setMark(locX+displace_x, locY+displace_y);
else if(count>1) {
count = count==4? 3: count;
while(x>=0 && x<length && y>=0 && y<length && grid[x][y]==0 && count<4) {
count=count+1;
x=x-displace_x;
y=y-displace_y; }
if(count==4)
setMark(locX+displace_x, locY+displace_y);
else if(direction!=nil)
gobangAI5_2(); }
else if(direction!=nil)
gobangAI5_2(); }
private boolean gobang_SpaceAI(int x, int y) /* 璸衡逞緇フ竚 */
{ int space=0;
do
{ space=space+1;
x=x+displace_x;
y=y+displace_y;
}while(x>=0 && x<length && y>=0 && y<length && grid[x][y]==0 && space<4); if(space+count>=5) /* 逞緇フ场だΤ硈絬ぇ */
return true;
else
{
space=0;
x=locX-displace_x;
y=locY-displace_y;
while(x>=0 && x<length && y>=0 && y<length && grid[x][y]==0 && space<4) {
space=space+1;
x=x-displace_x;
y=y-displace_y;
}
if(space+count>=5) /* 逞緇フ场だΤ硈絬ぇ */
return true;
else
return false;
}
}
public void ThreadStart() {
new Thread(this).start(); }
private void setMark(int x, int y) {
steps.add(grids[x][y]);
grids[x][y].setValue(-1);
WinCheck();
turn=true;
}
/* 璸衡êよΤ隔 */
private void setMark2(int x, int y) {
int space=0, temp_x=x, temp_y=y;
do {
space=space+1;
temp_x=temp_x+displace_x;
temp_y=temp_y+displace_y; }
while(temp_x>=0 && temp_x<length && temp_y>=0 && temp_y<length && grid[temp_x][temp_y]==0 && space<4);
if(space+step>=5)
setMark(x, y);
else
setMark(x-(step+1)*displace_x, y-(step+1)*displace_y); }
public void run() {
try {
switch(game_state) {
case Start: Thread.sleep(2000);
dialog.show();
game_state=Playing;
repaint();
break;
case End: repaint();
Thread.sleep(1500);
ReStart();
repaint();
break; } }
catch(InterruptedException ex)
{ }
}
public void paint(Graphics g) {
super.paint(g);
switch(game_state) {
case Start: g.drawString("2005.7 by Yu Lin Tao", 91, 240);
g.setFont(font);
g.setColor(Color.BLUE);
g.drawString("Gobang", 112, 120);
g.drawImage(title, 134, 135, this);
break;
case Playing:
case End:
g.drawString("產: 筿福:", 105, 40);
g.drawImage(black, 132, 30, this);
g.drawImage(white, 182, 30, this);
if(winner!=0) {
g.setFont(font);
g.setColor(Color.RED);
message = winner==1? "墓":"块";
g.drawString(message, 120, 185); }
break; } ｝
public void undo() {
if(steps.size()>0) {
for(int i=0; i<2; i++) {
((Grid)steps.get(steps.size()-1)).Initial();
steps.remove(steps.size()-1) } } }
private void Save() {
String str;
try {
File file = new File("innings.men");
file.createNewFile();
BufferedWriter write = new BufferedWriter(new FileWriter(file));
for(int i=0; i<steps.size(); i++) { str=(((Grid)steps.get(i)).getLocX())+","+(((Grid)steps.get(i)).g etLocY())+","+(((Grid)steps.get(i)).getValue());
write.write(str);
write.newLine();
}
write.close(); }
catch(Exception ex) { } }
private void Load() {
try {
String[] step_array;
String str;
File file = new File("innings.men");
if(!file.exists()) {
JOptionPane.showMessageDialog(null, "⊿Τ郎");
return;
}
BufferedReader read = new BufferedReader(new FileReader(file));
ReStart();
while(read.ready()) {
str=read.readLine();
step_array=str.split(",");
grids[Integer.parseInt(step_array[0])][Integer.parseInt(step_array[1] )].setValue(Integer.parseInt(step_array[2]));
steps.add(grids[Integer.parseInt(step_array[0])][Integer.parseInt(ste p_array[1])]); } }
catch(Exception ex)
{ } }
private class Grid extends JPanel implements MouseListener {
int x, y, value;
boolean selected;
public Grid(int x, int y) {
this.x=x;
this.y=y;
addMouseListener(this); }
public void mousePressed(MouseEvent event) {
if(game_state==Playing) {
int button=event.getButton();
if(button==MouseEvent.BUTTON1) {
if(value==0) {
steps.add(this);setValue(1); WinCheck();
turn=false;
if(game_state==Playing)
gobangAI(); } }
else
control_menu.show(this, event.getX(), event.getY()); } }
public void mouseEntered(MouseEvent event) {
if(game_state==Playing)
setSelected(true); }
public void mouseExited(MouseEvent event) {
if(game_state==Playing)
setSelected(false); }
public void mouseClicked(MouseEvent event) { }
public void mouseReleased(MouseEvent event) { }
public Dimension getPreferredSize() {
return new Dimension(20, 20)；}
public Dimension getMinimumSize() {
return getPreferredSize(); }
public int getLocX() { return x; }
public int getLocY() { return y; }
public int getValue() { return value; }
public void Initial() {
value=grid[x][y]=0;
selected=false;
repaint();
}
public void setValue(int new_value) {
locX=x;
locY=y;
value=grid[x][y]=new_value;
repaint();
}
public void setSelected(boolean select) {
selected=select;
repaint();
}
public void paintComponent(Graphics g)
{
super.paintComponent(g);
if(game_state!=Start && game_state!=Select)
{
g.drawLine(0, 10, 19, 10);
g.drawLine(10, 0, 10, 19);
g.setColor(Color.BLUE);
if(x==0)
g.drawLine(0, 0, 19, 0);
else if(x==length-1)
g.drawLine(0, 19, 19, 19);
if(y==0)
g.drawLine(19, 0, 19, 19);
else if(y==length-1)
g.drawLine(0, 0, 0, 19);
if(selected)
setBackground(Color.WHITE);
else
setBackground(Color.LIGHT_GRAY);
}
//g.drawString(x+" "+y, 1, 10);
if(value!=0) {
temp = value==1? black: white; g.drawImage(temp, 4, 4, this); } }
《Java程序设计》课程设计任务书一、课题设计名称
1. 小型记事本的设计与实现
2. 学生成绩管理的设计与实现
3. 五子棋双人对弈程序的设计与实现
4. 扫雷程序的设计与实现
5. 广告屏的设计与实现6．计算器的设计与实现
二、课题设计目的
通过课程设计，使学生巩固所学知识、培养学生动手能力。

学生用Java语言设计一个完整的应用程序，综合应用所学知识完成软件的分析、设计、调试和总结，提高学生对Java 语言的综合应用能力和解决问题的能力。

三、任务要求：
用Java语言开发工具（例如JDK、Jcreator、NetBeans等）制作一个简单的可运行的完整的应用程序或小型系统，按照程序设计的观点，先做需求分析，总体设计、详细设计，
然后编写代码，尔后进行测试，并编制出各阶段必要的文档。

在编写文档时，必须严格遵照要求，最后交出文档。

功能要求：各题目的具体功能要求见附录。

最后要求提交详细的课程设计报告，现场运行验收应用程序。

四、课题设计报告书要求：
1、课题设计报告书第一页为封面，封面上写清楚标题、班级、、指导老师、完成日期，
格式自己设计。

2、课题设计报告书第二页为本任务书。

3、课题设计报告书第三页为教师评语。

4、课题设计报告书第四页为目录。

5、课题设计报告书第五页开始为具体容：
（1）开发背景
（2）系统分析部分
1）功能描述
2）功能结构图
3）软件环境介绍
* 4）数据库设计
*5）数据库访问方法（3）系统设计部分
1）系统整体设计 2）文件架构导航图 3）模块设计
4）用户界面设计 5）处理流程图（4）重要代码编写
6、课题设计报告书最后一页是本次课程设计的小节和参考文献。

7、字数要求不少于3000字。

8、打印纸使用B5纸，页边距设为上、下、左2厘米，右1.5厘米，
五、如有雷同，将作不及格处理。

六、完成时间 2009.7.2
计算机工程
尚敬。