FlyBird(飞翔的小鸟)Java小游戏-阿里云开发者社区

FlyBird(飞翔的小鸟)Java小游戏

游戏简介

《flappy bird》是一款由来自越南的独立游戏开发者Dong Nguyen所开发的作品，游戏于2013年5月24日上线，并在2014年2月突然暴红。2014年2月，《Flappy Bird》被开发者本人从苹果及谷歌应用商店（Google Play）撤下。2014年8月份正式回归App Store，正式加入Flappy迷们期待已久的多人对战模式。游戏中玩家必须控制一只小鸟，跨越由各种不同长度水管所组成的障碍。

在《FlappyBird》这款游戏中，玩家只需要用一根手指来操控，点击触摸屏幕，小鸟就会往上飞，不断的点击就会不断的往高处飞。放松手指，则会快速下降。所以玩家要控制小鸟一直向前飞行，然后注意躲避途中高低不平的管子。

1、在游戏开始后，点击屏幕，要记住是有间歇的点击屏幕，不要让小鸟掉下来。

2、尽量保持平和的心情，点的时候不要下手太重，尽量注视着小鸟。

3、游戏的得分是，小鸟安全穿过一个柱子且不撞上就是1分。当然撞上就直接挂掉，只有一条命。

上面简介是这款游戏的原始版本的简介，本文主要是根据这款游戏，进行逆向工程把这款游戏复刻一遍。

游戏展示

按键盘的上下键来控制小鸟上下移动，碰到管道会大量扣血，但是没有的时候会缓慢回血。

当生命值不是正数的时候，就结束游戏，按下空格可以重新开始。

我的代码如下

我的gitee地址：https://gitee.com/geek-li-hua/small-game

代码讲解

文件结构：

首先是util包，这个包中放置的就是一些工具类，这里面存放的就是整个项目需要用到的各种常数,希望修改游戏的各种初始大小的话，那么可以通过修改这个类中的各个常数。

Constant类

package com.bird.util;
import java.awt.*;
public class Constant {
    // 窗口的大小
    public static final int FRAM_WIDTH=600;
    public static final int FRAM_HEIGHT=500;
    // 窗口的标题
    public static final String FRAM_TITLE="Fly Bird";
    // 窗口的初始化位置
    public static final int FRAM_X=200;
    public static final int FRAM_Y=200;
    // 图片路径
    public static final String BK_IMG_PATH = "img/bird_bk.png";
    // 游戏背景颜色
    public static final Color BK_COLOR = new Color(0x4B4CF); // 浅蓝色的背景
    // 小鸟的图片资源
    public static final String[] BIRD_IMG={"img/bird_normal.png", "img/bird_up.png","img/bird_down.png"};
    // 障碍物图片资源
    public static final String [] BARRIER_IMG_PATH={
            "img/barrier.png","img/barrier_up.png","img/barrier_down.png"};
}

GameUtil

一个游戏的工具类。

package com.bird.util;
import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.FileInputStream;
import java.io.IOException;
public class GameUtil {
    public static BufferedImage loadBufferedImage(String imgPath){
        try{
            return ImageIO.read(new FileInputStream(imgPath));
        } catch (IOException e){
            e.printStackTrace();
        }
        return null;
    }
}

GameApp

项目的启动类，这个类通过创建GameApp对象，来启动游戏。

package com.bird.app;
import com.bird.main.GameFrame;
public class GameApp {
    public static void main(String[] args) {
        new GameFrame();
    }
}

Barrier

在Barrier类中，是创造游戏中的各种障碍物的，里面拥有着详细的注释，通过注释的内容，用户可以自定义里面的某些内容。

