第三次Bolg作业

邻近期末，java课程上课的课时也完成，但是作业还是会有，让我们练习，主要是在pta。

主要的pta是一个名为电费计数的题目，要求模拟移动通讯中的各种计费。这是个比较难的题目，也分成了三次布置以实现不同的功能，所占分值也较大，我们先来说说这道题。

第一次

先给出这个题目的要求和格式的一些基本描述：

 

实现一个简单的电信计费程序：
假设南昌市电信分公司针对市内座机用户采用的计费方式：
月租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元。
每条通讯信息单独计费后累加，不是将所有时间累计后统一计费。
格式：号码+英文空格符+总的话费+英文空格符+余额
每个用户一行，用户之间按号码字符从小到大排序。

 

这道题的类图在题目中给出来了，利用分态，继承的知识将其设计好，其中User是用户类，包括属性： userRecords （用户记录）、balance（余额）、chargeMode（计费方式）、number（号码）。作为实体类切身实现用户的需要，如这个打电话，最重要的有号吗。通信是要受费的，要余额等等。

三个抽象类CallChargeRule。ChargeMode。CommunicationRecord分别实现，不同电话通信之间的计费规则（如省内通信，各个省之间的通信，座机之间，手机之间，座机手机之间等等）通信中可能会有消息记录（如打电话需记录具体时间长短来计算费用，发送短信需要计算短信长度来实现费用计算）

Client 类来完成具体操作时的一些判断，将不同的情况做出不同的处理得到不同的结果

下面给出Client和Main函数的代码

class Client {
private ArrayList<String> std=new ArrayList<String>();
private ArrayList<String> std1=new ArrayList<String>();
private ArrayList<UserRecords> userrecords=new ArrayList<UserRecords>();

public ArrayList<String> getStd() {
return std;
}

public void setStd(ArrayList<String> std) {
this.std = std;
}

public ArrayList<String> getStd1() {
return std1;
}

public void setStd1(ArrayList<String> std1) {
this.std1 = std1;
}

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

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

public void client() throws ParseException {
Scanner in=new Scanner(System.in);
SimpleDateFormat sdf=new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");

String s;
String s1="0791";
String s2="0790";
String s3="079[2-9]";
String s4="0701";
String regStr = "[u]-0791[0-9]{7,8}\\s[0]";
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])";
String[] split=new String[6];
while(true) {
int flag=0;
int flag1=0;
s=in.nextLine();
if(s.equals("end")) {
break;
}
if(s.matches("[u]-0791[0-9]{7,8}\\s[0]")||s.matches(regStr2)) {
if(s.charAt(0)=='t') {
if(std1.contains(s)) {
flag=1;
}
else if(flag==0 && flag == 0) {
std1.add(s);
}
}else if(s.charAt(0)=='u'){
String[] str1=s.split("\\s+");
if(std.contains(str1[0].substring(2))) {
flag1=1;
}
if(flag1==0) {
UserRecords userrecord=new UserRecords();
CallRecord callcord=new CallRecord();
userrecord.addCallingInCityRecords(callcord);
userrecords.add(userrecord);
String[] str=s.split("\\s+");
String number=str[0];
std.add(number.substring(2));
}
}
}
}
for(int i=0;i<std.size();i++) {
for(int j=0;j<std1.size();j++) {
split=std1.get(j).split("\\s+");
if(std.get(i).equals(split[0].substring(2))) {
CallRecord callcord=new CallRecord();
Date date1=sdf.parse(split[2]+" "+split[3]);
Date date2=sdf.parse(split[4]+" "+split[5]);
callcord.setStarTime(date1);
callcord.setEndTime(date2);
callcord.setCallingAddressAreaCode(split[0].substring(2,6));
callcord.setAnswerAddressAreaCode(split[1].substring(0,4));
if(callcord.getAnswerAddressAreaCode().matches(s1)) {
userrecords.get(i).addAnswerInCityRecords(callcord);
}else if(callcord.getAnswerAddressAreaCode().matches(s4)||callcord.getAnswerAddressAreaCode().matches(s3)||callcord.getAnswerAddressAreaCode().matches(s2)) {
userrecords.get(i).addAnswerInprovinceRecords(callcord);
}else {
userrecords.get(i).addAnswerInLandRecords(callcord);
}
}
}
}
}
}

class Main {

public static void main(String[] args) throws ParseException {

Client client=new Client();
// DecimalFormat df=new DecimalFormat("#.0");
ArrayList<String> std=new ArrayList<String>();
client.client();
for(int i=0;i<client.getStd().size();i++) {
User user=new User(client.getUserrecords().get(i));
String cost=String.format("%.1f",user.calCost());
String s=client.getStd().get(i)+" "+cost+" "+user.calBalance();
std.add(s);
}
Collections.sort(std);
for(int i=0;i<std.size();i++) {
System.out.println(std.get(i));
}
}

}

