7-1 电信计费系列1-座机计费 分数 80 作者 蔡轲 单位 南昌航空大学
实现一个简单的电信计费程序：
假设南昌市电信分公司针对市内座机用户采用的计费方式：
月租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中User是用户类，包括属性： userRecords （用户记录）、balance（余额）、chargeMode（计费方式）、number（号码）。 ChargeMode是计费方式的抽象类： chargeRules是计费方式所包含的各种计费规则的集合，ChargeRule类的定义见图3。 getMonthlyRent（）方法用于返回月租（monthlyRent）。 UserRecords是用户记录类，保存用户各种通话、短信的记录， 各种计费规则将使用其中的部分或者全部记录。 其属性从上到下依次是： 市内拨打电话、省内（不含市内）拨打电话、省外拨打电话、 市内接听电话、省内（不含市内）接听电话、省外接听电话的记录 以及发送短信、接收短信的记录。
图2中CommunicationRecord是抽象的通讯记录类： 包含callingNumber拨打号码、answerNumber接听号码两个属性。 CallRecord（通话记录）、MessageRecord（短信记录）是它的子类。 CallRecord（通话记录类）包含属性： 通话的起始、结束时间以及 拨号地点的区号（callingAddressAreaCode）、接听地点的区号（answerAddressAreaCode）。 区号用于记录在哪个地点拨打和接听的电话。座机无法移动，就是本机区号，如果是手机号，则会有差异。
图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其余参考样例详见附件，未尽事宜以附件样例为准：
https://images.ptausercontent.com/d3c5de10-9e3f-4a4c-877f-64e76c98f1b6.pdf
分析：
电信计费系列相较于多边形系列简单了很多，类图已经给出，只需要按照类图去实现功能即可。可能电信计费中稍微难一点的可能就是判断输入的格式的正则表达式，我一开始写的时候正则表达式也出了一些错，有些点无法过，所以我改用了一种简单粗暴的方式去判断，那就是将每种情况都在正则表达式中罗列出来。开户的正则表达式就非常的简单清晰，为"^u-[0-9]{11,12} 0$"，为什么是11-12，有人可能有疑问，因为区号不一定都是4位的，还存在3位的区号。通讯信息的正则表达式为"^t-[0]{1}[0-9]{9,11} [0]{1}[0-9]{9,11} [0-9]{4}[.](([1-9]{1})|([1]{1}[0-2]{1}))[.]([1-9]|([1-2]{1}[0-9]{1})|(3[0-1])) (([0-1][0-9])|(2[0-3]))[:]([0-5][0-9])[:]([0-5][0-9]) [0-9]{4}[.](([1-9]{1})|([1]{1}[0-2]{1}))[.]([1-9]|([1-2]{1}[0-9]{1})|3[0-1]) (([0-1][0-9])|(2[0-3]))[:]([0-5][0-9])[:]([0-5][0-9])$"，看着很长，实际上就是每种情况的罗列判定，像后面时间的格式都是固定的。两个正则表达式实现其余就很简单了，开户需要注意的是需要去重，而在接收通讯信息只需要如果接收的结果不为end就循环input.nextLine()接收，将每个通信记录的拨号信息放入拨号用户，收号信息放入收号用户，计费时只需要对每个用户的拨号信息和收号信息注意计费即可。电信计费最后实现出来代码看上去很长，实际上由很多都是get和set语句，真正要实现的核心内容并不多。座机互打，很简单的，输出需要注意排序。各类代码如下：
Main类
public class Main {
public static void main(String[] args) throws ParseException {
ArrayList<User> user=new ArrayList<>();
SimpleDateFormat sdf=new SimpleDateFormat( "yyyy.MM.dd HH:mm:ss" );
Scanner input=new Scanner(System.in);
String ss1="^u-[0-9]{11,12} 0$";
String ss2="^t-[0]{1}[0-9]{9,11} [0]{1}[0-9]{9,11} [0-9]{4}[.](([1-9]{1})|([1]{1}[0-2]{1}))[.]([1-9]|([1-2]{1}[0-9]{1})|(3[0-1])) (([0-1][0-9])|(2[0-3]))[:]([0-5][0-9])[:]([0-5][0-9]) [0-9]{4}[.](([1-9]{1})|([1]{1}[0-2]{1}))[.]([1-9]|([1-2]{1}[0-9]{1})|3[0-1]) (([0-1][0-9])|(2[0-3]))[:]([0-5][0-9])[:]([0-5][0-9])$";
String s1=input.nextLine();
String[] s01=s1.split(" ");
while(!s01[0].equals("end")){
if(!s1.matches(ss1)&&!s1.matches(ss2)){
s1=input.nextLine();
s01=s1.split(" ");
continue;
}
switch (s01[0].charAt(0)){
case 'u': {
boolean creat=true;
User u=new User();
u.setNumber(s01[0].substring(2));
u.setUserRecords(new UserRecords());
switch (s01[1]){
case "0":
u.setChargeMode(new LandlinePhoneCharging());
break;
case "1":
break;
case "2":
break;
}
for(int i=0;i< user.size();i++){
if(user.get(i).getNumber().equals(u.getNumber())){
creat=false;
}
}
if(creat!=false)
user.add(u);
break;
}
case 't':{
String s0=s01[0].substring(2);
for(int i=0;i< user.size();i++){
if(s0.equals(user.get(i).getNumber())){
if(s0.startsWith("0791")&&s01[1].startsWith("0791")){
CallRecord c=new CallRecord();
c.setStartTime(sdf.parse(s01[2]+" "+s01[3]));
c.setEndTime(sdf.parse(s01[4]+" "+s01[5]));
c.setCallingAddressAreaCode(s0.substring(0,4));
user.get(i).getUserRecords().addCallinglnCityRecords(c);
for(int j=0;j<user.size();j++){
if(s01[1].equals(user.get(j).getNumber())){
CallRecord c2=new CallRecord();
c2.setStartTime(sdf.parse(s01[2]+" "+s01[3]));
c2.setEndTime(sdf.parse(s01[4]+" "+s01[5]));
c2.setAnswerAddressAreaCode(s01[1]);
user.get(j).getUserRecords().addAnswerlnCityRecords(c2);
}
}
}
else if(s0.substring(0,4).matches("(079\\d)|(0701)")&&s01[1].substring(0,4).matches("(079\\d)|(0701)")){
CallRecord c=new CallRecord();
c.setStartTime(sdf.parse(s01[2]+" "+s01[3]));
c.setEndTime(sdf.parse(s01[4]+" "+s01[5]));
c.setCallingAddressAreaCode(s0.substring(0,4));
user.get(i).getUserRecords().addCallinglnProvinceRecords(c);
for(int j=0;j<user.size();j++){
if(s01[1].equals(user.get(j).getNumber())){
CallRecord c2=new CallRecord();
c2.setStartTime(sdf.parse(s01[2]+" "+s01[3]));
c2.setEndTime(sdf.parse(s01[4]+" "+s01[5]));
c2.setAnswerAddressAreaCode(s01[1]);
user.get(j).getUserRecords().addAnswerlnProvinceRecords(c2);
}
}
}
else{
CallRecord c=new CallRecord();
c.setStartTime(sdf.parse(s01[2]+" "+s01[3]));
c.setEndTime(sdf.parse(s01[4]+" "+s01[5]));
c.setCallingAddressAreaCode(s0.substring(0,4));
user.get(i).getUserRecords().addCallinglnLandRecords(c);
for(int j=0;j<user.size();j++){
if(s01[1].equals(user.get(j).getNumber())){
CallRecord c2=new CallRecord();
c2.setStartTime(sdf.parse(s01[2]+" "+s01[3]));
c2.setEndTime(sdf.parse(s01[4]+" "+s01[5]));
c2.setAnswerAddressAreaCode(s01[1]);
user.get(j).getUserRecords().addAnswerlnLandRecords(c2);
}
}
break;
}
}
}
}
}
s1=input.nextLine();
s01=s1.split(" ");
}
sort s=new sort();
s.Sort(user);
for(int i=0;i< user.size();i++){
System.out.println(user.get(i).getNumber()+" "+(float)user.get(i).calCost()+" "+(float)(user.get(i).getBalance()-user.get(i).calCost()-user.get(i).getChargeMode().getMonthlyRent()));
}
}
}CommunicationRecord类
abstract class CommunicationRecord{
private String callingNumber;
private String answerNumber;
String getCallingNumber(){
return this.callingNumber;
}
void setCallingNumber(String callingNumber){
this.callingNumber=callingNumber;
}
String getAnswerNumber(){
return this.answerNumber;
}
void setAnswerNumber(String answerNumber){
this.answerNumber=answerNumber;
}
}CallRecord类
class CallRecord extends CommunicationRecord{
private Date startTime;
private Date endTime;
private String callingAddressAreaCode;
private String answerAddressAreaCode;
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;
}
}MessageRecord类
class MessageRecord{
private String message;
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
}ChargeRule类
abstract class ChargeRule{
}存在空类很正常，方便以后维护加东西，开始框架搭好，后面填充也更加简单，不需要大改。
CallChargeRule类
abstract class CallChargeRule extends ChargeRule{
abstract double calCost(ArrayList<CallRecord> callRecords);
}LandPhonelnCityRule类
class LandPhonelnCityRule extends CallChargeRule{
double calCost(ArrayList<CallRecord> callRecords){
double sum=0;
for(int i=0;i<callRecords.size();i++){
long t1=callRecords.get(i).getStartTime().getTime();
long t2=callRecords.get(i).getEndTime().getTime();
if((t2-t1)%60000!=0)
sum+=0.1*((t2-t1)/60000+1);
else
sum+=0.1*((t2-t1)/60000);
}
return sum;
}
}LandPhonelnlandRule类
class LandPhonelnlandRule extends CallChargeRule{
double calCost(ArrayList<CallRecord> callRecords){
double sum=0;
for(int i=0;i<callRecords.size();i++){
long t1=callRecords.get(i).getStartTime().getTime();
long t2=callRecords.get(i).getEndTime().getTime();
if((t2-t1)%60000!=0)
sum+=0.6*((t2-t1)/60000+1);
else
sum+=0.6*((t2-t1)/60000);
}
return sum;
}
}LandPhonelnProvinceRule类
class LandPhonelnProvinceRule extends CallChargeRule{
double calCost(ArrayList<CallRecord> callRecords){
double sum=0;
for(int i=0;i<callRecords.size();i++){
long t1=callRecords.get(i).getStartTime().getTime();
long t2=callRecords.get(i).getEndTime().getTime();
if((t2-t1)%60000!=0)
sum+=0.3*((t2-t1)/60000+1);
else
sum+=0.3*((t2-t1)/60000);
}
return sum;
}
}ChargeMode类
abstract class ChargeMode{
private ArrayList<ChargeRule> chargeRules=new ArrayList<ChargeRule>();
public ArrayList<ChargeRule> getChargeRules() {
return chargeRules;
}
public void setChargeRules(ArrayList<ChargeRule> chargeRules) {
this.chargeRules = chargeRules;
}
public abstract double calCost(UserRecords userRecords);
public abstract double getMonthlyRent();
}LandlinePhoneCharging类
class LandlinePhoneCharging extends ChargeMode{
private double monthlyRent=20;
LandlinePhoneCharging(){
super();
getChargeRules().add(new LandPhonelnCityRule());
getChargeRules().add(new LandPhonelnProvinceRule());
getChargeRules().add(new LandPhonelnlandRule());
}
public double calCost(UserRecords userRecords){
double sum=0;
sum+=((LandPhonelnCityRule)getChargeRules().get(0)).calCost(userRecords.getCallinglnCityRecords());
sum+=((LandPhonelnProvinceRule)getChargeRules().get(1)).calCost(userRecords.getCallinglnProvinceRecords());
sum+=((LandPhonelnlandRule)getChargeRules().get(2)).calCost(userRecords.getCallinglnLandRecords());
return sum;
}
public double getMonthlyRent() {
return monthlyRent;
}
}UserRecords类
class UserRecords{
private ArrayList<CallRecord> callinglnCityRecords=new ArrayList<CallRecord>();
private ArrayList<CallRecord> callinglnProvinceRecords=new ArrayList<CallRecord>();
private ArrayList<CallRecord> callinglnLandRecords=new ArrayList<CallRecord>();
private ArrayList<CallRecord> answerlnCityRecords=new ArrayList<CallRecord>();
private ArrayList<CallRecord> answerlnProvinceRecords=new ArrayList<CallRecord>();
private ArrayList<CallRecord> answerlnLandRecords=new ArrayList<CallRecord>();
private ArrayList<MessageRecord> sendMessageRecords=new ArrayList<MessageRecord>();
private ArrayList<MessageRecord> receiveMessageRecords=new ArrayList<MessageRecord>();
void addCallinglnCityRecords(CallRecord callRecord){
callinglnCityRecords.add(callRecord);
}
void addCallinglnProvinceRecords(CallRecord callRecord){
callinglnProvinceRecords.add(callRecord);
}
void addCallinglnLandRecords(CallRecord callRecord){
callinglnLandRecords.add(callRecord);
}
void addAnswerlnCityRecords(CallRecord callRecord){
answerlnCityRecords.add(callRecord);
}
void addAnswerlnProvinceRecords(CallRecord callRecord){
answerlnProvinceRecords.add(callRecord);
}
void addAnswerlnLandRecords(CallRecord callRecord){
answerlnLandRecords.add(callRecord);
}
void SendMessageRecords(MessageRecord sendMessageRecord){
}
void ReceiveMessageRecords(MessageRecord receiveMessageRecord){
}
public ArrayList<MessageRecord> getSendMessageRecords() {
return sendMessageRecords;
}
public ArrayList<MessageRecord> getReceiveMessageRecords() {
return receiveMessageRecords;
}
public ArrayList<CallRecord> getCallinglnCityRecords() {
return callinglnCityRecords;
}
public ArrayList<CallRecord> getCallinglnLandRecords() {
return callinglnLandRecords;
}
public ArrayList<CallRecord> getCallinglnProvinceRecords() {
return callinglnProvinceRecords;
}
public ArrayList<CallRecord> getAnswerlnCityRecords() {
return answerlnCityRecords;
}
public ArrayList<CallRecord> getAnswerlnLandRecords() {
return answerlnLandRecords;
}
public ArrayList<CallRecord> getAnswerlnProvinceRecords() {
return answerlnProvinceRecords;
}
}User类
class User {
private UserRecords userRecords = new UserRecords();
private double balance = 100;
private ChargeMode chargeMode;
String number;
double calBalance() {
return getBalance()-calCost();
}
double calCost() {
return chargeMode.calCost(userRecords) ;
}
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;
}
}sort类
class sort{
void Sort(ArrayList<User> users){
for(int i=0;i<users.size()-1;i++){
for(int j=i+1;j<users.size();j++){
if(Long.parseLong(users.get(i).getNumber())>Long.parseLong(users.get(j).getNumber())){
User temp=users.get(i);
users.set(i,users.get(j));
users.set(j,temp);
}
}
}
}
}这题思路在上述分析中，这题简单，按照类图实现即可，连坑都没几个。
电信计费1-3都实现后类图如下：
SourceMonitor生成报表如下：
说明代码量大，但是实际复杂度并不大。
7-2 多态测试 分数 20 作者 董卫萍 单位 绍兴文理学院元培学院定义容器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.12纯纯的送分题，没什么分析的，写blog的时候发现当时写的时候，看错了，没使用接口，使用接口也差不多难度吧。代码如下：
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
int n=input.nextInt();
Container[] Containers=new Container[n];
for(int i=0;i<n;i++){
input.nextLine();
String type=input.nextLine();
if(type.equals("cube")){
double x=input.nextDouble();
Containers[i]=new Cube(x);
}
else if(type.equals("cylinder")){
double x=input.nextDouble();
double y=input.nextDouble();
Containers[i]=new cylinder(x,y);
}
}
System.out.printf("%.2f\n",Container.sumofArea(Containers));
System.out.printf("%.2f\n",Container.sumofVolume(Containers));
}
}
abstract class Container{
public static final double pi=3.1415926;
public abstract double area();
public abstract double volume();
static double sumofArea(Container c[]){
double sumArea=0;
for(int i=0;i<c.length;i++){
sumArea+=c[i].area();
}
return sumArea;
}
static double sumofVolume(Container c[]) {
double sumVolume=0;
for(int i=0;i<c.length;i++)
sumVolume+=c[i].volume();
return sumVolume;
}
}
class Cube extends Container{
double length;
Cube(double x){
this.length=x;
}
public double area(){
return 6*length*length;
}
public double volume(){
return length*length*length;
}
}
class cylinder extends Container{
double radius,hight;
cylinder(double x,double y){
this.radius=x;
this.hight=y;
}
public double area(){
return 2*pi*radius*radius+2*pi*radius*hight;
}
public double volume(){
return pi*radius*radius*hight;
}
}感谢观看！！！
标签：return,String,nchu,double,ArrayList,oop,2022,计费,public From： https://www.cnblogs.com/pillowtalk/p/16951712.html