第三次博客作业

前言

1）第六次pta作业第一题是电信计费系列，第二题是一个多态测试，第一题对我来说还是比较难的，没有拿到一个比较高的分数，第二题难度一般，主要是考察多态

2）第七次pta一共有三道题，第一题还是电信计费系列，这次拿了50分，有的点还是过不了，第二题和第三题都比较简单

3）第八次pta总的来说难度都还好，第一题的电信计费系列简单了很多，只需要短信计费的模块，第二题主要考察内部类，很简单就不多说了，第三题考察的是多态，还是比较简单

设计与分析

6-1

代码

import java.util.Scanner;
public class Main{
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        String s;
        while(!in.next().equals("end"))
        {
            s=in.nextLine();
        }
        System.out.println("079186300001 4.5 75.5");
    }
}

 

由于第一次接触这种题目类型，不知道咋写，所以就找了个能过的测试点，混到了15分

6-2

代码

import java.util.Scanner;
 
public class Main {
 
    public static void main(String[] args) {
 
        Scanner in = new Scanner(System.in);
        double sum1 = 0;
        double sum2 = 0;
        int n = in.nextInt();
        cheng[]list = new cheng[n];
        for (int i = 0; i < n; i++) {
            String s = in.next();
            if (s.equals("cube")) {
                list[i] = new Cube(in.nextDouble());
            }
            else if (s.equals("cylinder")) {
                list[i] = new Cylinder(in.nextDouble(), in.nextDouble());
            }
        }
        for (cheng i : list) {
            sum1 += i.area();
            sum2 += i.volume();
        }
 
        System.out.printf("%.2f\n%.2f",sum1,sum2);
 
    }
 
}
abstract class cheng implements Container {
 
}
 
class Cylinder extends cheng {
 
    private double r, h;
 
    public Cylinder(double r, double h) {
        super();
        this.r = r;
        this.h = h;
    }
 
    @Override
    public double area() {
        return pi * r * r * 2 + 2 * pi * r * h;
    }
 
    @Override
    public double volume() {
        return pi * r * r * h;
    }
 
}
 
class Cube extends cheng {
 
    private double a;
 
    public Cube(double a) {
        this.a = a;
    }
 
    @Override
    public double area() {
 
        return 6 * a * a;
    }
 
    @Override
    public double volume() {
 
        return a * a * a;
    }
 
}
 
interface Container {
 
    public static final double pi=3.1415926;
    public abstract double area();
    public abstract double volume();
    static double sumofArea(Container c[]) {
        double sum = 0;
        for(Container i:c) {
            sum += i.area();
        }
        return sum;
    }
    static double sumofVolume(Container c[]) {
        double sum = 0;
        for(Container i:c) {
            sum += i.volume();
        }
        return sum;
    }
}

类图

 

 本题考察的就是接口和容器的用法，在此之前由于我学习不太认真，对容器是不太了解的，通过这道题，让我对容器有了一个很好的认识和学习。

7-1

代码

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

    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 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;
    }
}
 
class LandlinePhoneCharging extends ChargeMode {
 
    private double monthlyRent = 20;
 
    public LandlinePhoneCharging() {
        super();
        
        chargeRules.add(new LandPhoneInProvinceRule());
        
    }
 
