Java__线程---基础知识全面实战---坦克大战系列为例

今天想将自己去年自己编写的坦克大战的代码与大家分享一下，主要面向学习过java但对java运用并不是很熟悉的同学，该编程代码基本上涉及了java基础知识的各个方面，大家可以通过练习该程序对自己的java进行一下实战。

每个程序版本代码中，都附有相关注释，看完注释大家就可以对本程序设计有个很明显的思路。真的很有趣，想对java重新温习的同学完全不必再对厚厚的java基础书籍进行阅读了，在跟着本次代码练习并分析后，大家一定会对java各方面基础知识 尤其是线程的知识有更深一步的了解！！！

本次坦克大战系列的各个版本都是在一步步的升级改进，难度逐渐加大，功能愈加完善；话不多说，先给大家分享一下代码(●ˇ∀ˇ●)

Tank大战 version1.0

实现功能：
  1.绘制出我方Tank;

2.可以通过键盘上下左右键 控制移动；

 package com.test;

 import java.awt.Color;
 import java.awt.Graphics;
 import java.awt.event.*;

 import javax.swing.*;

 public class MyTankGame extends JFrame {
     Mypanel mp=null;
     public static void main(String[] args) {
         // TODO 自动生成的方法存根
        MyTankGame mtg=new MyTankGame();
     }
     //构造函数
     public MyTankGame()
     {
         mp=new Mypanel();
         this.add(mp);
         this.setSize(800,600);
         this.setVisible(true);
         this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

     }

 }

 //坦克类
 class Tank
 {
      //表示坦克横坐标
     int x=0;
     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;
     }

     //表示坦克纵坐标
     int y=0;

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

 //我的Tank
 class Hero extends Tank
 {

     public Hero(int x, int y) {
         super(x, y);
         // TODO 自动生成的构造函数存根
     }

 }

 //我的面板
 class Mypanel extends JPanel
 {
     //定义一个我的坦克
     Hero hero=null;

     //构造函数
     public Mypanel()
     {
         hero=new Hero(100,100);
     }
     public void paint(Graphics g)
     {
         super.paint(g);
         //设置面板背景色，全部填充即可，默认为黑色
         g.fillRect(0, 0, 800, 600);
         //画出我的tank，放到paint函数中
         this.DrawTank(hero.getX(), hero.getY(), g,0,0);//hero.getX(), hero.getY()就将x,y传过去了
     }

     //画出tank
     public void DrawTank(int x,int y,Graphics g,int direct,int type)
     {
         //判断是什么类型坦克
         switch(type)
         {
         case 0://我的tank
             g.setColor(Color.cyan);
             break;
         case 1://敌人的tank
             g.setColor(Color.orange);
             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.fillRect(x+9, y, 2, 10);
             break;
         }
     }
 }

 /*
                           画出左边矩形
             g.fill3DRect(hero.getX(), hero.getY(), 5, 30, false);
             //画出右边矩形
             g.fill3DRect(hero.getX()+15, hero.getY(), 5, 30, false);
             //画出中间矩形
             g.fill3DRect(hero.getX()+5, hero.getY()+5, 10, 20, false);
             //画出中间圆形
             g.fillOval(hero.getX()+5, hero.getY()+10, 10, 10);
             //画出中间直线
             g.drawLine(hero.getX()+10, hero.getY()+15, 10, 20);
             break;

  */
  

Tank大战 version2.0

java练习---->坦克大战2.0------>引入多线程

实现功能：
  1.有敌方tank与我方tank;

2.我方tank可以控制移动；

3.我方tank可以发射炮弹；

