12-15周Java总结

前言

经历了期中考试的洗礼，我对于Java面向对象设计也有了进一步的了解。这几周主要完成了移动业务资费问题的pta任务，三次作业循序渐进，逐层深入，主要为了提升我们对类的深刻理解和准确运用，同时还考察了我们对于格式判断问题的处理，其中包括时间格式和号码格式，这两个是比较难的地方，特别是格式问题，涉及到许多细节，需要我们抽丝剥茧深入思考才能考虑到每一个点。总体的题量并不大，每次只有两三道题，但移动业务资费问题对于我们来说也是有些困难的。

PTA

PTA上面的题目主要有两种类型，一部分是一些基础类问题，主要涉及了接口、多态等基础语法问题，让我们对于基础知识的运用更加熟练；另一部分是一些实验类的题目，这几周涉及到的就是移动业务资费问题，让我们对Java的特点有更深刻的了解，让我们的代码逐渐规范，同时能够锻炼我们的思维能力以及对于题目的理解能力。

题目集9

这次作业有两道题，一主一副。

第一题

实现一个简单的电信计费程序：
假设南昌市电信分公司针对市内座机用户采用的计费方式：
月租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
图1中User是用户类，包括属性：
userRecords （用户记录）、balance（余额）、chargeMode（计费方式）、number（号码）。

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

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

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

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

                                        图3
图3是计费规则的相关类，这些类的核心方法是：
calCost（ArrayList<CallRecord> callRecords）。
该方法针根据输入参数callRecords中的所有记录计算某用户的某一项费用；如市话费。
输入参数callRecords的约束条件：必须是某一个用户的符合计费规则要求的所有记录。

LandPhoneInCityRule、LandPhoneInProvinceRule、LandPhoneInLandRule三个类分别是
座机拨打市内、省内、省外电话的计费规则类，用于实现这三种情况的费用计算。    
（提示：可以从UserRecords类中获取各种类型的callRecords）。

类图如下

这是第一次的移动业务资费问题，计算方面并不困难，主要的难点是需要理解各个类之间的关系，其次就是格式判断，不同情况需要有不同的判断格式。

第二题

定义容器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位。

类图如下：

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int num = in.nextInt();
        Container[] c = new Container[num];
        for(int i = 0;i < num;i++) {
            String name = in.next();
            if(name.equals("cube")) {
                double side = in.nextDouble();
                c[i] = new Cube(side);
            }else {
                double radius = in.nextDouble();
                double height = in.nextDouble();
                c[i] = new Cylinder(radius,height);
            }
        }
        System.out.printf("%.2f\n",Container.sumofArea(c));
        System.out.printf("%.2f",Container.sumofVolume(c));
    }

}

interface Container{
    public static final double pi = 3.1415926;
    public abstract double area();
    public abstract double volume();
    static double sumofArea(Container c[]) {
        double area = 0;
        for(int i = 0;i < c.length;i++) {
            area += c[i].area();
        }
        return area;
    }
    static double sumofVolume(Container c[]) {
        double valume = 0;
        for(int i = 0;i < c.length;i++) {
            valume += c[i].volume();
        }
        return valume;
    }
}

class Cube implements Container{
    private double side;


    public Cube(double side) {
        super();
        this.side = side;
    }

    @Override
    public double area() {
        double area = side * side * 6;
        return area;
    }

    @Override
    public double volume() {
        double volume = side * side * side;
        return volume;
    }
    
}

class Cylinder implements Container{
    private double radius;
    private double height;
    
    public Cylinder(double radius, double height) {
        super();
        this.radius = radius;
        this.height = height;
    }

    @Override
    public double area() {
        double area = 2 * pi * radius * height + pi * radius * radius * 2;
        return area;
    }

    @Override
    public double volume() {
        double volume = pi * radius * radius * height;
        return volume;
    }
    
}

题目集10

