Java实现坦克大战（1990有木有勾起童年回忆）

笔者最近一个星期又抽时间学习了一点点Java多线程编程，结合swing绘图做了一个特别简单版的坦克大战游戏。

功能说明：

1.仅仅有一关；英雄坦克（自己）只有一条命--不过可以很好的扩展，只要把MyPanel中的SuperTank做成跟敌人坦克一样的Vector即可；

2.右侧的调速面板仅可以调整我军坦克速度；子弹速度目前不可面板自动调整；

3.敌军总共20辆坦克，同时显示的有3辆；击毁一辆会在左上角自动增加一辆，直到上限20辆；

4.目前敌军坦克的移动完全是随机的，没有加入敌军向目标攻击的概率函数控制（后续优化）；

 

代码说明：

1.我本机是编写了三个*.java文件，当然拷贝后，完全可以直接在一个文件中粘贴并编译；

 

游戏截图：

 

/**
 * 坦克大战
 * 1.Created by Light on 2014-8-1  画坦克
 * 2.Modified by Light on 2014-8-1 让坦克按照键盘的方向键实现移动
 * 3.Modified by Light on 2014-8-1 让坦克发子弹,并且让子弹飞
 * 4.Modified by Light on 2014-8-4 让敌人坦克自由行动，让子弹打到坦克时，坦克和子弹都消失，让坦克少于三个时自动增加
 * 5.Modified by Light on 2014-8-4 优化敌军坦克行动代码和让敌军坦克发射子弹
 * 6.Modified by Light on 2014-8-5 让敌军的坦克发射子弹也能击毁英雄坦克
 */
package com.firstversion;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;


import javax.swing.*;
public class TankGame extends JFrame implements ActionListener{

	/**
	 * 不知道这是干什么用的，后续补充
	 */
	private static final long serialVersionUID = 1L;
	MyPanel mp ;
	oprationPanel mep;
	JSplitPane jsplit;
	JButton friend, enemy,speedUp,speedDown;
	JLabel speedArea;
	//主函数
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		new TankGame();
	}
	//坦克游戏的构造函数
	public TankGame()
	{
		mp = new MyPanel();
		
		mep = new oprationPanel();
		jsplit = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT);
		//暂时把分隔窗口收起功能注释掉,免的窗口发生变化导致坦克开出边界
		//jsplit.setOneTouchExpandable(true);
		
		friend = new JButton("友军");
		friend.addActionListener(mp);
		friend.setActionCommand("friend");
		friend.addKeyListener(mp);
		//http://blog.csdn.net/hn1232/article/details/4224863
		//因在另外一个Panel上添加button导致键盘监听失效，参考上面的博文将每个Button都加了键盘监听，功能恢复了，但是现在不明白原理
		enemy = new JButton("敌军");
		enemy.addActionListener(mp);
		enemy.setActionCommand("enemy");
		enemy.addKeyListener(mp);
		
		speedUp = new JButton("加速");
		speedUp.addActionListener(this);
		speedUp.addActionListener(mp);
		speedUp.setActionCommand("speedUp");
		speedUp.addKeyListener(mp);
		
		speedDown = new JButton("减速");
		speedDown.addActionListener(this);
		speedDown.addActionListener(mp);
		speedDown.setActionCommand("speedDown");
		speedDown.addKeyListener(mp);
		
		speedArea = new JLabel(String.valueOf(mp.st.getSpeed()));
		
		
		//Layout
		mep.add(friend);
		mep.add(enemy);
		mep.add(speedUp);
		mep.add(speedDown);
		mep.add(speedArea);
		
		jsplit.setLeftComponent(mp);
		jsplit.setRightComponent(mep);
		this.add(jsplit);
		
		//Listener set
		this.addKeyListener(mp);
		
		//启动MyPanel
		Thread t = new Thread(mp);
		t.start();
		
		//设置JFrame
		this.setSize(600, 450);
		this.setResizable(false);
		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		this.setLocation(350, 180);
		this.setVisible(true);
		jsplit.setDividerLocation(0.88);
		

	}
	
	//写一个方法用于刷新speedArea
	public void refreshSpeed()
	{
		speedArea.setText(String.valueOf(this.mp.st.getSpeed()));
	}

	@Override
	public void actionPerformed(ActionEvent e) {
		// TODO Auto-generated method stub
		this.refreshSpeed();	
		this.repaint();
	}

}


