Java初学笔记23-【坦克游戏——java部分代码】

坦克游戏部分代码

1.Tank

package project.tankgame04;

/**
 * @ClassName: Tank
 * @Description: 坦克父类
 */
public class Tank {
    private int x; //坦克的横坐标
    private int y; //坦克的纵坐标
    private int direction; //坦克方向 0123 上下左右
    private int speed = 3; //坦克速度

    /**
     * 坦克存活状态
     */
    private boolean t_sur = true;

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

    /**
     * 坦克上移动方法
     */
    public void moveUp(){
        y -= speed;
    }

    /**
     * 坦克右移动方法
     */
    public void moveRight(){
        x += speed;
    }

    /**
     * 坦克下移动方法
     */
    public void moveDown(){
        y += speed;
    }

    /**
     * 坦克左移动方法
     */
    public void moveLeft(){
        x -= speed;
    }

    /**
     * 坦克开火的方法
     */
    public void fire(){

    }

    public int getDirection() {
        return direction;
    }

    public void setDirection(int direction) {
        this.direction = direction;
    }

    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 getSpeed() {
        return speed;
    }

    public void setSpeed(int speed) {
        this.speed = speed;
    }

    public boolean isT_sur() {
        return t_sur;
    }

    public void setT_sur(boolean t_sur) {
        this.t_sur = t_sur;
    }
}

2. MyTank

package project.tankgame04;


import java.util.Vector;

/**
 * @ClassName: MyTank
 * @Description: 自己的坦克
 */
public class MyTank extends Tank {  //继承父类坦克

    /**
     * 属性：自己的子弹线程
     */
    MyBullet myBullet = null;

    /**
     * Vector集合：存储自己的子弹集合
     */
    Vector<MyBullet> myBullets = new Vector<>();

    /**
     * 自己的坦克-构造器
     */
    public MyTank(int x, int y) {
        super(x, y);
    }

    /**
     * 方法：自己坦克开火。
     * 实例化并启动自己的子弹线程
     */
    @Override
    public void fire() {
        //游戏面板控制自己的子弹最多为8个
        if(myBullets.size() == 8){
            return;
        }
        switch (getDirection()){
            case 0:
                myBullet = new MyBullet(getX()+20,getY(),getDirection());
                break;
            case 1:
                myBullet = new MyBullet(getX()+60,getY()+20,getDirection());
                break;
            case 2:
                myBullet = new MyBullet(getX()+20,getY()+60,getDirection());
                break;
            case 3:
                myBullet = new MyBullet(getX(),getY()+20,getDirection());
                break;
        }
        //将自己的子弹线程加入集合
        myBullets.add(myBullet);
        //启动子弹线程
        new Thread(myBullet).start();
    }

}

3. EnemyTank

package project.tankgame04;

import java.util.Vector;

/**
 * @ClassName: EnemyTank
 * @Description: 敌人的坦克线程
 */
public class EnemyTank extends Tank implements Runnable{
    /**
     * Vector集合：每个敌人坦克用集合存放自己的多个子弹线程
     */
    Vector<EnemyBullet> e_Bullets_Ve = new Vector<>();

    /**
     * 敌人坦克的构造器
     * @param x
     * @param y
     */
    public EnemyTank(int x, int y) {
        super(x, y);
    }

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

