PTA第三阶段题目集总结以及对课程的建议

总结部分：

 

1.前言

• 题目集7

　　　　　　   题目集4只有一题，整体难度中偏易

　　　　　　　题目7-1是对题目集4中的计价程序进行不同于题目集6的一种迭代，增加了口味度，并要求对每桌客人的口味度进行平均值计算。

• 题目集8

　　　　　　   题目集8也只有一题，整体难度偏易

　　　　　　   题目7-1给出了参考类图，要求设计一个程序对学生的课程成绩进行统计。

• 题目集9

　　　　　　　题目集9只有一题，题目量少但难度适中

　　　　　　　题目7-1要求编写程序统计一个输入的Java源码中关键字（区分大小写）出现的次数。（代码行数尽量少）

• 题目集10　

　　　　　　　题目集10题量适中，整体难度适中

　　　　　　　题目7-1要求编写程序储存学生信息并使用HashMap根据学生的学号对学生进行检索

　　　　　　　题目7-2要求编写程序储存学生信息并使用HashMap根据学生的学号进行排序，相当于上一题的变种

　　　　　　   题目7-3课程成绩统计程序-2，对题目集8的课程成绩统计程序进行迭代，新增课程类型实验课，课程最终成绩为各次实验的平均分

　　　　　　   题目7-4动物发声模拟器，利用多态实现，题目较为简单

• 题目集11

  　　　　　　题目7-1 容器-ArrayList-排序，利用容器ArrayList类对学生的成绩进行排序，较为简单

　　　　　　  题目7-2  课程成绩统计程序-3，再对题目集10中的课程成绩统计程序进行迭代，可以根据输入的课程分权重进行对学生成绩的计算

　　　　　　  题目7-3 Java-02基本语法-03-身份证排序，根据输入的身份证号提取出生日期并进行排序输出

  　　　　　　题目7-4 面向对象进阶-03-接口-自定义接口ArrayIntegerStack，自定义类模拟栈的实现

　　　　　　  题目7-5 Java-03面向对象基础-05-覆盖，定义PersonOverride类并覆盖其toString与equals方法。

2.设计与分析

　　OOP训练集7

　　　　　　7-1 菜单计价程序-5

　　　　　　对Dish类进行修改，新增taste和tasteValue属性用于对顾客的口味值进行统计，再对Main类中的方法进行修改即可完成解答

　　　　　　最终的类图如下：

 　　　　　　源码如下：

　　　　　　

import java.text.ParseException;
import java.time.LocalDate;
import java.time.LocalTime;
import java.util.Scanner;

@SuppressWarnings("unused")
public class Main {

    @SuppressWarnings("resource")
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner input = new Scanner(System.in);
        boolean islocked = false ;
        boolean isout = false ;
        
        String str;
        String[] s;
        Table table = new Table();
        Table[] tablelist = {table};
        Menu menu = Menu.getMenu();
        while(true) {
            str = input.nextLine();
            s = str.split(" ");
            
            //桌号
            if(s[0].matches("table")) {
                
                Order ordernew = new Order();
                Table tablenew = new Table();
                String[] arr_date = s[5].split("/");
                s[6] = s[6].replaceAll("/", ":");
                
                if(!s[1].matches("\\d+")) {
                    System.out.println("wrong format");
                    islocked = true;
                    continue;
                }
                
                LocalDate date = LocalDate.of(Integer.valueOf(arr_date[0]),Integer.valueOf(arr_date[1]) , Integer.valueOf(arr_date[2]));
                LocalTime time = LocalTime.parse(s[6]);
                tablenew = new Table(Integer.valueOf(s[1]),date,time,ordernew,s[3],s[4]);
                
                if(tablenew.isLegalOfTime() == 0) {
                    System.out.println("table " + tablenew.getTableNum() + " out of opening hours");
                    islocked = true;
                    continue;
                }
                
                if(tablenew.isLegelOfTelephone() && tablenew.isLegelOfName()) {
                    System.out.println("wrong format");
                    islocked = true;
                    continue ;
                }
                
//                System.out.println("table " + tablenew.getTableNum() + ": ");
                tablelist = addtable(tablelist , tablenew);
                isout = true;
            }
            
            //end退出循环
            else if(s[0].matches("end")) {
                break;
            }
            
            //对订单的操作
            else if(s[0].matches("\\d+") && !islocked) {
                
                if(s[1].matches("delete")) {
                    if(!getlasttable(tablelist).getOrder().isExistOrderNum(Integer.valueOf(s[0]))) {
                        System.out.println("delete error");
                    }
                    else
                        getlasttable(tablelist).getOrder().delARecordByOrderNum(Integer.valueOf(s[0]));
                }
                
                else if(s[1].matches("\\d")) {        //带点菜
                    
                }
                
                else {
                    //菜品不存在
                    try {
                        if(menu.searthDish(s[1]).equals(null)) {  
                            System.out.println(s[1] + " does not exist");
                            continue;
                        }
                    }catch(Exception e) {
                        System.out.println("wrong format");
                        continue;
                    }
                    try {
                        if(s.length == 4) {   //非特色菜
                            getlasttable(tablelist).getOrder().addARecord(Integer.valueOf(s[0]), s[1], Integer.valueOf(s[2]), Integer.valueOf(s[3]));
//                            System.out.println(Integer.valueOf(s[0]) + " " + s[1] + " " + menu.searthDish(s[1]).getPrice(Integer.valueOf(s[2]))*Integer.valueOf(s[3]));
                        }
                        if(s.length == 5) {   //特色菜
                            
                            getlasttable(tablelist).getOrder().addARecord(Integer.valueOf(s[0]), s[1], Integer.valueOf(s[3]), Integer.valueOf(s[4]) , Integer.valueOf(s[2]));
//                            System.out.println(Integer.valueOf(s[0]) + " " + s[1] + " " + menu.searthDish(s[1]).getPrice(Integer.valueOf(s[3]))*Integer.valueOf(s[4]));
                            
                        
                        }
                    }catch(Exception e) {
                        System.out.println("wrong format");
                        continue;
                    }
                }
            }
            
            //菜单加菜
            else {
                if(!islocked) {
                    if(!isout) {
                        try {
                            if(menu.searthDish(s[0]) == null) {
                                if(s.length == 2)
                                    menu.addDish(s[0], Integer.valueOf(s[1]));
                                else
                                    menu.addDish(s[0], Integer.valueOf(s[2]),true,s[1]);
                            }
                            else {
                                if(s.length == 2)
                                    menu.changeMenu(s[0], Integer.valueOf(s[1]));
                                else
                                    menu.changeSpecialMenu(s[0], s[1], Integer.valueOf(s[2]));
                                    
                            }
                        }catch(Exception e) {
                            System.out.println("wrong format");
                            continue;
                        }
                    }
                    else
                        System.out.println("invalid dish");
                }
            }
            
        }
        for(Table t : tablelist) {
            if(t != null ) {
                try {
                    if( t.getOrder().getTotalPrice() > 0) {
                        System.out.println("table " + t.getTableNum() + ": ");
                        for(Record r : t.getOrder().getRecords()) {
                            if(!r.getD().isSpecial()) {
                                System.out.println(r.getOrderNum() + " " + r.getD().getName() + " " +r.getPrice());
                            }
                            else {
                                if(isLegalOfValue(r.getD().getTaste(),r.getTastevalue())) {
                                    System.out.println(r.getOrderNum() + " " + r.getD().getName() + " " +r.getPrice());
                                }
                            }
                        }
                    }
                }catch(Exception e) {
                    break;
                }
            }
        }
        
        
        
        //循环结束输出各桌的总价以及折扣价
                
                for(Table t : tablelist) {
                    int pricefinal = 0;
                    int numofchuan = 0;  //川菜数
                    int spiciness = 0;     //辣度总和
                    int numofjin = 0;      //晋菜数
                    int acidity = 0;       //酸度总和
                    int numofzhe = 0;      //浙菜数
                    int sweetness =0;      //甜度总和
                    if(t != null && tablelist.length > 1) {
                        if(t.isLegalOfTime() == 1){
                            for(Record r : t.getOrder().getRecords()) {
                                
                                
                                if(r.getD().isSpecial()) {
                                    
                                    if(!r.isLegaloftastevalue(r.getD().getTaste(), r.getTastevalue())) {
                                        r.setNum(0);
                                        continue;
                                    }
                                    if(r.getD().getTaste().matches("川菜")) {
                                        numofchuan += r.getNum();
                                        spiciness += r.getTastevalue()*r.getNum();
                                    }
                                    if(r.getD().getTaste().matches("晋菜")) {
                                        numofjin += r.getNum();
                                        acidity += r.getTastevalue()*r.getNum();
                                    }
                                    if(r.getD().getTaste().matches("浙菜")) {
                                        numofzhe += r.getNum();
                                        sweetness += r.getTastevalue()*r.getNum();
                                    }
                                }
                                if(r.getD().isSpecial())
                                    pricefinal += (int)(r.getPrice() * 0.7 + 0.6);
                                else
                                    pricefinal += (int)(r.getPrice() * 0.6 + 0.6);
                            }
                            t.setRealprice(pricefinal);
                            if(pricefinal > 0) {
                                System.out.print("table " + t.getTableNum() + ":" + " " + t.getOrder().getTotalPrice() + " " + pricefinal);
                            
                                if(numofchuan > 0)
                                    System.out.print(" 川菜 " + numofchuan + " " + convertToAverageTasteValue("川菜",numofchuan,spiciness));
                                if(numofjin > 0)
                                    System.out.print(" 晋菜 " + numofjin + " " + convertToAverageTasteValue("晋菜",numofjin,acidity));
                                if(numofzhe > 0)
                                    System.out.print(" 浙菜 " + numofzhe + " " + convertToAverageTasteValue("浙菜",numofzhe,sweetness));
                                System.out.println();
                            }
                        }
                    
                        else if(t.isLegalOfTime() == 2) {
                            for(Record r : t.getOrder().getRecords()) {
                                if(r.getD().isSpecial()) {    
                                    if(!r.isLegaloftastevalue(r.getD().getTaste(), r.getTastevalue())) {
                                        r.setNum(0);
                                        continue;
                                    }
                                    if(r.getD().getTaste() != null) {
                                        if(r.getD().getTaste().matches("川菜")) {
                                            numofchuan += r.getNum();
                                            spiciness += r.getTastevalue()*r.getNum();
                                        }
                                        if(r.getD().getTaste().matches("晋菜")) {
                                            numofjin += r.getNum();
                                            acidity += r.getTastevalue()*r.getNum();
                                        }
                                        if(r.getD().getTaste().matches("浙菜")) {
                                            numofzhe += r.getNum();
                                            sweetness += r.getTastevalue()*r.getNum();
                                        }
                                    }
                                }
                                if(r.getD().isSpecial())
                                    pricefinal += (int)(r.getPrice() * 0.7 + 0.6);
                                else
                                    pricefinal += (int)(r.getPrice() * 0.8 + 0.6);
                            }
                            t.setRealprice(pricefinal);
                            if(pricefinal >0) {
                                System.out.print("table " + t.getTableNum() + ":" + " " + t.getOrder().getTotalPrice() + " " + pricefinal);
                            
                                if(numofchuan > 0)
                                    System.out.print(" 川菜 " + numofchuan + " " + convertToAverageTasteValue("川菜",numofchuan,spiciness));
                                if(numofjin > 0)
                                    System.out.print(" 晋菜 " + numofjin + " " + convertToAverageTasteValue("晋菜",numofjin,acidity));
                                if(numofzhe > 0)
                                    System.out.print(" 浙菜 " + numofzhe + " " + convertToAverageTasteValue("浙菜",numofzhe,sweetness));
                                System.out.println();
                            }
                        }
                        
                        else if(t.isLegalOfTime() == 3) {
                            
                            for(Record r : t.getOrder().getRecords()) {
                                
                                if(!r.getD().isSpecial())
                                    continue;
                                if(!r.isLegaloftastevalue(r.getD().getTaste(), r.getTastevalue())) {
                                    r.setNum(0);
                                    continue;
                                }
                                if(r.getD().getTaste().matches("川菜")) {
                                    numofchuan += r.getNum();
                                    spiciness += r.getTastevalue()*r.getNum();
                                }
                                if(r.getD().getTaste().matches("晋菜")) {
                                    numofjin += r.getNum();
                                    acidity += r.getTastevalue()*r.getNum();
                                }
                                if(r.getD().getTaste().matches("浙菜")) {
                                    numofzhe += r.getNum();
                                    sweetness += r.getTastevalue()*r.getNum();
                                }
                            }
                            pricefinal =t.getOrder().getTotalPrice();
                            t.setRealprice(pricefinal);
                            if(pricefinal > 0) {
                                System.out.print("table " + t.getTableNum() + ":" + " " + t.getOrder().getTotalPrice() + " " + pricefinal);
                            
                                if(numofchuan > 0)
                                    System.out.print(" 川菜 " + numofchuan + " " + convertToAverageTasteValue("川菜",numofchuan,spiciness));
                                if(numofjin > 0)
                                    System.out.print(" 晋菜 " + numofjin + " " + convertToAverageTasteValue("晋菜",numofjin,acidity));
                                if(numofzhe > 0)
                                    System.out.print(" 浙菜 " + numofzhe + " " + convertToAverageTasteValue("浙菜",numofzhe,sweetness));
                                System.out.println();
                            }
                        }
                    }
                    
                }
        
