OOP第一次博客总结

目录

　　1、前言

　　2、设计与分析

　　3、踩坑心得

　　4、改进建议

　　5、总结

 

题目集1：

1、计算年利率

2、身体质量指数（BMI）测算

3、九九乘法表（双重循环）

4、快递运费

5、去掉重复字符

6、统计一个子串在整串中出现的次数

7、有重复数据

8、从一个字符串中移除包含在另一个字符串中的字符

9、Prime Numbers

10、GPS数据处理

11、求定积分

12、列出最简真分数序列*

题目集2

1、长度质量计算单位换算

2、奇数求和

3、房产税计算2022

4、游戏角色选择

5、学号识别

6、巴比伦法求平方根近似值

7、二进制数值提取

8、判断三角形类型

9、求下一天

题目集3

1、创建圆类型

2、创建账户类Account

3、定义日期类

4、日期类设计

 

1、前言

　　这是我第一次用写Java的总结博客，也是刚接触Java这门编译语言。因为对Java的不了解，刚开始敲代码时很不适应，但Java与c语言又有部分相似，所以基础的语法这部分可以说是一点就通。尽管我接触Java还没到一个月，但是在这接近一个月的学习过程里，我能清楚的感觉到自己水平的提升，可以说是“痛并快乐着”。

　　题目集1有十二题，题量挺大的，虽然在现在看来题目较为基础，但在当时却确确实实是给了刚接触java的我一个下马威，让我快速适应c语言与Java编译语言的不同。简而言之，此次作业难度不大，主要是通过这些题目来了解Java的编译语法，让我们从上学期的程序设计基础中脱离，深入到本学期的面向对象程序设计中来。

　　题目集2有十题，类似于题目集一，但是题量有所减少，最后两题的难度有所提升，最后的一个判断三角形和求下一天在当时也困扰了我挺久。其中求下一天该题在第三次作业中还拓展到了求下n天以及求两天的天数差，难度在逐渐加大。

　　题目集3虽然只有四题，但是他的难度是前两个题目集无法比拟的。第一次用了多个类，并且的最后一题是题目集2最后一题的迭代，难度在我看来算是接触Java以来算是最难的一类题目了，写了很久查阅了很多资料也没能在截止时间做到满分。但在我看来，与其写那种基础的题目，不如写这种有难度的题目来的有意义，通过写这种难题能更快的帮助我们掌握语法和逻辑。

 

知识点方面：题目集一让我从c语言成功过渡到Java，虽然没有掌握很多新的知识（印象最深的是在这次题目集中第一次见到了Boolean类型），但是至少明白了Java的编译规则，能够编写出没有语法错误的Java代码，同时复习了上学期所学的基础语法；题目集二是题目集一的进阶版本，但是最后两题的难度明显有所加大，也正是这个题目集发布的期间，段老师给我们介绍了Java的框架，让我认识到了Java各个部分的名称以及大部分代码的意义，让我们知道了不同的方法与类的基本使用方法；题目集三很难但是也真的让我从中学到了非常多的东西（当然这个过程是非常痛苦的），例如多个类的使用，对象数组的使用，private封装的使用等等。

2、设计与分析

判断三角形类型

题目集2第八题具体代码如下：

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner input=new Scanner(System.in);
        float a,b,c;
        a=input.nextFloat();
        b=input.nextFloat();
        c=input.nextFloat();
        if (a >= 1 && a <= 200 && b >= 1 && b <= 200 && c >= 1 && c <= 200){
            if (a + b <= c || a + c <= b || b + c <= a){
                System.out.printf("Not a triangle");
            }
            else if (a == b && b == c){
                System.out.printf("Equilateral triangle");
            }
            else if ((a == b && Math.abs(a * a + b * b - c * c) < 0.0001) || (b == c &&
                    Math.abs(b * b + c * c - a * a) < 0.0001) || (a == c && Math.abs(a * a + c * c - b * b) < 0.0001)){
                System.out.printf("Isosceles right-angled triangle");
            }
            else if (a == b || a == c || b == c){
                System.out.printf("Isosceles triangle");
            }
            else if (((a * a + b * b) == c * c) || ((b * b + c * c) == a * a) || ((a * a + c * c) == b * b)){
                System.out.printf("Right-angled triangle");
            }
            else{
                System.out.printf("General triangle");
            }
        }
        else{
            System.out.printf("Wrong Format");
        }
    }
}

 

求下一天

　　

