【Java经典小游戏】大鱼吃小鱼 (两万字保姆级教程)

短命女 2024-04-26 03:19 82阅读 0赞

> ?一个人走得远了，就会忘记自己为了什么而出发，希望你可以不忘初心，不要随波逐流，一直走下去?  
> ? 欢迎关注?点赞?收藏?留言?  
> ? 本文由 [程序喵正在路上][Link 1] 原创，CSDN首发！  
> ? 系列专栏：[Java筑基小项目][Java]  
> ? 首发时间：2022年8月21日  
> ✅ 如果觉得博主的文章还不错的话，希望小伙伴们三连支持一下哦

#### 阅读指南 ####

*  一、项目演示
 *  二、项目准备
 *  三、项目实现
 *   *  1 - 创建游戏窗口
     *  2 - 添加背景图片
     *  3 - 制作封面
     *  4 - 启动页面的点击事件
     *  5 - 游戏开始时的背景添加
     *  6 - 双缓存解决闪屏问题
     *  7 - 敌方第一条小雨的添加
     *  8 - 敌方左方小鱼的批量添加
     *  9 - 我方鱼的生成
     *  10 - 我方鱼与敌方小鱼的碰撞测试
     *  11 - 游戏积分的实现
     *  12 - 关卡的设置
     *  13 - 界面优化
     *  14 - 右侧敌方鱼和多种敌方鱼的生成
     *  15 - boss鱼的添加
     *  16 - 游戏暂停功能和重新开始功能的实现
 *  四、源码分享

## 一、项目演示 ##

[点击观看项目演示视频][Link 2]

## 二、项目准备 ##

请移步到源码分享模块下载

## 三、项目实现 ##

### 1 - 创建游戏窗口 ###

创建一个游戏窗口类 **GameWin**，创建一个 **launch()** 启动方法，在其中设置窗口相关属性：

import javax.swing.*;
    
    public class GameWin extends JFrame {
        
        int width = 1440;
        int height = 900;
    
        //创建一个启动方法，设置窗口信息
        public void launch() {
        
            this.setVisible(true);                          //设置窗口可见
            this.setSize(width, height);                    //设置窗口大小
            this.setLocationRelativeTo(null);               //设置窗口居中
            this.setResizable(false);                       //设置窗口大小不可改变
            this.setTitle("大鱼吃小鱼");                     //设置窗口标题
            this.setDefaultCloseOperation(EXIT_ON_CLOSE);   //设置窗口按钮
        }
    }

创建一个游戏窗口测试类 **GameWinDemo**，进行窗口对象的创建和启动方法的调用：

public class GameWinDemo {
        
        public static void main(String[] args) {
        
            //创建一个游戏窗口对象
            GameWin gameWin = new GameWin();
    
            //启动窗口
            gameWin.launch();
        }
    }

![在这里插入图片描述][50efd4cea3604d66944d335304f9b6bb.png]

### 2 - 添加背景图片 ###

将下载的背景图片的文件夹复制到项目文件夹中：

![在这里插入图片描述][af3476b421d64cefaa7921e02ba487e6.png]

创建一个工具类 **GameUtils**，在其中添加背景图片：

import java.awt.*;
    
    public class GameUtils {
        
        public static Image bgimg = Toolkit.getDefaultToolkit().createImage("D:\\IDEA\\idea_Demo\\FishGame\\images\\sea.jpg");
    }

在 **GameWin** 类中添加 **paint** 方法，在其中绘制背景图片：

@Override
    public void paint(Graphics g) {
        
        //用画笔绘制背景图片
        g.drawImage(GameUtils.bgimg, 0, 0, null);
    }

如果发现背景图片加载不出来，先检查一下路径有没有写错，相对路径不行的话就试试绝对路径；有时候加载背景图片会较慢，可以试着将运行出来的窗口最小化后再恢复

![在这里插入图片描述][13cbf66429af4e38a0121c089c3f7862.png]

### 3 - 制作封面 ###

定义默认游戏状态，同时在 **paint** 方法中对游戏状态进行判断进而显示对应的游戏界面：

import javax.swing.*;
    import java.awt.*;
    
    public class GameWin extends JFrame {
        
        int width = 1440;
        int height = 900;
    
        //定义游戏默认状态
        static int state = 0;
    
        //创建一个启动方法，设置窗口信息
        public void launch() {
        
            this.setVisible(true);                          //设置窗口可见
            this.setSize(width, height);                    //设置窗口大小
            this.setLocationRelativeTo(null);               //设置窗口居中
            this.setResizable(false);                       //设置窗口大小不可改变
            this.setTitle("大鱼吃小鱼");                     //设置窗口标题
            this.setDefaultCloseOperation(EXIT_ON_CLOSE);   //设置窗口按钮
        }
    
        @Override
        public void paint(Graphics g) {
        
            //用画笔绘制背景图片
            g.drawImage(GameUtils.bgimg, 0, 0, null);
    
    		//游戏状态：0未开始，1游戏中，2游戏失败，3游戏胜利，4游戏暂停，5重新开始
            switch (state) {
        
                case 0:
                    g.drawImage(GameUtils.bgimg, 0, 0, null);
                    //为启动页面添加文字
                    g.setColor(Color.pink);
                    g.setFont(new Font("仿宋", Font.BOLD, 60));
                    g.drawString("请点击开始游戏", 600, 500);
                    break;
                case 1:
                    break;
                case 2:
                    break;
                case 3:
                    break;
                case 4:
                    break;
                default:
                    break;
            }
        }
    }

![在这里插入图片描述][b699f27852a4450aab3f1bba1b6080d1.png]

### 4 - 启动页面的点击事件 ###

在启动方法中添加鼠标监听器，当点击启动页面时游戏开始

//创建一个启动方法，设置窗口信息
    public void launch() {
        
        this.setVisible(true);                          //设置窗口可见
        this.setSize(width, height);                    //设置窗口大小
        this.setLocationRelativeTo(null);               //设置窗口居中
        this.setResizable(false);                       //设置窗口大小不可改变
        this.setTitle("大鱼吃小鱼");                     //设置窗口标题
        this.setDefaultCloseOperation(EXIT_ON_CLOSE);   //设置窗口按钮
    
        //添加鼠标监听事件
        this.addMouseListener(new MouseAdapter() {
        
            @Override
            public void mouseClicked(MouseEvent e) {
        
                if (e.getButton() == 1 && state == 0) {
        
                    state = 1;
                    repaint();
                }
            }
        });
    }

