第三次大作业

前言

    时间过的好快啊，转眼迎来了最后一次java的blog。突然有一种很不舍的感觉，因为疫情的缘故，大部分时间都是线上教学，我们的生活好像被按了加速键。在这段时间里，还是学到了点东西，自己对于java的理解更加深刻了，终于将自己的面向过程的思维转变了过来，能够面向对象的去解决问题。这次的作业总结主要是围绕电信计费系列的题目，主要考察了关于父类与子类的运用合理，还有抽象类的使用，并且更加深层次的使用容器，加强了类之间的联系与引用，还有近期的老朋友——正则表达式的使用。

 

      接下来是题目的详细分析……

 

nchu-software-oop-2022-6

 7-1 电信计费系列1-座机计费

   这道题嘛..有几个点确实是过不去，是关于一些无效输入的判断与忽略，考虑了好久，真的想不到了，所以那几分就放弃了。情况的考虑不周。

   以下是代码：

 

import java.util.Comparator;
import java.text.DecimalFormat;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Main {
    public static void main(String[] args) throws ParseException {
    ArrayList <User> users= new ArrayList <User> ();
    User user = null;
    Scanner in = new Scanner(System.in);
    String s=new String();
    boolean flag;
    boolean flag1;
    boolean flag2;
    boolean f=false;
    String[] s1; 
    String regexm = "u-0791\\d{7,8} 0";
    String regexn = "t-\\d{11,12} 0[1-9]{1}\\d{9,10} \\d{4}.\\d{1,2}.\\d{1,2}+ \\d{1,2}:\\d{1,2}:\\d{1,2} \\d{4}.\\d{1,2}.\\d{1,2}+ \\d{1,2}:\\d{1,2}:\\d{1,2}";

    int n;
    s=in.nextLine();
    do {
         flag = s.matches(regexm);//判断功能
         s1=s.split(" ");
        if(!flag) {
            s=in.nextLine();
            while(s.equals(""))
                s=in.nextLine();
            continue;
        }
     user =new User();
   

    user.getNumber(s1[0].substring(2));
    
     for(int i=0;i<users.size();i++) {
        if(user.number.equals(users.get(i).retNumber())) {
            f=true;
            break;
        }
    }
    if(f) {
        s=in.nextLine();
        while(s.equals(""))
            s=in.nextLine();
        continue;
    }
    users.add(user);
    s=in.nextLine();
    while(s.equals(""))
        s=in.nextLine();
    user.getDevice(Integer.parseInt(s1[1]));
    }while(s.charAt(0)=='u');
    
    do {
      s1=s.split(" ");
      flag = s.matches(regexn);//判断功能
        if(!flag) {
        s=in.nextLine();
        continue;
    }
        
        user=null;
        for(int i=0;i<users.size();i++) {
            if(s1[0].substring(2).equals(users.get(i).retNumber())) {
                user=users.get(i);
                break;
            }
                
        }
        if(user==null) {
            s=in.nextLine();
            while(s.equals(""))
                s=in.nextLine();
            continue;
        }
        
    CommunicationRecord records =new CommunicationRecord();
    String sm=s1[2]+" "+s1[3];
    String sn=s1[4]+" "+s1[5];
    if(!(records.validDateTimeSimple(sn)&&records.validDateTimeSimple(sm))) {
        s=in.nextLine();
        while(s.equals(""))
            s=in.nextLine();
           continue;
    }

    String regex0 = "0791";
       String regex1 = "(079\\d)|0701";

       flag = s1[1].substring(0,4).matches(regex0);//判断功能
       flag1 = s1[1].substring(0,4).matches(regex1);//判断功能    

       n=3;
       if(flag1) 
              n=2;
       if(flag) 
           n=1;
       
       
       records.answerNumber=s1[1];
       records.begintime=s1[2]+" "+s1[3];
       records.endtime=s1[4]+" "+s1[5];
       records.chose=n;
       user.setUserRecords(records);
       s=in.nextLine();
    }while(!s.equals("end"));
    
    DecimalFormat df =new DecimalFormat("0.0");
    Collections.sort(users,new UserComparator());
    for(int j=0;j<users.size();j++) {
        users.get(j).calcost();
        System.out.println(users.get(j).number+" "+users.get(j).getCost() +" "+users.get(j).getBalance());
    }
}
    public static class User {
ArrayList <CommunicationRecord> userRecords =new ArrayList <CommunicationRecord>();
    double balance=100;
    ChargeRules chargeRules =new ChargeRules();
    String number;
    Device device;
    double sumcost=0;
    
    public void setUserRecords(CommunicationRecord Records) {
        userRecords.add(Records);
    }
    public void setChargeRules(ChargeRules land) {
        this.chargeRules=chargeRules;
    }
    public void calcost() throws ParseException {
        for(int i=0;i<userRecords.size();i++) {
            double time =userRecords.get(i).sumtime();
            if(userRecords.get(i).chose==1) {
                cost(time*0.1);
            }
            else if(userRecords.get(i).chose==2) {
                cost(time*0.3);
            }
            else
                cost(time*0.6);
        }
    }
    public void getNumber(String s) {
    
        this.number=s;
        
    }
       public String retNumber() {
        return  this.number;
    }
    
    public void cost(double x) {
        this.balance=this.balance -x;
        sumcost+=x;
    }
    public double getBalance() {
        return balance;
    }
    public double getCost() {
        return sumcost;
    }
    public void getDevice(int x) {
        if(x==0) {
            device =new Landlines();
            LandRule land =new LandRule();
            setChargeRules(land);
            balance=balance-Landlines.monthlyRent;
        }
    }
    
   }

public static class ChargeRules {
   public double calCost(ArrayList<CallRecord> callRecords){
       return 0;
   }
}
public static class UserRecords {

}
  public static class UserComparator implements Comparator<User>{

@Override
public int compare(User s, User s1) {
    int flag = new Integer(s.number.compareTo(s1.number));
    return flag;
}

}
public static class Device {
    double monthlyRent;
    ArrayList <ChargeRules> chargeRules=new ArrayList <ChargeRules>();
    
    public void getChargeRules(ArrayList <ChargeRules> chargeRules) {
        this.chargeRules =chargeRules;
    }
}
 public static class CommunicationRecord {
    String callingNumber;
    String answerNumber;
    String begintime;
    String endtime;
    int chose;
    
      public static boolean validDateTimeSimple(String dateTime) {
        if(dateTime == null ) {
            return false;
        }
        DateFormat df = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
        df.setLenient(false);//表示严格验证
        
        try {
            df.parse(dateTime);
        } catch (ParseException e) {
            return false;
        }
        return true;
    }

    public long sumtime() throws ParseException {
        
            //一、时间减法可以用Calendar对象加法中，把第二个参数换成负数可以时间，这边就不列举了；使用第二种方式做时间减法
            //1、指定两个Date对象，业务中可以以参数的形式传递，不用new当前时间。
            DateFormat dateFormat = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
            String nowday = this.endtime;
            Date nowDate = dateFormat.parse(nowday);//当前时间
            String yesterday = this.begintime;
            Date yesterdayDate = dateFormat.parse(yesterday);//假设一个时间，工作业务中可以参数传递的形式来获取。
            //2、时间戳相减
            long yesterdayDateTime = yesterdayDate.getTime();//昨天的时间戳
            long nowDateTime = nowDate.getTime();//当前时间戳
            long result = nowDateTime - yesterdayDateTime;//毫秒
             
            long diffSecond = result / 1000; //1000毫秒等于1秒
            
            //4、换算成分钟
            long diffMinute = result / 60000 ;//60秒等于1分钟
            if(result%60000!=0){
                diffMinute=diffMinute+1;
            }
        return diffMinute;
    }
} 
   public static class CallRecord extends CommunicationRecord{
  String callingAddressAreaCode;
  String answerAddressAreaCode;
  String begintime;
  String endtime;
}
public static class Landlines extends Device{
    static double monthlyRent=20;
    
}
    public static class LandRule extends ChargeRules{

}
}

 

