视频链接:https://www.bilibili.com/video/BV1fh411y7R8

运算符

运算符

  • 运算符介绍

​ 运算符是一种特殊的符号,用以表示数据的运算、赋值和比较等。

  1. 算术运算符

  2. 赋值运算符

  3. 关系运算符 [比较运算符]

  4. 逻辑运算符

  5. 位运算符 [需要二进制基础]

  6. 三元运算符


一. 算术运算符

算术运算符

  • 介绍

    算术运算符是对数值类型的变量进行运算的,在 Java 程序中使用的非常多。

  • 算术运算符一览

% 的本质 看一个公式:a % b = a - a / b * b

a % b 当 a 是小数时,公式 = a - (int)a / b * b

image-20220508230138805 image-20220509213107049

  • 案例演示

image-20220508230401456
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
/**
* 演示算术运算符的使用
*/
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

//++的使用
//
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;
int k = j++; // 等价 k =j;j=j+1;
System.out.println("k=" + k + "j=" + j);//8 9
}
}
  • 细节说明

image-20220508232614621

算数运算符使用

  • 面试题

image-20220508232646110
  • 自增,自减课堂练习, 看看输出什么
image-20220508233829424
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
//练习

public class ArithmeticOperatorExercise01 {

//编写一个main方法
public static void main(String[] args) {

// int i = 1;//i->1
// i = i++; //规则使用临时变量: (1) temp=i;(2) i=i+1;(3)i=temp;
// System.out.println(i); // 1


// int i=1;
// i=++i; //规则使用临时变量: (1) i=i+1;(2) temp=i;(3)i=temp;
// System.out.println(i); //2
//
// 测试输出
int i1 = 10;
int i2 = 20;
int i = i1++;
System.out.print("i="+i);//10
System.out.println("i2="+i2);//20
i = --i2;
System.out.print("i="+i);//19
System.out.println("i2="+i2);//19


}
}
  1. 假如还有 59 天放假,问:合 xx 个星期零 xx 天

  2. 定义一个变量保存华氏温度,华氏温度转换摄氏温度的公式为:5/9*(华氏温度-100),请求出华氏温度对应的摄氏温度。 [234.5]

  3. 代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
//课堂练习

public class ArithmeticOperatorExercise02 {

//编写一个main方法
public static void main(String[] args) {

//1.需求:
//假如还有59天放假,问:合xx个星期零xx天
//2.思路分析
//(1) 使用int 变量 days 保存 天数
//(2) 一个星期是7天 星期数weeks: days / 7 零xx天leftDays days % 7
//(3) 输出

//3.走代码
int days = 25911;
int weeks = days / 7;
int leftDays = days % 7;
System.out.println(days + "天 合" + weeks + "星期零"
+ leftDays + "天");

//1.需求
//定义一个变量保存华氏温度,华氏温度转换摄氏温度的公式为
//:5/9*(华氏温度-100),请求出华氏温度对应的摄氏温度
//
//2思路分析
//(1) 先定义一个double huaShi 变量保存 华氏温度
//(2) 根据给出的公式,进行计算即可5/9*(华氏温度-100)
// 考虑数学公式和java语言的特性
//(3) 将得到的结果保存到double sheShi
//3走代码
double huaShi = 1234.6;
double sheShi = 5.0 / 9 * (huaShi - 100);
System.out.println("华氏温度" + huaShi
+ " 对应的摄氏温度=" + sheShi);

}
}

二. 关系运算符(比较运算符)

**关系运算符(比较运算符) **

  • 介绍

  1. 关系运算符的结果都是 boolean 型,也就是要么是 true,要么是 false

  2. 关系表达式 经常用在 if 结构的条件中或循环结构的条件中

  • 关系运算符一览

image-20220509001153917
  • 案例演示

案例演示关系运算符的使用(RelationalOperator.java)。

image-20220509001501843
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
//演示关系运算符的使用
//

public class RelationalOperator {

//编写一个main方法
public static void main(String[] args) {

int a = 9; //老韩提示: 开发中,不可以使用 a, b
int b = 8;
System.out.println(a > b); //T
System.out.println(a >= b); //T
System.out.println(a <= b); //F
System.out.println(a < b); //F
System.out.println(a == b); //F
System.out.println(a != b); //T
boolean flag = a > b; //T
System.out.println("flag=" + flag);
}
}
  • 细节说明

  1. 关系运算符的结果都是 boolean 型,也就是要么是 true,要么是 false。

  2. 关系运算符组成的表达式,我们称为关系表达式。 a > b

  3. 比较运算符"==“不能误写成”="


