项目-坦克大战3

防止敌人坦克重叠运动

• 1，可以得到所有的坦克—— 在EnemyTank类中增加成员，EnemyTank 可以得到敌人坦克的Vector
• 2，判断当前敌人坦克是否和其他的敌人坦克重叠或碰撞——在EnemyTank类中创建isTouchEnemyTank方法进行判断
• 3，控制坦克移动范围——在EnemyTank类重写线程的run方法中进行控制
• 4，将判断坦克重叠或碰撞的方法isTouchEnemyTank方法应用到敌人坦克线程中——在MyPanel类中的构造器中将enemyTank 中的setEnemyTanks 方法 应用到 enemyTanks ！！！
  

EnemyTank类

import java.util.Vector;

//敌人坦克
public class EnemyTank extends Tank implements Runnable {
    //给敌人坦克类，使用Vector 保存多个Shot
    Vector<Shot> shots = new Vector<>();

    //增加成员，EnemyTank 可以得到敌人坦克的Vector
    //分析：
    //1，
    Vector<EnemyTank> enemyTanks = new Vector<>();
    //定义敌人坦克的存活属性
    boolean isLive = true;

    public EnemyTank(int x, int y) {
        super(x, y);
    }

    //这里提供一个方法，可以将MyPanel的成员  Vector<EnemyTank> enemyTanks = new Vector<>();
    //设置到 EnemyTank 的成员 enemyTanks
    public void setEnemyTanks(Vector<EnemyTank> enemyTanks) {
        this.enemyTanks = enemyTanks;
    }

    //编写方法，判断当前这个敌人坦克，是否和  enemyTanks  中的其他坦克发生重叠或碰撞
    public boolean isTouchEnemyTank() {
        //判断当前这个敌人坦克（this）的方向
        switch (this.getDirect()) {
            case 0://上
                //让当前敌人坦克和其他所有的敌人坦克比较
                for (int i = 0; i < enemyTanks.size(); i++) {
                    //取出敌人所有坦克
                    EnemyTank enemyTank = enemyTanks.get(i);
                    //使得取出的坦克不和自己比较
                    if (enemyTank != this) {
                        //1,如果其他敌人坦克是上/下  x的范围[enemyTank.getX(),enemyTank.getX()+40]
                        //                        Y的范围[enemyTank.getY(),enemyTank.getY()+60]
                        if (enemyTank.getDirect() == 0 || enemyTank.getDirect() == 2) {
                            //2,当前坦克左上角的坐标 [this.getX,this.getY]
                            if (this.getX() >= enemyTank.getX()
                                    && this.getX() <= enemyTank.getX() + 40
                                    && this.getY() >= enemyTank.getY()
                                    && this.getY() <= enemyTank.getY() + 60) {
                                return true;
                            }
                            //2,当前坦克右上角的坐标 [this.getX+40,this.getY]
                            if (this.getX() + 40 >= enemyTank.getX()
                                    && this.getX()+40 <= enemyTank.getX() + 40
                                    && this.getY() >= enemyTank.getY()
                                    && this.getY() <= enemyTank.getY() + 60) {
                                return true;
                            }
                        }
                        //1，如果敌人坦克是左/右:X的范围[enemyTank.getX(),enemyTank.getX()+60]
                        //                     Y的范围[enemyTank.getY(),enemyTank.getY()+40]
                        if (enemyTank.getDirect() == 1 || enemyTank.getDirect() == 3) {
                            //2,当前坦克左上角的坐标 [this.getX,this.getY]
                            if (this.getX() >= enemyTank.getX()
                                    && this.getX() <= enemyTank.getX() + 60
                                    && this.getY() >= enemyTank.getY()
                                    && this.getY() <= enemyTank.getY() + 40) {
                                return true;
                            }
                            //2,当前坦克右上角的坐标 [this.getX+40,this.getY]
                            if (this.getX() + 40 >= enemyTank.getX()
                                    && this.getX() + 40 <= enemyTank.getX() + 60
                                    && this.getY() >= enemyTank.getY()
                                    && this.getY() <= enemyTank.getY() + 40) {
                                return true;
                            }
                        }

                    }
                }
                break;
            case 1://右
                //让当前敌人坦克和其他所有的敌人坦克比较
                for (int i = 0; i < enemyTanks.size(); i++) {
                    //取出敌人所有坦克
                    EnemyTank enemyTank = enemyTanks.get(i);
                    //使得取出的坦克不和自己比较
                    if (enemyTank != this) {
                        //1,如果其他敌人坦克是上/下  x的范围[enemyTank.getX(),enemyTank.getX()+40]
                        //                        Y的范围[enemyTank.getY(),enemyTank.getY()+60]
                        if (enemyTank.getDirect() == 0 || enemyTank.getDirect() == 2) {
                            //2,当前坦克右上角的坐标 [this.getX+60,this.getY]
                            if (this.getX() + 60 >= enemyTank.getX()
                                    && this.getX() + 60 <= enemyTank.getX() + 40
                                    && this.getY() >= enemyTank.getY()
                                    && this.getY() <= enemyTank.getY() + 60) {
                                return true;
                            }
                            //3,当前坦克右下角的坐标 [this.getX+60,this.getY+40]
                            if (this.getX() + 60 >= enemyTank.getX()
                                    && this.getX() + 60 <= enemyTank.getX() + 40
                                    && this.getY() + 40 >= enemyTank.getY()
                                    && this.getY() + 40 <= enemyTank.getY() + 60) {
                                return true;
                            }
                        }
                        //1，如果敌人坦克是左/右:X的范围[enemyTank.getX(),enemyTank.getX()+60]
                        //                     Y的范围[enemyTank.getY(),enemyTank.getY()+40]
                        if (enemyTank.getDirect() == 1 || enemyTank.getDirect() == 3) {
                            //2,当前坦克右上角的坐标 [this.getX+60,this.getY]
                            if (this.getX() + 60 >= enemyTank.getX()
                                    && this.getX() + 60 <= enemyTank.getX() + 60
                                    && this.getY() >= enemyTank.getY()
                                    && this.getY() <= enemyTank.getY() + 40) {
                                return true;
                            }
                            //2,当前坦克右下角的坐标 [this.getX+60,this.getY+40]
                            if (this.getX() + 60 >= enemyTank.getX()
                                    && this.getX() + 60 <= enemyTank.getX() + 60
                                    && this.getY() + 40 >= enemyTank.getY()
                                    && this.getY() + 40 <= enemyTank.getY() + 40) {
                                return true;
                            }
                        }

                    }
                }
                break;
            case 2:
                //让当前敌人坦克和其他所有的敌人坦克比较
                for (int i = 0; i < enemyTanks.size(); i++) {
                    //取出敌人所有坦克
                    EnemyTank enemyTank = enemyTanks.get(i);
                    //使得取出的坦克不和自己比较
                    if (enemyTank != this) {
                        //1,如果其他敌人坦克是上/下  x的范围[enemyTank.getX(),enemyTank.getX()+40]
                        //                        Y的范围[enemyTank.getY(),enemyTank.getY()+60]
                        if (enemyTank.getDirect() == 0 || enemyTank.getDirect() == 2) {
                            //2,当前坦克左下角的坐标 [this.getX,this.getY+60]
                            if (this.getX() >= enemyTank.getX()
                                    && this.getX() <= enemyTank.getX() + 40
                                    && this.getY() + 60 >= enemyTank.getY()
                                    && this.getY() + 60 <= enemyTank.getY() + 60) {
                                return true;
                            }
                            //3,当前坦克右下角的坐标 [this.getX+40,this.getY+60]
                            if (this.getX() + 40 >= enemyTank.getX()
                                    && this.getX() + 40 <= enemyTank.getX() + 40
                                    && this.getY() + 60 >= enemyTank.getY()
                                    && this.getY() + 60 <= enemyTank.getY() + 60) {
                                return true;
                            }
                        }
                        //1，如果敌人坦克是左/右:X的范围[enemyTank.getX(),enemyTank.getX()+60]
                        //                     Y的范围[enemyTank.getY(),enemyTank.getY()+40]
                        if (enemyTank.getDirect() == 1 || enemyTank.getDirect() == 3) {
                            //2,当前坦克左下角的坐标 [this.getX,this.getY+60]
                            if (this.getX() >= enemyTank.getX()
                                    && this.getX() <= enemyTank.getX() + 60
                                    && this.getY() + 60 >= enemyTank.getY()
                                    && this.getY() + 60 <= enemyTank.getY() + 40) {
                                return true;
                            }
                            //3,当前坦克右下角的坐标 [this.getX+40,this.getY+60]
                            if (this.getX() + 40 >= enemyTank.getX()
                                    && this.getX() + 40 <= enemyTank.getX() + 60
                                    && this.getY() + 60 >= enemyTank.getY()
                                    && this.getY() + 60 <= enemyTank.getY() + 40) {
                                return true;
                            }
                        }

                    }
                }
                break;
            case 3:
                //让当前敌人坦克和其他所有的敌人坦克比较
                for (int i = 0; i < enemyTanks.size(); i++) {
                    //取出敌人所有坦克
                    EnemyTank enemyTank = enemyTanks.get(i);
                    //使得取出的坦克不和自己比较
                    if (enemyTank != this) {
                        //1,如果其他敌人坦克是上/下  x的范围[enemyTank.getX(),enemyTank.getX()+40]
                        //                        Y的范围[enemyTank.getY(),enemyTank.getY()+60]
                        if (enemyTank.getDirect() == 0 || enemyTank.getDirect() == 2) {
                            //2,当前坦克左上角的坐标 [this.getX,this.getY]
                            if (this.getX() >= enemyTank.getX()
                                    && this.getX() <= enemyTank.getX() + 40
                                    && this.getY() >= enemyTank.getY()
                                    && this.getY() <= enemyTank.getY() + 60) {
                                return true;
                            }
                            //3,当前坦克左下角的坐标 [this.getX,this.getY+40]
                            if (this.getX() >= enemyTank.getX()
                                    && this.getX() <= enemyTank.getX() + 40
                                    && this.getY() + 40 >= enemyTank.getY()
                                    && this.getY() + 40 <= enemyTank.getY() + 60) {
                                return true;
                            }
                        }
                        //1，如果敌人坦克是左/右:X的范围[enemyTank.getX(),enemyTank.getX()+60]
                        //                     Y的范围[enemyTank.getY(),enemyTank.getY()+40]
                        if (enemyTank.getDirect() == 1 || enemyTank.getDirect() == 3) {
                            //2,当前坦克左上角的坐标 [this.getX,this.getY]
                            if (this.getX() >= enemyTank.getX()
                                    && this.getX() <= enemyTank.getX() + 60
                                    && this.getY() >= enemyTank.getY()
                                    && this.getY() <= enemyTank.getY() + 40) {
                                return true;
                            }
                            //3,当前坦克左下角的坐标 [this.getX,this.getY+40]
                            if (this.getX() >= enemyTank.getX()
                                    && this.getX() <= enemyTank.getX() + 60
                                    && this.getY() + 40 >= enemyTank.getY()
                                    && this.getY() + 40 <= enemyTank.getY() + 40) {
                                return true;
                            }
                        }

                    }
                }
                break;
        }
        return false;
    }

