注：学习了java基础后，做出来的一个小作品，可以用来巩固学习

概述:

飞翔的小鸟能够作为Java基础的收官之作，包涵了Java很多的基础知识，在学习完Java基础后，尝试编写一些东西，能够起到很好的查漏补缺的作用。这里实现了Java小游戏飞翔的小鸟的一些基本功能。另外，随着学习水平的提高，以后也有可能会进行不断地改进。

同时，以下代码我也会尽我所能做好注释解释清楚

编写要求：

Java基础知识的掌握，Java的三大特性（多态，封装，继承），窗口的绘制，画笔的使用，io流，异常处理，数组，集合等

概述:

编写要求：

游戏思路：

具体分析：

app包：

GameApp类：实现游戏的启动运行

main包：

GameFrame类：游戏主窗口类

Bird类：编写与小鸟有关的内容的类

Coloud类：

Barrier类：

GameBarrierLayer类：

Barrierpool类：

GameFrontGround类：

GameTime类：

Music类：

util包：

游戏共用到了三个包app包，放入游戏运行的入口类；main包，存放实现游戏各功能类的包；util包，存放游戏工具类以及一些常量的包；13个类，每个类都有各自的不同功能，方便进行查找和修改。

具体分析：

app包：

GameApp类：实现游戏的启动运行

GameApp类作为游戏的入口，进行初始化主窗口类的对象，来加载主窗口类的内容

代码为：

