PTA题目集7~9总结

PTA题目集7~9总结

（1）前言：

一、题目集7：

　知识点：

• 继承、多态的应用；

• ArrayList泛型的应用方法

• Comparable接口及泛型的应用　

• 单一职责原则的应用

• “开-闭”原则的应用

　题量：2道

　难度：四颗星

二、题目集8：

　　知识点：

• 类的合理设计

• ArrayList泛型的应用方法

• 抽象类的应用方法

• 继承与多态的应用

　　题量：1道

　　难度：五颗星

三、题目集9：

　　知识点：

• 继承与多态的应用

• 类的合理设计

• ArrayList泛型的应用方法

• 抽象类的应用　　

　　题量：1道

　　难度：五颗星

（2）设计与分析：

　　　 ①题目集7（7-1）、（7-2）两道题目的递进式设计分析总结：

　　　　题目要求：

　　　　7-1题目： 图形卡片排序游戏（详见作业指导书 2020-OO第07次作业-1指导书V1.0.pdf）

　　　　7-2题目：图形卡片分组游戏 （详见作业指导书2021-OO第07次作业-2指导书V1.0.pdf）

　　　　题目一所编写代码如下：

import java.util.ArrayList;
import java.util.Iterator;
import java.util.Scanner;
import java.util.TreeSet;

public class Main {
    public static Scanner input = new Scanner(System.in);
    public static void main(String[] args){
        ArrayList<Integer> list = new ArrayList<Integer>();
        int num = input.nextInt();
        while(num != 0){
            if(num < 0 || num > 4){
                System.out.println("Wrong Format");
                System.exit(0);
            }
            list.add(num);
            num = input.nextInt();
        }
        DealCardList dealCardList = new DealCardList(list);
        if(!dealCardList.validate()){
            System.out.println("Wrong Format");
            System.exit(0);
        }
        dealCardList.showResult();
        input.close();
    }
}
class DealCardList{
    ArrayList<Card> cardList=new ArrayList<>();
    DealCardList(){

    }
    DealCardList(ArrayList<Integer> card){
        for(Integer integer: card){
            if(integer==0){
                break;
            }
            switch (integer){
                case 1:
                    Card card1 = new Card(new Circle(Main.input.nextDouble()));
                    card1.getShape().setShapeName("Circle");
                    cardList.add(card1);
                    break;
                case 2:
                    Card card2 = new Card(new Rectangle(Main.input.nextDouble(),Main.input.nextDouble()));
                    card2.getShape().setShapeName("Rectangle");
                    cardList.add(card2);
                    break;
                case 3:
                    Card card3 = new Card(new Triangle(Main.input.nextDouble(),Main.input.nextDouble(),Main.input.nextDouble()));
                    card3.getShape().setShapeName("Triangle");
                    cardList.add(card3);
                    break;
                case 4:
                    Card card4 = new Card(new Trapezoid(Main.input.nextDouble(),Main.input.nextDouble(),Main.input.nextDouble()));
                    card4.getShape().setShapeName("Trapezoid");
                    cardList.add(card4);
                    break;
            }
        }
    }

    public boolean validate() {
        for(Card card:cardList) {
            if(!card.getShape().validate()){
                return false;
                //为加上break；
            }
        }
        return true;
    }
    public void cardSort(){
        TreeSet<Card> cards = new TreeSet<Card>(cardList);

        for (Card card : cards) {
            System.out.print(card.getShape());
        }
    }

    public double getAllArea(){
        double sum=0;
        for (Card card : cardList) {
            sum+=card.getShape().getArea();
        }
        return sum;
    }

    public void showResult() {
        System.out.println("The original list:");
        for (Card card : cardList) {
            System.out.print(card.getShape());
        }
        System.out.println();
        System.out.println("The sorted list:");
        cardSort();
        System.out.printf("\nSum of area:%.2f",getAllArea());
    }
}
class Card implements Comparable<Card>{
    private Shape shape;
    Card(){

    }
    Card(Shape shape){
        this.shape = shape;
    }
    public int compareTo(Card card) {
        return -(int) (this.shape.getArea()-card.shape.getArea());
    }
    public Shape getShape(){
        return shape;
    }
    public void setShape(Shape shape){
        this.shape = shape;
    }

}
abstract class Shape{
    private String shapeName;
    Shape(){

    }
    Shape(String shapeName){
        this.shapeName = shapeName;
    }

