1.运算符介绍（对应062节）
运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。主要有以下几种：
- 算术运算符
- 赋值运算符
- 关系运算符[比较运算符]
- 逻辑运算符
- 位运算符[需要二进制基础]
- 三元运算符
- 算术运算符：算术运算符是对数值类型的变量进行运算的，在Java 程序中使用的非常多。
以下是算术运算符一览
2.算术运算符的使用（对应063节）
public class ArithmeticOperator {
//编写一个main方法
public static void main(String[] args) {
// /使用
System.out.println(10 / 4); //从数学来看是2.5, java中 2
System.out.println(10.0 / 4); //java是2.5
// 注释快捷键 ctrl + /, 再次输入 ctrl + / 取消注释
double d = 10 / 4;//java中10 / 4 = 2, 2=>2.0
System.out.println(d);// 是2.0
// % 取模 ,取余
// 在 % 的本质 看一个公式!!!! a % b = a - a / b * b
// -10 % 3 => -10 - (-10) / 3 * 3 = -10 + 9 = -1
// 10 % -3 = 10 - 10 / (-3) * (-3) = 10 - 9 = 1
// -10 % -3 = (-10) - (-10) / (-3) * (-3) = -10 + 9 = -1
System.out.println(10 % 3); //1
System.out.println(-10 % 3); // -1
System.out.println(10 % -3); //1
System.out.println(-10 % -3);//-1
//++的使用
//作为独立的语句使用。前++和后++都完全等价于i=i+1
int i = 10;
i++;//自增 等价于 i = i + 1; => i = 11
++i;//自增 等价于 i = i + 1; => i = 12
System.out.println("i=" + i);//12
/*作为表达式使用时。前++：++i先自增后赋值
后++：i++先赋值后自增 */
int j = 8;
//int k = ++j; //等价 j=j+1;k=j; 最后的结果k=9,j=9
int k = j++; // 等价 k =j;j=j+1;
System.out.println("k=" + k + "j=" + j);//最后的结果k=8,j=9
}
}
注意：取模(取余)的时候，正负号和%左边的符号一致。或者用公式计算符号。
特殊的： 像-10.5%3，有小数，公式变了，加了个强转int，如下
得到结果是近似值，例如-10.4%3=-1.4（近似值），输出会是-1.4000000000004
- 细节
3.算术运算符练习题（对应064-067节）
4.关系运算符（对应068-069节）
- 介绍
- 关系运算符的结果都是boolean 型，也就是要么是true，要么是false
- 关系表达式经常用在if 结构的条件中或循环结构的条件中
- 常见关系运算符
- 注意细节
- 关系运算符的结果都是boolean 型，也就是要么是true，要么是false。
- 关系运算符组成的表达式，我们称为关系表达式。a > b
- 比较运算符"==“不能误写成”="
5.逻辑运算符（对应068-069节）
- 介绍
用于连接多个条件（多个关系表达式），最终的结果也是一个boolean 值。 - 逻辑运算符一览
分为两组学习
- 短路与&& ， 短路或||，取反!
- 逻辑与&，逻辑或|，^ 逻辑异或
说明逻辑运算规则： - a&b : & 叫逻辑与：规则：当a 和b 同时为true ,则结果为true, 否则为false
- a&&b : && 叫短路与：规则：当a 和b 同时为true ,则结果为true,否则为false
- a|b : | 叫逻辑或，规则：当a 和b ，有一个为true ,则结果为true,否则为false
- a||b : || 叫短路或，规则：当a 和b ，有一个为true ,则结果为true,否则为false
- !a : 叫取反，或者非运算。当a 为true, 则结果为false, 当a 为false 是，结果为true
- a^b: 叫逻辑异或，当a 和b 不同时，则结果为true, 否则为false
6. 短路与&& 和逻辑与& （对应071节）
- 基本规则
| 名称 | 语法 | 特点 |
|---|---|---|
| 短路与&& | 条件 1&&条件 2 | 两个条件都为 true，结果为 true,否则 false |
| 逻辑与& | 条件 1&条件 2 | 两个条件都为 true，结果为 true,否则 false |
- 代码演示
public class LogicOperator01 {
//编写一个main方法
public static void main(String[] args) {
//&&短路与 和 & 案例演示
int age = 50;
if(age > 20 && age < 90) {
System.out.println("ok100");
}
//&逻辑与使用
if(age > 20 & age < 90) {
System.out.println("ok200");
}
//区别
int a = 4;
int b = 9;
//对于&&短路与而言，如果第一个条件为false ,后面的条件不再判断
//对于&逻辑与而言，如果第一个条件为false ,后面的条件仍然会判断
if(a < 1 && ++b < 50) {
System.out.println("ok300");
}
System.out.println("a=" + a + " b=" + b);// 4 9
if(a < 1 & ++b < 50) {
System.out.println("ok300");
}
System.out.println("a=" + a + " b=" + b);// 4 10
}
}
- && 和& 使用区别
- &&短路与：如果第一个条件为false，则第二个条件不会判断，最终结果为false，效率高
- & 逻辑与：不管第一个条件是否为false，第二个条件都要判断，效率低
- 开发中， 我们使用的基本是使用短路与&&, 效率高
7.短路或|| 和逻辑或| （对应072节）
- 基本规则
| 名称 | 语法 | 特点 |
|---|---|---|
| 短路或 | 条件1短路或条件2 | 两个条件中只要有一个成立，结果为true,否则为false |
| 逻辑或 | 条件1逻辑或条件2 | 只要有一个条件成立，结果为true,否则为false |
- 代码演示
public class LogicOperator02 {
//编写一个main方法
public static void main(String[] args) {
//||短路或 和 |逻辑或 案例演示
//|| 规则: 两个条件中只要有一个成立，结果为true,否则为false
//| 规则: 两个条件中只要有一个成立，结果为true,否则为false
int age = 50;
if(age > 20 || age < 30) {
System.out.println("ok100");
}
//&逻辑与使用
if(age > 20 | age < 30) {
System.out.println("ok200");
}
//看看区别
//(1)||短路或：如果第一个条件为true，
//则第二个条件不会判断，最终结果为true，效率高
//(2)| 逻辑或：不管第一个条件是否为true，第二个条件都要判断，效率低
int a = 4;
int b = 9;
if( a > 1 || ++b > 4) { // 可以换成 | 测试，最后输出a=4 b=10
System.out.println("ok300");
}
System.out.println("a=" + a + " b=" + b); //4 9
}
}
- || 和| 使用区别
- ||短路或：如果第一个条件为true，则第二个条件不会判断，最终结果为true，效率高
- | 逻辑或：不管第一个条件是否为true，第二个条件都要判断，效率低
- 开发中，我们基本使用||
8.取反和逻辑异或^ （对应073节）
- 取反基本规则
| 名称 | 语法 | 特点 |
|---|---|---|
| ! 非（取反） | !条件 | 如果条件本身成立，结果为false，否则为true |
- 逻辑异或^
a^b: 叫逻辑异或，当a 和b 不同时，则结果为true, 否则为false
^逻辑异或，System.out.println( (4 < 1) ^ (6 > 3) ); // True
- 代码演示
public class InverseOperator {
//编写一个main方法
public static void main(String[] args) {
//! 操作是取反 T->F , F -> T
System.out.println(60 > 20); //True
System.out.println(!(60 > 20)); //False
//a^b: 叫逻辑异或，当 a 和 b 不同时，则结果为true, 否则为false
boolean b = (10 > 1) ^ ( 3 > 5);
System.out.println("b=" + b);//T
//或者写成 System.out.println((10 > 1) ^ ( 3 > 5));//T
}
}
9.逻辑运算练习题（对应074节）
-
练习题1 请写出每题的输出结果
解析：x++先比较先赋值，再自增 -
练习题2 请写输出结果
注意：第4行y=true，是赋值，不是判断
10.赋值运算符（对应076节）
- 介绍
赋值运算符就是将某个运算后的值，赋给指定的变量。
- 赋值运算符的分类
基本赋值运算符= int a = 10;
复合赋值运算符
+= ，-= ，*= ， /= ，%= 等, 重点讲解一个+= ，其它的使用是一个道理
a += b; [等价a = a + b; ]
a -= b; [等价a = a - b; ]
- 案例演示
- 赋值基本案例[int num1 = 10]
- += 的使用案例
- 赋值运算符特点
- 运算顺序从右往左int num = a + b + c;
- 赋值运算符的左边只能是变量,右边可以是变量、表达式、常量值
int num = 20; int num2= 78 * 34 - 10; int num3 = a; - 复合赋值运算符等价于下面的效果
比如：a+=3;等价于a=a+3; 其他类推 - 复合赋值运算符会进行类型转换。
byte b = 2; b+=3; b++;
- 代码演示
public class AssignOperator {
//编写一个main 方法
public static void main(String[] args) {
int n1 = 10;
n1 += 4;// n1 = n1 + 4;
System.out.println(n1); // 14
n1 /= 3;// n1 = n1 / 3;//4
System.out.println(n1); // 4
//复合赋值运算符会进行类型转换
byte b = 3;
b += 2; // 等价b = (byte)(b + 2);但是b=b+2不对，因为b+2会提升到int型。
b++; // b = (byte)(b+1);
}
}
11.三元运算符（对应077-079节）
- 基本语法： 条件表达式? 表达式1: 表达式2;
- 运算规则：
如果条件表达式为true，运算后的结果是表达式1；
如果条件表达式为false，运算后的结果是表达式2；
口诀: [一灯大师：一真大师] - 代码演示
public class TernaryOperator {
//编写一个main方法
public static void main(String[] args) {
int a = 10;
int b = 99;
// 解读
// 1. a > b 为 false
// 2. 返回 b--, 先返回 b的值,然后再 b-1
// 3. result返回的结果是99 ，而不是98，因为b--是先处理，再自减。但是后边的b=98
int result = a > b ? a++ : b--;
System.out.println("result=" + result);//99
System.out.println("a=" + a);//10
System.out.println("b=" + b);//98
}
}
- 使用细节
-
表达式1 和表达式2 要为可以赋给接收变量的类型(或可以自动转换)
-
三元运算符可以转成if–else 语句
int res = a > b ? a++ : --b;
上边这一行等价于 if ( a > b) res = a++;
else res = --b;
public class TernaryOperatorDetail {
//编写一个main 方法
public static void main(String[] args) {
//表达式1 和表达式2 要为可以赋给接收变量的类型
//(或可以自动转换/或者强制转换)
int a = 3;
int b = 8;
int c = a > b ? 1 : 3;//可以的，类型一致
int c = a > b ? (int)1.1 : (int)3.4;//可以的
int c = a > b ? 1.1 : 3.4;//是不对的，不能把double赋给int
double d = a > b ? a : b + 3;//可以的，满足int -> double
}
}
- 课堂练习：实现三个数的最大值
public class TernaryOperatorExercise {
//编写一个main方法
public static void main(String[] args) {
//案例：实现三个数的最大值
int n1 = 553;
int n2 = 33;
int n3 = 123;
//思路
//1. 先得到 n1 和 n2 中最大数 , 保存到 max1
//2. 然后再 求出 max1 和 n3中的最大数，保存到 max2
int max1 = n1 > n2 ? n1 : n2;
int max2 = max1 > n3 ? max1 : n3;
System.out.println("最大数=" + max2);
//使用一条语句实现, 推荐使用上面方法
//老师提示: 后面我们可以使用更好方法,比如排序
// int max = (n1 > n2 ? n1 : n2) > n3 ?
// (n1 > n2 ? n1 : n2) : n3;
// System.out.println("最大数=" + max);
}
}
12.运算符优先级（对应080节）
13.标识符的命名规则和规范（对应081-084节）
int cclass = 10;//是错的，class是关键字
int abcclass = 10; //是对的
int n = 40;
int N = 50;//区分大小写
System.out.println("n=" + n);//40
System.out.println("N=" + N);//50
// abc 和 aBc 是两个不同变量
int abc = 100;
int aBc = 200;
//标识符不能包含空格
//int a b = 300; 错的
//int a-b=10;
int goto1 = 10;
- 练习：判断下面变量名是否正确
hsp //ok
hsp12 //ok
1hsp //错误, 数字不能开头
h-s // 错误, 不能有-
x h // 错误， 有空格
h$4 // ok
class //错误，class 关键字
int // 错误,int 是关键字
double //错误,double 是关键字
public //错误,public 是关键字
static //错误,static 是关键字
goto //错误, goto 是保留字
stu_name //ok
- 标识符命名规范
- 包名：多单词组成时所有字母都小写：aaa.bbb.ccc //比如com.hsp.crm
- 类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz [大驼峰]
比如： TankShotGame - 变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz [小驼峰， 简称驼峰法]
比如： tankShotGame - 常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ
比如：定义一个所得税率TAX_RATE - 后面我们学习到类，包，接口，等时，我们的命名规范要这样遵守,更加详细的看文档.
- 关键字和保留字
关键字的定义和特点(不用背)
定义：被Java 语言赋予了特殊含义，用做专门用途的字符串（单词）
特点：关键字中所有字母都为小写
Java 保留字：现有Java 版本尚未使用，但以后版本可能会作为关键字使用。自己命名标识符时要避免使用这些保留字byValue、cast、future、generic、inner、operator、outer、rest、var 、goto 、const
14.键盘输入语句（对应085节）
- 介绍
在编程中，需要接收用户输入的数据，就可以使用键盘输入语句来获取。Input.java , 需要一个扫描器(对象), 就是Scanner
- 步骤：
- 导入该类的所在包, java.util.*
- 创建该类对象（声明变量）
- 调用里面的功能
- 代码演示
import java.util.Scanner;//表示把java.util下的Scanner类导入
public class Input {
//编写一个main方法
public static void main(String[] args) {
//演示接受用户的输入
//步骤
//Scanner类 表示 简单文本扫描器，在java.util 包
//1. 引入/导入 Scanner类所在的包
//2. 创建 Scanner 对象 , new 创建一个对象,体会
// myScanner 就是 Scanner类的对象
Scanner myScanner = new Scanner(System.in);
//3. 接收用户输入了， 使用 相关的方法
System.out.println("请输入名字");
//当程序执行到 next 方法时，会等待用户输入~~~
String name = myScanner.next(); //接收用户输入字符串
System.out.println("请输入年龄");
int age = myScanner.nextInt(); //接收用户输入int
System.out.println("请输入薪水");
double sal = myScanner.nextDouble(); //接收用户输入double
System.out.println("人的信息如下:");
System.out.println("名字=" + name
+ " 年龄=" + age + " 薪水=" + sal);
}
}
15.四种进制介绍（对应086节）
- 进制介绍
对于整数，有四种表示方式：
二进制：0,1 ，满2 进1.以0b 或0B 开头。
十进制：0-9 ，满10 进1。
八进制：0-7 ，满8 进1. 以数字0 开头表示。
十六进制：0-9 及A(10)-F(15)，满16 进1. 以0x 或0X 开头表示。此处的A-F 不区分大小写。 - 代码演示
public class BinaryTest {
//编写一个main方法
public static void main(String[] args) {
//n1 二进制
int n1 = 0b1010;
//n2 10进制
int n2 = 1010;
//n3 8进制
int n3 = 01010;
//n4 16进制
int n4 = 0X10101;
System.out.println("n1=" + n1); //10
System.out.println("n2=" + n2);//1010
System.out.println("n3=" + n3);//520
System.out.println("n4=" + n4);//65793
System.out.println(0x23A);
}
}
- 进制的图示：从上往下看
16.进制的转换（对应087-096节）
- 介绍
第一组
- 二进制转十进制
- 八进制转十进制
- 十六进制转十进制
第二组： - 十进制转二进制
- 十进制转八进制
- 十进制转十六进制
第三组 - 二进制转八进制
- 二进制转十六进制
第四组 - 八进制转二进制
- 十六进制转二进制
- 2进制转10进制
- 8进制转10进制
- 16进制转10进制
课堂练习：请将
0b110001100 转成十进制 //396
02456 转成十进制 //1326
0xA45 转成十进制 //2629
- 10进制转2进制
规则：将该数不断除以2，直到商为0 为止，然后将每步得到的余数倒过来，就是对应的二进制。
案例：请将34 转成二进制= 0B00100010
- 10进制转8进制
规则：将该数不断除以8，直到商为0 为止，然后将每步得到的余数倒过来，就是对应的八进制。
案例：请将131 转成八进制=> 0203
- 10进制转16进制
规则：将该数不断除以16，直到商为0 为止，然后将每步得到的余数倒过来，就是对应的十六进制。
案例：请将237 转成十六进制=> 0xED
课堂练习：(一定练习，使用计算器/用程序去验证)，程序不好写，用计算器
123 转成二进制=0b01111011
678 转成八进制=01246
8912 转成十六进制=0x22D0 - 2进制转8进制
规则：从低位开始,将二进制数每三位一组，转成对应的八进制数即可。
案例：请将ob11010101 转成八进制
ob11(3)010(2)101(5) => 0325 - 2进制转16进制
规则：从低位开始，将二进制数每四位一组，转成对应的十六进制数即可。
案例：请将ob11010101 转成十六进制
ob1101(D)0101(5) = 0xD5
课堂练习：请将
0b11100101 转成八进制 0345
0b1110010110 转成十六进制 0x396 - 8进制转2进制
规则：将八进制数每1 位，转成对应的一个3 位的二进制数即可。
案例：请将0237 转成二进制
02(010)3(011)7(111) = 0b10011111 - 16进制转2进制
规则：将十六进制数每1 位，转成对应的4 位的一个二进制数即可。
案例：请将0x23B 转成二进制
0x2(0010)3(0011)B(1011) = 0b001000111011
课堂练习：请将
01230 转成二进制=0010 1001 1000
0xAB29 转成二进制= 1010 1011 0010 1001
17.原码、反码、补码（对应098节）
18.位运算详解（对应099-100节）
- java 中有7 个位运算(&、|、^、~、>>、<<和>>>)
public class BitOperator {
//编写一个main方法
public static void main(String[] args) {
// 2&3推导
//1. 先得到 2的补码 => 先看2的原码，2是int类型，有4位，每位有8bit
// 所以2的原码 00000000 00000000 00000000 00000010
// 2的补码 00000000 00000000 00000000 00000010 正数三码合一
//2. 3的补码 3的原码 00000000 00000000 00000000 00000011
// 3的补码 00000000 00000000 00000000 00000011
//3. 按位&
// 00000000 00000000 00000000 00000010
// 00000000 00000000 00000000 00000011
// 00000000 00000000 00000000 00000010 & 运算后的补码
// 运算后的原码 也是 00000000 00000000 00000000 00000010
// 结果就是 2
System.out.println(2&3);//2
// ~-2推导
//1. 先得到 -2的原码 10000000 00000000 00000000 00000010
//2. -2的 反码 11111111 11111111 11111111 11111101
//3. -2的 补码 11111111 11111111 11111111 11111110
//4. ~-2操作 00000000 00000000 00000000 00000001运算后的补码
//5. 运算后的原码 就是 00000000 00000000 00000000 00000001 => 1
//因为运算后的补码符号位是0，是正数，三码合一
System.out.println(~-2);//1
// ~2推导
//1. 得到2的补码 00000000 00000000 00000000 00000010
//2. ~2操作 11111111 11111111 11111111 11111101 运算后的补码
//3. 运算后的反码 11111111 11111111 11111111 11111100
//4. 运算后的原码 10000000 00000000 00000000 00000011=>-3
System.out.println(~2); //-3
//2|3推导
//2的原码 00000000 00000000 00000000 00000010
//2的补码 00000000 00000000 00000000 00000010
//3的补码 00000000 00000000 00000000 00000011
// 2|3 00000000 00000000 00000000 00000011 运算后的补码
//运算后的原码 00000000 00000000 00000000 00000011 3
System.out.println(2|3); //3
//2^3推导
//2的补码 00000000 00000000 00000000 00000010
//3的补码 00000000 00000000 00000000 00000011
// 2^3 00000000 00000000 00000000 00000001 运算后的补码
//运算后的原码 00000000 00000000 00000000 00000001
System.out.println(2^3); //1
}
}
- 还有3 个位运算符>>、<< 和>>>
运算规则:
- 算术右移>>：低位溢出,符号位不变,并用符号位补溢出的高位。正数本质是除2
- 算术左移<<: 符号位不变,低位补0。。正数本质是乘2
- 逻辑右移 (>>>) 也叫无符号右移,运算规则是: 低位溢出，高位补0
- 特别说明：没有<<< 符号
应用案例BitOperator02.java
- int a=1>>2; //1 => 00000001 => 00000000 本质1 / 2 / 2 =0
- int c=1<<2; //1 => 00000001 => 00000100 本质1 * 2 * 2 = 4
- int d=4<<3; 本质 422*2=32
建议：掌握老师讲解的即可，不用再深入.
深入讲解：https://blog.csdn.net/m0_50736744/article/details/120529884
19.本章练习
第2题 int i=66;
System.out.println(++i+i); //执行i=i+1 =>i=67,结果为134
1050
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
