[java编程日记]捕鱼达人(一)

简介: [java编程日记]捕鱼达人

1.题目与思路

捕鱼达人

池塘是一个9行9列的空间,每一格最多有一条鱼。

池塘中有3种鱼:将鱼、士鱼、相鱼。

三种鱼分别有不同的移动方式:

将鱼:只能往上、下、左、右中的一个方向移动一格。

士鱼:只能往左上、右上、左下、右下一个方向移动一格。

相鱼:只能往左上、右上、左下、右下一个方向移动两格。

但是不能移动到原来已经有鱼的地方,不能移动到 Pool 之外。

如果能移动的四个方向都不为空或不在 Pool 内,则留在原地。

每次移动顺序为,从左上角到右下角。

例如,当前池塘中鱼的分布如下:

|1|0|2|0|3|

|0|0|0|0|0|

|0|4|0|0|0|

|0|0|0|0|5|

那么移动顺序为1->2->3->4->5

如果一次移动后,所有鱼都还在原地,清空池塘中所有鱼。

每一条鱼有一个价值和生命值:

将鱼:1和1

士鱼:2和2

相鱼:3和3

鱼被子弹打中后扣除子弹伤害量的生命,生命为0时死亡,从 Pool 中消失,炮台的剩余金钱增加其价值的数值。

子弹分三种:

普通子弹:只能打中目标位置的鱼,伤害为1,消耗金钱1。

十字子弹:能打中目标位置和目标位置上下左右一格的鱼,伤害为1,消耗金钱5。

叉号子弹:能打中目标位置和目标位置上左,上右,左下,右下一格的鱼,伤害为1,消耗金钱为5。

炮台可以改变当前子弹类型,或者对某个位置发射子弹。

池塘初始鱼数目和最大数目为n=5,类型和位置随机初始化,玩家可以消耗20金钱使n加1,但是最大为10。每次玩家进行一次操作(更换子弹类型,发射子弹,增加了鱼塘最大鱼数量),就使鱼移动一次,如果当前池塘中鱼的数量

少于最大数量,就在池塘的边缘部分(第一行或第一列或第八行或第八列)随机生成一条鱼。

炮台金钱变为0时结束程序,输出失败结果,

金钱变为1000时结束程序,输出成功结果。

这个题目里面,总共出现了3个对象,池子,鱼和子弹,我们可以用array list表来存储鱼和进行打印。

类和包如下

2.创造对象和接口,完善函数。

子弹

public class Bullet implements BulletInterface {
    int Power;//伤害
    int Consume;//消耗的金钱
    String Type;//子弹的种类
    public Bullet() {
    }
    public Bullet(int power, int consume, String type) {
        Power = power;
        Consume = consume;
        Type = type;
    }
    public void setPower(int power) {
        Power = power;
    }
    public int getConsume() {
        return Consume;
    }
    public void setConsume(int consume) {
        Consume = consume;
    }
    public String getType() {
        return Type;
    }
    public void setType(String type) {
        Type = type;
    }
    @Override
    public int getPower() {
        return Power;
    }
    /**
     * 返回子弹打到第 row 行, 第 col 列时,被波及的点
     * @param row
     * @param col
     * @return
     */
    @Override
    public MyPoint[] getAimedPoints(int row, int col) {
        return new MyPoint[0];
    }
}
/**
 * 炮台
 */
