OOP第一次博客作业

关于Java与面向对象：

目录：

一、前言

前言：

 

这个学期才开始接触Java，对于第一次作业总结感触比较生疏，在很多语法中有些不适应，经常犯一些问题，对于面向对象上学期学习C语言的过程中是从来没有接触过的。

 

在这开学到现在的过程中，到现在为止一共进行了3周，虽然说时间非常短，但是在这每天的语法练习中，对于自己的水平都是有感觉到明显的进步的。从C语言到本学期Java的学习当中，老师不会再像之前一样的去一节课一节课教学我们的语法知识，而是在我们自己学习Java的基本使用语法的基础上教学如何面向对象去进行刨析项目的成分再到设计出逻辑关系（power designer），然而对于这一部分的自学还是要通过自己的实践能力去熟悉代码的写入，其次以便提升我的敲码速度。

 

 知识点：

关于类：

1、类似C++中的struct，构造函数、内置方法(函数 )都比较相似

2、但是无法重载运算符，这是比较难受的一点。

3、尽量避免代码的重复，private和public的方法需要熟悉封装性。

4、为对象定义类，使用构造方法构造对象。

5、使用Java库中的类。

关于Java语法：

1、注意可变类的赋值是引用。

2、String类字符串的使用。

3、数组的基本用法。

关于作业题题量：

三次作业的题量相对还是比较多的。

关于作业难度：

三次作业的基本难度较简单易懂。

设计与分析：

第一次作业：总共有12道题目，分别为：

7-1 计算年利率	5
7-2 身体质量指数（BMI）测算	10
7-3 九九乘法表(双重循环)	15
7-4 快递运费	10
7-5 去掉重复的字符	5
7-6 统计一个子串在整串中出现的次数	5
7-7 有重复的数据	5
7-8 从一个字符串中移除包含在另一个字符串中的字符	5
7-9 Prime Numbers	5
7-10 GPS数据处理	10
7-11 求定积分	10
7-12 列出最简真分数序列*	15

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

第一次作业相对比较简单，也没有必要去建造别的类型去实现，只需要将其简单合并输出即可达到功能使用。然后首先在标识符、变量、以及数据类型方面，通过学习，我了解到标识符明白必须规范，不能随便定义，当以下划线(_)、美元符号($)等此类符号定义时，方可通过java编译，否则则会运行报错。通过OOP第一次题目集得知在不同的语言中，有大部分的语法成分相似，但还是有很多的不一样。对此，在本学期学习的Java入门小白开始，现在在进行数据判断还是只会用if与else去使用，在之后的代码写入的学习中，需要逐步意识到更好的更高级的使用方法与经验。 通过学习解答，对字符串的认知以char单个字符转化为使用String类型（char类型指标是一个字符。为了表示一串字符，可以使用称为String（字符串）的数据类型）。

在对类的使用，以及面向对象的实现——类的实例化，方法，构造参数的使用，我也收获颇丰，经常在因为主方法的类名与public static void main(String[] args)相同导致找不到main方法。

不仅仅如此，在使用字符串的时候，逐渐意识到对于Java的使用中，本身自带了很多种类可以去使用，不同于C语言的局限性那么大。在很多的题目中，巧妙地学习和运用相对应的类型可以帮助我们快速的完成所需要的功能。

其中7-1：这一题最开始写的一道Java题目，这个时候在结尾的控制浮点类型输入的小数点不知道怎么去实现，去寻找解决方案，学习运用了String类型中的format方法，将输出的格式转化为与C语言中的浮点数用“%”输出。

import java.util.Scanner;

public class Main{
    public static void main(String [] args){
        Scanner input = new Scanner(System.in);
        int b=input.nextInt();
        double c=0;
        if(b>0){
        if(b<=1){
            c=0.077*0.5;
        }
        else if(b>1&&b<=3){
            c=0.077*0.7;
        }
        else if(b>3&&b<=5){
            c=0.077*1.0;
        }
        else{
            c=0.077*1.1;
        }
        System.out.print(String.format("实际利率=%.2f",c*100));//使用String.format()
            System.out.print("%");
        }
        else{
            System.out.println("error");
        }
    }
}

其中7-6：应证了上面所说的关于字符型的使用，在Java的使用中有很多的类型可以去使用，学习运用了String类型，开始逐步了解字符串的使用方法（获取字符串，读取字符串，连接字符串）。

