面向对象程序设计：农夫过河问题

最新推荐文章于 2023-09-30 08:03:14 发布
最新推荐文章于 2023-09-30 08:03:14 发布
阅读量1.6k 收藏 17
点赞数 2
分类专栏： 面向对象程序设计 文章标签： 算法 intellij-idea
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mxc111213_/article/details/122729345
版权

农夫过河两种玩法：
1.农夫带一种东西过河
（原始玩法）
2.农夫带两种东西过河
(新增两个角色，胡萝卜，兔子，农夫不在时兔子会吃胡萝卜，狼会吃兔子)
先选择玩法：
在这里插入图片描述
在这里插入图片描述
第一种玩法的正确输入是：3123413
在这里插入图片描述
第二种玩法的正确步骤留给你们，下面上代码：

package ShiYan;

import java.util.Scanner;
public class Cross {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.println("请输入你想进行的游戏模式(1为传统玩法)(2为带两种东西过河)，请选择：");
        int Ze = input.nextInt();
        if (Ze == 1) {
            game11 game = new game11();
            game.play();
        } else if (Ze == 2) {
            game2 game2 = new game2();
            game2.play2();
        } else {
            System.out.println("输入错误！");
            System.exit(0);
        }
    }
}
class thing {
    private boolean hasCross = false;
    private boolean isAlive = true;

    public boolean isHasCross() {
        return hasCross;
    }

    public void setHasCross(boolean hasCross) {
        this.hasCross = hasCross;
    }

    public boolean isAlive() {
        return isAlive;
    }

    public void setAlive(boolean alive) {
        this.isAlive = alive;
    }

    public void showStatus() {
    }

    public void eatSheep(thing sheep, thing farmer) {
    }

    public void eatCabbage(thing cabbage, thing farmer) {
    }

    public void eatHuLuoBu(thing huLuoBu, thing farmer) {
    }
}

class cabbage11 extends thing {
    public void showStatus() {
        System.out.println("Cabbage is alive:" + super.isAlive());
        System.out.println("Cabbage has Cross:" + super.isHasCross());
    }
}

class wolf11 extends thing {
    String name;

    public wolf11(String name) {
        this.name = name;
        System.out.println("啊呜~~，我是可爱小狼仔 " + this.name + ",我又回来了！");
    }

    public void eatSheep(thing sheep, thing farmer) {
        if (!(sheep.isHasCross() == super.isHasCross() && farmer.isHasCross() == sheep.isHasCross())) {
            if ((sheep.isHasCross() == super.isHasCross()))
                sheep.setAlive(false);
        } else
            sheep.setAlive(true);
    }

    public void showStatus() {
        System.out.println("Wolf " + this.name + " is alive  :" + super.isAlive());
        System.out.println("Wolf " + this.name + " has Cross  :" + super.isHasCross());
    }
}

class farm11 extends thing {
    public void showStatus() {
        System.out.println("Farmer has Cross  :" + super.isHasCross());
    }
}

class sheep11 extends thing {
    String name;

    public sheep11(String name) {
        this.name = name;
        System.out.println("咩咩，我是可爱的小羊 " + this.name);
    }

    public void eatCabbage(thing cabbage, thing farmer) {
        if (!(cabbage.isHasCross() == super.isHasCross() && farmer.isHasCross() == cabbage.isHasCross())) {
            if ((cabbage.isHasCross() == super.isHasCross()))
                cabbage.setAlive(false);
        } else
            cabbage.setAlive(true);
    }

    public void showStatus() {
        System.out.println("Sheep " + this.name + " is alive :" + super.isAlive());
        System.out.println("Sheep " + this.name + " has Cross :" + super.isHasCross());
    }
}

class tuZi extends thing {
    String name;

    public tuZi(String name) {
        this.name = name;
        System.out.println("我是可爱的小兔兔" + this.name);
    }

    public void eatHuLuoBu(thing huLuoBu, thing farmer) {
        if (!(huLuoBu.isHasCross() == super.isHasCross() && farmer.isHasCross() == huLuoBu.isHasCross())) {
            if ((huLuoBu.isHasCross() == super.isHasCross()))
                huLuoBu.setAlive(false);
            else
                huLuoBu.setAlive(true);
        }
    }

    public void showStatus() {
        System.out.println("tuZi " + this.name + " is alive :" + super.isAlive());
        System.out.println("tuZi " + this.name + " has Cross :" + super.isHasCross());
    }
}

class huLuoBu extends thing {
    public void showStatus() {
        System.out.println("huLuoBu is alive:" + super.isAlive());
        System.out.println("huLuoBu has Cross:" + super.isHasCross());
    }
}

