大皮

去见、去学、去写。

南昌航空大学 软件学院 pta Java 第八次作业 蔡珂 opp

最后一次哩

题目列表

7-1 电信计费系列3-短信计费

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

本题只考虑短信计费,不考虑通信费用以及月租费。
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Objects;
import java.util.Scanner;
import java.util.Comparator;

import java.util.Date;
public class Main {
    static String []tel = {"0792","0793","0794","0795","0796","0797","0798","0799","0701"};
    public static void main(String[] args) throws ParseException {
        Scanner input = new Scanner(System.in);
        String ch = new String();
        ch = input.nextLine();
        ArrayList<User>users = new ArrayList<>();
        SimpleDateFormat date=new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
            //   System.out.printf(ch);
           while (!ch.equals("end")) {

                try {
                    if ((ch.matches("[u]-1[0-9]{10}\\s[13]")|| ch.matches("[u]-0791[0-9]{7,8}\\s[0]")|| ch.matches("[m]-1[0-9]{10}\\s" + "1[0-9]{10}\\s" + "[0-9a-zA-Z\\s\\.,]+"))) {
                        String[] splitSet = ch.split("-");
                        if (splitSet[0].equals("u")) {
                            String[] splitSet2 = splitSet[1].split(" ");
                            //
                            if(!numEqual(users,splitSet2[0])){
                                try {
                                    users.add(newUesr(splitSet2[0]));
                                } catch (Exception a){

                                }

                            }

                        } else {

                                users = newRecord(users, ch);
                        }
                    }
                }catch (Exception e){

                }

                ch = input.nextLine();
            }
        Collections.sort(users, new Cmp());
        for(User U:users){
            try {
                System.out.println(U.getNumber()+" "+printDouble(U.calCost())+" "+printDouble(U.calBalance()));
            }
            catch (Exception ps){

            }
        }




    }
     static User newUesr(String ch){
        User user = new User(ch);
        // System.out.printf(ch+"\n");
        return user;
    }
    public static double printDouble(double num) {
        String str = String.format("%.3f",num);
        num = Double.parseDouble(str);
        return num;
    }
    static boolean numEqual(ArrayList<User> User,String num){
        for(User user:User){
            if(user.getNumber().equals(num))
                return true;
        }
        return false;

    }
 static  ArrayList<User> newRecord(ArrayList<User> user,String ch) throws ParseException {
        String[] splitSet = ch.split(" ");
        String[] splitSet2 = splitSet[0].split("-");

        //System.out.printf("1");

        for (User U : user) {
            if (U.number.equals(splitSet2[1])) {
                int len = ch.length()-splitSet[0].length()-splitSet[1].length()-2;
                if(len%10!=0)
                    len = (len/10)+1;
                else len=(len/10);
                U.masnum+=len;
                return user;
            }
        }
        return user;
    }
    User judgeChargeforAnswering(User user,CallRecord callRecord){


        return user;
    }
   static int judgePlace(String ch){
        if (ch.equals("0791")) {
            return 1;
        }
        for (String tel2 : tel) {
            if (ch.equals(tel2)) {
                return 2;
            }
        }
        return 0;

    }

}
class LandPhoneInProvinceRule extends CallChargeRule{
    @Override
    public double calCost(CallRecord callRecord) {
        double sec = (callRecord.getEndTime().getTime() -callRecord.getStartTime().getTime())/ 1000;
        if (sec < 0) {
            return 0;
        }
        double minu = (int) sec / 60;
        if (sec % 60 != 0) {
            minu += 1;
        }

        return  minu * 0.3;
    }
}
class LandPhoneInLandRule extends CallChargeRule{
  @Override
  public double calCost(CallRecord callRecord) {
     double sec = (callRecord.getEndTime().getTime() -callRecord.getStartTime().getTime())/ 1000;
     if (sec < 0) {
      return 0;
     }
     double minu = (int) sec / 60;
     if (sec % 60 != 0) {
      minu += 1;
     }

     return  minu * 0.6;
  }
}
abstract class CallChargeRule extends ChargeRule{
    public abstract double calCost(CallRecord callRecord);
}
class CallRecord extends CommunicationRecord{
   Date startTime,endTime;
   String callingAddressAreaCode,answerAddressAreaCode;
    public CallRecord(){}
    public CallRecord(String a,String b,String c,String d,String callingAddressAreaCode,String answerAddressAreaCode) throws ParseException {
        super();
        SimpleDateFormat date=new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
        this.callingAddressAreaCode =callingAddressAreaCode;
        this.answerAddressAreaCode = answerAddressAreaCode;

        this.setStartTime(date.parse(a+" "+b));
        this.setEndTime(date.parse(c+" "+d));
    }
   Date getStartTime(){
     return startTime;
   }
   Date getEndTime(){
     return endTime;
   }
   String getCallingAddressAreaCode(){
    return callingAddressAreaCode;
   }
   String getAnswerAddressAreaCode(){
    return answerAddressAreaCode;
   }
   void setStartTime(Date startTime){
     this.startTime = startTime;
   }
   void setEndTime(Date endTime){
    this.endTime = endTime;
   }
   void setCallingAddressAreaCode(String callingAddressAreaCode){
     this.callingAddressAreaCode=callingAddressAreaCode;
   }
   void setAnswerAddressAreaCode(String answerAddressAreaCode){
    this.answerAddressAreaCode =answerAddressAreaCode;
   }

}
abstract class ChargeMode {
    ArrayList<ChargeRule>chargeRules =new ArrayList<ChargeRule>();
    ArrayList<ChargeRule> getChargeRules(){
        return chargeRules;
    }
    void  setChargeRules(ArrayList<ChargeRule> chargeRules) {
        this.chargeRules = (ArrayList<ChargeRule>) (chargeRules.clone());
    }
    public  abstract  double calCost(UserRecords userRecords);
    public  abstract  double getMonthlyRent();
}
class Cmp implements Comparator<User> {
    @Override
    public int compare(User U1, User U2) {

        return U1.getNumber().compareTo(U2.getNumber());
    }
}
abstract class CommunicationRecord {
    String callingNumer,answerNumer;
    void setCallingNumer(String callingNumer){
        this.callingNumer=callingNumer;
    }
    void  setAnswerNumer(String answerNumer){
        this.answerNumer =answerNumer;
    }
    String getCallingNumer(){
        return callingNumer;
    }
    String getAnswerNumer(){
        return answerNumer;
    }
}
 abstract class ChargeRule {
 }