然后通过一个循环完成字符串的连接。

import java.util.Scanner;

public class Main{
    public static void main(String[] args) {
        Scanner scan=new Scanner(System.in);
        String s=scan.nextLine();
        String b=scan.nextLine();
        int index=0;
        int count=0;
        while(true)
        {
            index=s.indexOf(b);
            if(index!=-1)
            {
                count++;
                s=s.substring(index+b.length());/连接字符串
            }
            else
            {
                break;
            }
        }
        System.out.print(count);
    }
}

其中7-10：这一题的难度相较于题目集一中是更难的一道题了，仔细审题之后不难得知，需要输出的是北京时间，所以需要我们在得出时间时候在进行校准。新的知识是运用了substring()返回字符串的子字符串，认识到Java中新的数据结构类型（布尔Boolean），Boolean类型分为true和false两种。

import java.util.Scanner;
public class Main{
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        String s1=null,time = null;
        while (in.hasNext())
        {
            s1=in.nextLine();
            if(s1.equals("END"))
            {
                break;
            }
            int sum=0;
            String []split=s1.split(",");
            if(split[0].equals("$GPRMC"))
            {
                int end=s1.indexOf("*");
                for(int i=1;i<end;i++)
                {
                    sum^=(int)s1.charAt(i);
                }
            sum%=65536;
            Boolean flag=split[2].equals("A");
            Boolean S=sum==Integer.parseInt(s1.substring(end+1),16);
            if(S==true&&flag==true)
            {
                time=split[1];
            }
        }
    }
    if(time!=null)
    {
        int h=(Integer.parseInt(time.substring(0,2))+8)%24;//substring()返回字符串的子字符串
        String m=time.substring(2,4);
        String s=time.substring(4,6);
        if(h<10)
            System.out.print("0");
        System.out.print(h+":"+m+":"+s);
      }
    }
}

第二次作业：总共有9道题目，分别为：

7-1 长度质量计量单位换算	5
7-2 奇数求和	10
7-3 房产税费计算2022	12
7-4 游戏角色选择	14
7-5 学号识别	10
7-6 巴比伦法求平方根近似值	10
7-7 二进制数值提取	10
7-8 判断三角形类型	15
7-9 求下一天	14

 

 

 

 

 

 

 

 

 

 

 

 

第二次作业相较于第一次有了一个新的提升，尤其是在7-9的一题中开始了迭代的题目升级，在第三次作业的分析中，逐步交流关于增加的类的创建等，7-9的出现同时也为第三次作业提前打了一个预防针。在此题目集中7-1~7-8，主要还是数据类型做出一个强化训练，整体难度其实并不大。在此题目训练结束后，我深刻的体会到学习编程单靠一个人的埋头苦干是要远远不行的，在很多情况下，不懂得问题需要和身边的同学一同交流在能实现学习的高效化。

其中7-1：在之前的控制小数位数的运用，到第一次使用数据的强制转化，不能用double直接输出，而是转化为float去输出，运用了数据类型的强制转化。

import java.util.Scanner;

public class Main{
    public static void main(String[] args) {
        Scanner scan=new Scanner(System.in);
        double a=scan.nextDouble();
        double b=scan.nextDouble();
        double c,d;
        c=a/0.45359237;
        d=b/0.0254;
        System.out.print((float)c+" "+(float)d);//强制转化
    }
}

其中7-8：这一道题在运用if与else的条件判断中要求比较高，其中印象最深的也就是本题的最难一个点，在多次测例中解决不了的是等腰直角三角形的判断。在最后交流与讨论中得知，两个整数的比值不可能必出无理数，于是将代码进行优化，类似于 Math.abs(ch1*ch1+ch2*ch2-ch3*ch3)<0.0000001 的办法进行判断。了解了浮点数类型的判断相等不能直接在if等语句的判定条件中去使用“==”进行判断，而是将其相减得出的值小于某个极小的数从而达到判断是否相等的目的。

import java.util.Scanner;

