java零基础Ⅰ– 运算符
运算符介绍
介绍
运算符是一种
特殊的符号
，用以表示数据的
运算、赋值和比较
等。
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 |
| + | 字符串相加 | “zzp”+“123” | “zzp123” |
案例演示：
案例演示算术运算符的使用：ArithmeticOperator.java
1、+，-，*，/，%，++，- -，重点 /，%，+ +
取模（余）%公式： a % b = a – a / b * b
2、自增：+ +
作为独立的语句使用；
前 + + 和后 + + 都完全等价于 i=i+1;
作为表达式使用：
前 + +： + +i 先自增后赋值
后 + +： i+ + 先赋值后自增
3、- -，+，-，* 是一个道理，完全可以类推。
/**
* 演示算术运算符的使用
*/
public class ArithmeticOperator{
//编写一个main方法
public static void main(String[] args){
// 除号 / 使用
System.out.println(10 / 4);//从数学来说看是2.5 实际在java中输出2 int类型
System.out.println(10.0 / 4);//在java中输出2.5 因为10.0 是double类型
double d = 10/4;//在java中 10/4 = 2 int类型, 最终2=>2.0 double类型
System.out.println(d);//2.0
System.out.println("============");
// 取模（余） % 使用
// 在 % 的本质 看一个公式 a % b = a - a / b * b
System.out.println(10 % 3);//1
// -10-(-10)/3*3 = -10 + 9 = -1
System.out.println(-10 % 3);//-1
// 10-10/(-3)*(-3) = 10 - 9 = 1
System.out.println(10 % -3);//1
// -10-(-10)/(-3)*(-3) = -10 + 9 = -1
System.out.println(-10 % -3);//-1
System.out.println("============");
// ++ 自增的使用 作为独立的语句使用；
int i = 10;
i++;// 自增 等价于 i = i + 1; i = 11;
++i;// 自增 等价于 i = i + 1; i = 12;
System.out.println("i=" + i);//i=12
/*
作为表达式使用：
前 ++i： ++i 先自增后赋值
后 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 k = j++;//等价 k=j;j=j+1;
System.out.println("k=" + k + "j=" + j);//k=8 j=9
}
}
面试题：
1、面试题1
int i = 1; // i -> 1
i = i++;//规则使用临时变量：(1)temp = i;(2) i = i+1;(3)i=temp;
System.out.println(i);//1
问：结果是多少？为什么？
2、面试题2
int i = 1;
i = ++i;//规则使用临时变量：(1) i = i+1;(2)temp = i;(3)i=temp;
System.out.println(i);//2
public class ArithmeticOperatorExercise01{
//编写一个main方法
public static void main(String[] args){
// int i = 1;// i -> 1
// i = i++;//规则使用临时变量：(1)temp = i;(2) i = i+1;(3)i=temp;
// System.out.println(i);//1
int i = 1;
i = ++i;//规则使用临时变量：(1) i = i+1;(2)temp = i;(3)i=temp;
System.out.println(i);//2
}
}
自增、自减
看看以下代码输出什么？
int i1 = 10;
int i2 = 20;
int i = i1 ++;//规则： i = i1 = 10; i1 = i1+1 = 11;
System.out.println("i=" + i);//10
System.out.println("i2=" + i2);//20
i = -- i2;//规则： i2 = i2 -1 = 19;i = i2 = 19;
System.out.println("i=" + i);//19
System.out.println("i2=" + i2);//19
public class ArithmeticOperatorExercise01{
//编写一个main方法
public static void main(String[] args){
int i1 = 10;
int i2 = 20;
int i = i1 ++;//规则： i = i1 = 10; i1 = i1+1 = 11;
System.out.println("i=" + i);//10
System.out.println("i2=" + i2);//20
i = -- i2;//规则： i2 = i2 -1 = 19;i = i2 = 19;
System.out.println("i=" + i);//19
System.out.println("i2=" + i2);//19
}
}
练习：
1、假如还有59天放假，问：合xx个星期零xx天
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天 星期数weeks：days / 7
// 零xx天leftDays：days % 7
//(3) 输出
//3.走代码
int days = 59;
int weeks = days / 7;//8
int leftDays = days % 7;//3
System.out.println(days+"天 合" + weeks + "个星期零"
+ leftDays + "天");//59天 合8个星期零3天
//1.需求：
//定义一个变量保存华氏温度，
//华氏温度转换摄氏度的公式为：5/9*(华氏温度-100)，
//请求出华氏温度对应的摄氏温度。[234.5]
//2.思路分析：
//(1) 先定义一个double huaShi 变量保存华氏温度
//(2) 根据给出的公式，进行计算即可 5/9*(华氏温度-100)
// 考虑数学公式和java语言的运算特性 5.0 /9*(华氏温度-100)
//(3) 将得到的结果保存到double sheShi
//3.走代码
double huaShi = 234.6;
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 | 检查是否是类的对象 | “zzp” instanceof String | true |
案例：
演示关系运算符的使用：
int a = 9;//提示：开发中，不可以使用 a,b a1,bc n1,n2..
int b = 8;
System.out.println( a > b );
System.out.println( a >= b );
System.out.println( a <= b );
System.out.println( a < b );
System.out.println( a == b );
System.out.println( a != b );
boolean flag = a > b;
public class RelationalOperator{
//编写一个main方法
public static void main(String[] args){
int a = 9;//提示：开发中，不可以使用 a,b
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;
System.out.println("flag=" + flag);//true
}
}
细节说明
1）关系运算符的结果都是boolean类型，也就是要么是true，要么是false
2）关系运算符组成的表达式，我们称为关系表达式。a>b
3）比较运算符 “==” 不能写成 “=”
逻辑运算符
介绍
用于连接多个条件
（多个关系表达式），最终的结果也是一个
boolean类型值
逻辑运算一览
分为两组学习
1）
短路与 && ，短路或 || ，取反 ！
2）
逻辑与 & ，逻辑或 | ，^ 逻辑异或
|
|
|
|
|
|
|
|---|---|---|---|---|---|---|
| true | true | true | true | true | false | false |
| true | false | false | false | true | false | true |
| false | true | false | false | true | true | true |
| 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
&& 和 & 基本规则
| 名称 | 语法 | 特点 |
|---|---|---|
| 短路与 && | 条件1 && 条件2 | 两个条件都为true，结果为true，否则为false |
| 逻辑与 & | 条件1 & 条件2 | 两个条件都为true，结果为true，否则为false |
&& 和 & 使用区别
1、&&短路与：如果第一个条件为false，则第二个条件则不会判断，最终结果为false。
2、& 逻辑与：不管第一个条件是否为false，第二个条件都要判断，效率低
3、开发中，我们使用的基本短路与
&&
，效率高
案例演示：
/**
* 演示逻辑运算符的使用
*/
public class LogicOpertaor01{
//编写一个main方法
public static void main(String[] args){
//&& 短路与 和 & 案例演示
int age = 50;
if(age > 20 && age < 90){ //true && true => true
System.out.println("OK100");//
}
//& 逻辑与使用
if(age > 20 && age < 90){ //true && true => true
System.out.println("OK200");//
}
//区别
int a = 4;
int b = 9;
//对于 &&短路与而言，如果第一个添加为false，后面条件的不再判断
// if(a < 1 && ++b < 50){ //false => false
// System.out.println("OK300");
// }
// System.out.println("a=" + a + " b=" + b);//a=4 b=9
//对于 &逻辑与而言，如果第一个添加为false，后面条件仍然会判断
if(a < 1 & ++b < 50){ //false & true => false
System.out.println("OK300");
}
System.out.println("a=" + a + " b=" + b);//a=4 b=10
}
}
|| 和 | 基本规则
| 名称 | 语法 | 特点 |
|---|---|---|
|
|
两个条件只要有一个成立，结果为true，否则为false |
|
|
只要有一个条件成立，结果为true，否则为false |
|| 和 | 使用区别
1、|| 短路或：如果第一个条件为true，则第二个条件不会判断，最终结果为true，效率高
2、| 逻辑或：不管第一个条件是否为true，第二个条件都要判断，效率低
3、开发中，我们基本使用
||
案例演示：
/**
* 演示 || 短路或 | 逻辑或 使用
*/
public class LogicOpertaor02{
//编写一个main方法
public static void main(String[] args){
//|| 短路或 和 | 逻辑或 案例演示
// || 规则：两个条件只要有一个成立，结果为true，否则为false
int age = 50;
if(age > 20 || age < 30){ //true || false => true
System.out.println("OK100");//OK100
}
// | 逻辑或
// | 规则：只要有一个条件成立，结果为true，否则为false
if(age > 20 | age < 30){ //true || false => true
System.out.println("OK200");//OK200
}
int a = 4;
int b = 9;
//区别：
//(1)|| 短路或：如果第一个条件为true，
// 则第二个条件不会判断，最终结果为true，效率高
// if(a > 1 || ++b > 4){ //true || true => true
// System.out.println("OK300");
// }
// System.out.println("a=" + a + " b=" + b);//a=4 b=9
//(2)| 逻辑或：不管第一个条件是否为true，
// 第二个条件都要判断，效率低
if(a > 1 | ++b > 4){ //true || true => true
System.out.println("OK400");
}
System.out.println("a=" + a + " b=" + b);//a=4 b=10
}
}
!取反 基本规则
| 名称 | 语法 | 特点 |
|---|---|---|
| ! 非（取反） | !条件 | 如果添加本身成立，结果为false，否则为true |
^案例演示
a^b：叫逻辑异或，当a 和 b 不同时，则结果为true，否则为false
^逻辑异或，System.out.println((4 < 1) ^ (6 > 3));//false ^ true ⇒ true
/**
* !和^案例演示
*/
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);// true ^ true => false
// System.out.println("b=" + b);//false
boolean b = (10 > 1) ^ ( 3 > 5);// true ^ false => true
System.out.println("b=" + b);//true
}
}
练习题：
写下面的输出结果：
int x = 5;
int y = 5;
//注意:
//(1)x++先比较: 5 == 6 = false;
//(2)后自增: x = x + 1 = 6
if(x++ == 6 & ++y == 6){//逻辑与 false & true ==> false
x = 11;
}
System.out.println("x=" + x + " y=" + y);//x=6 y=6
int x = 5,y = 5;
if(x++ == 6 && ++y == 6){//短路与 false && true ==> true
x = 11;
}
System.out.println("x=" + x + " y=" + y);//x=6 y=5
int x = 5,y = 5;
if(x++ == 5 | ++y == 5){//逻辑或 true | false ==> true
x = 11;
}
System.out.println("x=" + x + " y=" + y);//x=11 y=6
int x = 5,y = 5;
if(x++ == 5 || ++y == 5){//短路或 true || false ==> true
x = 11;
}
System.out.println("x=" + x + " y=" + y);//x=11 y=5
请写输出下面结果：
boolean x = true;
booelan y = false;
short z = 46;
// z++ == 46;
// (1) z == 46 ==> true
// (2) z = z +1 = 47
// y = true
if( (z++ == 46 ) && (y = true) ){//短路与 true && true ==> true
z ++;// z ++ = 47 + 1 = 48
}
// x = false
// ++z == 49;
// (1) z = z + 1 = 49
// (2) z == 49 ==> true
if( (x = false) || (++z == 49) ){//短路或 false || true ==> true
z ++;// z++ = 49 + 1 = 50
}
System.out.println("z=" + z);//z=50
赋值运算符
介绍
赋值运算符就是将某个
运算后的值，赋给指定的变量
赋值运算符的分类
基本赋值运算符
=
复合赋值运算符
+= ， -= ，、/= , %= 等，重点讲解一个 += ，其他一个道理
a += b; [等价：a = a + b;]
a -= b; [等价：a = a - b;]
案例演示
案例演示赋值运算符的基本使用。AssignOperator.java
1）赋值基本案例 [ int num1 = 10;]
2）+= 的使用
//演示赋值运算符的使用
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 = 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){
//复合赋值运算符会进行类型转换
byte b = 3;
b += 2;// 等价: b = (byte)(b + 2);
b++;// 等价: b = byte)(b + 1);
System.out.println(b);// 5
}
}
三元运算符
基本语法
条件表达式 ？ 表达式1 ： 表达式2；
运算规则：
1、如果条件表达式为true，运算后的结果是表达式1；
2、如果条件表达式为false，运算后的结果是表达式2；
案例演示
int a = 10;
int b = 99;
int result = a > b ? a++ : b++;
//三元运算符的使用
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("a=" + a);// 10
System.out.println("b=" + b);// 98
System.out.println("result=" + result);// 99
}
}
使用细节
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 ? a : b;//ok
//int c = a > b ? 1.1 : 3.4;//编译错误 double --> int
//int c = a > b ? (int)1.1 : (int)3.4;//ok
double c = a > b ? a : b + 3;// ok int --> double
System.out.println(c);// 11.0
}
}
练习：
案例：实现三个数的最大值
public class TernaryOperatorExercise{
//编写一个main方法
public static void main(String[] args){
//实现三个数的最大值
int n1 = 55;
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);//123
// 使用一条语句实现
int max = (1 > n2 ? n1 : n2) > n3 ?
(n1 > n2 ? n1 : n2) : n3;
System.out.println("最大数=" + max);//123
}
}
运算符优先级
1、运算符有不同的优先级，
所谓优先级就是表达式运算中的运算顺序
。如下面表格，上一行运算符总优先与下一行
| . () {} ; , | |
|---|---|
| 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 | = *= /= %= |
| += -= <<= >>= | |
>>>= &= ^= |
2、只有单目运算符、赋值运算符是
右向左
运算的。
梳理小结：
1）() , {} 等；【int a=2, b=5】
2）单目运算：++ – –
3）算术运算符：* / %
4）位移运算符：<< >>
5）比较运算符：< > <= >= instanceof
6）逻辑运算符：& | && ||
7）三元运算符：? :
8）赋值运算符：+= -= <<= >>=
标识符的命名规则和规范
标识符概念
1、Java 对各种变量、方法和类等命名时使用的字符序列称为
标识符
2、凡是自己可以起名字的地方都叫 标识符。【int num = 90;】
标识符的命名规则（必须遵守）
1、由26个英文字母大小写，0-9，_或 $ 组成
2、数字不可以开头。【int 3ac = 1;//错误】
3、不可以使用
关键字和保留字
，但能包含关键字和保留字。
4、Java 中严格区分大小写，长度无限制。【int totalNum = 10; int n = 90;】
5、标识符不能包含空格。【int a b = 90;//错误】
判断下面变量名是否正确
zzp //正确
zzp123 //正确
1zzp //错误 不能以数字开头
h-s //错误 不能有 -
x h //错误 有空格
h$4 //正确
class //错误 class关键字
int //错误 int关键字
double //错误 double关键字
public //错误 public关键字
static //错误 static关键字
goto //错误 goto保留字
stu_name //正确
标识符命名规范
1、
包名
：多单词组成时所有
字母都小写
：aaa.bbb.ccc //比如 com.zzp.spring
2、
类名、接口名
：多单词组成时，所有单词的
首字母大写
：XxxYyyZzz【大驼峰】，比如：TankShotGame
3、
变量名、方法名
：多单词组成时，
第一个字母首字母小写
，
第二个单词开始每个单词首字母大写
：xxxYyyZzz【小驼峰，简称
驼峰法
】，比如：tankShotGame
4、
常量名
：
所有字母都大写
。多单词时每个单词用
下划线连接
：XXX_YYY_ZZZ，比如：定义一个所得税 TAX_RATE
关键字
关键字的定义和特点
定义
：
被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 |
|---|
保留字
介绍
Java 保留字：现有Java版本尚为使用，但可以版本可能会作为关键字使用。自己命名标识符时要避免使用这些保留字
byValue、cast、future、generic、inner、operator、outer、rest、var、goto、const
。
键盘输入语句
介绍
在编程中，需要接收用户输入的数据，就可以使用键盘输入语句类获取。需要一个 扫描器（对象），就是 Scanner
步骤：
1）导入该类的所在包，
java.util.
*
2）创建该类的对象（声明变量）
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);
}
}
进制
进制介绍
对于整数，有四种表示方式：
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不区分大小写。
举例说明：
int n1 = 0b1010;//二进制 以0b 或 0B开头
int n2 = 1010;//十进制
int n3 = 01010;//八进制 以数字0开头表示
int n4 = 0x10101;//十六进制 以0x 或 0X 开头表示
//演示四种进制
public class BinaryTest{
//编写一个main方法
public static void main(String[] args){
// n1 二进制 以0b 或 0B开头
int n1 = 0b1010;
// n2 十进制
int n2 = 1010;
// n3 八进制 以数字0开头表示
int n3 = 01010;
// n4 十六进制 以0x 或 0X 开头表示
int n4 = 0x10101;
System.out.println("n1=" + n1);//10
System.out.println("n2=" + n2);//1010
System.out.println("n3=" + n3);//520
System.out.println("n4=" + n4);//65793
}
}
进制的图示
| 十进制 | 十六进制 | 八进制 | 二进制 |
|---|---|---|---|
| 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 |
进制的转换（基本功）
进制转换介绍
第一组：
- 二进制转十进制
- 八进制转十进制
- 十六进制转十进制
第二组：
- 十进制转二进制
- 十进制转八进制
- 十进制转十六进制
第三组：
- 二进制转八进制
- 二进制转十六进制
第四组：
- 八进制转二进制
- 十六进制转二进制
其他进制转十进制
- 二进制转十进制
- 八进制转十进制
- 十六进制转十进制
二进制转成十进制示例
规则：从最低位（右边）开始，将每个上的数提取出来，乘以2的（位数-1）次方，然后求和。
案例：请将 0b1011 传成十进制
# 从右边 开始<font color='red'>22</font>
0b1011 = 1*2的(1-1)次方 + 1*2的(2-1)次方 + 1*2的(3-1)次方 + 1*2的(4-1)次方
# 从右边 开始
0b
1
0
1
1
=
1 * 2的(1-1)次方
+
1 * 2的(2-1)次方
+ 0 * 2的(3-1)次方 +
1 * 2的(4-1)次方
= 1 + 2 + 0 + 8
= 11
八进制转成十进制示例
规则：从最低位（右边）开始，将每个位上的数提取出来，乘以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
练习：
0b110001100 转成 十进制
0b110001100
= 0 * 2^1 + 0 * 2^1 + 1 * 2^2 + 1 * 2^3 + 0 * 2^4 + 0 * 2^5 + 0 * 2^6 + 1 * 2^7 + 2 * 2^8
= 0 + 0 + 4 + 8 + 0 + 0 + 0 + 128 + 256
= 396
02456 转成 十进制
02456
= 6 * 8^0 + 5 * 8^1 + 4 * 8^2 + 2 * 8^3
= 6 + 40 + 256 + 1024
= 1326
0xA45 转成 十进制
0xA45
= 5 * 16^0 + 4 * 16^1 + 10 * 16^2
= 5 + 64 + 2560
= 2629
十进制转换成二进制
规则：将该数不断除以2，直到商为0为止，然后将每步得到的余数倒过来，就是对应的二进制。
案例：请将 34 转换成二进制
34 / 2 = 17 余 0
17 / 2 = 8 余 1
8 / 2 = 4 余 0
4 / 2 = 2 余 0
2 / 2 = 1 余 0
1 / 2 = 0 余 1
结果：34转换成二进制= 0B0010 0010
十进制转换成八进制
规则：将该数不断除以8，直到商为0为止，然后将每步得到的余数倒过来，就是对应的八进制
案例：请将 131 转成八进制
131 / 8 = 16 余 3
16 / 8 = 2 余 0
2 / 8 = 0 余 2
结果：131转成八进制=0203
十进制转换成十六进制
规则：将该数不断除以16，直到商为0为止，然后将每步得到的余数倒过来，就是对应的十六进制。
案例：请将 237 转成 十六进制
237 / 16 = 14 余 13 ->D
14 / 16 = 0 余 14 ->E
结果： 237转成十六进制 =0xED
练习：
123 转成 二进制
123 / 2 = 61 余 1
61 / 2 = 30 余 1
30 / 2 = 15 余 0
15 / 2 = 7 余 1
7 / 2 = 3 余 1
3 / 2 = 1 余 1
1 / 2 = 0 余 1
结果：123转成 二进制=0B0111 1011
678 转成八进制
678 / 8 = 84 余 6
84 / 8 = 10 余 4
10 / 8 = 1 余 2
1 / 8 = 0 余 1
结果：678转成八进制=01246
8912 转成十六进制
8912 / 16 = 557 余 0
557 / 16 = 34 余 13 ->D
34 / 16 = 2 余 2
2 / 16 = 0 余 2
结果：8912转成十六进制=0x22D0
二进制转换成八进制、十六进制
二进制转换成八进制
规则：从低位（右边）开始，将二进制每三位一组，转成对应的八进制即可。
案例：请将 0b11010101 转换成八进制
0b 011(3)
010(2)
101(5)
=3 2 5
最终结果：0325
### 二进制转换成十六进制
规则：从低位（右边）开始，将二进制数每四位一组，转成对应的十六进制数即可。
案例：请将 0b11010101 转成十六进制
0b 1101(13)
0101(5)
= 13 5
最终结果：0xD5
练习：
请将 0b11100101 转成 八进制
0b 011(3) 100(4) 101(5)
最终结果：0345
请将 0b11100101 转成 十六进制
0b 1110(14) 0101(5)
最终结果：0xE5
八进制、十六进制转成二进制
八进制转换成二进制
规则：将八进制数每1位，转成对应的的
一个3位的二进制
数即可
案例：请将 0237 转成二进制
0 237
2: 010
3: 011
7: 111
最终结果：0b1001 1111
十六进制转换成二进制
规则：将八进制数的每一位，转换对应的
4位的一个二进制
即可。
案例：请将0x23B转换成二进制
0x23B
2: 0010
3: 0011
B: 1011
最终结果：0b0010 0011 1011
练习：
请将 01230 转成二进制
01230
1: 001
2: 010
3: 011
0: 000
最终结果：0b0010 1001 1000
请将 0xAB29 转成二进制
0xAB29
A: 1010
B: 1011
2: 0010
9: 1001
最终结果：0b1010 1011 0010 1001
位运算思考题
1） 请看下面代码段，回答a,b,c,d,e结果是多少?
public static void main(String[] args)
{
//思路：
// （1）获取 1 的原码： 00000000 00000000 00000000 0000 0001
// 正数的原码，反码、补码都一样（三码合一）
// （2）>>2向右移2位 00000000 00000000 00000000 0000 0000 01(舍弃)
// 本质是: 1 / 2 / 2 = 0
//(3)最终结果： a = 0;
int a = 1 >> 2;//向右移2位
//思路：
//(1)获取 -1 的原码：10000000 00000000 00000000 0000 0001
// 转换为反码：11111111 11111111 11111111 1111 1110
// 转换为补码（反码+1）：11111111 11111111 11111111 1111 1111
//(2) >>2算术右移（补码）： 11111111 11111111 11111111 1111 1111 11(舍弃)
// >> 低位溢出，符号位不变，并用符号位补溢出的高位
// 补码转换为反码(-1)：11111111 11111111 11111111 1111 1110
// 反码转换原码：10000000 00000000 00000000 0000 0001
//(3) 最终结果： b = -1;
int b = -1 >> 2;//算术右移
//思路：
//(1)获取1的原码：00000000 00000000 00000000 0000 0001
// (2) <<2算术左移: 00000000 00000000 00000000 0000 0100
// 本质是: 1 * 2 * 2 = 4
//(3) 最终结果： c = 4;
int c = 1 << 2;//算术左移
//思路：
//(1)获取-1的原码：10000000 00000000 00000000 0000 0001
// 转换为反码：11111111 11111111 11111111 1111 1110
// 转换为补码（反码+1）：11111111 11111111 11111111 1111 1111
//(2) <<2算术右移（补码）： 11111111 11111111 11111111 1111 1100
// 符号位不变，低位补0
// 补码转换为反码(-1)：11111111 11111111 11111111 1111 1011
// 反码转换原码：10000000 00000000 00000000 0000 0100
//(3) 最终结果： d = -4;
int d = -1 << 2;
//思路：
// （1）获取3的原码：00000000 00000000 00000000 0000 0011
// (2)>>>无符号右移2位：00000000 00000000 00000000 0000 0000 11(舍弃)
//(3) 最终结果： e = 0;
int e = 3 >>> 2;// >>>无符号右移2位
//a,b,c,d,e结果是多少
System.out.println("a="+ a);//0
System.out.println("b=" + b);//-1
System.out.println("c=" + c);//4
System.out.println("d="+ d);//-4
System.out.println("e=" + e);//0
}
2）请回答在java中，下面的表达式的结果是：（位操作）
//思路：
//（1）获取2的原码：00000000 00000000 00000000 0000 0010
//(2) ~2区分操作 11111111 11111111 11111111 1111 1101 补码
// 补码转反码-1 ： 11111111 11111111 11111111 1111 1100
// 反码转原码： 10000000 00000000 00000000 0000 0011
//(3) 最终结果： -3;
~2 = -3;// 按位取反
//思路:
//(1)获取2的原码：00000000 00000000 00000000 0000 0010
//(2))获取3的原码：00000000 00000000 00000000 0000 0011
//(3) &按位与操作：00000000 00000000 00000000 0000 0010
// 最终结果： 2
2 & 3 = 2;// 2 按位与
//思路:
//(1)获取2的原码：00000000 00000000 00000000 0000 0010
//(2))获取3的原码：00000000 00000000 00000000 0000 0011
//(3) |按或或操作：00000000 00000000 00000000 000 00011
// 最终结果： 3
2 | 3 =3;
//思路:
//(1)获取-5的原码：10000000 00000000 00000000 0000 0101
// 转换为反码： 11111111 11111111 11111111 1111 1010
// 反码转换为补码（+1）：11111111 11111111 11111111 1111 1011
//(2) ~取反操作：00000000 00000000 00000000 0000 0100
// 最终结果： 4
~ -5 = 4;
//思路:
//(1)获取13原码: 00000000 00000000 00000000 0000 1101
//(2)获取7原码： 00000000 00000000 00000000 0000 0111
//(3) &按位与操作：00000000 00000000 00000000 0000 0101
// 最终结果： 5
13 & 7 = 5;
//思路:
//(1)获取5的原码：00000000 00000000 00000000 0000 0101
//(2))获取4的原码：00000000 00000000 00000000 0000 0100
//(3) |按或或操作：00000000 00000000 00000000 0000 0101
// 最终结果： 5
5 | 4 = 5;
//思路:
//(1)获取-3的原码：10000000 00000000 00000000 0000 0011
// 转换反码：11111111 11111111 11111111 1111 1100
// 转换补码+1: 11111111 11111111 11111111 1111 1101
//(2)获取3的原码: 00000000 00000000 00000000 0000 0011
//(3) ^按位异或操作：11111111 11111111 11111111 1111 1110 补码
// 转换反码 -1：11111111 11111111 11111111 1111 1101
// 转换为原码：10000000 00000000 00000000 0000 0010
// 最终结果： -2
-3^3 = -2;//^按位异或 3
二进制在运算中的说明
1、二进制是逢2进位制，0、1是基本算符。
2、现代的电子计算机技术全部采用的是二进制，因为它只使用0、1两个数字符号，非常简单方便，易于用电子方式实现。计算机内部处理的信息，都是采用二进制数来表示的。二进制（Binary）数用0和1两个数字及其组合来表示任何数。进位规则是“逢2进1”，数字1在不同的位上代表不同的值，按从右到左的次序，这个值以二倍递增。
原码、反码、补码(
重点、难点
)
对于有符号的而言：
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 |
比如： 2&3 ？ ~-2 ？ 2|3 ？ 2^3 ?
//位运算
public class BitOperator{
//编写一个main方法
public static void main(String[] args){
//推导过程
//1.先得到 2的补码
// => 2的原码 00000000 00000000 00000000 0000 0010
// 2的补码 00000000 00000000 00000000 0000 0010
//2.3的补码 ==> 3的源码 00000000 00000000 00000000 00000011
// 3的补码 00000000 00000000 00000000 0000 0011
//3.按位&
// 2的补码 00000000 00000000 00000000 0000 0010
// 3的补码 00000000 00000000 00000000 0000 0011
// 00000000 00000000 00000000 0000 0010 & 运算后的补码
// 运算的原码 也是 00000000 00000000 00000000 0000 0010
// 结果就是
System.out.println(2&3);//2
//推导过程
//1.先得到 -2的原码 10000000 00000000 00000000 0000 0010
//2. -2的 反码 11111111 11111111 11111111 1111 1101
//3. -2的补码(反码+1)11111111 11111111 11111111 1111 1110
//4. ~ -2取反操作 00000000 00000000 00000000 0000 0001
//5.运算后的源码 就是 00000000 00000000 00000000 0000 0001 => 1
System.out.println(~ -2);//1
//推导过程
//1.先得到2的补码： 00000000 00000000 00000000 0000 0010
//2.~2 按位取反 补码 11111111 11111111 11111111 1111 1101
//3. 运算后的反码 负数的反码 = 负数的补码 -1
// 11111111 11111111 11111111 1111 1100
//4. 运算后的原码 它的原码符号位不变，其它位取反（0 -> 1, 1 -> 0）
// 10000000 00000000 00000000 0000 0011 ==> -3
System.out.println(~2);//-3
//推导过程
//1.获取得到2的补码 00000000 00000000 00000000 0000 0010
//2.获取得到3的补码 00000000 00000000 00000000 0000 0011
// 按位或| 00000000 00000000 00000000 0000 0011
//运算的原码 也是 00000000 00000000 00000000 0000 0011
System.out.println(2|3);//3
//推导过程
//1.获取得到2的补码 00000000 00000000 00000000 0000 0010
//2.获取得到3的补码 00000000 00000000 00000000 0000 0011
// 按位异或^ 00000000 00000000 00000000 0000 0001
//运算的原码 也是 00000000 00000000 00000000 0000 0001
System.out.println(2^3);//1
}
}
还有3个位运算符 >>，<< 和 >>>
运算规则：
1、
算术右移 >>
：低位溢出，符号位不变，并用符号位补溢出的高位
2、
算术左移 <<
：符号位不变，低位补0
3、 >>> 逻辑右移也叫无符号右移，运算规则是：低位溢出，高位补0
4、特别说明：没有 <<< 符号
案例：BitOperator02.java
//1 => 00000000 00000000 00000000 0000 0001
//>>2: 00000000 00000000 00000000 0000 0000 01
// 本质是= 1 / 2 / 2 = 0
int a = 1 >>2;//算术右移
//1 => 00000000 00000000 00000000 0000 0001
//<<2: 00000000 00000000 00000000 0000 0100
// 本质是= 1 * 2 * 2 = 4
int c = 1 <<2;//算术左移
public class BitOperator02{
//编写一个main方法
public static void main(String[] args){
int a = 1 >>2;
int c = 1 <<2;
System.out.println("a="+ a);//0
System.out.println("c="+ c);//4
int b = 4 <<3;
// 0000 0100
// <<3 0010 0000
// 4 * 2^3
System.out.println("b="+ b);//32
System.out.println(15 >> 2);//15/2^2 =3
}
}
作业
1、计算下列表达式的结果
10 / 3 = ?;//3
10 / 5 = ?;//2
10 % 2 = ?;//0
//a % b 当 a 是小数时，公式 = a - (int)a / b * b
//注意：有小数运算，得到的结果是近似值
-10.5 % 3 = ?;//-10.5 - (-10)/3*3 = -10.5 - (-9) = -1.5
-10.4 % 3 = ?;//-10.4 - (-10)/3*3 = -10.5 - (-9) = -1.40000000004
2、试说出下面代码的结果
int i = 66;
//执行 i = i +1 => 67 ==> i = 67
// 67 + 67 = 134
System.out.println(++i + i);//134
3、在Java中，以下赋值语句正确的是（C、D）；
A) int num1 = (int) "18";//错误 应该使用 Integer.parseInt("18")
B) int num2 = 18.0; //错误 double --> int
C) double num3 = 3d;//正确 double 变量尾可加 D 或者 d 或不加
D) double num4 = 8;//正确 int --> double
E) int i = 48;char cn = i + 1;//错误 i + 1 => int -> char
F) byte b = 19;short s = b + 2;//错误 b + 2=> int --> short
4、试写出将String转换成double类型的语句，以及将char类型转换成String的语句，举例说明即可
String str = "18.8";//注意，字符串要可以被转成 double
double d1 = Double.parseDouble(str);
char c1 = '中';
String str2 = c1 + "";