package com.bird.main;
import com.bird.util.Constant;
import com.bird.util.GameUtil;
import java.awt.*;
import java.awt.image.BufferedImage;
/*
* 障碍物类
* */
public class Barrier {
    // 矩形参数
    private Rectangle rect;
    // 障碍物是否可以移动
    private boolean mob = true;
    // 障碍物的移动速度
    private  int speed = 3;
    // 障碍物需要的三个图片
    private  static BufferedImage[] imgs;
    // 障碍物状态
    private boolean visible;
    // 静态代码块初始化成员
    static {
        final int COUNT = 3;
        // 类加载的时候将三个图片初始化
        imgs = new BufferedImage[COUNT];
        for (int i = 0; i < COUNT; i++) {
            imgs[i] = GameUtil.loadBufferedImage(Constant.BARRIER_IMG_PATH[i]);
        }
    }
    // 位置
    private int x, y;
    // 宽度和高度
    private  int width, height;
    // 障碍物的类型
    private int type;
    public static final int TYPE_TOP_NORMAL = 0;
    public static final int TYPE_BOTTOM_NORMAL = 2;
    // 障碍物悬空
    public static final int TYPE_HOVER_NORMAL = 4;
    // 障碍物可以移动的状态
    public static final int TYPE_MOBILE = 6;
    // 获取障碍物的宽度和高度
    public static final int BARRIER_WIDTH = imgs[0].getWidth();
    public static final int BARRIER_HEIGHT = imgs[0].getHeight();
    public static final int BARRIER_HEAD_WIDTH = imgs[1].getWidth();
    public static final int BARRIER_HEAD_HEIGHT = imgs[1].getHeight();
    // 构造器
    public Barrier() {
        // 初始化矩形参数
        rect = new Rectangle();
    }
    // 宽度都是固定的，只需要控制障碍物的高度就可以了
    public Barrier(int x, int y, int height, int type) {
        this.x = x;
        this.y = y;
        this.width = BARRIER_WIDTH;
        this.height = height;
        this.type = type;
    }
    // 根据不同的类型绘制障碍物
    public void draw(Graphics g){
        switch ((type)){
            case TYPE_TOP_NORMAL:
                drawTopMormal(g);
                break;
            case TYPE_BOTTOM_NORMAL:
                drawNormalTop(g);
                break;
            case TYPE_HOVER_NORMAL: // 中间的悬空障碍物
                drawHoverNormal(g);
                break;
            case TYPE_MOBILE: // 障碍物可移动
                drawMobile(g);
                break;
        }
    }
    // 绘制从上到下的障碍物
    public void drawTopMormal(Graphics g){
        // 求出所需要的障碍物的块数
        // 公式：（当前障碍物的高度-障碍物的头部）/每一块的高度 然后 + 1
        int count = (height - BARRIER_HEAD_HEIGHT)/BARRIER_HEIGHT + 1;
        // for循环绘制障碍物
        for (int i = 0; i < count; i++) {
            g.drawImage(imgs[0], x, y + i * BARRIER_HEIGHT, null);
        }
        // 绘制头
        int y = height - BARRIER_HEAD_HEIGHT;
        g.drawImage(imgs[2], x - (BARRIER_HEAD_WIDTH - BARRIER_WIDTH) / 2, y, null);
        // 给障碍物添加向左的速度
        x -= speed;
        if (x < -50){ // 当障碍物越界了
            visible = false;  // 状态为false
        }
        // 调用矩形
        rect(g);
    }
    /*
    * 绘制障碍物碰撞矩形
    * */
    public void rect(Graphics g){
        int x1 = this.x;
        int y1 = this.y;
        int w1 = imgs[0].getWidth();
//        g.setColor(Color.blue);
//        g.drawRect(x1, y1, w1, height);
        // 设置矩形参数
        setRectangle(x1, y1, w1, height);
    }
    /*
    * 障碍物的碰撞矩形参数
    * */
    public void setRectangle(int x, int y, int width, int height){
        rect.x = x;
        rect.y = y;
        rect.width = width;
        rect.height = height;
    }
    // 获取矩形
    public Rectangle getRect() {
        return rect;
    }
    //绘制从下向上的障碍物
    private void drawNormalTop(Graphics g) {
        //求出所需要障碍物的块数
        int count = height/BARRIER_HEIGHT+1;
        //for循环绘制障碍物
        for (int i = 0; i < count; i++) {
            g.drawImage(imgs[0], x, Constant.FRAM_HEIGHT-i*BARRIER_HEIGHT,  null);
        }
        //绘制头
        int y = Constant.FRAM_HEIGHT-height;
        g.drawImage(imgs[1], x - (BARRIER_HEAD_WIDTH - BARRIER_WIDTH) / 2, y, null);
        x -= speed;
        if (x < -50){ // 当障碍物越界了
            visible = false;  // 状态为false
        }
        // 调用矩形
        rect(g);
    }
    //绘制中间的障碍物
    private void drawHoverNormal(Graphics g) {
        //求出所需要障碍物的块数
        int count = (height - BARRIER_HEAD_HEIGHT)/BARRIER_HEIGHT;
        // 绘制上头
        g.drawImage(imgs[1], x, y, null);
        //for循环绘制障碍物
        for (int i = 0; i < count; i++) {
            g.drawImage(imgs[0], x, y+BARRIER_HEAD_HEIGHT + i * BARRIER_HEIGHT,  null);
        }
        // 给障碍物绘制矩形外边
        rect(g);
        //绘制下头
        int yll = y + height - BARRIER_HEAD_HEIGHT;
        g.drawImage(imgs[2], x, yll, null);
        x -= speed;
        if (x < -50){ // 当障碍物越界了
            visible = false;  // 状态为false
        }
    }
    // 绘制可以移动的障碍物
    private void drawMobile(Graphics g) {
        //求出所需要障碍物的块数
        int count = (height - BARRIER_HEAD_HEIGHT)/BARRIER_HEIGHT;
        // 绘制上头
        g.drawImage(imgs[1], x, y, null);
        //for循环绘制障碍物
        for (int i = 0; i < count; i++) {
            g.drawImage(imgs[0], x, y+BARRIER_HEAD_HEIGHT + i * BARRIER_HEIGHT,  null);
        }
        // 给障碍物绘制矩形外边
        rect(g);
        //绘制下头
        int yll = y + height - BARRIER_HEAD_HEIGHT;
        g.drawImage(imgs[2], x, yll, null);
        x -= speed;
        if (x < -50){ // 当障碍物越界了
            visible = false;  // 状态为false
        }
        // 让物体移动
        if (mob){  // 让障碍物向上移动
            y += 5;
            if (y >= 250){
                mob = false;
            }
        }
        else{ // 让障碍物向下移动
            y -= 5;
            if (y <= 100){
                mob = true;
            }
        }
    }
    // 判断什么时候绘制下一组障碍物
    public boolean isInFrame(){
        return 600 - x > 150;
    }
    public int getX() {
        return x;
    }
    public void setX(int x) {
        this.x = x;
    }
    public int getY() {
        return y;
    }
    public void setY(int y) {
        this.y = y;
    }
    public int getHeight() {
        return height;
    }
    public void setHeight(int height) {
        this.height = height;
    }
    public int getType() {
        return type;
    }
    public void setType(int type) {
        this.type = type;
    }
    public boolean isVisible() {
        return visible;
    }
    public void setVisible(boolean visible) {
        this.visible = visible;
    }
}

