资料来源：https://www.bilibili.com/video/BV1Aq4y1W79E?p=2

1、战斗机：HeroPlane

  1. package cn.tx.ltzj;
  3. import javax.swing.*;
  4. import java.awt.*;
  6. // 飞机在不断的监控按下的键盘，所以继承Thread，单独使用一个线程
  7. public class HeroPlane extends Thread{
  9.     // 英雄机在画板上的位置
  10.     int x = 230, y = 600;
  12.     // 飞机大小
  13.     int width = 80, heigth = 80;
  15.     // 飞机移动的速度
  16.     int speed = 8;
  18.     // 飞机图像
  19.     Image image = new ImageIcon("img/10011.png").getImage();
  21.     // 定义键盘上方向键的标志
  22.     boolean up, down, left, right;
  24.     public HeroPlane(int x, int y, int width, int heigth) {
  25.         this.x = x;
  26.         this.y = y;
  27.         this.width = width;
  28.         this.heigth = heigth;
  29.     }
  31.     public HeroPlane() {
  32.     }
  34.     @Override
  35.     public void run() {
  36.         while (true){
  37.             if(up){
  38.                 // y轴向上
  39.                 y -= speed;
  40.             }
  41.             if(down){
  42.                 // y轴向下
  43.                 y += speed;
  44.             }
  45.             if(left){
  46.                 x -= speed;
  47.             }
  48.             if(right){
  49.                 x += speed;
  50.             }
  52.             try {
  53.                 Thread.sleep(10);
  54.             } catch (InterruptedException e) {
  55.                 e.printStackTrace();
  56.             }
  57.         }
  58.     }
  59. }

2、敌机：EnemyPlane

  1. package cn.tx.ltzj;
  3. import javax.swing.*;
  4. import java.awt.*;
  6. // 敌机
  7. public class EnemyPlane extends Thread{
  9.     public GameFrame gf;
  11.     // 敌机在画板上的位置
  12.     public int x, y;
  14.     // 飞机大小
  15.     public int width = 40, heigth = 40;
  17.     // 飞机移动的速度
  18.     public int speed = 1;
  20.     // 飞机图像
  21.    public Image image = new ImageIcon("img/10025.png").getImage();
  23.     public EnemyPlane(int x, int y, GameFrame gf) {
  24.         super();
  25.         this.gf = gf;
  26.         this.x = x;
  27.         this.y = y;
  28.     }
  30.     public EnemyPlane(int x, int y, int width, int heigth, GameFrame gf) {
  31.         super();
  32.         this.gf = gf;
  33.         this.x = x;
  34.         this.y = y;
  35.         this.width = width;
  36.         this.heigth = heigth;
  37.     }
  39.     // 飞翔的额逻辑，移动的逻辑都在这里
  40.     public void run(){
  41.         while (true){
  42.             // 向左走
  43.             // 碰撞到了
  44.             if(hit()){
  45.                 System.out.println("hit........");
  46.                 this.speed = 0;
  47.                 // 敌机爆炸了
  48.                 this.image = new ImageIcon("img/300350.png").getImage();
  49.                 try {
  50.                     Thread.sleep(500);
  51.                 } catch (InterruptedException e) {
  52.                     e.printStackTrace();
  53.                 }
  54.                 // 从屏幕中移除被击毁的敌机
  55.                 gf.enemyPlanes.remove(this);
  56.                 break; // 飞机被子弹击毁的中断。中断当前敌机的线程
  57.             }
  58.             // 飞机没有被击毁，但已过边界
  59.             if(this.y >= 760){
  60.                 break;
  61.             }
  62.             try {
  63.                 Thread.sleep(10);
  64.             } catch (InterruptedException e) {
  65.                 e.printStackTrace();
  66.             }
  67.         }
  68.     }
  70.     // 检测碰撞
  71.     public boolean hit(){
  73.         // Swing技术中，已经提供
  74.         // 声明敌机的矩形
  75.         Rectangle myrect = new Rectangle(this.x, this.y, this.width, this.heigth);
  76.         // 声明子弹的矩形
  77.         Rectangle rect = null;
  79.         // 遍历所有的矩形
  80.         for (int i = 0; i < gf.bullets.size(); i++) {
  81.             Bullet bullet = gf.bullets.get(i);
  82.             System.out.println("test hit");
  83.             rect = new Rectangle(bullet.x, bullet.y - 1, bullet.width, bullet.heigth);
  84.             // 碰撞检测：子弹与敌机的碰撞
  85.             if(myrect.intersects(rect)){
  86.                 return true;
  87.             }
  88.         }
  89.         return false;
  90.     }
  92.     @Override
  93.     public String toString() {
  94.         return "EnemyPlane{" +
  95.                 "x=" + x +
  96.                 ", y=" + y +
  97.                 ", width=" + width +
  98.                 ", heigth=" + heigth +
  99.                 '}';
  100.     }
  101. }

