[Java基本语法] 常量变量与运算符

🌸个人主页:https://blog.csdn.net/2301_80050796?spm=1000.2115.3001.5343
🏵️热门专栏:🍕 Collection与数据结构 (92平均质量分)https://blog.csdn.net/2301_80050796/category_12621348.html?spm=1001.2014.3001.5482
🧀线程与网络(96平均质量分) https://blog.csdn.net/2301_80050796/category_12643370.html?spm=1001.2014.3001.5482
🍭MySql数据库(93平均质量分)https://blog.csdn.net/2301_80050796/category_12629890.html?spm=1001.2014.3001.5482
🍬算法(97平均质量分)https://blog.csdn.net/2301_80050796/category_12676091.html?spm=1001.2014.3001.5482
感谢点赞与关注~~~

✒️ 今天开始,Java基本语法模块将进行重构.以保证文章质量.

1. 准备工作
- 1.1 安装idea
- 1.2 配置环境变量与安装jdk
2. 前置知识
- 2.1 Java的main方法
- 2.2 Java程序编写中的常见错误
- 2.3 Java程序是如何运行起来的
- 2.4 注释
- - 2.4.1 基本规则
  - 2.4.2 注释规范
- 2.5 标识符
- 2.6 关键字
3. 数据类型与变量
- 3.1 字面常量
- 3.2 数据类型
- 3.3 变量
- - 3.3.1 相关概念
  - 3.3.2 整形变量
  - 3.3.3 长整形变量
  - 3.3.4 短整型变量
  - 3.3.5 字节类型变量
  - 3.3.6 浮点类型变量
  - - 3.3.6.1 双精度浮点数
    - 3.3.6.2 单精度浮点数
  - 3.3.7 字符类型变量
  - 3.3.8 布尔类型变量
  - 3.3.9 类型转换
  - - 3.3.9.1 自动类型转换
    - 3.3.9.2 强制类型转换
  - 3.3.10 整形提升
  - 3.3.11 字符串类型
4. 运算符
- 4.1 算数运算符
- 4.2 关系运算符
- 4.3 逻辑运算符
- 4.4 位运算符
- 4.5 移位运算符
- 4.6 条件运算符(三目运算符)

1. 准备工作

1.1 安装idea

安装地址: https://www.jetbrains.com/zh-cn/idea/
安装社区版本即可,建议安装2021.3的版本,以便我们后面学习Spring时使用.

1.2 配置环境变量与安装jdk

可参考视频: https://www.bilibili.com/video/BV1N54y1U7AA/?spm_id_from=333.999.0.0&vd_source=f2e28dfb590b0d28f1fc01e22608db8d

2. 前置知识

2.1 Java的main方法

public class HelloWorld{
	public static void main(String[] args){
	System.out.println("Hello,world");
	}
}

在我们的idea中中写main方法的时候,只需要写一个main,会出来一个提示,之后一敲回车就自动帮你写好了.
同样,在idea中写打印拿一行的时候,只写一个sout,也会出来提示,一敲回车,也会自动补全代码.

上面是Java中main方法的写法,可以说是主流编程语言当中最"长"的.从上述代码中,我们可以看到一个完整的Java程序结构由以下三部分组成.
1.（扩展名为*.java)：源文件带有类的定义。类用来表示程序的一个组件，小程序或许只会有一个类。类的内容必须包含在花括号里面。
2.类：类中带有一个或多个方法。方法必须在类的内部声明。
3.方法：在方法的花括号中编写方法应该执行的语句。
总结一下：类存在于源文件里面；方法存在于类中；语句存在于方法中。
注意：在一个源文件中只能有一个public修饰的类，而且源文件名字必须与public修饰的类名字相同.

2.2 Java程序编写中的常见错误

源文件名后缀不是.java
类名与文件名不一致
main方法名字写错：mian
类没有使用public修饰
方法中语句没有以分号结尾
中文格式的分号
JDK环境没有配置好，操作系统不能识别javac或者java命令

2.3 Java程序是如何运行起来的

别看我们在idea中只点一个运行就可以让一个Java程序运行起来,其实在背后做了很多事情.
先通过javac编译程序把源文件进行编译，编译后生成的.class文件是由字节码组成的平台无关、面向JVM的文件。最后启动java虚拟机来运行.class文件，此时JVM会将字节码转换成平台能够理解的形式来运行。
在这里插入图片描述