class LandlinePhoneCharging  extends ChargeMode {
    double monthlyRent =20;
    public double calCost(UserRecords userRecords){
        double sum=0;
        for (CallRecord callRecord:userRecords.getCallingInCityRecords())
            sum+= new LandPhoneInCityRule().calCost(callRecord);
        for (CallRecord callRecord:userRecords.getCallingInLandRecords())
            sum+= new LandPhoneInLandRule().calCost(callRecord);
        for (CallRecord callRecord:userRecords.getCallingInProvinceRecords())
            sum+= new LandPhoneInProvinceRule().calCost(callRecord);

        return sum;
    }

    public double getMonthlyRent(){
        return monthlyRent;
    }
}
class LandPhoneInCityRule extends CallChargeRule{
    @Override
    public double calCost(CallRecord callRecord) {
        double sec = (callRecord.getEndTime().getTime() -callRecord.getStartTime().getTime())/ 1000;
        if (sec < 0) {
            return 0;
        }
        double minu = (int) sec / 60;
        if (sec % 60 != 0) {
            minu += 1;
        }

        return  minu * 0.1;
    }

}
class MobilePhoneCharging extends ChargeMode {

    private double monthlyRent = 15;


    @Override
    public double calCost(UserRecords userRecords) {
        double sum = 0;
        for (CallRecord callRecord:userRecords.getCallingInCityRecords())
            sum+= new MobilePhoneInlandRule().calCost(callRecord);
        for (CallRecord callRecord:userRecords.getCallingInLandRecords())
            sum+= new MobilePhoneInlandRule().calCost(callRecord);
        for (CallRecord callRecord:userRecords.getCallingInProvinceRecords())
            sum+= new MobilePhoneInProvinceRule().calCost(callRecord);
        for(CallRecord callRecord:userRecords.getCallingroamlnProvinceRecords())
            sum+= new MobilePhoneRoamInProvinceRule().calCost(callRecord);
        for(CallRecord callRecord:userRecords.getCallingroamlnLandRecords())
            sum+= new MobilePhoneRoamInLandRule().calCost(callRecord);
        for(CallRecord callRecord:userRecords.getAnswerroamlnLandRecords())
            sum+= new MobilePhoneRoamInLandRule().calCostans(callRecord);
        return sum;
    }

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

}
class MessageRecord extends CommunicationRecord{
    String message;
    String getMessage(){
        return message;
    }
    void setMessage(String message){
        this.message=message;
    }
}
class MobilePhoneInlandRule extends CallChargeRule{
    public double calCost(CallRecord callRecord) {
        double sec = (callRecord.getEndTime().getTime() -callRecord.getStartTime().getTime())/ 1000;
        if (sec < 0) {
            return 0;
        }
        double minu = (int) sec / 60;
        if (sec % 60 != 0) {
            minu += 1;
        }

        return  minu * 0.3;
    }
}
class MobilePhoneInProvinceRule extends CallChargeRule{
    public double calCost(CallRecord callRecord) {
        double sec = (callRecord.getEndTime().getTime() -callRecord.getStartTime().getTime())/ 1000;
        if (sec < 0) {
            return 0;
        }
        double minu = (int) sec / 60;
        if (sec % 60 != 0) {
            minu += 1;
        }
        return  minu * 0.2;
    }

}
class MobilePhoneRoamInLandRule extends CallChargeRule{
    public double calCost(CallRecord callRecord) {
        double sec = (callRecord.getEndTime().getTime() -callRecord.getStartTime().getTime())/ 1000;
        if (sec < 0) {
            return 0;
        }
        double minu = (int) sec / 60;
        if (sec % 60 != 0) {
            minu += 1;
        }
        return  minu * 0.6;
    }
    public double calCostans(CallRecord callRecord) {
        double sec = (callRecord.getEndTime().getTime() -callRecord.getStartTime().getTime())/ 1000;
        if (sec < 0) {
            return 0;
        }
        double minu = (int) sec / 60;
        if (sec % 60 != 0) {
            minu += 1;
        }
        //System.out.printf(minu+"\n");
        return  minu * 0.3;
    }
}
class MobilePhoneRoamInProvinceRule extends CallChargeRule{
    public double calCost(CallRecord callRecord) {
        double sec = (callRecord.getEndTime().getTime() -callRecord.getStartTime().getTime())/ 1000;
        if (sec < 0) {
            return 0;
        }
        double minu = (int) sec / 60;
        if (sec % 60 != 0) {
            minu += 1;
        }
        return  minu * 0.3;
    }
}
class UserRecords {
    ArrayList<CallRecord> callinglnCityRecords= new ArrayList<CallRecord>();
    ArrayList<CallRecord> callinglnProvinceRecords= new ArrayList<CallRecord>();
    ArrayList<CallRecord> callinglnLandRecords= new ArrayList<CallRecord>();
    ArrayList<CallRecord> callingroamlnProvinceRecords= new ArrayList<CallRecord>();
    ArrayList<CallRecord> callingroamlnLandRecords= new ArrayList<CallRecord>();
    ArrayList<CallRecord> answerlnCityRecords= new ArrayList<CallRecord>();
    ArrayList<CallRecord> answerlnProvinceRecords= new ArrayList<CallRecord>();
    ArrayList<CallRecord> answerlnLandRecords= new ArrayList<CallRecord>();
    ArrayList<CallRecord> answerroamlnProvinceRecords= new ArrayList<CallRecord>();
    ArrayList<CallRecord> answerroamlnLandRecords= new ArrayList<CallRecord>();
    ArrayList<MessageRecord> sendMessageRecords= new ArrayList<MessageRecord>();
    ArrayList<MessageRecord> receiveMessageRecords= new ArrayList<MessageRecord>();
    void addCallingInCityRecords(CallRecord callRecord){
        callinglnCityRecords.add(callRecord);
    }
    void addCallingInProvinceRecords(CallRecord callRecord){
        callinglnProvinceRecords.add(callRecord);
    }
    void addCallingInLandRecords(CallRecord callRecord){
        callinglnLandRecords.add(callRecord);
    }
    void addCallingRoamInProvinceRecords(CallRecord callRecord){
        callingroamlnProvinceRecords.add(callRecord);
    }
    void addCallingRoamInLandRecords(CallRecord callRecord){
        callingroamlnLandRecords.add(callRecord);
    }
    void addAnswerInCityRecords(CallRecord callRecord){
        answerlnCityRecords.add(callRecord);
    }
    void addAnswerInProvinceRecords(CallRecord callRecord){
        answerlnProvinceRecords.add(callRecord);
    }
    void addAnswerInLandRecords(CallRecord callRecord){
        answerlnLandRecords.add(callRecord);
    }
    void addAnswerRoamInProvinceRecords(CallRecord callRecord){
        answerroamlnProvinceRecords.add(callRecord);
    }
    void addAnswerRoamInLandRecords(CallRecord callRecord){
        answerroamlnLandRecords.add(callRecord);
    }
     void addSendMessageRecords(MessageRecord messageRecord){
        sendMessageRecords.add(messageRecord);
     }
    void addReceiveMessageRecords(MessageRecord messageRecord){
        receiveMessageRecords.add(messageRecord);
    }
    ArrayList<CallRecord> getCallingInCityRecords(){
        return  callinglnCityRecords;
    }
    ArrayList<CallRecord> getCallingInProvinceRecords(){
        return  callinglnProvinceRecords;
    }
    ArrayList<CallRecord> getCallingInLandRecords(){
        return  callinglnLandRecords;
    }
    ArrayList<CallRecord> getCallingroamlnProvinceRecords(){return callingroamlnProvinceRecords;}
    ArrayList<CallRecord> getCallingroamlnLandRecords(){return callingroamlnLandRecords;}
    ArrayList<CallRecord> getAnswerroamlnProvinceRecords(){return answerroamlnProvinceRecords;}
    ArrayList<CallRecord> getAnswerroamlnLandRecords(){return answerroamlnLandRecords;}

