首页 > 其他分享 >blog3

blog3

时间:2022-12-10 22:23:45浏览次数:47  
标签:return String double blog3 ArrayList userRecords public

一、前言 这几次的作业题量适中,主要重点封装、继承、多态、抽象类的使用、正则表达式,接口,还有一些和javafx相关的知识,主要题型就是看类图补全代码,其中电信计费系列是比较难的。 二、设计与分析 1、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,可根据理解自行调整:

image.png

                                    图1
图1中User是用户类,包括属性:
userRecords (用户记录)、balance(余额)、chargeMode(计费方式)、number(号码)。

ChargeMode是计费方式的抽象类:
chargeRules是计费方式所包含的各种计费规则的集合,ChargeRule类的定义见图3。
getMonthlyRent()方法用于返回月租(monthlyRent)。

UserRecords是用户记录类,保存用户各种通话、短信的记录,    
各种计费规则将使用其中的部分或者全部记录。
其属性从上到下依次是:
市内拨打电话、省内(不含市内)拨打电话、省外拨打电话、
市内接听电话、省内(不含市内)接听电话、省外接听电话的记录
以及发送短信、接收短信的记录。
 

image.png

                                     图2
图2中CommunicationRecord是抽象的通讯记录类:
包含callingNumber拨打号码、answerNumber接听号码两个属性。
CallRecord(通话记录)、MessageRecord(短信记录)是它的子类。

CallRecord(通话记录类)包含属性:
通话的起始、结束时间以及
拨号地点的区号(callingAddressAreaCode)、接听地点的区号(answerAddressAreaCode)。
区号用于记录在哪个地点拨打和接听的电话。座机无法移动,就是本机区号,如果是手机号,则会有差异。
 

image.png

                                        图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.ArrayList;
import java.util.Comparator;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;
import java.text.ParseException;
 
public class Main {
 
    public static void main(String[] args) {
 
        Outputtool outputtool = new Outputtool();
 
        Inputdeal inputdeal = new Inputdeal();
 
        ArrayList<User> users = new ArrayList<>();
 
        Scanner in = new Scanner(System.in);
 
        String input = in.nextLine();
 
        while (!input.equals("end")) {
            if (1 == inputdeal.check(input)) {
                inputdeal.writeUser(users, input);
            } 
            input = in.nextLine();
        }
 
        users.sort(new Comparator<User>() {
 
            @Override
            public int compare(User u1, User u2) {
                if (Double.parseDouble(u1.getNumber()) > Double.parseDouble(u2.getNumber())) {
                    return 1;
                } else {
                    return -1;
                }
            }
        });
 
        for (User u : users) {
            System.out.print(u.getNumber() + " ");
            outputtool.output(u.calCost());
            System.out.print(" ");
            outputtool.output(u.calBalance());
            System.out.println();
 
        }
 
    }
 
}
 
abstract class ChargeMode {
    protected ArrayList<ChargeRule> chargeRules = new ArrayList<>();
 
    public abstract double calCost(UserRecords userRecords);
 
    public abstract double getMonthlyRent();
 
    public ArrayList<ChargeRule> getChargeRules() {
        return chargeRules;
    }
 
    public void setChargeRules(ArrayList<ChargeRule> chargeRules) {
        this.chargeRules = chargeRules;
    }
}
 
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> answerInCityRecords = 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 addCallingInLandRecords(CallRecord callRecord) {
        callingInLandRecords.add(callRecord);
    }
 
    public void addAnswerInCityRecords(CallRecord callRecord) {
        answerInCityRecords.add(callRecord);
    }
 
    public void aaddAnswerInProvinceRecords(CallRecord callRecord) {
        answerInProvinceRecords.add(callRecord);
    }
 
    public void addAnswerInLandRecords(CallRecord callRecord) {
        answerInLandRecords.add(callRecord);
    }
 
    public void addSendMessageRecords(MessageRecord callRecord) {
        sendMessageRecords.add(callRecord);
    }
 
    public void addReceiveMessageRecords(MessageRecord callRecord) {
        receiveMessageRecords.add(callRecord);
    }
 
    public ArrayList<CallRecord> getCallingInCityRecords() {
        return callingInCityRecords;
    }
 
    public void setCallingInCityRecords(ArrayList<CallRecord> callingInCityRecords) {
        this.callingInCityRecords = callingInCityRecords;
    }
 
    public ArrayList<CallRecord> getCallingInProvinceRecords() {
        return callingInProvinceRecords;
    }
 
    public void setCallingInProvinceRecords(ArrayList<CallRecord> callingInProvinceRecords) {
        this.callingInProvinceRecords = callingInProvinceRecords;
    }
 
    public ArrayList<CallRecord> getCallingInLandRecords() {
        return callingInLandRecords;
    }
 
    public void setCallingInLandRecords(ArrayList<CallRecord> callingInLandRecords) {
        this.callingInLandRecords = callingInLandRecords;
    }
 
    public ArrayList<CallRecord> getAnswerInCityRecords() {
        return answerInCityRecords;
    }
 
    public void setAnswerInCityRecords(ArrayList<CallRecord> answerInCityRecords) {
        this.answerInCityRecords = answerInCityRecords;
    }
 
    public ArrayList<CallRecord> getAnswerInProvinceRecords() {
        return answerInProvinceRecords;
    }
 
    public void setAnswerInProvinceRecords(ArrayList<CallRecord> answerInProvinceRecords) {
        this.answerInProvinceRecords = answerInProvinceRecords;
    }
 
    public ArrayList<CallRecord> getAnswerInLandRecords() {
        return answerInLandRecords;
    }
 
    public void setAnswerInLandRecords(ArrayList<CallRecord> answerInLandRecords) {
        this.answerInLandRecords = answerInLandRecords;
    }
 
    public ArrayList<MessageRecord> getSendMessageRecords() {
        return sendMessageRecords;
    }
 
    public void setSendMessageRecords(ArrayList<MessageRecord> sendMessageRecords) {
        this.sendMessageRecords = sendMessageRecords;
    }
 
    public ArrayList<MessageRecord> getReceiveMessageRecords() {
        return receiveMessageRecords;
    }
 
    public void setReceiveMessageRecords(ArrayList<MessageRecord> receiveMessageRecords) {
        this.receiveMessageRecords = receiveMessageRecords;
    }
 
}
 
class LandlinePhoneCharging extends ChargeMode {
 
    private double monthlyRent = 20;
 
    public LandlinePhoneCharging() {
        super();
        chargeRules.add(new LandPhoneInCityRule());
        chargeRules.add(new LandPhoneInProvinceRule());
        chargeRules.add(new LandPhoneInlandRule());
    }
 
    @Override
    public double calCost(UserRecords userRecords) {
        double sumCost = 0;
        for (ChargeRule rule : chargeRules) {
            sumCost += rule.calCost(userRecords);
        }
        return sumCost;
    }
 
    @Override
    public double getMonthlyRent() {
        return monthlyRent;
    }
 
}
 
class Inputdeal {
 
