526互联

南昌航空大学-21207107-第一次博客作业

发布时间 2023-10-07 11:35:22作者: Nammm

引言

        在大三第一学期，我学习了一门新的课程叫做面向对象程序设计，这门课程主要是运用Java语言用面向对象的主要思想进行程序设计。课程已经过去了一个月了，现在写下这篇博客来行一个总结。
        至今为止，我一共进行了三次PTA大作业，难度从易到难，让我对面向对象这一思想有了基本的认识。

第一次大作业

        总的来说，第一次的pta作业不算很难，是初学者刚接触的基础，基本上只要学会Java语言的基本运用方法就可以完成这一次的大作业。

7-1 身体质量指数（BMI）测算

体重是反映和衡量一个人健康状况的重要标志之一，过胖和过瘦都不利于健康，BMI（身体质量指数）计算方法：体重（以千克为单位）除以身高（以米为单位）的平方。中国成人正常的BMI应在18.5-24之间，如果小于18.5为体重不足，如果大于等于24为超重，大于等于28为肥胖。请编写程序，测算身体状态。

输入格式:
两个数值：体重（以千克为单位），身高(以米为单位），数值间以空格分隔。例如：65.5 1.75。
注意：体重的世界纪录是727公斤，身高的世界纪录是2.72米。输入数据上限不得超过纪录，下限不得小于等于0；

输出格式:
输入数值超出范围 ：输出“input out of range”。例如：-2 3或者125 5。
BMI小于18.5 ：输出“thin”。
BMI大于等于18.5小于24 ：输出“fit”。
BMI大于等于24小于28 ：输出“overweight”。
BMII大于等于28 ：输出“fat”。

第一题较为简单，只需从键盘接收两个数据，并根据BMI的计算公式对数据进行相应的处理，然后再进行判断比较即可。

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        double Weight = input.nextDouble();
        double Height = input.nextDouble();
        if((Weight >0 && Weight <= 727) && (Height > 0 && Height <= 2.72)) {
            double BMI = Weight/(Height*Height);
            if (BMI < 18.5){
                System.out.println("thin");
            }
            if (BMI >= 18.5 && BMI < 24){
                System.out.println("fit");
            }
            if (BMI >= 24 && BMI < 28){
                System.out.println("overweight");
            }
            if (BMI >= 28){
                System.out.println("fat");
            }
        }
        else
            System.out.println("input out of range");
    }
}

7-2 长度质量计量单位换算

长度、质量的计量有多重不同的计算体系，有标准的国际单位制：千克与米，也有各个国家自己的计量方法如：磅、英寸；1磅等于0.45359237千克，1英寸等于0.0254米，请编写程序实现国际单位制与英制之间的换算。

输入格式:
两个浮点数，以空格分隔，第一个是质量（以千克为单位）、第二个是长度（以米为单位）。例如：0.45359237 0.0254。

输出格式:
两个浮点数，以空格分隔，第一个是质量（以磅为单位）、第二个是长度（以英寸为单位）。例如：1.0 1.0。

第二题方法与第一题基本一致，但要注意最后输出结果类型要转变为float。

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        double Weight1 = input.nextDouble();
        double Length1 = input.nextDouble();
        double Weight2;
        double Length2;
        if(Weight1!=0) {
            Weight2 = Weight1/0.45359237;
        }
        else
            Weight2 = 0;
        if(Length1!=0) {
            Length2 = Length1/0.0254;
        }
        else
            Length2 = 0;
        
            System.out.println((float)Weight2+" "+(float)Length2);
    }
}

7-3 NCHU_奇数求和

计算一个数列中所有奇数的和。

输入格式:
十个整数，以空格分隔。例如：1 2 3 4 5 6 7 8 9 0。

输出格式:
输入数列中所有奇数之和。例如：25。

在这题中判断奇数是这题关键，我选择用每个数除2的余数来判断。

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int num;
        int sum = 0;
        for(int i = 0;i<10;i++) {
            num=input.nextInt();
            if(num%2==1||num%2==-1) {
                sum=sum+num;
            }
        }
        System.out.println(sum);
    }
}

7-4 NCHU_房产税费计算

房屋交易在日常生活中非常常见的事情，房屋交易时要额外支付各种税费，按2022年房产交易新政策的规定买房人应缴纳税费包括：

1、契税：首次购房评估额90平（含）内1%、90平-144平（含）内1.5%，超过144平或非首 次3%，买方缴纳。

2、印花税：房款的0.05%。

3、交易费：3元/平方米。

4、测绘费：1.36元/平方米。

5、权属登记费及取证费：一般情况是在200元内。