        //根据人名输出价格
        for(int i = 1 ; i < tablelist.length ; i++) {
            for(int j = i + 1 ; j < tablelist.length ; j++) {
                if(tablelist[i].getName().compareToIgnoreCase(tablelist[j].getName()) > 0) {
                    Table temp = tablelist[i];
                    tablelist[i] = tablelist[j];
                    tablelist[j] = temp;
                }
            }
        }
        int[] paylist = new int[tablelist.length];
        for(int i = 1 ; i < tablelist.length ; i++) {
            paylist[i] = tablelist[i].getRealprice();
        }
        for(int i = 1 ; i < tablelist.length ; i++) {
            int j;
            for(j = i + 1 ; j <tablelist.length ; j++) {
                if(tablelist[i].getName().equals(tablelist[j].getName())) 
                    paylist[i] += paylist[j];  
                else
                    break;
            }
            if(paylist[i] > 0)
                System.out.println(tablelist[i].getName() + " " + tablelist[i].getTelephone() +" " + paylist[i]);
            i = j-1;
        }
//        for(int i = 1 ; i < tablelist.length ; i++) {
//            System.out.println(tablelist[i].getName());
//        }
        
    }
    
    /**
     * 用于获取tablelist中的最后一个table
     * @param tablelist
     * @return
     */
    public static  Table getlasttable(Table[] tablelist) {
        Table table = new Table();
        table = tablelist[tablelist.length - 1];
        return table; 
    }
    
    /**
     * 用于判定是否菜品序号正确排序
     * @param table
     * @param x
     * @return
     */
    public static boolean issort(Table table , int x) {
        if(table.equals(null))
            return true;
        boolean flag = true;
        for(Record i : table.getOrder().getRecords()) {
            if(i.getOrderNum() >= x) {
                flag = false;
                break;
            }
        }
        return flag;
    }
    
    
    /**
     * 用于向tablelist数组中增加Table,实现数组的扩容
     * @param tablelist  需要增加table的数组
     * @param tablenew   所增加的table
     * @return           扩容后的新的数组
     */
    public static Table[] addtable(Table[] tablelist , Table tablenew) {
        
        if(tablelist.length == 1) {
            Table[] tablelistnew = new Table[2];
            tablelistnew[1] = tablenew;
            return tablelistnew;
        }
        else {
            Table[] tablelistnew = new Table[tablelist.length + 1];
            for(int i = 0 ; i < tablelist.length ; i++) {
                tablelistnew[i] = tablelist[i];
            }
            tablelistnew[tablelist.length] = tablenew;
            return tablelistnew;
        }
        
    }
    /**
     * 根据菜系类型以及其他数据计算风味值
     * @param type       菜系类型
     * @param num        菜品数量
     * @param totalvalue 菜系风味值总和
     * @return
     */
    public static String convertToAverageTasteValue(String type, int num, int totalvalue) {
        int average = (int)((totalvalue*1.0/num*1.0)+0.6);
        if(type.matches("川菜")) {
            switch(average) {
            case 0:return "不辣";
            case 1:return "微辣";
            case 2:return "稍辣";
            case 3:return "辣";
            case 4:return "很辣";
            case 5:return "爆辣";
            }
        }
        if(type.matches("晋菜")) {
            switch(average) {
            case 0:return "不酸";
            case 1:return "微酸";
            case 2:return "稍酸";
            case 3:return "酸";
            case 4:return "很酸";
            }
        }
        if(type.matches("浙菜")) {
            switch(average) {
            case 0:return "不甜";
            case 1:return "微甜";
            case 2:return "稍甜";
            case 3:return "甜";
            }
        }
        return null;
    }
    /**
     * 用于判断是否风味值超范围
     * @param type 菜品类型
     * @param value 风味值
     * @return
     */
    public static boolean isLegalOfValue(String type, int value) {
        if(type.matches("川菜")) {
            if(value > -1 && value <6) 
                return true;
            else {
                System.out.println("spicy num out of range :" + value);
                return false;
            }
        }
        if(type.matches("晋菜")) {
            if(value > -1 && value <5) 
                return true;
            else {
                System.out.println("acidity num out of range :" + value);
                return false;
            }
        }
        if(type.matches("浙菜")) {
            if(value > -1 && value <4) 
                return true;
            else {
                System.out.println("sweetness num out of range :" + value);
                return false;
            }
        }
        return false;
    }
}




class Dish{
    private String name;//菜品名称
    private int unit_price; //单价
    private boolean special = false;
    private String taste;
    private int tasteValue;
    
    public Dish() {
        super();
        // TODO Auto-generated constructor stub
    }

    
    
    public Dish(String name, int unit_price) {
        super();
        this.name = name;
        this.unit_price = unit_price;
    }

    

    public Dish(String name, int unit_price, int tasteValue) {
        super();
        this.name = name;
        this.unit_price = unit_price;
        this.tasteValue = tasteValue;
    }



    public Dish(String name, int unit_price, boolean special) {
        super();
        this.name = name;
        this.unit_price = unit_price;
        this.special = special;
    }

    public Dish(String name, int unit_price, boolean special, String taste) {
        super();
        this.name = name;
        this.unit_price = unit_price;
        this.special = special;
        this.taste = taste;
    }



    public Dish(String name, int unit_price, boolean special, String taste, int tasteValue) {
        super();
        this.name = name;
        this.unit_price = unit_price;
        this.special = special;
        this.taste = taste;
        this.tasteValue = tasteValue;
    }

    public String getName() {
        return name;
    }

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

    public int getUnit_price() {
        return unit_price;
    }

    public void setUnit_price(int unit_price) {
        this.unit_price = unit_price;
    }

    public String getTaste() {
        return taste;
    }

    public void setTaste(String taste) {
        this.taste = taste;
    }

    public int getTasteValue() {
        return tasteValue;
    }

    public void setTasteValue(int tasteValue) {
        this.tasteValue = tasteValue;
    }
    
    public boolean isSpecial() {
        return special;
    }

    public void setSpecial(boolean special) {
        this.special = special;
    }

    /**
     * 
     * @return 口味错误返回false
     */
    public boolean isLegalOfTaste() {
        if(this.taste.matches("川菜"))
            return true;
        if(this.taste.matches("晋菜"))
            return true;
        if(this.taste.matches("浙菜"))
            return true;
        return false;
    }
    
    /**
     * 
     * @return 口味度超过正常范围返回false
     */
    public boolean isLegalOfTasteValue() {
        if(this.taste.matches("川菜")) {
            if(this.tasteValue > 5 || this.tasteValue < 0)
                return false;
        }
        if(this.taste.matches("晋菜")) {
            if(this.tasteValue > 4 || this.tasteValue < 0)
                return false;
        }
        if(this.taste.matches("浙菜")) {
            if(this.tasteValue > 3 || this.tasteValue < 0)
                return false;
        }
        return true;
    }
    
    /**
     * 计算菜品价格的方法，输入参数是点菜的份额（输入数据只能是1/2/3，代表小/中/大份）
     * @param portion  菜品的份额
     * @return         菜品的价格 小份菜的价格=菜品的基础价格。中份菜的价格=菜品的基础价格1.5。小份菜的价格=菜品的基础价格2。
     */
    public int getPrice(int portion){

        switch(portion) {
        case 1: return (int)(this.unit_price+0.6); 
        case 2: return (int)((this.unit_price*1.5)+0.6);
        case 3: return (int)((this.unit_price*2.0)+0.6);
        }            
        return 0;
    }
}
class Menu {
    private static Menu menu = null;
    private Dish[] dishs = {};
    
    private Menu() {
        
    }
    
    public static Menu getMenu() {
        if(menu == null)
            menu = new Menu();
        return menu;
    }

    public Dish[] getDishs() {
        return dishs;
    }

    public void setDishs(Dish[] dishs) {
        this.dishs = dishs;
    }
    
    /**
     * 根据菜品名称搜寻菜品
     * @param dishName  菜品名称
     * @return          菜品
     */
    public Dish searthDish(String dishName) {
        for(Dish i: dishs) {
            if(i.getName().equals(dishName))
                return i;
        }
        return null;
    }
    
    /**
     * 修改菜单信息
     * @param dishName
     * @param price
     * @param flag
     */
    public void changeSpecialMenu(String dishName , int price , boolean flag) {
        for(int i = 0 ; i < this.dishs.length ; i++) {
            if(dishName.equals(this.dishs[i].getName())) {
                dishs[i] = new Dish( dishName, price, flag);
            }
        }
    }
    
    public void changeSpecialMenu(String dishName ,String type, int price ) {
        for(int i = 0 ; i < this.dishs.length ; i++) {
            if(dishName.equals(this.dishs[i].getName())) {
                dishs[i] = new Dish( dishName, price, true, type);
            }
        }
    }
    
    /**
     * 修改菜单信息
     * @param dishName
     * @param price
     */
    public void changeMenu(String dishName , int price ) {
        for(int i = 0 ; i < this.dishs.length ; i++) {
            if(dishName.equals(this.dishs[i].getName())) {
                dishs[i] = new Dish( dishName, price);
            }
        }
    }
    
    /**
     * 菜单加菜
     * @param dishName
     * @param unit_price
     * @return
     */
    public Dish addDish(String dishName,int unit_price) {
        Dish dish = new Dish(dishName , unit_price , false);
        Dish[] newdishs = new Dish[this.dishs.length+1];
        for(int i = 0 ; i < this.dishs.length ; i++) {
            newdishs[i] = this.dishs[i];
        }
        newdishs[this.dishs.length] = dish;
        this.dishs = newdishs ;
        return dish;
    }
    
    /**
     * 菜单加菜
     * @param dishName
     * @param unit_price
     * @param special
     * @return
     */
    public Dish addDish(String dishName,int unit_price,boolean special) {
        Dish dish = new Dish(dishName , unit_price , true);
        if(this.searthDish(dishName).getName().equals(dishName)) {
            for(int i = 0 ; i < this.dishs.length ; i++) {
                if(this.dishs[i].getName().equals(dishName)) {
                    this.dishs[i].setUnit_price(unit_price);
                    this.dishs[i].setSpecial(special);
                }
            }
        }
        else {
            Dish[] newdishs = new Dish[this.dishs.length+1];
            for(int i = 0 ; i < this.dishs.length ; i++) {
                newdishs[i] = this.dishs[i];
            }
            newdishs[this.dishs.length] = dish;
            this.dishs = newdishs ;
        }
        
        return dish;
    }
    
