第一次博客作业

前言

　　前三次的题目主要包括 Java 基础语法，基本函数库的使用，题量较大，难度适中
　　本文中的的代码已上传至GitHub
　　项目地址：https://github.com/Waterfrontflowers/myJavaAtPta

---

设计与分析

7-8 判断三角形类型

​　　通过基础的三角形公式（两边之和大于第三边，勾股定理等）判定三角形类型

类图

SourceMonitor 结果

Parameter	Value
Project Directory	D:\SourceMonitorProject|
Project Name	SourceMonitorProject
Checkpoint Name	Checkpoint1
File Name	Main.java
Lines	41
Statements	23
Percent Branch Statements	39.1
Method Call Statements	18
Percent Lines with Comments	12.2
Classes and Interfaces	1
Methods per Class	1.00
Average Statements per Method	20.00
Line Number of Most Complex Method	9
Name of Most Complex Method	Main.main()
Maximum Complexity	21
Line Number of Deepest Block	16
Maximum Block Depth	4
Average Block Depth	2.48
Average Complexity	21.00

Most Complex Methods in 1 Class(es):	Complexity	Statements	Max Depth	Calls
Main.main()	21	20	4	18

Block Depth	Statements
0	2
1	1
2	8
3	8
4	4
5	0
6	0
7	0
8	0
9+	0

---

7-4 求下一天

​　　在题中有提到checkInputValidity()函数用于判断日期是否合法，这不仅可以用于输入检测，也可以用来检测对“年月日”中“日” + 1 天后是否合法，若不合法 则 “月” + 1 、 “日” = 1 ，年份控制同理。

类图

SourceMonitor 结果

Parameter	Value
Project Directory	D:\SourceMonitorProject\
Project Name	SourceMonitorProject
Checkpoint Name	Checkpoint1
File Name	Main.java
Lines	78
Statements	40
Percent Branch Statements	30.0
Method Call Statements	14
Percent Lines with Comments	10.3
Classes and Interfaces	1
Methods per Class	3.00
Average Statements per Method	11.33
Line Number of Most Complex Method	9
Name of Most Complex Method	Main.main()
Maximum Complexity	2
Line Number of Deepest Block	16
Maximum Block Depth	3
Average Block Depth	1.15
Average Complexity	1.50

Most Complex Methods in 1 Class(es):	Complexity	Statements	Max Depth	Calls
Main.if()	1	1	2	0
Main.main()	2	8	3	6

Block Depth	Statements
0	12
1	12
2	14
3	2
4	0
5	0
6	0
7	0
8	0
9+	0

---

7-5 求前N天

　　求前N天与求后一天的情况相类似，在向后加的基础上，加上先前减的情况，当 “日” 出现 < 0 的 时候 “日” = 31 、 “月” - 1 ，年份同理 ，同时计数 N 的 绝对值 次 正确日期 。

类图

SourceMonitor 结果

Parameter	Value
Project Directory	D:\SourceMonitorProject\
Project Name	SourceMonitorProject
Checkpoint Name	Checkpoint1
File Name	Main.java
Lines	100
Statements	52
Percent Branch Statements	17.3
Method Call Statements	21
Percent Lines with Comments	8.0
Classes and Interfaces	1
Methods per Class	7.00
Average Statements per Method	6.57
Line Number of Most Complex Method	9
Name of Most Complex Method	Main.main()
Maximum Complexity	3
Line Number of Deepest Block	84
Maximum Block Depth	7
Average Block Depth	2.48
Average Complexity	1.50

Most Complex Methods in 2 Class(es):	Complexity	Statements	Max Depth	Calls
checkInputValidity().if	1	2	7	0
checkInputValidity().if	1	2	4	0
Main.if()	1	1	2	0
Main.main()	3	9	3	7

Block Depth	Statements
0	9
1	11
2	13
3	4
4	6
5	2
6	3
7	4
8	0
9+	0

---

7-2 定义日期类

​　　7-2 将之前写在一个Main类里的 “静态方法” 改为 “实例方法” 独立到单独的类中，通过建立对象访问

类图

SourceMonitor 结果

Parameter	Value
Project Directory	D:\SourceMonitorProject\
Project Name	SourceMonitorProject
Checkpoint Name	Checkpoint1
File Name	Main.java
Lines	122
Statements	61
Percent Branch Statements	19.7
Method Call Statements	14
Percent Lines with Comments	6.6
Classes and Interfaces	2
Methods per Class	5.50
Average Statements per Method	4.00
Line Number of Most Complex Method	9
Name of Most Complex Method	Main.main()
Maximum Complexity	2
Line Number of Deepest Block	17
Maximum Block Depth	3
Average Block Depth	1.25
Average Complexity	1.10