输入格式:
四个数据，以空格分隔：
1、第几次购房（整数）
2、房款（整数/单位万元）
3、评估价（整数/单位万元）
4、房屋面积（浮点数/单位平方米）。
例如：1 100 100 90。

输出格式:
契税、印花税、交易费、测绘费（以元为单位），以空格分隔。例如：10000.0 500.0 270.0 122.4

在这题中，数据的种类比较多，处理起来也比较繁琐。要注意各个数据的类型是整数型还是浮点型。一开始我写的代码总是答案不正确，我检查了几遍也没发现逻辑上有问题，最后发现题目里有的数据使用的单位是万元，要将单位统一起来。

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        int num1,num2,num3;
        double num4;
        Scanner input = new Scanner (System.in);
        num1 = input.nextInt();
        num2 = input.nextInt()*10000;
        num3 = input.nextInt()*10000;
        num4 = input.nextDouble();
        double total1=0,total2,total3,total4;
        if(num1 == 1 && num4 <= 90) {
            total1 = 0.01 * num3;
        }
        if(num1 == 1 && num4 > 90 && num4 <= 144) {
            total1 = 0.015 * num3;
        }
        if(num1 != 1 || num4 > 144){
            total1 = 0.03 * num3;
        }
        total2 = 0.0005 * num2;
        total3 = 3 * num4;
        total4 = 1.36 * num4;
        System.out.println((float)total1+" "+(float)total2+" "+(float)total3+" "+(float)total4);
    }

}

7-5 游戏角色选择

一款网游中包括4个种族：人类、精灵、兽人、暗精灵，每个种族包含三种角色：战士、法师、射手。玩家新建人物时需要选择种族和角色。请编写角色选择程序。

输入格式:
两个整数：游戏种族、角色的选项，以空格分隔。例如：1 2。
种族选项设定为：1、人类 2、精灵 3、兽人 4、暗精灵
角色选项设定为：1、战士 2、法师 3、射手

输出格式:
所选择的种族、角色的名称，以空格分隔。例如：人类 法师
若输入数值超出选项范围，输出“Wrong Format”

这题比较简单，要注意一下非法输入。

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner (System.in);
        int race,role;
        race = input.nextInt();
        role = input.nextInt();
        if (race==1) {
            if(role==1) {
                System.out.println("人类 战士");
            }
            if(role==2) {
                System.out.println("人类 法师");
            }
            if(role==3) {
                System.out.println("人类 射手");
            }    
        }
        if (race==2) {
            if(role==1) {
                System.out.println("精灵 战士");
            }
            if(role==2) {
                System.out.println("精灵 法师");
            }
            if(role==3) {
                System.out.println("精灵 射手");
            }
        }
        if (race==3) {
            if(role==1) {
                System.out.println("兽人 战士");
            }
            if(role==2) {
                System.out.println("兽人 法师");
            }
            if(role==3) {
                System.out.println("兽人 射手");
            }
        }
        if (race==4) {
            if(role==1) {
                System.out.println("暗精灵 战士");
            }
            if(role==2) {
                System.out.println("暗精灵 法师");
            }
            if(role==3) {
                System.out.println("暗精灵 射手");
            }
        }
        if(race>4||role>3)
            System.out.println("Wrong Format");
    }
}

7-6 NCHU_学号识别

学校的学号由8位数字组成，前两位是入学年份（省略了20）；第3、4位是学院编号，01代表材料学院，02代表机械学院，03代表外语学院，20代表软件学院；第5、6位是学院内部班级编号，最后两位是班级内部学号。如：18011103，入学年份是2018年，材料学院，11班，03号

输入格式:
8位数字组成的学号。例如：18011103
注意：输入学号不是8位或者学院编号不是01、02、03、20其中之一，属于非法输入

这题主要是检测学号的输入，并进行判断。

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        String Toatal;
        String year,college,clas,num;
        Scanner in = new Scanner(System.in);
        Toatal = in.next();
        if(8!=Toatal.length()) {
            System.out.print("Wrong Format");
            return;
        }
        year = Toatal.substring(0,2);
        college = Toatal.substring(2,4);
        clas = Toatal.substring(4,6);
        num = Toatal.substring(6,8);
        if(college.equalsIgnoreCase("01")) {
                college = "材料学院";
        }else if(college.equalsIgnoreCase("02")) {
                college = "机械学院";
        }else if(college.equalsIgnoreCase("03")) {
                college = "外语学院";
        }else if(college.equalsIgnoreCase("20")) {
                college = "软件学院";
        }else {
            System.out.print("Wrong Format");
                return;
        }
                
                System.out.print("入学年份：20"+year+"年\n"
                        + "学院："+college+"\n"
                        + "班级："+clas+"\n"
                        + "学号："+num);
            }
}