三. 逻辑运算符

逻辑运算符

  • 介绍

​ 用于连接多个条件(多个关系表达式),最终的结果也是一个 boolean 值。

  • 逻辑运算符一览

分为两组学习

  1. 短路与 && , 短路或 ||,取反 !

  2. 逻辑与 &,逻辑或 |,^ 逻辑异或

image-20220509002134483
  • 说明逻辑运算规则

  1. a&b : & 叫逻辑与:规则:当 a 和 b 同时为 true ,则结果为 true, 否则为 false

  2. a&&b : && 叫短路与:规则:当 a 和 b 同时为 true ,则结果为 true,否则为 false

  3. a|b : | 叫逻辑或,规则:当 a 和 b ,有一个为 true ,则结果为 true,否则为 false

  4. a||b : || 叫短路或,规则:当 a 和 b ,有一个为 true ,则结果为 true,否则为 false

  5. !a : 叫取反,或者非运算。当 a 为 true, 则结果为 false, 当 a 为 false 是,结果为 true

  6. a^b: 叫逻辑异或,当 a 和 b 不同时,则结果为 true, 否则为 false


短路与逻辑与

  • && 和 & 基本规则

名称语法特点
短路与&&条件 1&&条件 2两个条件都为 true,结果为 true,否则 false
逻辑与&条件 1&条件 2
  • && 和 & 案例演示

案例演示&& 和 & 运算符的使用(LogicOperator01.java)。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
/**
* 演示逻辑运算符的使用
*/

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 10

}
}
  • && 和 & 使用区别

  1. &&短路与:如果第一个条件为 false,则第二个条件不会判断,最终结果为 false,效率高

  2. & 逻辑与:不管第一个条件是否为 false,第二个条件都要判断,效率低

  3. 开发中, 我们使用的基本是使用短路与&&, 效率高


短路或逻辑或

  • || 和 | 基本规则

名称语法特点
短路或||条件 1||条件2两个条件中只要有一个成立,结果为 true,否则为 false
逻辑或|条件 1|条件2只要有一个条件成立,结果为 true,否则为 false
  • || 和 | 案例演示

案例演示&& || !运算符的使用(LogicOperator02.java)。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
//演示| || 使用

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) { // 可以换成 | 测试
System.out.println("ok300");
}
System.out.println("a=" + a + " b=" + b); //4 9

}
}
  • || 和 | 使用区别

  1. ||短路或:如果第一个条件为 true,则第二个条件不会判断,最终结果为 true,效率高

  2. | 逻辑或:不管第一个条件是否为 true,第二个条件都要判断,效率低

  3. 开发中,我们基本使用 ||


逻辑非逻辑异或

  • ! 取反 基本规则

名称语法特点
! 非(取反)!条件如果条件本身成立,结果为 false,否则为 true
  • ! 案例演示

案例演示 !运算符的使用(InverseOperator.java)。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
//!和^案例演示

public class InverseOperator {

//编写一个main方法
public static void main(String[] args) {

//! 操作是取反 T->F , F -> T
System.out.println(60 > 20); //T
System.out.println(!(60 > 20)); //F

//a^b: 叫逻辑异或,当 a 和 b 不同时,则结果为true, 否则为false
boolean b = (10 > 1) ^ ( 3 > 5);
System.out.println("b=" + b);//T
}
}
  • ^ 案例演示

a^b: 叫逻辑异或,当 a 和 b 不同时,则结果为 true, 否则为 false

^逻辑异或,System.out.println( (4 < 1) ^ (6 > 3) ); // T


逻辑运算符练习

  • 练习题 1 请写出每题的输出结果

x ++== 6,先比较,再自增

image-20220509131958291
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
//验证