2.4 注释

为代码添加注释,是编程中一个非常好的习惯.这个注释是给别人看的,更是为3个月后的自己看的.写注释的初心就是为了使得代码阅读起来更加方便.

2.4.1 基本规则

Java中的注释主要分为一下三种:

单行注释：//注释内容（用的最多）
多行注释：/* 注释内容*/
文档注释： /** 文档注释 */（常见于方法和类之上描述方法和类的作用)，可以被javadoc工具解析，生成一套以网页文件形式体现的程序说明文档

/**
 * 多行注释
 */
public class Test {
    /**
     * 文档注释
     * @param args 方法参数
     */
    public static void main(String[] args) {
        System.out.println("hello world");//单行注释
    }
}

2.4.2 注释规范

内容准确: 注释内容要和代码一致, 匹配, 并在代码修改时及时更新.
篇幅合理: 注释既不应该太精简, 也不应该长篇大论.
使用中文: 一般中国公司都要求使用中文写注释, 外企另当别论.

2.5 标识符

在上述程序中，Test称为类名，main称为方法名，也可以将其称为标识符，即：在程序中由用户给类名、方法名或者变量所取的名字。

硬性规则
标识符中可以包含：字母、数字以及下划线和 $ 符号等等。
注意：标识符不能以数字开头，也不能是关键字，且严格区分大小写。
软性建议
- 类名：每个单词的首字母大写(大驼峰)
- 方法名：首字母小写，后面每个单词的首字母大写(小驼峰)
- 变量名：与方法名规则相同

2.6 关键字

关键字是由Java语言提前定义好的，有特殊含义的标识符，或者保留字。
注意：用户不能使用关键字定义标识符。
在Java中关键字有很多，这里给大家列出来一部分，先了解下后序在逐一详细解释。
在这里插入图片描述

3. 数据类型与变量

3.1 字面常量

常量即程序运行期间，固定不变的量称为常量，比如：一个礼拜七天，一年12个月等。常量不可以进行修改

public class Demo{
    public static void main(String[] args){
         System.Out.println("hello world!");
         System.Out.println(100);
         System.Out.println(3.14);
         System.Out.println('A');
         System.Out.println(true);
         System.Out.println(false);
   }
}

常用快捷键: Ctrl+d自动复制一行

其中：100、3.14、‘A’、true/false都是常量，将其称为字面常量。
字面常量的分类：

字符串常量：由""括起来的，比如“12345”、“hello”、“你好”。
整形常量：程序中直接写的数字(注意没有小数点)，比如：100、1000
浮点数常量：程序中直接写的小数，比如：3.14、0.49
字符常量：由单引号括起来的当个字符，比如：‘A’、‘1’
布尔常量：只有两种true和false
空常量：null

3.2 数据类型

在Java中数据类型主要分为两类：基本数据类型和引用数据类型。基本数据类型也叫有包装类,引用数据类型也叫做无包装类.

基本数据类型有四类八种：

四类：整型、浮点型、字符型以及布尔型
八种：

[注意事项]
- 不论是在16位系统还是32位系统，int都占用4个字节，long都占8个字节,所以Java具有较好的可移植性.
- 整形和浮点型都是带有符号的
- 整型默认为int型，浮点型默认为double

引用数据类型有:String(字符串类),数组,类,接口.

3.3 变量

3.3.1 相关概念

定义
在程序中，除了有始终不变的常量外，有些内容可能会经常改变，比如：人的年龄、身高、成绩分数、数学函数的计算结果等，对于这些经常改变的内容，在Java程序中，称为变量。而数据类型就是用来定义不同种类变量的。
语法格式

数据类型 变量名 = 初始值;

在Java中,所有类型定义的变量都是有符号的.

举例:

double d = 3.14;
char c = 'A';
boolean b = true;
 
System.Out.println(a);
System.Out.println(d);
System.Out.println(c);
System.Out.println(b);
 
a = 100;  // a是变量，a中的值是可以修改的，注意：= 在java中表示赋值，即将100交给a，a中保存的值就是100
System.Out.println(a);
 
// 注意：在一行可以定义多个相同类型的变量
int a1 = 10, a2 = 20, a3 = 30;
System.Out.println(a1);
System.Out.println(a2);
System.Out.println(a3);

[注意] Java中不允许使用未初始化的局部变量.

3.3.2 整形变量