7-8 NCHU_巴比伦法求平方根近似值

巴比伦法求n的近似值可以用以下公式：
nextGuess = (lastGuess+n/lastGuess)/2
程序初始运行时lastGuess可赋予一个最初的猜测值。当由公式求得的nextGuess和lastGuess相差较大时，把nextGuess的值赋给lastGuess，继续以上过程，直至nextGuess和lastGuess几乎相同，此时lastGuess或者nextGuess就是平方根的近似值。
本题要求：nextGuess和lastGuess的差值小于0.00001时认为两者几乎相同

这题看着比较吓人，但是读懂题目之后发现其实并没有想象中难，只要不断的循环在进行判断就可以了。

import java.util.Scanner;

public class Main {
    public static void main(String[] args){
        Scanner input = new Scanner(System.in);
        float n = input.nextFloat();
        float lastGuess = input.nextFloat();
        float nextGuess;
        if(n<=0||lastGuess<=0){
            System.out.print("Wrong Format");
            return;
        }
            nextGuess = (lastGuess+n/lastGuess)/2;
            while(Math.abs(nextGuess-lastGuess)>=0.00001){
                lastGuess = nextGuess;
                nextGuess = (lastGuess+n/lastGuess)/2;
            }
            System.out.print(lastGuess);
    }
}

7-9 二进制数值提取

在一个字符串中提取出其中的二进制数值序列，。

输入格式:
一个由0、1构成的序列，以-1为结束符，非0、1字符视为正常输入，但忽略不计，未包含结束符的序列视为非法输入。例如：abc00aj014421-1

输出格式:
将输入的序列去掉非0、1字符以及结尾符的数据内容，
注：结束符-1之后的0\1字符忽略不计。
例如：00011。

先判断字符串中是否含有-1，然后对-1前的序列进行一个01的提取，记得输入用nextLine()，next()读取不了空格和转义符。

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner (System.in);
        String a = input.nextLine();
        String b = "";
        for(int i=0;i<a.length();i++) {
            if(a.charAt(i)=='0'||a.charAt(i)=='1') {
                b+=a.charAt(i);
            }else if(a.charAt(i)=='-'&&a.charAt(i+1)=='1') {
                System.out.print(b);
                return;
            }
        }
        System.out.print("Wrong Format");
    }
}

7-7 判断三角形类型

输入三角形三条边，判断该三角形为什么类型的三角形。

输入格式:
在一行中输入三角形的三条边的值（实型数），可以用一个或多个空格或回车分隔，其中三条边的取值范围均为[1,200]。

输出格式:
（1）如果输入数据非法，则输出“Wrong Format”；
（2）如果输入数据合法，但三条边不能构成三角形，则输出“Not a triangle”；
（3）如果输入数据合法且能够成等边三角形，则输出“Equilateral triangle”；
（3）如果输入数据合法且能够成等腰直角三角形，则输出“Isosceles right-angled triangle”；
（5）如果输入数据合法且能够成等腰三角形，则输出“Isosceles triangle”；
（6）如果输入数据合法且能够成直角三角形，则输出“Right-angled triangle”；
（7）如果输入数据合法且能够成一般三角形，则输出“General triangle”。

        这一题是我觉得在第一次大作业里面最复杂的一道题了，因为这道题涉及到各种不同种类的三角形的判断。其中在这些不同种类的三角形里有很多都是相互重合的，这就需要对判定条件不断优化，从而才不会出现一个三角形被包含在多种类型里面。

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        double length1,length2,length3;
        Scanner input = new Scanner(System.in);
        length1 = input.nextDouble();
        length2 = input.nextDouble();
        length3 = input.nextDouble();
        
        if(length1<1||length1>200||length2<1||length2>200||length3<1||length3>200) {
            System.out.println("Wrong Format");
            return;
        }
        
        if(length1>=1&&length1<=200&&length2>=1&&length2<=200&&length3>=1&&length3<=200) {
            if(length1+length2<=length3||length1+length3<=length2||length3+length2<=length1) {
                System.out.println("Not a triangle");
                return;
            }
            if(length1==length2&&length2==length3){//等边条件
                System.out.println("Equilateral triangle");
                return;
            }
            if(length1+length2>length3&&length1+length3>length2&&length3+length2>length1){//能否构成
                
                if(length1==length2||length2==length3||length1==length3) {//等腰条件
                    
                    if((length1*length1+length2*length2-length3*length3<0.0001)||(length3*length3+length2*length2-length1*length1<0.0001)||(length1*length1+length3*length3-length2*length2<0.0001)){//直角条件
                        System.out.println("Isosceles right-angled triangle");
                        return;
                    }
                    else {
                    System.out.println("Isosceles triangle");
                    return;
                    }
                }

                     
                if(length1*length1+length2*length2==length3*length3||length3*length3+length2*length2==length1*length1||length1*length1+length3*length3==length2*length2) {
                    System.out.println("Right-angled triangle");
                    return;
                }
                
                if((length1!=length2&&length2!=length3)&&(length1*length1+length2*length2!=length3*length3&&length3*length3+length2*length2!=length1*length1&&length1*length1+length3*length3!=length2*length2)) {
                    System.out.println("General triangle");    
                    return;
                }
            }
        }
    }
}

