Java坦克大战代码

上代码前的图片：（爆炸效果）



请按这三张图片的顺序插入

上代码！

MyTankGame8.java

/**
 * 功能:坦克游戏的7.0      
 * 1.画出坦克(√)
 * 2.我的坦克可以上下左右移动(√)
 * 3.可以连发子弹(最多5).(√)
 * 4.当我的坦克击中敌人的坦克时，敌人就消失(爆炸的效果)(√)
 * 5.我被击中后，显示爆炸效果(√)
 * 6.防止敌人坦克重叠运动(√)
 *   6.1.判断是否碰撞的函数写到EnemyTank类
 * 7.可以分关(√)
 *   7.1.做一个开始的Panel，他是一个空的
 *   7.2.闪烁效果
 * 8.可以在玩游戏的时候暂停和继续(√)
 *   8.1.暂停的时候，坦克和子弹速度为0，并且坦克方向不变
 * 9.可以记录玩家的成绩(√)
 * 	 9.1.用文件流
 *   9.2.单写一个纪录类，完成玩家记录
 *   9.3.先完成保存共击毁了多少辆敌人的坦克的功能
 *   9.4.存盘退出游戏，可以记录当时的敌人的坦克的坐标，并可以修复
 * 10.java如何操作声音文件(√)
 */
package lesson_49;

import java.awt.*;       
import javax.swing.*;
import java.awt.event.*;
import java.util.*;
import javax.imageio.*;
import java.io.*;
@SuppressWarnings({"serial","unused"})
public class MyTankGame8 extends JFrame implements ActionListener {

	MyPanel mp =null;
	
	//定义一个开始面板
	MyStartPanel msp =null;
	
	//做出我需要的菜单
	JMenuBar jmb =null;
	
	//开始游戏
	JMenu jm1 =null;
	JMenuItem jmi1 =null;
	
	//退出系统
	JMenuItem jmi2 =null;
	
	//存盘退出
	JMenuItem jmi3 =null;
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		MyTankGame8 mtg =new MyTankGame8();
	}
	
	//构造函数
	public MyTankGame8()
	{		
		//创建菜单及菜单选项
		jmb =new JMenuBar();
		jm1 =new JMenu("游戏(G)");
		jmi1 =new JMenuItem("开始新游戏(N)");
		jmi2 =new JMenuItem("退出游戏(E)");
		jmi3 =new JMenuItem("存盘退出游戏(C)");
		
		jm1.add(jmi1);
		jm1.add(jmi2);
		jm1.add(jmi3);
		
		jmb.add(jm1);
		
		//设置快捷方式
		jm1.setMnemonic('G');
		jmi1.setMnemonic('N');
		jmi2.setMnemonic('E');
		jmi3.setMnemonic('C');
		
		//对jmi响应
		jmi1.addActionListener(this);
		jmi1.setActionCommand("newgame");
		jmi2.addActionListener(this);
		jmi2.setActionCommand("exit");
		jmi3.addActionListener(this);
		jmi3.setActionCommand("saveExit");
		
		msp =new MyStartPanel();
		this.add(msp);
		
		Thread th =new Thread(msp);
		th.start();
			
		this.setJMenuBar(jmb);
		this.setSize(600,500);
		this.setVisible(true);
		this.setTitle("坦克大战");
		this.setResizable(false);
		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
	}

	public void actionPerformed(ActionEvent e) 
	{
		//对用户不同的点击做出不同的管理
		if(e.getActionCommand().equals("newgame"))
		{
			mp =new MyPanel();
			//jp1 =new JPanel();
			
			//删除老的面板
			this.remove(msp);
			
			this.add(mp);
				
			//注册监听
			this.addKeyListener(mp);
			
			//启动mp线程
			Thread t =new Thread(mp);
			t.start();
			this.setVisible(true);
		}else if(e.getActionCommand().equals("exit"))
		{
			//用户点击了退出系统的菜单
			//保存击毁敌人数量
			Recorder.keepRecording();
			
			System.exit(0);
		}else if(e.getActionCommand().equals("saveExit"))
		{
			//工作
			new Recorder().setEts(mp.ets);
			
			//保存击毁敌人的数量和敌人的坐标
			new Recorder().keepRecAndEnemyTank();
			
			//退出
			System.exit(0);
		}
	}
}