    public int check(String input) {
        String[] inputs = input.split(" ");
        if (inputs.length == 2) {
            if (inputs[0].matches("^u-[0-9]{11,13}$")) {
                if (Integer.parseInt(inputs[1]) >= 0) {
                    if (Integer.parseInt(inputs[1]) <= 2) {
                        return 1;
                    }
                }
            }
        } else if (inputs.length == 6) {
//            if(input.matches("[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])")) {
//                return 2;
//            }
            if (validate(inputs[2]))
                if (validate(inputs[4]))
                    if (validatet(inputs[3]))
                        if (validatet(inputs[5]))
//                    if (inputs[0].matches("^t\\-[0-9]{10,12}$")) {
                            if (inputs[0].matches("[t]-0791[0-9]{7,8}")) {
                                if (inputs[1].matches(".[0-9]{9,11}"))
                                    return 2;
                            }
        }
        return 0;
    }
 
    private boolean validatet(String string) {
        String[] split = string.split(":");
        if (!string.matches("^([0-1]?[0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])$")) {
            return false;
        }
        return true;
    }
 
    public static boolean validate(String dateString) {
        // 使用正则表达式 测试 字符 符合 dddd.dd.dd 的格式(d表示数字)
        Pattern p = Pattern.compile("\\d{4}+[\\.]\\d{1,2}+[\\.]\\d{1,2}+");
        Matcher m = p.matcher(dateString);
        if (!m.matches()) {
            return false;
        }
 
        // 得到年月日
        String[] array = dateString.split("\\.");
        int year = Integer.valueOf(array[0]);
        int month = Integer.valueOf(array[1]);
        int day = Integer.valueOf(array[2]);
 
        if (month < 1 || month > 12) {
            return false;
        }
        int[] monthLengths = new int[] { 0, 31, -1, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
        if (isLeapYear(year)) {
            monthLengths[2] = 29;
        } else {
            monthLengths[2] = 28;
        }
        int monthLength = monthLengths[month];
        if (day < 1 || day > monthLength) {
            return false;
        }
        return true;
    }
 
    /** 是否是闰年 */
    private static boolean isLeapYear(int year) {
        return ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0);
    }
 
    public boolean judge(String input) {
 
        return false;
    }
 
    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 == 0) {
            usernew.setChargeMode(new LandlinePhoneCharging());
        }
        users.add(usernew);
    }
 
    public void writeRecord(ArrayList<User> users, String input) {
        String[] inputs = input.split(" ");
        inputs[0] = inputs[0].replace("t-", "");
 
        User callu = null, answeru = null;
        CallRecord callrecord = new CallRecord(inputs);
 
        for (User i : users) {
            if (i.getNumber().equals(inputs[0])) {
                callu = i;
            }
            if (i.getNumber().equals(inputs[1])) {
                answeru = i;
            }
            if (callu != null && answeru != null) {
                break;
            }
        }
 
        if (callu != null) {
            if (callrecord.getCallType() == 1) {
                callu.getUserRecords().addCallingInCityRecords(callrecord);
            } else if (callrecord.getCallType() == 2) {
                callu.getUserRecords().addCallingInProvinceRecords(callrecord);
            } else {
                callu.getUserRecords().addCallingInLandRecords(callrecord);
            }
        }
 
        if (answeru != null) {
            if (callrecord.getCallType() == 1) {
                answeru.getUserRecords().addAnswerInCityRecords(callrecord);
            } else if (callrecord.getCallType() == 2) {
 
                answeru.getUserRecords().aaddAnswerInProvinceRecords(callrecord);
            } else {
                answeru.getUserRecords().addAnswerInLandRecords(callrecord);
            }
        }
 
    }
 
}
 
abstract class CommunicationRecord {
    protected String callingNumber;
    protected String answerNumbe;
 
    public String getCallingNumber() {
        return callingNumber;
    }
 
    public void setCallingNumber(String callingNumber) {
        this.callingNumber = callingNumber;
    }
 
    public String getAnswerNumbe() {
        return answerNumbe;
    }
 
    public void setAnswerNumbe(String answerNumbe) {
        this.answerNumbe = answerNumbe;
    }
 
}
 
abstract class ChargeRule {
 
    abstract public double calCost(UserRecords userRecords);
 
}
 
class CallRecord extends CommunicationRecord {
    private Date startTime;
    private Date endTime;
    private String callingAddressAreaCode;
    private String answerAddressAreaCode;
 
    public int getCallType() {
        if (callingAddressAreaCode.equals(answerAddressAreaCode)) {
            return 1;
        }
        if (callingAddressAreaCode.matches("^079[0-9]$") || callingAddressAreaCode.equals("0701")) {
            if (answerAddressAreaCode.matches("^079[0-9]$") || answerAddressAreaCode.equals("0701")) {
                return 2;
            }
        }
        return 3;
    }
 
    public CallRecord(String[] inputs) {
        super();
        if (inputs[0].length() == 10) {
            callingAddressAreaCode = inputs[0].substring(0, 3);
        } else {
            callingAddressAreaCode = inputs[0].substring(0, 4);
        }
        if (inputs[1].length() == 10) {
            answerAddressAreaCode = inputs[1].substring(0, 3);
        } else {
            answerAddressAreaCode = inputs[1].substring(0, 4);
        }
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss", Locale.getDefault());
        try {
            startTime = simpleDateFormat.parse(inputs[2] + " " + inputs[3]);
            endTime = simpleDateFormat.parse(inputs[4] + " " + inputs[5]);
        } catch (ParseException e) {
        }
 
    }
 
    public CallRecord(Date startTime, Date endTime, String callingAddressAreaCode, String answerAddressAreaCode) {
        super();
        this.startTime = startTime;
        this.endTime = endTime;
        this.callingAddressAreaCode = callingAddressAreaCode;
        this.answerAddressAreaCode = 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;
    }
}
 
abstract class CallChargeRule extends ChargeRule {
 
}
 
class LandPhoneInCityRule extends CallChargeRule {
 
    @Override
    public double calCost(UserRecords userRecords) {
        double sumCost = 0;
        for (CallRecord call : userRecords.getCallingInCityRecords()) {
            double distanceS = (-call.getStartTime().getTime() + call.getEndTime().getTime()) / 1000;
            if (distanceS < 0) {
                continue;
            }
            double distanceM = (int) distanceS / 60;
            if (distanceS % 60 != 0) {
                distanceM += 1;
            }
            sumCost += distanceM * 0.1;
        }
        return sumCost;
    }
 
}
 
class LandPhoneInlandRule extends CallChargeRule {
 
    @Override
    public double calCost(UserRecords userRecords) {
        double sumCost = 0;
        for (CallRecord call : userRecords.getCallingInLandRecords()) {
            double distanceS = (-call.getStartTime().getTime() + call.getEndTime().getTime()) / 1000;
            if (distanceS < 0) {
                continue;
            }
            double distanceM = (int) distanceS / 60;
            if (distanceS % 60 != 0) {
                distanceM += 1;
            }
            sumCost += distanceM * 0.6;
        }
        return sumCost;
    }
 
}
 