    /**
     * 菜单增加特色菜
     * @param dishName        菜名
     * @param unit_price      价格
     * @param special         
     * @param taste           风味
     * @return
     */
    public Dish addDish(String dishName , int unit_price , boolean special , String taste ) {
        Dish dish = new Dish(dishName , unit_price , special , taste );
        Dish[] newdishs = new Dish[this.dishs.length+1];
        for(int i = 0 ; i < this.dishs.length ; i++) {
            newdishs[i] = this.dishs[i];
        }
        newdishs[this.dishs.length] = dish;
        this.dishs = newdishs ;
        return dish;
    }
}

class Order {
    Record[] records = {};//保存订单上每一道的记录

    public Order(Record[] records) {
        super();
        this.records = records;
    }

    public Order() {
        super();
        // TODO Auto-generated constructor stub
    }

    public Record[] getRecords() {
        return records;
    }

    public void setRecords(Record[] records) {
        this.records = records;
    }
    
    public int getTotalPrice(){//计算订单的总价
        int total = 0;
        for(Record i: records) {
            total += i.getPrice();
        }
        return total;
    }
    
    public Record addARecord(int orderNum,String dishName,int portion,int num) {
        Menu menu = Menu.getMenu();
        Record record = new Record(orderNum ,menu.searthDish(dishName),portion,num);
        Record[] newrecords = new Record[this.records.length+1];
        for(int i = 0 ; i < this.records.length ; i++) {
            newrecords[i] = records[i];
        }
        newrecords[this.records.length] = record;
        this.records = newrecords;
        return record;
    }
    
    public Record addARecord(int orderNum,String dishName,int portion,int num,int tastevalue) {
        Menu menu = Menu.getMenu();
        Record record = new Record(orderNum ,menu.searthDish(dishName),portion,num,tastevalue);
        Record[] newrecords = new Record[this.records.length+1];
        for(int i = 0 ; i < this.records.length ; i++) {
            newrecords[i] = records[i];
        }
        newrecords[this.records.length] = record;
        this.records = newrecords;
        return record;
    }
    
    public void delARecordByOrderNum(int orderNum){//根据序号删除一条记录
        boolean flag =false;
        for(Record i : this.records) {
            if(i.getOrderNum() == orderNum)
                flag = true;
        }
        if(flag) {
            Record[] newrecords = new Record[this.records.length-1];
        for(int i = 0 ,k =0; i < this.records.length ; i++) {
            if(records[i].getOrderNum() != orderNum) {
                newrecords[k] = this.records[i];
                k++;
            }
        }
        this.records = newrecords;
        }
        else
            System.out.println("delete error");
    }
    
    public boolean isExistOrderNum(int orderNum) {
        boolean flag =false;
        for(Record i : this.records) {
            if(i.getOrderNum() == orderNum)
                flag = true;
        }
        return flag;
    }
}

 class Record {
    private int orderNum;//序号

    private Dish d;//菜品\\

    private int portion;//份额（1/2/3代表小/中/大份
    
    private int num;//份数

    private int tastevalue; //风味值
    
    public Record(int orderNum, Dish d, int portion,int num) {
        super();
        this.orderNum = orderNum;
        this.d = d;
        this.portion = portion;
        this.num = num;
    }

    public Record(int orderNum, Dish d, int portion, int num, int tastevalue) {
        super();
        this.orderNum = orderNum;
        this.d = d;
        this.portion = portion;
        this.num = num;
        this.tastevalue = tastevalue;
    }

    public Record() {
        super();
        // TODO Auto-generated constructor stub
    }

    public int getOrderNum() {
        return orderNum;
    }

    public void setOrderNum(int orderNum) {
        this.orderNum = orderNum;
    }

    public Dish getD() {
        return d;
    }

    public void setD(Dish d) {
        this.d = d;
    }

    public int getPortion() {
        return portion;
    }

    public void setPortion(int portion) {
        this.portion = portion;
    }
    
    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }

    public int getPrice() {
        
        return this.d.getPrice(this.portion)*num;
    }

    public int getTastevalue() {
        return tastevalue;
    }

    public void setTastevalue(int tastevalue) {
        this.tastevalue = tastevalue;
    }
    
    public boolean isLegaloftastevalue(String type, int value) {
        if(type.matches("川菜")) {
            if(value > -1 && value <6) 
                return true;
            else {
                
                return false;
            }
        }
        if(type.matches("晋菜")) {
            if(value > -1 && value <5) 
                return true;
            else {
                
                return false;
            }
        }
        if(type.matches("浙菜")) {
            if(value > -1 && value <4) 
                return true;
            else {
                return false;
            }
        }
        return false;
    }
    
}


 class Table {
private int tableNum;
    
    private LocalDate date;
    
    private LocalTime time;

    private Order order;
    
    private String name;
    private String telephone;
    private int realprice = 0;
    
    
    public Table(int tableNum, LocalDate date, LocalTime time, Order order, String name, String telephone) {
        super();
        this.tableNum = tableNum;
        this.date = date;
        this.time = time;
        this.order = order;
        this.name = name;
        this.telephone = telephone;
    }

    public Table(int tableNum, LocalDate date, LocalTime time, Order order) {
        super();
        this.tableNum = tableNum;
        this.date = date;
        this.time = time;
        this.order = order;
    }

    public Table() {
        super();
        // TODO Auto-generated constructor stub
    }

    public int getTableNum() {
        return tableNum;
    }

    public void setTableNum(int tableNum) {
        this.tableNum = tableNum;
    }

    public LocalDate getDate() {
        return date;
    }

    public void setDate(LocalDate date) {
        this.date = date;
    }

    public LocalTime getTime() {
        return time;
    }

    public void setTime(LocalTime time) {
        this.time = time;
    }
    
    public Order getOrder() {
        return order;
    }

    public void setOrder(Order order) {
        this.order = order;
    }

    public String getName() {
        return name;
    }

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

    public String getTelephone() {
        return telephone;
    }

    public void setTelephone(String telephone) {
        this.telephone = telephone;
    }

    public int getRealprice() {
        return realprice;
    }

    public void setRealprice(int realprice) {
        this.realprice = realprice;
    }

    /**
     * 判断名字长度是否大于10
     * @return
     */
    public boolean isLegelOfName(){
        if(this.name.length() > 10)
            return false;
        return true;
    }
    /**
     * 判断手机号格式
     * @return 正确返回true
     */
    public boolean isLegelOfTelephone() {
        String s = "^(18[019] | 13[356])[0-9]{8}$";
        if(this.telephone.matches(s) && this.telephone.length() == 11) {
            return true; 
        }
        return false;
    }
    public boolean isLegalOfTableNum() {
        if(this.tableNum >55 || this.tableNum <1)
            return false;
        else
            return true;
    }
    
    /**
     * 判断折扣
     * @return 返回0表示时间越界 ，1表示6折， 2表示8折 ， 3表示不打折
     */
    public int isLegalOfTime() {
        LocalTime time1 = LocalTime.parse("09:29:59");
        LocalTime time2 = LocalTime.parse("21:30:01");
        LocalTime time3 = LocalTime.parse("10:29:59");
        LocalTime time4 = LocalTime.parse("14:30:01");
        LocalTime time5 = LocalTime.parse("16:59:59");
        LocalTime time6 = LocalTime.parse("20:30:01");
        if(this.date.getDayOfWeek().getValue() == 6 || this.date.getDayOfWeek().getValue() == 7) {
            if(this.time.isAfter(time1) && this.time.isBefore(time2))
                return 3;
        }
        else {
            if((this.time.isAfter(time3) && this.time.isBefore(time4)))
                return 1;
            if((this.time.isAfter(time5) && this.time.isBefore(time6)))
                return 2;
        }
        return 0;
    }
    
    public boolean isValidDate() {
        LocalDate date1 = LocalDate.parse("2022-01-01");
        LocalDate date2 = LocalDate.parse("2023-12-31");
        if(this.date.isAfter(date1) && this.date.isBefore(date2))
            return true;
        else
            return false;
    }
    
}

　　　　OOP训练集8

　　　　　　7-1课程成绩统计程序-1

　　　　　　先根据类图写出了Student，Course，Class，Score四个类，然后写两个类ExamScores ，ExamineScores，并让其继承Score。

　　　　　　　接着在让各个类implements Comparable接口，用于排序。

　　　　　　最后再完成主方法的接口即可，最终类图如下：

  　　　　　　　　源码如下：

　　　　　　

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

public class Main {
    public static void main(String[] args){
        ArrayList<Course> courses = new ArrayList<>();
        ArrayList<CourseSelection> courseSelections = new ArrayList<>();
        ArrayList<Class> classes = new ArrayList<>();
        ArrayList<Student> students = new ArrayList<>();
        String str;
        Scanner input = new Scanner(System.in);
        boolean inputOver = false;
        while(!inputOver){
            str = input.nextLine();
            String[] strings = str.split(" ");
            if(strings.length == 3 && str.matches("^[\u4e00-\u9fa5A-Za-z]{1,10} (必修|选修) (考试|考察)$")){
                Course course = new Course(strings[0] , strings[1] , strings[2]);
                boolean repeat = false;
                if(!courses.isEmpty()){
                    for(Course c : courses ){
                        if(c.getName().equals(strings[0])){
                            repeat = true;
                            break;
                        }
                    }
                }
                if(repeat){
                    continue;
                }
                if(strings[1].equals("必修")){
                    if(strings[2].equals("考试"))
                        courses.add(course);
                    else
                        System.out.println(strings[0] + " : course type & access mode mismatch");
                }
                else
                    courses.add(course);
            }
            else if(strings.length == 1 && strings[0].equals("end")){
                inputOver = true;
            }

            //考核方式为考察
            else if (strings.length == 4 && str.matches("^\\d{8} [\u4e00-\u9fa5A-Za-z]{1,10} [\u4e00-\u9fa5A-Za-z]{1,10} (\\d|[1-9]\\d|100)$")) {
                if(isRepeatOfScore(courseSelections , strings[0] , strings[2])){
                    continue;
                }
                Score score = new ExamineScores(Integer.parseInt(strings[3]));

                Student student = new Student(strings[0] , strings[1]);
                if(students.isEmpty()){
                    students.add(student);
                }
                else{
                    boolean flag = false;
                    for (Student s : students){
                        if (s.getNumber().equals(student.getNumber())) {
                            flag = true;
                            break;
                        }
                    }
                    if(!flag){
                        students.add(student);
                    }
                }


                //classes增加班级
                if(classes.isEmpty()){
                    classes.add(new Class(student.getNumber().substring(0,6)));
                    classes.get(0).addStudent(student);
                }
                else{
                    //
                    boolean flag = false;
                    for (Class c : classes){
                        if(c.getNum().equals(student.getNumber().substring(0,6))){
                            flag = true;
                            c.addStudent(student);
                        }
                    }
                    if(!flag){
                        classes.add(new Class(student.getNumber().substring(0,6)));
                        for(Class c : classes){
                            if(c.getNum().equals(student.getNumber().substring(0,6))) {
                                c.addStudent(student);
                            }
                        }

                    }

                }
                //courses加入课程
                Course course = null;
                for(Course c : courses){
                    if (c.getName().equals(strings[2])){
                        course = c;
                    }
                }
                if(course == null){
                    System.out.println(strings[2] + " does not exist");
                    continue;
                }

                if (course.getTestMode().equals("考试")) {
                    System.out.println(student.getNumber() + " " + student.getName() + " : access mode mismatch");
                    continue;
                }

                addStudentAndClassScore(courseSelections, classes, students, score, student, course);


            }

            //考核方式为考试
            else if(strings.length == 5 && str.matches("^\\d{8} [\u4e00-\u9fa5A-Za-z]{1,10} [\u4e00-\u9fa5A-Za-z]{1,10} (\\d|[1-9]\\d|100) (\\d|[1-9]\\d|100)$")){
                if(isRepeatOfScore(courseSelections , strings[0] , strings[2])){
                    continue;
                }
                Score score = new ExamScores(Integer.parseInt(strings[3]) , Integer.parseInt(strings[4]));

                //students加入学生
                Student student = new Student(strings[0] , strings[1]);
                if(students.isEmpty()){
                    students.add(student);
                }
                else{
                    boolean flag = false;
                    for (Student s : students){
                        if (s.getNumber().equals(student.getNumber())) {
                            flag = true;
                            break;
                        }
                    }
                    if(!flag){
                        students.add(student);
                    }
                }

                //增加班级
                if(classes.isEmpty()){
                    classes.add(new Class(student.getNumber().substring(0,6)));
                    classes.get(0).addStudent(student);
                }
                else{
                    //
                    boolean flag = false;
                    for (Class c : classes){
                        if(c.getNum().equals(student.getNumber().substring(0,6))){
                            flag = true;
                            c.addStudent(student);
                        }
                    }
                    //如果没有找到与该学生相同的班级则新建一个
                    if(!flag){
                        classes.add(new Class(student.getNumber().substring(0,6)));
                        for(Class c : classes){
                            if(c.getNum().equals(student.getNumber().substring(0,6))) {
                                c.addStudent(student);
                            }
                        }

                    }

                }

                //courses加入课程
                Course course = null;
                for(Course c : courses){
                    if (c.getName().equals(strings[2])){
                        course = c;
                    }
                }
                if(course == null){
                    System.out.println(strings[2] + " does not exist");
                    continue;
                }

                if (course.getTestMode().equals("考察")) {
                    System.out.println(student.getNumber() + " " + student.getName() + " : access mode mismatch");
                    continue;
                }

                addStudentAndClassScore(courseSelections, classes, students, score, student, course);


            }
            else
                System.out.println("wrong format");
        }
        //输出学生的平均分
        students.sort(Comparator.naturalOrder());
        for(Student s : students){
            try{
                System.out.println(s.getNumber() + " "
                        + s.getName() + " "
                        + s.getAverageScore());
            }catch (Exception e){
                System.out.println(s.getNumber() + " " + s.getName() +" did not take any exams");
            }

        }


        //输出课程平均分
        for(CourseSelection selection : courseSelections ){
            for(Course course : courses){
                if(selection.getCourse().getName().equals(course.getName())){
                    if(selection.getScore() instanceof ExamScores){
                        course.addExamScore((ExamScores) (selection.getScore()));
                    }
                    else{
                        course.addExamineScore((ExamineScores) (selection.getScore()));
                    }
                }
            }
        }
        boolean legal = true;
        try {
            courses.sort(Comparator.naturalOrder());
        }catch (Exception e){
            for(Course course: courses){
                System.out.println(course.getName() +" has no grades yet");
                legal = false;
            }
        }
        if(legal){
            for (Course course : courses){
                try{
                    if(course.getAverageUsualScore() == 0){
                        System.out.println(course.getName() + " "
                                + course.getAverageFinalScore() + " "
                                + course.getAverageScore());
                    }
                    else {
                        System.out.println(course.getName() + " "
                                + course.getAverageUsualScore() + " "
                                + course.getAverageFinalScore() + " "
                                + course.getAverageScore());
                    }
                }catch (Exception e){
                    System.out.println(course.getName() +" has no grades yet");
                }

            }
        }



        //输出班级平均分
        classes.sort(Comparator.naturalOrder());
        for (Class c : classes){
            if(c.getClassAverageScore() != 0)
                System.out.println(c.getNum() + " " + c.getClassAverageScore());
            else
                System.out.println(c.getNum() + " has no grades yet");
        }
    }

