首页 > 其他分享> 文章详细

BLOG3-超星、PTA、实验的总结

2022-06-10 15:33:42 阅读：126 来源： 互联网

标签：String BLOG3 System PTA 超星 println new public out

PTA大作业、期中考试以及超星作业总结

一.PTA电信计费大作业三次总结

1.前言：本次大作业主要分为三个部分，针对市内座机用户采用的计费方式，针对手机用户采用实时计费方式，

针对手机的短信计费等三个方式，也算环环递进，相较于前面的多边形计算来说，难度没有那么大，但是想要完成也得花费很多时间和精力，

对于正则表达式的运用判断，以及计费过程中的计算，都有着很大的难度，有耐心，肯花时间还是能解决的。

2.重点题目源码如下

实现南昌市电信分公司的计费程序，假设该公司针对手机和座机用户分别采取了两种计费方案，分别如下：
1、针对市内座机用户采用的计费方式（与电信计费系列1内容相同）：
月租20元，接电话免费，市内拨打电话0.1元/分钟，省内长途0.3元/分钟，国内长途拨打0.6元/分钟。不足一分钟按一分钟计。
假设本市的区号：0791，江西省内各地市区号包括：0790~0799以及0701。
2、针对手机用户采用实时计费方式：
月租15元，市内省内接电话均免费，市内拨打市内电话0.1元/分钟，市内拨打省内电话0.2元/分钟，市内拨打省外电话0.3元/分钟，省内漫游打电话0.3元/分钟，省外漫游接听0.3元/分钟，省外漫游拨打0.6元/分钟；
注：被叫电话属于市内、省内还是国内由被叫电话的接听地点区号决定，比如以下案例中，南昌市手机用户13307912264在区号为020的广州接听了电话，主叫号码应被计算为拨打了一个省外长途，同时，手机用户13307912264也要被计算省外接听漫游费：
u-13307912264 1
t-079186330022 13307912264 020 2022.1.3 10:00:25 2022.1.3 10:05:11

输入：
输入信息包括两种类型
1、逐行输入南昌市用户开户的信息，每行一个用户，含手机和座机用户
格式：u-号码计费类型（计费类型包括：0-座机 1-手机实时计费 2-手机A套餐）
例如：u-079186300001 0
座机号码由区号和电话号码拼接而成，电话号码包含7-8位数字，区号最高位是0。
手机号码由11位数字构成，最高位是1。
本题在电信计费系列1基础上增加类型1-手机实时计费。
手机设置0或者座机设置成1，此种错误可不做判断。
2、逐行输入本月某些用户的通讯信息，通讯信息格式：
座机呼叫座机：t-主叫号码接听号码起始时间结束时间
t-079186330022 058686330022 2022.1.3 10:00:25 2022.1.3 10:05:11
以上四项内容之间以一个英文空格分隔，
时间必须符合"yyyy.MM.dd HH:mm:ss"格式。提示：使用SimpleDateFormat类。
输入格式增加手机接打电话以及收发短信的格式，手机接打电话的信息除了号码之外需要额外记录拨打/接听的地点的区号，比如：
座机打手机：
t-主叫号码接听号码接听地点区号起始时间结束时间
t-079186330022 13305862264 020 2022.1.3 10:00:25 2022.1.3 10:05:11
手机互打：
t-主叫号码拨号地点接听号码接听地点区号起始时间结束时间
t-18907910010 0791 13305862264 0371 2022.1.3 10:00:25 2022.1.3 10:05:11

注意：以上两类信息，先输入所有开户信息，再输入所有通讯信息，最后一行以“end”结束。

输出：
根据输入的详细通讯信息，计算所有已开户的用户的当月费用（精确到小数点后2位，单位元）。假设每个用户初始余额是100元。
每条通讯、短信信息均单独计费后累加，不是将所有信息累计后统一计费。
格式：号码+英文空格符+总的话费+英文空格符+余额
每个用户一行，用户之间按号码字符从小到大排序。
错误处理：
输入数据中出现的不符合格式要求的行一律

类图

主函数代码如下：

