初识java

前言

　　因突发疫情的特殊因素，大二的下学期无法到校正常上课，因此我们在家通过网络学的方式开始学习了"java"这门编程语言，而学习到现在，大家对java的学习及了解步入了一个阶段，通过日常学习作业，我们也能够进行自我评估和锻炼，到目前共有三次周期作业练习，我个人能够及时保质完成；并从每一次作业中获的更多理解、感悟与进步！

作业过程总结

三次作业的迭代关系

　　老师发布的作业和作业顺序恰到好处，个人感觉在能有效帮助包括我在类初学java的小白对java有一个启蒙似理解；而且作业的连贯性不至于我们初学者觉得困难不易掌握。

　　第一次作业着重考察锻炼我们对例如“if-else”判断语句、“while、for 、switch case”循环语句的基本语句的运用掌握和方法属性的简单操作;

　　第二次作业则开始引导我们慢慢进入面向对象的大门；在第二次的作业中，映入更多的类和类方法的概念。这些概念刚开始理解起来有点不知所然；但睡着学习的推进；对这些基础概念的理解更加深厚了；记得作业当中对于日期的运算操作非常经典，我们需要创建跟多的方法和属性来实现代码功能；但他又绝不类似于c语言面向过程的概念，java更偏向于对任务对象的操作

　　第三次作业则映入了更加深层次的面向对象的概念，作业要求我们正对每个实现功能的对象设计对应的类，这么做可以让java代码的复用性更加出色。通过第三次作业训练的巩固，我们更加了解的面向对象的含义。

　　2. 如何通过作业逐步从面向过程过渡到面向对象

　　三次作业难度从简单到复杂；内容由浅到深，让我们对面向对象的学习增添遍历快捷；

　　由第一次作业的简单语句开头，到第三次作业针对每个实现功能的对象设计对应的类结束；这个过程能让我们更快从面向过程过度到面向对象中去。

　　3. 作业过程中遇到的问题及解决方法

　　1. 第一次作业让我们用简单的编程语句进行功能实现它的第四题判断三角形类型有个点始终不能通过，事后查阅资料了解到java处理浮点数有固定位数，无法无限循环；

　　后添加一个判断有限为浮点数的语句即可

