运算符
🐇运算符介绍
●运算符介绍
运算符是一种特殊的符号, 用以表示数据的运算, 赋值和比较等
1.算术运算符
2.赋值运算符
3.关系运算符 [比较运算符]
4.逻辑运算符
5.位运算符 [需要二进制基础]
6.三元运算符
🍄算术运算符
●介绍
算数运算符是对数值类型的变量进行运算的, 在Java程序中使用的非常多
●算术运算符一览
| 运算符 | 运算 | 范例 | 结果 |
|---|---|---|---|
| + | 正号 | +7 | 7 |
| - | 负号 | b=11 -b | -11 |
| + | 加 | 9+9 | 18 |
| - | 减 | 10-8 | 2 |
| * | 乘 | 7*8 | 56 |
| / | 除 | 9/9 | 1 |
| % | 取模(取余) | 11%9 | 2 |
| ++ ++ | 自增(前): 先运算后取值 自增(后): 先取值后运算 | a=2; b=++a; a=2; b=a++; | a=3; b=3 a=3; b=2 |
| - - - - | 自减(前): 先运算后取值 自减(后): 先取值后运算 | a=2; b= - -a a=2; b=a- - | a=1; b=1 a=1; b=2 |
| + | 字符串相加 | “zzw” + “, hello” | zzw, hello |
案例演示算术运算符的使用ArithmeticOperator.java
- +, -, *, /, %, ++, - -, 重点学习 /, %, ++
- 自增: ++
作为独立的语句使用
前++和后++都完全等价于i = i + 1
作为表达式使用
前++:++i 先自增后赋值
后++:i++ 先赋值后自增 - - -, +, -, * 类似, 不再举例
/**
* 演示算数运算符的使用
*/
public class ArithmeticOperator {
//编写一个main方法
public static void main(String[] args) {
// /使用
// 注销快捷键 ctrl + /, 再次输入 ctrl + / 取消注释
System.out.println(10 / 4);//从数学来看是2.5, java中 2
// 有多种类型的数据混合运算时, 系统首先自动将所有数据转换成容量最大的那种数据类型, 然后再进行计算.
// 自动提升原则: 表达式结果的类型自动提升为 操作数中最大的类型
System.out.println(10.0 / 4);//2.5
double d = 10 / 4;//java中 10 / 4 = 2, 2 => 2.0
System.out.println(d);//是2.0
// % 取模, 取余
// 在java中, %的本质 看一个公式 a % b = a - a / b * b
// -10 % 3 => -10 - (-10 / 3 * 3) = -10 - (-3 * 3) = -10 + 9 = -1
// 10 % -3 => 10 - (10 / -3 * -3) = 10 - (-3 * -3) = 10 - 9 = 1
// -10 % -3 => -10 - (-10 / -3 * -3) = -10 - (3 * -3) = -10 - (-9) = -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;
System.out.println("k=" + k + " j=" + j);//k=9 j=9*/
int j = 8;
int k = j++;//等价 k=j;j=j+1;
System.out.println("k=" + k + " j=" + j);//k=8 j=9
}
}
🐍算术运算符-注意事项和细节
●课堂练习一: ArithmeticOperatorExercise01.java
面试题1
int i = 1;//i=>1
i = i++; //规则: 使用临时变量; (1) temp = i; (2) i=i+1; (3) i=temp;
System.out.println(i);//问: 结果是多少? 为什么?
public class ArithmeticOperatorExercise01 {
//编写一个main方法
public static void main(String[] args) {
int i = 1;//i=>1
i = i++;
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);//问: 结果是多少? 为什么?
public class ArithmeticOperatorExercise01 {
//编写一个main方法
public static void main(String[] args) {
/*int i = 1;//i=>1
i = i++;
System.out.println(i);//1*/
int i = 1;//i=>1
i = ++i;
System.out.println(i);//2
}
}
●自增, 自减课堂练习, 看看输出什么
int i1 = 10;
int i2 = 20;
int i = i1++;//i1=11
System.out.println("i=" + i);//10
System.out.println("i2=" + i2);//20
i = --i2;
System.out.println("i=" + i);//19
System.out.println("i2=" + i2);//19
●课堂练习二 ArithmeticOperatorExercise02
1.假如还有59天放假, 问: 合xx个星期零xx天
//课堂练习
public class ArithmeticOperatorExercise02 {
//编写一个main方法
public static void main(String[] args) {
//1.需求:
//加入还有59天放假, 问: 和xx个星期零xx天
//2.思路分析
//(1) 使用int 变量 days 保存 天数
//(2) 一个星期是7天 days / 7 xx天leftDays days % 7
//3.代码
int days = 59;
int weeks = days / 7;
int leftDays = days % 7;
System.out.println(days + "天 合" + weeks
+ "个星期零" + leftDays + "天");
}
}
2.定义一个变量保存华氏温度, 华氏温度转换摄氏温度的公式为: 5/9*(华氏温度 - 100), 请求出华氏温度对应的摄氏温度. [234.5]
//课堂练习
public class ArithmeticOperatorExercise02 {
//编写一个main方法
public static void main(String[] args) {
//1.需求:
//加入还有59天放假, 问: 和xx个星期零xx天
//2.思路分析
//(1) 使用int 变量 days 保存 天数
//(2) 一个星期是7天 days / 7 xx天leftDays days % 7
//3.走代码
int days = 59;
int weeks = days / 7;
int leftDays = days % 7;
System.out.println(days + "天 合" + weeks
+ "个星期零" + leftDays + "天");
//1.需求
//定义一个变量保存华氏温度, 华氏温度转换摄氏温度的公式为:
//5/9*(华氏温度-100), 请求出华氏温度对应的摄氏温度. [234.5]
//2.思路分析
//(1)使用double 变量 huaShi 保存 华氏温度
//(2)根据给出的公式, 进行计算即可 5/9*(华氏温度-100)
// 考虑数学公式和java语言的特性
//(3)将得到的结果保存到double sheShi
//3.走代码
double huaShi = 234.5;
double sheShi = 5.0 / 9 * (huaShi - 100);
System.out.println("华氏温度=" + huaShi + " 对应的 摄氏温度=" + sheShi);
}
}
🍄关系运算符
●介绍
1.关系运算符的结果都是boolean型, 也就是要么是true, 要么是false
2.关系表达式 经常用在 if结构的条件中或循环结构的条件中
●关系运算符一览
| 运算符 | 运算 | 范例 | 结果 |
|---|---|---|---|
| == | 相等于 | 8 == 7 | false |
| != | 不等于 | 8 != 7 | true |
| < | 小于 | 8 < 7 | false |
| > | 大于 | 8 > 7 | true |
| <= | 小于等于 | 8 <= 7 | false |
| >= | 大于等于 | 8 >= 7 | true |
| instanceof | 检查是否是类的对象 | “zzw” instanceof String | true |
●案例演示
案例演示关系运算符的使用 RelationalOperator.java
//演示关系运算符的使用
public class RelationalOperator {
//编写一个main方法
public static void main(String[] args) {
//温馨提示: 开发中 不可以使用 a,b
int a = 9;
int b = 8;
System.out.println(a > b);//true
System.out.println(a >= b);//true
System.out.println(a <= b);//false
System.out.println(a < b);//false
System.out.println(a == b);//false
System.out.println(a != b);//true
boolean flag = a > b;//true
System.out.println("flag=" + flag);
}
}
●细节说明
1.关系运算符的结果都是boolean型, 也就是要么是true, 要么是false.
2.关系运算符组成的表达式, 我们称为关系表达式. a > b
3.比较运算符 “==” 不能误写成 “=”
🍄逻辑运算符
●介绍
用于连接多个条件(多个关系表达式), 最终的结果也是一个boolean值.
●逻辑运算符一览
√分为两组学习
1.短路与 &&, 短路或 ||, 取反!
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 |
●逻辑运算符一览
√说明逻辑运算规则:
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 两个条件都为true, 结果为true, 否则为false
● && 和 & 案例演示
案例演示&& 和 & 运算符的使用 LogicOperator01.java
/**
* 演示逻辑运算符的使用
*/
public class LogicOperator01 {
//编写一个main方法
public static void main(String[] args) {
//&&短路与 和 & 案例演示
double age = 50;
if(age > 20 && age < 90) {
System.out.println("ok100");//输出
}
if(age > 20 && age < 30) {
System.out.println("ok100");//不输出
}
//&逻辑与使用
if(age > 20 & age < 90) {
System.out.println("ok200");//输出
}
if(age > 20 & age < 30) {
System.out.println("ok200");//不输出
}
//区别
int a = 4;
int b = 9;
//对于&&短路与而言: 如果第一个条件为false, 后面的条件不再判断
if(a < 1 && ++b < 50) {
System.out.println("ok300");
}
System.out.println("a=" + a + " b=" + b);//a=4 b=9
//对于&逻辑与而言: 如果第一个条件为false, 后面的条件仍然会判断
if(a < 1 & ++b < 50) {
System.out.println("ok300");
}
System.out.println("a=" + a + " b=" + b);//a=4 b=10
}
}
//区别
int a = 4;
int b = 9;
//对于&&短路与而言: 如果第一个条件为true, 后面的条件继续判断
if(a < 10 && ++b < 50) {
System.out.println("ok300");
}
System.out.println("a=" + a + " b=" + b);//a=4 b=10
//区别
int a = 4;
int b = 9;
//对于&逻辑与而言: 如果第一个条件为true, 后面的条件继续判断
if(a < 10 & ++b < 50) {
System.out.println("ok300");
}
System.out.println("a=" + a + " b=" + b);//a=4 b=10
● && 和 & 使用区别
1.&&短路与: 如果第一个条件为false, 则第二个条件不会判断, 最终结果为false. 效率高.
2.&逻辑与: 不管第一个条件是否为false, 第二个条件都要判断, 效率低.
3.开发中, 我们使用的基本是短路与&&, 效率高
● || 和 | 基本规则
名称 语法 特点
短路或|| 条件1 | | 条件2 两个条件中只要有一个成立, 结果为true, 否则为false
逻辑或 | 条件1 | 条件2 两个条件中只要有一个条件成立, 结果为true, 否则为false
● || 和 | 案例演示
案例演示|| 和 | 运算符的使用 LogicOperator02.java
/**
* 演示逻辑运算符的使用
*/
public class LogicOperator02 {
//编写一个main方法
public static void main(String[] args) {
// 短路或|| 和 逻辑或| 案例演示
double age = 50;
if(age > 20 || age < 90) {
System.out.println("ok100");//输出
}
//|逻辑或 使用
if(age > 20 | age < 90) {
System.out.println("ok200");//输出
}
//区别
//||短路或: 如果第一个条件为true,
//则第二个条件不会判断, 最终结果为true. 效率高.
/*int a = 4;
int b = 9;
if(a > 1 || ++b > 4) {
System.out.println("ok300");
}
System.out.println("a=" + a + " b=" + b);//a=4 b=9*/
//&逻辑与: 不管第一个条件是否为false, 第二个条件都要判断, 效率低.
int a = 4;
int b = 9;
if(a > 1 | ++b > 4) {
System.out.println("ok300");
}
System.out.println("a=" + a + " b=" + b);//a=4 b=10
}
}
● || 和 | 使用区别
1.||短路或: 如果第一个条件为true, 则第二个条件不会判断, 最终结果为true. 效率高.
2.|逻辑或: 不管第一个条件是否为true, 第二个条件都要判断, 效率低.
3.开发中, 我们使用的基本是短路或||, 效率高
●! 取反 基本规则
名称 语法 特点
! 非 (取反) ! 条件 如果条件本身成立, 结果为false, 否则为true
● ! 案例演示
案例演示! 运算符的使用
● ^ 案例演示
a^b: 叫逻辑异或, 当 a 和 b 不同时, 结果为true, 否则为false
InverseOperator.java
/**
* ! 和 ^ 案例演示
*/
public class InverseOperator {
//编写一个main方法
public static void main(String[] args) {
//! 操作是取反 true->false, false->true
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);//true
}
}
🐍逻辑运算符-练习题
内存分析法
●练习题1 请写出每题的输出结果
&逻辑与: 不管第一个条件是否为false, 第二个条件都要判断, 效率低.
(每个条件表达式都要走一遍 最终结果: 只要有一个条件表达式为false,则最终结果为false, 否则为true )
int x = 5;
int y = 5;
if(x++ == 6 & ++y == 6) {//逻辑与
x = 11;
}
System.out.println("x=" + x + ",y=" + y);//x=6,y=6
&&短路与: 如果第一个条件为false, 则第二个条件不会判断, 最终结果为false. 效率高.
int x = 5;
int y = 5;
if(x++ == 6 && ++y == 6) {//短路与
x = 11;
}
System.out.println("x=" + x + ",y=" + y);//x=6,y=5
逻辑或: 不管第一个条件是否为true, 第二个条件都要判断, 效率低.
int x = 5;
int y = 5;
if(x++ == 5 | ++y == 5) {//逻辑或
x = 11;
}
System.out.println("x=" + x + ",y=" + y);//x=11,y=6
短路或: 如果第一个条件为true, 则第二个条件不会判断, 最终结果为true. 效率高.
int x = 5;
int y = 5;
if(x++ == 5 || ++y == 5) {//短路或
x = 11;
}
System.out.println("x=" + x + ",y=" + y);//x=11,y=5
●练习题2 请写出输出结果
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);//z=50
🍄赋值运算符
●介绍
赋值运算符就是将某个运算后的值, 赋给指定的变量
●赋值运算符的分类
√ 基本赋值运算符 int a = 10;
√ 复合赋值运算符
+=, -=, *=, /=, %= 等.
a += b; [等价a = a + b;]
a -= b; [等价a = a - b;]
●案例演示AssignOperator.java
+= 的使用案例
//演示赋值运算符的使用
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;
System.out.println(n1); //4
}
}
●赋值运算符特点
1.运算顺序从右往左 int num = a + b + c;
2.赋值运算符的左边, 只能是变量; 右边可以是变量, 表达式, 常量值.
比如: int num = 20; int num2 = 12 * 13 - 14; 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;
System.out.println(n1); //4
//复合赋值运算符会进行类型转换
byte b = 2;
b += 2; //等价 b = (byte) (b + 2);
b++;//等价 b = (byte) b + 1;
}
}
🍄三元运算符
●基本语法
条件表达式 ? 表达式1 : 表达式2;
● 运算规则
1.如果条件表达式为true, 运算后的结果是表达式1;
2.如果条件表达式为false, 运算后的结果是表达式2;
口诀: [一灯大师: 一真大师]
●案例演示 TernaryOperator.java
//演示三元运算符的使用
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);//99
System.out.println("a=" + a);//10
System.out.println("b=" + b);//98
}
}
●使用细节 TernaryOperatorDetail.java
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) 1.2;//可以的
double d = a > b ? a : b + 3;//可以的, 满足 int -> double
}
}
●课堂练习
案例: 实现三个数的最大值. TernaryOperatorExercise.java
//三元运算符细节
public class TernaryOperatorExercise {
//编写一个main方法
public static void main(String[] args) {
//案例: 实现三个数的最大值
int n1 = 555, n2 = 333, 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.只有单目运算符, 赋值运算符是从右向左运算的
| . () {} ; , | |
|---|---|
| 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 | ? : |
| R->L | = *= /= %= |
| += -= <<= >>= | |
| >>>= &= ^= |= |
梳理小结:
1.() , {} 等
2.单目运算 ++ - -
3.算数运算符
4.位移运算符
5.比较运算符
6.逻辑运算符
7.三元运算符
8.赋值运算符
🐍标识符的命名规则和规范
●标识符概念
1.Java对各种变量, 方法和类等命名时使用的字符序列称为标识符
2.凡是自己可以起名字的地方都叫标识符 int num1 = 90;
●标识符的命名规则(必须遵守)
1.由26个英文字母大小写, 0-9, _或 $ 组成
2.数字不可以开头. int 3ab = 1;//错误
3.不可以使用关键字和保留字, 但能包含关键字和保留字.
4.Java中严格区分大小写, 长度无限制. int totalNum = 10; int n = 90;
5.标识符不能包含空格. int a b = 90;
int aclass = 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;//正确
System.out.println("abc=" + abc);
System.out.println("aBc=" + aBc);
●判断下面变量名是否正确
zzw //ok
zzw123 //ok
1zzw //错误, 不能以数字开头
h-s //ok, 不能有 -
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.zzw.controller
2.类名, 接口名: 多单词组成时, 所有单词的首字母大写: XxxYyyZzz[大驼峰法]
3.变量名, 方法名: 多单词组成时, 第一个单词首字母小写, 第二个单词开始每个单词首字母大写: xxxYyyZzz[小驼峰, 简称 驼峰法] 比如: tankShotGame
4.常量名: 所有字母都大写, 多单词时每个单词用下划线连接: XXX_YYY_ZZZ
5.后面学习到 类, 包, 接口, 等时, 命名规范要这样遵守, 更加详细的资料看文档
🐍关键字&&保留字
●关键字的定义和特点
定义: 被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 |
|---|
●用于定义类与类之间关系的关键字
| extends | implements |
|---|
●用于定义建立实例及引用实例, 判断实例的关键字
| new | this | super | instanceof |
|---|
●用于异常处理的关键字
| try | catch | finally | throw | throws |
|---|
●用于包的关键字
| package | import |
|---|
●其它修饰符关键字
| native | strictfp | transient | volatile | assert |
|---|
保留字
●介绍
Java保留字: 现有Java版本尚未使用, 但以后版本可能会作为关键字使用. 自己命名标识符时虽然部分不会报错, 但要避免使用这些保留字
byValue, cast, future, generic, inner, operator, outer, rest, var, goto, const
🐍键盘输入语句
●介绍
在编程中, 需要接收用户输入的数据, 就可以使用键盘输入语句来获取. 需要一个扫描器(对象), 就是 Scanner
●步骤
1.导入该类的所在包, java.util.*
2.创建该类对象 (声明变量)
3.调用里面的功能
●案例演示
要求: 可以从控制台接收用户信息 [姓名, 年龄, 薪水] Input.java
import java.util.Scanner;//表示把java.util包下的Scanner类导入
public class Input {
//编写一个main方法
public static void main(String[] args) {
//要求: 可以从控制台接收用户信息 [姓名, 年龄, 薪水]
//演示接收用户的输入
//步骤
//Scanner类表示一个简单文本扫描器
//1.引入/导入 Scanner类所在的包
//2.创建 Scanner 对象, new 创建一个对象
// myScanner 就是 Scanner类的对象
Scanner myScanner = new Scanner(System.in);
//3.接收用户的输入, 使用 相关的方法
System.out.print("请输入名字: ");
//当程序执行到 next 方法时, 会等待用户输入~~~~
String name = myScanner.next();//表示接收用户输入
System.out.print("请输入年龄: ");
int age = myScanner.nextInt();//接受用户输入
System.out.print("请输入薪水: ");
double salary = myScanner.nextDouble();//接受用户输入
System.out.println("name=" + name + " age=" + age +
" salary=" + salary);
}
}
🐍进制
●进制介绍
对于整数, 有四种表示方式:
1.二进制: 0,1. 满2进1, 以0b或0B开头
2.十进制: 0-9. 满10进1
3.八进制: 0-7. 满8进1, 以数字0开头表示
4.十六进制: 0-9及A(10)-F(15). 满16进1, 以0x或0X开头表示, 此处的A-F不区分大小写.
●举例说明 BinaryTest.java
//演示四种进制
public class BinaryTest {
//编写一个main方法
public static void main(String[] args) {
//n1 二进制
int n1 = 0b1010;
//n2 十进制
int n2 = 1010;
//n3 八进制
int n3 = 01010;
//n4 十六进制
int n4 = 0X10101;
System.out.println("n1=" + n1);
System.out.println("n2=" + n2);
System.out.println("n3=" + n3);
System.out.println("n4=" + n4);
}
}
●进制的图示
| 十进制 | 十六进制 | 八进制 | 二进制 |
|---|---|---|---|
| 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 |
🐍进制的转换(基本功)
机制转换的介绍
●第一组:
1.二进制转十进制
2.八进制转十进制
3.十六进制转十进制
●第二组:
1.十进制转二进制
2.十进制转八进制
3.十进制转十六进制
●第三组:
1.二进制转八进制
2.二进制转十六进制
●第四组:
1.八进制转二进制
2.十六进制转二进制
🐍其它进制转十进制
● 二进制转十进制
●规则: 从最低位(右边)开始, 将每个位上的数提取出来, 乘以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
●八进制转十进制
●规则: 从最低位0开始, 将每个位上的数提取出来, 乘以8的(位数-1)次方, 然后求和
●案例: 请将 0234 转成十进制的数
0234 = 4 * 8的(1-1)次方 + 3 * 8的(2-1)次方 + 2 * 8的(3-1)次方 = 4 * 80 + 3 * 81 + 2 * 82 = 4 + 24 + 128 = 156
●十六进制转十进制
●规则: 从最低位(右边)开始, 将每个位上的数据提出来, 乘以16的(位数-1)次方, 然后求和
●案例: 请将 0x23A 转成十进制的数
0x23A = 10 * 16的(1-1)次方 + 3 * 16的(2-1)次方 + 2 * 16的(3-1)次方 = 10 * 160 + 3 * 161 + 2 * 162 = 10 + 48 + 512 = 570
课堂练习: 请将
0b110001100 转成 十进制
02456 转成 十进制
0xA45 转成 十进制
🐍十进制转其它进制
●十进制转二进制
●规则: 将该数不断除以2, 直到商为0为止, 然后将每步得到的余数倒过来, 就是对应的二进制.
●案例: 请将 34 转成二进制
●十进制转八进制
●规则: 将该数不断除以8, 直到商为0为止, 然后将每步得到的余数倒过来, 就是对应的八进制.
●案例: 请将 131 转成八进制
●十进制转十六进制
●规则: 将该数不断除以16, 直到商为0为止, 然后将每步得到的余数倒过来, 就是对应的十六进制
●案例: 请将 237 转成十六进制
课堂练习: (使用计算器/程序去验证)
123 转成 二进制
678 转成 八进制
8912 转成 十六进制
用计算器验证
🐍二进制转八,十六进制
●二进制转八进制
●规则: 从低位开始, 将二进制数每三位一组, 转成对应的八进制数即可. 111 => 7
●案例: 请将 0b11010101 转成八进制
0b11010101 = 0b11(3)010(2)101(5) = 0325
●二进制转十六进制
●规则: 从低位开始, 将二进制数每四位一组, 转成对应的十六进制数即可 1111 => 15
●案例: 请将 0b11010101 转成十六进制
0b11010101 = 0b1101(13)0101(5) = 0xD5
验证
●课堂练习: (使用计算器/程序去验证)
0b11100101 转成八进制
0b11100101 = 0b11(3)100(4)101(5) = 0345
0b1110010110 转成 十六进制
0b1110010110 = 0b11(3)1001(9)0110(6) = 0x396
●用计算器验证
🐍八,十六进制转二进制
●八进制转二进制
●规则: 将八进制数每1位, 转成对应的一个3位 的二进制数即可.
●案例: 请将 0237 转成二进制
0237 = 02(010)3(011)7(111) = 0b010011111
●十六进制转二进制
●规则: 将十六进制数每1位, 转成对应的一个4位 的二进制数即可.
●案例: 请将 0x23B 转成二进制
0x23B = 0x2(0010)3(0011)B(1011) = 0x0010 0011 1011
用计算器验证
课堂练习
01230 转成 二进制
01230 = 01(001)2(010)3(011)0(000) = 0b001010011000
0xAB29 转成 二进制
0xAB29 = 0xA(1010)B(1011)2(0010)9(1001) = 0x1010 1011 0010 1001
用计算器验证
🍄位运算
●二进制在运算中的说明
1.二进制是逢2进位的进位制, 0, 1是基本算符.
2.现代的电子计算机技术全部采用的是二进制, 因为它只是用0, 1两个数字符号, 非常简单方便, 易于用电子方式实现. 计算机内部处理的信息, 都是采用二进制数来表示的. 二进制 (Binary) 数用0和1两个数字及其组合来表示任意数. 进位规则是 “逢2进1”, 数字1在不同的位上表示不同的值, 按从右至左的次序, 这个值以二倍递增. 比如 1 2 4 8…
●原码, 反码, 补码(重点, 难点)
网上对原码, 反码, 补码的解释过于复杂, 这里精简几句话
1.二进制的最高位是符号位: 0表示正数, 1表示负数 (口诀: 0->0 1-> -)
2.正数的原码, 反码, 补码都一样(三码合一)
3.负数的反码 = 它的原码符号位不变, 其它位取反(0->1, 1->0)
4.负数的补码 = 它的反码 + 1, 负数的反码 = 它的补码 - 1
5.0的反码, 补码都是0
6.java没有无符号数, 换言之, java中的数都是有符号的.
7.在计算机运行的时候, 都是以补码的方式来运算的
8.当我们看运算结果的时候, 要看它的原码
●java中有7个运算符(&, |, ^, ~, >>, << 和 >>>)
√ 分别是按位与&, 按位或|, 按位异或^, 按位取反~, 它们的运算规则是
按位与& : 两位全为1, 结果为1, 否则为0
按位或 | : 两位有一个为1, 结果为1, 否则为0
按位异或^ : 两位一个为0, 一个为1, 结果为1, 否则为0
按位取反~ : 0->1, 1->0
BitOperator.java
//位运算
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
// 得到3的补码 00000000 00000000 00000000 00000011
//2. 2|3操作 00000000 00000000 00000000 00000011 运算后的补码
//3. 运算后的原码 也是 00000000 00000000 00000000 00000011 => 3
System.out.println(2|3);//3
//推导
//1. 得到2的补码 00000000 00000000 00000000 00000010
// 得到3的补码 00000000 00000000 00000000 00000011
//2. 2^3操作 00000000 00000000 00000000 00000001 运算后的补码
//3. 运算后的原码 也是 00000000 00000000 00000000 00000001 => 1
System.out.println(2^3);//1
//推导
//1. 得到-5的原码 10000000 00000000 00000000 00000101
//2. 得到-5的反码 11111111 11111111 11111111 11111010
//3. 得到-5的补码 11111111 11111111 11111111 11111011
//4. ~-5操作 00000000 00000000 00000000 00000100 运算后的补码
//5. 运算后的原码 也是 00000000 00000000 00000000 00000100 => 4
System.out.println(~-5);//4
//推导
//1. 得到13的补码 00000000 00000000 00000000 00001101
// 得到 7的补码 00000000 00000000 00000000 00000111
//2. 13&7操作 00000000 00000000 00000000 00000101 运算后的补码
//3. 运算后的原码 也是 00000000 00000000 00000000 00000101 => 5
System.out.println(13&7);//5
//推导
//1. 得到5的补码 00000000 00000000 00000000 00000101
// 得到4的补码 00000000 00000000 00000000 00000100
//2. 5|4操作 00000000 00000000 00000000 00000101 运算后的补码
//3. 运算后的原码 也是 00000000 00000000 00000000 00000101 => 5
System.out.println(5|4);//5
}
}
●还有3个位运算符 >>, << 和 >>>, 运算规则:
1.算术右移 >>: 低位溢出, 符号位不变, 并用符号位补溢出的高位
2.算数左移 <<: 符号位不变, 低位补0
3.>>> 逻辑右移也叫无符号右移, 运算规则是: 低位溢出, 高位补 0
4.特别说明: 没有 <<< 符号
●应用案例 BitOperator02.java
int a = 1 >> 2; => 00000000 00000000 00000000 00000001 => 00000000 00000000 00000000 0000000001 => 00000000 00000000 00000000 00000000 本质 1 / 2 / 2 = 0
int b = 1 << 2; => 00000000 00000000 00000000 00000001 => 00000000 00000000 00000000 00000100 => 00000000 00000000 00000000 00000100 => 本质 1*2*2 = 4
int c = -1 >> 2; => 10000000 00000000 00000000 00000001 => 10000000 00000000 00000000 0000000111 =>10000000 00000000 00000000 00000001 => -1
//位运算
public class BitOperator2 {
//编写一个main方法
public static void main(String[] args) {
//推导
//00000000 00000000 00000000 00000001
//=> 00000000 00000000 00000000 00000000
System.out.println(1 >> 2);//0
//推导
//00000000 00000000 00000000 00000001
//=> 00000000 00000000 00000000 00000100
System.out.println(1 << 2);//4
//推导
//00000000 00000000 00000000 00000100
//=> 00000000 00000000 00000000 00100000
System.out.println(4 << 3);//32 本质 4*2*2*2=32
//推导
//00000000 00000000 00000000 00001111
//=> 00000000 00000000 00000000 00000011
System.out.println(15 >> 2);// 15 / 2 / 2 = 3
//推导
//10000000 00000000 00000000 00000001
//=> 10000000 00000000 00000000 00000001
System.out.println(-1 >> 2);// -1
//推导
//10000000 00000000 00000000 00000001
//=> 10000000 00000000 00000000 00000100
System.out.println(-1 << 2);//-4 本质 -1*2*2 = 4
//推导
//00000000 00000000 00000000 00000011
//=> 00000000 00000000 00000000 00000000
System.out.println(3 >>> 2);//0 本质 3/2/2 = 0
}
}
🐇第四章 · 课后作业
1.计算下列表达式的结果
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 - (int) (-10.5) / 3 * 3 = -10.5 - (-10) / 3 * 3 = -10.5 - (-3) * 3 = -10.5 + 9 = -1.5
//注意: 有小数参与的运算, 得到的结果是近似值
System.out.println(-10.5%3);//-1.5
System.out.println(-10.4%3);//-1.4近似值 => -1.4000000000000004
2.试说出下面代码的结果
int i = 66;
System.out.println(++i+i);//先执行 i = i + 1; => i = 67 => 134
3.在Java中, 一下赋值语句正确的是(C D)
A. int num1 = (int) “18”; //错误 应该 Integer.parseInt(“18”);
B. int num2 = 18.0; //错误 double -> int 精度损失
C. double num3 = 3d; //ok
D. double num4 = 8; //ok
E. int i = 48; char ch = i + 1; //错误 int -> char 精度损失
F. byte b = 19; short s = b + 2; //错误 int -> short 精度损失
4.试写出将String转换成double类型的语句, 以及将char类型转换成String的语句. 举例说明即可
String类型转基本类型, 要用到基本类型的包装类的parseXX方法
String str = “123.3”;
double d = Double.parseDouble(str);
基本类型转String类型, 将 基本类型的值+“” 即可, 不能加toString()
char c = ‘a’;
str = c + “”;
310
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