设计与分析：首先，我是设计好了user类和需要判断日期和计算时间的类，还有记录通话记录的类、设备类作为座机的父类。然后再去按照输入输出去设计Main类里的一些判断和与其他类的交互，中途很多次添加了一些额外判断去忽略那些错误输入。

采坑心得：一开始不知道impleDateFormat类可以去判断日期输入是否合法，还是自己去判断，发现真的很麻烦，后面通过询问老师，才知道要用这个类里的功能。

改进建议：因为没有多边形复杂，自己又懒得写注释了，这是一个不好的下意识。感觉自己还是要多写注释，也是方便自己的使用。判断其实后面越改越觉得比较繁琐，一开始应该写个类来专门实现判断功能的。一开始写并没有考虑后面添加了手机功能的交互性，后面改其实麻烦很多，一开始以为自己一开始的设计可以交互，后面使用的时候才发现不行，以后还是要先多思考一会。

 

7-2 多态测试

   这道题还是比较简单的，因为老师将主要的方法都告诉我们了，我们只要简单的实现一些功能就好了。主要是训练多态的使用，还有容器的使用。

以下是代码：

 

import java.text.DecimalFormat;
import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner in =new Scanner (System.in);
        String s;
        int n=in.nextInt();
        Container[] c =new Container[n];
        for(int i=0;i<n;i++) {
            s=in.nextLine();
            s=in.nextLine();
            if(s.equals("cube")) {
                c[i]=new Cube();
                ((Cube)c[i]).l=in.nextDouble();
            }
            if(s.equals("cylinder")) {
                c[i]=new Cylinder();
                ((Cylinder)c[i]).r=in.nextDouble();
                ((Cylinder)c[i]).h=in.nextDouble();
                
            }
            
        }
        DecimalFormat df =new DecimalFormat("0.00");
        System.out.println(df.format(Container.sumofArea(c)));
        System.out.println(df.format(Container.sumofVolume(c)));
        
        
      }
    interface Container {
    public static final double pi=3.1415926;
    public abstract double area();
    public abstract double volume();
    static double sumofArea(Container c[]) {
        double sa=0;
        for(int i=0;i<c.length;i++) {
            sa+=c[i].area();
        }
        return sa;
    }
    static double sumofVolume(Container c[]) {
        double sv=0;
        for(int i=0;i<c.length;i++) {
            sv+=c[i].volume();
        }
        return sv;
    }
} 
public static class Cube implements Container {
    double l=0;
    @Override
    public double area() {
        
        return 6*l*l;
    }

    @Override
    public double volume() {
        
        return l*l*l;
    }

}
public static class Cylinder implements Container{
    double h=0;
    double r=0;
    @Override
    public double area() {
        
        return 2*pi*r*h+2*pi*r*r;
    }

    @Override
    public double volume() {
        
        return pi*r*r*h;
    }

}

}

 

 

 

nchu-software-oop-2022-7

7-1 电信计费系列2-手机+座机计费

     这道题主要是在上一次的大作业基础上添加了手机的相关功能。

以下是代码：