class boat11 {
    void boat(thing s) {
        s.setHasCross(!s.isHasCross());
    }

    void boat1(thing s1, thing s2) {
        s1.setHasCross(!s1.isHasCross());
        s2.setHasCross(!s2.isHasCross());
    }

    void boat2(thing a1, thing a2, thing a3) {
        a1.setHasCross(!a1.isHasCross());
        a2.setHasCross(!a2.isHasCross());
        a3.setHasCross(!a3.isHasCross());
    }
}

class gamegui11 {
    public static void menu() {
        /* 显示菜单 */
        System.out.println("==================Please choose operation============");
        System.out.println("\t==========1:Cross the river alone===========");
        System.out.println("\t==========2:Cross the river with wolf=========");
        System.out.println("\t==========3:Cross the river with sheep============");
        System.out.println("\t==========4:Cross the river with cabbage==========");
        System.out.println("\t==========0:Quit===============");
        System.out.println("===================================================");
        System.out.println("Input the number(0~4):");
    }

    public static void showStatus(thing farmer, thing wolf, thing sheep, thing cabbage) {
        farmer.showStatus();
        wolf.showStatus();
        sheep.showStatus();
        cabbage.showStatus();
    }
}

class game11 {
    thing wolf;
    thing sheep;
    thing cabbage;
    thing farmer;
    boat11 boat;

    game11() {
        wolf = new wolf11("jack");
        sheep = new sheep11("nancy");
        cabbage = new cabbage11();
        farmer = new farm11();
        boat = new boat11();
    }

    void play() {
        Scanner input = new Scanner(System.in);
        int choice = 0;            //用户输入选择
        boolean gameOver = false,//游戏结束标志，默认为false，代表游戏进行中，未结束
                win = false;     //游戏输赢标志，默认为false，代表未赢得游戏。
        while (!gameOver) {
            gamegui11.menu();               /错误原因：无法从 static 上下文引用非static方法menu()
            choice = input.nextInt();       ///所以将menu（）改为static类型
            switch (choice) {
                case 0:
                    System.out.println("Quit");
                    System.exit(0);
                    break;
                case 1:/* 农夫独自过河的处理 */
                    boat.boat(farmer);
                    break;
                case 2:/* 农夫带狼的处理 */
                    boat.boat1(farmer, wolf);
                    break;
                case 3:/* 农夫带羊的处理 */
                    boat.boat1(farmer, sheep);
                    break;
                case 4:/* 农夫带白菜的处理 */
                    boat.boat1(farmer, cabbage);
                    break;
            }
            wolf.eatSheep(sheep, farmer);//狼吃羊，如果羊不在同一边，则吃不到，如果在同一边，羊被吃
            sheep.eatCabbage(cabbage, farmer);//同上
            gamegui11.showStatus(farmer, wolf, sheep, cabbage);
            gameOver = isGameOver();
        }
        win = this.hasWin();
        if (win) {
            System.out.println("game over: you win !");
        } else {
            System.out.println("game over: you lose !");
        }
        input.close();
    }

    public boolean isGameOver() {
        if (sheep.isAlive() == false || cabbage.isAlive() == false) {
            return true;
        }
        if (wolf.isHasCross() && sheep.isHasCross() && cabbage.isHasCross()) {
            return true;
        }
        return false;
    }

    public boolean hasWin() {
        if (sheep.isAlive() == false || cabbage.isAlive() == false) {
            return false;
        }
        if (wolf.isHasCross() && sheep.isHasCross() && cabbage.isHasCross()) {
            return true;
        } else {
            return false;
        }
    }
}

class game2 {
    thing wolf;
    thing sheep;
    thing cabbage;
    thing farmer;
    thing tuZi;
    thing huLuoBu;
    boat11 boat;

    game2() {
        wolf = new wolf11("yueHan");
        tuZi = new tuZi("KaKa");
        sheep = new sheep11("Cindy");
        huLuoBu = new huLuoBu();
        cabbage = new cabbage11();
        farmer = new farm11();
        boat = new boat11();
    }