class LandPhoneInProvinceRule extends CallChargeRule {
 
    @Override
    public double calCost(UserRecords userRecords) {
        double sumCost = 0;
        for (CallRecord call : userRecords.getCallingInProvinceRecords()) {
            double distanceS = (-call.getStartTime().getTime() + call.getEndTime().getTime()) / 1000;
            if (distanceS < 0) {
                continue;
            }
            double distanceM = (int) distanceS / 60;
            if (distanceS % 60 != 0) {
                distanceM += 1;
            }
            sumCost += distanceM * 0.3;
        }
        return sumCost;
    }
 
}
 
class MessageRecord extends CommunicationRecord {
 
    private String message;
 
    public String getMessage() {
        return message;
    }
 
    public void setMessage(String message) {
        this.message = message;
    }
}
 
class User {
 
    private UserRecords userRecords = new UserRecords();
    private double balance = 100;
    private ChargeMode chargeMode;
    private String number;
 
    public double calCost() {
        return chargeMode.calCost(userRecords);
    }
 
    public double calBalance() {
        return balance - chargeMode.getMonthlyRent() - chargeMode.calCost(userRecords);
    }
 
    public UserRecords getUserRecords() {
        return userRecords;
    }
 
    public void setUserRecords(UserRecords userRecords) {
        this.userRecords = userRecords;
    }
 
    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;
    }
 
}
 
class Outputtool {
 
    public void output(double out) {
//        java.text.DecimalFormat df=new java.text.DecimalFormat("#.##");
//        String a=df.format(out);
//        System.out.print(a);
        BigDecimal numb = new BigDecimal(out);
        out = numb.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
        System.out.print(out);
    }
}

2、

7-1 电信计费系列2-手机+座机计费 分数 80 作者 蔡轲 单位 南昌航空大学

实现南昌市电信分公司的计费程序,假设该公司针对手机和座机用户分别采取了两种计费方案,分别如下:
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:

image.png
图1

图1中User是用户类,包括属性:
userRecords (用户记录)、balance(余额)、chargeMode(计费方式)、number(号码)。
ChargeMode是计费方式的抽象类:
chargeRules是计费方式所包含的各种计费规则的集合,ChargeRule类的定义见图3。
getMonthlyRent()方法用于返回月租(monthlyRent)。
UserRecords是用户记录类,保存用户各种通话、短信的记录,    
各种计费规则将使用其中的部分或者全部记录。
其属性从上到下依次是:
市内拨打电话、省内(不含市内)拨打电话、省外拨打电话、
市内接听电话、省内(不含市内)接听电话、省外接听电话的记录
以及发送短信、接收短信的记录。
 

image.png

图2

图2中CommunicationRecord是抽象的通讯记录类:
包含callingNumber拨打号码、answerNumber接听号码两个属性。
CallRecord(通话记录)、MessageRecord(短信记录)是它的子类。CallRecord(通话记录类)包含属性:
通话的起始、结束时间以及
拨号地点的区号(callingAddressAreaCode)、接听地点的区号(answerAddressAreaCode)。
区号用于记录在哪个地点拨打和接听的电话。座机无法移动,就是本机区号,如果是手机号,则会有差异。
 

image.png
图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

 

 

 
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.HashSet;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;


public class Main {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        HashSet <String> u = new HashSet<>();
        ArrayList <String>use = new ArrayList<>();
        ArrayList <String>data = new ArrayList<>();
        ArrayList<User> user = new ArrayList<>();
        ArrayList <String>record= new ArrayList<>();
        
        String  input = in.nextLine();
        while(!input.equals("end")) {
            if(input.contains(" ")) {
                if(input.length()>=15&&input.contains("u-")) {
                    u.add(input);
                }
                else if(input.length()>=26) {
                    data.add(input);
                }
            }
            input = in.nextLine();
        }
        for(String a:u) {
            use.add(a);
        }
        Collections.sort(use);
        for(String a:use) {
            if(deal1(a)==1) {
                //System.out.println(data);
                for(String b:data) {
                    if(deal2(a,b)==1) {
                        //System.out.println("yes");
                        record.add(b);
                    }
                }
                user.add(new User(a,record));
                record.clear();
            }
        }
        
        output(user);
    }
    
    private static void output(ArrayList<User> user) {
        for(User a:user) {
            System.out.print(a.getNumber()+" ");
            String cost = String.format("%.1f",a.calCost() );
            System.out.print(cost+" ");
            System.out.print(a.calBalance());
            System.out.println("");
        }
        
    }

    private static int deal2(String a,String b) {
        String []n = a.split(" ");
        String []num = n[0].split("-");
        String[]ab = b.split(" ");
        if(b.contains("t-")) {
            if(ab[0].contains(num[1])||ab[2].equals(num[1])||ab[1].equals(num[1])) {
                if(ab[1].matches("[0-9]{11,12}")&&ab[2].matches("[0-9]{4}\\.([1-9]|1[0-2])\\.([1-9]|[1-2][0-9]|3[0-1])")
                        &&ab[3].matches("([0-9]|1[0-9]|2[0-3])\\:[0-5][0-9]\\:[0-5][0-9]")
                        &&ab[4].matches("[0-9]{4}\\.([1-9]|1[0-2])\\.([1-9]|[1-2][0-9]|3[0-1])")
                        &&ab[5].matches("([0-9]|1[0-9]|2[0-3])\\:[0-5][0-9]\\:[0-5][0-9]")) {
                    return 1;
                }
//                u-13811111111 1
//                t-13811111111 0791 13811111110 020 2022.1.3 08:00:00 2022.1.3 08:09:20
//                end

                else if(ab[1].matches("[0-9]{3,4}")&&ab[2].matches("1[0-9]{10}")&&ab[3].matches("[0-9]{3,4}")
                        &&ab[4].matches("[0-9]{4}\\.([1-9]|1[0-2])\\.([1-9]|[1-2][0-9]|3[0-1])")
                        &&ab[5].matches("(0[0-9]|1[0-9]|2[0-3])\\:[0-5][0-9]\\:[0-5][0-9]")
                        &&ab[6].matches("[0-9]{4}\\.([1-9]|1[0-2])\\.([1-9]|[1-2][0-9]|3[0-1])")
                        &&ab[7].matches("(0[0-9]|1[0-9]|2[0-3])\\:[0-5][0-9]\\:[0-5][0-9]")) {
                    return 1;
                }
                //t-13986300001 0791 079186300001 2022.12.31 23:50:25 2023.1.2 00:05:11
                else if(ab[1].matches("[0-9]{3,4}")&&ab[2].matches("1[0-9]{10}")&&ab[3].matches("[0-9]{4}\\.([1-9]|1[0-2])\\.([1-9]|[1-2][0-9]|3[0-1])")
                        &&ab[4].matches("(0[0-9]|1[0-9]|2[0-3])\\:[0-5][0-9]\\:[0-5][0-9]")
                        &&ab[5].matches("[0-9]{4}\\.([1-9]|1[0-2])\\.([1-9]|[1-2][0-9]|3[0-1])")
                        &&ab[6].matches("(0[0-9]|1[0-9]|2[0-3])\\:[0-5][0-9]\\:[0-5][0-9]")) {
                    return 1;
                }
                else if(ab[1].matches("1[0-9]{10}")&&ab[2].matches("[0-9]{4}")&&ab[3].matches("[0-9]{4}\\.([1-9]|1[0-2])\\.([1-9]|[1-2][0-9]|3[0-1])")
                        &&ab[4].matches("(0[0-9]|1[0-9]|2[0-3])\\:[0-5][0-9]\\:[0-5][0-9]")
                        &&ab[5].matches("[0-9]{4}\\.([1-9]|1[0-2])\\.([1-9]|[1-2][0-9]|3[0-1])")
                        &&ab[6].matches("(0[0-9]|1[0-9]|2[0-3])\\:[0-5][0-9]\\:[0-5][0-9]")) {
                    return 1;
                }
                else if(ab[1].matches("[0-9]{3,4}")&&ab[2].matches("[0-9]{11,13}")&&ab[3].matches("[0-9]{4}\\.([1-9]|1[0-2])\\.([1-9]|[1-2][0-9]|3[0-1])")
                        &&ab[4].matches("(0[0-9]|1[0-9]|2[0-3])\\:[0-5][0-9]\\:[0-5][0-9]")
                        &&ab[5].matches("[0-9]{4}\\.([1-9]|1[0-2])\\.([1-9]|[1-2][0-9]|3[0-1])")
                        &&ab[6].matches("(0[0-9]|1[0-9]|2[0-3])\\:[0-5][0-9]\\:[0-5][0-9]")) {
                    return 1;
                }
            }
            
        }
        else if(b.contains("m-")) {
            String[]bb = b.split(" ");
            if(bb.length>=3) {
                String ms = b.substring(26,b.length());
                String regEx = "[_`~!@#$%^&*()+=|{}':;'\\[\\]<>/?~!@#¥%……&*()——+|{}【】‘;:”“’。,、?]|\n|\r|\t|[\u4e00-\u9fa5]";
                Pattern p = Pattern.compile(regEx);
                Matcher m = p.matcher(ms);  
                if(ab[0].matches("m\\-[0-9]{11}")&&ab[1].matches("[0-9]{11}")) {
                    while(m.find()) {
                        return 0;
                    }
                    return 1;
                }
            }
            
        }
        return 0;
    }

    private static int deal1(String data) {
        String []data1 = data.split(" ");
        //u-13986300001 1
        if(data1.length==2) {
            if(data1[0].matches("u-0791"+"[0-9]{7,9}$")) {
                return 1;
            }
            else if(data1[0].matches("u-1"+"[0-9]{9,11}$")) {
                return 1;
            }
        }
        return 0;
    }
}


