首页 > > 程序设计 > Java技术 >

Java坦克大战（三）

2018-06-27 09:56:04来源：未知 阅读 ()

新老客户大回馈,云服务器低至5折

关于这个坦克大战的项目是在学习Java基础的时候，拿来练习的最近看到这些代码，感觉很亲切，就把他们都复制下来，编辑成博客。回首看去，Java基础的学习确实应该建立在找项目练习上，这样才能将学到的基础知识用到实际当中，不然你知道什么是面向对象编程，什么是线程，什么是死锁，概念都了解了一大堆，等到实际应用的时候，还是力不从心。初学者千万不要灰心，真心是敲着敲着就有感觉了。下面还是循序渐进的介绍这个项目的几个版本，注释我写的很详细，新功能添加后部分代码有改动，如果感兴趣，可以看前几篇博客。

坦克大战（1.4版本）

1.MyTankGame类：

/*
 * 删掉很多之前的注释
 * 功能：线程（坦克打子弹）进过分析：子弹是个类
 */
package com.fanghua3;

import java.awt.*;
import java.awt.event.KeyEvent;
import java.util.Vector;

import javax.swing.*;

public class MyTankGame1_4 extends JFrame {

    Mypanel1_2 mp = null;

    public static void main(String[] args) {
        new MyTankGame1_4();
    }

    // 构造函数
    public MyTankGame1_4() {
        mp = new Mypanel1_2();

        // 启动mp线程
        Thread t = new Thread(mp);
        t.start();

        this.add(mp);
        // 注册监听
        this.addKeyListener(mp);

        this.setSize(400, 300);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setVisible(true);

    }
}

// 我的面板，拓宽思路：Panel本身就是一个刷新体
class Mypanel1_2 extends JPanel implements java.awt.event.KeyListener, Runnable {

    // 定义我的坦克
    Hero1_2 hero = null;
    // 定义敌人的坦克（不止一辆，线程安全,集合）
    Vector<EnemyTank> ets = new Vector<EnemyTank>();
    int enSize = 3;// 敌人坦克保持三个

    // 构造函数
    public Mypanel1_2() {
        hero = new Hero1_2(10, 10);
        for (int i = 0; i < enSize; i++) {

            // 创建一辆敌人的坦克
            EnemyTank et = new EnemyTank((i + 1) * 50, 0);
            et.setColor(0);
            // 坦克默认反向是0（向上），这里改一下
            et.setDirect(2);
            // 加入
            ets.add(et);

        }
    }

    // 重写paint函数
    public void paint(Graphics g) {
        // 一定要调用
        super.paint(g);
        g.fillRect(0, 0, 400, 300);
        // 画出自己的坦克(将方向填进去)
        this.drawTank(hero.getX(), hero.getY(), g, this.hero.direct, 1);

        // 画出子弹(后添加 hero.s.isLive==true,节省资源)
        if (hero.s != null && hero.s.isLive == true) {
            g.draw3DRect(hero.s.x, hero.s.y, 1, 1, false);
        }

        // 画出敌人的坦克
        for (int i = 0; i < enSize; i++) {
            this.drawTank(ets.get(i).getX(), ets.get(i).getY(), g, ets.get(i)
                    .getDirect(), 0);

        }

    }

    // 画出坦克的函数
    public void drawTank(int x, int y, Graphics g, int direct, int type) {
        // 坦克类型
        switch (type) {
        case 0:
            g.setColor(Color.green);
            break;
        case 1:
            g.setColor(Color.yellow);
            break;
        }
        // 方向设置
        switch (direct) {
        // 向上
        case 0:
            g.fill3DRect(x, y, 5, 30, false);
            g.fill3DRect(x + 15, y, 5, 30, false);
            g.fill3DRect(x + 5, y + 5, 10, 20, false);
            g.fillOval(x + 5, y + 10, 10, 10);
            g.drawLine(x + 10, y + 15, x + 10, y);
            break;
        // 向右
        case 1:
            g.fill3DRect(x, y, 30, 5, false);
            g.fill3DRect(x, y + 15, 30, 5, false);
            g.fill3DRect(x + 5, y + 5, 20, 10, false);
            g.fillOval(x + 10, y + 5, 10, 10);
            g.drawLine(x + 15, y + 10, x + 30, y + 10);
            break;
        // 向下
        case 2:
            g.fill3DRect(x, y, 5, 30, false);
            g.fill3DRect(x + 15, y, 5, 30, false);
            g.fill3DRect(x + 5, y + 5, 10, 20, false);
            g.fillOval(x + 5, y + 10, 10, 10);
            g.drawLine(x + 10, y + 15, x + 10, y + 30);
            break;
        // 向左
        case 3:
            g.fill3DRect(x, y, 30, 5, false);
            g.fill3DRect(x, y + 15, 30, 5, false);
            g.fill3DRect(x + 5, y + 5, 20, 10, false);
            g.fillOval(x + 10, y + 5, 10, 10);
            g.drawLine(x + 15, y + 10, x, y + 10);
            break;
        }

    }