### 5 - 游戏开始时的背景添加 ###

新建一个背景图的实体类 **Bg**，在 **GameWin** 类里创建其对象，并在 **case 1** 中调用绘制背景图的方法

import java.awt.*;
    
    public class Bg {
        
        void paintSelf(Graphics g) {
        
            g.drawImage(GameUtils.bgimg, 0, 0, null);
        }
    }

由于游戏中需要不断绘制背景图片，所以我们在启动方法中添加一个 **while** 循环，在其中每隔 **40** 毫秒重绘背景图

import javax.swing.*;
    import java.awt.*;
    import java.awt.event.*;
    
    public class GameWin extends JFrame {
        
        int width = 1440;
        int height = 900;
    
        //定义游戏默认状态
        static int state = 0;
    
        //获取背景图类的对象
        Bg bg = new Bg();
    
        //创建一个启动窗口，设置窗口信息
        public void launch() throws InterruptedException {
        
            this.setVisible(true);                          //设置窗口可见
            this.setSize(width, height);                    //设置窗口大小
            this.setLocationRelativeTo(null);               //设置窗口居中
            this.setResizable(false);                       //设置窗口大小不可改变
            this.setTitle("大鱼吃小鱼");                     //设置窗口标题
            this.setDefaultCloseOperation(EXIT_ON_CLOSE);   //设置窗口按钮
    
            //添加鼠标监听事件
            this.addMouseListener(new MouseAdapter() {
        
                @Override
                public void mouseClicked(MouseEvent e) {
        
                    if (e.getButton() == 1 && state == 0) {
        
                        state = 1;
                        repaint();
                    }
                }
            });
    
            //背景图片重复使用，需要重复调用repaint方法
            while(true) {
        
                repaint();
                Thread.sleep(40);
            }
        }
    
        @Override
        public void paint(Graphics g) {
        
            //用画笔绘制背景图片
            g.drawImage(GameUtils.bgimg, 0, 0, null);
    
            switch (state) {
        
                case 0:
                    g.drawImage(GameUtils.bgimg, 0, 0, null);
                    //为启动页面添加文字
                    g.setColor(Color.pink);
                    g.setFont(new Font("仿宋", Font.BOLD, 60));
                    g.drawString("请点击开始游戏", 500, 500);
                    break;
                case 1:
                    bg.paintSelf(g);
                    break;
                case 2:
                    break;
                case 3:
                    break;
                case 4:
                    break;
                default:
                    break;
            }
        }
    }

### 6 - 双缓存解决闪屏问题 ###

如果此时你的屏幕出现闪烁的情况，可以用下面的方法解决

整体思路为：

重新创建一个空的图片，将所有的组件先绘制到空的图片上，然后把绘制好的图片一次性地绘制到主窗口上

创建一个空图片对象，在 **paint** 方法中将所有组件绘制到空图片上，再一次性绘制到主窗口上

public class GameWin extends JFrame {
        
        int width = 1440;
        int height = 900;
    
        //定义游戏默认状态
        static int state = 0;
    
        //获取背景图类的对象
        Bg bg = new Bg();
    
        //创建一个空图片对象
        Image offScreenImage;
    
        //创建一个启动窗口，设置窗口信息
        public void launch() throws InterruptedException {
        
            this.setVisible(true);                          //设置窗口可见
            this.setSize(width, height);                    //设置窗口大小
            this.setLocationRelativeTo(null);               //设置窗口居中
            this.setResizable(false);                       //设置窗口大小不可改变
            this.setTitle("大鱼吃小鱼");                     //设置窗口标题
            this.setDefaultCloseOperation(EXIT_ON_CLOSE);   //设置窗口按钮
    
            //添加鼠标监听事件
            this.addMouseListener(new MouseAdapter() {
        
                @Override
                public void mouseClicked(MouseEvent e) {
        
                    if (e.getButton() == 1 && state == 0) {
        
                        state = 1;
                        repaint();
                    }
                }
            });
    
            //背景图片重复使用，需要重复调用repaint方法
            while (true) {
        
                repaint();
                Thread.sleep(40);
            }
        }
    
        @Override
        public void paint(Graphics g) {
        
            //懒加载模式初始化对象
            offScreenImage = createImage(width, height);
            Graphics gImage = offScreenImage.getGraphics();     //获取图片对应的画笔对象
    
            switch (state) {
        
                case 0:
                    //把组件重新绘制到主窗口中
                    gImage.drawImage(GameUtils.bgimg, 0, 0, null);
                    //为启动页面添加文字
                    gImage.setColor(Color.pink);
                    gImage.setFont(new Font("仿宋", Font.BOLD, 60));
                    gImage.drawString("请点击开始游戏", 500, 500);
                    break;
                case 1:
                    bg.paintSelf(gImage);
                    break;
                case 2:
                    break;
                case 3:
                    break;
                case 4:
                    break;
                default:
                    break;
            }
    
            //将绘制好的图片一次性绘制到主窗口中
            g.drawImage(offScreenImage, 0, 0, null);
        }
    }

### 7 - 敌方第一条小雨的添加 ###

新建敌方鱼的父类 **Enamy**，编写左敌方鱼类 **Enamy\_1\_L** 继承父类

import java.awt.*;
    
    public class Enamy {
        
        //定义图片
        Image img;
    
        //定义物体坐标
        int x;
        int y;
        int width;
        int height;
    
        //移动速度
        int speed;
    
        //方向
        int dir = 1;
    
        //敌方鱼的类型、分值
        int type;
        int count;
    
        //绘制自身方法
        public void paintSelf(Graphics g) {
        
            g.drawImage(img, x, y, width, height, null);
        }
    
        //获取自身矩形用于碰撞检测
        public Rectangle getRec() {
        
            return new Rectangle(x, y, width, height);
        }
    }
    
    //左敌方鱼类
    class Enamy_1_L extends Enamy {
        
        Enamy_1_L() {
        
            this.x = -45;
            this.y = (int) (Math.random() * 700 + 100);
            this.width = 45;
            this.height = 69;
            this.speed = 10;
            this.count = 1;
            this.img = GameUtils.enamy_l_img;
        }
    }