    private static void addStudentAndClassScore(ArrayList<CourseSelection> courseSelections, ArrayList<Class> classes, ArrayList<Student> students, Score score, Student student, Course course) {
        for(Student s : students){
            if(s.getNumber().equals(student.getNumber())){
                s.addACourseOfScore(score.getScore());
            }
        }
        for (Class c : classes){
            if(c.getNum().equals(student.getNumber().substring(0,6))){
                c.addTotalScore(score.getScore());
            }
        }
        CourseSelection courseSelection = new CourseSelection(course , student , score);
        courseSelections.add(courseSelection);
    }

    public static boolean isRepeatOfScore(ArrayList<CourseSelection> courseSelections , String studentNum ,String courseName){
        boolean repeat = false;
        if(!courseSelections.isEmpty()){
            for (CourseSelection c : courseSelections){
                if(c.getStudent().getNumber().equals(studentNum) && c.getCourse().getName().equals(courseName)){
                    repeat = true;
                    break;
                }
            }
        }
        return repeat;
    }
}

 class Class implements Comparable<Class>{
    private String num;
    private ArrayList<Student> students = new ArrayList<>();
    private int totalScore = 0;

    public Class(String num) {
        this.num = num;
    }


    public String getNum() {
        return num;
    }


    public void addStudent(Student student){
        students.add(student);
    }

    public void addTotalScore(int studentScore){
        this.totalScore += studentScore;
    }

    public int getClassAverageScore(){
        return (int)(this.totalScore/students.size());
    }

    @Override
    public int compareTo(Class o) {
        if (Integer.parseInt(this.getNum()) > Integer.parseInt(o.getNum())) {
            return 1;
        }
        else if(Integer.parseInt(this.getNum()) < Integer.parseInt(o.getNum())) {
            return -1;
        }
        return 0;
    }
}
class CourseSelection implements Comparable<CourseSelection>{
    private Course course;
    private Student student;
    private Score score;


    public CourseSelection(Course course, Student student, Score score) {
        this.course = course;
        this.student = student;
        this.score = score;
    }

    public Course getCourse() {
        return course;
    }


    public Student getStudent() {
        return student;
    }



    public Score getScore() {
        return score;
    }


    @Override
    public int compareTo(CourseSelection o) {
        if(Integer.parseInt(this.student.getNumber()) > Integer.parseInt(o.getStudent().getNumber()))
            return 1;
        else if(Integer.parseInt(this.student.getNumber()) < Integer.parseInt(o.getStudent().getNumber()))
            return -1;
        return this.score.compareTo(o.score);
    }
}
 class Course implements Comparable<Course>{
    //课程名字
    private String name;
    //是否必修
    private String compulsory;
    //考核方式
    private String testMode;

    private int scoreTotal = 0;

    private int usualScoreTotal = 0;

    private int finalScoreTotal = 0;
    //选课人数
    private int num = 0;


    public Course(String name, String compulsory, String testMode) {
        this.name = name;
        this.compulsory = compulsory;
        this.testMode = testMode;
    }

    public String getName() {
        return name;
    }


    public String getTestMode() {
        return testMode;
    }


    public void addExamScore(ExamScores score){
        this.finalScoreTotal += score.getFinalScore();
        this.usualScoreTotal += score.getUsualScore();
        this.scoreTotal += score.getScore();
        this.num += 1;
    }

    public void  addExamineScore(ExamineScores score){
        this.finalScoreTotal += score.getScore();
        this.scoreTotal += score.getScore();
        this.num += 1;
    }

    public int getAverageScore(){
        return (int)(this.scoreTotal/num);
    }

    public int getAverageUsualScore(){
        return (int)(this.usualScoreTotal/num);
    }

    public int getAverageFinalScore(){
        return (int)(this.finalScoreTotal/num);
    }

    @Override
    public int compareTo(Course o) {
        Collator instance = Collator.getInstance(Locale.CHINA);

        return instance.compare(this.name,o.getName());
    }
}
 class ExamineScores extends Score{//考察成绩
    private int finalScore;

    public  ExamineScores(int finalScore){
        this.finalScore = finalScore;
    }


    @Override
    public int getScore() {
        return this.finalScore;
    }

    @Override
    public int compareTo(Score o) {
        if(this.getScore() > o.getScore())
            return -1;
        else if(this.getScore() < o.getScore())
            return 1;
        return 0;
    }
}
class ExamScores extends Score{//考试成绩
    private int usualScore;
    private int finalScore;

    public ExamScores(int usualScore, int finalScore) {
        this.usualScore = usualScore;
        this.finalScore = finalScore;
    }


    public int getUsualScore() {
        return usualScore;
    }


    public int getFinalScore() {
        return finalScore;
    }


    @Override
    public int getScore() {
        return (int)(usualScore * 0.3 + finalScore * 0.7);
    }

    @Override
    public int compareTo(Score o) {
        if(this.getScore() > o.getScore())
            return -1;
        else if(this.getScore() < o.getScore())
            return 1;
        return 0;
    }
}
 abstract class Score implements Comparable<Score>{
    private int score;

    public Score() {
    }
    public abstract int getScore();
}
class Student implements Comparable<Student>{
    private String number;
    private String name;
    private int courseNum = 0;
    private int totalScore = 0;

    public Student(String number, String name) {
        this.number = number;
        this.name = name;
    }

    public String getNumber() {
        return number;
    }


    public String getName() {
        return name;
    }


    public void addACourseOfScore(int score){
        this.courseNum += 1;
        this.totalScore += score;
    }

    public int getAverageScore(){
        return (int)(this.totalScore/this.courseNum);
    }

    @Override
    public int compareTo(Student o) {
        if(Integer.parseInt(this.getNumber()) > Integer.parseInt(o.getNumber()))
            return 1;
        else if (Integer.parseInt(this.getNumber()) < Integer.parseInt(o.getNumber())) {
            return -1;
        }
        return 0;
    }
}

 

 

OOP训练集9

　　　　　　7-1 统计Java程序中关键词的出现次数

　　　　　　　　只需理解集合框架中的Map的用法以及提高程序模块化设计便可用尽可能少的代码行数完成解题。

 

　　　　　　　　最终源码如下：

import java.util.*;
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        HashMap<String,Integer> map = new HashMap<>();
        TreeMap<String,Integer> res = new TreeMap<>();
        String[] str = {"abstract","assert","boolean","break","byte","case","catch","char","class","continue","default","do","double","else","enum","extends","final","finally","float","for","if","implements","import","int","interface","instanceof","long","native","new","package","private","protected","public","return","short","static","strictfp","super","switch","synchronized","this","throw","throws","transient","try","void","volatile","while","goto","const","true","false","null"};
        for(int i=0; i<53; i++) map.put( str[i], 0);
        boolean flag = true;
        while(sc.hasNext()) {
            String s1 = sc.nextLine();
            StringBuilder s = new StringBuilder();
            if(s1.equals("exit")) break;
            flag = false;
            s.append(s1.replaceAll("\".*\"","").replaceAll("//.*","")); //运用正则表达式去除//注释的和双引号里的内容
            if(s.indexOf("/*")!=-1) { //删除/* */ 注释的
                if(s.indexOf("*/")!=-1) s.delete( s.indexOf("/*"), s.indexOf("*/")+2); // /* */注释没有跨行，删除/* */之间的内容
                else { // /* */跨行
                    s.delete( s.indexOf("/*"), s.length());
                    while(sc.hasNext()) { //一直输入直到出现 */
                        String sr = sc.nextLine();
                        if(sr.contains("*/")) {
                            s.append( sr.substring(sr.indexOf("*/")+2));
                            break;
                        }
                    }
                }
            }
            String sr = s.toString();
            sr = sr.replace("=", "a");
            int l = sr.length();
            for(int i=0; i<l; i++) {
                while(i<l && !check(sr.charAt(i))) {
                    i++;
                }
                int j = i;
                while(j<l && check(sr.charAt(j))){
                    j++;
                }
                if(i < l) {
                    String r = sr.substring( i, j); //把扫描出来的单词提前出来
                    if(map.containsKey(r)) { //判断是否是关键词
                        if(!res.containsKey(r)) res.put( r, 1);
                        else res.replace( r, (res.get(r)+1));
                    }
                }
                i = j;
            }
        }
        if( flag ) System.out.println("Wrong Format");
        else if(res.size()!=0){
            for(String i: res.keySet())
                System.out.println(res.get(i) + "\t" + i);
        }
    }
    public static boolean check( char x) {
        return (x >= 'a' && x <= 'z') || (x >= 'A' && x <= 'Z');
    }
}

OOP训练集10

　　　　　　7-1 容器-HashMap-检索

　　　　　　　　

　　　　　　输入多个学生的成绩信息，包括：学号、姓名、成绩。

　　　　　　学号是每个学生的唯一识别号，互不相同。

　　　　　　姓名可能会存在重复。

