BLOG-3

一、前言

面向对象程序设计（Object-Oriented Programming，简称OOP）是一种编程范式，它以对象作为程序的基本单元，将数据和操作封装在一起。面向对象程序设计的基本概念包括类、对象、继承、多态等。

  • 类（Class）是面向对象程序设计的基本构建块，它是一种抽象的数据类型，用于描述具有相同属性和行为的对象的集合。类定义了对象的属性（成员变量）和行为（方法）。

  • 对象（Object）是类的实例化结果，它是具体的、有状态的实体。对象可以根据类的定义，拥有自己的属性值，并能执行类中定义的方法。

  • 继承（Inheritance）是一种机制，允许在已有类的基础上创建新类，新类可以继承和扩展已有类的属性和方法。继承能够提供代码的重用性和层次化的组织结构。

  • 多态（Polymorphism）是指同一类型的对象在不同的情况下可以表现出不同的行为。多态性可以通过继承和接口实现，使得程序可以根据上下文选择合适的方法。

面向对象程序设计的优点包括代码的可重用性、可扩展性、易维护性和模块化等。它提供了一种更加灵活和抽象的编程方式，使得程序的设计和实现更加清晰和可管理。在前三次的作业中我主要使用了创建类和对象的知识，并未涉及到继承和多态的有关知识的运用。

 

二、作业分析

1.课程成绩统计程序-2

类图如下：

 

 

代码如下：

import java.text.Collator;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Locale;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        String tip = s.nextLine();
        systemin pi=new systemin();
        while (!tip.equals("end")) {
            pi.systemin(tip);
            tip = s.nextLine();
        }
        pi.Sort();
        pi.getnum();
        pi.getcourse();
        pi.getclass();
    }
}

abstract class gd{
    double Totalgd;
    public int getTotalgd() {
        return (int) Totalgd;
    }
    public int getUsualgd() {
        return 0;
    }
    public int getFinalgd() {
        return 0;
    }
}

class Examgd extends gd{
    int Usualgd;
    int Finalgd;
    public int getTotalgd(){
        return (int)(0.3*this.getUsualgd()+0.7*this.getFinalgd());
    }
    public int getUsualgd() {
        return Usualgd;
    }
    public void setUsualgd(int usualgd) {
        Usualgd = usualgd;
    }
    public int getFinalgd() {
        return Finalgd;
    }
    public void setFinalgd(int finalgd) {
        Finalgd = finalgd;
    }
}


class NoExamgd extends gd{
    int Finalgd;
    public int getTotalgd(){
        return Finalgd;
    }
    public int getFinalgd() {
        return Finalgd;
    }
    public void setFinalgd(int finalgd) {
        Finalgd = finalgd;
    }
}


class Course{
    String name;
    String kind;
    String method;

    public Course(String name, String kind, String method) {
        this.name = name;
        this.kind = kind;
        this.method = method;
    }
    public String getName() {
        return name;
    }
    public String getMethod() {
        return method;
    }
}

class Student{
    String num;
    String name;
    public Student(String num, String name) {
        this.num = num;
        this.name = name;
    }
    public String getNum() {
        return num;
    }
    public String getName() {
        return name;
    }
}


class SelectCourse{
    Course course;
    Student student;
    gd gd;
    public Course getCourse() {
        return course;
    }
    public void setCourse(Course course) {
        this.course = course;
    }
    public Student getStudent() {
        return student;
    }
    public void setStudent(Student student) {
        this.student = student;
    }
    public gd getgd() {
        return gd;
    }
    public void setgd(gd gd) {
        this.gd = gd;
    }
}