在 **GameUtils** 类中添加左敌方鱼类的图片

public class GameUtils {
        
        //背景图
        public static Image bgimg = Toolkit.getDefaultToolkit().createImage("D:\\IDEA\\idea_Demo\\FishGame\\images\\sea.jpg");
    
        //敌方鱼类
        public static Image enamy_l_img = Toolkit.getDefaultToolkit().createImage("D:\\IDEA\\idea_Demo\\FishGame\\images\\enemyFish\\fish1_r.gif");
    }

在 **GameWin** 类中创建左敌方鱼类对象并在 **case 1** 的情况下绘制左敌方鱼类

public class GameWin extends JFrame {
        
        //......
    
        //敌方鱼类
        Enamy enamy = new Enamy_1_L();
    
        //创建一个启动窗口，设置窗口信息
        public void launch() throws InterruptedException {
        
            //......
        }
    
        @Override
        public void paint(Graphics g) {
        
            //懒加载模式初始化对象
            offScreenImage = createImage(width, height);
            Graphics gImage = offScreenImage.getGraphics();     //获取图片对应的画笔对象
    
            switch (state) {
        
                case 0:
                    //把组件重新绘制到主窗口中
                    gImage.drawImage(GameUtils.bgimg, 0, 0, null);
                    //为启动页面添加文字
                    gImage.setColor(Color.pink);
                    gImage.setFont(new Font("仿宋", Font.BOLD, 60));
                    gImage.drawString("请点击开始游戏", 500, 500);
                    break;
                case 1:
                    bg.paintSelf(gImage);
                    enamy.paintSelf(gImage);
                    enamy.x += enamy.speed;
                    break;
                case 2:
                    break;
                case 3:
                    break;
                case 4:
                    break;
                default:
                    break;
            }
    
            //将绘制好的图片一次性绘制到主窗口中
            g.drawImage(offScreenImage, 0, 0, null);
        }
    }

![在这里插入图片描述][56a9531be7204384bde4fc90d97c11dc.png]

### 8 - 敌方左方小鱼的批量添加 ###

在工具类中创建一个所有敌方鱼物体的集合

public class GameUtils {
        
        //敌方鱼类集合
        public static List<Enamy> EnamyList = new ArrayList<>();
        
        //......
    }

在窗口类中添加一个方法，用于批量添加敌方鱼类

public class GameWin extends JFrame {
        
        //......
    
        //敌方鱼类
        Enamy enamy;
    
        //计数器，用来记录游戏的重绘次数，也是鱼生成的数量
        int time = 0;
    
        //创建一个启动窗口，设置窗口信息
        public void launch() throws InterruptedException {
        
            //......
            });
    
            //背景图片重复使用，需要重复调用repaint方法
            while (true) {
        
                repaint();
                time++;
                Thread.sleep(40);
            }
        }
    
        @Override
        public void paint(Graphics g) {
        
            //懒加载模式初始化对象
            offScreenImage = createImage(width, height);
            Graphics gImage = offScreenImage.getGraphics();     //获取图片对应的画笔对象
    
            switch (state) {
        
                case 0:
                    //......
                case 1:
                    bg.paintSelf(gImage);
                    logic();        //不断添加敌方鱼类
                    //遍历敌方鱼类集合，绘制敌方鱼类
                    for (Enamy enamy : GameUtils.EnamyList) {
        
                        enamy.paintSelf(gImage);
                    }
                    break;
                case 2:
                    break;
                case 3:
                    break;
                case 4:
                    break;
                default:
                    break;
            }
    
            //将绘制好的图片一次性绘制到主窗口中
            g.drawImage(offScreenImage, 0, 0, null);
        }
    
        //批量添加鱼类
        void logic() {
        
            //每重绘10次生成一条敌方鱼类
            if (time % 10 == 0) {
        
                enamy = new Enamy_1_L();
                GameUtils.EnamyList.add(enamy);
            }
    
            //移动方向
            for (Enamy enamy : GameUtils.EnamyList) {
        
                enamy.x = enamy.x + enamy.dir * enamy.speed;
            }
        }
    }

![在这里插入图片描述][91c070b5f8c840e2b3522c08f3735b3c.png]

### 9 - 我方鱼的生成 ###

在工具类中添加我方鱼类的图片

public class GameUtils {
        
        //......
        
        //我方鱼类
        public static Image myFishImg_L = Toolkit.getDefaultToolkit().createImage("D:\\IDEA\\idea_Demo\\FishGame\\images\\myFish\\myfish_left.gif");
        public static Image myFishImg_R = Toolkit.getDefaultToolkit().createImage("D:\\IDEA\\idea_Demo\\FishGame\\images\\myFish\\myfish_right.gif");
    }

创建我方鱼类

import java.awt.*;
    
    public class MyFish {
        
        //图片
        Image img = GameUtils.myFishImg_L;
        //坐标
        int x = 700;
        int y = 500;
        int width = 50;
        int height = 50;
        //移动速度
        int speed = 20;
        //等级
        int level = 1;
    
        //绘制自身的方法
        public void paintSelf(Graphics g) {
        
            g.drawImage(img, x, y, width, height, null);
        }
    
        //获取自身矩形的方法
        public Rectangle getRec() {
        
            return new Rectangle(x, y, width, height);
        }
    }

在窗口类中获取我方鱼的对象

//我方鱼类
    MyFish myFish = new MyFish();

在工具类中添加方向判定，用来控制我方鱼的方向

public class GameUtils {
        
        //方向
        static boolean UP = false;
        static boolean DOWN = false;
        static boolean LEFT = false;
        static boolean RIGHT = false;
    
        //......
    }

在我方鱼类添加一个方法，实现对键盘的控制

public class MyFish {
        
        //......
    
        //绘制自身的方法
        public void paintSelf(Graphics g) {
        
        	//调用方法
            logic();
            g.drawImage(img, x, y, width, height, null);
        }
    
