这里将会一步步实现游戏项目的基本功能。
AWT 和 Swing 是 Java 中常见的 GUI(图形用户界面)技术。
本次使用的是 AWT 技术。
首先是建立一个 Java 项目，并创建类 MyGameFrame。
package come.jungle.plane;import java.awt.*;import java.awt.event.WindowAdapter;import java.awt.event.WindowEvent;/*** 游戏主窗口* 使用 AWT 技术画出游戏主窗口*/// 让 MyGameFrame 继承 Frame，这样子可以在方法里使用 Frame 的所有方法public class MyGameFrame extends Frame { // 定义一个初始化窗口 public void launchFrame(){ this.setTitle("The Plane War - 阿jun"); // 定义图形化界面右上角的标题 setVisible(true); // 定义窗口是否可见，默认是不可见，所以需要设置为 true 可见 setSize(500,500); // 设置窗口大小的高宽均为 500 setLocation(100,100); // 定义打开窗口的位置，程序坐标系默认以右上角为零点 // 增加关闭窗口的动作，通过方法重写和匿名内部类 this.addWindowListener(new WindowAdapter() { @Override public void windowClosing(WindowEvent e) { System.exit(0); // 让程序正常退出 } }); } public static void main(String[] args){ // 定义类对象，对象调用方法 MyGameFrame gameFrame = new MyGameFrame(); gameFrame.launchFrame(); }}
如果要在窗口中画图或者显示什么内容，我们需要重写 paint(Graphics g) 方法。
这个方法的作用是：画出整个窗口以及内部内容。
它会被系统自动调用，我们无需去调用这个方法。
// 重写 paint 方法@Overridepublic void paint(Graphics g){ // paint 方法作用是：画出整个窗口及内部内容。被系统自动调用。}
package come.jungle.plane;import java.awt.*;import java.awt.event.WindowAdapter;import java.awt.event.WindowEvent;import static java.awt.Color.red;/*** 游戏主窗口* 使用 AWT 技术画出游戏主窗口*/// 让 MyGameFrame 继承 Frame，这样子可以在方法里使用 Frame 的所有方法public class MyGameFrame extends Frame { // 重写 paint 方法 @Override public void paint(Graphics g) { // 把 g 当成是一支画笔来帮助实现绘制 // 由于 g 是属于对外借过来使用的，所以在使用以后需要将其还原，否则会导致下次其他地方使用时出现错误。 Color c = g.getColor(); // 在这个方法里添加我们要绘制的内容 // 可以自定义画笔颜色,两种方式 g.setColor(red);// g.setColor(new Color(255,220,3)); // 画直线：使用 drawLine() 画一条线,确定起点和终点的坐标 g.drawLine(100,100,400,400); // 画矩形：起点为(100,100),宽高分别为300，200的矩形 g.drawRect(100,100,300,200); // 画椭圆：起点为(100,100),宽高分别为300，200的矩形 g.drawOval(100,100,300,200); // 椭圆的宽高来源是外切矩形的宽高，在程序里任何物体都是矩形。 // 画字符串 g.drawString("阿jun",300,300); // 返还画笔最初传进方法来时的颜色 g.setColor(c); } // 定义一个初始化窗口 public void launchFrame(){ this.setTitle("The Plane War - 阿jun"); // 定义图形化界面右上角的标题 setVisible(true); // 定义窗口是否可见，默认是不可见，所以需要设置为 true 可见 setSize(500,500); // 设置窗口大小的高宽均为 500 setLocation(100,100); // 定义打开窗口的位置，程序坐标系默认以右上角为零点 // 增加关闭窗口的动作，通过方法重写和匿名内部类 this.addWindowListener(new WindowAdapter() { @Override public void windowClosing(WindowEvent e) { System.exit(0); // 让程序正常退出 } }); } public static void main(String[] args){ // 定义类对象，对象调用方法 MyGameFrame gameFrame = new MyGameFrame(); gameFrame.launchFrame(); }}
游戏开发中，图片加载是最常见的技术。
在此处使用 ImageIO 类实现图片加载，并且为了代码的复用，将图片加载的方法封装到 GameUtil 工具类中，便于我们以后直接调用。
需要先将项目所需图片拷贝到项目的 src 下面，去建立新的文件夹 images 包用于存放所有图片。即在 src 下创建一个名为 images 的 package 包。
目前有两个文件：MyGameFrame.java 和 GameUtil.java
可以将一些辅助性的工具方法放到 GameUtil 中，便于重复调用。
MyGameFrame.java:
package come.jungle.plane;import java.awt.*;import java.awt.event.WindowAdapter;import java.awt.event.WindowEvent;import static java.awt.Color.red;/*** 游戏主窗口* 使用 AWT 技术画出游戏主窗口*/// 让 MyGameFrame 继承 Frame，这样子可以在方法里使用 Frame 的所有方法public class MyGameFrame extends Frame { // 在窗口中加载 png 图片 // 创建图片类对象，利用 getImage 方法加载图片 Image plane = GameUtil.getImage("images/plane.png"); Image bg = GameUtil.getImage("images/bg.png"); // 重写 paint 方法 @Override public void paint(Graphics g) { // 把 g 当成是一支画笔来帮助实现绘制 // 利用 drawImage() 方法在窗口中画图 // 加载 bg 作为背景图片，从(0,0) 开始，占用宽高为 500，500 g.drawImage(bg,0,0,500,500,null); // 加载 plane 作为飞机图片 g.drawImage(plane,100,100,22,33,null); } // 定义一个初始化窗口 public void launchFrame(){ this.setTitle("The Plane War - 阿jun"); // 定义图形化界面右上角的标题 setVisible(true); // 定义窗口是否可见，默认是不可见，所以需要设置为 true 可见 setSize(500,500); // 设置窗口大小的高宽均为 500 setLocation(100,100); // 定义打开窗口的位置，程序坐标系默认以右上角为零点 // 增加关闭窗口的动作，通过方法重写和匿名内部类 this.addWindowListener(new WindowAdapter() { @Override public void windowClosing(WindowEvent e) { System.exit(0); // 让程序正常退出 } }); } public static void main(String[] args){ // 定义类对象，对象调用方法 MyGameFrame gameFrame = new MyGameFrame(); gameFrame.launchFrame(); }}GameUtil.java:
package come.jungle.plane;import javax.imageio.ImageIO;import java.awt.*;import java.awt.image.BufferedImage;import java.io.IOException;import java.net.URL;/*** 游戏的工具类* 工具类中一般都是放置一些 static 方法*/public class GameUtil { // 构造器私有，防止别人创建本类对象（本项目可有可无） private GameUtil(){ } public static Image getImage(String path){ // 将对应字符串的路径传入，比如 /images/plane.png // 根据传入的字符串路径来加载对应的图片，加载以后形成一个图片对象返回 BufferedImage img = null; // 定义一个外部空对象 // 先获得当前类的一个 class 对象，然后获得一个类加载器，通过类加载器获得一个 resource 资源 URL u = GameUtil.class.getClassLoader().getResource(path); // 通过 ImageIO 调用 read() 方法，然后去读文件，会产生异常，需要去处理 try { img = ImageIO.read(u); } catch (IOException e) { e.printStackTrace(); } return img; } public static void main(String[] args) { // 测试程序是否异常，通过打印对象的方式，如果打印报异常或为空，则说明有异常 Image img = GameUtil.getImage("images/plane.png"); // 打印飞机图片对象，路径前方不加斜杠 System.out.println(img); }}
目前窗口仍然是静态的。本次结合多线程实现动画效果。
在 MyGameFrame 类中定义 “重画窗口线程 PaintThread 类”，将 PaintThread 定义成内部类，是为了方便使用 MyFameFrame 类的属性和方法。
同时利用双缓冲技术解决窗口闪烁问题。
双缓冲技术介绍：
双缓冲即在内存中创建一个与屏幕绘图区域一致的对象,先将图形绘制到内存中的这个对象上，再一次性将这个对象上的图形拷贝到屏幕上，这样能大大加快绘图的速度。
MyGameFrame.java
package come.jungle.plane;import java.awt.*;import java.awt.event.WindowAdapter;import java.awt.event.WindowEvent;import static java.awt.Color.red;/*** 游戏主窗口* 使用 AWT 技术画出游戏主窗口*/// 让 MyGameFrame 继承 Frame，这样子可以在方法里使用 Frame 的所有方法public class MyGameFrame extends Frame { // 定义双缓冲技术所需要的窗口长宽属性，基于初始化游戏窗口的长宽而定 // 在窗口中加载 png 图片 // 创建图片类对象，利用 getImage 方法加载图片 Image plane = GameUtil.getImage("images/plane.png"); Image bg = GameUtil.getImage("images/bg.png"); static int count = 0; int planeX = 100; // 将飞机的X坐标设置成一个变量。 // 重写 paint 方法 @Override public void paint(Graphics g) { // 把 g 当成是一支画笔来帮助实现绘制 System.out.println("绘制窗口次数：" + count); count++; // 利用 drawImage() 方法在窗口中画图 // 加载 bg 作为背景图片，从(0,0) 开始，占用宽高为 500，500 g.drawImage(bg,0,0,Constant.GAME_WIDTH,Constant.GAME_HEIGHT,null); // 加载 plane 作为飞机图片 g.drawImage(plane,planeX,100,22,33,null); planeX += 1; } // 定义一个初始化窗口 public void launchFrame(){ this.setTitle("The Plane War - 阿jun"); // 定义图形化界面右上角的标题 setVisible(true); // 定义窗口是否可见，默认是不可见，所以需要设置为 true 可见 // Constant.GAME_WIDTH 用于调用 Constant 类的 GAME_WIDTH 常量来使用 setSize(Constant.GAME_WIDTH,Constant.GAME_HEIGHT); // 设置窗口大小的高宽均为 500 setLocation(100,100); // 定义打开窗口的位置，程序坐标系默认以右上角为零点 // 增加关闭窗口的动作，通过方法重写和匿名内部类 this.addWindowListener(new WindowAdapter() { @Override public void windowClosing(WindowEvent e) { System.exit(0); // 让程序正常退出 } }); // 将重画窗口的线程类放入初始化窗口方法中，在程序初始化窗口时，就会调用这个方法，顺便调用线程类对象。 new PaintThread().start(); // 启动重画窗口的线程。 } /** * 定义一个重画窗口的线程类。 * 定义成内部类是为了方便直接使用窗口类的相关方法。 */ class PaintThread extends Thread{ // 重写 Thread类的 run() 方法 @Override public void run() { // 只要程序是活着的，就要求一直重画窗口，所以是 while(true) 死循环 while(true){ // repaint() 是外部类 Frame 的成员方法 repaint(); // 给程序设定一个重画时间间隔 try { // 程序执行到此处时，进度停 50 s Thread.sleep(50); // 1s=1000ms，即1s画20次（20*50=1000） } catch (InterruptedException e) { e.printStackTrace(); } } } } // 双缓冲技术解决窗口闪烁问题 private Image offScreenImage = null; public void update(Graphics g){ if(offScreenImage == null){ // 这里是游戏窗口的宽度和高度 offScreenImage = this.createImage(Constant.GAME_WIDTH,Constant.GAME_HEIGHT); } Graphics gOff = offScreenImage.getGraphics(); paint(gOff); g.drawImage(offScreenImage,0,0,null); } public static void main(String[] args){ // 定义类对象，对象调用方法 MyGameFrame gameFrame = new MyGameFrame(); gameFrame.launchFrame(); }}Constant.java
package come.jungle.plane;/** * 存放相关常量 * */public class Constant { // 定义双缓冲技术所需要的窗口长宽属性，基于初始化游戏窗口的长宽而定 // 游戏窗口的宽度 public static final int GAME_WIDTH = 500; // 游戏窗口的宽度 public static final int GAME_HEIGHT = 500;}
窗口中所有的对象(飞机、炮弹等等)都有很多共性:“图片对象、坐标位置、运行速度、宽度和高度”。
为了方便程序开发，我们需要设计一个GameObject类，它可以作为所有游戏物体的父类，方便我们编程。
MyGameFrame.java
package come.jungle.plane;import java.awt.*;import java.awt.event.WindowAdapter;import java.awt.event.WindowEvent;import static java.awt.Color.red;/*** 游戏主窗口* 使用 AWT 技术画出游戏主窗口*/// 让 MyGameFrame 继承 Frame，这样子可以在方法里使用 Frame 的所有方法public class MyGameFrame extends Frame { // 定义双缓冲技术所需要的窗口长宽属性，基于初始化游戏窗口的长宽而定 // 在窗口中加载 png 图片 // 创建图片类对象，利用 getImage 方法加载图片 Image planeImg = GameUtil.getImage("images/plane.png"); Image bg = GameUtil.getImage("images/bg.png"); static int count = 0; // 创建一个 GameObject 类的飞机对象，定义对应属性进行传入 // 要传入的属性值，GameObject(Image img, double x, double y, int speed, int width, int height) GameObject plane2 = new GameObject(planeImg,100,100,3,22,33); // 定义第二个GameObject类的飞机对象// GameObject plane3 = new GameObject(planeImg,200,200,3,22,33); // 重写 paint 方法 @Override public void paint(Graphics g) { // 把 g 当成是一支画笔来帮助实现绘制 System.out.println("绘制窗口次数：" + count); count++; // 利用 drawImage() 方法在窗口中画图 // 加载 bg 作为背景图片，从(0,0) 开始，占用宽高为 500，500 g.drawImage(bg,0,0,Constant.GAME_WIDTH,Constant.GAME_HEIGHT,null); // 飞机对象调用方法中的画笔属性 g，自己画自己 plane2.drawMyself(g); // 画第二个飞机物体，直接创建GameObject类的第二个飞机对象并调用 drawMyself(g) 方法即可。// plane3.drawMyself(g); } // 定义一个初始化窗口 public void launchFrame(){ this.setTitle("The Plane War - 阿jun"); // 定义图形化界面右上角的标题 setVisible(true); // 定义窗口是否可见，默认是不可见，所以需要设置为 true 可见 // Constant.GAME_WIDTH 用于调用 Constant 类的 GAME_WIDTH 常量来使用 setSize(Constant.GAME_WIDTH,Constant.GAME_HEIGHT); // 设置窗口大小的高宽均为 500 setLocation(100,100); // 定义打开窗口的位置，程序坐标系默认以右上角为零点 // 增加关闭窗口的动作，通过方法重写和匿名内部类 this.addWindowListener(new WindowAdapter() { @Override public void windowClosing(WindowEvent e) { System.exit(0); // 让程序正常退出 } }); // 将重画窗口的线程类放入初始化窗口方法中，在程序初始化窗口时，就会调用这个方法，顺便调用线程类对象。 new PaintThread().start(); // 启动重画窗口的线程。 } /** * 定义一个重画窗口的线程类。 * 定义成内部类是为了方便直接使用窗口类的相关方法。 */ class PaintThread extends Thread{ // 重写 Thread类的 run() 方法 @Override public void run() { // 只要程序是活着的，就要求一直重画窗口，所以是 while(true) 死循环 while(true){ // repaint() 是外部类 Frame 的成员方法 repaint(); // 给程序设定一个重画时间间隔 try { // 程序执行到此处时，进度停 50 s Thread.sleep(50); // 1s=1000ms，即1s画20次（20*50=1000） } catch (InterruptedException e) { e.printStackTrace(); } } } } // 双缓冲技术解决窗口闪烁问题 private Image offScreenImage = null; public void update(Graphics g){ if(offScreenImage == null){ // 这里是游戏窗口的宽度和高度 offScreenImage = this.createImage(Constant.GAME_WIDTH,Constant.GAME_HEIGHT); } Graphics gOff = offScreenImage.getGraphics(); paint(gOff); g.drawImage(offScreenImage,0,0,null); } public static void main(String[] args){ // 定义类对象，对象调用方法 MyGameFrame gameFrame = new MyGameFrame(); gameFrame.launchFrame(); }}GameObject.java
package come.jungle.plane;import java.awt.*;/** * 游戏物体的根类 * */public class GameObject { // 将这些属性定义好以后，之前定义的跟飞机相关的代码就可以去掉了 Image img; // 图片 double x,y; // 物体的坐标 int speed; // 物体移动的速度 int width,height; // 物体的宽度和高度 // 属性值可以通过初始化去获取，使用构造器去生成相关内容。 // 通过外部传入，对属性进行赋值。 public GameObject(Image img, double x, double y, int speed, int width, int height) { this.img = img; this.x = x; this.y = y; this.speed = speed; this.width = width; this.height = height; } // 定义一个方法来画自身 public void drawMyself(Graphics g){ // 传入double，参数值要求是int，所以需要int强制转型一下 g.drawImage(img,(int)x,(int)y,width,height,null); } /** * 所有的物体都是矩形，当你获得对应的矩形时，就可以做一些相关的判断操作 * 返回物体对应的矩形区域，便于后续在碰撞检测中使用 * @retrun */ public Rectangle getRect(){ // 返回飞机位置的坐标位置，宽度高度 return new Rectangle((int)x,(int)y,width,height); }}
有了 GameObject 这个父类，设计飞机类只需要简单继承即可。
重新设计了飞机类，通过继承 GameObject 父类以后，重写构造方法，实现飞机的移动。
Plane.java
package come.jungle.plane;import java.awt.*;public class Plane extends GameObject{ // 重写父类方法 @Override public void drawMyself(Graphics g) { super.drawMyself(g); // 飞机飞行的算法，可以自行设定 x += speed; } // 定义构造方法 public Plane(Image img, double x, double y, int speed) { this.img = img; this.x = x; this.y = y; this.speed = speed; // 不传宽度高度时，就自动获取传入图片的宽度高度 this.width = img.getWidth(null); this.height = img.getHeight(null); }}GameObject.java
多了一个无参构造方法
package come.jungle.plane;import java.awt.*;/** * 游戏物体的根类 * */public class GameObject { // 将这些属性定义好以后，之前定义的跟飞机相关的代码就可以去掉了 Image img; // 图片 double x,y; // 物体的坐标 int speed; // 物体移动的速度 int width,height; // 物体的宽度和高度 // 属性值可以通过初始化去获取，使用构造器去生成相关内容。 // 通过外部传入，对属性进行赋值。 public GameObject(Image img, double x, double y, int speed, int width, int height) { this.img = img; this.x = x; this.y = y; this.speed = speed; this.width = width; this.height = height; } // 定义一个方法来画自身 public void drawMyself(Graphics g){ // 传入double，参数值要求是int，所以需要int强制转型一下 g.drawImage(img,(int)x,(int)y,width,height,null); } // Plane 飞机子类继承 GameObject父类时，子类的无参构造器会调用父类的无参构造器，所以需定义一个GameObject父类的无参构造器 public GameObject(){} /** * 所有的物体都是矩形，当你获得对应的矩形时，就可以做一些相关的判断操作 * 返回物体对应的矩形区域，便于后续在碰撞检测中使用 * @retrun */ public Rectangle getRect(){ // 返回飞机位置的坐标位置，宽度高度 return new Rectangle((int)x,(int)y,width,height); }}MyGameFrame.java
package come.jungle.plane;import java.awt.*;import java.awt.event.WindowAdapter;import java.awt.event.WindowEvent;import static java.awt.Color.red;/*** 游戏主窗口* 使用 AWT 技术画出游戏主窗口*/// 让 MyGameFrame 继承 Frame，这样子可以在方法里使用 Frame 的所有方法public class MyGameFrame extends Frame { // 在窗口中加载 png 图片 // 创建图片类对象，利用 getImage 方法加载图片 Image planeImg = GameUtil.getImage("images/plane.png"); Image bg = GameUtil.getImage("images/bg.png"); static int count = 0; // 创建一个 Plane 类的飞机对象，定义对应属性进行传入 Plane p1 = new Plane(planeImg,200,200,2); Plane p2 = new Plane(planeImg,200,200,3); Plane p3 = new Plane(planeImg,200,200,4); // 重写 paint 方法 @Override public void paint(Graphics g) { // 把 g 当成是一支画笔来帮助实现绘制 System.out.println("绘制窗口次数：" + count); count++; // 利用 drawImage() 方法在窗口中画图 // 加载 bg 作为背景图片，从(0,0) 开始，占用宽高为 500，500 g.drawImage(bg,0,0,Constant.GAME_WIDTH,Constant.GAME_HEIGHT,null); // 飞机对象调用方法中的画笔属性 g，自己画自己 p1.drawMyself(g); p2.drawMyself(g); p3.drawMyself(g); } // 定义一个初始化窗口 public void launchFrame(){ this.setTitle("The Plane War - 阿jun"); // 定义图形化界面右上角的标题 setVisible(true); // 定义窗口是否可见，默认是不可见，所以需要设置为 true 可见 // Constant.GAME_WIDTH 用于调用 Constant 类的 GAME_WIDTH 常量来使用 setSize(Constant.GAME_WIDTH,Constant.GAME_HEIGHT); // 设置窗口大小的高宽均为 500 setLocation(100,100); // 定义打开窗口的位置，程序坐标系默认以右上角为零点 // 增加关闭窗口的动作，通过方法重写和匿名内部类 this.addWindowListener(new WindowAdapter() { @Override public void windowClosing(WindowEvent e) { System.exit(0); // 让程序正常退出 } }); // 将重画窗口的线程类放入初始化窗口方法中，在程序初始化窗口时，就会调用这个方法，顺便调用线程类对象。 new PaintThread().start(); // 启动重画窗口的线程。 } /** * 定义一个重画窗口的线程类。 * 定义成内部类是为了方便直接使用窗口类的相关方法。 */ class PaintThread extends Thread{ // 重写 Thread类的 run() 方法 @Override public void run() { // 只要程序是活着的，就要求一直重画窗口，所以是 while(true) 死循环 while(true){ // repaint() 是外部类 Frame 的成员方法 repaint(); // 给程序设定一个重画时间间隔 try { // 程序执行到此处时，进度停 50 s Thread.sleep(50); // 1s=1000ms，即1s画20次（20*50=1000） } catch (InterruptedException e) { e.printStackTrace(); } } } } // 双缓冲技术解决窗口闪烁问题 // 定义双缓冲技术所需要的窗口长宽属性，基于初始化游戏窗口的长宽而定 private Image offScreenImage = null; public void update(Graphics g){ if(offScreenImage == null){ // 这里是游戏窗口的宽度和高度 offScreenImage = this.createImage(Constant.GAME_WIDTH,Constant.GAME_HEIGHT); } Graphics gOff = offScreenImage.getGraphics(); paint(gOff); g.drawImage(offScreenImage,0,0,null); } public static void main(String[] args){ // 定义类对象，对象调用方法 MyGameFrame gameFrame = new MyGameFrame(); gameFrame.launchFrame(); }}
重点使用键盘进行交互。
使用键盘操控游戏物体，通过鼠标或其他，我们只需要通过相关API的帮助即可轻松实现。
使用面向对象的思想，实现键盘控制。
键盘控制原理：
键盘和程序交互时，每次按下键、松开键都会触发相应的键盘事件，事件的信息都封装到了KeyEvent对象中。
为了识别按下的键是哪个键，系统对键盘所有按键做了编号，每个按键都对应相应的数字。
比如∶回车键对应数字10，空格键对应数字32等。这些编号，我们都可以通过KeyEvent对象来查询，KeyEvent.VK_ENTER实际就是存储了数字10。
将飞机的键盘控制代码，放入了 Plane.java 飞机类中，在 MyGameFrame.java 中传入参数，调用对应方法即可。
Plane.java
package come.jungle.plane;import java.awt.*;import java.awt.event.KeyEvent;public class Plane extends GameObject{ // 飞机方向的控制 boolean left,right,up,down; // 重写父类方法 @Override public void drawMyself(Graphics g) { super.drawMyself(g); // 飞机飞行的算法，可以自行设定// x += speed; if (left){ x -= speed; } if (right){ x += speed; } if (up){ y -= speed; } if (down){ y += speed; } } // 定义飞机方向的方法 // 实现键盘按下对应的监听方法 public void addDirection(KeyEvent e){ switch(e.getKeyCode()){ case KeyEvent.VK_LEFT: left=true; break; case KeyEvent.VK_RIGHT: right=true; break; case KeyEvent.VK_UP: up=true; break; case KeyEvent.VK_DOWN: down=true; break; } } // 实现键盘松开的监听方法 public void minusDirection(KeyEvent e){ switch(e.getKeyCode()){ case KeyEvent.VK_LEFT: left=false; break; case KeyEvent.VK_RIGHT: right=false; break; case KeyEvent.VK_UP: up=false; break; case KeyEvent.VK_DOWN: down=false; break; } } // 定义构造方法 public Plane(Image img, double x, double y, int speed) { this.img = img; this.x = x; this.y = y; this.speed = speed; // 不传宽度高度时，就自动获取传入图片的宽度高度 this.width = img.getWidth(null); this.height = img.getHeight(null); }}MyGameFrame.java
package come.jungle.plane;import java.awt.*;import java.awt.event.KeyAdapter;import java.awt.event.KeyEvent;import java.awt.event.WindowAdapter;import java.awt.event.WindowEvent;import static java.awt.Color.red;/*** 游戏主窗口* 使用 AWT 技术画出游戏主窗口*/// 让 MyGameFrame 继承 Frame，这样子可以在方法里使用 Frame 的所有方法public class MyGameFrame extends Frame { // 在窗口中加载 png 图片 // 创建图片类对象，利用 getImage 方法加载图片 Image planeImg = GameUtil.getImage("images/plane.png"); Image bg = GameUtil.getImage("images/bg.png"); // 创建一个 Plane 类的飞机对象，定义对应属性进行传入 Plane p1 = new Plane(planeImg,200,200,7); // 重写 paint 方法 @Override public void paint(Graphics g) { // 把 g 当成是一支画笔来帮助实现绘制 // 利用 drawImage() 方法在窗口中画图 // 加载 bg 作为背景图片，从(0,0) 开始，占用宽高为 500，500 g.drawImage(bg,0,0,Constant.GAME_WIDTH,Constant.GAME_HEIGHT,null); // 飞机对象调用方法中的画笔属性 g，自己画自己 p1.drawMyself(g); // 测试方向键的效果：右上角为 (0,0)，通过更改坐标来实现移动 } // 定义一个初始化窗口 public void launchFrame(){ this.setTitle("The Plane War - 阿jun"); // 定义图形化界面右上角的标题 setVisible(true); // 定义窗口是否可见，默认是不可见，所以需要设置为 true 可见 // Constant.GAME_WIDTH 用于调用 Constant 类的 GAME_WIDTH 常量来使用 setSize(Constant.GAME_WIDTH,Constant.GAME_HEIGHT); // 设置窗口大小的高宽均为 500 setLocation(100,100); // 定义打开窗口的位置，程序坐标系默认以右上角为零点 // 增加关闭窗口的动作，通过方法重写和匿名内部类 this.addWindowListener(new WindowAdapter() { @Override public void windowClosing(WindowEvent e) { System.exit(0); // 让程序正常退出 } }); // 将重画窗口的线程类放入初始化窗口方法中，在程序初始化窗口时，就会调用这个方法，顺便调用线程类对象。 new PaintThread().start(); // 启动重画窗口的线程。 // 在程序初始化窗口时，启动键盘监听 this.addKeyListener(new KeyMonditor()); // 启动键盘监听 } /** * 定义一个重画窗口的线程类。 * 定义成内部类是为了方便直接使用窗口类的相关方法。 */ class PaintThread extends Thread{ // 重写 Thread类的 run() 方法 @Override public void run() { // 只要程序是活着的，就要求一直重画窗口，所以是 while(true) 死循环 while(true){ // repaint() 是外部类 Frame 的成员方法 repaint(); // 给程序设定一个重画时间间隔 try { // 程序执行到此处时，进度停 50 s Thread.sleep(50); // 1s=1000ms，即1s画20次（20*50=1000） } catch (InterruptedException e) { e.printStackTrace(); } } } } /** * 增加一个内部类，实现键盘的监听处理 * */ class KeyMonditor extends KeyAdapter{ // 重写方法，实现对按键状态(按下或抬起)的监听 // 重写键盘按下对应的监听方法 @Override public void keyPressed(KeyEvent e) { // 获取按下的按键是哪一个，每个按键都有一个特定的 code 值 System.out.println("按下：" + e.getKeyCode()); p1.addDirection(e); } // 重写键盘抬起(松开)对应的监听方法 @Override public void keyReleased(KeyEvent e) { // 获取抬起(松开)的按键是哪一个，每个按键都有一个特定的 code 值 System.out.println("抬起：" + e.getKeyCode()); p1.minusDirection(e); } } // 双缓冲技术解决窗口闪烁问题 // 定义双缓冲技术所需要的窗口长宽属性，基于初始化游戏窗口的长宽而定 private Image offScreenImage = null; public void update(Graphics g){ if(offScreenImage == null){ // 这里是游戏窗口的宽度和高度 offScreenImage = this.createImage(Constant.GAME_WIDTH,Constant.GAME_HEIGHT); } Graphics gOff = offScreenImage.getGraphics(); paint(gOff); g.drawImage(offScreenImage,0,0,null); } public static void main(String[] args){ // 定义类对象，对象调用方法 MyGameFrame gameFrame = new MyGameFrame(); gameFrame.launchFrame(); }}
可更深入了解构造器的用法以及容器的用法。
炮弹类我们用实心的黄色椭圆实现，不再加载新的图片。
我们的逻辑是在窗口固定位置(200,200)处生成炮弹，炮弹方向是随机的，并且遇到边界会反弹。
需要考虑的是炮弹的长宽对于碰撞边界值计算的影响。
使用容器或数组产生多发炮弹，本次用的是容器。
Shell.java
package come.jungle.plane;import java.awt.*;/** * 炮弹类 * */public class Shell extends GameObject{ // 继承了游戏物体根类的各个属性，比如坐标、速度、长宽。 double degree; // 定义炮弹的角度属性，炮弹沿着指定的角度飞行。 // 定义炮弹的初始构造器方法 public Shell(){ // 定义初始坐标 x = 200; y = 200; degree = Math.random()*Math.PI*2; // 生成一个任意角度数值// System.out.println(degree); width = 5; height = 5; speed = 5; } // 通过重写 drawMyself() 方法来画炮弹 @Override public void drawMyself(Graphics g) { // 定义炮弹的参数，画一个红色实心圆 Color c = g.getColor(); g.setColor(Color.yellow); g.fillOval((int)x,(int)y,width,height); g.setColor(c); // 用完以后，将画笔原本颜色还原。 // 根据自己的算法指定移动路径,speed是速度，利用角度进行x，y的距离计算 x += speed*Math.cos(degree); y += speed*Math.sin(degree); // 碰到边界改变方向，右上角为零点(0,0) // 由于炮弹有宽度，所以需要在计算碰撞边界时，去掉长宽值的影响 if (x < 0 || x > Constant.GAME_WIDTH - this.width){ degree = Math.PI-degree; } if (y < 40 || y > Constant.GAME_HEIGHT - this.height){ degree = -degree; } }}MyGameFrame.java
package come.jungle.plane;import java.awt.*;import java.awt.event.KeyAdapter;import java.awt.event.KeyEvent;import java.awt.event.WindowAdapter;import java.awt.event.WindowEvent;import static java.awt.Color.red;/*** 游戏主窗口* 使用 AWT 技术画出游戏主窗口*/// 让 MyGameFrame 继承 Frame，这样子可以在方法里使用 Frame 的所有方法public class MyGameFrame extends Frame { // 在窗口中加载 png 图片 // 创建图片类对象，利用 getImage 方法加载图片 Image planeImg = GameUtil.getImage("images/plane.png"); Image bg = GameUtil.getImage("images/bg.png"); // 创建一个 Plane 类的飞机对象，定义对应属性进行传入 Plane p1 = new Plane(planeImg,200,200,10); // 定义炮弹对象// Shell s1 = new Shell(); // 使用数组定义50个炮弹数组对象 Shell[] shells = new Shell[50]; // 重写 paint 方法 @Override public void paint(Graphics g) { // 把 g 当成是一支画笔来帮助实现绘制 // 利用 drawImage() 方法在窗口中画图 // 加载 bg 作为背景图片，从(0,0) 开始，占用宽高为 500，500 g.drawImage(bg,0,0,Constant.GAME_WIDTH,Constant.GAME_HEIGHT,null); // 飞机对象调用方法中的画笔属性 g，自己画自己 p1.drawMyself(g); // 画炮弹 for (int i=0;i <shells.length;i++){ shells[i].drawMyself(g); } } // 定义一个初始化窗口 public void launchFrame(){ this.setTitle("The Plane War - 阿jun"); // 定义图形化界面右上角的标题 setVisible(true); // 定义窗口是否可见，默认是不可见，所以需要设置为 true 可见 // Constant.GAME_WIDTH 用于调用 Constant 类的 GAME_WIDTH 常量来使用 setSize(Constant.GAME_WIDTH,Constant.GAME_HEIGHT); // 设置窗口大小的高宽均为 500 setLocation(100,100); // 定义打开窗口的位置，程序坐标系默认以右上角为零点 // 增加关闭窗口的动作，通过方法重写和匿名内部类 this.addWindowListener(new WindowAdapter() { @Override public void windowClosing(WindowEvent e) { System.exit(0); // 让程序正常退出 } }); // 将重画窗口的线程类放入初始化窗口方法中，在程序初始化窗口时，就会调用这个方法，顺便调用线程类对象。 new PaintThread().start(); // 启动重画窗口的线程。 // 在程序初始化窗口时，启动键盘监听 this.addKeyListener(new KeyMonditor()); // 启动键盘监听 // 利用for循环初始化创建 50 个炮弹对象 for (int i=0;i<50;i++){ shells[i] = new Shell(); } } /** * 定义一个重画窗口的线程类。 * 定义成内部类是为了方便直接使用窗口类的相关方法。 */ class PaintThread extends Thread{ // 重写 Thread类的 run() 方法 @Override public void run() { // 只要程序是活着的，就要求一直重画窗口，所以是 while(true) 死循环 while(true){ // repaint() 是外部类 Frame 的成员方法 repaint(); // 给程序设定一个重画时间间隔 try { // 程序执行到此处时，进度停 50 s Thread.sleep(50); // 1s=1000ms，即1s画20次（20*50=1000） } catch (InterruptedException e) { e.printStackTrace(); } } } } /** * 增加一个内部类，实现键盘的监听处理 * */ class KeyMonditor extends KeyAdapter{ // 重写方法，实现对按键状态(按下或抬起)的监听 // 重写键盘按下对应的监听方法 @Override public void keyPressed(KeyEvent e) { // 获取按下的按键是哪一个，每个按键都有一个特定的 code 值 System.out.println("按下：" + e.getKeyCode()); p1.addDirection(e); } // 重写键盘抬起(松开)对应的监听方法 @Override public void keyReleased(KeyEvent e) { // 获取抬起(松开)的按键是哪一个，每个按键都有一个特定的 code 值 System.out.println("抬起：" + e.getKeyCode()); p1.minusDirection(e); } } // 双缓冲技术解决窗口闪烁问题 // 定义双缓冲技术所需要的窗口长宽属性，基于初始化游戏窗口的长宽而定 private Image offScreenImage = null; public void update(Graphics g){ if(offScreenImage == null){ // 这里是游戏窗口的宽度和高度 offScreenImage = this.createImage(Constant.GAME_WIDTH,Constant.GAME_HEIGHT); } Graphics gOff = offScreenImage.getGraphics(); paint(gOff); g.drawImage(offScreenImage,0,0,null); } public static void main(String[] args){ // 定义类对象，对象调用方法 MyGameFrame gameFrame = new MyGameFrame(); gameFrame.launchFrame(); }}
游戏中，碰撞是遇到最频繁的技术。
很多游戏引擎内部已经做了碰撞检测处理,我们只需调用即可。
游戏中，多个元素是否碰到一起，实际上，通常是用“矩形检测”原理实现的。
游戏中所有的物体都可以抽象成“矩形”，我们只需判断两个矩形是否相交即可。对于一些复杂的多边形、不规则物体，实际上是将他分解成多个矩形，继续进行矩形检测。|
Java的 API中，为我们提供了Rectangle类来表示矩形相关信息，并且提供了intersects)方法，直接判断矩形是否相交。
实现了飞机碰到炮弹以后消失（即不再重画）的效果
MyGameFrame.java
package come.jungle.plane;import java.awt.*;import java.awt.event.KeyAdapter;import java.awt.event.KeyEvent;import java.awt.event.WindowAdapter;import java.awt.event.WindowEvent;import static java.awt.Color.red;/*** 游戏主窗口* 使用 AWT 技术画出游戏主窗口*/// 让 MyGameFrame 继承 Frame，这样子可以在方法里使用 Frame 的所有方法public class MyGameFrame extends Frame { // 在窗口中加载 png 图片 // 创建图片类对象，利用 getImage 方法加载图片 Image planeImg = GameUtil.getImage("images/plane.png"); Image bg = GameUtil.getImage("images/bg.png"); // 创建一个 Plane 类的飞机对象，定义对应属性进行传入 Plane p1 = new Plane(planeImg,300,300,10); // 定义炮弹对象// Shell s1 = new Shell(); // 使用数组定义50个炮弹数组对象 Shell[] shells = new Shell[3]; // 重写 paint 方法 @Override public void paint(Graphics g) { // 把 g 当成是一支画笔来帮助实现绘制 // 利用 drawImage() 方法在窗口中画图 // 加载 bg 作为背景图片，从(0,0) 开始，占用宽高为 500，500 g.drawImage(bg,0,0,Constant.GAME_WIDTH,Constant.GAME_HEIGHT,null); // 飞机对象调用方法中的画笔属性 g，自己画自己 p1.drawMyself(g); // 画炮弹 for (int i=0;i <shells.length;i++){ shells[i].drawMyself(g); // 碰撞检测，将所有的炮弹和飞机进行矩形碰撞检测，p1.getRect()表示为获取飞机对应的矩形 boolean peng = shells[i].getRect().intersects(p1.getRect()); if (peng){// System.out.println("飞机被击中了！！"); p1.live = false;// System.out.println(p1); } } } // 定义一个初始化窗口 public void launchFrame(){ this.setTitle("The Plane War - 阿jun"); // 定义图形化界面右上角的标题 setVisible(true); // 定义窗口是否可见，默认是不可见，所以需要设置为 true 可见 // Constant.GAME_WIDTH 用于调用 Constant 类的 GAME_WIDTH 常量来使用 setSize(Constant.GAME_WIDTH,Constant.GAME_HEIGHT); // 设置窗口大小的高宽均为 500 setLocation(100,100); // 定义打开窗口的位置，程序坐标系默认以右上角为零点 // 增加关闭窗口的动作，通过方法重写和匿名内部类 this.addWindowListener(new WindowAdapter() { @Override public void windowClosing(WindowEvent e) { System.exit(0); // 让程序正常退出 } }); // 将重画窗口的线程类放入初始化窗口方法中，在程序初始化窗口时，就会调用这个方法，顺便调用线程类对象。 new PaintThread().start(); // 启动重画窗口的线程。 // 在程序初始化窗口时，启动键盘监听 this.addKeyListener(new KeyMonditor()); // 启动键盘监听 // 利用for循环初始化创建 50 个炮弹对象 for (int i=0;i<shells.length;i++){ shells[i] = new Shell(); } } /** * 定义一个重画窗口的线程类。 * 定义成内部类是为了方便直接使用窗口类的相关方法。 */ class PaintThread extends Thread{ // 重写 Thread类的 run() 方法 @Override public void run() { // 只要程序是活着的，就要求一直重画窗口，所以是 while(true) 死循环 while(true){ // repaint() 是外部类 Frame 的成员方法 repaint(); // 给程序设定一个重画时间间隔 try { // 程序执行到此处时，进度停 50 s Thread.sleep(50); // 1s=1000ms，即1s画20次（20*50=1000） } catch (InterruptedException e) { e.printStackTrace(); } } } } /** * 增加一个内部类，实现键盘的监听处理 * */ class KeyMonditor extends KeyAdapter{ // 重写方法，实现对按键状态(按下或抬起)的监听 // 重写键盘按下对应的监听方法 @Override public void keyPressed(KeyEvent e) { // 获取按下的按键是哪一个，每个按键都有一个特定的 code 值// System.out.println("按下：" + e.getKeyCode()); p1.addDirection(e); } // 重写键盘抬起(松开)对应的监听方法 @Override public void keyReleased(KeyEvent e) { // 获取抬起(松开)的按键是哪一个，每个按键都有一个特定的 code 值// System.out.println("抬起：" + e.getKeyCode()); p1.minusDirection(e); } } // 双缓冲技术解决窗口闪烁问题 // 定义双缓冲技术所需要的窗口长宽属性，基于初始化游戏窗口的长宽而定 private Image offScreenImage = null; public void update(Graphics g){ if(offScreenImage == null){ // 这里是游戏窗口的宽度和高度 offScreenImage = this.createImage(Constant.GAME_WIDTH,Constant.GAME_HEIGHT); } Graphics gOff = offScreenImage.getGraphics(); paint(gOff); g.drawImage(offScreenImage,0,0,null); } public static void main(String[] args){ // 定义类对象，对象调用方法 MyGameFrame gameFrame = new MyGameFrame(); gameFrame.launchFrame(); }}Plane.java
package come.jungle.plane;import java.awt.*;import java.awt.event.KeyEvent;public class Plane extends GameObject{ // 飞机方向的控制 boolean left,right,up,down; public boolean live = true; // 定义飞机是否存活的变量，默认为 true。 // 重写父类方法 @Override public void drawMyself(Graphics g) { // 如果飞机没有存活,live=false，就不画了 if (live){ super.drawMyself(g); // 飞机飞行的算法，可以自行设定// x += speed; if (left){ x -= speed; } if (right){ x += speed; } if (up){ y -= speed; } if (down){ y += speed; } } } // 定义飞机方向的方法 // 实现键盘按下对应的监听方法 public void addDirection(KeyEvent e){ switch(e.getKeyCode()){ case KeyEvent.VK_LEFT: left=true; break; case KeyEvent.VK_RIGHT: right=true; break; case KeyEvent.VK_UP: up=true; break; case KeyEvent.VK_DOWN: down=true; break; } } // 实现键盘松开的监听方法 public void minusDirection(KeyEvent e){ switch(e.getKeyCode()){ case KeyEvent.VK_LEFT: left=false; break; case KeyEvent.VK_RIGHT: right=false; break; case KeyEvent.VK_UP: up=false; break; case KeyEvent.VK_DOWN: down=false; break; } } // 定义构造方法 public Plane(Image img, double x, double y, int speed) { this.img = img; this.x = x; this.y = y; this.speed = speed; // 不传宽度高度时，就自动获取传入图片的宽度高度 this.width = img.getWidth(null); this.height = img.getHeight(null); }}
在 src 目录的 images 文件夹下存放了爆炸相关系列图片。
新增了一个爆炸类文件 Explode.java，修改了 MyGameFrame.java 文件。
MyGameFrame.java
package come.jungle.plane;import java.awt.*;import java.awt.event.KeyAdapter;import java.awt.event.KeyEvent;import java.awt.event.WindowAdapter;import java.awt.event.WindowEvent;import static java.awt.Color.red;/*** 游戏主窗口* 使用 AWT 技术画出游戏主窗口*/// 让 MyGameFrame 继承 Frame，这样子可以在方法里使用 Frame 的所有方法public class MyGameFrame extends Frame { // 在窗口中加载 png 图片 // 创建图片类对象，利用 getImage 方法加载图片 Image planeImg = GameUtil.getImage("images/plane.png"); Image bg = GameUtil.getImage("images/bg.png"); // 创建一个 Plane 类的飞机对象，定义对应属性进行传入 Plane p1 = new Plane(planeImg,300,300,10); // 使用数组定义炮弹数组对象 Shell[] shells = new Shell[50]; // 爆炸 Explode explode; // 重写 paint 方法 @Override public void paint(Graphics g) { // 把 g 当成是一支画笔来帮助实现绘制 // 利用 drawImage() 方法在窗口中画图 // 加载 bg 作为背景图片，从(0,0) 开始，占用宽高为 500，500 g.drawImage(bg,0,0,Constant.GAME_WIDTH,Constant.GAME_HEIGHT,null); // 飞机对象调用方法中的画笔属性 g，自己画自己 p1.drawMyself(g); // 画炮弹 for (int i=0;i <shells.length;i++){ shells[i].drawMyself(g); // 碰撞检测，将所有的炮弹和飞机进行矩形碰撞检测，p1.getRect()表示为获取飞机对应的矩形 boolean peng = shells[i].getRect().intersects(p1.getRect()); if (peng){ p1.live = false; // 处理爆炸效果，默认炸了一次以后，炮弹再碰到就不炸了 if (explode==null){ // 当飞机被碰撞时，创建爆炸类的对象，并传入飞机当时的(x,y)坐标值 explode = new Explode(p1.x,p1.y); } // 画出爆炸效果系列图片 explode.drawMyself(g); } } } // 定义一个初始化窗口 public void launchFrame(){ this.setTitle("The Plane War - 阿jun"); // 定义图形化界面右上角的标题 setVisible(true); // 定义窗口是否可见，默认是不可见，所以需要设置为 true 可见 // Constant.GAME_WIDTH 用于调用 Constant 类的 GAME_WIDTH 常量来使用 setSize(Constant.GAME_WIDTH,Constant.GAME_HEIGHT); // 设置窗口大小的高宽均为 500 setLocation(100,100); // 定义打开窗口的位置，程序坐标系默认以右上角为零点 // 增加关闭窗口的动作，通过方法重写和匿名内部类 this.addWindowListener(new WindowAdapter() { @Override public void windowClosing(WindowEvent e) { System.exit(0); // 让程序正常退出 } }); // 将重画窗口的线程类放入初始化窗口方法中，在程序初始化窗口时，就会调用这个方法，顺便调用线程类对象。 new PaintThread().start(); // 启动重画窗口的线程。 // 在程序初始化窗口时，启动键盘监听 this.addKeyListener(new KeyMonditor()); // 启动键盘监听 // 利用for循环初始化创建 50 个炮弹对象 for (int i=0;i<shells.length;i++){ shells[i] = new Shell(); } } /** * 定义一个重画窗口的线程类。 * 定义成内部类是为了方便直接使用窗口类的相关方法。 */ class PaintThread extends Thread{ // 重写 Thread类的 run() 方法 @Override public void run() { // 只要程序是活着的，就要求一直重画窗口，所以是 while(true) 死循环 while(true){ // repaint() 是外部类 Frame 的成员方法 repaint(); // 给程序设定一个重画时间间隔 try { // 程序执行到此处时，进度停 50 s Thread.sleep(50); // 1s=1000ms，即1s画20次（20*50=1000） } catch (InterruptedException e) { e.printStackTrace(); } } } } /** * 增加一个内部类，实现键盘的监听处理 * */ class KeyMonditor extends KeyAdapter{ // 重写方法，实现对按键状态(按下或抬起)的监听 // 重写键盘按下对应的监听方法 @Override public void keyPressed(KeyEvent e) { // 获取按下的按键是哪一个，每个按键都有一个特定的 code 值// System.out.println("按下：" + e.getKeyCode()); p1.addDirection(e); } // 重写键盘抬起(松开)对应的监听方法 @Override public void keyReleased(KeyEvent e) { // 获取抬起(松开)的按键是哪一个，每个按键都有一个特定的 code 值// System.out.println("抬起：" + e.getKeyCode()); p1.minusDirection(e); } } // 双缓冲技术解决窗口闪烁问题 // 定义双缓冲技术所需要的窗口长宽属性，基于初始化游戏窗口的长宽而定 private Image offScreenImage = null; public void update(Graphics g){ if(offScreenImage == null){ // 这里是游戏窗口的宽度和高度 offScreenImage = this.createImage(Constant.GAME_WIDTH,Constant.GAME_HEIGHT); } Graphics gOff = offScreenImage.getGraphics(); paint(gOff); g.drawImage(offScreenImage,0,0,null); } public static void main(String[] args){ // 定义类对象，对象调用方法 MyGameFrame gameFrame = new MyGameFrame(); gameFrame.launchFrame(); }}Explode.java
package come.jungle.plane;import java.awt.*;/** * 爆炸类 **/public class Explode { // 定义爆炸位置 double x,y; // 创建一个数组存放爆炸相关图片 static Image[] imgs = new Image[16]; // 计数器：计算现在画了多少次了（确定图片次序） int count; // 静态初始化块初始化静态属性 static { // 通过 for 循环，将16个图片全部初始化完成。 for(int i=0;i<16;i++){ imgs[i] = GameUtil.getImage("images/Explode/e"+(i+1)+".png"); // 需要用数组对象去调用真正的方法，图片才会真正加载进来 imgs[i].getWidth(null); // 解决程序懒加载问题 } } // 定义方法来花自己 public void drawMyself(Graphics g){ if (count < 16){ g.drawImage(imgs[count],(int)x,(int)y,null ); count++; } } // 定义无参构造器 public Explode(){ } // 定义形参构造器 public Explode(double x, double y) { this.x = x; this.y = y; }}
基本功能实现以后，增加一些锦上添花的功能。
比如：游戏计时功能、全网排名等。
我们希望在玩游戏时，增加计时功能，可以清晰的看到自己玩了多长时间,增加刺激性。
这个功能的核心有两点:
1.时间计算：当前时刻-游戏结束的时刻。
2．显示时间到窗口。
MyGameFrame.java
package come.jungle.plane;import java.awt.*;import java.awt.event.KeyAdapter;import java.awt.event.KeyEvent;import java.awt.event.WindowAdapter;import java.awt.event.WindowEvent;import java.util.Date;import static java.awt.Color.red;/*** 游戏主窗口* 使用 AWT 技术画出游戏主窗口*/// 让 MyGameFrame 继承 Frame，这样子可以在方法里使用 Frame 的所有方法public class MyGameFrame extends Frame { // 在窗口中加载 png 图片 // 创建图片类对象，利用 getImage 方法加载图片 Image planeImg = GameUtil.getImage("images/plane.png"); Image bg = GameUtil.getImage("images/bg.png"); // 创建一个 Plane 类的飞机对象，定义对应属性进行传入 Plane p1 = new Plane(planeImg,300,300,10); // 使用数组定义炮弹数组对象 Shell[] shells = new Shell[50]; // 爆炸 Explode explode; Date start = new Date(); // 游戏开始时间（以当前游戏运行时间作为一个开始） Date end; // 游戏结束时间（飞机碰撞炮弹时结束） long period = 0; // 游戏时长多少秒 // 重写 paint 方法 @Override public void paint(Graphics g) { // 把 g 当成是一支画笔来帮助实现绘制 // 利用 drawImage() 方法在窗口中画图 // 加载 bg 作为背景图片，从(0,0) 开始，占用宽高为 500，500 g.drawImage(bg,0,0,Constant.GAME_WIDTH,Constant.GAME_HEIGHT,null); // 调用计算游戏时长相关方法，计算游戏时间 drawtime(g); // 飞机对象调用方法中的画笔属性 g，自己画自己 p1.drawMyself(g); // 画炮弹 for (int i=0;i <shells.length;i++){ shells[i].drawMyself(g); // 碰撞检测，将所有的炮弹和飞机进行矩形碰撞检测，p1.getRect()表示为获取飞机对应的矩形 boolean peng = shells[i].getRect().intersects(p1.getRect()); if (peng){ p1.live = false; // 处理爆炸效果，默认炸了一次以后，炮弹再碰到就不炸了 if (explode==null){ // 当飞机被碰撞时，创建爆炸类的对象，并传入飞机当时的(x,y)坐标值 explode = new Explode(p1.x,p1.y); } // 画出爆炸效果系列图片 explode.drawMyself(g); } } } // 对计算游戏时长的代码进行封装 public void drawtime(Graphics g){ // 获取画笔传进来时的属性 Color c = g.getColor(); Font f = g.getFont(); g.setColor(Color.green); if (p1.live){ // 将计时功能文字画在游戏窗口中 period = (System.currentTimeMillis()-start.getTime())/1000; // 计算游戏时长，单位是毫秒，所以除以1000变成秒 g.drawString("坚持："+period+"秒",30,50); }else{ if (end==null){ // 只有第一次的时候才为null，后面再画的时候就不为 null 了 end = new Date(); period = (end.getTime() - start.getTime())/1000; // 计算游戏结束时的总时长 } // 设置字体样式 g.setColor(Color.red); g.setFont((new Font("微软雅黑",Font.BOLD,30))); g.drawString("最终游戏时长："+period+"秒",200,200); } // 还原画笔传进来时的属性 g.setColor(c); g.setFont(f); } // 定义一个初始化窗口 public void launchFrame(){ this.setTitle("The Plane War - 阿jun"); // 定义图形化界面右上角的标题 setVisible(true); // 定义窗口是否可见，默认是不可见，所以需要设置为 true 可见 // Constant.GAME_WIDTH 用于调用 Constant 类的 GAME_WIDTH 常量来使用 setSize(Constant.GAME_WIDTH,Constant.GAME_HEIGHT); // 设置窗口大小的高宽均为 500 setLocation(100,100); // 定义打开窗口的位置，程序坐标系默认以右上角为零点 // 增加关闭窗口的动作，通过方法重写和匿名内部类 this.addWindowListener(new WindowAdapter() { @Override public void windowClosing(WindowEvent e) { System.exit(0); // 让程序正常退出 } }); // 将重画窗口的线程类放入初始化窗口方法中，在程序初始化窗口时，就会调用这个方法，顺便调用线程类对象。 new PaintThread().start(); // 启动重画窗口的线程。 // 在程序初始化窗口时，启动键盘监听 this.addKeyListener(new KeyMonditor()); // 启动键盘监听 // 利用for循环初始化创建 50 个炮弹对象 for (int i=0;i<shells.length;i++){ shells[i] = new Shell(); } } /** * 定义一个重画窗口的线程类。 * 定义成内部类是为了方便直接使用窗口类的相关方法。 */ class PaintThread extends Thread{ // 重写 Thread类的 run() 方法 @Override public void run() { // 只要程序是活着的，就要求一直重画窗口，所以是 while(true) 死循环 while(true){ // repaint() 是外部类 Frame 的成员方法 repaint(); // 给程序设定一个重画时间间隔 try { // 程序执行到此处时，进度停 50 s Thread.sleep(50); // 1s=1000ms，即1s画20次（20*50=1000） } catch (InterruptedException e) { e.printStackTrace(); } } } } /** * 增加一个内部类，实现键盘的监听处理 * */ class KeyMonditor extends KeyAdapter{ // 重写方法，实现对按键状态(按下或抬起)的监听 // 重写键盘按下对应的监听方法 @Override public void keyPressed(KeyEvent e) { // 获取按下的按键是哪一个，每个按键都有一个特定的 code 值// System.out.println("按下：" + e.getKeyCode()); p1.addDirection(e); } // 重写键盘抬起(松开)对应的监听方法 @Override public void keyReleased(KeyEvent e) { // 获取抬起(松开)的按键是哪一个，每个按键都有一个特定的 code 值// System.out.println("抬起：" + e.getKeyCode()); p1.minusDirection(e); } } // 双缓冲技术解决窗口闪烁问题 // 定义双缓冲技术所需要的窗口长宽属性，基于初始化游戏窗口的长宽而定 private Image offScreenImage = null; public void update(Graphics g){ if(offScreenImage == null){ // 这里是游戏窗口的宽度和高度 offScreenImage = this.createImage(Constant.GAME_WIDTH,Constant.GAME_HEIGHT); } Graphics gOff = offScreenImage.getGraphics(); paint(gOff); g.drawImage(offScreenImage,0,0,null); } public static void main(String[] args){ // 定义类对象，对象调用方法 MyGameFrame gameFrame = new MyGameFrame(); gameFrame.launchFrame(); }}
共有 7 个 java 文件，同时还有许多图片（可自行去截图寻找，比如尚学堂B站视频：链接地址）
7个Java文件分别为：MyGameFrame.java、Shell.java、Plane.java、GameObject.java、GameUtil.java、Explode.java、Constant.java
MyGameFrame.java
package come.jungle.plane;import java.awt.*;import java.awt.event.KeyAdapter;import java.awt.event.KeyEvent;import java.awt.event.WindowAdapter;import java.awt.event.WindowEvent;import java.util.Date;import static java.awt.Color.red;/*** 游戏主窗口* 使用 AWT 技术画出游戏主窗口*/// 让 MyGameFrame 继承 Frame，这样子可以在方法里使用 Frame 的所有方法public class MyGameFrame extends Frame { // 在窗口中加载 png 图片 // 创建图片类对象，利用 getImage 方法加载图片 Image planeImg = GameUtil.getImage("images/plane.png"); Image bg = GameUtil.getImage("images/bg.png"); // 创建一个 Plane 类的飞机对象，定义对应属性进行传入 Plane p1 = new Plane(planeImg,300,300,10); // 使用数组定义炮弹数组对象 Shell[] shells = new Shell[50]; // 爆炸 Explode explode; Date start = new Date(); // 游戏开始时间（以当前游戏运行时间作为一个开始） Date end; // 游戏结束时间（飞机碰撞炮弹时结束） long period = 0; // 游戏时长多少秒 // 重写 paint 方法 @Override public void paint(Graphics g) { // 把 g 当成是一支画笔来帮助实现绘制 // 利用 drawImage() 方法在窗口中画图 // 加载 bg 作为背景图片，从(0,0) 开始，占用宽高为 500，500 g.drawImage(bg,0,0,Constant.GAME_WIDTH,Constant.GAME_HEIGHT,null); // 调用计算游戏时长相关方法，计算游戏时间 drawtime(g); // 飞机对象调用方法中的画笔属性 g，自己画自己 p1.drawMyself(g); // 画炮弹 for (int i=0;i <shells.length;i++){ shells[i].drawMyself(g); // 碰撞检测，将所有的炮弹和飞机进行矩形碰撞检测，p1.getRect()表示为获取飞机对应的矩形 boolean peng = shells[i].getRect().intersects(p1.getRect()); if (peng){ p1.live = false; // 处理爆炸效果，默认炸了一次以后，炮弹再碰到就不炸了 if (explode==null){ // 当飞机被碰撞时，创建爆炸类的对象，并传入飞机当时的(x,y)坐标值 explode = new Explode(p1.x,p1.y); } // 画出爆炸效果系列图片 explode.drawMyself(g); } } } // 对计算游戏时长的代码进行封装 public void drawtime(Graphics g){ // 获取画笔传进来时的属性 Color c = g.getColor(); Font f = g.getFont(); g.setColor(Color.green); if (p1.live){ // 将计时功能文字画在游戏窗口中 period = (System.currentTimeMillis()-start.getTime())/1000; // 计算游戏时长，单位是毫秒，所以除以1000变成秒 g.drawString("坚持："+period+"秒",30,50); }else{ if (end==null){ // 只有第一次的时候才为null，后面再画的时候就不为 null 了 end = new Date(); period = (end.getTime() - start.getTime())/1000; // 计算游戏结束时的总时长 } // 设置字体样式 g.setColor(Color.red); g.setFont((new Font("微软雅黑",Font.BOLD,30))); g.drawString("最终游戏时长："+period+"秒",200,200); } // 还原画笔传进来时的属性 g.setColor(c); g.setFont(f); } // 定义一个初始化窗口 public void launchFrame(){ this.setTitle("The Plane War - 阿jun"); // 定义图形化界面右上角的标题 setVisible(true); // 定义窗口是否可见，默认是不可见，所以需要设置为 true 可见 // Constant.GAME_WIDTH 用于调用 Constant 类的 GAME_WIDTH 常量来使用 setSize(Constant.GAME_WIDTH,Constant.GAME_HEIGHT); // 设置窗口大小的高宽均为 500 setLocation(100,100); // 定义打开窗口的位置，程序坐标系默认以右上角为零点 // 增加关闭窗口的动作，通过方法重写和匿名内部类 this.addWindowListener(new WindowAdapter() { @Override public void windowClosing(WindowEvent e) { System.exit(0); // 让程序正常退出 } }); // 将重画窗口的线程类放入初始化窗口方法中，在程序初始化窗口时，就会调用这个方法，顺便调用线程类对象。 new PaintThread().start(); // 启动重画窗口的线程。 // 在程序初始化窗口时，启动键盘监听 this.addKeyListener(new KeyMonditor()); // 启动键盘监听 // 利用for循环初始化创建 50 个炮弹对象 for (int i=0;i<shells.length;i++){ shells[i] = new Shell(); } } /** * 定义一个重画窗口的线程类。 * 定义成内部类是为了方便直接使用窗口类的相关方法。 */ class PaintThread extends Thread{ // 重写 Thread类的 run() 方法 @Override public void run() { // 只要程序是活着的，就要求一直重画窗口，所以是 while(true) 死循环 while(true){ // repaint() 是外部类 Frame 的成员方法 repaint(); // 给程序设定一个重画时间间隔 try { // 程序执行到此处时，进度停 50 s Thread.sleep(50); // 1s=1000ms，即1s画20次（20*50=1000） } catch (InterruptedException e) { e.printStackTrace(); } } } } /** * 增加一个内部类，实现键盘的监听处理 * */ class KeyMonditor extends KeyAdapter{ // 重写方法，实现对按键状态(按下或抬起)的监听 // 重写键盘按下对应的监听方法 @Override public void keyPressed(KeyEvent e) { // 获取按下的按键是哪一个，每个按键都有一个特定的 code 值// System.out.println("按下：" + e.getKeyCode()); p1.addDirection(e); } // 重写键盘抬起(松开)对应的监听方法 @Override public void keyReleased(KeyEvent e) { // 获取抬起(松开)的按键是哪一个，每个按键都有一个特定的 code 值// System.out.println("抬起：" + e.getKeyCode()); p1.minusDirection(e); } } // 双缓冲技术解决窗口闪烁问题 // 定义双缓冲技术所需要的窗口长宽属性，基于初始化游戏窗口的长宽而定 private Image offScreenImage = null; public void update(Graphics g){ if(offScreenImage == null){ // 这里是游戏窗口的宽度和高度 offScreenImage = this.createImage(Constant.GAME_WIDTH,Constant.GAME_HEIGHT); } Graphics gOff = offScreenImage.getGraphics(); paint(gOff); g.drawImage(offScreenImage,0,0,null); } public static void main(String[] args){ // 定义类对象，对象调用方法 MyGameFrame gameFrame = new MyGameFrame(); gameFrame.launchFrame(); }}Shell.java
package come.jungle.plane;import java.awt.*;/** * 炮弹类 * */public class Shell extends GameObject{ // 继承了游戏物体根类的各个属性，比如坐标、速度、长宽。 double degree; // 定义炮弹的角度属性，炮弹沿着指定的角度飞行。 // 定义炮弹的初始构造器方法 public Shell(){ // 定义初始坐标 x = 200; y = 200; degree = Math.random()*Math.PI*2; // 生成一个任意角度数值// System.out.println(degree); width = 5; height = 5; speed = 5; } // 通过重写 drawMyself() 方法来画炮弹 @Override public void drawMyself(Graphics g) { // 定义炮弹的参数，画一个红色实心圆 Color c = g.getColor(); g.setColor(Color.yellow); g.fillOval((int)x,(int)y,width,height); g.setColor(c); // 用完以后，将画笔原本颜色还原。 // 根据自己的算法指定移动路径,speed是速度，利用角度进行x，y的距离计算 x += speed*Math.cos(degree); y += speed*Math.sin(degree); // 碰到边界改变方向，右上角为零点(0,0) // 由于炮弹有宽度，所以需要在计算碰撞边界时，去掉长宽值的影响 if (x < 0 || x > Constant.GAME_WIDTH - this.width){ degree = Math.PI-degree; } if (y < 40 || y > Constant.GAME_HEIGHT - this.height){ degree = -degree; } }}Plane.java
package come.jungle.plane;import java.awt.*;import java.awt.event.KeyEvent;public class Plane extends GameObject{ // 飞机方向的控制 boolean left,right,up,down; public boolean live = true; // 定义飞机是否存活的变量，默认为 true。 // 重写父类方法 @Override public void drawMyself(Graphics g) { // 如果飞机没有存活,live=false，就不画了 if (live){ super.drawMyself(g); // 飞机飞行的算法，可以自行设定// x += speed; if (left){ x -= speed; } if (right){ x += speed; } if (up){ y -= speed; } if (down){ y += speed; } } } // 定义飞机方向的方法 // 实现键盘按下对应的监听方法 public void addDirection(KeyEvent e){ switch(e.getKeyCode()){ case KeyEvent.VK_LEFT: left=true; break; case KeyEvent.VK_RIGHT: right=true; break; case KeyEvent.VK_UP: up=true; break; case KeyEvent.VK_DOWN: down=true; break; } } // 实现键盘松开的监听方法 public void minusDirection(KeyEvent e){ switch(e.getKeyCode()){ case KeyEvent.VK_LEFT: left=false; break; case KeyEvent.VK_RIGHT: right=false; break; case KeyEvent.VK_UP: up=false; break; case KeyEvent.VK_DOWN: down=false; break; } } // 定义构造方法 public Plane(Image img, double x, double y, int speed) { this.img = img; this.x = x; this.y = y; this.speed = speed; // 不传宽度高度时，就自动获取传入图片的宽度高度 this.width = img.getWidth(null); this.height = img.getHeight(null); }}GameObject.java
package come.jungle.plane;import java.awt.*;/** * 游戏物体的根类 * */public class GameObject { // 将这些属性定义好以后，之前定义的跟飞机相关的代码就可以去掉了 Image img; // 图片 double x,y; // 物体的坐标 int speed; // 物体移动的速度 int width,height; // 物体的宽度和高度 // 属性值可以通过初始化去获取，使用构造器去生成相关内容。 // 通过外部传入，对属性进行赋值。 public GameObject(Image img, double x, double y, int speed, int width, int height) { this.img = img; this.x = x; this.y = y; this.speed = speed; this.width = width; this.height = height; } // 定义一个方法来画自身 public void drawMyself(Graphics g){ // 传入double，参数值要求是int，所以需要int强制转型一下 g.drawImage(img,(int)x,(int)y,width,height,null); } // Plane 飞机子类继承 GameObject父类时，子类的无参构造器会调用父类的无参构造器，所以需定义一个GameObject父类的无参构造器 public GameObject(){} /** * 所有的物体都是矩形，当你获得对应的矩形时，就可以做一些相关的判断操作 * 返回物体对应的矩形区域，便于后续在碰撞检测中使用 * @retrun */ public Rectangle getRect(){ // 返回飞机位置的坐标位置，宽度高度 return new Rectangle((int)x,(int)y,width,height); }}GameUtil.java
package come.jungle.plane;import javax.imageio.ImageIO;import java.awt.*;import java.awt.image.BufferedImage;import java.io.IOException;import java.net.URL;/*** 游戏的工具类* 工具类中一般都是放置一些 static 方法*/public class GameUtil { // 构造器私有，防止别人创建本类对象（本项目可有可无） private GameUtil(){ } // 重点功能就是加载图片文件，并提供给外部引用 public static Image getImage(String path){ // 将对应字符串的路径传入，比如 /images/plane.png // 根据传入的字符串路径来加载对应的图片，加载以后形成一个图片对象返回 BufferedImage img = null; // 定义一个外部空对象 // 先获得当前类的一个 class 对象，然后获得一个类加载器，通过类加载器获得一个 resource 资源 URL u = GameUtil.class.getClassLoader().getResource(path); // 通过 ImageIO 调用 read() 方法，然后去读文件，会产生异常，需要去处理 try { img = ImageIO.read(u); } catch (IOException e) { e.printStackTrace(); } return img; } public static void main(String[] args) { // 测试程序是否异常，通过打印对象的方式，如果打印报异常或为空，则说明有异常 Image img = GameUtil.getImage("images/plane.png"); // 打印飞机图片对象，路径前方不加斜杠 System.out.println(img); }}Explode.java
package come.jungle.plane;import java.awt.*;/** * 爆炸类 **/public class Explode { // 定义爆炸位置 double x,y; // 创建一个数组存放爆炸相关图片 static Image[] imgs = new Image[16]; // 计数器：计算现在画了多少次了（确定图片次序） int count; // 静态初始化块初始化静态属性 static { // 通过 for 循环，将16个图片全部初始化完成。 for(int i=0;i<16;i++){ imgs[i] = GameUtil.getImage("images/Explode/e"+(i+1)+".png"); // 需要用数组对象去调用真正的方法，图片才会真正加载进来 imgs[i].getWidth(null); // 解决程序懒加载问题 } } // 定义方法来花自己 public void drawMyself(Graphics g){ if (count < 16){ g.drawImage(imgs[count],(int)x,(int)y,null ); count++; } } // 定义无参构造器 public Explode(){ } // 定义形参构造器 public Explode(double x, double y) { this.x = x; this.y = y; }}Constant.java
package come.jungle.plane;/** * 存放相关常量 * */public class Constant { // 定义双缓冲技术所需要的窗口长宽属性，基于初始化游戏窗口的长宽而定 // 游戏窗口的宽度 public static final int GAME_WIDTH = 500; // 游戏窗口的宽度 public static final int GAME_HEIGHT = 500;}