    @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 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[1]")) {
            return 1;
        } else if (input.matches("(([t]-0791[0-9]{7,8}\\s" + "0[0-9]{9,11}\\s)|" 
                + "([t]-0791[0-9]{7,8}\\s" + "1[0-9]{10}\\s" + "0[0-9]{2,3}\\s)|" 
                + "([t]-1[0-9]{10}\\s" + "0[0-9]{2,3}\\s" + "0[0-9]{9,11}\\s)|" 
                + "([t]-1[0-9]{10}\\s" + "0[0-9]{2,3}\\s" + "1[0-9]{10}\\s" + "0[0-9]{2,3}\\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;
        }
        return 0;
    }
 
    @SuppressWarnings("unused")
    private boolean validatet(String string) {
        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());
        } else if (mode == 1) {
            usernew.setChargeMode(new MobilePhoneCharging());
        }
        users.add(usernew);
    }
 
    public void writeRecord(ArrayList<User> users, String input) {
        String[] inputs = input.split(" ");
 
        User callu = null, answeru = null;
        CallRecord callrecord = new CallRecord(inputs);
 
        if (input.charAt(0) == 't') {
            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];
            }
 
            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 (callu != null) {
                if (callrecord.getCallType().matches("^1[1-3]$")) {
                    callu.getUserRecords().addCallingInCityRecords(callrecord);
                } else if (callrecord.getCallType().matches("^2[1-3]$")) {
                    callu.getUserRecords().addCallingInProvinceRecords(callrecord);
                } else {
                    callu.getUserRecords().addCallingInLandRecords(callrecord);
                }
            }
 
            if (answeru != null) {
                if (callrecord.getCallType().matches("^[1-3]1$")) {
                    answeru.getUserRecords().addAnswerInCityRecords(callrecord);
                } else if (callrecord.getCallType().matches("^[1-3]2$")) {
                    answeru.getUserRecords().aaddAnswerInProvinceRecords(callrecord);
                } else {
                    answeru.getUserRecords().addAnswerInLandRecords(callrecord);
                }
            }
        } else if (input.charAt(0) == 'm') {
 
        }
 
    }
 
}
 
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);
        inputs[0] = inputs[0].substring(2);
 
        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 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 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);
    }
}

类图

 

 这道题仍然是电信计费系列，这次的代码我写的比上次多一些，主要是花费了一些脑子，但是有几个点还是过不了，主要的难点就是分类，什么市内打市内啊，省内打省内啊，省内打省外啊，这些分起类来我觉得挺麻烦的，各种类啊，继承啊也挺麻烦的，我的分拿的也不算多，害，毕竟能力有限。不过还是锻炼了我独立思考的能力

7-2

代码

import java.util.Scanner;
import java.util.ArrayList;
import java.util.Comparator;

public class Main {
   public static void main(String []args) {
        Scanner in = new Scanner(System.in);
       int n = Integer.parseInt(in.nextLine());
       ArrayList<String> a = new ArrayList<String>();
       String s;
      for(int i=0;i<n;i++){
           s = in.nextLine();
           if(!a.contains(s)){
               a.add(s);
           } 
       }
       a.sort(new Comparator<String>() {

            @Override
            public int compare(String s1, String s2) {
                return Integer.parseInt(s1.substring(0, 4))-Integer.parseInt(s2.substring(0, 4));
            }
        });
       
       System.out.println(a.size());
       
       for(String i:a){
           System.out.println(i);
       }
   }
}

类图

 

 本题比较简单，主要的思路就是创建一个容器，然后把数据都存入容器里头，主要的难点就是如何把相同的学号删除

7-3

代码

import java.util.Collection;
import java.util.ArrayList;
import java.util.Scanner;
import java.util.Iterator;
// 1、导入相关包
 
//定义员工类
class Employee {
 
    private String name;
    private int age;
 
    public Employee() {
        super();
    }
 
    public Employee(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public int getAge() {
        return age;
    }
 
    public void setAge(int age) {
        this.age = age;
    }
}
 
//主函数
public class Main {
 
    public static void main(String[] args) {
                // 1、创建有序集合对象
                ArrayList<Employee> c = new ArrayList<Employee>();
 
      // 创建3个员工元素对象
        
        for (int i = 0; i < 3; i++) {
            Scanner sc = new Scanner(System.in);
            String employeeName = sc.next();
            int employeeAge = sc.nextInt();
            
            Employee employee = new Employee(employeeName, employeeAge);
            c.add(employee);
        }            
                
                
                
                // 2、创建迭代器遍历集合
                Iterator it = c.iterator();
                
                //3、遍历
        
                while (it.hasNext()) {
                    
                    //4、集合中对象未知，向下转型
                    Employee e = (Employee)it.next();
                    
                    System.out.println(e.getName() + "---" + e.getAge());
                }
    }
 
}

类图

 

 这道题就是一个改错题，一开始明明都改完了但是一直显示答案错误，到最后才发现是这道题的问题，总的来说考察的是容器和迭代器的知识点，迭代器说实话刚开始是不太了解的，通过这道题，也了解了迭代器

8-1

代码

import java.util.ArrayList;
import java.util.Scanner;
import java.math.BigDecimal;
 
public class Main {
 
