运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。 以下是所要介绍的运算符：
● 1) 算术运算符
● 2) 赋值运算符
● 3) 关系运算符 [比较运算符]
● 4) 逻辑运算符
● 5) 位运算符 [需要二进制基础]
● 6) 三元运算符
4.1 算术运算符
4.1.1 介绍
算术运算符是对数值类型的变量进行运算的，在 Java 程序中使用的非常多。
4.1.2 算术运算符一览
4.1.3 案例演示
案例演示算术运算符的使用说明：
- +，-，*，/，%，++，–，重点讲解/，%，++；
a. 对于除号（/）使用注意：如果除数或被除数其有个为小数，则java就认定为double类型！！！
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
b. 取模 ,取余（%）本质：a % b = a - a / b * b
a % b 当a是小数时，公式 = a - (int)a / b * b
// 在 % 的本质 看一个公式!!!! 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
- 自增：++
a. 作为独立的语句使用：前++和后++都完全等价于 i = i + 1；
//++的使用：独立语句
int i = 10;
i++;//自增 等价于 i = i + 1; => i = 11
++i;//自增 等价于 i = i + 1; => i = 12
System.out.println("i=" + i);//12
b. 作为表达式使用：前++：++i先自增后赋值；后++：i++先赋值后自增；
/*
作为表达式使用
前++：++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
- –，+，-，*是一个道理，完全可以类推。
/**
* 演示算术运算符的使用
*/
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
}
}
4.1.4 细节说明
- 对于除号“/”，它的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。例如：int x = 10 / 3，结果是 3；
- 当对一个数取模时，可以等价a % b = a - a / b * b，这样我们可以看到取模一个本质运算。
- 当自增当做一个独立语言使用 ，不管是 ++i，还是i ++，都是一样的，等价于 i = i + 1。
- 当自增当做一个表达式使用时，j = ++ i等价于i = i+1，j = i。
- 但自增当做一个表达式使用时，j = i ++等价于j = i，i = i + 1。
4.1.5 面试题
- 面试题1：
题解：需要使用到临时变量来存储目前i的值
int i = 1;//i->1
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
4.1.6 相关练习
- 假如还有 59 天放假，问：合 xx 个星期零 xx 天 。
public class ArithmeticOperatorExercise02{
public static void main(String[] args){
//1.需求：
//假如还有 59 天放假，问：合 xx 个星期零 xx 天
//2.思路分析：
//（1）使用int 变量days存储59天
//（2）一个星期七天， 星期数用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 + "天");
}
}
- 定义一个变量保存华氏温度，华氏温度转换摄氏温度的公式为：5/9*(华氏温度-100),请求出华氏温度对应的摄氏温度。 [234.5]
public class ArithmeticOperatorExercise02{
public static void main(String[] args){
//1.需求：
// 定义一个变量保存华氏温度，华氏温度转换摄氏温度的公式为：5/9*(华氏温度-100),
// 请求出华氏温度对应的摄氏温度。 [234.5]
// 2.思路分析：
// （1）先定义一个变量double huaShi 保存华氏温度；
// （2）根据给出的公式，进行计算即可5/9*(huaShi-100)；
// 考虑到数学语言和java的特性
// （3）将得到的代码保存到double sheShi。
// 3.代码实现
double huaShi = 123.6;
double sheShi = 5.0 / 9 * (huaShi - 100); // 注意除号那须有一个为小数！！！
System.out.println("华氏温度" + huaShi + " 对应的摄氏温度=" + sheShi);
}
}
4.2 关系运算符（比较运算符）
4.2.1 介绍
关系运算符也叫作比较运算符，进行操作数的比较。关系运算符的结果都是 boolean 型，也就是要么是 true，要么是 false。
关系表达式 经常用在 if 结构的条件中或循环结构的条件中。
4.2.2 关系运算符一览
4.2.3 案例演示
//演示关系运算符的使用
//
public class RelationalOperator {
//编写一个main方法
public static void main(String[] args) {
int a = 9; //爱摸鱼的TT~提示: 开发中，不可以使用 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);
}
}
4.2.4 细节说明
● 1) 关系运算符的结果都是 boolean 型，也就是要么是 true，要么是 false。
● 2) 关系运算符组成的表达式，我们称为关系表达式。 a > b
● 3) 比较运算符"==“不能误写成”="
4.3 逻辑运算符
4.3.1 介绍
用于连接多个条件（多个关系表达式），最终的结果也是一个 boolean 值。
4.3.2 逻辑运算符一览
我们将逻辑运算符分为两组学习：
● 1) 短路与 && ， 短路或 ||，取反 !
● 2) 逻辑与 &，逻辑或 |，^ 逻辑异或
上面表格不用特意背它，理解每个逻辑运算符含义即可，会用会判断就行了。
说明逻辑运算规则：
● 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
4.3.3 &&与&基本规则及区别
二者基本规则：
● 短路与&& 条件 1&&条件 2 两个条件都为 true，结果为 true,否则 false
● 逻辑与& 条件 1&条件 2 两个条件都为 true，结果为 true,否则 false
其区别：
● 1) &&短路与：如果第一个条件为 false，则第二个条件不会判断，最终结果为 false，效率高
● 2) & 逻辑与：不管第一个条件是否为 false，第二个条件都要判断，效率低
● 3) 开发中， 我们使用的基本是使用短路与&&, 效率高
4.3.4 && 和 & 案例演示
案例演示&& 和 & 运算符的使用
/**
* 演示逻辑运算符的使用
*/
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
}
}
4.3.5 || 与 | 基本规则及区别
二者基本规则：
● 短路或|| 条件 1||条件 2 两个条件中只要有一个成立，结果为 true,否则为 false
● |逻辑或 条件 1|条件 2 只要有一个条件成立，结果为 true,否则为 false
其区别：
● 1) ||短路或：如果第一个条件为 true，则第二个条件不会判断，最终结果为 true，效率高
● 2) | 逻辑或：不管第一个条件是否为 true，第二个条件都要判断，效率低
● 3) 开发中，我们基本使用 ||
4.3.6 || 和 | 案例演示
案例演示 || 和 | 运算符的使用：
//演示| || 使用
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
}
}
4.3.7 ! 取反 基本规则
● ! 非（取反） !条件 如果条件本身成立，结果为 false，否则为 true
4.3.8 ^ 异或 基本规则
● a^b: 叫逻辑异或，当 a 和 b 不同时，则结果为 true, 否则为 false
4.3.8 ！^ 案例演示
案例演示 ! ^运算符的使用(InverseOperator.java)
//!和^案例演示
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
}
}
4.3.9 练习题 1 请写出每题的输出结果
4.3.10 练习题 2 请写输出结果
4.4 赋值运算符
4.4.1 介绍
赋值运算符就是将某个运算后的值，赋给指定的变量。
4.4.2 赋值运算符的分类
● 基本赋值运算符 ：int a = 10;
● 复合赋值运算符
+= ，-= ，*= ， /= ，%= 等 , 重点讲解一个 += ，其它的使用是一个道理
a += b; [等价 a = a + b; ]
a -= b; [等价 a = a - b; ]
4.4.3 赋值运算符特点
● 1) 运算顺序从右往左
● int num = a + b + c;
● 2) 赋值运算符的左边 只能是变量,右边 可以是变量、表达式、常量值
■ int num = 20; int num2= 78 * 34 - 10; int num3 = a;
● 3) 复合赋值运算符等价于下面的效果
■ 比如：a+=3;等价于 a=a+3; 其他类推
● 4) 复合赋值运算符会进行类型转换。
■ 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 = (byte)(b+1);
System.out.println("b=" + b);
}
}
4.5 三元运算符
4.5.1 基本语法
条件表达式 ? 表达式 1: 表达式 2;
运算规则：
- 如果条件表达式为 true，运算后的结果是表达式 1；
- 如果条件表达式为 false，运算后的结果是表达式 2；
口诀: [一灯大师：一真大师]
4.5.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);
}
}
4.5.3 使用细节
● 1) 表达式 1 和表达式 2 要为可以赋给接收变量的类型(或可以自动转换)
● 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 ? (int)1.1 : (int)3.4;//可以的
double d = a > b ? a : b + 3;//可以的，满足 int -> double
System.out.println("c =" + c + " d = " + d);
}
}
4.5.4 巩固习题
案例：实现三个数的最大值 TernaryOperatorExercise.java
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);
//使用一条语句实现, 推荐使用上面方法
//爱摸鱼的TT~提示: 后面我们可以使用更好方法,比如排序
// int max = (n1 > n2 ? n1 : n2) > n3 ?
// (n1 > n2 ? n1 : n2) : n3;// 合并写，度读取效率低，不建议
// System.out.println("最大数=" + max);
}
}
4.6 运算符优先级
● 1) 运算符有不同的优先级，所谓优先级就是表达式运算中的运算顺序。如右表，上一行运算符总优先于下一行。
● 2) 只有单目运算符、赋值运算符是从右向左运算的。
● 3) 一览表, 不要背，使用多了，就熟悉了。
4.7 标识符的命名规则和规范
注意这个标题，既有规则和规范，二者是有区别的，规则就是必须遵守的，而规范只是书写的更加专业。
4.7.1 概念
- Java对各种变量、方法和类等命名时使用的字符序列称为标识符
- 凡是自己可以起名字的地方都是标识符，例如 int num1 = 90；
4.7.2 标识符的命名规则（必须遵守）
- 由26个英语字母大小写，数字0-9，下划线_ 或 $ 组成；
- 数字不可以开头，例如int 3ab = 1 ;//错误
- 不可以使用关键字和保留字，但能包含关键字和保留字
- Java中严格区分大小写，长度不限制，例如：int totalNum = 10；int n = 90；
- 标识符不能包含空格，例如：int a b = 90；
4.7.3 判断下面变量名是否正确
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
4.7.4 标识符命名规范[更加专业]
● 1) 包名：多单词组成时所有字母都小写：aaa.bbb.ccc //比如 com.hsp.crm
● 2) 类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz [大驼峰]
● 比如： TankShotGame
● 3) 变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz [小驼峰， 简称 驼峰法]
■ 比如： tankShotGame
● 4) 常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ
■ 比如 ：定义一个所得税率 TAX_RATE
● 5) 后面我们学习到 类，包，接口，等时，我们的命名规范要这样遵守,更加详细的看文档。
4.8 关键字
关键字的定义和特点 (不用背)
- 定义：被 Java 语言赋予了特殊含义，用做专门用途的字符串（单词）
- 特点：关键字中所有字母都为小写
4.9 保留字
Java 保留字：现有 Java 版本尚未使用，但以后版本可能会作为关键字使用。自己命名标识符时要避免使用这些保留字 byValue、cast、future、 generic、 inner、 operator、 outer、 rest、 var 、 goto 、const。
4.10 键盘输入语句
4.10.1 介绍
在编程中，需要接收用户输入的数据，就可以使用键盘输入语句来获取。Input.java , 需要一个扫描器(对象), 就是 Scanner。
4.10.2 使用步骤
● 1) 导入该类的所在包：java.util.*
● 2) 创建该类对象（声明变量）
● 3) 调用里面的功能
4.10.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);
}
}
4.11 进制(程序员的基本功)
4.11.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 不区分大小写。
4.11.2 举例说明 BinaryTest.java
//演示四种进制
//
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);
}
}
4.12 进制的转换(基本功)
4.12.1 进制转换的介绍
● 第一组： （其他进制转十进制）
○ 1) 二进制转十进制
○ 2) 八进制转十进制
○ 3) 十六进制转十进制
● 第二组：（十进制转其他进制）
○ 1) 十进制转二进制
○ 2) 十进制转八进制
○ 3) 十进制转十六进制
● 第三组 （二进制转八、十六进制）
○ 1) 二进制转八进制
○ 2) 二进制转十六进制
● 第四组 （八、十六转二进制）
○ 1) 八进制转二进制
○ 2) 十六进制转二进制
4.12.2 其他进制转换二进制
二进制转换成十进制
规则：从最低位（右边）开始，将每个位上的数提取出来，乘以2的（位数-1）次方，然后求和。
案例：请将0b1011转成十进制的数
八进制转换成十进制
规则：从最低位（右边）开始，将每个位上的数提取出来，乘以8的（位数-1）次方，然后求和。
案例：请将0234转成十进制的数
0234 = 4 * 8^0 + 3 * 8^1 + 2 * 8^2 = 4 + 24 + 128 = 156
十六进制转换成十进制
规则：从最低位(右边)开始，将每个位上的数提取出来，乘以 16 的(位数-1)次方，然后求和。
案例：请将 0x23A 转成十进制的数
0x23A = 10 * 16^0 + 3 * 16^1 + 2 * 16^2 = 10 + 48 + 512 = 570
4.12.3 十进制转其他进制
十进制转换成二进制
规则：将该数不断除以 2，直到商为 0 为止，然后将每步得到的余数倒过来，就是对应的二进制。
案例：请将 34 转成二进制
34 = 0B00100010
十进制转换成八进制
规则：将该数不断除以 8，直到商为 0 为止，然后将每步得到的余数倒过来，就是对应的八进制。
案例：请将 131 转成八进制 => 0203
十进制转换成十六进制
规则：将该数不断除以 16，直到商为 0 为止，然后将每步得到的余数倒过来，就是对应的十六进制。
案例：请将 237 转成十六进制 => 0xED
4.12.4 二进制转八、十六进制
二进制转八进制
规则：从低位开始,将二进制数每三位(2^3 = 8)一组，转成对应的八进制数即可。
案例：请将 ob11010101 转成八进制
ob11(3)010(2)101(5) => 0325
二进制转十六进制
规则：从低位开始，将二进制数每四位(2^4 = 16)一组，转成对应的十六进制数即可。
案例：请将 ob11010101 转成十六进制
ob1101(D)0101(5) = 0xD5
4.12.5 八、十六进制转二进制
八进制转二进制
规则：将八进制数每 1 位，转成对应的一个 3 位的二进制数即可。
案例：请将 0237 转成二进制
02(010)3(011)7(111) = 0b10011111
十六进制转二进制
规则：将十六进制数每 1 位，转成对应的 4 位的一个二进制数即可。
案例：请将 0x23B 转成二进制
0x2(0010)3(0011)B(1011) = 0b001000111011
4.13 位运算思考题
- 请看下面的代码段，回答 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);
}
- 请回答在 java 中，下面的表达式运算的结果是: (位操作)
~2=? // 按位取反
2&3=?// 2 按位与 3
2|3=?
~-5=?
13&7=?
5|4=?
-3^3=?//^ 按位异或
大家看了这两道思考题，是不是蒙圈了呢？感觉啥都没看懂，也没点头绪。是吧，这感觉就对了，你现在还是零基础，目前对这块蒙圈是正常现象，接下来，我会慢慢介绍具体知识点，敬请期待！
4.14 二进制在运算中的说明
- 二进制是逢2进位的进位制，0、1是基本算符。
- 现代的电子计算机技术全部都是采用二进制，因为它只使用0、1两个数字符号，非常简单方便，易于用电子方式实现。计算机内部处理的信息，都是采用二进制数表示的。二进制数用0和1两个数字及其组合来表示任何数。进位规则是“逢2进1”，数字1在不用的位上代表不同的值，按从右至左的次序，这个值以二倍递增。
4.15 原码、反码、补码（重点 难点）
网上对原码、反码、补码的解释过于复杂，我这里精简几句话：（背下来）
对于有符号的而言：
- 二进制的最高位是符号位：0表示正数，1表示负数（口诀：0 ->0 1 ->-)
- 正数的原码、反码、补码都一样（三码合一）
- 负数的反码 = 它的原码符号位不变，其他位取反（0 ->1 1 ->0)
- 负数的补码 = 它的反码 + 1；负数的反码 = 负数的补码 - 1；
- 0的反码、补码都是0
- java没有无符号数，换言之，java中的数都是有符号的
- 在计算机运算的时候，都是以二进制补码的方式来运算的
- 当我们看运算结果的时候，要看他的原码（重点）
4.16 位运算符
4.16.1 java中7个位运算
在Java中，有7个位运算符，分别是&、|、^、~、>>、<<、>>>
它们的运算规则是：
● 按位与&：两位全为1，结果为1，否则为0
● 按位或|：两位有一个为1，结果为1，否则为0
● 按位异或^：两位一个为0，一个为1，结果为1，否则为0
● 按位取反~：0 -> 1 1 -> 0
● 算术右移 >>：低位溢出,符号位不变,并用符号位补溢出的高位
● 算术左移 <<: 符号位不变,低位补 0
● >>> 逻辑右移也叫无符号右移,运算规则是: 低位溢出，高位补 0
■ 特别说明：没有 <<< 符号
//位运算
public class BitOperator {
//编写一个main方法
public static void main(String[] args) {
//看爱摸鱼的TT~的推导过程
//int类型为4个字节，1个字节8位，则一共32位
//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 （补码 - 1）
//4. 运算后的原码 10000000 00000000 00000000 00000011=>-3
System.out.println(~2); //-3
System.out.println(1 >> 2); ///1 => 00000001 => 00000000 本质 1 / 2 / 2 =0
System.out.println(1 << 2); 1 => 00000001 => 00000100 本质 1 * 2 * 2 = 4
System.out.println(4 << 3); // 4 * 2^3 = 32
System.out.println(15 >> 2); // 15 / (2^2) = 3
System.out.println(-10.4%3); // -1.4近似值
int i=66;
System.out.println(++i+i); //++i: i = i + 1 =67, 67 + 67 =134
}
}
以上内容页就到这儿了，建议：掌握爱摸鱼的TT~讲解的即可，不用再深入。
4.17 本章巩固练习
- 计算下列表达式的结果
10/3 = 3；10/5 = 2；10%2 = 0；-10.5%3 = ？
a % b 当a是小数时，公式 = a - (int)a / b * b
//-10.5 % 3 = -10.5 - (-10) / 3 * 3 = -10.5 + 9 = -1.5
//注意：有小数运算，得到结果是近似值，而不是精确值！！！
- 试说出下面代码的结果
int i = 66;
System.out.println(++i+i)// 执行 i = i + 1 => i = 67 => 134
-
在Java中，以下赋值语句正确的是（C D）
A、int num1 = (int)“18”; // 错误，应该是Integer.parseInt(“18”);
B、int num 2 = 18.0; // 错误，double ->int
C、double num3 = 3d; //ok
D、double num4 = 8; //ok int -> double
E、int i = 48;char ch = i + 1; // 错误 int ->char
F、byte b = 19;short s = b + 2; // 错误，int ->short -
试写出将String转换成double类型的语句，以及将char类型转换成String的语句，举例说明即可，写简单代码
String str = "18.8"; // 注意：字符串要可以被转成double
double d1 = Double.parseDouble(str);
char c1 = '爱';
String str2 = c1 + "";
本手册会持续更新，感谢大家的阅读~
对学习Java感兴趣的小伙伴、有任何问题都欢迎大家加我的WeChat：Zxutt_996一起探讨
一起遇到志同道合的我们吧，让我们一起在学习Java的路上打怪升级！加油，未来是我们的~
725
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