Barrierpool

在真实的游戏中，我们不仅仅是需要考虑，游戏的可以运行，对于游戏的设计者我们还需要考虑内存大小问题，是否会发生内存泄露或者内存溢出等等问题，我们在创造障碍物对象的时候，会不断的new对象，每一次new的过程就是一次新的内存申请，虽然最开始的时候这个占用的内存没有什么明显的感觉，但是当玩的时间久了，这个运行内存会越来越大，直到游戏崩溃，我见过很多非科班出身的游戏开发者，在内存及时处理这块往往都没有做，导致了，游戏玩着玩着就崩溃了。

package com.bird.main;
import java.util.ArrayList;
import java.util.List;
/*
* 为了避免反复的创建和销毁对象， 使用对象池来提前创建好一些对象
* 使用的时候从池中获得，使用完毕后，归还
* */
public class Barrierpool {
    // 用于管理池中所有对象的容器
    private  static List<Barrier> pool = new ArrayList<>();
    // 池中初始的对象个数
    public static final int initCount = 16;
    // 对象池中的最大个数
    public static final int maxCount = 20;
    static {
        // 初始化池中的对象
        for (int i = 0; i < initCount; i++) {
            pool.add(new Barrier());
        }
    }
    /*
    * 从池中获取一个对象
    *
    * */
    public static Barrier getPool(){
        int size = pool.size();
        // 如果池子中有对象才可以拿
        if(size > 0){
            // 移除并返回对象
            System.out.println("拿走一个");
            return pool.remove(size - 1);
        }
        else {
            // 池中没有对象了 只能new
            System.out.println("新的对象");
            return new Barrier();
        }
    }
    /*
    * 将对象归还容器中
    * */
    public static void setPool(Barrier barrier){
        if (pool.size() < maxCount){
            pool.add(barrier);
            System.out.println("容器归还了");
        }
    }
}