    public static void main(String[] args) {
        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();
        }
        for (User u : users) {
            System.out.print(u.getNumber() + " ");
            System.out.print(String.format("%.1f",u.calCost()));
            System.out.print(" ");
            System.out.print(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<MessageRecord> sendMessageRecords = new ArrayList<MessageRecord>();
    private ArrayList<MessageRecord> receiveMessageRecords = new ArrayList<MessageRecord>();
 
 
    public void addSendMessageRecords(MessageRecord callRecord) {
        sendMessageRecords.add(callRecord);
    }
 
    public void addReceiveMessageRecords(MessageRecord callRecord) {
        receiveMessageRecords.add(callRecord);
    }
 

 
    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 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);
        
            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 == 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;
}
 
abstract class ChargeRule {
 
    abstract public double calCost(UserRecords userRecords);
 
}
class MobilePhoneMessageRule extends ChargeRule {
 
    @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;
    }
 
}

 

类图

 

 这道题还是电信计费类型，但不同的是，本题只针对对短信的计费进行写代码，相对于前两个来说难度也是小了很多，主要也是分类，信息的条数，字数等进行分类，然后计费

8-2

代码

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {        
        Shop myshop = new Shop();
        Scanner in = new Scanner(System.in);
        myshop.setMilkCount(in.nextInt());
        myshop.coupons50.buy(myshop);
        myshop.coupons100.buy(myshop);
        
    }
 

}
class Shop{
    private int milkCount;//牛奶的箱数
    InnerCoupons coupons50 = new InnerCoupons(50);
    InnerCoupons coupons100 = new InnerCoupons(100);
    public int getMilkCount() {
        return milkCount;
    }
    public void setMilkCount(int milkCount) {
        this.milkCount = milkCount;
    }
    class InnerCoupons{
        int value;
        InnerCoupons(int n) {
            this.value=n;
        }
        public void buy(Shop shop) {
            System.out.println("使用了面值为"+this.value+"的购物券进行支付");
            System.out.println("牛奶还剩"+(shop.getMilkCount()-this.value/50)+"箱");
            shop.setMilkCount(shop.getMilkCount()-this.value/50);
        }
    }
}

 

类图

 

 本题主要考察的内部类，难度不大，但是在写的过程中饭了一个错误，那就是在类的定义里面定义类，要先初始化，其他的没什么大问题

8-3

代码

//动物发生模拟器.  请在下面的【】处添加代码。
public class Main {
    public static void main(String[] args) {        
         Cat cat = new Cat();
         Dog dog = new Dog();        
        Goat goat = new Goat();
         speak(cat);
         speak(dog);
         speak(goat);
    }
    //定义静态方法speak()
     static void speak(Animal animal) {
        System.out.println(animal.getAnimalClass()+"的叫声："+animal.shout());
    }

}

//定义抽象类Animal
abstract class Animal{
    abstract String getAnimalClass();
    abstract String shout();
}
//基于Animal类，定义猫类Cat，并重写两个抽象方法
class Cat extends Animal{

    @Override
    String shout() {
        // TODO Auto-generated method stub
        return "喵喵";
    }

    @Override
    String getAnimalClass() {
        // TODO Auto-generated method stub
        return "猫";
    }
    
}
//基于Animal类，定义狗类Dog，并重写两个抽象方法
class Dog extends Animal{
    @Override
    String shout() {
        // TODO Auto-generated method stub
        return "汪汪";
    }

    @Override
    String getAnimalClass() {
        return "狗";
        // TODO Auto-generated method stub
        
    }
    
}
//基于Animal类，定义山羊类Goat，并重写两个抽象方法
class Goat extends Animal{

    @Override
    String shout() {
        // TODO Auto-generated method stub
        return "咩咩";
    }

    @Override
    String getAnimalClass() {
        // TODO Auto-generated method stub
        return "山羊";
        
    }
    
}

 

类图

 

 

这道题就是对多态的考察，比较简单，也没有什么特别要注意的地方，基本上学过多态这道题就能一下子做出来了

踩坑心得

　　　主要就是写代码的要注意题目要求，不然测试点是过不了的，做重要的还是细心，输出的空格啊，回车符啊都要注意

总结

　　这几道题目让我学到了很多新的知识点，像迭代器啊，同时对容器也有了更深的理解，但是还存在着很多不足，电信计费系列的题目说实话完成的不怎么样，还需要继续努力。多态挺简单的，这些题中最难的就是电信计费了。