接下来我们需要实现eat()方法。其实这个方法的思路很简单，就是往集合中新添加一个元素，然后将蛇身中每一个元素的坐标向前进一位。稍加思索，我们就可以理解：除了集合的第一个元素，集合的剩余元素就是前一个集合的排列，无论顺序，坐标还有颜色都相同。我们在把随机点的坐标赋给集合的第一个元素，那么集合的吞吃功能就完成了，吃掉的点变成了蛇头。代码体现：

1. public void eat() {
   
2.         snake.add(new snakeNode());//往集合中新增加一个元素，不用具体赋值
   
3.         Length++;
   
4.         for(int x = Length-1; x >0; x--) {
   
5.                         snake.get(x).setX(snake.get(x-1).getX());
   
6.                         snake.get(x).setY(snake.get(x-1).getY());
   
7.                         snake.get(x).setColor(snake.get(x-1).getColor());//变化坐标时，颜色也要进行变换，这样顺序才能一致
   
8.                 }
   
9.                 snake.get(0).setX(newNode.getX());
   
10.                 snake.get(0).setY(newNode.getY());
    
11.                 snake.get(0).setColor(newNode.getColor());
    
12.                 CreateNode();//吞吃完毕后要继续创造新的随机点，让游戏得以继续
    
13.                 }
    
14.                
    
15. ```

复制代码

这里有一个细节问题要注意**。在Move()方法匹配调用eat(）方法后，一定要使用return退出Move()方法。因为如果不退出，那么eat()方法会把随机点的坐标赋值给蛇头，然后程序会继续运行。当运行到if语句查看是否撞到自己的方法时，由于之前定义的firstX与firstY的值与随机点的值相同，那么蛇头的第一个元素的值也就与firstX与firstY的值相同，这就会符合if语句的条件，导致出现不必要的错误。这是一个很隐蔽的错误，我之前在这里卡主了很长时间，希望大家能好好理解这一点**。之前我们还定义过一个Dead方法，用于在游戏结束时弹出相关界面。这个方法相对而言比较简单，我直接贴出代码：

1. public void Dead(String str) {//弹出当前的时间，并提示游戏结束
   
2.         Date date = new Date();
   
3.         SimpleDateFormat sd = new SimpleDateFormat();
   
4.         String str2 = sd.format(date);
   
5.         String str3 = str + "\n" + "很遗憾，游戏要结束了~~~";
   
6.         JOptionPane.showMessageDialog(this, str2 + "\n" + str3        );
   
7.                 System.exit(0);
   
8.         }
   
9. ```
   

复制代码

目前来说我们已经完成了全部的贪吃蛇代码，是不是很简单？一开始做的时候没有什么思路，但随着我们一步一步分析，整个项目的流程也就非常清晰。最后我们还要完善两个方面，第一个是每当我们的集合发生位置移动时，我们需要调用repaint()方法进行重绘，防止出现坐标变化时的残留现象。在我们的代码要对集合中元素的坐标产生改变时，就调用repaint（）方法进行重绘，防止可能出现的残留或者闪烁现象。第二点就是我们目前只是在坐标轴上进行移动，无法直接在图案上观测到。如何画出贪吃蛇的图形？这里就要用到java绘图类——paint()方法。java中任何一个图形界面，都需要paint函数来负责专门显现。paint()方法一般由父类自动维护，一旦子类重写，子类就必须自己完成所有的界面显示工作。paint()有三个受保护的方法，我们因为是要绘制组件，所以调用PaintComponent()方法即可。具体的绘制思路就是以每一个snakeNode为圆心，成员变量中定义的unit为半径画园，将贪吃蛇的图形全部绘制出来。之后再以width,length，两者乘以unit来做一个矩形。因为集合中元素与随机产生的元素都在width与length的限制中，所以当绘制的圆碰到绘制的边框时，就代表着集合中的元素与边框（width,length）产生了交界，到达了边界值，在移动就会超出边界，游戏也就会失败。

1. protected void paintComponent(Graphics g) {
   
2.                 super.paintComponent(g);//调用super是因为文中调用了repaint方法，需要每一次都清空再进行重绘
   
3.                 g.setColor(newNode.getColor());
   
4.                 g.fillOval(newNode.getX()*unit, newNode.getY()*unit, unit, unit);
   
5.                 g.setColor(newNode.getColor());
   
6.                 g.drawRect(0, 0, width*unit, length*unit);
   
7.                 for(int x = 0; x < Length; x++) {
   
8.                         g.setColor(snake.get(x).getColor());
   
9.                         g.fillOval(snake.get(x).getX()*unit, snake.get(x).getY()*unit, unit, unit);
   
10.                 }
    
11.                
    
12.         }
    