Bird

这个是鸟对象的类，如何创建一只小鸟，和这个小鸟的个性属性值怎么设置，这个在这个类里面我都通过了详细的注释进行了说明。

package com.bird.main;
import com.bird.util.Constant;
import com.bird.util.GameUtil;
import java.awt.*;
import java.awt.image.BufferedImage;
/*
* 小鸟类
* */
public class Bird {
    // 小鸟矩形对象
    private Rectangle rect;
    // 小鸟加速度
    private int acceleration;
    // 小鸟的命数
    private int bird_energe; // 默认1000滴血
    private int bird_default = 1000; // 初始值
    public int getBird_default() {
        return bird_default;
    }
    public void setBird_default(int bird_default) {
        this.bird_default = bird_default;
    }
    public int getBird_energe() {
        return bird_energe;
    }
    public void setBird_energe(int bird_energe) {
        this.bird_energe = bird_energe;
    }
    // 小鸟的生命 默认是存活
    public boolean life = true;
    // 存放小鸟图片
    private BufferedImage[] images;
    // 鸟的图片数量
    public static final int BIRD_IMG_COUNT = 3;
    // 鸟的状态
    private int state;
    public static final int STATE_NORMAR = 0; // 正常飞
    public static final int STATE_UP = 1; // 向上飞
    public static final int STATE_DOWN = 2; // 向下飞
    // 小鸟位置
    private int x = 200, y = 200;
    // 小鸟移动方向 上下
    public boolean up = false, down = false; // 默认不上不下
    // 小鸟移动速度
    private int speed = 4;
    // 构造方法中初始化资源
    public Bird(){
        // 创建小鸟图片数组
        images = new BufferedImage[BIRD_IMG_COUNT];
        for (int i = 0; i < BIRD_IMG_COUNT; i++) {
            // 加载每一张图片
            images[i] =GameUtil.loadBufferedImage(Constant.BIRD_IMG[i]);
        }
        int w = images[0].getWidth();
        int h = images[0].getWidth();
        rect = new Rectangle(w, h);
        bird_energe = getBird_default();
    }
    // 绘制小鸟
    public void draw(Graphics g){
        // 导入小鸟飞翔组件
        flyLogic();
        // 时刻绘制小鸟的图片
        g.drawImage(images[state], x, y, null);
        // 绘制小鸟的矩形
//        g.drawRect(x, y, (int)rect.getWidth(), rect.height);
        rect.x = this.x;
        rect.y = this.y;
    }
    // 控制小鸟移动方向
    public void flyLogic(){
        if (up){ // 判断鸟垂直方向怎么运动
            acceleration --;
            y += acceleration;
            if (acceleration < -10){ // 越往上扑腾越慢
                acceleration = -10;
            }
            if (y < 20){ // 到达底部边界了
                y = 20;
                acceleration = 0; // 加速度设置为0防止越界
            }
        }
        if (!up){ // 往下走
            acceleration ++; // 越落地越快
            y += acceleration;
            if (acceleration > 10){ // 最高10
                acceleration = 10;
            }
            if (y > 475){ // 到达顶部边界了
                y = 475;
                acceleration = 0; // 加速度设置为0防止越界
            }
        }
    }
    // 通过传入参数来判断小鸟垂直飞翔的方向
    public void fly(int fly){
        switch (fly){
            case 1: // 如果是1的话那么就是往上飞
                state=STATE_UP;
                up = true;
                break;
            case 5: // 如果是5的话往下飞
                state=STATE_DOWN;
                up = false;
                break;
        }
    }
    // 获取矩形参数
    public Rectangle getRect() {
        return rect;
    }
    /*
    * 重新绘制小鸟位置
    * */
    public void restartDraw(){
        life = true;
        x = 200;
        y = 200;
    }
}