　　　　　　使用HashMap存储学生信息，并实现根据学号的检索功能

　　　　　　输入格式:

　　　　　　输入多个学生的成绩信息，每个学生的成绩信息格式：学号+英文空格+姓名+英文空格+成绩

　　　　　　以“end”为输入结束标志

　　　　　　end之后输入某个学号，执行程序输出该生的详细信息

　　　　　　输出格式:　　

　　　　　　输出查询到的学生信息格式：学号+英文空格+姓名+英文空格+成绩

　　　　　　如果没有查询到，则输出："The student "+查询的学号+" does not exist"

 

 　　　　　　题目较为简单，根据要求完成解题即可，源码如下：

　　　　

import java.util.HashMap;
import java.util.Scanner;

public class Main {
    public static void main(String[] args){
        HashMap<String, Student> studentHashMap= new HashMap<>();
        boolean inputOver = false;
        String str;
        Scanner input = new Scanner(System.in);
        while(!inputOver){
            str = input.nextLine();
            String[] strings = str.split(" ");
            if(strings.length == 3 && str.matches("^\\d{8} \\S{1,10} (\\d|[1-9]\\d|100)$")){
                Student student = new Student(strings[0],strings[1],strings[2]);
                studentHashMap.put(strings[0],student);
            }

            else if(strings.length == 1 && strings[0].equals("end")){
                inputOver = true;
            }

        }
        str = input.nextLine();
        if(studentHashMap.containsKey(str)) {
            System.out.println(studentHashMap.get(str).getNum() + " " + studentHashMap.get(str).getName() + " " + studentHashMap.get(str).getScore());
        }
        else {
            System.out.println("The student " + str + " does not exist");
        }


    }
}
class Student{
    String num;
    String name;
    String score;


    public Student() {
    }

    public Student(String num, String name, String score) {
        this.num = num;
        this.name = name;
        this.score = score;
    }

    public String getNum() {
        return num;
    }

    public String getName() {
        return name;
    }

    public String getScore() {
        return score;
    }
}

　　　　　　7-2 容器-HashMap-排序

　　　　　　重写比较器，根据比较器进行排序即可，源码如下：

import java.util.*;


public class Main {
    public static void main(String[] args){
        HashMap<String, Student> studentHashMap= new HashMap<>();
        Comparator comparatorInteger = new ComparatorInteger();
        boolean inputOver = false;
        String str;
        Scanner input = new Scanner(System.in);
        while(!inputOver){
            str = input.nextLine();
            String[] strings = str.split(" ");
            if(strings.length == 3 && str.matches("^\\d{8} \\S{1,10} (\\d|[1-9]\\d|100)$")){
                Student student = new Student(strings[0],strings[1],strings[2]);
                studentHashMap.put(strings[0],student);
            }

            else if(strings.length == 1 && strings[0].equals("end")){
                inputOver = true;
            }

        }
        Set set = studentHashMap.keySet();
        Object[] arr = set.toArray();
        Arrays.sort(arr,comparatorInteger);
        for(Object key : arr){
            System.out.println(studentHashMap.get(key).getNum() + " " + studentHashMap.get(key).getName() + " " + studentHashMap.get(key).getScore());
        }


    }
}
class Student {
    String num;
    String name;
    String score;


    public Student() {
    }

    public Student(String num, String name, String score) {
        this.num = num;
        this.name = name;
        this.score = score;
    }

    public String getNum() {
        return num;
    }

    public String getName() {
        return name;
    }

    public String getScore() {
        return score;
    }

}

class ComparatorInteger implements Comparator<String> {
    @Override   //使得逆序      o1比o2小，返回正数——需要调换位置
    public int compare(String o1, String o2) {
        return o2.compareTo(o1);
    }
}

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

　　　　　　对先前的程序进行迭代，新增Experiment类继承Score类用于记录实验课程成绩，再对Main类进行相应修改即可，最终类图如下：

 

 　　　　　　　　源码如下：

　　　　　　

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

public class Main {
    public static void main(String[] args){
        ArrayList<Course> courses = new ArrayList<>();
        ArrayList<CourseSelection> courseSelections = new ArrayList<>();
        ArrayList<Class> classes = new ArrayList<>();
        ArrayList<Student> students = new ArrayList<>();
        String str;
        Scanner input = new Scanner(System.in);
        boolean inputOver = false;
        while(!inputOver){
            str = input.nextLine();
            String[] strings = str.split(" ");
            if(strings.length == 3 && str.matches("^\\S{1,10} (必修|选修|实验) (考试|考察|实验)$")){
                Course course = new Course(strings[0] , strings[2]);
                boolean repeat = false;
                if(!courses.isEmpty()){
                    for(Course c : courses ){
                        if(c.getName().equals(strings[0])){
                            repeat = true;
                            break;
                        }
                    }
                }
                if(repeat){
                    continue;
                }
                if(strings[1].equals("必修")){
                    if(strings[2].equals("考试"))
                        courses.add(course);
                    else
                        System.out.println(strings[0] + " : course type & access mode mismatch");
                }
                else if(strings[1].equals("实验")){
                    if(strings[2].equals("实验"))
                        courses.add(course);
                    else
                        System.out.println(strings[0] + " : course type & access mode mismatch");
                }
                else
                    courses.add(course);
            }
            else if(strings.length == 1 && strings[0].equals("end")){
                inputOver = true;
            }

            //考核方式为考察
            else if (strings.length == 4 && str.matches("^\\d{8} \\S{1,10} \\S{1,10} (\\d|[1-9]\\d|100)$")) {
                if(isRepeatOfScore(courseSelections , strings[0] , strings[2])){
                    continue;
                }
                Score score = new ExamineScores(Integer.parseInt(strings[3]));

                //students加入学生
                Student student = new Student(strings[0] , strings[1]);
                if(students.isEmpty()){
                    students.add(student);
                }
                else{
                    boolean flag = false;
                    for (Student s : students){
                        if (s.getNumber().equals(student.getNumber())) {
                            flag = true;
                            break;
                        }
                    }
                    if(!flag){
                        students.add(student);
                    }
                }


                //classes增加班级
                if(classes.isEmpty()){
                    classes.add(new Class(student.getNumber().substring(0,6)));
                    classes.get(0).addStudent(student);
                }
                else{
                    //
                    boolean flag = false;
                    for (Class c : classes){
                        if(c.getNum().equals(student.getNumber().substring(0,6))){
                            flag = true;
                            c.addStudent(student);
                        }
                    }

                    //如果没有找到与该学生相同的班级则新建一个
                    if(!flag){
                        classes.add(new Class(student.getNumber().substring(0,6)));
                        for(Class c : classes){
                            if(c.getNum().equals(student.getNumber().substring(0,6))) {
                                c.addStudent(student);
                            }
                        }

                    }

                }
                //courses加入课程
                Course course = null;
                for(Course c : courses){
                    if (c.getName().equals(strings[2])){
                        course = c;
                    }
                }
                if(course == null){
                    System.out.println(strings[2] + " does not exist");
                    continue;
                }

                if (!course.getTestMode().equals("考察")) {
                    System.out.println(student.getNumber() + " " + student.getName() + " : access mode mismatch");
                    continue;
                }

                addStudentAndClassScore(courseSelections, classes, students, score, student, course);


            }

            //考核方式为考试
            else if(strings.length == 5 && str.matches("^\\d{8} \\S{1,10} \\S{1,10} (\\d|[1-9]\\d|100) (\\d|[1-9]\\d|100)$")){
                if(isRepeatOfScore(courseSelections , strings[0] , strings[2])){
                    continue;
                }
                Score score = new ExamScores(Integer.parseInt(strings[3]) , Integer.parseInt(strings[4]));

                //students加入学生
                Student student = new Student(strings[0] , strings[1]);
                if(students.isEmpty()){
                    students.add(student);
                }
                else{
                    boolean flag = false;
                    for (Student s : students){
                        if (s.getNumber().equals(student.getNumber())) {
                            flag = true;
                            break;
                        }
                    }
                    if(!flag){
                        students.add(student);
                    }
                }

                //增加班级
                if(classes.isEmpty()){
                    classes.add(new Class(student.getNumber().substring(0,6)));
                    classes.get(0).addStudent(student);
                }
                else{
                    //
                    boolean flag = false;
                    for (Class c : classes){
                        if(c.getNum().equals(student.getNumber().substring(0,6))){
                            flag = true;
                            c.addStudent(student);
                        }
                    }
                    //如果没有找到与该学生相同的班级则新建一个
                    if(!flag){
                        classes.add(new Class(student.getNumber().substring(0,6)));
                        for(Class c : classes){
                            if(c.getNum().equals(student.getNumber().substring(0,6))) {
                                c.addStudent(student);
                            }
                        }

                    }

                }

                //courses加入课程
                Course course = null;
                for(Course c : courses){
                    if (c.getName().equals(strings[2])){
                        course = c;
                    }
                }
                if(course == null){
                    System.out.println(strings[2] + " does not exist");
                    continue;
                }

                if (!course.getTestMode().equals("考试")) {
                    System.out.println(student.getNumber() + " " + student.getName() + " : access mode mismatch");
                    continue;
                }

                addStudentAndClassScore(courseSelections, classes, students, score, student, course);


            }
            else if (str.matches("^\\d{8} \\S{1,10} \\S{1,10} [4-9] ((\\d|[1-9]\\d|100) )*(\\d|[1-9]\\d|100)$")) {
                if(isRepeatOfScore(courseSelections , strings[0] , strings[2])){
                    continue;
                }
                boolean isOk = true;
                for (int i = 4 ; i < strings.length ;i++){
                    if(!strings[i].matches("(\\d|[1-9]\\d|100)")){
                        isOk = false;
                        break;
                    }
                }
                if(!isOk)
                    continue;
                Experiment score = new Experiment();
                for(int i = 4 ; i < strings.length ; i++){
                    score.addAExperimentScore(Integer.parseInt(strings[i]));
                }

                //students加入学生
                Student student = new Student(strings[0] , strings[1]);
                if(students.isEmpty()){
                    students.add(student);
                }
                else{
                    boolean flag = false;
                    for (Student s : students){
                        if (s.getNumber().equals(student.getNumber())) {
                            flag = true;
                            break;
                        }
                    }
                    if(!flag){
                        students.add(student);
                    }
                }

                //增加班级
                if(classes.isEmpty()){
                    classes.add(new Class(student.getNumber().substring(0,6)));
                    classes.get(0).addStudent(student);
                }
                else{
                    //
                    boolean flag = false;
                    for (Class c : classes){
                        if(c.getNum().equals(student.getNumber().substring(0,6))){
                            flag = true;
                            c.addStudent(student);
                        }
                    }
                    //如果没有找到与该学生相同的班级则新建一个
                    if(!flag){
                        classes.add(new Class(student.getNumber().substring(0,6)));
                        for(Class c : classes){
                            if(c.getNum().equals(student.getNumber().substring(0,6))) {
                                c.addStudent(student);
                            }
                        }

                    }

                }

                //courses加入课程
                Course course = null;
                for(Course c : courses){
                    if (c.getName().equals(strings[2])){
                        course = c;
                    }
                }
                if(course == null){
                    System.out.println(strings[2] + " does not exist");
                    continue;
                }
                if (!course.getTestMode().equals("实验")||strings.length != Integer.parseInt(strings[3])+4) {
                    System.out.println(student.getNumber() + " " + student.getName() + " : access mode mismatch");
                    continue;
                }

                addStudentAndClassScore(courseSelections, classes, students, score, student, course);
            }
            else
                System.out.println("wrong format");
        }
        //输出学生的平均分
        students.sort(Comparator.naturalOrder());
        for(Student s : students){
            try{
                System.out.println(s.getNumber() + " "
                        + s.getName() + " "
                        + s.getAverageScore());
            }catch (Exception e){
                System.out.println(s.getNumber() + " " + s.getName() +" did not take any exams");
            }

        }


        //输出课程平均分
        for(CourseSelection selection : courseSelections ){
            for(Course course : courses){
                if(selection.getCourse().getName().equals(course.getName())){
                    if(selection.getScore() instanceof ExamScores){
                        course.addExamScore((ExamScores) (selection.getScore()));
                    }
                    else if(selection.getScore() instanceof ExamineScores){
                        course.addExamineScore((ExamineScores) (selection.getScore()));
                    }
                    else
                        course.addExperimentScore((Experiment) (selection.getScore()));
                }
            }
        }
        boolean legal = true;
        try {
            courses.sort(Comparator.naturalOrder());
        }catch (Exception e){
            for(Course course: courses){
                System.out.println(course.getName() +" has no grades yet");
                legal = false;
            }
        }
        if(legal){
            for (Course course : courses){
                try{
                    if(course.getTestMode().equals("考察")){
                        System.out.println(course.getName() + " "
                                + course.getAverageFinalScore() + " "
                                + course.getAverageScore());
                    }
                    else if(course.getTestMode().equals("实验")){
                        System.out.println(course.getName() + " "
                                + course.getAverageScore());
                    }
                    else {
                        System.out.println(course.getName() + " "
                                + course.getAverageUsualScore() + " "
                                + course.getAverageFinalScore() + " "
                                + course.getAverageScore());
                    }
                }catch (Exception e){
                    System.out.println(course.getName() +" has no grades yet");
                }

            }
        }



        //输出班级平均分
        classes.sort(Comparator.naturalOrder());
        for (Class c : classes){
            if(c.getClassAverageScore() != 0)
                System.out.println(c.getNum() + " " + c.getClassAverageScore());
            else
                System.out.println(c.getNum() + " has no grades yet");
        }
    }

