• 微信公众号:美女很有趣。 工作之余,放松一下,关注即送10G+美女照片!

java第1-3次作业总结

开发技术 开发技术 3小时前 2次浏览

一.前言:

  (1)第一次题目集只是简单的学习了java的语法(主类的使用以及main方法,还有基本的输入输出等),还没有真正运用面向对象,代码的编写仍然是采用面向过程的思想。题目数量比较合适,题目难度我认为so easy。

  (2)第二次题目集主要是类中的方法的创建以及使用。题目数量比较合适,题目难度我认为适中。

  (3)第三次题目集才算是用到了面向对象的思想,创建类进行封装。题目数量比较合适,题目难度我认为偏难。

 

二.设计与分析:

  (1)题目集1中:

    -8 判断三角形类型:

   java第1-3次作业总结

 我的思路:根据输入的数据,先检查数据是否合法–>是否能构成三角形–>是否为等边三角形–>是否为等腰直角三角形–>是否为等腰三角形–>是否为直角三角形–>是否为一般三角形。

如此,将题目的7种情况全部考虑进去。思路比较简单,没有什么复杂地方。思路虽然清晰,但是写出来的代码属实垃圾(轻喷)。只是一个面向过程的思路。

java第1-3次作业总结

 

 

     我的源码如下:

java第1-3次作业总结java第1-3次作业总结

 1 import java.util.Scanner;
 2 
 3 public class Main {
 4     public static void main(String[] args) {
 5         Scanner in = new Scanner(System.in);
 6         double a = in.nextDouble();
 7         double b = in.nextDouble();
 8         double c = in.nextDouble();
 9         
10         if(a<1||a>200||b<1||b>200||c<1||c>200) {
11             System.out.print("Wrong Format");
12         }
13         else if(a+b<=c||a+c<=b||b+c<=a) {
14             System.out.print("Not a triangle");
15         }
16         else if(a==b&&a==c) {
17             System.out.print("Equilateral triangle");
18         }
19         else if((a==b&&a*a+b*b-c*c<0.1)||(a==c&&a*a+c*c-b*b<0.1)||(c==b&&c*c+b*b-a*a<0.1)) {
20             System.out.print("Isosceles right-angled triangle");
21         }
22         else if(a==b||a==c||b==c) {
23             System.out.print("Isosceles triangle");
24         }
25         else if(a*a+b*b-c*c<0.1||a*a+c*c-b*b<0.1||c*c+b*b-a*a<0.1) {
26             System.out.print("Right-angled triangle");
27         }
28         else {
29             System.out.print("General triangle");
30         }
31     }
32 }

View Code

 

  (2)题目集2中:-3 判断闰年及星期几,-4 求下一天,-5 求前N天  整合在了一起,-4与-5只是在-3的基础上加了两个方法。

java第1-3次作业总结

 

java第1-3次作业总结

 

java第1-3次作业总结

 

此次是构建类的方法,求下一天的方法可以整合到求前n天的方法中,参数n=-1(在这里我写了两个)

思路:求前n天的日期通过将现在的日期+或-|n|,看是否不在本月来更改月份,进而看是否需要更改年份。

java第1-3次作业总结java第1-3次作业总结

 

 

源码如下:

