PTA题目集1至3的总结。

1. 前言

前3次主要是类与类之间的关系：关联，依赖，组合，聚合。以及如何通过类与类之间发消息来解决题目集的问题，还有就是理解单一职责原则（SRP）在代码中的应用。前3次的题量不是很多，前俩题比较容易，第3题较难。

第一次作业

1.目标：设计一个基础的航班货运配载模块。系统需要记录航班的基本信息（航班号、最大起飞重量、最大业载重量）。地勤人员可以按照货物重量从高到低向该航班添加货物（货物名称、重量）。系统需要实时计算当前已装载的总重量，并判断是否超载。

2.代码如下

import java.util.Scanner;

    public class Main{

        public static void main(String[] args){

            Scanner scanner=new Scanner(System.in);

            Flight flight=new Flight();

            flight.setFlightNo(scanner.next());

            flight.setMaxWeight(scanner.nextDouble());

            flight.setN(scanner.nextInt());

            Cargo[] cargo=new Cargo[flight.getN()];

            for(int i=0;i<flight.getN();i++){

                cargo[i]=new Cargo();

                cargo[i].setCargoName(scanner.next());

                cargo[i].setCargoWeight(scanner.nextDouble());

             }

            CargoSorter c=new CargoSorter();

            c.cargoSorter(cargo,flight);

            LoadManifest l=new LoadManifest();

            l.addCargo(cargo,flight);

            TotalWeight To=new TotalWeight();

            To.totalWeight(cargo,flight);

            System.out.printf("总重量: %.1fkg / 最大载重: %.1fkg\n",To.totalWeight1,flight.getMaxWeight());

            OverloadDetection O=new OverloadDetection();

            O.over(To,flight);

        }

    }

    class LoadManifest{

        private Cargo[] cargo;

        public void addCargo(Cargo[] cargo,Flight flight){

            for(int i=0;i<flight.getN();i++)

            {

                System.out.printf("货物[%s 重量:%.1fkg]\n",cargo[i].getCargoName(),cargo[i].getCargoWeight());

            }

        }

    }

    class TotalWeight{

        public double totalWeight1=0;

        public void totalWeight(Cargo[] cargo,Flight flight){

            for(int i=0;i<flight.getN();i++)

                {

                    this.totalWeight1+=cargo[i].getCargoWeight();

                }

        }

    }

    class OverloadDetection{

        public void over(TotalWeight totalWeight,Flight flight){

            if(totalWeight.totalWeight1<=flight.getMaxWeight())

            {

                System.out.printf("配载状态：正常");

                return;

            }

            if(totalWeight.totalWeight1>flight.getMaxWeight())

            {

                System.out.printf("警告：严重超载");

                return;

            }

        }

    }

    class Cargo{

        private String cargoName;

        private double cargoWeight;

        public String getCargoName() {

            return cargoName;

        }

        public void setCargoName(String cargoName) {

            this.cargoName=cargoName;

        }

        public double getCargoWeight() {

            return cargoWeight;

        }

        public void setCargoWeight(double cargoWeight) {

            this.cargoWeight=cargoWeight;

        }

    }

    class Flight{

        private String flightNo;

        private double maxWeight;

        private int n;

        public String getFlightNo() {

            return flightNo;

        }

        public void setFlightNo(String flightNo) {

            this.flightNo=flightNo;

        }

        public double getMaxWeight() {

            return maxWeight;

        }

        public void setMaxWeight(double maxWeight) {

            this.maxWeight=maxWeight;

        }

        public int getN() {

            return n;

        }

        public void setN(int n) {

            this.n=n;

        }

    }

    class CargoSorter{

        public void cargoSorter(Cargo[] cargo,Flight flight)

        {

            String t;

            double p;

            for(int i=0;i<flight.getN();i++)

                {

                    for(int j=i+1;j<flight.getN();j++)

                        {

                            if(cargo[i].getCargoWeight()<cargo[j].getCargoWeight())

                            {

                                t=cargo[i].getCargoName();

                                p=cargo[i].getCargoWeight();

                                cargo[i].setCargoWeight(cargo[j].getCargoWeight());

                                cargo[i].setCargoName(cargo[j].getCargoName());

                                cargo[j].setCargoWeight(p);

                                cargo[j].setCargoName(t);

                            }

                        }

                }

        }

}