package com.firstversion;

import java.awt.Color;
import java.awt.Graphics;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.util.*;
import javax.swing.JPanel;
import java.lang.Thread;


//个人Panel,用于重写paint方便自定义
class MyPanel extends JPanel implements KeyListener,ActionListener,Runnable
{
	/**
	 * 暂时不清楚这个是干什么用的
	 */
	private static final long serialVersionUID = 1L;
	//英雄坦克
	SuperTank st = null;	
	//敌军坦克,使用Vector来装敌军坦克群
	int enemyNum = 3;
	Vector<EnemyTank> enemyTanks = null;
	//个人Panel构造方法
	
	public MyPanel()
	{
		//初始化英雄坦克-->位置在底层中央，方向朝上
		st = new SuperTank(250,350);
		//初始化敌人坦克，并为每个坦克启动一个线程-->在上层，方向朝下
		enemyTanks = new Vector<EnemyTank>();
		for(int i=0;i<enemyNum;i++)
		{
			//初始化敌军坦克
			EnemyTank et = new EnemyTank(i*100,0);
			//初始化敌军坦克的类型和方向
			et.setDirection(3);
			et.setTankType(1);
			//将敌军坦克装载Vector中管理
			enemyTanks.addElement(et);
			//System.out.println("装了"+(i+1)+"个");
			//System.out.println("总共"+(enemyTanks.size())+"个");
			Thread t = new Thread(this.enemyTanks.get(i));
			t.start();
		}
				
	}
	
	//重写paint方法
	public void paint(Graphics g)
	{
		super.paint(g);
		//设置一下背景颜色
		g.fillRect(0, 0, 600, 450);
		//画英雄坦克
		if(this.st.isLive())
		{
			this.createTank(this.st.getX(),this.st.getY(),g,this.st.getTankType(),this.st.getDirection());
		}
		
		//画英雄坦克子弹,要先判断子弹是否存在（子弹集是否为空）并且是否存活
		if(!(this.st.bulletVector.isEmpty()))//子弹集不为空
		{
			for(int i=0;i<this.st.bulletVector.size();i++)//遍历子弹集
			{
				Bullet b = this.st.bulletVector.get(i);
				if(b.isLive())//子弹为存活状态
				{
					//画子弹,x和y是取得子弹当前的最新坐标参照点
					g.fillOval(b.getX(), b.getY(), 4, 4);
				}
			}
		}
			
		//画敌军坦克 for
		for(int i=0;i<enemyTanks.size();i++)
		{
			//System.out.println("画了"+(i+1)+"个");
			//System.out.println("总共"+(enemyTanks.size())+"个");
			EnemyTank et = this.enemyTanks.get(i);
			if(et.isLive())
			{
				this.createTank(et.getX(),et.getY(),g,et.getTankType(),et.getDirection());
			}
			//System.out.println("画了"+(i+1)+"个");
			//画敌军坦克子弹
			for(int j=0;j<et.bulletVector.size();j++)
			{
				Bullet b = et.bulletVector.get(j);
				if(b.isLive())
				{
					//画子弹,x和y是取得子弹当前的最新坐标参照点
					g.fillOval(b.getX(), b.getY(), 4, 4);
				}
			}
		}
		
	}
	