13. ```

复制代码

最后给出完整的实现代码：

1. package game;
   
2. 
   
3. import java.awt.Color;
   
4. 
   
5. public class SnakeNode {//定义蛇身集合中的各个元素点
   
6.         private int x;
   
7.         private int y;
   
8.         private Color color;
   
9.         public SnakeNode() {
   
10.                 super();
    
11.                
    
12.         }
    
13.         public SnakeNode(int x, int y, Color color) {
    
14.                 super();
    
15.                 this.x = x;
    
16.                 this.y = y;
    
17.                 this.color = color;
    
18.         }
    
19.         public int getX() {
    
20.                 return x;
    
21.         }
    
22.         public void setX(int x) {
    
23.                 this.x = x;
    
24.         }
    
25.         public int getY() {
    
26.                 return y;
    
27.         }
    
28.         public void setY(int y) {
    
29.                 this.y = y;
    
30.         }
    
31.         public Color getColor() {
    
32.                 return color;
    
33.         }
    
34.         public void setColor(Color color) {
    
35.                 this.color = color;
    
36.         }
    
37.        
    
38.        
    
39. 
    
40. }
    
41. 
    
42. ```
    
43. 
    
44. ```
    
45. package game;
    
46. 
    
47. import java.awt.Color;
    
48. import java.awt.Graphics;
    
49. import java.awt.event.ActionEvent;
    
50. import java.awt.event.ActionListener;
    
51. import java.awt.event.KeyAdapter;
    
52. import java.awt.event.KeyEvent;
    
53. import java.text.SimpleDateFormat;
    
54. import java.util.ArrayList;
    
55. import java.util.Date;
    
56. import java.util.Random;
    
57. 
    
58. import javax.swing.JOptionPane;
    
59. import javax.swing.JPanel;
    
60. import javax.swing.Timer;
    
61. 
    
62. public class MainGame extends JPanel{
    
63.         private final int length = 20;//定义活动范围
    
64.         private final int width = 30;//定义活动范围
    
65.         private final int unit = 20;//定义单位长度
    
66.         private ArrayList<SnakeNode> snake = new ArrayList<>();//定义蛇身的集合
    
67.         private int Direction;//定义蛇头的方向
    
68.         private int Length ;//定义蛇身的长度
    
69.         private SnakeNode newNode = new SnakeNode(1,1,Color.BLACK);//定义随机点
    
70.         Timer time = new Timer(1000,new ThingsListener());
    
71.        
    
72.        
    
73. 
    
74.         public MainGame() {//初始化各项数据与方法
    
75.                 snake.add(new SnakeNode(width/2,length/2,Color.GREEN));
    
76.                 snake.add(new SnakeNode(width/2,length/2+1,Color.BLUE));
    
77.                 snake.add(new SnakeNode(width/2,length/2+2,Color.RED));
    
78.                
    
79.                 Direction = 1;//定义初始方向为向上
    
80.                 Length = 3;//蛇身长度为3
    
81.                 CreateNode();//产生随机点
    
82.                 time.start();
    
83.                
    
84.                 this.addKeyListener(new KeyAdapter() {//捕捉键盘的按键事件
    
85.                         public void keyPressed(KeyEvent e) {
    
86.                                 int direction = 0;//定义一个按下按钮后要去的方向
    
87.                                 switch(e.getKeyCode()) {
    
88.                                         case KeyEvent.VK_UP://按下向上，返回1
    
89.                                                 direction = 1;
    
90.                                                 break;
    
91.                                         case KeyEvent.VK_DOWN://按下向下，返回-1
    
92.                                                 direction = -1;
    
93.                                                 break;
    
94.                                         case KeyEvent.VK_LEFT://按下相左，返回2
    
95.                                                 direction = 2;
    
96.                                                 break;
    
97.                                         case KeyEvent.VK_RIGHT://按下向右，返回-2
    
98.                                                 direction = -2;
    
99.                                                 break;
    
100.                                         default:
     
101.                                                 break;
     
102.                                 }
     
103.                                 if(direction + Direction !=0) {//不能反向运动
     
104.                                         Direction = direction;
     
105.                                         Move(direction);
     
106.                                         repaint();
     
107.                                 }
     
108.                         }
     
109.                 });
     
110.                
     
111.         }
     
112.         public void Move(int direction) {//定义蛇身移动的方法
     
113.                 int FirstX = snake.get(0).getX();//获取蛇第一个点
     
114.                 int FirstY = snake.get(0).getY();//获取蛇第二个点
     
115.                
     
116.                 switch(direction) {
     
117.                         case 1:
     
118.                                 FirstY--;
     
119.                                 break;
     
120.                         case -1:
     
121.                                 FirstY++;
     
122.                                 break;
     
123.                         case 2:
     
124.                                 FirstX--;
     
125.                                 break;
     
126.                         case -2:
     
127.                                 FirstX++;
     
128.                                 break;
     
129.                         default:
     
130.                                 break;
     
131.                 }
     
132.                
     
133.                 if(FirstX == newNode.getX()&&FirstY == newNode.getY()) {//当碰到随机点时
     
134.                         getNode();
     
135.                         return;
     
136.                 }
     
137.                
     
138.                 for(int x = 0; x < Length; x++) {//当碰到蛇身自己时
     
139.                         if((FirstX==snake.get(x).getX())&&(FirstY == snake.get(x).getY())) {
     
140.                                 Dead("你碰到自己啦~~~");
     
141.                         }
     
142.                 }
     
143.                
     
144.                 if(FirstX < 0 || FirstX > width-1  || FirstY < 0 || FirstY > length -1) {
     
145.                         Dead("菜鸡，你撞墙啦~~~~~");
     
146.                 }
     
147.                
     
148.                
     
149.                
     
150.                 for(int x = Length - 1; x > 0; x--) {
     
151.                         snake.get(x).setX(snake.get(x-1).getX());
     
152.                         snake.get(x).setY(snake.get(x-1).getY());
     
153.                 }
     
154.                 snake.get(0).setX(FirstX);
     
155.                 snake.get(0).setY(FirstY);
     
156.                 repaint();
     
157.         }
     
158.        
     
159.         public void getNode() {
     
160.                 snake.add(new SnakeNode());
     
161.                 Length++;
     
162.                 for(int x = Length-1; x >0; x--) {
     
163.                         snake.get(x).setX(snake.get(x-1).getX());
     
164.                         snake.get(x).setY(snake.get(x-1).getY());
     
165.                         snake.get(x).setColor(snake.get(x-1).getColor());
     
166.                 }
     
167.                 snake.get(0).setX(newNode.getX());
     
168.                 snake.get(0).setY(newNode.getY());
     
169.                 snake.get(0).setColor(newNode.getColor());
     
170.                 CreateNode();
     
171.                 repaint();
     
172.                
     
173.                
     
174.         }
     
175.        
     
176.         public void Dead(String s) {
     
177.                 Date date = new Date();
     
178.                 SimpleDateFormat sd = new SimpleDateFormat();
     
179.                 String str2 = sd.format(date);
     
180.                 String str = s +"\n" +"所以说游戏不得已将结束了";
     
181.                 JOptionPane.showMessageDialog(this, str2 + "\n" + str        );
     
182.                 System.exit(0);
     
183.         }
     
184.        
     
185.         public void CreateNode() {//创造随机点的方法
     
186.                 int newX = 0;
     
187.                 int newY = 0;
     
188.                 Boolean flag = true;
     
189.                 while(flag) {
     
190.                 newX = new Random().nextInt(width);
     
191.                 newY = new Random().nextInt(length);
     
192.                
     
193.                 for(int i = 0; i < Length; i++) {
     
194.                         if(snake.get(i).getX()==newX && snake.get(i).getY()==newY) {
     
195.                                 flag = true;
     
196.                                 break;
     
197.                         }
     
198.                                 flag= false;
     
199.                         }
     
200.                 }
     
201.                
     
202.                 Color color = new Color(new Random().nextInt(255),new Random().nextInt(255),new Random().nextInt(255));
     
203.                 newNode.setX(newX);
     
204.                 newNode.setY(newY);
     
205.                 newNode.setColor(color);
     
206.                 this.setBackground(new Color(new Random().nextInt(255),new Random().nextInt(255),new Random().nextInt(255)));//这里给画板的背景换随机色
     
207.         }
     
208.        
     
209.         class ThingsListener implements ActionListener {//设置一个监听器事件
     
210.                 public void actionPerformed(ActionEvent e) {
     
211.                         Move(Direction);
     
212.                         repaint();
     
213.                 }
     
214.         }
     
215.        
     
216.         protected void paintComponent(Graphics g) {
     
217.                 super.paintComponent(g);
     
218.                 g.setColor(newNode.getColor());
     
219.                 g.fillOval(newNode.getX()*unit, newNode.getY()*unit, unit, unit);
     
220.                 g.setColor(newNode.getColor());
     
221.                 g.drawRect(0, 0, width*unit, length*unit);
     
222.                 for(int x = 0; x < Length; x++) {
     
223.                         g.setColor(snake.get(x).getColor());
     
224.                         g.fillOval(snake.get(x).getX()*unit, snake.get(x).getY()*unit, unit, unit);
     
225.                 }
     
226.                
     
227.         }
     
228.        
     
229.                
     
230.        
     
231. 
     
232. }
     
233. 
     
234. ```
     
235. 
     
236. ```
     
237. package game;
     
238. 
     
239. import java.awt.Color;
     
240. 
     
241. import javax.swing.JFrame;
     
242. 
     
243. public class Test {
     
244.         public static void main(String[] args) {
     
245.                 JFrame frame = new JFrame("贪吃蛇————————————made by chenjiaheng");
     
246.                 frame.setBounds(0,0,800,500);
     
247.                 MainGame sn = new MainGame();
     
248.                 frame.add(sn);
     
249.                 frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
     
250.                 frame.setVisible(true);
     
251.                 sn.requestFocus();
     
252.         }
     
253. 
     
254. }
     
255. 
     
256. ```
     

复制代码

写到这里，整个贪吃蛇的项目，包括思路，实现，代码都算是完成了。其实代码如何实现并不困难，重要的是如何通过方法和技巧将大问题分解成一个一个小问题，最后再加以解决。在这里完成的只是贪吃蛇的基本功能，在以后自己可能会继续实现更多的功能，包括插入图片，加入排行榜，记录个数等功能。从0到1，从无到有，希望自己的文章能给各位朋友带来帮助。如果有什么好的想法和思路，自己也会继续在博客中和大家分享。

不错不错，学习了