南昌航空大學實驗報告
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(*￣▽￣*)ブ！");
}
}