    @Override
    public void keyTyped(KeyEvent e) {
        // TODO Auto-generated method stub

    }

    @Override
    public void keyPressed(KeyEvent e) {
        // TODO Auto-generated method stub
        // 已更正为顺时针
        if (e.getKeyCode() == KeyEvent.VK_UP 
                || e.getKeyCode() == KeyEvent.VK_W) {
            this.hero.moveUp();
            this.hero.setDirect(0);
        } else if (e.getKeyCode() == KeyEvent.VK_RIGHT
                || e.getKeyCode() == KeyEvent.VK_D) {
            this.hero.setDirect(1);
            this.hero.moveRight();
        } else if (e.getKeyCode() == KeyEvent.VK_DOWN
                || e.getKeyCode() == KeyEvent.VK_S) {
            this.hero.moveDown();
            this.hero.setDirect(2);
        } else if (e.getKeyCode() == KeyEvent.VK_LEFT
                || e.getKeyCode() == KeyEvent.VK_A) {
            this.hero.moveLeft();
            this.hero.setDirect(3);
        } else if (e.getKeyCode() == KeyEvent.VK_J) {
            // 将J键设置为发出子弹
            this.hero.shotEnemy();
            this.repaint();
        }

    }

    @Override
    public void keyReleased(KeyEvent e) {
        // TODO Auto-generated method stub

    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        // 每隔100毫秒去重绘
        while (true) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

            // 重绘
            this.repaint();
        }
    }
}

2.Menbers类：

package com.fanghua3;
//子弹类
class Shot implements Runnable{
    int x;
    int y;
    int direct;
    //设置子弹的消亡（默认活着的）
    boolean isLive=true;
    //speed要给个初始值1，之前给0，按J键，子弹没有动
    int speed=1;
    public Shot(int x, int y,int direct) {
        super();
        this.x = x;
        this.y= y;
        this.direct=direct;
        
    }
    @Override
    public void run() {
        // TODO Auto-generated method stub
        
        while(true){
            //设置子弹休息50毫秒
            
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            
            switch(direct){
            case 0:
                y-=speed;
                break;
            case 1:
                x+=speed;
                break;
            case 2:
                y+=speed;
                break;
            case 3:
                x-=speed;
                break;
            }
            System.out.println("子弹坐标x="+x+"y="+y);
            //子弹什么时候死亡
            //判断该子弹是否碰到边缘
            if(x<0||x>400||y<0||y>300){
                this.isLive=false;
                break;
            }
        }
    }
}

//坦克类
class Tank1_2 {
    
    int x = 0;
    int y = 0;

    // 坦克方向：0表示上，1表示右，2表示下，3表示左
    int direct = 0;
    int speed = 1;
    //坦克的颜色
    int color;

    public int getColor() {
        return color;
    }

    public void setColor(int color) {
        this.color = color;
    }

    public int getSpeed() {
        return speed;
    }

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

    public int getDirect() {
        return direct;
    }

    public void setDirect(int direct) {
        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 Tank1_2(int x, int y) {
        this.x = x;
        this.y = y;

    }

}
//敌人的坦克
class EnemyTank extends Tank1_2{
    
    public EnemyTank(int x, int y) {
        super(x, y);
        // TODO Auto-generated constructor stub
    }
}

//我的坦克
class Hero1_2 extends Tank1_2 {
    //子弹
    Shot s=null;
    public Hero1_2(int x, int y) {
        super(x, y);
    }
    //坦克开火
    public void shotEnemy(){
        
        switch(this.direct){
        case 0:
            s=new Shot(x+10,y,0);
            
            break;
        
        case 1:
            s=new Shot(x+30,y+10,1);
            break;
        
        case 2:
            s=new Shot(x+10,y+30,2);
            break;
        
        case 3:
            s=new Shot(x,y+10,3);
            break;
        }
        //启动子弹线程
        Thread t=new Thread(s);
        t.start();
    }

    public void moveUp() {
        y -= speed;
    }
    public void moveRight() {
        x += speed;
    }
    public void moveDown() {
        y += speed;
    }
    public void moveLeft() {
        x -= speed;
    }
}

坦克大战（1.5版本）

1.MyTankGame类：

/*
 * 删掉很多之前的注释
 * 功能：子弹连发,（线程）最多5颗子弹
 * 敌人坦克消失
 */
package com.fanghua4;

import java.awt.*;
import java.awt.event.KeyEvent;
import java.util.Vector;

import javax.swing.*;

public class MyTankGame1_5 extends JFrame {

    Mypanel1_2 mp = null;

    public static void main(String[] args) {
        new MyTankGame1_5();
    }