3、玩家：Player

  1. package cn.tx.ltzj;
  3. import java.awt.event.KeyAdapter;
  4. import java.awt.event.KeyEvent;
  6. /**
  7.  * 定义一个玩家，继承键盘适配器
  8.  */
  9. public class Player extends KeyAdapter {
  11.     GameFrame gameFrame;
  13.     public Player(GameFrame gameFrame) {
  14.         this.gameFrame = gameFrame;
  15.     }
  17.     /**
  18.      * 按住键盘
  19.      * @param e
  20.      */
  21.     @Override
  22.     public void keyPressed(KeyEvent e) {
  23.         // 获取敲击键盘时，具体键对应的数值
  24.         int keyCode = e.getKeyCode();
  25.         // 键盘上的上下左右键对应的值分别为：38、40、37、39
  26.         switch(keyCode){
  27.             case 38:
  28.                 gameFrame.heroPlane.up = true;
  29.                 break;
  30.             case 40:
  31.                 gameFrame.heroPlane.down = true;
  32.                 break;
  33.             case 37:
  34.                 gameFrame.heroPlane.left = true;
  35.                 break;
  36.             case 39:
  37.                 gameFrame.heroPlane.right = true;
  38.                 break;
  39.             case 66: // 装子弹
  40.                 addBullut();
  41.                 break;
  43.         }
  44.         System.out.println(keyCode);
  45.     }
  47.     /**
  48.      * 松开键盘
  49.      * @param e
  50.      */
  51.     @Override
  52.     public void keyReleased(KeyEvent e) {
  53.         // 松开键盘时，具体键对应的数值
  54.         int keyCode = e.getKeyCode();
  55.         switch(keyCode){
  56.             case 38:
  57.                 gameFrame.heroPlane.up = false;
  58.                 break;
  59.             case 40:
  60.                 gameFrame.heroPlane.down = false;
  61.                 break;
  62.             case 37:
  63.                 gameFrame.heroPlane.left = false;
  64.                 break;
  65.             case 39:
  66.                 gameFrame.heroPlane.right = false;
  67.                 break;
  68.         }
  69.     }
  71.     /**
  72.      * 装弹
  73.      */
  74.     public void addBullut(){
  75.         gameFrame.bullets.add(new Bullet(gameFrame.heroPlane.x + 5, gameFrame.heroPlane.y - 20));
  76.     }
  77. }

4、子弹：Bullet

  1. package cn.tx.ltzj;
  3. import javax.swing.*;
  4. import java.awt.*;
  6. // 子弹
  7. public class Bullet{
  9.     // 子弹在画板上的位置
  10.     int x, y;
  12.     // 飞机大小
  13.     int width = 50, heigth = 50;
  15.     // 子弹移动的速度
  16.     int speed = 10;
  18.     // 子弹图像
  19.     Image image = new ImageIcon("img/30025.png").getImage();
  21.     public Bullet(int x, int y, int width, int heigth) {
  22.         this.x = x;
  23.         this.y = y;
  24.         this.width = width;
  25.         this.heigth = heigth;
  26.     }
  28.     public Bullet(int x, int y) {
  29.         this.x = x;
  30.         this.y = y;
  31.     }
  33.     public Bullet() {
  34.     }
  35. }