其中在Client中有正则表达式的判断，关于正则表达式，以前也写过blog，还有time函数的应用，这些可以帮助更加简便清晰的实现代码。

第二次

上一次主要是座机的通信计费，这次是手机的，在关键的位置更改代码即可完成

第三次

这次就不太一样了。这次我们完成的是短信之间的通信，首先短信不管你什么时候发，发送短信时时间这些事都不需要处理。短信看你发送几条，通过短信个数来计费，并且看你发送短信的长度，超过一定的长度（本题为10）则增加短信数量。

class CallRecord extends CommunicationRecord {
private Date startTime;
private Date endTime;
private String callingAddressAreaCode;
private String answerAddressAreaCode;

public String getCallType() {
String type = "";
if (callingAddressAreaCode.equals("0791")) {
type = type.concat("1");
} else if (callingAddressAreaCode.matches("^079[023456789]$") || callingAddressAreaCode.equals("0701")) {
type = type.concat("2");
} else {
type = type.concat("3");
}

if (answerAddressAreaCode.equals("0791")) {
type = type.concat("1");
} else if (answerAddressAreaCode.matches("^079[023456789]$") || answerAddressAreaCode.equals("0701")) {
type = type.concat("2");
} else {
type = type.concat("3");
}

return type;
}

public CallRecord(String[] inputs) {
super();

char type = inputs[0].charAt(0);

String sd = null, st = null, ed = null, et = null;

if (type == 't') {
if (inputs.length == 6) {
sd = inputs[2];
st = inputs[3];
ed = inputs[4];
et = inputs[5];
callingAddressAreaCode = inputs[0].substring(0, 4);
answerAddressAreaCode = inputs[1].substring(0, 4);
} else if (inputs.length == 7) {
sd = inputs[3];
st = inputs[4];
ed = inputs[5];
et = inputs[6];
if (inputs[0].charAt(0) != '0') {
if (inputs[2].length() == 10) {
answerAddressAreaCode = inputs[2].substring(0, 3);
} else {
answerAddressAreaCode = inputs[2].substring(0, 4);
}
callingAddressAreaCode = inputs[1];
} else {
if (inputs[0].length() == 10) {
callingAddressAreaCode = inputs[0].substring(0, 3);
} else {
callingAddressAreaCode = inputs[0].substring(0, 4);
}
answerAddressAreaCode = inputs[2];
}
} else if (inputs.length == 8) {
sd = inputs[4];
st = inputs[5];
ed = inputs[6];
et = inputs[7];
callingAddressAreaCode = inputs[1];
answerAddressAreaCode = inputs[3];
}
} else if (type == 'm') {

}
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss", Locale.getDefault());
try {
startTime = simpleDateFormat.parse(sd + " " + st);
endTime = simpleDateFormat.parse(ed + " " + et);
} catch (ParseException e) {
}

}

 

class MobilePhoneMessageRule extends CallChargeRule {

@Override
public double calCost(UserRecords userRecords) {
double sumCost = 0;
int number = 0;
for (MessageRecord m : userRecords.getSendMessageRecords()) {
int length = m.getMessage().length();
if (length <= 10) {
number++;
} else {
number += length / 10;
if (length % 10 != 0) {
number++;
}
}
}
if (number <= 3) {
sumCost = number * 0.1;
} else if (number <= 5) {
sumCost = 0.3 + 0.2 * (number - 3);
} else {
sumCost = 0.7 + 0.3 * (number - 5);
}
return sumCost;
}

}

 

class Inputdeal {

public int check(String input) {
if (input.matches("[u]-0791[0-9]{7,8}\\s[0]") || input.matches("[u]-1[0-9]{10}\\s[13]")) {
return 1;
} else if (input.matches("[m]-1[0-9]{10}\\s" + "1[0-9]{10}\\s" + "[0-9a-zA-Z\\s\\.,]+")) {
return 2;
}
return 0;
}

public void writeUser(ArrayList<User> users, String input) {
User usernew = new User();
String[] inputs = input.split(" ");
String num = inputs[0].substring(2);
for (User i : users) {
if (i.getNumber().equals(num)) {
return;
}
}
usernew.setNumber(num);
int mode = Integer.parseInt(inputs[1]);
if (mode == 3) {
usernew.setChargeMode(new MobilePhoneMassageCharging());
}
users.add(usernew);
}

public void writeRecord(ArrayList<User> users, String input) {
String[] inputs = input.split(" ");
inputs[0] = inputs[0].substring(2);

User callu = null, answeru = null;

String out = inputs[0];
String in = "";
if (inputs.length == 6) {
in = inputs[1];
} else if (inputs.length == 7) {
in = inputs[1];
} else if (inputs.length == 8) {
in = inputs[2];
} else {
in = inputs[1];
}

for (User i : users) {
if (i.getNumber().equals(out)) {
callu = i;
}
if (i.getNumber().equals(in)) {
answeru = i;
}
if (callu != null && answeru != null) {
break;
}
}

if (input.charAt(0) == 'm') {
MessageRecord messageRecord = new MessageRecord(input);
if (callu != null) {
callu.getUserRecords().addSendMessageRecords(messageRecord);
;
}
if (answeru != null) {
callu.getUserRecords().addReceiveMessageRecords(messageRecord);
}
}

}

}

之后还有一些小题目在这里说一说

模拟动物叫的题目，定义一个动物叫的抽象类，让具体动物的叫声继承父类，在主类中调用子类。

class Main {
public static void main(String[] args) {
Cat cat = new Cat();
Dog dog = new Dog();
Goat goat = new Goat();
System.out.println(cat.getVoice());
System.out.println(dog.getVoice());
System.out.println(goat.getVoice());

}

}

abstract class Animal {

private String voice;

public abstract String getVoice();

public abstract void setVoice(String voice);


}
class Dog extends Animal{

@Override
public String getVoice() {
return "狗的叫声：汪汪";
}

@Override
public void setVoice(String voice) {


}

 

}
class Cat extends Animal{

@Override
public String getVoice() {
// TODO Auto-generated method stub
return "猫的叫声：喵喵";
}

@Override
public void setVoice(String voice) {
// TODO Auto-generated method stub

}

}
class Goat extends Animal{

 

@Override
public String getVoice() {
// TODO Auto-generated method stub
return "山羊的叫声：咩咩";
}

@Override
public void setVoice(String voice) {
// TODO Auto-generated method stub

}

}

写一个购物卷和商品的题，在测试类Main中，创建一个Shop类的对象myshop，从键盘输入一个整数（大于或等于3），将其设置为牛奶的箱数。假定有顾客分别使用了该商店面值为50的购物券、面值为100的购物券各消费一次，分别输出消费后商店剩下的牛奶箱数。牛奶的箱数与价格的关系为箱数*50=价格，只要搞清楚这个关系，剩下的都是基本语法的问题

import java.util.Scanner;

public class Main{
public static void main(String args[]){
// int in;
Scanner input = new Scanner(System.in);
Shop shop = new Shop(input.nextInt());
shop.a.buy();
System.out.println("使用了面值为50的购物券进行支付");
System.out.println("牛奶还剩"+shop.getMilkCount()+"箱");
shop.b.buy();
System.out.println("使用了面值为100的购物券进行支付");
System.out.println("牛奶还剩"+shop.getMilkCount()+"箱");
}
}

class Shop{
private int milkCount;
InnerCoupons a = new InnerCoupons(50);
InnerCoupons b = new InnerCoupons(100);

public Shop(int nextInt) {
milkCount = nextInt;
}

public int getMilkCount() {
return milkCount;
}

public void setMilkCount(int milkCount) {
this.milkCount = milkCount;
}
class InnerCoupons{
public int value;
public void buy(){
milkCount -= value/50;
}
InnerCoupons(int value){
this.value = value;
}
}
}

解决记录学生信息和有时信息重复处理的问题，把它的不同的数据存储在不同的属性中，在遍历一遍，遇到重复的就删除掉，非常简便。

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Scanner;
public class Main {
public static void main(String args[]){

ArrayList<Employee> list = new ArrayList<Employee>();

Scanner input = new Scanner(System.in);

int n = input.nextInt();
input.nextLine();
for (int i = 0; i < n; i++) {
String studentImformation = input.nextLine();
Employee list1 = new Employee(studentImformation.split("\\s"));
if (!list.contains(list1)) {
list.add(list1);
}
}
Collections.sort(list, new Comparator<Employee>() {
public int compare(Employee student1, Employee student2) {
return student1.getN().compareTo(student2.getN());
}
});
System.out.println(list.size());
for (Employee each:list) {
System.out.println(each.toString());
}
}

}

class Employee {

private String n;
private String name;
private int age;
private String xb;

public Employee(String[] in){
n = in[0];
name = in[1];
age = Integer.parseInt(in[2]);
xb = in[3];
}

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 String getXb() {
return xb;
}

public void setXb(String xb) {
this.xb = xb;
}

 

public String getN() {
return n;
}

 

public void setN(String n) {
this.n = n;
}

public boolean equals(Object obj) {
Employee temp = (Employee) obj;
return temp.getName().equals(name);
}

public String toString() {
return n + " " + name + " " + age + " " + xb;
}
}