1.
运算符:
int
a
;
int
b
,
c
,
d
,
e
;
int
a
=
250
;
int
a
;
a
=
250
;
int
b
=
a
+
10
;
System
.
out
.
println
(
b
);
a
=
a
+
10
;
//
在
a
本身基础之上增
10
short
s1
=
5
;
short
s2
=
6
;
short
s3
=
(
short
)(
s1
+
s2
);
算术:
+
、
-
、
*
、
/
、
%
、
++
、
--
%:
取模
/
取余,余数为
0
即为整除
System
.
out
.
println
(
5
%
2
);
//1
,商
2
余
1
System
.
out
.
println
(
8
%
2
);
//0
,商
4
余
0----
整除
System
.
out
.
println
(
2
%
8
);
//2
,商
0
余
2
++/--:
自增
1/
自减
1
,可在变量前也可在变量后
单独使用时,在前在后都一样
被使用时,在前在后不一样
a++
的值为
a----------(a--
的值为
a)
++a
的值为
a+1--------(--a
的值为
a-1)
//
演示
++
单独使用
int a
=
5
,
b
=
5
;
a
++
;
//
相当于
a=a+1
++
b
;
//
相当于
b=b+1
System
.
out
.
println
(
a
);
//6
System
.
out
.
println
(
b
);
//6
//
演示
++
被使用
int a
=
5
,
b
=
5
;
int c
=
a
++
;
//1)
将
a++
的值
5
赋值给
c 2)a
自增
1
变为
6
//----a++
的值为
a(5)
,所以
c
的值就是
5
int d
= ++
b
;
//1)
将
++b
的值
6
赋值给
d 2)b
自增
1
变为
6
//++b
的值为
b+1(6)
,所以
d
的值就是
6
System
.
out
.
println
(
a
);
//6
System
.
out
.
println
(
b
);
//6
System
.
out
.
println
(
c
);
//5
System
.
out
.
println
(
d
);
//6
//
演示
--
单独使用
:
int a
=
5
,
b
=
5
;
a
--
;
--
b
;
System
.
out
.
println
(
a
);
//4
System
.
out
.
println
(
b
);
//4
//
演示
--
被使用
:
int a
=
5
,
b
=
5
;
int c
=
a
--
;
//1)
将
a--
的值
5
赋值给
c 2)a
自减
1
变为
4
int d
= --
b
;
//1)
将
--b
的值
4
赋值给
d 2)b
自减
1
变为
4
System
.
out
.
println
(
a
);
//4
System
.
out
.
println
(
b
);
//4
System
.
out
.
println
(
c
);
//5
System
.
out
.
println
(
d
);
//4
关系:
>
、
<
、
>=
、
<=
、
==
、
!=
1
)
>
(
大于
)
、
<
(
小于
)
>=
(
大于或等于
)
、
<=
(
小于或等于
)
==
(
等于
)
、
!=
(
不等于
)
2
)
关系运算的结果为
boolean
型,
关系成立则为
true
,关系不成立则为
false
int
a
=
5
,
b
=
10
,
c
=
5
;
boolean
b1
=
a
>
b
;
System
.
out
.
println
(
b1
);
//false
System
.
out
.
println
(
c
<
b
);
//true
System
.
out
.
println
(
a
>=
c
);
//true
System
.
out
.
println
(
a
<=
b
);
//true
System
.
out
.
println
(
a
==
c
);
//true
System
.
out
.
println
(
a
!=
c
);
//false
System
.
out
.
println
(
a
+
c
>
10
);
//false
System
.
out
.
println
(
a
%
2
==
0
);
//false
System
.
out
.
println
(
a
++>
5
);
//false--------a
自增
1
变为
6
System
.
out
.
println
(
a
++>
5
);
//true---------a
自增
1
变为
7
逻辑:
&&
、
||
、
!
逻辑运算是建立在关系运算的基础之上的
逻辑运算的结果也是
boolean
型
&&:
短路与
(
并且
)
,两边都为真则为真,见
false
则
false
int
a
=
5
,
b
=
10
,
c
=
5
;
boolean
b1
=
b
>=
a
&&
b
<
c
;
System
.
out
.
println
(
b1
);
//true&&false=false
System
.
out
.
println
(
b
<=
c
&&
b
>
a
);
//false&&true=false
System
.
out
.
println
(
a
==
b
&&
c
>
b
);
//false&&false=false
System
.
out
.
println
(
b
!=
c
&&
a
<
b
);
//true&&true=true
//
演示短路
boolean
b1
=
a
>
b
&&
c
++>
2
;
System
.
out
.
println
(
b1
);
//false
System
.
out
.
println
(
c
);
//5
,发生短路了
||:
短路或
(
或者
)
,有真则为真,见
true
则
true
int
a
=
5
,
b
=
10
,
c
=
5
;
System
.
out
.
println
(
b
>=
a
||
b
<
c
);
//true||false=true
System
.
out
.
println
(
b
<=
c
||
b
>
a
);
//false||true=true
System
.
out
.
println
(
b
!=
c
||
a
<
b
);
//true||true=true
System
.
out
.
println
(
a
==
b
||
c
>
b
);
//false||false=false
//
演示短路
boolean
b2
=
a
<
b
||
c
++>
2
;
System
.
out
.
println
(
b2
);
//true
System
.
out
.
println
(
c
);
//5
,发生短路了
!:
逻辑非
(
取反
)
,非真则假,非假则真
int
a
=
5
,
b
=
10
,
c
=
5
;
boolean
b2
= !
(
a
<
b
);
System
.
out
.
println
(
b2
);
//!true=false
System
.
out
.
println
(
!
(
a
>
b
));
//!false=true
赋值:
=
、
+=
、
-=
、
*=
、
/=
、
%=
简单赋值运算符:
=
扩展赋值运算符:
+=
、
-=
、
*=
、
/=
、
%=
---
注意
:
扩展赋值运算符自带强转功能
int
a
=
5
;
a
+=
10
;
//
相当于
a=(int)(a+10)
System
.
out
.
println
(
a
);
//15
a
*=
2
;
//
相当于
a=(int)(a*2)
System
.
out
.
println
(
a
);
//30
a
/=
6
;
//
相当于
a=(int)(a/6)
System
.
out
.
println
(
a
);
//5
//
小面试题
:
short
s
=
5
;
//s = s+10; //
编译错误,需强转
: s=(short)(s+10);
s
+=
10
;
//
相当于
: s=(short)(s+10);
字符串连接:
+
若两边为数字,则做加法运算
若两边出现了字符串,则做字符串连接
任意类型的数据只要和字符串连,结果都会变为字符串类型
---
同化作用
int
age
=
38
;
System
.
out
.
println
(
"age="
);
//age=
System
.
out
.
println
(
age
);
//38
System
.
out
.
println
(
"age="
+
age
);
//age=38
System
.
out
.
println
(
"
我的年龄是
"
+
age
);
//
我的年龄是
38
System
.
out
.
println
(
"
我今年
"
+
age
+
"
岁了
"
);
//
我今年
38
岁了
String
name
=
"WKJ"
;
System
.
out
.
println
(
"name="
+
name
);
//name=WKJ
System
.
out
.
println
(
"
大家好,我叫
"
+
name
);
//
大家好,我叫
WKJ
System
.
out
.
println
(
"
大家好,我叫
"
+
name
+
"
,今年
"
+
age
+
"
岁了
"
);
//
大家好,我
叫
WKJ
,今年
38
岁了
System
.
out
.
println
(
10
+
20
+
""
+
30
);
//3030--------String
System
.
out
.
println
(
""
+
10
+
20
+
30
);
//102030------String
System
.
out
.
println
(
10
+
20
+
30
+
""
);
//60----------String
条件
/
三目:
语法:
boolean?
数
1:
数
2
执行过程:
整个表达式是有值的,它的值要么是问号后的数
1
,要么是冒号后的数
2
判断
boolean
的值
:
若为
true
,则整个表达式的结果为
?
号后的数
1
若为
false
,则整个表达式的结果为
:
号后的数
2
int
num
=
0
;
int
flag
=
num
>
0
?
1
:
-
1
;
System
.
out
.
println
(
flag
);
//-1
int
a
=
8
,
b
=
55
;
int
max
=
a
>
b
?
a
:
b
;
System
.
out
.
println
(
"max="
+
max
);
2.
分支结构:基于条件执行的语句
if
结构:
1
条路
1
)
语法
:
if
(
boolean
){
语句块
-------------
基于条件执行的语句
}
2
)
执行过程
:
判断
boolean
的值
:
若为
true
,则执行语句块
(
整个结束
)
若为
false
,则直接结束
//1)
偶数的判断
:
int
num
=
6
;
if
(
num
%
2
==
0
){
//
带数
(6,5)
System
.
out
.
println
(
num
+
"
是偶数
"
);
}
System
.
out
.
println
(
"
继续执行
..."
);
//1)
满
500
打
8
折
double
price
=
300.0
;
//
消费金额
if
(
price
>=
500
){
//
满
500
带数
(600.0,300.0)
price
=
price
*
0.8
;
//
打
8
折
}
System
.
out
.
println
(
"
最终结算金额为
:"
+
price
);
if...else
结构:
2
条路
1
)
语法
:
if
(
boolean
){
语句块
1
}
else
{
语句块
2
}
2
)
执行过程
:
判断
boolean
的值
:
若为
true
,则执行语句块
1
(
整个结束
)
若为
false
,则执行语句块
2
(
整个结束
)
3
)
说明
:
语句块
1
和语句块
2
,必走其中之一
----------
2
选
1
//1)
偶数、奇数的判断
:
int
num
=
5
;
//
带数
(6,5)
补充:
1.
任何复杂的程序逻辑都可以通过三种结构来实现:
顺序结构:从上往下逐行执行,每句必走
分支结构:有条件的执行某语句,并非每句必走
1. Scanner
接收用户输入的数据:共
3
步
-----------
不需要理解,先记住它,面向对象第五天才能理解
package
day04
;
import
java
.
util
.
Scanner
;
//1.
导入扫描仪
//Scanner
的演示
public class
ScannerDemo
{
public static
void
main
(
String
[]
args
) {
Scanner scan
=
new
Scanner
(
System
.
in
);
//2.
新建一个扫描仪叫
scan
System
.
out
.
println
(
"
请输入年龄
:"
);
int
age
=
scan
.
nextInt
();
//3.
用扫描仪扫描一个整数赋值给
age
System
.
out
.
println
(
"
请输入商品价格
:"
);
double
price
=
scan
.
nextDouble
();
//3.
用扫描仪扫描一个小数赋值给
price
System
.
out
.
println
(
"
年龄为
:"
+
age
+
"
,商品价格为
:"
+
price
);
}
}
2.
分支结构:
if...else if
结构:多条路
1
)
语法
:
if
(
boolean
-
1
){
语句块
1
}
else if
(
boolean
-
2
){
语句块
2
}
else if
(
boolean
-
3
){
语句块
3
}
else
{
语句块
4
}
2
)
执行过程
:
判断
boolean
-
1
,若为
true
则执行语句块
1
(
结束
)
,若为
false
则
再判断
boolean
-
2
,若为
true
则执行语句块
2
(
结束
)
,若为
false
则
再判断
boolean
-
3
,若为
true
则执行语句块
3
(
结束
)
,若为
false
则执行语句块
4
(
结束
)
3
)
说明
:
语句块
1
/
2
/
3
/
4
,必走其中之一
-------
多选
1
package
day04
;
import
java
.
util
.
Scanner
;
//
成绩等级判断
public class
ScoreLevel
{
public static
void
main
(
String
[]
args
) {
Scanner scan
=
new
Scanner
(
System
.
in
);
System
.
out
.
println
(
"
请输入成绩
:"
);
double
score
=
scan
.
nextDouble
();
//
带数
(888,-45,95,85,65,40)
if
(
score
<
0
||
score
>
100
){
System
.
out
.
println
(
"
成绩不合法
"
);
}
else if
(
score
>=
90
){
//
成绩合法
System
.
out
.
println
(
"A-
优秀
"
);
}
else if
(
score
>=
80
){
System
.
out
.
println
(
"B-
良好
"
);
}
else if
(
score
>=
60
){
System
.
out
.
println
(
"C-
中等
"
);
}
else
{
System
.
out
.
println
(
"D-
不及格
"
);
}
}
}
switch...case
结构:
优点:效率高、结构清晰
缺点:只能对整数判断相等
break
:跳出
switch
面试题:
switch
后数据的类型可以为:
byte,short,char,int,String,
枚举类型
package
day04
;
import
java
.
util
.
Scanner
;
//
命令解析程序
public class
CommandBySwitch
{
public static
void
main
(
String
[]
args
) {
Scanner scan
=
new
Scanner
(
System
.
in
);
System
.
out
.
println
(
"
请选择功能
: 1.
存款
2.
取款
3.
查询余额
4.
退卡
"
);
int
command
=
scan
.
nextInt
();
switch
(
command
){
case
1
:
System
.
out
.
println
(
"
存款操作
..."
);
break
;
case
2
:
System
.
out
.
println
(
"
取款操作
..."
);
break
;
case
3
:
System
.
out
.
println
(
"
查询余额操作
..."
);
break
;
case
4
:
System
.
out
.
println
(
"
退卡操作
..."
);
break
;
default
:
System
.
out
.
println
(
"
输入错误
"
);
}
}
}
3.
循环:反复多次执行一段相同或相似的代码
4.
循环三要素:
循环变量的初始化
循环的条件
(
以循环变量为基础
)
循环变量的改变
(
向着循环的结束变
)
循环变量:在整个循环过程中所反复改变的那个数
案例一:
输出
5
次
"
行动是成功的阶梯
"
行动是成功的阶梯
行动是成功的阶梯
行动是成功的阶梯
行动是成功的阶梯
行动是成功的阶梯
循环变量
:
次数
times
1
)
int
times
=
0
;
2
)
times
<
5
3
)
times
++
;
times
=
0
/
1
/
2
/
3
/
4
/
5
时结束
案例二:
输出
9
的乘法表
:
1
*
9
=
9
2
*
9
=
18
3
*
9
=
27
4
*
9
=
36
5
*
9
=
45
6
*
9
=
54
7
*
9
=
63
8
*
9
=
72
9
*
9
=
81
循环变量
:
因数
num
1
)
int
num
=
1
;
2
)
num
<=
9
3
)
num
++
;
num
=
1
/
2
/
3
/
4
/
5
/
6
/
7
/
8
/
9
/
10
时结束
1
*
9
=
9
3
*
9
=
27
5
*
9
=
45
7
*
9
=
63
9
*
9
=
81
循环变量
:
因数
num
1
)
int
num
=
1
;
2
)
num
<=
9
3
)
num
+=
2
;
num
=
1
/
3
/
5
/
7
/
9
/
11
时结束
5.
循环结构:
while
结构:先判断后执行,有可能一次都不执行
1
)
语法
:
while
(
boolean
){
语句块
/
循环体
----------
反复执行的代码
}
2
)
执行过程
:
判断
boolean
的值,若为
true
则执行语句块,
再判断
boolean
的值,若为
true
则再执行语句块,
再判断
boolean
的值,若为
true
则再执行语句块,
如此反复,直到
boolean
的值为
false
时,
while
循环结束
//2)
输出
9
的乘法表
: //3*9=27
int
num
=
1
;
while
(
num
<=
9
){
System
.
out
.
println
(
num
+
"*9="
+
num
*
9
);
num
+=
2
;
//num++;
}
System
.
out
.
println
(
"
继续执行
..."
);
//1)
输出
5
次
"
行动是成功的阶梯
":
int
times
=
0
;
//1)
循环变量的初始化
while
(
times
<
5
){
//2)
循环的条件
System
.
out
.
println
(
"
行动是成功的阶梯
"
);
times
++
;
//3)
循环变量的改变
}
System
.
out
.
println
(
"
继续执行
..."
);
*/
/*
执行过程
:
times=0
true
输出
times=1
true
输出
times=2
true
输出
times=3
true
输出
times=4
true
输出
times=5
false while
循环结束
输出继续执行
...
*/
package
day04
;
import
java
.
util
.
Scanner
;
//
猜数字小游戏
public class
Guessing
{
public static
void
main
(
String
[]
args
) {
Scanner scan
=
new
Scanner
(
System
.
in
);
int
num
=
(
int
)(
Math
.
random
()
*
1000
+
1
);
//1
到
1000
之内的随机数
System
.
out
.
println
(
num
);
//
作弊
//300(
大
),200(
小
),250(
对
)
System
.
out
.
println
(
"
猜吧
!"
);
int
guess
=
scan
.
nextInt
();
//1.
while
(
guess
!=
num
){
//2.
if
(
guess
>
num
){
System
.
out
.
println
(
"
太大了
"
);
}
else
{
System
.
out
.
println
(
"
太小了
"
);
}
System
.
out
.
println
(
"
猜吧
!"
);
guess
=
scan
.
nextInt
();
//3.
}
System
.
out
.
println
(
"
恭喜你猜对了
!"
);
}
}
do...while
结构:先执行后判断,至少执行一次
当第
1
要素与第
3
要素的代码相同时,首选
do...while
package
day04
;
import
java
.
util
.
Scanner
;
//
猜数字小游戏
public class
Guessing
{
public static
void
main
(
String
[]
args
) {
补充:
1.
任何复杂的程序逻辑都可以通过三种结构来实现:
顺序结构:从上往下逐行执行,每句必走
分支结构:有条件的执行某语句一次,并非每句必走
循环结构:有条件的执行某语句多次,并非每句必走
2.
生成随机数:
1
到
1000
3.
变量的作用域
/
范围:
从变量的声明开始,到包含它最近的大括号结束
1.
循环结构:
for
结构:应用率高、与次数相关的循环
1
)
语法
:
// 1 2 3
for
(
要素
1
;
要素
2
;
要素
3
){
语句块
/
循环体
---------------
反复执行的语句
4
}
2
)
执行过程
:
1243243243243243.
..
2
for
(
int
times
=
0
;
times
<
5
;
times
++
){
System
.
out
.
println
(
"
行动是成功的阶梯
"
);
}
//
特殊的
: for
中的循环变量
num
的作用域
---
仅在当前
for
中
for
(
int
num
=
1
;
num
<=
9
;
num
++
){
System
.
out
.
println
(
num
+
"*9="
+
num
*
9
);
}
for
(
int
num
=
1
;
num
<=
9
;
num
+=
2
){
System
.
out
.
println
(
num
+
"*9="
+
num
*
9
);
}
/*
执行过程
:
num=1 true 1*9=9
num=3 true 3*9=27
num=5 true 5*9=45
num=7 true 7*9=63
num=9 true 9*9=81
num=11 false for
循环结束
*/
//
演示
for
的特殊语法格式
:
int
num
=
1
;
for
(;
num
<=
9
;
num
++
){
System
.
out
.
println
(
num
+
"*9="
+
num
*
9
);
}
for
(
int
num
=
1
;
num
<=
9
;){
System
.
out
.
println
(
num
+
"*9="
+
num
*
9
);
num
++
;
}
for
(;;){
//
没有条件的循环就是一个死循环
System
.
out
.
println
(
"
我爱
Java"
);
}
for
(
int
i
=
1
,
j
=
5
;
i
<=
5
;
i
+=
2
,
j
-=
2
){
}
/*
i=1,j=5
i=3,j=3
i=5,j=1
i=7,j=-1
*/
//
随机加法运算器
package
day05
;
import
java
.
util
.
Scanner
;
//
随机加法运算器
public class
Addition
{
public static
void
main
(
String
[]
args
) {
Scanner scan
=
new
Scanner
(
System
.
in
);
int
score
=
0
;
//
总分
for
(
int
i
=
1
;
i
<=
10
;
i
++
){
//10
次
(1)25+65=?
int
a
=
(
int
)(
Math
.
random
()
*
100
);
//
加数
a--0
到
99
的随机数
int
b
=
(
int
)(
Math
.
random
()
*
100
);
//
加数
b--0
到
99
的随机数
int
result
=
a
+
b
;
//
存正确答案
System
.
out
.
println
(
"("
+
i
+
")"
+
a
+
"+"
+
b
+
"=?"
);
//1)
出题
System
.
out
.
println
(
"
算吧
!"
);
int
answer
=
scan
.
nextInt
();
//2)
答题
if
(
answer
==-
1
){
//3)
判题
break
;
}
if
(
answer
==
result
){
System
.
out
.
println
(
"
答对了
"
);
score
+=
10
;
//
答对
1
题,加
10
分
}
else
{
System
.
out
.
println
(
"
答错了
"
);
}
}
System
.
out
.
println
(
"
总分为
:"
+
score
);
}
}
2.
三种循环结构如何选择:
先看循环是否与次数相关:
若相关
-------------------------------------
直接上
for
若无关,再看第
1
要素与第
3
相互的代码是否相同:
若相同
--------------------------------
直接上
do...while
若不同
--------------------------------
直接上
while
3. break
:跳出循环
for
(
int
num
=
1
;
num
<=
9
;
num
++
){
if
(
num
==
4
){
//
在某种特定条件下,提前结束循环
break
;
//
跳出循环
}
System
.
out
.
println
(
num
+
"*9="
+
num
*
9
);
}
/*
执行过程
:
num=1 1*9=9
num=2 2*9=18
num=3 3*9=27
num=4
*/
continue
:跳过循环体中剩余语句而进入下一次循环
//
输出
9
的乘法表,只要不能被
3
整除
for
(
int
num
=
1
;
num
<=
9
;
num
++
){
if
(
num
%
3
!=
0
){
System
.
out
.
println
(
num
+
"*9="
+
num
*
9
);
}
}
//
输出
9
的乘法表,跳过能被
3
整除的
for
(
int
num
=
1
;
num
<=
9
;
num
++
){
if
(
num
%
3
==
0
){
continue
;
//
跳过循环体中剩余语句而进入下一次循环
}
System
.
out
.
println
(
num
+
"*9="
+
num
*
9
);
}
/*
num=1 1*9=9
num=2 2*9=18
num=3
num=4 4*9=36
num=5 5*9=45
num=6
num=7 7*9=63
num=8 8*9=72
num=9
num=10 false
*/
4.
嵌套循环:
循环中套循环,常常多行多列时使用,一般外层控制行,内层控制列
执行规则:外层循环走一次,内层循环走所有次
建议:嵌套层数越少越好,能用一层就不用两层,能用两层就不用三层
break
只能跳出当前一层循环
//
九九乘法表
public class
MultiTable
{
public static
void
main
(
String
[]
args
) {
for
(
int
num
=
1
;
num
<=
9
;
num
++
){
//
控制行
for
(
int
i
=
1
;
i
<=
num
;
i
++
){
//
控制列
System
.
out
.
print
(
i
+
"*"
+
num
+
"="
+
i
*
num
+
"\t"
);
}
System
.
out
.
println
();
//
换行
}
/*
执行过程
:
num=3
i=1 1*3=3
i=2 2*3=6
i=3 3*3=9
i=4 false
换行
num=2
i=1 1*2=2
i=2 2*2=4
i=3 false
换行
num=1
i=1 1*1=1
i=2 false
换行
*/
}
}
5.
数组:
是一种数据类型
(
引用类型
)
相同数据类型元素的集合
定义:
//
声明整型数组
arr
,包含
10
个元素,每个元素都是
int
型,默认值为
0
int
[]
arr
=
new
int
[
10
];
初始化:
------------------
初始化的是数组中的元素
int
[]
arr1
=
new
int
[
3
];
//0,0,0
int
[]
arr2
=
{
2
,
5
,
8
};
//2,5,8
int
[]
arr3
=
new
int
[]{
2
,
5
,
8
};
//2,5,8
int
[]
arr4
;
//arr4 = {2,5,8}; //
编译错误,此方式只能声明同时初始化
arr4
=
new
int
[]{
2
,
5
,
8
};
//
正确
访问:
--------------
访问的是数组中的元素
通过
(
数组名
.length)
可以获取数组的长度
(
元素个数
)
通过下标
/
索引来访问数组中的元素,下标从
0
开始,最大到
(
数组的长度
-1)
遍历
/
迭代:从头到尾挨个走一遍
补充:
1.
变量的重名问题:
作用域重叠时,变量不能同名
2. \t
:水平制表位,固定占
8
位
3.
数组元素的默认值:
4.
异常:
ArrayIndexOutOfBoundsException
:数组下标越界异常
数组下标为
0
到
(
数组长度
-1)
,若超出这个范围则发生数组下标越界异常