基础篇_开发命令行程序(输入输出,类型、变量、运算符,条件语句,循环语句,方法,package与jar)

文章目录

一. 输入输出
- 1. System.out
- 2. System.in
- 3. Scanner
- 4. 变量名
- 5. 关键字
二. 类型、变量、运算符
- 1. 字符与字符串
- - 字符值与字符串值
  - 转义字符
  - 文本块
- 2. 类型
- - 何为类型
  - 数字类型
  - 字符类型
- 3. 变量与运算符
- - 变量
  - 运算符
- 4. 练习 - 房贷计算器
- - Math.pow()
  - 数字格式化
  - 查阅 Javadoc
三. 条件语句
- 1. boolean 类型
- 2. 单条件
- 3. 多条件
- 4. 相反条件
四. 循环语句
- 1. 循环语句语法
- 2. 变量的作用范围
- 3. 练习 - 贷款计算详情
五. 方法
- 1. 定义方法
- 2. 调用方法
- 3. 方法的意义
- 4. 练习 - 贷款计算 - 方法改写
- - 说明1
  - 说明2
  - 说明3
六. package 与 jar
- 1. package
- 2. import
- 3. jar

一. 输入输出

输入的作用，就是由使用者告诉程序要操作的数据
- 例如，我要通过饿了么订餐，你得告诉程序你要吃什么，送货地址是什么吧
输出的作用，就是由程序向使用者展现执行的结果
- 还是订餐的例子，程序向你展示骑手接单没有，送到哪里了
将来输入输出来源会有多种，比如 app，网页，终端程序等等

1. System.out

之前已经介绍过【标准输出】：System.out

打开 jshell 用一下，回忆下对象和方法使用格式

对象.方法(参数);

套用一下，对象是 System.out，方法是 println，参数是 “你好”

jshell> System.out.println("你好");
你好

小技巧

jshell 中用 Tab 键可以提示对象有哪些方法
jshell 中省略 ; 也不会报错

2. System.in

再来看看输入，对象是 System.in，方法叫 read，没有参数

jshell> System.in.read();

运行后，可以看到光标一闪一闪，表示正在等待用户的输入，这时输入小 a

jshell> System.in.read();
a
$1 ==> 97

会显示 97，称之为返回值，代表 read() 读入的结果
- 因为计算机中所有符号，都是用数字表示，参看下表
前面的 $1 是一个【变量】，将来它就代表 97，也就是刚才输入的小 a
【变量】可以反复被使用