类图如下：

各类中的代码实现比较简单。

踩坑心得：没有踩坑，但是由于public double totalWeight1=0;这个没有定义成private属性，导致扣分，以后会注意不再犯这个低级错误。

心得；通过这个OPP1题目我知道了如何设计类，以及处理类与类之间的简单关系。

第二次作业

1. 目标：在第一次的基础上设计一个扩展的航班货运配载模块，实现以下功能：1.航班信息管理，2.货舱管理3.货物装载。

2. 迭代：多货舱管理与重量排序装载。

3. 代码如下；

import java.util.Scanner;

public class Main{

    public static void main(String[] args){

        Scanner scanner=new Scanner(System.in);

        Flight flight=new Flight();

        flight.setFlightNo(scanner.next());

        flight.setMaxWeight(scanner.nextDouble());

        flight.setMaxWeight1(scanner.nextDouble());

        int m=scanner.nextInt();

        CargoCompartment[] compartments=new CargoCompartment[m];

        for(int i=0;i<m;i++){

            compartments[i]=new CargoCompartment();

            compartments[i].setId(scanner.next());

            compartments[i].setMaxWeight(scanner.nextDouble());

            int row=scanner.nextInt();

            int col=scanner.nextInt();

            compartments[i].createPositions(row,col);

        }

        int n=scanner.nextInt();

        Cargo[] cargo=new Cargo[n];

        String[] target=new String[n];

        for(int i=0;i<n;i++){

            cargo[i]=new Cargo();

            cargo[i].setId(scanner.next());

            cargo[i].setWeight(scanner.nextDouble());

            target[i]=scanner.next();

        }

        flight.setList(n);

        LoadDispatcher ld=new LoadDispatcher();

        ld.sortCargos(cargo,target,flight);

        System.out.println("===== 货物按重量降序排序后装载结果 =====");

        for(int i=0;i<n;i++){

            CargoCompartment cct=null;

            for(int j=0;j<m;j++){

                if(compartments[j].getId().equals(target[i])){

                    cct=compartments[j];

                    break;

                }

            }

            if(cct!=null){

                cct.addCargo(cargo[i]);

            }

        }

        System.out.println();

        double total=0;

        for(int i=0;i<m;i++){

            total+=compartments[i].getCurrentWeight();

            String st=compartments[i].getCurrentWeight()>compartments[i].getMaxWeight()?"超载":"正常";

            System.out.printf("货舱[%s] 已装重量: %.1fkg / 最大载重: %.1fkg → 状态: %s\n",compartments[i].getId(),compartments[i].getCurrentWeight(),compartments[i].getMaxWeight(),st);

        }

        System.out.printf("航班总重量: %.1fkg / 最大起飞重量: %.1fkg / 最大业载: %.1fkg\n",total,flight.getMaxWeight(),flight.getMaxWeight1());

        InputValidator validator=new InputValidator();

        boolean ot=validator.checkDouble(total,flight.getMaxWeight());

        boolean op=validator.checkDouble(total,flight.getMaxWeight1());

        if(ot&&op)

            System.out.println("警告：超过最大起飞重量和最大业载重量");

        else if(ot)

            System.out.println("警告：超过最大起飞重量");

        else if(op)

            System.out.println("警告：超过最大业载重量");

        else

            System.out.println("整体配载状态：正常");

    }

}

class Position{

    private int r;

    private int c;

    public int getR(){

        return r;

    }

    public void setR(int r){

        this.r=r;

    }

    public int getC(){

        return c;

    }

    public void setC(int c){

        this.c=c;

    }

    public String getPosName(){

        return r+"-"+c;

    }

}

class Cargo{

    private String id;

    private double weight;

    public String getId(){

        return id;

    }

    public void setId(String id){

        this.id=id;

    }

    public double getWeight(){

        return weight;

    }

    public void setWeight(double weight){

        this.weight=weight;

    }

}