class User{
    
    private UserRecords userRecords = new UserRecords();
    private double balance = 100;
    private ChargeMode chargeMode;
    private String number;
    private String choice;
    
    User(String use,ArrayList<String>record){
        String []n = use.split(" ");
        this.choice = n[1];
        String []num = n[0].split("-");
        this.setNumber(num[1]);
        if(n[1].equals("0")||n[1].equals("1")) {
            for(String a:record) {
                CallRecord deal = new CallRecord();
                deal.Deal(a,userRecords,choice,n);
            }
        }
        else {
            for(String a:record) {
                MessageRecord deal = new MessageRecord();
                deal.Deal(a,userRecords,num[1]);
            }
        }
        
        if(n[1].equals("0")) {
            this.chargeMode = new LandlinePhoneCharging();
        }
        else if(n[1].equals("1")) {
            this.chargeMode = new PhoneChaging();
        }
        else if(n[1].equals("3")) {
            this.chargeMode = new MassageChaging();
        }
        
    }
//t-13986300001 0791 079186300001 2022.12.31 23:50:25 2023.1.1 00:05:11
    public double calCost() {
        return chargeMode.calCost(this.userRecords);
    }

    public double calBalance() {
        return balance - chargeMode.getMonthlyRent()-chargeMode.calCost(userRecords);
    }

    public UserRecords getUserRecords() {
        return userRecords;
    }

    public void setUserRecords(UserRecords userRecords) {
        this.userRecords = userRecords;
    }

    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;
    }

}





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> answerInCityRecords = 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 addCallingInLandRecords (CallRecord callRecord) {
        callingInLandRecords.add(callRecord);
    }
    public void addAnswerInCityRecords (CallRecord answerRecord) {
        answerInCityRecords.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<MessageRecord> getSendMessageRecords (){
        return sendMessageRecords;    
    }
    public ArrayList<MessageRecord> getReceiveMessageRecords (){
        return receiveMessageRecords;
    }
    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 answerInProvinceRecords;
    }
    public ArrayList<CallRecord> getAnswerInLandRecords (){
        return answerInLandRecords;
    }

}

class CallRecord extends CommunicationRecord{
    
    private Date startTime;
    private Date endTime;
    private String callingAddressAreaCode;
    private String answerAddressAreaCode;
    
    public void Deal(String a, UserRecords userRecords,String choice,String[]n) {
        String []call = a.split(" ");
        String []num = call[0].split("-");
        if(call.length==6) {
            if(call[1].length()==12) {
                this.setAnswerAddressAreaCode(call[1].substring(0,4));
            }
            else {
                this.setAnswerAddressAreaCode(call[1].substring(0,3));
            }
            this.setCallingAddressAreaCode(num[1].substring(0,4));
            this.setCallingNumber(num[1]);
            this.setAnswerNumber(call[1]);
        }
    //        座机打手机:
    //        t-主叫号码 接听号码 接听地点区号 起始时间 结束时间
    //        t-079186330022 13305862264 020 2022.1.3 10:00:25 2022.1.3 10:05:11
        else if(call.length==7) {
                this.setAnswerAddressAreaCode(call[2]);
                this.setAnswerNumber(call[1]);
                this.setCallingAddressAreaCode(num[1].substring(0,4));
                this.setCallingNumber(num[1]);
        }
        
    //        手机互打:
    //        t-主叫号码 拨号地点 接听号码 接听地点区号 起始时间 结束时间
    //        t-18907910010 0791 13305862264 0371 2022.1.3 10:00:25 2022.1.3 10:05:11
        else if(call.length==8) {
            this.setAnswerAddressAreaCode(call[3]);
            this.setAnswerNumber(call[2]);
            this.setCallingAddressAreaCode(call[1]);
            this.setCallingNumber(num[1]);
        }
        this.setTime(call);
        this.setType(userRecords,choice,call,num,n);
    
        
    }
    
    private void setTime(String []call) {
        int i = call.length-4;
        // t-079186330022 058686330022 2022.1.3 10:00:25 2022.1.3 10:05:11
         SimpleDateFormat time = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
         try {
             this.startTime = time.parse(call[i]+" "+call[i+1]);
             this.endTime = time.parse(call[i+2]+" "+call[i+3]);
         }catch (ParseException e) {
             
        }
    }