4.敌方tank未作处理；

 package TankGame2;

 import java.awt.*;
 import java.awt.event.KeyEvent;
 import java.awt.event.KeyListener;
 import java.util.*;
 import javax.swing.*;
 public class MyTankGame2  extends JFrame
 {
  MyPanel mp=null;
  public static void main(String[] args)
  {
   MyTankGame2 mytankgame1=new MyTankGame2();
  }

  public MyTankGame2()
  {
   mp=new MyPanel();
   //启动mp线程

   Thread t=new Thread(mp);
   t.start();

   this.add(mp);
   this.addKeyListener(mp);

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

 class MyPanel extends JPanel implements KeyListener,Runnable
 {
  //定义我的坦克，成员变量
  Hero hero=null;

  //定义敌人的坦克组

  Vector<EnemyTank> ets=new Vector<EnemyTank>();
  int enSize=3;

  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);

    //画出子弹
    if (hero.s!=null&&hero.s.isLive==true)
    {
     g.draw3DRect(hero.s.x, hero.s.y, 1, 1, false);

    }

    //画出敌人的坦克
    for(int i=0;i<ets.size();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.cyan);break;
   case 1:
    g.setColor(Color.yellow);break;
   }
   //判断方向

   switch(direct)
   {
   //向上
   case 0:
     //画出我的坦克（到时候再封装成一个函数）
     //1.画出左面的矩形
     //g.drawRect(hero.getX(), hero.getY(), 5, 30);
     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);
     //画出中间的圆
     g.fillOval(x+4, y+10,10,10);
     //画出线
     g.drawLine(x+9, y+15, x+9, 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+4, 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;
   } 

  }

  public MyPanel()
  {
   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);
    ets.add(et);
   }

  }

  //键按下处理a表示左，s表示向下，w表示向上，d表示向右
  public void keyPressed(KeyEvent e)
  {
   if(e.getKeyCode()==KeyEvent.VK_UP)
   {
    // 设置我的坦克的方向
    this.hero.setDirect(0);
    this.hero.moveUp();
   }

   else if (e.getKeyCode()==KeyEvent.VK_DOWN)
   {
    this.hero.setDirect(2);
    this.hero.moveDown();
   }

   else if (e.getKeyCode()==KeyEvent.VK_RIGHT)
   {
    this.hero.setDirect(1);
    this.hero.moveRight();

   }
   else if (e.getKeyCode()==KeyEvent.VK_LEFT)
   {
    this.hero.setDirect(3);
    this.hero.moveLeft();
   }

   if (e.getKeyCode()==KeyEvent.VK_SPACE)
   {
    this.hero.shotEnemy();

   }

   //必须重新绘制Panel
   this.repaint();
  }

  public void keyReleased(KeyEvent e)                      //有什么用？！！！！！！！！！！！
  {

  }
  public void keyTyped(KeyEvent e)
  {

  }
  public void run()
  {
  //每个一百毫秒去重画子弹
   while(true)
   {
    try {
     Thread.sleep(100);
    } catch (InterruptedException e) {
     // TODO Auto-generated catch block
     e.printStackTrace();
    }
    this.repaint();

   }
  }

 }

 class Tank
 {

  //设置坦克的速度
  int speed=1;
  public int getSpeed()
  {
   return speed;
  }
  public void setSpeed(int speed)
  {
   this.speed = speed;
  }
  //表示坦克的横坐标
  int x=0;
  //坦克的纵坐标
  int y=0;
  int direct=0;
  int color;

  //坦克方向，0表示上，1表示右，2表示下，3表示左
  public int getColor() {
   return color;
  }
  public void setColor(int color) {
   this.color = color;
  }
  public int getDirect()
  {
   return direct;
  }

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

  public int getX()
  {
   return x;
  }
  public void setX(int x)
  {
   this.x = x;
  }
  public int getY()
  {
   return y;
  }
  public void setY(int y)
  {
   this.y = y;
  }

 }

 class EnemyTank extends Tank
 {
  public EnemyTank(int x,int y)
  {
   super(x,y);                                                            //super的用法？？？

  }
 }

 //我的坦克
 class Hero extends Tank
 {
  //子弹
  Shot s=null;
  public Hero(int x, int y)
  {
   super(x,y);
  }
  //坦克向上移动

  //坦克的开火的能力和动作
  public void shotEnemy()
  {
   switch(this.direct)
   {
    case 0:
     s=new Shot(x+9,y-1,0);
     break;
    case 1:
     s=new Shot(x+30,y+10,1);
     break;
    case 2:
     s=new Shot(x+9,y+30,2);
     break;
    case 3:
     s=new Shot(x-1,y+9,3);
     break;
   }

   Thread t=new Thread(s);
   t.start();

  }

  public void moveUp()
  {
   this.y-=speed;
  }
  public void moveRight()
  {
   this.x+=speed;
  }

  public void moveDown()
  {
   this.y+=speed;
  }
  public void moveLeft()
  {
   this.x-=speed;
  }
 }

 class Shot implements Runnable                                        //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 (InterruptedException 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;

    }

   }

  }
 }

Tank大战 version3.0

java练习---->坦克大战3.0

实现功能：
  1.有敌方tank与我方tank;

2.我方tank可以控制移动，可以发射炮弹；

3.写一个函数专门判断子弹是否击中敌人坦克；

4.判断tank是否活着；

