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

发布时间：2024年01月04日

目录

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 打印当前目录内容，文件夹为<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
  1. 包名
    使用小写字母如 com.xxx.settlment，不要 com.xxx.Settlement
    单词间不要用字符隔开，比如 com.xxx.settlment.jsfutil，而不要com.xxx.settlement.jsf_util
  2. 后缀名
后缀名意义举例
Impl这个类是一个实现类，而不是接口PaymentOrderServiceImpl
Inter这个类是一个接口LifeCycleInter
Dao这个类封装了数据访问方法PaymentOrderDao
Listener响应某种事件的类PaymentSuccessListener
Wrapper这是一个包装类，为了给某个类提供没有的能力SelectableOrderListWrapper
Bean这是一个POJOMenuStateBean
  1. 方法名
    首字母小写，如 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()
  1. 静态常量
    全大写用下划线分割，如
    public static find String ORDER_PAID_EVENT = “ORDER_PAID_EVENT”;
  2. 枚举
    全大写，用下划线分割，如

public enum Events {
ORDER_PAID,
ORDER_CREATED

}

  1. 二元三元运算符两边用一个空格隔开
b - d = e;
return a == b ? 1 : 0;
  1. 逗号语句后如不换行，紧跟一个空格
    如下：
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
  1. 引用数据类型
    字符串，数组，类，接口
  2. 数据所占内存和取值范围
  • 字节即Byte。1Byte = 8 bit位，即8个0或1
  • 默认指例如一个数23，默认就是int类型。一个小数2.3默认就是double类型
  • 默认值指该变量未赋值时默认存储的值
  • E 表科学计数法，1.4013E - 45 意思是1.4013 * 10^ - 45
数据类型关键字内存占用取值范围
字节型byte1个字节-128~127即 -2^7 ~ 2^7 -1
短整型short2个字节-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
字符型char2个字节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. 变量概念
    程序运行期间，内容可以发生改变的量。
数据类型 变量名称；//创建了一个变量
变量名称 = 数据值；//赋值，将右数据值赋值交给左变量
数据类型 变量名称 = 数据值；
  1. 变量的使用
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);
  1. 变量的注意事项
  • 创建多个变量，变量间名称不可以重复
  • 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;

编译器优化

  • ?byte/char/short 赋值时若右侧全为常量，如果右侧比较小，会隐含的补上一个强转。 如果右侧值超过，则报错
    在这里插入图片描述

  • switch case 匹配到哪一个case就从哪一个位置向下执行，直到遇到break或整体结束

  • 三种循环里，若条件从未满足，do -while 至少会执行一次

  • 在IDEA中，delete一个Module，外部打开project打开还是存在的，怎么导入一个外部保存的Module
    file-project structure + import module setup sdk即可

  • 方法的三种调用形式，单独调，打印调，赋值调。void返回值类型只能单独调

  • 一个方法中可以有多个return，但必须保证同时只走一个return

  • ?重载： 多个方法的名称一样，但参数列表不一样 与参数名称无关，与返回值类型无关

二、编程计算练习

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才会退出
文章来源:https://blog.csdn.net/qq_24990383/article/details/135093850
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
最新文章