    // 构造函数
    public MyTankGame1_5() {
        mp = new Mypanel1_2();

        // 启动mp线程
        Thread t = new Thread(mp);
        t.start();

        this.add(mp);
        // 注册监听
        this.addKeyListener(mp);

        this.setSize(400, 300);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setVisible(true);

    }
}

// 我的面板，拓宽思路：Panel本身就是一个刷新体
class Mypanel1_2 extends JPanel implements java.awt.event.KeyListener, Runnable {

    // 定义我的坦克
    Hero1_2 hero = null;
    // 定义敌人的坦克（不止一辆，线程安全,集合）
    Vector<EnemyTank> ets = new Vector<EnemyTank>();
    int enSize = 3;// 敌人坦克保持三个

    // 构造函数
    public Mypanel1_2() {
        hero = new Hero1_2(10, 10);
        for (int i = 0; i < enSize; i++) {

            // 创建一辆敌人的坦克
            EnemyTank et = new EnemyTank((i + 1) * 50, 0);
            et.setColor(0);
            // 坦克默认反向是0（向上），这里改一下
            et.setDirect(2);
            // 加入
            ets.add(et);

        }
    }

    // 重写paint函数
    public void paint(Graphics g) {
        // 一定要调用
        super.paint(g);
        g.fillRect(0, 0, 400, 300);
        // 画出自己的坦克(将方向填进去)
        this.drawTank(hero.getX(), hero.getY(), g, this.hero.direct, 1);

        // 从ss中取出每一颗子弹，并画出
        for (int i = 0; i < hero.ss.size(); i++) {

            Shot myShot = hero.ss.get(i);
            if (myShot != null && myShot.isLive == true) {
                g.draw3DRect(myShot.x, myShot.y, 1, 1, false);

                /*
                 * 画出一颗子弹(后添加 hero.s.isLive==true,节省资源) if (hero.s != null
                 * &&hero.s.isLive == true) { g.draw3DRect(hero.s.x, hero.s.y,
                 * 1, 1,false); }
                 */
            }
            if (myShot.isLive == false) {
                // 从ss(向量)中删除该子弹
                // hero.ss.remove(i);会报异常。
                hero.ss.remove(myShot);
            }
        }

        // 画出敌人的坦克
        for (int i = 0; i < enSize; i++) {
            EnemyTank et = ets.get(i);
            if (et.isLive) {
                this.drawTank(et.getX(), et.getY(), g, et.getDirect(), 0);
            }
        }
    }

    // 写一个函数 专门判断是否击中敌人坦克
    public void hitTank(Shot s, EnemyTank et) {
        // 判断该坦克的方向
        switch (et.direct) {
        // 敌人坦克的方向是0或2，一致
        case 0:
        case 2:
            if (s.x > et.x && s.x < et.x + 20 && s.y > et.y && s.y < et.y + 30) {
                // 击中（子弹死亡，敌人四万）
                s.isLive = false;
                et.isLive = false;
            }
        break;
        case 1:
        case 3:
            if (s.x > et.x && s.x < et.x + 30 && s.y > et.y && s.y < et.y + 20) {
                // 击中（子弹死亡，敌人四万）
                s.isLive = false;
                et.isLive = false;
            }
        break;
        }
    }

    // 画出坦克的函数
    public void drawTank(int x, int y, Graphics g, int direct, int type) {
        // 坦克类型
        switch (type) {
        case 0:
            g.setColor(Color.green);
            break;
        case 1:
            g.setColor(Color.yellow);
            break;
        }
        // 方向设置
        switch (direct) {
        // 向上
        case 0:
            g.fill3DRect(x, y, 5, 30, false);
            g.fill3DRect(x + 15, y, 5, 30, false);
            g.fill3DRect(x + 5, y + 5, 10, 20, false);
            g.fillOval(x + 5, y + 10, 10, 10);
            g.drawLine(x + 10, y + 15, x + 10, y);
            break;
        // 向右
        case 1:
            g.fill3DRect(x, y, 30, 5, false);
            g.fill3DRect(x, y + 15, 30, 5, false);
            g.fill3DRect(x + 5, y + 5, 20, 10, false);
            g.fillOval(x + 10, y + 5, 10, 10);
            g.drawLine(x + 15, y + 10, x + 30, y + 10);
            break;
        // 向下
        case 2:
            g.fill3DRect(x, y, 5, 30, false);
            g.fill3DRect(x + 15, y, 5, 30, false);
            g.fill3DRect(x + 5, y + 5, 10, 20, false);
            g.fillOval(x + 5, y + 10, 10, 10);
            g.drawLine(x + 10, y + 15, x + 10, y + 30);
            break;
        // 向左
        case 3:
            g.fill3DRect(x, y, 30, 5, false);
            g.fill3DRect(x, y + 15, 30, 5, false);
            g.fill3DRect(x + 5, y + 5, 20, 10, false);
            g.fillOval(x + 10, y + 5, 10, 10);
            g.drawLine(x + 15, y + 10, x, y + 10);
            break;
        }

    }