@SuppressWarnings({"serial"})
//就是一个提示的作用
class MyStartPanel extends JPanel implements Runnable
{
	int times =0;
	
	public void paint(Graphics g)
	{
		super.paint(g);
		
		g.fillRect(0,0,416,339);
		
		if(times%2==0)
		{
			g.setColor(Color.YELLOW);
			//开关信息的字体
			Font myFont =new Font("微软雅黑",Font.BOLD,30);
			g.setFont(myFont);
			
			//提示信息
			g.drawString("stage:1",150,150);
		}
	}

	public void run() 
	{
		while(true)
		{
			//休眠
			try {
				Thread.sleep(500);
			}catch (InterruptedException e){
				e.printStackTrace();
			}
			
			times++;
			
			this.repaint();
		}
	}
}

//我的面板
@SuppressWarnings({"serial"})
class MyPanel extends JPanel implements KeyListener,Runnable
{
	//定义一个我的坦克
	Hero hero =null;
	
	//定义敌人的坦克组
	Vector<EnemyTank> ets =new Vector<EnemyTank>();
	
	//定义炸弹
	Vector<Bomb> bombs =new Vector<Bomb>();
	
	int enSize=3;
	
	//定义三张图片,三张图片才能组成一颗炸弹
	Image image1 =null;
	Image image2 =null;
	Image image3 =null;
	
	//构造函数
	public MyPanel()
	{
		//恢复记录
		Recorder.getRecoring();
		
		hero =new Hero(100,100);
		
		//初始化敌人的坦克
		for(int i=0;i<enSize;i++)
		{
			//创建一辆敌人的坦克对象
			EnemyTank et =new EnemyTank((i+1)*50,0);
			
			et.setColor(0);
			et.setDirect(2);
			
			//将MyPanel的敌人坦克向量交给该敌人坦克
			et.setEts(ets);
			
			//启动敌人的坦克
			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);
		}
		
		try{
			image1 =ImageIO.read(new File("bemb_1.gif"));
			image2 =ImageIO.read(new File("bemb_2.gif"));
			image3 =ImageIO.read(new File("bemb_3.gif"));
		}catch(Exception e){
			e.printStackTrace();
		}
		