public class Main{
public static void main(String[] args) throws ParseException {
Scanner input = new Scanner(System.in);
ArrayList<User> users = new ArrayList<User>();
String string = input.nextLine();
String datePatten = "((([0-9]{3}[1-9]|[0-9]{2}[1-9][0-9]|[0-9][1-9][0-9]{2}|[1-9][0-9]{3})\\.(((0?[13578]|1[02])\\.(" +
"[1-9]|[12][0-9]|3[01]))|(([469]|11)\\.([1-9]|[12][0-9]|30))|(2\\.([1-9]|[1][0-9]|2[0-8]))))|(((" +
"[0-9]{2})([48]|[2468][048]|[13579][26])|(([48]|[2468][048]|[3579][26])00))\\.2\\.29))" +
"\\s([0-1]?[0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])";
String patten1 = "[u][-][0][7][9][1][0-9]{7,8}\\s[0]";
String patten2 = "[u][-][1][3][0-9]{9}\\s[1]";

String patten3 = "[t]-0791[0-9]{7,8}\\s" + "0[0-9]{9,11}\\s"+datePatten + "\\s" + datePatten;//座机打座机
String patten4 = "[t]-0791[0-9]{7,8}\\s" +"1[0-9]{10}\\s"+"0[0-9]{2,3}\\s"+datePatten + "\\s" + datePatten;//座机打手机
String patten5 = "[t]-1[0-9]{10}\\s" +"0[0-9]{2,3}\\s"+"0[0-9]{10,11}\\s"+datePatten + "\\s" + datePatten;//手机打座机
String patten6 = "[t]-1[0-9]{10}\\s" +"0[0-9]{2,3}\\s"+"1[0-9]{10}\\s"+"0[0-9]{2,3}\\s"+datePatten + "\\s" + datePatten;//手机打手机

while (!string.equals("end")) {
String str[] = string.split(" ");
if (string.matches(patten1)) {
String number = str[0].substring(2);
if (!isUser(number,users)) {
User user = new User(number);
LandlinePhoneCharging landlinePhoneCharging = new LandlinePhoneCharging();
user.setChargeMode(landlinePhoneCharging);
users.add(user);
}
}else if (string.matches(patten2)) {
String number = str[0].substring(2);
if (!isUser(number,users)) {
User user = new User(number);
MobilelinePhoneCharing mobilePhoneCharging = new MobilelinePhoneCharing();
user.setChargeMode(mobilePhoneCharging);
users.add(user);
}
}else if (string.matches(patten3)) {
Date startTime = new Date();
Date endTime = new Date();
String callNum = str[0].substring(2);
String answerNum = str[1];
SimpleDateFormat content = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
startTime = content.parse(str[2] + " " + str[3]);
endTime = content.parse(str[4] + " "+ str[5]);
CallRecord callRecord = new CallRecord(startTime,endTime,callNum,answerNum);
setLinePhoneCallRecord(users,callNum,answerNum,callRecord);

}else if (string.matches(patten4)) { //座机打手机
Date startTime = new Date();
Date endTime = new Date();
String callNum = str[0].substring(2);
String answerNum = str[1];
SimpleDateFormat content = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
startTime = content.parse(str[3] + " " + str[4]);
endTime = content.parse(str[5] + " " + str[6]);
CallRecord callRecord = new CallRecord(startTime,endTime,callNum,answerNum);
if (isUser(callNum,users)) {
int n = findUserNum(callNum,users);
int check = checkLinePhone(str[2]);
if (check == 1) {
users.get(n).getUserRecords().addCallingInCityRecords(callRecord);
}else if (check == 2) {
users.get(n).getUserRecords().addCallingInProvinceRecords(callRecord);
}else if (check == 3) {
users.get(n).getUserRecords().addCallingInLandRecords(callRecord);
}
}
if (isUser(answerNum,users)){
int n = findUserNum(answerNum,users);
int check = checkLineToMobile(callNum,str[2]);
if (!callNum.substring(0,4).matches("[0][7]([9][0-9]|[0][1])") || !str[2].matches("[0][7]([9][0-9]|[0][1])")) {
users.get(n).getUserRecords().addAnswerOutProvinceRecords(callRecord);
}
}
}else if (string.matches(patten5)) { //手机打座机
Date startTime = new Date();
Date endTime = new Date();
String callNum = str[0].substring(2);
String answerNum = str[2];
SimpleDateFormat content = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
startTime = content.parse(str[3] + " " + str[4]);
endTime = content.parse(str[5] + " " + str[6]);
CallRecord callRecord = new CallRecord(startTime,endTime,callNum,answerNum);
if (isUser(callNum,users)) {
int n = findUserNum(callNum,users);
int check = checkMobileToLine(str[1],answerNum.substring(0,4));
switch (check) {
case 1:
users.get(n).getUserRecords().addCallingInCityRecords(callRecord);break;
case 2:
users.get(n).getUserRecords().addCallingInProvinceRecords(callRecord);break;
case 3:
users.get(n).getUserRecords().addCallingInLandRecords(callRecord);break;
case 4:
users.get(n).getUserRecords().addCallingRecordsInProvince(callRecord);break;
case 5:
users.get(n).getUserRecords().addCallingOutProvinceRecords(callRecord);break;
}
}
}else if (string.matches(patten6)) { //手机互打
Date startTime = new Date();
Date endTime = new Date();
String callNum = str[0].substring(2);
String answerNum = str[2];
SimpleDateFormat content = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
startTime = content.parse(str[4] + " " + str[5]);
endTime = content.parse(str[6] + " " + str[7]);
CallRecord callRecord = new CallRecord(startTime,endTime,callNum,answerNum);
setMobilePhoneCallRecord(users,callNum,answerNum,callRecord,str[1],str[3]);
}
string = input.nextLine();
}
Collections.sort(users, new Comparator<User>() {
@Override
public int compare(User o1, User o2) {
return o1.getNumber().compareTo(o2.getNumber());
}
});
for (int i = 0;i < users.size();i++) {
System.out.println(String.format("%s %.1f %.1f",users.get(i).getNumber(),users.get(i).calCost(),
users.get(i).calBalance()));
}
}

7-1 电信计费系列3-短信计费

实现一个简单的电信计费程序，针对手机的短信采用如下计费方式：
1、接收短信免费，发送短信0.1元/条，超过3条0.2元/条，超过5条0.3元/条。
2、如果一次发送短信的字符数量超过10个，按每10个字符一条短信进行计算。

输入：
输入信息包括两种类型
1、逐行输入南昌市手机用户开户的信息，每行一个用户。
格式：u-号码计费类型（计费类型包括：0-座机 1-手机实时计费 2-手机A套餐 3-手机短信计费）
例如：u-13305862264 3
座机号码由区号和电话号码拼接而成，电话号码包含7-8位数字，区号最高位是0。
手机号码由11位数字构成，最高位是1。
本题只针对类型3-手机短信计费。
2、逐行输入本月某些用户的短信信息，短信的格式：
m-主叫号码，接收号码，短信内容（短信内容只能由数字、字母、空格、英文逗号、英文句号组成）
m-18907910010 13305862264 welcome to jiangxi.
m-13305862264 18907910010 thank you.

注意：以上两类信息，先输入所有开户信息，再输入所有通讯信息，最后一行以“end”结束。
输出：
根据输入的详细短信信息，计算所有已开户的用户的当月短信费用（精确到小数点后2位，单位元）。假设每个用户初始余额是100元。
每条短信信息均单独计费后累加，不是将所有信息累计后统一计费。
格式：号码+英文空格符+总的话费+英文空格符+余额
每个用户一行，用户之间按号码字符从小到大排序。
错误处理：
输入数据中出现的不符合格式要求的行一律忽略。
本题只做格式的错误判断，无需做内容上不合理的判断，比如同一个电话两条通讯记录的时间有重合、开户号码非南昌市的号码、自己给自己打电话等，此类情况都当成正确的输入计算。但时间的输入必须符合要求，比如不能输入2022.13.61 28:72:65。

下面是我写题的源码

import java.util.Date;
import java.util.ArrayList;
import java.util.Scanner;
import java.util.Collections;
abstract class CallChargeRule extends ChargeRule {

public abstract double calCost(UserRecords userRecords);
}
class CallRecord {

private Date starTime;
private Date endTime;
private String callingAddressAreaCode;
private String answerAddressAreaCode;

public Date getStarTime() {
return starTime;
}
public void setStarTime(Date starTime) {
this.starTime = starTime;
}
public Date getEndTime() {
return endTime;
}
public void setEndTime(Date endTime) {
this.endTime = endTime;
}
public String getCallingAddressAreaCode() {
return callingAddressAreaCode;
}
public void setCallingAddressAreaCode(String callingAddressAreaCode) {
this.callingAddressAreaCode = callingAddressAreaCode;
}
public String getAnswerAddressAreaCode() {
return answerAddressAreaCode;
}
public void setAnswerAddressAreaCode(String answerAddressAreaCode) {
this.answerAddressAreaCode = answerAddressAreaCode;
}

}
abstract class ChargeMode {
private ArrayList<ChargeRule> arraylist =new ArrayList<>();

public ArrayList<ChargeRule> getArraylist() {
return arraylist;
}

public void setArraylist(ArrayList<ChargeRule> arraylist) {
this.arraylist = arraylist;
}
public abstract double calCost(UserRecords userRecords);
public abstract double getMountlyRent();
}
abstract class ChargeRule {

}
class Client {
private ArrayList<String> arr=new ArrayList<String>();
private ArrayList<String> arr1=new ArrayList<String>();
private ArrayList<UserRecords> userrecords=new ArrayList<UserRecords>();

public ArrayList<String> getArr() {
return arr;
}

public void setArr(ArrayList<String> arr) {
this.arr = arr;
}

public ArrayList<String> getArr1() {
return arr;
}

public void setArr1(ArrayList<String> arr1) {
this.arr = arr1;
}

public ArrayList<UserRecords> getUserrecords() {
return userrecords;
}

public void setUserrecords(ArrayList<UserRecords> userrecords) {
this.userrecords = userrecords;
}

public void client() {
Scanner in=new Scanner(System.in);
String s;
int flag=1;
int flag1=1;
String regStr1="[u]-1[0-9]{10}\\s[3]";
String regStr4 = "[m]-1[0-9]{10}\\s"+"1[0-9]{10}\\s"+"[[A-Z]||[a-z]||[0-9]||\\s||,||.]+";
while(true) {
s=in.nextLine();
if(s.equals("end")) {
break;
}
if(s.matches(regStr1)) {
if(arr.contains(s)) {
flag=0;
}
if(flag==1) {
arr.add(s);
}
}
if(s.matches(regStr4)) {
arr1.add(s);
}
}
for(int j=0;j<arr.size();j++) {
String[] str=arr.get(j).split("\\s+");
UserRecords userrecord=new UserRecords();
userrecords.add(userrecord);
for(int i=0;i<arr1.size();i++) {
String[] split=arr1.get(i).split("\\s+");
if(str[0].substring(2).equals(split[0].substring(2))) {
MessageRecord message=new MessageRecord();
message.setMessage(arr1.get(i).substring(26));
message.setCallingNumber(split[0].substring(2));
message.setAnswerNumber(split[1]);
userrecords.get(j).addSendMessageRecords(message);
}
}
}
}
}
abstract class CommunicationRecord {

protected String callingNumber;
protected String answerNumber;
public String getCallingNumber() {
return callingNumber;
}
public void setCallingNumber(String callingNumber) {
this.callingNumber = callingNumber;
}
public String getAnswerNumber() {
return answerNumber;
}
public void setAnswerNumber(String answerNumber) {
this.answerNumber = answerNumber;
}

}
public class Main {

public static void main(String[] args) {

Client client=new Client();
ArrayList<String> arr=new ArrayList<String>();
client.client();
for(int i=0;i<client.getArr().size();i++) {
String[] str=client.getArr().get(i).split("\\s+");
User user=new User(client.getUserrecords().get(i));
String cost=String.format("%.1f", user.calCost());
String s=str[0].substring(2)+" "+cost+" "+user.calBalance();
arr.add(s);
}
Collections.sort(arr);
for(int i=0;i<arr.size();i++) {
System.out.println(arr.get(i));
}
}
}
class MessageRecord extends CommunicationRecord{

private String message;

public String getMessage() {

return message;
}

public void setMessage(String message) {
this.message = message;
}
}
class User {

private double balance=100;
ChargeMode chargeMode;
String number;
UserRecords userrecords;
public User(UserRecords userrecords) {
super();
this.userrecords = userrecords;
}
public double calCost() {
double sum=0;
double calcost=0;
double x=0;
for(int i=0;i<userrecords.getSendMessageRecords().size();i++) {
double k=1;
double a=userrecords.getSendMessageRecords().get(i).getMessage().length();
while(a>10) {
a=a-10;
k++;
}
x=x+k;

}
if(x<=3) {
calcost=0.1*x;
}else if(x>3&&x<=5) {
calcost=0.3+0.2*(x-3);
}else if(x>5) {
calcost=0.7+0.3*(x-5);
}
return calcost;
}
public double calBalance() {
String s=String.format("%.1f", calCost());
double cost=Double.parseDouble(s);
setBalance(getBalance()-cost);
return getBalance();
}
public double getBalance() {
return balance;
}
public ChargeMode getChargeMode() {
return chargeMode;
}
public String getNumber() {
return number;
}
public void setBalance(double balance) {
this.balance = balance;
}
public void setChargeMode(ChargeMode chargeMode) {
this.chargeMode = chargeMode;
}
public void setNumber(String number) {
this.number = number;
}

}
class UserRecords {

private ArrayList<CallRecord> callingInCityRecords=new ArrayList<CallRecord>();
private ArrayList<CallRecord> callingInProvinceRecords=new ArrayList<CallRecord>();
private ArrayList<CallRecord> callingInLandRecords=new ArrayList<CallRecord>();
private ArrayList<CallRecord> answerInCityRecord=new ArrayList<CallRecord>();
private ArrayList<CallRecord> answerInProvinceRecords=new ArrayList<CallRecord>();
private ArrayList<CallRecord> answerInLandRecords=new ArrayList<CallRecord>();
private ArrayList<MessageRecord> sendMessageRecords=new ArrayList<MessageRecord>();
private ArrayList<MessageRecord> receiveMessageRecords=new ArrayList<MessageRecord>();

public void addCallingInCityRecords(CallRecord callRecord) {
callingInCityRecords.add(callRecord);
}
public void addCallingInProvinceRecords(CallRecord callRecord) {
callingInProvinceRecords.add(callRecord);
}
public void addCallingLandRecords(CallRecord callRecord) {
callingInLandRecords.add(callRecord);
}
public void addAnswerInCityRecords(CallRecord AnswerRecord) {
answerInCityRecord.add(AnswerRecord);
}

public void addAnswerInprovinceRecords(CallRecord AnswerRecord) {
answerInProvinceRecords.add(AnswerRecord);
}
public void addAnswerInLandRecords(CallRecord AnswerRecord) {
answerInLandRecords.add(AnswerRecord);
}
public void addSendMessageRecords(MessageRecord sendMessageRecord) {
sendMessageRecords.add(sendMessageRecord);
}
public void addReceiveMessageRecords(MessageRecord receiveMessageRecord) {
receiveMessageRecords.add(receiveMessageRecord);
}
public ArrayList<CallRecord> getCallingInCityRecords() {
return callingInCityRecords;
}
public ArrayList<CallRecord> getCallingInProvinceRecords() {
return callingInProvinceRecords;
}
public ArrayList<CallRecord> getCallingInLandRecords() {
return callingInLandRecords;
}
public ArrayList<CallRecord> getAnswerInCityRecord() {
return answerInCityRecord;
}
public ArrayList<CallRecord> getAnswerInProvinceRecords() {
return answerInProvinceRecords;
}
public ArrayList<CallRecord> getAnswerInLandRecords() {
return answerInLandRecords;
}
public ArrayList<MessageRecord> getSendMessageRecords() {
return sendMessageRecords;
}
public ArrayList<MessageRecord> getReceiveMessageRecords() {
return receiveMessageRecords;
}

}

二、期中考试相关题目总结

期中考试的几个题目相对来说难度不大，主要就是考察对类的建立

设计一个类表示平面直角坐标系上的点Point，私有属性分别为横坐标x与纵坐标y，数据类型均为实型数，除构造方法以及属性的getter与setter方法外，定义一个用于显示信息的方法display(),用来输出该坐标点的坐标信息，格式如下：(x,y)，数值保留两位小数。为简化题目，其中，坐标点的取值范围设定为(0,200]。若输入有误，系统则直接输出Wrong Format
设计一个类表示平面直角坐标系上的线Line，私有属性除了标识线段两端的点point1、point2外，还有一个字符串类型的color，用于表示该线段的颜色，同样，除构造方法以及属性的getter与setter方法外，定义一个用于计算该线段长度的方法getDistance(),还有一个用于显示信息的方法display(),用来输出线段的相关信息，输出格式如下：

但是题目最下方中明确提到需要用到题目所给的类来编写代码，而我头铁，考试时未注意，用了自己的类，题目也能拿到分数，只是所创建的类不是很符合题目要求

题目要求的类图如下:

下面附上我本题的源码

import java.util.Scanner;

public class Main {

public static void main(String[] args) {
point p1=new point();
p1.display();

}
}
class point{
Scanner in =new Scanner (System.in);
private double x1=in.nextDouble() ;
private double y1=in.nextDouble() ;
private double x2=in.nextDouble() ;
private double y2=in.nextDouble() ;

public void display() {
String color =in.next();
if(x1 <= 0 || x1 > 200 || x2 <= 0 || x2 > 200 || y1 <= 0 || y1 > 200 || y2 <= 0 || y2 >200) {
System.out.print("Wrong Format");
}
else {
System.out.println("The line's color is:"+color);
System.out.println("The line's begin point's Coordinate is:");
System.out.println ("("+String.format("%1$.2f", x1)+","+String.format("%1$.2f", y1)+")");
System.out.println("The line's end point's Coordinate is:");
System.out.println ("("+String.format("%1$.2f", x2)+","+String.format("%1$.2f", y2)+")");
double distance = Math.pow(Math.pow(x1 - x2,2) + Math.pow(y1 - y2, 2),0.5);
System.out.println("The line's length is:"+String.format("%1$.2f", distance));

}

}

}

三、超星学习通实验四相关总结

农夫过河问题: -一个农夫带着-匹狼、一只羊、-颗白菜要过河，河上只有一条船能够渡河，而且农夫每次最多只能带一个动物或物品过河。当农夫不在的时候狼会吃羊，羊会吃白菜

请以代码为基础，将程序代码补充完整，实现农夫过河游戏功能:由用户选择角色过河，系统自动判断游戏的胜负:当出现有生物被吃掉的时候，游戏失败，所有角色都到了河的另边，游戏成功。

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();

}