class Flight{

    private String flightNo;

    private double maxWeight;

    private double maxWeight1;

    private int List;

    public String getFlightNo(){

        return flightNo;

    }

    public void setFlightNo(String flightNo){

        this.flightNo=flightNo;

    }

    public double getMaxWeight(){

        return maxWeight;

    }

    public void setMaxWeight(double maxWeight){

        this.maxWeight=maxWeight;

    }

    public double getMaxWeight1(){

        return maxWeight1;

    }

    public void setMaxWeight1(double maxWeight1){

        this.maxWeight1=maxWeight1;

    }

    public int getList(){

        return List;

    }

    public void setList(int List){

        this.List=List;

    }

}

class LoadDispatcher{

    public void sortCargos(Cargo[] cargo,String[] target,Flight flight){

        int n=flight.getList();

         for(int i=0;i<n-1;i++){

             for(int j=0;j<n-1-i;j++){

                 if(cargo[j].getWeight()<cargo[j+1].getWeight()){

                     Cargo tmp=cargo[j];

                     cargo[j]=cargo[j+1];

                     cargo[j+1]=tmp;

                     String tmpT=target[j];

                     target[j]=target[j+1];

                     target[j+1]=tmpT;

                 }

             }

         }

    }

    public Cargo findCargo(Cargo cargo){

        return cargo;

    }

}

class CargoCompartment{

    private String id;

    private double maxWeight;

    private Position[] positions;

    private Cargo[] cargos=new Cargo[100];

    private double currentWeight=0;

    private int t=0;

    public String getId(){

        return id;

    }

    public void setId(String id){

        this.id=id;

    }

    public double getMaxWeight(){

        return maxWeight;

    }

    public void setMaxWeight(double maxWeight){

        this.maxWeight=maxWeight;

    }

    public void createPositions(int row,int col){

        positions=new Position[row*col];

        int index=0;

        for(int i=1;i<=row;i++){

            for(int j=1;j<=col;j++){

                Position p=new Position();

                p.setR(i);

                p.setC(j);

                positions[index++]=p;

            }

        }

    }

    public void addCargo(Cargo cargo){

        if(currentWeight+cargo.getWeight()<=maxWeight){

            cargos[t++]=cargo;

            currentWeight+=cargo.getWeight();

            System.out.printf("货物[%s 重量:%.1fkg] → 装入货舱[%s] 成功\n",cargo.getId(),cargo.getWeight(),id);

        }else{

            System.out.printf("货物[%s 重量:%.1fkg] → 装入货舱[%s] 失败\n",cargo.getId(),cargo.getWeight(),id);

        }

    }

    public double getCurrentWeight(){

        return currentWeight;

    }

}

class InputValidator{

    public boolean checkInt(int value,int min,int max){

        return value>=min&&value<=max;

    }

    public boolean checkDouble(double value,double limit){

        return value>limit;

    }

}

类图如下；

各类中的代码实现比较简单，关系实现比较简单。

踩坑心得：在完成代码后提交后没有满分，然后自己直接考虑是不是自己的代码在一些方面的处理存在bug,然后最终发现是在处理配载失败的输出存在问题，没有按照给的输出形式输出，在以后的问题中我会吸取教训，改正自我。

心得: 通过这次题目我知道了需求的重要性，如果没有完全弄明白题目的所有需求，那么即使类设计的非常完美，但是也无法得到满意的结果，所以在写代码之前一定要把需求弄明白（这才是最重要的）。

第三次作业.

1. 目标: 在V2基础上的主要增量引入旅客实体：新增旅客及行李的管理，旅客体重按标准值（75kg）自动计算。引入核心业务算法：新增基于物理力矩的“航空器载重平衡计算”功能.增强鲁棒性要求：在数据录入过程中，要对数据进行合法性验证，如果发现有非法输入，立即停止应用程序运行。

2. 代码如下:

import java.util.Scanner;

import java.util.LinkedList;

import java.util.List;

public class Main{

