代碼：

主類：

創建游戲窗口對象，調用啟動方法

public class TankWar {
    public static void main(String[] args) {
        //創建游戲窗口對象,調用運行方法
        new GamePanel().lunch();
    }
}

游戲對象類：

所有游戲對象的超類

 1 import java.awt.*;
 2 
 3 public abstract class GameObject {
 4     //圖像
 5     protected Image image;
 6     //坐標
 7     protected int x;
 8     protected int y;
 9     //定義四個bool方向變量，當方向變量為true時進行移動
10     protected boolean left = false;
11     protected boolean right = false;
12     protected boolean down = false;
13     protected boolean up = false;
14     //設置Jframe容器
15     protected GamePanel gamePanel;
16     //構造方法
17     public GameObject(String image, int x, int y, GamePanel gamePanel) {
18         this.image = Toolkit.getDefaultToolkit().getImage(image);
19         this.x = x;
20         this.y = y;
21         this.gamePanel = gamePanel;
22     }
23     //繪制自己
24     public abstract void paintSelf(Graphics g);
25     //返回矩形進行碰撞檢測
26     public abstract Rectangle gerRec();
27 }

坦克類：

子類有玩家和地方坦克類

  1 import java.awt.*;
  2 import java.awt.event.KeyEvent;
  3 import java.util.ArrayList;
  4 import java.util.Iterator;
  5 import java.util.Random;
  6 //坦克類
  7 public abstract class Tank extends GameObject {
  8     //定義移動次數
  9     public int movetime= 0;
 10     //定義坦克長寬
 11     public int width = 40;
 12     public int height = 40;
 13     //移動速度
 14     protected int speed = 5;
 15     // 定義初始方向
 16     public Direction direction ;
 17     // 定義子彈發射冷卻變量
 18     boolean attackCoolDown = true;
 19     //定義四個方向圖片
 20     private String upImg;
 21     private String downImg;
 22     private String leftImg;
 23     private String rightImg;
 24 
 25 
 26     public Tank(String image, int x, int y, GamePanel gamePanel, String upImg, String downImg, String leftImg, String rightImg) {
 27         super(image, x, y, gamePanel);
 28         this.upImg = upImg;
 29         this.downImg = downImg;
 30         this.leftImg = leftImg;
 31         this.rightImg = rightImg;
 32     }
 33 
 34     //定義移動方法
 35     //向左移動
 36     public void leftward() {
 37         //判斷的時坦克下一步移動的位置是否發生碰撞，如果沒有碰撞到牆或者邊界或者物體，則進行移動，否則只設置圖片和方向;
 38         if (hitWall(x-speed,y)&&hitTank(x-speed,y))
 39         x -= speed;
 40         setImg(leftImg);
 41         direction = Direction.LEFT;
 42     }
 43 
 44     public void rightward() {
 45         if (hitWall(x+speed,y)&&hitTank(x+speed,y))
 46         x += speed;
 47         setImg(rightImg);
 48         direction = Direction.RIGHT;
 49     }
 50 
 51     public void upward() {
 52         if (hitWall(x,y-speed)&&hitTank(x,y-speed))
 53         y -= speed;
 54         setImg(upImg);
 55         direction = Direction.UP;
 56     }
 57 
 58     public void downward() {
 59         if (hitWall(x,y+speed)&&hitTank(x,y+speed))
 60         y += speed;
 61         setImg(downImg);
 62         //枚舉
 63         direction = Direction.DOWN;
 64     }
 65 
 66     //設置坦克圖片
 67     private void setImg(String Img) {
 68         this.image = Toolkit.getDefaultToolkit().getImage(Img);
 69     }
 70 
 71     //攻擊方法，在鍵盤監聽事件中調用攻擊方法
 72     public void attack() {
 73         //如果攻擊冷卻為true則攻擊
 74         if (attackCoolDown) {
 75             //創建子彈對象
 76             //獲取坦克頭部坐標
 77             Point p = getHeadPoint();
 78             Bullet bullet = new Bullet("images/bullet.png", p.x, p.y, this.gamePanel, direction);
 79             //將子彈添加到子彈集合中
 80             gamePanel.bullets.add(bullet);
 81             //啟動線程，每隔一秒更改攻擊冷卻變量，實現攻擊間隔為一秒
 82             new MyThread().start();
 83         }
 84 
 85     }
 86     //檢測是否碰撞到坦克，若碰撞則返回false，否則返回true;
 87     public boolean hitTank(int a,int d)
 88     {
 89         Rectangle newrec = new Rectangle(a, d, width, height);
 90         //獲得地方坦克集合，遍歷
 91         ArrayList<Bot> bots = gamePanel.bots;
 92         for (Bot b : bots)
 93         {
 94             if (b==this)
 95                 break;
 96             //利用intersects方法檢測是否發生碰撞
 97             if (b.gerRec().intersects(newrec))
 98             {
 99                 //即將發生碰撞將該坦克移動次數設置為39，進行下一次移動則改變方向
100                 this.movetime = 39;
101                 return false;
102             }
103         }
104         return true;
105     }
106     //檢測是否與圍牆、邊界、玩家和基地碰撞
107     public boolean hitWall(int a,int b)
108     {
109         Rectangle newrec = new Rectangle(a, b, width, height);
110         //獲取圍牆集合
111         ArrayList<Wall> walls = gamePanel.walls;
112         for (Wall w : walls)
113         {
114             if (w.gerRec().intersects(newrec))
115             {
116                 this.movetime = 39;
117                 return false;
118             }
119         }
120         //檢測是否碰撞邊界
121         if (a<=5||a+width>=780||b<=25||b+height>=600)
122             return false;
123         //檢測是否碰撞基地
124         if (newrec.intersects(gamePanel.base.gerRec()))
125             return false;
126         //檢測是否碰撞玩家
127         if (this!=gamePanel.player)
128         {
129             if (this.gerRec().intersects(gamePanel.player.gerRec()))
130                 return false;
131         }
132         return true;
133     }
134     //得到坦克炮口坐標
135     public Point getHeadPoint() {
136         switch (direction) {
137             case UP:
138                 return new Point(x + width / 2, y);
139             case DOWN:
140                 return new Point(x + width / 2, y + height);
141             case LEFT:
142                 return new Point(x, y + height / 2);
143             case RIGHT:
144                 return new Point(x + width, y + height / 2);
145         }
146         return null;
147     }
148 
149 
150     @Override
151     public abstract void paintSelf(Graphics g);
152 
153     @Override
154     public abstract Rectangle gerRec();
155 
156     //自定義線程
157     class MyThread extends Thread {
158         @Override
159         public void run() {
160             attackCoolDown = false;
161             try {
162                 MyThread.sleep(1000);
163             } catch (InterruptedException e) {
164                 e.printStackTrace();
165             }
166             attackCoolDown = true;
167             this.stop();
168         }
169     }
170 }

