nchu-software-oop-2022-6
實現一個簡單的電信計費程式：
假設南昌市電信分公司針對市內座機使用者採用的計費方式：
月租20元，接電話免費，市內撥打電話0.1元/分鐘，省內長途0.3元/分鐘，國內長途撥打0.6元/分鐘。不足一分鐘按一分鐘計。
南昌市的區號：0791，江西省內各地市區號包括：0790~0799以及0701。
輸入格式:
輸入資訊包括兩種型別
1、逐行輸入南昌市使用者開戶的資訊，每行一個使用者，
格式：u-號碼 計費型別 （計費型別包括：0-座機 1-手機實時計費 2-手機A套餐）
例如：u-079186300001 0
座機號碼除區號外由是7-8位數字組成。
本題只考慮計費型別0-座機計費，電信系列2、3題會逐步增加計費型別。
2、逐行輸入本月某些使用者的通訊資訊，通訊資訊格式：
座機呼叫座機：t-主叫號碼 接聽號碼 起始時間 結束時間
t-079186330022 058686330022 2022.1.3 10:00:25 2022.1.3 10:05:11
以上四項內容之間以一個英文空格分隔，
時間必須符合"yyyy.MM.dd HH:mm:ss"格式。提示：使用SimpleDateFormat類。
以上兩類資訊，先輸入所有開戶資訊，再輸入所有通訊資訊，最後一行以“end”
注意：
本題非法輸入只做格式非法的判斷，不做內容是否合理的判斷（時間除外，否則無法計算），比如：
1、輸入的所有通訊資訊均認為是同一個月的通訊資訊，不做日期是否在同一個月還是多個月的判定，直接將通訊費用累加，因此月租只計算一次。
2、記錄中如果同一電話號碼的多條通話記錄時間出現重合，這種情況也不做判斷，直接 計算每條記錄的費用並累加。
3、使用者區號不為南昌市的區號也作為正常使用者處理。
輸出格式:
根據輸入的詳細通訊資訊，計算所有已開戶的使用者的當月費用（精確到小數點後2位，
單位元）。假設每個使用者初始餘額是100元。
每條通訊資訊單獨計費後累加，不是將所有時間累計後統一計費。
格式：號碼+英文空格符+總的話費+英文空格符+餘額
每個使用者一行，使用者之間按號碼字元從小到大排序。
錯誤處理：
輸入資料中出現的不符合格式要求的行一律忽略。
建議類圖：
參見圖1、2、3，可根據理解自行調整：
圖1中User是使用者類，包括屬性： userRecords （使用者記錄）、balance（餘額）、chargeMode（計費方式）、number（號碼）。 ChargeMode是計費方式的抽象類： chargeRules是計費方式所包含的各種計費規則的集合，ChargeRule類的定義見圖3。 getMonthlyRent（）方法用於返回月租（monthlyRent）。 UserRecords是使用者記錄類，儲存使用者各種通話、簡訊的記錄， 各種計費規則將使用其中的部分或者全部記錄。 其屬性從上到下依次是： 市內撥打電話、省內（不含市內）撥打電話、省外撥打電話、 市內接聽電話、省內（不含市內）接聽電話、省外接聽電話的記錄 以及傳送簡訊、接收簡訊的記錄。
圖2中CommunicationRecord是抽象的通訊記錄類： 包含callingNumber撥打號碼、answerNumber接聽號碼兩個屬性。 CallRecord（通話記錄）、MessageRecord（簡訊記錄）是它的子類。 CallRecord（通話記錄類）包含屬性： 通話的起始、結束時間以及 撥號地點的區號（callingAddressAreaCode）、接聽地點的區號（answerAddressAreaCode）。 區號用於記錄在哪個地點撥打和接聽的電話。座機無法移動，就是本機區號，如果是手機號，則會有差異。
圖3是計費規則的相關類，這些類的核心方法是： calCost（ArrayList<CallRecord> callRecords）。 該方法針根據輸入引數callRecords中的所有記錄計算某使用者的某一項費用；如市話費。 輸入引數callRecords的約束條件：必須是某一個使用者的符合計費規則要求的所有記錄。 LandPhoneInCityRule、LandPhoneInProvinceRule、LandPhoneInLandRule三個類分別是 座機撥打市內、省內、省外電話的計費規則類，用於實現這三種情況的費用計算。 （提示：可以從UserRecords類中獲取各種型別的callRecords）。
後續擴充套件說明：
後續題目集將增加手機使用者，手機使用者的計費方式中除了與座機計費類似的主叫通話費之外，還包含市外接聽電話的漫遊費以及發簡訊的費用。在本題的設計時可統一考慮。
通話記錄中，手機需要額外記錄撥打/接聽的地點的區號，比如：
座機打手機：t-主叫號碼 接聽號碼 接聽地點區號 起始時間 結束時間
t-079186330022 13305862264 020 2022.1.3 10:00:25 2022.1.3 10:05:11
手機互打：t-主叫號碼 撥號地點 接聽號碼 接聽地點區號 起始時間 結束時間
t-18907910010 0791 13305862264 0371 2022.1.3 10:00:25 2022.1.3 10:05:11
簡訊的格式：m-主叫號碼，接收號碼，簡訊內容
m-18907910010 13305862264 welcome to jiangxi
m-13305862264 18907910010 thank you
輸入樣例:
在這裡給出一組輸入。例如：
u-079186300001 0
t-079186300001 058686330022 2022.1.3 10:00:25 2022.1.3 10:05:25
end輸出樣例:
在這裡給出相應的輸出。例如：
079186300001 3.0 77.0其餘參考樣例詳見附件，未盡事宜以附件樣例為準：
https://images.ptausercontent.com/d3c5de10-9e3f-4a4c-877f-64e76c98f1b6.pdf
分析：
電信計費系列相較於多邊形系列簡單了很多，類圖已經給出，只需要按照類圖去實現功能即可。可能電信計費中稍微難一點的可能就是判斷輸入的格式的正則表示式，我一開始寫的時候正則表示式也出了一些錯，有些點無法過，所以我改用了一種簡單粗暴的方式去判斷，那就是將每種情況都在正則表示式中羅列出來。開戶的正則表示式就非常的簡單清晰，為"^u-[0-9]{11,12} 0$"，為什麼是11-12，有人可能有疑問，因為區號不一定都是4位的，還存在3位的區號。通訊資訊的正則表示式為"^t-[0]{1}[0-9]{9,11} [0]{1}[0-9]{9,11} [0-9]{4}[.](([1-9]{1})|([1]{1}[0-2]{1}))[.]([1-9]|([1-2]{1}[0-9]{1})|(3[0-1])) (([0-1][0-9])|(2[0-3]))[:]([0-5][0-9])[:]([0-5][0-9]) [0-9]{4}[.](([1-9]{1})|([1]{1}[0-2]{1}))[.]([1-9]|([1-2]{1}[0-9]{1})|3[0-1]) (([0-1][0-9])|(2[0-3]))[:]([0-5][0-9])[:]([0-5][0-9])$"，看著很長，實際上就是每種情況的羅列判定，像後面時間的格式都是固定的。兩個正則表示式實現其餘就很簡單了，開戶需要注意的是需要去重，而在接收通訊資訊只需要如果接收的結果不為end就迴圈input.nextLine()接收，將每個通訊記錄的撥號資訊放入撥號使用者，收號資訊放入收號使用者，計費時只需要對每個使用者的撥號資訊和收號資訊注意計費即可。電信計費最後實現出來程式碼看上去很長，實際上由很多都是get和set語句，真正要實現的核心內容並不多。座機互打，很簡單的，輸出需要注意排序。各類程式碼如下：
Main類
public class Main {
public static void main(String[] args) throws ParseException {
ArrayList<User> user=new ArrayList<>();
SimpleDateFormat sdf=new SimpleDateFormat( "yyyy.MM.dd HH:mm:ss" );
Scanner input=new Scanner(System.in);
String ss1="^u-[0-9]{11,12} 0$";
String ss2="^t-[0]{1}[0-9]{9,11} [0]{1}[0-9]{9,11} [0-9]{4}[.](([1-9]{1})|([1]{1}[0-2]{1}))[.]([1-9]|([1-2]{1}[0-9]{1})|(3[0-1])) (([0-1][0-9])|(2[0-3]))[:]([0-5][0-9])[:]([0-5][0-9]) [0-9]{4}[.](([1-9]{1})|([1]{1}[0-2]{1}))[.]([1-9]|([1-2]{1}[0-9]{1})|3[0-1]) (([0-1][0-9])|(2[0-3]))[:]([0-5][0-9])[:]([0-5][0-9])$";
String s1=input.nextLine();
String[] s01=s1.split(" ");
while(!s01[0].equals("end")){
if(!s1.matches(ss1)&&!s1.matches(ss2)){
s1=input.nextLine();
s01=s1.split(" ");
continue;
}
switch (s01[0].charAt(0)){
case 'u': {
boolean creat=true;
User u=new User();
u.setNumber(s01[0].substring(2));
u.setUserRecords(new UserRecords());
switch (s01[1]){
case "0":
u.setChargeMode(new LandlinePhoneCharging());
break;
case "1":
break;
case "2":
break;
}
for(int i=0;i< user.size();i++){
if(user.get(i).getNumber().equals(u.getNumber())){
creat=false;
}
}
if(creat!=false)
user.add(u);
break;
}
case 't':{
String s0=s01[0].substring(2);
for(int i=0;i< user.size();i++){
if(s0.equals(user.get(i).getNumber())){
if(s0.startsWith("0791")&&s01[1].startsWith("0791")){
CallRecord c=new CallRecord();
c.setStartTime(sdf.parse(s01[2]+" "+s01[3]));
c.setEndTime(sdf.parse(s01[4]+" "+s01[5]));
c.setCallingAddressAreaCode(s0.substring(0,4));
user.get(i).getUserRecords().addCallinglnCityRecords(c);
for(int j=0;j<user.size();j++){
if(s01[1].equals(user.get(j).getNumber())){
CallRecord c2=new CallRecord();
c2.setStartTime(sdf.parse(s01[2]+" "+s01[3]));
c2.setEndTime(sdf.parse(s01[4]+" "+s01[5]));
c2.setAnswerAddressAreaCode(s01[1]);
user.get(j).getUserRecords().addAnswerlnCityRecords(c2);
}
}
}
else if(s0.substring(0,4).matches("(079\\d)|(0701)")&&s01[1].substring(0,4).matches("(079\\d)|(0701)")){
CallRecord c=new CallRecord();
c.setStartTime(sdf.parse(s01[2]+" "+s01[3]));
c.setEndTime(sdf.parse(s01[4]+" "+s01[5]));
c.setCallingAddressAreaCode(s0.substring(0,4));
user.get(i).getUserRecords().addCallinglnProvinceRecords(c);
for(int j=0;j<user.size();j++){
if(s01[1].equals(user.get(j).getNumber())){
CallRecord c2=new CallRecord();
c2.setStartTime(sdf.parse(s01[2]+" "+s01[3]));
c2.setEndTime(sdf.parse(s01[4]+" "+s01[5]));
c2.setAnswerAddressAreaCode(s01[1]);
user.get(j).getUserRecords().addAnswerlnProvinceRecords(c2);
}
}
}
else{
CallRecord c=new CallRecord();
c.setStartTime(sdf.parse(s01[2]+" "+s01[3]));
c.setEndTime(sdf.parse(s01[4]+" "+s01[5]));
c.setCallingAddressAreaCode(s0.substring(0,4));
user.get(i).getUserRecords().addCallinglnLandRecords(c);
for(int j=0;j<user.size();j++){
if(s01[1].equals(user.get(j).getNumber())){
CallRecord c2=new CallRecord();
c2.setStartTime(sdf.parse(s01[2]+" "+s01[3]));
c2.setEndTime(sdf.parse(s01[4]+" "+s01[5]));
c2.setAnswerAddressAreaCode(s01[1]);
user.get(j).getUserRecords().addAnswerlnLandRecords(c2);
}
}
break;
}
}
}
}
}
s1=input.nextLine();
s01=s1.split(" ");
}
sort s=new sort();
s.Sort(user);
for(int i=0;i< user.size();i++){
System.out.println(user.get(i).getNumber()+" "+(float)user.get(i).calCost()+" "+(float)(user.get(i).getBalance()-user.get(i).calCost()-user.get(i).getChargeMode().getMonthlyRent()));
}
}
}CommunicationRecord類
abstract class CommunicationRecord{
private String callingNumber;
private String answerNumber;
String getCallingNumber(){
return this.callingNumber;
}
void setCallingNumber(String callingNumber){
this.callingNumber=callingNumber;
}
String getAnswerNumber(){
return this.answerNumber;
}
void setAnswerNumber(String answerNumber){
this.answerNumber=answerNumber;
}
}CallRecord類
class CallRecord extends CommunicationRecord{
private Date startTime;
private Date endTime;
private String callingAddressAreaCode;
private String answerAddressAreaCode;
public Date getStartTime() {
return startTime;
}
public void setStartTime(Date startTime) {
this.startTime = startTime;
}
public Date getEndTime() {
return endTime;
}
public void setEndTime(Date endTime) {
this.endTime = endTime;
}
public String getCallingAddressAreaCode() {
return callingAddressAreaCode;
}
public void setCallingAddressAreaCode(String callingAddressAreaCode) {
this.callingAddressAreaCode = callingAddressAreaCode;
}
public String getAnswerAddressAreaCode() {
return answerAddressAreaCode;
}
public void setAnswerAddressAreaCode(String answerAddressAreaCode) {
this.answerAddressAreaCode = answerAddressAreaCode;
}
}MessageRecord類
class MessageRecord{
private String message;
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
}ChargeRule類
abstract class ChargeRule{
}存在空類很正常，方便以後維護加東西，開始框架搭好，後面填充也更加簡單，不需要大改。
CallChargeRule類
abstract class CallChargeRule extends ChargeRule{
abstract double calCost(ArrayList<CallRecord> callRecords);
}LandPhonelnCityRule類
class LandPhonelnCityRule extends CallChargeRule{
double calCost(ArrayList<CallRecord> callRecords){
double sum=0;
for(int i=0;i<callRecords.size();i++){
long t1=callRecords.get(i).getStartTime().getTime();
long t2=callRecords.get(i).getEndTime().getTime();
if((t2-t1)%60000!=0)
sum+=0.1*((t2-t1)/60000+1);
else
sum+=0.1*((t2-t1)/60000);
}
return sum;
}
}LandPhonelnlandRule類
class LandPhonelnlandRule extends CallChargeRule{
double calCost(ArrayList<CallRecord> callRecords){
double sum=0;
for(int i=0;i<callRecords.size();i++){
long t1=callRecords.get(i).getStartTime().getTime();
long t2=callRecords.get(i).getEndTime().getTime();
if((t2-t1)%60000!=0)
sum+=0.6*((t2-t1)/60000+1);
else
sum+=0.6*((t2-t1)/60000);
}
return sum;
}
}LandPhonelnProvinceRule類
class LandPhonelnProvinceRule extends CallChargeRule{
double calCost(ArrayList<CallRecord> callRecords){
double sum=0;
for(int i=0;i<callRecords.size();i++){
long t1=callRecords.get(i).getStartTime().getTime();
long t2=callRecords.get(i).getEndTime().getTime();
if((t2-t1)%60000!=0)
sum+=0.3*((t2-t1)/60000+1);
else
sum+=0.3*((t2-t1)/60000);
}
return sum;
}
}ChargeMode類
abstract class ChargeMode{
private ArrayList<ChargeRule> chargeRules=new ArrayList<ChargeRule>();
public ArrayList<ChargeRule> getChargeRules() {
return chargeRules;
}
public void setChargeRules(ArrayList<ChargeRule> chargeRules) {
this.chargeRules = chargeRules;
}
public abstract double calCost(UserRecords userRecords);
public abstract double getMonthlyRent();
}LandlinePhoneCharging類
class LandlinePhoneCharging extends ChargeMode{
private double monthlyRent=20;
LandlinePhoneCharging(){
super();
getChargeRules().add(new LandPhonelnCityRule());
getChargeRules().add(new LandPhonelnProvinceRule());
getChargeRules().add(new LandPhonelnlandRule());
}
public double calCost(UserRecords userRecords){
double sum=0;
sum+=((LandPhonelnCityRule)getChargeRules().get(0)).calCost(userRecords.getCallinglnCityRecords());
sum+=((LandPhonelnProvinceRule)getChargeRules().get(1)).calCost(userRecords.getCallinglnProvinceRecords());
sum+=((LandPhonelnlandRule)getChargeRules().get(2)).calCost(userRecords.getCallinglnLandRecords());
return sum;
}
public double getMonthlyRent() {
return monthlyRent;
}
}UserRecords類
class UserRecords{
private ArrayList<CallRecord> callinglnCityRecords=new ArrayList<CallRecord>();
private ArrayList<CallRecord> callinglnProvinceRecords=new ArrayList<CallRecord>();
private ArrayList<CallRecord> callinglnLandRecords=new ArrayList<CallRecord>();
private ArrayList<CallRecord> answerlnCityRecords=new ArrayList<CallRecord>();
private ArrayList<CallRecord> answerlnProvinceRecords=new ArrayList<CallRecord>();
private ArrayList<CallRecord> answerlnLandRecords=new ArrayList<CallRecord>();
private ArrayList<MessageRecord> sendMessageRecords=new ArrayList<MessageRecord>();
private ArrayList<MessageRecord> receiveMessageRecords=new ArrayList<MessageRecord>();
void addCallinglnCityRecords(CallRecord callRecord){
callinglnCityRecords.add(callRecord);
}
void addCallinglnProvinceRecords(CallRecord callRecord){
callinglnProvinceRecords.add(callRecord);
}
void addCallinglnLandRecords(CallRecord callRecord){
callinglnLandRecords.add(callRecord);
}
void addAnswerlnCityRecords(CallRecord callRecord){
answerlnCityRecords.add(callRecord);
}
void addAnswerlnProvinceRecords(CallRecord callRecord){
answerlnProvinceRecords.add(callRecord);
}
void addAnswerlnLandRecords(CallRecord callRecord){
answerlnLandRecords.add(callRecord);
}
void SendMessageRecords(MessageRecord sendMessageRecord){
}
void ReceiveMessageRecords(MessageRecord receiveMessageRecord){
}
public ArrayList<MessageRecord> getSendMessageRecords() {
return sendMessageRecords;
}
public ArrayList<MessageRecord> getReceiveMessageRecords() {
return receiveMessageRecords;
}
public ArrayList<CallRecord> getCallinglnCityRecords() {
return callinglnCityRecords;
}
public ArrayList<CallRecord> getCallinglnLandRecords() {
return callinglnLandRecords;
}
public ArrayList<CallRecord> getCallinglnProvinceRecords() {
return callinglnProvinceRecords;
}
public ArrayList<CallRecord> getAnswerlnCityRecords() {
return answerlnCityRecords;
}
public ArrayList<CallRecord> getAnswerlnLandRecords() {
return answerlnLandRecords;
}
public ArrayList<CallRecord> getAnswerlnProvinceRecords() {
return answerlnProvinceRecords;
}
}User類
class User {
private UserRecords userRecords = new UserRecords();
private double balance = 100;
private ChargeMode chargeMode;
String number;
double calBalance() {
return getBalance()-calCost();
}
double calCost() {
return chargeMode.calCost(userRecords) ;
}
public UserRecords getUserRecords() {
return userRecords;
}
public void setUserRecords(UserRecords userRecords) {
this.userRecords = userRecords;
}
public double getBalance() {
return balance;
}
public ChargeMode getChargeMode() {
return chargeMode;
}
public void setChargeMode(ChargeMode chargeMode) {
this.chargeMode = chargeMode;
}
public String getNumber() {
return number;
}
public void setNumber(String number) {
this.number = number;
}
}sort類
class sort{
void Sort(ArrayList<User> users){
for(int i=0;i<users.size()-1;i++){
for(int j=i+1;j<users.size();j++){
if(Long.parseLong(users.get(i).getNumber())>Long.parseLong(users.get(j).getNumber())){
User temp=users.get(i);
users.set(i,users.get(j));
users.set(j,temp);
}
}
}
}
}這題思路在上述分析中，這題簡單，按照類圖實現即可，連坑都沒幾個。
電信計費1-3都實現後類圖如下：
SourceMonitor生成報表如下：
說明程式碼量大，但是實際複雜度並不大。
7-2 多型測試 分數 20 作者 董衛萍 單位 紹興文理學院元培學院定義容器Container介面。模擬實現一個容器類層次結構，並進行介面的實現、抽象方法重寫和多型機制測試。各容器類實現求表面積、體積的方法。
- 定義介面Container：
屬性：
public static final double pi=3.1415926;
抽象方法:
public abstract double area();
public abstract double volume();
static double sumofArea(Container c[]);
static double sumofVolume(Container c[]);
其中兩個靜態方法分別計算返回容器陣列中所有物件的面積之和、周長之和； - 定義Cube類、Cylinder類均實現自Container介面。
Cube類(屬性：邊長double型別)、Cylinder類(屬性：底圓半徑、高，double型別)。
輸入格式:
第一行n表示物件個數，物件型別用cube、cylinder區分，cube表示立方體物件，後面輸入邊長，輸入cylinder表示圓柱體物件，後面是底圓半徑、高。
輸出格式:
分別輸出所有容器物件的表面積之和、體積之和，結果保留小數點後2位。
輸入樣例:
在這裡給出一組輸入。例如：
4
cube
15.7
cylinder
23.5 100
cube
46.8
cylinder
17.5 200輸出樣例:
在這裡給出相應的輸出。例如：
56771.13
472290.12純純的送分題，沒什麼分析的，寫blog的時候發現當時寫的時候，看錯了，沒使用介面，使用介面也差不多難度吧。程式碼如下：
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
int n=input.nextInt();
Container[] Containers=new Container[n];
for(int i=0;i<n;i++){
input.nextLine();
String type=input.nextLine();
if(type.equals("cube")){
double x=input.nextDouble();
Containers[i]=new Cube(x);
}
else if(type.equals("cylinder")){
double x=input.nextDouble();
double y=input.nextDouble();
Containers[i]=new cylinder(x,y);
}
}
System.out.printf("%.2f\n",Container.sumofArea(Containers));
System.out.printf("%.2f\n",Container.sumofVolume(Containers));
}
}
abstract class Container{
public static final double pi=3.1415926;
public abstract double area();
public abstract double volume();
static double sumofArea(Container c[]){
double sumArea=0;
for(int i=0;i<c.length;i++){
sumArea+=c[i].area();
}
return sumArea;
}
static double sumofVolume(Container c[]) {
double sumVolume=0;
for(int i=0;i<c.length;i++)
sumVolume+=c[i].volume();
return sumVolume;
}
}
class Cube extends Container{
double length;
Cube(double x){
this.length=x;
}
public double area(){
return 6*length*length;
}
public double volume(){
return length*length*length;
}
}
class cylinder extends Container{
double radius,hight;
cylinder(double x,double y){
this.radius=x;
this.hight=y;
}
public double area(){
return 2*pi*radius*radius+2*pi*radius*hight;
}
public double volume(){
return pi*radius*radius*hight;
}
}感謝觀看！！！