    private static void addStudentAndClassScore(ArrayList<CourseSelection> courseSelections, ArrayList<Class> classes, ArrayList<Student> students, Score score, Student student, Course course) {
        for(Student s : students){
            if(s.getNumber().equals(student.getNumber())){
                s.addACourseOfScore(score.getScore());
            }
        }
        for (Class c : classes){
            if(c.getNum().equals(student.getNumber().substring(0,6))){
                c.addTotalScore(score.getScore());
            }
        }
        CourseSelection courseSelection = new CourseSelection(course , student , score);
        courseSelections.add(courseSelection);
    }

    public static boolean isRepeatOfScore(ArrayList<CourseSelection> courseSelections , String studentNum ,String courseName){
        boolean repeat = false;
        if(!courseSelections.isEmpty()){
            for (CourseSelection c : courseSelections){
                if(c.getStudent().getNumber().equals(studentNum) && c.getCourse().getName().equals(courseName)){
                    repeat = true;
                    break;
                }
            }
        }
        return repeat;
    }
}

class Class implements Comparable<Class>{
    private String num;
    private ArrayList<Student> students = new ArrayList<>();
    private int totalScore = 0;

    public Class(String num) {
        this.num = num;
    }


    public String getNum() {
        return num;
    }


    public void addStudent(Student student){
        students.add(student);
    }

    public void addTotalScore(int studentScore){
        this.totalScore += studentScore;
    }

    public int getClassAverageScore(){
        return this.totalScore/students.size();
    }

    @Override
    public int compareTo(Class o) {
        if (Integer.parseInt(this.getNum()) > Integer.parseInt(o.getNum())) {
            return 1;
        }
        else if(Integer.parseInt(this.getNum()) < Integer.parseInt(o.getNum())) {
            return -1;
        }
        return 0;
    }
}
class CourseSelection implements Comparable<CourseSelection>{
    private Course course;
    private Student student;
    private Score score;


    public CourseSelection(Course course, Student student, Score score) {
        this.course = course;
        this.student = student;
        this.score = score;
    }

    public Course getCourse() {
        return course;
    }


    public Student getStudent() {
        return student;
    }



    public Score getScore() {
        return score;
    }


    @Override
    public int compareTo(CourseSelection o) {
        if(Integer.parseInt(this.student.getNumber()) > Integer.parseInt(o.getStudent().getNumber()))
            return 1;
        else if(Integer.parseInt(this.student.getNumber()) < Integer.parseInt(o.getStudent().getNumber()))
            return -1;
        return this.score.compareTo(o.score);
    }
}
class Course implements Comparable<Course>{
    //课程名字
    private String name;
    //考核方式
    private String testMode;

    private int scoreTotal = 0;

    private int usualScoreTotal = 0;

    private int finalScoreTotal = 0;
    //选课人数
    private int num = 0;


    public Course(String name, String testMode) {
        this.name = name;
        //是否必修
        this.testMode = testMode;
    }

    public String getName() {
        return name;
    }


    public String getTestMode() {
        return testMode;
    }


    public void addExamScore(ExamScores score){
        this.finalScoreTotal += score.getFinalScore();
        this.usualScoreTotal += score.getUsualScore();
        this.scoreTotal += score.getScore();
        this.num += 1;
    }

    public void  addExamineScore(ExamineScores score){
        this.finalScoreTotal += score.getScore();
        this.scoreTotal += score.getScore();
        this.num += 1;
    }

    public void addExperimentScore(Experiment score){
        this.finalScoreTotal += score.getScore();
        this.scoreTotal += score.getScore();
        this.num += 1;
    }

    public int getAverageScore(){
        return this.scoreTotal/num;
    }

    public int getAverageUsualScore(){
        return this.usualScoreTotal/num;
    }

    public int getAverageFinalScore(){
        return this.finalScoreTotal/num;
    }

    @Override
    public int compareTo(Course o) {
        Collator instance = Collator.getInstance(Locale.CHINA);

        return instance.compare(this.name,o.getName());
    }
}
class ExamineScores extends Score{//考察成绩
    private int finalScore;

    public  ExamineScores(int finalScore){
        this.finalScore = finalScore;
    }


    @Override
    public int getScore() {
        return this.finalScore;
    }

    @Override
    public int compareTo(Score o) {
        if(this.getScore() > o.getScore())
            return -1;
        else if(this.getScore() < o.getScore())
            return 1;
        return 0;
    }
}
class ExamScores extends Score{//考试成绩
    private int usualScore;
    private int finalScore;

    public ExamScores(int usualScore, int finalScore) {
        this.usualScore = usualScore;
        this.finalScore = finalScore;
    }


    public int getUsualScore() {
        return usualScore;
    }


    public int getFinalScore() {
        return finalScore;
    }


    @Override
    public int getScore() {
        return (int)(usualScore * 0.3 + finalScore * 0.7);
    }

    @Override
    public int compareTo(Score o) {
        if(this.getScore() > o.getScore())
            return -1;
        else if(this.getScore() < o.getScore())
            return 1;
        return 0;
    }
}
abstract class Score implements Comparable<Score>{

    public Score() {
    }
    public abstract int getScore();
}
class Experiment extends Score{
    ArrayList<Integer> scores = new ArrayList<>();

    public Experiment() {
    }

    public void addAExperimentScore(int score){
        this.scores.add(score);
    }

    @Override
    public int getScore() {
        int totalScore = 0;
        for(Integer score : this.scores){
            totalScore += score;
        }

        return totalScore/this.scores.size();
    }

    @Override
    public int compareTo(Score o) {
        return Integer.compare(this.getScore(),o.getScore());
    }
}


class Student implements Comparable<Student>{
    private String number;
    private String name;
    private int courseNum = 0;
    private int totalScore = 0;

    public Student(String number, String name) {
        this.number = number;
        this.name = name;
    }

    public String getNumber() {
        return number;
    }


    public String getName() {
        return name;
    }


    public void addACourseOfScore(int score){
        this.courseNum += 1;
        this.totalScore += score;
    }

    public int getAverageScore(){
        return this.totalScore/this.courseNum;
    }

    @Override
    public int compareTo(Student o) {
        if(Integer.parseInt(this.getNumber()) > Integer.parseInt(o.getNumber()))
            return 1;
        else if (Integer.parseInt(this.getNumber()) < Integer.parseInt(o.getNumber())) {
            return -1;
        }
        return 0;
    }
}

 　　　　　　7-4 动物发声模拟器（多态）

　　　　　　　该题较为简单，利用多态即可轻松实现，源码如下：

//动物发生模拟器.  请在下面的【】处添加代码。
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){
        if(animal.getClass() == Dog.class){
            System.out.println("狗的叫声：" + animal.shout());
        }
        else if(animal.getClass() == Cat.class){
            System.out.println("猫的叫声：" + animal.shout());
        }
        else if(animal.getClass() == Goat.class){
            System.out.println("山羊的叫声：" + animal.shout());
        }
    }

}

//定义抽象类Animal
abstract class Animal{
    public abstract Class getAnimalClass();
    public abstract String shout();
}
//基于Animal类，定义猫类Cat，并重写两个抽象方法
class Cat extends Animal{

    @Override
    public Class getAnimalClass() {

        return this.getClass();
    }

    @Override
    public String shout() {
        return "喵喵";
    }
}
//基于Animal类，定义狗类Dog，并重写两个抽象方法
class Dog extends Animal {


    @Override
    public Class getAnimalClass() {
        return this.getClass();
    }

    @Override
    public String shout() {
        return "汪汪";
    }
}
//基于Animal类，定义山羊类Goat，并重写两个抽象方法
class Goat extends Animal{


    @Override
    public Class getAnimalClass() {
        return this.getClass();
    }

    @Override
    public String shout() {
        return "咩咩";
    }
}

OOP训练集11

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

　　　　再对先前的代码进行迭代，根据输入课程信息时输入的权重比例计算考试与实验的分数

　　　　修改ExamScore类中计算分数的方法和Experiment类中计算分数的代码，接着修改主方法中的部分代码即可

　　　　最终类图如下：

 　　　　　　源码如下：

　　　　

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

