Java实验四

大家好，欢迎来到IT知识分享网。

南昌航空大学实验报告

2021   年 11   月   26  日

课程名称：面向对象程序设计B            实验名称：     抽象类与接口（一）（二）                                  

学号：           姓名：          同组人：                                                

指导教师评定：                                      签名：                          

 

一、实验目的

1、 掌握Java语言中final关键字的含义及使用方法；

2、 掌握Java语言中抽象类的基本概念及使用方法；

3、 掌握Java语言中接口的基本概念及使用方法；

4、 理解程序设计中常用数据结构的用法；

5、 掌握Java语言中List相关类的使用方法；

6、 掌握Java语言中Map相关类的使用方法；

二、实验要求

1、 根据实验步骤中提出的要求，使用eclipse等开发工具编写相应的Java程序；

2、 编译、运行自己所编写的Java程序；

3、 根据编译与运行过程中所获得的错误信息修改程序直至获得正确的结果；

4、 记录实验中遇到的各类问题并以及解决办法。

三、实验步骤

实验四（一）：

1、 以如下类图为基础，重构实验二中农夫过河游戏的代码。相关类说明如下：

抽象类：

MaterialObject：抽象物品类

AbstracTransport：抽象交通工具类

（place：所在地；capacity：容量；goodes：货物列表）

moveTo（String destination）移动到目的地

AbstractRule：抽象规则类

judge（）根据规则判断结果

AbstractGame：抽象游戏类

（gameOverRule：游戏结束规则； gameSuccessRule：游戏输赢规则； gameData：游戏数据）

play（）执行游戏

Animal：动物类   

addedToRecipe（MaterialObject m）添加某物品进该动物的食谱

isFood（MaterialObject m）判断某物品是否在它的食谱中

canBeEat（MaterialObject m）判断某物品能不能被吃到

eat（MaterialObject m）吃某样食物

Person：人类

Plante：植物类

Boat：船类

crossRiver（）过河

crossRiver（Person person）将人运载过河

crossRiver（Person person，MaterialObject m）将人和某样物品运载过河

board（MaterialObject m）物品m上船

crossRiver（MaterialObject m）物品m下船

CrossRiverRule：判断是否都渡过河的规则类

hasCross（MaterialObject m）物品m是否渡过了河

ObjectExistRule：判断物品是否都还存在的规则类

GameOverRule：判断游戏是否结束的规则类

GameSuccessRule：判断游戏输赢的规则类

GameUI：游戏界面类

 

 

 

 

这个主要是读懂类图，再按照类图去写代码，基本没什么问题，具体代码请见附录。

实验四（二）：

2、 在实验4-1的基础上新增一个高兴Happy和哭泣Cry接口，农夫、狼、羊实现Happy接口，农夫在成功渡河、狼在吃羊、羊吃白菜的时候执行高兴接口方法，通过控制台输出不同的内容（内容可自定义，但三观要正）。羊、白菜实现Cry接口，当羊和白菜被吃的时候会用自己的方式哭泣并在控制台输出。

接口代码如下：public interface Happy {

public void happy();

}

 

 

public interface Cry {

public void cry();

}

在需要使用的情况下再去根据想输出的内容去重写里面的方法

四、实验结果    

因为实验四（二）是（一）的基础上添加了个接口，所以在这里就直接演示实验四（二）的代码，代码运行结果如下：

 

 

 

若是失败：

 

 

 

 

若是成功：

 

 

 

五、实验小结

 这次的实验依旧是分两节课完成，第一次课则是按照类图重新去设计农夫过河，第二次课则是在一的基础上加上笑和哭的接口，总体来说还是比较简单的，有点难度的还是在第一节课。在实验中，我还用到了List和Map，在这里也算是再次了解熟悉了List相关类的使用方法Map相关类的使用方法，同时也对接口的使用有了更加深刻的了解，让我收获最大的还是通过所提供的类图去编写代码，让我了解到了代码通过它这样设计，可以大大的降低了耦合度，使类与类之间的联系没那么密切，便于后续的代码的改进，同时也让我知道了平时设计代码的时候应该也要注意代码耦合度的问题。

 

六、附录

package 农夫过河;

 