        //......
    
        void logic() {
        
            if (GameUtils.UP) {
        
                y = y - speed;
            }
            if (GameUtils.DOWN) {
        
                y = y + speed;
            }
    
            if (GameUtils.LEFT) {
        
                x = x - speed;
                img = GameUtils.myFishImg_L;
            }
            if (GameUtils.RIGHT) {
        
                x = x + speed;
                img = GameUtils.myFishImg_R;
            }
        }
    }

在窗口类的 **paint** 方法的 **case 1** 中，添加我方鱼类所创造的方法

import javax.swing.*;
    import java.awt.*;
    import java.awt.event.KeyAdapter;
    import java.awt.event.KeyEvent;
    import java.awt.event.MouseAdapter;
    import java.awt.event.MouseEvent;
    
    public class GameWin extends JFrame {
        
        //......
    
        //我方鱼类
        MyFish myFish = new MyFish();
    
        //创建一个启动窗口，设置窗口信息
        public void launch() throws InterruptedException {
        
            //......
            });
    
            //键盘移动
            this.addKeyListener(new KeyAdapter() {
        
                @Override//按压
                public void keyPressed(KeyEvent e) {
        
                    //上下左右四个键的ASCII值为 上 ↑:38下 ↓: 40左 ←: 37右 →: 39
                    if (e.getKeyCode() == 38) {
        
                        GameUtils.UP = true;
                    }
                    if (e.getKeyCode() == 40) {
        
                        GameUtils.DOWN = true;
                    }
                    if (e.getKeyCode() == 37) {
        
                        GameUtils.LEFT = true;
                    }
                    if (e.getKeyCode() == 39) {
        
                        GameUtils.RIGHT = true;
                    }
                }
    
                @Override//抬起
                public void keyReleased(KeyEvent e) {
        
                    if (e.getKeyCode() == 38) {
        
                        GameUtils.UP = false;
                    }
                    if (e.getKeyCode() == 40) {
        
                        GameUtils.DOWN = false;
                    }
                    if (e.getKeyCode() == 37) {
        
                        GameUtils.LEFT = false;
                    }
                    if (e.getKeyCode() == 39) {
        
                        GameUtils.RIGHT = false;
                    }
                }
            });
    
            //......
        }
    
        @Override
        public void paint(Graphics g) {
        
            //懒加载模式初始化对象
            offScreenImage = createImage(width, height);
            Graphics gImage = offScreenImage.getGraphics();     //获取图片对应的画笔对象
    
            switch (state) {
        
                case 0:
                    //......
                    break;
                case 1:
                    bg.paintSelf(gImage);
                    myFish.paintSelf(gImage);
                    logic();        //不断添加敌方鱼类
                    for (Enamy enamy : GameUtils.EnamyList) {
        
                        enamy.paintSelf(gImage);
                    }
                    break;
                case 2:
                    break;
                case 3:
                    break;
                case 4:
                    break;
                default:
                    break;
            }
    
            //将绘制好的图片一次性绘制到主窗口中
            g.drawImage(offScreenImage, 0, 0, null);
        }
    
        //批量添加鱼类
        void logic() {
        
            //......
        }
    }

![在这里插入图片描述][9639a61ab8e6481eb8e4c2a2626195a0.png]

### 10 - 我方鱼与敌方小鱼的碰撞测试 ###

在游戏中所有物体被视为矩形，两个物体是否碰撞，即检测两个物体的所在矩形是否有重叠部分

具体检测，就是让我方鱼与敌方鱼的矩形进行一一检测，在窗口类的 **logic()** 方法中实现

//批量添加鱼类
    void logic() {
        
        //每重绘10次生成一条敌方鱼类
        if (time % 10 == 0) {
        
            enamy = new Enamy_1_L();
            GameUtils.EnamyList.add(enamy);
        }
    
        //移动方向
        for (Enamy enamy : GameUtils.EnamyList) {
        
            enamy.x = enamy.x + enamy.dir * enamy.speed;
    
            //我方鱼与敌方鱼的碰撞检测
            if (myFish.getRec().intersects(enamy.getRec())) {
        
                enamy.x = -200;
                enamy.y = -200;
            }
        }
    }

![在这里插入图片描述][74e627dbee0449228be7b068d0a7f259.png]

### 11 - 游戏积分的实现 ###

在工具类中定义分数

//分数
    static int count = 0;

在窗口类中实现我方鱼吃掉敌方鱼增加分数，同时在页面上打印分数

public class GameWin extends JFrame {
        
        //......
    
        @Override
        public void paint(Graphics g) {
        
            //懒加载模式初始化对象
            offScreenImage = createImage(width, height);
            Graphics gImage = offScreenImage.getGraphics();     //获取图片对应的画笔对象
    
            switch (state) {
        
                case 0:
                    //......
                case 1:
                    bg.paintSelf(gImage);
                    //*******打印所得积分********
                    gImage.setColor(Color.ORANGE);
                    gImage.setFont(new Font("仿宋", Font.BOLD, 50));
                    gImage.drawString("积分：" + GameUtils.count, 200, 120);
                    myFish.paintSelf(gImage);
                    logic();        //不断添加敌方鱼类
                    for (Enamy enamy : GameUtils.EnamyList) {
        
                        enamy.paintSelf(gImage);
                    }
                    break;
                case 2:
                    break;
                case 3:
                    break;
                case 4:
                    break;
                default:
                    break;
            }
    
            //......
    
        //批量添加鱼类
        void logic() {
        
            //......
    
            //移动方向
            for (Enamy enamy : GameUtils.EnamyList) {
        
                enamy.x = enamy.x + enamy.dir * enamy.speed;
    
                //我方鱼与敌方鱼的碰撞检测
                if (myFish.getRec().intersects(enamy.getRec())) {
        
                    enamy.x = -200;
                    enamy.y = -200;
                    //********得分********
                    GameUtils.count += enamy.count;
                }
            }
        }
    }

在我方鱼类中实现吃掉敌方鱼后，我方鱼体积增加

public class MyFish {
        
        //......
    
        //绘制自身的方法
        public void paintSelf(Graphics g) {
        
            logic();
            g.drawImage(img, x, y, width + GameUtils.count, height + GameUtils.count, null);
        }
    