（注：本版本中，Tank是不可以发射炮弹的······）

 package TankGame3;

 import java.awt.*;
 import java.awt.event.KeyEvent;
 import java.awt.event.KeyListener;
 import java.util.*;
 import javax.swing.*;
 import java.util.Vector;
 public class MyTankGame4  extends JFrame
 {
  MyPanel mp=null;
  public static void main(String[] args)
  {
   MyTankGame4 mytankgame1=new MyTankGame4();
  }

  public MyTankGame4()
  {
   mp=new MyPanel();
   //启动mp线程

   Thread t=new Thread(mp);
   t.start();

   this.add(mp);
   this.addKeyListener(mp);

   this.setSize(400,300);
   this.setVisible(true);
   this.setDefaultCloseOperation(EXIT_ON_CLOSE);
  }
 }
 class MyPanel extends JPanel implements KeyListener,Runnable
 {
  //定义我的坦克，成员变量
  Hero hero=null;

  //定义敌人的坦克组

  Vector<EnemyTank> ets=new Vector<EnemyTank>();
  int enSize=3;

  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);

    //从Vector ss中取出每一颗子弹，并画出
    for(int i=0;i<this.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<ets.size();i++)
    {
     EnemyTank et=ets.get(i);
     if(et.isLive)
     {
     this.drawTank(ets.get(i).getX(),ets.get(i).getY(), g,ets.get(i).getDirect(), 0);
     }
    }

  }

  //写一个函数专门判断子弹是否击中敌人坦克
  public void hitTank(Shot s,EnemyTank et)
  {
   //判断该坦克的方向
   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;
    }
   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;

    }

   }

  }

  //画出坦克函数（扩展）
  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.drawRect(hero.getX(), hero.getY(), 5, 30);
     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);
     //画出中间的圆
     g.fillOval(x+4, y+10,10,10);
     //画出线
     g.drawLine(x+9, y+15, x+9, 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+4, 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;
   } 

  }

  public MyPanel()
  {
   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);
    ets.add(et);
   }

  }

  //键按下处理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_S)
   {
    this.hero.setDirect(2);
    this.hero.moveDown();
   }

   else if (e.getKeyCode()==KeyEvent.VK_D)
   {
    this.hero.setDirect(1);
    this.hero.moveRight();

   }
   else if (e.getKeyCode()==KeyEvent.VK_A)
   {
    this.hero.setDirect(3);
    this.hero.moveLeft();
   }

   if (e.getKeyCode()==KeyEvent.VK_J)
   {
    this.hero.shotEnemy();
   }  

   //必须重新绘制Panel
   this.repaint();
  }
  public void keyReleased(KeyEvent e)
  {

  }
  public void keyTyped(KeyEvent e)
  {

  }
  public void run()
  {
  //每个一百毫秒去重画子弹
   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();

   }
  }

 }

 //package MyTankGame4;
 //import java.util.Vector;
 //import MyTankGame4.Shot;
 //import MyTankGame4.Tank;
 class Tank
 {

  //设置坦克的速度
  int speed=1;
  public int getSpeed()
  {
   return speed;
  }
  public void setSpeed(int speed)
  {
   this.speed = speed;
  }
  //表示坦克的横坐标
  int x=0;
  //坦克的纵坐标
  int y=0;
  int direct=0;
  int color;

  //坦克方向，0表示上，1表示右，2表示下，3表示左
  public int getColor() {
   return color;
  }
  public void setColor(int color) {
   this.color = color;
  }
  public int getDirect()
  {
   return direct;
  }

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

  public int getX()
  {
   return x;
  }
  public void setX(int x)
  {
   this.x = x;
  }
  public int getY()
  {
   return y;
  }
  public void setY(int y)
  {
   this.y = y;
  }

 }

 class EnemyTank extends Tank
 {
  boolean isLive=true;
  public EnemyTank(int x,int y)
  {
   super(x,y);

  }
 }

 //我的坦克
 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+9,y-1,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+9,y+30,2);
     ss.add(s);
     break;
    case 3:
     s=new Shot(x-1,y+9,3);     ss.add(s);
     ss.add(s);
     break;
   }

   Thread t=new Thread(s);
   t.start();

  }

  public void moveUp()
  {
   this.y-=speed;
  }
  public void moveRight()
  {
   this.x+=speed;
  }

  public void moveDown()
  {
   this.y+=speed;
  }
  public void moveLeft()
  {
   this.x-=speed;
  }
 }
 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 (InterruptedException 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;

    }

   }

  }
 }

Tank大战 version4.0

java练习---->坦克大战4.0

实现功能：
  1.有敌方tank与我方tank;

2.双方都可以控制移动，可以发射炮弹；

3.敌方坦克可以被击中消失

4.有爆炸效果；