public class AbstractGame {

GameOverRule gameOverRule;

GameSuccessRule gameSuccessRule;

GameData gameData;

CrossRiverRule crossRiverRule;

ObjectExistRule objectExistRule;

public AbstractGame()

{

gameOverRule=new GameOverRule();

gameSuccessRule=new GameSuccessRule();

gameData=new GameData();

crossRiverRule=new CrossRiverRule();

objectExistRule=new ObjectExistRule();

}

public void play()

{

 

}

}

 

 

package 农夫过河;

 

import java.util.ArrayList;

 

public class AbstracTransport {

String place=”未过河“;

int capacity;

ArrayList <MaterialObject> goodses=new ArrayList<MaterialObject>();

public void moveTo() {

return;

}

}

 

package 农夫过河;

 

public class AbstractRule {

public boolean judeg()

{

return true;

}

}

package 农夫过河;

 

import java.util.HashSet;

public class Animal extends MaterialObject{

private HashSet recipe=new HashSet();

public boolean eat(MaterialObject m,MaterialObject n)

{

return (isFood(m)&&canBeEat(m,n));

}

public void addedToRecipe(MaterialObject m)

{

recipe.add(m);

}

public boolean isFood(MaterialObject m)

{

return recipe.contains(m);

}

public boolean canBeEat(MaterialObject m,MaterialObject n)

{

return (this.place.equals(m.place)&&!this.place.equals(n.place));

}

}

package 农夫过河;

 

public class Boat extends AbstracTransport{

public Boat()

{

capacity=3;

}

public void board(MaterialObject m)

{

if(goodses.size()<3)

goodses.add(m);

}

public void crossRiver()

{

MaterialObject member;

for(int i=0;i<goodses.size();i++)

{

member=goodses.get(i);

member.turnplace();

}

}

public void disembark()

{

goodses.clear();

}

}

package 农夫过河;

 

public class Cabbage extends MaterialObject implements Cry{

public Cabbage()

{

type=”白菜“;

}

public void cry()

{

System.out.println(“被吃了，┭┮﹏┭┮！“);

}

}

package 农夫过河;

 

public class CrossRiverRule extends AbstractRule {

public boolean hasCross(Farmer farmer,Sheep sheep,Cabbage cabbage,Wolf wolf)

{

return(farmer.place.equals(“已过河“)&&sheep.place.equals(“已过河“)&&cabbage.place.equals(“已过河“)&&wolf.place.equals(“已过河“));

}

}

package 农夫过河;

 

public interface Cry {

public void cry();

}

package 农夫过河;

 

public class Farmer extends MaterialObject implements Happy{

public Farmer()

{

type=”农夫“;

}

public void happy()

{

System.out.println(“过河了，o(*￣▽￣*)ブ！“);

}

}

package 农夫过河;

 

import java.util.Scanner;

 

public class Game extends AbstractGame {

GameUI GameUI;

public Game()

{

GameUI=new GameUI();

}

public void play()

{

Scanner input = new Scanner(System.in);

int choice = 0; //用户输入选择

boolean gameOver=false,//游戏结束标志，默认为false，代表游戏进行中，未结束

win=false;     //游戏输赢标志，默认为false，代表未赢得游戏。

while(!gameOver)

{

GameUI.menu();

choice = input.nextInt();

switch(choice)

{

case 0:

System.out.println(“game over: you lose !”);

System.exit(0);

break;

case 1:/* 农夫独自过河的处理 */

gameData.boat.board(gameData.farmer);

break;

case 2:/* 农夫带狼的处理 */

if(gameData.farmer.place.equals(gameData.wolf.place)) {

gameData.boat.board(gameData.farmer);

gameData.boat.board(gameData.wolf);

}

else

System.out.println(“操作错误，请选择有效操作！“);

break;

case 3:/* 农夫带羊的处理 */

if(gameData.farmer.place.equals(gameData.sheep.place)) {

gameData.boat.board(gameData.farmer);

gameData.boat.board(gameData.sheep);

}

else

System.out.println(“操作错误，请选择有效操作！“);

break;

case 4:/* 农夫带白菜的处理 */

if(gameData.farmer.place.equals(gameData.cabbage.place)) {

gameData.boat.board(gameData.farmer);

gameData.boat.board(gameData.cabbage);

}

else

System.out.println(“操作错误，请选择有效操作！“);

break;

default: System.out.println(“请输入范围内的值“);

}

            gameData.boat.crossRiver();

            gameData.boat.disembark();

            if(gameData.wolf.eat(gameData.sheep, gameData.farmer))//狼吃羊和兔子，如果羊不在同一边，则吃不到，如果在同一边，羊被吃

             gameData.sheep.diedOut();

            if(gameData.sheep.eat(gameData.cabbage, gameData.farmer))//同上

             gameData.cabbage.diedOut();

GameUI.showStatus(gameData.farmer,gameData.wolf,gameData.sheep,gameData.cabbage);

gameOver = gameOverRule.GameOver(crossRiverRule, objectExistRule,gameData.farmer,gameData.sheep,gameData.cabbage,gameData.wolf);

}

win=gameSuccessRule.GameSuccess(crossRiverRule,gameData.farmer,gameData.sheep,gameData.cabbage,gameData.wolf);

if(win) {

System.out.println(“game over: you win !”);

}else {

System.out.println(“game over: you lose !”);

}

input.close();

}

}