    @Override
    public void keyTyped(KeyEvent e) {
        // TODO Auto-generated method stub

    }

    @Override
    public void keyPressed(KeyEvent e) {
        // TODO Auto-generated method stub
        // 已更正为顺时针
        if (e.getKeyCode() == KeyEvent.VK_UP || e.getKeyCode() == KeyEvent.VK_W) {
            this.hero.moveUp();
            this.hero.setDirect(0);
        } else if (e.getKeyCode() == KeyEvent.VK_RIGHT
                || e.getKeyCode() == KeyEvent.VK_D) {
            this.hero.setDirect(1);
            this.hero.moveRight();
        } else if (e.getKeyCode() == KeyEvent.VK_DOWN
                || e.getKeyCode() == KeyEvent.VK_S) {
            this.hero.moveDown();
            this.hero.setDirect(2);
        } else if (e.getKeyCode() == KeyEvent.VK_LEFT
                || e.getKeyCode() == KeyEvent.VK_A) {
            this.hero.moveLeft();
            this.hero.setDirect(3);
        } else if (e.getKeyCode() == KeyEvent.VK_J) {
            // 将J键设置为发出子弹
            // 子弹连发，J被按几下，发几颗：this.hero.shotEnemy();
            // this.repaint();在run函数里，不应该设计在这里
            if (this.hero.ss.size() <= 4) {
                this.hero.shotEnemy();
            }

        }

    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        // 每隔100毫秒去重绘
        while (true) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            // 判断是否击中（写在这里,虽然在每次重绘的时候都要调用，但是没办法）
            // 每一颗子弹都要和每个坦克进行匹配
            for (int i = 0; i < hero.ss.size(); i++) {
                // 取出子弹
                Shot myShot = hero.ss.get(i);
                // 判断子弹是否有效
                if (myShot.isLive) {
                    // 取出每个坦克，与它判断
                    for (int j = 0; j < ets.size(); j++) {
                        // 取出坦克
                        EnemyTank et = ets.get(j);

                        if (et.isLive) {
                            this.hitTank(myShot, et);
                        }
                    }
                }
            }

            // 重绘
            this.repaint();
        }
    }

    @Override
    public void keyReleased(KeyEvent e) {
        // TODO Auto-generated method stub

    }

}

2.Menbers类：

package com.fanghua4;

import java.util.Vector;

//子弹类
class Shot implements Runnable {
    int x;
    int y;
    int direct;
    // 设置子弹的消亡（默认活着的）
    boolean isLive = true;
    // speed要给个初始值1，之前给0，按J键，子弹没有动
    int speed = 1;

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

    }

    @Override
    public void run() {
        // TODO Auto-generated method stub

        while (true) {
            // 设置子弹休息50毫秒

            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

            switch (direct) {
            case 0:
                y -= speed;
                break;
            case 1:
                x += speed;
                break;
            case 2:
                y += speed;
                break;
            case 3:
                x -= speed;
                break;
            }
            System.out.println("子弹坐标x=" + x + "y=" + y);
            // 子弹什么时候死亡
            // 判断该子弹是否碰到边缘
            if (x < 0 || x > 400 || y < 0 || y > 300) {
                this.isLive = false;
                break;
            }
        }
    }
}

// 坦克类
class Tank1_2 {

    int x = 0;
    int y = 0;

    // 坦克方向：0表示上，1表示右，2表示下，3表示左
    int direct = 0;
    int speed = 1;
    // 坦克的颜色
    int color;

    public int getColor() {
        return color;
    }

    public void setColor(int color) {
        this.color = color;
    }

    public int getSpeed() {
        return speed;
    }

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

    public int getDirect() {
        return direct;
    }

    public void setDirect(int direct) {
        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 Tank1_2(int x, int y) {
        this.x = x;
        this.y = y;

    }

}

// 敌人的坦克
class EnemyTank extends Tank1_2 {

    boolean isLive = true;


    public EnemyTank(int x, int y) {
        super(x, y);
        // TODO Auto-generated constructor stub
    }
}

// 我的坦克
class Hero1_2 extends Tank1_2 {
    // 多个子弹，用向量创建
    Vector<Shot> ss = new Vector<Shot>();
    // 子弹
    Shot s = null;

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

    // 坦克开火
    public void shotEnemy() {

        switch (this.direct) {
        case 0:
            s = new Shot(x + 10, y, 0);
            // 把子弹加入向量
            ss.add(s);
            break;

        case 1:
            s = new Shot(x + 30, y + 10, 1);
            // 把子弹加入向量
            ss.add(s);
            break;

        case 2:
            s = new Shot(x + 10, y + 30, 2);
            // 把子弹加入向量
            ss.add(s);
            break;

        case 3:
            s = new Shot(x, y + 10, 3);
            // 把子弹加入向量
            ss.add(s);
            break;
        }
        // 启动子弹线程
        Thread t = new Thread(s);
        t.start();
    }