        //获取自身矩形的方法
        public Rectangle getRec() {
        
            return new Rectangle(x, y, width + GameUtils.count, height + GameUtils.count);
        }
    
       //......
    }

![在这里插入图片描述][3a13195772bc47a0b769b80643e11319.png]

### 12 - 关卡的设置 ###

根据积分来实现关卡的设置，如果达到目标积分则过关，并增加我方鱼的等级

在工具类中定义关卡等级

//关卡等级
    static int level = 0;

在窗口类的 **logic()** 方法中设置关卡

public class GameWin extends JFrame {
        
        //......
    
        @Override
        public void paint(Graphics g) {
        
            //懒加载模式初始化对象
            offScreenImage = createImage(width, height);
            Graphics gImage = offScreenImage.getGraphics();     //获取图片对应的画笔对象
    
            switch (state) {
        
                case 0:
                    //......
                    break;
                case 1:
                    //......
                    break;
                case 2:
                    break;
                case 3: //玩家胜利
                	bg.paintSelf(gImage);
                    myFish.paintSelf(gImage);
                    gImage.setColor(Color.ORANGE);
                    gImage.setFont(new Font("仿宋", Font.BOLD, 80));
                    gImage.drawString("积分: " + GameUtils.count, 200, 120);
                    gImage.drawString("胜利", 400, 500);
                    break;
                case 4:
                    break;
                default:
                    break;
            }
    
            //将绘制好的图片一次性绘制到主窗口中
            g.drawImage(offScreenImage, 0, 0, null);
        }
    
        //批量添加鱼类
        void logic() {
        
            //关卡难度
            if (GameUtils.count < 5) {
        
                GameUtils.level = 0;
                myFish.level = 1;
            } else if (GameUtils.count <= 15) {
        
                GameUtils.level = 1;
            } else if (GameUtils.count <= 50) {
        
                GameUtils.level = 2;
                myFish.level = 2;
            } else if (GameUtils.count <= 150) {
        
                GameUtils.level = 3;
                myFish.level = 3;
            } else if (GameUtils.count <= 300) {
        
                GameUtils.level = 4;
                myFish.level = 3;
            } else {
         //分数大于300，玩家胜利
                state = 3;
            }
    
            //......
        }
    }

![在这里插入图片描述][66aac17105174f03b93fa46b9ec81bf8.png]

### 13 - 界面优化 ###

实现游戏界面积分、难度、关卡的可视化编写

在工具类中定义绘制文字的方法

//绘制文字的方法
    public static void drawWord(Graphics g, String str, Color color, int size, int x, int y) {
        
        g.setColor(color);
        g.setFont(new Font("仿宋", Font.BOLD, size));
        g.drawString(str, x, y);
    }

在背景类中让积分、难度、我方鱼等级可视化

public class Bg {
        
        void paintSelf(Graphics g, int fishLevel) {
        
            g.drawImage(GameUtils.bgimg, 0, 0, null);
            switch (GameWin.state) {
        
                case 0:
                    GameUtils.drawWord(g, "请点击开始游戏", Color.RED, 80, 500, 500);
                    break;
                case 1:
                    GameUtils.drawWord(g, "积分:" + GameUtils.count, Color.ORANGE, 50, 200, 120);
                    GameUtils.drawWord(g, "难度:" + GameUtils.level, Color.ORANGE, 50, 600, 120);
                    GameUtils.drawWord(g, "等级:" + fishLevel, Color.ORANGE, 50, 1000, 120);
                    break;
                case 2:
                    break;
                case 3:
                    GameUtils.drawWord(g, "积分:" + GameUtils.count, Color.ORANGE, 50, 200, 120);
                    GameUtils.drawWord(g, "难度:" + GameUtils.level, Color.ORANGE, 50, 600, 120);
                    GameUtils.drawWord(g, "等级:" + fishLevel, Color.ORANGE, 50, 1000, 120);
                    GameUtils.drawWord(g, "胜利", Color.RED, 80, 700, 500);
                    break;
                default:
                    break;
            }
        }
    }

对窗口类的 **paint** 方法进行优化

@Override
    public void paint(Graphics g) {
        
        //懒加载模式初始化对象
        offScreenImage = createImage(width, height);
        Graphics gImage = offScreenImage.getGraphics();     //获取图片对应的画笔对象
        bg.paintSelf(gImage, myFish.level);  //***********************
    
        //游戏状态：0未开始，1游戏中，2游戏失败，3游戏胜利，4游戏暂停，5重新开始
        switch (state) {
        
            case 0:
                break;
            case 1:
                myFish.paintSelf(gImage);
                logic();        //不断添加敌方鱼类
                for (Enamy enamy : GameUtils.EnamyList) {
        
                    enamy.paintSelf(gImage);
                }
                break;
            case 2:
                break;
            case 3: //玩家胜利
                myFish.paintSelf(gImage);
                break;
            case 4:
                break;
            default:
                break;
        }
    
        //将绘制好的图片一次性绘制到主窗口中
        g.drawImage(offScreenImage, 0, 0, null);
    }

### 14 - 右侧敌方鱼和多种敌方鱼的生成 ###

首先实现右侧敌方小鱼的生成，在工具类中添加右侧敌方小鱼的图

在敌方鱼类中创建敌方小鱼右类继承敌方小鱼左类

//右敌方鱼类
    class Enamy_1_R extends Enamy_1_L {
        
        Enamy_1_R() {
        
            this.x = 1400;
            dir = -1;
            this.img = GameUtils.enamy_r_img;
        }
    }

在窗口类中定义随机数，使左右敌方小鱼随机出现

public class GameWin extends JFrame {
        
        //......
    
        //定义一个随机数，以此让左右鱼的数量随机
        double random;
    
        //......
    
            random = Math.random();
    
            //每重绘10次生成一条敌方鱼类
            if (time % 10 == 0) {
        
                if (random > 0.5) {
        
                    enamy = new Enamy_1_L();
                } else {
        
                    enamy = new Enamy_1_R();
                }
                GameUtils.EnamyList.add(enamy);
            }
    