第二次大作业

7-1 成绩计算-1-类、数组的基本运用

创建学生类，包含

属性：学号（String）、姓名（String）、语文成绩（int）、数学成绩（int）、物理成绩（int）

方法：计算总分、计算平均分

输入5个学生的信息，将每个学生的信息封装在一个学生对象中。

按输入顺序依次输出5个学生的总分、平均分（精确到小数点后两位，舍去部分按四舍五入规则计入最后一位）。
输入格式:
5个学生信息，每个学生信息格式：

学号+英文空格+姓名+英文空格+语文成绩+英文空格+数学成绩+英文空格+物理成绩
例如：
22201311 张琳 80 80 80

22201312 黄昊 66 82 81

22201313 李少辰 77 76 80

22201314 袁婷 62 79 90

22201315 朱哲一 74 98 94

输出格式:
5个学生信息，每个学生信息格式：

学号+英文空格+姓名+英文空格+总成绩+英文空格+平均分

例如：

22201311 张琳 240 80.00

22201312 黄昊 229 76.33

22201313 李少辰 233 77.67

22201314 袁婷 231 77.00

22201315 朱哲一 266 88.67

在这一题中用到了类的相关知识，创建了一个学生类，将学生的各种信息存储在类中。除此以外还要注意浮点数的保留几位小数的操作。

import java.util.Scanner;

public class Main {
    public static void main(String[] args){
        student []Stu = new student[5];
        Scanner input = new Scanner (System.in);
        int []scores = new int[3];
        double total=0;
        double average;
        for(int i=0;i<5;i++) {
            String ID = input.next();
            String Name = input.next();
            for(int j=0;j<3;j++) {
                scores[j] = input.nextInt();
                total += scores[j];
            }
            average = total/3;
            Stu[i] =  new student(ID,Name,scores,total,average);
            total=0;
        }
    
        for(int i=0;i<5;i++) {
            System.out.print(Stu[i].ID+" "+Stu[i].Name+" "+(int)Stu[i].total+" ");
            System.out.println(String.format("%.2f", Stu[i].average));
        }
        
    }
    public static class student{
        String ID;
        String Name;
        int []scores;
        double total=0;
        double average;

        public student(String ID,String Name,int []scores,double total,double average) {
            this.ID = ID;
            this.Name = Name;
            this.scores = scores;
            this.total = total;
            this.average = average;
        }
    }
}

7-2 成绩计算-2-关联类

创建成绩类，包含：

属性：平时成绩（int）、期末成绩（int）

方法：计算总成绩（计算规则：平时成绩*0.4+期末成绩*0.6，保留整数部分，小数部分直接丢弃）

创建学生类，包含：

属性：学号（String）、姓名（String）、语文成绩（成绩类）、数学成绩（成绩类）、物理成绩（成绩类）

方法：计算总分、计算平均分

输入3个学生的信息，将每个学生的信息封装在一个学生对象中。

按输入顺序依次输出3个学生的总分、平均分（精确到小数点后两位，舍去部分按四舍五入规则计入最后一位）。
输入格式:
依次输入3个学生的每门课成绩，每个学生成绩信息格式：

学号+英文空格+姓名+英文空格+课程名+英文空格+平时成绩+英文空格+期末成绩
注：3个学生的课程顺序可能会不一致

例如：
22201311 张琳 语文 70 80

22201311 张琳 数学 85 89

22201311 张琳 物理 75 83

22201312 黄昊 语文 66 78

22201312 黄昊 数学 76 82

22201312 黄昊 物理 83 82

22201313 李少辰 语文 86 76

22201313 李少辰 数学 78 76

22201313 李少辰 物理 87 76

输出格式:
3个学生信息，每个学生信息格式：

学号+英文空格+姓名+英文空格+总成绩+英文空格+平均分

例如：


22201311 张琳 242 80.67

22201312 黄昊 234 78.00

22201313 李少辰 236 78.67