    void play2() {
        Scanner input = new Scanner(System.in);
        int choice = 0;            //用户输入选择
        boolean gameOver2 = false,//游戏结束标志，默认为false，代表游戏进行中，未结束
                win2 = false;     //游戏输赢标志，默认为false，代表未赢得游戏。
        while (!gameOver2) {
            gamegui2.menu();               /错误原因：无法从 static 上下文引用非static方法menu()
            choice = input.nextInt();       ///所以将menu（）改为static类型
            switch (choice) {
                case 0:
                    System.out.println("Quit");
                    System.exit(0);
                    break;
                case 1:/* 农夫独自过河的处理 */
                    boat.boat(farmer);
                    break;
                case 2:/* 农夫带狼的处理 */
                    boat.boat1(farmer, wolf);
                    break;
                case 3:/* 农夫带羊的处理 */
                    boat.boat1(farmer, sheep);
                    break;
                case 4:/* 农夫带白菜的处理 */
                    boat.boat1(farmer, cabbage);
                    break;
                case 5://带兔子过河
                    boat.boat1(tuZi, farmer);
                    break;
                case 6://带胡萝卜过河
                    boat.boat1(huLuoBu, farmer);
                    break;
                case 7:
                    boat.boat2(wolf, sheep, farmer);
                    break;
                case 8:
                    boat.boat2(wolf, cabbage, farmer);
                    break;
                case 9:
                    boat.boat2(wolf, tuZi, farmer);
                    break;
                case 10:
                    boat.boat2(wolf, huLuoBu, farmer);
                    break;
                case 11:
                    boat.boat2(cabbage, sheep, farmer);
                    break;
                case 12:
                    boat.boat2(tuZi, sheep, farmer);
                    break;
                case 13:
                    boat.boat2(huLuoBu, sheep, farmer);
                    break;
                case 14:
                    boat.boat2(cabbage, tuZi, farmer);
                    break;
                case 15:
                    boat.boat2(cabbage, huLuoBu, farmer);
                    break;
                case 16:
                    boat.boat2(tuZi, huLuoBu, farmer);
                    break;
            }
            wolf.eatSheep(sheep, farmer);        //狼吃羊，如果羊不在同一边，则吃不到，如果在同一边，羊被吃
            sheep.eatCabbage(cabbage, farmer);
            sheep.eatCabbage(huLuoBu, farmer);//同上
            tuZi.eatHuLuoBu(huLuoBu, farmer);
            wolf.eatSheep(tuZi, farmer);         //狼吃兔子
            gamegui2.showStatus(farmer, wolf, sheep, cabbage, tuZi, huLuoBu);
            gameOver2 = isGameOver2();
        }
        win2 = this.hasWin2();
        if (win2) {
            System.out.println("game over: you win !");
        } else {
            System.out.println("game over: you lose !");
        }
        input.close();
    }

    public boolean isGameOver2() {
        if (sheep.isAlive() == false || cabbage.isAlive() == false || tuZi.isAlive() == false || huLuoBu.isAlive() == false) {
            return true;
        }
        if (wolf.isHasCross() && sheep.isHasCross() && cabbage.isHasCross() && tuZi.isHasCross() && huLuoBu.isHasCross()) {
            return true;
        }
        return false;
    }

    public boolean hasWin2() {
        if (sheep.isAlive() == false || cabbage.isAlive() == false || tuZi.isAlive() == false || huLuoBu.isAlive() == false) {
            return false;
        }
        if (wolf.isHasCross() && sheep.isHasCross() && cabbage.isHasCross() && tuZi.isHasCross() && huLuoBu.isHasCross()) {
            return true;
        } else {
            return false;
        }
    }
}

class gamegui2 {
    public static void menu() {
        /* 显示菜单 */
        System.out.println("==================Please choose operation============");
        System.out.println("\t==========1:Cross the river alone===========");
        System.out.println("\t==========2:Cross the river with wolf=========");
        System.out.println("\t==========3:Cross the river with sheep============");
        System.out.println("\t==========4:Cross the river with cabbage==========");
        System.out.println("\t==========5:Cross the river with tuZi==========");
        System.out.println("\t==========6:Cross the river with huLuoBu==========");
        System.out.println("\t==========7:Cross the river with wolf and sheep=========");
        System.out.println("\t==========8:Cross the river with wolf and cabbage=========");
        System.out.println("\t==========9:Cross the river with wolf and tuZi=========");
        System.out.println("\t==========10:Cross the river with wolf and huLuoBu=========");
        System.out.println("\t==========11:Cross the river with sheep and cabbage============");
        System.out.println("\t==========12:Cross the river with sheep and tuZi============");
        System.out.println("\t==========13:Cross the river with sheep and huLuoBu============");
        System.out.println("\t==========14:Cross the river with cabbage and tuZi==========");
        System.out.println("\t==========15:Cross the river with cabbage and huLuoBu==========");
        System.out.println("\t==========16:Cross the river with tuZi and huLuoBU==========");
        System.out.println("\t==========0:Quit===============");
        System.out.println("===================================================");
        System.out.println("Input the number(0~16):");
    }