import java.util.Scanner;
public class Main {
    
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        double ai=in.nextDouble();
        double bi=in.nextDouble();
        double ci=in.nextDouble();
        double a=0,b=0,c=0,k=0;
        a=ai;
        if(bi>a) {
            k=a;
            a=bi;
            bi=k;
        }
        if(ci>a) {
            k=a;
            a=ci;
            ci=k;
        }    
        if(bi>ci) {
            b=bi;
            c=ci;
        }
        else {
            b=ci;

　　2. 第二次作业没有直接运用面向对象的方法，所以很复杂；其中日期的各种运算十分繁琐，每一个功能都要知悉考虑；我完成求下n天代码时，考虑不严谨频频出错。

后知悉debug发现闰年的日期没有考虑好。

public static void nextDate(int year,int month,int day) {
        //求输入日期的下一天
        if(Main.checkInputValidity(year, month, day)) {
            
                if(month!=2&&(month==4||month==6||month==9||month==11)&&day<30) {
                    day++;
                }
                else if(month!=2&&(month==4||month==6||month==9||month==11)&&day==30) {
                    day=1;
                    month++;
                }
                else if(month!=2&&(month==1||month==3||month==5||month==7||month==8||month==10||month==12)&&day<31) {
                    day++;
                }
                else if(month!=2&&(month==1||month==3||month==5||month==7||month==8||month==10||month==12)&&day==31) {
                    if(month==12) {
                        day=1;
                        month=1;
                        year++;
                    }
                    else {
                        day=1;
                        month++;
                    }
                }
                else if(Main.isLeapYear(year)&&month==2&&day<29) {
                    day++;
                }
                else if(Main.isLeapYear(year)&&month==2&&day==29){
                    day=1;
                    month++;
                }
                else if(!(Main.isLeapYear(year))&&month==2&&day<28) {
                    day++;
                }
                else if(!(Main.isLeapYear(year))&&month==2&&day==28) {
                    day=1;
                    month++;
                }
                else;
                System.out.print("Next date is:"+year+"-"+month+"-"+day);
        }
        else
            System.out.print("Wrong Format");
    }

　　3. 第三次作业针对对象设计类来处理问题，接近了面向对象的思维；在第三小题整型数最大值测试点频频出错，后仔细检查发现当年份超出合法日器上限报错，后添加报错输出正确

class DateUtil{
        private Day day;
        
        public DateUtil() {
            
        }
        public DateUtil(int y,int m,int d) {
            day=new Day(y,m,d);
        }
        public void setDay(Day d) {
            
        }
        public Day getDay() {
            return day;
        }
        
        public boolean checkInputValidity() {
            //检测输入的年、月、日是否合法
            boolean k=true;
            if(!day.getMonth().getYear().validate()||!day.getMonth().validate()||!day.validate())
                k=false;
                return k;
        }
        public DateUtil getNextNDays(int n) {
            for(int i=0;i<n;i++) {
                if(((day.getValue()<day.mon_maxnum[day.getMonth().getValue()])&&day.getMonth().getYear().isLeapTear())||((day.getValue()<day.mon_minnum[day.getMonth().getValue()])&&!day.getMonth().getYear().isLeapTear()))
                    day.dayIncrement();
                else if(day.getMonth().getValue()<12) {
                    day.resetMin();
                    day.getMonth().monthIncrement();
                }
                else {
                    day.resetMin();
                    day.getMonth().resetMin();
                    if(this.checkInputValidity())
                        day.getMonth().getYear().yearIncrement();
                    else {
                        System.out.println("Wrong Format");
                        System.exit(0);
                    }                        
                }
            }
            return this;
        }
        public DateUtil getPreviousNDays(int n) {
            for(int i=0;i<n;i++) {
                if(day.getValue()>1)
                    day.dayReduction();
                else if(day.getMonth().getValue()>1) {                
                    day.getMonth().monthReduction();
                    day.resetMax();
                }
                else {
                    day.getMonth().getYear().yearReduction();
                    day.getMonth().resetMax();
                    day.resetMax();
                }        
            }
            return this;
        }
        public boolean compareDates(DateUtil date) {
            if(this.day.getMonth().getYear().getValue()>date.day.getMonth().getYear().getValue())
                return true;
            else if(this.day.getMonth().getYear().getValue()<date.day.getMonth().getYear().getValue())
                return false;
            else if(this.day.getMonth().getValue()>date.day.getMonth().getValue())
                return true;
            else if(this.day.getMonth().getValue()<date.day.getMonth().getValue())
                return false;
            else if(this.day.getValue()>date.day.getValue())
                return true;
            else if(this.day.getValue()<date.day.getValue())
                return false;
            else 
                return false;
        }
        public boolean equalTwoDates(DateUtil date) {
            if(this.day.getMonth().getYear().getValue()==date.day.getMonth().getYear().getValue()&&this.day.getMonth().getValue()==date.day.getMonth().getValue()&&this.day.getValue()==date.day.getValue())
                return true;
            else
                return false;
        }
        public int getDaysofDates(DateUtil date) {
            int i=0;
            if(!this.compareDates(date)) {
                for(i=0;!this.equalTwoDates(date);i++) {
                    if(((day.getValue()<day.mon_maxnum[day.getMonth().getValue()])&&day.getMonth().getYear().isLeapTear())||((day.getValue()<day.mon_minnum[day.getMonth().getValue()])&&!day.getMonth().getYear().isLeapTear()))
                        day.dayIncrement();
                    else if(day.getMonth().getValue()<12) {
                        day.resetMin();
                        day.getMonth().monthIncrement();
                    }
                    else {
                        day.resetMin();
                        day.getMonth().resetMin();
                        day.getMonth().getYear().yearIncrement();
                    }
                }
            }
            else {
                for(i=0;!this.equalTwoDates(date);i++) {
                    if(day.getValue()>1)
                        day.dayReduction();
                    else if(day.getMonth().getValue()>1) {
                        day.resetMax();
                        day.getMonth().monthReduction();
                    }
                    else {
                        day.resetMax();
                        day.getMonth().resetMax();
                        day.getMonth().getYear().yearReduction();
                    }        
                }
            }
            return i;
        }
        public String showDate() {
            return (this.day.getMonth().getYear().getValue()+"-"+this.day.getMonth().getValue()+"-"+this.day.getValue());
        }
    }

　　4. 每次作业花费的时间比例

　　随着面向对象含义深入，作业第一次最少，第二次次之。第三次花费时间最长。

　　5. 对编程过程的严谨性的认识及教训

严谨性即健壮性，健壮性有时也和容错性，可移植性，正确性有交叉的地放。比如，一个软件可以从错误的输入推断出正确合理的输入，这属于容错性量度标准，但是也可以认为这个软件是健壮的

逻辑严谨性十分重要；缺乏严谨的代码就缺少价值存在意义。

　　设计心得

　　1. 面向过程与面向对象的比较

面向过程适合简单、不需要协作的事务;而面向对象思想更契合人的思维模式。他们都贯穿于软件分析、设计和开发各个阶段，对应面向对象就分别称为面向对象分析、面向对象设计和面向对象编程。C语言是一种典型的面向过程语言，Java是一种典型的面向对象语言。面向对象具有三大特征：封装性、继承性和多态性，而面向过程没有继承性和多态性，并且面向过程的封装只是封装功能，而面向对象可以封装数据和功能。所以面向对象优势更明显。

　　2.面向对象设计的基本原则理解

“开-闭”原则;　　

单一功能原则

里氏替换原则

接口隔离原则

依赖倒置原则

等等我们目前甚至没有接触到的原则含义。

测试的理解与实践

　　1. 测试对于编码质量的重要性

测试对于编程十分重要，一份优秀的编程旺旺进过了大量测试用例以验证可用性及是否存在错误。

完成编程后进行测试可以让你写出更好的代码，可测试的代码一定是优雅的代码（为了可测试，你必须要解耦，必须要遵循较好的设计模式

让你重构之类的操作更加放心，因为测试会告诉你影响了哪些功能点

　　2. 假如让你设计测试用例，你会如何做

假如我来设计测试用例，我首先要对待测试代码总体功能了解清楚，代码源码大致浏览，在设计用例找出薄弱地点从而修正改善代码质量

课程收获

通过这段时间对java的学习，我逐渐了解的面向对象的含义概念，并通过周末作业的练习我要逐渐习惯面向对象的编程思维；它能有效改进编程效率提高编程理解；

编程过程中也经常性出现多或少的错误，无法完全理解题目含义，有时候编写的代码会习惯性沿袭面向过程的思维。导致编程低速抵效。这些都提醒我以后编写代码的过程中一定要跟家严谨，心平气和。

通过一段时间java的学习，我理解了类属性对象方法的用法和关系。这些天付出的努力变成了知识，我内心非常充实。

posted @ 2020-04-06 00:35 上白阅读(188) 评论(0) 收藏举报

刷新页面返回顶部

上白

初识java

前言

作业过程总结

设计心得

测试的理解与实践

课程收获

公告

　　设计心得