		//初始化图片
//		image1 =Toolkit.getDefaultToolkit().getImage(Panel.class.getResource("/bemb_1.gif"));
//		image2 =Toolkit.getDefaultToolkit().getImage(Panel.class.getResource("/bemb_2.gif"));
//		image3 =Toolkit.getDefaultToolkit().getImage(Panel.class.getResource("/bemb_3.gif"));
	}
	
	//画出提示信息
	public void showInfo(Graphics g)
	{	
		//画出提示信息坦克(该坦克不参与战斗)
		this.drawTank(80,330,g,0,0);
		g.setColor(Color.BLACK);
		g.drawString(Recorder.getEnNum()-3+"",105,350);
		this.drawTank(150,330,g,0,1);
		g.setColor(Color.BLACK);
		g.drawString(Recorder.getMyLife()+"",175,350);
		
		//画出玩家的总成绩
		Font f =new Font("宋体",Font.BOLD,20);
		
		g.setFont(f);
		g.setColor(Color.BLACK);
		g.drawString("您的总成绩",420,30);
	
		this.drawTank(420,60,g,0,0);
	
		g.setColor(Color.BLACK);
		g.drawString(Recorder.getAllEnNum()+"",455,80);
	}
	
	//重新paint
	public void paint(Graphics g)
	{
		super.paint(g);
		g.setColor(Color.BLACK);
		g.fillRect(0,0,400,300);
		
		//画出提示信息
		this.showInfo(g);
		
		//画出自己的坦克
		if(hero.isLive)
		{
			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);
			}
			if(myShot.isLive==false)
			{
				//从ss中删除掉该子弹
				hero.ss.remove(myShot);
			}
		}
		
		//画出炸弹
		for(int i=0;i<bombs.size();i++)
		{
			//System.out.println("bombs.size()="+bombs.size());
			//取出炸弹
			Bomb b =bombs.get(i);
			
			if(b.life>6){
				g.drawImage(image1,b.x,b.y,30,30,this);
			}else if(b.life>3){
				g.drawImage(image2,b.x,b.y,30,30,this);
			}else{
				g.drawImage(image3,b.x,b.y,30,30,this);
			}
			
			//让b的生命减小
			b.lifeDown();
			
			//如果炸弹生命值为0，就把该炸弹从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 enemyTank =et.ss.get(j);
					
					if(enemyTank.isLive)
					{
						g.draw3DRect(enemyTank.x,enemyTank.y,1,1,false);
					}else{
						//如果敌人的坦克死亡就从Vector中删掉
						et.ss.remove(enemyTank);
					}
				}
			}
		}
	}
	
	//敌人的子弹是否击中我
	public void hieMe()
	{
		//取出每一个敌人的坦克
		for(int i=0;i<ets.size();i++)
		{
			//取出坦克
			EnemyTank et =ets.get(i);
			
			//取出每一颗子弹
			for(int j=0;j<et.ss.size();j++)
			{
				//取出子弹
				Shot enemyShot =et.ss.get(j);
				
				if(hero.isLive)
				{
					if(this.hitTank(enemyShot,hero))
					{
						//Recorder.reduceEnNum();
						//Recorder.addEnNumRec();
					}
				}
			}
		}
	}
	
	//判断我的坦克是否击中敌人的坦克
	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)
					{
						if(this.hitTank(myShot,et))
						{
							Recorder.reduceEnNum();
							Recorder.addEnNumRec();
						}
					}
				}
			}
		}
	}

	//写一个函数，专门判断子弹是否击中敌人坦克
	public boolean hitTank(Shot s,Tank et)
	{
		boolean b2 =false;
		
		//判断该坦克的方向
		switch(et.direct)
		{
			//如果敌人的坦克方向是上或下
			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;
					
					b2=true;
					
					//创建一颗炸弹,放入Vector
					Bomb b =new Bomb(et.x,et.y);
					
					//放入Vector
					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;
					
					b2=true;
					
					//创建一颗炸弹,放入Vector
					Bomb b =new Bomb(et.x,et.y);
					
					//放入Vector
					bombs.add(b);
				}
				break;
		}
		
		return b2;
	}
	
	//画出坦克的函数(扩展)
	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;
		}
		
		//判断方向
		switch(direct)
		{
			//向上
		    case 0:
		    	//画出我的坦克(到时在封装成函数)
				//1.画出左边的矩形
				g.fill3DRect(x,y,5,30,false);
			
				//2.画出右边的矩形
				g.fill3DRect(x+15,y,5,30,false);
			
				//3.画出中间矩形
				g.fill3DRect(x+5,y+5,10,20,false);
			
				//4.画出圆形
				g.fillOval(x+5,y+10,10,10);
				
				//5.画出线
				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:
		    	//向下
				//1.画出左边的矩形
				g.fill3DRect(x,y,5,30,false);
			
				//2.画出右边的矩形
				g.fill3DRect(x+15,y,5,30,false);
			
				//3.画出中间矩形
				g.fill3DRect(x+5,y+5,10,20,false);
			
				//4.画出圆形
				g.fillOval(x+5,y+10,10,10);
				
				//5.画出线
				g.drawLine(x+10,y+15,x+10,y+30);
		    	break;
		    case 3:
		    	//向左
				//1.画出左边的矩形
				g.fill3DRect(x,y,30,5,false);
			
				//2.画出右边的矩形
				g.fill3DRect(x,y+15,30,5,false);
			
				//3.画出中间矩形
				g.fill3DRect(x+5,y+5,20,10,false);
			
				//4.画出圆形
				g.fillOval(x+10,y+5,10,10);
				
				//5.画出线
				g.drawLine(x+15,y+10,x,y+10);
		    	break;
		}
	}

	//键按下 a表示向左,s表示向下,w表示向上,d表示向右
	public void keyPressed(KeyEvent e) 
	{
		if(e.getKeyCode()==KeyEvent.VK_W)
		{
			//设置我的坦克的方向
			this.hero.setDirect(0);
			this.hero.moveUp();
		}else if(e.getKeyCode()==KeyEvent.VK_D)
		{
			//向右
			this.hero.setDirect(1);
			this.hero.moveRight();
		}else if(e.getKeyCode()==KeyEvent.VK_S)
		{
			//向下
			this.hero.setDirect(2);
			this.hero.moveDown();
		}else if(e.getKeyCode()==KeyEvent.VK_A)
		{
			//向左
			this.hero.setDirect(3);
			this.hero.moveLeft();
		}
		
		//判断玩家是否按下j键
		if(e.getKeyCode()==KeyEvent.VK_J)
		{
			//开火
			if(this.hero.ss.size()<=4)
			{
				this.hero.shotEnemy();	
			}
		}
		
		//必须重绘MyPanel
		this.repaint();
	}
	
	public void keyReleased(KeyEvent e) {
		
	}
	
	public void keyTyped(KeyEvent e) {
		
	}
	
	public void run()
	{
		//每隔一百毫秒刷新一次
		while(true)
		{
			try{
				Thread.sleep(100);
			}catch(Exception e){
				e.printStackTrace();
			}
			
			this.hitEnemyTank();
			
			//判断敌人的坦克有没有击中我的坦克
			this.hieMe();
			
			//重绘
			repaint();
		}
	}
}