Cloud

Cloud类云彩类，云彩会有哪些属性，在这个类中都会体现出来，至于云彩的移动效果是怎么做出来的，原理为给云彩一个向后的速度，这样就可以制作出云彩在动的效果了，想要给游戏更多的可扩展性，不如给游戏加上导弹或者什么道具，本质上和做云彩是一个道理的。

package com.bird.main;
import java.awt.*;
import java.awt.image.BufferedImage;
/*
* 云彩类
* */
public class Cloud {
    // 云彩图片
    private BufferedImage img;
    // 云彩速度
    private int speed;
    // 云彩位置
    private  int x, y;
    // 有参和无参构造方法
    public Cloud() {
    }
    public Cloud(BufferedImage img, int speed, int x, int y) {
        this.img = img;
        this.speed = speed;
        this.x = x;
        this.y = y;
    }
    // 绘制方法
    public void draw(Graphics g){
        // 给云一个向后的速度
        x-= speed;
        g.drawImage(img, x, y, null);
    }
    /*
    * 用于判断云彩是否飞出屏幕以外
    * */
    public boolean isOutFrame(){
        if (x < -100){
            return true;
        }
        return false;
    }
}

GameBackGround

背景类，在这个类中会初始化很多游戏的背景相关的图片等等属性。

package com.bird.main;
import com.bird.util.Constant;
import com.bird.util.GameUtil;
import java.awt.*;
import java.awt.image.BufferedImage;
/*
* 游戏背景类
* */
public class GameBackGround {
    //背景需要的资源图片
    private BufferedImage bkimg;
    // 构造器初始化资源
    public GameBackGround(){
            bkimg = GameUtil.loadBufferedImage(Constant.BK_IMG_PATH);
    }
    // 绘制图片
    public void draw(Graphics g){
        // 填充背景颜色
        g.setColor(Constant.BK_COLOR);
        // 画在窗口
        g.fillRect(0, 0, Constant.FRAM_WIDTH, Constant.FRAM_HEIGHT);
        // 设置背景为黑色
        g.setColor(Color.black);
        // 获取图片的高度和宽度
        int height = bkimg.getHeight();
        int width = bkimg.getWidth();
        // 循环次数
        int count = Constant.FRAM_WIDTH/width + 1;
        for (int i = 0; i < count; i++) {
            g.drawImage(bkimg, width * i, Constant.FRAM_HEIGHT-height, null);
        }
    }
}

GameBarrierLayer

这个类就是如何布置游戏中产生的障碍物。

