java游戏项目超级马里奥

最新推荐文章于 2022-10-29 10:05:17 发布

falldeep

最新推荐文章于 2022-10-29 10:05:17 发布

阅读量6.7k

点赞数 9

分类专栏： java实战项目文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/falldeep/article/details/122217102

版权

java实战项目专栏收录该内容

5 篇文章 3 订阅

订阅专栏

项目说明

此项目总共代码量为700行左右，在b站有教程（时长2h），是笔者在小学期时做的项目，项目采用了多线程的设计实现了人物和怪兽的移动。

另外按照b站的教程，它最终是无法打包成jar包的，因为它图片路径的写法问题，按照我的写法就可以打包成jar包，且不会有找不到图片的问题，图片路径写法

游戏还添加了music，需要另外加jar包，只支持wav格式的音乐

jar包为jl-1.0.1.jar

需要打包的源码（文件夹打包）的话点击这个链接

源码下载

游戏素材下载点击下面这个链接

图片、背景音乐、jl-1.0.1.jar包

可运行jar文件（直接开玩版）点击下面这个链接

直接开玩版

图1-1游戏截图

游戏说明

wasd控制马里奥的移动，共有三关，走到最后拉下旗子游戏胜利。

项目实现

先看看工程架构

源码

BackGround

package com.sqm;

import java.awt.image.BufferedImage;
import java.util.ArrayList;
import java.util.List;

public class BackGround
{
    //当前场景要显示的图片
    private BufferedImage bgImage = null;
    //记录当前是第几个场景
    private int sort;
    //判断是否是最后一个场景
    private boolean flag;
    //用于存放我们所有的障碍物
    private List<Obstacle> obstacleList = new ArrayList<>();
    //用于存放我们所有的敌人
    private List<Enemy> enemyList = new ArrayList<>();
    //用于显示旗杆
    private BufferedImage gan = null;
    //用于显示城堡
    private BufferedImage tower = null;
    //判断马里奥是否到达旗杆位置
    private boolean isReach = false;
    //判断旗子是否落地
    private boolean isBase = false;

    public List<Obstacle> getObstacleList() {
        return obstacleList;
    }

    public BackGround() {

    }

