Java入门（二）
Java入门（二）
- Java中的运算符
-
- 1.算术运算符
-
- 基本四则运算符+ - * / %
- 增量赋值运算符 += -= *= /= %=
- 自增/自减运算符 ++ --
- 2.关系运算符
- 3.逻辑运算符
-
- 逻辑与 &&
- 逻辑或 ||
- 逻辑非 !
- & 和 | (不推荐使用)
- 4.位运算符
-
- 按位与 &
- 按位或 |
- 按位取反 ~
- 按位异或 ^
- 5.移位运算(了解）
-
- 左移 <<
- 右移 >>
- 无符号右移 >>>
- 6.条件运算符
- 7.运算符的优先级
- 8.小结
- 典型例题
- Java中的关键字
-
- 用于定义访问权限修饰符的关键字
- 用于定义类，函数，变量修饰符的关键字
- 用于定义类与类之间关系的关键字
- 用于定义建立实例及引用实例，判断实例的关键字
- 用于异常处理的关键字
- 用于包的关键字
- 其他修饰符关键字
- 程序逻辑控制
-
- 1.顺序结构
- 2.分支结构
-
- 1.if 语句
- 2.switch 语句
- 3.循环结构
-
- 1.while 循环
- 2.break
- 3.continue
- 4.for 循环
- 5.do while 循环
Java中的运算符
1.算术运算符
基本四则运算符+ - * / %
规则比较简单，值得注意：
-
int类型/ int类型结果还是 int，需要使用 double 来计算。如图
运行结果如下：
-
0 不能作为除数
当0做除数时，会发生运行时异常（也称非受查异常）。
运行结果如下
-
% 表示取余
不仅仅可以对 int 求模，也能对 double 来求模。
运行结果如下
增量赋值运算符 += -= *= /= %=
运行结果如下
其他增量赋值运算符相类似。
自增/自减运算符 ++ –
需要注意的是前置（后置）自增/自减
前置自增/自减，如下
运行结果如下
后置自增/自减，如下
运行结果如下
我们不难发现，前置自增/自减，先进行赋值，后再进行运算；
而后置自增/自减，先进行运算，后再赋值。
与C语言不同的是如下情况
它的运行结果如下
这一点是需要我们注意的。
小结：
- 如果不取自增运算的表达式的返回值，则前置自增和后置自增没有区别。
- 如果取表达式的返回值，则前置自增的返回值是自增之后的值，后置自增的返回值是自增之前的值。
2.关系运算符
关系运算符主要有六个==、 !=、 < 、>、 <=、 >=。
注意，Java中，关系运算符的表达式返回值都是boolean类型（ true 或者 false ）。这是与C语言有所不同的。
例如：
运行结果如下
3.逻辑运算符
逻辑运算符主要有三个：&&、||、! 。
注意，逻辑运算符的操作数(操作数往往是关系运算符的结果)和返回值都是 boolean类型
逻辑与 &&
规则：两个操作数都为 true，结果为 true，否则结果为 false 。
逻辑或 ||
规则：两个操作数都为 false，结果为 false，否则结果为 true。
逻辑非 !
规则：操作数为 true，结果为 false；操作数为 false，结果为 true(这是个单目运算符，只有一个操作数)。
运行结果如下
在这里，&& 和 || 遵守短路求值的规则，对于 &&，如果左侧表达式值为 false，则表达式的整体的值一定是 false，无需计算右侧表达式。同理，对于 ||，如果左侧表达式值为 true，则表达式的整体的值一定是 true，无需计算右侧表达式。
& 和 | (不推荐使用)
& 和 | 如果操作数为 boolean 的时候，也表示逻辑运算，但是和 && 以及 || 相比，它们不支持短路求值。
4.位运算符
Java 中对数据的操作的最小单位不是字节，而是二进制位。位运算符主要有四个： & 、 | 、 ~ 、 ^
按位与 &
如果两个二进制位都是 1，则结果为 1，否则结果为 0 。
按位或 |
如果两个二进制位都是 0，则结果为 0，否则结果为 1 。
运行结果如下
其原因如下图所示
按位取反 ~
如果该位为 0 则转为 1，如果该位为 1 则转为 0 。
运行结果如下
分析如下图
注意：
- 0x 前缀的数字为 十六进制 数字。十六进制可以看成是二进制的简化表示方式。一个十六进制数字对应 4 个二进制位。
- 0xf 表示 10 进制的 15，也就是二进制的 1111。
- printf 能够格式化输出内容，%x 表示按照十六进制输出。
- \n 表示换行符。
按位异或 ^
如果两个数字的二进制位相同，则结果为 0，相异则结果为 1。
运行结果如下
其原因是，1的二进制表示为 0 1，2的二进制表示为 1 0。进行按位异或^运算，其结果二进制表示为 1 1 ，按照十六进制输出为3。
5.移位运算(了解）
移位运算符有三个： << 、 >> 、 >>> 。它们都是按照二进制位来运算的。
左移 <<
最左侧位不要了，最右侧补 0 。
右移 >>
最右侧位不要了，最左侧补符号位(正数补0，负数补1)。
无符号右移 >>>
最右侧位不要了, 最左侧补 0 。
运行结果如下
原因如下
注意:
- 左移 1 位，相当于原数字×2。左移 N 位，相当于原数字×2 的N次方。
- 右移 1 位，相当于原数字÷2。右移 N 位，相当于原数字÷2 的N次方。
- 由于计算机计算移位效率高于计算乘除，当某个代码正好乘除 2 的N次方的时候可以用移位运算代替。
- 移动负数位或者移位位数过大都没有意义。
6.条件运算符
也叫三目运算符，只有一个：
表达式1 ? 表达式2 : 表达式3
当 表达式1 的值为 true 时，整个表达式的值为 表达式2 的值；当 表达式1 的值为 false 时，整个表达式的值为 表达式3 的值。
例如，两个数中的较大的数。
运行结果如下
这样，我们很轻松地就求取了两数中的较大值。
7.运算符的优先级
运算符之间是有优先级的，具体的规则我在这里也不赘述了，也不必记忆。只要在可能存在歧义的代码中加上括号即可。
8.小结
- % 操作再 Java 中也能针对 double 来计算。
- 需要区分清楚前置自增和后置自增之间的区别。
- 由于 Java 是强类型语言，因此对于类型检查较严格，因此像 && 之类的运算操作数必须是 boolean类型。
- 要区分清楚 & 和 | 什么时候是表示按位运算，什么时候表示逻辑运算。
整体来看，Java 的运算符的基本规则和 C 语言基本一致。
典型例题
一.交换两个整数的值。在这里为大家提供三种方法。
方法一，使用中间变量。这也是最普遍的方法。
public class TestDemo {
public static void main(String[] args) {
int a = 10;
int b = 20;
int temp = a;//引入中间变量
a = b;
b = temp;
System.out.println(a);
System.out.println(b);
}
}
方法二，使用加法原理，但是不足之处是数据可能会溢出
public class TestDemo {
public static void main(String[] args) {
int a = 10;
int b = 20;
a = a + b;//交换两个数字，加法原理，不足是可能会溢出
b = a - b;
a = a - b;
System.out.println(a);
System.out.println(b);
}
}
方法三，使用异或（^）位运算符
public class TestDemo {
public static void main(String[] args) {
int a = 10;
int b = 20;
a = a^b;//交换两个数字，不使用中间变量,且不会溢出
b = a^b;
a = a^b;
System.out.println(a);
System.out.println(b);
}
}
二.给定三个 int 变量，求其中的最大值和最小值。
上代码
public class TestDemo {
public static void main(String[] args) {
int a = 10;
int b = 20;
int c = 30；
int max = a > b ? a : b;// 求两个整数的最大值
max = max > c ? max :c;
int min = a < b ? a : b;// 求两个整数的最小值
min = min < c ? min : c;
System.out.println(max);
System.out.println(min);
}
}
就是如此之简单。
Java中的关键字
用于定义访问权限修饰符的关键字
private 、protected 、public 。
用于定义类，函数，变量修饰符的关键字
abstract 、final 、static 、synchronized 。
用于定义类与类之间关系的关键字
extends 、 implements 。
用于定义建立实例及引用实例，判断实例的关键字
new 、this 、 super 、 instanceof 。
用于异常处理的关键字
try 、 catch 、 finally 、 throw 、 throws 。
用于包的关键字
package 、 import 。
其他修饰符关键字
native 、 strictfp 、transient 、 volatile 、 assert 。
随着Java学习的不断深入，会逐渐地总结到以上关键字。
程序逻辑控制
1.顺序结构
顺序结构比较简单。就像我们之前写过的代码就是顺序结构的，按照代码书写的顺序一行一行执行。
System.out.println("111");
System.out.println("222");
System.out.println("333");
它的运行结果就为
111
222
333
2.分支结构
1.if 语句
基本语法形式1
if(布尔表达式){
//条件满足时执行代码
}
基本语法形式2
if(布尔表达式){
//条件满足时执行代码
}else{
//条件不满足时执行代码
}
基本语法形式3 多分支的情况
if(布尔表达式){
//条件满足时执行代码
}else if(布尔表达式){
//条件满足时执行代码
}else{
//条件都不满足时执行代码
}
注意，悬垂else问题
if / else 语句中可以不加大括号，但是也可以写语句(只能写一条语句). 此时 else 是和最接近的 if 匹配（也就是就近原则），但是实际开发中不建议这么写，最好加上大括号。
三个常见编程题（多分支）
1.判断一个整型数字是奇数还是偶数
public class TestDemo {
public static void main(String[] args) {
int num = 10;//判断一个数字是奇数还是偶数
if (num % 2 == 0) {
System.out.println("num 是偶数");
} else {
System.out.println("num 是奇数");
}
}
}
2.判定一个数字是正数还是负数
public class TestDemo {
public static void main(String[] args) {
int num = 10;
if (num > 0) {
System.out.println("num 是正数");
} else if (num < 0) {
System.out.println("num 是负数");
} else {
System.out.println("num 是 0");
}
}
}
3.判断一个年份是否为闰年。
public class TestDemo {
public static void main(String[] args) {
int year = 2021;
if (year % 100 == 0) {
// 判定世纪闰年
if (year % 400 == 0) {
System.out.println("是闰年");
} else {
System.out.println("不是闰年");
}
} else {
// 普通闰年
if (year % 4 == 0) {
System.out.println("是闰年");
}else {
System.out.println("不是闰年");
}
}
}
}
由运行结果可知，2021年不是闰年。
2.switch 语句
基本语法
switch(整数|枚举|字符|字符串){
case 内容1 : {
内容满足时执行语句;
[break;]
}
case 内容2 : {
内容满足时执行语句;
[break;]
}
...
default:{
内容都不满足时执行语句;
[break;]
}
}
根据 switch 中值的不同，会执行对应的 case 语句，遇到 break 就会结束该 case 语句。如果 switch 中的值没有匹配的 case，就会执行 default 中的语句。建议一个 switch 语句最好都要带上 default 语句。
3.循环结构
1.while 循环
基本语法格式:
while(循环条件){
循环语句;
}
循环条件为 true，则执行循环语句；否则结束循环。
注意事项
- 和 if 类似, while 下面的语句可以不写 { } ，但是不写的时候只能支持一条语句。建议还是加上 { }。
- 和 if 类似，while 后面的 { 建议和 while 写在同一行。
- 和 if 类似，while 后面不要多写分号，否则会导致循环不能正确执行。
例，计算1！+2！+3！+4！+5！
public class TestDemo {
public static void main(String[] args) {
int num = 1;
int sum = 0;
// 外层循环负责求阶乘的和
while (num <= 5) {
int factorResult = 1;
int tmp = 1;
// 内层循环负责完成求阶乘的细节
while (tmp <= num) {
factorResult *= tmp;
tmp++;
}
sum += factorResult;
num++;
}
System.out.println("sum= " + sum);
}
}
2.break
break 的功能是让循环提前结束。也就是跳出循环。
3.continue
continue 的功能是跳过这次循环，立即进入下次循环。
4.for 循环
基本语法
for(表达式1;表达式2;表达式3){
循环体;
}
表达式1: 用于初始化循环变量。
表达式2: 循环条件。
表达式3: 更新循环变量。
与 while 循环相比，for 循环将这三个部分合并在一起, 写代码时不容易遗漏。
5.do while 循环
基本语法
do{
循环语句;
}while(循环条件);
这个循环，最大的不同就是先执行循环语句，然后再判定循环条件。
到这里，Java入门（二）基本结束了，下面为大家提供一个通过Java编程实现的小游戏。猜数字游戏。
import java.util.Random;
import java.util.Scanner;;
public class TestDemo {
public static void main(String[] args) {
Random random = new Random(); // 默认随机种子是系统时间
Scanner sc = new Scanner(System.in);
int toGuess = random.nextInt(100);
// System.out.println("toGuess: " + toGuess);
while (true) {
System.out.println("请输入要输入的数字: (1-100)");
int num = sc.nextInt();
if (num < toGuess) {
System.out.println("小了");
} else if (num > toGuess) {
System.out.println("大了");
} else {
System.out.println("恭喜回答正确");
break;
}
}
sc.close();
}
}
铁汁们，我们下期见。