import java.util.*;
class Date{
private int year;
private int month;
private int day;

public Date(int year,int month,int day){
this.year=year;
this.month=month;
this.day=day;
}


public void setDay(int day){
this.day = day;
}
public int getDay(){
return day;
}
public void setMonth(int month){
this.month = month;
}
public int getMonth(){
return month;
}
public void setYear(int month){
this.year = year;
}
public int getYear(){
return year;
}


public static boolean isLeapYear(int year) {
boolean isLeapYear = (year % 4 == 0 && year % 100 != 0 )||year % 400 == 0;
return isLeapYear;
}
public static boolean checkInputValidity(int year,int month,int day) {
int[] a=new int[]{0,31,28,31,30,31,30,31,31,30,31,30,31};
if(isLeapYear(year))
a[2] = 29;
boolean checkInputValidity = (year>=1900 && year<=2000 && month>0 && month<=12 && day<=a[month] && day>0);
return checkInputValidity;
}
public static void getNextDate(int year,int month,int day) {
int[] a=new int[]{0,31,28,31,30,31,30,31,31,30,31,30,31};
int day1 = day;
int month1 = month;
int year1 = year;
if(isLeapYear(year))
a[2] = 29;
if(checkInputValidity(year,month,day)) {
if(month==12) {
if(day==a[month]) {
year1 = year+1;
month1 = 1;
day1 = 1;
}
else{
month1 = month;
day1 = day +1;
}
}
else {
if(day==a[month]) {
month1 = month + 1;
day1 = 1;
}
else{
month1 = month;
day1 = day+1;
}
}
System.out.println("Next day is:"+year1+"-"+month1+"-"+day1);
}
else
System.out.println("Date Format is Wrong");
}
}

public class Main{
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
int year = input.nextInt();
int month = input.nextInt();
int day = input.nextInt();
Date oop=new Date(year , month , day);
oop.setYear(year);
oop.setMonth(month);
oop.setDay(day);
oop.getNextDate(oop.getYear(), oop.getMonth(),oop.getDay());
}
}

 

　　题目集三相对于三四题，一二题比较简单，题目集最后两题都是关于日期类的编写，有了前面编写代码的经验，我也对我的算法进行了一定的优化。

定义日期类

　　本题吸取了上一次的经验，对我的代码进行了优化，并且涉及到的类的关系也比较简单，以下是本题的类图及代码：

1 

 

 1 import java.util.*;
 2 public class Main{
 3     public static void main(String[] args){
 4         Scanner input = new Scanner(System.in);
 5         int year,month,day;
 6         year=input.nextInt();
 7         month=input.nextInt();
 8         day=input.nextInt();
 9         Date date = new Date(year,month,day);
10         if (!date.checkInputValidity()){
11             System.out.printf("Date Format is Wrong");
12             return;
13         }
14         date.getNextDate();
15         if (date.checkInputValidity()){
16             System.out.printf("Next day is:%d-%d-%d",date.getYear(),date.getMonth(),date.getDay());
17         }
18         else{
19             System.out.printf("Date Format is Wrong");
20         }
21     }
22 }
23 class Date{
24     private int year;
25     private int month;
26     private int day;
27     public int[] mon_maxnum = new int[]{0,31,28,31,30,31,30,31,31,30,31,30,31};
28     public Date(){
29 
30     }
31 
32     public Date(int year,int month,int day){
33         this.year = year;
34         this.month = month;
35         this.day = day;
36     }
37     public int getYear(){
38         return this.year;
39     }
40 
41     public void setYear(int year){
42         this.year=year;
43     }
44 
45     public int getMonth(){
46         return this.month;
47     }
48 
49     public void setMonth(int month){
50         this.month=month;
51     }
52 
53     public int getDay(){
54         return this.day;
55     }
56 
57     public void setDay(int day){
58         this.day=day;
59     }
60 
61     public boolean isLeapYear(int year){
62         if ((this.year % 4 == 0 && this.year % 100 != 0) || (year % 400 == 0)){
63             return true;
64         } else{
65             return false;
66         }
67     }
68 
69     public boolean checkInputValidity(){
70         if (isLeapYear(this.year)){
71             mon_maxnum[2] = 29;
72         }
73         if ((this.year >= 1900 && this.year <= 2000) && (this.month >= 1 && this.month <= 12) && (this.day >= 1 && this.day <= mon_maxnum[this.month])){
74             return true;
75         } else{
76             return false;
77         }
78     }
79     public void getNextDate(){
80         if (isLeapYear(this.year)){
81             mon_maxnum[2] = 29;
82         }
83         if (this.day + 1 > mon_maxnum[this.month]){
84             this.day = 1;
85             if (this.month < 12){
86                 this.month++;
87             } else{
88                 this.month = 1;
89                 this.year++;
90             }
91         } else{
92             this.day++;
93         }
94     }
95 }

 

日期类设计

　　这里现附上本题的类图：

 

 

 