创建类后没有showStatus的方法，在新建的四个类中创建方法showStatus

运行程序后，Main中实体化一个game，game含有若干Objs并且调用GameGui.menu后，再play把他们运行起来

即 Main = > Game = > Objs && GameGui

Main中实体化一个game，game含有多个Objs并且调用GameGui.menu，最后使用play运行

即 Main = > Game

Game= > Objs

Objs && GameGui

问题：

1.虽然将一类对象（farmer, wolf, sheep, cabbage....）继承自一个父类，但子类本身没有什么独特的属性和成员，仅仅调用了父类的构造函数

解决办法：无需多余明确Farmer，Wolf，Sheep以及Cabbage这几个子类

2: 耦合性偏高

五.错误1：直接用类调用了一个非static方法

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

while(!gameOver)

{

GameGui.menu();

choice = input.nextInt();

switch(choice)

cabbage.crossRiver=!( cabbage.crossRiver);

break;

}

wolf.eatSheep(sheep);//狼吃羊，如果羊不在同一边，则吃不到，如果在同一边，羊被吃

sheep.eatCabbage(cabbage);//同上

GameGui.showStatus(farmer,wolf,sheep,cabbage);

gameOver = isGameOver();

解决办法：将该方法设为static，直接用类调用该方法

错误2.