public class Main{
    public static void main(String[] args) {
        Scanner scan=new Scanner(System.in);
        double ch1=scan.nextDouble();
        double ch2=scan.nextDouble();
        double ch3=scan.nextDouble();
        if(ch1<1||ch1>200||ch2<1||ch2>200||ch3<1||ch3>200){
            System.out.println("Wrong Format");
        }else if(ch1+ch2<=ch3||ch1+ch3<=ch2||ch2+ch3<=ch1){
            System.out.println("Not a triangle");
        }else if(ch1==ch2&&ch2==ch3&&ch1==ch3){
            System.out.println("Equilateral triangle");
        }else if((ch1==ch2&&(Math.abs(ch1*ch1+ch2*ch2-ch3*ch3)<0.0000001)
                  ||(ch1==ch3&&(Math.abs(ch1*ch1+ch3*ch3-ch2*ch2)<0.0000001))
                  ||(ch2==ch3&&(Math.abs(ch2*ch2+ch3*ch3-ch1*ch1)<0.0000001)))){//浮点数类型的判断
            System.out.println("Isosceles right-angled triangle");
        }else if(ch1==ch2||ch1==ch3||ch2==ch3){
            System.out.println("Isosceles triangle");
        }else if((ch1*ch1+ch2*ch2==ch3*ch3)||(ch1*ch1+ch3*ch3==ch2*ch2)||(ch3*ch3+ch2*ch2==ch1*ch1)){
            System.out.println("Right-angled triangle");
        }else{
            System.out.println("General triangle");
        }
    }
}

第三次作业：总共有4道题目，分别为：

7-1 创建圆形类	6
7-2 创建账户类Account	16
7-3 定义日期类	34
7-4 日期类设计	44

 

 

 

 

对于第三次作业的训练，我深刻的感觉到题目的大大提升难度，从第一题开始学习如何为对象定义一个类型，构造里面的属性以及其种类，创建对象和定义类，使用无参或者有参的构造方法构造对象（使用new操作符调用构造方法创建对象，构造方法必须与所在类同名，构造方法没有返回类型，甚至连void也没有，构造方法是在创建一个对象时由new操作符调用的。构造方法的作用是初始化对象），然后是针对访问对象的数据和方法的学习，再包括对于date类的理解和其中如何进行的有进一步的理解。

其中7-3：这一题是继承第二次作业的7-9迭代过来的，要求输出下一天的日期，有第二题的引子下再重新优化这个源码，可以采用学习到的创建类的使用。有了类的帮助就非常轻松的完成了7-3的功能实现

这边是类图：

然后是源码展示：

import java.util.Scanner;

public class Main{
public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    Date date=new Date();
    int year=scan.nextInt();
    int month=scan.nextInt();
    int day=scan.nextInt();
    date.setYear(year);
    date.setMonth(month);
    date.setDay(day);
    date.getNextDate();
}
}
class Date{
    private int year;
    private int month;
    private int day;
    int[] mon_maxnum=new int[]{0,31,28,31,30,31,30,31,31,30,31,30,31};
    Date(){
        year=0;
        month=0;
        day=0;
    }
    Date(int year,int month,int day){
        this.year=year;
        this.month=month;
        this.day=day;
    }
    public int getYear(){
        return year;
    }
    public void setYear(int year){
        this.year=year;
    }
    public int getMonth(){
        return month;
    }
    public void setMonth(int month){
        this.month=month;
    }
    public int getDay(){
        return day;
    }
    public void setDay(int day){
        this.day=day;
    }
    public boolean isLeapYear(int year){//判断是否为闰年
        if((year%4==0&&year%100!=0)||year%400==0){
            return true;
        }else{
            return false;
        }
    }
    public boolean checkInputValidity(){//检查是否输入有误
        if((year>=1900&&year<=2000)&&
           (month>=1&&month<=12)&&
          (day>=1&&day<=31)){
            if(isLeapYear(year)&&month==2&&(day>=1&&day<=29)){
                return true;
            }else if(day>=1&&day<=mon_maxnum[month]){
                return true;
            }else{
                return false;
            }
        }else{
            return false;
        }
    }
    public void getNextDate(){//求下一天
        if(checkInputValidity()==false){
            System.out.print("Date Format is Wrong");
        }else{
            if(isLeapYear(year)){
                            mon_maxnum[2]=29;
            }
            if(day>=1&&day<mon_maxnum[month]){
                day++;
            }
            if(day==mon_maxnum[month]){
                day=1;
                if(month!=12){
                    month++;
                }else{
                    month=1;
                    year++;
                }
            }
            System.out.println("Next day is:"+year+"-"+month+"-"+day);
        }
    }
}

不难发现，Java中的类的创建给代码的结构化提供了无可替代的作用，至于下一天的算法只需要注意闰年的二月份带来的变化考虑到特殊即可。