第三次作业第四题：日期类设计。该题分为两个板块（因为求前n天和求下n天方法类似，我就把他们归于一个板块了），分别是求前n天或者是下n天以及两个日期的天数差。

下面附上我未改良过的初始源码：

 

import java.util.Scanner;

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);
        }        
    }

    public int month;
    public int year;
    public int day;
}

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

 

虽然该代码实现了题目要求的大部分功能，但是可以看出仍然有些问题：由于int能读取的最大值的限制，当求取下n天时，如果n为int的最大值，那么该程序就会输出奇怪且不正确的结果。在当时我是没有意识到这个问题的，看到了int最大值的测试点后我才考虑到是不是我的int进行了加法运算，导致某个数超出了int的最大值，从而导致程序出现异常。果然，我发现在getnextndays这个方法里面发现了144行的m = m + day;我就明白肯定是这里出现了错误，于是我查询了相关资料，并且向同学请教，将该部分的代码进行了修改：

 

public DateUtil getNextNDays (int n){
         DateUtil Date = new DateUtil(this.year, this.month, this.day);
         for (; n > 0; ) {
             if (isLeapYear(Date.getYear())) {
                 mon_maxnum[2] = 29;
             } else {
                 mon_maxnum[2] = 28;
             }
             if (Date.getDay() < mon_maxnum[Date.getMonth()]) {
                 Date.setDay(Date.getDay() + 1);
                 n--;
             } else {
                 if (Date.getMonth() < 12) {
                     Date.setMonth(Date.getMonth() + 1);
                     Date.setDay(1);
                     n--;
                 } else {
                     Date.setMonth(1);
                     Date.setDay(1);
                     Date.setYear(Date.getYear() + 1);
                     n--;
                 }
             }
         }
         return Date;
    }

 

 

 

 

 

3、踩坑心得

踩到的第一个坑就是判断三角形这题：浮点数的相加会有误差出现，这就导致了判断三角形类型的余弦定理的使用上与我们正常的认知不同，不能利用两个边的平方与第三个边的平方的关系来判定三角形的类型。因为在做题之前忘记了这一点，导致我完成代码之后感觉良好但是有几个测试点无法通过。询问同学之后才知道Java中浮点数的相加会产生误差，但是这个误差非常小，所以我们只要让两边的差小于一个很小的数就等同于两边相等。源码如下：       

import java.util.Scanner;

public class Main {
    
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        
        Scanner in = new Scanner(System.in);
        float a = in.nextFloat();
        float b = in.nextFloat();
        float c = in.nextFloat();
        double wucha = 0.001;
        if(a<1||b<1||c<1||a>200||b>200||c>200)
        {
            System.out.println("Wrong Format");
            return;
        }
        else if(a+b<c+wucha||a+c<b+wucha||b+c<a+wucha)
        {
            System.out.println("Not a triangle");
            return;
        }
        else if(a==b||a==c||b==c)
        {
            if(a==b&&a==c)
            {
                System.out.println("Equilateral triangle");
                return;
            }
            else if((a*a+b*b<c*c+wucha&&a*a+b*b>c*c-wucha)||(a*a+c*c<b*b+wucha&&a*a+c*c>b*b-wucha)||(c*c+b*b<a*a+wucha&&c*c+b*b>a*a-wucha))
            {
                System.out.println("Isosceles right-angled triangle");
                return;
            }
            else
            {
                System.out.println("Isosceles triangle");
                return;
            }
        }
        else if((a*a+b*b<c*c+wucha&&a*a+b*b>c*c-wucha)||(a*a+c*c<b*b+wucha&&a*a+c*c>b*b-wucha)||(c*c+b*b<a*a+wucha&&c*c+b*b>a*a-wucha))
        {
            System.out.println("Right-angled triangle");
            return;
        }
        else
        {
            System.out.println("General triangle");
            return;
        }
    }
}

 第二个坑就是第三次作业的第二题：我自己感觉写的很正确，但是提交之后却总是有两个测试点过不去。我用一些常用的例子以及题目给的样例检验都是合格的，所以一直没有发现问题在哪。当我向一些满分的同学询问之后，恰好有一位同学经历过跟我一样的错误，我才知道我错在了求利率这里。 

double monthlyInterestRate = (balance / 1200) * annualInterestRate;
这一步必须要先除后乘，否则会丢失精度从而导致错误。（这个是真的不知道，困扰很久，请教了很多人）

import java.util.*;
class Account{
    private int id = 0;
    private double balance = 0;
    private double annualInterestRate = 0;
    