public interface BatteryInterface {
    /**
     * 获取剩余的金钱数
     * @return
     */
    int getLeftMoney();
    /**
     * 花费 money
     * 只有剩余金钱数大于等于 money 才能花费
     * @param money
     */
    void reduceMoney(int money);
    /**
     * 获取 money
     * @param money
     */
    void gainMoney(int money);
    /**
     * 设置当前使用的 bullet
     * @param bullet
     */
    void setBullet(Bullet bullet);
    /**
     * 获取当前使用的 bullet
     */
    Bullet getBullet();
    /**
     * 向第 row 行, 第 col 列发出当前使用的子弹
     * @param row
     * @param col
     */
    void shoot(int row, int col);

import java.util.Random;
public class Fish extends MyPoint implements FishInterface {
    private int HP;//血量
    private int Value;//价值
    private MyPoint location;//位置
    public Fish() {
    }//无参数的构造
    public int getHP() {
        return HP;
    }
    public void setHP(int HP) {
        this.HP = HP;
    }
    public void setValue(int value) {
        Value = value;
    }
    //构造方法
    /**
     * 移动,根据自己的移动规则,移动到一个空位置
     *
     * @return 是否移动了
     */
    @Override
    public boolean move() {
        Random r = new Random();
        int number = r.nextInt(4) + 1;
        if (HP == 1) {
            if (number == 1) {
                this.setRow(this.getRow() - 1);
                this.setCol(this.getCol());
            }
            if (number == 2) {
                this.setRow(this.getRow() + 1);
                this.setCol(this.getCol());
            }
            if (number == 3) {
                this.setRow(this.getRow());
                this.setCol(this.getCol() - 1);
            }
            if (number == 4) {
                this.setRow(this.getRow());
                this.setCol(this.getCol() + 1);
            }
        }
        if (HP == 2) {
            if (number == 1) {
                this.setRow(this.getRow() - 1);
                this.setCol(this.getCol() - 1);
            }
            if (number == 2) {
                this.setRow(this.getRow() - 1);
                this.setCol(this.getCol() + 1);
            }
            if (number == 3) {
                this.setRow(this.getRow() + 1);
                this.setCol(this.getCol() - 1);
            }
            if (number == 4) {
                this.setRow(this.getRow() + 1);
                this.setCol(this.getCol() + 1);
            }
        }
        if (HP == 3) {
            if (number == 1) {
                this.setRow(this.getRow() - 2);
                this.setCol(this.getCol() - 2);
            }
            if (number == 2) {
                this.setRow(this.getRow() - 2);
                this.setCol(this.getCol() + 2);
            }
            if (number == 3) {
                this.setRow(this.getRow() + 2);
                this.setCol(this.getCol() - 2);
            }
            if (number == 4) {
                this.setRow(this.getRow() + 2);
                this.setCol(this.getCol() + 2);
            }
        }
        return false;
    }
    @Override
    public MyPoint getLocation() {
        return location;
    }//返回鱼的坐标
    @Override
    public boolean isAlive() {
        if (this.HP <= 0) return false;
        else {
            return true;
        }
    }//查看是否活着
    @Override
    public int getValue() {
        return this.Value;
    }//获得价值
    @Override
    public void getDamage(int damage) {
        this.HP = this.HP - damage;
    }//接受伤害
}
public interface FishInterface {
    /**
     * 移动,根据自己的移动规则,移动到一个空位置
     * @return 是否移动了
     */
    boolean move();
    /**
     * 返回当前在池塘的位置
     * @return
     */
    MyPoint getLocation();
    /**
     *
     * @return 是否还存活着
     */
    boolean isAlive();
    /**
     *
     * @return 鱼的价值
     */
    int getValue();
    /**
     * 接受多少的伤害
     * @return
     */
    void getDamage(int damage);
}

池子

import java.util.ArrayList;
public class Pool implements PoolInterface {
    int Rows;
    int Cols;
    ArrayList<MyPoint> Points;
    //成员变量
    public Pool() {
    }
    public Pool(int rows, int cols, ArrayList<MyPoint> points) {
        Rows = rows;
        Cols = cols;
        Points = points;
    }
    public ArrayList<MyPoint> getPoints() {
        return Points;
    }
    public void setPoints(ArrayList<MyPoint> points) {
        Points = points;
    }
    public Pool(ArrayList<MyPoint> points) {
        Points = points;
    }
    public void setRows(int rows) {
        Rows = rows;
    }
    public void setCols(int cols) {
        Cols = cols;
    }
    @Override
    public int getRows() {
        return Rows;
    }
    @Override
    public int getCols() {
        return Cols;
    }
    @Override
    public Fish getAt(int row, int col) {
        return null;
    }
    /**
     * 设置第 row 行, 第 col 列的 Fish
     * @param row
     * @param col
     */
    @Override
    public void setAt(int row, int col, Fish fish) {
    }
    /**
     * 返回 第 row 行, 第 col 列 是否为 null
     * @param row
     * @param col
     * @return
     */
    @Override
    public boolean isEmpty(int row, int col) {
        return false;
    }
    //构造方法
}
/**
 * 池塘
 */
public interface PoolInterface {
    /**
     * 返回 Pool 的行数
     * @return
     */
    int getRows();
    /**
     * 返回 Pool 的列数
     * @return
     */
    int getCols();
    /**
     * 返回在第 row 行, 第 col 列的 Fish
     * 如果指定位置没有 Fish 则返回 null
     * @param row
     * @param col
     * @return
     */
    Fish getAt(int row, int col);
    /**
     * 设置第 row 行, 第 col 列的 Fish
     * @param row
     * @param col
     */
    void setAt(int row, int col, Fish fish);
    /**
     * 返回 第 row 行, 第 col 列 是否为 null
     * @param row
     * @param col
     * @return
     */
    boolean isEmpty(int row, int col);
}

---------------------------------------------------------------------------------------------------------------------------------然后我用菜单这个类,包含这些对象和其他数据

import java.util.ArrayList;
public class Menu implements MenuInterface {
    int money;
    Bullet bullet;
    ArrayList<MyPoint> points;
    ArrayList<Fish> list;
    public Menu() {
    }
    public Menu(int money, Bullet bullet, ArrayList<MyPoint> points, ArrayList<Fish> list) {
        this.money = money;
        this.bullet = bullet;
        this.points = points;
        this.list = list;
    }
    public int getMoney() {
        return money;
    }
    public void setMoney(int money) {
        this.money = money;
    }
    public Bullet getBullet() {
        return bullet;
    }
    public void setBullet(Bullet bullet) {
        this.bullet = bullet;
    }
    public ArrayList<MyPoint> getPoints() {
        return points;
    }
    public void setPoints(ArrayList<MyPoint> points) {
        this.points = points;
    }
    public ArrayList<Fish> getList() {
        return list;
    }
    public void setList(ArrayList<Fish> list) {
        this.list = list;
    }
    @Override
    public void printSelection() {
        System.out.println("=========================");
        System.out.println("1.选择普通子弹");
        System.out.println("2.选择十字子弹");
        System.out.println("3.选择叉号子弹");
        System.out.println("4.发出子弹");
        System.out.println("5.增加最大鱼条数");
        System.out.println("=========================");
        System.out.println(" 请选择操作选项:");
    }//打印选择菜单
    @Override
    public void printPool() {
        System.out.println("====================捕鱼达人=======================");
        System.out.println("0|--1----2----3----4----5----6----7----8----9---|");
        for (int i = 1; i <= 9; i++) {
            System.out.print(i);
            for (int j = 1; j <= 9; j++) {
                System.out.print("|");
                ;
                String pt = chazhao(points, list, i, j);
                System.out.print(pt);
            }
            System.out.println("|");
        }
        System.out.println("====================***制作=====================");
    }//打印池子
    @Override
    public void printBatteryMessage() {
        System.out.println("=========================");
        System.out.println("剩余金钱数:" + money);
        System.out.println("当前子弹种类:" + bullet.Type);
        System.out.println("=========================");
    }//打印玩家信息
    @Override
    public void printMenu() {
        System.out.println("=================================================");
        System.out.println("                  1.开始游戏");
        System.out.println("                  0.退出游戏");
        System.out.println("=================================================");
    }//打印总菜单
    //在(i,j)的位置看是否有这条鱼
    public static String chazhao(ArrayList<MyPoint> points, ArrayList<Fish> list, int i, int j) {
        for (int dexPoints = 0; dexPoints < points.size(); dexPoints++) {
            for (int dexLise = 0; dexLise < list.size(); dexLise++) {
                if (points.get(dexPoints).getRow() + 1 == i && i == list.get(dexLise).getRow()) {
                    if (points.get(dexPoints).getCol() + 1 == j && j == list.get(dexLise).getCol()) {
                        if (list.get(dexLise).getValue() == 1) return " 将鱼";
                        if (list.get(dexLise).getValue() == 2) return " 士鱼";
                        if (list.get(dexLise).getValue() == 3) return " 相鱼";
                    }
                }
            }
        }
        return "    ";
    }
}



相关文章
|
1月前
|
Java
如何在Java中进行多线程编程
Java多线程编程常用方式包括:继承Thread类、实现Runnable接口、Callable接口(可返回结果)及使用线程池。推荐线程池以提升性能,避免频繁创建线程。结合同步与通信机制,可有效管理并发任务。
146 6
|
1月前
|
IDE Java 编译器
java编程最基础学习
Java入门需掌握:环境搭建、基础语法、面向对象、数组集合与异常处理。通过实践编写简单程序,逐步深入学习,打牢编程基础。
190 0
|
2月前
|
SQL Java 数据库
2025 年 Java 从零基础小白到编程高手的详细学习路线攻略
2025年Java学习路线涵盖基础语法、面向对象、数据库、JavaWeb、Spring全家桶、分布式、云原生与高并发技术,结合实战项目与源码分析,助力零基础学员系统掌握Java开发技能,从入门到精通,全面提升竞争力,顺利进阶编程高手。
550 1
|
1月前
|
安全 前端开发 Java
从反射到方法句柄:深入探索Java动态编程的终极解决方案
从反射到方法句柄,Java 动态编程不断演进。方法句柄以强类型、低开销、易优化的特性,解决反射性能差、类型弱、安全性低等问题,结合 `invokedynamic` 成为支撑 Lambda 与动态语言的终极方案。
145 0
|
3月前
|
安全 Java 数据库连接
2025 年最新 Java 学习路线图含实操指南助你高效入门 Java 编程掌握核心技能
2025年最新Java学习路线图,涵盖基础环境搭建、核心特性(如密封类、虚拟线程)、模块化开发、响应式编程、主流框架(Spring Boot 3、Spring Security 6)、数据库操作(JPA + Hibernate 6)及微服务实战,助你掌握企业级开发技能。
572 3
|
2月前
|
Java 开发者
Java并发编程:CountDownLatch实战解析
Java并发编程:CountDownLatch实战解析
437 100
|
2月前
|
算法 Java
Java多线程编程:实现线程间数据共享机制
以上就是Java中几种主要处理多线程序列化资源以及协调各自独立运行但需相互配合以完成任务threads 的技术手段与策略。正确应用上述技术将大大增强你程序稳定性与效率同时也降低bug出现率因此深刻理解每项技术背后理论至关重要.
220 16
|
2月前
|
NoSQL Java 关系型数据库
超全 Java 学习路线,帮你系统掌握编程的超详细 Java 学习路线
本文为超全Java学习路线,涵盖基础语法、面向对象编程、数据结构与算法、多线程、JVM原理、主流框架(如Spring Boot)、数据库(MySQL、Redis)及项目实战等内容,助力从零基础到企业级开发高手的进阶之路。
282 1
|
3月前
|
安全 算法 Java
Java泛型编程:类型安全与擦除机制
Java泛型详解:从基础语法到类型擦除机制,深入解析通配符与PECS原则,探讨运行时类型获取技巧及最佳实践,助你掌握泛型精髓,写出更安全、灵活的代码。
|
3月前
|
安全 Java Shell
Java模块化编程(JPMS)简介与实践
本文全面解析Java 9模块化系统(JPMS),帮助开发者解决JAR地狱、类路径冲突等常见问题,提升代码的封装性、性能与可维护性。内容涵盖模块化核心概念、module-info语法、模块声明、实战迁移、多模块项目构建、高级特性及最佳实践,同时提供常见问题和面试高频题解析,助你掌握Java模块化编程精髓,打造更健壮的应用。
下一篇
oss云网关配置