这一题与上一题处理的方法基本相似，只不过数据稍微多了一点。

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        student []Stu = new student[9];
        Scanner input = new Scanner (System.in);
        String ID;
        String Name;
        String subject;
        int []scores = new int[2];
        double total=0;
        double interim=0;
        double final_=0;
        double interim_average;
        double final_average;
        double Average;
        for(int i=0;i<9;i++) {
            ID = input.next();
            Name = input.next();
            subject = input.next();
            for(int j=0;j<2;j++) {
                scores[j] = input.nextInt();
            }
            total += (int)(0.4*scores[0]+0.6*scores[1]);
            interim += scores[0];
            final_ += scores[1];
            if(i==2) {
                interim_average = interim/3;
                final_average = final_/3;
                Average = total/3;
                Stu[1] = new student(ID,Name,scores,total,interim_average,final_average,Average);
                total = 0;
                interim = 0;
                final_ = 0;
            }
            if(i==5) {
                interim_average = interim/3;
                final_average = final_/3;
                Average = total/3;
                Stu[2] = new student(ID,Name,scores,total,interim_average,final_average,Average);
                total = 0;
                interim = 0;
                final_ = 0;
            }
            if(i==8) {
                interim_average = interim/3;
                final_average = final_/3;
                Average = total/3;
                Stu[3] = new student(ID,Name,scores,total,interim_average,final_average,Average);
                total = 0;
                interim = 0;
                final_ = 0;
            }
        }
        for(int i=1;i<=3;i++) {
             System.out.println(Stu[i].ID+" "+Stu[i].Name+" "+(int)Stu[i].total+" "+String.format("%.2f", Stu[i].interim_average)+" "+String.format("%.2f", Stu[i].final_average)+" "+String.format("%.2f", Stu[i].Average));
             //System.out.println(String.format("%.2f", Stu[i].interim_average)+" ");
             //System.out.println(String.format("%.2f", Stu[i].final_average)+" ");
             //System.out.println(String.format("%.2f", Stu[i].Average)+" ");
        }
    }
    public static class student{
        String ID;
        String Name;
        int []scores;
        double total;
        double interim_average;
        double final_average;
        double Average;
        
        public student(String ID,String Name,int []scores,double total,double interim_average,double final_average,double Average) {
            this.ID = ID;
            this.Name = Name;
            this.scores = scores;
            this.total = total;
            this.interim_average = interim_average;
            this.final_average = final_average;
            this.Average = Average;
        }
    }
}

 7-3 有重复的数据

在一大堆数据中找出重复的是一件经常要做的事情。现在，我们要处理许多整数，在这些整数中，可能存在重复的数据。

你要写一个程序来做这件事情，读入数据，检查是否有重复的数据。如果有，输出“YES”这三个字母；如果没有，则输出“NO”。

输入格式:
你的程序首先会读到一个正整数n,n∈[1,100000]，然后是n个整数。

输出格式:
如果这些整数中存在重复的，就输出：

YES
否则，就输出：

NO

        一开始我看到这道题感觉这道题挺简单的，无非就是使用多次循环将每一个数与后面的数来比较，实际操作起来也比较顺利。可是当提交的时候，有两个名称是很慢的测试点却怎么也通不过，这时候我意识到是我这个方法嵌套的循环太多了，时间复杂度太大了。后来查阅网上资料发现使用哈希表就可以简洁的解决这一道题。

import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;

public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        
        int n =input.nextInt();
        input.nextLine();
        String str = input.nextLine();
        String[] strs = str.split(" ");
        Set<Integer> set = new HashSet<Integer>();
        for (int i=0; i<n; i++) {
            set.add(Integer.parseInt(strs[i]));
        }
        if (set.size() == n) {
            System.out.println("NO");
        }else {
            System.out.println("YES");
        }
    }
}

7-4 去掉重复的数据

在一大堆数据中找出重复的是一件经常要做的事情。现在，我们要处理许多整数，在这些整数中，可能存在重复的数据。

你要写一个程序来做这件事情，读入数据，检查是否有重复的数据。如果有，去掉所有重复的数字。最后按照输入顺序输出没有重复数字的数据。所有重复的数字只保留第一次出现的那份。

输入格式:
你的程序首先会读到一个正整数 n，1≤n≤100000。
然后是 n 个整数，这些整数的范围是 [1, 100000]。

输出格式:
在一行中按照输入顺序输出去除重复之后的数据。每两个数据之间有一个空格，行首尾不得有多余空格。

这一题遇上一题大同小异，同样需要使用哈希表来完成。