            //判断此时敌人坦克是否存活，以及坦克里面的子弹线程是否还有
            //使敌人坦克可以发射3颗子弹
            if(isT_sur() && e_Bullets_Ve.size() < 5){

                EnemyBullet  bul = null;
                //根据此时坦克的位置创建敌人子弹线程
                switch (getDirection()){
                    case 0:
                        bul = new EnemyBullet(getX()+20,getY(),0);
                        break;
                    case 1:
                        bul = new EnemyBullet(getX()+60,getY()+20,1);
                        break;
                    case 2:
                        bul = new EnemyBullet(getX()+20,getY()+60,2);
                        break;
                    case 3:
                        bul = new EnemyBullet(getX(),getY()+20,3);
                        break;
                }
                //将敌人子弹线程加入集合
                e_Bullets_Ve.add(bul);
                //启动敌人子弹线程
                new Thread(bul).start();
            }
            switch (getDirection()){
                case 0:
                    for (int i = 0; i < 10; i++) {
                        try {
                            Thread.sleep(50);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        if(getY() > 0){
                            moveUp();
                        }
                    }
                    break;
                case 1:
                    for (int i = 0; i < 10; i++) {
                        try {
                            Thread.sleep(50);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        if(getX() + 60 < 1000){
                            moveRight();
                        }
                    }
                    break;
                case 2:
                    for (int i = 0; i < 10; i++) {
                        try {
                            Thread.sleep(50);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        if(getY() + 60 < 750){
                            moveDown();
                        }
                    }
                    break;
                case 3:
                    for (int i = 0; i < 10; i++) {
                        try {
                            Thread.sleep(50);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        if(getX() > 0){
                            moveLeft();
                        }
                    }
                    break;
            }

            //为敌人坦克设置随机方向
            setDirection((int)(Math.random()*4));
            //敌人坦克死亡，结束线程
            if(!isT_sur()){
                System.out.println("敌人坦克线程： "+ Thread.currentThread().getName()
                        +" 已经结束");
                break;
            }
        }
    }
}

4. MyBullet

package project.tankgame04;

/**
 * @Package: project.tankgame03
 * @ClassName: MyBullet
 * @Author: 爱吃凉拌辣芒果
 * @CreateTime: 2021/10/28 9:57
 * @Description:  我的子弹线程
 */
public class MyBullet extends Bullet implements Runnable{

    /**
     * 构造函数：初始化我的子弹原始位置以及方向
     *
     * @param b_x
     * @param b_y
     * @param b_direction
     */
    public MyBullet(int b_x, int b_y, int b_direction) {
        super(b_x, b_y, b_direction);
    }

    @Override
    public void run() {
        while (true){
            //休眠50毫秒
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //判断自己的子弹方向，沿着这一方向移动
            switch (getB_direction()){
                case 0:
                    setB_y(getB_y()-getB_speed());
                    break;
                case 1:
                    setB_x(getB_x()+getB_speed());
                    break;
                case 2:
                    setB_y(getB_y()+getB_speed());
                    break;
                case 3:
                    setB_x(getB_x()-getB_speed());
                    break;
            }
            System.out.println("我的子弹坐标"+getB_x()+" "+getB_y());
            //如果自己的子弹超出世界边界，或者生命状态在其他地方被设置成false，则
            //设置子弹线程的生命状态为false，并且结束线程
            if(!(getB_x()>=0 && getB_x()<=1000 && getB_y()>=0 &&getB_y()<=750)
                    || isB_sur() == false){
                setB_sur(false);
                System.out.println("我的子弹线程 "+ Thread.currentThread().getName() +" 已经结束");
                break;
            }
        }
    }
}

5. EnemyBullet

package project.tankgame04;

/**
 * @Package: project.tankgame03
 * @ClassName: EnemyBullet
 * @Author: 爱吃凉拌辣芒果
 * @CreateTime: 2021/10/28 14:10
 * @Description:
 */
public class EnemyBullet extends Bullet implements Runnable{
    /**
     * 构造函数：初始化帝人子弹的原始位置以及方向
     *
     * @param b_x
     * @param b_y
     * @param b_direction
     */
    public EnemyBullet(int b_x, int b_y, int b_direction) {
        super(b_x, b_y, b_direction);
    }

    @Override
    public void run() {
        while (true){
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            switch (getB_direction()){
                case 0:
                    setB_y(getB_y()-getB_speed());
                    break;
                case 1:
                    setB_x(getB_x()+getB_speed());
                    break;
                case 2:
                    setB_y(getB_y()+getB_speed());
                    break;
                case 3:
                    setB_x(getB_x()-getB_speed());
                    break;
            }
            System.out.println("敌人子弹坐标"+getB_x()+" "+getB_y());
            if(!(getB_x()>=0 && getB_x()<=1000 && getB_y()>=0 &&getB_y()<=750)
                    || !isB_sur()){
                setB_sur(false);
                System.out.println("敌人子弹线程 "+ Thread.currentThread().getName() +" 已经结束");
                break;
            }
        }
    }
}

6. Bullet

package project.tankgame04;

/**
 * @Package: project.tankgame03
 * @ClassName: Bullet
 * @Author: 爱吃凉拌辣芒果
 * @CreateTime: 2021/10/28 9:50
 * @Description:  子弹父类
 */
public class Bullet {
    /**
     * 子弹的b_x位置
     */
    private int b_x;
    /**
     * 子弹的b_y位置
     */
    private int b_y;
    /**
     * 子弹的方向 0123 上右下左
     */
    private int b_direction;
    /**
     * 子弹的速度  默认3
     */
    private int b_speed = 3;
    /**
     * 子弹存活状态
     */
    private boolean b_sur = true;

    /**
     * 构造函数：初始化子弹的原始位置以及方向
     * @param b_x
     * @param b_y
     * @param b_direction
     */
    public Bullet(int b_x, int b_y, int b_direction) {
        this.b_x = b_x;
        this.b_y = b_y;
        this.b_direction = b_direction;
    }

    /**
     * 获取子弹x坐标
     * @return
     */
    public int getB_x() {
        return b_x;
    }

    /**
     * 设置子弹x坐标
     * @return
     */
    public void setB_x(int b_x) {
        this.b_x = b_x;
    }

    /**
     * 获取子弹y坐标
     * @return
     */
    public int getB_y() {
        return b_y;
    }

    /**
     * 设置子弹y坐标
     * @return
     */
    public void setB_y(int b_y) {
        this.b_y = b_y;
    }

    /**
     * 获取子弹方向
     * @return
     */
    public int getB_direction() {
        return b_direction;
    }

    /**
     * 设置获取子弹方向
     * @return
     */
    public void setB_direction(int b_direction) {
        this.b_direction = b_direction;
    }


    /**
     * 获取子弹速度
     * @return
     */
    public int getB_speed() {
        return b_speed;
    }


    /**
     * 设置子弹速度
     * @return
     */
    public void setB_speed(int b_speed) {
        this.b_speed = b_speed;
    }

    /**
     * 获取子弹存活状态
     * @return
     */
    public boolean isB_sur() {
        return b_sur;
    }

    /**
     * 设置子弹存活状态
     * @return
     */
    public void setB_sur(boolean b_sur) {
        this.b_sur = b_sur;
    }
}

7. Bomb

package project.tankgame04;

/**
 * @Package: project.tankgame03
 * @ClassName: Bomb
 * @Author: 爱吃凉拌辣芒果
 * @CreateTime: 2021/10/29 9:41
 * @Description: 炸弹特效类
 */
public class Bomb {
    /**
     * 炸弹的X坐标
     */
    int x;

    /**
     * 炸弹的Y坐标
     */
    int y;

    /**
     * 炸弹的生命周期
     */
    int life = 9;

    /**
     * 炸弹的存活状态
     */
    boolean isLive = true;

    /**
     * 炸弹构造器，初始化X,Y坐标
     * @param x
     * @param y
     */
    public Bomb(int x, int y) {
        this.x = x;
        this.y = y;
    }

    /**
     * 使炸弹图片生命值逐渐减少
     */
    public void cutLife(){
        if(isLive && life>=0){
            life--;
        }else{
            isLive = false;
        }
    }
}

8.TankPanel

package project.tankgame04;

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

/**
 * @ClassName: TankPanel
 * @Description: 坦克游戏区域————“画板”
 */
public class TankPanel extends JPanel implements KeyListener,Runnable{

    /**
     * 定义我的坦克
     */
    MyTank mytank = null;

    /**
     * Vector集合：集合中存放敌人坦克
     */
    Vector<EnemyTank> enemyTanks = new Vector<>();

    /**
     * 敌人坦克数量
     */
    int enemyTankNum = 3;

    /**
     * Vector集合：存放炸弹特效
     * 当自己的子弹击中敌人坦克时，加入一个炸弹
     */
    Vector<Bomb> bombs = new Vector<>();

    /**
     * 声明3个存放炸弹特效的变量image1，image2，image3
     */
    Image image1 = null;
    Image image2 = null;
    Image image3 = null;

    /**
     * “画板”构造器
     */
    public TankPanel(){
        //初始化我的坦克
        mytank = new MyTank(100,600);
        //初始化敌人坦克，默认朝下
        for (int i = 0; i < enemyTankNum; i++) {
            EnemyTank enemyTank = new EnemyTank(100 * (i + 1), 0);
            //初始化敌人的子弹
            EnemyBullet enemyBullet = new EnemyBullet(enemyTank.getX() + 20,
                    enemyTank.getY() + 60, 2);
            //把敌人子弹加入到集合中
            enemyTank.e_Bullets_Ve.add(enemyBullet);
            //启动敌人子弹线程
            new Thread(enemyBullet).start();
            enemyTank.setDirection(2);
            //把敌人坦克加入到集合中
            enemyTanks.add(enemyTank);
            new Thread(enemyTank).start();
        }
        //初始化炸弹特效图片
        image1 = Toolkit.getDefaultToolkit()
                .getImage(TankPanel.class.getResource("/bomb_1.gif"));
        image2 = Toolkit.getDefaultToolkit()
                .getImage(TankPanel.class.getResource("/bomb_2.gif"));
        image3 = Toolkit.getDefaultToolkit()
                .getImage(TankPanel.class.getResource("/bomb_3.gif"));
    }

    /**
     * paint绘画方法
     * @param g
     */
    @Override
    public void paint(Graphics g) {
        super.paint(g);
        //默认黑色矩形背景
        g.setColor(Color.BLACK);
        //默认黑色矩形1000 × 750
        g.fillRect(0,0,1000,750);

        //绘制-自己的坦克
        if(mytank != null && mytank.isT_sur()){
            drawTank(mytank.getX(),mytank.getY(),g,mytank.getDirection(),0);
        }

        //绘制敌人的坦克
        //判断敌人坦克集合不为空
        if(enemyTanks != null){
            //遍历敌人坦克集合
            for (int i = 0; i < enemyTanks.size(); i++) {
                //取出每个敌人坦克
                EnemyTank enemyTank = enemyTanks.get(i);
                //判断每个坦克的生命状态
                if(enemyTank.isT_sur()) {
                    drawTank(enemyTank.getX(), enemyTank.getY(), g,
                            enemyTank.getDirection(), 1);
                }else{
                    //坦克的生命状态为false，除了不绘画之外，还需要在
                    //集合中移除
                    enemyTanks.remove(enemyTank);
                }
            }
        }

        //绘制自己的子弹
        //遍历自己的子弹集合
        if(mytank.myBullets != null){
            for (int i = 0; i < mytank.myBullets.size(); i++) {
                //取出每个子弹
                MyBullet myBullet = mytank.myBullets.get(i);
                //判断子弹的生命状态
                if(myBullet != null && myBullet.isB_sur()){
                    g.setColor(Color.RED);
                    g.fillOval(myBullet.getB_x(),myBullet.getB_y(),5,5);
                }else{
                    mytank.myBullets.remove(myBullet);
                }
            }
        }

        //绘制敌人的子弹
        //判断敌人坦克集合不为空
        if(enemyTanks != null ){
            //遍历敌人坦克集合
            for (int i = 0; i < enemyTanks.size(); i++) {
                //取出每个敌人坦克
                EnemyTank enemyTank = enemyTanks.get(i);
                //判断敌人坦克的子弹集合不为空
                if(enemyTank.e_Bullets_Ve != null){
                    //遍历敌人坦克的子弹集合
                    for (int j = 0; j < enemyTank.e_Bullets_Ve.size(); j++) {
                        //取出每个敌人坦克的子弹
                        EnemyBullet enemyBullet = enemyTank.e_Bullets_Ve.get(j);
                        //判断每个敌人子弹的状态
                        if(enemyBullet.isB_sur()){
                            g.setColor(Color.yellow);
                            g.fillOval(enemyBullet.getB_x(), enemyBullet.getB_y(),
                                    5, 5);
                        }else{
                            //敌人子弹的生命状态为false，除了不绘画之外
                            // 还需要在集合中移除
                            enemyTank.e_Bullets_Ve.remove(enemyBullet);
                        }
                    }
                }
            }
        }

        //绘制炸弹特效
        //遍历炸弹集合
        for (int i = 0; i < bombs.size(); i++) {
            //取出每一个炸弹
            Bomb bomb = bombs.get(i);
            if(bomb.isLive){
                //分阶段绘制炸弹
                if(bomb.life > 6){
                    g.drawImage(image1,bomb.x,bomb.y,50,50,this);
                    bomb.cutLife();
                }else if(bomb.life > 3){
                    g.drawImage(image2,bomb.x,bomb.y,50,50,this);
                    bomb.cutLife();
                }else{
                    g.drawImage(image3,bomb.x,bomb.y,50,50,this);
                    bomb.cutLife();
                }
            }else{
                bombs.remove(bomb);
            }
        }
    }

    /**
     * 画坦克的方法
     * @param x 坦克左上角的x坐标
     * @param y 坦克右上角的x坐标
     * @param g 画笔
     * @param direct  坦克的方向（上下左右）
     * @param type 坦克类型
     */
    public void drawTank(int x, int y, Graphics g,int direct,int type){
        //根据不同类型的坦克，设置不同的颜色
        switch (type){
            case 0://我们的坦克
                g.setColor(Color.pink);
                break;
            case 1: //敌人坦克
                g.setColor(Color.yellow);
                break;
        }

        //根据坦克方向，绘制不同的坦克
        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,y+20,x+30,y+20);  //坦克炮筒
                break;
        }
    }