其中7-4：最为日期Date类的最后一个迭代题目，增加了前n天、后n天、两个日期之间相差多少天的功能。优化之后的类：

 

 

代码展示如下：

运用类的调用，使代码更加具有条理，看起来不会太烧脑

public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int year = 0;
        int month = 0;
        int day = 0;
        int choice = input.nextInt();
        if (choice == 1) { // test getNextNDays method
            int m = 0;
            year = Integer.parseInt(input.next());
            month = Integer.parseInt(input.next());
            day = Integer.parseInt(input.next());
            DateUtil date = new DateUtil(year, month, day);
            if (!date.checkInputValidity()) {
                System.out.println("Wrong Format");
                System.exit(0);
            }
            m = input.nextInt();
            if (m < 0) {
                System.out.println("Wrong Format");
                System.exit(0);
            }
            System.out.print(date.getYear() + "-" + date.getMonth() + "-" + date.getDay() + " next " + m + " days is:");
            System.out.println(date.getNextNDays(m).showDate());
        } else if (choice == 2) { // test getPreviousNDays method
            int n = 0;
            year = Integer.parseInt(input.next());
            month = Integer.parseInt(input.next());
            day = Integer.parseInt(input.next());

            DateUtil date = new DateUtil(year, month, day);

            if (!date.checkInputValidity()) {
                System.out.println("Wrong Format");
                System.exit(0);
            }

            n = input.nextInt();

            if (n < 0) {
                System.out.println("Wrong Format");
                System.exit(0);
            }

            System.out.print(
                    date.getYear() + "-" + date.getMonth() + "-" + date.getDay() + " previous " + n + " days is:");
            System.out.println(date.getPreviousNDays(n).showDate());
        } else if (choice == 3) {    //test getDaysofDates method
            year = Integer.parseInt(input.next());
            month = Integer.parseInt(input.next());
            day = Integer.parseInt(input.next());

            int anotherYear = Integer.parseInt(input.next());
            int anotherMonth = Integer.parseInt(input.next());
            int anotherDay = Integer.parseInt(input.next());

            DateUtil fromDate = new DateUtil(year, month, day);
            DateUtil toDate = new DateUtil(anotherYear, anotherMonth, anotherDay);

            if (fromDate.checkInputValidity() && toDate.checkInputValidity()) {
                System.out.println("The days between " + fromDate.showDate() + 
                        " and " + toDate.showDate() + " are:"
                        + fromDate.getDaysofDates(toDate));
            } else {
                System.out.println("Wrong Format");
                System.exit(0);
            }
        }
        else{
            System.out.println("Wrong Format");
            System.exit(0);
        }        
    }
}

class DateUtil{
    private int year;
    private int month;
    private int day;
    int[] mon_maxnum=new int[]{0,31,28,31,30,31,30,31,31,30,31,30,31};
    public DateUtil(int year,int month,int day){
        this.year=year;
        this.month=month;
        this.day=day;
    }
    public int getYear(){
        return year;
    }
    public void setYear(int year){
        this.year=year;
    }
    public int getMonth(){
        return month;
    }
    public void setMonth(int month){
        this.month=month;
    }
    public int getDay(){
        return day;
    }
    public void setDay(int day){
        this.day=day;
    }
    public boolean isLeapYear(int year){
        if((year%4==0&&year%100!=0)||year%400==0){
            return true;
        }else{
            return false;
        }
    }
    public boolean checkInputValidity(){
        if(year < 1820 || year > 2020)
            return false;
        if(month < 1 || month > 12)
            return false;
        if(isLeapYear(year)){
            if(month == 2){
                if(day < 1 || day > 29)
                    return false;
            }
            else
            if(day < 1 || day > mon_maxnum[month])
                return false;
        }
        if(!isLeapYear(year)){
            if(day<1 || day > mon_maxnum[month])
                return false;
        }
        return true;
    }
    public DateUtil getNextNDays(int n){
        while(n>365){
            if(isLeapYear(year)&&month<=2){
                if(day==29&&month==2){
                    day=1;
                    month=3;
                }
                year++;
                n-=366;
            }else if(isLeapYear(year+1)&&month>2){
                year++;
                n-=366;
            }else{
                year++;
                n-=365;
            }
        }
        for(int i=0;i<n;i++){
            day++;
            if(isLeapYear(year) && month == 2){
                if(day > 29){
                    month++;
                    day = 1;
                }
            }
            else if(day > mon_maxnum[month]){
                month++;
                day = 1;
                if(month > 12){
                    month = 1;
                    year++;
                }
            }
        }
        DateUtil date = new DateUtil(year, month, day);
        return date;
    }
    public DateUtil getPreviousNDays(int n){
        while(n>365){
            if(isLeapYear(year)&&month>2){
                year--;
                n-=366;
            }else if(isLeapYear(year-1)&&month<=2){
                year--;
                n-=366;
            }else{
                year--;
                n-=365;
            }
        }
        for(int i=0;i<n;i++){
            day--;
            if(day < 1){
                month--;
                if(month < 1){
                    month = 12;
                    year--;
                }
                if(isLeapYear(year)&&month==2){
                    day=29;
                }else{
                    day=mon_maxnum[month];
                }
            }
        }
        DateUtil date = new DateUtil(year, month, day);
        return date;
    }
    public String showDate(){
        return year+"-"+month+"-"+day;
    }
}