import java.util.Comparator;
import java.text.DecimalFormat;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Main {
    
public static void main(String[] args) throws ParseException {
    ArrayList <User> users= new ArrayList <User> ();
    User user = null;
    Scanner in = new Scanner(System.in);
    String s=new String();
    Device diver = null ;
    boolean flag;
    boolean flag1;
    boolean flag2;
    boolean f=false;
    String[] s1; 
    String regexm = "u-0791\\d{7,8} 0";  //座机
    String regexp = "u-1\\d{10} 1";   //手机
    String regexn = "t-\\d{11,12} 0[1-9]{1}\\d{9,10} \\d{4}.\\d{1,2}.\\d{1,2}+ \\d{1,2}:\\d{1,2}:\\d{1,2} \\d{4}.\\d{1,2}.\\d{1,2}+ \\d{1,2}:\\d{1,2}:\\d{1,2}";
    //座机打座机
    String regexn0 = "t-\\d{11,12} 1\\d{10} 0\\d{2,3} \\d{4}.\\d{1,2}.\\d{1,2}+ \\d{1,2}:\\d{1,2}:\\d{1,2} \\d{4}.\\d{1,2}.\\d{1,2}+ \\d{1,2}:\\d{1,2}:\\d{1,2}";
    //座机打手机
    String regexn1 ="t-\\d{11} 0\\d{2,3} 1\\d{10} 0\\d{2,3} \\d{4}.\\d{1,2}.\\d{1,2}+ \\d{1,2}:\\d{1,2}:\\d{1,2} \\d{4}.\\d{1,2}.\\d{1,2}+ \\d{1,2}:\\d{1,2}:\\d{1,2}";
    //手机互打
    String regexn2 ="t-1\\d{10} 0\\d{2,3} 0[1-9]{1}\\d{9,10} \\d{4}.\\d{1,2}.\\d{1,2}+ \\d{1,2}:\\d{1,2}:\\d{1,2} \\d{4}.\\d{1,2}.\\d{1,2}+ \\d{1,2}:\\d{1,2}:\\d{1,2}";
    //手机打座
    int n;
    s=in.nextLine();
    do {
         flag = s.matches(regexm)||s.matches(regexp);//判断功能
         s1=s.split(" ");
        if(!flag) {
            s=in.nextLine();
            while(s.equals(""))
                s=in.nextLine();
            continue;
        }
     user =new User();
   

    user.getNumber(s1[0].substring(2));
    
   for(int i=0;i<users.size();i++) {
        if(user.number.equals(users.get(i).retNumber())) {
            f=true;
            break;
        }
    }
    if(f) {
        s=in.nextLine();
        while(s.equals(""))
            s=in.nextLine();
        f=false;
        continue;
    }
    users.add(user);
    s=in.nextLine();
    while(s.equals(""))
        s=in.nextLine();
    user.getDevice(Integer.parseInt(s1[1]));
    }while(s.charAt(0)=='u');
    
    do {
      s1=s.split(" ");
      flag = s.matches(regexn)||s.matches(regexn0)||s.matches(regexn1)||s.matches(regexn2);//判断功能
        if(!flag) {
        s=in.nextLine();
        continue;
    }
        
        user=null;
        for(int i=0;i<users.size();i++) {
            if(s1[0].substring(2).equals(users.get(i).retNumber())) {
                user=users.get(i);
                break;
            }
                
        }
    if(user==null) {
             String regex0 = "0791";
                    String regex1 = "(079\\d)|0701";
                    boolean flagx = s1[3].matches(regex0)||s1[2].matches(regex0);//判断功能
                    boolean flagy = s1[3].matches(regex1)||s1[2].matches(regex0);//判断功能    
                    int m=3;//省外
                       if(flagy) 
                              m=2;    //省内
                       if(flagx) 
                           m=1;    //市内
            
            for(int i=0;i<users.size();i++) {
                if(s1[2].equals(users.get(i).retNumber())) {
                       if(m==3) {
                           CommunicationRecord records =new CommunicationRecord();
                           records.begintime=s1[4]+" "+s1[5];
                           records.endtime=s1[6]+" "+s1[7];
                           users.get(i).cost(records.sumtime()*0.3);
                       }
                       }
                if(s1[1].equals(users.get(i).retNumber())) {
                    if(m==3) {
                        CommunicationRecord records =new CommunicationRecord();
                        records.begintime=s1[3]+" "+s1[4];
                        records.endtime=s1[5]+" "+s1[6];
                        users.get(i).cost(records.sumtime()*0.3);
                    }
                    }
                }
            s=in.nextLine();
            continue;
        }
        
    if(s.matches(regexn)) {
        diver =new Landlines();
        int i=((Landlines)diver).input1(user, s1, s);
        if(i==-1) {
            s=in.nextLine();
             continue;
        }    
    }
    else if(s.matches(regexn0)) { //考虑漫游
        diver=new Landlines();
        int i=((Landlines)diver).input2(users,user, s1, s);
        if(i==-1) {
            s=in.nextLine();
             continue;
        }    
    }
    else if(s.matches(regexn1)) {  //考虑漫游
        diver=new Phone();
        int i=((Phone)diver).input1(users,user, s1, s);
        if(i==-1) {
            s=in.nextLine();
             continue;
        }    
    }
    else if(s.matches(regexn2)) {
        diver=new Phone();
        int i=((Phone)diver).input2(user, s1, s);
        if(i==-1) {
            s=in.nextLine();
             continue;
        }    
     }
    
       s=in.nextLine();
       while(s.equals(""))
           s=in.nextLine();
    }while(!s.equals("end"));
    
    Collections.sort(users,new UserComparator());
    for(int j=0;j<users.size();j++) {
        users.get(j).calcost();
        System.out.println(users.get(j).number+" "+users.get(j).getCost() +" "+users.get(j).getBalance());
    }
}
public static class User {
    ArrayList <CommunicationRecord> userRecords =new ArrayList <CommunicationRecord>();
    double balance=100;
    ChargeRules chargeRules =new ChargeRules();
    String number;
    Device device;
    double sumcost=0;
    
    public void setUserRecords(CommunicationRecord Records) {
        userRecords.add(Records);
    }
    public void setChargeRules(ChargeRules land) {
        this.chargeRules=chargeRules;
    }
    public void calcost() throws ParseException {
        for(int i=0;i<userRecords.size();i++) {
            double time =userRecords.get(i).sumtime();
            if(userRecords.get(i).chose1==0) {
                if(userRecords.get(i).chose==1) 
                cost(time*0.1);
            
            else if(userRecords.get(i).chose==2) 
                cost(time*0.3);
            
            else
                cost(time*0.6);
            }
            
            else {
                if(userRecords.get(i).chose==1) {
                    if(userRecords.get(i).chose1==1)
                        cost(time*0.1);
                    else if(userRecords.get(i).chose1==2) 
                        cost(time*0.2);
                    
                    else
                        cost(time*0.3);
                }
                else if(userRecords.get(i).chose==2) {
                        cost(time*0.3);
                }
                else if(userRecords.get(i).chose==3) {
                    cost(time*0.6);
            }
                
            }
        }
    }
    public void getNumber(String s) {
        this.number=s;
    }
    public String retNumber() {
        return  this.number;
    }
    
    public void cost(double x) {
        this.balance=this.balance -x;
        sumcost+=x;
    }
    public double getBalance() {
        return balance;
    }
    public double getCost() {
        return sumcost;
    }
    public void getDevice(int x) {
        if(x==0) {
            device =new Landlines();
            LandRule land =new LandRule();
            setChargeRules(land);
            balance=balance-Landlines.monthlyRent;
        }
        if(x==1) {
            device =new Phone();
            LandRule land =new LandRule();
            setChargeRules(land);
            balance=balance-Phone.monthlyRent;
        }
    }
    
}

public static class ChargeRules {
   public double calCost(ArrayList<CallRecord> callRecords){
       return 0;
   }
}
public static class UserRecords {

}
  public static class UserComparator implements Comparator<User>{

@Override
public int compare(User s, User s1) {
    int flag = new Integer(s.number.compareTo(s1.number));
    return flag;
}

}
public static class Device {
    double monthlyRent;
    ArrayList <ChargeRules> chargeRules=new ArrayList <ChargeRules>();
    
    public void getChargeRules(ArrayList <ChargeRules> chargeRules) {
        this.chargeRules =chargeRules;
    }
}
 public static class CommunicationRecord {
    String callingNumber;
    String answerNumber;
    String begintime;
    String endtime;
    int chose=0;
    int chose1=0;
    int month;
    
    
      public static boolean validDateTimeSimple(String dateTime) {
        if(dateTime == null ) {
            return false;
        }
        DateFormat df = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
        df.setLenient(false);//表示严格验证
        
        try {
            df.parse(dateTime);
        } catch (ParseException e) {
            return false;
        }
        return true;
    }

    public long sumtime() throws ParseException {
        
            //一、时间减法可以用Calendar对象加法中，把第二个参数换成负数可以时间，这边就不列举了；使用第二种方式做时间减法
            //1、指定两个Date对象，业务中可以以参数的形式传递，不用new当前时间。
            DateFormat dateFormat = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
            String nowday = this.endtime;
            Date nowDate = dateFormat.parse(nowday);//当前时间
            String yesterday = this.begintime;
            Date yesterdayDate = dateFormat.parse(yesterday);//假设一个时间，工作业务中可以参数传递的形式来获取。
            //2、时间戳相减
            long yesterdayDateTime = yesterdayDate.getTime();//昨天的时间戳
            long nowDateTime = nowDate.getTime();//当前时间戳
            long result = nowDateTime - yesterdayDateTime;//毫秒
             
            long diffSecond = result / 1000; //1000毫秒等于1秒
            
            //4、换算成分钟
            long diffMinute = result / 60000 ;//60秒等于1分钟
            if(result%60000!=0){
                diffMinute=diffMinute+1;
            }
        return diffMinute;
    }
} 
   public static class CallRecord extends CommunicationRecord{
  String callingAddressAreaCode;
  String answerAddressAreaCode;
  String begintime;
  String endtime;
}
public static class Landlines extends Device{
        static double monthlyRent=20;
    
    public int input1(User user,String[] s1,String s) {
    
            boolean flag;
            boolean flag1;
            boolean flag2;
          
            int n=0;
        CommunicationRecord records =new CommunicationRecord();
        String sm=s1[2]+" "+s1[3];
        String sn=s1[4]+" "+s1[5];
        if(!(records.validDateTimeSimple(sn)&&records.validDateTimeSimple(sm))) {
               return -1;
        }

        String regex0 = "0791";
           String regex1 = "(079\\d)|0701";

           flag = s1[1].substring(0,4).matches(regex0);//判断功能
           flag1 = s1[1].substring(0,4).matches(regex1);//判断功能    

           n=3;
           if(flag1) 
                  n=2;
           if(flag) 
               n=1;
           
           records.answerNumber=s1[1];
           records.begintime=s1[2]+" "+s1[3];
           records.endtime=s1[4]+" "+s1[5];
           records.chose=n;
           user.setUserRecords(records);
           return 1;
    }
    public int input2(ArrayList<User> users, User user,String[] s1,String s) throws ParseException {

            boolean flag;
            boolean flag1;
            boolean flag2;
            boolean flag3;
            int m=0;
            int n=0;
        CommunicationRecord records =new CommunicationRecord();
        String sm=s1[3]+" "+s1[4];
        String sn=s1[5]+" "+s1[6];
        if(!(records.validDateTimeSimple(sn)&&records.validDateTimeSimple(sm))) {
               return -1;
        }

        String regex0 = "0791";
           String regex1 = "(079\\d)|0701";

           flag =  s1[0].substring(2,6).matches(regex0);//判断功能
           flag1 = s1[0].substring(2,6).matches(regex1);//判断功能    
           flag2 =  s1[2].matches(regex0);//判断功能
           flag3 = s1[2].matches(regex1);//判断功能    

           
          
           n=3;   //省外
           if(flag3) 
                  n=2;    //省内
           if(flag2) 
               n=1;    //市内
           m=3;   //省外
           if(flag3) 
                  m=2;    //省内
           if(flag2) 
               m=1;    //市内
        
           records.answerNumber=s1[1];
           records.begintime=s1[3]+" "+s1[4];
           records.endtime=s1[5]+" "+s1[6];
           records.chose=n;
           user.setUserRecords(records);
           
           if(m==3) {
               for(int i=0;i<users.size();i++) {
                   if(users.get(i).number.equals(s1[1])) {
                       users.get(i).cost(records.sumtime()*0.3);
                   }
                       
               }
           }
           return 1;
    }
}


    public static class LandRule extends ChargeRules{

}
    public static class Phone extends Device{
    static double monthlyRent=15;
    
    public int input1(ArrayList<User> users, User user,String[] s1,String s) throws ParseException {
            boolean flag;
            boolean flag1;
            boolean flag2;
            boolean flag3;
            int n=0;
            int m=0;
        CommunicationRecord records =new CommunicationRecord();
        String sm=s1[4]+" "+s1[5];
        String sn=s1[6]+" "+s1[7];
        if(!(records.validDateTimeSimple(sn)&&records.validDateTimeSimple(sm))) {
               return -1;
        }

        String regex0 = "0791";
           String regex1 = "(079\\d)|0701";

           flag = s1[1].matches(regex0);//判断功能
           flag1 = s1[1].matches(regex1);//判断功能    
           flag2 = s1[3].matches(regex0);//判断功能
           flag3 = s1[3].matches(regex1);//判断功能    

           n=3;  //省外
           if(flag1) 
                  n=2;  //省内
           if(flag) 
               n=1;  //市内
           
           m=3;   //省外
           if(flag3) 
                  m=2;    //省内
           if(flag2) 
               m=1;    //市内
           
           records.answerNumber=s1[2];
            records.begintime=s1[4]+" "+s1[5];
           records.endtime=s1[6]+" "+s1[7];
           records.chose=n;
           records.chose1=m;
            user.setUserRecords(records);
           if(m==3) {
               for(int i=0;i<users.size();i++) {
                   if(users.get(i).number.equals(s1[2])) {
                       users.get(i).cost(records.sumtime()*0.3);
                   }
                       
               }
           }
          
          
           return 1;
    }
    
    public int input2(User user,String[] s1,String s) {
        boolean flag;
        boolean flag1;
        boolean flag2;
        boolean flag3;
        int n=0;
        
    CommunicationRecord records =new CommunicationRecord();
    String sm=s1[3]+" "+s1[4];
    String sn=s1[5]+" "+s1[6];
    if(!(records.validDateTimeSimple(sn)&&records.validDateTimeSimple(sm))) {
           return -1;
    }

    String regex0 = "0791";
       String regex1 = "(079\\d)|0701";

       flag = s1[1].matches(regex0);//判断功能
       flag1 = s1[1].matches(regex1);//判断功能    
       flag2 = s1[2].substring(0,4).matches(regex0);//判断功能
       flag3 = s1[2].substring(0,4).matches(regex1);//判断功能    

       n=3;  //省外
       if(flag1) 
              n=2;  //省内
       if(flag) 
           n=1;  //市内
       
   
       
       records.answerNumber=s1[2];
       
       records.begintime=s1[3]+" "+s1[4];
       records.endtime=s1[5]+" "+s1[6];
       records.chose=n;
     
       user.setUserRecords(records);
       return 1;
}
}

}

 

 设计与分析：设计思路跟写上一题座机的差不多，毕竟我也是在那个代码的基础上改进的，主要是将一部分的判断代码写到别的类里去了，但是复用性也不高，因为都有一部分的改动，主要是添加了手机类，并且让设备类成为它的父类。主要是判断相关的功能比较繁琐。