    ArrayList<CallRecord> getAnswerInCityRecords(){
        return  answerlnCityRecords;
    }
    ArrayList<CallRecord> getAnswerInProvinceRecords(){
        return  answerlnProvinceRecords;
    }
    ArrayList<CallRecord> getAnswerInLandRecords(){
        return  answerlnLandRecords;
    }
    ArrayList<MessageRecord> getSendMessageRecords(){
        return  sendMessageRecords;
    }
    ArrayList<MessageRecord> getReceiveMessageRecords(){
        return  receiveMessageRecords;
    }
}

class MobilePhoneInCityRule extends CallChargeRule{
    public double calCost(CallRecord callRecord) {
        double sec = (callRecord.getEndTime().getTime() -callRecord.getStartTime().getTime())/ 1000;
        if (sec < 0) {
            return 0;
        }
        double minu = (int) sec / 60;
        if (sec % 60 != 0) {
            minu += 1;
        }

        return  minu * 0.1;
    }

}
class User {
    UserRecords userRecords = new UserRecords();
    double balance =100;
    ChargeMode chargeMode;
    String number;
    int masnum;
    public User(){}
    public User(String number){
        masnum=0;
        this.number = number;
    }
    double calBalance(){
        return 100-calCost();
    }
    double  calCost(){

        if(masnum<=3)
            return 0.1*masnum;
        else if(masnum<=5)
            return 0.3+(masnum-3)*0.2;
        else
            return 0.7+(masnum-5)*0.3;
    }
    UserRecords getUserRecords(){
        return userRecords;
    }
    void  setUserRecords(UserRecords userRecords){
        this.userRecords=userRecords;
    }