5.可以计算生命值和炸弹生命；

 package TankGame4;
 //package MyTankGame4;
 import java.util.Vector;
 import java.awt.*;
 import java.awt.event.KeyEvent;
 import java.awt.event.KeyListener;
 import java.util.*;
 import javax.swing.*;
 public class MyTankGame4  extends JFrame
 {
  MyPanel mp=null;
  public static void main(String[] args)
  {
   MyTankGame4 mytankgame1=new MyTankGame4();
  }

  public MyTankGame4()
  {
   mp=new MyPanel();
   //启动mp线程

   Thread t=new Thread(mp);

   t.start();

   this.add(mp);
   this.addKeyListener(mp);

   this.setSize(400,300);
   this.setVisible(true);
   this.setDefaultCloseOperation(EXIT_ON_CLOSE);
  }
 }
 class MyPanel extends JPanel implements KeyListener,Runnable
 {
  //定义我的坦克，成员变量
  Hero hero=null;

  //定义敌人的坦克组

  Vector<EnemyTank> ets=new Vector<EnemyTank>();
  int enSize=5;

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

  public void run()
  {
  //每个一百毫秒去重画子弹
   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();
    //判断是否需要给坦克加入新的子弹
    for(int i=0;i<ets.size();i++)
    {
     EnemyTank et=ets.get(i);
     if(et.isLive)
     {
      if (et.ss.size()<5&&(int)(100*Math.random())>75)
      {
       //每辆坦克的子弹少于5发的话
       //添加
       Shot s=null;
       switch(et.direct)
       {
       case 0:
        s=new Shot(et.x+9,et.y-1,0);
        et.ss.add(s);
        break;
       case 1:
        s=new Shot(et.x+30,et.y+10,1);
        et.ss.add(s);
        break;
       case 2:
        s=new Shot(et.x+9,et.y+30,2);
        et.ss.add(s);
        break;
       case 3:
        s=new Shot(et.x-1,et.y+9,3);
        et.ss.add(s);
        break;
       }

       //启动子弹线程
       Thread t=new Thread(s);
       t.start();

      }

     }
    }

   }

  }

  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);

    //从Vector ss中取出每一颗子弹，并画出
    for(int i=0;i<this.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++)
    {
    // 取出炸弹
    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，我们就剔除
    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(ets.get(i).getX(),ets.get(i).getY(), g,ets.get(i).getDirect(), 0);
     //画出敌人的子弹

     for(int j=0;j<et.ss.size();j++)
     {
      //取出子弹
      Shot enemyShot=et.ss.get(j);
      if(enemyShot.isLive)
      {
       g.draw3DRect(enemyShot.x, enemyShot.y, 1, 1, false);
      }
      else
      {
      //如果敌人的坦克死亡就从Vector去掉
       et.ss.remove(enemyShot);

      }

     }
     }
    }

  }

  //写一个函数专门判断子弹是否击中敌人坦克
  public void hitTank(Shot s,EnemyTank et)
  {
   //判断该坦克的方向
   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;
     //创建一个炸弹，放入Vector
     Bomb b=new Bomb(et.x,et.y);
     //放入Vector
     bombs.add(b);
    }
   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);
     //放入Vector
     bombs.add(b);
    }

   }

  }

  //画出坦克函数（扩展）
  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.drawRect(hero.getX(), hero.getY(), 5, 30);
     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);
     //画出中间的圆
     g.fillOval(x+4, y+10,10,10);
     //画出线
     g.drawLine(x+9, y+15, x+9, 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+4, 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;
   } 

  }

  //定义三张图片,三张图片切换组成一颗炸弹
  Image image1=null;
  Image image2=null;
  Image image3=null;

  //构造函数
  public MyPanel()
  {
   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);
    //启动敌人的坦克

    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("/33.jpg"));
   image2=Toolkit.getDefaultToolkit().getImage(Panel.class.getResource("/22.jpg"));
   image3=Toolkit.getDefaultToolkit().getImage(Panel.class.getResource("/11.jpg"));

  }

 //键按下处理向左，向下，向上，向右
 public void keyPressed(KeyEvent e)
 {
  if(e.getKeyCode()==KeyEvent.VK_UP)
  {
   // 设置我的坦克的方向
   this.hero.setDirect(0);
   this.hero.moveUp();
  }

  else if (e.getKeyCode()==KeyEvent.VK_DOWN)
  {
   this.hero.setDirect(2);
   this.hero.moveDown();
  }

  else if (e.getKeyCode()==KeyEvent.VK_RIGHT)
  {
   this.hero.setDirect(1);
   this.hero.moveRight();

  }
  else if (e.getKeyCode()==KeyEvent.VK_LEFT)
  {
   this.hero.setDirect(3);
   this.hero.moveLeft();
  }

  if (e.getKeyCode()==KeyEvent.VK_J)
  {
   this.hero.shotEnemy();

  }
   //必须重新绘制Panel
   this.repaint();
  }
  public void keyReleased(KeyEvent e)
  {

  }
  public void keyTyped(KeyEvent e)
  {

  }

 }

 class Tank
 {

  //设置坦克的速度
  int speed=3;
  public int getSpeed()
  {
   return speed;
  }
  public void setSpeed(int speed)
  {
   this.speed = speed;
  }
  //表示坦克的横坐标
  int x=0;
  //坦克的纵坐标
  int y=0;
  int direct=0;
  int color;

  //坦克方向，0表示上，1表示右，2表示下，3表示左
  public int getColor() {
   return color;
  }
  public void setColor(int color) {
   this.color = color;
  }
  public int getDirect()
  {
   return direct;
  }

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

  public int getX()
  {
   return x;
  }
  public void setX(int x)
  {
   this.x = x;
  }
  public int getY()
  {
   return y;
  }
  public void setY(int y)
  {
   this.y = y;
  }

 }

 class EnemyTank extends Tank implements Runnable
 {
  boolean isLive=true;

  //定义一个向量，可以存放敌人的子弹

  Vector<Shot> ss=new Vector<Shot>();
  //敌人添加子弹应该在刚刚创建坦克和坦克子弹死亡之后

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

  }
  public void run() {
   while(true)
   {  //移动前进
    switch(this.direct)
    {
    case 0:
     for(int i=0;i<(int)(100*Math.random());i++)
     {
      try
      {
       Thread.sleep(50);
      }
      catch (Exception e)
      {
       e.printStackTrace();
      }
      if(y>=speed)
      {
       y-=speed;
      }
     }
     break;
    case 1:
     for(int i=0;i<(int)(100*Math.random());i++)
     {
      try
      {
       Thread.sleep(50);
      }
      catch (Exception e)
      {
       e.printStackTrace();
      }
      if(x<=400-(speed+30))
      {
       x+=speed;
      }
     }
     break;
    case 2:
     for(int i=0;i<(int)(100*Math.random());i++)
     {
      try
      {
       Thread.sleep(50);
      }
      catch (Exception e)
      {
       e.printStackTrace();
      }
      if(y<=300-(speed+30))
      {
       y+=speed;
      }
     }
     break;
    case 3:
     for(int i=0;i<(int)(100*Math.random());i++)
     {
      try
      {
       Thread.sleep(50);
      }
      catch (Exception e)
      {
       e.printStackTrace();
      }
      if(x>=speed)
      {
       x-=speed;
      }

     }
     break;

    }

    //让坦克随机产生一个新的方向
    if(Math.random()>0.50)
    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+9,y-1,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+9,y+30,2);
     ss.add(s);
     break;
    case 3:
     s=new Shot(x-1,y+9,3);     ss.add(s);
     ss.add(s);
     break;
   }

   Thread t=new Thread(s);
   t.start();

  }

  public void moveUp()
  {
   this.y-=speed;
  }
  public void moveRight()
  {
   this.x+=speed;
  }

  public void moveDown()
  {
   this.y+=speed;
  }
  public void moveLeft()
  {
   this.x-=speed;
  }
 }

 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 (InterruptedException 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 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;}

  }

 }

Tank大战 version5.0

java练习---->坦克大战5.0

实现功能：
  1.在原有基础啊上进行优化和功能完善；

2.增加闯关功能等；