Most Complex Methods in 2 Class(es):	Complexity	Statements	Max Depth	Calls
Date.Date()	1	3	2	0
Date.Date()	1	0	0	0
Date.getDay()	1	1	2	0
Date.getMonth()	1	1	2	0
Date.getYear()	1	1	2	0
Date.if()	1	1	2	0
Date.setDay()	1	1	2	0
Date.setMonth()	1	1	2	0
Date.setYear()	1	1	2	0
Main.main()	2	9	3	6

Block Depth	Statements
0	13
1	22
2	24
3	2
4	0
5	0
6	0
7	0
8	0
9+	0

---

7-3 一元多项式求导

​　　通过正则表达式似乎是最简单的提取各项的最便利的方式，但在实际运用中发现，单个一元式中似乎各个位置都可以缺失，甚至在极端情况下只要有一个就行了，这对提炼正则表达式产生难度，作者在截止前未能提取正确的正则表达式，存在部分BUG

类图

---

SourceMonitor 结果

Parameter	Value
Project Directory	D:\SourceMonitorProject\
Project Name	SourceMonitorProject
Checkpoint Name	Checkpoint1
File Name	Main.java
Lines	174
Statements	103
Percent Branch Statements	28.2
Method Call Statements	50
Percent Lines with Comments	7.5
Classes and Interfaces	2
Methods per Class	3.00
Average Statements per Method	14.67
Line Number of Most Complex Method	41
Name of Most Complex Method	Polynomial.regular()
Maximum Complexity	18
Line Number of Deepest Block	55
Maximum Block Depth	6
Average Block Depth	3.52
Average Complexity	6.83

Most Complex Methods in 2 Class(es):	Complexity	Statements	Max Depth	Calls
Main.main()	2	8	3	5
Polynomial.derivative()	2	3	3	0
Polynomial.getPolynomial()	1	1	2	0
Polynomial.Polynomial()	1	1	2	1
Polynomial.print()	17	27	5	9
Polynomial.regular()	18	48	6	35

Block Depth	Statements
0	5
1	10
2	17
3	13
4	19
5	30
6	9
7	0
8	0
9+	0

---

采坑心得

7-8

​　　这一题碰到的最大的问题是在float, double 这些浮点数计算时，使用乘除这类的运算会出现精度误差。这几乎是计算机无法避免的。在编码时我们不能使用两边 == 的方式判定 ，而是改为相减小于一定的误差值的算法。

7-2/4/5

​　　这三题可以说几乎没什么大坑，主要是Java的基础语法和边界值检测。

7-3

​　　这是三次作业中最复杂的，在系数、乘号、次方号、x 、指数中，大多能独立存在，要覆盖所有情况，最好是多个正则表达式取或，进行运算取值，较为复杂。

---

改进建议

​　　在之前编码的时候，用了不少的“魔法值”，这或许对将来再次看代码的时候会造成不少的麻烦，各个参数的意义不够明确，在将来会尽力使用 final 常量来定义他们。

​　　在之后的编码中尽量做到方法之间的分工合作，把任务分散开，加强代码易读性。

---

总结

　　Java 作为一个面向对象的语言，与C语言的构成确实有不小的区别，习惯面向对象的思维方式是这门课必要的内容。

面向对象

面向对象有以下优点：

1. 结构清晰，程序是模块化和结构化，更加符合人类的思维方式；

2. 易扩展，代码重用率高，可继承，可覆盖，可以设计出低耦合的系统；

3. 易维护，系统低耦合的特点有利于减少程序的后期维护工作量。

面向对象也有以下缺点：

1. 开销大，当要修改对象内部时，对象的属性不允许外部直接存取，所以要增加许多没有其他意义、只负责读或写的行为。这会为编程工作增加负担，增加运行开销，并且使程序显得臃肿。
2. 性能低，由于面向更高的逻辑抽象层，使得面向对象在实现的时候，不得不做出性能上面的牺牲，计算时间和空间存储大小都开销很大。

Java 数据类型

基本数据类型

Java语言提供了八种基本类型。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。

byte

• byte 数据类型是8位、有符号的，以二进制补码表示的整数；
• 最小值是 -128（-2^7）；
• 最大值是 127（2^7-1）；
• 默认值是 0；
• byte 类型用在大型数组中节约空间，主要代替整数，因为 byte 变量占用的空间只有 int 类型的四分之一；

short

