看完马士兵的坦克大战之后写出来的，有些粗糙，但是基本功能算是实现了……
整个程序使用GUI实现，只要谈谈其中的算法吧：
    蛇不停移动的算法： 游戏开始的时候，蛇默认长度是5，每一节是装在一个集合里面的，移动的时候，蛇尾先移动到倒数第二节的位置，倒数第2节移动到倒数第三节的位置…… 直到第二节移动到蛇头的位置，最后一步就根据键盘的输入移动蛇头了，这样就完成了一次移动；
    如果向上移动，代码如下：
               if(up){
                        for(j=i-1;j>0;j--){
                                points.get(j).x = points.get(j-1).x;
                                points.get(j).y = points.get(j-1).y;
                        }
                        points.get(0).y -= 20;
                        j = i-1;
                }

    蛇的不停移动用一个不停循环的线程来实现：
               public class MThread implements Runnable{
                public void run(){
                        while(aLive){
                                move();
                                try{
                                        Thread.sleep(time);
                                }catch(InterruptedException e){
                                        e.printStackTrace();
                                }
                        }
                }
        }

     程序中一共有三个类：Snake(蛇类） 、Food(食物类)、 GreedSnake(游戏主程序)

    Snake代码如下：

1. import java.util.*;
   
2. import java.awt.*;
   
3. import java.awt.event.*;
   
4. 
   
5. class Snake{
   
6.         Point po = null;
   
7.         int size = 0;
   
8.         GreedSnake gs;
   
9.         private int time = 150;
   
10. 
    
11.         ArrayList<Point> points = new ArrayList<Point>();
    
12.         Point head;
    
13.         
    
14.         private int step = 0;
    
15.         private int scoreAdd = 0;
    
16.         private boolean up = false,down = false,left = false,right = false;
    
17.         private boolean aLive = true;
    
18.         private Rectangle rect = null;
    
19. 
    
20.         enum Direction {U,D,L,R};
    
21.         Direction dir = Direction.U;
    
22. 
    
23.         public Snake(Point po,int size,GreedSnake gs){
    
24.                 this.po = po;
    
25.                 this.size = size;
    
26.                 this.gs = gs;
    
27.                 for(int i=0;i<size;i++){
    
28.                         addPoint(po);
    
29.                         po.x-=20;
    
30.                         po = new Point(po.x,po.y);
    
31.                 }
    
32.                 new Thread(new MThread()).start();
    
33.         }
    
34. 
    
35.         public boolean isAlive(){
    
36.                 return this.aLive;
    
37.         }
    
38.                
    
39.         public void Live(boolean aLive){
    
40.                 this.aLive = aLive;
    
41.         }
    
42. 
    
43.         public void addPoint(Point p){
    
44.                 points.add(p);               
    
45.         }
    
46.         
    
47.         public void speedUp(){
    
48.                 time-=20;
    
49.         }
    
50. 
    
51.         public void directionReset(){
    
52.                 up = false; down = false; left = false; right = false;
    
53.         }
    
54.         //设置蛇在移动时不能反方向移动
    
55.         public void keyPressed(KeyEvent e){
    
56.                 if(up||down){
    
57.                         switch(e.getKeyCode()){
    
58. 
    
59.                         case KeyEvent.VK_UP :
    
60.                         break;
    
61.                         case KeyEvent.VK_DOWN :
    
62.                         break;
    
63.                         case KeyEvent.VK_LEFT :
    
64.                                 directionReset();
    
65.                                 left = true;
    
66.                         break;
    
67.                         case KeyEvent.VK_RIGHT :
    
68.                                 directionReset();
    
69.                                 right = true;
    
70.                         break;
    
71.                         }
    
72.                 }
    
73.                 if(left||right){
    
74.                         switch(e.getKeyCode()){
    
75. 
    
76.                         case KeyEvent.VK_UP :
    
77.                                 directionReset();
    
78.                                 up = true;
    
79.                         break;
    
80.                         case KeyEvent.VK_DOWN :
    
81.                                 directionReset();
    
82.                                 down = true;
    
83.                         break;
    
84.                         case KeyEvent.VK_LEFT :
    
85.                         break;
    
86.                         case KeyEvent.VK_RIGHT :
    
87.                         break;
    
88.                         }
    
89.                 }
    
90.                 if(!up&&!down&&!left&&!right){
    
91.                         switch(e.getKeyCode()){
    
92. 
    
93.                         case KeyEvent.VK_UP :
    
94.                                 directionReset();
    
95.                                 up = true;
    
96.                         break;
    
97.                         case KeyEvent.VK_DOWN :
    
98.                                 directionReset();
    
99.                                 down = true;
    
100.                         break;
     
101.                         case KeyEvent.VK_LEFT :
     
102.                         break;
     
103.                         case KeyEvent.VK_RIGHT :
     
104.                                 directionReset();
     
105.                                 right = true;
     
106.                         break;
     
107.                         }
     
108.                 }
     
109.         }
     
110.         
     
111.         //蛇的移动算法
     
112.         public void move(){
     
113.                
     
114.                 int i = points.size();
     
115.                 int j;
     
116.                
     
117.                 if(up){
     
118.                         for(j=i-1;j>0;j--){
     
119.                                 points.get(j).x = points.get(j-1).x;
     
120.                                 points.get(j).y = points.get(j-1).y;
     
121.                         }
     
122.                         points.get(0).y -= 20;
     
123.                         j = i-1;
     
124.                 }
     
125.         
     
126.                 else if(down){
     
127.                                        
     
128.                         for(j=i-1;j>0;j--){
     
129.                                 points.get(j).x = points.get(j-1).x;
     
130.                                 points.get(j).y = points.get(j-1).y;
     
131.                         }
     
132.                         points.get(0).y += 20;
     
133.                         j = i-1;
     
134.                 }        
     
135.                 else if(left){
     
136.                                 
     
137.                         for(j=i-1;j>0;j--){
     
138.                                 points.get(j).x = points.get(j-1).x;
     
139.                                 points.get(j).y = points.get(j-1).y;
     
140.                         }
     
141.                         points.get(0).x -= 20;
     
142.                         j = i-1;
     
143.                 }
     
144.                 else if(right){
     
145.                                        
     
146.                         for(j=i-1;j>0;j--){
     
147.                                 points.get(j).x = points.get(j-1).x;
     
148.                                 points.get(j).y = points.get(j-1).y;
     
149.                         }
     
150.                         points.get(0).x += 20;
     
151.                         j = i-1;
     
152.                 }
     
153.                
     
154.                 head = points.get(0);
     
155.                 rect = new Rectangle(head.x,head.y,20,20);
     
156.                 if(head.x<20||head.x>780|head.y<30||head.y>580){
     
157.                         aLive = false;
     
158.                 }
     
159.                 for(int t=1;t<points.size();t++){
     
160.                         if(head.x == points.get(t).x && head.y == points.get(t).y){
     
161.                                 aLive = false;
     
162.                         }
     
163.                 }
     
164. 
     
165.         }
     
166.         //蛇吃到食物时的处理
     
167.         public void eat(){
     
168.                 for(int i=0;i<gs.foods.size();i++){
     
169.                         if(rect.contains(gs.foods.get(i).x, gs.foods.get(i).y) &&gs.foods.get(i).isAlive()){
     
170.                                 gs.foods.get(i).setAlive(false);
     
171.                                 gs.foods.remove(i);
     
172.                                 grow();
     
173.                         }
     
174.                 }
     
175.         }
     
176. 
     
177.         public void grow(){
     
178.                 Point lastPoint = points.get(points.size()-1);
     
179.                 Point newEnd = new Point(lastPoint.x,lastPoint.y);
     
180.                 addPoint(newEnd);
     
181.                 if(step == 5) {
     
182.                         speedUp();
     
183.                         scoreAdd+=3;
     
184.                         step = 0;
     
185.                 }
     
186.                 step++;
     
187.         }
     
188. 
     
189.         public void paint(Graphics g){
     
190.                 Color c = g.getColor();
     
191.                 g.setColor(Color.GREEN);
     
192.                 g.drawString(" head area:"+head.x+","+head.y,30,50);
     
193.                 g.drawString(" scores:"+(points.size()-5)*(5+scoreAdd),30,70);
     
194.                 Iterator<Point> i = points.iterator();
     
195.                 while(i.hasNext()){
     
196.                         Point p = i.next();
     
197.                         g.setColor(Color.GREEN);
     
198.                         g.fillRect(p.x,p.y,20,20);
     
199.                         g.setColor(Color.YELLOW);
     
200.                         g.fillOval(p.x,p.y,20,20);
     
201.                 }
     
202.                 g.setColor(c);
     
203.                 eat();
     
204.         }
     
205. 
     
206.         //创建一个线程让蛇不停地移动
     
207.         public class MThread implements Runnable{
     
208.                 public void run(){
     
209.                         while(aLive){
     
210.                                 move();
     
211.                                 try{
     
212.                                         Thread.sleep(time);
     
213.                                 }catch(InterruptedException e){
     
214.                                         e.printStackTrace();
     
215.                                 }
     
216.                         }
     
217.                 }
     
218.         }
     
219.         
     
220. }

复制代码

GreedSnake 代码：

额 …………总算完了  告诉我怎么贴代码  不会啊！！  上传附件吧  诶。。。

        

太厉害了，大神啊