3.完结版！！！！！

 package TankGame5;

 import java.awt.*;
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
 import java.awt.event.KeyEvent;
 import java.awt.event.KeyListener;
 import java.io.BufferedReader;
 import java.io.BufferedWriter;
 import java.io.File;
 import java.io.FileReader;
 import java.io.FileWriter;
 import java.io.IOException;
 import java.util.*;
 import java.io.*;
 import java.util.Vector;
 import javax.imageio.ImageIO;
 import javax.swing.*;

 public class MyTankGame5  extends JFrame implements ActionListener
 {
     //声明一个标志
  int  flag=0;
 // 声明一个运行面板
  MyPanel mp=null;
  //定义一个开始的面板
  MyStartPanel msp=null;

  //做出我需要的菜单
  JMenuBar jmb=null;
  //开始游戏
  JMenu jm1=null;
  JMenuItem jmi1=null;
     //退出系统
  JMenuItem jmi2=null;
  JMenuItem jmi3=null;
  JMenuItem jmi4=null;

  public static void main(String[] args)
  {
   MyTankGame5 mytankgame1=new MyTankGame5();
   mytankgame1.setLocationRelativeTo(null);//将JFrame设置在中间
 //  mytankgame1.setLocation(210,140);//设置JFrame的位置
  }

  public MyTankGame5() //构造
  {//初始化菜单栏
   jmb=new JMenuBar();
   jm1=new JMenu("游戏(G)");

   //设置快捷方式
   jm1.setMnemonic('G');
   jmi1=new JMenuItem("开始新游戏(N)");
   jmi2=new JMenuItem("退出游戏(E)");
   jmi3=new JMenuItem("存盘退出(C)");
   jmi4=new JMenuItem("继续上次游戏(L)");

   jmi1.setMnemonic('N');
   jmi2.setMnemonic('E');
   jmi3.setMnemonic('C');
   jmi4.setMnemonic('L');

   //对jmi1响应，注册监听，标记消息源
   jmi1.addActionListener(this);
   jmi1.setActionCommand("new game");

   jmi2.addActionListener(this);
   jmi2.setActionCommand("exit");

   jmi3.addActionListener(this);
   jmi3.setActionCommand("save and exit");

   jmi4.addActionListener(this);
   jmi4.setActionCommand("continue game");

   jm1.add(jmi1);
   jm1.add(jmi2);
   jm1.add(jmi3);
   jm1.add(jmi4);
   jmb.add(jm1);

 //  声明初始化面板

   msp=new MyStartPanel();

   Thread t=new Thread(msp);
   t.start();
 //  初始化窗口，构造函数的重点
   this.setJMenuBar(jmb);//千万注意啊！！！！

   this.add(msp);
   this.setSize(400,300);
   this.setVisible(true);
   this.setDefaultCloseOperation(EXIT_ON_CLOSE);
  }
  public void actionPerformed(ActionEvent e)
  {
   //对用户不同的点击做出不同的处理
 //     首先得到command字符串，判断消息源
   if(e.getActionCommand().equals("new game"))
   {
    this.setSize(600,500);
    mp=new MyPanel(flag);
    //启动mp线程

    Thread t1=new Thread(mp);

    t1.start();
    //先删除旧的面板
    this.remove(msp);

    this.add(mp);
    //注册监听
    this.addKeyListener(mp);
    //显示
    this.setVisible(true);
   }
   else if(e.getActionCommand().equals("exit"))
   {
    //用户退出
    //保存击毁敌人数量
    Recorder.keepRecording();
    System.exit(0);
   }

   else if(e.getActionCommand().equals("save and exit"))
   {
    Recorder.keepRecAndEnemyTank(mp.ets);
    if(this.mp.hero.isLive==true)
    {
     Recorder.keepRecAndMyTank(this.mp.hero);

    }
    System.exit(0);
   }
   else if(e.getActionCommand().equals("continue game"))
   {
    this.setSize(600,500);
    flag=1;
    mp=new MyPanel(flag);
    //启动mp线程

    Thread t1=new Thread(mp);

    t1.start();
    //先删除旧的面板
    this.remove(msp);

    this.add(mp);
    //注册监听
    this.addKeyListener(mp);
    //显示
    this.setVisible(true);
   }
  }
 }

 //开始面板起一个提示的作用
 class MyStartPanel extends JPanel implements Runnable
 {
  int times=0;
  public void paint(Graphics g)
  {
   super.paint(g);
   g.fillRect(0, 0, 400, 300);
   //提示信息
   if(times%2==0)
   {
    g.setColor(Color.yellow);
    //开关信息的字体
    try{
    Font myFont=new Font("华文新魏",Font.BOLD,30);
    g.setFont(myFont);
    }   catch(Exception e){e.printStackTrace();}

    g.drawString("stage:1", 150, 150);
   }
  }
  public void run()
  {
   while(true)
   {
    try {
     Thread.sleep(500);
    } catch (Exception e) {
     // TODO Auto-generated catch block
     e.printStackTrace();
    }
    this.repaint();
    times++;
    if(times==1000) times=0;
   }
  }

 }

 class MyPanel extends JPanel implements KeyListener,Runnable
 {
  //定义我的坦克，成员变量
  Hero hero=null;

  //判断是续上局还是新的游戏
  String flag="newGame";

  //定义敌人的坦克组

  Vector<EnemyTank> ets=new Vector<EnemyTank>();
 // 全局变量，声明，敌人坦克数量
  static int enSize=5;
  public static int getEnSize() {
   return enSize;
  }
  //定义炸弹集合
  Vector<Bomb> bombs=new Vector<Bomb>();
 // paint 方法被面板适时自动调用
  public void paint (Graphics g)
  {
    super.paint(g);
    g.fillRect(0,0,400,300);

    //画出提示信息
    this.showInfo(g);

    //画出自己的坦克
    if(hero.isLive==true)
    {
    this.drawTank(hero.getX(), hero.getY(), g, this.hero.direct, 1);
    }
    //从Vector ss中取出每一颗子弹，并画出，如果有子弹
    for(int i=0;i<this.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++)
    {
    // 取出炸弹
    Bomb b=bombs.get(i);

    if(b.life>6)
    {
     g.drawOval(b.x, b.y, 30, 30);
 //       g.drawImage(image1, b.x, b.y, 30,30,this);
    }
    else if(b.life>3)
    {
        g.drawOval(b.x, b.y, 20, 20);
 //    g.drawImage(image2, b.x, b.y, 30,30,this);

    }
    else
    {
        g.drawOval(b.x, b.y, 10, 10);
 //    g.drawImage(image3, b.x, b.y, 30,30,this);
    }
    //让b的生命值减小
    b.lifeDown();
    //如果炸弹的生命值为0，我们就剔除
    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(ets.get(i).getX(),ets.get(i).getY(), g,ets.get(i).getDirect(), 0);
     //画出敌人的子弹

     for(int j=0;j<et.ss.size();j++)
     {
      //取出子弹
      Shot enemyShot=et.ss.get(j);
      if(enemyShot.isLive)
      {
       g.draw3DRect(enemyShot.x, enemyShot.y, 1, 1, false);
      }
      else
      {
      //如果敌人的坦克死亡就从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);
     if(hero.isLive)//&&Recorder.getMyLife()>=1
     {
      this.hitTank(enemyShot, hero);
      //Recorder.setMyLife(Recorder.getMyLife()-1);
     }

    }

   }

  }

  //判断我的子弹是否击中敌人的坦克
  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);

      }
     }

    }
   }

  }

  //写一个函数专门判断子弹是否击中敌人坦克
  public void hitTank(Shot s,Tank et)
  {
   //判断该坦克的方向
   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;
     //减少敌人数量
     if (et.getClass()==EnemyTank.class)//反射机制
     {
      Recorder.reduceEnNum();
      //增加我的记录
      Recorder.addEnNumRec();
     }

     if (et.getClass()==Hero.class)//反射机制
     {

     }
     //创建一个炸弹，放入Vector
     Bomb b=new Bomb(et.x,et.y);
     //放入Vector
     bombs.add(b);
    }
   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;
     //减少敌人数量
     if (et.getClass()==EnemyTank.class)//反射机制
     {
      Recorder.reduceEnNum();
      //增加我的记录
      Recorder.addEnNumRec();
     }

     if (et.getClass()==Hero.class)//反射机制
     {
      Recorder.setMyLife(Recorder.getMyLife() - 1);
     }
     //创建一个炸弹，放入Vector
     Bomb b=new Bomb(et.x,et.y);
     //放入Vector
     bombs.add(b);
    }

   }

  }

  //画出坦克函数（扩展）
  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.drawRect(hero.getX(), hero.getY(), 5, 30);
     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);
     //画出中间的圆
     g.fillOval(x+4, y+10,10,10);
     //画出线
     g.drawLine(x+9, y+15, x+9, 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+4, 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;
   } 

  }

  public void run()
  {
  //每个一百毫秒去重画子弹
   while(true)
   {
    try {
     Thread.sleep(100);
    } catch (InterruptedException e) {
     e.printStackTrace();
    }

    this.hitEnemyTank();

    //函数，判断敌人的子弹是否击中我了
    this.hitMe();

    this.repaint();
    //判断是否需要给坦克加入新的子弹
    for(int i=0;i<ets.size();i++)
    {
     EnemyTank et=ets.get(i);
     if(et.isLive)
     {
      if (et.ss.size()<3)
      {
       //没有子弹了
       //添加
       Shot s=null;
       switch(et.direct)
       {
       case 0:
        s=new Shot(et.x+9,et.y-1,0);
        et.ss.add(s);
        break;
       case 1:
        s=new Shot(et.x+30,et.y+10,1);
        et.ss.add(s);
        break;
       case 2:
        s=new Shot(et.x+9,et.y+30,2);
        et.ss.add(s);
        break;
       case 3:
        s=new Shot(et.x-1,et.y+9,3);
        et.ss.add(s);
        break;
       }

       //启动子弹线程
       Thread t=new Thread(s);
       t.start();
      }
     }
    }
   }
  }
  //定义三张图片,三张图片切换组成一颗炸弹
  Image image1=null;
  Image image2=null;
  Image image3=null;
  int flagOfContinue;
  //构造函数
  public MyPanel(int flag)
  {  

   this.flagOfContinue=flag;
   //恢复记录
   Recorder.getRecording();

   if(this.flagOfContinue==0)
   {
    //如果不是继续上次就直接建一个
    hero=new Hero(100,100);
    //初始化敌人的坦克
    for(int i=0;i<enSize;i++)
    {
     //创建敌人的坦克对象
     EnemyTank et=new EnemyTank((i+1)*60,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);
    }
   }
   else if(this.flagOfContinue==1)
   {
    //如果是继续上次的就读取坐标
    Vector<Node> nodes1=new Vector<Node>();
    nodes1=Recorder.getNodes();

     //初始化敌人的坦克
     for(int i=0;i<nodes1.size();i++)
     {
      if(nodes1.get(i).type==0)
      {
       //创建敌人的坦克对象
       EnemyTank et=new EnemyTank(nodes1.get(i).x,nodes1.get(i).y);
       et.setColor(0);
       et.setDirect(nodes1.get(i).direct);
       //将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);
      }
      else if(nodes1.get(i).type==1)
      {
       //如果保存有我上次的坦克的信息，就按照信息保存
       hero=new Hero(nodes1.get(i).x,nodes1.get(i).y);
       hero.setDirect(nodes1.get(i).direct);
      }
     }

   }

 //  image1=Toolkit.getDefaultToolkit().getImage(Panel.class.getResource("/33.jpg"));//文件应该放在src文件夹里面
 //  image2=Toolkit.getDefaultToolkit().getImage(Panel.class.getResource("/22.jpg"));
 //  image3=Toolkit.getDefaultToolkit().getImage(Panel.class.getResource("/11.jpg"));
   //关于图像我们使用好一点的方法，引入java.io.File;和java.io.IOException;
   try
   {
    image1=ImageIO.read(new File("33.jpg"));//此时文件应该放在工程的根目录里面
    image2=ImageIO.read(new File("22.jpg"));
    image3=ImageIO.read(new File("11.jpg"));
   }
   catch (IOException e)
   {
    e.printStackTrace();
   }

  }
  //画出提示信息
  public void showInfo(Graphics g)
  {
    //画出提示信息的坦克 ，该坦克不参加战斗
    this.drawTank(80,330,g,0,0);
    g.setColor(Color.black);
    g.drawString(Recorder.getEnNum()+"",110,350);

    this.drawTank(150,330,g,0,1);
    g.setColor(Color.black);
    g.drawString(Recorder.getMyLife()+"",180,350);
    //画出玩家的总成绩

    g.setColor(Color.black);
 try{
    Font f=new Font("宋体",Font.BOLD,20);
    g.setFont(f);
 }catch(Exception e){    e.printStackTrace();}
    g.drawString("您的总成绩：",420,40);

    this.drawTank(420, 60, g, 0, 0);

    g.setColor(Color.BLACK);
    g.drawString(Recorder.getAllEnemy()+"",460,80);

  }

  //键按下处理a表示左，s表示向下，w表示向上，d表示向右
  public void keyPressed(KeyEvent e)
  {
   if(hero.isLive)
   {
    if(e.getKeyCode()==KeyEvent.VK_UP&&hero.getY()>0)
    {
     // 设置我的坦克的方向
     this.hero.setDirect(0);
     this.hero.moveUp();
    }

    else if (e.getKeyCode()==KeyEvent.VK_DOWN&&hero.getY()<270)
    {
     this.hero.setDirect(2);
     this.hero.moveDown();
    }

    else if (e.getKeyCode()==KeyEvent.VK_RIGHT&&hero.getX()<370)
    {
     this.hero.setDirect(1);
     this.hero.moveRight();

    }
    else if (e.getKeyCode()==KeyEvent.VK_LEFT&&hero.getX()>0)
    {
     this.hero.setDirect(3);
     this.hero.moveLeft();
    }

    if (e.getKeyCode()==KeyEvent.VK_SPACE)
    {
     this.hero.shotEnemy();
    }  

    //必须重新绘制Panel
    this.repaint();
   }
  }
  public void keyReleased(KeyEvent e)
  {

  }
  public void keyTyped(KeyEvent e)
  {

  }

 }

 //----------------------------------------------------

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

 }

 //记录类
 class Recorder
 {
  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;
  }
  //记录每关多少敌人
  private static int enNum=MyPanel.getEnSize();
  //设置我有多少可以用的人
  public static int myLife=3;
  //记录总共消灭了多少敌人
  private static  int  allEnNum=0;
  //从文件中恢复记录点
  static Vector<Node> nodes=new Vector<Node>();
  private static FileWriter fw=null;
  private static BufferedWriter bw=null;
  private static FileReader fr=null;
  private static BufferedReader br=null;

  public static Vector<Node> getNodes()
  {
   try {
    fr=new FileReader("d:\\myRecording.txt");
    br=new BufferedReader(fr);
    String n="";

    n=br.readLine();//读第一行
    allEnNum=Integer.parseInt(n);
    while((n=br.readLine())!=null)
    {
     String []xyz=n.split(" ");//按照空格返回数组，新技能
     Node node=new Node(Integer.parseInt(xyz[0]),Integer.parseInt(xyz[1]),Integer.parseInt(xyz[2]),Integer.parseInt(xyz[3]));
     nodes.add(node);
    }
   }

   catch (Exception e)
   {
    e.printStackTrace();
   }
   finally
   {
    try {
     br.close();
     fr.close();
    } catch (Exception e) {
     e.printStackTrace();
    }
   }
   return nodes;
  }
  public static void keepRecAndEnemyTank(Vector<EnemyTank> ets)
  {
   try
   {
    //创建
    fw=new FileWriter("d:\\myRecording.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 record=et.x+" "+et.y+" "+et.direct+" "+0;
      //写入
      bw.write(record+"\r\n");
     }
    }

   }
   catch (Exception e)
   {
    e.printStackTrace();
   }
   finally
   {
    //关闭流
    try {
     //谁先开谁后关
     bw.close();
     fw.close();
    } catch (Exception e2) {
    }
   }

  }

  public static void keepRecAndMyTank(Hero hero)
  {
   try
   {
    //创建
    fw=new FileWriter("d:\\myRecording.txt",true);//追加
    bw=new BufferedWriter(fw);

    //保存当前我的坐标和方向
    String record=hero.x+" "+hero.y+" "+hero.direct+" "+1;
    //写入
    bw.write(record+"\r\n");    

   }

   catch (Exception e)
   {
    e.printStackTrace();
   }
   finally
   {
     //关闭流
    try
    {
     //谁先开谁后关
     bw.close();
     fw.close();
    }
    catch (Exception e2)
    {
     e2.printStackTrace();
    }
   }

  }

  //从文件中读取记录
  public static void getRecording()
  {
   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 e2) {
    }
   }
  }

  public static int getAllEnemy() {
   return allEnNum;
  }
  public static void reduceEnNum()
  {
   enNum--;
  }

  //消灭敌人
  public static void addEnNumRec()
  {
   allEnNum++;
  }

 }

 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 Tank
 {

  //设置坦克的速度
  int speed=3;
  public int getSpeed()
  {
   return speed;
  }
  public void setSpeed(int speed)
  {
   this.speed = speed;
  }
  //表示坦克的横坐标
  int x=0;
  //坦克的纵坐标
  int y=0;
  int direct=0;
  int color;
  boolean isLive=true;

  //坦克方向，0表示上，1表示右，2表示下，3表示左
  public int getColor() {
   return color;
  }
  public void setColor(int color) {
   this.color = color;
  }
  public int getDirect()
  {
   return direct;
  }

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

  public int getX()
  {
   return x;
  }
  public void setX(int x)
  {
   this.x = x;
  }
  public int getY()
  {
   return y;
  }
  public void setY(int y)
  {
   this.y = y;
  }

 }

 class EnemyTank extends Tank implements Runnable
 {
  //定义一个向量，可以访问到MyPanel上所有敌人的坦克
  Vector<EnemyTank> ets=new Vector<EnemyTank>();

  //定义一个向量，可以存放敌人的子弹

  Vector<Shot> ss=new Vector<Shot>();
  //敌人添加子弹应该在刚刚创建坦克和坦克子弹死亡之后
  public EnemyTank(int x,int y)
  {
   super(x,y);
  }

  //得到MyPanel的敌人坦克向量
  public void setEts(Vector<EnemyTank> vv)
  {
   this.ets=vv;

  }

  //判断是否碰到了别人的坦克
  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<=et.x+20&&this.y>=et.y&&this.y<=et.y+30)
       {
        return true;
       }

      }

      if(et.direct==1||et.direct==3)
      {
       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+30)
       {
        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==1||et.direct==3)
      {
       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;
       }
      }
     }

    }

   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<=et.x+20&&this.y+30>=et.y&&this.y+30<=et.y+30)
       {
        return true;
       }

      }

      if(et.direct==1||et.direct==3)
      {
       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;
       }
       if(this.x+20>=et.x && this.x+20<=et.x+30&&this.y+30>=et.y&&this.y+30<=et.y+30)
       {
        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<=et.y+30)
       {
        return true;
       }
       if(this.x>=et.x&&this.x<=et.x+20&&this.y>=et.y&&this.y<=et.y+30)
       {
        return true;
       }

      }

      if(et.direct==1||et.direct==3)
      {
       if(this.x>=et.x&&this.x<=et.x+30&&this.y+20>=et.y&&this.y+20<=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;
       }
      }
     }

    }
   }

   return b;
  }

  public void run() {
   while(true)
   {
    switch(this.direct)
    {
    case 0:
     for(int i=0;i<(int)(100*Math.random());i++)
     {
      try
      {
       Thread.sleep(50);
      }
      catch (Exception e)
      {
       e.printStackTrace();
      }
      if(y>=speed && !this.isTouchOtherEnemy())
      {
       y-=speed;
      }
     }
     break;
    case 1:
     for(int i=0;i<(int)(100*Math.random());i++)
     {
      try
      {
       Thread.sleep(50);
      }
      catch (Exception e)
      {
       e.printStackTrace();
      }
      if(x<=(400-(speed+30))&& !this.isTouchOtherEnemy())
      {
       x+=speed;
      }
     }
     break;
    case 2:
     for(int i=0;i<(int)(100*Math.random());i++)
     {
      try
      {
       Thread.sleep(50);
      }
      catch (Exception e)
      {
       e.printStackTrace();
      }
      if(y<=(300-(speed+30))&& !this.isTouchOtherEnemy())
      {
       y+=speed;
      }
     }
     break;
    case 3:
     for(int i=0;i<(int)(100*Math.random());i++)
     {
      try
      {
       Thread.sleep(50);
      }
      catch (Exception e)
      {
       e.printStackTrace();
      }
      if(x>=speed && !this.isTouchOtherEnemy())
      {
       x-=speed;
      }

     }
     break;

    }

    //让坦克随机产生一个新的方向
    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+9,y-1,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+9,y+30,2);
     ss.add(s);
     break;
    case 3:
     s=new Shot(x-1,y+9,3);     ss.add(s);
     ss.add(s);
     break;
   }

   Thread t=new Thread(s);
   t.start();

  }

  public void moveUp()
  {
   this.y-=speed;
  }
  public void moveRight()
  {
   this.x+=speed;
  }

  public void moveDown()
  {
   this.y+=speed;
  }
  public void moveLeft()
  {
   this.x-=speed;
  }
 }

 class Shot implements Runnable
 {
  int x;
  int y;
  int direct;
  int speed=2;
  //是否活着

  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 (InterruptedException 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;

    }

   }

  }
 }

注：如果大家很多java基础内容不是很清楚，可以观看韩顺平的java学习视频，跟着教程做程序，效果很明显！(●ˇ∀ˇ●)