采坑心得：时间花费的不太多，所以分数不高，因为遇上了端午，一直在准备回家的东西，确实有点没心思写作业了，一开始的很多时间也浪费了，确实有点遗憾。

改进建议：还是要多花点时间在作业上，在一些时候也要学会沉下心来去认认真真的写点东西，不要一直拖。

 

7-2 sdut-Collection-sort--C~K的班级（II）

  这道题主要考察了对于容器HashMap的使用，集合容器，不会让元素重复出现，是个很好的特点。其中还有关于元素的排序，我是在网上学习借鉴了别人的方法写的。

 以下是代码：

 

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;


public class Main {

    public static void main(String[] args) {
        HashMap<String,Student> students =new HashMap<String,Student>();
        Scanner in = new Scanner(System.in);
        int n=in.nextInt();
        String s=new String();
        s=in.nextLine();
        for(int i=0;i<n;i++) {
            s=in.nextLine();
            String[] ns=s.split(" ");
            Student s1 =new Student(ns[0],ns[1],ns[2],ns[3]);
            students.put(s1.num,s1);
        }
        
    
        HashMap<String,Student> sortHashMap = sortHashMap(students);

//返回所有value值 ！！！这个很便捷。
        System.out.println(sortHashMap.size());
        for(Student value :sortHashMap.values()) {
            System.out.println(value.num+" "+value.name+" "+value.age+" "+value.sex);
            
        }  
    }

    

     
        public static HashMap<String,Student> sortHashMap(HashMap<String,Student> map) {
            // 首先拿到 map 的键值对集合
            Set<Map.Entry<String,Student>> entrySet = map.entrySet();
            // 将 set 集合转为 List 集合，为什么，为了使用工具类的排序方法
            List<Map.Entry<String,Student>> list = new ArrayList<Map.Entry<String,Student>>(entrySet);
            // 使用 Collections 集合工具类对 list 进行排序，排序规则使用匿名内部类来实现
            Collections.sort(list, new Comparator<Map.Entry<String,Student>>() {
                @Override
                public int compare(Map.Entry<String,Student> o1, Map.Entry<String,Student> o2) {
                    //按照要求根据 User 的 age 的升序进行排,如果是倒序就是o2-o1
                    int flag = new Integer(o1.getValue().num.compareTo(o2.getValue().num));
                    return flag;
                }
            });
            //创建一个新的有序的 HashMap 子类的集合
            LinkedHashMap<String,Student> linkedHashMap = new LinkedHashMap<String,Student>();
            //将 List 中的数据存储在 LinkedHashMap 中
            for (Map.Entry<String,Student> entry : list) {
                linkedHashMap.put(entry.getKey(), entry.getValue());
            }
            //返回结果
            return linkedHashMap;
        }
    
}
 class Student {
    String name;
    String num;
    String sex;
    String age;
    public Student(String num, String name,String age, String sex) {
        super();
        this.age=age;
        this.name = name;
        this.num = num;
        this.sex = sex;
    }
    
}

 

 

 