public class Test {

//编写一个main方法
public static void main(String[] args) {

// int x = 5;
// int y=5;
// if(x++==6 & ++y==6){ //逻辑与
// x = 11;
// }
// System.out.println("x="+x+",y="+y);
// //6, 6
// int x = 5,y = 5;

// if(x++==6 && ++y==6){
// x = 11;
// }
// System.out.println("x="+x+",y="+y);
// //6, 5
//
// int x = 5,y = 5;
// if(x++==5 | ++y==5){
// x =11;
// }
// System.out.println("x="+x+",y="+y);
//11, 6
//
// int x = 5,y = 5;
// if(x++==5 || ++y==5){
// x =11;
// }
// System.out.println("x="+x+",y="+y);
//11, 5
//
//
boolean x=true;
boolean y=false;
short z=46;
if( (z++==46)&& (y=true) ) z++;
if((x=false) || (++z==49)) z++;
System. out.println("z="+z); //50

}
}
  • 练习题 2 请写输出结果

image-20220509132450314

四. 赋值运算符

  • 介绍

赋值运算符就是将某个运算后的值,赋给指定的变量。

  • 赋值运算符的分类

​ += ,-= ,*= , /= ,%= 等 , 重点讲解一个 += ,其它的使用是一个道理

​ a += b; [等价 a = a + b; ]

​ a -= b; [等价 a = a - b; ]

  • 案例演示

案例演示赋值运算符的基本使用。AssignOperator.java

  1. 赋值基本案例 [int num1 = 10]

  2. += 的使用案例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
//演示赋值运算符的使用

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 = (byte)(b+1);

}
}
  • 赋值运算符特点

  1. 运算顺序从右往左 int num = a + b + c;

  2. 赋值运算符的左边 只能是变量,右边 可以是变量、表达式、常量值

​ int num = 20; int num2= 78 * 34 - 10; int num3 = a;

  1. 复合赋值运算符等价于下面的效果

​ 比如:a+=3;等价于 a=a+3; 其他类推

  1. 复合赋值运算符会进行类型转换。

​ byte b = 2; b+=3; b++;

image-20220509134732958

五. 三元运算符

  • 基本语法

条件表达式 ? 表达式 1: 表达式 2;

运算规则

  1. 如果条件表达式为 true,运算后的结果是表达式 1;

  2. 如果条件表达式为 false,运算后的结果是表达式 2;

口诀: [一灯大师:一真大师]

  • 案例演示 TernaryOperator.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
//三元运算符使用

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. 返回的结果是99
int result = a > b ? a++ : b--;
System.out.println("result=" + result);
System.out.println("a=" + a);
System.out.println("b=" + b);

}
}

  • 使用细节 TernaryOperatorDetail.java

  1. 表达式 1 和表达式 2 要为可以赋给接收变量的类型(或可以自动转换)

  2. 三元运算符可以转成 if–else 语句

​ int res = a > b ? a++ : --b;

​ if ( a > b) res = a++;

​ else res = --b;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
//三元运算符细节

public class TernaryOperatorDetail {

//编写一个main方法
public static void main(String[] args) {
//表达式1和表达式2要为可以赋给接收变量的类型
//(或可以自动转换/或者强制转换)
int a = 3;
int b = 8;
int c = a > b ? (int)1.1 : (int)3.4;//可以的
double d = a > b ? a : b + 3;//可以的,满足 int -> double
}
}
  • 课堂练习

案例:实现三个数的最大值 TernaryOperatorExercise.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
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);
//

}
}

六. 运算符优先级

运算符优先级

  1. 运算符有不同的优先级,所谓优先级就是表达式运算中的运算顺序。如右表,上一行运算符总优先于下一行。

  2. 只有单目运算符、赋值运算符是从右向左运算的。

  3. 一览表, 不要背,使用多了,就熟悉了

梳理小节:小伙伴有一个大致印象,使用多了,就熟悉

  1. () , {} 等
  2. 单目运算 ++ –
  3. 算数运算符
  4. 位移运算符
  5. 比较运算符
  6. 逻辑运算符
  7. 三元运算符
  8. 赋值运算符
image-20220509162226749

标识符命名规则和规范

七. 标识符规则

标识符的命名规则规范

image-20220509162810243
1
2
3
4
5
6
7
8
9
10
11
12
13
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; //x
//int a-b=10;
int goto1 = 10;
  • 判断下面变量名是否正确

1
2
3
4
5
6
7
8
9
10
11
12
13
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

八. 标识符规范