	//专门写一个方法来创建坦克-->参数：初始横坐标/初始纵坐标/画笔/坦克类型/坦克方向	
	public void createTank(int x,int y,Graphics g,int tankType, int direction)
	{
		//先根据tankType判断坦克类型
		switch(tankType)
		{//0-->自己; 1--> 敌军
		case 0: g.setColor(Color.YELLOW); break; //暂时使用颜色来标识tankType
		case 1: g.setColor(Color.CYAN); break;
		}
		//接着根据direction判断坦克朝向,因为坦克朝不同的方向画法可能不一样,比如炮筒的画法和旗帜的画法肯定不一样
		switch(direction)
		{//0-->right; 1-->left; 2-->up; 3-->down;
		case 0: //认为是朝右
			//画两条履带
			g.fill3DRect(x, y, 60, 10, false);
			g.fill3DRect(x, y+30, 60, 10, false);
			//画坦克体
			g.fill3DRect(x+10, y+10, 30, 20, false);
			//画盖子
			g.fillOval(x+18, y+13, 14, 14);
			//画炮筒+炮筒头(略粗一点点)
			g.drawLine(x+25, y+20, x+60, y+20);
			g.drawLine(x+55, y+19, x+60, y+19);
			g.drawLine(x+55, y+21, x+60, y+21);
			break;
		case 1://朝左-->由朝右掉头
			//画两条履带
			g.fill3DRect(x, y, 60, 10, false);
			g.fill3DRect(x, y+30, 60, 10, false);
			//画坦克体
			g.fill3DRect(x+20, y+10, 30, 20, false);
			//画盖子
			g.fillOval(x+28, y+13, 14, 14);
			//画炮筒+炮筒头(略粗一点点)
			g.drawLine(x+35, y+20, x, y+20);
			g.drawLine(x+5, y+19, x, y+19);
			g.drawLine(x+5, y+21, x, y+21);
			break;
		case 2://朝上-->由朝右转头
			//画两条履带
			g.fill3DRect(x, y, 10, 60, false);
			g.fill3DRect(x+30, y, 10, 60, false);
			//画坦克体
			g.fill3DRect(x+10, y+20, 20, 30, false);
			//画盖子
			g.fillOval(x+13, y+28, 14, 14);
			//画炮筒+炮筒头(略粗一点点)
			g.drawLine(x+20, y, x+20, y+35);
			g.drawLine(x+19, y, x+19, y+5);
			g.drawLine(x+21, y, x+21, y+5);
			break;
		case 3://朝下-->由朝上掉头
			//画两条履带
			g.fill3DRect(x, y, 10, 60, false);
			g.fill3DRect(x+30, y, 10, 60, false);
			//画坦克体
			g.fill3DRect(x+10, y+10, 20, 30, false);
			//画盖子
			g.fillOval(x+13, y+18, 14, 14);
			//画炮筒+炮筒头(略粗一点点)
			g.drawLine(x+20, y+10, x+20, y+60);
			g.drawLine(x+19, y+55, x+19, y+60);
			g.drawLine(x+21, y+55, x+21, y+60);
			break;
		}
		
	}
	
	//写一个方法或者当前Panel中存活的敌军坦克数
	public int getAliveTanks()
	{
		int aliveTankNum = 0;
		for(int i=0;i<this.enemyTanks.size();i++)
		{
			EnemyTank et = this.enemyTanks.get(i);
			if(et.isLive())
			{
				aliveTankNum++;
			}
		}
		return aliveTankNum ;
	}

	//写一个方法判断面板中的子弹是否与坦克遭遇，遭遇则将坦克置为isLive = false
	public void gotTarget(Bullet b,EnemyTank et)
	{
		//一定要判断子弹和坦克是否存活,不然会碰到幽灵坦克和幽灵子弹
		if(b.isLive() && et.isLive())
		{
			//需要根据坦克的方向来判断
			switch(et.getDirection())
			{
			case 0:
			case 1: 
				if(b.getX()>et.getX() && b.getX() < et.getX()+56 && b.getY()>et.getY() && b.getY()<et.getY()+36)
				{
					b.setLive(false);//将子弹置为死亡
					et.setLive(false);//将坦克置为死亡
				}
				break;
			case 2:
			case 3: 
				if(b.getX()>et.getX() && b.getX()<et.getX()+36 && b.getY()>et.getY() && b.getY()<et.getY()+56)
				{
					b.setLive(false);//将子弹置为死亡
					et.setLive(false);//将坦克置为死亡
				}
				break;			
			}
		
		}
	}

	//写一个方法判断英雄坦克死亡
	public void isSuperDead(Bullet b,SuperTank st)
	{
		//先判断敌军子弹是否存活
		if(b.isLive() && st.isLive())
		{
			//需要根据坦克的方向来判断
			switch(st.getDirection())
			{
			case 0:
			case 1: 
				if(b.getX()>st.getX() && b.getX() < st.getX()+56 && b.getY()>st.getY() && b.getY()<st.getY()+36)
				{
					b.setLive(false);//将子弹置为死亡
					st.setLive(false);//将坦克置为死亡
				}
				break;
			case 2:
			case 3: 
				if(b.getX()>st.getX() && b.getX()<st.getX()+36 && b.getY()>st.getY() && b.getY()<st.getY()+56)
				{
					b.setLive(false);//将子弹置为死亡
					st.setLive(false);//将坦克置为死亡
				}
				break;			
			}
		}
	}
	//写一个方法加入坦克