    /**
     * 字符输出事件方法
     * @param e
     */
    @Override
    public void keyTyped(KeyEvent e) {

    }

    /**
     * 键盘按下事件方法
     * WDSA 坦克的方向：上右下左
     * @param e
     */
    @Override
    public void keyPressed(KeyEvent e) {
        if(e.getKeyCode() == KeyEvent.VK_W){
            mytank.setDirection(0);  //更改坦克的方向
            if(mytank.getY()>0){
                mytank.moveUp(); //使坦克向上走
            }
        }else if(e.getKeyCode() == KeyEvent.VK_D){
            mytank.setDirection(1);
            if(mytank.getX()+60<1000){
                mytank.moveRight(); //使坦克向右走
            }
        }else if(e.getKeyCode() == KeyEvent.VK_S){
            mytank.setDirection(2);
            if(mytank.getY()+60<750){
                mytank.moveDown(); //使坦克向下走
            }
        }else if(e.getKeyCode() == KeyEvent.VK_A){
            mytank.setDirection(3);
            if(mytank.getX()>0){
                mytank.moveLeft(); //使坦克向左走
            }
        }
        //按下J键 子弹射击
        if(mytank != null && mytank.isT_sur()){
            if(e.getKeyCode() == KeyEvent.VK_J){
                mytank.fire();
            }
        }
        this.repaint();
    }

