【JavaSE】P1~P32 进制，字节，Java代码规范，常量，变量，运算符

IDEA常用快键键和快捷用法

• idea
  shift + F6 鼠标选中原变量名，批量替换变量名
  Alt +insert 打开Generate，快速生成构造器和Getter,Setter。或者Code ->Generate 选择
  
  

Alt + 回车 Enter 选中在使用的类名，对已经写了用的类，自动导包
fori 后 回车enter 快速生成循环参数i

• array.fori 快速生成循环遍历数组array
  变量.fori快速生成for循环，i从0++到变量大小
  同理：list.fori 快速生成遍历ArrayList的for循环（ArrayList list）
• 自动生成接收返回值的变量： 选择调用有返回值的方法，alt + enter选local那一项，定义变量名后enter确定
  
  

一、需要复习的重难点概念

1 进制、字节、DOS操作命令语句

进制及转化

• HEX 16进制 DEC 10进制 OCT 进制 BIN 2进制

• 10进制转2进制：
  辗转相除法，10进制数每次除2，记录余数，直到10进制数除到0，余数反制即为对应2进制数
  

• 2进制转10进制：
  从最低位即2进制最右开始，每一位对应的10进制值分别为 2^0, 2^1, 2^2……依次类推。每位的1或0乘以该位10进制值，全部加起来得到总体10进制值。
  

字节

位（bit）：一个数字0或一个1，代表一位
字节（Byte）：每逢8位是一个字节，这是数据存储的最小单位。
1 Byte = 8bit
比方说，办了一个带宽100Mbps的宽带，下载东西时速度应该为100/8 ≈ 12.5 MB/s。因为单位一个是Byte，一个是bit

1KB = 1024Byte = 2^10 Byte
1MB = 1024KB
1GB = 1024MB
1TB = 1024GB
1PB = 1024TB
1EB = 1024PB
1ZB = 1024EB

DOS系统命令提示符

MS-DOS(Microsoft Disk Operating System) 非图形操作系统
正斜杠/ 反斜杠
Win+R 输入cmd打开，>前为当前所在文件夹位置
1、切换盘符 盘符名： 大小写都可 D: c:
2、进入文件夹 cd 文件夹名 多级进入cd ……\……\
3、Tab补全字符or多个备选项则切换，例如要进入哪个文件夹时，cd li 按下Tab
4、cd.. 返回上级文件夹
5、cd \ 直接返回D盘根路径
6、dir 打印当前目录内容，文件夹为

，文件显示大小
7、cls 清屏
8、exit 退出

2 Java 常用代码规范