    public void moveUp() {
        y -= speed;
    }

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

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

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

坦克大战（1.6版本）

1.MyTankGame类

/*
 * 功能：
 * 1.实现爆炸效果
 * 2.敌人坦克可移动，可以连发子弹
 * 3.敌人击中我的坦克，我爆炸
 * 4.击中第一个坦克爆炸的效果不明显
 */
package com.fanghua5;

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

public class MyTankGame1_6 extends JFrame {

    Mypanel1_2 mp = null;

    public static void main(String[] args) {
        new MyTankGame1_6();
    }

    // 构造函数
    public MyTankGame1_6() {
        mp = new Mypanel1_2();

        // 启动mp线程
        Thread t = new Thread(mp);
        t.start();

        this.add(mp);
        // 注册监听
        this.addKeyListener(mp);

        this.setSize(400, 300);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setVisible(true);

    }
}

// 我的面板，拓宽思路：Panel本身就是一个刷新体
class Mypanel1_2 extends JPanel implements java.awt.event.KeyListener, Runnable {

    // 定义我的坦克
    Hero1_2 hero = null;
    // 定义敌人的坦克（不止一辆，线程安全,集合）
    Vector<EnemyTank> ets = new Vector<EnemyTank>();

    // 定义炸弹集合
    Vector<Bomb> bombs = new Vector<Bomb>();

    int enSize = 4;// 敌人坦克保持四个

    // 定义三张图片(三张图片才能组成一颗炸弹)
    Image image1 = null;
    Image image2 = null;
    Image image3 = null;

    // 构造函数
    public Mypanel1_2() {
        hero = new Hero1_2(10, 10);
        for (int i = 0; i < enSize; i++) {

            // 创建一辆敌人的坦克
            EnemyTank et = new EnemyTank((i + 1) * 50, 0);
            et.setColor(0);
            // 坦克默认反向是0（向上），这里改一下
            et.setDirect(2);
            // 加入
            ets.add(et);

            // 启动敌人的坦克
            Thread t = new Thread(et);
            t.start();
            // 给敌人坦克添加一颗子弹
            Shot s = new Shot(et.x + 10, et.y + 30, 2);
            // 加入给敌人的坦克
            et.ss.add(s);

            Thread t2 = new Thread(s);
            t2.start();
            ets.add(et);

        }
        // 初始话图片，这样做击中第一个坦克，爆炸的效果不明显。下面优化
        image1 = Toolkit.getDefaultToolkit().getImage(
                Panel.class.getResource("/bomb_1.gif"));
        image2 = Toolkit.getDefaultToolkit().getImage(
                Panel.class.getResource("/bomb_2.gif"));
        image3 = Toolkit.getDefaultToolkit().getImage(
                Panel.class.getResource("/bomb_3.gif"));
    
//        引包：import javax.imageio.ImagesssIO;
//        try {
//            image1=ImageIO.read(new File("/bomsb_1.gif"));
//            image2=ImageIO.read(new File("/bomb_2.gif"));
//            image3=ImageIO.read(new File("/bomb_3.gif"));
//        } catch (IOException e) {
//            // TODO Auto-generated catch block
//            e.printStackTrace();
//        }
    }

    // 重写paint函数
    public void paint(Graphics g) {
        // 一定要调用
        super.paint(g);
        g.fillRect(0, 0, 400, 350);
        // 画出自己的坦克(将方向填进去)
        if (hero.isLive == true) {
            this.drawTank(hero.getX(), hero.getY(), g, this.hero.direct, 1);
        }
        // 从ss中取出每一颗子弹，并画出
        for (int i = 0; i < hero.ss.size(); i++) {

            Shot myShot = hero.ss.get(i);
            if (myShot != null && myShot.isLive == true) {
                g.draw3DRect(myShot.x, myShot.y, 1, 1, false);

                /*
                 * 画出一颗子弹(后添加 hero.s.isLive==true,节省资源) if (hero.s != null
                 * &&hero.s.isLive == true) { g.draw3DRect(hero.s.x, hero.s.y,
                 * 1, 1,false); }
                 */
            }
            if (myShot.isLive == false) {
                // 从ss(向量)中删除该子弹
                // hero.ss.remove(i);会报异常。
                hero.ss.remove(myShot);
            }
        }

        // 画出炸弹
        for (int i = 0; i < bombs.size(); i++) {
            // 取出炸弹
            Bomb b = bombs.get(i);
            if (b.life > 6) {
                g.drawImage(image1, b.x, b.y, 30, 30, this);
            } else if (b.life > 4) {
                g.drawImage(image2, b.x, b.y, 30, 30, this);
            } else {
                g.drawImage(image3, b.x, b.y, 30, 30, this);
            }
            // 让b的生命值减小
            b.lifeDown();
            // 如果炸弹生命值为零，就把该炸弹从bombs向量中去掉
            if (b.life == 0) {
                bombs.remove(b);
            }

        }

        // 画出敌人的坦克
        for (int i = 0; i < ets.size(); i++) {
            EnemyTank et = ets.get(i);
            if (et.isLive) {
                this.drawTank(et.getX(), et.getY(), g, et.getDirect(), 0);

                // 画出敌人的子弹
                for (int j = 0; j < et.ss.size(); j++) {
                    // 取出子弹
                    Shot enemyShot = et.ss.get(j);
                    if (enemyShot != null && enemyShot.isLive == true) {
                        g.draw3DRect(enemyShot.x, enemyShot.y, 1, 1, false);
                    }
                    if (enemyShot.isLive == false) {
                        // 如果敌人的坦克死亡了，就从Vector中删除
                        et.ss.remove(enemyShot);
                    }
                }
            }
        }
    }

