java第10-16周考了很多东西，从起初的点线面的计算到现在的电信计费，电信计费是正式进入面对对象程序设计的总结。
现在对10-16周考察的java题目进行逐步分析和总结。
PTA大作业6
7-1 电信计费系列1-座机计费
实现一个简单的电信计费程序：
假设南昌市电信分公司针对市内座机用户采用的计费方式：
月租20元，接电话免费，市内拨打电话0.1元/分钟，省内长途0.3元/分钟，国内长途拨打0.6元/分钟。不足一分钟按一分钟计。
南昌市的区号：0791，江西省内各地市区号包括：0790~0799以及0701。
输入格式:
输入信息包括两种类型
1、逐行输入南昌市用户开户的信息，每行一个用户，
格式：u-号码 计费类型 （计费类型包括：0-座机 1-手机实时计费 2-手机A套餐）
例如：u-079186300001 0
座机号码除区号外由是7-8位数字组成。
本题只考虑计费类型0-座机计费，电信系列2、3题会逐步增加计费类型。
2、逐行输入本月某些用户的通讯信息，通讯信息格式：
座机呼叫座机：t-主叫号码 接听号码 起始时间 结束时间
t-079186330022 058686330022 2022.1.3 10:00:25 2022.1.3 10:05:11
以上四项内容之间以一个英文空格分隔，
时间必须符合"yyyy.MM.dd HH:mm:ss"格式。提示：使用SimpleDateFormat类。
以上两类信息，先输入所有开户信息，再输入所有通讯信息，最后一行以“end”结束。
注意：
本题非法输入只做格式非法的判断，不做内容是否合理的判断（时间除外，否则无法计算），比如：
1、输入的所有通讯信息均认为是同一个月的通讯信息，不做日期是否在同一个月还是多个月的判定，直接将通讯费用累加，因此月租只计算一次。
2、记录中如果同一电话号码的多条通话记录时间出现重合，这种情况也不做判断，直接 计算每条记录的费用并累加。
3、用户区号不为南昌市的区号也作为正常用户处理。
输出格式:
根据输入的详细通讯信息，计算所有已开户的用户的当月费用（精确到小数点后2位，
单位元）。假设每个用户初始余额是100元。
每条通讯信息单独计费后累加，不是将所有时间累计后统一计费。
格式：号码+英文空格符+总的话费+英文空格符+余额
每个用户一行，用户之间按号码字符从小到大排序。
错误处理：
输入数据中出现的不符合格式要求的行一律忽略。
建议类图：
参见图1、2、3，可根据理解自行调整：
图1
图1中User是用户类，包括属性：
userRecords （用户记录）、balance（余额）、chargeMode（计费方式）、number（号码）。
ChargeMode是计费方式的抽象类：
chargeRules是计费方式所包含的各种计费规则的集合，ChargeRule类的定义见图3。
getMonthlyRent（）方法用于返回月租（monthlyRent）。
UserRecords是用户记录类，保存用户各种通话、短信的记录，
各种计费规则将使用其中的部分或者全部记录。
其属性从上到下依次是：
市内拨打电话、省内（不含市内）拨打电话、省外拨打电话、
市内接听电话、省内（不含市内）接听电话、省外接听电话的记录
以及发送短信、接收短信的记录。
图2
图2中CommunicationRecord是抽象的通讯记录类：
包含callingNumber拨打号码、answerNumber接听号码两个属性。
CallRecord（通话记录）、MessageRecord（短信记录）是它的子类。
CallRecord（通话记录类）包含属性：
通话的起始、结束时间以及
拨号地点的区号（callingAddressAreaCode）、接听地点的区号（answerAddressAreaCode）。
区号用于记录在哪个地点拨打和接听的电话。座机无法移动，就是本机区号，如果是手机号，则会有差异。
图3
图3是计费规则的相关类，这些类的核心方法是：
calCost（ArrayList<CallRecord> callRecords）。
该方法针根据输入参数callRecords中的所有记录计算某用户的某一项费用；如市话费。
输入参数callRecords的约束条件：必须是某一个用户的符合计费规则要求的所有记录。
LandPhoneInCityRule、LandPhoneInProvinceRule、LandPhoneInLandRule三个类分别是
座机拨打市内、省内、省外电话的计费规则类，用于实现这三种情况的费用计算。
（提示：可以从UserRecords类中获取各种类型的callRecords）。
后续扩展说明：
后续题目集将增加手机用户，手机用户的计费方式中除了与座机计费类似的主叫通话费之外，还包含市外接听电话的漫游费以及发短信的费用。在本题的设计时可统一考虑。
通话记录中，手机需要额外记录拨打/接听的地点的区号，比如：
座机打手机：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
短信的格式：m-主叫号码，接收号码，短信内容
m-18907910010 13305862264 welcome to jiangxi
m-13305862264 18907910010 thank you
输入样例:
在这里给出一组输入。例如：
u-079186300001 0
t-079186300001 058686330022 2022.1.3 10:00:25 2022.1.3 10:05:25
end
输出样例:
在这里给出相应的输出。例如：
079186300001 3.0 77.0
代码：import java.util.Date;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Scanner;
import java.util.TreeMap;
import java.util.ArrayList;public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner in=new Scanner(System.in);
String s=in.nextLine();
TreeMap<String,User> tree=new TreeMap<String,User>();
while(!s.equals("end")) {
if(wrong(s)) {
String[] s1=s.split(" ");
String number=s1[0].substring(3, 14);
String number3=s1[0].substring(6);
ChargeMode chargeMode=new LandlinePhoneCharging();
User user=new User(chargeMode,number3);
tree.put(number3, user);
}
if(wrong1(s)) {
String[] s2=s.split(" ");
String number1=s2[0].substring(2);
String number2=s2[1];
String start=s2[2]+" "+s2[3];
String end=s2[4]+" "+s2[5];
Date start1 = new Date();
Date end1 = new Date();
String count1=s2[0].substring(2,6);
String count2=s2[1].substring(0,4);
String number3=s2[0].substring(6);
String number4=s2[1].substring(4);
SimpleDateFormat format = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
try {
start1 = format.parse(start);
end1 = format.parse(end);
} catch (ParseException e) {
e.printStackTrace();
}
CallRecord record=new CallRecord(number3,number4,start1,end1);
// UserRecords records=new UserRecords();
if (tree.get(number3) != null){
if(count1.equals(count2)) {
tree.get(number3).getUserRecords().addCallingCityRecords(record);
}
else if((count1.equals("0791") &&count2.equals("0790"))
|| (count1.equals("0791") && count2.equals("0792"))
|| (count1.equals("0791") && count2.equals("0793"))
|| (count1.equals("0791") && count2.equals("0794"))
|| (count1.equals("0791") && count2.equals("0795"))
|| (count1.equals("0791") && count2.equals("0796"))
|| (count1.equals("0791") && count2.equals("0797"))
|| (count1.equals("0791") && count2.equals("0798"))
|| (count1.equals("0791") && count2.equals("0799"))
|| (count1.equals("0791") && count2.equals("0701"))) {
tree.get(number3).getUserRecords().addCallingProvinceRecords(record);
}
else {
tree.get(number3).getUserRecords().addCallingLandRecords(record);
}
LandlinePhoneCharging g=new LandlinePhoneCharging();
}
// User user=new User();
}
s=in.nextLine();
}
for (User user : tree.values()) {
double cost = Math.round(user.calCost() * 100) / 100.0 - 20;
System.out.printf("0791" + user.getNumber() + " " + "%.1f" + " "
+ Math.round(user.calBalance() * 100) / 100.0,cost);
System.out.println("");
} }
public static boolean wrong(String s) {
if (!s.matches("u-[0-9]{11,12}\\s[0,1,2]")) {
return false;
}
else {
return true;
}
}
public static boolean wrong1(String s) {
String regStr2 = "[t]-0791[0-9]{7,8}\\s" + "0[0-9]{9,11}\\s" +
"((([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])\\.(0?" +
"[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])\\s" +
"((([0-9]{3}[1-9]|[0-9]{2}[1-9][0-9]|[0-9][1-9][0-9]{2}|[1-9][0-9]{3})\\.((([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])"; if(s.matches(regStr2)) {
return true;
}
else {
return false;
}
}}
abstract class CallChargeRule extends ChargeRule { public CallChargeRule() {
// TODO Auto-generated constructor stub
}
public abstract double calCost(ArrayList<CallRecord> callRecord) ;}
class CallRecord extends CommunicationRecord{
private Date startTime;
private Date endTime;
private String callingAddressAreaCode;
private String answerAddressAreaCode;
private String callingNumber;
private String answerNumber; public CallRecord(String callingNumber, String answerNumber, Date startTime, Date endTime) {
// super(callingNumber, answerNumber);
this.startTime = startTime;
this.endTime = endTime;
// this.callingAddressAreaCode = callingAddressAreaCode;
// this.answerAddressAreaCode = answerAddressAreaCode;
this.callingNumber = callingNumber;
this.answerNumber = 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 CallRecord() {
// TODO Auto-generated constructor stub
} public Date getStartTime() {
return startTime;
} public void setStartTime(Date startTime) {
this.startTime = startTime;
} 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 {
ArrayList<ChargeRule> chargeRule = new ArrayList<ChargeRule>();
public ArrayList<ChargeRule> getChargeRule() {
return chargeRule;
} public void setChargeRule(ArrayList<ChargeRule> chargeRule) {
this.chargeRule = chargeRule;
} public abstract double calCost(UserRecords userRecords);
public abstract double getMonthlyRent();}
abstract class ChargeRule { public ChargeRule() {
// TODO Auto-generated constructor stub
}
public abstract double calCost(ArrayList<CallRecord> callRecord) ;}
abstract class CommunicationRecord {
private String callingNumber;
private String answerNumber; public CommunicationRecord(String callingNumber, String answerNumber) {
super();
this.callingNumber = callingNumber;
this.answerNumber = answerNumber;
} public CommunicationRecord() {
// TODO Auto-generated constructor stub
} 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;
}}
class LandlinePhoneCharging extends ChargeMode {
double montlyRent = 20; public LandlinePhoneCharging() {
super();
// TODO 自动生成的构造函数存根
} public double calCost(UserRecords userRecords) {
getChargeRule().add(new LandPhoneInCityRule());
getChargeRule().add(new LandPhoneInProvinceRule());
getChargeRule().add(new LandPhoneInLandRule());
double sum = 0;
sum = super.getChargeRule().get(0).calCost(userRecords.getCallingInCityRecords())
+ super.getChargeRule().get(1).calCost(userRecords.getCallingInProvinceRecords())
+ super.getChargeRule().get(2).calCost(userRecords.getCallingInLandRecords());
return sum;
} @Override
public double getMonthlyRent() {
// TODO 自动生成的方法存根
return this.montlyRent;
}
// @Override
// public double getMothlyRent() {
// // TODO Auto-generated method stub
// return 0;
// }}
class LandPhoneInCityRule extends CallChargeRule{ public LandPhoneInCityRule() {
// TODO Auto-generated constructor stub
} @Override
public double calCost(ArrayList<CallRecord> callRecord) {
// TODO Auto-generated method stub
double sum=0;
for(CallRecord a:callRecord) {
sum = sum + Math.ceil((a.getEndTime().getTime() - a.getStartTime().getTime()) / 1000.0 / 60.0);
}
double num=sum*0.1;
return num;
}}
final class LandPhoneInLandRule extends CallChargeRule{ public LandPhoneInLandRule() {
// TODO Auto-generated constructor stub
} @Override
public double calCost(ArrayList<CallRecord> callRecord) {
// TODO Auto-generated method stub
double sum=0;
for(CallRecord a:callRecord) {
sum = sum + Math.ceil((a.getEndTime().getTime() - a.getStartTime().getTime()) / 1000.0 / 60.0);
}
double num=sum*0.6;
return num;
}}
class LandPhoneInProvinceRule extends CallChargeRule{ public LandPhoneInProvinceRule() {
// TODO Auto-generated constructor stub
} @Override
public double calCost(ArrayList<CallRecord> callRecord) {
// TODO Auto-generated method stub
double sum=0;
for(CallRecord a:callRecord) {
sum = sum + Math.ceil((a.getEndTime().getTime() - a.getStartTime().getTime()) / 1000.0 / 60.0);
}
double num=sum*0.3;
return num;
}}
class MessageRecord extends CommunicationRecord{
private String message; public MessageRecord(String callingNumber, String answerNumber, String message) {
super(callingNumber, answerNumber);
this.message = message;
} public MessageRecord() {
// TODO Auto-generated constructor stub
} public String getMessage() {
return message;
} public void setMessage(String message) {
this.message = message;
}}
class User {
UserRecords userRecords=new UserRecords();
private double balance=100;
ChargeMode chargemode;
private String number;
public User(ChargeMode chargemode, String number) {
super();
this.chargemode = chargemode;
this.number = number;
} public UserRecords getUserRecords() {
return userRecords;
} public void setUserRecords(UserRecords userRecords) {
this.userRecords = userRecords;
} public double getBalance() {
return balance;
} public ChargeMode getChargemode() {
return chargemode;
} public void setChargemode(ChargeMode chargemode) {
this.chargemode = chargemode;
} public String getNumber() {
return number;
} public void setNumber(String number) {
this.number = number;
} public User() {
// TODO Auto-generated constructor stub
}
public double calBalance() {
double calBalance=this.balance-calCost();
return calBalance;
}
public double calCost() {
double calCost=chargemode.getMonthlyRent()+chargemode.calCost(userRecords);
return calCost;
}
}
class UserRecords {
ArrayList<CallRecord> callingInCityRecords = new ArrayList<CallRecord>();
ArrayList<CallRecord> callingInProvinceRecords = new ArrayList<CallRecord>();
ArrayList<CallRecord> callingInLandRecords = new ArrayList<CallRecord>();
ArrayList<CallRecord> answerInCityRecords = new ArrayList<CallRecord>();
ArrayList<CallRecord> answerInProvinceRecords = new ArrayList<CallRecord>();
ArrayList<CallRecord> answerInLandRecords = new ArrayList<CallRecord>();
ArrayList<MessageRecord> sendMessageRecords = new ArrayList<MessageRecord>();
ArrayList<MessageRecord> receiveMessageRecords = new ArrayList<MessageRecord>();
public void addCallingCityRecords(CallRecord callRecord) {
callingInCityRecords.add(callRecord);
}
public void addCallingProvinceRecords(CallRecord callRecord) {
callingInProvinceRecords.add(callRecord);
}
public void addCallingLandRecords(CallRecord callRecord) {
callingInLandRecords.add(callRecord);
}
public void addAnswerInCityRecords(CallRecord callRecord) {
answerInCityRecords.add(callRecord);
}
public void addAnswerInProvinceRecords(CallRecord callRecord) {
answerInProvinceRecords.add(callRecord);
}
public void addAnswerInLandRecords(CallRecord callRecord) {
answerInLandRecords.add(callRecord);
}
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> getAnswerInCityRecords() {
return answerInCityRecords;
}
public ArrayList<CallRecord> getAnswerInProvinceRecords() {
return callingInProvinceRecords;
}
public ArrayList<CallRecord> getAnswerInLandRecords() {
return callingInLandRecords;
}
}
思路：电信计费方面是一个新颖的题目， 我对其首先根据要求创建了User类，是对对象的专用类，我对该类进行了封装处理，使其可以不易被其他类访问，
再根据要求创建了一系列记账等计算主类，使其更易理解和后续的改进。
总结：针对这个作业来说，我学会了面向对象的程序设计，这个程序更偏向对对象的设计，更丰富了对象的感受，也使得这个程序后续的改进更加方便，
程序代码还有待改进，后面作业也有写。
7-2 多态测试
定义容器Container接口。模拟实现一个容器类层次结构，并进行接口的实现、抽象方法重写和多态机制测试。各容器类实现求表面积、体积的方法。
- 定义接口Container：
属性：
public static final double pi=3.1415926;
抽象方法:
public abstract double area();
public abstract double volume();
static double sumofArea(Container c[]);
static double sumofVolume(Container c[]);
其中两个静态方法分别计算返回容器数组中所有对象的面积之和、周长之和； - 定义Cube类、Cylinder类均实现自Container接口。
Cube类(属性：边长double类型)、Cylinder类(属性：底圆半径、高，double类型)。
输入格式:
第一行n表示对象个数，对象类型用cube、cylinder区分，cube表示立方体对象，后面输入边长，输入cylinder表示圆柱体对象，后面是底圆半径、高。
输出格式:
分别输出所有容器对象的表面积之和、体积之和，结果保留小数点后2位。
输入样例:
在这里给出一组输入。例如：
4
cube
15.7
cylinder
23.5 100
cube
46.8
cylinder
17.5 200
输出样例:
在这里给出相应的输出。例如：
56771.13
472290.12import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in=new Scanner(System.in);
int n=in.nextInt();
int count=0;
Container c[]=new Container[n];
for(int i=0;i<c.length;i++) {
String s=in.next();
if(s.equals("cube")) {
c[i]=new Cube(in.nextDouble());
}
else {
c[i]=new Cylinder(in.nextDouble(),in.nextDouble());
}
}
System.out.printf("%.2f",sumofArea(c));
System.out.printf("\n");
System.out.printf("%.2f",sumofVolume(c)); }
public static double sumofArea(Container c[]) {
double sum=0;
for(int i=0;i<c.length;i++) {
if(c[i] instanceof Cube) {
sum=sum+((Cube)c[i]).area();
}
else {
sum=sum+((Cylinder)c[i]).area();
}
}
return sum;
}
public static double sumofVolume(Container c[]) {
double sum=0;
for(int i=0;i<c.length;i++) {
if(c[i] instanceof Cube) {
sum=sum+((Cube)c[i]).volume();
}
else {
sum=sum+((Cylinder)c[i]).volume();
}
}
return sum;
}}
interface Container {
public static final double pi=3.1415926;
public abstract double area();
public abstract double volume();}
class Cube implements Container{
private double l; public Cube() {
} public Cube(double l) {
super();
this.l = l;
} public double area() {
double area=6*l*l;
return area;
} public double volume() {
double volume=l*l*l;
return volume;
}}
class Cylinder implements Container{
private double r;
private double h; public Cylinder() {
} public Cylinder(double r, double h) {
super();
this.r = r;
this.h = h;
}
public double area() {
double area=2*pi*r*r+2*pi*h*r;
return area;
}
public double volume() {
double volume = pi*r*r*h;
return volume;
}}本次多态测试使我学会了对多态类的处理。定义容器Container接口。模拟实现一个容器类层次结构，并进行接口的实现、抽象方法重写和多态机制测试。各容器类实现求表面积、体积的方法。
还有对接口实现，抽象方法重写等等。都后续有待改进。
PTA大作业七
7-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元。
每条通讯、短信信息均单独计费后累加，不是将所有信息累计后统一计费。
格式：号码+英文空格符+总的话费+英文空格符+余额
每个用户一行，用户之间按号码字符从小到大排序。
错误处理：
输入数据中出现的不符合格式要求的行一律忽略。
本题只做格式的错误判断，无需做内容上不合理的判断，比如同一个电话两条通讯记录的时间有重合、开户号码非南昌市的号码等，此类情况都当成正确的输入计算。但时间的输入必须符合要求，比如不能输入2022.13.61 28:72:65。
建议类图：
参见图1、2、3：
图1
图1中User是用户类，包括属性：
userRecords （用户记录）、balance（余额）、chargeMode（计费方式）、number（号码）。
ChargeMode是计费方式的抽象类：
chargeRules是计费方式所包含的各种计费规则的集合，ChargeRule类的定义见图3。
getMonthlyRent（）方法用于返回月租（monthlyRent）。
UserRecords是用户记录类，保存用户各种通话、短信的记录，
各种计费规则将使用其中的部分或者全部记录。
其属性从上到下依次是：
市内拨打电话、省内（不含市内）拨打电话、省外拨打电话、
市内接听电话、省内（不含市内）接听电话、省外接听电话的记录
以及发送短信、接收短信的记录。
图2
图2中CommunicationRecord是抽象的通讯记录类：
包含callingNumber拨打号码、answerNumber接听号码两个属性。
CallRecord（通话记录）、MessageRecord（短信记录）是它的子类。CallRecord（通话记录类）包含属性：
通话的起始、结束时间以及
拨号地点的区号（callingAddressAreaCode）、接听地点的区号（answerAddressAreaCode）。
区号用于记录在哪个地点拨打和接听的电话。座机无法移动，就是本机区号，如果是手机号，则会有差异。
图3
图3是计费规则的相关类，这些类的核心方法是：
calCost（ArrayList<CallRecord> callRecords）。
该方法针根据输入参数callRecords中的所有记录计算某用户的某一项费用；如市话费。
输入参数callRecords的约束条件：必须是某一个用户的符合计费规则要求的所有记录。
SendMessageRule是发送短信的计费规则类，用于计算发送短信的费用。
LandPhoneInCityRule、LandPhoneInProvinceRule、LandPhoneInLandRule三个类分别是座机拨打市内、省内、省外电话的计费规则类，用于实现这三种情况的费用计算。
（提示：可以从UserRecords类中获取各种类型的callRecords）。
注意：以上图中所定义的类不是限定要求，根据实际需要自行补充或修改。
输入样例:
在这里给出一组输入。例如：
u-13811111111 1
t-13811111111 0791 13811111110 020 2022.1.3 08:00:00 2022.1.3 08:09:20
end
输出样例:
在这里给出相应的输出。例如：
13811111111 3.0 82.0电信计费方面是一个新颖的题目， 我对其首先根据要求创建了User类，是对对象的专用类，我对该类进行了封装处理，使其可以不易被其他类访问，
再根据要求创建了一系列记账等计算主类，使其更易理解和后续的改进。
总结：针对这个作业来说，我学会了面向对象的程序设计，这个程序更偏向对对象的设计，更丰富了对象的感受，也使得这个程序后续的改进更加方便，
程序代码还有待改进，后续还会再次改进。
7-2 sdut-Collection-sort--C~K的班级（II）
经过不懈的努力，C~K终于当上了班主任。
现在他要统计班里学生的名单，但是C~K在教务系统中导出班级名单时出了问题，发现会有同学的信息重复，现在他想把重复的同学信息删掉，只保留一个，
但是工作量太大了，所以找到了会编程的你，你能帮他解决这个问题吗？
输入格式:
第一行输入一个N，代表C~K导出的名单共有N行（N<100000）.
接下来的N行，每一行包括一个同学的信息，学号 姓名 年龄 性别。
输出格式:
第一行输出一个n，代表删除重复名字后C~K的班级共有几人。
接下来的n行，输出每一个同学的信息，输出按照学号从小到大的顺序。
输入样例:
6
0001 MeiK 20 M
0001 MeiK 20 M
0002 sdk2 21 M
0002 sdk2 21 M
0002 sdk2 21 M
0000 blf2 22 F
输出样例:
3
0000 blf2 22 F
0001 MeiK 20 M
0002 sdk2 21 Mimport java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int a = in.nextInt();
int b = in.nextInt();
}
}import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int a = in.nextInt();
int b = in.nextInt();
}
}代码较为简单，题目不复杂，没有学到什么新颖的东西。。。。
7-3 阅读程序，按照题目需求修改程序功能需求：
使用集合存储3个员工的信息（有序);
通过迭代器依次找出所有的员工。
提示：学生复制以下代码到编程区，并按需求进行调试修改。
// 1、导入相关包
//定义员工类
class Employee {
private String name;
private int age;
public Employee() {
super();
}
public Employee(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
//主函数
public class Main {
public static void main(String[] args) {
// 1、创建有序集合对象
Collection c ;
// 创建3个员工元素对象
for (int i = 0; i < 3; i++) {
Scanner sc = new Scanner(System.in);
String employeeName = sc.nextLine();
int employeeAge = sc.nextInt();
Employee employee = new Employee(employeeName, employeeAge);
c.add(employee);
}
// 2、创建迭代器遍历集合
Iterator it;
//3、遍历
while (it.hasnext) {
//4、集合中对象未知，向下转型
Employee e = it.next();
System.out.println(e.getName() + "---" + e.getAge());
}
}
}
输入样例:
在这里给出一组输入。例如：
zs
10
ls
20
ww
30
输出样例:
在这里给出相应的输出。例如：
zs---10
ls---20
ww---30// 1、导入相关包
//定义员工类
class Employee { private String name;
private int age; public Employee() {
super();
} public Employee(String name, int age) {
super();
this.name = name;
this.age = age;
} public String getName() {
return name;
} public void setName(String name) {
this.name = name;
} public int getAge() {
return age;
} public void setAge(int age) {
this.age = age;
}
}//主函数
public class Main { public static void main(String[] args) {
// 1、创建有序集合对象
Collection c ; // 创建3个员工元素对象
for (int i = 0; i < 3; i++) {
Scanner sc = new Scanner(System.in);
String employeeName = sc.nextLine();
int employeeAge = sc.nextInt();
Employee employee = new Employee(employeeName, employeeAge);
c.add(employee);
}
// 2、创建迭代器遍历集合
Iterator it;
//3、遍历
while (it.hasnext) {
//4、集合中对象未知，向下转型
Employee e = it.next();
System.out.println(e.getName() + "---" + e.getAge());
}
}}简单来说就是对迭代器的处理和运用，定义类以及其他函数，灵活运用迭代器遍历集合就好。。。
7-2 编写一个类Shop（商店）、内部类InnerCoupons（内部购物券）
分数 30
全屏浏览题目
切换布局
作者 吴光生
单位 新余学院
编写一个类Shop（商店），该类中有一个成员内部类InnerCoupons（内部购物券），可以用于购买该商店的牛奶（假设每箱牛奶售价为50元）。要求如下：
（1）Shop类中有私有属性milkCount（牛奶的箱数，int类型）、公有的成员方法setMilkCount( )和getMilkCount( )分别用于设置和获取牛奶的箱数。
（2）成员内部类InnerCoupons，有公有属性value（面值，int类型），一个带参数的构造方法可以设定购物券的面值value，一个公有的成员方法buy( )要求输出使用了面值为多少的购物券进行支付，同时使商店牛奶的箱数减少value/50。
（3）Shop类中还有成员变量coupons50（面值为50元的内部购物券，类型为InnerCoupons）、coupons100（面值为100元的内部购物券，类型为InnerCoupons）。
（4）在Shop类的构造方法中，调用内部类InnerCoupons的带参数的构造方法分别创建上面的购物券coupons50、coupons100。
在测试类Main中，创建一个Shop类的对象myshop，从键盘输入一个整数（大于或等于3），将其设置为牛奶的箱数。假定有顾客分别使用了该商店面值为50的购物券、面值为100的购物券各消费一次，分别输出消费后商店剩下的牛奶箱数。
输入格式:
输入一个大于或等于3的整数。
输出格式:
使用了面值为50的购物券进行支付
牛奶还剩XX箱
使用了面值为100的购物券进行支付
牛奶还剩XX箱
输入样例:
在这里给出一组输入。例如：
5
输出样例:
在这里给出相应的输出。例如：
使用了面值为50的购物券进行支付
牛奶还剩4箱
使用了面值为100的购物券进行支付
牛奶还剩2箱import java.util.Scanner;
class Shop{
private int milkCount;
public InnerCoupons coupons50=new InnerCoupons(50);
public InnerCoupons coupons100=new InnerCoupons(100);
public Shop() {
super();
// TODO Auto-generated constructor stub
} public InnerCoupons getCoupons50() {
return coupons50;
} public InnerCoupons getCoupons100() {
return coupons100;
} public int getMilkCount() {
return milkCount;
} public void setMilkCount(int milkCount) {
this.milkCount = milkCount;
}
class InnerCoupons {
public int value; public InnerCoupons() {
super();
// TODO Auto-generated constructor stub
}
public InnerCoupons(int value) {
super();
this.value = value;
}
public void buy() {
System.out.println("使用了面值为"+value+"的购物券进行支付");
System.out.println("牛奶还剩"+(getMilkCount()-value/50)+"箱");
setMilkCount(getMilkCount()-value/50);
}
}
}
public class Main{
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
Shop myshop = new Shop();
int x = input.nextInt();
myshop.setMilkCount(x);
myshop.getCoupons50().buy();
myshop.getCoupons100().buy();
}
}
7-3 动物发声模拟器（多态）
分数 20
全屏浏览题目
切换布局
作者 刘凤良
单位 天津仁爱学院
设计一个动物发生模拟器，用于模拟不同动物的叫声。比如狮吼、虎啸、狗旺旺、猫喵喵……。
定义抽象类Animal，包含两个抽象方法：获取动物类别getAnimalClass()、动物叫shout()；
然后基于抽象类Animal定义狗类Dog、猫类Cat和山羊Goat，用getAnimalClass()方法返回不同的动物类别（比如猫，狗，山羊），用shout()方法分别输出不同的叫声（比如喵喵、汪汪、咩咩）。
最后编写AnimalShoutTest类测试，输出：
猫的叫声：喵喵
狗的叫声：汪汪
山羊的叫声：咩咩
其中，在AnimalShoutTestMain类中，用speak(Animal animal){}方法输出动物animal的叫声，在main()方法中调用speak()方法，分别输出猫、狗和山羊对象的叫声。
请在下面的【】处添加代码。
//动物发生模拟器. 请在下面的【】处添加代码。
public class AnimalShoutTest2 {
public static void main(String[] args) {
Cat cat = new Cat();
Dog dog = new Dog();
Goat goat = new Goat();
speak(cat);
speak(dog);
speak(goat);
}
//定义静态方法speak()
【】
}
//定义抽象类Animal
【】class Animal{
【】
}
//基于Animal类，定义猫类Cat，并重写两个抽象方法
class Cat 【】{
【】
【】
}
//基于Animal类，定义狗类Dog，并重写两个抽象方法
class Dog 【】{
【】
【】
}
//基于Animal类，定义山羊类Goat，并重写两个抽象方法
class Goat 【】{
【】
【】
}
输入样例:
输出样例:
猫的叫声：喵喵
狗的叫声：汪汪
山羊的叫声：咩咩public class Main {
public static void main(String[] args) {
Cat cat = new Cat();
Dog dog = new Dog();
Goat goat = new Goat();
speak(cat);
speak(dog);
speak(goat);
}
//定义静态方法speak()
public static void speak(Animal animal) {
System.out.print(animal.getAnimalClass()+"的叫声：");
animal.shout();
}
}//定义抽象类Animal
abstract class Animal{
public abstract String getAnimalClass();
public abstract void shout();
}
//基于Animal类，定义猫类Cat，并重写两个抽象方法
class Cat extends Animal{
private String cat = "猫";
@Override
public String getAnimalClass() {
// TODO Auto-generated method stub
return cat;
} @Override
public void shout() {
// TODO Auto-generated method stub
System.out.println("喵喵");
}
}
//基于Animal类，定义狗类Dog，并重写两个抽象方法
class Dog extends Animal{
private String dog = "狗";
@Override
public String getAnimalClass() {
// TODO Auto-generated method stub
return dog;
} @Override
public void shout() {
// TODO Auto-generated method stub
System.out.println("汪汪");
}
}
//基于Animal类，定义山羊类Goat，并重写两个抽象方法
class Goat extends Animal{
private String goat = "山羊";
@Override
public String getAnimalClass() {
// TODO Auto-generated method stub
return goat;
}
@Override
public void shout() {
// TODO Auto-generated method stub
System.out.println("咩咩");
}
}这个作业很有意思。可以灵活使用其他类的互相调用来实现对动物声音的模仿，其中，在AnimalShoutTestMain类中，用speak(Animal animal){}方法输出动物animal的叫声，在main()方法中调用speak()方法，分别输出猫、狗和山羊对象的叫声。
总结：从10周到16周，有很多题目不会，代码也不太会打，学到的东西却很多，类图也能看的很容易了，对于刚学java时
更加熟练。后续写面向对象的程序设计会先对要求图画出相关类图，方便创建以及调用。