    /**
     * 键盘弹起事件方法
     * @param e
     */
    @Override
    public void keyReleased(KeyEvent e) {

    }

    /**
     * “画板”刷新
     */
    @Override
    public void run() {
        while (true){
            //画板隔0.1秒刷新一次
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            killEnenmy();
            killMyTank();
            this.repaint();
        }
    }

    /**
     * 方法：自己的子弹打敌人坦克
     * 设置自己的子弹和敌人坦克的生命状态
     * @param myBullet  自己的子弹
     * @param enemyTank  敌人坦克
     */
    public void bitEnenmy(MyBullet myBullet, EnemyTank enemyTank){
        switch (enemyTank.getDirection()){
            case 0:
            case 2:
                if(myBullet.getB_x() >= enemyTank.getX() && myBullet.getB_x() <= enemyTank.getX()+40
                        && myBullet.getB_y() >= enemyTank.getY() && myBullet.getB_y() <= enemyTank.getY()+60 ){
                    //子弹状态：FALSE
                    myBullet.setB_sur(false);
                    //坦克状态：FALSE
                    enemyTank.setT_sur(false);
                    for (int i = 0; i < enemyTank.e_Bullets_Ve.size(); i++) {
                        EnemyBullet enemyBullet = enemyTank.e_Bullets_Ve.get(i);
                        enemyBullet.setB_sur(false);
                    }
                    //把炸弹特效放在敌人位置处，并加入集合
                    bombs.add(new Bomb(enemyTank.getX(),enemyTank.getY()));
                }
                break;
            case 1:
            case 3:
                if(myBullet.getB_x() >= enemyTank.getX() && myBullet.getB_x() <= enemyTank.getX()+60
                        && myBullet.getB_y() >= enemyTank.getY() && myBullet.getB_y() <= enemyTank.getY()+40 ){
                    //子弹状态：FALSE
                    myBullet.setB_sur(false);
                    //坦克状态：FALSE
                    enemyTank.setT_sur(false);
                    for (int i = 0; i < enemyTank.e_Bullets_Ve.size(); i++) {
                        EnemyBullet enemyBullet = enemyTank.e_Bullets_Ve.get(i);
                        enemyBullet.setB_sur(false);
                    }
                    //把炸弹特效放在敌人位置处，并加入集合
                    bombs.add(new Bomb(enemyTank.getX(),enemyTank.getY()));
                }
                break;
        }
    }

