一. 输入输出
- 输入的作用,就是由使用者告诉程序要操作的数据
- 例如,我要通过饿了么订餐,你得告诉程序你要吃什么,送货地址是什么吧
- 输出的作用,就是由程序向使用者展现执行的结果
- 还是订餐的例子,程序向你展示骑手接单没有,送到哪里了
- 将来输入输出来源会有多种,比如 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 ) [-2^7,2^7) [−27,27) 即 [ − 128 , 128 ) [-128,128) [−128,128) | |
short | 整数类型,用2个字节表示 | [ − 2 15 , 2 15 ) [-2^{15},2^{15}) [−215,215) | |
int | 整数类型,用4个字节表示 | [ − 2 31 , 2 31 ) [-2^{31},2^{31}) [−231,231) | |
long | 整数类型,用8个字节表示 | [ − 2 63 , 2 63 ) [-2^{63},2^{63}) [−263,263) | L |
float | 浮点小数,用4个字节表示 | [ − 1.9999999 ∗ 2 127 , 1.9999999 ∗ 2 127 ] [-1.9999999 * 2^{127},1.9999999 * 2^{127}] [−1.9999999∗2127,1.9999999∗2127] | F |
double | 浮点小数,用8个字节表示 | [ − 1.9999999 ∗ 2 1023 , 1.9999999 ∗ 2 1023 ] [-1.9999999 * 2^{1023},1.9999999 * 2^{1023}] [−1.9999999∗21023,1.9999999∗21023] | D |
-
[]
包含等于,()
不包含等于 -
类型后缀
- 不区分大小写,但建议用大写,因为小写的 L 与 1 容易混淆
- 尾符号 D 可以省略
-
float 和 double 精度不同,即小数点后的位数
- float 的精度二进制是 23,换算成十进制是 6~7
- double 的精度二进制是 52,换算成十进制是 15~16
字符类型
类型名 | 说明 | 范围 |
---|---|---|
char | 字符类型,配合单引号 | [ 0 , 2 16 ) [0,2^{16}) [0,216) 即 [ 0 , 65536 ) [0, 65536) [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 * r * (1 + r)^m / ((1 + r)^m - 1) 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 语句
}
}
- 有一种特殊情况不需要 import 导入,即 java.lang 包下的类使用时,都不需要 import
3. jar
代码写完了,我们最终要发布成品吧,那是把源文件直接给使用者吗?显然不是吧。最终交给 jvm 运行的是 class 类文件,我们会把这多个 class 类文件打成一个压缩包,交付给用户。
用 idea 可以方便地打包
步骤1:创建工件(artifact)
步骤2:构建工件
文章来源:https://www.toymoban.com/news/detail-797557.html
步骤3:运行 jar 包,需要客户电脑上安装好 jdk文章来源地址https://www.toymoban.com/news/detail-797557.html
java -jar jar包文件名
到了这里,关于基础篇_开发命令行程序(输入输出,类型、变量、运算符,条件语句,循环语句,方法,package与jar)的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!