标识符：在Java中对类名、变量名、方法名等这些要素进行命名的字符序列称为标识符。
通俗的理解：凡是程序员自己命名的地方都叫做标识符。
1、标识符的命名规则（必须遵守，否则编译或运行错误）
（1）Java的标识符必须用26个英文字母的大小写、数字0-9，美元符号**$，下划线_**
（2）Java的标识符不能使用关键字（包含保留字）和特殊值
例如：class,public,static,void等
一共不能用的有50个关键字+3个特殊值
（3）不能使用空格 class Biao Shi Fu{} ×
（4）数字不能开头 class 2Test{} ×
（5）Java的标识符严格区分大小写
2、标识符的命名规范（建议遵守，不遵守会被鄙视）
（1）见名知意
让别人一看就知道这个类、变量、方法的意义在哪里。
（2）类名、接口名等，要求每一个单词的首字母大写，形式：XxxYyyZzz
例如：HelloWorld，BiaoShiFu
（3）变量名、方法名等：要求从第二个单词开始，首字母大写，其余字母小写，
形式：xxxYyyZzz
例如：main()方法，println()方法，print()方法，nextInt()方法
（4）包名等：要求所有单词都小写，每个单词之间使用.分割
形式：xxx.yyy.zzz
例如：java.lang,java.util,java.io,java.text,java.time等
（5）常量名：要求所有单词都大写，每个单词之间使用_分割
形式：XXX_YYY_ZZZ
例如：PI（圆周率），MAX_VALUE（最大值）
环境变量：path
作用：环境变量是给操作系统找xx命令的路径。
1.变量：
作用：用来存储值（数据）
在Java中，变量本质上，就是代表一块内存区域。
变量中的数据是存储在JVM内存中。
2、变量有三个要素：
（1）数据类型
是用来存储：字符串、小数、整数、单个字符、布尔值、对象…
（2）变量名
在程序中，通过变量名来进行访问这块内存及其里面的数据
（3）值
变量中存的具体的值
变量中的值是可以变的
class TestVariable{
public static void main(String[] args){
//想要用一个变量，来存储年龄
//int就是数据类型
//age就是变量名
//18就是变量的值
int age = 18;
System.out.println(age);
age = age + 1;
System.out.println(age);
}
}
**Define：定义，声明
Use：使用
Variable：变量 **
1.变量使用的原则：
（1）先声明后使用
包括后面用到的类、方法等，都是遵循先声明后使用
（2）变量必须先初始化（第一次赋值）再访问它的值（打印、计算、比较操作）
（3）变量的声明，在同一个作用域中，只能声明一次，但是赋值可以很多次
作用域：从变量声明处开始，到它所属的{}结束
class DefineAndUseVariable{
public static void main(String[] args){
int age = 18;
// int age = 19;//错误的，第二次赋值不用再加数据类型
age = 19;//第二次赋值
System.out.println(age);
if(true){
int num = 0;
}
//System.out.println(num);//错误的，出了num的作用域
}
2、如何声明一个变量？
格式：
数据类型 变量名;
例如：
int age;
3、如何给变量赋值？
格式：
变量名 = 变量值;
例如：
age = 18;
常用的变量的数据类型（刚开始）：
int（整数）
double（小数）
char（单个字符）
String（字符串）
class DefineAndUseVariable{
public static void main(String[] args){
int age = 19;
System.out.println(age);
String name = "柴林燕";//字符串的常量必须用""（双引号）
char gender = '女';//单字符的常量，必须用''（单引号）
double weight = 40.5;//小数类型
boolean marry = true;//布尔类型 真的，假的，成立，不成立
}
public static void test(){
//System.out.println(age);//错误的，出了age的作用域
}
}
class TestExer2{
public static void main(String[] args){
String name = "柴林燕";
/*
""中的内容，原因显示
name是变量，在显示的时候，不是显示name单词，而是把name变量中存的值取出来显示，所以这里name不加""
"姓名：" + name：把姓名:和name变量中的值拼接起来一起显示
*/
System.out.println("姓名：" + name);
}
}
1.Java中的数据类型：
（1）基本数据类型（8种）
（2）引用数据类型（今天不讲）
String是引用数据类型
2.基本数据类型
（1）、整型系列
byte: 字节类型 范围：-128~127
1个字节
short:短整型
2个字节 范围：-32768~32767(前后三万)
int:整型
4个字节 范围：…
long:长整型
8个字节
说明：对于long类型的常量，需要加大写L（建议用大写）或小写l 例如:long tel = 18201583096L;
（2）、小数类型，浮点型系列
float:
单精度浮点型，4个字节，
大概的精度范围是，把小数用科学记数法表示后，小数点后6~7位
说明：float类型的常量，需要在数字后面加F或f 例如：float f = 1.2F;
double：双精度浮点型，8个字节
大概的精度范围是，把小数用科学记数法表示后，小数点后15~16位
（3）、字符类型
char：单字符类型，2个字节，可以表示汉字
在Java中是使用Unicode编码表表示。（兼容ASCII码）
每一个字符都有一个唯一的Unicode编码值。
例如：
数字0，Unicode编码值是48
数字1，Unicode编码值是49
…
字母A，Unicode编码值是65
字母B，Unicode编码值是66
…
字母a，Unicode编码值是97
字母b，Unicode编码值是98
…
如何表示char类型的字符常量呢？
（1）‘一个字符’，例如：‘女’,‘A’ 例：char shuang = ‘"’;//这样可以，表示单个字符
（2）‘转义字符’，例如：’\n’（换行）,’\t’（制表位Tab键）,
‘\’（斜杠）,’"’（双引号）,’’’（单引号）, 例：System.out.println(“柴老师说:“今天天气真好””);//这里要输出双引号，需要转义
‘\b’（删除键Backspace）,’\r’（回车键）
（3）’\u 字符的Unicode编码值的十六进制形式’ 例：char shang = ‘\u5c1a’;
(4)、布尔类型
boolean：只能存两个值之一：true,false
一般boolean的值用于条件判断
计算机表示数据用二进制表示，即0和1
那么一位0或1，我们用bit（位），最小单位
计算机中最基本的单位用的byte字节，
1字节 = 8位
1KB = 1024B
1MB = 1024KB
1GB = 1024MB
1TB = 1024GB
…
3.扩展：
硬件厂商存储单位用1000进位，不是1024.
带宽 100Mb,b = bit
class TestType{
public static void main(String[] args){
boolean marry = false;
if(marry){//marry中的值为true，就表示条件成立
System.out.println("已婚");
}else{
System.out.println("未婚");
}
System.out.println("--------------------------");
byte b = 127;
long tel = 18201583096L;
float f = 1.2F;
char shuang = '"';//这样可以，表示单个字符
System.out.println(shuang);
System.out.println("柴老师说:\"今天天气真好\"");//这里要输出双引号，需要转义
char shang = '\u5c1a';
System.out.println(shang);
}
}
声明一些变量，来保存，一份图书信息：
书名：
作者：
价格：
销量：
库存量：
是否是促销产品：
class TestExer3{
public static void main(String[] args){
/*
String的S是大写的
*/
String bookName = "《从入门到放弃》";
String author = "柴林燕";
double price = 100.0;
int sale = 0;
int amount = 100;
boolean cu = true;
System.out.println("书名：" + bookName);
System.out.println("作者：" + author);
System.out.println("价格：" + price);
System.out.println("销量：" + sale);
System.out.println("库存量：" + amount);
System.out.println("是否促销：" + cu);
}
}
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）这个.（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不参与
③当需要把某个存储范围小的变量强制提升为存储范围大的类型时，也可以使用强制类型转换
class Test03_TypeChange{
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类型
}
}
class Test04_TypeChange{
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.
但是++在前还是在后，对于整个表达式的计算来说是不一样的。
++i 在前，先自增，然后取自增后变量的值，
i++ 在后，先取变量的值，然后变量自增。
但是不管怎么样，自增变量的取值与自增操作一前一后一定是一起完成的。
自减：–
类同自增
class Test05_Arithmetic{
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("----------------------------------");
/*
第一个：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
System.out.println("b = " + b);//4
System.out.println("c = " + c);//3
System.out.println("d = " + d);//12
*/
int b = 1;
int c = 2;
int d = b++ + ++b + ++b * c++;
System.out.println("b = " + b);
System.out.println("c = " + c);
System.out.println("d = " + d);
}
}
class Test06_Exer1{
public static void main(String[] args){
/*
第一步：i++
（1）先取i的值“1”，放起来
（2）i自增，i=2
第二步：++i
（1）先自增，i=3
（2）再取i的值“3”，放起来
第三步：计算求和 1 + 3 = 4
System.out.println(i++ + ++i);//4
System.out.println(i);//3
*/
int i = 1;
System.out.println(i++ + ++i);
System.out.println(i);
}
}
class Test06_Exer2{
public static void main(String[] args){
/*
第一步：i++
（1）先取i的值“1”，放起来
（2）i自增,i=2
第二步：j
（1）取j的值，放起来
第三步：
求乘积，1*2 = 2，再把结果放起来
第四步：++j
（1）先自增，j=3
（2）再取j的值“3”，放起来
第五步：求和 2 + 3 = 5
System.out.println(i++ * j + ++j);//5
*/
int i = 1;
int j = 2;
System.out.println(i++ * j + ++j);
}
}
class Test06_Exer3{
public static void main(String[] args){
/*
第一步：++i
(1)先自增,i=2
(2)在取i的值“2”，放起来
第二步：j
(1)取j的值“2”，放起来
第三步：++i
(1)先自增，i=3
(2)在取i的值"3"，放起来
第四步：求乘积
2 * 3 = 6，结果放起来
第五步：求和
2 + 6 = 8
*/
int i = 1;
int j = 2;
System.out.println(++i + j * ++i);
}
}
（1）基本的赋值运算符：=
赋值操作：永远是把=右边的常量值、变量中值、表达式计算的值赋值给=左边的变量，
即=左边只能是一个变量。
运算的顺序：把右边的整个表达式先算完，才会做最后的赋值操作。
（2）扩展的赋值运算符
例如：
+=
-=
*=
/=
%=
…
class Test09_Modify2{
public static void main(String[] args){
int i = 1;
int j = 5;
//j *= i++ + j++; 等加于 j = j * (i++ + j++);
/*
第一步：先把j的值“5”放起来
第二步：i++
(1)先取i的值“1”，放起来
(2)i自增，i=2
第三步：j++
(1)先取j的值“5”
(2)在j自增 j = 6
第四步：求和
1 + 5 = 6
第三步：乘
用“5” * (和) = 5 * 6 = 30
第四步：赋值，把乘积赋值给j
*/
j *= i++ + j++;
System.out.println("i = " + i);//2
System.out.println("j = " + j);//30
}
}
运算符：比较运算符
大于：>
小于：<
大于等于：>=
小于等于：<=
等于：==
注意，谨防与赋值的=混淆
不等于：!=
比较运算符，计算完后的结果只有两个：true,false
说明比较运算符的表达式，可以作为（1）判断的条件（2）逻辑运算符的操作数
比较运算符能够用于基本数据类型，不能用于引用数据类型。
除了==和!=，关于引用数据类型时它俩的意义后面再讲。
一元运算符：操作数只有一个
例如：a++ 其中a就是操作数
-a 其中a就是操作
二元运算符：需要两个操作数
例如：求和 a+b 其中a和b就是操作
比较大小 age>=18 其中的age和18都是操作数
三元运算符：需要三个操作数
class Test10_Compare{
public static void main(String[] args){
/*
有一个变量age,表示年龄，判断是否成年（满足18岁）
*/
int age = 26;
System.out.println("是否成年：" + (age>=18)); //比较运算符能够用于基本数据类型，不能用于引用数据类型。(去掉括号)
/*
比较运算符作为条件
*/
if(age >= 18){
System.out.println("祝你玩得愉快！");
}else{
System.out.println("未成年不得进入！");
}
/*
有一个变量，存储的是boolean类型的值
*/
boolean flag = false;
if(flag == true){//不会修改flag里面的值
System.out.println("条件成立");
}
//与上面的语句是等价的
if(flag){
System.out.println("条件成立");
}
if(flag = true){//不是比较，而是赋值，结果仍然是布尔值，只要是布尔值就可以作为条件
System.out.println("条件成立");
}
System.out.println("flag = " + flag);
/*
有一个变量，存储的是其他类型的值
*/
int num = 1;
if(num == 1){
System.out.println("num=1");
}
//if(num = 1){//错误的，因为num=1是赋值表达式，结果还是int，int值是不能作为条件的
// System.out.println("num=1");
//}
}
}
运算符：逻辑运算符
逻辑与：&
类似于：且
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
class Test11_Logic{
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);
/*
短路与：&&
短路或：||
*/
/*
第一步：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成立
*/
int i = 1;
int j;
if(i++ == 1 || ++i == 2){
j = 1;
}else{
j = 2;
}
System.out.println("i = " + i);
System.out.println("j = " + j);
}
}
答案：
1 ：x=2 y=2
2 ：x=2 y=1
3 ：x=7 y=2
4 ：x=7 y=1
举例 3
class Test12_Exer3{
public static void main(String[] args){
int x = 1;
int y = 1;
/*
第一步：x++
(1)先取x的值“1”
(2)再x自增x = 2
第二步：比较
用“1”与1比较， 1==1，成立，true
中间是|，不是短路或，右边要继续
第三步：++y
(1)y先自增，y=2
(2)再去y的值“2”
第四步：比较
用“2”与1比较 2==1，不成立，结果为false
第五步：逻辑
true & false，结果为true，总的if成立，要执行x = 7
*/
if(x++ == 1 | ++y==1){
x = 7;
}
System.out.println("x = " + x + ",y = " + y);//x = 7,y = 2
}
}
第一种情况为：z = 44
第二种情况为：z = 46
运算符：条件运算符
因为它是唯一的三元运算符，所以也称为三元运算符
条件表达式 ？ 结果表达式1 ： 结果表达式2
整个表达式包含三个部分。
运算规则：如果条件表达式成立，就取结果表达式1的值，否则就取结果表达式2的值
class Test14_Condition{
public static void main(String[] args){
boolean marry = false;
System.out.println(marry ? "已婚" : "未婚");
//找出x和y中的最大值
int x = 4;
int y = 4;
int max = x>=y ? x : y;
/*
等价于
if(x>=y){
max = x;
}else{
max = y;
}
*/
System.out.println(x + "，" + y + "中的最大值是：" + max);
}
}
运算符：（了解）位运算符
效率很高，但是可读性不好
因为它是基于二进制补码直接运算的。
左移：<<
运算规则：<<几位，就乘以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
class Test15_Bit{
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);
}
}