    public String getShapeName() {
        return shapeName;
    }
    public void setShapeName(String shapeName) {
        this.shapeName = shapeName;
    }
    public abstract double getArea();
    public abstract boolean validate();
    public String toString() {
        return getShapeName()+":"+String.format("%.2f ",getArea());
    }
}
class Triangle extends Shape{
    private double side1;
    private double side2;
    private double side3;
    Triangle(){

    }
    Triangle(double side1,double side2,double side3){
        this.side1 = side1;
        this.side2 = side2;
        this.side3 = side3;
    }

    @Override
    public double getArea() {
        double s = (side1 + side2 + side3) / 2;
        double area=Math.round(Math.sqrt(s * (s - side1) * (s - side2) * (s - side3))*100.00)*0.01;
        return area;
    }

    @Override
    public boolean validate() {
        return (side1+side2>side3&&side1+side3>side2&&side2+side3>side1);
    }
}
class Trapezoid extends Shape{
    private double topSide;
    private double bottomSide;
    private double heightSide;
    Trapezoid(){

    }
    Trapezoid(double topSide,double bottomSide,double heightSide){
        this.topSide = topSide;
        this.bottomSide = bottomSide;
        this.heightSide = heightSide;
    }

    @Override
    public boolean validate() {
        return topSide>0&&heightSide>0&&bottomSide>0;
    }

    @Override
    public double getArea() {
        return (topSide+bottomSide)*heightSide/2;
    }
}
class Circle extends Shape{
    private double radius;
    Circle(){

    }
    Circle(double radius){
        this.radius = radius;
    }

    public double getRadius() {
        return radius;
    }

    public void setRadius(double radius) {
        this.radius = radius;
    }

    @Override
    public double getArea() {
        double area = Math.round(Math.PI * radius * radius*100.00)*0.01d;
        return area;
    }

    @Override
    public boolean validate() {
        return this.radius>0;
    }
}
class Rectangle extends Shape{
    private double width;
    private double length;
    Rectangle(){

    }
    Rectangle(double width,double length){
        this.width = width;
        this.length = length;
    }
    public void setLength(double length) {
        this.length = length;
    }
    public double getLength() {
        return length;
    }

    public void setWidth(double width) {
        this.width = width;
    }

    public double getWidth() {
        return width;
    }

    @Override
    public double getArea() {
        return length*width;
    }

    @Override
    public boolean validate() {
        return length>0&&width>0;
    }
}

 　　　　题目一具体数据如图所示：

 

 　　　　题目一类图设计如下：

 

 

 

 

　　　　题目二编写代码如下：

// import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Scanner;
import java.util.TreeSet;