    public static void main(String[] args){

        Scanner scanner=new Scanner(System.in);

        InputValidator iv=new InputValidator();

        Flight flight=new Flight();

        flight.setFlightNo(scanner.next());

        CargoCompartment front=new CargoCompartment();

        front.setId("1");

        int fRow=scanner.nextInt();

        if(fRow<0){

            System.out.println("数值不能为负数！");

            return;

        }

        int fCol=scanner.nextInt();

        if(fCol<0){

            System.out.println("数值不能为负数！");

            return;

        }

        double fm=scanner.nextDouble();

        if(fm<0){

            System.out.println("数值不能为负数！");

            return;

        }

        front.setMaxWeight(fm);

        front.createPositions(fRow,fCol);

        CargoCompartment aft=new CargoCompartment();

        aft.setId("2");

        int aRow=scanner.nextInt();

        if(aRow<0){

            System.out.println("数值不能为负数！");

            return;

        }

        int aCol=scanner.nextInt();

        if(aCol<0){

            System.out.println("数值不能为负数！");

            return;

        }

        double am=scanner.nextDouble();

        if(am<0){

            System.out.println("数值不能为负数！");

            return;

        }

        aft.setMaxWeight(am);

        aft.createPositions(aRow,aCol);

        int n=scanner.nextInt();

        if(n<0){

            System.out.println("数值不能为负数！");

            return;

        }

        Passenger[] ps=new Passenger[n];

        for(int i=0;i<n;i++){

            ps[i]=new Passenger();

            ps[i].creatLuggage();

            double pg=scanner.nextDouble();

            if(pg<0){

                System.out.println("数值不能为负数！");

                return;

            }

            ps[i].getLuggage().setP(pg);

        }

        List<Passenger> list=new LinkedList<>();

        for(Passenger p:ps){

            list.add(p);

        }

        flight.setPassengerList(list);

        int m=scanner.nextInt();

        if(m<0){

            System.out.println("数值不能为负数！");

            return;

        }

        int pNum=scanner.nextInt();

        if(pNum<0){

            System.out.println("数值不能为负数！");

            return;

        }

        if(!iv.checkInt(pNum,1,m)){

            System.out.println("输入必须在 1 到 "+m+" 之间！");

            return;

        }

        for(int i=0;i<pNum;i++){

            Cargo c=new Cargo();

            c.setId(scanner.nextInt()+"");

            double w=scanner.nextDouble();

            if(w<0){

                System.out.println("数值不能为负数！");

                return;

            }

            c.setWeight(w);

            if(front.getCurrentWeight()+w>front.getMaxWeight()){

                System.out.printf("!!! 警告：[1]剩余容量不足(当前载重%.1f/%.1fkg)，请重新分配或减轻重量！\n",front.getCurrentWeight(),front.getMaxWeight());

                return ;

            }

            front.addCargo(c);

        }

        for(int i=0;i<m-pNum;i++){

            Cargo c=new Cargo();

            c.setId(scanner.nextInt()+"");

            double w=scanner.nextDouble();

            if(w<0){

                System.out.println("数值不能为负数！");

                return;

            }

            c.setWeight(w);

            if(aft.getCurrentWeight()+w>aft.getMaxWeight()){

                System.out.printf("!!! 警告：[2]剩余容量不足(当前载重%.1f/%.1fkg)，请重新分配或减轻重量！\n",aft.getCurrentWeight(),aft.getMaxWeight());

                return;

            }

            aft.addCargo(c);

        }

        flight.setMaxWeight(front.getMaxWeight());

        flight.setMaxWeight1(aft.getMaxWeight());

        WeightBalanceCalculator cal=new WeightBalanceCalculator();

        cal.generateLoadSheet(flight,ps,front,aft);

    }

}

class Passenger{

    private String name;

    private Luggage luggage;

    public void creatLuggage(){

        luggage=new Luggage();

    }

    public String getName(){

        return name;

    }

    public void setName(String name){

        this.name=name;

    }

    public double totalWeight(){

        return 75+luggage.getP();

    }

    public Luggage getLuggage(){

        return luggage;

    }

}

class Luggage{

    private double p;

    public double getP(){

        return p;

    }

    public void setP(double p){

        this.p=p;

    }

}