class systemin{
    private final ArrayList<SelectCourse> selectCourses = new ArrayList<>();
    private final ArrayList<Course> courses = new ArrayList<>();
    private final ArrayList<Student> students = new ArrayList<>();
    private final ArrayList<String> Class = new ArrayList<>();
    private final HashMap<String,String> cm=new HashMap();
    public void systemin(String input){
        String []inputs=input.split(" ");
        if(Imatch.minput(input)==1){
            cm.put(inputs[0],inputs[2]);
            if(checkC(inputs[0])!=null)return;
            else {
                if(inputs[1].equals("必修")&&(!inputs[2].equals("考试"))){
                    System.out.println(inputs[0]+" : course type & access mode mismatch");
                }
                else if(inputs[1].equals("选修")&&!(inputs[2].equals("考试")||inputs[2].equals("考察"))){
                    System.out.println(inputs[0]+" : course type & access mode mismatch");
                }
                else if(inputs[1].equals("实验")&&!(inputs[2].equals("实验"))){
                    System.out.println(inputs[0]+" : course type & access mode mismatch");
                }
                else courses.add(new Course(inputs[0],inputs[1],inputs[2]));
            }
        }
        else if(Imatch.minput(input)==2){
            Course findcourse=checkC(inputs[2]);
            if(inputs.length>5&&(Integer.parseInt(inputs[3])<4||Integer.parseInt(inputs[3])>9)) {
                System.out.println("wrong format");
                return;
            }
            Student newStudent = new Student(inputs[0],inputs[1]);
            if(!checkStudent(newStudent.getNum()))students.add(newStudent);
            if(!checkClass(inputs[0].substring(0,6))){
                Class.add(inputs[0].substring(0,6));
            }
            if(cs(inputs[0],inputs[2]))return;
            if(findcourse==null){

                System.out.println(inputs[2]+" does not exist");
                return;
            }
            else if(findcourse.getMethod().equals("考试")&&inputs.length!=5){
                System.out.println(inputs[0]+' '+inputs[1]+" : access mode mismatch");
            }
            else if(findcourse.getMethod().equals("考察")&&inputs.length!=4){
                System.out.println(inputs[0]+' '+inputs[1]+" : access mode mismatch");
            }
            else if(findcourse.getMethod().equals("实验")&&(inputs.length-4!=Integer.parseInt(inputs[3]))){
                System.out.println(inputs[0]+' '+inputs[1]+" : access mode mismatch");
            }
            else{
                SelectCourse newSelectCourse=new SelectCourse();
                newSelectCourse.setCourse(findcourse);
                gd gd=null;
                if(findcourse.getMethod().equals("考试")){
                    Examgd examgd=new Examgd();
                    examgd.setUsualgd(Integer.parseInt(inputs[3]));
                    examgd.setFinalgd(Integer.parseInt(inputs[4]));
                    gd=examgd;
                }
                else if(findcourse.getMethod().equals("实验")){
                    NoExamgd noExamgd=new NoExamgd();
                    double sumScore=0;
                    for (int i=4;i<inputs.length;i++)sumScore+=Integer.parseInt(inputs[i]);
                    noExamgd.setFinalgd((int)(sumScore/Integer.parseInt(inputs[3])));
                    gd=noExamgd;
                }
                else {
                    NoExamgd noExamgd=new NoExamgd();
                    noExamgd.setFinalgd(Integer.parseInt(inputs[3]));
                    gd=noExamgd;
                }
                newSelectCourse.setgd(gd);
                newSelectCourse.setStudent(newStudent);
                selectCourses.add(newSelectCourse);
            }
        }
        else System.out.println("wrong format");
    }

    private Course checkC(String courseName){
        for (Course course:courses){
            if(course.getName().equals(courseName))return course;
        }
        return null;
    }
    
    private Boolean checkStudent(String num){
        for (Student student:students){
            if(student.getNum().equals(num))return true;
        }
        return false;
    }
    private Boolean checkClass(String classnum){
        for (String cname:Class){
            if(cname.equals(classnum))return true;
        }
        return false;
    }

    private Boolean cs(String stunum,String cname){
        for (SelectCourse selectCourse:selectCourses){
            if(selectCourse.getStudent().getNum().equals(stunum)&&selectCourse.getCourse().getName().equals(cname))return true;
        }
        return false;
    }

    public void getnum(){

        for (Student student:students){
            double sum=0;
            int count=0;
            for (SelectCourse selectCourse:selectCourses){
                if (selectCourse.getStudent().getNum().equals(student.getNum()))
                {
                    sum+=selectCourse.getgd().getTotalgd();
                    count++;
                }
            }
            if(count==0) System.out.println(student.getNum()+' '+student.getName()+' '+"did not take any exams");
            else System.out.println(student.getNum()+' '+student.getName()+' '+(int)(sum/count));
        }
    }
    public void getcourse(){
        for (Course course:courses){
            double sumUsualScore=0;
            double sumFinalScore=0;
            double sumTotalScore=0;
            int count=0;
            for(SelectCourse selectCourse:selectCourses){
                if(selectCourse.getCourse().getName().equals(course.getName())){
                    count++;
                    sumTotalScore+=selectCourse.getgd().getTotalgd();
                    sumFinalScore+=selectCourse.getgd().getFinalgd();
                    if(selectCourse.getCourse().getMethod().equals("考试")){
                        sumUsualScore+=selectCourse.getgd().getUsualgd();
                    }
                }
            }
            if (count==0) System.out.println(course.getName()+' '+"has no grades yet");
            else if(course.getMethod().equals("考试"))System.out.println(course.getName()+' '+(int)(sumUsualScore/count)+' '+(int)(sumFinalScore/count)+' '+(int)(sumTotalScore/count));
            else if(course.getMethod().equals("考察"))System.out.println(course.getName()+' '+(int)(sumFinalScore/count)+' '+(int)(sumTotalScore/count));
            else if(course.getMethod().equals("实验"))System.out.println(course.getName()+' '+(int)(sumFinalScore/count));
        }
    }
    public void getclass(){
        for (String classnum:Class){
            double sum=0;
            int count=0;
            for (SelectCourse selectCourse:selectCourses){
                if(selectCourse.getStudent().getNum().substring(0,6).equals(classnum)){
                    sum+=selectCourse.getgd().getTotalgd();
                    count++;
                }
            }
            if(count==0) System.out.println(classnum+' '+"has no grades yet");
            else System.out.println(classnum+' '+(int)(sum/count));
        }
    }
    public void Sort(){
        students.sort(Comparator.comparing(Student::getNum));
        courses.sort((x,y)->{
            Collator instance = Collator.getInstance(Locale.CHINA);
            return instance.compare(x.getName(), y.getName());
        } );
        Collections.sort(Class);
    }
}