public class Main {
    public static Scanner input = new Scanner(System.in);
    public static void main(String[] args){
        ArrayList<Integer> list = new ArrayList<Integer>();
        int num = input.nextInt();
        while(num != 0){
            if(num < 0 || num > 4){
                System.out.println("Wrong Format");
                System.exit(0);
            }
            list.add(num);
            num = input.nextInt();
        }
        DealCardList dealCardList = new DealCardList(list);
        if(!dealCardList.validate()){
            System.out.println("Wrong Format");
            System.exit(0);
        }
        dealCardList.showResult();
        input.close();
    }
}
class DealCardList<cardList> {
    ArrayList<Card> cardList=new ArrayList<>();
    ArrayList<Card> circleList=new ArrayList<>();
    ArrayList<Card> rectangleList = new ArrayList<>();
    ArrayList<Card> trapezoidList = new ArrayList<>();
    ArrayList<Card> triangleList = new ArrayList<>();
    DealCardList(){

    }
    DealCardList(ArrayList<Integer> card){
        for(Integer integer: card){
            if(integer==0){
                break;
            }
            switch (integer){
                case 1:
                   Card card1 = new Card(new Circle(Main.input.nextDouble()));
                   card1.getShape().setShapeName("Circle");
                   cardList.add(card1);
                   circleList.add(card1);
                    break;
                case 2:
                   Card card2 = new Card(new Rectangle(Main.input.nextDouble(),Main.input.nextDouble()));
                   card2.getShape().setShapeName("Rectangle");
                   cardList.add(card2);
                   rectangleList.add(card2);
                    break;
                case 3:
                    Card card3 = new Card(new Triangle(Main.input.nextDouble(),Main.input.nextDouble(),Main.input.nextDouble()));
                    card3.getShape().setShapeName("Triangle");
                    cardList.add(card3);
                    triangleList.add(card3);
                    break;
                case 4:
                    Card card4 = new Card(new Trapezoid(Main.input.nextDouble(),Main.input.nextDouble(),Main.input.nextDouble()));
                    card4.getShape().setShapeName("Trapezoid");
                    cardList.add(card4);
                    trapezoidList.add(card4);
                    break;
            }
        }
    }

    public boolean validate() {
        for(Card card:cardList) {
            if(!card.getShape().validate()){
                return false;
                //为加上break；
            }
        }
        return true;
    }
    public void cardSort(ArrayList cardList){
        TreeSet<Card> cards = new TreeSet<Card>(cardList);
        System.out.print("[");
        for (Card card : cards) {
            System.out.print(card.getShape());
        }
        System.out.print("]");
   }
    
    public double getMaxArea(){
        double circleSum=0,rectangleSum = 0,triangleSum = 0,trapezoidSum=0;
        for (Card card : circleList) {
            circleSum+=card.getShape().getArea();
        }
        for (Card card1:rectangleList
             ) {
            triangleSum+= card1.getShape().getArea();
        }
        for (Card card2:trapezoidList
             ) {
            trapezoidSum+=card2.getShape().getArea();
        }
        for (Card card3:triangleList
             ) {
            triangleSum+=card3.getShape().getArea();
        }
        double d=circleSum>rectangleSum?circleSum:rectangleSum;
        double  t=d>trapezoidSum?d:trapezoidSum;
        double max = t>triangleSum?t:triangleSum;
        return max;
    }
    public double getCircleArea(){
        double sum = 0;
        for (Card card:circleList) {
            sum+=card.getShape().getArea();
        }
        return sum;
    }
    public double getRectangleArea(){
        double sum = 0;
        for (Card card:rectangleList) {
            sum+=card.getShape().getArea();
        }
        return sum;
    }
    public double getTrapezoidArea(){
        double sum = 0;
        for (Card card:trapezoidList) {
            sum+=card.getShape().getArea();
        }
        return sum;
    }
    public double getTriangleArea(){
        double sum = 0;
        for (Card card:triangleList) {
            sum+=card.getShape().getArea();
        }
        return sum;
    }
    public void showResult() {
     
        if(cardList.size()==0){
           
            System.out.println("Wrong Format");
            System.exit(0);
        }
          System.out.println("The original list:");
        System.out.print("[");
        for (Card card : cardList) {
            System.out.print(card.getShape());
        }
        System.out.print("]");
        System.out.println();
        System.out.println("The Separated List:");
        System.out.print("[");
        for (Card card : circleList) {
            System.out.print(card.getShape());
        }
        System.out.print("]");
        System.out.print("[");
        for (Card card : rectangleList) {
            System.out.print(card.getShape());
        }
        System.out.print("]");
        System.out.print("[");
        for (Card card : triangleList) {
            System.out.print(card.getShape());
        }
        System.out.print("]");
        System.out.print("[");
        for (Card card : trapezoidList) {
            System.out.print(card.getShape());
        }
        System.out.print("]");
        System.out.println();
        System.out.println("The Separated sorted List:");
        cardSort(circleList);
        cardSort(rectangleList);
        cardSort(triangleList);
        cardSort(trapezoidList);
        System.out.println();
      System.out.printf("The max area:%.2f",getMaxArea());
    }
}
class Card implements Comparable<Card>{
    private Shape shape;
    Card(){

    }
    Card(Shape shape){
        this.shape = shape;
    }
    public int compareTo(Card card) {
        return -(int) (this.shape.getArea()-card.shape.getArea());
    }
    public Shape getShape(){
        return shape;
    }
    public void setShape(Shape shape){
        this.shape = shape;
    }

}
abstract class Shape{
    private String shapeName;
    Shape(){

    }
    Shape(String shapeName){
        this.shapeName = shapeName;
    }