    private void setType(UserRecords userRecords,String choice,String[]call,String[]num,String []n) {
        if(choice.equals("0")) {
            String []nu= n[0].split("-");
            if(this.getCallingNumber().equals(nu[1])) {
                if(this.getAnswerAddressAreaCode().matches("0791")) {
                    userRecords.addCallingInCityRecords(this);
                    
                }
                else if(this.getAnswerAddressAreaCode().matches("079[0-9]")||
                        this.getAnswerAddressAreaCode().matches("0701")) {
                    userRecords.addCallingInProvinceRecords(this);
                }
                else {
                    userRecords.addCallingInLandRecords(this);
                }
            }
        }

        else if(choice.equals("1")) {
            if(num[1].equals(this.getCallingNumber())) {
                if(this.getAnswerAddressAreaCode().matches("0791")) {
                    userRecords.addCallingInCityRecords(this);
                }
                else if(this.getAnswerAddressAreaCode().matches("079[0-9]")||
                        this.getAnswerAddressAreaCode().matches("0701")) {
                    userRecords.addCallingInProvinceRecords(this);
                }
                else {
                    userRecords.addCallingInLandRecords(this);
                }
                
            }
            else if(num[1].equals(this.getAnswerNumber())) {
                if(this.getAnswerAddressAreaCode().matches("0791")) {
                    userRecords.addAnswerInCityRecords(this);
                }
                else if(this.getAnswerAddressAreaCode().matches("079[0-9]")||
                        this.getAnswerAddressAreaCode().matches("0701")) {
                    userRecords.addAnswerInProvinceRecords(this);
                }
                else {
                    userRecords.addAnswerInLandRecords(this);
                }
            }
        }
        
    }
    
    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 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;
    }
}

class MessageRecord extends CommunicationRecord{
    private String massage;
    
    public void Deal(String a, UserRecords userRecords,String num) {
        String []mess = a.split(" ");
        if(mess[0].contains(num)) {
            this.setMessage(a.substring(26, a.length()));
            userRecords.addSendMessageRecords(this);
        }
    }
    public String getMessage(){
        return massage;
    }
//    u-18907910010 3
//    m-18907910010 13305862264 aaaaaaaaaaaaaaaaaaaaaaa
//    end
    public void setMessage (String message) {
        this.massage = message;
    }
}



abstract class ChargeMode{
    
    protected ArrayList<ChargeRule> chargeRules = new ArrayList<>();

    public abstract double calCost(UserRecords userRecords);

    public abstract double getMonthlyRent();

    public ArrayList<ChargeRule> getChargeRules() {
        return chargeRules;
    }

    public void setChargeRules(ArrayList<ChargeRule> chargeRules) {
        this.chargeRules = chargeRules;
    }

}

class LandlinePhoneCharging extends ChargeMode{
    double monthlyRent  = 20;
    
    public LandlinePhoneCharging() {
        super();
        this.getChargeRules ().add(new LandPhoneInCityRule());
        this.getChargeRules ().add(new LandPhoneInProvinceRule());
        this.getChargeRules ().add(new LandPhoneInlandRule());
    }

    @Override
    public double calCost(UserRecords userRecords) {
        double sumCost = 0;
        for (ChargeRule a : chargeRules) {
            sumCost += a.calCost(userRecords);
        }
        return sumCost;
    }

    @Override
    public double getMonthlyRent() {
        return monthlyRent;
    }
}

class PhoneChaging extends ChargeMode{
    
    double monthlyRent = 15;

    public PhoneChaging() {
        super();
        this.getChargeRules ().add(new PhoneInCityRule());
        this.getChargeRules ().add(new PhoneInProvinceRule());
        this.getChargeRules ().add(new PhoneInlandRule());
    }
    
    @Override
    public double calCost(UserRecords userRecords) {
        double sumCost = 0;
        for (ChargeRule a : chargeRules) {
            sumCost += a.calCost(userRecords);
        }
        return sumCost;
    }

    @Override
    public double getMonthlyRent() {
        return monthlyRent;
    }
    
    
}

class MassageChaging extends ChargeMode{
    
    public MassageChaging() {
        super();
        this.getChargeRules ().add(new SendMessageRule());
    }

    @Override
    public double calCost(UserRecords userRecords) {
        double sumCost = 0;
        for (ChargeRule a : chargeRules) {
            sumCost += a.calCost(userRecords);
        }
        return sumCost;
    }

    @Override
    public double getMonthlyRent() {
        return 0;
    }
    
}

abstract class ChargeRule{

    protected abstract double calCost(UserRecords userRecords);

}

abstract class CallChargeRule extends ChargeRule{
    
    
    
    public double calCost (CallRecord callRecords) {
        return 0;
    }
}

class LandPhoneInCityRule extends CallChargeRule{

    @Override
    protected double calCost(UserRecords userRecords) {
        double sumCost = 0;
        
        for (CallRecord a: userRecords.getCallingInCityRecords()) {
            double time = (a.getEndTime().getTime()-a.getStartTime().getTime())/1000;
            if (time < 0) {
                continue;
            }
            double timec = (int) time / 60;
            if (time % 60 != 0) {
                timec += 1;
            }
            sumCost += timec * 0.2;         
        }
        
        return sumCost;
    }
    
}

class LandPhoneInlandRule extends CallChargeRule{
    
    @Override
    protected double calCost(UserRecords userRecords) {
        double sumCost = 0;
        for (CallRecord a: userRecords.getCallingInLandRecords()) {
            double time = (a.getEndTime().getTime()-a.getStartTime().getTime())/1000;            
            if (time < 0) {
                continue;
            }
            double timec = (int) time / 60;
            if (time % 60 != 0) {
                timec += 1;
            }
            sumCost += timec * 0.6;
        }
        return sumCost;
    }
    
}

class LandPhoneInProvinceRule extends CallChargeRule{

    @Override
    protected double calCost(UserRecords userRecords) {
        double sumCost = 0;
        for (CallRecord a: userRecords.getCallingInProvinceRecords()) {
            double time = (a.getEndTime().getTime()-a.getStartTime().getTime())/1000;        
            if (time < 0) {
                continue;
            }
            double timec = (int) time / 60;
            if (time % 60 != 0) {
                timec += 1;
            }
            sumCost += timec * 0.3;
        }
        return sumCost;
    }
}


class PhoneInCityRule extends CallChargeRule{

    @Override
    protected double calCost(UserRecords userRecords) {
        double sumCost = 0;
        for (CallRecord a: userRecords.getCallingInCityRecords()) {
            double time = (a.getEndTime().getTime()-a.getStartTime().getTime())/1000;            
            if (time < 0) {
                continue;
            }
            double timec = (int) time / 60;
            if (time % 60 != 0) {
                timec += 1;
            }
            
            if(a.getCallingAddressAreaCode().matches("0971"))
                sumCost += timec * 0.1;
            else if(a.getAnswerAddressAreaCode().matches("079[0-9]")||
                    a.getAnswerAddressAreaCode().matches("0701"))
                sumCost += timec * 0.3;
            else 
                sumCost += timec * 0.6;
        }
        
        return sumCost;
    }
    
}