    public static void showStatus(thing farmer, thing wolf, thing sheep, thing cabbage, thing tiZi, thing huLuoBu) {
        farmer.showStatus();
        wolf.showStatus();
        sheep.showStatus();
        cabbage.showStatus();
        tiZi.showStatus();
        huLuoBu.showStatus();
    }
}
江景.
关注
专栏目录
使用编程模拟农夫过河
qwe7758521123zxc的博客
01-08 618
农夫带着狼, 羊, 白菜过河 如果农夫没有在旁边看着它们, 狼就会吃羊, 羊会吃白菜 但是小船一次只能载一人一物 请用程序打印出张三带它们过河的流程 样例输出: 羊-> 狼-> 羊<- 白菜-> 运行截图 代码区 #define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include <stdlib.h> #include <string> #define MAX_STEP 20 //最大下标
java农夫过河_C语言实现农夫过河代码及解析
weixin_42397335的博客
03-08 1048
问题描述一个农夫在河边带了一只狼、一只羊和一颗白菜，他需要把这三样东西用船带到河的对岸。然而，这艘船只能容下农夫本人和另外一样东西。如果农夫不在场的话，狼会吃掉羊，羊也会吃掉白菜。请编程为农夫解决这个过河问题。问题分析根据问题描述可知，该问题涉及的对象较多，而且运算步骤也较为复杂，因此，在使用C语言实现时，首先需要将具体问题数字化。由于整个过程的实现需要多步，而不同步骤中各个事物所处的位置不同，因...
c语言农夫过河思维游戏程序及源代码
01-17
c语言农夫过河思维游戏程序及源代码，简单易懂，并有详细注释！
用Java编写农夫过河问题_编程练习题2——农夫过河问题初步求解
weixin_39852647的博客
02-27 547
Question:农夫需要把狼、羊、菜和自己运到河对岸去，只有农夫能够划船，而且船比较小，除农夫之外每次只能运一种东西，当然也可以不运东西，如果没有农夫看着，羊会偷吃菜，狼会吃羊。请考虑一种方法，让农夫能够安全地安排这些东西和他自己过河。(参考：http://blog.csdn.net/orbit/article/details/7563220)本文只是用面向过程的方法，利用二进制位，得出一种过河...
面向对象程序设计 - 农夫过河 - Java
热门推荐
寄存学习笔记，心得
04-02 1万+
用到：继承，封装，多态； 可选游戏模式：经典模式（农夫，狼，羊，菜），(农夫不在时)狼吃羊、羊吃菜，小船最大承载量为 2；新模式（农夫，狼，羊，菜，兔子，胡萝卜），(农夫不在时)狼吃羊、狼吃兔、羊吃菜、兔子吃胡萝卜，小船最大承载量为 3；地狱模式（农夫，狼，羊，菜，兔子，胡萝卜），(农夫不在时)狼吃羊、狼吃兔子、羊吃菜、兔子吃白菜、兔子吃胡萝卜，小船最大承载量为 3
农夫过河问题代码
04-05
农夫过河问题的一种解法.一个在校大学生的课程设计。请斧正！
数据结构与算法经典程序：农夫过河问题讲解
瞿小凯的博客
04-30 3756
农夫过河经典问题
Linux编程：农夫过河问题解决与程序设计
"这篇课程设计报告关注的是使用Linux编程解决'农夫过河'问题，学生需要编写一个模拟渡河过程的程序，并涉及到shell脚本和C语言程序设计的相关知识。" 在这次“农夫过河”的课程设计中，学生们需要运用编程技巧来...
趣味算法：农夫过河问题求解及程序设计
- 案例5：**农夫过河** - 教授自下而上的程序设计策略，涉及边界条件和递归。 3. **问题求解步骤**： - **问题抽象描述**：将实际问题转化为数学模型，如用二维数组表示图的连通性。 - **设计算法**：确定解决...
实验五：prolog求解农夫过河问题（人工智能实验报告）
12-25
包含prolog求解农夫过河问题的实验报告、源代码及试验运行截图
农夫过河问题源码
04-22
问题是：一位老农带着猫、狗、鱼过河，河边有一条船，每次老农只能带一只动物过河。当老农不和猫狗鱼在一起时，狗会咬猫，猫会吃鱼，当老农和猫狗鱼在一起时，则不会发生这种问题。编程解决猫狗鱼过河问题。
农夫过河问题【代码+流程图+可执行文件】
11-05
采用深度优先遍历图的方法，解决农夫过河的问题，有代码，有可执行文件和流程图
农夫过河问题
06-10
数据结构，农夫过河。详细讲述过河 #include //0代表在河的这边;1代表在河的对岸 struct Condition{ int farmer; int wolf; int sheep; int cabbage; }; struct Condition conditions[100];//结构体条件数组 char * action [100]; void takeWolfOver(int i) //把狼来过去 { action[i]="把狼过去.---->对岸"; conditions[i+1].wolf=1; conditions[i+1].sheep=conditions[i].sheep; conditions[i+1].cabbage=conditions[i].cabbage; } void takeWolfBack(int i)/*把狼带回来*/ { action[i]="带狼回来.本岸对岸"; conditions[i+1].wolf=conditions[i].wolf; conditions[i+1].sheep=1; conditions[i+1].cabbage=conditions[i].cabbage; } void takeSheepBack(int i)/*把羊带回来*/ { action[i]="带羊回来.本岸对岸"; conditions[i+1].wolf=conditions[i].wolf; conditions[i+1].sheep=conditions[i].sheep; conditions[i+1].cabbage=1; } void takeCabbageBack(int i)/*把菜带回来*/ { action[i]="带菜回来.本岸对岸"; conditions[i+1].wolf=conditions[i].wolf; conditions[i+1].sheep=conditions[i].sheep; conditions[i+1].cabbage=conditions[i].cabbage;/*全不动*/ } void getBackBarely(int i)/*返回时的情况*/ { action[i]="空手回来.本岸<---(barely)"; conditions[i+1].wolf=conditions[i].wolf; conditions[i+1].sheep=conditions[i].sheep; conditions[i+1].cabbage=conditions[i].cabbage; } void showSolution(int i)/*显示解决方法*/ { int c; printf("\n"); printf("%s\n","解决办法:"); for(c=0;c<i;c++) { printf("step%d:%s\n",c+1,action[c
农夫过河C源代码
06-08
农夫过河问题的 C源代码。
农夫过河（狼，羊，菜）C++实现
10-07
一个农夫带着一只狼，一只羊和一筐菜，欲从河的左岸坐船到右岸，由于船太小，农夫每次只能带一样东西过河，并且没有农夫看管的话，狼会吃掉羊，羊会吃菜。设计一个方案，使农夫可以无损失的过河。 代码请用VS2010打开，你也可以尝试把C++代码自己部署到对应的编译器上。
农夫过河问题的算法与实现.doc
05-07
农夫过河问题的算法与实现 农夫过河问题是指农夫带一只狼、一只羊和一棵白菜在河南岸，需要安全运到北岸。这类问题的实质是系统的状态问题，要寻求的是从初始状态经一系列的安全状态到达系统的终止状态的一条路径。...
java农夫过河_Java简单实现农夫过河问题示例
weixin_42401025的博客
02-12 987
本文实例讲述了Java简单实现农夫过河问题。分享给大家供大家参考，具体如下：一、问题描述老伯伯要带鱼、狗、猫过河到对岸.，有一条船，只能坐一个人，老伯每次只能带一样动物过河，当老伯不在的时侯狗会咬猫，猫会吃鱼.，请问怎么顺序过河呢？二、实现代码package demo;import java.util.ArrayList;import java.util.List;public class Cro...
VB编程系列（5）：农夫过河
qq_37183108的博客
06-11 679
问题描述：一个农夫带了一只狼、一只羊和一颗白菜来到甲岸，他要把这三样东西东用船从甲岸带到乙岸，但这艘船只能容下农夫本人和另外一样东东。如果农夫不在场的话，狼会吃掉羊，羊会吃掉白菜。请编程为农夫解决这个过河问题。解题思路：第一次看到这类问题时，我蒙圈了——这就是个文字推理题，也能用编程来解决？细想之后，明白！只要能用数字表示，就能用程序来处理。要确保三样东东都能过河，就必须使得农夫不在河岸的时候，甲...
C语言实现农夫过河游戏的代码及解析
最新发布
2301_79325339的博客
09-30 393
然后，我们进入一个循环，不断尝试移动物体。在每次循环中，我们遍历每个物体，如果物体在当前岸，就尝试将其移动到另一岸。在移动之前，我们先判断移动后的状态是否安全，如果安全则输出当前状态，否则将物体移回原来的岸。根据限制条件，我们检查狼和羊、羊和菜是否在同一岸，如果不在同一岸且农夫不在场景中，则返回0表示不安全，否则返回1表示安全。数组的下标分别代表农夫、狼、羊和白菜，数组的值为0表示物体在左岸，为1表示物体在右岸。这样，通过不断的移动物体并判断状态的安全性，直到达到目标状态，我们就完成了农夫过河的游戏。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

江景.

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值