\	00	01	02	03	04	05	06	07	08	09	10	11	12	13	14	15
0000	无	无	无	无	无	无	无	无	无	无	无	无	无	无	无	无
0016	无	无	无	无	无	无	无	无	无	无	无	无	无	无	无	无
0032		!	"	#	$	%	&	’	(	)	*	+	,	-	.	/
0048	0	1	2	3	4	5	6	7	8	9	:	;	<	=	>	?
0064	@	A	B	C	D	E	F	G	H	I	J	K	L	M	N	O
0080	P	Q	R	S	T	U	V	W	X	Y	Z	[	\	]	^	_
0096	`	a	b	c	d	e	f	g	h	i	j	k	l	m	n	o
0112	p	q	r	s	t	u	v	w	x	y	z	{	\|	}	~	无

System.in 的缺点

字符被转成的数字，不便人类阅读
只能输入一个字符

3. Scanner

用 Scanner 改进，System.in 是 java 为我们提供好的对象，而 Scanner 需要我们自己创建，语法是

jshell> new Scanner(System.in);
$2 ==> java.util.Scanner...

将来这个 $2 就代表刚才的 Scanner 对象，我们称之为【变量】

Scanner 对象里面最常用的方法是 nextLine，用法如下

jshell> $2.nextLine();
你好啊
$3 ==> "你好啊"

4. 变量名

$2，$3 这样作为变量名虽然也可以，但如果用更有意义的名称来表示，更方便人类阅读、记忆。例如

jshell> var scanner = new Scanner(System.in)
scanner ==> java.util.Scanner[delimiters=\p{javaWhitespace}+] ... \E][infinity string=\Q∞\E]

jshell> var line = scanner.nextLine()
hello
line ==> "hello"

scanner 就代指输入对象
line 就代指用 nextLine() 读取到的字符串值
var 是关键字，代表某种类型，具体有哪些类型后面再展开

5. 关键字

变量取名时要注意两个规则，不能以数字开头，不能是关键字

什么是关键字呢？关键字就是 java 中有特殊意义的单词，例如见过的有 class，var，new 等等，如果用 idea 中可以通过特殊颜色强调哪些单词是关键字，可以看到这些蓝色的单词都属于关键字

至java 17 为止，共有 67 个关键字，参看这两份表格，这些关键字，都会在今后的课程中陆续学到
在这里插入图片描述

在这里插入图片描述

二. 类型、变量、运算符

1. 字符与字符串

字符值与字符串值

像这样用双引号引起来的值，在 Java 里称为字符串，字符串顾名思义，由多个字符组成，单个字符用单引号表示，例如

jshell> 'a'
$4 ==> 'a'

jshell> "abc"
$5 ==> "abc"

单引号里必须由一个字符
双引号里可以有零个、一个、多个字符

转义字符

比如我需要输出一个单引号字符值，''' 这样写行不行？本意是想表示中间的单引号，但遗憾的是java把前两个单引号当成了一对，把它当作了那个空字符了

怎么办呢

为了把真正的单引号跟语法的单引号区分开，需要给它加一个反斜杠标记，告诉java，我想表示真正的单引号，而不是语法中的单引号。试一下。

jshell> System.out.println("\'")
'

这种结合了反斜杠的具有特殊含义的字符，称之为转义字符（Escape Character）

常见的有七个：\' \" \\ \n \t \b \r 刚才已经讲过单引号转义了

继续来看几个例子

jshell> System.out.println("\"") // 双引号转义
"

jshell> System.out.println("\\") // 反斜杠本身转义
\

jshell> System.out.println("1\n2") // 换行
1
2

jshell> System.out.println("123\t4") // 缩进
123     4

jshell> System.out.println("123\b4") // 退格
124

jshell> System.out.println("123\r4") // 回车，退格是光标退一格，回车是退到头
423

文本块

最后再再来看看文本块，如果有一段文字内，其中需要有很多的转义字符，那么可读性会变得很差，例如

jshell> System.out.println("床前\"明月\"光，\n疑是地上霜。")

因此在 java 14 这个版本引入了文本块来进行改善。

jshell> System.out.println("""
                           床前"明月"光，
                           疑是地上霜。""")

文本块本质上还是属于字符串值，由一对三个双引号作为起始和结束标记，中间如果想表示双引号、换行这两个特殊字符，无需再转义表示

一个注意事项是 “”" 后需要换个行，不要紧接着写字符。

2. 类型

何为类型

现在让用户输入两个数，求得相加结果

jshell> scanner.nextLine()
1
$22 ==> "1"

jshell> scanner.nextLine()
2
$23 ==> "2"

jshell> $22 + $23
$24 ==> "12"

显然，这并不是我们想要的结果，它是输入的值当作了字符串，+ 号执行的是字符串连接操作，解决办法如下

jshell> scanner.nextInt()
1
$25 ==> 1

jshell> scanner.nextInt()
2
$26 ==> 2

jshell> $25 + $26
$27 ==> 3

nextLine() 和 nextInt() 返回的类型是不同的

前者返回的是字符串，类型为 String，+ 表示两个字符串连接
后者返回的是整数，类型为 int，+ 表示两个整数相加

数字类型

类型名	说明	数字范围	类型后缀
byte	整数类型，用1个字节表示	$2^7,2^7)$ 即 $[- 128, 128)$
short	整数类型，用2个字节表示	$2^{15},2^{15})$
int	整数类型，用4个字节表示	$2^{31},2^{31})$
long	整数类型，用8个字节表示	$2^{63},2^{63})$	L
float	浮点小数，用4个字节表示	$1.9999999 * 2^{127},1.9999999 * 2^{127}]$	F
double	浮点小数，用8个字节表示	$1.9999999 * 2^{1023},1.9999999 * 2^{1023}]$	D

[] 包含等于，() 不包含等于
类型后缀
- 不区分大小写，但建议用大写，因为小写的 L 与 1 容易混淆
- 尾符号 D 可以省略
float 和 double 精度不同，即小数点后的位数
- float 的精度二进制是 23，换算成十进制是 6~7
- double 的精度二进制是 52，换算成十进制是 15~16

字符类型

类型名	说明	范围
char	字符类型，配合单引号	$0,2^{16})$ 即 $[0, 65536)$
String	字符串类型，配合双引号或文本块	-

3. 变量与运算符

变量

变量的定义格式为

类型 变量名 = 值;

从语法可以看到，变量由类型和名称组成，类型决定了变量能存储的数据大小与数据格式，名字用来代表后面的值
这个语法其实咱们前面见过类似的，var scanner = new Scanner(System.in)，这里 var 是类型，因为之前我们还没有学习具体有哪些类型，因此使用了 var 来代表某种类型，scanner是变量名，后面这一串就是值，也是 Scanner 对象

= 称之为赋值运算符，可以用来更新变量代表的值。

例如：

int a = 10

这行代码的意思是，定义了整型变量a，更新它的初始值为10

再来一句：

a = 20

这时候为啥不用写前面的类型了呢，因为变量定义只需一次，定义好之后变量就可以反复使用了，这行代码的意思是，将 a 所代表的值更新为 20

变量可以用来保存运算的结果，它自身也能参与运算

运算符

int a = 5 + 3

结果为 8

int a = 5 - 3

结果为 2

int a = 5 * 3

结果为 15

int a = 5 / 3

结果为 1，整数除法有两个注意点

整数除法，只会保留商，而小数部分会被舍弃，并不考虑四舍五入
除0是不合法的，会出错

int a = 5 % 3

结果为 2

小数加减乘除与整数类似，只是小数除法可以保留小数点后的数字，而且可以除零，例如

jshell> 5.0 / 3.0
$40 ==> 1.6666666666666667

jshell> 5.0 / 0.0
$41 ==> Infinity

增强赋值运算符

int a = 20; 
a = a + 10;

意思是，获取 a 的原有值 20，执行加 10 运算，将新的结果重新赋值给 a，a 代表的值被更新成了 30。可以用 += 增强赋值运算符达到类似的效果

a += 10;

先不要看 = 号，获取 a 的原有值 30，执行加 10 运算，运算的结果 40 赋值给 a

a -= 10;

先拿 a 的原有值 40 与后面的 10 做减法，再将结果 30 赋值给 a

自增自减运算符

两个特殊运算符 ++ 与 –

++ 是让变量自增1，-- 是让变量自减1，举个例子

int a = 10;
a++;

结果为 11，++ 和 – 既可以写在变量之前，也可以写在变量之后，这两种写法的区别，我们到高级篇再讲，目前暂不用去了解

4. 练习 - 房贷计算器

【等额本息还款】法计算房贷

术语

等额本息是指一种贷款的还款方式，是在还款期内，每月偿还同等数额的贷款（包括本金和利息）

每月偿还的贷款可以通过下述公式计算

$p * r * (1 + r)^m / ((1 + r)^m - 1)$

p 为贷款本金 principal
r 为月利率 monthlyInterestRate
m 为还款月数 months

公式中这些都是什么意思呢

例如：贷款 200 万元，对应公式中的 p，200 万就是贷款本金，年利率 6%，月利率 mr 就是 6% / 12 = 0.5%，假设 10 年还清，这时还款月数就是 360 个月。套入公式计算即可得到每月还多少钱

要完成这个计算，有一点没学过的是求这里的 1+ mr 的 m 次方，计算它需要用一个求幂方法，这个方法是 jdk 核心类库中 Math 这个类提供的，Math的字面意思是数学，Math 类中提供了很多与数学计算相关的方法，如果你以后有这方面需求，就找它。

Math.pow()

pow 是 static 方法，语法为 类名.方法名(参数值)，它需要两个参数，参数1是底数，参数2是指数

jshell> Math.pow(2.0, 1)
$42 ==> 2.0

jshell> Math.pow(2.0, 2)
$43 ==> 4.0

jshell> Math.pow(2.0, 3)
$44 ==> 8.0

解答

打开 idea，编写 Calculator 类

public class Calculator {
    
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入贷款本金 p");
        double p = scanner.nextDouble();
        
        System.out.println("请输入年利率 r%");
        double yr = scanner.nextDouble();
        double mr = yr / 100.0 / 12.0;
        
        System.out.println("请输入贷款月数 m");
        int m = scanner.nextInt();
        
        System.out.println(p * mr * Math.pow((1 + mr), m) / (Math.pow((1 + mr), m) - 1));
    }
}

数字格式化

对结果的数字进行格式化，让它以货币的格式来显示

需要借助核心类库中一个 NumberFormat 对象，字面意思是数字格式化，使用它的 getCurrencyInstance 方法来获取一个货币格式化对象，再使用它的 format 方法把 double 小数格式化为货币格式，格式化时也会保留两位小数

例子

System.out.println(NumberFormat.getCurrencyInstance(Locale.CHINA).format(1000000.00));   System.out.println(NumberFormat.getCurrencyInstance(Locale.US).format(1000000.00));
System.out.println(NumberFormat.getCurrencyInstance(Locale.GERMANY).format(1000000.00));
System.out.println(NumberFormat.getCurrencyInstance(Locale.KOREA).format(1000000.00));

输出

¥1,000,000.00
$1,000,000.00
1.000.000,00 €
₩1,000,000

如果 Locale 省略不写，默认为中国

房贷计算器可以改写为

double payment = p * mr * Math.pow((1 + mr), m) / (Math.pow((1 + mr), m) - 1);       System.out.println(NumberFormat.getCurrencyInstance().format(payment));

查阅 Javadoc

练习做完了，大家学到了什么呢？

有同学说，学会怎么算每月还款了，是吗？并不是，通过这个例子，要认识到 java 核心类库能帮我们解决很多问题，比如说求幂运算，比如说数字格式化，包括之前学过的 Scanner 都是核心类库提供的功能，这就提醒我们，要解决某个编程问题之前，要先想一想核心类库有没有这方面的功能，如果有拿来用就行了，不必自己重新实现某项功能的代码，我们是站在巨人的肩膀上进行编程的。

当然，同学们并不是一开始就知道核心类库都提供了哪些功能，因此，这就需要我们不断去熟悉核心类库，熟悉它都有哪些类，哪些方法，比较重要的功能都在后续的课程中都会陆续介绍到，当然呢，同学们也不能总等着老师来喂知识，也可以自己查阅 javadoc 来扩展自己的知识面

javadoc 就是 java documentation 的缩写，我们下载的 jdk 中已经自带了，无需额外再下载。那怎么查阅 javadoc 呢，如果大家用的是 idea，那么可以通过一些快捷键来查阅java文档

比如想看看类的文档，这时先按 Ctrl + N 查找类，假设我想看 Math 类的文档，输入要查阅的类名 Math，回车，可以跳转到这个类
接下来我想看看方法的文档怎么办呢，按一下 ctrl + f12，列出当前类的所有方法，绿色表示可以使用方法，橙色带锁的，表示是该类一种特殊的私有方法，不能直接使用。找感兴趣的方法时，如果你懂一些英文单词，那么会有一定优势，例如你想找一个平方根方法，它对应的英文是 sqrt，这时敲入这几个字母，就会定位到方法，同样可以用翻译查看该方法的功能
可以查到它的作用：返回一个数的平方根，这是方法名，查看后面括号内可以得知，需要一个参数，代表要求平方根的那个数字，是一个double 小数，方法名称前还有个 double 表示它的结果类型也是一个 double 小数
Math 中的方法大部分都是 static 方法，也就是配合类名使用的方法，之前也说过，用法为类名.方法名(参数)

在平时写代码时，如果忘记了某个方法的作用，可以光标定位到该方法，按 Ctrl + Q 进行查阅，效果是类似的

三. 条件语句

编程时有一种重要的语句叫做条件语句，之前我们学过的都属于顺序语句，也就是从上至下，依次要执行每一行代码。

但是有的情况下，我们并不希望所有代码都执行，而是希望满足条件的代码才执行

例如：要对用户输入数据的合法性进行检查：

贷款本金必须大于0
贷款月数范围在 1 ~ 360 之间
年利率范围在 1% ~ 36% 之间

如果你输入的值连这些条件都不满足，有必要去计算每月还款金额吗？

这种情况下，就要用到条件语句了，它的语法格式为

if(条件) {
    // 条件为 true 执行这里
} else {
    // 条件为 false 执行这里
}

什么意思呢，if 本意是如果，如果条件成立，执行代码1，else 本意是否则，即条件不成立，执行代码2，其中 else { } 语句块不是必须的，可以省略

那么条件这部分怎么写呢？对于数字类型可以借助比较运算符的运算结果来充当条件，参考下面的表格，这种表格列出了所有比较运算符

比较运算符	含义
a == b	判断 a 与 b 是否相等
a > b	判断 a 是否 > b
a >= b	判断 a 是否 >= b
a < b	判断 a 是否 < b
a <= b	判断 a 是否 <= b
a != b	判断 a 与 b 是否不相等

1. boolean 类型

判断的结果是布尔类型，可以充当条件，它的取值非真即假，真用 true 表示，假用 false 表示

2. 单条件

jshell> int a = 1000;
a ==> 1000

jshell> if(a > 0){
   ...>     System.out.println("ok");
   ...> } else {
   ...>     System.out.println("必须>0");
   ...> }
ok

jshell> a = -1000;
a ==> -1000

jshell> if(a > 0){
   ...>     System.out.println("ok");
   ...> } else {
   ...>     System.out.println("必须>0");
   ...> }
必须>0

房贷计算器改写如下

public static void main(String[] args) {

    Scanner scanner = new Scanner(System.in);
    System.out.println("请输入贷款本金 p");
    double p = scanner.nextDouble();
    if(p > 0) {
        System.out.println("请输入年利率 r%");
        double yr = scanner.nextDouble();
        double mr = yr / 100.0 / 12.0;

        System.out.println("请输入贷款月数 m");
        int m = scanner.nextInt();

        double payment = p * mr * Math.pow((1 + mr), m) / (Math.pow((1 + mr), m) - 1);
        System.out.println(NumberFormat.getCurrencyInstance().format(payment));
    } else {
        System.out.println("贷款金额必须大于0");
    }

}

3. 多条件

刚才我们在判断贷款本金的时候，只需要有一个大于 0 的条件就可以了，但是接下来我们要去检查年利率的时候，他是在一个范围之间，这就必须有两个条件，一个条件呢是要让年利率大于等于 1%，第二个条件呢，是让上年利率必须小于等于 36%，而且呢这两个条件你必须同时成立

多个条件可以用逻辑运算符连接

逻辑运算符	含义
条件1 && 条件2	&& 意思是并且，两个条件必须同时成立，结果为 true
条件1 \|\| 条件2	\|\| 意思是或者，两个条件有一个成立，结果为 true
! 条件	! 意思是取反

举例

jshell> int b = 120;
b ==> 120

jshell> if(b >= 1 && b <= 360) {
   ...>     System.out.println("ok");
   ...> } else {
   ...>     System.out.println("必须在1~360之间");
   ...> }
ok

jshell> b = 0
b ==> 0

jshell> if(b >= 1 && b <= 360) {
   ...>     System.out.println("ok");
   ...> } else {
   ...>     System.out.println("必须在1~360之间");
   ...> }
必须在1~360之间

jshell> b = 361
b ==> 361

jshell> if(b >= 1 && b <= 360) {
   ...>     System.out.println("ok");
   ...> } else {
   ...>     System.out.println("必须在1~360之间");
   ...> }
必须在1~360之间

房贷计算器改写如下

public static void main(String[] args) {

    Scanner scanner = new Scanner(System.in);
    System.out.println("请输入贷款本金 p");
    double p = scanner.nextDouble();
    if(p > 0.0) {
        System.out.println("请输入年利率 r%");
        double yr = scanner.nextDouble();
        if (yr >= 1.0 && yr <= 36.0) {
            double mr = yr / 100.0 / 12.0;
            System.out.println("请输入贷款月数 m");
            int m = scanner.nextInt();
            if (m >= 1 && m <= 360) {
                double payment = 
                    p * mr * Math.pow((1 + mr), m) / (Math.pow((1 + mr), m) - 1);
                System.out.println(NumberFormat.getCurrencyInstance()
                                   .format(payment));
            } else {
                System.out.println("贷款月数范围在 1 ~ 360 之间");
            }
        } else {
            System.out.println("年利率范围在 1% ~ 36% 之间");
        }
    } else {
        System.out.println("贷款金额必须大于0");
    }
}

4. 相反条件

我们这段代码，逻辑上没错，但你会发现不容易阅读

多层 if 嵌套导致代码的可读性变得很差，一旦大家写代码时出现了两层以上的 if 语句，就要小心了。如何改进呢？

这里给同学们介绍一种方法：可以去除 else 提高代码可读性

比如，现在有两个分支，c 是一个条件，要么走分支1，要么走分支2，用下面的 if else 可以表示

if(c) {
    // 分支1
} else {
    // 分支2
}

等价于

if(!c) {
    // 分支2
} else {
    // 分支1
}

能不能不写 else 呢？假设进入了分支2，分支2的代码执行后，程序还会继续向下执行，导致分支1也被执行

if(!c) {
    // 分支2
}
// 分支1

可以改写为下面的形式，这样就避免了 else 出现

if(!c) {
    // 分支2
    return; 
}
// 分支1

总结一下，以上代码的等价转换，有一句口诀：条件取反，if else 倒置，return 一加， else 可去

变换有一定的规律：

原条件	相反条件1	相反条件2
p > 0.0	!(p > 0.0)	p <= 0.0
yr >= 1.0 && yr <= 36.0	!(yr >= 1.0 && yr <= 36.0)	yr < 1.0 \|\| yr > 36.0
m < 1 \|\| m > 360	!(m < 1 \|\| m > 360)	m >= 1 && m <= 360

用逻辑与连接的两个条件，可以两个条件分别取反，然后&&变||
- 年利率>=1.0 并且<=36.0 的相反条件是：年利率<1.0 或者年利率>36.0
用逻辑或连接的两个条件，可以两个条件分别取反，然后||变&&

这种逻辑变换规律称之为反演规则，公式记不住没关系，简单的反演我们自己就能想出来，复杂的变换才用公式保证正确性

房贷计算器改写如下

public static void main(String[] args) {

    Scanner scanner = new Scanner(System.in);
    System.out.println("请输入贷款本金 p");
    double p = scanner.nextDouble();
    if (p <= 0.0) {
        System.out.println("贷款金额必须大于0");
        return;
    }
    System.out.println("请输入年利率 r%");
    double yr = scanner.nextDouble();
    if (yr < 1.0 || yr > 36.0) {
        System.out.println("年利率范围在 1% ~ 36% 之间");
        return;
    }
    double mr = yr / 100.0 / 12.0;
    System.out.println("请输入贷款月数 m");
    int m = scanner.nextInt();
    if (m < 1 || m > 360) {
        System.out.println("贷款月数范围在 1 ~ 360 之间");
        return;
    }
    double payment = p * mr * Math.pow((1 + mr), m) / (Math.pow((1 + mr), m) - 1);
    System.out.println(NumberFormat.getCurrencyInstance().format(payment));

}

四. 循环语句

1. 循环语句语法

for(初始化变量; 终止条件; 更新变量) {
    // 循环体代码
}

初始化部分仅执行一次
执行终止条件，如果为 true 继续循环，如果为 false 退出循环
执行循环体代码
执行迭代部分，从 2 开始执行

例如

for(int i = 0; i < 3; i++) {
    System.out.println(i);
}

执行流程如下

声明一个变量 i，初始值为 0，用来控制循环次数
判断 i < 3，此时 i 取值是 0，条件为 true，继续循环
System.out.println(0)
i++，自增为 1
判断 i < 3，此时 i 取值是 1，条件为 true，继续循环
System.out.println(1)
i++，自增为 2
判断 i < 3，此时 i 取值是 2，条件为 true，继续循环
System.out.println(2)
i++，自增为 3
判断 i < 3，此时 i 取值是 3，条件为 false，退出循环

2. 变量的作用范围

上例中 i 的作用范围，仅在循环语句的 {} 内有效，现在要求求 1~100 的整数和，则需要把 sum 这个变量定义在 {} 外层

int sum = 0;
for (int i = 1; i <= 100; i++) {
    sum += i;
}
System.out.println(sum);

这里能否这样写

for (int i = 1; i <= 100; i++) {
    int sum = 0;
    sum += i;
}
System.out.println(sum);

不行，变量有它们各自的作用范围，从变量的定义开始，找到包围它的，右 } 括号为止。

在它上面用它
在右括号外用它

3. 练习 - 贷款计算详情

现在需要计算每月偿还的利息、偿还的本金、剩余的本金

例如，借款 1000 元，利息 100%，两月还清，根据公式计算出来每月还款 1333.33

月份	本月还款	偿还本金	偿还利息	剩余本金
1	1333.33	333.33	1000.00	666.67
2	1333.33	666.67	666.67	0
总额	2666.67	1000.00	1666.67

可以看到

$偿还利息 = 剩余本金 * 月利率$
$偿还本金 = 每月还款 - 偿还利息$

房贷计算器改写如下

public static void main(String[] args) {

    Scanner scanner = new Scanner(System.in);
    System.out.println("请输入贷款本金 p");
    double p = scanner.nextDouble();
    if (p <= 0.0) {
        System.out.println("贷款金额必须大于0");
        return;
    }
    System.out.println("请输入年利率 r%");
    double yr = scanner.nextDouble();
    if (yr < 1.0 || yr > 36.0) {
        System.out.println("年利率范围在 1% ~ 36% 之间");
        return;
    }
    double mr = yr / 100.0 / 12.0;
    System.out.println("请输入贷款月数 m");
    int m = scanner.nextInt();
    if (m < 1 || m > 360) {
        System.out.println("贷款月数范围在 1 ~ 360 之间");
        return;
    }
    double payment = p * mr * Math.pow((1 + mr), m) / (Math.pow((1 + mr), m) - 1);
    System.out.println(NumberFormat.getCurrencyInstance().format(payment));

    double totalInterest = 0.0;                 // 总利息
    for (int i = 1; i <= m; i++) {
        double interest = p * mr;               // 每月偿还利息
        double principal = payment - interest;  // 每月偿还本金
        p -= principal;                         // 剩余本金
        totalInterest += interest;
        System.out.print(i);
        System.out.print("\t本月还款:" + 
                         NumberFormat.getCurrencyInstance().format(payment));
        System.out.print("\t偿还本金:" + 
                         NumberFormat.getCurrencyInstance().format(principal));
        System.out.print("\t偿还利息:" + 
                         NumberFormat.getCurrencyInstance().format(interest));
        System.out.println("\t剩余本金:" + NumberFormat.getCurrencyInstance().format(p));
    }
    System.out.print("总还款额:" + 
                     NumberFormat.getCurrencyInstance().format(payment * m));
    System.out.println("\t总利息:" + 
                       NumberFormat.getCurrencyInstance().format(totalInterest));
}

五. 方法

将来代码多了，全部写在 main 方法里，会显得非常凌乱，难于阅读。这节课的目标是使用方法来改写前面的代码。

1. 定义方法

先来了解一下定义方法的语法

[访问修饰符] [static] 返回结果类型 方法名([参数类型1 参数名1, 参数类型2 参数名2, ...]) {
    // 方法体
    return 返回结果
}

其中用 [] 的（[] 不是语法的一部分）是可选部分
访问修饰符先省略不写，后面再讲
static 这里先写上，这个前面提过，用 static 修饰的方法不属于对象
方法执行完毕后可能会有返回结果
- 如果没有返回结果，返回值类型填写 void
- 如果有返回结果，填写实际的类型，例如
  - 返回整数，填写 int
  - 返回小数，填写 double
方法名随便起，但应当做到望文生义
参数是方法执行时需要传入的数据，可以有零到多个，格式为【参数类型参数名】，多个参数之间用逗号分隔
{} 内写方法的具体代码
最后 return 用来结束方法的运行，如果方法有返回结果，也需要配合 return 把结果传递给调用者

例如，想计算一下两个整数的和

class Test {
    static int add(int a, int b) {
        return a + b;
    }
}

2. 调用方法

回忆一下 Math.pow(2.0, 2) 就是一个由 java 提供好的 static 方法，它怎么用呢，Math 是类名，pow 是方法名，括号内是参数，对于我们自己写的 static 方法，用法是类似的：

类名.方法名([参数值1, 参数值2, ...])

即

Test.add(100,200);

怎么拿到返回结果呢？

int c = Test.add(100,200);

如果是调用本类 static 方法，可以省略前面的类名

3. 方法的意义

学完了方法的定义、调用流程，再来看看方法的意义

方法的一个意义在于隐藏实现细节：

例如，对于前面例子中的【等额本息】方式计算房贷，如果没有方法，那就要求编程者必须非常清楚计算公式

double payment = p * mr * Math.pow((1 + mr), m) / (Math.pow((1 + mr), m) - 1);

假设有一位资深程序员（例如你）提供了计算房贷方法，那么编程者就只需要知道：

计算等额本金还款，需要一个名字叫calculate的方法

它需要三个参数，… ，至于具体的计算过程，被隐藏在了方法内部

double payment = calculate(p, mr, m);

p 贷款本金
mr 月利率
m 贷款月数

对于使用它的小白程序员来讲，无需了解它的实现细节，直接拿来用就可以了。小白程序员是站在你的肩膀上编程

方法的另一个意义在于减少重复代码、提高代码的可维护性：

对比以下代码，第一段是没用方法，如果有一处写错了，所有重复的地方都得修改

double p1 = p * mr * Math.pow((1 + mr), m) / (Math.pow((1 + mr), m) - 1);
double p2 = p * mr * Math.pow((1 + mr), m) / (Math.pow((1 + mr), m) - 1);
double p3 = p * mr * Math.pow((1 + mr), m) / (Math.pow((1 + mr), m) - 1);

用了方法，万一写错，只需要一个地方的代码需要修改

static double calculate(double p, double mr, int m) {
    return p * mr * Math.pow((1 + mr), m) / (Math.pow((1 + mr), m) - 1);
}

4. 练习 - 贷款计算 - 方法改写

public class Calculator3 {
    public static void main(String[] args) {
        double p = inputAndCheckP();
        double mr = inputAndCheckMr();
        int m = inputAndCheckM();
        double payment = Calculator3.calculate(p, mr, m);
        printDetails(p, mr, m, payment);
    }

    static double inputAndCheckP() {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入本金");
        double p = scanner.nextDouble();
        if(p <= 0) {
//            System.out.println("贷款金额必须 > 0");
            // throw new 异常类型("提示信息")
            throw new IllegalArgumentException("贷款金额必须 > 0");
        }
        return p;
    }

    static double inputAndCheckMr() {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入年利率");
        double yr = scanner.nextDouble();
        if(yr < 1.0 || yr > 36.0) {
            throw new IllegalArgumentException("年利率必须是 1 ~ 36");
        }
        return yr / 12.0 / 100;
    }

    static int inputAndCheckM() {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入还款月数");
        int m = scanner.nextInt();
        if(m < 1 || m > 360) {
            throw new IllegalArgumentException("贷款月数必须是 1 ~ 360");
        }
        return m;
    }

    static void printDetails(double p, double mr, int m, double payment) {
        for (int i = 0; i < m; i++) {
            double payInterest = p * mr;                    // 偿还利息
            double payPrincipal = payment - payInterest;    // 偿还本金
            p -= payPrincipal;                              // 剩余本金
            System.out.print ("月份:" + (i + 1));
            System.out.print("\t本月还款:" + NumberFormat.getCurrencyInstance().format(payment));
            System.out.print("\t偿还本金:" + NumberFormat.getCurrencyInstance().format(payPrincipal));
            System.out.print("\t偿还利息:" + NumberFormat.getCurrencyInstance().format(payInterest));
            System.out.println("\t剩余本金:" + NumberFormat.getCurrencyInstance().format(p));
        }
        System.out.println("总还款额:" + NumberFormat.getCurrencyInstance().format(payment * m));
    }


    /**
     * 以等额本息方式计算每月还款金额
     * @param p 本金
     * @param mr 月利率
     * @param m 还款月数
     * @return 每月还款金额
     */
    static double calculate(double p, double mr, int m) {
        double pow = Math.pow(1 + mr, m);
        return p * mr * pow / (pow - 1);
    }
}

说明1

大家抽取方法时有一个原则，就是把一组完整功能，所对应的多行代码抽取为一个方法，这里我们把计算还款总额和计算还款详情，分别抽取了两个方法

calculate
printDetails

抽取时，要点如下

方法名要见文知义
返回值不着急写，看看方法的外部需不需要用到这个方法内的变量
- 需要，返回值定义为结果类型
- 不需要，返回值定义为 void
参数也不着急写，看方法内缺哪些变量定义，以它们为方法参数

说明2

对于 calculate 这种比较重要的方法定义，最好给它加一个文档，你得告诉将来这个方法的使用者，怎么用这个方法，每个参数是什么意思。

先写斜杠两个星号的开始，不用着急写它的结束，直接一回车。idea 就会自动生成一段 javadoc 文档，你可以在这里介绍方法的作用

在 @param 这里对每个参数进行说明
在 @return 这里对返回值进行说明。

说明3

如果在某些验证不通过，想让剩余代码不要运行，可以利用 throw 语法

return 这种语法叫正常返回，也就是当方法调用后，代码还会继续运行
还有就是这种throw 语法，它称为异常返回，如果没有额外处理，代码从方法调用后就中断运行

六. package 与 jar

1. package

随着我们写的类越来越多，把他们都放在一块儿来管理，感觉比较的不规范，因此，我们要引入一个新的package语法，对源文件进行一个更好的管理。

其实这个package说白了就是Java中一种目录结构

|- 包1
    |- 从属于包1 的类
|- 包2
    |- 从属于包2 的类

语法：

package 包名; // 告诉下面的类从属于此包

class 类 {
    
}

包的命名一般都是域名的倒置，如

baidu.com 域名的倒置就是 com.baidu
bilibilicom 域名的倒置就是 com.bilibili

2. import

与 package 关系非常密切的一个语法：import，如果你的类想使用另外一个类，而两个类不同包，这时就必须用 import，把另一个类导入进来才能使用

package com.itheima.a;

import java.util.Scanner;

class Calulator {
    public static void main(String[] args) {
        // 要用到 Scanner, 这时就用用到上面的 import 语句
    }
}