Java农夫过河问题的继承与多态实现详解
题目描述：
一个农夫带着一匹狼、一只羊、一颗白菜要过河，只有一条船而且农夫每次最多只能带一个动物或物品过河，并且当农夫不在的时候狼会吃羊，羊会吃白菜。，请设计程序，由用户选择角色过河，系统自动判断游戏的胜负：当出现有生物被吃掉的时候，游戏失败，所有角色都到了河的另一边，游戏成功。
话不多说，直接看代码：
package Test1;
import java.util.Scanner;
public class Client {
static Farmer farmer = new Farmer();
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 ("+farmer.wolf.name+")"+"=========");
System.out.println("\t==========3:Cross the river with ("+farmer.sheep.name+")"+"============");
System.out.println("\t==========4:Cross the river with ("+farmer.cabbage.name+")"+"==========");
System.out.println("\t==========0:Quit===============");
System.out.println("===================================================");
System.out.println("Input the number(0~4):");
}
public static void show()/* 输出农夫、各种动物、物品的状态（生存、位置） */
{
System.out.println("过河状态：");
System.out.println(farmer.sheep.name+": 是否在左边河："+farmer.sheep.is_across_left+
" 是否在右边河"+farmer.sheep.is_across_right+" 是否存活："+farmer.sheep.is_alive);
//如果羊过河成功则河左边显示false河右边显示true
System.out.println(farmer.cabbage.name+": 是否在左边河："+farmer.cabbage.is_across_left+
" 是否在右边河"+farmer.cabbage.is_across_right+" 是否存活："+farmer.cabbage.is_alive);
//如果白菜过河成功则河左边显示false河右边显示true
System.out.println(farmer.wolf.name+": 是否在左边河："+farmer.wolf.is_across_left+
" 是否在右边河"+farmer.wolf.is_across_right+" 是否存活："+farmer.wolf.is_alive);
//如果狼过河成功则河左边显示false河右边显示true
System.out.println("农夫: 是否在左边河："+farmer.is_across_left+" 是否在右边河"+farmer.is_across_right);
}
public static void is_alive() { //判断羊和白菜是否被吃
if(farmer.sheep.is_across_left==farmer.wolf.is_across_left&&farmer.sheep.is_across_right==farmer.wolf.is_across_right
&&farmer.is_across_left==farmer.sheep.is_across_right&&farmer.is_across_right==farmer.sheep.is_across_left
&&farmer.is_across_left==farmer.wolf.is_across_right&&farmer.is_across_right==farmer.wolf.is_across_left) {
//如果羊和狼在同一边且农夫在另外一边时则羊会被吃
farmer.sheep.is_alive=false;
}
if(farmer.sheep.is_across_left==farmer.cabbage.is_across_left&&farmer.sheep.is_across_right==farmer.cabbage.is_across_right
&&farmer.is_across_left==farmer.cabbage.is_across_right&&farmer.is_across_right==farmer.cabbage.is_across_left
&&farmer.is_across_left==farmer.sheep.is_across_right&&farmer.is_across_right==farmer.sheep.is_across_left) {
//如果羊和白菜在同一边且农夫在另外一边时则白菜会被吃
farmer.cabbage.is_alive=false;
}
}
public static int is_win(){ //判断是否成功过河
if(farmer.sheep.is_alive==false||farmer.cabbage.is_alive==false) {
return 0; //如果羊或白菜被吃了则返回0直接退出游戏失败
}
if(farmer.is_across_right==true&&farmer.sheep.is_across_right==true&&farmer.wolf.is_across_right&&farmer.cabbage.is_across_right==true)
{ //如果农夫羊狼白菜都到了河的右边则返回1游戏成功
return 1;
}
return 2; //其他情况则继续进行
}
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner input = new Scanner(System.in);
int choice = 0;
int m=2; //将m的初始值设置为2表示正在进行的情况
boolean gamevoer=false,win=false;
while(!gamevoer)
{
if(m==1||m==0) { //如果m=0或1则直接退出显示游戏结果
break;
}
menu();
choice = input.nextInt();
System.out.println("\n");
switch(choice)
{
case 0: gamevoer=true;
break;
case 1:{
farmer.cross_alone(); /* 农夫独自过河的处理 */
//农夫位置的判断
is_alive();
show();
m=is_win(); //m用来记录方法的返回值0,1,2
if(m==1) //如果m=1,则表示过河成功
{
win=true;//直接输出游戏成功
}
break;
}
//以下情况类似
case 2:{
farmer.cross_wolf();/* 农夫带狼的处理 */
is_alive();
show();
m=is_win();
if(m==1)
{
win=true;
}
break;
}
case 3:{
farmer.cross_sheep();/* 农夫带羊的处理 */
is_alive();
show();
m=is_win();
if(m==1)
{
win=true;
}
break;
}
case 4:{
farmer.cross_cabbage(); /* 农夫带白菜的处理 */
is_alive();
show();
m=is_win();
if(m==1)
{
win=true;
}
break;
}
}
}
if(win) {
System.out.println("game over: you win !");
}else {
System.out.println("game over: you lose !");
}
input.close();
}
}
package Test1;
public class Cabbage extends wuti {
public Cabbage(){
super.name="白菜";
}
}
package Test1;
public class Farmer{
boolean is_across_left = true ; //默认河左边为开始的一边
boolean is_across_right = false;
Sheep sheep = new Sheep();
Wolf wolf = new Wolf();
Cabbage cabbage = new Cabbage();
public void cross_cabbage () {
if(cabbage.is_across_left==is_across_left||cabbage.is_across_right==is_across_right) { //如果白菜农夫在一边
if(cabbage.is_across_left==false) { //白菜右边到左边
cabbage.is_across_left=true;
cabbage.is_across_right=false;
}
else { //白菜左边到右边
cabbage.is_across_left=false;
cabbage.is_across_right=true;
}
if(is_across_left==false) { //农夫右边到左边
is_across_left=true;
is_across_right=false;
}
else { //农夫左边到右边
is_across_left=false;
is_across_right=true;
}
}
else { //如果白菜农夫不在一边则白菜无法过河
System.out.println(cabbage.name+"不再农夫这边");
}
}
public void cross_sheep() {
if(sheep.is_across_left==is_across_left||sheep.is_across_right==is_across_right) { //如果羊农夫在一边
if(sheep.is_across_left==false) { //羊右边到左边
sheep.is_across_left=true;
sheep.is_across_right=false;
}
else{ //羊左边到右边
sheep.is_across_left=false;
sheep.is_across_right=true;
}
if(is_across_left==false) { //农夫右边到左边
is_across_left=true;
is_across_right=false;
}
else{ //农夫左边到右边
is_across_left=false;
is_across_right=true;
}
}
else { //如果羊农夫不在一边则羊无法过河
System.out.println(sheep.name+"不再农夫这边");
}
}
public void cross_wolf() {
if(wolf.is_across_left==is_across_left||wolf.is_across_right==is_across_right) { //如果狼农夫在一边
if(wolf.is_across_left==false) { //狼右边到左边
wolf.is_across_left=true;
wolf.is_across_right=false;
}
else { //狼左边到右边
wolf.is_across_left=false;
wolf.is_across_right=true;
}
if(is_across_left==false) { //农夫右边到左边
is_across_left=true;
is_across_right=false;
}
else { //农夫左边到右边
is_across_left=false;
is_across_right=true;
}
}
else { //如果狼农夫不在一边则狼无法过河
System.out.println(wolf.name+"不再农夫这边");
}
}
public void cross_alone() {
if(is_across_left==false) { //农夫右边到左边
is_across_left=true;
is_across_right=false;
}
else{ //农夫左边到右边
is_across_left=false;
is_across_right=true;
}
}
}
package Test1;
public class Sheep extends wuti{
public Sheep(){
super.name="羊";
}
}
package Test1;
public class Wolf extends wuti{
public Wolf(){
super.name="狼";
}
}
package Test1;
public class wuti {
String name;
boolean is_across_left = true ;
boolean is_across_right = false;
boolean is_alive = true;
}
首先创建一个物体类wuti.java,其中包括name用来说明要过河的物体, is_across_left表示在河的左边，默认为true, is_across_right表示在河的右边，默认为false, is_alive表示物体没有被吃，这个类是父类，将会有3个类继承自此类，分别是Cabbage，Sheep，Wolf类，但是这3个类中只有分别表示名字的构造方法，虽然简单但是有利于游戏的变更，比如实验要求的将狼，羊，白菜改为狐狸，兔子，胡萝卜，这样的话只需要将super.name改为需要的物体名称就可以。
然后创建一个Farmer类，其中包括cross_cabbage ()方法，cross_sheep()方法，cross_wolf()方法，这3个方法分别用来表示农夫和白菜，羊，狼过河的情况，而且农夫必须和物体在一边，否则会输出提示表示物体与农夫的位置不一样无法进行过河。
最后创建一个Client类，其中包括menu()方法，show()方法，is_alive()方法，is_win()方法，menu()方法显示一个类似菜单的选择项，可以选择想要过河的情况。show()方法输出农夫、各种动物、物品的状态（生存、位置），如果物体过河成功则河左边（is_across_left）显示false河右边（is_across_right）显示true。is_alive()方法用来判断羊和白菜是否被吃，如果羊和狼在同一边且农夫在另外一边时则羊会被吃，如果羊和白菜在同一边且农夫在另外一边时则白菜会被吃。is_win()方法判断是否成功过河，如果羊或白菜被吃了则返回0直接退出游戏失败，如果农夫羊狼白菜都到了河的右边则返回1游戏成功。
在主方法中，将m的初始值设置为2表示正在进行的情况，在while循环中如果m=0或1则直接退出显示游戏结果，在switch语句中case0,1,2,3,4分别选择过河的物体的情况，case中farmer.cross_alone()等类似的方法表示农夫和物体过河的位置以及是否成功过河的情况，is_alive()方法表示判断物体是否被吃，show()方法输出农夫、各种动物、物品的状态（生存、位置），is_win()方法判断是否成功过河。巧妙利用m的值判断是否过河成功。
结果显示：
可以试试。
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持小牛知识库。
-
问题内容： 继承和多态都构成IS- A关系吗？在运行时发生继承和“重写”多态性而在编译时发生“过载”多态性是真的吗？我之所以这样问，是因为许多论坛似乎给出了相互矛盾且常常令人困惑的答案。 谢谢！ 问题答案： 对于问题的第一部分，我认为维基百科提供了一个很好的定义： 在面向对象的程序设计中，子类型多态或包含多态是类型理论中的一个概念，其中名称可以表示许多不同类的实例，只要它们与某个公共超类相关即可。
-
问题内容： 假设我有两个班级：动物和狗。狗是动物的子类。我执行以下代码： 现在，我可以通过a变量来调用Dog类的方法。 但是我的问题是：如果我可以通过Dog对象（继承性）调用Animal的所有方法，那么为什么要使用多态原理呢？我可以声明： 通过此声明，可以使用所有Animal方法和Dog方法。那么为什么要使用多态呢？非常感谢您的回答。 问题答案： 在Java中，多态和继承的概念被“焊接在一起”。通
-
问题内容： 您如何处理在Java中仅具有单一继承的问题？这是我的具体问题： 我有三个（简化的）课程： 这是我认为最基本的实现，但是我想进行其他实现。 可以说我想添加一个新的变量，比如wordLength，但是我想使用继承来添加它。意思是我不想修改那个原始的AbstractWord类。即与此类似： 我知道java不允许我这样做，但是它使我的代码非常难看。现在，每当我添加一个字段时，我都将其添加到Ab
-
本文向大家介绍C++/java 继承类的多态详解及实例代码，包括了C++/java 继承类的多态详解及实例代码的使用技巧和注意事项，需要的朋友参考一下 C++/java 继承类的多态详解 学过C++和Java的人都知道，他们二者由于都可以进行面向对象编程，而面向对象编程的三大特性就是封装、继承、多态，所有今天我们就来简单了解一下C++和Java在多态这方面的不同。 首先我们各看一个案例。 C++
-
本文向大家介绍PHP接口继承及接口多继承原理与实现方法详解，包括了PHP接口继承及接口多继承原理与实现方法详解的使用技巧和注意事项，需要的朋友参考一下 本文实例讲述了PHP接口继承及接口多继承原理与实现方法。分享给大家供大家参考，具体如下： 在PHP的接口中，接口可以继承接口。虽然PHP类只能继承一个父类（单继承），但是接口和类不同，接口可以实现多继承，可以继承一个或者多个接口。当然接口的继承也是
-
问题内容： 我不太明白为什么可以在Java中继承静态方法？ 继承就像从基类继承，而Static属于Class而不是Object。 那么，如果静态仅属于该类，为什么它会滴入派生类呢？它不应该只与定义它的类一起使用吗？ 继承静态方法是一种好的编程习惯吗？ 问题答案： 在Java中，静态方法不是 继承的 （或正确的词被 覆盖 ），但可以 隐藏 。 这里最大的不同是它们不像对象方法那样经受多态性。 运行时