class PhoneInProvinceRule extends CallChargeRule{

    @Override
    protected double calCost(UserRecords userRecords) {
        double sumCost = 0;
        for (CallRecord a: userRecords.getCallingInProvinceRecords()) {
            double time = (a.getEndTime().getTime()-a.getStartTime().getTime())/1000;            
            if (time < 0) {
                continue;
            }
            double timec = (int) time / 60;
            if (time % 60 != 0) {
                timec += 1;
            }
            
            if(a.getCallingAddressAreaCode().matches("0971"))
                sumCost += timec * 0.2;
            else if(a.getAnswerAddressAreaCode().matches("079[0-9]")||
                    a.getAnswerAddressAreaCode().matches("0701"))
                sumCost += timec * 0.3;
            else 
                sumCost += timec * 0.6;
        }
        return sumCost;
    }
    
}

class PhoneInlandRule extends CallChargeRule{

    @Override
    protected double calCost(UserRecords userRecords) {
        double sumCost = 0;
        for (CallRecord a: userRecords.getCallingInLandRecords()) {
            double time = (a.getEndTime().getTime()-a.getStartTime().getTime())/1000;            
            if (time < 0) {
                continue;
            }
            double timec = (int) time / 60;
            if (time % 60 != 0) {
                timec += 1;
            }
            
            if(a.getCallingAddressAreaCode().matches("0791"))
                sumCost += timec * 0.3;
            else if(a.getAnswerAddressAreaCode().matches("079[0-9]")||
                    a.getAnswerAddressAreaCode().matches("0701"))
                sumCost += timec * 0.3;
            else 
                sumCost += timec * 0.6;
        }
        for (CallRecord a: userRecords.getAnswerInLandRecords()) {
            double time = (a.getEndTime().getTime()-a.getStartTime().getTime())/1000;            
            if (time < 0) {
                continue;
            }
            double timec = (int) time / 60;
            if (time % 60 != 0) {
                timec += 1;
            }
            sumCost += timec * 0.3;    
        }
        return sumCost;
    }
    
}



abstract class MessageChargeRule extends ChargeRule{

    @Override
    protected double calCost(UserRecords userRecords) {
        return 0;
    }
    
}

class SendMessageRule extends MessageChargeRule{
    @Override
    protected double calCost(UserRecords userRecords) {
        double sumCost = 0;
        double set = 0;
        int n = userRecords.getSendMessageRecords().size();
        for(MessageRecord a: userRecords.getSendMessageRecords()) {
            int sum = a.getMessage().length();
            int b=0;
            if(sum>10) {
                if(sum%10!=0) {
                    b=sum/10;
                    n+=b;
                }
                else {
                    b=sum/10;
                    n+=b-1;
                }
            }
        }
        
        if(n>=1&&n<=3) {
            sumCost+=0.1*n;
        }
        else if(n>3&&n<=5) {
            sumCost+=0.2*(n-3)+0.1*3;
        }
        else {
            if(n>0) {
                if(n<=8) {
                    sumCost+=0.3*5+0.1*(n-5);
                }
                else {
                    sumCost+=0.3*(n-5)+0.2*2+0.1*3;
                }
            }
            
        }
        
        
        return sumCost;
    }
    
}
View Code

3、

7-1 电信计费系列3-短信计费 分数 50 作者 蔡轲 单位 南昌航空大学

实现一个简单的电信计费程序,针对手机的短信采用如下计费方式:
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。

本题只考虑短信计费,不考虑通信费用以及月租费。

建议类图:
参见图1、2、3:

image.png

图1

图1中User是用户类,包括属性:
userRecords (用户记录)、balance(余额)、chargeMode(计费方式)、number(号码)。
ChargeMode是计费方式的抽象类:
chargeRules是计费方式所包含的各种计费规则的集合,ChargeRule类的定义见图3。
getMonthlyRent()方法用于返回月租(monthlyRent)。    
UserRecords是用户记录类,保存用户各种通话、短信的记录,    
各种计费规则将使用其中的部分或者全部记录。
其属性从上到下依次是:
市内拨打电话、省内(不含市内)拨打电话、省外拨打电话、
市内接听电话、省内(不含市内)接听电话、省外接听电话的记录
以及发送短信、接收短信的记录。
 

image.png

图2

    图2中CommunicationRecord是抽象的通讯记录类:
包含callingNumber拨打号码、answerNumber接听号码两个属性。
CallRecord(通话记录)、MessageRecord(短信记录)是它的子类。
 

image.png

图3
图3是计费规则的相关类,这些类的核心方法是:
calCost(ArrayList callRecords)。
该方法针根据输入参数callRecords中的所有记录计算某用户的某一项费用;如市话费。
输入参数callRecords的约束条件:必须是某一个用户的符合计费规则要求的所有记录。
SendMessageRule是发送短信的计费规则类,用于计算发送短信的费用。
LandPhoneInCityRule、LandPhoneInProvinceRule、LandPhoneInLandRule三个类分别是座机拨打市内、省内、省外电话的计费规则类,用于实现这三种情况的费用计算。

(提示:可以从UserRecords类中获取各种类型的callRecords)。
 

注意:以上图中所定义的类不是限定要求,根据实际需要自行补充或修改。

输入样例:

在这里给出一组输入。例如:

u-18907910010 3
m-18907910010 13305862264 aaaaaaaaaaaaaaaaaaaaaaa
end
 

输出样例:

在这里给出相应的输出。例如:

18907910010 0.3 99.7
 
### 输入样例1:
 

在这里给出一组输入。例如:

u-18907910010 3
m-18907910010 13305862264 aaaaaaaaaaaa
m-18907910010 13305862264 aaaaaaa.
m-18907910010 13305862264 bb,bbbb
end
 

输出样例1:

在这里给出相应的输出。例如:

18907910010 0.5 99.5
import java.util.ArrayList;
import java.util.Comparator;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;
import java.text.ParseException;
 
public class Main {
 
    public static void main(String[] args) {
 
        Outputtool outputtool = new Outputtool();
 
        Inputdeal inputdeal = new Inputdeal();
 
        ArrayList<User> users = new ArrayList<>();
 
        Scanner in = new Scanner(System.in);
 
        String input = in.nextLine();
 
        while (!input.equals("end")) {
            if (1 == inputdeal.check(input)) {
                inputdeal.writeUser(users, input);
            } else if (2 == inputdeal.check(input)) {
                inputdeal.writeRecord(users, input);
            }
            input = in.nextLine();
        }
 
        users.sort(new Comparator<User>() {
 
            @Override
            public int compare(User u1, User u2) {
                if (u1.getNumber().charAt(0) == '0' && u2.getNumber().charAt(0) != '0') {
                    return -1;
                } else if (u1.getNumber().charAt(0) != '0' && u2.getNumber().charAt(0) == '0') {
                    return 1;
                }
                if (Double.parseDouble(u1.getNumber()) > Double.parseDouble(u2.getNumber())) {
                    return 1;
                } else {
                    return -1;
                }
            }
        });
 
        for (User u : users) {
            System.out.print(u.getNumber() + " ");
            outputtool.output(u.calCost());
            System.out.print(" ");
            outputtool.output(u.calBalance());
            System.out.println();
 
        }
 
    }
 
}
 