	public void addEnemyTank()
	{
		EnemyTank et = new EnemyTank(0,0);
		et.setDirection(3);
		et.setTankType(1);
		//一定记得把坦克加入到Vector中，不然尼玛取不到，也画不出来
		this.enemyTanks.add(et);
		Thread t = new Thread(et);
		t.start();
	}
	
	@Override //重写监听方法
	public void actionPerformed(ActionEvent e) {
		// TODO Auto-generated method stub
		if(e.getActionCommand().equals("friend"))
		{
			this.st.setTankType(0);
		}else if(e.getActionCommand().equals("enemy"))
		{
			this.st.setTankType(1);
		}else if(e.getActionCommand().equals("speedUp"))
		{
			this.st.setSpeed(this.st.getSpeed()+1);
			
		}else if(e.getActionCommand().equals("speedDown"))
		{
			if((this.st.getSpeed()-1)>0)
			{
				this.st.setSpeed(this.st.getSpeed()-1);
			}else{
				this.st.setSpeed(1);
			}
			
		}else{
			System.out.println("真神奇，你竟然能让程序跑到这个逻辑来！");
		}
		this.repaint();
	}

	@Override
	public void keyPressed(KeyEvent e) {
		// TODO Auto-generated method stub
		if(e.getKeyCode()==KeyEvent.VK_S)
		{
			this.st.setDirection(3);//控制方向
			this.st.move(this.st.getDirection());
		}else if(e.getKeyCode()==KeyEvent.VK_W)
		{
			this.st.setDirection(2);
			this.st.move(this.st.getDirection());
		}else if(e.getKeyCode()==KeyEvent.VK_A)
		{
			this.st.setDirection(1);
			this.st.move(this.st.getDirection());
		}else if(e.getKeyCode()==KeyEvent.VK_D)
		{
			this.st.setDirection(0);
			this.st.move(this.st.getDirection());
		}
		//判断发射子弹
		if(e.getKeyCode()==KeyEvent.VK_J)
		{
			this.st.fair();
		}
		
		this.repaint();
	}

	@Override//释放键盘
	public void keyReleased(KeyEvent ke) {
		// TODO Auto-generated method stub
		
	}

	@Override//打印字符
	public void keyTyped(KeyEvent ke) {
		// TODO Auto-generated method stub
		
	}

	
	@Override
	public void run() {
		// 重写run()方法，刷新整个MyPanel
		while(true)
		{
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			//System.out.println("刷新了一次！");//测试使用
			//判断子弹是否击中敌军坦克
			for(int i=0;i<this.st.bulletVector.size();i++)
			{
				Bullet b = this.st.bulletVector.get(i);
				for(int j=0;j<this.enemyTanks.size();j++)
				{
					EnemyTank et = this.enemyTanks.get(j);
					this.gotTarget(b, et);
				}
			}
			//判断英雄坦克是否死亡-->对每辆坦克的每颗子弹进行判断
			for(int i=0;i<this.enemyTanks.size();i++)
			{
				if(this.enemyTanks.get(i).isLive())
				{
					EnemyTank et = this.enemyTanks.get(i);
					for(int j=0;j<et.bulletVector.size();j++)
					{
						if(et.bulletVector.get(j).isLive())
						{
							Bullet b = et.bulletVector.get(j);
							this.isSuperDead(b, this.st);
						}
					}
				}
			}
			//判断敌军坦克是否需要增加,少于三个存活的坦克则增加到三个，总数达到20个则不再增加
			if(this.getAliveTanks()<3 && this.enemyTanks.size()<20)
			{
				this.addEnemyTank();
			}
			//敌军射击
			for(int j=0;j<this.enemyTanks.size();j++)
			{
				if(this.enemyTanks.get(j).isLive())
				{
					this.enemyTanks.get(j).fair();
				}
			}
			
			//重新调用repaint()
			this.repaint();					
		}		
	}	
}