    public String getShapeName() {
        return shapeName;
    }
    public void setShapeName(String shapeName) {
        this.shapeName = shapeName;
    }
    public abstract double getArea();
    public abstract boolean validate();
    public String toString() {
        return getShapeName()+":"+String.format("%.2f ",getArea());
    }
}
class Triangle extends Shape{
    private double side1;
    private double side2;
    private double side3;
    Triangle(){

    }
    Triangle(double side1,double side2,double side3){
            this.side1 = side1;
            this.side2 = side2;
            this.side3 = side3;
    }

    @Override
    public double getArea() {
        double s = (side1 + side2 + side3) / 2;
        double area=Math.round(Math.sqrt(s * (s - side1) * (s - side2) * (s - side3))*100.00)*0.01;
        return area;
    }

    @Override
    public boolean validate() {
        return (side1+side2>side3&&side1+side3>side2&&side2+side3>side1);
    }
}
class Trapezoid extends Shape{
    private double topSide;
    private double bottomSide;
    private double heightSide;
    Trapezoid(){

    }
    Trapezoid(double topSide,double bottomSide,double heightSide){
            this.topSide = topSide;
            this.bottomSide = bottomSide;
            this.heightSide = heightSide;
    }

    @Override
    public boolean validate() {
       return topSide>0&&heightSide>0&&bottomSide>0;
    }

    @Override
    public double getArea() {
        return (topSide+bottomSide)*heightSide/2;
    }
}
class Circle extends Shape{
    private double radius;
    Circle(){

    }
    Circle(double radius){
        this.radius = radius;
    }

    public double getRadius() {
        return radius;
    }

    public void setRadius(double radius) {
        this.radius = radius;
    }

    @Override
    public double getArea() {
        double area = Math.round(Math.PI * radius * radius*100.00)*0.01d;
        return area;
    }

    @Override
    public boolean validate() {
        return this.radius>0;
    }
}
class Rectangle extends Shape{
    private double width;
    private double length;
    Rectangle(){

    }
    Rectangle(double width,double length){
        this.width = width;
        this.length = length;
    }
    public void setLength(double length) {
        this.length = length;
    }
    public double getLength() {
        return length;
    }

    public void setWidth(double width) {
        this.width = width;
    }

    public double getWidth() {
        return width;
    }

    @Override
    public double getArea() {
        return length*width;
    }

    @Override
    public boolean validate() {
       return length>0&&width>0;
    }
}

　　　　题目二具体数据如下图所示：

 

 

 

　　　　题目二类图设计如下：

题目主要是利用继承的思想，从抽象图形类设计开始，一个抽象图形类中，拥有该图形的抽象面积计算方法，在不同的图形中有属于该图形面积计算的相关方法。对于每个图形卡片，设计一个集合对所定义的图形进行存储并按照面积大小顺序进行相关排序。在第一题的基础之上，对第二题递进式地采用对各个图形进行多个输入输出并且分组。在不同图形分界处加上分割他们地标志图形中括号，再将单个图形输入输出改为多个输入输出，不同图形之间来一个顺序排列，同时不改变原来所有图形地顺序排列。两者之间地递进关系比较明显，在编写代码时基本沿袭第一次地代码，比较方便。

②题目集8和题目集9两道ATM机仿真题目的设计思路分析总结

题目要求：

　　题目集8： ATM机类结构设计（一） （题目详情 (pintia.cn)）