7-3 阅读程序，按照题目需求修改程序

这道题更简单了，老师已经给了大部分代码，略微修改就好了。

以下是代码

 

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

//1、导入相关包

//定义员工类
class Employee {

    private String name;
    private int age;

    public Employee() {
        super();
    }

    public Employee(String name, int age) {
        super();
        name=name.substring(0,2);
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

//主函数
public class Main {

    public static void main(String[] args) {
                // 1、创建有序集合对象
        ArrayList<Employee> c =new ArrayList<Employee>();

   // 创建3个员工元素对象
                Scanner sc = new Scanner(System.in);
        for (int i = 0; i < 3; i++) {
            String employeeName = sc.nextLine();
            int employeeAge = Integer.parseInt(sc.nextLine());
            Employee employee = new Employee(employeeName, employeeAge);
            c.add(employee);
        }            
                
                
                //3、遍历
                for (int i=0;i<3;i++) {
                    System.out.println(c.get(i).getName() + "---" + c.get(i).getAge());
                }
    }

}

 

 

 

nchu-software-oop-2022-8

 

7-1 电信计费系列3-短信计费

 

     这个应该算的上是在座机的基础上改进的，因为需求比较简单，老师的要求也是只考虑短信计费，不考虑通信费用以及月租费。需求比较简单。但我为了方便还是在上一题的基础上改的。

 

以下是代码

 

 

import java.util.Comparator;
import java.text.DecimalFormat;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.text.DecimalFormat;
public class Main {
    
public static void main(String[] args) throws ParseException {
    ArrayList <User> users= new ArrayList <User> ();
    User user = null;
    Scanner in = new Scanner(System.in);
    String s=new String();
    Device diver = null ;
    boolean flag;
    boolean flag1;
    boolean flag2;
    boolean f=false;
    String[] s1; 
    String regexm = "u-0791\\d{7,8} 0";  //座机
    String regexp = "u-1\\d{10} 1";   //手机
    String regext = "u-1\\d{10} 3";   //短信
     String regexn = "t-\\d{10,13} \\d{10,13} \\d{4}\\.([1-9]|1[0-2])\\.([1-9]|[1-2][0-9]|3[0-1]) (2[0-3]|[0-1]\\d):[0-5]\\d:[0-5]\\d \\d{4}\\.([1-9]|1[0-2])\\.([1-9]|[1-2][0-9]|3[0-1]) (2[0-3]|[0-1]\\d):[0-5]\\d:[0-5]\\d";
     //座机打座机
    String regexn0 = "t-\\d{11,12} 1\\d{10} 0\\d{2,3} \\d{4}.\\d{1,2}.\\d{1,2}+ \\d{1,2}:\\d{1,2}:\\d{1,2} \\d{4}.\\d{1,2}.\\d{1,2}+ \\d{1,2}:\\d{1,2}:\\d{1,2}";
    //座机打手机
    String regexn1 ="t-\\d{11} 0\\d{2,3} 1\\d{10} 0\\d{2,3} \\d{4}.\\d{1,2}.\\d{1,2}+ \\d{1,2}:\\d{1,2}:\\d{1,2} \\d{4}.\\d{1,2}.\\d{1,2}+ \\d{1,2}:\\d{1,2}:\\d{1,2}";
    //手机互打
    String regexn2 ="t-1\\d{10} 0\\d{2,3} 0[1-9]{1}\\d{9,10} \\d{4}.\\d{1,2}.\\d{1,2}+ \\d{1,2}:\\d{1,2}:\\d{1,2} \\d{4}.\\d{1,2}.\\d{1,2}+ \\d{1,2}:\\d{1,2}:\\d{1,2}";
    //手机打座
    String text ="m-1\\d{10} 1\\d{10} [A-Za-z0-9 ,.]+";
    int n;
    s=in.nextLine();
    do {
         flag =s.matches(regext)||s.matches(regexm)||s.matches(regexp);//判断功能
         s1=s.split(" ");
        if(!flag) {
            s=in.nextLine();
            while(s.equals(""))
                s=in.nextLine();
            continue;
        }
     user =new User();
   

    user.getNumber(s1[0].substring(2));
    
   for(int i=0;i<users.size();i++) {
        if(user.number.equals(users.get(i).retNumber())) {
            f=true;
            break;
        }
    }
    if(f) {
        s=in.nextLine();
        while(s.equals(""))
            s=in.nextLine();
        f=false;
        continue;
    }
    users.add(user);
    s=in.nextLine();
    while(s.equals(""))
        s=in.nextLine();
    user.getDevice(Integer.parseInt(s1[1]));
    }while(s.charAt(0)=='u');
    
    do {
      s1=s.split(" ");
      flag =  s.matches(text)||s.matches(regexn)||s.matches(regexn0)||s.matches(regexn1)||s.matches(regexn2);//判断功能
        if(!flag) {
        s=in.nextLine();
        continue;
    }
        
        user=null;
        for(int i=0;i<users.size();i++) {
            if(s1[0].substring(2).equals(users.get(i).retNumber())) {
                user=users.get(i);
                break;
            }
                
        }
        if(user==null) {
//              String regex0 = "0791";
//                     String regex1 = "(079\\d)|0701";
//                     boolean flagx = s1[3].matches(regex0)||s1[2].matches(regex0);//判断功能
//                     boolean flagy = s1[3].matches(regex1)||s1[2].matches(regex0);//判断功能    
//                     int m=3;//省外
//                        if(flagy) 
//                               m=2;    //省内
//                        if(flagx) 
//                            m=1;    //市内
            
//             for(int i=0;i<users.size();i++) {
//                 if(s1[2].equals(users.get(i).retNumber())) {
//                        if(m==3) {
//                            CommunicationRecord records =new CommunicationRecord();
//                            records.begintime=s1[4]+" "+s1[5];
//                            records.endtime=s1[6]+" "+s1[7];
//                            users.get(i).cost(records.sumtime()*0.3);
//                        }
//                        }
//                 if(s1[1].equals(users.get(i).retNumber())) {
//                     if(m==3) {
//                         CommunicationRecord records =new CommunicationRecord();
//                         records.begintime=s1[3]+" "+s1[4];
//                         records.endtime=s1[5]+" "+s1[6];
//                         users.get(i).cost(records.sumtime()*0.3);
//                     }
//                     }
//                 }
            s=in.nextLine();
            continue;
        }
    if( s.matches(text)) {
        user.message(s.substring(26));
    }
    if(s.matches(regexn)) {
        diver =new Landlines();
        int i=((Landlines)diver).input1(user, s1, s);
        if(i==-1) {
            s=in.nextLine();
             continue;
        }    
    }
    else if(s.matches(regexn0)) { //考虑漫游
        diver=new Landlines();
        int i=((Landlines)diver).input2(users,user, s1, s);
        if(i==-1) {
            s=in.nextLine();
             continue;
        }    
    }
    else if(s.matches(regexn1)) {  //考虑漫游
        diver=new Phone();
        int i=((Phone)diver).input1(users,user, s1, s);
        if(i==-1) {
            s=in.nextLine();
             continue;
        }    
    }
    else if(s.matches(regexn2)) {
        diver=new Phone();
        int i=((Phone)diver).input2(user, s1, s);
        if(i==-1) {
            s=in.nextLine();
             continue;
        }    
     }
    
       s=in.nextLine();
       while(s.equals(""))
           s=in.nextLine();
    }while(!s.equals("end"));
    
    Collections.sort(users,new UserComparator());
    
    DecimalFormat df =new DecimalFormat("0.0##");

    for(int j=0;j<users.size();j++) {
//        users.get(j).calcost();
           users.get(j).messagecost();
        System.out.println(users.get(j).number+" "+df.format(users.get(j).getCost()) +" "+df.format(users.get(j).getBalance()));
    }
}
public static class User {
ArrayList <CommunicationRecord> userRecords =new ArrayList <CommunicationRecord>();
    double balance=100;
    ChargeRules chargeRules =new ChargeRules();
    String number;
    Device device;
    double sumcost=0;
    MessageRecord text=new MessageRecord();
    public void setUserRecords(CommunicationRecord Records) {
        userRecords.add(Records);
    }
    public void setChargeRules(ChargeRules land) {
        this.chargeRules=chargeRules;
    }
    public void calcost() throws ParseException {
        for(int i=0;i<userRecords.size();i++) {
            double time =userRecords.get(i).sumtime();
            if(userRecords.get(i).chose1==0) {
                if(userRecords.get(i).chose==1) 
                cost(time*0.1);
            
            else if(userRecords.get(i).chose==2) 
                cost(time*0.3);
            
            else
                cost(time*0.6);
            }
            
            else {
                if(userRecords.get(i).chose==1) {
                    if(userRecords.get(i).chose1==1)
                        cost(time*0.1);
                    else if(userRecords.get(i).chose1==2) 
                        cost(time*0.2);
                    
                    else
                        cost(time*0.3);
                }
                else if(userRecords.get(i).chose==2) {
                        cost(time*0.3);
                }
                else if(userRecords.get(i).chose==3) {
                    cost(time*0.6);
            }
                
            }
        }
        }
    public void message(String s) {
        
        text.jisuan(s);
        
    }
    public void messagecost() {
        cost(text.cost(text.num));
    }
    public void getNumber(String s) {
        this.number=s;
    }
    public String retNumber() {
        return  this.number;
    }
    
    public void cost(double x) {
        this.balance=this.balance -x;
        sumcost+=x;
    }
    public double getBalance() {
        return balance;
    }
    public double getCost() {
        return sumcost;
    }
    public void getDevice(int x) {
        if(x==0) {
            device =new Landlines();
            LandRule land =new LandRule();
            setChargeRules(land);
            balance=balance-Landlines.monthlyRent;
        }
        if(x==1) {
            device =new Phone();
            LandRule land =new LandRule();
            setChargeRules(land);
            balance=balance-Phone.monthlyRent;
        }
        if(x==3) {
            device =new Phone();
            LandRule land =new LandRule();
            setChargeRules(land);
        }
    }
    
}


public static class ChargeRules {
   public double calCost(ArrayList<CallRecord> callRecords){
       return 0;
   }
}
public static class UserRecords {

}
  public static class UserComparator implements Comparator<User>{

@Override
public int compare(User s, User s1) {
    int flag = new Integer(s.number.compareTo(s1.number));
    return flag;
}

}
public static class Device {
    double monthlyRent;
    ArrayList <ChargeRules> chargeRules=new ArrayList <ChargeRules>();
    
    public void getChargeRules(ArrayList <ChargeRules> chargeRules) {
        this.chargeRules =chargeRules;
    }
}
 public static class CommunicationRecord {
    String callingNumber;
    String answerNumber;
    String begintime;
    String endtime;
    int chose=0;
    int chose1=0;
    int month;
    
    
      public static boolean validDateTimeSimple(String dateTime) {
        if(dateTime == null ) {
            return false;
        }
        DateFormat df = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
        df.setLenient(false);//表示严格验证
        
        try {
            df.parse(dateTime);
        } catch (ParseException e) {
            return false;
        }
        return true;
    }

    public long sumtime() throws ParseException {
        
            //一、时间减法可以用Calendar对象加法中，把第二个参数换成负数可以时间，这边就不列举了；使用第二种方式做时间减法
            //1、指定两个Date对象，业务中可以以参数的形式传递，不用new当前时间。
            DateFormat dateFormat = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
            String nowday = this.endtime;
            Date nowDate = dateFormat.parse(nowday);//当前时间
            String yesterday = this.begintime;
            Date yesterdayDate = dateFormat.parse(yesterday);//假设一个时间，工作业务中可以参数传递的形式来获取。
            //2、时间戳相减
            long yesterdayDateTime = yesterdayDate.getTime();//昨天的时间戳
            long nowDateTime = nowDate.getTime();//当前时间戳
            long result = nowDateTime - yesterdayDateTime;//毫秒
             
            long diffSecond = result / 1000; //1000毫秒等于1秒
            
            //4、换算成分钟
            long diffMinute = result / 60000 ;//60秒等于1分钟
            if(result%60000!=0){
                diffMinute=diffMinute+1;
            }
        return diffMinute;
    }
} 
   public static class CallRecord extends CommunicationRecord{
  String callingAddressAreaCode;
  String answerAddressAreaCode;
  String begintime;
  String endtime;
}
public static class Landlines extends Device{
        static double monthlyRent=20;
    
    public int input1(User user,String[] s1,String s) {
    
            boolean flag;
            boolean flag1;
            boolean flag2;
          
            int n=0;
        CommunicationRecord records =new CommunicationRecord();
        String sm=s1[2]+" "+s1[3];
        String sn=s1[4]+" "+s1[5];
        if(!(records.validDateTimeSimple(sn)&&records.validDateTimeSimple(sm))) {
               return -1;
        }

        String regex0 = "0791";
           String regex1 = "(079\\d)|0701";

           flag = s1[1].substring(0,4).matches(regex0);//判断功能
           flag1 = s1[1].substring(0,4).matches(regex1);//判断功能    

           n=3;
           if(flag1) 
                  n=2;
           if(flag) 
               n=1;
           
           records.answerNumber=s1[1];
           records.begintime=s1[2]+" "+s1[3];
           records.endtime=s1[4]+" "+s1[5];
           records.chose=n;
           user.setUserRecords(records);
           return 1;
    }
    public int input2(ArrayList<User> users, User user,String[] s1,String s) throws ParseException {

            boolean flag;
            boolean flag1;
            boolean flag2;
            boolean flag3;
            int m=0;
            int n=0;
        CommunicationRecord records =new CommunicationRecord();
        String sm=s1[3]+" "+s1[4];
        String sn=s1[5]+" "+s1[6];
        if(!(records.validDateTimeSimple(sn)&&records.validDateTimeSimple(sm))) {
               return -1;
        }

        String regex0 = "0791";
           String regex1 = "(079\\d)|0701";

           flag =  s1[0].substring(2,6).matches(regex0);//判断功能
           flag1 = s1[0].substring(2,6).matches(regex1);//判断功能    
           flag2 =  s1[2].matches(regex0);//判断功能
           flag3 = s1[2].matches(regex1);//判断功能    

           
          
           n=3;   //省外
           if(flag3) 
                  n=2;    //省内
           if(flag2) 
               n=1;    //市内
           m=3;   //省外
           if(flag3) 
                  m=2;    //省内
           if(flag2) 
               m=1;    //市内
        
           records.answerNumber=s1[1];
           records.begintime=s1[3]+" "+s1[4];
           records.endtime=s1[5]+" "+s1[6];
           records.chose=n;
           user.setUserRecords(records);
           
           if(m==3) {
               for(int i=0;i<users.size();i++) {
                   if(users.get(i).number.equals(s1[1])) {
                       users.get(i).cost(records.sumtime()*0.3);
                   }
                       
               }
           }
           return 1;
    }
}


    public static class LandRule extends ChargeRules{

}
    public static class Phone extends Device{
    static double monthlyRent=15;
    
    public int input1(ArrayList<User> users, User user,String[] s1,String s) throws ParseException {
            boolean flag;
            boolean flag1;
            boolean flag2;
            boolean flag3;
            int n=0;
            int m=0;
        CommunicationRecord records =new CommunicationRecord();
        String sm=s1[4]+" "+s1[5];
        String sn=s1[6]+" "+s1[7];
        if(!(records.validDateTimeSimple(sn)&&records.validDateTimeSimple(sm))) {
               return -1;
        }

        String regex0 = "0791";
           String regex1 = "(079\\d)|0701";

           flag = s1[1].matches(regex0);//判断功能
           flag1 = s1[1].matches(regex1);//判断功能    
           flag2 = s1[3].matches(regex0);//判断功能
           flag3 = s1[3].matches(regex1);//判断功能    

           n=3;  //省外
           if(flag1) 
                  n=2;  //省内
           if(flag) 
               n=1;  //市内
           
           m=3;   //省外
           if(flag3) 
                  m=2;    //省内
           if(flag2) 
               m=1;    //市内
           
           records.answerNumber=s1[2];
            records.begintime=s1[4]+" "+s1[5];
           records.endtime=s1[6]+" "+s1[7];
           records.chose=n;
           records.chose1=m;
            user.setUserRecords(records);
           if(m==3) {
               for(int i=0;i<users.size();i++) {
                   if(users.get(i).number.equals(s1[2])) {
                       users.get(i).cost(records.sumtime()*0.3);
                   }
                       
               }
           }
          
          
           return 1;
    }
    
    public int input2(User user,String[] s1,String s) {
        boolean flag;
        boolean flag1;
        boolean flag2;
        boolean flag3;
        int n=0;
        
    CommunicationRecord records =new CommunicationRecord();
    String sm=s1[3]+" "+s1[4];
    String sn=s1[5]+" "+s1[6];
    if(!(records.validDateTimeSimple(sn)&&records.validDateTimeSimple(sm))) {
           return -1;
    }

    String regex0 = "0791";
       String regex1 = "(079\\d)|0701";

       flag = s1[1].matches(regex0);//判断功能
       flag1 = s1[1].matches(regex1);//判断功能    
       flag2 = s1[2].substring(0,4).matches(regex0);//判断功能
       flag3 = s1[2].substring(0,4).matches(regex1);//判断功能    

       n=3;  //省外
       if(flag1) 
              n=2;  //省内
       if(flag) 
           n=1;  //市内
       
   
       
       records.answerNumber=s1[2];
       
       records.begintime=s1[3]+" "+s1[4];
       records.endtime=s1[5]+" "+s1[6];
       records.chose=n;
     
       user.setUserRecords(records);
       return 1;
}
}

   static class MessageRecord extends CommunicationRecord{
    int num=0;
    
    public void  jisuan(String s) {
        int l=s.length()/10;
        if(s.length()%10!=0)
            l=l+1;
        num +=l;
    }
    
    public double cost(int x) {
        if(x<=3) {
            return x*0.1;
        }
        else if(x>3&&x<=5) {
            return 0.3+(x-3)*0.2;
        }
        else {
            return 0.3+0.4+(x-5)*0.3;
        }
    }
}
 
}

 

 

设计与分析：我只是在原有的基础上增添了一些新的判断语句，还有改进计算花费的方式。增添了MessageRecord类去记录短信，方便计算费用。

 

采坑心得：判断短信字符串的方式一开始就是/S，后面发现不行，仔细一看题才发现是：短信内容只能由数字、字母、空格、英文逗号、英文句号组成。后面又改进。而且发现自己设计类的时候，一开始是考虑的比较周全的，写着写着自己居然会忘记一些东西，感觉以后自己要多用记事本了。

 

改进建议：多写注释吧。

 

 

 

 

7-2 编写一个类Shop（商店）、内部类InnerCoupons（内部购物券）

 

这道题比较简单，因为老师把需求写的比较详细，而且把结构的设计方法都告诉我们了。考了成员内部类的相关内容。

 

以下是代码:

 

import java.util.Scanner;

public class Main{
      public static void main(String[] args) {
        Shop myshop =new Shop();
        Scanner in =new Scanner(System.in);
        int x= in.nextInt();
        myshop.setMilkCount(x);
        
        myshop.setMilkCount(myshop.getMilkCount()-myshop.coupons50.buy());
        System.out.println("使用了面值为"+myshop.coupons50.value+"的购物券进行支付");
        System.out.println("牛奶还剩"+myshop.getMilkCount()+"箱");
        myshop.setMilkCount(myshop.getMilkCount()-myshop.coupons100.buy());
        System.out.println("使用了面值为"+myshop.coupons100.value+"的购物券进行支付");
        System.out.println("牛奶还剩"+myshop.getMilkCount()+"箱");
        
    }
}  
 class Shop {
   private int milkCount;
   InnerCoupons coupons50;
   InnerCoupons coupons100;
   public Shop() {
        super();
        this.coupons50 =new InnerCoupons(50);
        this.coupons100 =new InnerCoupons(100);
    }
 
   public void setMilkCount(int x ) {
       this.milkCount=x;
   }
   public int getMilkCount() {
       return this.milkCount;
   }
   
   public class InnerCoupons {
     public int value;

    public InnerCoupons(int value) {
        super();
        this.value = value;
    }
     public int buy() {
         
         return value/50;
     }
     
  }

}

    

 

 

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

 

  这道题更简单了，老师把基本模板给了我们，只要我们把一些细节添加上去就好了。主要考察的还是多态的运用。

 

以下是代码:

 

//动物发生模拟器.  请在下面的【】处添加代码。
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);
  }
  static //定义静态方法speak()
  void speak(Animal animal) {
      animal.shout();
  }

}

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

    @Override
    public void getAnimalclass() {
        // TODO Auto-generated method stub
        
    }

    @Override
    public void shout() {
        System.out.println("猫的叫声：喵喵");
        
    }
 
}
//基于Animal类，定义狗类Dog，并重写两个抽象方法
class Dog extends Animal{