class WeightBalanceCalculator{

    private static double emptyWeight=40000;

    private static double emptyCGArm=16.25;

    private static double passengerCompartmentAverageArm=18;

    private static double forwardCargoHoldArm=12;

    private static double headCargoHoldArm=22;

    private static double MAC=5;

    private static double MAC1=15;

    public double getPassengerTotalWeight(Passenger[] passenger,int n){

        double total=0;

        for(int i=0;i<n;i++){

            total+=passenger[i].totalWeight();

        }

        return total;

    }

    public double getPassengerLJ(Passenger[] passenger,int n){

        return getPassengerTotalWeight(passenger,n)*passengerCompartmentAverageArm;

    }

    public double getCargoTotalweight(CargoCompartment front,CargoCompartment aft){

        return front.getCurrentWeight()+aft.getCurrentWeight();

    }

    public double getCargoLJ1(CargoCompartment flight){

        return flight.getCurrentWeight()*forwardCargoHoldArm;

    }

    public double getCargoLJ2(CargoCompartment flight){

        return flight.getCurrentWeight()*headCargoHoldArm;

    }

    public double getFlightTotalWeight(Passenger[] p,int n,CargoCompartment front,CargoCompartment aft){

        return getCargoTotalweight(front,aft)+getPassengerTotalWeight(p,n)+emptyWeight;

    }

    public double getTotalLJ(Passenger[] p,int n,CargoCompartment flight,CargoCompartment flight1){

        return emptyWeight*emptyCGArm+getPassengerLJ(p,n)+getCargoLJ1(flight)+getCargoLJ2(flight1);

    }

    public double getCenterofGravity(Passenger[] p,int n,CargoCompartment front,CargoCompartment aft){

        return getTotalLJ(p,n,front,aft)/getFlightTotalWeight(p,n,front,aft);

    }

    public void MACC(Passenger[] p,int n,CargoCompartment front,CargoCompartment aft){

        double t=(getCenterofGravity(p,n,front,aft)-MAC1)/MAC*100;

        if(t<=38.0&&t>=25.0){

            System.out.println("配平评估: 安全 (GREEN)");

        }else{

            System.out.println("配平评估: 危险 (RED - 超出极限重心范围)");

        }

    }

    public void generateLoadSheet(Flight flight, Passenger[] ps, CargoCompartment front, CargoCompartment aft){

        int n = ps.length;

        System.out.println("======================================");

        System.out.println("     航班 "+flight.getFlightNo()+" 载重平衡舱单");

        System.out.println("======================================");

        System.out.println("【基础数据】");

        System.out.printf("空机重量: 40000.0 kg  | 力臂: 16.3 m\n");

        System.out.println("【旅客数据】");

        System.out.printf("旅客人数: %d  | 总重(含行李): %.1f kg\n", n, getPassengerTotalWeight(ps,n));

        System.out.println("【货物数据】");

        System.out.printf("[1] 装载: %.1fkg / %.1fkg (力臂: 12.0m)\n", front.getCurrentWeight(), flight.getMaxWeight());

        front.printCargoInfo();

        System.out.printf("[2] 装载: %.1fkg / %.1fkg (力臂: 22.0m)\n", aft.getCurrentWeight(), flight.getMaxWeight1());

        aft.printCargoInfo();

        System.out.println("【汇总计算】");

        System.out.printf("起飞总重量: %.1f kg\n", getFlightTotalWeight(ps,n,front,aft));

        System.out.printf("总力矩:%.1f kg·m\n", getTotalLJ(ps,n,front,aft));

        System.out.printf("实际重心(CG): %.1f m\n", getCenterofGravity(ps,n,front,aft));

        System.out.printf("重心百分比(%%MAC): %.1f%%\n", ((getCenterofGravity(ps,n,front,aft)-MAC1)/MAC)*100);

        System.out.println("======================================");

        MACC(ps,n,front,aft);

        System.out.println("======================================");

    }

}

class Position{

    private int r;

    private int c;

    public int getR(){

        return r;

    }

    public void setR(int r){

        if(r<0) r=0;

        this.r=r;

    }