package 农夫过河;

 

public class GameData {

Farmer farmer;

Wolf wolf;

Sheep sheep;

Cabbage cabbage;

Boat boat;

public GameData()

{

farmer=new Farmer();

cabbage=new Cabbage();

sheep=new Sheep(cabbage);

wolf=new Wolf(sheep);

boat=new Boat();

}

}

package 农夫过河;

 

public class GameOverRule extends AbstractRule{

public boolean GameOver(CrossRiverRule CrossRiverRule,ObjectExistRule ObjectExistRule,Farmer farmer,Sheep sheep,Cabbage cabbage,Wolf wolf) {

return (CrossRiverRule.hasCross(farmer,sheep,cabbage,wolf)||!ObjectExistRule.isExist(cabbage, sheep));

}

}

package 农夫过河;

 

public class GameSuccessRule extends AbstractRule{

public boolean GameSuccess(CrossRiverRule CrossRiverRule,Farmer farmer,Sheep sheep,Cabbage cabbage,Wolf wolf) {

return (CrossRiverRule.hasCross(farmer,sheep,cabbage,wolf));

}

}

package 农夫过河;

 

public class GameUI {

public 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:”);

}

public void showStatus(Farmer farmer, Wolf wolf, Sheep sheep, Cabbage cabbage)

{

farmer.showStatus();

if(farmer.place.equals(“已过河“))

farmer.happy();

wolf.showStatus();

if(!sheep.isExist())

wolf.happy();

sheep.showStatus();

if(!cabbage.isExist)

sheep.happy();

if(!sheep.isExist())

sheep.cry();

cabbage.showStatus();

if(!cabbage.isExist())

cabbage.cry();

}

}

package 农夫过河;

 

public interface Happy {

public void happy();

}

package 农夫过河;

 

import java.util.Scanner;

 

public class Main {

 public static void main(String[] args) {

        Game Game=new Game();

        Game.play();

    }

}

package 农夫过河;

 

public class MaterialObject {

String type;

String place=”未过河“;

boolean isExist=true;

public void diedOut()

{

isExist=!isExist;

}

public boolean isExist()

{

return isExist;

}

public void showStatus()

{

System.out.println(type+”    :”+”place:”+place+”   isExist:”+isExist);

}

public void turnplace()

{

if(place.equals(“未过河“))

place=”已过河“;

else if(place.equals(“已过河“))

place=”未过河“;

}

}

package 农夫过河;

 

public class ObjectExistRule extends AbstractRule{

public boolean isExist(Cabbage cabbage,Sheep sheep)

{

return (cabbage.isExist()&&sheep.isExist());

}

}

package 农夫过河;

 

public class Sheep extends Animal implements Happy,Cry {

public Sheep(Cabbage cabbage)

{

type=”山羊“;

addedToRecipe(cabbage);

}

public void happy()

{

System.out.println(“吃白菜了，o(*￣▽￣*)ブ！“);

}

public void cry()

{

System.out.println(“被吃了，┭┮﹏┭┮！“);

}

}

package 农夫过河;

 

public class Wolf extends Animal implements Happy{

public Wolf(Sheep sheep)

{

type=”野狼“;

addedToRecipe(sheep);

}

public void happy()

{

System.out.println(“吃羊了，o(*￣▽￣*)ブ！“);

}

}