玩家類

 1 import java.awt.*;
 2 import java.awt.event.KeyEvent;
 3 import java.util.ArrayList;
 4 import java.util.Iterator;
 5 
 6 public class Player extends Tank{
 7     public Player(String image, int x, int y, GamePanel gamePanel, String upImg, String downImg, String leftImg, String rightImg) {
 8         super(image, x, y, gamePanel, upImg, downImg, leftImg, rightImg);
 9     }
10     //添加鍵盤監聽事件，按下則方向鍵則將坦克該方向設置為true
11     public void keyPressed(KeyEvent k) {
12 
13         switch (k.getKeyCode()) {
14             case KeyEvent.VK_UP:
15                 up = true;
16                 break;
17             case KeyEvent.VK_DOWN:
18                 down = true;
19                 break;
20             case KeyEvent.VK_LEFT:
21                 left = true;
22                 break;
23             case KeyEvent.VK_RIGHT:
24                 right = true;
25                 break;
26                 //按下空格調用攻擊鍵
27             case KeyEvent.VK_SPACE:
28                 attack();
29         }
30     }
31     //按鍵松開時，將方向變量設為false，實現鍵盤按住不放時坦克可以持續移動
32     public void keyReleased(KeyEvent k) {
33         switch (k.getKeyCode()) {
34             case KeyEvent.VK_UP:
35                 up = false;
36                 break;
37             case KeyEvent.VK_DOWN:
38                 down = false;
39                 break;
40             case KeyEvent.VK_LEFT:
41                 left = false;
42                 break;
43             case KeyEvent.VK_RIGHT:
44                 right = false;
45                 break;
46         }
47     }
48     //方向變量為true則調用對應的移動方法
49     private void move() {
50         if(left)
51             leftward();
52         else if(right)
53             rightward();
54         else if(up)
55             upward();
56         else if(down)
57             downward();
58     }
59     //繪制自己，同時調用移動方法
60     @Override
61     public void paintSelf(Graphics g) {
62     g.drawImage(image,x,y,null);
63     move();
64     }
65     @Override
66     public Rectangle gerRec() {
67         return new Rectangle(x,y,width,height);
68     }
69 }