package com.bird.main;
import com.bird.util.Constant;
import java.awt.*;
import java.io.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
/*
* 游戏中障碍物层类
* */
public class GameBarrierLayer {
    // 游戏时间
    private GameTime gameTime;
    // 最高成绩的文本
    private int txt;
    // 随机种子
    private Random random = new Random();
    // 障碍物的集合
    private List<Barrier> barriers;
    public GameBarrierLayer(){
        // 初始化障碍物
        barriers = new ArrayList<>();
        // 初始化时间
        gameTime = new GameTime();
    }
    // 绘制障碍物
    public void draw(Graphics g, Bird bird) throws IOException {
//        Barrier barrier = new Barrier(200, 0, 200, 0);
//        barriers.add(barrier);
//        barriers.get(0).draw(g);
//
//        Barrier barrier1 = new Barrier(300, 0, 200, 2);
//        barriers.add(barrier1);
//        barriers.get(1).draw(g);
        // 画障碍物
        for (int i = 0; i < barriers.size(); i++) {
            Barrier barrier = barriers.get(i);
            if (barrier.isVisible()){ // 如果对象存在
                barrier.draw(g);     // 画出对象
            }
            else {
                // 如果不存在
                Barrier remove = barriers.remove(i);
                // 设置对象
                Barrierpool.setPool(remove);
                i --;
            }
        }
        // 判断障碍物和小鸟是否撞上了
        collideBird(bird);
        // 加入逻辑控制组件
        logic(g, bird);
    }
    // 逻辑组件
    public void logic(Graphics g, Bird bird) throws IOException {
        // 小鸟当前生命值
        g.setColor(Color.red);
        g.setFont(new Font("微软雅黑", 1, 20));
        g.drawString("生命值：" + bird.getBird_energe(),370, 50);
        if (barriers.size() == 0){
            ran();
            // 游戏刚开始的时候
            gameTime.begin(); // 时间开始
//            Barrier top = new Barrier(600, 0, numberTop, 0);
//            barriers.add(top);
//            Barrier down = new Barrier(600, 500-numberDown, numberDown, 2);
//            barriers.add(down);
            insert(600, 0, numberTop, 0);
            insert(600, Constant.FRAM_HEIGHT -numberDown, numberDown, 2);
        }
        else
        {
            // 计算时间差
            long differ = gameTime.differ();
            // 设置时间样式
            g.setColor(Color.white);
            g.setFont(new Font("微软雅黑", 1, 20));
            g.drawString("坚持了"+ differ + "秒", 30, 50);
            // 显示最高成绩记录
            txt = getText();
            if (differ <= txt)
            {
                g.drawString("最高成绩：" + txt, 200, 50);
            }
            else
            {
                setText(String.valueOf(differ));
                g.drawString("最高成绩：" + getText(), 200, 50);
            }
            // 判断最后一个障碍物是否完全进入屏幕内
            Barrier last = barriers.get(barriers.size() - 1);
            if (last.isInFrame()){
                ran();
//                Barrier top = new Barrier(600, 0, numberTop, 0);
//                barriers.add(top);
//                Barrier down = new Barrier(600, 500-numberDown, numberDown, 2);
//                barriers.add(down);
                if (number < 50){
                    insert(600, 32, 440, 4);
                }
                else if (number > 250) // 绘制可以移动的障碍物
                {
                    insert(600, 125, 200, 6);
                }
                else
                {
                    insert(600, 0, numberTop, 0);
                    insert(600, Constant.FRAM_HEIGHT -numberDown, numberDown, 2);
                }
            }
        }
    }
    /*
    * 用于从池中获取对象，并把参数封装成barrier，存入barriers数组中
    *
    * */
    public void insert(int x, int y, int height, int type){
        // 获取一个新的障碍物
        Barrier top = Barrierpool.getPool();
        // 设置参数并加入到障碍物数组里面
        top.setX(x);
        top.setY(y);
        top.setHeight(height);
        top.setType(type);
        // 初始设置对象状态为true
        top.setVisible(true);
        barriers.add(top);
    }
    // 上方障碍物的高度
    private int numberTop;
    // 下方障碍物的高度
    private int numberDown;
    // 障碍物的种类数量
    private int number;
    // 产生两个100~500之间的随机高度
    public void ran(){
        numberTop = random.nextInt(400) + 100;
        numberDown = random.nextInt(400) + 100;
        number = random.nextInt(500);
        if (numberTop + numberDown > 450){
            ran(); // 如果两个管道的高度相加大于450 就代表两个管道重合了
            // 然后重新生成
        }
    }
    /*
    * 判断障碍物和小鸟是否发生碰撞
    * */
    public boolean collideBird(Bird bird){
        for (int i = 0; i < barriers.size(); i++) {
            Barrier barrier = barriers.get(i);
            // 判断矩形是否相交
            if (barrier.getRect().intersects(bird.getRect())){
                System.out.println("撞上了");
                bird.setBird_energe(bird.getBird_energe() - random.nextInt(60)); // 随机扣除0~100点血
                if (bird.getBird_energe() <= 0){
                    bird.life = false; // 小鸟装上之后就g了
                }
                return true;
            }
            else
            {
                if (bird.getBird_energe() == bird.getBird_default()){
                }
                else {
                    // 回血功能
                    bird.setBird_energe(bird.getBird_energe() + 1);
                }
            }
        }
        return false;
    }
    /*
    * 用于清空障碍物的池子
    * */
    public void restart(){
        barriers.clear();
    }
    File file = new File("record/game.txt");
    /*
    * 用于得到文件中的数据
    * */
    public int getText() throws IOException {
        BufferedReader in = null;
        try {
            in = new BufferedReader(new FileReader(file));
        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        }
        int read = Integer.parseInt(in.readLine()); // 把获取的字符串转换为int
        in.close();
        return read;
    }
    /*
    * 用于存储数据
    * */
    public void setText(String str) throws IOException {
        FileWriter fileWriter = null;
        fileWriter = new FileWriter(file);
        // 向文件中写数据
        fileWriter.write(str);
        fileWriter.close();
    }
}