    @Override
    public void run() {
        while (true) {

            //这里我们判断如果shots size（） = 0; 创建一颗子弹，放入到shots集合，并启动
            if (isLive && shots.size() < 1) {
                Shot s = null;
                //判断坦克的方向，创建对应的子弹
                switch (getDirect()) {
                    case 0:
                        s = new Shot(getX() + 20, getY(), 0);
                        break;
                    case 1:
                        s = new Shot(getX() + 60, getY() + 20, 1);
                        break;
                    case 2:
                        s = new Shot(getX() + 20, getY() + 60, 2);
                        break;
                    case 3:
                        s = new Shot(getX(), getY() + 20, 3);
                        break;
                }
                shots.add(s);
                new Thread(s).start();
            }
            //控制坦克移动范围
            switch (getDirect()) {
                //根据坦克的方向来进行移动
                case 0://向上
                    //让坦克保持一个方向，走30步
                    for (int i = 0; i < 30; i++) {
                        if (getY() > 0 && !isTouchEnemyTank()) {
                            moveUp();
                        }
                        //休眠50好眠
                        try {
                            Thread.sleep(50);
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }
                    break;
                case 1://向右
                    //让坦克保持一个方向，走30步
                    for (int i = 0; i < 30; i++) {
                        if (getX() + 60 < 1000&& !isTouchEnemyTank()) {
                            moveRight();
                        }
                        //休眠50好眠
                        try {
                            Thread.sleep(50);
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }
                    break;
                case 2://向下
                    //让坦克保持一个方向，走30步
                    for (int i = 0; i < 30; i++) {
                        if (getY() + 60 < 750&& !isTouchEnemyTank()) {
                            moveDown();
                        }
                        //休眠50好眠
                        try {
                            Thread.sleep(50);
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }
                    break;
                case 3://向左
                    //让坦克保持一个方向，走30步
                    for (int i = 0; i < 10; i++) {
                        if (getX() > 0&& !isTouchEnemyTank()) {
                            moveLeft();
                        }

                        //休眠50好眠
                        try {
                            Thread.sleep(50);
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }

                    break;
            }
            //休眠50好眠
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            // 然后随机的改变坦克方向0-3
            setDirect((int) (Math.random() * 4));  //0-3

            //一旦写并发程序，一定要考虑清楚，该线程什么时候结束
            if (!isLive) {
                break;
            }
        }
    }
}

MyPanel类

//画板类
public class MyPanel extends JPanel implements KeyListener, Runnable {
    //定义我的坦克
    Hero hero = null;
    //定义敌人坦克，放入到Vector（线程安全，可以有多个）
    Vector<EnemyTank> enemyTanks = new Vector<>();
    int enemyTankSize = 6;
    //定义一个Vector，用于存放炸弹（炸弹既不属于我方坦克也不属于地方坦克 ，所以坦克放在画板类）
    //当我们的子弹击中坦克时，就加入一个Bomb对象到bombs
    Vector<Bomb> bombs = new Vector<>();
    //定义三张炸弹图片，用于显示爆炸效果
    Image image1 = null;
    Image image2 = null;
    Image image3 = null;

    public MyPanel() {//初始化自己的坦克
        hero = new Hero(100, 100);
        hero.setSpeed(5);

        //初始化敌人的坦克
        for (int i = 0; i < enemyTankSize; i++) {
            //创建一个敌人的坦克
            EnemyTank enemyTank = new EnemyTank(100 * (i + 1), 0);

            //将enemyTank 中的setEnemyTanks 方法 应用到 enemyTanks ！！！
            enemyTank.setEnemyTanks(enemyTanks);
            //启动敌人坦克线程，让他动起来
            new Thread(enemyTank).start();
            //设置方向```java
            //在这里插入代码片
            enemyTank.setDirect(2);
            //给该enemyTank 加入一颗子弹                                                                                                                                               
            Shot shot = new Shot(enemyTank.getX() + 20, enemyTank.getY() + 60, enemyTank.getDirect());
            enemyTank.shots.add(shot);
            //启动shot对象
            new Thread(shot).start();
            //把敌人的坦克加入的总的坦克对象中
            enemyTanks.add(enemyTank);
        }

记录玩家的总成绩（累积击毁敌方坦克数）

• 1，显示击毁坦克的信息：在MyPanel中编写showInfo方法，用于显示我方击毁坦克的信息
• 2，将我们击毁的坦克数量动态化：创建Recorder类，定义变量用来记录敌方坦克的数量
• 3，将击毁的坦克数量和敌人坦克的坐标和方向传入文件：创建keepRecord 利用IO流进行操作
• 4，设置关闭窗体时，游戏的信息传入文件：在窗体 中增加相应关闭窗口的处理

玩游戏时，可以选择时开新游戏还是继续新游戏

• 1，设置开 新游戏、继续游戏 的选项：在窗体类中进行设置，1为新游戏；2为继续游戏
• 2，设置判断语句，设置各个选项时的操作：在Mypanel类中，画敌方坦克时进行操作
• 3，若是继续游戏：从之前保存的文件中恢复相关信息：在Recorder类中，增加一个方法，用于读取recordFile，恢复相关信息

最终版：敌方坦克不重叠；记录成绩等

窗体类： TankGame02

import javax.swing.*;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.util.Scanner;

//窗体类
public class TankGame02 extends JFrame {//窗体
    static   Scanner scanner = new Scanner(System.in);
    public static void main(String[] args) {

        new TankGame02();
    }
    private MyPanel mp = null;//创建画板对象

    public TankGame02(){
        System.out.println("请输入选择  1，新游戏  2，继续上局");
        String key = scanner.nextLine();
        mp = new MyPanel(key);//画板初试化
        //将mp放入Thread对象中
        Thread thread = new Thread(mp);
        thread.start();
        this.add(mp);//把画板传入窗体
        this.setSize(1200,750);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        //窗体JFrame对象可以监听键盘事件，面板实现了键盘监听器
        // 即可以监听到面板发生的监听事件
        this.addKeyListener(mp);
        this.setVisible(true);

        //在JFrame 中增加相应关闭窗口的处理
        this.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                Recorder.keepRecord();
                System.exit(0);
            }
        });
    }

}

坦克父类：Tank

//坦克父类
public class Tank {
    private int x;//坦克的横坐标
    private int y;//坦克的纵坐标
    boolean isLive  =true; //判断坦克是否存活
    private int direct;//坦克方向   //direct表示方法：  0：向上   1：向右    2：向下    3：向左
    private int speed = 1;

    public int getSpeed() {
        return speed;
    }

    public void setSpeed(int speed) {
        this.speed = speed;
    }
    //定义 可以上下左右移动的方法
    public void moveUp() {
        y -= speed;
    }

    public void moveDown() {
        y += speed;
    }

    public void moveLeft() {
        x -= speed;
    }

    public void moveRight() {
        x += speed;
    }


    public Tank(int direct) {
        this.direct = direct;
    }

    public int getDirect() {
        return direct;
    }

    public void setDirect(int direct) {
        this.direct = direct;
    }

    public Tank(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }
}

子弹类：Shot

public class Shot implements Runnable {
    int x;//子弹的横坐标
    int y;//子弹的Y坐标
    int direct;//子弹的方向
    int speed = 50;
    boolean isLive = true;//子弹何时退出

    public Shot(int x, int y, int direct) {
        this.x = x;
        this.y = y;
        this.direct = direct;
    }

    @Override
    public void run() {
        while (true){
            //让线程休眠一会
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            //根据方向改变x，y坐标
            switch (direct){
                case 0://上
                    y-=speed;
                    break;
                case 1://右
                    x+=speed;
                    break;
                case 2://下
                    y+=speed;
                    break;
                case 3://左
                    x-=speed;
                    break;
            }
            //我们输除 x，y的坐标
            System.out.println("子弹x="+x+"子弹y="+y+"方向"+direct);
            //当子弹移动到面板的边界时，就应该销毁（把启动的子弹的线程销毁）
            //当子弹碰到敌人坦克时，也应该结束线程
            if(!(x>=0&&x<=1000&&y>=0&&y<=750&&isLive)){
                isLive = false;
                break;
            }

        }
    }
}

成绩记录类：Recorder

import java.io.*;
import java.nio.charset.StandardCharsets;
import java.util.Vector;

public class Recorder {
    //定义变量，记录敌方坦克的数量
    public static int allEnemyTankNum = 1;

    //定义IO对象，准备写数据到文件中
    private static BufferedWriter bw = null;
    private static BufferedReader br = null;
    private static String recordFile = "d:\\myRecord.txt";
    //定义Vector 指向MyPanel 对象的敌人坦克 Vector
    private static Vector<EnemyTank> enemyTanks = null;
    //定义一个Node的Vector，用于保存敌人的信息node
    private static Vector<Node> nodes = new Vector<>();

    public static void setEnemyTanks(Vector<EnemyTank> enemyTanks) {
        Recorder.enemyTanks = enemyTanks;
    }

    public static int getAllEnemyTankNum() {
        return allEnemyTankNum;
    }

    //增加一个方法，用于读取recordFile，恢复相关信息
    public static Vector<Node> getNodesAndEnemyRec() {
        try {
            br = new BufferedReader(new FileReader(recordFile));
            String s = br.readLine();
//            System.out.println(s);
            allEnemyTankNum = Integer.parseInt(s);
//            System.out.println(allEnemyTankNum);
            //循环读取文件，生成nodes集合
            String line = " ";
            while ((line = br.readLine()) != null) {
                String[] xyd = line.split(" ");
                Node node = new Node(Integer.parseInt(xyd[0]), Integer.parseInt(xyd[1]), Integer.parseInt(xyd[2]));
                nodes.add(node);//放入到nodes Vector
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            if (br != null) {
                try {
                    br.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }

        return nodes;
    }

    //增加一个方法，当游戏退出时，我们将allEnemyTankNum 保存到 recordFile
    //对keepRecord 方法进行升级，保留敌人坦克的坐标和方向
    public static void keepRecord() {
        try {
            bw = new BufferedWriter(new FileWriter(recordFile));
            System.out.println(allEnemyTankNum + "----");
            bw.write(allEnemyTankNum+"");
            bw.newLine();

            //遍历敌人坦克的Vector，然后根据情况保存即可
            //OOP思想，定义一个属性，然后通过setXxx得到 敌人坦克的Vector
            for (int i = 0; i < enemyTanks.size(); i++) {
                //取出敌人坦克
                EnemyTank enemyTank = enemyTanks.get(i);
                if (enemyTank.isLive) {
                    //保存该enemyTank信息
                    String record = enemyTank.getX() + " " + enemyTank.getY() + " " + enemyTank.getDirect();
                    bw.write(record);
                    bw.newLine();
                }
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            try {
                if (bw != null) {
                    bw.close();
                }
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }

        ;
    }

    public static void setAllEnemyTankNum(int allEnemyTankNum) {
        Recorder.allEnemyTankNum = allEnemyTankNum;
    }

    //当我方坦克击毁一个敌人坦克，就应当 allEnemyTankNum++
    public static void addAllEnemyTankNum() {
        Recorder.allEnemyTankNum++;
    }
}

节点类：用来指代打掉的敌方坦克Node

public class Node {
    int x ;
    int y;
    int direct;

    public Node(int x, int y, int direct) {
        this.x = x;
        this.y = y;
        this.direct = direct;
    }

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }

    public int getDirect() {
        return direct;
    }

    public void setDirect(int direct) {
        this.direct = direct;
    }
}

画板类：MyPanel

import javax.swing.*;
import java.awt.*;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.util.ArrayList;
import java.util.Vector;

//画板类
public class MyPanel extends JPanel implements KeyListener, Runnable {
    //定义我的坦克
    Hero hero = null;
    //定义敌人坦克，放入到Vector（线程安全，可以有多个）
    Vector<EnemyTank> enemyTanks = new Vector<>();
    //定义一个存放Node 对象的Vector 用于恢复敌人的坐标和方向
    Vector<Node> nodes = new Vector<>();
    int enemyTankSize = 6;
    //定义一个Vector，用于存放炸弹（炸弹既不属于我方坦克也不属于地方坦克 ，所以坦克放在画板类）
    //当我们的子弹击中坦克时，就加入一个Bomb对象到bombs
    Vector<Bomb> bombs = new Vector<>();
    //定义三张炸弹图片，用于显示爆炸效果
    Image image1 = null;
    Image image2 = null;
    Image image3 = null;

    public MyPanel(String key) {//初始化自己的坦克
        nodes = Recorder.getNodesAndEnemyRec();
        //将MyPanel对象的 enemyTanks 设置给Recorder 的enemyTanks
        Recorder.setEnemyTanks(enemyTanks);

        hero = new Hero(100, 100);
        hero.setSpeed(5);


        switch (key){
            case "1":
                //初始化敌人的坦克
                for (int i = 0; i < enemyTankSize; i++) {
                    //创建一个敌人的坦克
                    EnemyTank enemyTank = new EnemyTank(100 * (i + 1), 0);
                    //将enemyTank 中的setEnemyTanks 方法 应用到 enemyTanks ！！！
                    enemyTank.setEnemyTanks(enemyTanks);
                    //启动敌人坦克线程，让他动起来
                    new Thread(enemyTank).start();
                    //设置方向```java
                    //在这里插入代码片
                    enemyTank.setDirect(2);
                    //给该enemyTank 加入一颗子弹
                    Shot shot = new Shot(enemyTank.getX() + 20, enemyTank.getY() + 60, enemyTank.getDirect());
                    enemyTank.shots.add(shot);
                    //启动shot对象
                    new Thread(shot).start();
                    //把敌人的坦克加入的总的坦克对象中
                    enemyTanks.add(enemyTank);
                }
                break;
            case "2":
                //初始化敌人的坦克
                for (int i = 0; i < nodes.size(); i++) {
                    Node node = nodes.get(i);
                    //创建一个敌人的坦克
                    EnemyTank enemyTank = new EnemyTank(node.getX(),node.getY());
                    //将enemyTank 中的setEnemyTanks 方法 应用到 enemyTanks ！！！
                    enemyTank.setEnemyTanks(enemyTanks);
                    //启动敌人坦克线程，让他动起来
                    new Thread(enemyTank).start();
                    //设置方向```java
                    //在这里插入代码片
                    enemyTank.setDirect(node.getDirect());
                    //给该enemyTank 加入一颗子弹
                    Shot shot = new Shot(enemyTank.getX() + 20, enemyTank.getY() + 60, enemyTank.getDirect());
                    enemyTank.shots.add(shot);
                    //启动shot对象
                    new Thread(shot).start();
                    //把敌人的坦克加入的总的坦克对象中
                    enemyTanks.add(enemyTank);
                }
                break;
            default:
                System.out.println("你的输入有误");

        }

//        image1 = Toolkit.getDefaultToolkit().getImage(Panel.class.getResource("/1.gif"));
//        image2 = Toolkit.getDefaultToolkit().getImage(Panel.class.getResource("/2.gif"));
//        image3 = Toolkit.getDefaultToolkit().getImage(Panel.class.getResource("/3.gif"));
        //初始化照片对象
        image1 = new ImageIcon("image/1.gif").getImage();
        image2 = new ImageIcon("image/2.gif").getImage();
        image3 = new ImageIcon("image/3.gif").getImage();



    }
    //编写方法   用于显示我方击毁坦克的信息
    public void showInfo(Graphics g){
        //画出玩家的总成绩
        //设置字体
        g.setColor(Color.BLACK);
        Font font = new Font("宋体", Font.BOLD, 20);
        g.setFont(font);
        //添加汉字
        g.drawString("您累积击毁敌方坦克",920,30);

        //画出一个敌方坦克
        drawTank(920,60,g,0,0);
        //写出击中的坦克数量  这里需要重新设置颜色
        g.setColor(Color.BLUE);
        g.drawString(Recorder.getAllEnemyTankNum()+"",980,100);
    }

    @Override
    public void paint(Graphics g) {
        super.paint(g);
        //3，通过画笔填充一个矩形区域   g.fillRect();
        g.fillRect(0, 0, 900, 750);//填充矩形，默认为黑色
        showInfo(g);
        if (hero != null && hero.isLive){
        //画出自己的坦克
        drawTank(hero.getX(), hero.getY(), g, hero.getDirect(), 1);}
//        drawTank(hero.getX() +100,hero.getY(),g,hero.getDirect(),0);
//        drawTank(hero.getX() +200,hero.getY(),g,hero.getDirect(),0);
//        drawTank(hero.getX() +300,hero.getY(),g,hero.getDirect(),1);
        //判断何时画子弹
//        if (hero.shot != null && hero.shot.isLive == true) {
//            g.setColor(Color.white);
//            g.draw3DRect(hero.shot.x, hero.shot.y, 1, 1, false);
//
//        }
        //将hero的子弹集合shots，遍历取出绘制
        for (int i = 0; i < hero.shots.size(); i++) {
            Shot shot = hero.shots.get(i);
            if (shot != null && shot.isLive == true) {
            g.setColor(Color.white);
            g.draw3DRect(shot.x, shot.y, 1, 1, false);
        }else {//如果该shot对象已经无效，就从shots集合中拿掉
                hero.shots.remove(shot);
            }

        }
        //如果bombs 集合中有对象，就画出
        for (int i = 0; i < bombs.size(); i++) {
            //取出来炸弹
            Bomb bomb = bombs.get(i);
            //根据当前这个bomb对象的life值去画出对应的图片
            if (bomb.life > 6) {
                g.drawImage(image1, bomb.x, bomb.y, 60, 60, this);
            } else if (bomb.life > 3) {
                g.drawImage(image2, bomb.x, bomb.y, 60, 60, this);
            } else {
                g.drawImage(image3, bomb.x, bomb.y, 60, 60, this);
            }
            //让这个炸弹的生命值减少
            bomb.lifeDown();
            //如果 bomb life 为0 ，就从bombs的集合中删除
            if (bomb.life == 0) {
                bombs.remove(bomb);
            }
        }
        //画出敌人的坦克
        for (int i = 0; i < enemyTanks.size(); i++) {
            //从Vector取出坦克
            EnemyTank enemyTank = enemyTanks.get(i);
            //判断当前坦克是否还存活
            if (enemyTank.isLive) {//当敌人坦克时存活的，才画出该坦克
                drawTank(enemyTank.getX(), enemyTank.getY(), g, enemyTank.getDirect(), 0);
                //画出 enemyTank 所有子弹
                for (int j = 0; j < enemyTank.shots.size(); j++) {
                    //取出子弹
                    Shot shot = enemyTank.shots.get(j);
                    //绘制
                    if (shot.isLive) {//isLive=true
                        g.setColor(Color.white);
                         g.draw3DRect(shot.x, shot.y, 1, 1, false);
                    } else {
                        //从Vector 移除
                        enemyTank.shots.remove(shot);
                    }
                }
            }
        }
    }
    /*
    int x 坦克的横坐标
    int y 坦克的纵坐标
    Graphics g  画笔
    int direct  坦克的方向
    int type  坦克的类型
     */

    public void drawTank(int x, int y, Graphics g, int direct, int type) {


        switch (type) {
            case 0://敌人的坦克
                g.setColor(Color.cyan);
                break;
            case 1://我的坦克
                g.setColor(Color.yellow);
                break;
        }

        //根据坦克的方向，来绘制坦克
        //direct表示方法：  0：向上   1：向右    2：向下    3：向左
        switch (direct) {
            case 0://表示向上
                g.fill3DRect(x, y, 10, 60, false);//画出坦克左边轮子
                g.fill3DRect(x + 30, y, 10, 60, false);//画出坦克右边轮子
                g.fill3DRect(x + 10, y + 10, 20, 40, false);//画出坦克盖子
                g.fillOval(x + 10, y + 20, 20, 20);//画出圆形盖子
                g.drawLine(x + 20, y + 30, x + 20, y);//画出炮筒
                break;
            case 1://表示向右
                g.fill3DRect(x, y, 60, 10, false);//画出坦克上边轮子
                g.fill3DRect(x, y + 30, 60, 10, false);//画出坦克下边轮子
                g.fill3DRect(x + 10, y + 10, 40, 20, false);//画出坦克盖子
                g.fillOval(x + 20, y + 10, 20, 20);//画出圆形盖子
                g.drawLine(x + 30, y + 20, x + 60, y + 20);//画出炮筒
                break;
            case 2://表示向下
                g.fill3DRect(x, y, 10, 60, false);//画出坦克左边轮子
                g.fill3DRect(x + 30, y, 10, 60, false);//画出坦克右边轮子
                g.fill3DRect(x + 10, y + 10, 20, 40, false);//画出坦克盖子
                g.fillOval(x + 10, y + 20, 20, 20);//画出圆形盖子
                g.drawLine(x + 20, y + 30, x + 20, y + 60);//画出炮筒
                break;
            case 3://表示向左
                g.fill3DRect(x, y, 60, 10, false);//画出坦克上边轮子
                g.fill3DRect(x, y + 30, 60, 10, false);//画出坦克下边轮子
                g.fill3DRect(x + 10, y + 10, 40, 20, false);//画出坦克盖子
                g.fillOval(x + 20, y + 10, 20, 20);//画出圆形盖子
                g.drawLine(x + 30, y + 20, x, y + 20);//画出炮筒
                break;
            default:
                System.out.println("暂时没有处理");
        }
    }
    //编写方法，判断敌人坦克是否击中我方坦克
    public void hitHero(){
        //遍历所有的敌人坦克
        for (int i = 0; i < enemyTanks.size(); i++) {
            //取出敌人坦克
            EnemyTank enemyTank = enemyTanks.get(i);
            //遍历enemyTank 对象的所有子弹
            for (int j = 0; j < enemyTank.shots.size(); j++) {
                //取出子弹
                Shot shot = enemyTank.shots.get(j);
                //判断shot 是否击中我的坦克
                if (hero.isLive&&shot.isLive){
                    hitTank( shot,hero);

                }
            }

        }
    }
    public void hitEnemy(){
        //判断我们的子弹是否击中了敌人坦克
        if (hero.shot != null && hero.shot.isLive) {//当我方的子弹还存活
            //遍历敌人所有的坦克
            for (int i = 0; i < enemyTanks.size(); i++) {
                EnemyTank enemyTank = enemyTanks.get(i);
                hitTank(hero.shot, enemyTank);
            }
        }
    }

    //编写方法：判断我方子弹是否击敌人坦克
    //什么时候判断，我方坦克是否击中敌人坦克？  run方法
    public void hitTank(Shot s, Tank tank) {
        //判断s 击中坦克
        switch (tank.getDirect()) {
            case 0://敌人坦克向上
            case 2://敌人坦克向下
                if (s.x > tank.getX() && s.y < tank.getY() + 40 &&
                        s.y > tank.getY() && s.y < tank.getY() + 60) {
                    s.isLive = false;
                    tank.isLive = false;
                    //当我的子弹击中敌人坦克后，将enenmyTank 从Vector 拿掉
                    enemyTanks.remove(tank);
                    //当我方击毁一个enemyTanks敌人坦克时，就对数据allEnemyTankNum++
                    //解读：因为enemyTank 可以是 Hero 也可以是 EnemyTank
                    if (tank instanceof EnemyTank){
                        Recorder.addAllEnemyTankNum();
                    }
                    //这里敌人坦克被击中
                    //创建Bomb对象，加入到bombs集合
                    Bomb bomb = new Bomb(tank.getX(), tank.getY());
                    bombs.add(bomb);
                }
                break;
            case 1://敌人坦克向右
            case 3://敌人坦克向下
                if (s.x > tank.getX() && s.y < tank.getY() + 60 &&
                        s.y > tank.getY() && s.y < tank.getY() + 40) {
                    s.isLive = false;
                    tank.isLive = false;
                    //当我的子弹击中敌人坦克后，将enenmyTank 从Vector 拿掉
                    //当我方击毁一个enemyTanks敌人坦克时，就对数据allEnemyTankNum++
                    //解读：因为enemyTank 可以是 Hero 也可以是 EnemyTank
                    if (tank instanceof EnemyTank){
                        Recorder.addAllEnemyTankNum();
                    }
                    Bomb bomb = new Bomb(tank.getX(), tank.getY());
                    bombs.add(bomb);
                }
                break;

        }

    }

    //有字符输出时，该方法就会触发
    @Override
    public void keyTyped(KeyEvent e) {

    }

    //当某个键按下，该方法会触发
    @Override
    public void keyPressed(KeyEvent e) {

        if (e.getKeyCode() == KeyEvent.VK_W) {//上
            //改变坦克方向
            hero.setDirect(0);
            //让坦克动起来
            if (hero.getY()>0){
                hero.moveUp();
            }
        } else if (e.getKeyCode() == KeyEvent.VK_S) {//下
            hero.setDirect(2);
            if (hero.getY()+60<750){
                hero.moveDown();
            }
        } else if (e.getKeyCode() == KeyEvent.VK_A) {//左
            hero.setDirect(3);
            if (hero.getX()>0){
                hero.moveLeft();
            }
        } else if (e.getKeyCode() == KeyEvent.VK_D) {//右
            hero.setDirect(1);
            if (hero.getX()+60<1000)
            hero.moveRight();
        }

        //如果用户按下的是J，就发射
        if (e.getKeyCode() == KeyEvent.VK_J) {
            //判断hero的子弹是否销毁---发射一颗子弹
            if (hero.shot==null|| !hero.shot.isLive) {
                //线程销毁后，不代表shot对象为空,所以还需要判断shot的声明周期，才可以继续发子弹
                hero.shotEnemyTank();
            }
            //发射多颗子弹
            hero.shotEnemyTank();
        }

        //重绘
        repaint();
    }

    //当某个键释放(松开)，该方法会触发
    @Override
    public void keyReleased(KeyEvent e) {

    }

    //添加线程的方法，确保子弹可以重绘
    @Override
    public void run() {//每隔 100毫秒，重绘区域，刷新绘图区域，子弹就移动
        while (true) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            //判断我们坦克是否击中别人
            hitEnemy();
            //判断敌人坦克是否击中我们
//            hitHero();
            this.repaint();
        }
    }
}

我方坦克类：Hero

import java.util.Vector;

//自己的坦克，继承坦克父类
public class Hero extends Tank {
    //定义一个Shot对象，表示一个射击（线程）
    Shot shot = null;
    //可以发射多颗子弹
    Vector<Shot> shots = new Vector<>();
    public Hero(int x, int y) {
        super(x, y);
    }
    public void  shotEnemyTank(){
        //发多颗子弹怎么办？ 控制在我们的面板上，最多只有5颗子弹
        if (shots.size()==5){
            return;
        }
        //创建Shot对象，根据当前Hero对象的位置和方向来创建Shot
        switch (getDirect()){//得到Hero对象方向
            case 0://上
                shot = new Shot(getX()+20,getY(),0);
                break;
            case 1://右
                shot = new Shot(getX()+60,getY()+20,1);
                break;
            case 2://下
                shot = new Shot(getX()+20,getY()+60,2);
                break;
            case 3://左
                shot = new Shot(getX(),getY()+20,3);
                break;
        }

        //把新创建的shot放入到shots中
        shots.add(shot);
        //启动我们的shot线程
        new Thread(shot).start();
    }
}

敌方坦克类：EnemyTank

import java.util.Vector;

//敌人坦克
public class EnemyTank extends Tank implements Runnable {
    //给敌人坦克类，使用Vector 保存多个Shot
    Vector<Shot> shots = new Vector<>();

    //增加成员，EnemyTank 可以得到敌人坦克的Vector
    //分析：
    //1，
    Vector<EnemyTank> enemyTanks = new Vector<>();
    //定义敌人坦克的存活属性
    boolean isLive = true;

    public EnemyTank(int x, int y) {
        super(x, y);
    }

    //这里提供一个方法，可以将MyPanel的成员  Vector<EnemyTank> enemyTanks = new Vector<>();
    //设置到 EnemyTank 的成员 enemyTanks
    public void setEnemyTanks(Vector<EnemyTank> enemyTanks) {
        this.enemyTanks = enemyTanks;
    }

    //编写方法，判断当前这个敌人坦克，是否和  enemyTanks  中的其他坦克发生重叠或碰撞
    public boolean isTouchEnemyTank() {
        //判断当前这个敌人坦克（this）的方向
        switch (this.getDirect()) {
            case 0://上
                //让当前敌人坦克和其他所有的敌人坦克比较
                for (int i = 0; i < enemyTanks.size(); i++) {
                    //取出敌人所有坦克
                    EnemyTank enemyTank = enemyTanks.get(i);
                    //使得取出的坦克不和自己比较
                    if (enemyTank != this) {
                        //1,如果其他敌人坦克是上/下  x的范围[enemyTank.getX(),enemyTank.getX()+40]
                        //                        Y的范围[enemyTank.getY(),enemyTank.getY()+60]
                        if (enemyTank.getDirect() == 0 || enemyTank.getDirect() == 2) {
                            //2,当前坦克左上角的坐标 [this.getX,this.getY]
                            if (this.getX() >= enemyTank.getX()
                                    && this.getX() <= enemyTank.getX() + 40
                                    && this.getY() >= enemyTank.getY()
                                    && this.getY() <= enemyTank.getY() + 60) {
                                return true;
                            }
                            //2,当前坦克右上角的坐标 [this.getX+40,this.getY]
                            if (this.getX() + 40 >= enemyTank.getX()
                                    && this.getX()+40 <= enemyTank.getX() + 40
                                    && this.getY() >= enemyTank.getY()
                                    && this.getY() <= enemyTank.getY() + 60) {
                                return true;
                            }
                        }
                        //1，如果敌人坦克是左/右:X的范围[enemyTank.getX(),enemyTank.getX()+60]
                        //                     Y的范围[enemyTank.getY(),enemyTank.getY()+40]
                        if (enemyTank.getDirect() == 1 || enemyTank.getDirect() == 3) {
                            //2,当前坦克左上角的坐标 [this.getX,this.getY]
                            if (this.getX() >= enemyTank.getX()
                                    && this.getX() <= enemyTank.getX() + 60
                                    && this.getY() >= enemyTank.getY()
                                    && this.getY() <= enemyTank.getY() + 40) {
                                return true;
                            }
                            //2,当前坦克右上角的坐标 [this.getX+40,this.getY]
                            if (this.getX() + 40 >= enemyTank.getX()
                                    && this.getX() + 40 <= enemyTank.getX() + 60
                                    && this.getY() >= enemyTank.getY()
                                    && this.getY() <= enemyTank.getY() + 40) {
                                return true;
                            }
                        }

                    }
                }
                break;
            case 1://右
                //让当前敌人坦克和其他所有的敌人坦克比较
                for (int i = 0; i < enemyTanks.size(); i++) {
                    //取出敌人所有坦克
                    EnemyTank enemyTank = enemyTanks.get(i);
                    //使得取出的坦克不和自己比较
                    if (enemyTank != this) {
                        //1,如果其他敌人坦克是上/下  x的范围[enemyTank.getX(),enemyTank.getX()+40]
                        //                        Y的范围[enemyTank.getY(),enemyTank.getY()+60]
                        if (enemyTank.getDirect() == 0 || enemyTank.getDirect() == 2) {
                            //2,当前坦克右上角的坐标 [this.getX+60,this.getY]
                            if (this.getX() + 60 >= enemyTank.getX()
                                    && this.getX() + 60 <= enemyTank.getX() + 40
                                    && this.getY() >= enemyTank.getY()
                                    && this.getY() <= enemyTank.getY() + 60) {
                                return true;
                            }
                            //3,当前坦克右下角的坐标 [this.getX+60,this.getY+40]
                            if (this.getX() + 60 >= enemyTank.getX()
                                    && this.getX() + 60 <= enemyTank.getX() + 40
                                    && this.getY() + 40 >= enemyTank.getY()
                                    && this.getY() + 40 <= enemyTank.getY() + 60) {
                                return true;
                            }
                        }
                        //1，如果敌人坦克是左/右:X的范围[enemyTank.getX(),enemyTank.getX()+60]
                        //                     Y的范围[enemyTank.getY(),enemyTank.getY()+40]
                        if (enemyTank.getDirect() == 1 || enemyTank.getDirect() == 3) {
                            //2,当前坦克右上角的坐标 [this.getX+60,this.getY]
                            if (this.getX() + 60 >= enemyTank.getX()
                                    && this.getX() + 60 <= enemyTank.getX() + 60
                                    && this.getY() >= enemyTank.getY()
                                    && this.getY() <= enemyTank.getY() + 40) {
                                return true;
                            }
                            //2,当前坦克右下角的坐标 [this.getX+60,this.getY+40]
                            if (this.getX() + 60 >= enemyTank.getX()
                                    && this.getX() + 60 <= enemyTank.getX() + 60
                                    && this.getY() + 40 >= enemyTank.getY()
                                    && this.getY() + 40 <= enemyTank.getY() + 40) {
                                return true;
                            }
                        }

                    }
                }
                break;
            case 2:
                //让当前敌人坦克和其他所有的敌人坦克比较
                for (int i = 0; i < enemyTanks.size(); i++) {
                    //取出敌人所有坦克
                    EnemyTank enemyTank = enemyTanks.get(i);
                    //使得取出的坦克不和自己比较
                    if (enemyTank != this) {
                        //1,如果其他敌人坦克是上/下  x的范围[enemyTank.getX(),enemyTank.getX()+40]
                        //                        Y的范围[enemyTank.getY(),enemyTank.getY()+60]
                        if (enemyTank.getDirect() == 0 || enemyTank.getDirect() == 2) {
                            //2,当前坦克左下角的坐标 [this.getX,this.getY+60]
                            if (this.getX() >= enemyTank.getX()
                                    && this.getX() <= enemyTank.getX() + 40
                                    && this.getY() + 60 >= enemyTank.getY()
                                    && this.getY() + 60 <= enemyTank.getY() + 60) {
                                return true;
                            }
                            //3,当前坦克右下角的坐标 [this.getX+40,this.getY+60]
                            if (this.getX() + 40 >= enemyTank.getX()
                                    && this.getX() + 40 <= enemyTank.getX() + 40
                                    && this.getY() + 60 >= enemyTank.getY()
                                    && this.getY() + 60 <= enemyTank.getY() + 60) {
                                return true;
                            }
                        }
                        //1，如果敌人坦克是左/右:X的范围[enemyTank.getX(),enemyTank.getX()+60]
                        //                     Y的范围[enemyTank.getY(),enemyTank.getY()+40]
                        if (enemyTank.getDirect() == 1 || enemyTank.getDirect() == 3) {
                            //2,当前坦克左下角的坐标 [this.getX,this.getY+60]
                            if (this.getX() >= enemyTank.getX()
                                    && this.getX() <= enemyTank.getX() + 60
                                    && this.getY() + 60 >= enemyTank.getY()
                                    && this.getY() + 60 <= enemyTank.getY() + 40) {
                                return true;
                            }
                            //3,当前坦克右下角的坐标 [this.getX+40,this.getY+60]
                            if (this.getX() + 40 >= enemyTank.getX()
                                    && this.getX() + 40 <= enemyTank.getX() + 60
                                    && this.getY() + 60 >= enemyTank.getY()
                                    && this.getY() + 60 <= enemyTank.getY() + 40) {
                                return true;
                            }
                        }

                    }
                }
                break;
            case 3:
                //让当前敌人坦克和其他所有的敌人坦克比较
                for (int i = 0; i < enemyTanks.size(); i++) {
                    //取出敌人所有坦克
                    EnemyTank enemyTank = enemyTanks.get(i);
                    //使得取出的坦克不和自己比较
                    if (enemyTank != this) {
                        //1,如果其他敌人坦克是上/下  x的范围[enemyTank.getX(),enemyTank.getX()+40]
                        //                        Y的范围[enemyTank.getY(),enemyTank.getY()+60]
                        if (enemyTank.getDirect() == 0 || enemyTank.getDirect() == 2) {
                            //2,当前坦克左上角的坐标 [this.getX,this.getY]
                            if (this.getX() >= enemyTank.getX()
                                    && this.getX() <= enemyTank.getX() + 40
                                    && this.getY() >= enemyTank.getY()
                                    && this.getY() <= enemyTank.getY() + 60) {
                                return true;
                            }
                            //3,当前坦克左下角的坐标 [this.getX,this.getY+40]
                            if (this.getX() >= enemyTank.getX()
                                    && this.getX() <= enemyTank.getX() + 40
                                    && this.getY() + 40 >= enemyTank.getY()
                                    && this.getY() + 40 <= enemyTank.getY() + 60) {
                                return true;
                            }
                        }
                        //1，如果敌人坦克是左/右:X的范围[enemyTank.getX(),enemyTank.getX()+60]
                        //                     Y的范围[enemyTank.getY(),enemyTank.getY()+40]
                        if (enemyTank.getDirect() == 1 || enemyTank.getDirect() == 3) {
                            //2,当前坦克左上角的坐标 [this.getX,this.getY]
                            if (this.getX() >= enemyTank.getX()
                                    && this.getX() <= enemyTank.getX() + 60
                                    && this.getY() >= enemyTank.getY()
                                    && this.getY() <= enemyTank.getY() + 40) {
                                return true;
                            }
                            //3,当前坦克左下角的坐标 [this.getX,this.getY+40]
                            if (this.getX() >= enemyTank.getX()
                                    && this.getX() <= enemyTank.getX() + 60
                                    && this.getY() + 40 >= enemyTank.getY()
                                    && this.getY() + 40 <= enemyTank.getY() + 40) {
                                return true;
                            }
                        }

                    }
                }
                break;
        }
        return false;
    }

    @Override
    public void run() {
        while (true) {

            //这里我们判断如果shots size（） = 0; 创建一颗子弹，放入到shots集合，并启动
            if (isLive && shots.size() < 1) {
                Shot s = null;
                //判断坦克的方向，创建对应的子弹
                switch (getDirect()) {
                    case 0:
                        s = new Shot(getX() + 20, getY(), 0);
                        break;
                    case 1:
                        s = new Shot(getX() + 60, getY() + 20, 1);
                        break;
                    case 2:
                        s = new Shot(getX() + 20, getY() + 60, 2);
                        break;
                    case 3:
                        s = new Shot(getX(), getY() + 20, 3);
                        break;
                }
                shots.add(s);
                new Thread(s).start();
            }
            //控制坦克移动范围
            switch (getDirect()) {
                //根据坦克的方向来进行移动
                case 0://向上
                    //让坦克保持一个方向，走30步
                    for (int i = 0; i < 30; i++) {
                        if (getY() > 0 && !isTouchEnemyTank()) {
                            moveUp();
                        }
                        //休眠50好眠
                        try {
                            Thread.sleep(50);
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }
                    break;
                case 1://向右
                    //让坦克保持一个方向，走30步
                    for (int i = 0; i < 30; i++) {
                        if (getX() + 60 < 1000&& !isTouchEnemyTank()) {
                            moveRight();
                        }
                        //休眠50好眠
                        try {
                            Thread.sleep(50);
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }
                    break;
                case 2://向下
                    //让坦克保持一个方向，走30步
                    for (int i = 0; i < 30; i++) {
                        if (getY() + 60 < 750&& !isTouchEnemyTank()) {
                            moveDown();
                        }
                        //休眠50好眠
                        try {
                            Thread.sleep(50);
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }
                    break;
                case 3://向左
                    //让坦克保持一个方向，走30步
                    for (int i = 0; i < 10; i++) {
                        if (getX() > 0&& !isTouchEnemyTank()) {
                            moveLeft();
                        }

                        //休眠50好眠
                        try {
                            Thread.sleep(50);
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }

                    break;
            }
            //休眠50好眠
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            // 然后随机的改变坦克方向0-3
            setDirect((int) (Math.random() * 4));  //0-3

            //一旦写并发程序，一定要考虑清楚，该线程什么时候结束
            if (!isLive) {
                break;
            }
        }
    }
}

炸弹类：Bomb

//炸弹类
public class Bomb {
    int x, y;//炸弹的坐标
    int life = 9;//炸弹的生命周期
    boolean isLive = true;//是否还存活

    public Bomb(int x, int y) {
        this.x = x;
        this.y = y;
    }
    //减少生命值
    public void lifeDown() {//配合图片出现爆炸效果
        if (life > 0) {
            life--;
        } else {
            isLive = false;
        }
    }

}