class Imatch {
    static String stuNumMatching = "[0-9]{8}";
    static String stuNameMatching = "\\S{1,10}";
    static String scoreMatching = "(\\d|[1-9]\\d|100)";
    static String courseNameMatching = "\\S{1,10}";
    static String courseTypeMatching = "(选修|必修|实验)";
    static String  checkcourseTypeMatching = "(考试|考察|实验)";
    static String courseInput = courseNameMatching + " " + courseTypeMatching + " " + checkcourseTypeMatching;
    static String scoreInput = stuNumMatching + " " + stuNameMatching + " " + courseNameMatching + " " +
            scoreMatching + "(\\s"+scoreMatching+")*";
    public static int minput(String s) {
        if (matchingCourse(s)) {
            return 1;
        }
        if (matchingScore(s)) {
            return 2;
        }
        return 0;
    }
    private static boolean matchingCourse(String s) {
        return s.matches(courseInput);
    }
    private static boolean matchingScore(String s) {
        return s.matches(scoreInput);
    }

}

 

 2.课程成绩统计程序-3

 不会，没写出来。

 

 3.立体图形问题

 类图如下：

 

代码如下：

import java.util.Scanner;
import java.lang.Math;

abstract class Solid {
    abstract double getSurfaceArea();
    abstract double getVolume();
}

class Cube extends Solid {
    private double side;

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

    @Override
    double getSurfaceArea() {
        return 6 * Math.pow(side,2);
    }

    @Override
    double getVolume() {
        return Math.pow(side,3);
    }
}

class RegularPyramid extends Solid {
    private double side;

    public RegularPyramid(double side) {
        this.side = side;
    }

    @Override
    double getSurfaceArea() {
        return Math.sqrt(3) * Math.pow(side,2);
    }

    @Override
    double getVolume() {
        return Math.sqrt(2) * Math.pow(side,3)/12;
    }
}

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        double side = sc.nextDouble();

        display(new Cube(side));
        display(new RegularPyramid(side));
    }

    public static void display(Solid solid) {
        System.out.println(String.format("%.2f", solid.getSurfaceArea()));
        System.out.println(String.format("%.2f", solid.getVolume()));
    }
}

分析：基本不难，就是三棱锥的表面积和体积公式写不对，三棱锥的表面积是4个边长为a的等边三角形，而等边三角形的面积公式是√3/4a2，三棱锥的表面积公式就是√3a2；三棱锥的高是√2/(3√3)a，三棱锥的体积就是√2/12a3。

 

4.魔方问题

类图如下：

代码如下：

import java.util.Scanner;
import java.lang.Math;

abstract class Solid {
    abstract String Colour();
    abstract double getSurfaceArea();
    abstract double getVolume();
}

class Cube extends Solid {
    private String colour;
    private int order;
    private double side;

    public Cube(String colour,int order,double side) {
        this.colour = colour;
        this.order = order;
        this.side = side;
    }

    @Override
    String Colour(){
        return colour;
    }

    @Override
    double getSurfaceArea() {
        return 6 * Math.pow(side * order,2);
    }

    @Override
    double getVolume() {
        return Math.pow(side * order,3);
    }
}

class RegularPyramid extends Solid {
    private String colour;
    private int order;
    private double side;

    public RegularPyramid(String colour,int order,double side) {
        this.colour = colour;
        this.order = order;
        this.side = side;
    }

    @Override
    String Colour(){
        return colour;
    }

    @Override
    double getSurfaceArea() {
        return Math.sqrt(3) * Math.pow(side * order,2);
    }

    @Override
    double getVolume() {
        return Math.sqrt(2) * Math.pow(side * order,3)/12;
    }
}

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String colour1 = sc.next();
        int order1 = sc.nextInt();
        double side1 = sc.nextDouble();
        String colour2 = sc.next();
        int order2 = sc.nextInt();
        double side2 = sc.nextDouble();
        display(new Cube(colour1,order1,side1));
        display(new RegularPyramid(colour2,order2,side2));
    }

    public static void display(Solid solid) {
        System.out.println(solid.Colour());
        System.out.println(String.format("%.2f", solid.getSurfaceArea()));
        System.out.println(String.format("%.2f", solid.getVolume()));
    }
}

分析：以上一题为基础，增加了颜色和阶数以及区分是立方体还是三棱锥。现在边长a变成了小单元的边长，乘上一个阶数就是整个魔方的边长。就是在公式的地方边长后面在乘上一个阶数即可。

 

5.魔方排序问题

有点思路，但前面计算三棱锥表面积和体积浪费了太多时间，没写出来。

 

6. 销售步枪问题（附加题）

没做。

 

三、总结

　　通过完成这三次pta的作业，我发现我在Java上有很多地方不明白，具体是哪儿不明白又说不上来。

posted @ 2023-12-09 21:28  zasmaxes  阅读(29)  评论(0)    收藏  举报