27.Java 飞机游戏小项目
游戏项目基本功能开发、飞机类设计、炮弹类设计、碰撞检测技术设计、爆炸效果的实现、其它小功能（游戏计时）。
开篇
- 游戏项目基本功能开发
- 飞机类设计
- 炮弹类设计
- 碰撞检测设计
- 爆炸效果的实现
- 其他功能
- 计时功能
游戏项目基本功能开发
这里将会一步步实现游戏项目的基本功能。
使用 AWT 技术画出游戏主窗口
AWT 和 Swing 是 Java 中常见的 GUI(图形用户界面)技术。
本次使用的是 AWT 技术。
首先是建立一个 Java 项目，并创建类 MyGameFrame。
代码示例：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 使用方法介绍
// 重写 paint 方法@Override
public void paint(Graphics g){
// paint 方法作用是：画出整个窗口及内部内容。被系统自动调用。
}
Graphics 画笔对象_画图形
代码示例：
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实现图片加载技术
游戏开发中，图片加载是最常见的技术。
在此处使用 ImageIO 类实现图片加载，并且为了代码的复用，将图片加载的方法封装到 GameUtil 工具类中，便于我们以后直接调用。
需要先将项目所需图片拷贝到项目的 src 下面，去建立新的文件夹 images 包用于存放所有图片。即在 src 下创建一个名为 images 的 package 包。
目前有两个文件：MyGameFrame.java 和 GameUtil.java
代码示例：GameUtil工具类：加载图片代码
可以将一些辅助性的工具方法放到 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 的实现（0.5版）
窗口中所有的对象(飞机、炮弹等等)都有很多共性:“图片对象、坐标位置、运行速度、宽度和高度”。
为了方便程序开发，我们需要设计一个GameObject类，它可以作为所有游戏物体的父类，方便我们编程。
代码示例：MyGameFrame.java的修改和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);
}
}
设计飞机类 Plane（0.5版本）：创建多个飞机
有了 GameObject 这个父类，设计飞机类只需要简单继承即可。
重新设计了飞机类，通过继承 GameObject 父类以后，重写构造方法，实现飞机的移动。
代码示例：增加了一个Plane飞机类，修改了 GameObject.java 和 MyGameFrame.java
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();
}
}
飞机类设计（0.6版）
键盘控制原理
重点使用键盘进行交互。
使用键盘操控游戏物体，通过鼠标或其他，我们只需要通过相关API的帮助即可轻松实现。
使用面向对象的思想，实现键盘控制。
键盘控制原理：
键盘和程序交互时，每次按下键、松开键都会触发相应的键盘事件，事件的信息都封装到了KeyEvent对象中。
为了识别按下的键是哪个键，系统对键盘所有按键做了编号，每个按键都对应相应的数字。
比如∶回车键对应数字10，空格键对应数字32等。这些编号，我们都可以通过KeyEvent对象来查询，KeyEvent.VK_ENTER实际就是存储了数字10。
代码示例：Plane.java 和 MyGameFrame.java
将飞机的键盘控制代码，放入了 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();
}
}
炮弹类设计（0.7版）
可更深入了解构造器的用法以及容器的用法。
炮弹类基本设计
炮弹类我们用实心的黄色椭圆实现，不再加载新的图片。
我们的逻辑是在窗口固定位置(200,200)处生成炮弹，炮弹方向是随机的，并且遇到边界会反弹。
需要考虑的是炮弹的长宽对于碰撞边界值计算的影响。
使用容器或数组产生多发炮弹，本次用的是容器。
代码示例：新增了一个炮弹类 Shell.java
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();
}
}
碰撞检测技术（0.8版）
游戏中，碰撞是遇到最频繁的技术。
很多游戏引擎内部已经做了碰撞检测处理,我们只需调用即可。
矩形碰撞原理
游戏中，多个元素是否碰到一起，实际上，通常是用“矩形检测”原理实现的。
游戏中所有的物体都可以抽象成“矩形”，我们只需判断两个矩形是否相交即可。对于一些复杂的多边形、不规则物体，实际上是将他分解成多个矩形，继续进行矩形检测。|
Java的 API中，为我们提供了Rectangle类来表示矩形相关信息，并且提供了intersects)方法，直接判断矩形是否相交。
代码示例：更改了两个文件，MyGameFrame.java 和 Plane.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 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);
}
}
爆炸效果的实现（0.9版本）
在 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.0版）
基本功能实现以后，增加一些锦上添花的功能。
比如：游戏计时功能、全网排名等。
计时功能
我们希望在玩游戏时，增加计时功能，可以清晰的看到自己玩了多长时间,增加刺激性。
这个功能的核心有两点:
1.时间计算：当前时刻-游戏结束的时刻。
2．显示时间到窗口。
代码示例：只修改了 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 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;
}
最终效果
以上是 27.Java 飞机游戏小项目 的全部内容， 来源链接： utcz.com/z/394973.html