Members.java

package lesson_49;

import java.util.*;
import java.io.*;
//纪录类，同时也可以保存玩家的
class Recorder
{
	//记录每关有多少个敌人
	private static int enNum=23;
	
	//设置我有多少可用的人
	private static int myLife=3;
	
	//记录总共消灭了多少辆坦克
	private static int allEnNum=0;
	
	private static FileWriter fw =null;
	private static BufferedWriter bw =null;
	private static FileReader fr =null;
	private static BufferedReader br =null;
	private Vector<EnemyTank> ets = new Vector<EnemyTank>();
	
	//保存击毁敌人的数量和敌人坦克坐标，方向
	public void keepRecAndEnemyTank()
	{
		try{
			fw =new FileWriter("d:\\myRecording1.txt");
			bw =new BufferedWriter(fw);
			
			bw.write(allEnNum+"\r\n");
			
			//保存当前活的敌人坦克的坐标和方向
			for(int i=0;i<ets.size();i++)
			{
				//取出第一个坦克
				EnemyTank et =ets.get(i);
				
				if(et.isLive)
				{
					//活的就保存
					String recode =et.x+" "+et.y+" "+et.direct;
				
					//写入
					bw.write(recode+"\r\n");
				}
			}
		}catch(Exception e){
			e.printStackTrace();
		}finally{
			try{
				bw.close();
				fw.close();
			}catch(Exception e){
				e.printStackTrace();
			}
		}
	}
	
	//从文件中读取，记录
	public static void getRecoring()
	{
		try{
			fr =new FileReader("d:\\myRecording.txt");
			br =new BufferedReader(fr);
			String n =br.readLine();
			allEnNum =Integer.parseInt(n);
		}catch(Exception e){
			e.printStackTrace();
		}finally{
			try{
				br.close();
				fr.close();
			}catch(Exception e){
				e.printStackTrace();
			}
		}
	}
	
	//把玩家击毁敌人坦克数量保存到文件中
	public static void keepRecording() 
	{
		try{
			fw =new FileWriter("d:\\myRecording.txt");
			bw =new BufferedWriter(fw);
			
			bw.write(allEnNum+"\r\n");
		}catch(Exception e){
			e.printStackTrace();
		}finally{
			try{
				bw.close();
				fw.close();
			}catch(Exception e){
				e.printStackTrace();
			}
		}
	}
	
	public static int getAllEnNum() {
		return allEnNum;
	}

	public static void setAllEnNum(int allEnNum) {
		Recorder.allEnNum = allEnNum;
	}

	public static int getEnNum() {
		return enNum;
	}

	public static void setEnNum(int enNum) {
		Recorder.enNum = enNum;
	}

	public static int getMyLife() {
		return myLife;
	}

	public static void setMyLife(int myLife) {
		Recorder.myLife = myLife;
	}
	
	//减少敌人数量
	public static void reduceEnNum()
	{
		enNum--;
	}
	
	//消灭敌人
	public static void addEnNumRec()
	{
		allEnNum++;
	}
	
	public Vector<EnemyTank> getEts()
	{
		return ets;
	}
	
	public void setEts(Vector<EnemyTank> ets1)
	{
		//this.ets =ets;
		System.out.println("ok");
	}
}

//炸弹类
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{
			this.isLive=false;
		}
	}
}

//子弹类
class Shot implements Runnable
{
	int x;
	int y;
	int direct;
	int speed=1;
	
	//是否还活着
	boolean isLive =true;
	
	public Shot(int x,int y,int direct)
	{
		this.x=x;
		this.y=y;
		this.direct=direct;
	}
	