GameFrame

游戏框架类，在这个类中就把所有创建好了的类，Bird,GameBackGroud对象等等拼接组装到了一个框架中了。

public class GameFrame extends Frame { // 继承框架类
    // 实例化gamebackGround类
    private GameBackGround gameBackGround;
    // 实例化Bird类
    private Bird bird;
    // 实例化GameFrontGround类
    private GameFrontGround gameFrontGround;
    // 实例化GameBarrierLayer类
    private GameBarrierLayer gameBarrierLayer;
    // 存放图片的集合
    private BufferedImage buffimg = new BufferedImage(Constant.FRAM_WIDTH, Constant.FRAM_WIDTH, BufferedImage.TYPE_4BYTE_ABGR);
    // 构造方法中初始化一些参数
    public GameFrame(){
        // 窗口是否可见
        setVisible(true); // 设置窗口可见
        // 窗口的大小
        setSize(Constant.FRAM_WIDTH, Constant.FRAM_HEIGHT);
        // 窗口的标题
        setTitle(Constant.FRAM_TITLE);
        // 窗口的初始化位置
        setLocation(Constant.FRAM_X, Constant.FRAM_Y);
        // 窗口的大小不可改变
        setResizable(false);
        // 窗口的关闭事件
        addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                System.exit(0); // 结束程序 返回0
            }
        });
        // 初始化背景
        initGamg();
        // 启动线程
        new run().start();
        // 添加按键监听
        addKeyListener(new KeyAdapter() {
            @Override
            public void keyPressed(KeyEvent e) {
                // 按下向上键的话 然后向上飞
                add(e);
            }
            @Override
            public void keyReleased(KeyEvent e) {
                // 松开向上键的话 就是往下飞
                minu(e);
            }
        });
    }
    // 初始化对象
    public void initGamg(){
        // 加载背景图片
        gameBackGround = new GameBackGround();
        // 加载小鸟图片
        bird = new Bird();
        // 加载前景
        gameFrontGround = new GameFrontGround();
        // 加载障碍物
        gameBarrierLayer = new GameBarrierLayer();
    }
    // 创建线程
    class run extends Thread{
        @Override
        public void run(){
            // 弄一个循环 持续的调用下面的方法
            while(true){
                repaint();
                try {
                    // 设置每33毫秒刷新一次
                    Thread.sleep(33);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }
    // 重写update方法时刻更新背景
    @Override
    public void update(Graphics g) {
        if (bird.life){
            // 得到图片画笔
            Graphics graphics = buffimg.getGraphics();
            // 把画笔存入到背景和小鸟对象中
            gameBackGround.draw(graphics);
            bird.draw(graphics);
            // 绘制前景
            gameFrontGround.draw(graphics);
            // 绘制障碍物
            try {
                gameBarrierLayer.draw(graphics, bird);
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
            // 一次性的将图片绘制到屏幕
            // 通过这个方法可以解决屏幕闪烁问题
            g.drawImage(buffimg, 0, 0, null);
        }
        else {
            String over = "游戏结束";
            g.setColor(Color.red);
            // 设置字体属性
            g.setFont(new Font("微软雅黑", 1, 60));
            g.drawString(over, 120, 250);
            // 重开提示词
            String reset = "Space Reset Game";
            g.drawString(reset, 25, 350);
        }
    }
    // 按键 让小鸟往上飞
    public void add(KeyEvent e){
        // 通过按键事件e来获取按键的值
        // 判断按键的值
        switch (e.getKeyCode()){
            // 如果是向上的按键的话 那么就传值1
            case KeyEvent.VK_UP:
                bird.fly(1);
                break;
            case KeyEvent.VK_SPACE:
                if (bird.life == false){ // 当小鸟死了的时候按下空格键重开
                    restart();
                }
                break;
        }
    }
    // 抬键 让小鸟往下飞
    public void minu(KeyEvent e){
        // 通过按键事件e来获取按键的值
        // 判断按键的值
        switch (e.getKeyCode()){
            // 这里是还是up因为是松开向上键的事件
            case KeyEvent.VK_UP:
                bird.fly(5);
                break;
        }
    }
    /*
    * 重置游戏
    * */
    public void restart(){
        gameBarrierLayer.restart(); // 清空障碍物
        bird.restartDraw(); // 重绘小鸟
        bird.setBird_energe(bird.getBird_default());
    }
}

GameFrontGround

游戏前景类，这个类就是用于制作游戏的一些前景，比如就是我们最开始的Cloud类，云类这些东西就是游戏的前景。

import com.bird.util.GameUtil;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
/*
* 游戏的前景类
* */
public class GameFrontGround {
    // 云彩的个数
    public static final int CLOUND_COUNT = 2;
    // 存放云彩的容器
    private List<Cloud> clouds;
    // 云彩的飞行速度
    public static final int CLOUND_SPEED = 9;
    // 使用得到的图片资源
    private BufferedImage[] img;
    // 用于产生随机数
    private Random random;
    // 构造器初始化数据
    public GameFrontGround() {
        clouds = new ArrayList<>();
        img = new BufferedImage[CLOUND_COUNT];
        // 容器中添加云彩图片
        for (int i = 0; i < CLOUND_COUNT; i++) {
            img[i] = GameUtil.loadBufferedImage("img/cloud" + i + ".png");
        }
        // 用于产生随机的云彩
        random = new Random();
    }
    // 绘制云彩
    public void draw(Graphics g){
        logic(); // 载入逻辑组件
        // 绘制云彩
        for (int i = 0; i < clouds.size(); i++) {
            clouds.get(i).draw(g);
        }
    }
    /*
    * 用于控制云彩的个数
    * */
    private void logic(){
        if ((int)(500 * Math.random()) < 20){ // 这里就是控制云彩产生的频率的判断 可以自定设置 通过修改if中的表达式
            // 创建云对象
            // 我们有两张云朵的图片 随机产生，然后再试速度 位置的话 就是 从最右边开始生成 上下的话位置随机
            Cloud cloud = new Cloud(img[random.nextInt(CLOUND_COUNT)], CLOUND_SPEED, 600, random.nextInt(150));
            // 向容器中添加云彩
            clouds.add(cloud);
        }
        for (int i = 0; i < clouds.size(); i++) {
            Cloud cloud = clouds.get(i);
            if (cloud.isOutFrame()){ // 如果云出界了
                clouds.remove(i);
                i -- ;
                System.out.println("云被移除" + cloud);
            }
        }
    }
}

GameTime

游戏的时间类，这类的目的是记录游戏的时间，开始时间，结束时间，时间差，这个的可以用来记录每次小鸟的游戏记录。

package com.bird.main;
/*
* 游戏计时器
* */
public class GameTime {
    // 开始时间
    private long beginTime;
    // 结束时间
    private  long endTime;
    // 时间差
    public long differ;
    public GameTime(){}
    public void begin(){
        beginTime = System.currentTimeMillis(); // 系统当前时间
    }
    // 开始与结束相差的时间
    public long differ(){
        endTime =  System.currentTimeMillis(); // 系统当前时间
        return differ = (endTime - beginTime) / 1000;
    }
}

如果大家觉得有用的话，可以关注我下面的微信公众号，极客李华，我会在里面更新更多行业资讯，企业面试内容，编程资源，如何写出可以让大厂面试官眼前一亮的简历等内容，让大家更好学习编程，我的抖音，B站也叫极客李华。

FlyBird(飞翔的小鸟)Java小游戏