• short 数据类型是 16 位、有符号的以二进制补码表示的整数
• 最小值是 -32768（-2^15）；
• 最大值是 32767（2^15 - 1）；
• Short 数据类型也可以像 byte 那样节省空间。一个short变量是int型变量所占空间的二分之一；
• 默认值是 0；

int

• int 数据类型是32位、有符号的以二进制补码表示的整数；
• 最小值是 -2,147,483,648（-2^31）；
• 最大值是 2,147,483,647（2^31 - 1）；
• 一般地整型变量默认为 int 类型；
• 默认值是 0 ；

long

• long 数据类型是 64 位、有符号的以二进制补码表示的整数；
• 最小值是 -9,223,372,036,854,775,808（-2^63）；
• 最大值是 9,223,372,036,854,775,807（2^63 -1）；
• 这种类型主要使用在需要比较大整数的系统上；
• 默认值是 0L；
  "L"理论上不分大小写，但是若写成"l"容易与数字"1"混淆，不容易分辩。所以最好大写。

float

• float 数据类型是单精度、32位、符合IEEE 754标准的浮点数；
• float 在储存大型浮点数组的时候可节省内存空间；
• 默认值是 0.0f；
• 浮点数不能用来表示精确的值，如货币；

double

• double 数据类型是双精度、64 位、符合 IEEE 754 标准的浮点数；

• 浮点数的默认类型为 double 类型；

• double类型同样不能表示精确的值，如货币；

• 默认值是 0.0d；

  7 是一个 int 字面量，而 7D，7. 和 8.0 是 double 字面量。

boolean

• boolean数据类型表示一位的信息；
• 只有两个取值：true 和 false；
• 这种类型只作为一种标志来记录 true/false 情况；
• 默认值是 false；

char

• char 类型是一个单一的 16 位 Unicode 字符；

• 最小值是 \u0000（十进制等效值为 0）；

• 最大值是 \uffff（即为 65535）；

• char 数据类型可以储存任何字符；

引用数据类型

• 在Java中，引用类型的变量非常类似于C/C++的指针。引用类型指向一个对象，指向对象的变量是引用变量。这些变量在声明时被指定为一个特定的类型，比如 Employee、Puppy 等。变量一旦声明后，类型就不能被改变了。
• 对象、数组都是引用数据类型。
• 所有引用类型的默认值都是null。
• 一个引用变量可以用来引用任何与之兼容的类型。

封装

• 在面向对象程式设计方法中，封装（英语：Encapsulation）是指一种将抽象性函式接口的实现细节部分包装、隐藏起来的方法。

• 封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。

• 要访问该类的代码和数据，必须通过严格的接口控制。

• 封装最主要的功能在于我们能修改自己的实现代码，而不用修改那些调用我们代码的程序片段。

• 适当的封装可以让程式码更容易理解与维护，也加强了程式码的安全性。

优点：

1. 良好的封装能够减少耦合。
2. 类内部的结构可以自由修改。
3. 可以对成员变量进行更精确的控制。
4. 隐藏信息，实现细节。

封装的步骤：

1. 修改属性的可见性来限制对属性的访问（一般限制为private）
2. 对每个值属性提供对外的公共方法访问，也就是创建一对赋取值方法，用于对私有属性的访问

包

为了更好地组织类，Java 提供了包机制，用于区别类名的命名空间。

包的作用

1. 把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。
2. 如同文件夹一样，包也采用了树形目录的存储方式。同一个包中的类名字是不同的，不同的包中的类的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。因此，包可以避免名字冲突。
3. 包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。

Java 使用包（package）这种机制是为了防止命名冲突，访问控制，提供搜索和定位类（class）、接口、枚举（enumerations）和注释（annotation）等

创建包

创建包的时候，你需要为这个包取一个合适的名字。之后，如果其他的一个源文件包含了这个包提供的类、接口、枚举或者注释类型的时候，都必须将这个包的声明放在这个源文件的开头。

包声明应该在源文件的第一行，每个源文件只能有一个包声明，这个文件中的每个类型都应用于它。

如果一个源文件中没有使用包声明，那么其中的类，函数，枚举，注释等将被放在一个无名的包（unnamed package）中。

import 关键字

为了能够使用某一个包的成员，我们需要在 Java 程序中明确导入该包。使用 "import" 语句可完成此功能。

在 java 源文件中 import 语句应位于 package 语句之后，所有类的定义之前，可以没有，也可以有多条

注意：

类文件中可以包含任意数量的 import 声明。import 声明必须在包声明之后，类声明之前。

package 的目录结构

类放在包中会有两种主要的结果：

• 包名成为类名的一部分。
• 包名必须与相应的字节码所在的目录结构相吻合。