public class Main {
    public static void main(String[] args){
        ArrayList<Course> courses = new ArrayList<>();
        ArrayList<CourseSelection> courseSelections = new ArrayList<>();
        ArrayList<Class> classes = new ArrayList<>();
        ArrayList<Student> students = new ArrayList<>();
        String str;
        Scanner input = new Scanner(System.in);
        boolean inputOver = false;
        while(!inputOver) {
            str = input.nextLine();
            String[] strings = str.split(" ");
            if(strings.length == 3 && str.matches("^\\S{1,10} 选修 (考试|考察|实验)$")){
                Course course = new Course(strings[0] , strings[2]);
                if(isRepeatOfCourse(courses,strings[0])){
                    continue;
                }
                if(strings[2].equals("实验")){
                    System.out.println(strings[0] + " : course type & access mode mismatch");
                }
                else {
                    courses.add(course);
                }
            }
            else if(strings.length == 5 && str.matches("^\\S{1,10} 必修 (考试|考察|实验) (0\\.\\d+) (0\\.\\d+)$")){
                Course course = new Course(strings[0] , strings[2] , Double.parseDouble(strings[3]) , Double.parseDouble(strings[4]));
                if(isRepeatOfCourse(courses,strings[0])){
                    continue;
                }
                if(Double.parseDouble(strings[3]) + Double.parseDouble(strings[4]) != 1){
                    System.out.println(strings[0] + " : weight value error");
                    continue;
                }

                if(strings[2].equals("考试")){
                    courses.add(course);
                }
                else{
                    System.out.println(strings[0] + " : course type & access mode mismatch");
                }
            }
            else if(str.matches("^\\S{1,10} 实验 (考试|考察|实验) [4-9] ((0\\.\\d+) )*(0\\.\\d+)$")){
                ArrayList<Double> rateList = new ArrayList<>();
                for(int i = 4; i < strings.length ;i++){
                    double d = Double.parseDouble(strings[i]);
                    rateList.add(d);
                }
                Course course = new Course(strings[0] , strings[2] , rateList);
                if(isRepeatOfCourse(courses,strings[0])){
                    continue;
                }
                if(strings.length - 4 != Integer.parseInt(strings[3])){
                    System.out.println(strings[0] + " : number of scores does not match");
                    continue;
                }
                double totalRate = 0;
                for(Double d : rateList){
                    totalRate += d;
                }
                if(totalRate != 1){
                    System.out.println(strings[0] + " : weight value error");
                    continue;
                }

                if(strings[2].equals("实验")){
                    courses.add(course);
                }
                else{
                    System.out.println(strings[0] + " : course type & access mode mismatch");
                }
            }
            else if(strings.length == 1 && strings[0].equals("end")){
                inputOver = true;
            }
            //考察
            else if (strings.length == 4 && str.matches("^\\d{8} \\S{1,10} \\S{1,10} (\\d|[1-9]\\d|100)$")){
                if(isRepeatOfScore(courseSelections , strings[0] , strings[2])){
                    continue;
                }
                Score score = new ExamineScores(Integer.parseInt(strings[3]));

                //students加入学生
                Student student = new Student(strings[0] , strings[1]);
                if(students.isEmpty()){
                    students.add(student);
                }
                else{
                    boolean flag = false;
                    for (Student s : students){
                        if (s.getNumber().equals(student.getNumber())) {
                            flag = true;
                            break;
                        }
                    }
                    if(!flag){
                        students.add(student);
                    }
                }

                //classes增加班级
                if(classes.isEmpty()){
                    classes.add(new Class(student.getNumber().substring(0,6)));
                    classes.get(0).addStudent(student);
                }
                else{
                    //
                    boolean flag = false;
                    for (Class c : classes){
                        if(c.getNum().equals(student.getNumber().substring(0,6))){
                            flag = true;
                            c.addStudent(student);
                        }
                    }

                    //如果没有找到与该学生相同的班级则新建一个
                    if(!flag){
                        classes.add(new Class(student.getNumber().substring(0,6)));
                        for(Class c : classes){
                            if(c.getNum().equals(student.getNumber().substring(0,6))) {
                                c.addStudent(student);
                            }
                        }

                    }

                }
                //courses加入课程
                Course course = null;
                for(Course c : courses){
                    if (c.getName().equals(strings[2])){
                        course = c;
                    }
                }
                if(course == null){
                    System.out.println(strings[2] + " does not exist");
                    continue;
                }

                if (!course.getTestMode().equals("考察")) {
                    System.out.println(student.getNumber() + " " + student.getName() + " : access mode mismatch");
                    continue;
                }

                addStudentAndClassScore(courseSelections, classes, students, score, student, course);




            }
            //考试
            else if(strings.length == 5 && str.matches("^\\d{8} \\S{1,10} \\S{1,10} (\\d|[1-9]\\d|100) (\\d|[1-9]\\d|100)$")){
                if(isRepeatOfScore(courseSelections , strings[0] , strings[2])){
                    continue;
                }
                ExamScores score = new ExamScores(Integer.parseInt(strings[3]) , Integer.parseInt(strings[4]));

                //students加入学生
                Student student = new Student(strings[0] , strings[1]);
                if(students.isEmpty()){
                    students.add(student);
                }
                else{
                    boolean flag = false;
                    for (Student s : students){
                        if (s.getNumber().equals(student.getNumber())) {
                            flag = true;
                            break;
                        }
                    }
                    if(!flag){
                        students.add(student);
                    }
                }

                //增加班级
                if(classes.isEmpty()){
                    classes.add(new Class(student.getNumber().substring(0,6)));
                    classes.get(0).addStudent(student);
                }
                else{
                    //
                    boolean flag = false;
                    for (Class c : classes){
                        if(c.getNum().equals(student.getNumber().substring(0,6))){
                            flag = true;
                            c.addStudent(student);
                        }
                    }
                    //如果没有找到与该学生相同的班级则新建一个
                    if(!flag){
                        classes.add(new Class(student.getNumber().substring(0,6)));
                        for(Class c : classes){
                            if(c.getNum().equals(student.getNumber().substring(0,6))) {
                                c.addStudent(student);
                            }
                        }

                    }

                }

                //courses加入课程
                Course course = null;
                for(Course c : courses){
                    if (c.getName().equals(strings[2])){
                        course = c;
                    }
                }
                if(course == null){
                    System.out.println(strings[2] + " does not exist");
                    continue;
                }

                if (!course.getTestMode().equals("考试")) {
                    System.out.println(student.getNumber() + " " + student.getName() + " : access mode mismatch");
                    continue;
                }
                score.setFinalRate(course.getFinalRate());
                score.setUsualRate(course.getUsualRate());
                addStudentAndClassScore(courseSelections, classes, students, score, student, course);


            }
            //实验
            else if (str.matches("^\\d{8} \\S{1,10} \\S{1,10} ((\\d|[1-9]\\d|100) )*(\\d|[1-9]\\d|100)$")){
                if(isRepeatOfScore(courseSelections , strings[0] , strings[2])){
                    continue;
                }
                boolean isOk = true;
                for (int i = 3 ; i < strings.length ;i++){
                    if(!strings[i].matches("(\\d|[1-9]\\d|100)")){
                        isOk = false;
                        break;
                    }
                }
                if(!isOk)
                    continue;
                Experiment score = new Experiment();
                for(int i = 3 ; i < strings.length ; i++){
                    score.addAExperimentScore(Integer.parseInt(strings[i]));
                }

                //students加入学生
                Student student = new Student(strings[0] , strings[1]);
                if(students.isEmpty()){
                    students.add(student);
                }
                else{
                    boolean flag = false;
                    for (Student s : students){
                        if (s.getNumber().equals(student.getNumber())) {
                            flag = true;
                            break;
                        }
                    }
                    if(!flag){
                        students.add(student);
                    }
                }

                //增加班级
                if(classes.isEmpty()){
                    classes.add(new Class(student.getNumber().substring(0,6)));
                    classes.get(0).addStudent(student);
                }
                else{
                    //
                    boolean flag = false;
                    for (Class c : classes){
                        if(c.getNum().equals(student.getNumber().substring(0,6))){
                            flag = true;
                            c.addStudent(student);
                        }
                    }
                    //如果没有找到与该学生相同的班级则新建一个
                    if(!flag){
                        classes.add(new Class(student.getNumber().substring(0,6)));
                        for(Class c : classes){
                            if(c.getNum().equals(student.getNumber().substring(0,6))) {
                                c.addStudent(student);
                            }
                        }

                    }

                }

                //courses加入课程
                Course course = null;
                for(Course c : courses){
                    if (c.getName().equals(strings[2])){
                        course = c;
                    }
                }
                if(course == null){
                    System.out.println(strings[2] + " does not exist");
                    continue;
                }
                if (!course.getTestMode().equals("实验")||strings.length != course.getRateList().size() + 3) {
                    System.out.println(student.getNumber() + " " + student.getName() + " : access mode mismatch");
                    continue;
                }

                score.setRateList(course.getRateList());
                addStudentAndClassScore(courseSelections, classes, students, score, student, course);
            }
            else
                System.out.println("wrong format");
        }
        //输出学生的平均分
        students.sort(Comparator.naturalOrder());
        for(Student s : students){
            try{
                System.out.println(s.getNumber() + " "
                        + s.getName() + " "
                        + s.getAverageScore());
            }catch (Exception e){
                System.out.println(s.getNumber() + " " + s.getName() +" did not take any exams");
            }

        }


        //输出课程平均分
        for(CourseSelection selection : courseSelections ){
            for(Course course : courses){
                if(selection.getCourse().getName().equals(course.getName())){
                    if(selection.getScore() instanceof ExamScores){
                        course.addExamScore((ExamScores) (selection.getScore()));
                    }
                    else if(selection.getScore() instanceof ExamineScores){
                        course.addExamineScore((ExamineScores) (selection.getScore()));
                    }
                    else
                        course.addExperimentScore((Experiment) (selection.getScore()));
                }
            }
        }
        boolean legal = true;
        try {
            courses.sort(Comparator.naturalOrder());
        }catch (Exception e){
            for(Course course: courses){
                System.out.println(course.getName() +" has no grades yet");
                legal = false;
            }
        }
        if(legal){
            for (Course course : courses){
                try{
                    if(course.getTestMode().equals("考察")){
                        System.out.println(course.getName() + " "
                                + course.getAverageFinalScore() + " "
                                + course.getAverageScore());
                    }
                    else if(course.getTestMode().equals("实验")){
                        System.out.println(course.getName() + " "
                                + course.getAverageScore());
                    }
                    else {
                        System.out.println(course.getName() + " "
                                + course.getAverageUsualScore() + " "
                                + course.getAverageFinalScore() + " "
                                + course.getAverageScore());
                    }
                }catch (Exception e){
                    System.out.println(course.getName() +" has no grades yet");
                }

            }
        }



        //输出班级平均分
        classes.sort(Comparator.naturalOrder());
        for (Class c : classes){
            if(c.getClassAverageScore() != 0)
                System.out.println(c.getNum() + " " + c.getClassAverageScore());
            else
                System.out.println(c.getNum() + " has no grades yet");
        }





    }
    public static boolean isRepeatOfCourse(ArrayList<Course> courses , String str){
        boolean repeat = false;
        if(!courses.isEmpty()){
            for(Course c : courses ){
                if(c.getName().equals(str)){
                    repeat = true;
                    break;
                }
            }
        }
        return repeat;
    }

    public static boolean isRepeatOfScore(ArrayList<CourseSelection> courseSelections , String studentNum ,String courseName){
        boolean repeat = false;
        if(!courseSelections.isEmpty()){
            for (CourseSelection c : courseSelections){
                if(c.getStudent().getNumber().equals(studentNum) && c.getCourse().getName().equals(courseName)){
                    repeat = true;
                    break;
                }
            }
        }
        return repeat;
    }

    private static void addStudentAndClassScore(ArrayList<CourseSelection> courseSelections, ArrayList<Class> classes, ArrayList<Student> students, Score score, Student student, Course course) {
        for(Student s : students){
            if(s.getNumber().equals(student.getNumber())){
                s.addACourseOfScore(score.getScore());
            }
        }
        for (Class c : classes){
            if(c.getNum().equals(student.getNumber().substring(0,6))){
                c.addTotalScore(score.getScore());
            }
        }
        CourseSelection courseSelection = new CourseSelection(course , student , score);
        courseSelections.add(courseSelection);
    }

}
class Class implements Comparable<Class>{
    private String num;
    private ArrayList<Student> students = new ArrayList<>();
    private int totalScore = 0;

    public Class(String num) {
        this.num = num;
    }


    public String getNum() {
        return num;
    }


    public void addStudent(Student student){
        students.add(student);
    }

    public void addTotalScore(int studentScore){
        this.totalScore += studentScore;
    }

    public int getClassAverageScore(){
        return this.totalScore/students.size();
    }

    @Override
    public int compareTo(Class o) {
        if (Integer.parseInt(this.getNum()) > Integer.parseInt(o.getNum())) {
            return 1;
        }
        else if(Integer.parseInt(this.getNum()) < Integer.parseInt(o.getNum())) {
            return -1;
        }
        return 0;
    }
}
//学生
class Student implements Comparable<Student>{
    private String number;
    private String name;
    private int courseNum = 0;
    private int totalScore = 0;

    public Student(String number, String name) {
        this.number = number;
        this.name = name;
    }

    public String getNumber() {
        return number;
    }


    public String getName() {
        return name;
    }


    public void addACourseOfScore(int score){
        this.courseNum += 1;
        this.totalScore += score;
    }

    public int getAverageScore(){
        return this.totalScore/this.courseNum;
    }

    @Override
    public int compareTo(Student o) {
        if(Integer.parseInt(this.getNumber()) > Integer.parseInt(o.getNumber()))
            return 1;
        else if (Integer.parseInt(this.getNumber()) < Integer.parseInt(o.getNumber())) {
            return -1;
        }
        return 0;
    }
}
class Course implements Comparable<Course>{
    //课程名字
    private String name;
    //考核方式
    private String testMode;

    private double usualRate;

    private double finalRate;

    private ArrayList<Double> rateList;

    private int scoreTotal = 0;

    private int usualScoreTotal = 0;

    private int finalScoreTotal = 0;
    //选课人数
    private int num = 0;


    public Course(String name, String testMode) {
        this.name = name;
        //是否必修
        this.testMode = testMode;
    }