//操作面板类
class oprationPanel extends JPanel
{

	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;

	public oprationPanel()
	{
		
	}
	
}


package com.firstversion;

import java.util.*;

class Tank
{
	private int x=100;//坦克初始位置的横坐标
	private int y=100;//坦克初始位置的纵坐标
	private int direction=2; //坦克的朝向
	private int speed=4;//坦克的速度
	private int tankType=0;//坦克类型
	private boolean isLive = true ;//坦克默认存活

	Vector<Bullet> bulletVector = null;//使用Vector是为了使每个打出去的子弹都是一个线程，同时每个坦克可以打出多个子弹
	//成员属性访问和设置方法群
	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 getDirection() {
		return direction;
	}
	public void setDirection(int direction) {
		this.direction = direction;
	}
	public int getSpeed() {
		return speed;
	}
	public void setSpeed(int speed) {
		this.speed = speed;
	}
	public int getTankType() {
		return tankType;
	}
	public void setTankType(int tankType) {
		this.tankType = tankType;
	}
	public boolean isLive() {
		return isLive;
	}
	public void setLive(boolean isLive) {
		this.isLive = isLive;
	}


	
	//坦克构造函数,很重要,对于需要在其他位置调用的成员属性，在此都需要初始化，不然会报空指针
	public Tank(int x, int y)
	{
		this.x=x;
		this.y=y;
		//这句话初始化Vector一定要有的，不然会在MyPanel中调用出现空指针错误
		bulletVector = new Vector<Bullet>();
		
	}
	//坦克移动的能力方法，以方向为入参
	public void move(int direction)
	{//0-->right; 1-->left; 2-->up; 3-->down;
		switch(direction)
		{
		case 0: if(x+speed<455) x+=speed; break;
		case 1: if(x-speed>0) x-=speed; break;
		case 2: if(y-speed>0) y-=speed; break;
		case 3: if(y+speed<362) y+=speed; break;
		default: break;
		}
		//System.out.println("跑了一次！");
	}

	//判断当前坦克存活子弹数
	public int getAliveBullets()
	{
		int aliveBulletNum =0 ;
		for(int i=0;i<this.bulletVector.size();i++)
		{
			Bullet b = this.bulletVector.get(i);
			if(b.isLive())
			{
				aliveBulletNum++;
			}
		}
		return aliveBulletNum;
	}
}

class SuperTank extends Tank
{
	
	public SuperTank(int x,int y)
	{
		super(x,y);//使用父类的能够匹配（参数个数与类型完全一致）的构造函数
	}
	//fair
	public void fair()
	{//每次开火就产生一个子弹，也就是子弹类的实例对象,加入到bulletVector中的最后一位，再从最后一个取取出来启动线程
		if(this.getAliveBullets()<3)
		{
			switch(this.getDirection())
			{
			case 0: bulletVector.addElement(new Bullet(this.getX()+60,this.getY()+18,this.getDirection())); break;
			case 1: bulletVector.addElement(new Bullet(this.getX()-4,this.getY()+18,this.getDirection())); break;
			case 2: bulletVector.addElement(new Bullet(this.getX()+18,this.getY()-4,this.getDirection())); break;
			case 3: bulletVector.addElement(new Bullet(this.getX()+18,this.getY()+60,this.getDirection()));break;
			}
			//在每次发射动作之后，就要启动这个线程
			Thread t = new Thread(bulletVector.lastElement());
			t.start();
		}

	}
}


//敌军坦克类，因为敌军坦克需要自己走动,所以实现Runnable接口，另每一个敌军坦克对象作为一个线程
class EnemyTank extends Tank implements Runnable
{
	private boolean isMoving = false ;
	private int fairController = 25 ;

	public int getFairController() {
		return fairController;
	}
	public void setFairController(int fairController) {
		this.fairController = fairController;
	}