敵方坦克類

 1 import java.awt.*;
 2 import java.awt.event.KeyEvent;
 3 import java.util.ArrayList;
 4 import java.util.Random;
 5 //敵方坦克類
 6 public class Bot extends Tank{
 7 
 8 
 9     public Bot(String image, int x, int y, GamePanel gamePanel, String upImg, String downImg, String leftImg, String rightImg) {
10         super(image, x, y, gamePanel, upImg, downImg, leftImg, rightImg);
11         direction = getRanDirect();
12     }
13 
14     //自定義隨機移動方法，當移動次數為40時隨機改變方向
15     public void go()
16     {
17         //調用攻擊方法
18         attack();
19        if (movetime == 40)
20        {
21            direction = getRanDirect();
22            movetime = 0;
23        }
24        else
25            movetime++;
26         switch (direction)
27         {
28             case DOWN:downward();break;
29             case LEFT:leftward();break;
30             case RIGHT:rightward();break;
31             case UP:upward();break;
32         }
33     }
34     //隨機獲取移動方向
35     public Direction getRanDirect()
36     {
37         Random random = new Random();
38         int i = random.nextInt(4);
39         switch (i)
40         {
41             case 0: return Direction.UP;
42             case 1: return Direction.DOWN;
43             case 2: return Direction.LEFT;
44             case 3: return Direction.RIGHT;
45         }
46         return null;
47     }
48 
49     //重寫攻擊方法
50     @Override
51     public void attack()
52     {
53         if(attackCoolDown) {
54             Random random = new Random();
55             int i = random.nextInt(50);
56             if (i == 1) {
57                 Point p = getHeadPoint();
58                 EnemyBullet bullet = new EnemyBullet("images/bullet.png", p.x, p.y, this.gamePanel, direction);
59                 this.gamePanel.bullets.add(bullet);
60                 new MyThread().start();
61             }
62         }
63     }
64     //重寫繪制方法，使用自定義移動方法
65     @Override
66     public void paintSelf(Graphics g) {
67         g.drawImage(image,x,y,null);
68         go();
69     }
70 
71     @Override
72     public Rectangle gerRec() {
73         return new Rectangle(x,y,width,height);
74     }
75 }