标识符命名规范[更加专业]

  1. 包名:多单词组成时所有字母都小写:aaa.bbb.ccc //比如 com.hsp.crm

  2. 类名、接口名:多单词组成时,所有单词的首字母大写:XxxYyyZzz [大驼峰]

​ 比如: TankShotGame

  1. 变量名、方法名:多单词组成时,第一个单词首字母小写,第二个单词开始每个单词首字母大写:xxxYyyZzz [小驼峰, 简称 驼峰法]

​ 比如: tankShotGame

  1. 常量名:所有字母都大写。多单词时每个单词用下划线连接:XXX_YYY_ZZZ

​ 比如 :定义一个所得税率 TAX_RATE

  1. 后面我们学习到 类,包,接口,等时,我们的命名规范要这样遵守,更加详细的看文档.


九. 关键字保留字

关键字

关键字的定义和特点 (不用背)

定义:被 Java 语言赋予了特殊含义,用做 专门用途的字符串(单词)

特点:关键字中所有字母都为小写

image-20220509164734847 image-20220509164755233

保留字

  • 介绍

​ Java 保留字:现有 Java 版本尚未使用,但以后版本可能会作为关键字使用。自己命名标识符时要避免使用这些保留字

byValue、cast、future、 generic、 inner、 operator、 outer、 rest、 var 、 goto 、const


键盘输入

十. 键盘输入

键盘输入语句

  • 介绍

在编程中,需要接收用户输入的数据,就可以使用键盘输入语句来获取。Input.java , 需要一个 扫描器(对象), 就是 Scanner

  • 步骤 :

  1. 导入该类的所在包, java.util.*

  2. 创建该类对象(声明变量)

  3. 调用里面的功能

image-20220509165317654
  • 案例演示:

要求:可以从控制台接收用户信息,【姓名,年龄,薪水】

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
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);

}
}
image-20220509170543727

进制

十一. 四种进制介绍

进制(程序员的基本功)

  • 进制介绍

对于整数,有四种表示方式:

二进制: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 不区分大小写。

  • 举例说明 BinaryTest.java

image-20220509171113729 image-20220509171329500
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
//演示四种进制
//
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);
System.out.println("n2=" + n2);
System.out.println("n3=" + n3);
System.out.println("n4=" + n4);
System.out.println(0x23A);

}
}
  • 进制的图示

image-20220509171412620 image-20220509171547659

进制的转换(基本功)

进制转换的介绍

  • 第一组:

  1. 二进制转十进制

  2. 八进制转十进制

  3. 十六进制转十进制

  • 第二组:

  1. 十进制转二进制

  2. 十进制转八进制

  3. 十进制转十六进制

  • 第三组

  1. 二进制转八进制

  2. 二进制转十六进制

  • 第四组

  1. 八进制转二进制

  2. 十六进制转二进制

  • 其他进制转十进制

十二. 2进制转10进制

二进制转换成十进制示例

image-20220509172209929

十三. 8进制转10进制

八进制转换成十进制示例

十四. 16进制转10进制

十六进制转换成十进制示例

规则:从最低位(右边)开始,将每个位上的数提取出来,乘以 16 的(位数-1)次方,然后求和

案例:请将 0x23A 转成十进制的数

0x23A = 10 * 16^0 + 3 * 16 ^ 1 + 2 * 16^2 = 10 + 48 + 512 = 570

1
System.out.println(0x23A);	//570

课堂练习:请将

0b110001100 转成 十进制

02456 转成十进制

0xA45 转成十进制


十进制转其它进制

image-20220509173320742

十五. 10进制转2进制

十进制转换成二进制

规则:将该数不断除以 2,直到商为 0 为止,然后将每步得到的余数倒过来,就是对应的二进制

案例:请将 34 转成二进制 = 0B00100010

image-20220509194122002

十六. 10进制转8进制

十进制转换成八进制

规则:将该数不断除以 8,直到商为 0 为止,然后将每步得到的余数倒过来,就是对应的八进制

案例:请将 131 转成八进制 => 0203

image-20220509194522001

十七. 10进制转16进制

十进制转换成十六进制

规则:将该数不断除以 16,直到商为 0 为止,然后将每步得到的余数倒过来,就是对应的十六进制

案例:请将 237 转成十六进制 => 0xED

image-20220509194651804
  • 课堂练习:(一定练习,使用计算器/用程序去验证)