import java.util.LinkedHashSet;
import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int f = input.nextInt();
        int flag=0;
        String str = input.nextLine();
        while(input.hasNext())
        {
            String s = input.nextLine();
            str = str + s;
        }
        String[] arr = str.split(" ");
        LinkedHashSet<String> list = new LinkedHashSet<String>();
        for (int i = 0; i < arr.length; i++) {
            list.add(arr[i]);
        }
        for (String w : list) {
                if(flag==0)
                {
                    System.out.print(w);
                    flag = 1;
                }
                else System.out.print(" "+w);
        }
    }
}

7-6 GPS测绘中度分秒转换

在测绘中，获取经度和纬度信息的时候，可以是度分秒格式，也可以是小数点格式。例如一个北纬的纬度信息，30°41′52.37″ ，可以转换为 30.697881。

规则：
(1)度和分都是整数，秒可以含有小数。将用户输入的第一个整数，加上第二个整数除以60，再加上第三个浮点数除以3600，就是最终结果。

(2)在输出结果时，保留6位小数。

(3)题目假定用户输入的数据，一定是合法的数据。

输入格式:
三个数值，数之间用空格分开。

输出格式:
见输出样例。

输入样例:
两个整数后，跟上一个小数。数据之间用空格分开。三个数分别代表度、分、秒。

这道题比较简单用到的操作就是处理数据，特别要注意的是要进行浮点数的小数保留。

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int du;
        double fen;
        double miao;
        double total;
        du = input.nextInt();
        fen = input.nextInt();
        miao = input.nextDouble();
        total = du+fen/60+miao/3600;
        System.out.println(du+"°"+(int)fen+"′"+miao+"″"+" = "+String.format("%.6f", total));
    }
}

7-7 菜单计价程序-1

某饭店提供4种菜，每种菜品的基础价格如下：
西红柿炒蛋 15
清炒土豆丝 12
麻婆豆腐 12
油淋生菜 9

设计点菜计价程序，根据输入的订单，计算并输出总价格。
订单由一条或多条点菜记录组成，每条记录一行，最后以"end"结束
每条点菜记录包含：菜名、份额两个信息。
份额可选项包括：1、2、3，分别代表小、中、大份）

不同份额菜价的计算方法：
小份菜的价格=菜品的基础价格。
中份菜的价格=菜品的基础价格1.5。
小份菜的价格=菜品的基础价格2。
如果计算出现小数，按四舍五入的规则进行处理。

参考以下类的模板进行设计：
菜品类：对应菜谱上一道菜的信息。
Dish {
String name;//菜品名称
int unit_price; //单价
int getPrice(int portion)//计算菜品价格的方法，输入参数是点菜的份额（输入数据只能是1/2/3，代表小/中/大份）
}

菜谱类：对应菜谱，包含饭店提供的所有菜的信息。
Menu {
Dish[] dishs ;//菜品数组，保存所有菜品信息
Dish searthDish(String dishName)//根据菜名在菜谱中查找菜品信息，返回Dish对象。
}

点菜记录类：保存订单上的一道菜品记录
Record {
Dish d;//菜品
int portion;//份额（1/2/3代表小/中/大份）
int getPrice()//计价，计算本条记录的价格
}

订单类：保存用户点的所有菜的信息。
Order {
Record[] records；//保存订单上每一道的记录
int getTotalPrice()//计算订单的总价
Record addARecord(String dishName,int portion)
//添加一条菜品信息到订单中。
}

输入格式:
每条点菜记录的格式：
菜名+空格（英文）+份额
注：份额可输入（1/2/3）， 1代表小份，2代表中份，3代表大份。
最后一条记录以“end”结束。

输出格式:
订单上所有菜品的总价（整数数值），每份菜
如果订单中包含不能识别的菜名，则在总价之前输出“** does not exist”，**是不能识别的菜名

这道题应该是这次大作业里面最难的一道题目了，题目本意是让我们用面向对象的思想创建多个类，在写这道题的时候，我因为嫌麻烦还是用了面向过程的思想

import java.util.Scanner;

public class Main{
    public static void main(String[] args){
        Scanner input=new Scanner(System.in);
        String []wrong = new String[100];
        int n=0;
        String dish;
        String []menu =new String[]{"西红柿炒蛋","清炒土豆丝","麻婆豆腐","油淋生菜"};
        int price=0,size1;
        for(;;){
            int count=0;
            dish=input.next();
            if(dish.equals("end"))break;
            size1=input.nextInt();
            if(dish.equals(menu[0])){
                count=1;
                if(size1==1)price=price+15;
                if(size1==2)price=price+23;
                if(size1==3)price=price+30;
            }
            else if(dish.equals(menu[1])){
                count=1;
                if(size1==1)price=price+12;
                if(size1==2)price=price+18;
                if(size1==3)price=price+24;
            }
            else if(dish.equals(menu[2])){
                count=1;
                if(size1==1)price=price+12;
                if(size1==2)price=price+18;
                if(size1==3)price=price+24;
            }
            else if(dish.equals(menu[3])){
                count=1;
                if(size1==1)price=price+9;
                if(size1==2)price=price+14;
                if(size1==3)price=price+18;
            }
            if(count==0) {
                n++;
                wrong[n] = dish+" does"+" "+"not"+" "+"exist";
            }
        }
        if(n!=0) {
            for(int i=1;i<=n;i++) {
                System.out.print(wrong[i]+"\n");
            }
        }
        System.out.println(price);
    }
}

