一、进制
/*
进制：（了解）
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的值
精选练习题
//练习：假设今天是周4，100天以后是周几？
int day=100;
int cs=100%7;
int now=(4+cs)%7;
System.out.println("100天后是周" + now);
---------------------------------------
//练习3：如下代码的运算结果是：
int i = 2;
i *= i++; //i=i*i++ //4
int j = 2;
j *= j+1; //j=j*(j+1) //6
int k = 2;
k *= ++k; //k=k*(++k) //6
System.out.println("i=" + i);
System.out.println("j=" + j);
System.out.println("k=" + k);
--------------------
/*
//练习4：为抵抗洪水，战士连续作战89小时，编程计算共多少天零多少小时？
int times=89;
int day=89/24;
int newTimes=89%24;
System.out.println("天数:"+day);
System.out.println("小时:"+newTimes);
*/
/*
//练习5：假设今天是周4，100天以后是周几？
int day=100;
int cs=100%7;
int now=(4+cs)%7;
System.out.println("100天后是周" + now);
*/
## 第八题
案例：求三个整数x,y,z中的最大值
* 按步骤编写代码，效果如图所示：
* 编写步骤：
1. 定义类Test8
2. 定义main方法
3. 定义三个int类型变量,x,y,z，随意赋值整数值
4. 定义一个int类型变量max，先存储x与y中的最大值（使用三元运算符）
5. 再次对max赋值，让它等于上面max与z中的最大值（使用三元运算符）
6. 输出结果
*/
/*
int a=2,b=5,c=7;
int max=a>b?a:b;
max=max>c?max:c;
System.out.println(max);
*/
/*
## 第九题
案例：给定一个年份，判断是否是闰年
闰年的判断标准是：
? 1）可以被4整除，但不可被100整除
? 2）可以被400整除
* 按步骤编写代码，效果如图所示：
* 编写步骤：
1. 定义类Test9
2. 定义main方法
3. 定义一个int类型变量year，随意赋值一个年份
4. 定一个一个boolean类型变量，用来保存这个年份是否是闰年的结果
5. 输出结果
*/
/*
int year=2020;
boolean flag=year%4==0&&year%100!=0||year%400==0;
System.out.println(year+(flag?"是":"不是")+"闰年");
*/
//----------------------------------------------------------------
/*## 第十题
案例：小明要到美国旅游，可是那里的温度是以华氏度为单位记录的。它需要一个程序将华氏温度（80度）转换为摄氏度，并以华氏度和摄氏度为单位分别显示该温度。
* 编写步骤：
1. 定义类Test10
2. 定义main方法
3. 定义一个double类型变量hua，存储华氏温度80
4. 定义一个double类型变量she，存储摄氏温度，根据公式求值
5. 输出结果*/
double hua = 80;
double she = (hua-32)/1.8;
System.out.println("华氏度" + hua + "℉转为摄氏度是" + she + "℃");
}