java第1-3次作业总结java第1-3次作业总结

  1 import java.util.Scanner;
  2 
  3 public class Main {
  4     public static void main(String[] args) {
  5         Scanner in = new Scanner(System.in);
  6 
  7         int year = in.nextInt();
  8         int month = in.nextInt();
  9         int day = in.nextInt();
 10         int n = in.nextInt();
 11         
 12         if(checkInputValidity(year, month, day) && n>=-10 && n<=10) {
 13             num_nextDate(year, month, day, n);
 14         }
 15         else {
 16             System.out.println("Wrong Format");
 17         }
 18     }
 19 
 20     public static boolean checkInputValidity(int year, int month, int day) {//判断输入日期是否合法,返回布尔值
 21         if (year < 1820 || year > 2020)
 22             return false;
 23         else {
 24             switch (month) {
 25             case 1:
 26                 if (day < 1 || day > 31)
 27                     return false;
 28                 break;
 29             case 2:
 30                 if (isLeapYear(year)) {
 31                     if (day < 1 || day > 29)
 32                         return false;
 33                 } else {
 34                     if (day < 1 || day > 28)
 35                         return false;
 36                 }
 37                 break;
 38             case 3:
 39                 if (day < 1 || day > 31)
 40                     return false;
 41                 break;
 42             case 4:
 43                 if (day < 1 || day > 30)
 44                     return false;
 45                 break;
 46             case 5:
 47                 if (day < 1 || day > 31)
 48                     return false;
 49                 break;
 50             case 6:
 51                 if (day < 1 || day > 30)
 52                     return false;
 53                 break;
 54             case 7:
 55                 if (day < 1 || day > 31)
 56                     return false;
 57                 break;
 58             case 8:
 59                 if (day < 1 || day > 31)
 60                     return false;
 61                 break;
 62             case 9:
 63                 if (day < 1 || day > 30)
 64                     return false;
 65                 break;
 66             case 10:
 67                 if (day < 1 || day > 31)
 68                     return false;
 69                 break;
 70             case 11:
 71                 if (day < 1 || day > 30)
 72                     return false;
 73                 break;
 74             case 12:
 75                 if (day < 1 || day > 31)
 76                     return false;
 77                 break;
 78 
 79             default:
 80                 return false;
 81             }
 82         }
 83         return true;
 84     }
 85 
 86     public static boolean isLeapYear(int year) {// 判断year是否为闰年,返回boolean类型
 87         if (year % 400 == 0 || (year % 4 == 0 && year % 100 != 0)) {
 88             return true;
 89         } else
 90             return false;
 91     }
 92 
 93     public static int numOfDays(int year, int month, int day) {// 求出year-month-day到0001-1-1的距离天数,返回整型数
 94         int sum = 0;
 95         for (int i = 1; i < year; i++) {
 96             if (isLeapYear(i))
 97                 sum += 366;
 98             else
 99                 sum += 365;
100         }
101         for (int i = 1; i < month; i++) {
102             switch (i) {
103             case 1:
104                 sum += 31;
105                 break;
106             case 2:
107                 if (isLeapYear(year)) {
108                     sum += 29;
109                 } else {
110                     sum += 28;
111                 }
112                 break;
113             case 3:
114                 sum += 31;
115                 break;
116             case 4:
117                 sum += 30;
118                 break;
119             case 5:
120                 sum += 31;
121                 break;
122             case 6:
123                 sum += 30;
124                 break;
125             case 7:
126                 sum += 31;
127                 break;
128             case 8:
129                 sum += 31;
130                 break;
131             case 9:
132                 sum += 30;
133                 break;
134             case 10:
135                 sum += 31;
136                 break;
137             case 11:
138                 sum += 30;
139                 break;
140             case 12:
141                 sum += 31;
142                 break;
143 
144             default:
145                 break;
146             }
147         }
148 
149         return sum+day;
150     }
151 
152     public static String getWhatDay(int days) {// 根据天数返回星期几,其中参数days为天数,整型数,返回星期几的英文单词
153         switch (days % 7) {
154         case 0:
155             return "Sunday";
156         case 1:
157             return "Monday";
158         case 2:
159             return "Tuesday";
160         case 3:
161             return "Wednesday";
162         case 4:
163             return "Thursday";
164         case 5:
165             return "Friday";
166         default:
167             return "Saturday";
168         }
169     }
170     
171     public static void nextDate(int year, int month, int day) {//求输入日期的下一天
172         int[] md = new int[] {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
173         if(isLeapYear(year))
174             md[1] = 29;
175         day++;
176         if(day > md[month-1]) {
177             day = 1;
178             month++;
179         }
180         if(month > 12) {
181             month = 1;
182             year++;
183         }
184         
185         System.out.println("Next date is:"+year+"-"+month+"-"+day);
186     }
187     
188     public static void num_nextDate(int year, int month, int day, int n) {//求输入日期的n天的日期
189         int[] md = new int[] {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
190         if(isLeapYear(year))
191             md[1] = 29;
192         day -= n;
193         if(day > md[month-1]) {
194             day -= md[month-1];
195             month++;
196             if(month > 12) {
197                 month = 1;
198                 year++;
199             }
200         }
201         else if(day < 1) {
202             month--;
203             if(month < 1) {
204                 month = 12;
205                 year--;
206             }
207             day += md[month-1];
208         }
209         
210         System.out.println(n+" days ago is:"+year+"-"+month+"-"+day);
211     }
212 }

View Code

 

  (3)题目集3中

-2 定义日期类

java第1-3次作业总结

 

这个很简单,类中的属性以及方法都很好完成,没有难点。

 

 

java第1-3次作业总结java第1-3次作业总结

 

 

 

 

源码如下:

java第1-3次作业总结java第1-3次作业总结

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

View Code

 

-3 一元多项式求导(类设计)

java第1-3次作业总结

 

 思路如下:判断表达式的正误:每个项的情况概括有如下几种,写出其正则表达式

系数 * 自变量 ^ 指数 举例
        5、+5、-5
        x
    5*x
    x^5、x^-5
-5*x^5

 

求导:遍历表达式,每找到一个x分别往前找到其系数,往后找到其指数,对每一项求导,将计算得到的项依次插在StringBuffer()中,这样就能直接跳过常数项。最后对所得到的表达式进行化简,通过replaceAll()方法。

java第1-3次作业总结java第1-3次作业总结

 

 

 

 

 

 

 

 

源码如下:

java第1-3次作业总结java第1-3次作业总结

  1 import java.math.BigInteger;
  2 import java.util.Scanner;
  3 import java.util.regex.Matcher;
  4 import java.util.regex.Pattern;
  5 
  6 public class Main {
  7     public static void main(String[] args) {
  8         Scanner in = new Scanner(System.in);
  9 
 10         Expression A = new Expression(in.nextLine());
 11         
 12         A.outDerivative();
 13     }
 14 }
 15 
 16 class Expression {// 简单多项式求导
 17     private String str = new String();
 18 
 19     Expression(String str) {
 20         this.str = str.replaceAll(" ", "");
 21     }
 22 
 23     String getStr() {
 24         return this.str;
 25     }
 26 
 27     boolean checkInputValidity() {// 表达式输入是否合法
 28         if (this.str.matches("^(([+-]?[1-9]\d*)|([+-]?([1-9]\d*\*)?x(\^[+-]?[1-9]\d*)?))+$")) {
 29             return true;
 30         }
 31 
 32         return false;
 33     }
 34 
 35     void outDerivative() {// 输出导函数
 36         Expression ex = new Expression(this.str);
 37         if(ex.checkInputValidity()) {
 38             StringBuffer strbuf = new StringBuffer();
 39             BigInteger a = new BigInteger("0");//系数
 40             BigInteger b = new BigInteger("0");//指数
 41             for(int i = 0; i < ex.str.length(); i++) {
 42                 if(ex.str.charAt(i)=='x') {
 43                     a = new BigInteger("0");//系数初始化
 44                     b = new BigInteger("0");//指数初始化
 45                     if(i+1<ex.str.length()&&ex.str.charAt(i+1)=='^') {//计算指数
 46                         int j = i+2;
 47                         if(ex.str.charAt(j)=='+') {
 48                             while(j+1<ex.str.length()&&(ex.str.charAt(j+1)>='0'&&ex.str.charAt(j+1)<='9')) {
 49                                 //b = b*10+(ex.str.charAt(j+1)-'0');
 50                                 b = b.multiply(new BigInteger("10"));
 51                                 b = b.add(new BigInteger(Character.toString(ex.str.charAt(j+1))));
 52                                 j++;
 53                             }
 54                         }
 55                         else if(ex.str.charAt(j)=='-') {
 56                             while(j+1<ex.str.length()&&ex.str.charAt(j+1)>='0'&&ex.str.charAt(j+1)<='9') {
 57                                 //b = b*10-(ex.str.charAt(j+1)-'0');
 58                                 b = b.multiply(new BigInteger("10"));
 59                                 b = b.subtract(new BigInteger(Character.toString(ex.str.charAt(j+1))));
 60                                 j++;
 61                             }
 62                         }
 63                         else {
 64                             b = b.add(new BigInteger(Character.toString(ex.str.charAt(j))));
 65                             while(j+1<ex.str.length()&&(ex.str.charAt(j+1)-'0'>=0&&ex.str.charAt(j+1)-'0'<=9)) {
 66                                 b = b.multiply(new BigInteger("10"));
 67                                 b = b.add(new BigInteger(Character.toString(ex.str.charAt(j+1))));
 68                                 j++;
 69                             }
 70                         }
 71                     }
 72                     else {
 73                         b = b.add(new BigInteger("1"));
 74                     }
 75                     
 76                     if(i-1>=0&&ex.str.charAt(i-1)=='*') {//计算系数
 77                         int j = i-2;
 78                         while(j>0&&ex.str.charAt(j)!='+'&&ex.str.charAt(j)!='-') {
 79                             j--;
 80                         }
 81                         if(ex.str.charAt(j)=='+') {
 82                             j++;
 83                             while(ex.str.charAt(j)!='*') {
 84                                 //a = a*10+(ex.str.charAt(j)-'0');
 85                                 a = a.multiply(new BigInteger("10"));
 86                                 a = a.add(new BigInteger(Character.toString(ex.str.charAt(j))));
 87                                 j++;
 88                             }
 89                         }
 90                         else if(ex.str.charAt(j)=='-'){
 91                             j++;
 92                             while(ex.str.charAt(j)!='*') {
 93                                 //a = a*10-(ex.str.charAt(j)-'0');
 94                                 a = a.multiply(new BigInteger("10"));
 95                                 a = a.subtract(new BigInteger(Character.toString(ex.str.charAt(j))));
 96                                 j++;
 97                             }
 98                         }
 99                         else {
100                             while(ex.str.charAt(j)!='*') {
101                                 a = a.multiply(new BigInteger("10"));
102                                 a = a.add(new BigInteger(Character.toString(ex.str.charAt(j))));
103                                 j++;
104                             }
105                         }
106                     }
107                     else {
108                         if(i-1>=0&&ex.str.charAt(i-1)=='-') {
109                             a = a.subtract(new BigInteger("1"));
110                         }
111                         else {
112                             a = a.add(new BigInteger("1"));
113                         }
114                     }
115                     
116                     a = a.multiply(b);
117                     b = b.subtract(new BigInteger("1"));
118                     if(a.compareTo(new BigInteger("0"))>=0) {
119                         strbuf.append('+');
120                     }
121                     strbuf.append(a.toString()+"*x^"+b.toString());
122                 }
123             }
124             
125             if(strbuf.toString().isEmpty()) {
126                 System.out.println(0);
127             }
128             else {
129                 if(strbuf.charAt(0)=='+') {
130                     strbuf.delete(0, 1);
131                 }
132                 String str1 = strbuf.toString().replaceAll("x\^0", "1");
133                 str1 = str1.replaceAll("1\*", "");
134                 str1 = str1.replaceAll("\*1", "");
135                 //bug点测试start
136                 Pattern p = Pattern.compile("(\+\d+\+)|(\+\d+\-)");
137                 Matcher m = p.matcher(str1);
138                 StringBuffer sf = new StringBuffer(str1);
139                 int i = 0;
140                 while(m.find()){
141                     //System.out.println(m.group(1)+"|||"+m.start());
142                     sf.delete(m.start()-i, m.start()+1-i);
143                     i++;
144                 }
145                 //System.out.println(sf);
146                 p = Pattern.compile("(\+\d+$)");
147                 m = p.matcher(sf);
148                 i = 0;
149                 while(m.find()){
150                     //System.out.println(m.group(1)+"|||"+m.start());
151                     sf.delete(m.start()-i, m.start()+1-i);
152                     i++;
153                 }
154                 
155                 System.out.println(sf);
156                 //bug点测试end
157                 //System.out.println(str1);
158             }
159         }
160         else {
161             System.out.println("Wrong Format");
162         }
163     }
164 }

View Code

 

 

 

三.采坑心得:

  (1)题目集1中:-1 计算两个数的和(键盘读取两个整数相加输出即可),-2 电话键盘字母数字转换 (通过str.charAt(0)读取首字母,并用Character.toLowerCase()方法转化为小写,或者Character.toUpperCase()转化为大写,减少判断条件),-3 成绩分级管理(一系列的if-else即可完成)

          -4 计算税率(我是将switch与if混合使用一个一个判断并写计算表达式的,有点啰嗦),这题犯了点错误,在计算结果的表达式数据打错了(数据太多很尴尬,不够仔细)

          -7 对多个整数进行排序(我在想C有qsort(),C++有sort(),那java应该也有排序方法能直接用,在度娘找到了Arrays.sort(),这题我就直接简单的过了)

          -8 判断三角形类型(这题有个小坑,在判断直角三角形是不能直接用a^2+b^2==c^2来判断,整形数据用这个没问题,但是像根号2*根号2=4的这类无法通过,查阅资料后发现因为double类型不是精确数据无法通过==来判断,会有误差,之后通过a*a+b*b-c*c<0.1来判断通过了所有的测试样例

 

  (2)题目集2中:-1 IP地址转换(因为每8位转换10进制,我写了一个8位二进制转十进制的方法,将输入的32位二进制数分成4个8位二进制数计算,很方便)

          -3 判断闰年及星期几(计算相隔天数的时候注意闰年要多加1天)

          -4 求下一天(在这里要注意月份以及年份的分隔点,注意判断就ok了)

          -5 求前N天(开始没看这题,不然写一个就好了,-4就不需要写了,与-4类似,注意月份以及年份的分隔点)

 

  (3)题目集3中:-1与-2比较简单,一个个方法写就很简单。

          -3 一元多项式求导(学习了正则表达式,在正则表达式判断输入是否合法这里纠结了很久,最后写出来的虽然通过了样例,但是自己实测还有点有问题,改正在建议中)(还有一个大数的点开始没有过,因为用的int型,通过度娘找到了BigInteger类,学习了这个类后过了)(这个题目最后一个测试点过不去,询问同学后发现是题目问题,在输出项中正的常数项前面的‘+’被吞了,特意去掉了这个加号过了最后的测试点,烦)

我写的正则判断“^(([+-]?[1-9]\d*)|([+-]?([1-9]\d*\*)?x(\^[+-]?[1-9]\d*)?))+$”java第1-3次作业总结,连续输入两个x没有返回错误。

 

 

 

 

四.改进建议:

  (1)题目集1中:-4 计算税率这题我认为采用数组比较好(我没有,导致数据输入错了,改数据让自己难受)在更改数据时很方便。

          

  (2)题目集2中:-3 判断闰年及星期几中,写判断输入数据是否合法以及计算相隔天数时,没有将每个月的天数集合成一个数组,写了很多的if-else,到了-4,-5才反应过来用一个数组表示,节省了很多的代码长度。

 

  (3)题目集3中:-3 一元多项式求导中我之后又写了个正则判断“^(([+-]?[1-9]\d*)|([+-]?([1-9]\d*\*)?x(\^[+-]?[1-9]\d*)?))(([+-][1-9]\\d*)|([+-]([1-9]\\d*\\*)?x(\\^[+-]?[1-9]\\d*)?))*$”

java第1-3次作业总结,通过了这个样例,是否还有其他错误目前没有发现。在求输出导函数时一大串代码全写在了一个方法中,可读性差,修改不方便,我应该分成多个方法去写方便修改(表达式化简、求系数、求指数、输出最终结果等)。

 

 

 

 

五.总结:

  这三次题目集的训练让我初步进入了面向对象的大门,掌握了类的构造及其属性方法,面向对象进行封装能增加代码的可读性,便于代码的修改。

  学会了正则表达式的判断,简单了解了Matcher类、Pattern类、BigInteger类等的方法(封装真好用)。

  通过圈复杂度的分析,发现自己的代码也就自己愿意看吧(可读性实在是la),写成多个类或方法能明显提高代码可读性。

  在类中的属性定义为private私有的,这样类中的属性只能通过类中的方法来获取或者更改,能够提高代码的安全性(封装yyds)。


程序员灯塔
转载请注明原文链接:java第1-3次作业总结
喜欢 (0)