Java基础_运算符
第四章 运算符
运算符是一种特殊的符号,用以表示数据的运算、赋值和比较等。
运算符:
就是对常量或者变量进行操作的符号。
比如: + - * /
表达式:
用运算符把常量或者变量连接起来的,符合Java语法的式子就是表达式。
比如:a + b 这个整体就是表达式。
而其中+是算术运算符的一种,所以这个表达式也称之为 算术表达式
4.1 运算符的种类
-
算数运算符
-
关系运算符 [ 比较运算符 ]
-
逻辑运算符
-
赋值运算符
-
三元运算符
-
位运算符 [ 学习二进制的基础 ]
4.1.1 算数运算符
在 Java 程序中,算术运算符是对数值类型的变量进行运算的,经常会使用到。
运算符 | 运算 | 实现 | 结果 |
---|---|---|---|
+ | 正号 | +9 | 9 |
- | 负号 | z=12; -z |
-12 |
+ | 加 | 6 + 9 | 15 |
- | 减 | 9 - 6 | 3 |
* | 乘 | 6 * 9 | 54 |
/ | 除 | 54 / 3 | 18 |
% | 取余 | 9 / 6 | 3 |
++ ++ |
自增(前):先运算后取值 自增(后):先取值后运算 |
x = 9; y = ++9; x = 9; y = 9++; |
x = 9; y = 10; x = 10; y = 9; |
-- -- |
自减(前):先运算后取值 自减(后):先取值后运算 |
x = 9; y = ++9; x = 9; y = 9++; |
x = 9; y = 8; x = 8; y = 9; |
= | 字符串拼接/连接 | "Xiao"+"Yuan" | "XiaoYuan" |
代码实现:
需求:使用所有运算符进行练习。
-
练习基本运算符的使用
-
重点了解: / 、% 、++ 、--
-
% 取模要注意 数据的类型
-
++ 自增 可以作为独立的语句使用,也可以作为表达式使用
作为独立语句使用时: ++i 和 i++ 都表示 i = i + 1;
作为表达式使用时:
前++ ++i
: ++i 先自增 后赋值
后++ i++
: i++ 先赋值 后自增
【Arithmetic(算数)Operator(运算符)】
//算数运算符运算符进行练习
public class ArithmeticOperator{
//编写一个main方法
public static void main(String[] args){
//此次练习为了便于了解,一律使用 int double String 类型的变量
int num1 = 10; // int ---> 10
int num2 = 90; // int ---> 90
double num3 = 3.33; // double ---> 3.33
double num4 = 4.44; // double ---> 4.44
String num5 = "Xiao"; // String ---> Xiao
String num6 = "Yuan"; // String ---> Yuan
int test2 = + 11; // int ---> 11
int test3 = - 22; // int ---> -22
//正号负号
System.out.println(test2); // 11
System.out.println(test3); // -22
//加法运算 +
double sum1 = num1 + num2; // double ---> int 10 + int 90;
System.out.println(sum1); // double ---> 100.0
//减法运算 -
double sum2 = num2 - num1; // double ---> int 90 - int 10;
System.out.println(sum1); // double ---> 80.0
//乘法运算 *
double sum3 = num1 * num2; // double ---> int 10 * int 90;
System.out.println(sum3); // double ---> 900.0
//除法运算 /
double sum4 = num2 / num1; // double ---> int 90 / int 10;
System.out.println(sum4); // double ---> 9.0
//特例: 除法运算 小数
System.out.println( 10 / 4 ); // int10 / int4 = int 2 ---》 2.5 整数丢失精度
System.out.println( 10.0 / 4 ); // double10 / int 4 = double 2.5 ----> 自动转为精度高的计算
double test1 = 10 / 4; // int10 / int4 = int2后 ----> 自动提升为精度高的变量
System.out.println(test1); // double ---> 2.0
//拼接运算 +
System.out.println(num5 + num6); // String ---> XiaoYuan
//分割线
System.out.println("-----------------------------------------------------------");
//取模运算 % -->取余数
// x % y = x - [(x / y) * y ] ---> 计算全部按照其类型来计算
// 11 % 10 = 11 - [(11/10)*10] = 11 - 1*10 = 11- 10 =1
System.out.println( test2 % num1 ); // int11 / int10 ===> % ===> 1
// -22 % 10 = -22 - [(-22/10)*10] = -22 - [-2*10] = -22 + 20 =-2
System.out.println( test3 % num1 ); // int-22 / int10 ===> % ===> -2
// 90 % -22 = 90 - [(90/-22)*-22] = 90 - [-4*-22] = 90- 88 =2
System.out.println( num2 % test3 ); // int90 / int-22 ===> % ===> 2
// -69 % -66 = -69 - [(-69/-66)*-66] = -69 - [1*-66] = -69 + 66 =-3
System.out.println( -69 % -66 ); // int-69 / int-66 ===> % ===> -3
//分割线
System.out.println("-----------------------------------------------------------");
// 自增运算 ++
int i1 = 1; //定义一个 int 类型的变量 i1
//可以作为独立语句使用,作为独立语句使用时:
//前++ 和 后++ 都可以表示为 i = i + 1;
i1++; // i1 = i1 + 1;
System.out.println("i1自增结束,结果为:" + i1); //int ---> 2
++i1; // i1 = i1 + 1;
System.out.println("i1自增结束,结果为:" + i1); //int ---> 3
//作为表达式使用:
int i2 = 2; // int ---> 2
int i3 = 3; // int ---> 3
//前++ :++i 先自增后赋值
int j1 = ++i2; // 先自增 i2 = i2(=2) + 1; 后赋值 j1 = i2;
System.out.println("j1,结果为:" + j1); //int ---> 3
System.out.println("i2自增结束,结果为:" + i2); //int ---> 3
//后++ :i++ 先赋值后自增
int j2 = i3++; // 先赋值 j2 = i3(=3); 后自增 i3 = i3(=3) + 1;
System.out.println("j2,结果为:" + j2); //int ---> 3
System.out.println("i3自增结束,结果为:" + i3); //int ---> 4
//分割线
System.out.println("-----------------------------------------------------------");
// 自增运算 --
int i11 = 11; //定义一个 int 类型的变量 i11
//可以作为独立语句使用,作为独立语句使用时:
//前-- 和 后-- 都可以表示为 i = i - 1;
i11--; // i11 = i11 - 1;
System.out.println("i1自减结束,结果为:" + i11); //int ---> 10
--i11; // i11 = i11 - 1;
System.out.println("i1自减结束,结果为:" + i11); //int ---> 9
//作为表达式使用:
int i12 = 12; // int ---> 12
int i13 = 13; // int ---> 13
//前-- :--i 先自减后赋值
int j12 = --i12; // 先自减 i12 = i12(=12) - 1; 后赋值 j12 = i12;
System.out.println("j12,结果为:" + j12); //int ---> 11
System.out.println("i12自减结束,结果为:" + i12); //int ---> 11
//后-- :i-- 先赋值后自减
int j13 = i13--; // 先赋值 j13 = i3(=3); 后自减 i13 = i13(=13) - 1;
System.out.println("j13,结果为:" + j13); //int ---> 13
System.out.println("i13自减结束,结果为:" + i13); //int ---> 12
}
}
细节说明:
-
对于 出号'/' , 整数除法运算和小数除法运算是有区别的:整数之间做除法时,只保留整数部分(默认int类型,精度丢失)。
-
对于 取模'%',其底层运算为:
x % y = x - [(x / y) * y]
,这就是取模的运算本质。 -
当 自增 作为 独立语句使用时, ++i 等价于 i++ 等价于 i + 1
-
当自增作为一个表达式使用时,++i 先自增 再赋值
-
当自增作为一个表达式使用时,i++ 先赋值 再自增
面试题:
[ArithmeticOperatorInterview.java]
1、面试题一 :
题目:
int i =1 ;
i = i++;
System.out.println(i);
求 控制台打印的结果?及其如何实现
//面试题练习
public class ArithmeticOperatorInterview{
//编写一个main方法
public static void main(String[] args){
/*
题目:
int i = 1;
i = i++;
System.out.println(i);
求 控制台打印的结果?及其如何实现
*/
int i = 1; // int 类型 ---> 1
// 规则使用临时变量 1、temp = i ; 2、i = i++; 3、i = temp;
/*
先赋值,后自增
自己理解:i = 1 --> i ; i++ --> i = i + 1; i = 1
*/
i = i++; // int 类型 ---> 1
System.out.println(i); // 1
}
}
2、面试题二 :
题目:
int i =1 ;
i = ++1;
System.out.println(i);
求 控制台打印的结果?及其如何实现
//面试题练习
public class ArithmeticOperatorInterview{
//编写一个main方法
public static void main(String[] args){
/*
题目:
int i = 1;
i = ++i;
System.out.println(i);
求 控制台打印的结果?及其如何实现
*/
int i = 1; // int 类型 ---> 1
// 规则使用临时变量 1、i = i++; 2、temp = i; 3、i = temp;
/*
先赋值,后自增
自己理解:i++ --> i = i + 1 --> 2; i = i++ = 2 --> i = i = 2
*/
i = ++i; // int 类型 ---> 2
System.out.println(i); // 2
}
}
运算符练习:
[ArithmeticOperatorExercise01.java]
int num1 = 10;
int num2 = 20'
int sum3 = num1++;
System.out.println("sum3 自增后的结果为:" + sum3);
System.out.println("num2 结果为:" + num2);
sum3 = --num2;
System.out.println("sum3 自减后的结果为:" + sum3);
System.out.println("num2 结果为:" + num2);
//1、自增,自减 练习实现
public class ArithmeticOperatorExercise01{
//编写一个main方法
public static void main(String[] args){
// int 类型 num1 ---> 10
int num1 = 10;
// int 类型 num2 ---> 20
int num2 = 20;
// int 类型 sum3 ---> 10
int sum3 = num1++;
System.out.println("sum3 自增后的结果为:" + sum3); // int ---> 10
System.out.println("num2 结果为:" + num2); // int ---> 20
// int 类型 sum3 ---> 19
sum3 = --num2;
System.out.println("sum3 自减后的结果为:" + sum3); // int ---> 19
System.out.println("num2 结果为:" + num2); // int ---> 19
}
}
[ArithmeticOperatorExercise02.java]
假如还有 59 天放假,问:合 xx 个星期零 xx 天
定义一个变量保存华氏温度,华氏温度转换摄氏温度的公式为:5/9*(华氏温度-100),请求出华氏温度对应的摄氏温度。[234.5]
//2、生活应用题
public class ArithmeticOperatorExercise02{
//编写一个main方法
public static void main(String[] args){
//1、假如还有 59 天放假,问:合 xx 个星期零 xx 天
//需求分析:
//(1) 使用int变量 nearVacation 保存距离放假总天数。
//(2) 定义 一个星期 week 是 7 天 星期数 nearWeek : nearVacation / week
// 距离放假的不足星期的天数:nearDay: nearVacation % week
// 定义 距离放假总天数。
int nearVacation = 59;
// 定义 每一周 时长为七天
int week = 7;
//计算 距离放假的星期数
int nearWeek = nearVacation / week;
//计算 距离放假的不足星期的天数
int nearDay = nearVacation % week;
//在控制台打印 距离需求1
System.out.println("距离放假还有"+ nearVacation + "天,合计:"
+ nearWeek +"个星期零"+ nearDay + "天!");
//2、定义一个变量保存华氏温度,华氏温度转换摄氏温度的公式为:
// 5/9*(华氏温度-100),请求出华氏温度对应的摄氏温度。[234.5]
//声明 一个 double类型的变量 fahrenheit 华氏温度
double fahrenheit;
//声明 一个 double类型的变量 centigrade 摄氏温度
double centigrade;
fahrenheit = 234.5; //把 待求的温度 234.5 赋给 华氏温度
centigrade = 5.0 / 9.0 * (fahrenheit - 100); //计算出对应的摄氏度
//在控制台打印 距离需求2
System.out.println("华氏温度:"+ fahrenheit + "\n对应的摄氏温度为:"+ centigrade);
}
}
4.1.2 关系运算符
关系运算符的结果都是 boolean 型,也就是要么是 true,要么是 false
关系表达式 经常用在 if 结构的条件中或循环结构的条件中
关系运算符也叫比较运算符
运算符 | 运算 | 实现 | 结果 |
---|---|---|---|
== | 相等于 | 6 == 9 | false |
!= | 不等于 | 6 != 9 | true |
< | 小于 | 6 < 9 | true |
> | 大于 | 6 > 9 | false |
<= | 小于等于 | 6 <= 9 | true |
>= | 大于等于 | 6 >= 9 | false |
instanceof | 检查是不是类的对象 | "Xiao" instanceof String | true |
代码实现:
关系运算符的使用 [RelationalOperator.java]
//关系运算符进行练习
public class RelationOperator{
//编写一个main方法
public static void main(String[] args){
//声明一个 变量名为 relationOne 的 int类型变量
int relationOne = 66;
//声明一个 变量名为 relationTwo 的 int类型变量
int relationTwo = 99;
//关系运算符的使用: == != < <= > >= instanceof
System.out.println(relationOne == relationTwo); // Boolean ---> false
System.out.println(relationOne != relationTwo); // Boolean ---> true
System.out.println(relationOne < relationTwo); // Boolean ---> true
System.out.println(relationOne > relationTwo); // Boolean ---> false
System.out.println(relationOne <= relationTwo); // Boolean ---> true
System.out.println(relationOne >= relationTwo); // Boolean ---> false
System.out.println("Yuan" instanceof String); // Boolean ---> true
// System.out.println(int instanceof RelationOperator); // Boolean ---> true
boolean relation = relationOne!=relationTwo;
System.out.println("赋给relation的Boolean类型是:"+ relation);
}
}
细节说明:
-
关系运算符的结果都是 boolean类型,是 true 或者 false。
-
关系运算符组成的表达式,被称为:关系表达式 a == b;
-
比较运算符 '==' 不能写为 '='; 一个是相等 一个是赋值。
4.1.3 逻辑运算符
用于连接多个条件(多个关系表达式),最终的结果也是一个 boolean 值。
- 短路与 && , 短路或 ||,取反 !
运算符 | 运算 | 作用 | 实现 | 结果 |
---|---|---|---|---|
&& | 与 | 左右两边的布尔表达式都为真,结果才为真 | true&&false | false |
|| | 或 | 两边布尔表达式只要有一个为真,结果为真 | true&&false | true |
! | 非 | 布尔表达式为真,结果为假 布尔表达式为假,结果为假 |
!(true) | false |
^(作为逻辑运算符时) | 异或 | 两边布尔表达式都为真,结果为假 只有一边的表达式为真,结果为真 |
true^true | false |
- 逻辑与 &,逻辑或 |,^ 逻辑异或
运算符 | 运算 | 作用 | 实现 | 结果 |
---|---|---|---|---|
& | 与 | 左右两边的布尔表达式都为真,结果才为真 | true&&false | false |
| | 或 | 两边布尔表达式只要有一个为真,结果为真 | true&&false | true |
! | 非 | 布尔表达式为真,结果为假 | !true | false |
^(作为逻辑运算符时) | 异或 | 两边布尔表达式都为真,结果为假 只有一边的表达式为真,结果为真 |
true^true | false |
- 说明逻辑运算规则:
-
a&b : & 叫逻辑与:规则:当 a 和 b 同时为 true ,则结果为 true, 否则为 false
true & true --> true
true & false --> false
左边不为真,输出false -
a&&b : && 叫短路与:规则:当 a 和 b 同时为 true ,则结果为 true,否则为 false
true & true --> true
true & false --> false
全部不为真,输出false -
a|b : | 叫逻辑或,规则:当 a 和 b ,有一个为 true ,则结果为 true,否则为 false
true & true --> false
true & false --> true
-
a||b : || 叫短路或,规则:当 a 和 b ,有一个为 true ,则结果为 true,否则为 false
-
!a : 叫取反,或者非运算。当 a 为 true, 则结果为 false, 当 a 为 false 是,结果为 true
-
a^b: 叫逻辑异或,当 a 和 b 不同时,则结果为 true, 否则为 false
逻辑与 &
短路与 &&
基本规则:
名称 | 语法 | 特点 |
---|---|---|
短路与&& | 条件 1 && 条件 2 | 两个条件都为 true,结果为 true,否则 false |
逻辑与& | 条件 1 & 条件 2 | 两个条件都为 true,结果为 true,否则 false |
使用区别:
-
& 逻辑与:不管第一个条件是否为 false,第二个条件都会判断。
-
&& 短路与:如果第一个条件为 false,则第二个条件不会判断,最终结果为 false。
-
在正常项目开发中, 我们会优选选择 短路与&&,开发效率相对较高。
代码实现:
// 逻辑运算符的使用案例
public class LogicOperator01{
//编写一个main方法
public static void main(String[] args){
//声明一个 boyAge 的int变量
int boyAge = 21; // int ---> 21
//声明一个 girlAge 的int变量
int girlAge = 22; // int ---> 22
// 逻辑运算符 -- & 逻辑与 和 && 短路与
// 1、if语句 逻辑与&
if( boyAge < 22 & girlAge > 20 ){
//在控制台打印 if语句无误
System.out.println("if语句成立,输出逻辑与&相关信息--true!");
} // 语句为 true
// 2、if语句 逻辑与&&
if( boyAge < 22 && girlAge > 20 ){
//在控制台打印 if语句无误
System.out.println("if语句成立,输出逻辑与&&相关信息--true!");
} // 语句为 true
// 3、if语句 逻辑与& 错误判断
if( girlAge < 16 & boyAge > 18 ){
//在控制台打印 if语句无误
System.out.println("if语句成立,输出逻辑与&相关信息--false!");
} // 语句为 false
// 4、if语句 逻辑与&& 错误判断
if( boyAge < 22 && girlAge > 20 ){
//在控制台打印 if语句无误
System.out.println("if语句成立,输出逻辑与&&相关信息--false!");
} // 语句为 false
//分隔符
System.out.println("---------------------------------");
// 逻辑 & 不管第一个条件是否为 false,第二个条件都会判断。
if( boyAge < 20 & ++girlAge > 20 ){
//在控制台打印 --- 条件全部执行
System.out.println("if语句条件全部执行,输出逻辑与&相关信息--false!");
} // 语句为 false
System.out.println("boyAge的数值为:"+ boyAge + "。girlAge的数值为:" + girlAge);
// && 短路与:如果第一个条件为 false,则第二个条件不会判断,最终结果为 false。
if( --girlAge < 20 && ++boyAge > 20 ){
//在控制台打印 --- 条件全部执行
System.out.println("if语句条件全部执行,输出逻辑与&&相关信息--false!");
} // 语句为 false
System.out.println("boyAge的数值为:"+ boyAge + "。girlAge的数值为:" + girlAge);
//分隔符
System.out.println("---------------------------------");
//测试--前面为true,后面是否执行 短路与&&
if( --boyAge < 25 && --girlAge > 25 )
{
//在控制台打印 --- 前半句为true,后半句为 false --- 》 false
System.out.println("前半句为true,后半句为 false --- 》 false");
}
System.out.println("boyAge的数值为:"+ boyAge + "。girlAge的数值为:" + girlAge);
}
}
逻辑或 |
, 短路或 ||
基本规则:
名称 | 语法 | 特点 |
---|---|---|
逻辑或 | | 条件 1|条件 2 | 只要有一个条件成立,结果为 true,否则为 false |
短路或 | | 条件 1| |
使用区别:
-
| 逻辑或:不管第一个条件是否为 true,第二个条件都要判断。
-
||短路或:如果第一个条件为 true,则第二个条件不会判断,最终结果为 true。
-
在正常项目开发中, 我们会优选选择 短路或 ||,开发效率相对较高。
代码实现:
// 逻辑运算符的使用案例
public class LogicOperator02{
//编写一个main方法
public static void main(String[] args){
//声明一个 appleNum 的int变量
int appleNum = 66; // int ---> 21
//声明一个 eggNum 的int变量
int eggNum = 99; // int ---> 22
// 逻辑运算符 -- | 逻辑或 和 || 短路或
// 逻辑或 | 只要有一个条件成立,结果为 true,否则为 false
if( appleNum < 100 | eggNum > 100){
System.out.println("1条件成立,输出结果为:True");
}
// 逻辑或 || 只要有一个条件成立,结果为 true,否则为false
if( appleNum < 100 || eggNum > 100){
System.out.println("2条件成立,输出结果为:True");
} else {
System.out.println("条件不成立,输出结果为:False");
}
// | 逻辑或:不管第一个条件是否为 true,第二个条件都要判断。
if( ++appleNum > 110 | ++eggNum > 110){
System.out.println("3条件成立,输出结果为:True");
}
System.out.println("ApllleNum的数量为:"+ appleNum + ",EggNum的数量为:"+ eggNum);
// ||短路或:如果第一个条件为 true,则第二个条件不会判断,最终结果为 true。
if( --appleNum > 110 || --eggNum > 110){
System.out.println("4条件成立,输出结果为:True");
}
System.out.println("ApllleNum的数量为:"+ appleNum + ",EggNum的数量为:"+ eggNum);
}
}
逻辑非 !
, 逻辑异或 ^
基本规则:
名称 | 语法 | 特点 |
---|---|---|
逻辑非 ! (取反) | !条件 | 如果条件本身成立,结果为 false,否则为 true |
逻辑异或 ^ | 条件 1 ^ 条件 2 | 当 条件1 和 条件2 不同时, 则结果为 true, 否则为 false |
代码实现:
// 逻辑运算符的使用案例
public class LogicOperator03{
//编写一个main方法
public static void main(String[] args){
int num1 = 66;
int num2 = 99;
//!是 逻辑非 取值反 ===》 !true = false
System.out.println(num1 < num2); // boolean ---> true
System.out.println(!(num1 < num2)); // boolean ---> false
System.out.println(num1 > num2); // boolean ---> false
System.out.println((num1 > num2) == !(num1 < num2)); // boolean ---> true
//分隔符
System.out.println("---------------------------------");
// ^ 是 逻辑异或 ,当 条件1 和 条件2 不同时,结果为true,否则为 false
boolean sum3 = (num1 > 1) ^ (num2 > 2);
System.out.println("sum3的结果为:"+ sum3); // boolean ---> false
System.out.println((num1 < num2) ^ (num1 > num2)); // boolean ---> true
System.out.println((num1 < 100) ^ (num2 < 100)); // boolean ---> false
}
}
逻辑运算符 代码练习:
练习一、
//逻辑运算符 代码练习:
public class LoginOperatorExercise01{
//编写一个main方法
public static void main(String[] args){
//定义两个 int 变量
int num1 = 9;
int num2 = 9;
//第一题 --> 10 10
if( num1++ == 10 & ++num2 == 10 ){
num1 = 99;
}
System.out.println("1、num1的值为:"+ num1 + ",num2的值为:" + num2);
//定义两个 int 变量
int num3 = 9;
int num4 = 9;
//第二题 --> 10 9
if( num3++ == 10 && ++num4 == 10 ){
num3 = 99;
}
System.out.println("1、num3的值为:"+ num3 + ",num4的值为:" + num4);
//定义两个 int 变量
int num5 = 9;
int num6 = 9;
//第三题 --> 99 10
if( num5++ == 9 | ++num6 == 9 ){
num5 = 99;
}
System.out.println("1、num5的值为:"+ num5 + ",num6的值为:" + num6);
//定义两个 int 变量
int num7 = 9;
int num8 = 9;
//第四题 --> 99 9
if( num7++ == 9 || ++num8 == 9){
num7 = 99;
}
System.out.println("1、num7的值为:"+ num7 + ",num8的值为:" + num8);
}
}
练习二、
//逻辑运算符 代码练习:
public class LoginOperatorExercise02{
//编写一个main方法
public static void main(String[] args){
//定义两个 boolean 类型的变量
boolean x = true;
boolean y = false;
//定义一个 short 类型的变量
short z = 96;
//首先判断 : true && y = true ==> true z = 97; y = true;
if(( z++ == 96 ) && ( y = true)){
z++; // z = 98
// if判断:false || true ==> true x = false; z = 99;
if(( x = false ) || ( ++z == 99 )){
z++; // z= 100
}
}
System.out.println("输出z的最终值为:"+ z );
}
}
4.1.4 赋值运算符
赋值运算符就是将某个运算后的值,赋给指定的变量。
赋值运算符的分类
- 基本赋值运算符 [ = ]
int number = 99
double number = 99.99
=
等号赋值
- 复合赋值运算符
[ +=、-=、*=、/=、%= 以及其他 = ]
a += b;
======> a = a + b;
a -= b;
======> a = a - b;
a *= b;
======> a = a * b;
a /= b;
======> a = a / b;
a %= b;
======> a = a % b;
-
复合赋值运算符基本使用 [ AssignOperator.java ]
-
基本赋值运算符 [
int num1 = 10
] -
复合赋值运算符 [
num1 += 10
]
//赋值运算符的基本使用
public class AssignOperator{
//编写一个main方法
public static void main(String[] args){
//基本赋值运算符的使用
int num1 = 10; // 10
num1 = 33; //将常量33 赋给变量num1
//复合赋值运算符的使用
int num2 = 66; // 66
num2 += num1; // num2 = num2 + num1; 66 + 33 = 99;
System.out.println("复合运算后的值为:"+ num2);
}
}
赋值运算符的特点
-
运算顺序:从右往左
int number = num1 + num2 + num3;
先运算再赋给number -
赋值运算符的 左边 只能是变量,右边 可以是变量、表达式、常量值
int number = 33;
int number = 33 * 3 * 4 /4;
int number = number;
-
复合赋值运算符的本质是
变量 复合运算符 常量 ===> 变量 = 变量 运算符 常量
-
复合赋值运算符会进行类型转换
byte be1 = 9;
be1 += 1 ===> be1 = be1 + 1;
be1++; ===> be1 = be1 + 1;
其中后两个涉及到了强制转换,因为 变量+常量 自动提升为 int类型
代码实现:
//赋值运算符的基本使用
public class AssignOperator{
//编写一个main方法
public static void main(String[] args){
//基本赋值运算符的使用
int num1 = 10; // 10
num1 = 33; //将常量33 赋给变量num1
//复合赋值运算符的使用
int num2 = 66; // 66
num2 += num1; // num2 = num2 + num1; 66 + 33 = 99;
System.out.println("复合运算后的值为:"+ num2);
//运算顺序:从右往左
//赋值运算符的 左边 只能是变量,右边 可以是变量、表达式、常量值
int sum = num1 + num2 * 2; // 将 运算后的值赋给 变量sum
System.out.println("sum的值为:"+ sum); // 231
//复合赋值运算符会进行类型转换
byte be1 = 9; // 9
byte be2 = 6; // 6
System.out.println("be1的值为:"+ be1);
System.out.println("be2的值为:"+ be2);
be1 += 1; // be1 = (byte)(be1 + 1);
// be2 = be2 + 2; // 从int转换到byte可能会有损失
System.out.println("+=be1的值为:"+ be1);
//System.out.println("be2的值为:"+ be2);
be1++; // be1 = (byte)(be1 + 1);
System.out.println("be1++的值为:"+ be1);
}
}
4.1.5 三元运算符
基本语法: 条件表达式 ? 表达式 1: 表达式 2;
运算规则:
-
对条件表达式进行运算判断,为 true 或 false;
-
如果条件表达式为 true,运算后的结果是表达式 1;
-
如果条件表达式为 false,运算后的结果是表达式 2;
基本使用:
【TernartOperator.java】
//三元运算符的基本使用
public class TernaryOperator{
//编写一个main方法
public static void main(String[] args){
//定义两个int类型的变量 方便比较
int small = 33; // 33
int big = 66; // 66
/*
1. small > big 为false;
2. 然后执行条件2 big++;
3. 后++ 先赋值后增加 故 result1 = 66;
4. 返回的结果为: 66;
*/
int result1 = small > big ? small++ : big++;
int result2 = small < big ? small-- : big--;
System.out.println("条件表达式判断为 false 时候的值为" + result1); //66
System.out.println("条件表达式判断为 true 时候的值为" + result2); //33
}
}
细节说明:
-
表达式 1 和表达式 2 要为可以赋给接收变量的类型(或可以自动转换)
-
三元运算符 可以转成 if--else 语句
//三元运算符
int result = big > small > big++ : small--;
//if -- else 语句
if(big > small){
result = big ++;
} else {
result = small --;
}
细节代码实现:
//三元运算符的使用细节
public class TernaryOperatorDetail{
//编写一个main方法
public static void main(String[] args){
//表达式 1 和表达式 2 要为可以赋给接收变量的类型
//(也可以自动转换和强制转换)
int num1 = 33;
int num2 = 66;
double num3 = 99.99;
double num4 = 3.14;
//直接赋给 sum int类型
int sum1 = num1 > num2 ? 99 : 88;
// int sum = num1 > num2 ? num3 : num4;
//从double转换到int可能会有损失 故需要强制类型转换
int sum = num1 > num2 ? (int)num3 : (int)num4;
// 从 int ==》 double 可以完成自动转换
double sum0 = num3 > num4 ? num1 : num2 + 1;
System.out.println("相同 类型的值为" + sum1); // 88
System.out.println("int 类型的值为" + sum); // 3
System.out.println("double 类型的值为" + sum0); // 33.0
}
}
代码实现:
实现三个数取最大值 【 TernaryOperatorDetail.java 】
//三元运算符的代码练习
public class TernaryOperatorExercise{
//编写一个main方法
public static void main(String[] args){
//实现三个数取最大值
int num1 = 33;
int num2 = 66;
int num3 = 99;
//通过三元运算符实现 比较
//先通过两个值的比较 num1 和 num2 得到最大值 保存到 max1 里
//然后比较 max1 和 第三个值 得到最大值 最后 得到最大值 max2
int max1 = num1 > num2 ? num1 : num2; //比较 num1 和 num2
int max2 = max1 > num3 ? max1 : num3; //比较 max1 和 num3
System.out.println("三个数中的最大值为:"+ max2); // 最大值为:99
//通过三元运算符实现 一条语句
//程序优化上 不建议使用这条语句 因为 程序重复执行
int max = (num1 > num2 ? num1 : num2) > num3 ? (num1 > num2 ? num1 : num2) : num3;
}
}
4.1.6 位运算符
位运算符有七个,分为两类:
- 逻辑位运算符:位与(&)、位或(|)、位异或(^)、非位(~)
- 移位运算符:左移(<<)、右移(>>)、无符号右移(>>>)
位运算符表-逻辑位运算符
位运算符 | 名称 | 作用 | 举例 | 结果 |
---|---|---|---|---|
& | 按位与 | 两个位都为1,结果才为1 | 2&4 | 0 |
I | 按位或 | 两个位有一个为1,结果为1 | 2I4 | 6 |
~ | 按位求反 | 位为0,结果为1 位为0,结果为1 |
~2 | -3 |
^(用作位运算符时) | 按位异或 | 两个位都为0,结果为1 | 2^4 | 6 |
逻辑位运算符的基本使用:
//位运算 的基本使用
public class BitOperator{
//编写一个main方法
public static void main(String[] args){
// 按位与 & 的基本使用
// 数值自动判定为 int类型
/* 1.先得到2的原码 --> 00000000 00000000 00000000 00000010
* 然后得到2的补码 --> 00000000 00000000 00000000 00000010
* 2.先得到3的原码 --> 00000000 00000000 00000000 00000011
* 然后得到3的补码 --> 00000000 00000000 00000000 00000011
* 4.执行 按位与 判断
* 2的补码 00000000 00000000 00000000 00000010
* 3的补码 00000000 00000000 00000000 00000011
* ----------------------------------------------------------------
* 按位与后的补码 00000000 00000000 00000000 00000010
* 运算后的原码 00000000 00000000 00000000 00000010
* 故结果为: 2
*/
System.out.println(2&3); // int --> 2
// 按位取反 ~ 的基本使用
// 数值自动判定为 int类型
/* 1.先得到2的原码 --> 10000000 00000000 00000000 00000010
* 然后的到2的反码 --> 11111111 11111111 11111111 11111101
* 然后得到2的补码 --> 11111111 11111111 11111111 11111110
* 2.执行运算 按位取反
* 取反后的补码 结果 --> 00000000 00000000 00000000 00000001
* 取反后的原码为 --> 00000000 00000000 00000000 00000001
* 3.先得到3的原码 --> 00000000 00000000 00000000 00000011
* 然后得到3的补码 --> 00000000 00000000 00000000 00000011
* 4.执行运算 按位取反
* 取反后的补码 11111111 11111111 11111111 11111011
* 取反后的原码 100000000 00000000 00000000 00000100
* ----------------------------------------------------------------
* ~-2 ---> 1 ~3 ---> -4
*/
System.out.println(~-2); // 1
System.out.println(~3); //-4
// 按位或的基本使用
// 数值自动判定为 int类型
/* 1.先得到2的原码 --> 00000000 00000000 00000000 00000010
* 然后得到2的补码 --> 00000000 00000000 00000000 00000010
* 2.先得到3的原码 --> 00000000 00000000 00000000 00000011
* 然后得到3的补码 --> 00000000 00000000 00000000 00000011
* 4.执行运算 按位或
* 2的补码 00000000 00000000 00000000 00000010
* 3的补码 00000000 00000000 00000000 00000011
* ----------------------------------------------------------------
* 按位或后的补码 00000000 00000000 00000000 00000011
* 运算后的原码 00000000 00000000 00000000 00000011
* 故结果为: 3
*/
System.out.println(2|3);
// 按位异或的基本使用
// 数值自动判定为 int类型
/* 1.先得到2的原码 --> 00000000 00000000 00000000 00000010
* 然后得到2的补码 --> 00000000 00000000 00000000 00000010
* 2.先得到3的原码 --> 00000000 00000000 00000000 00000011
* 然后得到3的补码 --> 00000000 00000000 00000000 00000011
* 4.执行运算 按位或
* 2的补码 00000000 00000000 00000000 00000010
* 3的补码 00000000 00000000 00000000 00000011
* ----------------------------------------------------------------
* 按位或后的补码 00000000 00000000 00000000 0000001
* 运算后的原码 00000000 00000000 00000000 00000001
* 故结果为: 1
*/
System.out.println(2^3);
}
}
位运算符表-移位运算符
位运算符 | 名称 | 作用 | 举例 | 结果 |
---|---|---|---|---|
<< | 算数左移 | 符号位不变,低位补 0 其实就是 左边的值 * 2^右边的值 |
2 << 2 | 8 |
>> | 算数右移 | 低位溢出,符号位不变,并用符号位补溢出的高位 其实就是 左边的值 / 2^右边的值 |
4 >> 2 | 1 |
>>> | 逻辑右移 无符号右移 |
低位溢出,高位补 0 符号位也参与移动,空位补0,被移除的舍去 |
1 >>> 3 | 0 |
逻辑位运算符的基本使用:
//位运算 移位运算符 的基本使用
public class BitOperator01{
//编写一个main方法
public static void main(String[] args){
/*
* 1. int 22的原码为: 00000000 00000000 00000000 00010110;
* 2. 22 的 补码为: 00000000 00000000 00000000 00010110;
* 3. 符号位不变 , 向左移两个位数 ,低位补0
* 4. << 后的补码为:00000000 00000000 00000000 01011000;
* << 后的原码为:00000000 00000000 00000000 01011000;
* 5. 本质为:22 * 2 * 2 ==> 22 * 2^2 = 88
*/
int num1 = 22 << 2 ;
/*
* 1. int 88的原码为: 00000000 00000000 00000000 01011000;
* 2. 88 的 补码为: 00000000 00000000 00000000 01011000;
* 3. 符号位不变 , 向右移两个位数 ,符号位补溢出位置
* 4. >> 后的补码为:00000000 00000000 00000000 00010110;
* >> 后的原码为:00000000 00000000 00000000 00010110;
* 5. 本质为:88 / 2 / 2 ==> 88 / 2^2 = 22
*/
int num2 = 88 >> 2 ;
/*
* 1. int 88的原码为: 00000000 00000000 00000000 01011000;
* 2. 88 的 补码为: 00000000 00000000 00000000 01011000;
* 3. 符号位也参与移动,空位补0,被移除的舍去
* 4. >>> 后的补码为:00000000 00000000 00000000 00010110;
* >>> 后的原码为:00000000 00000000 00000000 00010110;
* 5. 本质为:88 / 2 / 2 ==> 88 / 2^2 = 22
*/
int num3 = 88 >>> 2;
System.out.println(num1); // 88
System.out.println(num2); // 22
System.out.println(num3); // 22
}
}
位运算符表的基本使用:
//位运算的思考猜测
public class BitOperator02{
//编写一个main方法
public static void main(String[] args){
int n1 = 1 >> 2; //算术右移
int n2 = -1 >> 2; //算术右移
int n3 = 1 >> 2; //算术左移
int n4 = -1 >> 2; //算术左移
int n5 = -1 >>> 2; //逻辑右移
//以上移位运算符的结果为:
System.out.println("n1="+ n1); //0
System.out.println("n2="+ n2); //-1
System.out.println("n3="+ n3); //0
System.out.println("n4="+ n4); //-1
System.out.println("n5="+ n5); //1073741823
//以下逻辑位运算符为
System.out.println(~2);//按位取反 -3
System.out.println(~-5);//按位取反 4
System.out.println(2&3);//按位与 2
System.out.println(13&7);//按位与 5
System.out.println(2|3);//按位或 3
System.out.println(5|4);//按位或 5
System.out.println(-3^3);//按位异或 -2
}
}
4.1.7 运算符优先级
-
运算符又不同的优先级,所谓的优先级就是表达式运算中的运算顺序。
-
运算符中从右往左运算的是:单目运算符、赋值运算符。
-
表格中的上一行运算符优先于下一行运算符。
. () {} ; , | |
---|---|
Right ——> Left | ++ -- ~ !(data type) |
Left ——> Right | * / % |
Left ——> Right | + - |
Left ——> Right | << >> >>> 位移 |
Left ——> Right | < > <= >= instanceof |
Left ——> Right | == != |
Left ——> Right | & |
Left ——> Right | ^ |
Left ——> Right | |
Left ——> Right | && |
Left ——> Right | |
Left ——> Right | ? : |
Right ——> Left | = *= /= %= |
+= -= <<= >>= | |
>>>= &= ^= |= |
4.1.7 运算符综合练习
计算下列表达式的结果
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.parselnt("18") ;
B) int num2= 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; shorts = b+2; //错误int -> short试写出将String转换成double类型的语句, 以及将char类型转换成String的语句,举例
说明即可,写简单代码
String str = "18.8";//注意字符串要可以被转成double
double d1 = Double.parseDouble(str);
charc1 = '原';
String str2 = c1 + "";
4.2 标识符的命名规则和命名规范
标识符的概念
-
Java 对各种变量、方法和类等命名时使用的字符序列称为标识符
-
简称-凡是可以自己定义名称的地方都叫标识符 int number = 100; number为标识符。
标识符的命名规则
-
只能由26个字母大小写,数字0-9,_或$组成(不能有空格)
-
不能由数字开头
-
严格区分大小写
-
不能使用关键字和保留字,但是能包含关键字和保留字
代码练习:
//命名规范的练习
public class VariableJudgment{
//编写一个main方法
public static void main(String[] args){
int yuan; // 可以 由26个字母大小写,数字0-9,_或$组成
int yuan01; // 可以 由26个字母大小写,数字0-9,_或$组成
int 0yuan; // 不可以 不能以数字开头
int x-y; // 不可以 不能有 - 符号
int x y; // 不可一 变量名不能有空格
int x$y; // 可以 由26个字母大小写,数字0-9,_或$组成
int class; //不可以 不能用关键字
int int; //不可以 不能用关键字
int double; //不可以 不能用关键字
int public; //不可以 不能用关键字
int static; //不可以 不能用关键字
int goto; //不可以 不能用保留字
int xiao_yuan; // 可以 由26个字母大小写,数字0-9,_或$组成
}
}
标识符命名规[基础版]
- 包名:
多单词组成时所有字母都小写:aaa.bbb.ccc //比如 com.hsp.crm
- 类名、接口名:
多单词组成时,所有单词的首字母大写:XxxYyyZzz [大驼峰]
比如: TankShotGame
- 变量名、方法名:
多单词组成时,第一个单词首字母小写,第二个单词开始每个单词首字母大写:xxxYyyZzz [小驼峰,简称 驼峰法] 比如: tankShotGame
- 常量名:
所有字母都大写。多单词时每个单词用下划线连接:XXX_YYY_ZZZ
比如 :定义一个所得税率 TAX_RATE.
- 后面我们学习到 类,包,接口,等时,我们的命名规范要这样遵守,更加详细的看文档.
代码示例:
//命名规范的示例
public class NamingRules{
//编写一个main方法
public static void main(String[] args){
//不能包含空格
// int a B = 999; // ××××××
//不能由数字开头
// int 01Test = 100; // ××××××
//不能使用关键字和保留字,但是能包含关键字和保留字
// int class = 10 ; // ××××××
int class01 = 10 ; // √√√√√√
//严格区分大小写
int n = 1; // √√√√√√
int N = 2; // √√√√√√
System.out.println(n == N); // false 不相等
System.out.println(n + N + " = 1 + 2"); // false 不相等
// abc 和 aBc 是两个不同的变量
int abc = 33;
int aBc = 66;
System.out.println(abc == aBc); // false 不相等
System.out.println(abc + aBc + " = 33 + 66");
4.3 关键字
48个关键字:
abstract、assert、boolean、break、byte、case、catch、char、class、continue、default、do、double、else、enum、extends、final、finally、float、for、if、implements、import、int、interface、instanceof、long、native、new、package、private、protected、public、return、short、static、strictfp、super、switch、synchronized、this、throw、throws、transient、try、void、volatile、while。
4.4 保留字
Java 保留字:现有 Java 版本尚未使用,但以后版本可能会作为关键字使用。自己命名标识符时要避免使用这些保留字。
2个保留字(现在没用以后可能用到作为关键字):goto、const。
byValue、cast、future、 generic、 inner、 operator、 outer、 rest、 var 、 goto 、const
3个特殊直接量:true、false、null。
4.5 键盘输入语句
在编程中,需要接收用户输入的数据,就可以使用键盘输入语句来获取。Input.java , 需要一个扫描器(对象), 就是Scanner
实现步骤:
-
导入该类的所在包, java.util.*
-
创建该类对象(声明变量)
-
调用里面的功能
代码实现:
要求:可以从控制台接收用户信息,【姓名,年龄,薪水】
//键盘输入的练习
import java.util.Scanner; //导入 java.util 下的 Scanner 类
public class Input{
//编写一个main方法
public static void main(String[] args){
//要求:可以从控制台接收用户信息,【姓名,年龄,薪水】
//需求实现:
//1. 导入 java.util 下的 Scanner 类
//2. 创建 Scanner 对象 实例 --> scanner 就是 Scanner 类的对象
//3. 调用 Scanner 里面的方法 获取用户输入的信息
//创建 扫描器 实例
Scanner scanner = new Scanner(System.in);
//接受用户输入信息
System.out.println("请输入用户的姓名:");
//当程序执行到 next 方法时,会等待用户输入
String userName = scanner.next();
//接受用户输入信息
System.out.println("请输入用户的年龄:");
//当程序执行到 next 方法时,会等待用户输入
int userAge = scanner.nextInt();
//接受用户输入信息
System.out.println("请输入用户的薪水:");
//当程序执行到 next 方法时,会等待用户输入
double userSalary = scanner.nextDouble();
System.out.println("--------以下为用户的基本信息--------");
System.out.println("用户姓名:" + userName
+ "\t用户年龄:" + userAge
+ "\t用户收入:" + userSalary
);
}
}
4.6 进制(程序员的基本功)
十进制 | 十六进制 | 八进制 | 二进制 |
---|---|---|---|
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/a | 12 | 1010 |
11 | B/a | 13 | 1011 |
12 | C/c | 14 | 1100 |
13 | D/d | 15 | 1101 |
14 | E/e | 16 | 1110 |
15 | F/f | 17 | 1111 |
16 | 10 | 20 | 10000 |
17 | 11 | 21 | 10001 |
4.6.1 进制介绍
对于整数,有四种表示方式:
二进制:0,1
,满 2 进 1. 以 0b 或 0B 开头。
---------- 二进制是Binary,简写为B
十进制:0-9
,满 10 进 1.
---------- 十进制是Decimal,简写为D
八进制:0-7
,满 8 进 1. 以数字 0 开头表示。
---------- 八进制是Octal,简写为O
十六进制:0-9 及 A(10)-F(15)
,满 16 进 1. 以 0x 或 0X 开头表示。此处的 A-F 不区分大小写。
---------- 十六进制为Hexadecimal,简写为H
代码实现:
BinaryTest.java
//四种进制的格式信息
public class BinaryTest{
//编写一个main方法
public static void main(String[] args){
//用二进制表示
int base2 = 0B1111; // int --->15
//用八进制表示
int base8 = 01121; // int --->
//用十进制表示
int base10 = 1121; // int --->
//用十六进制表示
int base16 = 0X1121; // int --->
System.out.println("二进制为:"+ base2); //15
System.out.println("八进制为:"+ base8); //593
System.out.println("十进制为:"+ base10); //1121
System.out.println("十六进制为:"+ base16); //4385
System.out.println(0X1121B); //70171
}
}
4.6.2 进制的转换(基本功)
-
进制转十进制
二进制转十进制;
八进制转十进制;
十六进制转十进制;
-
十进制转进制
十进制转二进制;
十进制转八进制;
十进制转十六进制;
-
二进制转进制
二进制转八进制;
二进制转十六进制;
-
进制转二进制
八进制转二进制;
十六进制转二进制;
一、进制转十进制
以 1100 为例,分别以二进制,八进制,十六进制转换为 十进制
1. 二进制转十进制
转换方法:
从最低位(右边)开始,将每个位上的数提取出来,乘以2的(位数- 1)次方,然后求和。
二进制 0b1100 --> 十进制:
1 * 2³(2的(位数4 -1)次方) + 1 * 2²(2的(位数3 -1)次方) + 0 * 2 + 0 *1 = 12
2. 八进制转十进制
转换方法:
从最低位(右边)开始,将每个位上的数提取出来,乘以8的(位数- 1)次方,然后求和。
八进制 01100 --> 十进制:
1 * 8³ + 1 * 8² + 0 * 8 + 0 * 1 = 512 + 64 = 576
3. 十六进制转十进制
转换方法:
从最低位(右边)开始,将每个位上的数提取出来,乘以16的(位数- 1)次方,然后求和。
十六进制 0X1100 --> 十进制:
1 * 16³ + 1 * 16² + 0 * 16 + 0 * 1 = 16 * 16 * 16 + 16 * 16 = 4352
4. 转换练习
0b110001100 转成 十进制
--> 1 * 2^8 + 1 * 2^7 + 1 * 2^3 + 1 * 2^2 = 256+ 128+ 8 + 4 = 396
02456 转成 十进制--> 2 * 8^3 + 4 * 8^2 + 5 * 8 + 6 * 1 = 1024 + 256 + 40 + 6 = 1326
0xA45 转成 十进制--> A * 16^2 + 4 * 16 + 5 * 1 = 2560 + 64 + 5 = 2629
二、十进制转进制
十进制以 99、9999 为例,以十进制 分别转换为 二进制,八进制,十六进制
1. 十进制转二进制;
转换方法:
十进制数除以2,余数为权位上的数,得到商继续除以2,直到商为0终止,然后反向取余数。
十进制 99 --> 二进制: ( 0b01100011 )
99 / 2 --1 = 49 / 2 -- 1 = 24 / 2 -- 0 = 12 / 2 -- 0 = 6 / 2 -- 0 = 3 / 2 -- 1 = ---- 1
2. 十进制转八进制;
转换方法:
十进制数除以8,余数为权位上的数,得到商继续除以8,直到商为0终止,然后反向取余数。
十进制 9999 --> 八进制: ( 023417 )
9999 / 8 -- 7 = 1249 / 8 -- 1 = 0156 / 8 -- 4 = 019 / 8 -- 3 = ----2
3. 十进制转十六进制;
转换方法:
十进制数除以16,余数为权位上的数,得到商继续除以16,直到商为0终止,然后反向取余数。
十进制 9999 --> 十六进制: ( 0X270F )
9999 / 16 -- 15 = 624 / 16 -- 0 = 39 / 16 -- 7 = ----2
4. 转换练习
123 转成 二进制 => 0b01111011
123 / 2 -- 1 = 61 / 2 -- 1 = 30 / 2 -- 0 = 15 / 2 -- 1 = 7 / 2 -- 1 = 3 / 2 -- 1 = 1
678 转成八进制 => 01246
678 / 8 -- 6 = 84 / 8 -- 4 = 10 / 8 -- 2 = 1
8912 转成十六进制 => 0x22D0
8912 / 16 -- 0 = 557 / 16 -- 13 = 34 / 16 -- 2 = 2
三、二进制转进制
二进制以 10110110 为例, 以二进制 分别转换为八进制,十六进制
1. 二进制转八进制;
转换方法:
从低位开始,将二进制数每三位一组,转成对应的八进制数即可。
二进制 10110110 --> 八进制:
110 --> 6 、110 --> 6 、010 --> 2
----> 0266
2. 二进制转十六进制;
转换方法:
从低位开始,将二进制数每四位一组,转成对应的十六进制数即可。
二进制 10110110 --> 十六进制:
0110 --> 6 、 1011 --> 11
----> 0XB6
3. 转换练习
0b11100101 转成 八进制
-->011 --> 3
100 --> 4
101 --> 5
--> 3450b1110010110 转成 十六进制
-->
0011 --> 3
1001 --> 9
0110 --> 6
--> 396
四、进制转二进制
八进制,十六进制 以 765 、0x42b为例,分别转换二进制
1. 八进制转二进制
转换方法:
将八进制数每 1 位,转成对应的一个 3 位的二进制数即可。(注意事项,三位二进制转成八进制是从右到左开始转换,不足时补0)。
八进制 765--> 二进制:(0b000111110101)
7 / 2 -- 1 = 3 / 2 -- 1 = 1
----> 111
6 / 2 -- 0 = 3 / 2 -- 1 = 1
----> 110
5 / 2 -- 1 = 2 / 2 -- 0 = 1
----> 101
2. 十六进制转二进制
转换方法:
将十六进制数每 1 位,转成对应的一个 4 位的二进制数即可。(注意事项,四位二进制转成十六进制是从右到左开始转换,不足时补0)。
八进制 0x42b --> 二进制:
4 / 2 -- 0 = 2 / 2 -- 0 = 1
----> 0100
2 / 2 -- 0 = 1
----> 0010
11 / 2 -- 1 = 5 / 2 -- 1 = 2 / 2 -- 0 = 1
----> 1011
3. 转换练习
01230 转成 二进制 --> 0b0010 1001 100
001
010
011
000
0xAB29 转成二进制 --> 0b1010 1011 0010 1001
A --> 1010
B --> 1011
0010
1001
五、原码、反码、补码(重点 难点)
对于有符号的而言:二进制的最高位是符号位: 0表示正数,1表示负数
正数的原码,反码,补码都相同
负数的反码=原码取反(原码符号位不变,其他取反)
负数的补码=原码取反 + 1
0的反码、补码都是0
Java 没有无符号数 ==》 Java 都是有符号的数
在计算机运算的时候,都是以补码的方式来运算的。
当我们看运算结果的时候,要以原码来看
原码、反码和补码
1、机器数与真值
机器数:在计算机中数据和符号全部数字化,最高位为符号位,且用0表示正、1表示负,那么把包括符号在内的一个二进制数我们称为机器数,机器数: 有原码、反码和补码三种表示方法。
比如,十进制中的数 +3 ,计算机字长为8位,转换成二进制就是00000011。如果是 -3 ,就是 10000011 。
那么,这里的 00000011 和 10000011 就是机器数。
真值:用“+”、“—”号表示的二进制数。
机器数因为第一位是符号位,所以机器数的形式值就不等于真正的数值。例如上面的有符号数 10000011,其最高位1代表负,其真正数值是 -3 而不是形式值131(10000011转换成十进制等于131)。所以,为区别起见,将带符号位的机器数对应的真正数值称为机器数的真值。
例:0000 0001的真值 = +000 0001 = +1,
1000 0001的真值 = - 000 0001 = -1
2、原码、反码和补码的概念
原码:
是最简单的机器数表示法。其数符位用0表示正,1表示负,其余各位表示真值本身。
即用第一位表示符号, 其余位表示值,比如如果是8位二进制:
1的原码是00000001,
-1的原码是10000001。
反码:
正数的反码同原码, 负数的反码为除符号位外,其它各位按位取反。
正数的反码是其本身, 负数的反码是在其原码的基础上,符号位不变,其余各个位取反
1的反码是00000001,
-1的反码是11111110。
补码:
正数的补码同原码,负数的补码为反码加1。
负数的补码是在其原码的基础上, 符号位不变, 其余各位取反, 最后+1
1的补码是00000001,
-1的补码是11111110。