    public int getC(){

        return c;

    }

    public void setC(int c){

        if(c<0) c=0;

        this.c=c;

    }

}

class Cargo{

    private String id;

    private double weight;

    public String getId(){

        return id;

    }

    public void setId(String id){

        this.id=id;

    }

    public double getWeight(){

        return weight;

    }

    public void setWeight(double weight){

        this.weight=weight;

    }

}

class Flight{

    private String flightNo;

    private double maxWeight;

    private double maxWeight1;

    private List<Passenger> passengerList;

    public String getFlightNo(){

        return flightNo;

    }

    public void setFlightNo(String flightNo){

        this.flightNo=flightNo;

    }

    public double getMaxWeight(){

        return maxWeight;

    }

    public void setMaxWeight(double maxWeight){

        this.maxWeight=maxWeight;

    }

    public double getMaxWeight1(){

        return maxWeight1;

    }

    public void setMaxWeight1(double maxWeight1){

        this.maxWeight1=maxWeight1;

    }

    public List<Passenger> getPassengerList() {

        return passengerList;

    }

    public void setPassengerList(List<Passenger> passengerList) {

        this.passengerList = passengerList;

    }

}

class CargoCompartment{

    private String id;

    private double maxWeight;

    private Position[] positions;

    private Cargo[] cargos=new Cargo[100];

    private double currentWeight=0;

    private int t=0;

    public String getId(){

        return id;

    }

    public void setId(String id){

        this.id=id;

    }

    public double getMaxWeight(){

        return maxWeight;

    }

    public void setMaxWeight(double maxWeight){

        this.maxWeight=maxWeight;

    }

    public void createPositions(int row,int col){

        if(row <0) row=0;

        if(col <0) col=0;

        positions=new Position[row*col];

        int index=0;

        for(int i=1;i<=row;i++){

            for(int j=1;j<=col;j++){

                Position p=new Position();

                p.setR(i);

                p.setC(j);

                positions[index++]=p;

            }

        }

    }

    public void addCargo(Cargo cargo){

        cargos[t++]=cargo;

        currentWeight+=cargo.getWeight();

    }

    public double getCurrentWeight(){

        return currentWeight;

    }

    public void printCargoInfo(){

        for(int i=0;i<t;i++){

            System.out.printf("  ->[%s, %.1fkg]\n",cargos[i].getId(),cargos[i].getWeight());

        }

    }

}

class InputValidator{

    public boolean checkInt(int v,int min,int max){

        return v>=min&&v<=max;

    }

    public boolean checkDouble(double v,double min){

        return v>=min;

    }

}

类图如下:

类间关系比较复杂，题目难度较难。

踩坑心得：由于没有不能装载或数据无效的样例结果输出，所以在“前舱容量不足测试”，“后舱容量不足测试”，“输入数据范围非法（装载前舱货物数量）测试”这三个测试点上一直过不去，然后结合真实的飞机装载情况来分析我的输出结果有什么差错，发现前舱的货物数量范围应该是1到m,而不是0到m。而且在判断前舱，后舱容量是否允许在装入货物是我的原来思路如果不可以装入的话应该是输出中要显示当前的货舱重量+不能装入的哪个货物重量之和的数据，但是结合实际情况应该是不能装入的货物重量不应该计入载重量值中。

心得: 通过这次题目我更一步的熟悉了怎么处理类与类之间的4种给关系。

总结:

通过这三次的题目，类与类之间的关系处理已比较熟练，能快速的理清题目中所包含的所有类间关系，还有就是知道了需求的重要性。我觉得还需要进一步学习和研究的是ArrayList和LinkedList的应用，熟练掌握对它们的操作，教师授课很好，作业难度还行，课程推进速度合适，实验难度还可以，另外我建议在PTA的题目中可以加入一些不同输出结果的案例，我在第2，3次作业集中就在输出格式这个测试点卡了俩三个小时。

posted @ 2026-05-18 16:39 hzj111 阅读(8) 评论(0) 收藏举报

刷新页面返回顶部

hzj111

PTA题目集1至3的总结。

公告