            //......
    }

![在这里插入图片描述][b303a775beef45c5a0f9847d1f52bc9c.png]

接下来是其他敌方鱼类的生成，其原理与敌方小鱼的生成原理一致

在窗口类添加敌方鱼图

//敌方鱼类
    public static Image enamy_l_img = Toolkit.getDefaultToolkit().createImage("D:\\IDEA\\idea_Demo\\FishGame\\images\\enemyFish\\fish1_r.gif");
    public static Image enamy_r_img = Toolkit.getDefaultToolkit().createImage("D:\\IDEA\\idea_Demo\\FishGame\\images\\enemyFish\\fish1_l.gif");
    public static Image enamy_l_2img = Toolkit.getDefaultToolkit().createImage("D:\\IDEA\\idea_Demo\\FishGame\\images\\enemyFish\\fish2_r.png");
    public static Image enamy_r_2img = Toolkit.getDefaultToolkit().createImage("D:\\IDEA\\idea_Demo\\FishGame\\images\\enemyFish\\fish2_l.png");
    public static Image enamy_l_3img = Toolkit.getDefaultToolkit().createImage("D:\\IDEA\\idea_Demo\\FishGame\\images\\enemyFish\\fish3_r.png");
    public static Image enamy_r_3img = Toolkit.getDefaultToolkit().createImage("D:\\IDEA\\idea_Demo\\FishGame\\images\\enemyFish\\fish3_l.png");

创建剩下的敌方鱼类并写入参数

class Enamy_2_L extends Enamy {
        
        Enamy_2_L() {
        
            this.x = -100;
            this.y = (int) (Math.random() * 700 + 100);
            this.width = 100;
            this.height = 100;
            this.speed = 5;
            this.count = 2;
            this.type = 2;
            this.img = GameUtils.enamy_l_2img;
        }
    }
    
    class Enamy_2_R extends Enamy_2_L {
        
        Enamy_2_R() {
        
            this.x = 1400;
            dir = -1;
            this.img = GameUtils.enamy_r_2img;
        }
    }
    
    class Enamy_3_L extends Enamy {
        
        Enamy_3_L() {
        
            this.x = -300;
            this.y = (int) (Math.random() * 700 + 100);
            this.width = 300;
            this.height = 150;
            this.speed = 15;
            this.count = 5;
            this.type = 3;
            this.img = GameUtils.enamy_l_3img;
        }
    	
    	//由于第3种鱼的体积过大，我们需要将其修改一下
        public Rectangle getRec() {
        
            return new Rectangle(x + 40, y + 30, width - 80, height - 60);
        }
    }
    
    class Enamy_3_R extends Enamy_3_L {
        
        Enamy_3_R() {
        
            this.x = 1400;
            dir = -1;
            this.img = GameUtils.enamy_r_3img;
        }
    }

在窗口类种添加敌方鱼的生成，添加我方鱼和敌方鱼的等级比较来判断游戏是否失败，同时游戏失败界面只剩下敌方鱼类

public class GameWin extends JFrame {
        
        //......
    
        @Override
        public void paint(Graphics g) {
        
            //懒加载模式初始化对象
            offScreenImage = createImage(width, height);
            Graphics gImage = offScreenImage.getGraphics();     //获取图片对应的画笔对象
            bg.paintSelf(gImage, myFish.level);
    
            //游戏状态：0未开始，1游戏中，2游戏失败，3游戏胜利，4游戏暂停，5重新开始
            switch (state) {
        
                case 0:
                    break;
                case 1:
                    myFish.paintSelf(gImage);
                    logic();        //不断添加敌方鱼类
                    for (Enamy enamy : GameUtils.EnamyList) {
        
                        enamy.paintSelf(gImage);
                    }
                    break;
                case 2:
                	//*********游戏失败界面*********
                    logic();        //不断添加敌方鱼类
                    for (Enamy enamy : GameUtils.EnamyList) {
        
                        enamy.paintSelf(gImage);
                    }
                    break;
                case 3: //玩家胜利
                    myFish.paintSelf(gImage);
                    break;
                case 4:
                    break;
                default:
                    break;
            }
    
            //将绘制好的图片一次性绘制到主窗口中
            g.drawImage(offScreenImage, 0, 0, null);
        }
    
        //批量添加鱼类
        void logic() {
        
            //......
    
            random = Math.random();
    
    		//********根据游戏等级生成鱼类********
            switch (GameUtils.level) {
        
                case 4:
                case 3:
                case 2:
                    if (time % 30 == 0) {
        
                        if (random > 0.5) {
        
                            enamy = new Enamy_3_L();
                        } else {
        
                            enamy = new Enamy_3_R();
                        }
                        GameUtils.EnamyList.add(enamy);
                    }
                case 1:
                    if (time % 20 == 0) {
        
                        if (random > 0.5) {
        
                            enamy = new Enamy_2_L();
                        } else {
        
                            enamy = new Enamy_2_R();
                        }
                        GameUtils.EnamyList.add(enamy);
                    }
                case 0:
                    //每重绘10次生成一条敌方鱼类
                    if (time % 10 == 0) {
        
                        if (random > 0.5) {
        
                            enamy = new Enamy_1_L();
                        } else {
        
                            enamy = new Enamy_1_R();
                        }
                        GameUtils.EnamyList.add(enamy);
                    }
                    break;
                default:
                    break;
            }
    
    
            //移动方向
            for (Enamy enamy : GameUtils.EnamyList) {
        
                enamy.x = enamy.x + enamy.dir * enamy.speed;
    
                //我方鱼与敌方鱼的碰撞检测
                if (myFish.getRec().intersects(enamy.getRec())) {
        
                	//********如果我方鱼的等级大于等于敌方鱼*******
                    if (myFish.level >= enamy.type) {
         
                        enamy.x = -200;
                        enamy.y = -200;
                        //得分
                        GameUtils.count += enamy.count;
                    } else {
        
                        state = 2;
                    }
                }
            }
        }
    }

背景类优化：

public class Bg {
        