abstract class ChargeMode {
    protected ArrayList<ChargeRule> chargeRules = new ArrayList<>();
 
    public abstract double calCost(UserRecords userRecords);
 
    public abstract double getMonthlyRent();
 
    public ArrayList<ChargeRule> getChargeRules() {
        return chargeRules;
    }
 
    public void setChargeRules(ArrayList<ChargeRule> chargeRules) {
        this.chargeRules = chargeRules;
    }
}
 
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> answerInCityRecords = 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 addCallingInLandRecords(CallRecord callRecord) {
        callingInLandRecords.add(callRecord);
    }
 
    public void addAnswerInCityRecords(CallRecord callRecord) {
        answerInCityRecords.add(callRecord);
    }
 
    public void aaddAnswerInProvinceRecords(CallRecord callRecord) {
        answerInProvinceRecords.add(callRecord);
    }
 
    public void addAnswerInLandRecords(CallRecord callRecord) {
        answerInLandRecords.add(callRecord);
    }
 
    public void addSendMessageRecords(MessageRecord callRecord) {
        sendMessageRecords.add(callRecord);
    }
 
    public void addReceiveMessageRecords(MessageRecord callRecord) {
        receiveMessageRecords.add(callRecord);
    }
 
    public ArrayList<CallRecord> getCallingInCityRecords() {
        return callingInCityRecords;
    }
 
    public void setCallingInCityRecords(ArrayList<CallRecord> callingInCityRecords) {
        this.callingInCityRecords = callingInCityRecords;
    }
 
    public ArrayList<CallRecord> getCallingInProvinceRecords() {
        return callingInProvinceRecords;
    }
 
    public void setCallingInProvinceRecords(ArrayList<CallRecord> callingInProvinceRecords) {
        this.callingInProvinceRecords = callingInProvinceRecords;
    }
 
    public ArrayList<CallRecord> getCallingInLandRecords() {
        return callingInLandRecords;
    }
 
    public void setCallingInLandRecords(ArrayList<CallRecord> callingInLandRecords) {
        this.callingInLandRecords = callingInLandRecords;
    }
 
    public ArrayList<CallRecord> getAnswerInCityRecords() {
        return answerInCityRecords;
    }
 
    public void setAnswerInCityRecords(ArrayList<CallRecord> answerInCityRecords) {
        this.answerInCityRecords = answerInCityRecords;
    }
 
    public ArrayList<CallRecord> getAnswerInProvinceRecords() {
        return answerInProvinceRecords;
    }
 
    public void setAnswerInProvinceRecords(ArrayList<CallRecord> answerInProvinceRecords) {
        this.answerInProvinceRecords = answerInProvinceRecords;
    }
 
    public ArrayList<CallRecord> getAnswerInLandRecords() {
        return answerInLandRecords;
    }
 
    public void setAnswerInLandRecords(ArrayList<CallRecord> answerInLandRecords) {
        this.answerInLandRecords = answerInLandRecords;
    }
 
    public ArrayList<MessageRecord> getSendMessageRecords() {
        return sendMessageRecords;
    }
 
    public void setSendMessageRecords(ArrayList<MessageRecord> sendMessageRecords) {
        this.sendMessageRecords = sendMessageRecords;
    }
 
    public ArrayList<MessageRecord> getReceiveMessageRecords() {
        return receiveMessageRecords;
    }
 
    public void setReceiveMessageRecords(ArrayList<MessageRecord> receiveMessageRecords) {
        this.receiveMessageRecords = receiveMessageRecords;
    }
 
}
 
class LandlinePhoneCharging extends ChargeMode {
 
    private double monthlyRent = 20;
 
    public LandlinePhoneCharging() {
        super();
        chargeRules.add(new LandPhoneInCityRule());
        chargeRules.add(new LandPhoneInProvinceRule());
        chargeRules.add(new LandPhoneInlandRule());
    }
 
    @Override
    public double calCost(UserRecords userRecords) {
        double sumCost = 0;
        for (ChargeRule rule : chargeRules) {
            sumCost += rule.calCost(userRecords);
        }
        return sumCost;
    }
 
    @Override
    public double getMonthlyRent() {
        return monthlyRent;
    }
 
}
 
class MobilePhoneCharging extends ChargeMode {
 
    private double monthlyRent = 15;
 
    public MobilePhoneCharging() {
        super();
        chargeRules.add(new MobilePhoneInCityRule());
        chargeRules.add(new MobilePhoneInProvinceRule());
        chargeRules.add(new MobilePhoneInlandRule());
    }
 
    @Override
    public double calCost(UserRecords userRecords) {
        double sumCost = 0;
        for (ChargeRule rule : chargeRules) {
            sumCost += rule.calCost(userRecords);
        }
        return sumCost;
    }
 
    @Override
    public double getMonthlyRent() {
        return monthlyRent;
    }
 
}
 
class MobilePhoneMassageCharging extends ChargeMode {
 
    private double monthlyRent = 0;
 
    public MobilePhoneMassageCharging() {
        super();
        chargeRules.add(new MobilePhoneMessageRule());
    }
 
    @Override
    public double calCost(UserRecords userRecords) {
        double sumCost = 0;
        for (ChargeRule rule : chargeRules) {
            sumCost += rule.calCost(userRecords);
        }
        return sumCost;
    }
 
    @Override
    public double getMonthlyRent() {
        return monthlyRent;
    }
 
}
 
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 == 0) {
            usernew.setChargeMode(new LandlinePhoneCharging());
        } else if (mode == 1) {
            usernew.setChargeMode(new MobilePhoneCharging());
        } else 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);
            }
        }
 
    }
 
}
 
abstract class CommunicationRecord {
    protected String callingNumber;
    protected String answerNumbe;
 
    public String getCallingNumber() {
        return callingNumber;
    }
 
    public void setCallingNumber(String callingNumber) {
        this.callingNumber = callingNumber;
    }
 
    public String getAnswerNumbe() {
        return answerNumbe;
    }
 
    public void setAnswerNumbe(String answerNumbe) {
        this.answerNumbe = answerNumbe;
    }
 
}
 
abstract class ChargeRule {
 
    abstract public double calCost(UserRecords userRecords);
 
}
 
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) {
        }
 
    }
 
    public CallRecord(Date startTime, Date endTime, String callingAddressAreaCode, String answerAddressAreaCode) {
        super();
        this.startTime = startTime;
        this.endTime = endTime;
        this.callingAddressAreaCode = callingAddressAreaCode;
        this.answerAddressAreaCode = 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;
    }
}
 
abstract class CallChargeRule extends ChargeRule {
 
}
 
class LandPhoneInCityRule extends CallChargeRule {
 