public class GameGui {

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(0~4):");

}

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

/* 输出农夫、各种动物、物品的状态（生存、位置） */

farmer.showStatus();

wolf.showStatus();

sheep.showStatus();

cabbage.showStatus();

}

错误原因：子类直接访问继承自父类的private变量

解决方法：创建一个getName方法来获取name

-------------------------------------------------------------------------------------------

将Main移到src下

public class Main {

public static void main(String[] args) {

// TODO Auto-generated method stub

Game game = new Game();

game.play();

}

运行图片：

二、好处

把不同的子类对象都当作父类来看，可以屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，以适应需求的不断变化。

赋值之后，父类型的引用就可以根据当前赋值给它的子对象的特性以不同的方式运作。也就是说，父亲的行为像儿子，而不是儿子的行为像父亲。

简单的说，建立一个父类对象的引用，它所指对象可以是这个父类的对象，也可以是它的子类的对象。java中当子类拥有和父类同样的函数，当通过这个父类对象的引用调用这个函数的时候，调用到的是子类中的函数。

每个类分工明确，程序能够合理且高效的运行，同时也具备可扩展性与可复用性。

未能对实验三中的多态问题进行合理的改进，程序中的多态部分依然不能起到很强的作用。

七、源码

package FammerCrossing;

public class Main {

public static void main(String[] args) {

Menu play =new Menu();

play.mune();

}

package FammerCrossing;

import java.util.Scanner;

public class Menu {

public void mune() {

Game game1 = new Game();

System.out.println("欢迎来到农夫过河游戏");

System.out.println("1.开始游戏");

System.out.println("2.关闭游戏");

System.out.println("请选择1或2(其他数字退出游戏)");

Scanner input = new Scanner(System.in);

int num = input.nextInt();

switch (num) {

case 1:

game1.game();

break;

case 2:

System.exit(0);

break;

default:

System.exit(0);

}

package FammerCrossing;

import java.util.Scanner;

public class Game {

public void game(){

System.out.println("请输入农夫名字：");

Scanner input= new Scanner(System.in);

String famname= input.nextLine();

Player fammer=new Player();

fammer.setName(famname);

System.out.println("你好！我是"+famname);

System.out.println("请输入狼名字：");

String wolfname= input.nextLine();

Player wolf=new Player();

wolf.setName(wolfname);

System.out.println("啊呜~~~我"+wolfname+"狼又回来了");

System.out.println("请输入羊名字：");

String sheepname= input.nextLine();

Player sheep=new Player();

sheep.setName(sheepname);

System.out.println("咩咩，我是可爱的小羊"+sheepname);

Player cabbage=new Player();

boolean gameover=false;

while (!gameover){

System.out.println("===========请做出你的选择==========");

System.out.println("===========1.农夫一个人过河==========");

System.out.println("===========2.农夫带小狼过河==========");

System.out.println("===========3.农夫带小羊过河=========");

System.out.println("===========4.农夫带蔬菜过河==========");

System.out.println("==================================================");

System.out.println("===========输入1-4==========");

int choice=input.nextInt();

switch (choice){

case 1:fammer.Crossing=!fammer.Crossing;break;

case 2:fammer.Crossing=!fammer.Crossing;wolf.Crossing=!wolf.Crossing;break;

case 3:fammer.Crossing=!fammer.Crossing;sheep.Crossing=!sheep.Crossing;break;

case 4:fammer.Crossing=!fammer.Crossing;cabbage.Crossing=!cabbage.Crossing;break;

}

if(sheep.Crossing==wolf.Crossing&&sheep.Crossing!=fammer.Crossing){

sheep.Alive=false;

}

if(cabbage.Crossing==sheep.Crossing&&cabbage.Crossing!=fammer.Crossing){

cabbage.Alive=false;

}

if(sheep.Alive==false||cabbage.Alive==false){

gameover=true;

}

if(sheep.Alive==true&&cabbage.Alive==true&&fammer.Crossing==true&&sheep.Crossing==true&&wolf.Crossing==true&&cabbage.Crossing==true){

gameover=true;

}

showStatus check=new showStatus();

check.showstatus(fammer,wolf,sheep,cabbage);

}

package FammerCrossing;

public class Player {

private String name;

public boolean Crossing=false;

public boolean Alive=true;

public void setName(String name) {

if(name.length()>=1&&name.length()<=6){

this.name = name;

}

else{

System.out.println("输入名字过长，名字成为默认名字");

this.name="ll";

}

public String getName() {

return name;

}

package FammerCrossing;

public class showStatus {

public void showstatus(Player fammer,Player wolf,Player sheep,Player cabbage){

if(sheep.Alive==false||cabbage.Alive==false){

System.out.println("过河失败哦");

if(fammer.Crossing==true){

System.out.println("农夫已过河");

}else{

System.out.println("农夫未过河");

}

if(wolf.Crossing==true){

System.out.println("小狼已过河");

}else{

System.out.println("小狼未过河");

}

if(sheep.Crossing==true){

System.out.println("小羊已过河");

}else{

System.out.println("小羊未过河");

}

if(cabbage.Crossing==true){

System.out.println("蔬菜已过河");

}else{

System.out.println("蔬菜未过河");

}

System.out.println("========================");

if(sheep.Alive==false){

System.out.println("小羊"+sheep.getName()+"已经被小狼"+wolf.getName()+"吃了！");

}

if(cabbage.Alive==false){

System.out.println("蔬菜已经被小羊"+sheep.getName( )+"吃了！");

}

else{

System.out.println("恭喜过河成功");

}

标签：String,BLOG3,System,PTA,超星,println,new,public,out
来源： https://www.cnblogs.com/wengjian-111/p/16363372.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

BLOG3-超星、PTA、实验的总结