总结

前言

---

 

 

在这几次的大作业中，完成的功能是电信计费，其中的主要知识点是对类图的理解和将类图转换成代码的能力，同时学习了Date类和SimpleDateFormat类的用法，用于规范时间，能够将String类型的字符串转换成特定格式的Date类型，这对时间的计算非常有利。只要解决了时间计算的问题后，计算费用也更简便。

这几次的题量都不多，主要是电信计费的难度，其实其难度并不比先前的多边形计算大，但最让人头大的还是格式错误、非法输入的问题，这让人无从下手，不是算法的错误，而要自己想想有哪些非法的情况，这属实难想，导致每次都没能完美的完成题目。

设计与分析

---

 

由于此次的题目中给出了相应的类图，只要照着类图将功能实现就可以了，所以在类图的设计上并没有花很大的精力，这也是这次比多边形计算简单的一个点。

通话计费代码

 

 

 

 

import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;

public class Main {

    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        ArrayList<User> user = new ArrayList<User>();
        String input = in.nextLine();
        while(input.isEmpty()) {
            input = in.nextLine();
        }
        while(input.matches("u\\-1\\d{10} [1,3]")) {
                String[] s=input.split(" ");
                user.add(new User(s[0],s[1]));
                input = in.nextLine();
            while(input.isEmpty()) {
                input = in.nextLine();
            }
        }
        while(!input.equals("end")) {
            if(input.matches("m-1\\d{10} 1\\d{10} ([A-Za-z]||\\,||\\d||\\.|| )+")) {
                String[] s =input.split(" ");
                MessageRecord record = new MessageRecord(s[0].substring(2),s[1],input.substring(26, input.length()));
                int i;
                for(i=0;i<user.size();i++) {
                    user.get(i).setRecords(record);;
                }
                
            }
            input = in.nextLine();
            while(input.isEmpty()) {
                input = in.nextLine();
            }
        }
        Collections.sort(user);
        
        for(int i=0;i<user.size();i++) {
            System.out.printf("%s %.1f %.1f\n",user.get(i).getN(),user.get(i).calCost(),user.get(i).calBalance());
        }
    }

}

class UserRecords {
    ArrayList<MessageRecord>  sendMessageRecords= new ArrayList<MessageRecord>();
    ArrayList<MessageRecord>  receiveMessageRecords= new ArrayList<MessageRecord>();
    
    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;
    }
}

class MessageRecord {
    String sendNumber;
    String receiveNumber;
    String message;
    
    public MessageRecord() {
        
    }
    
    public MessageRecord(String sendNumber,String receiveNumber,String message) {
        this.message = message;
        this.receiveNumber = receiveNumber;
        this.sendNumber = sendNumber;
    }
    
    public String getMessage() {
        return message;
    }
    
    public String getreceiveNumber() {
        return receiveNumber;
    }
    
    public String getsendNumber() {
        return sendNumber;
    }
}

class User implements Comparable<Object>{
    double balance = 100;
    String number;
    String type;
    UserRecords records = new UserRecords();
    
    public User() {
        
    }
    
    public User(String s1,String s2) {
        number = s1.substring(2);
        type = s2;
    }
    
    public void setRecords(MessageRecord messageRecord) {
        if(getN().equals(messageRecord.getsendNumber()))
            records.addSendMessageRecords(messageRecord);
        else if(getN().equals(messageRecord.getreceiveNumber()))
            records.addReceiveMessageRecords(messageRecord);
    }
    
    public UserRecords getRecords() {
        return records;
    }
    
    public void setN(String num) {
        number = num;
    }
    
    public String getN() {
        return number;
    }
    
    
    public double getBalance() {
        return balance;
    }
    
    public double calBalance(){
        return getBalance() - calCost();
    }
    
    public double calCost() {
        ArrayList<MessageRecord>  sendMessageRecords = getRecords().getSendMessageRecords();
        int i;
        double count = 0;
        double cost;
        MessageRecord messagerecord = new MessageRecord();
        String message;
        for(i=0;i<sendMessageRecords.size();i++) {
            messagerecord = sendMessageRecords.get(i);
            message = messagerecord.getMessage();
            count  += Math.ceil(message.length()*1.0/10);
        }
        if(count<=3)
            cost = 0.1*count;
        else if(count<=5)
            cost =0.3 + 0.2*(count-3);
        else
            cost =0.3+0.4+ 0.3*(count-5);
        return cost;
    }

    @Override
    public int compareTo(Object o) {
        User user = (User) o;
        return this.number.compareTo(user.number);
    }
}

 

 

 

 踩坑心得

---

 

SimpleDateFormat类能够进行时间格式的判断。

利用Date类和SimpleDateFormat类就可以定义时间并且计算出时间差，解决了时间计算的难题。

用Math.ceil()能够将为满1的数计为1，即若有小数为，则将进1位。

利用正则表达式判断格式正误。

改进建议

---

 

完善格式判断方法，将所有非法输入解决。

在加入通话记录时用了很多if来判断是用什么打什么，可以改进为，先生成记录 ，再直接将记录传入User的setRecord方法中，再进行判断是本用户接还是本用户打。

总结

首先要将所给类图的关系理清楚，明确各个类之间的关系，和其职能，这样才能更好的分工。

在判断格式正误时，利用正则表达式能更加有效。

在要涉及时间的计算或表示时，可以利用Date类和SimpleDateFormat类进行定义，能使问题轻松解决。