子彈類

  1 import java.awt.*;
  2 import java.util.ArrayList;
  3 import java.util.Iterator;
  4 import java.util.ListIterator;
  5 
  6 public class Bullet extends GameObject{
  7     //尺寸
  8     int width = 10;
  9     int height = 10;
 10     //速度
 11     int speed = 20;
 12     //方向
 13     Direction direction;
 14     //定義移動方法
 15     public void leftword()
 16     {
 17         x -= speed;
 18     }
 19     public void rightword()
 20     {
 21         x += speed;
 22     }
 23     public void upword()
 24     {
 25         y -= speed;
 26     }
 27     public void downword()
 28     {
 29         y += speed;
 30     }
 31 
 32     public Bullet(String image, int x, int y, GamePanel gamePanel, Direction direction) {
 33         super(image, x, y, gamePanel);
 34         this.direction = direction;
 35     }
 36 
 37     public void go()
 38     {
 39             switch (direction)
 40             {
 41                 case UP:
 42                     upword();break;
 43                 case DOWN:
 44                     downword();break;
 45                 case LEFT:
 46                     leftword();break;
 47                 case RIGHT:
 48                     rightword();break;
 49             }
 50         //檢測是否到達邊界
 51         hitboder();
 52     }
 53     //檢測是否碰撞邊界
 54     public void hitboder()
 55     {
 56         //到達邊界將該子彈添加進清除子彈集合
 57         if (x<=15||y<=45||x>=770||y>=580)
 58             gamePanel.removelist.add(this);
 59     }
 60     //碰撞圍牆，子彈和圍牆消失
 61     public void hitWall() {
 62         //獲取牆集合
 63         ArrayList<Wall> walls = this.gamePanel.walls;
 64         //獲取圍牆集合迭代器
 65         ListIterator<Wall> wal = walls.listIterator();
 66         while (wal.hasNext())
 67         {
 68             Wall b = wal.next();
 69             if(this.gerRec().intersects(b.gerRec()))
 70             {
 71                 //因為在增強for循環中，刪除元素會造成異常，所以采用迭代器的刪除方法
 72                 wal.remove();
 73                 //將子彈添加入清除子彈集合
 74                 this.gamePanel.removelist.add(this);
 75             }
 76         }
 77         //如果子彈擊中基地，設置為狀態2游戲失敗
 78         if (this.gerRec().intersects(gamePanel.base.gerRec()))
 79         {
 80             gamePanel.state = 2;
 81         }
 82     }
 83     //同碰撞圍牆檢測，檢測是否碰撞地方坦克
 84     public void hitBot() {
 85         ArrayList<Bot> bots = this.gamePanel.bots;
 86         ListIterator<Bot> bot = bots.listIterator();
 87         while (bot.hasNext())
 88         {
 89             Bot b = bot.next();
 90             if(this.gerRec().intersects(b.gerRec()))
 91             {
 92                 bot.remove();
 93                 this.gamePanel.removelist.add(this);
 94             }
 95         }
 96     }
 97     @Override
 98     public void paintSelf(Graphics g) {
 99         g.drawImage(image,x,y,null);
100         this.go();
101         hitBot();
102         hitWall();
103     }
104 
105     @Override
106     public Rectangle gerRec() {
107         return new Rectangle(x,y,width,height);
108     }
109 }

敵方子彈類：

//敵方子彈類，繼承子彈類
public class EnemyBullet extends Bullet{
    public EnemyBullet(String image, int x, int y, GamePanel gamePanel, Direction direction) {
        super(image, x, y, gamePanel, direction);
    }
    //重寫碰撞坦克方法，如果碰撞玩家則游戲結束
    @Override
    public void hitBot()
    {
        if(this.gerRec().intersects(this.gamePanel.player.gerRec()))
        {
            this.gamePanel.state = 2;
        }
    }
}

圍牆類：

 1 import java.awt.*;
 2 //定義圍牆類
 3 public class Wall extends GameObject{
 4     //定義長度
 5     int length = 35;
 6 
 7     public Wall(String image, int x, int y, GamePanel gamePanel) {
 8         super(image, x, y, gamePanel);
 9     }
10 
11     @Override
12     public void paintSelf(Graphics g) {
13         g.drawImage(image,x,y,null);
14     }
15 
16     @Override
17     public Rectangle gerRec() {
18         return new Rectangle(x,y,length,length);
19     }
20 }

基地類

 1 import java.awt.*;
 2 //基地類
 3 public class Base extends GameObject{
 4     //設置長度
 5     int length = 35;
 6 
 7     public Base(String image, int x, int y, GamePanel gamePanel) {
 8         super(image, x, y, gamePanel);
 9     }
10 
11     @Override
12     public void paintSelf(Graphics g) {
13         g.drawImage(image,x,y,null);
14     }
15 
16     @Override
17     public Rectangle gerRec() {
18         return new Rectangle(x,y,length,length);
19     }
20 }