	public boolean isMoving() {
		return isMoving;
	}
	public void setMoving(boolean isMoving) {
		this.isMoving = isMoving;
	}
	public EnemyTank(int x, int y) {
		super(x, y);
	}
	//fair automatically -- fair controller
	//fair
	public void fair()
	{//每次开火就产生一个子弹，也就是子弹类的实例对象,加入到bulletVector中的最后一位，再从最后一个取取出来启动线程
		if(this.fairController>0)
		{
			this.fairController--;
			//System.out.println("不发射子弹");
		}else
		{
			//System.out.println("发射子弹");
			switch(this.getDirection())
			{
			case 0: bulletVector.addElement(new Bullet(this.getX()+60,this.getY()+18,this.getDirection())); break;
			case 1: bulletVector.addElement(new Bullet(this.getX()-4,this.getY()+18,this.getDirection())); break;
			case 2: bulletVector.addElement(new Bullet(this.getX()+18,this.getY()-4,this.getDirection())); break;
			case 3: bulletVector.addElement(new Bullet(this.getX()+18,this.getY()+60,this.getDirection()));break;
			}
			//在每次发射动作之后，就要启动这个线程
			Thread t = new Thread(bulletVector.lastElement());
			t.start();
			this.setFairController(25);
		}
		
	}
	@Override
	public void run() {
		// TODO Auto-generated method stub
		int i =500;
		int j =3;
		while(true)
		{
			//休眠
			try {
				Thread.sleep(i);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			//随机秒	
			i = (int)(Math.random()*5000);
			//开始计时毫秒级时间
			Date d = new Date();
			long longtime = d.getTime();
			//测试打印代码
			//System.out.println(longtime);
			//System.out.println(longtime+i);
			//System.out.println((new Date()).getTime());
			
			//随机方向
			j = ((int)(Math.random()*100))%4;
			//一定要按照随机的方向给敌军坦克设置方向，不能只定义移动方向，不然你会看到坦克横着开
			this.setDirection(j);
			//休眠结束时,将坦克置为移动状态
			this.setMoving(true);
			//在随机数期间保持运动
			while(true)
			{
				try {
					Thread.sleep(100);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				Date d2 = new Date();
				//System.out.println("d2:"+d2.getTime());
				if(longtime+i>d2.getTime())
				{
					//调用移动方法
					this.move(j);
				}else{
					//停止时发射一个子弹
					this.fair();
					break;
				}
			}
			
			//退出循环时,将坦克置为静止
			this.setMoving(false);
			//在坦克静止时，每隔2~3s发射一颗子弹
			//判断线程退出
			if(this.isLive()==false)
			{
				break;
			}
		}
	}
}



//子弹类,作为线程处理
class Bullet implements Runnable
{
	private int x;
	private int y;
	private int speed = 5;//妈的这个地方坑死老子了，打了子弹就是不走，最后找到初始速度尼玛默认为0了
	private int direction;
	private boolean isLive = true;//默认子弹是激活的
	
	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 int getDirection() {
		return direction;
	}

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

	public boolean isLive() {
		return isLive;
	}

	public void setLive(boolean isLive) {
		this.isLive = isLive;
	}

	//Bullet构造方法
	public Bullet(int x, int y, int direction)
	{
		this.x=x;
		this.y=y;
		this.direction=direction;
	}
	
	@Override//重写run()方法
	public void run(){
		//在fair()的方法中，会调用start(),进而似的run()得以执行,所以在run()中需要包含当前子弹线程结束的逻辑判断
		//需要进行当前子弹的方向的判断
		while(true)
		{
			try {
				Thread.sleep(100);//每100毫秒变化一次初始位置,这样在MyPanel中进行repaint()就可以实现让子弹飞了
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			switch(this.direction)
			{
			case 0: x+=this.speed; break;
			case 1: x-=this.speed; break;
			case 2: y-=this.speed; break;
			case 3: y+=this.speed; break;
			}
			
			//System.out.println("子弹坐标:["+this.x+","+this.y+"]");//测试使用
			//判断子弹到边界自动退出线程
			if(x<0||y<0||x>600||y>450)
			{
				this.setLive(false);//将子弹状态置为非激活,作为后面在画子弹时需要判断的条件
				break;
				//这里不知道怎么在退出线程时,清除Vector中已经消亡的子弹；初步考虑应该在外部按照时间和子弹状态来清除子弹
			}else if(this.isLive==false){
				break;
			}
				
		}

	}
	
}