参考 Java基础——java代码规范详细版————————————————
版权声明：本文为CSDN博主「ddm01」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_34869143/article/details/94554253(https://blog.csdn.net/qq_34869143/article/details/94554253)

1. 标识符

• 标识符硬命名规则：
  1.可用26个英文字母大小写 0到9数字 $ _
  2.不能以数字开头
  3.不能是关键字
• 软规则：
  1.类名，大驼峰，即每个单词首字母大写。 MyNote
  2.变量名，方法名，除了第一个单词后续单词首字母大写。小驼峰 myCode

2. 包名
   使用小写字母如 com.xxx.settlment，不要 com.xxx.Settlement
   单词间不要用字符隔开，比如 com.xxx.settlment.jsfutil，而不要com.xxx.settlement.jsf_util
   英文小写，数字，英文句.
   包名.相当于分隔符，多层文件夹
3. 后缀名

后缀名	意义	举例
Impl	这个类是一个实现类，而不是接口	PaymentOrderServiceImpl
Inter	这个类是一个接口	LifeCycleInter
Dao	这个类封装了数据访问方法	PaymentOrderDao
Listener	响应某种事件的类	PaymentSuccessListener
Wrapper	这是一个包装类，为了给某个类提供没有的能力	SelectableOrderListWrapper
Bean	这是一个POJO	MenuStateBean

4. 方法名
   首字母小写，如 addOrder() 不要 AddOrder()
   动词在前，如 addOrder()，不要orderAdd()
   动词前缀往往表达特定的含义，如下表：

前缀名	意义	举例
create	创建	createOrder()
delete	删除	deleteOrder()
add	创建，暗示新创建的对象属于某个集合	addPaidOrder()
remove	删除	removeOrder()
init或则initialize	初始化，暗示会做些诸如获取资源等特殊动作	initializeObjectPool
destroy	销毁，暗示会做些诸如释放资源的特殊动作	destroyObjectPool
open	打开	openConnection()
close	关闭	closeConnection()
read	读取	readUserName()
write	写入	writeUserName()
get	获得	getName()
set	设置	setName()
copy	复制	copyCustomerList()
modity	修改	modifyActualTotalAmount()
calculate	数值计算	calculateCommission()
do	执行某个过程或流程	doOrderCancelJob()
start	开始	startOrderProcessing()
stop	结束	stopOrderProcessing()
send	发送某个消息或事件	sendOrderPaidMessage()
receive	接受消息或时间	receiveOrderPaidMessgae()
find	查找对象	findNewSupplier()

5. 静态常量
   全大写用下划线分割，如
   public static find String ORDER_PAID_EVENT = “ORDER_PAID_EVENT”;
6. 枚举
   全大写，用下划线分割，如

public enum Events {
ORDER_PAID,
ORDER_CREATED

}

7. 二元三元运算符两边用一个空格隔开

b - d = e;
return a == b ? 1 : 0;

8. 逗号语句后如不换行，紧跟一个空格
   如下：

call(a, b, c);

不能如下：

call(a,b,c);

3 常量及常量的打印

1. 常量概念和分类
   常量：程序运行齐健，固定不变的
   字符串：“”引起来的
   整数：100,250
   浮点数：2.5 ， -3.14， 0.0
   字符：‘A’引起来的，不可以为空，也不能是两个字符，必须有且仅有一个字符
   布尔：只有true 和false两种取值
   空常量： null
2. 常量打印

 		System.out.println("ABC");
        System.out.println("");//字符串可以为空
        System.out.println("0");
        System.out.println(-500);
        System.out.println(30);
        System.out.println(3.14);
        System.out.println(-2.5);
//× 错误写法 System.out.ptintln('');
//× 错误写法 System.out.ptintln(‘AS’);
 		System.out.println('s');
        System.out.println(true);

• ？疑问，char怎么打印为他的码值而非字符

   		System.out.println(num3);//%
        System.out.println(num3 + 0);//37

因为char/byte/short类型计算时会提升为int

4 变量

数据类型及取值范围

1. 基本数据类型
   4类8种

• 整数型：byte,short,int（默认）,long（数后带L或l推荐大写）
• 浮点型：double（默认）,float(后带F或f推荐大写）
• 字符型：char
• 布尔型：boolean

2. 引用数据类型
   字符串，数组，类，接口
3. 数据所占内存和取值范围

• 字节即Byte。1Byte = 8 bit位，即8个0或1
• 默认指例如一个数23，默认就是int类型。一个小数2.3默认就是double类型
• 默认值指该变量未赋值时默认存储的值
• E 表科学计数法，1.4013E - 45 意思是1.4013 * 10^ - 45

数据类型	关键字	内存占用	取值范围
字节型	byte	1个字节	-128~127即 -2^7 ~ 2^7 -1
短整型	short	2个字节	-32768~32767即 -2^15 ~ 2^15-1
整型	int(默认)	4个字节	-2^31 ~ 2^31
长整型	long（赋值数后带L或l）	8个字节	-2^63 ~ 2^ 63 - 1
单精度浮点数	float(赋值数后带F或f)	4个字节	1.4013E - 45 ~ 3.4028 E - 38
双精度浮点数	double(默认)	8个字节	4.9E-324 ~ 1.7977E + 308
字符型	char	2个字节	ASCII码 0~65535

• 根据数据所占字节，计算取值范围。一个字节Byte是8个bit,首位做正负符号标识，byte的取值范围为什么是-2^7~2^7-1？
  主要因为补码 0000 0000 = 0 ;补码1000 0000 看似为 -0实际 = -2^7是规定

  因为内部存储的是补码，正数的原码=反码=补码；最高位为符号位=0。负数反码=原码除符号位外全取反，补码=反码+1；最高位为符号位=1。

  8个bit位的情况下，最大正数原码反码补码:0111 1111= 2^7-1最小负数原码 ：1000 0000 反码：1111 1111 补码 1000 0000 相当于最高位即代表符号位又代表值所以=-2^7。

• 字符串不是基本类型，而是引用类型

• 浮点可能只是一个近似值，并非精确值

• 数据范围与字节数不一定相关，比如float和long，long8字节 的最大值2^63 ≈ 9.223E+18。float最大值数量级+38，远超。因为使用了科学计数法

• 浮点数默认double ，用float加后缀F或f。整型默认int用long加L或l（推荐用大写）

变量的概念和使用

1. 变量概念
   程序运行期间，内容可以发生改变的量。

数据类型 变量名称；//创建了一个变量
变量名称 = 数据值；//赋值，将右数据值赋值交给左变量
数据类型 变量名称 = 数据值；

2. 变量的使用

int num1;
num1 = 10;
num1 = 20;
int num2 = 25;

右侧数值范围不能超过左侧数据类型的取值范围，不然错

long num6 = 3000000L;//大写L更明确，必须加L
float num7 = 2.5F;//也是必须加F

错 因为var1，num没有初始化就不能使用 ×

boolean var1;
//boolean var2 = var1;
int num;
//System.out.println(num);

3. 变量的注意事项

• 创建多个变量，变量间名称不可以重复
• float和long，数据值字母后缀F和L
• short,byte 右数赋值不可太大会超出
• 没赋值的变量，不能直接使用。例如打印，作为数据值赋值
• 变量使用不能超过作用域范围，[作用域]从定义变量的一行开始，一直到所属的大括号结束为止，创建变量之前不能使用
• 可以通过一个语句创建多个变量，一般不推荐。数据类型统一的情况可用

int a, b, c; a = 10; b = 20; c = 40;
int x = 100, y = 20, z = 300;

数据类型转换

1. 自动类型转换（隐式）
   自动：数据范围从小到大
   long num1 = 100;//左右不一样，自动转换
   double num2 = 2.5F;
   float num3 = 30L;//float范围更大
2. 强制类型转换（显式）
   格式 范围小的类型 范围小的变量名 = （范围小的类型）原本范围大的数据；
   int num = (int)100L;//从long强转为int，且100没超int范围大小
   // int num == 100L;错
3. 数据类型转换注意事项

• 强转不推荐，有可能精度损失，数据溢出

		//int num4 = (int)6000000000;
        int num5 = (int)6000000000L;
        System.out.println(num5);//1705032704

• 60亿超出int最大范围，int最大21亿左右。所以数据值一定要带L，为long类型。强转后，结果不报错但为1705032704，因为数据溢出
• int num = (int)3.5;//3精度损失。
  
• byte/short/char这三种类型都可以发生数学运算（即+，-，*，/，%）

		char zifu1 = 's';
        System.out.println(zifu1 + 1);//116
        char zifu2 = '我';
        System.out.println(zifu2 - zifu1);//24990

• byte/short/char运算时，都会被首先提升成int，再计算
  

 		byte num6 = 2;
        byte num7 = 34;
        //byte result1 = num6 + num7;错
        //因为num6 + num7运算时提升为int，结果也是int
        int result2 = num6 + num7;
        byte result3 =(byte)(num6 + num7);

• boolean 不能数据转换，不能当做0或1

ASCII码表（128种）

• 常见字符与数字对应关系
  48 ~ 数字0开始到9
  65 ~ 大写字母A开始到Z
  97 ~ 小写字母a到z

		char zifu3 = 'c';
        int num = zifu3;//从小到大自动类型转换
        System.out.println('中' + 0);//20013
        //因为输出时， +将char计算前提升为int再计算

数字和字符的对照关系表（编码表）
ASCII：美国信息交换标准代码
Unicode:万国码，开头0~127，和ASCII一样，128开始有更多字符

基本数据类型极其数学计算

• float 和 long 赋值时后跟F或L,最好大写因为l与1容易混淆

• 不同数据类型的运算注意点：
  ❤byte/short/char类型数据在计算时会自动提升为int，所以接收方必须是int或将结果强转
  取模只针对整数，其他取模没意义
  ❤运算当中有不同类型的数据，结果将会是数据类型范围大的那种
  ❤对于String类型数据+为链接，后续加到的都为字符串
  除非用小括号优先级最高，会先加再链接

例如：

System.out.println(50 + 70 + "str"+ 30 + 70);//120str3070
System.out.println("eat" + (40 + 50));//eat90

• ❤注意复合赋值运算符隐含了一个强制类型转化
• byte += 6;//是正确写法，相当于byte + int 要运算所以byte提升为int，运算包括加减乘除，取模。相当于 int + int = int ,直接写byte = 6 + byte 错。

• 数据类型的默认赋值：
  整型 0
  浮点型0.0
  字符型 ‘\u0000’
  布尔型 false
  引用型 null

5 运算符

四则运算：+，-，*，/
取模，取余数：%（只有对整数用除法，取模才有余数的意义）
注意：一旦运算当中有不同类型的数据，那么结果将会是数据类型范围大的那种

1. 加号用法

• 数值，加法
• char计算前，提升为int再算对应Unicode
• 对于字符串String，+代表连接

  		String str1 = "Hello";
        System.out.println("Hello" + "World");//HelloWorld
        String str2 = "Java";
        System.out.println(str2 + 20);//Java20
        System.out.println(str2 + 20 + 30);//Java2030
        System.out.println(str2 + (20 + 30));//Java50

任何数据类型和字符串进行连接时，结果都会变成字符串

自增自减，–，++

++ 让一个变量+一个数字1；--让一个变量-一个数字1
++num，先+再用；num++，先用再+；--同理
单独用前后无所谓

        int x = 10;
        int y = 20;
        int result3 = ++x + y--;//11 + 20//x = 11,y = 19

只有变量才能用自增自减，常量不行

num++;√
30--;×

赋值运算符

+= a+=1 相当于a = a + 1;
-= a -= 3 相当于 a = a -3;
*= 依次类推
/=
%=
注意：
1.只有变量才能使用赋值运算符，常量不能赋值
2.复合赋值运算符其中隐含了一个强制类型转换
byte num = 30;
num += 5;
分析过程 num = num + 5;
= byte + 5
= byte + int
= int + int 前面提过，byte,short,char计算时都会先自动提升成int再计算
= int -> byte = (byte)int
所以说复合赋值运算符中隐含了一个强制类型转换

逻辑运算符

• 逻辑运算符 && || 短路，即左边条件若能判断结果就不运行右边条件
• 逻辑与或可连续比较多个条件 A && B && C 。但< ，> 不可以 连续写，只能比较两个

三目运算符

• ❤三元运算符 ？：；结果必须被使用，被赋值或打印

        ● 3 > 4 ? 2 : 10
        
		if(8 > (3 > 4 ? 2 : 10)){
            System.out.println("nice");
        }
        int result = 3 > 4 ? 2 : 10;
        System.out.println(3 > 4 ? 2 : 10);

• 两结果必须同时满足于为int，A,B都要符合左侧数据要求

 ● int result = 3 > 4 ? 2.5 : 10;
 int result = 3 > 4 ? 2 : 10;

编译器的两点优化

1. byte/char/short 赋值时若右侧全为常量，如果右侧比较小，会隐含的补上一个强转（byte）(short)(char)。 如果右侧值超过，则报错
   
   
2. 编译器的常量优化
   在给变量进行赋值的时候，如果右侧的表达式全为常量，没有任何变量，那么编译器javac将会直接将若干个常量表达式计算得到结果，如short result = 5 + 8;编译后得到的.class字节码文件当中直接就是：short result = 13;没有超出左侧范围所以正确。（这里又用了第一点优化）
   但注意：一旦表达式当中有变量参与，就不能这样优化：short a = 5;
   short result = 2 + a + 8;变量有可能改变，所以不常量优化
   

二、编程计算练习

1、 把234（DEC）转为BIN

---

辗转相除法
234/2 = 117 余0,117/2 =58余1依次类推，直到除数为0停止
234（DEC） = 11101010(BIN)

验证结果，

2、把0011010101100（BIN）转为DEC十进制

---

验证：1101 0101 100

3、 字节转换

买一个100Mbps的宽带，问下载速度最快多少

数字信息流的基本单位是比特bit，为一个1或者1个0。所以表示带宽的单位就是bps，意思就是每秒通过的信息流的比特bit数。100M带宽就是100Mbps表示1秒钟通过信息流的比特数为100M，即100*2^20 bit= 1亿（100000000）个位。
因为 8bit = 1Byte，1MB = 2^20 Byte

所以 100Mb = 100/8 MB
100Mb/s = 12.5MB/s

4、DOS操作系统下指令

按照给出指令操作
打开cmd,切换盘符到D盘，进入一个文件夹，打印当前目录下文件，选择一个进入时只打前半部分名称使用补全快捷键，返回上级文件夹，清屏，返回根目录，退出

5、判断数据类型定义，分析错误并改正

		byte b1 = y;
        int i1 = 1243;
        char c1 = "@";
        char c2 = '';
        char c3 = '34';
        char c4 = '齐';
        short s1 = 235;
        double d1= 325.214;
        float f1 = 1.2;
        float f2 = 0;
        long l1 = 1235321434543;
        boolean bb1 = true;
        String ss1 = "";
        String ss2 = 's';
        String ss3 = " 45# 53对";

---

A:
flaot数据在赋值时数值尾部带一个f或者F,long类型同理，带L或l，一般默认大写，因为小写l容易混淆

		byte b1 = 12;
        int i1 = 1243;
        ×char c1 = "@";//char c1 = '@';//字符必须用单引号
        ×char c2 = '';//char c2 = 'd';//字符不可以为空
        ×char c3 = '34';//char c3 = '3';//也不可以为两个字符
        char c4 = '齐';//中文也算一个字符
        short s1 = 235;
        double d1= 325.214;
        ×float f1 = 1.2;//float f1 = 1.2F;//尾带F
        float f2 = 0;//这里正确不是因为0是float类，而是因为自动类型转换，int数据范围更小
        ×long l1 = 1235321434543;//long l1 = 1235321434543L;//尾带L
        boolean bb1 = true;
        String ss1 = "";//可以为空
        ×String ss2 = 's';//String ss2 = "s";//字符串必须用双引号
        String ss3 = " 45# 53对";
        //空常量 null

6、不同数据类型运算，判断对错，并改正

		int num1 = 10;
        num1 += 3;

        int num2;
        System.out.println(num2);

        int x, y, z;
        double a = 1, b = 3.4, c = 5.6;

        byte b1 = 34;
        byte b2 = 5;
        byte b3 = 128;
        short s1 = 98;
        short s2 = 23;
        short s3 = 32768;
        char c1 = '中';
        char c2 = 65535;
        char c3 = 65536;
        long l1 = 12345L;
        double d1 = 23.53;

        int num3 = b1 + s1;
        byte num4 = b2 + s1;
        char num5 = b2 + s1 + c1;

        b2 += s1;

        int num6 = l1 + c2 + b2;
        long num7 = l1 + c2 + b2;
        double num8 = c2 + d1;

 		num3 > 7 ? num3 = '*' : num3 = '%';

---

A:

        num1 += 3;
        
        byte num1 = 10;
		 ● num1 = num1 + 3;
		//错误原因：byte/short/char类型变量计算时都是自动提升为int类型，需要Int类型的变量来接收运算结果

        int num2;
        ● System.out.println(num2);
//错在num2没有初始化赋值，没有初始化之前只是定义了。不可以使用，包括打印或者运算

        int x, y, z;
        double a = 1, b = 3.4, c = 5.6;
//同时初始化定义多个变量，但必须得是同一个数据类型
        byte b1 = 34;
        //解释：虽然是int类型数据赋值给byte类型变量，但byte/short/char有编译器优化，即若赋值的是常量且不超范围，隐含的有一个强转。
        byte b2 = 5;
        ● byte b3 = 128;
        //byte是1个字节，2^7 范围-128 ~ 127
        short s1 = 98;
        short s2 = 23;
        ● short s3 = 32768;
        //short两个字节 2^15，范围-32768 ~ 32767
        char c1 = '中';
        char c2 = 65535;
        ● char c3 = 65536;
         //char取值范围：0~65535
        long l1 = 12345L;
        double d1 = 23.53;

        int num3 = b1 + s1;
        b2 += s1;
         ● byte num4 = b2 + s1;
         ● char num5 = b2 + s1 + c1;
         //问题都在于byte/char/short类型数据运算时会自动提升为int类型
         //而复合运算符会隐含一个强转，所以正确

       ●  int num6 = l1 + c2 + b2;
l1是long类型变量，多种不同数据类型变量计算时，结果的数据类型与数据范围最大的那个一致	，应该用范围大于等于long的数据类型接收
        long num7 = l1 + c2 + b2;
        double num8 = c2 + d1;

	   ● num3 > 7 ? num3 = '*' : num3 = '%';
 //三目运算符的结果一定要被使用，打印或者接收，不然就是错

7、逻辑运算符判断程序运行结果

  		 int num1 = 10;
        int num2 = 34;
        char num3 = '7';
        char num4 = 97;
//--------------------------------------------------
//前置++和后置的区别，||，|两个或运算符区别
        if(num1 < 9 || ++num4 > 97){
            System.out.println(num4);
        } 
	    if(num1 < 9 || num4++ <= 98){
            System.out.println(num4 + 0);
        }
      if(num1 > 9 || num4++ <= 98){
            System.out.println(num4);
        } 
      if(num1 > 9 | num4++ <= 98){
            System.out.println(num4);
        }

//&&,&两个并运算符区别
        if(++num1 > 10 && ++num2 > 34 && ++num3 > '7' ){
            System.out.println(num1 + "," + num2 + "," + num3);
        }
	   if(++num1 < 10 && ++num2 > 34 && ++num3 > '7' ){
            ;
        }else{
            System.out.println(num1 + "," + num2 + "," + num3);
        }
        if(++num1 < 10 & ++num2 > 34 & ++num3 > '7' ){
            ;
        }else{
            System.out.println(num1 + "," + num2 + "," + num3);
        }

       if(num1++ > 11 || ++num2 > 34 || ++num3 > '7' ){
            System.out.println(num1 + "," + num2 + "," + num3);
        }
		if(num1++ > 12 | ++num2 > 35 | ++num3 > '8' ){
            System.out.println(num1 + "," + num2 + "," + num3);
        }
        
        if(num1 < 0 || num1 > 0 && num1++ >= 15){
            System.out.println(num1);
        }
        if((num1 < 0 && num1 > 0) && num1++ >= 16){
            ;
        }
        else{
            System.out.println(num1);

        } 

		num3 = '%';
        System.out.println(num3);
        System.out.println(num3 + 0);

        num3 = '(';
        switch(num3){
            case '*':
                System.out.println("num3是*");
            case '(':
                System.out.println("num3是(");
            case '$':
                System.out.println("num3是$");
                break;
            case '@':
                System.out.println("num3是@");
                break;
            default:
                System.out.println();
                break;
        }
     

---

A:

 	    int num1 = 10;
        int num2 = 34;
        char num3 = '7';
        char num4 = 97;
//--------------------------------------------------
//前置++和后置的区别，||，|两个或运算符区别
        if(num1 < 9 || ++num4 > 97){
            System.out.println(num4);
        } /*b(98) ： 条件1 错，所以 ||或才会判断条件2，++num4先加再使用，98 > 97，if成功*/
	    if(num1 < 9 || num4++ <= 98){
            System.out.println(num4 + 0);
        }/*99 : num4先用后加，98 <= 98后再++ ，char类型运算提升为int输出 */
      if(num1 > 9 || num4++ <= 98){
            System.out.println(num4);
        }  /*c(99) :因为|| 中条件1true，已经可以确定结果是true,条件2不执行*/
      if(num1 > 9 | num4++ <= 98){
            System.out.println(num4);
        }//d(100) | 和&都没有短路，已经能出结果也会执行所有条件

//&&,&两个并运算符区别
        if(++num1 > 10 && ++num2 > 34 && ++num3 > '7' ){
            System.out.println(num1 + "," + num2 + "," + num3);
        }//11,35,8 ：其中8是字符格式，&&是可以连续判断多个条件当没有错误的，就无法短路，全执行，++num1先加再用
	   if(++num1 < 10 && ++num2 > 34 && ++num3 > '7' ){
            ;
        }else{
            System.out.println(num1 + "," + num2 + "," + num3);
        }//12,35,8 ：条件1错，后续条件不执行
        if(++num1 < 10 & ++num2 > 34 & ++num3 > '7' ){
            ;
        }else{
            System.out.println(num1 + "," + num2 + "," + num3);
        }//13,36,9//条件1 错不影响全部条件都要执行

       if(num1++ > 11 || ++num2 > 34 || ++num3 > '7' ){
            System.out.println(num1 + "," + num2 + "," + num3);
        }//14,36,9 : 条件1先用后加，11 > 11 false,短路，后续条件不执行
		if(num1++ > 12 | ++num2 > 35 | ++num3 > '8' ){
            System.out.println(num1 + "," + num2 + "," + num3);
        }//15，37,:(10) ：条件1 12 > 12先用后加到13 ,错不影响后续执行
        
        if(num1 < 0 || num1 > 0 && num1++ >= 15){
            System.out.println(num1);
        }//16 :&& 优先级高于||，相当于（false || (true && true)）
        if((num1 < 0 && num1 > 0) && num1++ >= 16){
            ;
        }
        else{
            System.out.println(num1);

        } //16 :(false && true) && 不执行

        //num3 > 7 ? num3 = '*' : num3 = '%';


		num3 = '%';
        System.out.println(num3);//%
        System.out.println(num3 + 0);//37

        num3 = '(';
        switch(num3){
            case '*':
                System.out.println("num3是*");
            case '(':
                System.out.println("num3是(");
            case '$':
                System.out.println("num3是$");
                break;
            case '@':
                System.out.println("num3是@");
                break;
            default:
                System.out.println();
                break;
        }
        //num3是(
        //num3是$
        //: 因为一遇到符合的case就进入，但遇到break才会退出