    // 判断敌人的子弹是否击中我
    public void hitMe() {
        // 取出每一个敌人的坦克
        for (int i = 0; i < this.ets.size(); i++) {
            // 取出坦克
            EnemyTank et = ets.get(i);
            // 取出每一颗子弹
            for (int j = 0; j < et.ss.size(); j++) {
                // 取出子弹
                Shot enemyShot = et.ss.get(j);

                this.hitTank(enemyShot, hero);
            }

        }
    }

    // 判断我是否击中敌人的坦克
    public void hitEnemyTank() {
        // 判断是否被击中敌人的坦克
        for (int i = 0; i < hero.ss.size(); i++) {
            // 取出我的子弹与敌人坦克匹配
            Shot myShot = hero.ss.get(i);
            // 判断子弹是否有效
            if (myShot.isLive) {
                // 取出每个坦克，与它判断
                for (int j = 0; j < ets.size(); j++) {
                    // 取出坦克
                    EnemyTank et = ets.get(j);
                    if (et.isLive) {
                        this.hitTank(myShot, et);
                    }
                }
            }
        }
    }

    // 写一个函数 专门判断是否击中敌人坦克(原来第二参数： EnemyTank et)
    public void hitTank(Shot s, Tank1_2 et) {
        // 判断该坦克的方向
        switch (et.direct) {
        // 敌人坦克的方向是0或2，一致
        case 0:
        case 2:
            if (s.x >= et.x && s.x <= et.x + 20 && s.y >= et.y
                    && s.y <= et.y + 30) {
                // 击中（子弹死亡，敌人死亡）
                s.isLive = false;
                et.isLive = false;

                // 创建一颗炸弹，放入Vector中
                Bomb b = new Bomb(et.x, et.y);
                // 放入
                bombs.add(b);
            }
        break;
        case 1:
        case 3:
            if (s.x >= et.x && s.x <= et.x + 30 && s.y >= et.y
                    && s.y <= et.y + 20) {
                // 击中（子弹死亡，敌人死亡）
                s.isLive = false;
                et.isLive = false;
                // 创建一颗炸弹，放入Vector中
                Bomb b = new Bomb(et.x, et.y);
                // 放入
                bombs.add(b);
            }
        break;
        }
    }

    // 画出坦克的函数
    public void drawTank(int x, int y, Graphics g, int direct, int type) {
        // 坦克类型
        switch (type) {
        case 0:
            g.setColor(Color.green);
            break;
        case 1:
            g.setColor(Color.yellow);
            break;
        }
        // 方向设置
        switch (direct) {
        // 向上
        case 0:
            g.fill3DRect(x, y, 5, 30, false);
            g.fill3DRect(x + 15, y, 5, 30, false);
            g.fill3DRect(x + 5, y + 5, 10, 20, false);
            g.fillOval(x + 5, y + 10, 10, 10);
            g.drawLine(x + 10, y + 15, x + 10, y);
            break;
        // 向右
        case 1:
            g.fill3DRect(x, y, 30, 5, false);
            g.fill3DRect(x, y + 15, 30, 5, false);
            g.fill3DRect(x + 5, y + 5, 20, 10, false);
            g.fillOval(x + 10, y + 5, 10, 10);
            g.drawLine(x + 15, y + 10, x + 30, y + 10);
            break;
        // 向下
        case 2:
            g.fill3DRect(x, y, 5, 30, false);
            g.fill3DRect(x + 15, y, 5, 30, false);
            g.fill3DRect(x + 5, y + 5, 10, 20, false);
            g.fillOval(x + 5, y + 10, 10, 10);
            g.drawLine(x + 10, y + 15, x + 10, y + 30);
            break;
        // 向左
        case 3:
            g.fill3DRect(x, y, 30, 5, false);
            g.fill3DRect(x, y + 15, 30, 5, false);
            g.fill3DRect(x + 5, y + 5, 20, 10, false);
            g.fillOval(x + 10, y + 5, 10, 10);
            g.drawLine(x + 15, y + 10, x, y + 10);
            break;
        }

    }