// 方式一：在定义时给出初始值
int a = 10;
System.Out.println(a);
 
// 方式二：在定义时没有给初始值，但使用前必须设置初值
int b;
b = 10;
System.Out.println(b);
 
// 使用方式二定义后，在使用前如果没有赋值，则编译期间会报错
int c;
System.Out.println(c);
c = 100;
 
// int型变量所能表示的范围：
System.Out.println(Integer.MIN_VALUE);
System.Out.println(Integer.MAX_VALUE);

[注意事项]

int不论在何种系统下都是4个字节
推荐使用方式一定义，如果没有合适的初始值，可以设置为0
在给变量设置初始值时，值不能超过int的表示范围，否则会导致溢出
变量在使用之前必须要赋初值，否则编译报错.
int的包装类型为 Integer,功能上比int更加强大,后续介绍.

3.3.3 长整形变量

int a = 10;
long b = 10;   // long定义的长整型变量
 
long c = 10L; // 为了区分int和long类型，一般建议：long类型变量的初始值之后加L或者l
long d = 10l; // 一般更加以加大写L，因为小写l与1不好区分
 
// long型变量所能表示的范围：这个数据范围远超过 int 的表示范围. 足够绝大部分的工程场景使用. 
System.Out.println(Long.MIN_VALUE);
System.Out.println(Long.MAX_VALUE);

[注意事项]

长整型变量的初始值后加L或者l，推荐加L.
长整型不论在那个系统下都占8个字节
long的包装类型为Long(首字母大写)

3.3.4 短整型变量

short a = 10;
System.Out.println(a);
 
// short型变量所能表示的范围：
System.Out.println(Short.MIN_VALUE);
System.Out.println(Short.MAX_VALUE);

[注意事项]

short在任何系统下都占2个字节
short的表示范围为：-32768 ~ 32767
使用时注意不要超过范围(一般使用比较少)
short的包装类型为Short(首字母大写)

3.3.5 字节类型变量

byte b = 10;
System.Out.println(b);
 
// byte型变量所能表示的范围：
System.Out.println(Byte.MIN_VALUE);
System.Out.println(Byte.MAX_VALUE);

[注意事项]

byte在任何系统下都占1个字节
byte的范围是：-128 ~ 127(这组数字需要记住,是一个常识)
字节的包装类型为Byte

3.3.6 浮点类型变量

3.3.6.1 双精度浮点数

double d = 3.14;
System.Out.println(d);

下面有两组代码:

int a = 1;
int b = 2;
System.out.println(a / b);

这里我们在运行之后发现,输出的结果并不是0.5.这就是其中的一个注意事项:在 Java 中, int 除以 int 的值仍然是 int(会直接舍弃小数部分)。

double num = 1.1;
System.out.println(num * num);

这里我们发现输出的结果并不是1.21.只要是小数运算出的数字,都没有精确的结果.

[注意事项]

double在任何系统下都占8个字节
浮点数与整数在内存中的存储方式不同，不能单纯使用2ⁿ的形式来计算
double的包装类型为Double
double 类型的内存布局遵守 IEEE 754 标准(和C语言一样), 尝试使用有限的内存空间表示可能无限的小数, 势必会存在一定的精度误差，因此浮点数是个近似值，并不是精确值。

3.3.6.2 单精度浮点数

ﬂoat num = 1.0f;    // 写作 1.0F 也可以,注意加上后缀
System.out.println(num);

ﬂoat 类型在 Java 中占四个字节, 同样遵守 IEEE 754 标准. 由于表示的数据精度范围较小, 一般在工程上用到浮点数都优先考虑 double, 不太推荐使用 ﬂoat.

3.3.7 字符类型变量

注意:与出语言不同,Java中的字符类型是2字节.

char c1 = 'A';    // 大写字母
char c2 = '1';    // 数字字符
 
System.out.println(c1);
System.out.println(c2);
 
// 注意：java中的字符可以存放整形
char c3 = '帅';
System.out.println(c3);

[注意事项]

Java 中使用单引号 + 单个字母的形式表示字符字面值.
计算机中的字符本质上是一个整数. 在 C 语言中使用 ASCII 表示字符, 而 Java 中使用 Unicode 表示字符. 因此一个字符占用两个字节, 表示的字符种类更多, 包括中文.
关于汉字的编码方式,一般有两种,一种是Unicode方式,就是2字节,另一种是utf-8的方式,是3字节.
char的包装类型为Character