    double getBalance(){
        return balance;
    }
    ChargeMode getChargeMode(){
        return chargeMode;
    }
    void  setChargeMode(ChargeMode chargeMode){
        this.chargeMode=chargeMode;
    }
    String getNumber(){
        return number;
    }
    void setNumber(String number){
        this.number =number;
    }
}


7-2 编写一个类Shop(商店)、内部类InnerCoupons(内部购物券)

编写一个类Shop(商店),该类中有一个成员内部类InnerCoupons(内部购物券),可以用于购买该商店的牛奶(假设每箱牛奶售价为50元)。要求如下:
(1)Shop类中有私有属性milkCount(牛奶的箱数,int类型)、公有的成员方法setMilkCount( )和getMilkCount( )分别用于设置和获取牛奶的箱数。
(2)成员内部类InnerCoupons,有公有属性value(面值,int类型),一个带参数的构造方法可以设定购物券的面值value,一个公有的成员方法buy( )要求输出使用了面值为多少的购物券进行支付,同时使商店牛奶的箱数减少value/50。
(3)Shop类中还有成员变量coupons50(面值为50元的内部购物券,类型为InnerCoupons)、coupons100(面值为100元的内部购物券,类型为InnerCoupons)。
(4)在Shop类的构造方法中,调用内部类InnerCoupons的带参数的构造方法分别创建上面的购物券coupons50、coupons100。