    public BackGround(int sort, boolean flag) {
        this.sort = sort;
        this.flag = flag;
        if (flag) {
            bgImage = StaticValue.bg2;
        } else {
            bgImage = StaticValue.bg;
        }

        //判断是否是第一关
        if (sort == 1)
        {
            //绘制第一关的地面,上地面type=1，下地面type=2
            for (int i = 0; i < 27; i++) {
                obstacleList.add(new Obstacle(i * 30,420,1,this));
            }

            for (int j = 0; j <= 120; j+=30) {
                for (int i = 0; i < 27; i++) {
                    obstacleList.add(new Obstacle(i*30,570-j,2,this));
                }
            }

            //绘制砖块A
            for (int i = 120; i <= 150; i+=30) {
                obstacleList.add(new Obstacle(i,300,7,this));
            }

            //绘制砖块B-F
            for (int i = 300; i <= 570; i+=30) {
                if (i == 360 || i == 390 || i == 480 || i == 510 || i == 540)
                {
                    obstacleList.add(new Obstacle(i,300,7,this));
                }
                else
                {
                    obstacleList.add(new Obstacle(i,300,0,this));
                }
            }

            //绘制砖块G
            for (int i = 420; i <= 450; i+= 30) {
                obstacleList.add(new Obstacle(i,240,7,this));
            }

            //绘制水管
            for (int i = 360; i <= 600; i+=25) {
                if (i == 360)
                {
                    obstacleList.add(new Obstacle(620,i,3,this));
                    obstacleList.add(new Obstacle(645,i,4,this));
                }
                else
                {
                    obstacleList.add(new Obstacle(620,i,5,this));
                    obstacleList.add(new Obstacle(645,i,6,this));
                }
            }

            //绘制第一关的蘑菇敌人
            enemyList.add(new Enemy(580,385,1,true,this));
            //绘制第一关的食人花敌人
            enemyList.add(new Enemy(635,420,2,true,this,328,428));

        }

        //判断是否是第二关
        if (sort == 2)
        {
            //绘制第二关的地面,上地面type=1，下地面type=2
            for (int i = 0; i < 27; i++) {
                obstacleList.add(new Obstacle(i * 30,420,1,this));
            }

            for (int j = 0; j <= 120; j+=30) {
                for (int i = 0; i < 27; i++) {
                    obstacleList.add(new Obstacle(i*30,570-j,2,this));
                }
            }

            //绘制第一个水管
            for (int i = 360; i <= 600; i+=25) {
                if (i == 360) {
                    obstacleList.add(new Obstacle(60, i, 3, this));
                    obstacleList.add(new Obstacle(85, i, 4, this));
                } else {
                    obstacleList.add(new Obstacle(60, i, 5, this));
                    obstacleList.add(new Obstacle(85, i, 6, this));
                }
            }
                //绘制第二个水管
                for (int i = 330; i <= 600; i+=25) {
                    if (i == 330) {
                        obstacleList.add(new Obstacle(620, i, 3, this));
                        obstacleList.add(new Obstacle(645, i, 4, this));
                    } else {
                        obstacleList.add(new Obstacle(620, i, 5, this));
                        obstacleList.add(new Obstacle(645, i, 6, this));
                    }
                }

                //绘制砖块C
                obstacleList.add(new Obstacle(300,330,0,this));

                //绘制砖块BEG
            for (int i = 270; i <= 330; i+=30) {
                if (i == 270 || i == 330)
                {
                    obstacleList.add(new Obstacle(i,360,0,this));
                }
                else
                {
                    obstacleList.add(new Obstacle(i,360,7,this));
                }
            }
                //绘制砖块ADFHI
            for (int i = 240; i <= 360; i+=30) {
                if (i == 240 || i == 360)
                {
                    obstacleList.add(new Obstacle(i,390,0,this));
                }
                else
                {
                    obstacleList.add(new Obstacle(i,390,7,this));
                }
            }

                //绘制妨碍1砖块
                obstacleList.add(new Obstacle(240,300,0,this));

                //绘制1-4砖块
            for (int i = 360; i <= 540; i+=60) {
                    obstacleList.add(new Obstacle(i,270,7,this));
            }

            //绘制第二关的第一个食人花敌人
            enemyList.add(new Enemy(75,420,2,true,this,328,418));
            //绘制第二关的第二个食人花敌人
            enemyList.add(new Enemy(635,420,2,true,this,298,388));
            //绘制第二关的第一个蘑菇敌人
            enemyList.add(new Enemy(200,385,1,true,this));
            //绘制第二关的第二个蘑菇敌人
            enemyList.add(new Enemy(500,385,1,true,this));
            }

        //判断是否是第三关
        if (sort == 3)
        {
            //绘制第三关的地面,上地面type=1，下地面type=2
            for (int i = 0; i < 27; i++) {
                obstacleList.add(new Obstacle(i * 30,420,1,this));
            }

            for (int j = 0; j <= 120; j+=30) {
                for (int i = 0; i < 27; i++) {
                    obstacleList.add(new Obstacle(i*30,570-j,2,this));
                }
            }

            //绘制第三个背景的A—O砖块
            int temp = 290;
            for (int i = 390; i >= 270; i-=30) {
                for (int j = temp; j <= 410; j+=30) {
                    obstacleList.add(new Obstacle(j,i,7,this));
                }
                temp += 30;
            }

            //绘制第三个背景的P-R砖块
            temp = 60;
            for (int i = 390; i >= 360; i-=30) {
                for(int j = temp;j <= 90; j += 30)
                {
                    obstacleList.add(new Obstacle(j,i,7,this));
                }
                temp += 30;
            }

            //绘制旗杆
            gan = StaticValue.gan;
            //绘制城堡
            tower = StaticValue.tower;
            //添加旗子到旗杆上
            obstacleList.add(new Obstacle(515,220,8,this));

            //绘制第三关的蘑菇敌人
            enemyList.add(new Enemy(150,385,1,true,this));

        }

    }


    public BufferedImage getBgImage() {
        return bgImage;
    }

    public int getSort() {
        return sort;
    }

    public boolean isFlag() {
        return flag;
    }

    public BufferedImage getGan() {
        return gan;
    }