第三次大作业

7-1 jmu-java-日期类的基本使用

给定一个日期，判定是否为合法日期。如果合法，判断该年是否闰年，该日期是当年第几天、当月第几天、当周第几天、。
给定起始日期与结束日期，判定日期是否合法且结束日期是否早于起始日期。如果均合法，输出结束日期与起始日期之间的相差的天数、月数、念书。
输入格式:
第一行输入一个日期字符串，格式为"YYYY-MM-dd"
第二行输入两个日期字符串，中间使用空格隔开。分别代表开始日期与结束日期。

输出格式:
如果第一行日期字符串非法，输出自定义的错误信息。
如果第一行日期有效，输出相关信息，如果是闰年要输出是闰年。
如果第二行两个日期，只要有一个无效。就输出相关错误信息。
如果第二行两个日期有效且结束日期不早于开始日期，输出相关信息。

这道题由于国庆假期，没有做出来，只实现了部分的功能，只能判断是某年和某月的第几天，判断不了某周的第几天。

package Q1;

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        String date1;
        Scanner input = new Scanner(System.in);
        date1 = input.nextLine();
        String[] arr = date1.split("-");
        int y = Integer.parseInt(arr[0]);
        int m = Integer.parseInt(arr[1]);
        int d = Integer.parseInt(arr[2]);
        if(y%4==0) {
            if(m==1) {
                System.out.println(date1+"是闰年");
                System.out.println(date1+"是今年的第"+d+"天,当月第"+d+"天");
            }
            if(m==2) {
                System.out.println(date1+"是闰年");
                System.out.println(date1+"是今年的第"+(d+31)+"天,当月第"+d+"天");
            }
            if(m==3) {
                System.out.println(date1+"是闰年");
                System.out.println(date1+"是今年的第"+(d+60)+"天,当月第"+d+"天");
            }
            if(m==4) {
                System.out.println(date1+"是闰年");
                System.out.println(date1+"是今年的第"+(d+91)+"天,当月第"+d+"天");
            }
            if(m==5) {
                System.out.println(date1+"是闰年");
                System.out.println(date1+"是今年的第"+(d+121)+"天,当月第"+d+"天");
            }
            if(m==6) {
                System.out.println(date1+"是闰年");
                System.out.println(date1+"是今年的第"+(d+152)+"天,当月第"+d+"天");
            }
            if(m==7) {
                System.out.println(date1+"是闰年");
                System.out.println(date1+"是今年的第"+(d+182)+"天,当月第"+d+"天");
            }
            if(m==8) {
                System.out.println(date1+"是闰年");
                System.out.println(date1+"是今年的第"+(d+213)+"天,当月第"+d+"天");
            }
            if(m==9) {
                System.out.println(date1+"是闰年");
                System.out.println(date1+"是今年的第"+(d+244)+"天,当月第"+d+"天");
            }
            if(m==10) {
                System.out.println(date1+"是闰年");
                System.out.println(date1+"是今年的第"+(d+274)+"天,当月第"+d+"天");
            }
            if(m==11) {
                System.out.println(date1+"是闰年");
                System.out.println(date1+"是今年的第"+(d+305)+"天,当月第"+d+"天");
            }
            if(m==12) {
                System.out.println(date1+"是闰年");
                System.out.println(date1+"是今年的第"+(d+335)+"天,当月第"+d+"天");
            }
        }
        if(y%4!=0) {
            if(m==1) {
                System.out.println(date1+"是今年的第"+d+"天,当月第"+d+"天");
            }
            if(m==2) {
                System.out.println(date1+"是今年的第"+(d+31)+"天,当月第"+d+"天");
            }
            if(m==3) {
                System.out.println(date1+"是今年的第"+(d+59)+"天,当月第"+d+"天");
            }
            if(m==4) {
                System.out.println(date1+"是今年的第"+(d+90)+"天,当月第"+d+"天");
            }
            if(m==5) {
                System.out.println(date1+"是今年的第"+(d+120)+"天,当月第"+d+"天");
            }
            if(m==6) {
                System.out.println(date1+"是今年的第"+(d+151)+"天,当月第"+d+"天");
            }
            if(m==7) {
                System.out.println(date1+"是今年的第"+(d+181)+"天,当月第"+d+"天");
            }
            if(m==8) {
                System.out.println(date1+"是今年的第"+(d+212)+"天,当月第"+d+"天");
            }
            if(m==9) {
                System.out.println(date1+"是今年的第"+(d+243)+"天,当月第"+d+"天");
            }
            if(m==10) {
                System.out.println(date1+"是今年的第"+(d+273)+"天,当月第"+d+"天");
            }
            if(m==11) {
                System.out.println(date1+"是今年的第"+(d+304)+"天,当月第"+d+"天");
            }
            if(m==12) {
                System.out.println(date1+"是今年的第"+(d+334)+"天,当月第"+d+"天");
            }
        }
    }
}