5、主类：GameFrame

  1. package cn.tx.ltzj;
  3. import javax.swing.*;
  4. import java.awt.*;
  5. import java.awt.image.BufferedImage;
  6. import java.util.Random;
  7. import java.util.Vector;
  9. // Java做成图形界面，需要借助JFram
  10. public class GameFrame extends JFrame {
  12.     HeroPlane heroPlane;
  14.     // 定义子弹的集合。Vector线程安全，需要销毁子弹
  15.     Vector<Bullet> bullets = new Vector<>();
  17.     // 敌机集合
  18.     Vector<EnemyPlane> enemyPlanes = new Vector<>();
  20.     GameFrame frame;
  22.     public GameFrame(){
  24.         frame = this;
  26.         // 创建英雄机
  27.         heroPlane = new HeroPlane();
  28.         heroPlane.start(); // 启动飞机单独的线程
  30.         // 设置窗体的宽高
  31.         this.setSize(500, 760);
  32.         // 标题
  33.         this.setTitle("雷霆战机");
  34.         this.setResizable(false);
  35.         this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
  36.         this.setLocationRelativeTo(null);
  37.         // 窗口可见
  38.         this.setVisible(true);
  40.         // 单独启动一个线程，供画笔使用，画笔会一直执行
  41.         new Thread(new Runnable() {
  42.             @Override
  43.             public void run() {
  44.                 while (true){
  45.                     repaint();  // 不间断调用paint方法
  46.                     try {
  47.                         Thread.sleep(10);
  48.                     } catch (InterruptedException e) {
  49.                         e.printStackTrace();
  50.                     }
  51.                 }
  52.             }
  53.         }).start();
  55.         // 产生敌机的线程，不断产生
  56.         new Thread(new Runnable() {
  58.             Random random = new Random();
  59.             @Override
  60.             public void run() {
  61.                 while (true){
  62.                     // 不断产生敌机，让X轴随机
  63.                     EnemyPlane enemyPlane = new EnemyPlane(random.nextInt(500), 0, frame);
  64.                     // 启动敌机：必须在生产敌机的时候就要启动敌机，而不是绘制敌机的时候启动，
  65.                     // 否则报错Exception in thread "AWT-EventQueue-0" java.lang.IllegalThreadStateException
  66.                     enemyPlane.start();
  67.                     enemyPlanes.add(enemyPlane);
  68.                     try {
  69.                         Thread.sleep(500);
  70.                     } catch (InterruptedException e) {
  71.                         e.printStackTrace();
  72.                     }
  73.                 }
  74.             }
  75.         }).start();
  77.     }
  79.     /**
  80.      * 在窗口上画，内容，paint这个画笔的方法在窗口初始化的时候会默认的执行
  81.      * @param graphics  画笔
  82.      */
  83.     public void paint(Graphics graphics){
  84.         // System.out.println("绘制画板");
  85.         // 画背景
  86.         BufferedImage image = (BufferedImage) this.createImage(this.getSize().width, this.getSize().height);
  87.         // 高效缓存的画笔
  89.         Graphics bi = image.getGraphics();
  90.         // 绘制背景图，在当前窗口的0, 0位置上
  91.         bi.drawImage(new ImageIcon("img/skypay_bg.png").getImage(),0,0,null);
  93.         // 绘制飞机
  94.         bi.drawImage(heroPlane.image, heroPlane.x, heroPlane.y, heroPlane.width, heroPlane.heigth,null);
  96.         // 绘制子弹
  97.         for (int i = 0; i < bullets.size(); i++) {
  98.             // System.out.println(bullets);
  99.             Bullet bullet = bullets.get(i);
  100.             if(bullet.y > 0){
  101.                 bi.drawImage(bullet.image, bullet.x, bullet.y -= bullet.speed, bullet.width, bullet.heigth, null);
  102.             }else {
  103.                 // 子弹到屏幕外了，删除子弹
  104.                 bullets.remove(bullet);
  105.             }
  106.         }
  108.         // 绘制敌机
  109.         for (int i = 0; i < enemyPlanes.size(); i++) {
  110.             // System.out.println(enemyPlanes);
  111.             EnemyPlane ep = enemyPlanes.get(i);
  113.             if(ep.y < 760){
  114.                 bi.drawImage(ep.image, ep.x, ep.y += ep.speed, ep.width, ep.heigth, null);
  115.             }else {
  116.                 // 敌机到屏幕外了，删除敌机
  117.                 bullets.remove(ep);
  118.             }
  119.         }
  121.         // 生效
  122.         graphics.drawImage(image,0,0,null);
  124.     }
  126.     public static void main(String[] args) {
  127.         GameFrame frame = new GameFrame();
  128.         Player player = new Player(frame);
  129.         // 在启动GameFrame后，启用player
  130.         frame.addKeyListener(player);
  131.     }
  132. }