    public Course(String name, String testMode, ArrayList<Double> rateList) {
        this.name = name;
        this.testMode = testMode;
        this.rateList = rateList;
    }

    public Course(String name, String testMode, double usualRate, double finalRate) {
        this.name = name;
        this.testMode = testMode;
        this.usualRate = usualRate;
        this.finalRate = finalRate;
    }

    public double getUsualRate() {
        return usualRate;
    }

    public double getFinalRate() {
        return finalRate;
    }

    public ArrayList<Double> getRateList() {
        return rateList;
    }

    public String getName() {
        return name;
    }


    public String getTestMode() {
        return testMode;
    }

    public boolean isExamRateLegal(){
        return this.finalRate + this.usualRate == 1;
    }

    public boolean isExperimentRateLegal(){
        double sum = 0;
        for(Double d : this.rateList){
            sum += d;
        }
        return sum == 1;
    }

    public void addExamScore(ExamScores score){
        this.finalScoreTotal += score.getFinalScore();
        this.usualScoreTotal += score.getUsualScore();
        this.scoreTotal += score.getScore();
        this.num += 1;
    }

    public void  addExamineScore(ExamineScores score){
        this.finalScoreTotal += score.getScore();
        this.scoreTotal += score.getScore();
        this.num += 1;
    }

    public void addExperimentScore(Experiment score){
        this.finalScoreTotal += score.getScore();
        this.scoreTotal += score.getScore();
        this.num += 1;
    }

    public int getAverageScore(){
        return this.scoreTotal/num;
    }

    public int getAverageUsualScore(){
        return this.usualScoreTotal/num;
    }

    public int getAverageFinalScore(){
        return this.finalScoreTotal/num;
    }

    @Override
    public int compareTo(Course o) {
        Collator instance = Collator.getInstance(Locale.CHINA);

        return instance.compare(this.name,o.getName());
    }
}
abstract class Score implements Comparable<Score>{

    public Score() {
    }
    public abstract int getScore();
}
class Experiment extends Score{
    ArrayList<Integer> scores = new ArrayList<>();
    ArrayList<Double> rateList;


    public Experiment() {
    }

    public void addAExperimentScore(int score){
        this.scores.add(score);
    }

    public void setRateList(ArrayList<Double> rateList) {
        this.rateList = rateList;
    }

    @Override
    public int getScore() {
        double totalScore = 0;
        for(int i = 0 ; i < scores.size() ; i++){
            totalScore += scores.get(i) * rateList.get(i);
        }

        return (int)totalScore;
    }

    @Override
    public int compareTo(Score o) {
        return Integer.compare(this.getScore(),o.getScore());
    }
}
class ExamineScores extends Score{//考察成绩
    private int finalScore;

    public  ExamineScores(int finalScore){
        this.finalScore = finalScore;
    }


    @Override
    public int getScore() {
        return this.finalScore;
    }

    @Override
    public int compareTo(Score o) {
        if(this.getScore() > o.getScore())
            return -1;
        else if(this.getScore() < o.getScore())
            return 1;
        return 0;
    }
}
class ExamScores extends Score{//考试成绩
    private int usualScore;
    private int finalScore;
    private double usualRate;
    private double finalRate;


    public ExamScores(int usualScore, int finalScore) {
        this.usualScore = usualScore;
        this.finalScore = finalScore;
        this.usualRate = 0.3;
        this.finalRate = 0.7;

    }

    public void setUsualRate(double usualRate) {
        this.usualRate = usualRate;
    }

    public void setFinalRate(double finalRate) {
        this.finalRate = finalRate;
    }

    public int getUsualScore() {
        return usualScore;
    }


    public int getFinalScore() {
        return finalScore;
    }


    @Override
    public int getScore() {
        return (int)(usualScore * usualRate + finalScore * finalRate);
    }

    @Override
    public int compareTo(Score o) {
        if(this.getScore() > o.getScore())
            return -1;
        else if(this.getScore() < o.getScore())
            return 1;
        return 0;
    }
}
class CourseSelection implements Comparable<CourseSelection>{
    private Course course;
    private Student student;
    private Score score;


    public CourseSelection(Course course, Student student, Score score) {
        this.course = course;
        this.student = student;
        this.score = score;
    }

    public Course getCourse() {
        return course;
    }


    public Student getStudent() {
        return student;
    }



    public Score getScore() {
        return score;
    }


    @Override
    public int compareTo(CourseSelection o) {
        if(Integer.parseInt(this.student.getNumber()) > Integer.parseInt(o.getStudent().getNumber()))
            return 1;
        else if(Integer.parseInt(this.student.getNumber()) < Integer.parseInt(o.getStudent().getNumber()))
            return -1;
        return this.score.compareTo(o.score);
    }
}

　　　　　　7-3 jmu-Java-02基本语法-03-身份证排序

　　　　　　　　接入Comparable接口并利用其进行排序即可

　　　　　　　　源码如下：

 

import java.time.LocalDate;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.Scanner;

public class Main {
    public static void main(String[] args){
        Scanner input = new Scanner(System.in);
        int n = Integer.parseInt(input.nextLine());
        ArrayList<IdCardNum> idCardNums = new ArrayList<>();
        while (n > 0){
            idCardNums.add(new IdCardNum(input.nextLine()));
            n--;
        }
        idCardNums.sort(Comparator.naturalOrder());
        boolean inputOver = false;
        while (!inputOver){
            String str = input.nextLine();
            if (str.matches("^sort2$")){
                for (IdCardNum idCardNum : idCardNums){
                    System.out.println(idCardNum.getNum());
                }
            } else if (str.matches("^sort1$")) {
                for (IdCardNum idCardNum : idCardNums){
                    System.out.println(idCardNum.getLocalDate());
                }
            } else if (str.matches("e")) {
                System.out.println("exit");
                inputOver = true;
            }else
                System.out.println("wrong format");
        }

    }
}
class IdCardNum implements Comparable<IdCardNum>{
    private String num;

    public IdCardNum() {
    }

    public IdCardNum(String num) {
        this.num = num;
    }

    public String getNum() {
        return num;
    }

    public LocalDate getLocalDate() {
        String date = this.getNum().substring(6,10) + "-" + this.getNum().substring(10,12) + "-" + this.getNum().substring(12,14);
        return LocalDate.parse(date);
    }

    @Override
    public int compareTo(IdCardNum o) {
        if(this.getLocalDate().isAfter(o.getLocalDate()))
            return 1;
        else if(this.getLocalDate().isBefore(o.getLocalDate()))
            return -1;
        else
            return 0;
    }
}

　　　　7-4 jmu-Java-04面向对象进阶-03-接口-自定义接口ArrayIntegerStack

 　　　　　　熟悉接口的使用方法，以及有一定对栈的理解即可完成解答

　　　　　　　源码如下：

import java.util.*;

public class Main {
    public static void main(String[] args){
        Scanner input = new Scanner(System.in);
        int n = input.nextInt();
        ArrayIntegerStack stack = new ArrayIntegerStack(n);
        int m = input.nextInt();
        for(int i = 0 ; i < m ; i++){
            Integer item = input.nextInt();
            System.out.println(stack.push(item));
        }
        System.out.println(stack.peek() + "," + stack.empty() + "," + stack.size());
        System.out.println(Arrays.toString(stack.getIntegers()));
        int o = input.nextInt();
        for(int i = 0 ; i < o ; i++){
            System.out.println(stack.pop());
        }
        System.out.println(stack.peek() + "," + stack.empty() + "," + stack.size());
        System.out.println(Arrays.toString(stack.getIntegers()));
    }
}

interface IntegerStack {
    public Integer push(Integer item);  //如果item为null，则不入栈直接返回null。如果栈满，也返回null。如果插入成功，返回item。

    public Integer pop();   //出栈，如果为空，则返回null。出栈时只移动栈顶指针，相应位置不置为null
    public Integer peek();  //获得栈顶元素，如果为空，则返回null.
    public boolean empty(); //如果为空返回true
    public int size();      //返回栈中元素个数
}

class ArrayIntegerStack implements IntegerStack{ //内部使用数组实现。创建时，可指定内部数组大小
    private Integer[] integers ;
    public int point;


    public ArrayIntegerStack(){
        this.integers = new Integer[0];
        this.point = -1;
    }

    public  ArrayIntegerStack(int n){
        this.integers = new Integer[n];
        this.point = -1;
    }

    public Integer[] getIntegers() {
        return integers;
    }

    @Override
    public Integer push(Integer item) {
        if(item == null)
            return null;
        if(this.size() == this.integers.length)
            return null;
        this.point += 1;
        this.integers[point] = item;
        return item;
    }

    @Override
    public Integer pop() {

        if (this.empty())
            return null;
        Integer integer = this.integers[point];
        point -= 1;
        return integer;
    }

    @Override
    public Integer peek() {

        if (this.empty())
            return null;
        return this.integers[point];
    }

    @Override
    public boolean empty() {
        return this.point < 0;
    }

    @Override
    public int size() {
        return point + 1;
    }
}

 　　　　　　7-5 jmu-Java-03面向对象基础-05-覆盖

　　　　　　   理解Override的概念以及用法即可完成解答

　　　　　　　　源码如下：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;

public class Main {
    public static void main(String[] args){
        Scanner input = new Scanner(System.in);
        ArrayList<PersonOverride> persons1 = new ArrayList<>();
        int n1 = input.nextInt();
        for (int i = 0 ; i < n1 ; i++){
            PersonOverride personOverride = new PersonOverride();
            persons1.add(personOverride);
        }
        ArrayList<PersonOverride> persons2 = new ArrayList<>();
        int n2 = input.nextInt();
        for (int i = 0 ; i < n2 ; i++){
            String name = input.next();
            int age = input.nextInt();
            boolean gender = input.nextBoolean();
            PersonOverride personOverride = new PersonOverride(name , age , gender);
            if(isNotRepeat(persons2, personOverride))
                persons2.add(personOverride);
        }
        for (PersonOverride personOverride : persons1){
            System.out.println(personOverride);
        }
        for (PersonOverride personOverride : persons2){
            System.out.println(personOverride);
        }
        System.out.println(persons2.size());
        System.out.println(Arrays.toString(PersonOverride.class.getConstructors()));
    }
    public static boolean isNotRepeat(ArrayList<PersonOverride> persons , PersonOverride personOverride){
        if(persons.isEmpty())
            return true;
        for(PersonOverride personOverride1 : persons){
            if(personOverride1.equals(personOverride))
                return false;
        }
        return true;
    }

}
class PersonOverride {
    private String name;
    private int age;
    private boolean gender;

    public PersonOverride() {
        this("default",1,true);
    }

    public PersonOverride(String name, int age, boolean gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public boolean isGender() {
        return gender;
    }

    @Override
    public boolean equals(Object o){
        return this.name.equals(((PersonOverride) o).getName()) && this.age == ((PersonOverride) o).getAge() && this.gender == ((PersonOverride) o).isGender();
    }

    @Override
    public String toString(){
        String str = this.name;
        str += "-";
        str += Integer.toString(this.age);
        str += "-";
        str += Boolean.toString(this.gender);
        return str;
    }

}

 3.踩坑心得

　　　　在第一次的课程成绩统计系统中最开始并没有使用正则表达式对输入进行判断而是人为进行判断，导致许多非法输入难以去除，导致程序抛出异常　　

 　　　　使用正则前：

 　　　　　　使用正则后：

 4.改进建议

　　　　要多使用正则表达式对输入的数据，文本进行处理，尽量避免人为对数据判断，避免异常输入却没被考虑到的情况

　　　　  防止异常的产生。

5.总结

　　　　通过这一阶段的学习，掌握了基本的面向对象的设计思路，思想。

  ···　　　掌握了接口，继承，多态等概念以及使用运用方法

　　　　  掌握了程序设计七大原则

　　　　  掌握了使用异常编写程序的方法

 　　　　 掌握了正则表达式的使用，能运用正则表达式对文本进行处理

 

 建议

 　　　　可以增加边讲边练的部分，感觉在课上写代码更容易掌握所学的内容