Java 笔记 2
进制
进制的分类
十进制：
数字范围：0-9
进位规则：逢十进一
二进制：
数字范围：0-1
进位规则：逢二进一
八进制：
数字范围：0-7
进位规则：逢八进一
十六进制：
数字范围：0-9、A-F（或者a-f）
进位规则：逢十六进一
十进制 二进制 八进制 十六进制
0 0 0 0 0
1 1 1 1 1
2 2 10 2 2
3 3 11 3 3
4 4 100 4 4
5 5 101 5 5
6 6 110 6 6
7 7 111 7 7
8 8 1000 10 8
9 9 1001 11 9
10 10 1010 12 A
11 11 1011 13 B
12 12 1100 14 C
13 13 1101 15 D
14 14 1110 16 E
15 15 1111 17 F
16 16 10000 20 10
。。。。
25 25 11001
本质上，就是生活中的十进制，和计算机世界中的二进制
因为在计算机中二进制数字太长了，在代码中去表示二进制很繁琐，
那么引入了八进制和十六进制，为了快速和简短的表示二进制
（1）十进制–>二进制
（2）二进制–>八进制
把二进制从最右边开始，三位一组
（3）二进制–>十六进制
把二进制从最右边开始，四位一组
在程序中如何表示某个数字是十进制、二进制、八进制、十六进制
十进制，正常写
二进制，在数字前面加0B或0b
八进制，在数字前面加0
十六进制，在数字前面加0X或0x
为什么byte类型的范围是-128~127？
byte是1个字节，1个字节是8位
计算机中是使用“补码”的形式来存储数据的，为了理解/换算“补码”，我们在引入“原码、反码”。
规定：正数的原码、反码、补码三码合一；
负数的原码、反码、补码是不同的。
因为计算机中把最高位（最左边的二进制位）定为符号位，0表示正数，1表示负数。
25：
原码：0001 1001
反码：0001 1001
补码：0001 1001
-25：
原码：1001 1001
反码：1110 0110 符号位不变，其余位取反（0变1,1变0）
补码：1110 0111 在反码上加1
正0: 0000 0000
正数：
0000 0001 : 1
|
0111 1111 : 127
负数：补码
1000 0001 ： 补码（1000 0001）-》反码（1000 0000）–》原码（1111 1111） -127
|
1111 1111 ： 补码（1111 1111）-》反码（1111 1110）–》原码（1000 0001）-1
负0：1000 0000 如果用它表示负0，就浪费了，所以用它来表示其他的数
-127的二进制的补码：1000 0001
1的二进制的补码：0000 0001
-127 - 1 = （补码：1000 0001）-（补码：0000 0001） = 补码（1000 0000） = -128
计算机中用符号位来表示正、负，就是为了底层设计的简化，让符号位也参与计算。
浮点型的float和double在底层如何存储？
计算机中只有二进制？
那么如果存储3.14？
小数涉及：（1）整数部分（2）小数部分（3）这个.（4）正负号
化繁为简：
1、小数–>二进制：
（1）整数部分：除2倒取余
（2）小数部分：乘2取整数部分
3.14==》11.00100…
2、把这个二进制用科学记数法表示
1.1 00100… * n的1次方
用科学计数法表示后，对于二进制的科学计数法，整数部分永远是1，那这样的话，
整数部分就不用存了，小数点也不存了
只要存三个内容：（1）正负号（2）挪完后的几次方，指数（3）二进制的小数部分（称为尾数）
float：4个字节，就被分为三个部分，最高位还是符号位，接下来的8位用来存指数部分，然后剩下的存尾数，额如果存不下的尾数，就舍去了
double：8个字节，就被分为三个部分，最高位还是符号位，接下来的11位用来存指数部分，然后剩下的存尾数，额如果存不下的尾数，就舍去了
了解：
（1）浮点类型不精确，因为十进制的小数部分转二进制会需要舍去
（2）float类型的4个字节能表示的数字范围比long类型的8个字节还要大
因为浮点型底层存的是指数
基本数据类型之间的转换：
（1）自动类型转换
①把存储范围小的类型的值赋值给存储范围大的类型的变量，自动可以完成升级
byte->short->int->long->float->double
char->
②boolean不参与
③byte,short,char如果进行算术运算都会自动升级为int
（2）强制类型转换
①把存储范围大的类型的值，赋值给存储范围小的类型变量时，需要强制类型转换
double->float->long->int->short->byte
->char
强制类型转换是有风险的：可能会溢出或损失精度
②boolean不参与
③当需要把某个存储范围小的变量强制提升为存储范围大的类型时，也可以使用强制类型转换
public static void main(String[] args){
/*
从左边看d1是double类型
从右边看10是int类型
int类型的值，赋值给了double类型的变量，那么它会自动升级为double
*/
double d1 = 10;
System.out.println("d1 = " + d1);
/*
从左边看i1是int类型
从右边看10.0是double类型
double类型的值，赋值给int类型的变量，如果直接赋值会报错：错误: 不兼容的类型: 从double转换到int可能会有损失
*/
//int i1 = 10.3;
int i1 = (int)10.3;
System.out.println("i1 = " + i1);
byte b1 = 127;
byte b2 = 2;
//byte b3 = b1 + b2;//报错：不兼容的类型: 从int转换到byte可能会有损失，因为byte+byte就自动升级为int
byte b3 = (byte)(b1 + b2);
System.out.println("b3 = " + b3);
short s1 = 1;
short s2 = 2;
//short s3 = s1 + s2;//short+short会自动升级为int
short s3 = (short)(s1 + s2);
System.out.println("s3 = " + s3);
char c1 = '0';//'0'的编码值是48
char c2 = '1';//'1'的编码值是49
//char c3 = c1 + c2;//char+char会自动升级为int
char c3 = (char)(c1 + c2);
System.out.println("c3 = " + c3);//'a'
boolean flag = true;
//int num = (int)flag;//不兼容的类型: boolean无法转换为int
int x = 1;
int y = 2;
System.out.println("x / y = " + x/y);//整数/整数，结果还是整数，只保留整数部分
System.out.println("x / y = " + (double)x/y);//把x的int类型先强制升级为double类型
}
public static void main(String[] args){
char c1 = '0';
char c2 = '1';
/*
c1 + c2，按照求和运算，char + char结果是int
""代表空字符串，
当int的97与""进行 “+”拼接，结果还是97的字符串
*/
System.out.println(c1 + c2 + "");//97
/*
"" + c1，按照“拼接”运算，字符串 + char，结果是字符串，结果是"0"
"0" + c2，按照“拼接”运算，字符串 + char，结果是字符串，结果是"01"
*/
System.out.println("" + c1 + c2 );//01
/*
c1 + ""，按照“拼接”运算，char + 字符串 ，结果是字符串，结果是"0"
"0" + c2，按照“拼接”运算，字符串 + char，结果是字符串，结果是"01"
*/
System.out.println(c1 + "" + c2 );//01
}
运算符
1、算术运算符
加：+
减：-
乘：*
除：/
特殊：整数/整数，结果只保留整数部分
取模（取余）：%
特殊：只看被模数的正负号
被模数%模数
正号：+
负号：-
自增：++
对于自增变量本身来说，都会+1.
但是++在前还是在后，对于整个表达式的计算来说是不一样的。
++在前，先自增，然后取自增后变量的值，
++在后，先取变量的值，然后变量自增。
但是不管怎么样，自增变量的取值与自增操作一前一后一定是一起完成的。
自减：–
类同自增
```
public static void main(String[] args){
int x = 10;
int y = 3;
//System.out.println("x + y = " + x + y);//变为拼接
System.out.println("x + y = " + (x + y));
System.out.println("x - y = " + (x - y));
System.out.println("x * y = " + (x * y));
System.out.println("x / y = " + (x / y));
System.out.println("x % y = " + (x % y));
System.out.println("----------------------------------");
System.out.println("5%2 = " + 5%2);
System.out.println("-5%2 = " + -5%2);
System.out.println("5%-2 = " + 5%-2);
System.out.println("-5%-2 = " + -5%-2);
System.out.println("----------------------------------");
int a = -3;
System.out.println(-a);
System.out.println("----------------------------------");
int i = 2;
i++;
System.out.println("i = " + i);
int j = 2;
++j;
System.out.println("j = " + j);
System.out.println("----------------------------------");
int m = 1;
int n = ++m;//m先自增，然后把m的值取出来赋值给n
System.out.println("m = " + m);//2
System.out.println("n = " + n);//2
System.out.println("----------------------------------");
int p = 1;
int q = p++;//（1）先取出p的值"1"，先放到一个“操作数栈”，（2）然后p变量完成自增（3）把刚才放在“操作数栈”中的值赋值给q
System.out.println("p = " + p);//2
System.out.println("q = " + q);//1
System.out.println("----------------------------------");
int z = 1;
z = z++;//(1)先取出z的值"1"，先放到一个“操作数栈”，（2）然后z自增，变为2（3）把刚才放在“操作数栈”中的值赋值给z
System.out.println("z = " + z);
System.out.println("----------------------------------");
int b = 1;
int c = 2;
/*
第一个：b++
（1）先取b的值“1”，先放到一个“操作数栈”，
（2）紧接着b就自增了，b=2
第二步：++b
（1）先b自增，b=3
（2）紧接着再取b的值“3”，先放到一个“操作数栈”，
第三步：++b
（1）先b自增，b=4
（2）紧接着再取b的值“4”，先放到一个“操作数栈”，
第四步：c++
（1）先取c的值“2”，先放到一个“操作数栈”，
（2）紧接着c自增，c=3
第五步：算乘 ++b和c++的乘法部分
4*2 = 8 然后在压回“操作数栈”，
第六步：再算 b++ + ++b + 乘的结果
1 + 3 + 8 = 12
*/
int d = b++ + ++b + ++b * c++;
System.out.println("b = " + b);//4
System.out.println("c = " + c);//3
System.out.println("d = " + d);//12
}
```
运算符：
4、逻辑运算符
逻辑与：&
类似于：且
true & true 结果为true
true & false 结果为false
false & true 结果为false
false & false 结果为false
逻辑或：|
类似于：或
true | true 结果为true
true | false 结果为true
false | true 结果为true
false | false 结果为false
逻辑非：!
类似于：取反
!true 结果为false
!false 结果为true
逻辑异或：^
类似于：求不同
true ^ true 结果为false
true ^ false 结果为true
false ^ true 结果为true
false ^ false 结果为false
短路与：&&
结果：和&是一样的
运算规则：如果&&的左边已经是false，右边就不看了
true & true 结果为true
true & false 结果为false
false & ? 结果为false
false & ? 结果为false
短路或：||
结果：和|是一样的
运算规则：如果||左边已经是true，右边就不看了
true | ？ 结果为true
true | ？ 结果为true
false | true 结果为true
false | false 结果为false
public static void main(String[] args){
/*
判断成绩是否在70和80之间
数学：70<=score<=80
Java中：
*/
int score = -78;
/*
Test11_Logic.java:14: 错误: 二元运算符 '<=' 的操作数类型错误
if( 70<=score<=80){
^
第一个类型: boolean 70<=score的运算结果是true或false
第二个类型: int
1 个错误
*/
//if( 70<=score<=80){
// System.out.println("良好");
//}
if(70<=score & score<=80){
System.out.println("良好");
}
/*
假设成绩合理范围[0,100]
判断成绩是否小于0 或 大于100，输出成绩有误
*/
if(score<0 | score>100){
System.out.println("成绩有误");
}
/*
假设成绩合理范围[0,100]
判断成绩是否在合理范围内
*/
if(score>=0 & score<=100){
}
//或下面这么写
if(!(score<0 | score>100)){
}
System.out.println(true ^ true);
System.out.println(true ^ false);
System.out.println(false ^ true);
System.out.println(false ^ false);
/*
短路与：&&
短路或：||
*/
int i = 1;
int j;
/*
第一步：i++
(1)先取i的值“1”，放起来
(2)在i自增,i=2
第二步：算比较
放起来的“1” == 1比较，成立
&&左边是true，不会短路
第三步：++i
(1)先自增i=3
(2)再取i的值“3”，放起来
第四步：比较
放起来的“3” == 2比较，结果是false，不成立
第五步：
左边的true && 右边的false运算，结果为false，总的if不成立，走else
*/
//if(i++ == 1 && ++i == 2){
// j = 1;
//}else{
// j = 2;
//}
/*
第一步：i++
(1)先取i的值“1”，放起来
(2)在i自增,i=2
第二步：算比较
放起来的“1” == 1比较，成立
||左边是true，会发生短路，右边不看了（++i == 2）没运算
第三步：
true || ?，结果为true,总的if成立
*/
if(i++ == 1 || ++i == 2){
j = 1;
}else{
j = 2;
}
System.out.println("i = " + i);
System.out.println("j = " + j);
}
运算符：（了解）
6、位运算符
效率很高，但是可读性不好
因为它是基于二进制补码直接运算的。
左移：<<
运算规则：<<几位，就乘以2的几次方
二进制补码左移n位，右边补0
右移：>>
运算规则：>>几位，就除以2的几次方
二进制补码右移n位，左边补0还是1，看最高位
无符号右移：>>>
运算规则：二进制补码右移n位，左边补0，对于负数来说，移完后，变为正数
按位与：&
1 & 1 结果1
1 & 0 结果0
0 & 1 结果0
0 & 0 结果0
按位或：|
1 | 1 结果1
1 | 0 结果1
0 | 1 结果1
0 | 0 结果0
按位异或：^
1 ^ 1 结果0
1 ^ 0 结果1
0 ^ 1 结果1
0 ^ 0 结果0
按位取反：~（一元运算符）
~1为0
~0为1
public static void main(String[] args){
/*
4的二进制：0000 0100
4<<3：0 0100000
*/
System.out.println(4 << 3);//等价于4乘以2的3次方，4*8=32
/*
32的二进制：0010 0000
32>>4：0000 0010
*/
System.out.println(32 >>4);//等价于32除以2的4次方，32/16 =2
/*
-32的二进制：
原码：1010 0000
反码：1101 1111
补码：1110 0000
-32>>4：1111 1110
补码：1111 1110
反码：1111 1101
原码：1000 0010
*/
System.out.println(-32 >>4);
System.out.println(32 >>> 4);//和>>一样，左边补0
/*
-32的二进制：
原码：1000 0000 0000 0000 0000 0000 0010 0000
反码：1111 1111 1111 1111 1111 1111 1101 1111
补码：1111 1111 1111 1111 1111 1111 1110 0000
-32>>>4：0000 1111 1111 1111 1111 1111 1111 1110
最高位是0，是正数
*/
System.out.println(-32 >>> 4);
/*
32：0000 0000 0000 0000 0000 0000 0010 0000
25：0000 0000 0000 0000 0000 0000 0001 1001
32 & 25：0000 0000 0000 0000 0000 0000 0000 0000
*/
System.out.println(32 & 25);
/*
32：0000 0000 0000 0000 0000 0000 0010 0000
25：0000 0000 0000 0000 0000 0000 0001 1001
32 | 25：0000 0000 0000 0000 0000 0000 0011 1001
*/
System.out.println(32 | 25);
/*
32：0000 0000 0000 0000 0000 0000 0010 0000
25：0000 0000 0000 0000 0000 0000 0001 1001
32 | 25：0000 0000 0000 0000 0000 0000 0011 1001
*/
System.out.println(32 ^ 25);
/*
3：0000 0000 0000 0000 0000 0000 0000 0011
~3:1111 1111 1111 1111 1111 1111 1111 1100
补码：1111 1111 1111 1111 1111 1111 1111 1100
反码：1111 1111 1111 1111 1111 1111 1111 1011
原码：1000 0000 0000 0000 0000 0000 0000 0100 -4
*/
System.out.println(~3);
}
交换两个变量值的三种方法
public static void main(String[] args){
int x = 1;
int y = 2;
/*
通用的方案：适用于任意的数据类型
借助于第三个通样类型的临时变量
*/
int temp = x;//x变量中值就赋值给了temp temp = 1
x = y;//再把y中的值放到x中，x = 2
y = temp;//再把temp中的值赋值给y y=1
System.out.println("x = " + x);
System.out.println("y = " + y);
x = 1;
y = 2;
/*
方案二：只适用于int等整数类型
*/
x = x ^ y;
y = x ^ y;//(新的x) ^ 原来的y = (原来的x ^ 原来的y) ^ 原来的y = 原来的x （求不同）
x = x ^ y;//(新的x) ^ 新的y = (原来的x ^ 原来的y) ^ 原来的x = 原来的y
System.out.println("x = " + x);
System.out.println("y = " + y);
x = 1;
y = 2;
/*
方案三：只适用于int等整数类型
有风险，可能会溢出
*/
x = x + y;//有风险，可能会溢出
y = x - y;//(新的x) - 原来的y = (原来的x + 原来的y)- 原来的y = 原来的x
x = x - y;//(新的x) - 新的y = (原来的x + 原来的y) - 原来的x = 原来的y
System.out.println("x = " + x);
System.out.println("y = " + y);
/*
以下不推荐
*/
x = 1;
y = 2;
x = x * y;//风险更大
y = x / y;
x = x / y;
}