命令行的贪吃蛇--集合的运用-原创手记-慕课网

研一下学期，java基础学习的整理，每一步都要走的踏实，输入同样要有输出，总结更加重要。
这是一个简单的贪吃蛇展示，主要分为4个类
1.Node类：节点坐标定义
2.Worm类：蛇身的节点是一个集合，实现头部插入，尾部删除。
3.WormPanel类：贪吃蛇的面板，包含框框、蛇
4.WornDemo：测试类

Node类：

package com.snack;

public class Node {
    private int i;
    private int j;
    public Node(){

    }
    public Node(int i,int j){
        this.i=i;
        this.j=j;

    }
    public int getI(){
        return i;
    }
    public int getJ(){
        return j;
    }
    public void setI(int i){
        this.i=i;
    }
    public void setJ(int j){
        this.j=j;
    }

    public String toString(){
        return "["+i+","+j+"]";
    }
   @Override
    public boolean equals(Object obj){
       if(obj==null){
           return false;
       }
       if(this==obj){
           return true;
       }
       if (obj instanceof Node)
       {
           Node other=(Node) obj;
           return this.i==other.i&&this.j==other.j;
       }
       return false; 
    }
   public int hashCode(){
       return i*10000+j;
   }
}

Worm类：

package com.snack;

import java.util.LinkedList;

import javax.management.RuntimeErrorException;

public class Worm {
    public static final int UP=-10;//向上
    public static final int Down=-10;//向下
    public static final int Left=-1;//向左
    public static final int Right=1;//向右

    private LinkedList<Node> nodes=new LinkedList<>();//插入速度快  可以头尾插入
    private int dir;//方向变量
    public Worm(){
        nodes.add(new Node(3,9));
        nodes.add(new Node(4,9));
        nodes.add(new Node(5,9));
        nodes.add(new Node(5,10));
        nodes.add(new Node(5,11));
        nodes.add(new Node(6,11));
        nodes.add(new Node(7,11));
        dir=Right;//默认方向向右
    }
    /*
     * 沿着当前方向走一步 
     */
    public void step(){
        //取出当前头节点
        Node head =nodes.getFirst();//get(0)
        //计算新的头结点
        int i=head.getI()+dir/10;
        int j=head.getJ()+dir%10;
        head=new Node(i,j);
        nodes.addFirst(head);//nodes.add(0,head);
        nodes.removeLast();//nodes.remove(nodes.size()-1)
    }

    /*
     * 换方向走一步
     * dir 新方向
     */
    public void step(int dir){
        if(this.dir+dir==0){
            throw new RuntimeException( "不能往方向走啊");
        }
        this.dir=dir;
        step();
    }
    public boolean contains(int i,int j){
//      Node node=new Node(i,j);
        return nodes.contains(new Node(i,j));
    }

    public String toString(){
        return nodes.toString();
    }
}

WormPanel类：

package com.snack;

public class WormPanel {
    private Worm worm;
    private int rows;
    private int cols;
    public WormPanel(int rows,int cols){
        this.rows=rows;
        this.cols=cols;
        worm = new Worm();
    }
    /*
     * 显示面板内容
     */
    public void print(){
        for(int i=0;i<rows;i++){
            for(int j=0;j<cols;j++){
                if(i==0||i==rows-1){
                    System.out.print("—");
                }
                else if(j==0||j==cols-1){
                    System.out.print("|");
                }else if(worm.contains(i,j)){
                    System.out.print("*");
                }else {
                    System.out.print(" ");
                }
            }
            System.out.println();
        }
    }

    /*
     * 获取面板上的蛇
     * return蛇对象
     */
    public Worm getWorm(){
        return worm;

    }

}

主测试类：

package com.snack;

import java.util.Scanner;

public class WormDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        WormPanel pane=new WormPanel(15,45);
        Scanner console = new Scanner(System.in);
        Worm worm=pane.getWorm();//获取面板上的蛇

        for(;;){
            pane.print();
            System.out.println("请输入方向");
            String cmd=console.nextLine();

            if(cmd.equalsIgnoreCase("U")){
                worm.step(worm.UP);
            }else if(cmd.equalsIgnoreCase("D")){
                worm.step(worm.Down);
            }else if(cmd.equalsIgnoreCase("L")){
                worm.step(worm.Left);
            }else if(cmd.equalsIgnoreCase("R")){
                worm.step(worm.Right);
            }else if(cmd.equalsIgnoreCase("q")){
                System.out.println("See you~");
                break;
            }
            else{
                worm.step();
            }

        }

    }

}

代码总结：
Node类：定义了 i，j 横纵坐标用于输出面板用的该类中还定义toString方法，用于输出节点的坐标。重写了equals方法可以自动重写equals方法和hashcode方法的虽然现在还不太理解为什么要重写hashcode方法

if (obj instanceof Node)
//     {
//         Node other=(Node) obj;
//         return this.i==other.i&&this.j==other.j;
｝

A instanceof B :A 是不是B类型的对象或者A对象能不能转成B类型
通常来判断子类对象是可以转换成父类对象。

Worm类：
定义了上下左右四个常量，这个细细探究一下是非常巧妙的。尤其是代码中的

        int i=head.getI()+dir/10;
        int j=head.getJ()+dir%10;

UP: i-1 (i是行)
DOMN: i+1
LEFT: j-1
RIGHT: j+1

就是10 -10 1 -1 这样四个参数加上/10和%10 取整取余的操作可以巧妙的实现想要ij变化的效果还是要动脑子的

step（）是向当前方向走一步 step 有参的是换方向走一步其实后者只要把当前的方向改一下就好了 this.dir=dir; 定义了不能反向走用了一个new RuntimeException（）用来抛出一个异常。

利用LinkedList的特性实现在头部插入一个点并把结尾的节点杀出 addFirst和removeLast 合适

该类中还定义了contains方法用来判断面板中是否包含蛇身的节点是的话就打印这样就能很轻松的把蛇给打印出来

Wormpanel类中没有什么好说的就是打印面板和蛇利用contains方法。

WormDemo类：
主函数入口，for（;;）是指没有循环初始条件满足什么的。。