	public void run()
	{	
		while(true)
		{
			try
			{
				Thread.sleep(50);
			}catch(Exception e){
				e.printStackTrace();
			}
			
			switch(direct)
			{
				case 0:
					//向上
					y-=speed;
					break;
				case 1:
					//左
					x+=speed;
					break;
				case 2:
					//下
					y+=speed;
					break;
				case 3:
					//右
					x-=speed;
					break;
			}
				
			//子弹何时死亡[???思考题???]
			//判断该子弹是否碰到边缘
			if(x<0||x>400||y<0||y>300)
			{
				this.isLive=false;
				break;
			}
		}
	}
}

//坦克类
class Tank
{
	//表示坦克的横坐标
	int x=0;
	
	//坦克纵坐标
	int y=0;
	
	//坦克方向
	//0表示上，1表示右，2表示下，3表示左
	int direct=0;
	int color;
	
	boolean isLive =true;
	
	public int getColor() {
		return color;
	}

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

	//坦克的速度
	int speed=1;
	
	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 Tank(int x,int y)
	{
		this.x=x;
		this.y=y;
	}
}

//敌人的坦克,把敌人做成线程类
class EnemyTank extends Tank implements Runnable 
{
	//boolean isLive=true;
	
	//定义一个向量，可以访问到MyPanel上所有敌人的坦克
	Vector<EnemyTank> ets =new Vector<EnemyTank>(); 
	
	//定义一个向量，可以存放敌人的子弹
	Vector<Shot> ss =new Vector<Shot>();
	
	//敌人添加子弹，应当在刚刚创建的坦克和敌人的坦克死亡的过后
	
	int times =0;
	
	public EnemyTank(int x,int y)
	{
		super(x,y);
	}
	
	//得到MyPanel的敌人坦克向量
	public void setEts(Vector<EnemyTank> vv)
	{
		this.ets=vv;
		//isTouchOtherEnemy();
	}
	
	//判断是否碰到了别的敌人坦克
	public boolean isTouchOtherEnemy()
	{
		boolean b=false;
		
		switch(this.direct)
		{
			case 0:
				//我的坦克在上
				//取出所有敌人的坦克
				for(int i=0;i<ets.size();i++)
				{
					//取出第一个坦克
					EnemyTank et =ets.get(i);
					
					//如果不是自己
					if(et!=this)
					{
						//如果敌人的方向是向下或向上
						if(et.direct==0||et.direct==2)
						{
							if(this.x>=et.x&&this.x<=et.x+20&&this.y>=et.y&&this.y<=et.y+30)
							{
								return true;
							}
							
							if(this.x+20>=et.x&&this.x+20<et.x+20&&this.y>=et.y&&this.y<=et.y+30)
							{
								return true;
							}
						}
						
						//向左或向右
						if(et.direct==3||et.direct==1)
						{
							if(this.x>=et.x&&this.x<=et.x+30&&this.y>=et.y&&this.y<=et.y+20)
							{
								return true;
							}
							
							if(this.x+20>=et.x&&this.x+20<et.x+30&&this.y>=et.y&&this.y<=et.y+20)
							{
								return true;
							}
						}
					}
				}
				break;
			case 1:
				//我的坦克在右
				//取出所有敌人的坦克
				for(int i=0;i<ets.size();i++)
				{
					//取出第一个坦克
					EnemyTank et =ets.get(i);
					
					//如果不是自己
					if(et!=this)
					{
						//如果敌人的方向是向下或向上
						if(et.direct==0||et.direct==2)
						{
							if(this.x+30>=et.x&&this.x+30<=et.x+20&&this.y>=et.y&&this.y<=et.y+30)
							{
								return true;
							}
							
							if(this.x+30>=et.x&&this.x+30<=et.x+20&&this.y+20>=et.y&&this.y+20<=et.y+30)
							{
								return true;
							}
						}
						
						//向左或向右
						if(et.direct==3||et.direct==1)
						{
							if(this.x+30>=et.x&&this.x+30<=et.x+30&&this.y>=et.y&&this.y<=et.y+20)
							{
								return true;
							}
							
							if(this.x+30>=et.x&&this.x+30<=et.x+30&&this.y+20>=et.y&&this.y+20<=et.y+20)
							{
								return true;
							}
						}
					}
				}
				break;
			case 2:
				//我的坦克在下
				//取出所有敌人的坦克
				for(int i=0;i<ets.size();i++)
				{
					//取出第一个坦克
					EnemyTank et =ets.get(i);
					
					//如果不是自己
					if(et!=this)
					{
						//如果敌人的方向是向下或向上
						if(et.direct==0||et.direct==2)
						{
							if(this.x>=et.x&&this.x<=et.x+20&&this.y+30>=et.y&&this.y+30<=et.y+30)
							{
								return true;
							}
							
							if(this.x+20>=et.x&&this.x+20<=et.x+20&&this.y+30>=et.y&&this.y+30<=et.y+30)
							{
								return true;
							}
						}
						
						//向左或向右
						if(et.direct==3||et.direct==1)
						{
							if(this.x>=et.x&&this.x<=et.x+30&&this.y+30>=et.y&&this.y+30<=et.y+20)
							{
								return true;
							}
							
							if(this.x+20>=et.x&&this.x+20<=et.x+30&&this.y+30>=et.y&&this.y+30<=et.y+20)
							{
								return true;
							}
						}
					}
				} 
				break;
			case 3:
				//我的敌人坦克向左  
				//取出所有敌人的坦克
				for(int i=0;i<ets.size();i++)
				{
					//取出第一个坦克
					EnemyTank et =ets.get(i);
					
					//如果不是自己
					if(et!=this)
					{
						//如果敌人的方向是向下或向上
						if(et.direct==0||et.direct==2)
						{
							if(this.x>=et.x&&this.x<=et.x+20&&this.y>=et.y&&this.y+30<=et.y+30)
							{
								return true;
							}
							
							if(this.x>=et.x&&this.x<=et.x+20&&this.y+20>=et.y&&this.y+20<=et.y+30)
							{
								return true;
							}
						}
						
						//向左或向右
						if(et.direct==3||et.direct==1)
						{
							if(this.x>=et.x&&this.x<=et.x+30&&this.y>=et.y&&this.y<=et.y+20)
							{
								return true;
							}
							
							if(this.x>=et.x&&this.x<=et.x+30&&this.y+20>=et.y&&this.y+20<=et.y+20)
							{
								return true;
							}
						}
					}
				}
				break;
		}
		
		return b;
	}
	
