标签：了解 OLE 简化 har 拼接 部分 异或 字符串类 程序
一、进制
/*
进制：（了解）
1、进制的分类
十进制：
数字范围：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）二进制-->十六进制
把二进制从最右边开始，四位一组
2、在程序中如何表示某个数字是十进制、二进制、八进制、十六进制
十进制，正常写
二进制，在数字前面加0B或0b
八进制，在数字前面加0
十六进制，在数字前面加0X或0x
3、为什么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
计算机中用符号位来表示正、负，就是为了底层设计的简化，让符号位也参与计算。
*/
class Test01_JinZhi{
public static void main(String[] args){
System.out.println(10);//十进制，正常写
System.out.println(0B10);//二进制，在数字前面加0B或0b
System.out.println(010);//八进制，在数字前面加0
System.out.println(0X10);//十六进制，在数字前面加0X或0x
}
}
/*
了解：浮点型的float和double在底层如何存储？
计算机中只有二进制？
那么如果存储3.14？
小数涉及：（1）整数部分（2）小数部分.（3）正负号
化繁为简：
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个字节还要大
因为浮点型底层存的是指数
*/
class Test02_FloatDoubleSave{
}
03-----------------------------------------
/*
基本数据类型之间的转换：
（1）自动类型转换
①把存储范围小的类型的值赋值给存储范围大的类型的变量，自动可以完成升级
byte->short->int->long->float->double
char->
②boolean不参与
③byte,short,char如果进行算术运算都会自动升级为int
（2）强制类型转换
①把存储范围大的类型的值，赋值给存储范围小的类型变量时，需要强制类型转换
double->float->long->int->short->byte
->char
强制类型转换是有风险的：可能会溢出或损失精度
②boolean不参与
③当需要把某个存储范围小的变量强制提升为存储范围大的类型时，也可以使用强制类型转换
*/
【注意】
数据类型转换的特例：字符串类型
所有类型与字符串“+”拼接，结果都是字符串
------------------------
运算符：
1、算术运算符
加：+
减：-
乘：*
除：/
特殊：整数/整数，结果只保留整数部分
取模（取余）：%
特殊：只看被模数的正负号
被模数%模数
正号：+
负号：-
自增：++
对于自增变量本身来说，都会+1.
但是++在前还是在后，对于整个表达式的计算来说是不一样的。
++在前，先自增，然后取自增后变量的值，
++在后，先取变量的值，然后变量自增。
但是不管怎么样，自增变量的取值与自增操作一前一后一定是一起完成的。
自减：--
类同自增
例子1
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
例子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
例题2
例题3
注意事项：
/*
运算符：
2、赋值运算符
（1）基本的赋值运算符：=
赋值操作：永远是把=右边的常量值、变量中值、表达式计算的值赋值给=左边的变量，
即=左边只能是一个变量。
运算的顺序：把右边的整个表达式先算完，才会做最后的赋值操作。
（2）扩展的赋值运算符
例如：
+=
-=
*=
/=
%=
...
b2 += b1;//等价于 b2 = (byte)(b2 + b1);
*/
什么叫一元运算符，什么叫二元运算符
一元运算符：操作数只有一个
例如：a++ 其中a就是操作数
-a 其中a就是操作
二元运算符：需要两个操作数
例如：求和 a+b 其中a和b就是操作
比较大小 age>=18 其中的age和18都是操作数
三元运算符：需要三个操作数
逻辑运算符
运算符：
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
*/
运算符：
5、条件运算符，（三元运算符）
因为它是唯一的三元运算符，所以也称为三元运算符
条件表达式 ？ 结果表达式1 ： 结果表达式2
整个表达式包含三个部分。
运算规则：如果条件表达式成立，就取结果表达式1的值，否则就取结果表达式2的值
标签：了解 OLE 简化 har 拼接 部分 异或 字符串类 程序
原文地址：https://www.cnblogs.com/liliang07/p/13174329.html