对于求n天之后的代码，算法基本与7-3相似，在之前的基础上增加排除够量的日期，在做出这些算法的实现后，对照之后很容易知道前n天的算法如何推出来，两个十分相近。

踩坑心得：

1.作为一个刚入门的小白，对于最开始处理一些数据还是有很多地方做的非常差，例如在变量可取值范围很大的时候不能直接套上循环进行程序运行，有方法去调节循环次数，将其降低。从一开始的date中的天数加减一天天实现到降低循环次数分别从年月日去实现，部分修正后改成的算法，先判断年再到月，最后到日，可以是程序运行的更迅速。

加n天循环

        while(n>365){//增加
            if(isLeapYear(year)&&month<=2){
                if(day==29&&month==2){
                    day=1;
                    month=3;
                }
                year++;
                n-=366;
            }else if(isLeapYear(year+1)&&month>2){
                year++;
                n-=366;
            }else{
                year++;
                n-=365;
            }
        }
        for(int i=0;i<n;i++){
            day++;
            if(isLeapYear(year) && month == 2){
                if(day > 29){
                    month++;
                    day = 1;
                }
            }
            else if(day > mon_maxnum[month]){
                month++;
                day = 1;
                if(month > 12){
                    month = 1;
                    year++;
                }
            }
        }

减n天循环

        while(n>365){
            if(isLeapYear(year)&&month>2){
                year--;
                n-=366;
            }else if(isLeapYear(year-1)&&month<=2){
                year--;
                n-=366;
            }else{
                year--;
                n-=365;
            }
        }
        for(int i=0;i<n;i++){
            day--;
            if(day < 1){
                month--;
                if(month < 1){
                    month = 12;
                    year--;
                }
                if(isLeapYear(year)&&month==2){
                    day=29;
                }else{
                    day=mon_maxnum[month];
                }
            }
        }

由此改变即可使代码更加有层次不会太繁琐去运行。

改进建议：

在以后的学习中，不断地练习写代码的能力，无非就是对之前的问题在不断地接受新的知识之后能够以更快的速度和更巧妙的办法去实现其功能，包括最基本的数组的建造可以去用ArrayList类去替换，其中包含的方法是非常好用的。不过对于这些的学习都是需要我们自己投入更多的时间去练习以及熟练掌握以后去实践。毕竟不管在学什么专业都应该去主动。随着入门的时间越来越长，接触的题目也会越来越难，一种类型的题目，如同此次的题目一样，都是不断完善不断迭代的。

总结：

本人第一次写博客，这在很多地方的运用还是非常懵懂，还需要多多学习，不管是对于eclipse得分使用还是对power designer的使用等等，都是需要不断去熟悉。对于这三次作业集，在结束了这刚开始Java代码书写，了解了Java的基本语法的实现。但是在类、方法什么的地方还是会有很多疑问，在日后的学习过程中，要不断的去学习更多种类的类的使用，并且让自己对基本的结构有更深的认识，积极参与讨论交流，代码的学习与未来的就业都不是一个人去实现，都需要团队合作共同进步。改进算法也是其中我想要说的一个点，在和他人交流后，可以得知别人的解题分析思维，让自己的思维更加活跃，当然在网络平台上也应该去多搜集他人推荐的学习方法、划重点的好用知识以及实用的学习办公的工具。