​ 123 转成 二进制 => ?

​ 678 转成八进制 => 04126

​ 8912 转成十六进制 => ?


二进制转换成八进制、十六进制

image-20220509195013056

十八. 2进制转8进制

规则:从低位开始,将二进制数每三位一组,转成对应的八进制数即可

案例:请将 ob11010101 转成八进制

ob11(3)010(2)101(5) => 0325

image-20220509195435973

十九. 2进制转16进制

规则:从低位开始,将二进制数每四位一组,转成对应的十六进制数即可

案例:请将 ob11010101 转成十六进制

ob1101(D)0101(5) = 0xD5

image-20220509195728223

课堂练习:请将

​ 0b11100101 转成 八进制

​ 0b1110010110 转成 十六进制 => 0x396


八进制、十六进制转成二进制

image-20220509195905562

二十. 8进制转2进制

规则:将八进制数每 1 位,转成对应的一个 3 位的二进制数即可

案例:请将 0237 转成二进制

02(010)3(011)7(111) = 0b10011111

image-20220509200424994

二一. 16进制转2进制

规则:将十六进制数每 1 位,转成对应的 4 位的一个二进制数即可

案例:请将 0x23B 转成二进制

0x2(0010)3(0011)B(1011) = 0b001000111011

image-20220509201525174
  • 课堂练习:请将

01230 转成 二进制

0xAB29 转成二进制 => 0xA(1010)B(1011)2(0010)9(1001) =>0b1010101100101001


二二. 位运算思考题

位运算的思考题

  1. 请看下面的代码段,回答 a,b,c,d,e 结果是多少?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public static void maiin(String []args) 
{

int a=1>>2; // 1 向右位移 2 位

int b=-1>>2;//算术右移

int c=1<<2;//算术左移

int d=-1<<2;//

int e=3>>>2;//无符号右移

//a,b,c,d,e 结果是多少

System.out.println("a="+a);

System.out.println("b="+b);

System.out.println("c="+c);

System.out.println("d="+d);

System.out.println("e="+e);

}
  1. 请回答在 java 中,下面的表达式运算的结果是: (位操作), 晚上练习

1
2
3
4
5
6
7
8
9
10
11
12
13
~2=?	// 按位取反 

2&3=? // 2 按位与 3

2|3=?

~-5=?

13&7=?

5|4=?

-3^3=? //^ 按位异或

二三. 原码反码补码

二进制在运算中的说明

image-20220509202541652

原码、反码、补码(重点 难点)

image-20220509202730922

第 7 点,因为补码把正数、负数统一起来了


二四. 位运算

位运算符

  • java 中有 7 个位运算(&、|、^、~、>>、<<和 >>>)

image-20220509203957600
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
//位运算


public class BitOperator {

//编写一个main方法
public static void main(String[] args) {

// 2&3
//看老师的推导过程
//1. 先得到 2的补码 => 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
System.out.println(~-2);//1

//推导
//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
}
}

位运算符

  • 还有 3 个位运算符 >>、<< 和 >>> , 运算规则:

  1. 算术右移 >>:低位溢出,符号位不变,并用符号位补溢出的高位

  2. 算术左移 <<: 符号位不变,低位补 0

  3. >>> 逻辑右移也叫无符号右移,运算规则是: 低位溢出,高位补 0

  4. 特别说明:没有 <<< 符号

  • 应用案例 BitOperator02.java

  1. int a=1>>2; //1 => 00000001 => 00000000 本质 1 / 2 / 2 =0

  2. int c=1<<2; //1 => 00000001 => 00000100 本质 1 * 2 * 2 = 4

image-20220509212136583
1
2
3
4
5
6
7
8
9
10
11
12

public class BitOperator02 {

//编写一个main方法
public static void main(String[] args) {
System.out.println(1 >> 2); //0
System.out.println(1 << 2); //4
System.out.println(4 << 3); // 4 * 2 * 2 * 2 = 32
System.out.println(15 >> 2); // 15 / 2 / 2 = 3

}
}
  • 完成前面的案例

建议:掌握老师讲解的即可,不用再深入


本章作业

image-20220509212539569
1
2
3
4
System.out.println(-10.4%3); // -1.4近似值

int i=66;
System.out.println(++i+i); //134
image-20220509213557540
image-20220509213758196