    @Override
    public double calCost(UserRecords userRecords) {
        double sumCost = 0;
        for (CallRecord call : userRecords.getCallingInCityRecords()) {
            double distanceS = (-call.getStartTime().getTime() + call.getEndTime().getTime()) / 1000;
            if (distanceS < 0) {
                continue;
            }
            double distanceM = (int) distanceS / 60;
            if (distanceS % 60 != 0) {
                distanceM += 1;
            }
            if (call.getCallType().equals("11")) {
                sumCost += distanceM * 0.1;
            } else if (call.getCallType().equals("12")) {
                sumCost += distanceM * 0.3;
            } else if (call.getCallType().equals("13")) {
                sumCost += distanceM * 0.6;
            }
        }
        return sumCost;
    }
 
}
 
class LandPhoneInlandRule extends CallChargeRule {
 
    @Override
    public double calCost(UserRecords userRecords) {
        double sumCost = 0;
        for (CallRecord call : userRecords.getCallingInLandRecords()) {
            double distanceS = (-call.getStartTime().getTime() + call.getEndTime().getTime()) / 1000;
            if (distanceS < 0) {
                continue;
            }
            double distanceM = (int) distanceS / 60;
            if (distanceS % 60 != 0) {
                distanceM += 1;
            }
            sumCost += distanceM * 0.6;
        }
        return sumCost;
    }
 
}
 
class LandPhoneInProvinceRule extends CallChargeRule {
 
    @Override
    public double calCost(UserRecords userRecords) {
        double sumCost = 0;
        for (CallRecord call : userRecords.getCallingInProvinceRecords()) {
            double distanceS = (-call.getStartTime().getTime() + call.getEndTime().getTime()) / 1000;
            if (distanceS < 0) {
                continue;
            }
            double distanceM = (int) distanceS / 60;
            if (distanceS % 60 != 0) {
                distanceM += 1;
            }
            sumCost += distanceM * 0.3;
        }
        return sumCost;
    }
 
}
 
class MobilePhoneInCityRule extends CallChargeRule {
 
    @Override
    public double calCost(UserRecords userRecords) {
        double sumCost = 0;
        for (CallRecord call : userRecords.getCallingInCityRecords()) {
            double distanceS = (-call.getStartTime().getTime() + call.getEndTime().getTime()) / 1000;
            if (distanceS < 0) {
                continue;
            }
            double distanceM = (int) distanceS / 60;
            if (distanceS % 60 != 0) {
                distanceM += 1;
            }
            if (call.getCallType().equals("11")) {
                sumCost += distanceM * 0.1;
            } else if (call.getCallType().equals("12")) {
                sumCost += distanceM * 0.2;
            } else if (call.getCallType().equals("13")) {
                sumCost += distanceM * 0.3;
            }
 
        }
        return sumCost;
    }
 
}
 
class MobilePhoneInlandRule extends CallChargeRule {
 
    @Override
    public double calCost(UserRecords userRecords) {
        double sumCost = 0;
        for (CallRecord call : userRecords.getCallingInLandRecords()) {
            double distanceS = (-call.getStartTime().getTime() + call.getEndTime().getTime()) / 1000;
            if (distanceS < 0) {
                continue;
            }
            double distanceM = (int) distanceS / 60;
            if (distanceS % 60 != 0) {
                distanceM += 1;
            }
            sumCost += distanceM * 0.6;
        }
        for (CallRecord call : userRecords.getAnswerInLandRecords()) {
            double distanceS = (-call.getStartTime().getTime() + call.getEndTime().getTime()) / 1000;
            if (distanceS < 0) {
                continue;
            }
            double distanceM = (int) distanceS / 60;
            if (distanceS % 60 != 0) {
                distanceM += 1;
            }
            sumCost += distanceM * 0.3;
        }
        return sumCost;
    }
 
}
 
class MobilePhoneInProvinceRule extends CallChargeRule {
 
    @Override
    public double calCost(UserRecords userRecords) {
        double sumCost = 0;
        for (CallRecord call : userRecords.getCallingInProvinceRecords()) {
            double distanceS = (-call.getStartTime().getTime() + call.getEndTime().getTime()) / 1000;
            if (distanceS < 0) {
                continue;
            }
            double distanceM = (int) distanceS / 60;
            if (distanceS % 60 != 0) {
                distanceM += 1;
            }
            if (call.getCallType().equals("21")) {
                sumCost += distanceM * 0.3;
            } else if (call.getCallType().equals("22")) {
                sumCost += distanceM * 0.3;
            } else if (call.getCallType().equals("23")) {
                sumCost += distanceM * 0.3;
            }
        }
        return sumCost;
    }
 
}
 
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 MessageRecord extends CommunicationRecord {
 
    private String message;
 
    public MessageRecord(String input) {
        super();
        this.message = input.substring(26);
    }
 
    public String getMessage() {
        return message;
    }
 
    public void setMessage(String message) {
        this.message = message;
    }
}
 
class User {
 
    private UserRecords userRecords = new UserRecords();
    private double balance = 100;
    private ChargeMode chargeMode;
    private String number;
 
    public double calCost() {
        return chargeMode.calCost(userRecords);
    }
 
    public double calBalance() {
        return balance - chargeMode.getMonthlyRent() - chargeMode.calCost(userRecords);
    }
 
    public UserRecords getUserRecords() {
        return userRecords;
    }
 
    public void setUserRecords(UserRecords userRecords) {
        this.userRecords = userRecords;
    }
 
    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;
    }
 
}
 
class Outputtool {
 
    @SuppressWarnings("deprecation")
    public void output(double out) {
        BigDecimal numb = new BigDecimal(out);
        out = numb.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
        System.out.print(out);
    }
}
View Code




三、总结
本学期的java学习结束了,我有些许懊悔,因为没有完全地投入到java学习中,作业的任务我一般也是留到最后做。但我学到了蛮多知识,诸如封装、继承、多态、抽象类的使用、正则表达式,还有接口等等,但java的学习和巩固还未停止,
多多动手,去看好的代码,跟着学,尽量让自己不后悔没好好学。

标签:return,String,double,blog3,ArrayList,userRecords,public
From: https://www.cnblogs.com/cornfieldchase/p/16972465.html

相关文章

  • Blog3:nchu-software-oop-2022-6~8
    Blog3:nchu-software-oop-2022-6~8一、前言不知不觉,已到了本学期末尾,面向对象程序设计这门课也已经结课。课程虽然结束了,但需要学习和巩固的知识点还有很多。同时,这也......
  • Remember的Java-blog3
    一、前言    此次blog为电信计费系列的座机,手机,短信大作业总结。相对于前几次的多边形,这次在算法上更简单,但是涉及到的内容很多,比如容器的使用、抛出异常、抽象类......
  • BLOG3
    一、前言1、知识点 类和对象:  类(class)和对象(object)是两种以计算机为载体的计算机语言的合称。对象是对客观事物的抽象,类是对对象的抽象。类是一种抽象......
  • Blog3-电信计费系列题目集
    前言电信计费系列题目虽然难度相对于多边形系列有所下降,但涉及知识点很广,主要如下:1、容器的使用2、抛出异常3、抽象类4、继承与多态5、正则表达式6、类和对象设计......