代码收藏家 Java运算符详解：基础知识超全总结，包含进制转换，不容错过！
Hello，大家好！我是小周，从今天开始我将给大家带来我新的系列–Java基础知识超全超详细总结，里面是我对Java这门语言的全部心血。在这个系列中我会持续更新，从对小白最不友好的软件安装再到JavaSE到JavaEE，保证让屏幕前的各位从0到1学会Java这门语言，同时也欢迎各位大佬友友看见我这篇博客与我共同探讨，检查博客中小周没有注意到的问题，大家一起学习进步！！！今天给大家讲的是运算符这一章节！！！
三、运算符
3.1 运算符介绍
运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。
算术运算符
赋值运算符
关系运算符 [比较运算符]
逻辑运算符
位运算符 [需要二进制基础]
三元运算符
3.2 算术运算符
3.2.1 介绍
算术运算符是对数值类型的变量进行运算的，在 Java 程序中使用的非常多。
3.2.2算术运算符一览
| 运算符 | 运算 | 范例 | 结果 |
|---|---|---|---|
| + | 正号 | +9 | 9 |
| – | 负号 | b=9;-b | -9 |
| + | 加 | 9+9 | 18 |
| – | 减 | 10-9 | 1 |
| * | 乘 | 9*9 | 81 |
| / | 除 | 9/9 | 1 |
| % | 取模（取余） | 10%9 | 1 |
| ++ | 自增（前）：先运算后取值 | a=9;b=++a; | a=10;b=10 |
| ++ | 自增（后）：先取值后运算 | a=9; b=a++; | a=10;b=9 |
| — | 自减（前）：先运算后取值 | a=9; b=–a; | a=8;b=8 |
| — | 自减（后）：先运算后取值 | a=9; b=a–; | a=8;b=9 |
| + | 字符串相加 | "zzz"+"fff" | "zzz fff" |
3.2.3案例演示
/**
* 演示算术运算符的使用
*/
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
// 当a是小数时，公式变成 a % b = a - (int)a / b * b,会有一个强制类型转换
// 注意：有小数运算，得到的结果时近似值
System.out.println(10 % 3); //1
System.out.println(-10 % 3); // -1
// -10 % 3 => -10 - (-10) / 3 * 3 = -10 + 9 = -1
System.out.println(10 % -3); //1
// 10 % -3 = 10 - 10 / (-3) * (-3) = 10 - 9 = 1
System.out.println(-10 % -3);//-1
// -10 % -3 = (-10) - (-10) / (-3) * (-3) = -10 + 9 = -1
//++的使用
int i = 10;
i++;//自增 等价于 i = i + 1; => i = 11
System.out.println("i=" + 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
}
}一些细节我已经写在了注释当中，我们来编译运行一下
每个结果都和我们分析的一样
3.2.4 细节说明
对于除号“/”，它的整数除和小数除是有区别的: 整数之间做除法时，只保留整数部分而舍弃小数部分。例如:int x = 10/3; 结果是 3
当对一个数取模时，可以等价 a % b = a – a / b * b，这样我们可以看到 取模的一个本质运算。
当 自增 当做一个独立语言使用时，不管是 ++i; 还是 i++; 都是一样的，等价
当 自增 当做一个表达式使用时 j = ++i 等价 j=j+1;i=j
当 自增 当做一个表达式使用时 j = i++ 等价 j=i;i=i+1
3.2.5 面试题
面试题1 int i=1;//i->1 i=i++ + ++i; //规则使用临时变量: (1) temp=i;(2) i=i+1;(3)i=temp; System.out.println(i); // 1 问: 结果是多少? 为什么?
编译运行后，结果和我们分析的一样
面试题2 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大家下去动手算算着四个代码分别输出什么
3.2.7 课堂练习
在这里给大家出两道题，大家自己动手做做
1.假如还有 59 天放假，问：合 xx 个星期零 xx 天
2.定义一个变量保存华氏温度，华氏温度转换摄氏温度的公式为：5/9*(华氏温度-100),请求出华氏温度对应的摄氏温度。
在这里我将小周写的代码粘贴到这里，供大家参考
//课堂练习
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 = 59;
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);//要注意一定要是浮点数除法，否则5/9结果是0，导致最终的摄氏温度错误一直是0
System.out.println("华氏温度" + huaShi
+ " 对应的摄氏温度=" + sheShi);
}
}3.3 关系运算符(比较运算符)
3.3.1 介绍
-
关系运算符的结果都是 boolean 型，也就是要么是 true，要么是 false
-
关系表达式经常用在 if 结构的条件中或循环结构的条件中
3.3.2 关系运算符一览
| 运算符 | 运算 | 范例 | 结果 |
|---|---|---|---|
| == | 相等于 | 9==8 | false |
| != | 不等于 | 9!=8 | true |
| < | 小于 | 9<8 | false |
| > | 大于 | 9>8 | true |
| <= | 小于等于 | 9<=8 | false |
| >= | 大于等于 | 9>=8 | true |
| instanceof | 检查是否是类的对象 | "zzz" instanceof String | true |
3.3.3 案例演示
//演示关系运算符的使用
//
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);
}
}我们来运行编译一下看看
和我们分析的一模一样
3.3.4 细节说明
-
关系运算符的结果都是 boolean 型，也就是要么是 true，要么是 false。
-
关系运算符组成的表达式，我们称为关系表达式。 a > b
-
比较运算符"=="不能误写成"="
3.4 逻辑运算符
3.4.1 介绍
用于连接多个条件（多个关系表达式），最终的结果也是一个 boolean 值。
3.4.2 逻辑运算符一览
分为两组学习
-
短路与 && ， 短路或 ||，取反 !
-
逻辑与 &，逻辑或 |，^ 逻辑异或
| a | b | a&b | a&&b | a|b | a||b | !a | a^b |
|---|---|---|---|---|---|---|---|
| true | true | true | true | true | true | false | false |
| true | false | false | false | true | true | false | true |
| false | true | false | false | true | true | true | true |
| false | false | false | false | false | false | true | false |
说明逻辑运算规则：
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
3.4.3 && 和 & 基本规则
| 名称 | 语法 | 特点 |
|---|---|---|
| 短路与&& | 条件1&&条件2 | 两个条件都为 true，结果为 true,否则 false |
| 逻辑与& | 条件1&条件2 | 两个条件都为 true，结果为 true,否则 false |
3.4.4 && 和 & 使用区别
-
&&短路与：如果第一个条件为 false，则第二个条件不会判断，最终结果为 false，效率高
-
& 逻辑与：不管第一个条件是否为 false，第二个条件都要判断，效率低
-
开发中， 我们使用的基本是使用短路与&&, 效率高
3.4.5 && 和 & 案例演示
/**
* 演示逻辑运算符的使用
*/
public class LogicOperator01 {
//编写一个main方法
public static void main(String[] args) {
//&&短路与 和 逻辑& 案例演示
//&&短路与使用
int age = 60;
if(age > 20 && age < 90) {
System.out.println("ok1");
}
//&逻辑与使用
if(age > 20 & age < 90) {
System.out.println("ok2");
}
//区别
int a = 4;
int b = 9;
//对于&&短路与而言，如果第一个条件为false ,后面的条件不再判断
//对于&逻辑与而言，如果第一个条件为false ,后面的条件仍然会判断
if(a < 1 && ++b < 50) {
System.out.println("ok3");//不会输出
}
System.out.println("a=" + a + " b=" + b);// 4 9
if(a < 1 & ++b < 50) {
System.out.println("ok3");//不会输出
}
System.out.println("a=" + a + " b=" + b);// 4 10
}
}我们运行编译看看两种运算符的差别
3.4.6 || 和 | 基本规则
| 名称 | 语法 | 特点 |
|---|---|---|
| 短路或|| | 条件 1||条件2 | 两个条件中只要有一个成立，结果为 true,否则为 false |
| 逻辑或| | 条件 1|条件2 | 只要有一个条件成立，结果为 true,否则为 false |
3.4.7 || 和 | 使用区别
-
||短路或：如果第一个条件为 true，则第二个条件不会判断，最终结果为 true，效率高
-
| 逻辑或：不管第一个条件是否为 true，第二个条件都要判断，效率低
-
开发中，我们基本使用 ||
3.4.8 || 和 | 案例演示
//演示| || 使用
public class LogicOperator02 {
//编写一个main方法
public static void main(String[] args) {
//||短路或 和 |逻辑或 案例演示
//|| 规则: 两个条件中只要有一个成立，结果为true,否则为false
//| 规则: 两个条件中只要有一个成立，结果为true,否则为false
//||短路或使用
int age = 60;
if(age > 20 || age < 30) {
System.out.println("ok1");
}
//|逻辑或使用
if(age > 20 | age < 30) {
System.out.println("ok2");
}
//区别
//(1)||短路或：如果第一个条件为true，
//则第二个条件不会判断，最终结果为true，效率高
//(2)| 逻辑或：不管第一个条件是否为true，第二个条件都要判断，效率低
int a = 4;
int b = 9;
if( a > 1 || ++b > 4) {
System.out.println("ok3");//输出
}
System.out.println("a=" + a + " b=" + b); //4 9
if( a > 1 | ++b > 4) {
System.out.println("ok3");//输出
}
System.out.println("a=" + a + " b=" + b); //4 10
}
}
编译运行后的结果和我们分析的一样
3.4.9! 取反基本规则
| 名称 | 语法 | 特点 |
|---|---|---|
| ! 非（取反） | !条件 | 如果条件本身成立，结果为 false，否则为 true |
3.4.10 !案例演示
我们来运行编译一下，看看结果和我们分析的是否一样
一模一样
3.4.11 ^案例演示
编译运行我们看看
和我们分析的一模一样
3.4.12 练习题
1、请写出该题的输出结果
int x = 5;
int y = 5;
if (x++ == 6 && ++y == 6) { // 逻辑与
x = 11;
}
System.out.println("x=" + x + ", y=" + y); // 6, 52、请写出该题的输出结果
int x = 5, y = 5;
if (x++ == 5 || ++y == 5) {
x = 11;
}
System.out.println("x=" + x + ", y=" + y); // 11, 53、请写出该题的输出结果
int x = 5, y = 5;
if (x++ == 6 & ++y == 6) {
x = 11;
}
System.out.println("x=" + x + ", y=" + y); // 6, 64、请写出该题的输出结果
int x = 5, y = 5;
if (x++ == 5 | ++y == 5) {
x = 11;
}
System.out.println("x=" + x + ", y=" + y); // 11, 65、请写出该题的输出结果
boolean x = true;
boolean y = false;
short z = 46;
if ((z++ == 46) && (y = true)) z++;//46->47->48,是将true赋值给y，不是判断相等
if ((x = false) || (++z == 49)) z++;//48->49->50
System.out.println("z=" + z); // 503.5 赋值运算符
3.5.1 介绍
赋值运算符就是将某个运算后的值，赋给指定的变量。
3.5.2 赋值运算符的分类
基本赋值运算符 =
int a = 10;
复合赋值运算符
+= ，-= ，*= ， /= ，%= 等 , 重点讲解一个 += ，其它的使用是一个道理
a += b; [等价 a = a + b; ]
a -= b; [等价 a = a – b; ]
3.5.3 赋值运算符特点
运算顺序从右往左 int num = a + b + c;
赋值运算符的左边 只能是变量,右边 可以是变量、表达式、常量值
int num = 20; int num2= 78 * 34 – 10; int num3 = a;
复合赋值运算符等价于右面的效果 比如：a+=3;等价于 a=a+3; 其他类推
复合赋值运算符会进行类型转换。 byte b = 2;
3.5.4 案例演示
//演示赋值运算符的使用
public class AssignOperator {
//编写一个main方法
public static void main(String[] args) {
int n1 = 10;
n1 += 4;// n1 = n1 + 4;
System.out.println(n1); // 14
n1 -= 5;// n1 = n1 - 4;
System.out.println(n1); // 9
n1 /= 3;// n1 = n1 / 3;
System.out.println(n1); // 3
n1 *= 6;// n1 = n1 * 6;
System.out.println(n1); // 18
n1 %= 2;// n1 = n1 % 2;
System.out.println(n1); // 0
//复合赋值运算符会进行类型转换
byte b = 3;
b += 2; // 等价 b = (byte)(b + 2);
//b = b + 2 这么写是错误的，类型不兼容
b++; // b = (byte)(b+1);
//b = b + 1 这么写是错误的，类型不兼容
}
}
编译运行后的结果和我们分析的一致
3.6 三元运算符
3.6.1 基本语法
条件表达式 ? 表达式 1: 表达式 2;
运算规则：
-
如果条件表达式为 true，运算后的结果是表达式 1；
-
如果条件表达式为 false，运算后的结果是表达式 2；
3.6.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. 返回的结果是99
int result = a > b ? a++ : b--;
System.out.println("result=" + result);
System.out.println("a=" + a);
System.out.println("b=" + b);
int c = 10;
int d = 99;
// 解读
// 1. a < b 为 true
// 2. 返回 a++, 先返回 a的值,然后再a+1
// 3. 返回的结果是 10
int result2 = c < d ? c++ : d--;
System.out.println("result2=" + result2);
System.out.println("c=" + c);
System.out.println("d=" + d);
}
}
编译运行发现结果和我们分析的一模一样
3.6.3 使用细节
-
表达式 1 和表达式 2 要为可以赋给接收变量的类型(或可以自动转换)
-
三元运算符可以转成 if–else 语句
//三元运算符细节
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;//可以的
//等价于
//if(a>b){
// c = (int)1.1
//}else{
// c = (int)3.4
//}
double d = a > b ? a : b + 3;//可以的，满足 int -> double
System.out.println(c);// 3
System.out.println(d);// 11.0
}
}编译运行看一下结果
和我们分析的一模一样
3.6.4 课堂练习
案例：实现三个数的最大值
public class TernaryOperatorExercise {
//编写一个main方法
public static void main(String[] args) {
//案例：实现三个数的最大值
int n1 = 1;
int n2 = 3;
int n3 = 2;
//思路
//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);
}
}编译运行看一下
两种方法都可以得到这三个数中的最大数
3.7 运算符优先级
运算符有不同的优先级，所谓优先级就是表达式运算中的运算顺序。如右表，上一行运算符总优先于下一行。
只有单目运算符、赋值运算符是从右向左运算的。
一览表, 不要背，使用多了，就熟悉了
| . () [] , ; | |
|---|---|
| R–>L | ++ — ~ ! (data type) |
| L–>R | * / % |
| L–>R | + – |
| L–>R | << >> >>> 位移 |
| L–>R | < > <= >= instanceof |
| L–>R | == != |
| L–>R | & |
| L–>R | ^ |
| L–>R | | |
| L–>R | && |
| L–>R | || |
| L–>R | ? : |
| R–>L | = *= /= %= |
| += -= <<= >>= | |
| >>>= &= ^= |
3.8 标识符的命名规则和规范
标识符概念
-
Java对各种变量、方法和类等命名时使用的字符序列称为标识符。
-
凡是自己可以起名字的地方都叫标识符，如
int num1 = 90;
标识符的命名规则（必须遵守）
-
由26个英文字母大小写、0-9、_ 或 $ 组成。
-
数字不能以开头，如
int 3ab = 1;错误。 -
不能使用关键字和保留字，但能包含关键字和保留字。
-
Java中严格区分大小写，长度无限制。如
int totalNum = 10; int n = 90; -
标识符不能包含空格。如
int a b = 90;
3.8.1 判断下面变量名是否正确
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
3.8.2 标识符命名规范[更加专业]
包名：多单词组成时所有字母都小写：aaa.bbb.ccc //比如 com.hsp.crm
类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz [大驼峰]
比如： TankShotGame
变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz [小驼峰， 简称 驼峰法]
比如： tankShotGame
常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ
比如 ：定义一个所得税率 TAX_RATE
后面我们学习到 类，包，接口，等时，我们的命名规范要这样遵守,更加详细的看文档.
3.9 关键字
关键字的定义和特点 (不用背)
定义：被 Java 语言赋予了特殊含义，用做专门用途的字符串（单词）
特点：关键字中所有字母都为小写
用于定义数据类型的关键字
| class | interface | enum | byte | short |
|---|---|---|---|---|
| int | long | float | double | char |
| boolean | void |
用于定义数据类型值的关键字
| true | false | null |
|---|
用于定义流程控制的关键字
| if | else | switch | case | default |
|---|---|---|---|---|
| while | do | for | break | continue |
| return |
用于定义访问权限修饰符的关键字
| 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 |
|---|
3.10 保留字
Java 保留字：现有 Java 版本尚未使用，但以后版本可能会作为关键字使用。自己命名标识符时要避免使用这些保留字 byValue、cast、future、 generic、 inner、 operator、 outer、 rest、 var 、 goto 、const
3.11 键盘输入语句
3.11.1 介绍
在编程中，需要接收用户输入的数据，就可以使用键盘输入语句来获取。Input.java , 需要一个 扫描器(对象), 就是Scanner
3.11.2 步骤 ：
-
导入该类的所在包, java.util.*
-
创建该类对象（声明变量）
-
调用里面的功能
3.11.3 案例演示：
要求：可以从控制台接收用户信息，【姓名，年龄，薪水】
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);
}
}大家可以下去自己运行一下，看看等待用户输入是什么意思
3.12 进制(程序员的基本功)
3.12.1 进制介绍
对于整数，有四种表示方式：
二进制：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 不区分大小写。
3.12.2 举例说明
//演示四种进制
//
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);
}
}编译运行得到
这是不同数字进制经过转换后得到的对应的十进制数
3.13 进制的图示
| 十进制 | 十六进制 | 八进制 | 二进制 |
|---|---|---|---|
| 0 | 0 | 0 | 0 |
| 1 | 1 | 1 | 1 |
| 2 | 2 | 2 | 10 |
| 3 | 3 | 3 | 11 |
| 4 | 4 | 4 | 100 |
| 5 | 5 | 5 | 101 |
| 6 | 6 | 6 | 110 |
| 7 | 7 | 7 | 111 |
| 8 | 8 | 10 | 1000 |
| 9 | 9 | 11 | 1001 |
| 10 | A | 12 | 1010 |
| 11 | B | 13 | 1011 |
| 12 | C | 14 | 1100 |
| 13 | D | 15 | 1101 |
| 14 | E | 16 | 1110 |
| 15 | F | 17 | 1111 |
| 16 | 10 | 20 | 10000 |
| 17 | 11 | 21 | 10001 |
3.14 进制的转换(基本功)
3.14.1 进制转换的介绍
第一组：
二进制转十进制
八进制转十进制
十六进制转十进制
第二组：
十进制转二进制
十进制转八进制
十进制转十六进制
第三组
二进制转八进制
二进制转十六进制
第四组
八进制转二进制
十六进制转二进制
3.15 二进制转换成十进制
规则： 从最低位（右边）开始，将每个位上的数提取出来，乘以2的（位数-1）次方，然后求和。
案例： 请将0b1011转换成十进制的数
0b1011=1×2的(1−1)次方+1×2的(2−1)次方+0×2的(3−1)次方+1×2的(4−1)次方=1+2+0+8=11
因此，二进制数0b1011等于十进制数11
3.16 八进制转换成十进制示例
规则： 从最低位（右边）开始，将每个位上的数提取出来，乘以8的（位数-1）次方，然后求和。
案例： 请将0234转换成十进制的数
0234=4×8的(1-1)次方+3×8的(2-1)次方+2×8的(3-1)次方=4+24+128=156
因此，八进制数0234等于十进制数156
3.17 十六进制转换成十进制示例
规则：从最低位(右边)开始，将每个位上的数提取出来，乘以 16 的(位数-1)次方，然后求和。
案例：请将 0x23A 转成十进制的数
0x23A = 10 * 16的(1-1)次方 + 3 * 16 的 (2-1)次方 + 2 * 16的(3-1)次方 = 10 + 48 + 512 = 570
课堂练习：
请将0b110001100 转成 十进制 128+256+8+4 = 396
02456 转成十进制 6+40+256+1024=1326
0xA45 转成十进制5+64+2560=2629
3.18 十进制转换成二进制
规则：将该数不断除以 2，直到商为 0 为止，然后将每步得到的余数倒过来，就是对应的二进制。
案例：请将 34 转成二进制 = 0B00100010
3.19 十进制转换成八进制
规则：将该数不断除以 8，直到商为 0 为止，然后将每步得到的余数倒过来，就是对应的八进制。和上图类似
案例：请将 131 转成八进制 => 0203
3.20 十进制转换成十六进制
规则：将该数不断除以 16，直到商为 0 为止，然后将每步得到的余数倒过来，就是对应的十六进制。
案例：请将 237 转成十六进制 => 0xED
练习：(一定练习，使用计算器/用程序去验证)
123 转成 二进制 => 0111 1011
678 转成八进制 => 01246
8912 转成十六进制 => 0x22D0
3.21 二进制转换成八进制
规则：从低位开始,将二进制数每三位一组，转成对应的八进制数即可
案例：请将 0b11010101 转成八进制 0b11(3)010(2)101(5) => 0325
3.22 二进制转换成十六进制
规则：从低位开始，将二进制数每四位一组，转成对应的十六进制数即可
案例：请将 0b11010101 转成十六进制 0b1101(D)0101(5) = 0xD5
课堂练习：请将
0b11100101 转成 八进制 – 0b11(3)100(4)101(5)
0b1110010110 转成 十六进制 – 0b11(3)1001(9)0110 (6)
3.23 八进制转换成二进制
规则：将八进制数每 1 位，转成对应的一个 3 位的二进制数即可
案例：请将 0237 转成二进制 02(010)3(011)7(111) = 0b10011111
3.24 十六进制转换成二进制
规则：将十六进制数每 1 位，转成对应的 4 位的一个二进制数即可。
案例：请将 0x23B 转成二进制 0x2(0010)3(0011)B(1011) = 0b001000111011
课堂练习：请将
01230 转成 二进制 – 01(001)2(010)3(011)0(000) – 001010011000
0xAB29 转成二进制 – 0xA(1010)B(1011)2(0010)9(1001)
3.25 位运算的思考题
-
请看下面的代码段，回答 a,b,c,d,e 结果是多少?
public static void main(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);
}2、请回答在 java 中，下面的表达式运算的结果是: (位操作)
~2=? //按位取反
2&3=?// 2 按位与 3
2|3=?
~-5=?
13&7=?
5|4=?
-3^3=?
3.26 二进制在运算中的说明
1、二进制是逢2进位的进位制，0，1是基本算符。
2、现代的电子计算机技术全部采用的是二进制，因为它只使用0、1两个数字符号，非常简单方便，易于用电子方式实现。计算机内部处理的信息，都是采用二进制数来表示的。二进制（Binary）数用0和1两个数字及其组合来表示任何数。进位规则是“逢2进1”，数字1在不同的位上代表不同的值，按从右至左的次序，这个值以2倍递增。
3.27 原码、反码、补码(重点 难点)：
网上对原码、反码、补码的解释过于复杂，我这里精简几句话：（背下来）
对于有符号的而言：
二进制的最高位是符号位：0表示正数，1表示负数（老韩口诀：0->01-> -）
正数的原码、反码、补码都一样（三码合一）
负数的反码=它的原码符号位不变，其他位取反(0->1, 1->0)
负数的补码=它的反码+1，负数的补码 = 负数的原码 – 1
0的反码、补码都是0
Java没有无符号数，换言之，Java中的数都是有符号的
在计算机运算的时候，都是以补码的方式来运算的。
当我们看运算结果的时候，要看它的原码（重点）
3.28 位运算符
3.28.1 java 中有 7 个位运算(&、|、 ^ 、~、>>、<<和 >>>)
分别是按位与&，按位或|，按位异或^，按位取反~，它们的运算规则是：
按位与&：两位全为1，结果为1，否则为0
按位或|：两位有一个为1，结果为1，否则为0
按位异或^：两位一个为0，一个为1，结果为1，否则为0
按位取反~：0->1，1->0
看代码
//位运算
public class BitOperator {
//编写一个main方法
public static void main(String[] args) {
//推导过程：
//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
//推导
//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
//推导
//1. 得到2的补码 00000000 00000000 00000000 00000010
//2. 得到3的补码 00000000 00000000 00000000 00000011
//2. 2|3操作 得到运算后的补码
// 00000000 00000000 00000000 00000011
//3. 运算后的原码 00000000 00000000 00000000 00000011
System.out.println(2|3); //3
//推导
//1. 得到2的补码 00000000 00000000 00000000 00000010
//2. 得到3的补码 00000000 00000000 00000000 00000011
//2. 2^3操作 得到运算后的补码
// 00000000 00000000 00000000 00000001
//3. 运算后的原码 00000000 00000000 00000000 00000001
System.out.println(2^3); //1
}
}编译运行一下我们看结果
结果和我们分析的一样
3.28.2 还有 3 个位运算符 >>、<< 和 >>> , 运算规则:
-
算术右移 >>：低位溢出,符号位不变,并用符号位补溢出的高位
-
算术左移 <<: 符号位不变,低位补 0
-
逻辑右移>>>也叫无符号右移,运算规则是: 低位溢出，高位补 0
-
特别说明：没有 <<< 符号
3.29.3 案例演示
-
int a=1>>2; //1 => 00000001 => 00000000 本质 1 / 2 / 2 =0
-
int c=1<<2; //1 => 00000001 => 00000100 本质 1 * 2 * 2 = 4
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
}
}编译运行一下我们看看
和我们分析的一模一样
位运算掌握我上面讲解的即可，不用再深入
好啦！！！第三部分运算符就到这里啦！！！内容很多，很琐碎，各位小白要下去好好阅读学习哦！！！敬请期待下一章节的程序控制结构吧！！
作者：不容二虎