　　题目集9：ATM机类结构设计（二）（题目详情 (pintia.cn))

　　题目集8类图设计：

 

 题目集9类图设计：

 题目集8是要求我们设计一个不能跨行取款，只存在借记卡账户的小型ATM机系统，通过输入相应的卡号、密码、ATM机编号和相关取款金额对账户中余额进行取款操作，也可不输入金额单纯对余额进行查询操作。相对于题目集8，题目集9的ATM机设计上增加了跨行存取款业务，同时还增加了借贷卡账户，完善了ATM机系统的功能。对于跨行取款操作，系统还将对其进行相关手续费扣除。

（3）踩坑心得：

•  由于对输入为0时输出地代码设计错误，在提交代码地过程中，第一个点始终过不了，最终设计为输出Wrong Format.时终于通过测试点。同时在第二题最后一个测试点中，当为三种卡片测试时，测试点也始终过不了，但是前面的三种卡片测试点显示又过了。

　　找测试点哪里出了问题真的有点摸不着头脑。

• 在编写代码过程中，对于程序的设计思路不能够很好的把握，同时不能理解如何实现各个功能，导致在编写代码过程中，写了很多没用的代码，写了删，删了又继续写，但是最终什么都没有写出来、并且浪费了时间。理解程序步骤，顺着程序的思路来，写代码前不能一股脑就直接写，否则真会什么都写不出来，题目集中每一道题都并非容易，每次我都像踩坑一样，一踩一个中。然后写出地代码在运行测试时没有一个过。
• 对于代码中要用到的知识点不能够熟练掌握，同时还不太会运用时，在写代码时如果避开要用到的知识，写代码时会特别地艰难，像图像卡片排序中用到的集合会方便一些，但是我一开始编写时并没有去利用集合而是采用数组的方式对图形进行存储，但是当我真正运用起来时，我发现自己不会用，也不知道怎么用。
• 题目集7-2是对题目集7-1的加强，ATM（二）是对ATM（一）的加强，但是在每一次的加强练习中不是能够很好的将要设计的程序完整地呈现，难度有在加大，然后会突然感觉自己什么都不会，就像是一步回到解放前。测试点也未能在规定时间完成。
• 编写代码中有一个特别致命的缺点，我在没有什么思路时立刻开始写代码，所写出来的代码质量并不好。

（4）改进建议：

• 代码难度突增有点让人措手不及，就像上学期C语言的课设题目，有点让人痛苦...... , 希望稍稍降低一点难度，难度不要从地下突然飙到云端啊。
• 提交代码时，希望对于一些极限情况的输出结果适当给予说明，有时候不太明白在一些极限情况下，所编写的代码要给予他怎样的输出，比如说是进行报错还是只用空输出就行。
• 希望老师课堂上多讲讲题目，一些例题或是网上的觉得好的题目都可以在课堂上进行讲解，尤其是一些做题的思路总结，让学生可以多学习学习老师是如何解决问题的。
• 建议老师选取做题比较好的同学在课堂上分享一下自己的做题经验以及做题的思路供大家学习参考。
• 因为可以感受到老师在课堂上对同学们讲解自己对某一问题看法表述的锻炼，我想建议老师在授课计划完成并且时间充裕之时让同学们谈谈pta及实验课作业的相关见解。

（5）总结：

第七次pta作业（图形卡片排序游戏、图形卡片分组游戏）中，让我对Java中继承、接口和复用有了进一步的了解。同时感受到封装对复用的进一步帮助、抽象方法在子类图形方法中的具体实现。

之后的两次作业（ATM设计（一）、ATM设计（二））中，我对Java中集合，关联，聚合，组合之间的关系也有了进一步的了解，同时在程序的类结构设计中应如何设计类与类之间的关系有了进一步的思考。

通过这几次的作业，自己也有发现，写代码并不是一蹴而就，首先要思考因从哪里下手，以及对于要用到的Java知识点，及如何实现所要解决的问题。这学期的JavaPTA作业有在一次比一次加大难度，会经常感觉到力不从心。

课下的代码练习还有待加强