[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 "    ";
    }
}



相关文章
|
15天前
|
Java 程序员
Java编程中的异常处理:从基础到高级
在Java的世界中,异常处理是代码健壮性的守护神。本文将带你从异常的基本概念出发,逐步深入到高级用法,探索如何优雅地处理程序中的错误和异常情况。通过实际案例,我们将一起学习如何编写更可靠、更易于维护的Java代码。准备好了吗?让我们一起踏上这段旅程,解锁Java异常处理的秘密!
|
18天前
|
设计模式 Java 开发者
Java多线程编程的陷阱与解决方案####
本文深入探讨了Java多线程编程中常见的问题及其解决策略。通过分析竞态条件、死锁、活锁等典型场景,并结合代码示例和实用技巧,帮助开发者有效避免这些陷阱,提升并发程序的稳定性和性能。 ####
|
18天前
|
缓存 Java 开发者
Java多线程编程的陷阱与最佳实践####
本文深入探讨了Java多线程编程中常见的陷阱,如竞态条件、死锁和内存一致性错误,并提供了实用的避免策略。通过分析典型错误案例,本文旨在帮助开发者更好地理解和掌握多线程环境下的编程技巧,从而提升并发程序的稳定性和性能。 ####
|
11天前
|
安全 算法 Java
Java多线程编程中的陷阱与最佳实践####
本文探讨了Java多线程编程中常见的陷阱,并介绍了如何通过最佳实践来避免这些问题。我们将从基础概念入手,逐步深入到具体的代码示例,帮助开发者更好地理解和应用多线程技术。无论是初学者还是有经验的开发者,都能从中获得有价值的见解和建议。 ####
|
12天前
|
Java 调度
Java中的多线程编程与并发控制
本文深入探讨了Java编程语言中多线程编程的基础知识和并发控制机制。文章首先介绍了多线程的基本概念,包括线程的定义、生命周期以及在Java中创建和管理线程的方法。接着,详细讲解了Java提供的同步机制,如synchronized关键字、wait()和notify()方法等,以及如何通过这些机制实现线程间的协调与通信。最后,本文还讨论了一些常见的并发问题,例如死锁、竞态条件等,并提供了相应的解决策略。
34 3
|
17天前
|
开发框架 安全 Java
Java 反射机制:动态编程的强大利器
Java反射机制允许程序在运行时检查类、接口、字段和方法的信息,并能操作对象。它提供了一种动态编程的方式,使得代码更加灵活,能够适应未知的或变化的需求,是开发框架和库的重要工具。
35 2
|
22天前
|
Java 程序员
Java编程中的异常处理:从基础到高级
在Java的世界里,异常是程序运行中不可忽视的“惊喜”。它们可能突如其来,也可能悄无声息地潜伏。掌握异常处理的艺术,意味着你能够优雅地面对程序的不完美,并确保它即使在风雨飘摇中也能继续航行。本文将引导你理解Java异常的本质,探索捕获和处理这些异常的方法,并最终学会如何利用自定义异常为你的代码增添力量。
|
18天前
|
安全 Java 开发者
Java中的多线程编程:从基础到实践
本文深入探讨了Java多线程编程的核心概念和实践技巧,旨在帮助读者理解多线程的工作原理,掌握线程的创建、管理和同步机制。通过具体示例和最佳实践,本文展示了如何在Java应用中有效地利用多线程技术,提高程序性能和响应速度。
52 1
|
19天前
|
Java API 数据库
Java 反射机制:动态编程的 “魔法钥匙”
Java反射机制是允许程序在运行时访问类、方法和字段信息的强大工具,被誉为动态编程的“魔法钥匙”。通过反射,开发者可以创建更加灵活、可扩展的应用程序。
36 0
|
21天前
|
缓存 Java 开发者
Java中的多线程编程:从基础到进阶
在Java的世界中,多线程编程是一块不可或缺的拼图。它不仅提升了程序的效率和响应性,还让复杂任务变得井然有序。本文将带你领略多线程编程的魅力,从创建线程的基础操作到高级同步机制的应用,再到线程池的高效管理,我们将一步步揭开多线程编程的神秘面纱。无论你是初学者还是有一定经验的开发者,这篇文章都会为你提供新的视角和深入的理解。让我们一起探索Java多线程编程的世界,开启一段精彩的旅程吧!
37 0