import main.GameFrame;public class GameApp {public static void main(String[] args){
//实例化GameFrame类new GameFrame();}
}

main包：

GameFrame类：游戏主窗口类

所有游戏中绘制的内容都在这个窗口中完成，进行编写的功能具体有：实例化各类；

初始化游戏中一些内容的对象；

添加监听事件；

重写update方法实现双缓冲技术，避免屏幕闪烁问题，同时添加上游戏暂停结束的画面；

代码具体的实现

package main;import static util.Constant.*;import java.awt.*;
import java.awt.event.*;
import java.awt.image.BufferedImage;//游戏的主窗口类，所有在游戏中绘制的内容都在此窗口中完成
//GameFrame继承Frame，使GameFrame类有创建窗口的功能
public class GameFrame extends Frame {//实例化GameBackGround中的类private GameBackGround gameBackGround;//实例化小鸟的类private Bird bird;//实例化障碍物层类private GameBarrierLayer gameBarrierLayer;//实例化前景类private GameFrontGround gameFrontGround;//实例化云彩类private Cloud cloud;//存放图片的 图片//设置一张图片//传进图片的长度和高度private BufferedImage buffimg = new BufferedImage(FRAM_WIDTH, FRAM_HEIGHT, BufferedImage.TYPE_4BYTE_ABGR);//定义一个构造方法初始化一些参数public GameFrame(){//窗口是否可见setVisible(true);//窗口大小（没有定义静态之前，需要使用类名进行调用）
//        setSize(Constant.FRAM_WIDTH, Constant.FRAM_HEIGHT);//如果把Constant=包定义成静态的,后面加上.*,则可以省略Constant的调用setSize(FRAM_WIDTH, FRAM_HEIGHT);//窗口标题setTitle(FRAM_TITLE);//窗口的初始化位置setLocation(FRAM_X, FRAM_Y);//窗口的大小不可改变setResizable(false);//给窗口添加关闭事件/*该代码为在  Swing  程序中添加一个窗口监听器，并为窗口关闭事件添加一个监听函数。当用户关闭窗口时，代码会调用  System  类的  exit()  方法，将程序正常结束。由于传入的窗口适配器是匿名内部类，这意味着我们可以简单地在构建对象时指定事件，而不用创建新的自定义窗口适配器类。*/addWindowListener(new WindowAdapter() {@Overridepublic void windowClosing(WindowEvent e) {System.exit(0);//结束程序}});//在构造器中调用下面初始化的对象initGame();//启动线程new run().start();//添加监听/*KeyAdapter是一个类KeyAdapter中已经实现了对键盘事件的监听方法，但这些方法的实现是空的，我们需要在使用时重写这些方法，根据需求处理键盘事件。*/addKeyListener(new KeyAdapter() {@Overridepublic void keyPressed(KeyEvent e) {
//调用add方法，实现相应的键盘监听add(e);}@Overridepublic void keyReleased(KeyEvent e) {minu(e);}});}//初始化对象/*在GameFrame类中，实例化了GameBackGround类的对象gameBackGround，即在GameFrame对象初始化的同时也初始化了gameBackGround对象。这是因为在游戏的主窗口中，需要在窗口中绘制游戏的背景。在GameBackGround类中封装了绘制背景的方法，因此需要创建一个GameBackGround对象，通过调用其方法来绘制背景。同时，在GameBackGround类中还包含了游戏中玩家、敌人、子弹等对象的初始化，这些对象同样需要在GameFrame中使用，因此需要实例化GameBackGround类的对象。*/public void initGame(){
//分别实例化GameBackGround类，Bird类，GameFrontGround类，GameBarrierLayer类的对象，gameBackGround = new GameBackGround();bird = new Bird();gameFrontGround = new GameFrontGround();gameBarrierLayer = new GameBarrierLayer();}//写一个线程/** 这是一个继承自Thread类的run类。* 它重写了Thread类中的run方法。* 在这个run方法中，它执行了repaint()方法，* 这个方法会调用paint()方法重新绘制组件。* 在多线程环境下，这个类的实例可以与其他线程并发执行。* 当这个线程启动时，它会自动调用run方法。* 所以在这个run方法中，它会反复调用repaint方法来不断刷新界面。*/class run extends Thread{@Overridepublic void run(){while (true) {repaint();try {Thread.sleep(30);} catch (InterruptedException e) {e.printStackTrace();}}}}
//定义初始化是否开始的状态为true，在后面方便实现游戏暂停public static boolean isStarted = true;//写一个update方法，所有需要绘制的内容都在这里面绘制/*这段代码是Java中的重写方法，通常用于在每次图形界面需要更新时，自动调用该方法。具体而言，该方法首先调用了gameBackGround对象的draw方法，绘制了背景图像。
然后调用了bird对象的draw方法，绘制了小鸟图像。这里需要注意的是，Graphics对象是一个类似于画布的实例，
draw方法则是用来在画布上绘制图像的方法。因此，在调用draw方法时，
需要将该对象作为参数传递进去，使得绘制的图像可以正确显示在画布上。
实现了游戏界面的绘制需要注意的是，该方法实现了双缓冲技术，即先将需要绘制的所有元素绘制在缓存图片上，
然后再一次性绘制到屏幕上，避免了图像闪烁等问题。*/
@Overridepublic void update(Graphics g){
//进行判断，如果小鸟的生命值大于0，并且处于游戏开始状态，执行代码if (bird.life > 0 && isStarted == true){
//播放音乐Music.playMusic();//得到图片的画笔Graphics graphics = buffimg.getGraphics();//把所有要绘制的东西全部放在这张图片上,绘制背景，小鸟，前景，障碍物gameBackGround.draw(graphics);bird.draw(graphics);gameFrontGround.draw(graphics);gameBarrierLayer.draw(graphics,bird);//然后一次性把这张图片绘制在屏幕中g.drawImage(buffimg, 0, 0, null);}//如果小鸟的生命值大于0，游戏处于暂停状态，执行下列代码
else if(bird.life > 0 && isStarted == false){//停止播放音乐Music.stopMusic();
//           设置字体颜色为白色g.setColor(Color.WHITE);
//        设置字体，风格，字号g.setFont(new Font("微软雅黑", 1, 40));//打印游戏暂停时的提示语）g.drawString("点击空格键开始", 120, 180);}else{//小鸟死亡时执行下列语句
//        停止播放音乐Music.stopMusic();
//        定义游戏结束的提示String over = "游戏结束";
//        设置字体的颜色为红色g.setColor(Color.red);
//        设置字体，风格，字号g.setFont(new Font("微软雅黑", 1,60));
//        字体打印的语句，xy对应的位置g.drawString(over, 180, 200);
//        重新开始的提示语String reset = "Space Reset Game";
//        打印的内容，对应xy轴的位置g.drawString(reset, 25, 300);}}//调整up与down的true与false情况//fly等于1，up为true，为5，up为false//按键public void add(KeyEvent e){switch(e.getKeyCode()){case KeyEvent.VK_UP:
//        如果点击的是上建，up定义为true，Bird类中会根据up的值定义小鸟的飞行状态bird.fly(1);break;
//        点击的是空格键case KeyEvent.VK_SPACE:
//        如果小鸟生命值为0，小鸟死亡时if (bird.life == 0){
//        重新开始游戏restart();}else{
//        小鸟没有死亡，isStarted取相反值，使游戏停止isStarted = !isStarted;                }break;}}//松键方法public void minu(KeyEvent e){switch (e.getKeyCode()){
//        松开向上按键，调用小鸟类中的fly方法，up定义为false，小鸟飞翔状态改变case KeyEvent.VK_UP:bird.fly(5);break;}}public void restart(){//清空障碍物gameBarrierLayer.restant();//小鸟回原来位置bird.restarDraw();//重新定义是否开始的状态为trueisStarted = true;}}

Bird类：编写与小鸟有关的内容的类

定义小鸟的初始状态；给小鸟添加矩形框，方便进行碰撞检测；定义控制小鸟移动，改变小鸟移动，重新定义小鸟位置与生命值的方法

package main;import static util.Constant.*;
import util.GameUtil;import java.awt.*;
import java.awt.image.BufferedImage;public class Bird {//定义一个加速度accelerationprivate int acceleration =0;//给小鸟添加矩形框private Rectangle rect;//小鸟设定生命值public int  life = 3;//定义一个数组，存放小鸟图片，三张private BufferedImage[] images;public static final int BIRD_IMAGE_COUNT = 3;//小鸟移动的方向private boolean up = false, down = false;//小鸟初始化速度private int speed = 4;//小鸟状态,小鸟的状态等于对应的数字时，把小鸟的图片换成对应的图片private int state;public static final int STATE_NORMAL = 0;//平着飞public static final int STATE_UP = 1;//向上飞public static final int STATE_DOWN = 2;//向下飞//小鸟位置private int x = 150, y = 200;//构造方法中对资源初始化public Bird(){//初始化集合用来存储小鸟的个数/*这段代码是用来初始化小鸟对象的构造方法，其中主要包含了对小鸟图片资源的初始化。具体来说，该构造方法通过定义一个名为images的实例变量来存储小鸟的图片资源，其长度为BIRD_IMAGE_COUNT，即小鸟图片的数量。接下来使用了一个for循环，循环次数为BIRD_IMAGE_COUNT，即将每张小鸟图片的路径传进GameUtil.loadBufferedImage方法中，获得对应的BufferedImage对象后存入images数组中，使得小鸟对象的images变量存储了所有小鸟图片资源。其中loadBufferedImage是一种自定义的方法，用于将指定路径的图片文件读入内存并返回对应的BufferedImage对象。在游戏中，小鸟的各个动作需要对应不同的图片资源，因此此步骤对所有小鸟图片资源的读取和存储是十分必要的。*/images = new BufferedImage[BIRD_IMAGE_COUNT];for (int i = 0; i < BIRD_IMAGE_COUNT; i++) {//把路径传进来，把每张小鸟图片的路径传入GameUtil.loadBufferedImage方法中images[i] = GameUtil.loadBufferedImage(BIRD_IMG[i]);}//定义矩形框的宽高，宽高为小鸟图片的宽高int w = images[0].getWidth();int h = images[0].getHeight();
//        实例化矩形框rect = new Rectangle(w,h);}//绘制小鸟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(){//点击上建，up的值为trueif (up == true){
//            y -= speed;
//        小鸟的加速度自减acceleration--;
//        设置小鸟y坐标的移动y+=acceleration;
//    如果加速度小于10，令加速度等于-10if (acceleration < -10){acceleration = -10;}
//        如果y坐标小于20，令y坐标不变，加速度为0if (y < 20){y = 20;acceleration = 0;}}
//松开向上箭头键，up为false，情况与上面类似if (up != true){
//            y += speed;acceleration++;y+=acceleration;if (acceleration > 10){acceleration = 10;}if (y > 475){y = 475;acceleration = 0;}}}//改变小鸟状态的方法public void fly(int fly){switch(fly){case 1:state = 1;up = true;break;case 5:state = 2;up = false;break;}}//定义矩形框的get方法，方便障碍物画矩形框public Rectangle getRect() {return rect;}//重新绘制小鸟位置与小鸟生命值public void restarDraw(){life = 3;x = 200;y = 200;}
}

Coloud类：与云彩有关的类

详细有云彩速度，位置的定义，画出云彩的方法，判断云彩是否飞出屏幕以外的方法

package 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;}//写一个draw方法画出云彩public void draw(Graphics g){
//    实现云的移动，云在x轴上以speed的速度不断移动x -= speed;
//    画出云的位置，参数分别为云的图片，xy轴的坐标，转换了更多图像时要通知的对象g.drawImage(img, x, y, null);}//判断云彩是否飞出屏幕以外，根据返回值的类型在GameFrontGround类中判断是否需要移除云public boolean isOutFrame(){
//        如果云的x坐标小于-50if(x < -50){
//        返回truereturn true;}else{return false;}}
}

Barrier类：障碍物类

与障碍物有关的操作的编写，定义障碍物的矩形，速度，存放障碍物的数组，障碍物的状态；

静态代码块初始化障碍物的参数，在加载类时优先执行；

draw方法，绘制障碍物；

绘制四种障碍物的方法；

给障碍物绘制矩形用于进行碰撞检测的方法；

判断绘制障碍物时机的方法；

package main;import util.Constant;
import util.GameUtil;import java.awt.*;
import java.awt.image.BufferedImage;//障碍物类
public class Barrier {//用于判断障碍物是否要进行移动private boolean mob = true;//定义一个矩形private  Rectangle rect;//定义障碍物的速度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;//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_NOVER_NORMAL = 4;public static final int TYPE_MOBLE = 6;//获得障碍物的宽度和高度//中间
//    imgs[]数组中第一张图片的宽高public static final int BARRIRE_WIDTH = imgs[0].getWidth();public static final int BARRIRE_HEIGHT = imgs[0].getHeight();//上下朝向
//    分别为imgs[]数组中第二张图片的宽高public static final int BARRIRE_HEAD_WIDTH = imgs[1].getWidth();public static final int BARRIRE_HEAD_HEIGHT = imgs[1].getHeight();//定义构造器public Barrier(){//初始化矩形参数rect = new Rectangle();}//编写draw方法，根据不同的类型绘制障碍物public void draw(Graphics g){switch(type){case TYPE_TOP_NORMAL:
//        画出从上到下的障碍物drawTopNormal(g);break;
//        画出从下到上的障碍物case TYPE_BOTTOM_NORMAL:drawNormalTop(g);break;
//        画出中间的障碍物case TYPE_NOVER_NORMAL:drawHoverNormal(g);break;
//        画出中间移动的障碍物case TYPE_MOBLE:drawMobile(g);break;}}//绘制从上到下的障碍物public void drawTopNormal(Graphics g){//求出所需要的障碍物的块数//高度减去头的高度，再除以中间的高度加1就是中间障碍物所需要的块数int count = (height - BARRIRE_HEAD_HEIGHT)/BARRIRE_HEIGHT+1;//使用for循环绘制中间障碍物for (int i = 0; i < count; i++) {//drawImage方法用来绘制图片g.drawImage(imgs[0], x, y+i*BARRIRE_HEIGHT, null);}//绘制头int y = height - BARRIRE_HEAD_HEIGHT;
//    画出imgs数组中第三张图片，参数分别为对应的图片，xy轴的坐标，转换更多图像时
//要通知的对象，这里不进行通知g.drawImage(imgs[2], x - (BARRIRE_HEAD_WIDTH - BARRIRE_WIDTH)/2, y, null);
//    头的左边左移，实现障碍物的移动x -= speed;if (x < -50){
//        设置visible的值，判断是否需要移除障碍物visible = false;}
//        调用绘制矩形框的方法绘制矩形框rect(g);}//绘制从下往上的障碍物public void drawNormalTop(Graphics g){//障碍物所需要的块数int count = height / BARRIRE_HEIGHT + 1;//for循环绘制中间障碍物for (int i = 0; i < count; i++) {
//        drawImage方法画出图片，g.drawImage(imgs[0], x, y+imgs[1].getHeight()+i*imgs[0].getHeight(), null);}//绘制头int y = Constant.FRAM_HEIGHT-height;
//        this.y = y;g.drawImage(imgs[1], x - (BARRIRE_HEAD_WIDTH-BARRIRE_WIDTH)/2, y, null);x -= speed;//如果障碍物除了屏幕以外，状态改为falseif (x < -50){visible = false;}rect(g);}//绘制中间的障碍物public void drawHoverNormal(Graphics g){//求出所需要的障碍物的块数//高度减去头的高度，再除以中间的高度加1就是中间障碍物所需要的块数int count = (height - BARRIRE_HEAD_HEIGHT) / BARRIRE_HEIGHT;
//        System.out.println(count+"aaaa");//绘制上头g.drawImage(imgs[1], x, y, null);//使用for循环绘制中间障碍物for (int i = 0; i < count; i++) {//drawImage方法用来绘制图片g.drawImage(imgs[0], x, y+BARRIRE_HEAD_HEIGHT+i*BARRIRE_HEIGHT, null);}rect(g);//绘制下头int y11 = y+height - BARRIRE_HEAD_HEIGHT;
//        System.out.println(y);g.drawImage(imgs[2], x, y11, null);x -= speed;if (x < -50){visible = false;}}//绘制可以移动的障碍物public void drawMobile(Graphics g){//求出所需要的障碍物的块数//高度减去头的高度，再除以中间的高度加1就是中间障碍物所需要的块数int count = (height - BARRIRE_HEAD_HEIGHT) / BARRIRE_HEIGHT;
//        System.out.println(count+"aaaa");//绘制上头g.drawImage(imgs[1], x, y, null);//使用for循环绘制中间障碍物for (int i = 0; i < count; i++) {//drawImage方法用来绘制图片g.drawImage(imgs[0], x, y+BARRIRE_HEAD_HEIGHT+i*BARRIRE_HEIGHT, null);}
//        调用画矩形框的方法绘制矩形框rect(g);//绘制下头int y11 = y+height - BARRIRE_HEAD_HEIGHT;g.drawImage(imgs[2], x, y11, null);x -= speed;if (x < -50){visible = false;}//让障碍物移动if (mob){y+=5;if(y >=250){mob = false;}}else if (!mob){y-=5;if (y<=100){mob = true;}}}/*rect(Graphics  g)：绘制障碍物碰撞的矩形。该方法接收一个  Graphics  对象  g，用于在指定区域绘制障碍物的矩形。它使用障碍物的  x、y  坐标来确定绘制的矩形的位置，使用障碍物图片数组  imgs[0]  的宽度  w1  来确定矩形的宽度，而  height  则作为矩形的高度。在绘制矩形时，使用了预设的颜色  Color.red。*///绘制障碍物碰撞的矩形public void rect(Graphics g){int x1 = this.x;int y1 = this.y;int w1 = imgs[0].getWidth();g.setColor(Color.red);
//        g.drawRect(x1, y1, w1, height);//调用障碍物矩形参数的方法setRecyangle(x1, y1, w1, height);}/*setRecyangle(int  x,  int  y,  int  width,  int  height)：障碍物的矩形参数。该方法接收四个整数参数，分别表示矩形的位置和大小。它将这四个参数值赋值给对象的矩形参数  rect，以便后续在游戏中进行碰撞检测。*///障碍物的矩形参数public void setRecyangle(int x, int y, int width, int height){rect.x = x;rect.y = y;rect.width = width;rect.height = height;}//判断什么时候绘制障碍物，可以调节障碍物之间的距离，让游戏简单或困难public boolean isInFrame(){return 600-x>180;}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 getVisible(){return visible;}public void setVisible(boolean visible){this.visible = visible;}public Rectangle getRect() {return rect;}
}

GameBarrierLayer类：障碍物层类

定义一个数据记录小鸟飞行的最大时间；

实例化时间类，获取随机数，定义List集合存放障碍物，定义构造器初始化数据；

编写drw方法绘制障碍物；

编写logic方法定义游戏开始，暂停，结束状态；

编写insert方法获得障碍物对象，添加障碍物；

ran方法产生随机数；

判断小鸟发生碰撞的方法；

清空障碍物池；

储存和得到数据方法；

package main;import java.awt.*;
import java.io.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;//障碍物层类
public class GameBarrierLayer {//定义一个数据private int txt;//实例化时间类private GameTime gameTime;private Random random = new Random();/*这是一个Java类定义，主要作用是创建一个障碍物图层，并且使用ArrayList来存储障碍物对象。代码中的  "List<Barrier>  barriers"  是一个成员变量，
表示一个障碍物对象的列表，其中每个障碍物对象的类型是  "Barrier"。在构造函数中，使用  "ArrayList<>()"  初始化了  "barriers"  列表，
该列表将用于存储障碍物对象。
由于  "ArrayList"  类实现了  "List"  接口，
因此它提供了一些方便的方法来管理和访问列表中的元素。因此，在创建  "GameBarrierLayer"  对象时，
可以使用构造函数来初始化  "barriers"  列表，
然后将其用于存储障碍物对象。
*///定义一个数组存放障碍物private List<Barrier> barriers;//定义构造器初始化数组public GameBarrierLayer(){barriers = new ArrayList<>();gameTime = new GameTime();}//绘制障碍物/*该代码是一个游戏中生成障碍物的功能实现。在draw方法中，首先通过for循环遍历所有已存在的障碍物对象并进行绘制。接着调用logic方法，该方法用于检测是否需要生成新的障碍物。在logic方法中，首先判断已存在的障碍物数量是否为0，
若为0则调用ran方法生成一个随机数作为障碍物的高度，
并创建上下两个障碍物对象。这两个对象的x坐标都为600，
即在屏幕最右边生成，并分别设置其高度为numberTop和500-numberDown。若已存在障碍物，
则检测最后一个障碍物是否已经完全进入屏幕内（即其x坐标是否小于0），
若已经进入则和上述过程相同再生成一个新的障碍物对。总的来说，这段代码的作用是实现游戏中不断生成障碍物的效果，
并且保证生成的障碍物数量始终能够满足游戏的需求。
*/public void draw(Graphics g,Bird bird){
//    如果不使用循环进行编写//new一个障碍物类
//        Barrier barrier = new Barrier(200, 0, 200, 0);
//        barrier.draw(g);
//        barriers.add(barrier);
//        barriers.get(0).draw(g);
//        Barrier barrier1 = new Barrier(300, 0, 300, 2);
//        barriers.add(barrier1);
//        barriers.get(1).draw(g);//    定义了一个循环变量i，初始值为0，每次循环自增1，
//    直到i小于barriers的大小（即barriers列表中元素的数量）时循环结束。for(int i = 0; i < barriers.size(); i++){
//        通过get(i)方法从barriers列表中获取当前元素
//        并给barrier变量赋值，用于之后的操作。Barrier barrier = barriers.get(i);
//    判断barrier元素的可见属性是否为true，
//    如果是，就执行下一行的代码；否则执行else语句块中的代码。if (barrier.getVisible() == true){
//调用barrier元素的draw()方法来绘制该元素的外观，
//    即在屏幕上显示。barrier.draw(g);}else{
//    从barriers列表中移除当前元素并将其赋给remove变量。Barrier remove =barriers.remove(i);
//   将remove元素放回对象池（可以理解为回收该对象，
//以便之后重复利用）。Barrierpool.setPool(remove);
//由于remove元素被移除后，
//后面的元素都往前移了一位，
//所以需要将循环变量i减去1以便下一次循环能正确地处理所有元素。i--;}}
//    判断小鸟是否发生碰撞collideBird(bird);
//    logic(g,bird);}/*游戏的主要逻辑部分。首先判断是否已经生成了障碍物，如果没有则调用  `ran()`  方法生成随机数来决定生成障碍物的种类和数量，并开始计时。然后根据障碍物种类和数量调用  `insert()`  方法创建相应数量的障碍物对象，添加到  `barriers`  集合中。如果已经存在障碍物，则显示已经坚持的时间和当前小鸟的生命值，并根据上一次的最高记录调用  `getTxt()`  方法获取最高纪录，如果当前时间比最高纪录长，则更新最高纪录并调用  `setTxt()`  方法保存到文件中。接着判断最后一个障碍物是否已经完全进入屏幕内，如果是则再次随机生成障碍物种类和数量，并调用  `insert()`  方法创建新的障碍物对象后添加到  `barriers`  集合中。最后刷新游戏窗口，并继续下一次循环*/public void logic(Graphics g,Bird bird){
//    如果障碍物集合为空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, 500-numberDown, numberDown, 2);}else{
//        获得游戏时间，并把游戏时间打印出来long differ = gameTime.differ();
//设置字体，格式，大小g.setFont(new Font("微软雅黑", 1, 20));
//设置字体颜色g.setColor(Color.black);
//画出经历的时间g.drawString("坚持了"+differ+"秒", 30, 50);
//画出小鸟生命值剩余情况g.drawString("小鸟生命："+bird.life,450,50);
//获得文本内储存的数据txt = getTxt();if (differ <= txt){
//如果经历的时间小于文本内储存的数据，打印最高成绩为文本内数据g.drawString("最高成绩 :"+txt, 200, 50);}else{//否则，储存最高记录setTxt(String.valueOf(differ));
//                打印最高记录g.drawString("最高成绩:"+differ, 200, 50);}//判断最后一个障碍物是否完全进入屏幕内Barrier last = barriers.get(barriers.size() - 1);
//如果进入屏幕内if (last.isInFrame()){
//重新生成随机数ran();
//    生成的随机数小于50if(number < 50){
// 画insert(600, 50, 350, 4);
//                    System.out.println("440的障碍物");}else if(number > 450){insert(600, 125, 200, 6);
//                    System.out.println("220的一个障碍物");}else{insert(600, 0, numberTop, 0);insert(600, 500-numberDown, numberDown, 2);}
//                //障碍物从屏幕最右边生成.创建上下两个障碍物对象
//                //上方
//                Barrier top = new Barrier(600, 0, numberTop, 0);
//                barriers.add(top);
//                //下方
//                Barrier down = new Barrier(600, 500-numberDown, numberDown, 2);
//                barriers.add(down);}}}//从池中获取对象，把参数封装成barrier存入barriers数组中/*这段代码的作用是往一个存储障碍物的列表中添加一个新的障碍物，
总体来说，这段代码是实现了从对象池中获取一个Barrier对象，
并通过给其属性赋值的方式来创建一个新的障碍物，
最后将其添加到存储障碍物的列表中。
这种方式可以避免频繁地创建和销毁对象带来的性能问题。
*/
//定义了一个公共方法insert，传入参数包括障碍物的位置和类型信息public void insert(int x, int y, int num, int type){
//    从一个对象池中获取一个Barrier对象，并赋值给top变量Barrier top = Barrierpool.getPool();
//    给top对象设置x坐标top.setX(x);
//    给top对象设置y坐标。top.setY(y);
//    //给top对象设置长度top.setHeight(num);//    给top对象设置类型。top.setType(type);
//设置visiable的值为truetop.setVisible(true);
//    将top对象添加到一个存储障碍物的列表中。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);//如果管道重合（两个管道的高度和大于450，小鸟无法飞过），重新生成随机数if (numberTop + numberDown >= 450){ran();}}//判断障碍物与小鸟发生碰撞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.life--;
//    移除与小鸟相撞的障碍物对象barriers.remove(barrier);}}return false;}//清空障碍物池的方法public void restant(){barriers.clear();}//创建一个File,传入记录最高分数文件的路径，创建的文件内传入一个数字，否则会报出异常static File file = new File("传入txt文件的路径");//储存数据了，写入一个字符串到文件中public static void setTxt(String str){
//    创建一个FileWrite的对象，该对象是FileWriter的实现类，置为null，方便异常处理FileWriter fileWriter = null;try {//利用传入的文件对象，创建FileWriter对象，指定写入的文件fileWriter = new FileWriter(file);} catch (IOException e) {e.printStackTrace();}try {//调用write方法，把参数str写入到文件中fileWriter.write(str);} catch (IOException e) {e.printStackTrace();}try {//关闭文件fileWriter.close();} catch (IOException e) {e.printStackTrace();}}//得到文件中的数据public int getTxt(){
//创建一个名为in的BufferedReader对象，该对象取至file文件，null方便进行异常处理BufferedReader in = null;
//    通过readLine方法逐行读取文件内容，并将其解析为整数值，赋值给readtry {//利用传入的文件file，创建BufferedReader的对象in = new BufferedReader(new FileReader(file));} catch (FileNotFoundException e) {e.printStackTrace();}
//        String s = in.readLine();int read = 0;try {//从文件中读取一行字符串，并将其转换为整型值read = Integer.parseInt(in.readLine());} catch (IOException e) {e.printStackTrace();}try {//关闭文件流in.close();} catch (IOException e) {e.printStackTrace();}//返回读到的整型值return read;}}

Barrierpool类：障碍物池类

创建用于管理池中所有对象的容器

定义池中初始化对象的个数和池中对象的最大个数

使用静态代码块初始化池中的对象

分别定义从从池中获取对象和把对象归还容器的方法

package main;import java.util.List;
import java.util.ArrayList;/*每次需要障碍物的时候都会创建一个对象，占用大量内存，需要创建一个对象池类
为了避免反复创建和销毁对象，使用对象池来创建好一些对象，
使用的时候从池中获得，使用完毕后，归还*/
public class Barrierpool {/*这段代码是一个使用对象池技术实现的管理器。
对象池是一种重复利用已经创建的对象来避免重复创建和
销毁对象的技术，从而提高程序性能。在这个示例中，对象池中存储的是Barrier对象。
这个对象池使用一个静态的List<Barrier>来存储对象，
而不是每次需要一个Barrier对象时都重新创建。
对象池的大小是之前定义的initCount。*///用于管理池中所有对象的容器private static List<Barrier> pool = new ArrayList<>();//池中初始化对象的个数public static final int initCount = 16;//对象池中最大个数public static final int maxCount = 20;/*初始化对象池的过程在static块中进行，这个块是在类加载时运行的，并且只会执行一次。在这个示例中，static块创建了initCount个Barrier对象，并将它们添加到对象池中。这样，在需要Barrier对象的时候，程序可以从对象池中获取可用的对象，而不是重新创建一个新的对象。*///初始化池中的对象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{//池中没有对象，只能newSystem.out.println("新的对象");//新定义一个对象，返回给方法return new Barrier();}}//把对象归还容器public static  void setPool(Barrier barrier){//如果池中障碍物的数量小于最大数量if (pool.size() < maxCount){//向池中添加障碍物pool.add(barrier);System.out.println("容器归还了");}}
}

GameFrontGround类：背景类

定义云彩的个数，存放云彩的集合，云彩的飞行速度；

得到资源图片，制造随机数的函数；

构造器初始化数据；

绘制云彩的方法；

控制云彩个数的方法；

package main;import 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 {//云彩的个数private static final int CLOUND_COUNT = 2;//存放云彩的容器/*这行代码是定义了一个名为clouds的List对象，其中存储了一组Cloud对象。这个List是Java中的一种集合，使用它可以把若干个元素放在一起，进行批量操作，比如添加元素、遍历元素、删除元素等等。具体的使用方式可能需要根据具体的场景和业务需求来进行调整。*/private List<Cloud> clouds;//云彩飞行的速度private static final int CLOUND_SPEED = 1;/*这行代码定义了一个类型为  BufferedImage  数组的变量  img。BufferedImage  是  Java  中表示图像的类，
它是一个实现了  RenderedImage  接口的缓存图像类，
可以用于操作和修改图像数据。
数组表示可以存储多张图片数据的数组，
每个元素代表一张图片，可以对每张图片单独进行操作。
因此，private  BufferedImage[]  img;定义了一个变量  img，它可以存储多张  BufferedImage  图像，可以对每张图片进行单独处理。*///使用到的图片资源private BufferedImage[] img;//制造随机数的函数private Random random;//构造器初始化数据public GameFrontGround(){/*这行代码声明了一个名为  "clouds"  的  ArrayList（动态数组）对象，并对其进行初始化。在这个例子中，"<>"  符号表示  ArrayList  存储的是未知类型的元素，
这样声明和初始化  ArrayList  对象后，
就可以在其中存储和操作元素。通常，
开发人员使用  add()  方法将元素添加到  ArrayList中，
使用  get()  方法访问  ArrayList  中的特定元素，
使用  size()  方法获取  ArrayList  的大小等。*///实例化存放云彩的容器clouds = new ArrayList<>();//定义数组中储存元素的最大数量img = new BufferedImage[CLOUND_COUNT];//容器中添加云彩图片for (int i = 0; i < CLOUND_COUNT; i++) {//调用GameUtil方法中的loadBufferedImage方法来获取图片添加到//img数组中img[i] = GameUtil.loadBufferedImage("newBird\\img\\cloud"+i+".png");//括号内填写图片的路径}//创建一个随机数的对象random = new Random();}//绘制云彩public void draw(Graphics g){
//        //传入图片（创建对象）//没有使用循环
//        Cloud cloud = new Cloud(img[1], CLOUND_SPEED, 300, 300);
//        //把云彩添加到容器中
//        //clouds是一个集合
//        clouds.add(cloud);//调用方法控制云彩的个数logic();for (int i = 0; i < clouds.size(); i++) {//画出云彩clouds.get(i).draw(g);}}//控制云彩个数的方法private void logic(){//产生一个0~500的随机数//Math.random()方法产生一个0~1的随机数//如果生成的随机数小于8if((int)(500*Math.random())< 8){///生成一个新的云的图像，使用了随机的图片速度，位移参数Cloud cloud = new Cloud(img[random.nextInt(CLOUND_COUNT)], CLOUND_SPEED, 600, random.nextInt(180));//将新生成的云添加到云列表中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 main;public class GameTime {//开始private long beginTime;//结束private long endTime;//时间差private long differ;public GameTime(){}//计时开始方法，System调用方法，计算从起始时间开始到现在的时间public void begin(){beginTime = System.currentTimeMillis();}//时间差方法public long differ(){//获得从起始时间开始到游戏结束时的时间endTime = System.currentTimeMillis();
//        得到时间差，除以1000是以秒为单位return differ = (endTime - beginTime)/1000;}
}

Music类：音乐类

声明背景音乐文件

静态代码块加载背景音乐文件

循环播放音乐的方法

停止播放音乐的方法

package main;import javax.sound.sampled.*;
import java.io.File;public class Music {//声明了名为music的private static Clip变量，表示音乐文件private static Clip music;//加载背景音乐文件，并将其储存在music变量中static{File bgMusicFile = new File("newBird\\\\img\\\\bgm2.wav");try{AudioInputStream ais = AudioSystem.getAudioInputStream(bgMusicFile);music = AudioSystem.getClip();music.open(ais);}catch (Exception e){e.printStackTrace();}}public static void playMusic(){//循环播放music.loop(Clip.LOOP_CONTINUOUSLY);}//停止播放音乐public static void stopMusic(){music.stop();}
}

util包：

Constant类：初始化游戏中需要用到的一些参数

定义窗口大小的变量；

定义窗口标题，窗口初始化位置；

定义背景颜色；

定义数组存放小鸟图片的路径；

定义数组存放障碍物图片资源的路径；

package 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 = "飞翔的小鸟";//窗口初始化的位置//静态最终变量public static final int FRAM_X = 200;public static final int FRAM_Y = 200;//图片的路径public static final String BK_IMG_OATH = "newBird\\img\\bird_bk.png";//定义背景的颜色public static final Color BK_COLOR = new Color(0X4B4CF);//存放三张小鸟图片的路径public static final String[] BIRD_IMG = {"newBird\\img\\bird_normal.png","newBIrd\\img\\bird_up.png","newBird\\img\\bird_down.png"};//定义障碍物图片资源（路径）public static final String[] BARRIER_IMG_PATH = {"newBird\\img\\barrier.png","newBird\\img\\barrier_up.png","newBird\\img\\barrier_down.png"};
}

GameUtil：定义加载图片的工具

装载图片

package 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{/*这里是创建一个输入流，用来读取指定路径下的文件，imgPath是文件路径。在该方法中，我们使用FileInputStream将图片文件读入内存中，返回BufferedImage对象。*/return ImageIO.read(new FileInputStream(imgPath));}catch(IOException e){e.printStackTrace();}return null;}
}

java小游戏——飞翔的小鸟（java初学作品）相关推荐

java小游戏-飞翔的小鸟
java小游戏-ava小游戏-飞翔的小鸟 1 游戏窗口的显示 2 游戏背景添加 3 背景颜色的添加 4 屏幕中绘制小鸟 5 实现小鸟上下移动 6 解决屏幕闪烁问题 7 云彩的添加与移动 8 云彩的自动 ...
java小游戏飞翔的小鸟，校园新手入门，分分钟带你玩转编程
本课程讲解了飞翔的小鸟游戏的详细编写流程,即使你是刚入门java的新手,只要你简单掌握了该游戏所需要的javase基础知识,便可以跟随教程视频完成属于你自己的飞翔的小鸟游戏!同时还可以加深和巩固你对面 ...
Java小游戏------飞翔的小鸟
我们要做出这个样子的游戏首先就要分析我们需要创建几个类,有鸟类.柱子类.地面类,然后就是游戏判定.我的思路就是,先创建这几个类,然后把这些类,对应的东西,画到游戏界面上,再确定游戏碰撞机制,当小鸟碰 ...
java小游戏英文文献,连连看Java小游戏毕业设计论文
连连看Java小游戏毕业设计论文连连看连连看 JavaJava 小游戏毕业论文小游戏毕业论文设计设计学生姓名学生姓名学学号号系系别别专专业业指导教师指导教师软件 071 班目目 ...
Java小游戏-飞翔小鸟
摘要 Eclipse 是一个开放源代码的.基于Java的可扩展开发平台.就其本身而言,它只是一个框架和一组服务,用于通过插件组件构建开发环境.幸运的是,Eclipse 附带了一个标准的插件集,包括J ...
unity2D小游戏---飞翔的小鸟
飞翔的小鸟一.柱子的移动二.小鸟的控制三.游戏暂停开始一.柱子的移动 1.制作柱子:新建空物体,包含上方柱子,下方柱子和空物体(用于计算得分) 2.给柱子和空物体加上适合大小的碰撞体空物体需 ...
java小游戏------Flappy Bird（飞翔的小鸟含源码）
前言:本小游戏可作为java入门阶段收尾创作. 需:掌握面向对象的使用,了解多线程和异常处理等知识. 如上图所示:我们需要绘制背景,小鸟,障碍物,当然也包括游戏开始界面以及死亡界面. 一:思路解析: ...
Java SpringMVC+H5飞翔的小鸟游戏微信小程序源码
源码介绍 Java SpringMVC+H5飞翔的小鸟游戏微信小程序源码试验性质的一个微信小程序,用canvas做的一个类似flappy-bird的小游戏. 包含一些基本的功能:躲避障碍物.计分.排 ...
【源码+图片素材】Java开发经典游戏飞翔的小鸟_Java游戏项目Flappy Bird像素鸟游戏_Java小游戏_Java初级项目_Java课程设计项目
开发环境: jdk1.8 开发工具: IDEA JavaEE基础: 变量.数据类型.判断语句.循环结构.数组.集合.简单窗口创建.图形图片绘制.双缓存技术.事件-键盘事件.物体的碰撞检测.File [ ...

java小游戏——飞翔的小鸟（java初学作品）

概述:

编写要求：

具体分析：

app包：

GameApp类：实现游戏的启动运行

main包：

GameFrame类：游戏主窗口类

Bird类：编写与小鸟有关的内容的类

Coloud类：与云彩有关的类

Barrier类：障碍物类

GameBarrierLayer类：障碍物层类

Barrierpool类：障碍物池类

GameFrontGround类：背景类

GameTime类：时间类

Music类：音乐类

util包：

Constant类：初始化游戏中需要用到的一些参数

GameUtil：定义加载图片的工具

java小游戏——飞翔的小鸟（java初学作品）相关推荐

最新文章

热门文章