在测试类Main中,创建一个Shop类的对象myshop,从键盘输入一个整数(大于或等于3),将其设置为牛奶的箱数。假定有顾客分别使用了该商店面值为50的购物券、面值为100的购物券各消费一次,分别输出消费后商店剩下的牛奶箱数。

输入格式:

输入一个大于或等于3的整数。

输出格式:

使用了面值为50的购物券进行支付
牛奶还剩XX箱
使用了面值为100的购物券进行支付
牛奶还剩XX箱
import java.util.*;


//主函数
public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int num = sc.nextInt();
        Shop shop = new Shop();
        shop.num = num;
        shop.innerCoupons.setValue(50);
        shop.innerCoupons.buy();
        shop.innerCoupons.setValue(100);
        shop.innerCoupons.buy();
    }

}
class  Shop{
    int num;
    InnerCoupons innerCoupons;
    class InnerCoupons{
        int value;
        void setValue(int value){
            this.value=value;
        }
        void buy(){
            num -= value/50;
            System.out.printf("使用了面值为"+value+"的购物券进行支付" +
                    "\n" +
                    "牛奶还剩"+num+"箱\n");
        }
        
    }
    public Shop(){
        innerCoupons = new InnerCoupons();
    };
    




}

7-3 动物发声模拟器(多态)

设计一个动物发生模拟器,用于模拟不同动物的叫声。比如狮吼、虎啸、狗旺旺、猫喵喵……。
定义抽象类Animal,包含两个抽象方法:获取动物类别getAnimalClass()、动物叫shout();
然后基于抽象类Animal定义狗类Dog、猫类Cat和山羊Goat,用getAnimalClass()方法返回不同的动物类别(比如猫,狗,山羊),用shout()方法分别输出不同的叫声(比如喵喵、汪汪、咩咩)。
最后编写AnimalShoutTest类测试,输出:
猫的叫声:喵喵
狗的叫声:汪汪
山羊的叫声:咩咩

其中,在AnimalShoutTestMain类中,用speak(Animal animal){}方法输出动物animal的叫声,在main()方法中调用speak()方法,分别输出猫、狗和山羊对象的叫声。

请在下面的【】处添加代码。
class Main {
    public static void main(String[] args) {
        Animal cat = new Cat();
        Animal dog = new Dog();
        Animal goat = new Goat();
        speak(cat);
        speak(dog);
        speak(goat);
    }
    //定义静态方法speak()
    static void  speak(Animal animal){
        animal.getSpeak();
    }

}
abstract class Animal{
    abstract void getSpeak();
}

//定义抽象类Animal
class Cat extends Animal{
    String speak ;
    public Cat(){speak="喵喵";}
    void getSpeak(){
        System.out.printf("猫的叫声:"+speak+"\n");
    }
}
//基于Animal类,定义狗类Dog,并重写两个抽象方法
class Dog extends Animal{
    String speak ;
    public Dog(){speak="汪汪";}
    void getSpeak(){
        System.out.printf("狗的叫声:"+speak+"\n");
    }
        }
//基于Animal类,定义山羊类Goat,并重写两个抽象方法
class Goat extends Animal{
    String speak;
    public Goat(){
        speak="咩咩";
    }
    void getSpeak(){
        System.out.printf("山羊的叫声:"+speak+"\n");
    }


}

posted on 2022-12-10 19:22  大皮QAQ  阅读(100)  评论(0编辑  收藏  举报

导航

回到顶部叭QAQ