    public BufferedImage getTower() {
        return tower;
    }

    public boolean isReach() {
        return isReach;
    }

    public BackGround setReach(boolean reach) {
        isReach = reach;
        return this;
    }

    public boolean isBase() {
        return isBase;
    }

    public BackGround setBase(boolean base) {
        isBase = base;
        return this;
    }

    public List<Enemy> getEnemyList() {
        return enemyList;
    }
}

Enamy

package com.sqm;

import java.awt.image.BufferedImage;

public class Enemy implements Runnable
{
    //存储当前坐标
    private int x,y;
    //存储敌人类型
    private int type;
    //判断敌人运动的方向
    private boolean face_to = true;
    //用于显示敌人当前的图像
    private BufferedImage show;
    //定义一个背景对象
    private  BackGround bg;
    //食人花运动的极限范围
    private int max_up = 0;
    private int max_down = 0;
    //定义线程对象实现敌人运动
    private Thread thread = new Thread(this);
    //定义当前图片的状态
    private int image_type = 0;

    //蘑菇敌人的构造函数
    public Enemy(int x, int y, int type, boolean face_to, BackGround bg) {
        this.x = x;
        this.y = y;
        this.type = type;
        this.face_to = face_to;
        this.bg = bg;
        show = StaticValue.mogu.get(0);
        thread.start();
    }

    //食人花敌人构造函数
    public Enemy(int x, int y, int type, boolean face_to, BackGround bg, int max_up, int max_down) {
        this.x = x;
        this.y = y;
        this.type = type;
        this.face_to = face_to;
        this.bg = bg;
        this.max_up = max_up;
        this.max_down = max_down;
        show = StaticValue.flower.get(0);
        thread.start();
    }

    //死亡方法
    public void death()
    {
        show = StaticValue.mogu.get(2);
        this.bg.getEnemyList().remove(this);
    }

    @Override
    public void run() {
        while (true)
        {
            //判断敌人是否是蘑菇敌人
            if (type == 1)
            {
                if (face_to)//true为向左移动
                {
                    this.x -= 2;
                }
                else
                {
                    this.x += 2;
                }
                image_type = image_type == 1 ? 0 : 1;

                show = StaticValue.mogu.get(image_type);
            }

            //定义两个布尔变量,用于判断是否能向左向右移动
            boolean canLeft = true;
            boolean canRight = true;

            for (int i = 0; i < bg.getObstacleList().size(); i++)
            {
              Obstacle ob1 = bg.getObstacleList().get(i);
              //判断是否可以向右走
                if (ob1.getX() == this.x + 36 && ob1.getY() + 65 > this.y && ob1.getY() - 35 < this.y)
                {
                    canRight = false;
                }
                //判断是否可以向左走
                if (ob1.getX() == this.x - 36 && ob1.getY() + 65 > this.y && ob1.getY() - 35 < this.y)
                {
                    canLeft = false;
                }
            }

            if (face_to && !canLeft || this.x == 0)
            {
                face_to = false;
            }
            else if (!face_to && !canRight || this.x == 764)
            {
                face_to = true;
            }

            //判断是否是食人花敌人
            if(type == 2)
            {
                if (face_to)
                {
                    this.y -= 2;
                }
                else
                {
                    this.y += 2;
                }

                image_type = image_type == 1 ? 0 : 1;

                //食人花是否到达极限位置
                if (face_to && this.y == max_up)
                {
                    face_to = false;
                }
                if (!face_to && this.y == max_down)
                {
                    face_to = true;
                }

                show = StaticValue.flower.get(image_type);
            }
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }

    }

    public int getX() {
        return x;
    }

    public int getY() {
        return y;
    }

    public BufferedImage getShow() {
        return show;
    }

    public int getType() {
        return type;
    }
}

Main

package com.sqm;

import javazoom.jl.decoder.JavaLayerException;

import javax.swing.*;
import java.awt.*;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.List;

public class Main extends JFrame implements KeyListener,Runnable
{
    //用于存储所有背景
    private List<BackGround> allBg = new ArrayList<>();
    //用于存储当前背景
    private BackGround nowBg = new BackGround();
    //用于双缓存
    private Image offScreanImage = null;
    //马里奥对象
    private Mario mario = new Mario();
    //定义一个线程对象，用于实现马里奥的运动
    private Thread thread = new Thread(this);