这次作业有三道题，第一题同样是移动业务资费问题，后面两题涉及到了容器、迭代器、集合对象。

第一题类图如下：

相比第一次增加了针对手机用户采用实时计费方式：

月租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

因此类图看起来要比第一次的复杂好多，但总体来说都是大同小异，这种时候继承和多态就起了非常重要的作用。

第二题

经过不懈的努力，C~K终于当上了班主任。

现在他要统计班里学生的名单，但是C~K在教务系统中导出班级名单时出了问题，发现会有同学的信息重复，现在他想把重复的同学信息删掉，只保留一个，
但是工作量太大了，所以找到了会编程的你，你能帮他解决这个问题吗？

输入格式:

第一行输入一个N，代表C~K导出的名单共有N行（N<100000）.

接下来的N行，每一行包括一个同学的信息，学号姓名年龄性别。

输出格式:

第一行输出一个n，代表删除重复名字后C~K的班级共有几人。

接下来的n行，输出每一个同学的信息，输出按照学号从小到大的顺序。

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);
        int num = in.nextInt();
        String s = in.nextLine();
        ArrayList<Student> arr = new ArrayList<Student>();
        for(int i = 0;i < num;i++) {
            s = in.nextLine();
            String[] imfor = s.split(" ");
            Student stu = new Student(imfor[0],imfor[1],imfor[2],imfor[3]);
            boolean flag = true;
            for(int j = 0;j < arr.size();j++) {
                if(stu.getNumber().equals(arr.get(j).getNumber())) {
                    flag = false;
                    break;
                }
            }
            if(flag) {
                arr.add(stu);
            }
            
        }
        Collections.sort(arr);
        System.out.println(arr.size());
        for(int i = 0;i < arr.size();i++) {
            System.out.println(arr.get(i).toString());
        }
    }

}

class Student implements Comparable<Student>{
    private String number;
    private String name;
    private int age;
    private String gender;
    
    public Student(String number, String name, String age, String gender) {
        super();
        this.number = number;
        this.name = name;
        this.age = Integer.valueOf(age);
        this.gender = gender;
    }

    public String getNumber() {
        return number;
    }

    public void setNumber(String number) {
        this.number = number;
    }

    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 String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }
    
    public String toString() {
        return number + " " + name + " " + age + " " + gender;
    }

    @Override
    public int compareTo(Student o) {
        return Integer.valueOf(this.number) - Integer.valueOf(o.number);
    }
    
}

View Code

第三题

 1 import java.util.ArrayList;
 2 import java.util.Collection;
 3 import java.util.Iterator;
 4 import java.util.Scanner;
 5 
 6 //1、导入相关包
 7 
 8 //定义员工类
 9 class Employee {
10 
11     private String name;
12     private int age;
13 
14     public Employee() {
15         super();
16     }
17 
18     public Employee(String name, int age) {
19         super();
20         this.name = name;
21         this.age = age;
22     }
23 
24     public String getName() {
25         return name;
26     }
27 
28     public void setName(String name) {
29         this.name = name;
30     }
31 
32     public int getAge() {
33         return age;
34     }
35 
36     public void setAge(int age) {
37         this.age = age;
38     }
39 }
40 
41 //主函数
42 public class Main {
43 
44     public static void main(String[] args) {
45     // 1、创建有序集合对象
46         Collection c = new ArrayList();
47         Scanner sc = new Scanner(System.in);
48    // 创建3个员工元素对象
49         for (int i = 0; i < 3; i++) {
50             
51             String employeeName = sc.next();
52             int employeeAge = sc.nextInt();
53             
54             Employee employee = new Employee(employeeName, employeeAge);
55             c.add(employee);
56         }            
57         // 2、创建迭代器遍历集合
58         Iterator<Employee> it = c.iterator();
59                 
60         //3、遍历
61         while (it.hasNext()) {
62             //4、集合中对象未知，向下转型
63             Employee e =  it.next();                
64             //System.out.println(e.getName() + "---" + e.getAge());
65         }
66     }
67 
68 }