GamePanel類

  1 import javax.swing.*;
  2 import java.applet.AudioClip;
  3 import java.awt.*;
  4 import java.awt.event.KeyAdapter;
  5 import java.awt.event.KeyEvent;
  6 import java.awt.event.KeyListener;
  7 import java.util.ArrayList;
  8 import java.util.Random;
  9 
 10 public class GamePanel extends JFrame {
 11     //游戲狀態;設置狀態為0:開始界面狀態
 12     int state = 0;
 13     //窗口長寬
 14     int width =800;
 15     int height=610 ;
 16     //雙緩存圖片
 17     Image bufferImage  = null;
 18     //select指針初始坐標
 19     int y = 260;
 20     //重繪次數
 21     int repaintNum = 0;
 22     // 開始界面的坦克圖標
 23     Image  select = Toolkit.getDefaultToolkit().getImage("images/right.jpg");
 24     //基地
 25     Base base = new Base("images/base.gif",340,570,this);
 26     //子彈列表
 27     ArrayList<Bullet> bullets = new ArrayList<>();
 28     //敵方坦克列表
 29     ArrayList<Bot> bots = new ArrayList<>();
 30     //地方子彈列表
 31     ArrayList<EnemyBullet> enemyBullets = new ArrayList<>();
 32     //需要刪除的地方子彈列表
 33     ArrayList<Bullet> removelist = new ArrayList<>();
 34     //牆列表
 35     ArrayList<Wall> walls = new ArrayList<>();
 36     //玩家
 37     Player player = new Player("images/up.jpg",125,510,this,"images/up.jpg",
 38             "images/down.jpg","images/left.jpg","images/right.jpg");
 39 
 40 
 41     //窗口啟動方法
 42     public void lunch()
 43     {
 44         //添加鍵盤監聽器
 45         this.addKeyListener(new KeyMonitor());
 46         //標題
 47         setTitle("坦克大戰");
 48         //窗口初始大小
 49         setSize(width,height);
 50         //使屏幕居中
 51         setLocationRelativeTo(null);
 52         //添加關閉事件
 53         setDefaultCloseOperation(3);
 54         //用戶不能調整大小
 55         setResizable(false);
 56         //使窗口可見
 57         setVisible(true);
 58         //創建敵方坦克和圍牆
 59         buildBot();
 60         buildWall();
 61         //每隔20ms重繪一次
 62         while(true)
 63         {
 64             //如果坦克數量小於10並且每重繪三百次重新生成一個地方坦克
 65             if(bots.size()<10&&repaintNum%300 == 0)
 66             {
 67                 //獲取隨機坐標
 68                 Random random = new Random();
 69                 int xx = random.nextInt(700);
 70                 Bot bot = new Bot("images/bot_u.png",xx,110,this,"images/bot_u.png","images/bot_d.png","images/bot_l.png","images/bot_r.png");
 71                //添加入敵方坦克列表
 72                 bots.add(bot);
 73             }
 74             //重繪
 75             repaint();
 76             //線程休眠50ms;
 77             try {
 78                 Thread.sleep(50);
 79             } catch (InterruptedException e) {
 80                 e.printStackTrace();
 81             }
 82         }
 83     }
 84     //創建坦克對象
 85     private void buildBot() {
 86         for(int i = 0;i<5;i++)
 87         {
 88             String img = null;
 89             //隨機獲取坦克坐標
 90             Random random = new Random();
 91             int xx = random.nextInt(700);
 92             int yy = random.nextInt(300);
 93             int o = random.nextInt(4);
 94             //隨機獲取坦克朝向
 95             switch (o)
 96             {
 97                 case 0 : img = "images/bot_u.png";break;
 98                 case 1 : img = "images/bot_d.png";break;
 99                 case 2 : img = "images/bot_l.png";break;
100                 case 3 : img = "images/bot_r.png";break;
101             }
102             Bot bot = new Bot(img,xx,yy,this,"images/bot_u.png","images/bot_d.png","images/bot_l.png","images/bot_r.png");
103             bots.add(bot);
104         }
105     }
106     //建造圍牆對象
107     private void buildWall() {
108         String wal = "images/wall.gif";
109         walls.add(new Wall(wal,100,200,this));
110         walls.add(new Wall(wal,100,240,this));
111         walls.add(new Wall(wal,100,280,this));
112         walls.add(new Wall(wal,100,320,this));
113         walls.add(new Wall(wal,100,360,this));
114         walls.add(new Wall(wal,360,180,this));
115         walls.add(new Wall(wal,400,180,this));
116         walls.add(new Wall(wal,320,180,this));
117         walls.add(new Wall(wal,280,180,this));
118         walls.add(new Wall(wal,500,250,this));
119         walls.add(new Wall(wal,540,295,this));
120         walls.add(new Wall(wal,580,340,this));
121         walls.add(new Wall(wal,700,100,this));
122         walls.add(new Wall(wal,700,140,this));
123         walls.add(new Wall(wal,700,180,this));
124         walls.add(new Wall(wal,700,220,this));
125         walls.add(new Wall(wal,300,560,this));
126         walls.add(new Wall(wal,300,520,this));
127         walls.add(new Wall(wal,340,520,this));
128         walls.add(new Wall(wal,380,520,this));
129         walls.add(new Wall(wal,380,560,this));
130     }
131     //定義清除列表函數，使用可變參數，可以傳入多個集合;
132     public void clear(ArrayList ...al)
133     {
134         //遍歷參數數組
135         for (ArrayList a : al)
136         {
137             //如果列表不為空則清空
138             if (a.size()!=0)
139                 a.clear();
140         }
141     }
142 
143     //paint方法
144     @Override
145     public void paint(Graphics g) {
146         //重繪次數+1
147         repaintNum++;
148         //現將元素繪制到圖片，再將圖片繪制到界面內，解決屏幕閃動問題;
149         if(bufferImage ==null)
150         {
151             bufferImage = this.createImage(width,height);
152         }
153         //獲取圖片的畫筆
154         Graphics graphics = bufferImage.getGraphics();
155         //設置畫筆顏色
156         graphics.setColor(Color.black);
157         //繪制實心矩形
158         graphics.fillRect(0,0,width,height);
159         //狀態為0時，繪制游戲開始界面
160         if(state == 0)
161         {
162             //改變畫筆顏色
163             graphics.setColor(new Color(158, 51, 51, 218));
164             //改變文字大小和樣式
165             graphics.setFont(new Font("楷體",Font.BOLD,100));
166             //添加文字
167             graphics.drawString("BATTILE CITY",80,170);
168             graphics.setFont(new Font("微軟雅黑",Font.BOLD,40));
169             graphics.setColor(Color.white);
170             graphics.drawString("開始游戲",320,300);
171             graphics.drawString("游戲說明",320,400);
172             graphics.drawImage(select,240,y,null);
173         }
174         //1: 游戲進行中界面
175         else if(state == 1){
176             //顯示敵人數量
177             graphics.setFont(new Font("微軟雅黑",Font.BOLD,20));
178             graphics.setColor(Color.white);
179             graphics.drawString("敵人數量:"+bots.size(),40,80);
180             //繪制玩家坦克
181             player.paintSelf(graphics);
182             //移除應該消滅的子彈
183             bullets.removeAll(removelist);
184             //遍歷子彈集合，繪制子彈
185             for (Bullet b:bullets) {
186                 b.paintSelf(graphics);
187             }
188             //遍歷敵方子彈集合，繪制子彈
189             for (EnemyBullet b:enemyBullets) {
190                 b.paintSelf(graphics);
191             }
192             //遍歷敵方坦克集合，繪制敵方坦克
193             for(Bot b : bots)
194             {
195                 b.paintSelf(graphics);
196             }
197             //遍歷圍牆集合，繪制圍牆
198             for(Wall w : walls)
199             {
200                 w.paintSelf(graphics);
201             }
202             //繪制基地
203             base.paintSelf(graphics);
204             //如果坦克數量為零，判定勝利，進入狀態四
205             if (bots.size()==0)
206                 state = 4;
207         }
208         //2: 繪制游戲失敗界面
209         else if(state == 2)
210         {
211             //首先清空所有集合元素
212             clear(bullets,bots,walls,enemyBullets);
213             //繪制界面
214             graphics.drawImage(Toolkit.getDefaultToolkit().getImage("images/gameover.png"),50,0,null);
215             graphics.setFont(new Font("微軟雅黑",Font.BOLD,40));
216             graphics.setColor(Color.white);
217             graphics.drawString("重新來過",320,300);
218             graphics.drawString("退出游戲",320,400);
219             graphics.drawImage(select,240,y,null);
220         }
221         //4: 繪制游戲勝利界面
222         else if (state == 4)
223         {
224             //改變畫筆顏色
225             graphics.setColor(new Color(158, 51, 51, 218));
226             //改變文字大小和樣式
227             graphics.setFont(new Font("楷體",Font.BOLD,100));
228             //添加文字
229             graphics.drawString("V I C T O R Y",80,170);
230             graphics.setFont(new Font("微軟雅黑",Font.BOLD,40));
231             graphics.setColor(Color.white);
232             graphics.drawString("再來一次",320,300);
233             graphics.drawString("退出游戲",320,400);
234             graphics.drawImage(select,240,y,null);
235         }
236         //5: 繪制游戲說明界面
237         else if (state == 5)
238         {
239             graphics.setColor(Color.white);
240             graphics.setFont(new Font("楷體",Font.BOLD,40));
241             //添加文字
242             graphics.drawString("通過鍵盤上的方向鍵控制坦克移動，",80,170);
243             graphics.drawString("空格控制子彈發射，每隔一秒只能",80,230);
244             graphics.drawString("發射一顆子彈，敵方坦克擊中我方",80,290);
245             graphics.drawString("坦克或者基地則游戲失敗，消滅地",80,350);
246             graphics.drawString("方所有坦克則獲得勝利。",80,410);
247             graphics.drawString("按enter鍵返回開始界面",80,470);
248         }
249         // 將圖片繪制到界面中
250         g.drawImage(bufferImage,0,0,null);
251 
252     }
253     //鍵盤監視器
254     class KeyMonitor extends KeyAdapter{
255         //按下鍵盤
256         @Override
257         public void keyPressed (KeyEvent e)
258         {
259             //監聽游戲開始界面
260             if(state ==0)
261             {
262                 //改變坦克圖標位置
263                 if(e.getKeyCode()==KeyEvent.VK_UP||e.getKeyCode()==KeyEvent.VK_DOWN)
264                 {
265                     if(y == 260)
266                         y = 360;
267                     else
268                         y = 260;
269                 }
270                 //根據圖標位置選擇下一步狀態
271                 if(e.getKeyCode() == KeyEvent.VK_ENTER)
272                     if(y==260)
273                         //開始游戲
274                         state = 1;
275                     else
276                         //游戲說明
277                         state = 5;
278             }
279             //監聽游戲運行時界面
280             else if(state == 1){
281                 //為玩家添加鍵盤監聽事件
282                 player.keyPressed(e);
283             }
284             //監聽游戲失敗或者勝利界面
285             else if (state == 2||state ==4)
286             {
287                 if(e.getKeyCode()==KeyEvent.VK_UP||e.getKeyCode()==KeyEvent.VK_DOWN)
288                 {
289                     if(y == 260)
290                         y = 360;
291                     else
292                         y = 260;
293                 }
294                 if(e.getKeyCode() == KeyEvent.VK_ENTER)
295                 {
296                     //重新游戲，添加圍牆，敵人，並設置玩家起始坐標，設置狀態1開始游戲
297                     if(y == 260)
298                     {
299                         buildBot();
300                         buildWall();
301                         state = 1;
302                         player.x = 125;
303                         player.y = 510;
304                     }
305                     //退出java虛擬機
306                     else
307                         System.exit(0);
308                 }
309             //監聽游戲說明界面
310             }
311             else if (state == 5)
312             {
313                 if (e.getKeyCode() == KeyEvent.VK_ENTER)
314                     state =0;
315             }
316         }
317         //為玩家添加鍵盤監聽事件
318         @Override
319         public void keyReleased(KeyEvent e)
320         {
321             player.keyReleased(e);
322         }
323     }
324 }

枚舉類

1 //枚舉類
2 public enum Direction {
3     UP,DOWN,LEFT,RIGHT
4 }

運行截圖：

狀態0：

狀態 5

狀態 1

狀態2 ：

狀態 4：

游戲素材

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 java實現的坦克大戰 java的坦克大戰坦克大戰--Java類型 Java-坦克大戰 Java坦克大戰（一） Java坦克大戰（三） Java坦克大戰（四） java學習之坦克大戰游戲新手小項目-java坦克大戰 JAVA課程設計（坦克大戰）