    public Main()
    {
        this.setSize(800,600);
        this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        this.setVisible(true);
        this.setResizable(false);
        this.setLocationRelativeTo(null);
        this.setTitle("Mario");
        this.addKeyListener(this);
        StaticValue.init();
        //初始化马里奥
        mario = new Mario(10,355);
        //创建全部场景
        for (int i = 1; i <= 3; i++) {
            allBg.add(new BackGround(i,i == 3 ? true : false));//bool判断是否是最后一关
        }
        //将第一个场景设置为当前场景
        nowBg = allBg.get(0);
        mario.setBackGround(nowBg);
        //绘制图像
        repaint();
        thread.start();
        try {
            new Music();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (JavaLayerException e) {
            e.printStackTrace();
        }
    }

    public void paint(Graphics g)
    {
        if(offScreanImage == null)
        {
            offScreanImage = createImage(800, 600);
        }

        Graphics graphics = offScreanImage.getGraphics();
        graphics.fillRect(0,0,800,600);

        //绘制背景
        graphics.drawImage(nowBg.getBgImage(),0,0,this);

        //绘制敌人
        for (Enemy e:nowBg.getEnemyList())
        {
            graphics.drawImage(e.getShow(),e.getX(),e.getY(),this);
        }

        //绘制障碍物
        for (Obstacle ob : nowBg.getObstacleList()) {
            graphics.drawImage(ob.getShow(), ob.getX(),ob.getY(),this);
        }

        //绘制城堡
        graphics.drawImage(nowBg.getTower(),620,270,this);
        //绘制旗杆
        graphics.drawImage(nowBg.getGan(),500,220,this);

        //绘制马里奥
        graphics.drawImage(mario.getShow(),mario.getX(),mario.getY(),this);

        //将图像绘制到窗口中
        g.drawImage(offScreanImage,0,0,this);

    }

    public static void main(String[] args)
    {
        Main main = new Main();
    }


    public void keyTyped(KeyEvent e)
    {

    }

    //当键盘按下按键时调用
    public void keyPressed(KeyEvent e)
    {
        //向右移动
        if (e.getKeyCode() == 68)
        {
            mario.rightMove();
        }
        //向左移动
        if (e.getKeyCode() == 65)
        {
            mario.leftMove();
        }
        //跳跃
        if (e.getKeyCode() == 87)
        {
            mario.jump();
        }
    }

    //当键盘松开时使用
    public void keyReleased(KeyEvent e)
    {
        //向右停止
        if (e.getKeyCode() == 68)
        {
            mario.rightStop();
        }
        //向左停止
        if (e.getKeyCode() == 65)
        {
            mario.leftStop();
        }
    }

    @Override
    public void run() {
        while (true)
        {
            repaint();
            try {
                Thread.sleep(50);

                if (mario.getX() >= 775)
                {
                    if(nowBg.getSort()!=3)
                    {
                        nowBg = allBg.get(nowBg.getSort());//第一关的图片索引下标为0，此行代码为前往下一关
                        mario.setBackGround(nowBg);
                        mario.setX(10);
                        mario.setY(355);
                    }

                }

                //判断马里奥是否死亡
                if (mario.isDeath())
                {
                    JOptionPane.showMessageDialog(this,"GAME OVER");
                    System.exit(0);
                }

                //判断游戏是否结束
                if (mario.isOK())
                {
                    JOptionPane.showMessageDialog(this,"恭喜你！成功通关了");
                    System.exit(0);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

Mario

package com.sqm;

import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;

import java.awt.image.BufferedImage;

public class Mario implements Runnable
{
    //移动速度
    static int speed = 5;
    //用于表示横纵坐标
    private int x;
    private int y;
    //用于表示当前状态
    private String status;
    //用于显示当前状态对应的图像
    private BufferedImage show = null;
    //定义一个BackGround对象，用来获取障碍物地点信息
    private BackGround backGround = new BackGround();
    //用来实现马里奥的动作
    private Thread thread = null;
    //马里奥的移动速度
    private  int xSpeed;
    //马里奥的跳跃速度
    private  int ySpeed;
    //定义一个索引
    private int index;
    //表示马里奥的上升时间
    private int upTime = 0;
    //用于判断马里奥是否走到了城堡的门口
    private  boolean isOK;
    //用于判断马里奥是否死亡
    private boolean isDeath = false;

    public Mario() {}

    public Mario(int x, int y) {
        this.x = x;
        this.y = y;
        show = StaticValue.stand_R;
        this.status = "stand--right";
        thread = new Thread(this);
        thread.start();
    }

    //马里奥死亡方法
    public void death()
    {
        isDeath = true;
    }

    //马里奥向左移动
    public void leftMove()
    {
        //改变速度
        xSpeed = -speed;
        //判断马里奥是否碰到旗子
        if (backGround.isReach())
        {
            xSpeed = 0;
        }
        //判断马里奥是否处在空中
        if(status.indexOf("jump") != -1)
        {
            status = "jump--left";
        }
        else
        {
            status = "move--left";
        }
    }

    //马里奥向右移动
    public void rightMove()
    {
        //改变速度
        xSpeed = speed;
        //判断马里奥是否碰到旗子
        if (backGround.isReach())
        {
            xSpeed = 0;
        }
        //判断马里奥是否处在空中
        if(status.indexOf("jump") != -1)
        {
            status = "jump--right";
        }
        else
        {
            status = "move--right";
        }
    }

    //马里奥向左停止
    public void leftStop()
    {
        //改变速度
        xSpeed = 0;
        //判断马里奥是否处在空中
        if(status.indexOf("jump") != -1)
        {
            status = "jump--left";
        }
        else
        {
            status = "stop--left";
        }
    }

    //马里奥向右停止
    public void rightStop()
    {
        //改变速度
        xSpeed = 0;
        //判断马里奥是否处在空中
        if(status.indexOf("jump") != -1)
        {
            status = "jump--right";
        }
        else
        {
            status = "stop--right";
        }
    }

    //马里奥跳跃
    public void jump()
    {
        //判断马里奥是否处于跳跃状态
        if(status.indexOf("jump") == -1)
        {
            if (status.indexOf("left") != -1)
            {
                status = "jump--left";
            }
            else
            {
                status = "jump--right";
            }
            ySpeed = -2 * speed;
            upTime = 7;
        }

        //判断马里奥是否碰到旗子
        if (backGround.isReach())
        {
            ySpeed = 0;
        }
    }

    //马里奥下落
    public void fall()
    {
        if (status.indexOf("left") != -1)
        {
            status = "jump--left";
        }
        else
        {
            status = "jump--right";
        }
        ySpeed = 2 * speed;
    }

    @Override
    public void run()
    {
        while (true)
        {

            //判断是否处于障碍物上
            boolean onObstacle = false;

            //判断是否可以往右走
            boolean canRirht = true;

            //判断是否可以往左走
            boolean canLeft = true;

            //判断马里奥是否到达旗杆位置
            if(backGround.isFlag() && this.x >= 500)
            {
                this.backGround.setReach(true);

                //判断旗子是否下落完成
                if (this.backGround.isBase())
                {
                    status = "move--right";
                    if (x < 690)
                    {
                        x += 5;
                    }
                    else
                    {
                        isOK = true;
                    }
                }
                else
                {
                    if (y < 395)//马里奥在空中
                    {
                        xSpeed = 0;
                        this.y += 5;
                        status = "jump--right";
                    }
                    if (y > 395)
                    {
                        this.y = 395;
                        status = "stop--right";
                    }
                }
            }

            else
            {

                //遍历当前场景里所有的障碍物
                for (int i = 0; i < backGround.getObstacleList().size(); i++) {
                    Obstacle ob = backGround.getObstacleList().get(i);
                    //判断马里奥是否位于障碍物上
                    if (ob.getY() == this.y + 25 && (ob.getX() > this.x - 30 && ob.getX() < this.x + 25)) {
                        onObstacle = true;
                    }

                    //判断是否跳起来顶到砖块
                    if (ob.getY() >= this.y - 30 && ob.getY() <= this.y - 20 && ob.getX() > this.x - 30 && ob.getX() < this.getX() + 25) {
                        if (ob.getType() == 0)//如果类型为0则移除
                        {
                            backGround.getObstacleList().remove(ob);
                        }
                        upTime = 0;//顶到砖块后立刻下落
                    }

                    //判断是否可以往右走
                    if (ob.getX() == this.x + 25 && ob.getY() > this.y - 30 && ob.getY() < this.y + 25) {
                        canLeft = false;
                    }
                    //判断是否可以往左走
                    if (ob.getX() == this.x - 30 && ob.getY() > this.y - 30 && ob.getY() < this.y + 25) {
                        canRirht = false;
                    }

                }

                //判断马里奥是否碰到敌人死亡或者踩死蘑菇敌人
                for (int i = 0; i < backGround.getEnemyList().size(); i++)
                {
                    Enemy e = backGround.getEnemyList().get(i);

                    if (e.getY() == this.y + 20 && e.getX() - 25 <= this.x && e.getX() + 35 >= this.x)//踩死敌人
                    {
                        if (e.getType() == 1)//蘑菇敌人
                        {
                            e.death();
                            upTime = 3;
                            ySpeed = -10;
                        }
                        else if (e.getType() == 2)//踩到食人花，马里奥死亡
                        {
                            death();
                        }

                    }
                    //碰到敌人
                    if (e.getX() + 35 > this.x && e.getX() - 25 < this.x && e.getY() + 35 > this.y && e.getY() - 20 < this.y)
                    {
                        //马里奥死亡
                        death();
                    }

                }

                //进行马里奥跳跃操作
                if (onObstacle && upTime == 0) {
                    if (status.indexOf("left") != -1) {
                        if (xSpeed != 0) {
                            status = "move--left";
                        } else {
                            status = "stop--left";
                        }
                    } else {
                        if (xSpeed != 0) {
                            status = "move--right";
                        } else {
                            status = "stop--right";
                        }
                    }
                } else {
                    if (upTime != 0) {
                        upTime--;
                    } else {
                        fall();
                    }
                    y += ySpeed;
                }
            }
            if((canLeft && xSpeed > 0 )|| (canRirht && xSpeed < 0))
            {
                x += xSpeed;
                //判断马里奥是否到了最左边
                if (x < 0)
                {
                    x = 0;
                }
            }
            //判断当前是否在移动状态
            if(status.contains("move"))
            {
                index = index == 0 ? 1 : 0;
            }
            //判断是否向左移动
            if ("move--left".equals(status))
            {
                show = StaticValue.run_L.get(index);
            }
            //判断是否向右移动
            if ("move--right".equals(status))
            {
                show = StaticValue.run_R.get(index);
            }
            //判断是否向左停止
            if ("stop--left".equals(status))
            {
                show = StaticValue.stand_L;
            }
            //判断是否向右停止
            if ("stop--right".equals(status))
            {
                show = StaticValue.stand_R;
            }
            //判断是否向左跳跃
            if ("jump--left".equals(status))
            {
                show = StaticValue.jump_L;
            }
            //判断是否向右跳跃
            if ("jump--right".equals(status))
            {
                show = StaticValue.jump_R;
            }

            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }

    public int getX() {
        return x;
    }

    public Mario setX(int x) {
        this.x = x;
        return this;
    }

    public int getY() {
        return y;
    }

    public Mario setY(int y) {
        this.y = y;
        return this;
    }

    public BufferedImage getShow() {
        return show;
    }

    public Mario setShow(BufferedImage show) {
        this.show = show;
        return this;
    }

    public Mario setBackGround(BackGround backGround) {
        this.backGround = backGround;
        return this;
    }

    public boolean isOK() {
        return isOK;
    }

    public boolean isDeath() {
        return isDeath;
    }
}

Music

package com.sqm;

import javazoom.jl.decoder.JavaLayerException;
import javazoom.jl.player.Player;

import javax.imageio.ImageIO;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;

public class Music
{
    public Music() throws FileNotFoundException, JavaLayerException {
        Player player;
        InputStream resourceAsStream = Thread.currentThread().getContextClassLoader().getResourceAsStream("Music/music.wav");
        BufferedInputStream name = new BufferedInputStream(resourceAsStream);

        player = new Player(name);
        player.play();
    }
}

Obstacle

package com.sqm;

import java.awt.image.BufferedImage;

public class Obstacle implements Runnable
{
    //坐标
    private int x;
    private int y;
    //用于记录障碍物类型
    private int type;
    //用于显示图像
    private BufferedImage show = null;
    //定义当前场景对象
    private BackGround bg = null;
    //定义一个线程对象完成旗子下落
    private Thread thread = new Thread(this);

    public Obstacle(int x, int y, int type,BackGround bg) {
        this.x = x;
        this.y = y;
        this.type = type;
        this.show = StaticValue.obstacle.get(type);
        this.bg = bg;
        //如果是旗子的话，启动线程
        if (type == 8)
        {
            thread.start();
        }
    }

    public int getX() {
        return x;
    }

    public int getY() {
        return y;
    }

    public int getType() {
        return type;
    }

    public BufferedImage getShow() {
        return show;
    }

    @Override
    public void run() {
        while (true)
        {
            if (this.bg.isReach())//到达旗子
            {
                if (this.y < 374)
                {
                    this.y += 5;
                }
                else
                {
                    this.bg.setBase(true);
                }
            }
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

StaticValue

package com.sqm;

import javax.imageio.ImageIO;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;

public class StaticValue
{
    //背景
    public static BufferedImage bg = null;
    public static BufferedImage bg2 = null;
    //马里奥向左跳
    public static BufferedImage jump_L = null;
    //马里奥向右跳
    public static BufferedImage jump_R = null;
    //马里奥左站立
    public static BufferedImage stand_L = null;
    //马里奥右站立
    public static BufferedImage stand_R = null;
    //城堡
    public static BufferedImage tower = null;
    //旗杆
    public static BufferedImage gan = null;
    //障碍物
    public static List<BufferedImage> obstacle = new ArrayList<>();
    //马里奥向左跑
    public static List<BufferedImage> run_L = new ArrayList<>();
    //马里奥向右跑
    public static List<BufferedImage> run_R = new ArrayList<>();
    //蘑菇敌人
    public static List<BufferedImage> mogu = new ArrayList<>();
    //食人花敌人
    public static List<BufferedImage> flower = new ArrayList<>();

    //获取图片
    public static BufferedImage readImage(String path)
    {
        BufferedImage image = null;
        try
        {
            //返回当前运行文件的目录
            InputStream resourceAsStream = Thread.currentThread().getContextClassLoader().getResourceAsStream("images/" + path);
            image = ImageIO.read(resourceAsStream);
            resourceAsStream.close();
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
        return image;
    }

    //初始化方法
    public static void init()
    {
        //加载背景图片
        bg = readImage("bg.png");
        bg2 = readImage("bg2.png");
        //加载马里奥向左站立
        stand_L = readImage("s_mario_stand_L.png");
        //加载马里奥向右站立
        stand_R = readImage("s_mario_stand_R.png");
        //加载城堡
        tower = readImage("tower.png");
        //加载旗杆
        gan = readImage("gan.png");
        //加载马里奥向左跳跃
        jump_L = readImage("s_mario_jump1_L.png");
        //加载马里奥向右跳跃
        jump_R = readImage("s_mario_jump1_R.png");

        //加载马里奥向左向右跑
        for (int i = 1; i <= 2; i++)
        {
            run_L.add(readImage("s_mario_run" + i + "_L.png"));
            run_R.add(readImage("s_mario_run" + i + "_R.png"));
        }

        //加载障碍物
        obstacle.add(readImage("brick.png"));
        obstacle.add(readImage("soil_up.png"));
        obstacle.add(readImage("soil_base.png"));

        //加载水管
        for (int i = 1; i <= 4; i++)
        {
          obstacle.add(readImage("pipe" + i + ".png"));
        }
        //加载不可破坏的砖块和旗子
        obstacle.add(readImage("brick2.png"));
        obstacle.add(readImage("flag.png"));

        //加载蘑菇敌人
        for (int i = 1; i <= 3; i++) {
            mogu.add(readImage("fungus" + i + ".png"));
        }
        //加载食人花敌人
        for (int i = 1; i <= 2; i++)
        {
            flower.add(readImage("flower1." + i + ".png"));
        }
    }
}