java版的贪吃蛇毕业论文
贪吃蛇
姓名：
摘要：
本文用J2SE 实现大家耳熟能详的一个贪吃蛇游戏来综合运用所学知识，本游戏运用软件工程思想（螺旋模型），打好游戏主体框架，JA V A 的面向对象思想，封装类，接口等概念，来完成本游戏，打到综合运用知识的目的。 ⑴．本游戏开发平台：WINXP ； ⑵．JA V A 开发环境: JDK1.6 +Eclipse； ⑶．开发语言：J2SE 关键词：
中央控制器; 游戏面板; 食物; 蛇; 石头
The Greed Snake
Abstract ： In this paper, J2SE implementation of a Snake game familiar to the integrated use
of what they have learned, this game is the use of software engineering thinking (spiral model), the main framework of the fight game, JA V A object-oriented thinking, wrapper classes, interface concepts to complete this game, hitting the integrated use of knowledge and purpose. ⑴. The game development platform: WINXP;
⑵. JAV A Development Environment: JDK1.6 + Eclipse; ⑶. Development Languages: J2SE
Keywords ：Controller;GamePanel;Food;Snake;Ground
前言
贪吃蛇游戏背景：
蛇引诱夏娃吃了苹果之后，就被贬为毒虫，阴险的象征。 而蛇吃东西是整只动物吞进去的，大概在文艺复兴的时候（好象是那个时候但是不确定）就有人发明的一种游戏，是现在贪吃蛇的前身。后来慢慢的发展就变成了今天的贪吃蛇了、现在贪吃蛇主要应用于手机游戏。
本文运用软件工程思想、JAVA 面向对象编程、类的封装、抽象类的使用（接口），游戏编码规范遵循MVC 模式，循序渐进实现贪吃蛇的相关功能。
一 ：游戏中的面向对象分析与设计 ㈠ ●涉及到几个对象（类） ㈡ ●每个类有什么方法
1 . 首先得有个游戏显示面板(GamePanel)类 该类有一个方法void display(); //用来显示游戏面板 2 . 得有个蛇(Snake)类 该类有以下几个方法:
void move(); //移动（走一步） void changeDirection(); //改变方向 void eatFood(); //吃食物（身体变长）
voolean is EatBody();//蛇是否吃到了自己的身体 void drawMe();//显示 3 . 一个食物类（Food ）类 该类有以下方法:
boolean is SnakeEatFood(Snake); //判断蛇是否吃到了食物 void drawMe();//显示
4 . 一个背景石头（Ground ）类 该类有以下方法：
Boolean isSnakeEatRock(Snake); //蛇是否吃到了石头 void drawMe();//显示
此时类之间的关系如下图所示：
图1 各个类之间的关系
二 ： 编写贪吃蛇游戏中的各个类的主体框架性代码
本有序遵循MVC （Model-View-Controller ）所以首先建立以上几个实体类并定义相应的包名：liang.snake.entities 包下定义Food 、Ground 、Snake 三个类，再在liang.snake.view 包下定义GamePanel 类，再在，按照以上说明的各个类具有的方法，写上如下代码：
package liang.snake.entities; public class Food { }
package liang.snake.entities;
public class Ground {
public boolean isSnakeEatRock()
public boolean isSnakeEatFood(Snake snake) {
System.out .println("Snake's eat food"); return false ; }
public void drawme() {
System. out .println("Food's drawme"); }
{
return false ;
} }
package liang.snake.entities;
public class Snake {
public void move() public void drawme() {
System. out .println("Ground's drawme"); }
{
System.out .println("Snake's move"); }
public void changeDirection(int direction) {
System.out .println("Snake's changeDirection"); }
public void eatFood() {
System.out .println("Snake's eat food"); }
public boolean isEatBody() {
System.out .println("Snake's eat body"); return false ; }
public void drawMe(){
System.out .println("Snake's drawMe"); }
package liang.snake.view;
import java.awt.Graphics; import javax.swing.JPanel;
import liang.snake.entities.Food; import liang.snake.entities.Ground; import liang.snake.entities.Snake; public class GamePanel extends JPanel{ private Snake snake ; private Ground ground ; private Food food ;
public void paintComponent(Graphics g) { snake .drawMe(); ground .drawme(); food .drawme(); }
public void display(Snake snake,Ground ground,Food food)
{
this . snake =snake; this . ground =ground; this . food =food;
System.out .println("GamePanel's display"); this .repaint(); }
三 ： 编写Controler 类与实现蛇移动的事件监听
由于蛇不能直接操作显示面板（GamePanel ）所以这里定义一个监听器SnakeListener:里面定义一个方法：
void snakeMove(Snake); 每当蛇移动一步就触发监听器，调用snakeMoved()由Controller 去实现监听器的接口，然后由控制器去触发显示面板的事件源，让显示面板完成相应操作。 逻辑图如下：
图2 事件监听建立联系
在Snake 中增加蛇的方向常量：
public static final int UP =1; public static final int DOWN =-1; public static final int LEFT =2; public static final int RIGHT =-2;
并添加一个接口：
package liang.snake.Listener; import liang.snake.entities.Snake;
Controler 实现SnakeListener 接口并处理案件消息：代码如下: package liang.snake.Controller; import java.awt.event.KeyAdapter; import java.awt.event.KeyEvent;
import liang.snake.Listener.SnakeListener; import liang.snake.entities.Food; import liang.snake.entities.Ground; import liang.snake.entities.Snake;
public interface SnakeListener { }
public void SnakeMove(Snake snake);
import liang.snake.view.GamePanel;
public class Controller extends KeyAdapter implements SnakeListener{
Snake snake =new Snake(); Ground ground =new Ground();
Food food =new Food();
GamePanel gamepanel =new GamePanel();
public Controller(Snake snake, Ground ground, Food food, GamePanel gamepanel) {
}
this . snake = snake; this . ground = ground; this . food = food;
this . gamepanel = gamepanel;
public void keyReleased(KeyEvent e) {
}
switch (e.getKeyCode()) {
case KeyEvent.VK_UP :
snake .changeDirection(Snake.UP); break ;
case KeyEvent.VK_DOWN :
snake .changeDirection(Snake.DOWN); break ;
case KeyEvent.VK_LEFT :
snake .changeDirection(Snake.LEFT); break ;
case KeyEvent.VK_RIGHT : }
snake .changeDirection(Snake.RIGHT); break ;
public void newgame() { }
public void SnakeMove(Snake snake) { snake .start();
gamepanel .display(snake,ground , food ); }
开发到此时，Snake 中应该增加监听器，并另启动一个线程来不断调用蛇的move();在Snake 中提供一个启动线程的方法，在Snake 中增加如下代码： private Set listener =new HashSet();
public void addSnakeListener(SnakeListener l) {
if (l!=null ) } }
public void start() {
new Thread(new SnakeDriver()).run(); }
并在Run 方法中增加
this . listener .add(l);
}
for (SnakeListener l: listener ) {
l.SnakeMove(Snake.this );
}
try { }
catch (InterruptedException e) {
Thread.sleep(1000);
}
四 ：编写对各个类进行测试的程序代码 构建一个新类Game 来测试程序代码： package liang.snake.Game; import java.applet.AudioClip; import java.awt.BorderLayout; import java.io.File;
import java.net.MalformedURLException; import java.net.URL; import javax.swing.JFrame;
import liang.snake.Controller.Controller; import liang.snake.entities.Food; import liang.snake.entities.Ground; import liang.snake.entities.Snake; import liang.snake.view.GamePanel; public class Game {
public static void main(String[] args) {
JFrame jf=new JFrame(" 我的论文" ); Snake snake=new Snake();
Ground ground=new Ground(); Food food=new Food();
GamePanel gamepanel=new GamePanel();
Controller controller=new Controller(snake, ground,
food, gamepanel);
jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); jf.setLocation(400, 0); jf.setSize(800, 600);
jf.add(gamepanel);
jf.addKeyListener(controller); snake.addSnakeListener(controller); jf.setVisible(true );
}
}
运行这个带有main()的类，在Eclipse 的Console 窗口中可以看到如下信息： Snake's move
GamePanel's display Snake's drawMe Ground's drawme Food's drawme Snake's drawMe Ground's drawme Food's drawme Snake's move
GamePanel's display Snake's drawMe Ground's drawme Food's drawme
这就意味着，当蛇移动一次，就触发监听器，有控制器(controller)给GamePanel 发送指令，让它重画，GamePanel 中的
public void display(Snake snake,Ground ground, Food food) {
System.out .println("GamePanel's display"); this . snake =snake; this . ground =ground; this . food =food; this .repaint(); }
这个方法依次画出几个实体，所以打印出上述信息。到了这一步我们的基本框架打好了，下面开始第5步
五 ： 蛇的数据结构设计与移动显示 分析：
要区分蛇头和蛇尾巴，这就要求这个数据结构是有序的，
还要经常访问第一个和最后一个节点，所以LinkedList 最合适，因为它有getFirst(),getLast()方法和removeLast()方法
蛇下一步移动到哪是由方向控制的，前面已经定义过，蛇透坐标如下图：
图3 蛇头方向计算新蛇头坐标
在Snake 的 move()中增加
body .removeLast();
int x=body .getFirst().x ; int y=body .getFirst().y ; switch (direction) {
case UP : y--;
break ;
case DOWN : y++;
break ;
case LEFT : x--;
break ;
case RIGHT :
}
break ;
Point newhead=new Point(x,y); //加头
body .addFirst(newhead); 并定义 private int direction ;
为了能更方便的维护游戏，这里定义Global 类来定义常量如下： package liang.snake.Global; public class Global { }
并修改游戏中窗口大小为：
jf.setSize(Global.CELL_SIZE*Global.WIDTH ,Global. CELL_SIZE*Global. HIGHT );
再加上如下代码，对蛇初始化： public Snake()
{ }
public void init() {
int x=Global.WIDTH /2; int y=Global.HIGHT /2; int nodenum=3;
for (int i=0;i
body .addFirst(new Point(x++,y)); init();
public static final int CELL_SIZE=20; public static int HIGHT =30; public static int WIDTH =30;
}
this . direction =RIGHT ;
在蛇的drawMe(Graphics g)中些上如下让蛇显示的代码： 这里的画图采用填充3D 矩形来实现： for (Point p:body ) {
g.fill3DRect(p.x *Global.CELL_SIZE,
p. y *Global.CELL_SIZE, Global.CELL_SIZE, Global.CELL_SIZE, true ); }
画图的规则如下图：
图4 计算格子坐标和像素坐标
此时运行Game 类就可以看到蛇显示在面板中了，如图：
图5 显示面板显示的蛇
但是蛇越走越长，是因为没有擦除以前的图像，在GamePanel paintComponent(Graphics g)中添加如下代码：
的
g.setColor(new Color(0xcfcfcf));
g.fill3DRect(0,
0,Global. CELL_SIZE*Global.WIDTH
,
Global. CELL_SIZE*Global.HIGHT , true ); 此时蛇就可以正常移动了如图：
图6 移动中的蛇
通过按键改变移动方向，此时的蛇身体节点显示为白色，我们再在蛇的绘制方法中位器指定颜色：代码如下：
图7 指定颜色后的蛇
六 ： 试与修正蛇的移动与显示问题
此时的蛇当移动到窗口边界的时候就能走出窗口还有蛇可以穿过自己的身体，这些游戏规则中式不允许的， 下面来修正这些问题, 修改Snake 中的move()方法如下： 首先定义public int olddirection , newdirection ; 防止蛇穿过自己身体： public void move() { //去尾
if (olddirection +newdirection !=0) { }
body .removeLast();
int x=body .getFirst().x ;
olddirection =newdirection ;
int y=body .getFirst().y ;
switch (olddirection ) {
case UP :
y--; if (y
y=Global.HIGHT -1;
case DOWN :
y++;
if (y>=Global.HIGHT ) { } break ;
y=0;
case LEFT :
x--; if (x
x=Global.WIDTH -1;
case RIGHT :
x++;
if (x>=Global.WIDTH ) { }
x=0 ;
}
Point newhead=new Point(x,y); //加头
body .addFirst(newhead);
System.out .println("Snake's move"); }
public void changeDirection(int direction) {
System.out .println("Snake's changeDirection"); newdirection =direction; 并修改蛇的初始化方法如下：
olddirection =newdirection =RIGHT ; 此时就修正了上面的问题，可以运行Game 类来测试下 七 ： 编写与测试表示食物的类并实现吃食物 首先在Snake 类中添加 public Point getHead() {
return body .getFirst(); }
用来获取头结点, 然后再Food 类中写上如下代码： package liang.snake.entities; import java.awt.Color; import java.awt.Graphics; import java.awt.Point;
import liang.snake.Global.Global; public class Food extends Point{
public void newfood(Point p) {
this .setLocation(p); }
public boolean isSnakeEatFood(Snake snake) {
System.out .println("Snake's eat food"); return this .equals(snake.getHead()); }
public void drawme(Graphics g) {
System. out .println("Food's drawme");
g.fill3DRect(this . x *Global.CELL_SIZE, this . y *Global.CELL_SIZ
E , Global.CELL_SIZE, Global.CELL_SIZE, true ); } }
此时就可以画出食物并判断蛇是否吃到了食物, 接下来就可以在Controller 中处理吃食物的代码，吃了食物我们只要把先前移动去除的尾巴再给加上就实现了蛇吃食物身体变长的效果了，如下： 定义Point oldTail ；
在蛇move()中保存去除的尾巴：oldTail = body .removeLast(); 在Controller 中的SnakeMove(Snake snake)中添加 if (food .isSnakeEatFood(snake)) {
snake.eatFood();
food .newfood(ground .getPoint());
}
并在Snake 中的eatFood()中增加如下代码： body .addLast(oldTail );
此时要运行游戏依赖与下一步的石头处理中的getPoint()方法实现随机产生食物下面开始继续开发：
八 ： 为游戏增加作为障碍物的石头
这里添加石头我们用2维数组来表示，置1则为石头，否则为空，在Ground 类中写上如下代码：
package liang.snake.entities; import java.awt.Color; import java.awt.Graphics;
import java.awt.Point; import java.util.Random;
import liang.snake.Global.Global; public class Ground {
private static int [][] rocks = new int
[Global.WIDTH ][Global.HIGHT ];
public static Color shitou =null ; public Ground() { }
public void clear() {
for (int x = 0; x
for (int y = 0; y
public boolean isSnakeEatRock(Snake snake) {
for (int x=0;x
for (int y=0;y
if (rocks [x][y]==1&&
x==snake.getHead().x &&
for (int x=0;x
{ }
rocks [x][0]=1;
rocks [x][Global.HIGHT -1]=1;
shitou =Color.RED ;
y==snake.getHead().y ) {
return true ;
}
}
}
return false ; }
public static Point getPoint() { Random random=new Random(); int x=0,y=0; do {
x=random.nextInt(Global.WIDTH ); y=random.nextInt(Global.HIGHT );
}while (rocks [x][y]==1); return new Point(x,y);
}
public void drawme(Graphics g) { System.out .println("Ground's drawme"); for (int x=0;x
g.fill3DRect(x*Global.CELL_SIZE,
y*Global.CELL_SIZE, Global.CELL_SIZE, Global.CELL_SIZE,
}
}
}
true );
}
再在各个调用方法中填上相应参数，运行Game 类，效果如图：
图8 添加了食物、石头后的图
为窗口数值大小增加35PX 因为此时的窗口标题栏占用了些空间，导致下面的石头没有显示出来，修改Game 类中的
jf.setSize(Global.CELL_SIZE*Global.WIDTH +10,Global.CELL_SIZE*Global. HIGHT +35);再测试，效果显示完全正常下面继续开发： 九 ： 为蛇增加吃到石头而死掉的功能
这里我们采用吃食物一样的方式，当舌头的坐标与石头重合时，就让蛇死掉，至于蛇死掉我们只需要将Snake 中的县城结束掉即可，所以我们在Snake 中定义boolean life=true;
当蛇头坐标与石头坐标重合的时候只要将此变量设置为false, 用life 作为蛇线程的循环条件，具体代码如下：
定义蛇的die 方法 public void die() {
life =false ;
JOptionPane.showMessageDialog(Game.jf, " 您控制的蛇因为意外死亡, 呜呼哀哉，死的可真惨啊~~", " 游戏结束" , 2); System.out .println("The snake is dead"); }
并将Game 类中的public static JFrame jf =new JFrame(" 我的论文" ); 放到main 方法前面，下面测试游戏，如下图：
图9 蛇吃到食物后死亡
当蛇吃到石头就死亡了！
十 ： 为蛇增加吃到蛇身而死掉的功能：
同样我们用舌头去便利蛇身体，当舌头鱼蛇身体重合时则调用蛇的die();代码如下： 修改Snake 中
public boolean isEatBody()
{
System.out .println("Snake's eat body");
for (int i=1;i
{
}
return false ;
}
并在Controller 中的SnakeMove(Snake snake)中增加如下代码：
if (snake.isEatBody())
{ } snake.die(); if (body .get(i).equals(this .getHead())) return true ;
运行游戏测试效果如下图所示：
图10 蛇吃到身体后死亡
到此时贪吃蛇的基本功能已经基本实现~由于篇幅有限只写到这，源码以及帮助文档附件我随后贴上！请读者参照我附上的文件包！！
结束语:通过上述游戏开发过程，我们对J2SE 的面向对象设计思想，抽象类的使用（接口）以及软件工程思想有了一次综合性的练习，设计游戏中遇到的逻辑错误，可以通过Eclipse 的Debug 来进行调试，培养我们的思维，逻辑能力。。。
参考文献： [1]张孝祥-JA V A 就业培训教程
[2]软件工程-西安电子科技大学出版社
[3]胡伏湘，雷军环．Java 程序设计实用教程．清华大学出版社，
2005.