    /**
     * 取出自己的子弹集合与敌人坦克进行遍历看是否击中
     */
    public void killEnenmy(){
        //遍历自己的坦克子弹,取出每个子弹
        for (int i = 0; i < mytank.myBullets.size(); i++) {
            MyBullet myBullet = mytank.myBullets.get(i);
            //判断自己的子弹打中敌人
            for (int j = 0; j < enemyTanks.size(); j++) {
                if (enemyTanks != null && myBullet!= null){
                    EnemyTank enemyTank = enemyTanks.get(j);
                    bitEnenmy(myBullet,enemyTank);
                }
            }
        }
    }

    /**
     * 方法：敌人的子弹打自己坦克
     * 设置敌人的子弹和自己人坦克的生命状态
     * @param enemyBullet  敌人的子弹
     * @param mytank  自己的坦克
     */
    public void bitMyTank(EnemyBullet enemyBullet, MyTank mytank){
        if(mytank != null && mytank.isT_sur()) {
            switch (mytank.getDirection()) {
                case 0:
                case 2:
                    if (enemyBullet.getB_x() >= mytank.getX() && enemyBullet.getB_x() <= mytank.getX() + 40
                            && enemyBullet.getB_y() >= mytank.getY() && enemyBullet.getB_y() <= mytank.getY() + 60) {
                        //子弹状态：FALSE
                        enemyBullet.setB_sur(false);
                        //坦克状态：FALSE
                        mytank.setT_sur(false);
                        for (int i = 0; i < mytank.myBullets.size(); i++) {
                            MyBullet myBullet = mytank.myBullets.get(i);
                            myBullet.setB_sur(false);
                        }
                        //把炸弹特效放在自己位置处，并加入集合
                        bombs.add(new Bomb(mytank.getX(), mytank.getY()));
                    }
                    break;
                case 1:
                case 3:
                    if (enemyBullet.getB_x() >= mytank.getX() && enemyBullet.getB_x() <= mytank.getX() + 60
                            && enemyBullet.getB_y() >= mytank.getY() && enemyBullet.getB_y() <= mytank.getY() + 40) {
                        //子弹状态：FALSE
                        enemyBullet.setB_sur(false);
                        //坦克状态：FALSE
                        mytank.setT_sur(false);
                        for (int i = 0; i < mytank.myBullets.size(); i++) {
                            MyBullet myBullet = mytank.myBullets.get(i);
                            myBullet.setB_sur(false);
                        }
                        //把炸弹特效放在自己位置处，并加入集合
                        bombs.add(new Bomb(mytank.getX(), mytank.getY()));
                    }
                    break;
            }
        }
    }