    @Override
    public void getAnimalclass() {
        // TODO Auto-generated method stub
        
    }

    @Override
    public void shout() {
        System.out.println("狗的叫声：汪汪");
        
    }
 
}
//基于Animal类，定义山羊类Goat，并重写两个抽象方法
class Goat extends Animal{

    @Override
    public void getAnimalclass() {
        // TODO Auto-generated method stub
        
    }

    @Override
    public void shout() {
        System.out.println("山羊的叫声：咩咩");
        
    }
 
}

 

 

 

 

 

总结

   这次的大作业总体来说还是比之前简单很多的，但知识点还是不少的，有关于类之间的运用，父类与之类的合理运用，多态的使用，容器的详细使用方法和小技巧，还有最近经常遇见的正则表达式的使用。这次我是敲好再贴上来哒！突然意识到我们好像到了要跟面向对象的学习说再见的时候了，但我知道这只是暂时的，后续还是会有很多机会去进一步的学习的（我知道还有java的课设）。没有人能限制我们的学习。回顾这一学期，确实很多时候会被java的题目搞崩溃过，觉得很难，跟c语言很不一样，觉得难度突然升级。但我们还是熬过来了，并且真的认认真真的学到了很多东西。还是觉得练习最重要，多多练习才会让自己熟悉java。还有就是多花时间学习东西吧，她们不会辜负我们的。以后也要继续加油鸭！