        void paintSelf(Graphics g, int fishLevel) {
        
            g.drawImage(GameUtils.bgimg, 0, 0, null);
            switch (GameWin.state) {
        
                case 0 -> GameUtils.drawWord(g, "请点击开始游戏", Color.RED, 80, 500, 500);
                case 1 -> {
        
                    GameUtils.drawWord(g, "积分:" + GameUtils.count, Color.ORANGE, 50, 200, 120);
                    GameUtils.drawWord(g, "难度:" + GameUtils.level, Color.ORANGE, 50, 600, 120);
                    GameUtils.drawWord(g, "等级:" + fishLevel, Color.ORANGE, 50, 1000, 120);
                }
                case 2 -> {
        
                    GameUtils.drawWord(g, "积分:" + GameUtils.count, Color.ORANGE, 50, 200, 120);
                    GameUtils.drawWord(g, "难度:" + GameUtils.level, Color.ORANGE, 50, 600, 120);
                    GameUtils.drawWord(g, "等级:" + fishLevel, Color.ORANGE, 50, 1000, 120);
                    GameUtils.drawWord(g, "失败", Color.RED, 80, 600, 500);
                }
                case 3 -> {
        
                    GameUtils.drawWord(g, "积分:" + GameUtils.count, Color.ORANGE, 50, 200, 120);
                    GameUtils.drawWord(g, "难度:" + GameUtils.level, Color.ORANGE, 50, 600, 120);
                    GameUtils.drawWord(g, "等级:" + fishLevel, Color.ORANGE, 50, 1000, 120);
                    GameUtils.drawWord(g, "胜利", Color.RED, 80, 700, 500);
                }
                default -> {
        
                }
            }
        }
    }

![在这里插入图片描述][b3b75ca7febd4096984e76df04e9db81.png]

### 15 - boss鱼的添加 ###

在工具类中添加敌方 **boss** 鱼

public static Image boss_img = Toolkit.getDefaultToolkit().createImage("D:\\IDEA\\idea_Demo\\FishGame\\images\\enemyFish\\boss.gif");

创建敌方 **boss** 鱼类继承父类

class Enamy_Boss extends Enamy {
        
        Enamy_Boss() {
        
            this.x = -1000;
            this.y = (int) (Math.random()*700 + 100);
            this.width = 340;
            this.height = 340;
            this.speed = 100;
            this.count = 0;
            this.type = 10;
            this.img = GameUtils.boss_img;
        }
    }

在窗口类中获取敌方 **boss** 鱼类，在游戏等级为 **4** 的代码块中，添加 **boss** 生成的条件，同时对 **boss** 和我方鱼类及其他鱼类碰撞的情况做出处理

public class GameWin extends JFrame {
        
        //......
    
        //敌方boss类
        Enamy boss;
        //是否生成boss
        boolean isboss = false;
    
        //创建一个启动窗口，设置窗口信息
        public void launch() throws InterruptedException {
        
            //......
        }
    
        @Override
        public void paint(Graphics g) {
        
            //懒加载模式初始化对象
            offScreenImage = createImage(width, height);
            Graphics gImage = offScreenImage.getGraphics();     //获取图片对应的画笔对象
            bg.paintSelf(gImage, myFish.level);
    
            //游戏状态：0未开始，1游戏中，2游戏失败，3游戏胜利，4游戏暂停，5重新开始
            switch (state) {
        
                case 0:
                    break;
                case 1:
                    myFish.paintSelf(gImage);
                    logic();        //不断添加敌方鱼类
                    for (Enamy enamy : GameUtils.EnamyList) {
        
                        enamy.paintSelf(gImage);
                    }
                    //********boss鱼的生成********
                    if (isboss) {
        
                        boss.x += boss.dir * boss.speed;
                        boss.paintSelf(gImage);
                        if (boss.x < 0) {
        
                            gImage.setColor(Color.RED);
                            gImage.fillRect(boss.x, boss.y, 2400, boss.height / 30);
                        }
                    }
                    break;
                case 2:
                    logic();        //不断添加敌方鱼类
                    for (Enamy enamy : GameUtils.EnamyList) {
        
                        enamy.paintSelf(gImage);
                    }
                    //********添加敌方boss********
                    if (isboss) {
        
                        boss.paintSelf(gImage);
                    }
                    break;
                case 3: //玩家胜利
                    myFish.paintSelf(gImage);
                    break;
                case 4:
                    break;
                default:
                    break;
            }
    
            //将绘制好的图片一次性绘制到主窗口中
            g.drawImage(offScreenImage, 0, 0, null);
        }
    
        //批量添加鱼类
        void logic() {
        
            //关卡难度
            if (GameUtils.count < 5) {
        
                GameUtils.level = 0;
                myFish.level = 1;
            } else if (GameUtils.count <= 15) {
        
                GameUtils.level = 1;
            } else if (GameUtils.count <= 50) {
        
                GameUtils.level = 2;
                myFish.level = 2;
            } else if (GameUtils.count <= 150) {
        
                GameUtils.level = 3;
                myFish.level = 3;
            } else if (GameUtils.count <= 300) {
        
                GameUtils.level = 4;
                myFish.level = 3;
            } else {
         //分数大于300，玩家胜利
                state = 3;
            }
    
            random = Math.random();
    
            switch (GameUtils.level) {
        
                case 4:
                	//********判断是否生成boss********
                    if (time % 60 == 0) {
        
                        if (random > 0) {
        
                            boss = new Enamy_Boss();
                            isboss = true;
                        }
                    }
                case 3:
                case 2:
                    //......
                case 1:
                   //......
                case 0:
                    //......
                default:
                    break;
            }
    
    
            //移动方向
            for (Enamy enamy : GameUtils.EnamyList) {
        
                enamy.x = enamy.x + enamy.dir * enamy.speed;
    
                //********boss鱼的碰撞处理********
                if (isboss) {
        
                    if (boss.getRec().intersects(enamy.getRec())) {
        
                        enamy.x = -200;
                        enamy.y = -200;
                    }
                    if (boss.getRec().intersects(myFish.getRec())) {
        
                        state = 2;
                    }
                }
    
                //......
            }
        }
    }

![在这里插入图片描述][8bcae6560b2f4d15b01c6f3a2bd1d7c4.png]

### 16 - 游戏暂停功能和重新开始功能的实现 ###

首先实现暂停功能，如果游戏状态为 **4**，则游戏暂停，我们使用空格键来实现游戏暂停功能

在 **launch** 方法中添加键盘的监听事件

public class GameWin extends JFrame {
        