    /**
     * 取出敌人的子弹与自己坦克遍历，看是否击中自己的坦克
     */
    public void killMyTank(){
        //先遍历敌人的坦克
        for (int i = 0; i < enemyTanks.size(); i++) {
            //取出每个敌人坦克
            EnemyTank enemyTank = enemyTanks.get(i);
            //遍历每个敌人坦克里面的每个子弹线程
            for (int j = 0; j < enemyTank.e_Bullets_Ve.size(); j++) {
                EnemyBullet bullet = enemyTank.e_Bullets_Ve.get(j);
                bitMyTank(bullet,mytank);
            }
        }
    }
}

9.TankGame04

package project.tankgame04;

import javax.swing.*;

/**
 * @ClassName: TankGame04
 * @Description: 坦克游戏3.0框架
 */
public class TankGame04 extends JFrame {

    TankPanel tankPanel01 = null; //先定义一个空的1.0“画板”

    public static void main(String[] args) {
        TankGame04 tankGame01 = new TankGame04();
    }

    /**
     * 构造器
     */
    public TankGame04(){
        tankPanel01 = new TankPanel(); //初始化1.0“画板”
        this.add(tankPanel01);  //添加1.0“画板”
        this.setSize(1000,750); //设置“画板”大小
        this.setVisible(true); //设置“画板”可见
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //点×关闭
        this.addKeyListener(tankPanel01);
        new Thread(tankPanel01).start();
    }
}