    public Account(int id,double balance) {
        this.id = id;
        this.balance = balance;
    }
    
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public double getBalance() {
        return balance;
    }
    public void setBalance(double balance) {
        this.balance = balance;
    }
    public double getAnnualInterestRate() {
        return annualInterestRate;
    }
    public void setAnnualInterestRate(double annualInterestRate) {
        this.annualInterestRate = annualInterestRate;
    }
    public double getMonthlyInterestRate() {
        double monthlyInterestRate = (balance / 1200) * annualInterestRate;
        return monthlyInterestRate;
    }
    
    public void withDraw(double withDraw) {
        if(withDraw > balance || withDraw < 0)
            System.out.println("WithDraw Amount Wrong");
        else
            balance = balance - withDraw;
    }
    public void deposit(double deposit) {
        if(deposit > 20000 || deposit < 0 )
            System.out.println("Deposit Amount Wrong");
        else
            balance = balance + deposit ;
    }
}

public class Main{
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int id = in.nextInt();
        double balance = in.nextDouble();
        double annualInterestRate = in.nextDouble();
        double withDraw = in.nextDouble();
        double deposit = in.nextDouble();
        char DateCreated = 2020-07-31;
        Account account = new Account( id , balance );
        account.setAnnualInterestRate(annualInterestRate);
        account.withDraw(withDraw);
        account.deposit(deposit);
        System.out.println("The Account'balance:"+String.format("%.2f",account.getBalance()));
        System.out.println("The Monthly interest:"+String.format("%.2f",account.getMonthlyInterestRate()));
        System.out.println("The Account'dateCreated:2020-07-31");
    }
}

第三个坑无疑就是求下n天的int最大值的那个测试点了，不写这一题都快忘记了int还有最大值这一说，得控制好对象，争取每个对象都在合理的范围内。（虽然这题的测试点角度很刁钻，但我觉得他其实也很有意义，很有意思）因为上文附过源码，所以我在这就不再附一次了。

 

通过这几次作业，写代码的学习我明白代码的学习不只是光看书或者是看网课就能提高自己的，更重要的是与他人的交流，与他人思想的碰撞。只有取他人之长补自己之短，才能够真正意义上的垒高自己，真正的学会Java这门编译语言。路还很长。

4、改进建议

　　写题目一定是为了解决实际问题的，而不能盯着测试点看，如果代码仅仅是为了通过几个测试点而编写出来的，那这样的练习可以说是毫无意义。再就是对代码的学习应该要懂得类比，举一反三：例如第三次作业的第三题求下一天，与第三次作业的第四题的求前n天求下n天本质上就是一个类型的题目，如果我们能弄懂求下一天的原理，那么见到求下n天之类的题目时就会有一种熟悉感，编写代码的过程也会变得很轻松，问题就迎刃而解。从这里可以明白，我们对代码的理解不能停留在表面，应可以看的更远，争取做到举一反三。如果我们对写过的题目的理解仅仅停留在表面，那我们每次写迭代的题目都会像是一个新的题目，这无形中扩大了题目的难度，同时也失去了迭代题目最宝贵的意义：引导我们的思想不断深入理解题目的意义。

5、总结

 　　这是我第一次写关于Java学习的博客总结，同时对Java的学习也是刚刚开始，所以我知道自己身上仍然有很多不足，但是学习一种新的编程语言本来就是一个不简单的过程，看到自己身上的缺陷是正常的，重要的是看到缺陷之后能努力去改正他，尽力去做得更好。同时我也发现，Java的学习不仅仅是需要对基础知识的熟悉，更要细心，同时养成良好的习惯。如果没有良好的编译习惯，那当程序运行异常找错时，是非常非常痛苦的，这一点我深有体会。因为不熟悉debug的操作，然后写代码时又喜欢节省空间，把代码挤在一起，所以出现错误查错的时候非常难受，密密麻麻的代码没有章法揉成一团，这浪费了我非常多的时间。这些应该是我写完pta三次作业最大的收获吧！再就是关于Java的课的看法：虽然我每节课都赶去抢前排，每节课都尽量去认真听，但我却很少能听懂段老师在课上讲解的知识点，就只能在csdn查找相关的文章，在厚厚的Java书里阅读语法，照猫画虎的在eclipse里敲代码，对private，class，public，static等词汇的用法几乎是一窍不通……只能利用课后的慕课来弥补语法知识的匮乏。Java的作业量不算少，然后题目的难度分布正常，前面的题目比较容易上手，后面的题目一般就需要我查阅相关资料来完成。其他的方面我没有什么看法意见，我觉得段老师这种教学模式虽然让我们很累很痛苦，但是从这个学习的过程中是可以真真正正的学习到东西的。总而言之，Java的学习之路才刚开始，即使前路一片茫茫黑暗，但是只要持之以恒，也一定能在这条路上走出属于自己的风采。