        //......
    
        //创建一个启动窗口，设置窗口信息
        public void launch() throws InterruptedException {
        
            //......
    
            //键盘移动
            this.addKeyListener(new KeyAdapter() {
        
                @Override//按压
                public void keyPressed(KeyEvent e) {
        
                    //上下左右四个键的ASCII值为 上 ↑:38下 ↓: 40左 ←: 37右 →: 39
                    if (e.getKeyCode() == 38) {
        
                        GameUtils.UP = true;
                    }
                    if (e.getKeyCode() == 40) {
        
                        GameUtils.DOWN = true;
                    }
                    if (e.getKeyCode() == 37) {
        
                        GameUtils.LEFT = true;
                    }
                    if (e.getKeyCode() == 39) {
        
                        GameUtils.RIGHT = true;
                    }
                    //********空格键********
                    if (e.getKeyCode() == 32) {
        
                        //如果游戏状态为运行中，则暂停，反之
                        switch (state) {
        
                            case 1:
                                state = 4;
                                GameUtils.drawWord(getGraphics(), "游戏暂停!!!", Color.RED, 50, 600, 400);
                                break;
                            case 4:
                                state = 1;
                                break;
                        }
                    }
                }
    
                @Override//抬起
                public void keyReleased(KeyEvent e) {
        
                    if (e.getKeyCode() == 38) {
        
                        GameUtils.UP = false;
                    }
                    if (e.getKeyCode() == 40) {
        
                        GameUtils.DOWN = false;
                    }
                    if (e.getKeyCode() == 37) {
        
                        GameUtils.LEFT = false;
                    }
                    if (e.getKeyCode() == 39) {
        
                        GameUtils.RIGHT = false;
                    }
                }
            });
    
            //背景图片重复使用，需要重复调用repaint方法
            while (true) {
        
                repaint();
                time++;
                Thread.sleep(40);
            }
        }
    
        @Override
        public void paint(Graphics g) {
        
            //......
                case 4:
                	//********
                    return;
                default:
                    break;
            }
    
            //将绘制好的图片一次性绘制到主窗口中
            g.drawImage(offScreenImage, 0, 0, null);
        }
    
        //批量添加鱼类
        ......
    }

![在这里插入图片描述][be2078c26bfb4026ac22de479badafcd.png]

接下来是重新开始功能，在窗口类中创建一个新的方法，将游戏状态恢复到初始，然后定义在游戏状态为结束或胜利的情况下，点击鼠标左键进入重新开始界面

//重新开始
    void reGame() {
        
        GameUtils.EnamyList.clear();
        time =0;
        myFish.level = 0;
        GameUtils.count = 0;
        myFish.x = 700;
        myFish.y = 500;
        myFish.width = 50;
        myFish.height = 50;
        boss = null;
        isboss = false;
    }

//创建一个启动窗口，设置窗口信息
    public void launch() throws InterruptedException {
        
        //......
    
        //添加鼠标监听事件
        this.addMouseListener(new MouseAdapter() {
        
            @Override
            public void mouseClicked(MouseEvent e) {
        
                if (e.getButton() == 1 && state == 0) {
        
                    state = 1;
                    repaint();
                }
                //重新开始
                if (e.getButton() == 1 && (state == 2 || state == 3)) {
        
                    reGame();
                    state = 1;
                }
            }
        });
    
        //键盘移动
        //......
    }

## 四、源码分享 ##

项目素材和源码下载：[https://pan.baidu.com/s/1Iy8On96ag4NnKFfwdhw9Aw?pwd=84jc][https_pan.baidu.com_s_1Iy8On96ag4NnKFfwdhw9Aw_pwd_84jc]

> ? 这次的分享就到这里啦，继续加油哦^^  
> ? 我是[程序喵][Link 1]，陪你一点点进步  
> ? 有出错的地方欢迎在评论区指出来，共同进步，谢谢啦

[Link 1]: https://blog.csdn.net/weixin_62511863?spm=1011.2421.3001.5343
[Java]: https://blog.csdn.net/weixin_62511863/category_11975552.html?spm=1001.2014.3001.5482
[Link 2]: https://live.csdn.net/v/233776
[50efd4cea3604d66944d335304f9b6bb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/09a01060bb2b4f4cbd82554093490552.png
[af3476b421d64cefaa7921e02ba487e6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/1720515fcefb4ce5a8ab3b6f0b368bfe.png
[13cbf66429af4e38a0121c089c3f7862.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/9e9b80166504412bbcb25c675e293641.png
[b699f27852a4450aab3f1bba1b6080d1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/c31d792135574bb9bf06cb5cfa31bcbc.png
[56a9531be7204384bde4fc90d97c11dc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/1cd1931c56234e438626fe879b608a1f.png
[91c070b5f8c840e2b3522c08f3735b3c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/24870911bc89453da39bdc7df2a3fe68.png
[9639a61ab8e6481eb8e4c2a2626195a0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/7f40f0a7e2404e57b3777656c1b9716d.png
[74e627dbee0449228be7b068d0a7f259.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/d08333bcf1de4047a2e74a362c5e2968.png
[3a13195772bc47a0b769b80643e11319.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/0f70858235d54e6abb27904b87960973.png
[66aac17105174f03b93fa46b9ec81bf8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/430d817a6591400eba2857d424f8dc5b.png
[b303a775beef45c5a0f9847d1f52bc9c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/0fedede6ec5144ebabd41756f064f71e.png
[b3b75ca7febd4096984e76df04e9db81.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/e09651e343844212bfd5b7b6a9c3977d.png
[8bcae6560b2f4d15b01c6f3a2bd1d7c4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/00b58eaa23d74ae68059bbb4bb83bfcf.png
[be2078c26bfb4026ac22de479badafcd.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/93dec0725231408cbd5c8eae4b2e21a7.png
[https_pan.baidu.com_s_1Iy8On96ag4NnKFfwdhw9Aw_pwd_84jc]: https://pan.baidu.com/s/1Iy8On96ag4NnKFfwdhw9Aw?pwd=84jc