3.3.8 布尔类型变量

布尔类型常用来表示真假.

boolean b = true;
System.out.println(b);
 
b = false;
System.out.println(b);

[注意事项]

boolean 类型的变量只有两种取值, true 表示真, false 表示假.
Java 的 boolean 类型和 int 不能相互转换, 不存在 1 表示 true, 0 表示 false 这样的用法.没有类似与出语言中,非0表示真,0表示假这这种说法.
boolean的包装类型为Boolean.
boolean并没有明确规定占几个字节,但是在Oracle公司的虚拟机实现中，boolean占1个字节.

3.3.9 类型转换

Java中作为一个强类型的编程语言,当不同类型之间的变量相互赋值的时候,会有较为严格的校验.

int a = 10;
long b = 100L;
b = a;   // 可以通过编译
a = b;   // 编译失败,不可以把表示范围较大的赋值给表示范围较小的.

在Java中,当参与运算的数据类型不一致的时候,就会进行类型转换,Java中类型转化主要分为3种,自动类型转换和强制类型转换.

3.3.9.1 自动类型转换

自动类型转换即：代码不需要经过任何处理，在代码编译时，编译器会自动进行处理。特点：数据范围小的转为数据范围大的时会自动进行。
比如上面的那个例子.

3.3.9.2 强制类型转换

这种转换方式有一定的缺点:会发生数据截断,会发生数据丢失.
当进行操作时，代码需要经过一定的格式处理，不能自动完成。特点：数据范围大的到数据范围小
的.在数据的前面加上用小括号加上括起来的数据类型来完成强制类型转换.

int a = 10;
long b = 100L;
b = a;        // int-->long，数据范围由小到大，隐式转换
a = (int)b;   // long-->int, 数据范围由大到小，需要强转，否则编译失败
 
ﬂoat f = 3.14F;
double d = 5.12;
d = f;        // ﬂoat-->double，数据范围由小到大，隐式转换
f = (ﬂoat)d; // double-->ﬂoat, 数据范围由大到小，需要强转，否则编译失败
 
a = d;   // 报错，类型不兼容
a = (int)d;   // int没有double表示的数据范围大，需要强转，小数点之后全部丢弃
 
byte b1 = 100;        // 100默认为int，没有超过byte范围，隐式转换
byte b2 = (byte)257;  // 257默认为int，超过byte范围，需要显示转换，否则报错
 
boolean ﬂag = true;
a = ﬂag;   // 编译失败：类型不兼容
ﬂag = a;   // 编译失败：类型不兼容

[注意事项]

不同数字类型的变量之间赋值, 表示范围更小的类型能隐式转换成范围较大的类型.
如果需要把范围大的类型赋值给范围小的, 需要强制类型转换, 但是可能精度丢失.
将一个字面值常量进行赋值的时候, Java 会自动针对数字范围进行检查
强制类型转换不一定能成功，不相干的类型不能互相转换.比如我们前面提到的boolean类型和int类型.

3.3.10 整形提升

不同类型的数据之间相互运算时，数据类型小的会被提升到数据类型大的。

int与long之间：int会被提升为long

int a = 10;
long b = 20;
int c = a + b;  // 编译出错: a + b==>int + long--> long + long,出现编译出错的原因是,赋值给int会造成数据丢失.
long d = a + b;  // 编译成功：a + b==>int + long--->long + long 赋值给long

byte与byte的运算

byte a = 10;
byte b = 20;
byte c = a + b;
System.out.println(c);

上述代码会出现编译报错.我们由此可以得出以下结论:
byte 和 byte 都是相同类型, 但是出现编译报错. 原因是, 虽然 a 和 b 都是 byte, 但是计算 a + b 会先将 a和 b 都提升成 int, 再进行计算, 得到的结果也是 int, 这是赋给 c, 就会出现上述错误.
由于计算机的 CPU 通常是按照 4 个字节为单位从内存中读写数据. 为了硬件上实现方便, 诸如 byte 和 short这种低于 4 个字节的类型, 会先提升成 int, 再参与计算.
[小结]

对于不同类型的数据混合运算的时候,范围小的会提升为范围大的.
对于short和byte这种比4个字节小的类型,会先提升为4字节的int类型之后再进行运算.

3.3.11 字符串类型

String类型注意首字母大写,而且没有包装类.
在Java使用String类定义字符串类型,比如:

public static void main(String[] args) {
    String s1 = "hello";
    String s2 = " world";
    System.out.println(s1);
    System.out.println(s2);
    System.out.println(s1+s2);   // s1+s2表示：将s1和s2进行拼接
}

Java中的字符串,没有所谓一’\0’结尾这一说.
Java中的字符串和其他数据类型进行+运算的时候,就是在进行字符串的拼接.
比如下面还有一段容易出错的代码:

public class main {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println("hello"+a+b);
    }
}

运行结果是:
在这里插入图片描述
如果想要出现30 的效果,就要在a+b上加括号

public class main {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println("hello"+(a+b));
    }
}

在这里插入图片描述
关于字符串类型的一些其他操作,我们在后面介绍到String类型时候再进行说明.

4. 运算符

4.1 算数运算符

基本四则运算符:加减乘除模.(+ - * / %)

int a = 20;
int b = 10;
 
System.out.println(a + b);     // 30
System.out.println(a - b);     // 10
System.out.println(a * b);     // 200
System.out.println(a / b);     // 2
System.out.println(a % b);     // 0 --->模运算相当于数学中除法的余数

[注意]

都是二元运算符,使用时必须要有左右两个运算符.
int/int结果还是int,而且会向下取整.
做除法和取模的时候,做操作数不可以为0.
%不仅可以对整形取模,也可以对double类型取模,但是没有意义,一般都是对整数取模.
两侧操作数类型不一致的时候,向范围大的类型提升.

增量运算符(+= -= *= %=)
该种类型运算符操作完成后，会将操纵的结果赋值给左操作数。

int a = 1;
a += 2;                  // 相当于 a = a + 2
System.out.println(a);   // 输出3
a -= 1;                  // 相当于 a = a - 1
System.out.println(a);   // 输出2
a *= 3;                  // 相当于 a = a * 3
System.out.println(a);   // 输出6
a /= 3;                  // 相当于 a = a / 3
System.out.println(a);   // 输出2
a %= 3;                  // 相当于 a = a % 2
System.out.println(a);   // 输出2

[注意事项]
1. 只有变量可以进行增量运算,常量不可以.
2. 在进行增量运算的时候,会发生数据截断.和前面整形提升的原理正好相反.

自增/自减运算符符(++ --)
++是给变量的值+1,–是变量的值-1.

int a = 1;
a++;    // 后置++   表示给a的值加1，此时a的值为2
System.out.println(a++);   // 注意：后置++是先使用变量原来值，表示式结束时给变量+1，因此输出2
System.out.println(a);     // 输出3
++a;    // 前置++   表示给a的值加1
System.out.println(++a);   // 注意：前置++是先给变量+1，然后使用变量中的值，因此输出5
System.out.println(a);     // 输出5
// --操作符给操作-1，与++含义类似

[注意]

如果单独使用，【前置++】和【后置++】没有任何区别
如果混合使用，【前置++】先+1，然后使用变量+1之后的值，【后置++】先使用变量原来的值，表达式结束时给变量+1.
只有变量才能使用自增/自减运算符，常量不能使用，因为常量不允许被修改.

4.2 关系运算符

关系运算符主要有六个: == != < > <= >= ，其计算结果是 true 或者 false.

int a = 10;
int b = 20;
// 注意：在Java中 = 表示赋值，要与数学中的含义区分
//     在Java中 == 表示相等
System.out.println(a == b);       // false
System.out.println(a != b);       // true
System.out.println(a < b);        // true
System.out.println(a > b);        // false
System.out.println(a <= b);       // true
System.out.println(a >= b);       // false

[注意事项]
当需要多次判断时，不能连着写，比如：3 < a < 5，Java程序与数学中是有区别的,需要写为a>3 && a<5.

4.3 逻辑运算符

逻辑运算符主要有三个: && || ! ，运算结果都是 boolean类型.

逻辑与&&
语法规则：表达式1 && 表达式2，左右表达式必须是boolean类型的结果.

int a = 1;
int b = 2;
 
System.out.println(a == 1 && b == 2);   // 左为真 且 右为真 则结果为真
System.out.println(a == 1 && b > 100);  // 左为真 但 右为假 则结果为假
System.out.println(a > 100 && b == 2);  // 左为假 但 右为真 则结果为假
System.out.println(a > 100 && b > 100); // 左为假 且 右为假 则结果为假