    @Override
    public void keyTyped(KeyEvent e) {
        // TODO Auto-generated method stub

    }

    @Override
    public void keyPressed(KeyEvent e) {
        // TODO Auto-generated method stub
        // 已更正为顺时针
        if (e.getKeyCode() == KeyEvent.VK_UP || e.getKeyCode() == KeyEvent.VK_W) {
            this.hero.moveUp();
            this.hero.setDirect(0);
        } else if (e.getKeyCode() == KeyEvent.VK_RIGHT
                || e.getKeyCode() == KeyEvent.VK_D) {
            this.hero.setDirect(1);
            this.hero.moveRight();
        } else if (e.getKeyCode() == KeyEvent.VK_DOWN
                || e.getKeyCode() == KeyEvent.VK_S) {
            this.hero.moveDown();
            this.hero.setDirect(2);
        } else if (e.getKeyCode() == KeyEvent.VK_LEFT
                || e.getKeyCode() == KeyEvent.VK_A) {
            this.hero.moveLeft();
            this.hero.setDirect(3);
        } else if (e.getKeyCode() == KeyEvent.VK_J) {
            // 将J键设置为发出子弹
            // 子弹连发，J被按几下，发几颗：this.hero.shotEnemy();
            // this.repaint();在run函数里，不应该设计在这里
            if (this.hero.ss.size() <= 4) {
                this.hero.shotEnemy();
            }

        }

    }

    @Override
    public void keyReleased(KeyEvent e) {
        // TODO Auto-generated method stub

    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        // 每隔100毫秒去重绘
        while (true) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            // 判断是否击中（写在这里,虽然在每次重绘的时候都要调用，但是没办法）
            // 每一颗子弹都要和每个坦克进行匹配
            for (int i = 0; i < hero.ss.size(); i++) {
                // 取出子弹
                Shot myShot = hero.ss.get(i);
                // 判断子弹是否有效
                if (myShot.isLive) {
                    // 取出每个坦克，与它判断
                    for (int j = 0; j < ets.size(); j++) {
                        // 取出坦克
                        EnemyTank et = ets.get(j);

                        if (et.isLive) {
                            this.hitTank(myShot, et);
                        }
                    }
                }
            }
            this.hitEnemyTank();

            this.hitMe();

            // 重绘
            this.repaint();
        }
    }
}

2.Menbers类：

package com.fanghua5;

import java.util.Vector;

//炸弹类(没必要定义为线程，因为它不会移动，没有坐标改变)
class Bomb {
    // 定义炸弹的坐标
    int x, y;
    int life = 9;// 炸弹的生命(三张图片)
    // 可以看出isLive很有用，它可以决定类（或者对象）要不要展现在面板上
    boolean isLive = true;

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

    // 炸弹减少生命值
    public void lifeDown() {
        if (life > 0) {
            life--;
        } else {
            this.isLive = false;
        }
    }

}

// 子弹类
class Shot implements Runnable {
    int x;
    int y;
    int direct;
    // 设置子弹的消亡（默认活着的）
    boolean isLive = true;
    // speed要给个初始值1，之前给0，按J键，子弹没有动
    int speed = 1;

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

    }

    @Override
    public void run() {
        // TODO Auto-generated method stub

        while (true) {
            // 设置子弹休息50毫秒

            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

            switch (direct) {
            case 0:
                y -= speed;
                break;
            case 1:
                x += speed;
                break;
            case 2:
                y += speed;
                break;
            case 3:
                x -= speed;
                break;
            }
            // 测试用：System.out.println("子弹坐标x=" + x + "y=" + y);
            // 子弹什么时候死亡
            // 判断该子弹是否碰到边缘
            if (x < 0 || x > 400 || y < 0 || y > 300) {
                this.isLive = false;
                break;
            }
        }
    }
}

// 坦克类
class Tank1_2 {

    int x = 0;
    int y = 0;
    boolean isLive=true;

    // 坦克方向：0表示上，1表示右，2表示下，3表示左
    int direct = 0;
    int speed = 1;
    // 坦克的颜色
    int color;

    public int getColor() {
        return color;
    }

    public void setColor(int color) {
        this.color = color;
    }

    public int getSpeed() {
        return speed;
    }

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

    public int getDirect() {
        return direct;
    }

    public void setDirect(int direct) {
        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 Tank1_2(int x, int y) {
        this.x = x;
        this.y = y;

    }

}

// 敌人的坦克(做成线程，会移动)
class EnemyTank extends Tank1_2 implements Runnable {

    //从父类继承了，去掉：boolean isLive = true;
    int times = 0;// 让time累积
    // 定义向量，可以存放敌人的子弹
    Vector<Shot> ss = new Vector<Shot>();

    // 敌人添加子弹，应该刚刚创建坦克和敌人子弹死亡后

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