7-4 判断两个日期的先后，计算间隔天数、周数

从键盘输入两个日期，格式如：2022-06-18。判断两个日期的先后，并输出它们之间间隔的天数、周数（不足一周按0计算）。

预备知识：通过查询Java API文档，了解Scanner类中nextLine()等方法、String类中split()等方法、Integer类中parseInt()等方法的用法，了解LocalDate类中of()、isAfter()、isBefore()、until()等方法的使用规则，了解ChronoUnit类中DAYS、WEEKS、MONTHS等单位的用法。

输入格式:



输入两行，每行输入一个日期，日期格式如：2022-06-18




输出格式:




第一行输出：第一个日期比第二个日期更早（晚）
第二行输出：两个日期间隔XX天
第三行输出：两个日期间隔XX周


 




在这道题了判断两个日期先后可以用isbefore（）函数来实现判断，还有一个难点在于如何将输入的日期给格式化，在这里我用到了charAt（）函数，对输入的字符串进行检测，当不符合yyyy-mm-dd的要求的时候，在月份和年份前面补上0，使其成为标准格式。




import java.time.LocalDate;
import java.time.temporal.ChronoUnit;
import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        String date1;
        String date2;
        Scanner input = new Scanner(System.in);
        date1 = input.nextLine();
        date2 = input.nextLine();
        char flag1= date1.charAt(4);
        char flag2= date2.charAt(4);
        StringBuilder D1 = new StringBuilder(date1);
        StringBuilder D2 = new StringBuilder(date2);
        int length1 = D1.length();
        int length2 = D2.length();
        
        if(D1.charAt(6)==flag1)
            D1.insert(5,"0");
        if(D1.length()!=10)
            D1.insert(8,"0");
        
        if(D2.charAt(6)==flag2)
            D2.insert(5,"0");
        if(D2.length()!=10)
            D2.insert(8,"0");
        
        LocalDate Date1 = LocalDate.parse(D1);
        LocalDate Date2 = LocalDate.parse(D2);
        if(Date1.isBefore(Date2)){
            System.out.println("第一个日期比第二个日期更早");
        }
        else{
            System.out.println("第一个日期比第二个日期更晚");
        }
        long days = ChronoUnit.DAYS.between(Date1, Date2);
        if (days<0)
            days = days*(-1);
        System.out.println("两个日期间隔"+days+"天");
        int weeks = (int) (days/7);
        System.out.println("两个日期间隔"+weeks+"周");
    }
}




实验收获


通过参与这几次实验，我获得了以下几方面的收获：


    

  1. 

    了解了面向对象程序设计的基本概念和原则。在实验中，我们通过设计类、对象和继承关系等来模拟现实世界的场景，体会到了面向对象思想的强大之处。
    

    2. 

  2. 

    提高了编程能力和代码质量。在实验中，我们需要遵循良好的编码规范和设计原则，编写清晰、简洁、可维护的代码。这有助于提高我的编程技巧和代码质量。
    

    3. 

  3. 

    锻炼了团队合作和沟通能力。在实验中，我们组成小组一起完成任务，需要共同讨论问题、制定计划，并协作解决各种困难和挑战。这锻炼了我们的团队合作和沟通能力。
    

    4. 

  4. 

    增强了问题解决能力和调试技巧。在实验过程中，我们遇到了许多编程问题和错误，需要通过调试和排查来解决。这让我更加熟悉了调试工具和技巧，提高了我解决问题的能力。
    

    5. 



结语


        通过这次面向对象程序设计实验，我深入理解了面向对象的思想和方法，掌握了面向对象程序设计的基本技巧。同时，我也意识到学习编程不仅仅是学习语法和工具，更重要的是培养良好的编程思维和设计能力。通过不断实践和学习，我相信我会在未来的编程之路上不断成长和进步。