逻辑或 ||
语法规则：表达式1 || 表达式2，左右表达式必须是boolean类型的结果.

int a = 1;
int b = 2;
 
System.out.println(a == 1 || b == 2);   // 左为真 且 右为真 则结果为真
System.out.println(a == 1 || b > 100);  // 左为真 但 右为假 则结果也为真
System.out.println(a > 100 || b == 2);  // 左为假 但 右为真 则结果也为真
System.out.println(a > 100 || b > 100); // 左为假 且 右为假 则结果为假

左右表达式至少有一个为真,则结果为真.

逻辑非 !
语法规则：! 表达式
真变假，假变真

int a = 1;
System.out.println(!(a == 1));   // a == 1 为true，取个非就是false
System.out.println(!(a != 1));  // a != 1 为false，取个非就是true

短路求值
&& 和 || 遵守短路求值的规则

System.out.println(10 > 20 && 10 / 0 == 0);             // 打印 false
System.out.println(10 < 20 || 10 / 0 == 0);             // 打印 true

我们都知道, 计算 10 / 0 会导致程序抛出异常. 但是上面的代码却能正常运行, 说明 10 / 0 并没有真正被求值
[注意]

对于 && , 如果左侧表达式值为 false, 则表达式结果一定是 false, 无需计算右侧表达式.
对于 ||, 如果左侧表达式值为 true, 则表达式结果一定是 true, 无需计算右侧表达式.
& 和 | 如果表达式结果为 boolean 时, 也表示逻辑运算. 但与 && || 相比, 它们不支持短路求值.

4.4 位运算符

位运算符主要有四个: & | ~ ^ ，除 ~ 是一元运算符外，其余都是二元运算符。
位操作表示按二进制位运算. 计算机中都是使用二进制来表示数据的(01构成的序列), 按位运算就是在按照二进制位的每一位依次进行计算.

按位与 &: 如果两个二进制位都是 1, 则结果为 1, 否则结果为 0.
举例:10和20
按位或 |: 如果两个二进制位都是 0, 则结果为 0, 否则结果为 1.
按位取反 ~: 如果该位为 0 则转为 1, 如果该位为 1 则转为 0
按位异或 ^: 如果两个数字的二进制位相同, 则结果为 0, 相异则结果为 1.

int a = 0x1;
int b = 0x2;
System.out.printf("%x\n", a ^ b);

[注意] 如果两个数相同，则异或的结果为0.

举例:单身狗原则
1 ^ 2 ^ 3 ^2 ^ 1 == 3

4.5 移位运算符

移位运算符有三个: << >> >>> ，都是二元运算符，且都是按照二进制比特位来运算的.

左移 <<: 最左侧位不要了, 最右侧补 0.

int a = 0x10;
System.out.printf("%x\n", a << 1);
// 运行结果(注意, 是按十六进制打印的)
//20

[注意] 左移的时候,会丢弃符号位,因此正数左移可能会变成负数.
2. 右移 >>: 最右侧位不要了, 最左侧补符号位(正数补0, 负数补1)

int a = 0x10;
System.out.printf("%x\n", a >> 1);
 
// 运行结果(注意, 是按十六进制打印的)
//8
    
int b = 0xffff0000;
System.out.printf("%x\n", b >> 1);
 
// 运行结果(注意, 是按十六进制打印的)
//ffff8000

无符号右移 >>>: 最右侧位不要了, 最左侧补 0.

int a = 0xffffff;
System.out.printf("%x\n", a >>> 1);
 
// 运行结果(注意, 是按十六进制打印的)
//7fffffff

[结论]

左移 1 位, 相当于原数字 * 2. 左移 N 位, 相当于原数字 * 2 的N次方.
右移 1 位, 相当于原数字 / 2. 右移 N 位, 相当于原数字 / 2 的N次方.
由于计算机计算移位效率高于计算乘除, 当某个代码正好乘除 2 的N次方的时候可以用移位运算代替.

4.6 条件运算符(三目运算符)

表达式1 ? 表达式2 : 表达式3
当表达式1 的值为 true 时, 整个表达式的值为表达式2 的值;
当表达式1 的值为 false 时, 整个表达式的值为表达式3 的值.
[注意事项]

表达式2和表达式3的结果要是同类型的，除非能发生类型隐式类型转换.
表达式不能单独存在，其产生的结果必须要被使用.