    @Override
    public void run() {
        // TODO Auto-generated method stub
        while (true) {
            try {
                // 设置坦克休息一会
                Thread.sleep(50);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            switch (this.direct) {
            case 0:
                // 说明坦克正在向上运动（继续往上走，符合实际）
                // y -= speed;设置坦克平滑移动的效果
                for (int i = 0; i < 30; i++) {
                    if (y > 0) {
                        y -= speed;
                    }
                    try {
                        Thread.sleep(50);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                break;
            case 1:
                for (int i = 0; i < 30; i++) {
                    // 这里注意坐标起点问题不是（400x300）
                    if (x < 350) {
                        x += speed;
                    }
                    try {
                        Thread.sleep(50);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                break;
            case 2:
                for (int i = 0; i < 30; i++) {
                    if (y < 250) {
                        y += speed;
                    }
                    try {
                        Thread.sleep(50);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                break;
            case 3:
                for (int i = 0; i < 30; i++) {
                    if (x > 0) {
                        x -= speed;
                    }
                    try {
                        Thread.sleep(50);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                break;
            }
            this.times++;
            // 设置3秒发一颗子弹
            if (times % 2 == 0) {
                if (isLive) {
                    if (ss.size() < 5) {
                        Shot s = null;
                        // 没有子弹，添加
                        switch (direct) {
                        case 0:
                            s = new Shot(x + 10, y, 0);
                            ss.add(s);
                            break;
                        case 1:
                            s = new Shot(x + 30, y + 10, 1);
                            ss.add(s);
                            break;
                        case 2:
                            s = new Shot(x + 10, y + 30, 2);
                            ss.add(s);
                            break;
                        case 3:
                            s = new Shot(x, y + 10, 3);
                            ss.add(s);
                            break;
                        }
                        // 启动子弹线程
                        Thread t = new Thread(s);
                        t.start();
                    }
                }
            }
            // 让坦克随机产生一个新的方向
            this.direct = (int) (Math.random() * 4);
            // 判断敌人坦克是否死亡了(双等号)
            if (this.isLive == false) {
                // 让坦克死亡，后退出线程
                return;
            }

        }
    }
}

// 我的坦克
class Hero1_2 extends Tank1_2 {
    // 多个子弹，用向量创建
    Vector<Shot> ss = new Vector<Shot>();
    // 子弹
    Shot s = null;
    

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

    // 坦克开火
    public void shotEnemy() {

        switch (this.direct) {
        case 0:
            s = new Shot(x + 10, y, 0);
            // 把子弹加入向量
            ss.add(s);
            break;

        case 1:
            s = new Shot(x + 30, y + 10, 1);
            // 把子弹加入向量
            ss.add(s);
            break;

        case 2:
            s = new Shot(x + 10, y + 30, 2);
            // 把子弹加入向量
            ss.add(s);
            break;

        case 3:
            s = new Shot(x, y + 10, 3);
            // 把子弹加入向量
            ss.add(s);
            break;
        }
        // 启动子弹线程（创建线程，赶紧传参，我在这里吃了大亏！）
        Thread t = new Thread(s);
        t.start();
    }

    public void moveUp() {
        y -= speed;
    }

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

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

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

1.6版本（图：基本功能都已经实现）

之后，我还会继续写一篇博客，来记录该坦克大战的最终版本（2.0），这个坦克大战的项目利用Java图形界面来实现坦克的绘制，画质比较粗糙，部分的坐标没有那么精确。

标签：

版权申明：本站文章部分自网络，如有侵权，请联系：west999com@outlook.com
特别注意：本站所有转载文章言论不代表本站观点，本站所提供的摄影照片，插画，设计作品，如需使用，请与原作者联系，版权归原作者所有

上一篇：【转】Java工程师成神之路

下一篇：struts2框架学习笔记5：OGNL表达式

相关文章

IDC资讯： 主机资讯 注册资讯 托管资讯 vps资讯 网站建设

网站运营： 建站经验 策划盈利 搜索优化 网站推广 免费资源

网站联盟： 联盟新闻 联盟介绍 联盟点评 网赚技巧

行业资讯： 搜索引擎 网络游戏 电子商务 广告传媒

网络编程： Asp.Net编程 Asp编程 Php编程 Xml编程 Access Mssql Mysql 其它

服务器技术： Web服务器 Ftp服务器 Mail服务器 Dns服务器 安全防护

软件技巧： 其它软件 Word Excel Powerpoint Ghost Vista QQ空间 QQ FlashGet 迅雷

网页制作： FrontPages Dreamweaver Javascript css photoshop fireworks Flash

程序设计： Java技术 C/C++ VB delphi

网络知识： 网络协议 网络安全 网络管理 组网方案 Cisco技术

操作系统： Win2000 WinXP Win2003 Mac OS Linux FreeBSD

热门词条
最新资讯
热门关注
热门标签