View Code

题目集11

这次题目集也有三道题，第一题同样是移动业务资费问题，只是这次不再是打电话，而是发短信的资费问题。后两题是相对来说比较简单的题目，又涉及到多态问题，基本都一次通过测试点。

第一题类图

相较于通话来说，短信计费就稍微简单一些，通话计费涉及到的时间问题在短信这里就不需要着重判断了，并且这项业务只有手机和手机之间可以进行，这样就大大降低了格式判断问题的难度。

第二题

import java.util.Scanner;

public class Main {
  public static void main(String[] args) {        
       Scanner in = new Scanner(System.in);
       Shop shop = new Shop();
       shop.setMilkCount(in.nextInt());
       shop.coupons50.buy();
       shop.setMilkCount(shop.getMilkCount()-1);
       System.out.println("牛奶还剩" + shop.getMilkCount() + "箱");
       shop.coupons100.buy();
       shop.setMilkCount(shop.getMilkCount()-2);
       System.out.println("牛奶还剩" + shop.getMilkCount() + "箱");
  }
}

class Shop{
    private int milkCount;
    public InnerCoupons coupons50;
    public InnerCoupons coupons100;
    public Shop() {
        coupons50 = new InnerCoupons(50);
        coupons100 = new InnerCoupons(100);
    }
    public int getMilkCount() {
        return milkCount;
    }
    public void setMilkCount(int milkCount) {
        this.milkCount = milkCount;
    }
    
}

class InnerCoupons{
    public int value;

    public InnerCoupons(int value) {
        super();
        this.value = value;
    }
    
    public void buy() {
        System.out.println("使用了面值为" + value + "的购物券进行支付");
    }
}

View Code

第三题

//动物发生模拟器.  请在下面的【】处添加代码。
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()
  public static void speak(Animal animal){
      System.out.println(animal.getAnimalClass() + "的叫声：" + animal.shout());
  }

}

//定义抽象类Animal
abstract class Animal{
  private String name;
  private String shout;
  
  public Animal(String name, String shout) {
    super();
    this.name = name;
    this.shout = shout;
}
  
  public String getName() {
    return name;
  }

  public void setName(String name) {
    this.name = name;
  }

  public String getShout() {
    return shout;
  }

  public void setShout(String shout) {
    this.shout = shout;
  }

  abstract public String getAnimalClass();
  abstract public String shout();
}
//基于Animal类，定义猫类Cat，并重写两个抽象方法
class Cat extends Animal{
    public Cat() {
        super("猫","喵喵");
        // TODO Auto-generated constructor stub
    }

    @Override
    public String getAnimalClass() {
        return super.getName();
    }

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

    @Override
    public String getAnimalClass() {
        return super.getName();
    }

    @Override
    public String shout() {
        // TODO Auto-generated method stub
        return super.getShout();
    }
}
//基于Animal类，定义山羊类Goat，并重写两个抽象方法
class Goat extends Animal{
    public Goat() {
        super("山羊","咩咩");
        // TODO Auto-generated constructor stub
    }

    @Override
    public String getAnimalClass() {
        return super.getName();
    }

    @Override
    public String shout() {
        // TODO Auto-generated method stub
        return super.getShout();
    }
}

View Code

总结

这几周的学习主要是关于移动业务资费问题，不知不觉也到了期末，这一阶段的Java学习也将告一段落，但是我所学到的东西完全不够，这仅仅是皮毛，需要我之后的持续性学习，才能更加深入理解面向对象设计。

posted @ 2022-06-15 18:10 ~9y2 阅读(60) 评论(0) 收藏举报

刷新页面返回顶部

~9y2

12-15周Java总结

前言

PTA

题目集9

输入格式:

输出格式:

输入格式:

输出格式:

题目集10

第二题

输入格式:

输出格式:

第三题

题目集11

总结

公告