	public void run()
	{
		while(true)
		{
			try{
				Thread.sleep(50);
			}catch(Exception e){
				e.printStackTrace();
			}
			
			switch(this.direct)
			{
				case 0:
					//说明坦克正在向上
					for(int i=0;i<30;i++)
					{
						if(y>0&&!this.isTouchOtherEnemy())
						{
							y-=speed;
						}
						
						try{
							Thread.sleep(50);
						}catch(Exception e){
							e.printStackTrace();
						}
					}
					break;
				case 1:
					//向右
					for(int i=0;i<30;i++)
					{
						//保证坦克不出边界
						if(x<400&&!this.isTouchOtherEnemy())
						{
							x+=speed;
						}
						
						try{
							Thread.sleep(50);
						}catch(Exception e){
							e.printStackTrace();
						}
					}
					break;
				case 2:
					//向下
					for(int i=0;i<30;i++)
					{
						if(y<300&&!this.isTouchOtherEnemy())
						{
							y+=speed;
						}
						
						try{
							Thread.sleep(50);
						}catch(Exception e){
							e.printStackTrace();
						}
					}
					break;
				case 3:
					//向左
					for(int i=0;i<30;i++)
					{
						if(x>0&&!this.isTouchOtherEnemy())
						{
							x-=speed;
						}
						
						try{
							Thread.sleep(50);
						}catch(Exception e){
							e.printStackTrace();
						}
					}
					break;
			}
			
			this.times++;
			
			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+10,y+10,3);
								ss.add(s);
								break;
						}
						
						Thread t =new Thread(s);
						t.start();
					}
				}
			}
			
			//让坦克随机长生一个新的方向
			this.direct=(int)(Math.random()*4);
			
			//判断敌人坦克是否死亡
			if(this.isLive==false)
			{
				//让坦克死亡后，退出线程
				break;
			}
		}
	}
}

//定义我的坦克
class Hero extends Tank
{	
	//子弹
	//Shot s=null;
	Vector<Shot>ss =new Vector<Shot>();
	Shot s =null;
	
	public Hero(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;
	}
}

完结

本文地址：https://blog.csdn.net/weixin_45445598/article/details/107590035