Java-02_变量与运算符

1. 关键字（keyword）

• 定义：被Java语言赋予了特殊含义，用做专门用途的字符串（或单词）
  • 关键字有 class、public 、 static 、 void 等，这些单词已经被Java定义好了。
• 特点：全部关键字都是小写字母。
• 官方地址： https://docs.oracle.com/javase/tutorial/java/nutsandbolts/_keywords.html

Java Language Keywords

2. 标识符( identifier)

Java中变量、方法、类等要素命名时使用的字符序列，称为标识符。

技巧：凡是自己可以起名字的地方都叫标识符。

标识符的命名规则（必须遵守的硬性规定）：

> 由26个英文字母大小写，0-9 ，_或 $ 组成  
> 数字不可以开头。
> 不可以使用关键字和保留字，但能包含关键字和保留字。
> Java中严格区分大小写，长度无限制。
> 标识符不能包含空格。

标识符的命名规范（建议遵守的软性要求）:

> 包名：多单词组成时所有字母都小写：xxxyyyzzz。
  例如：java.lang、com.start.bean
  
> 类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz
  例如：HelloWorld，String，System等
  
> 变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz
  例如：age,name,bookName,main,binarySearch,getName
  
> 常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ
  例如：MAX_VALUE,PI,DEFAULT_CAPACITY

注意：在起名字时，为了提高阅读性，要尽量有意义，“见名知意”。

3. 变量

3.1 变量

• 变量的概念：

  • 内存中的一个存储区域，该区域的数据可以在同一类型范围内不断变化

  • 变量的构成包含三个要素：数据类型、变量名、存储的值

  • Java中变量声明的格式：数据类型 变量名 = 变量值

• 变量的作用：用于在内存中保存数据。

• 使用变量注意：

  • Java中每个变量必须先声明，后使用。
  • 使用变量名来访问这块区域的数据。
  • 变量的作用域：其定义所在的一对{ }内。
  • 变量只有在其作用域内才有效。出了作用域，变量不可以再被调用。
  • 同一个作用域内，不能定义重名的变量。

3.2 Java中变量的数据类型

Java中变量的数据类型分为两大类：

• 基本数据类型：包括 整数类型、浮点数类型、字符类型、布尔类型。

• 引用数据类型：包括数组、 类、接口、枚举、注解、记录。

  

3.3 变量的使用

3.3.1 步骤1：变量的声明

格式：数据类型  变量名;

//例如：
//存储一个整数类型的年龄
int age; 

//存储一个小数类型的体重
double weight;

//存储一个单字符类型的性别 
char gender;

//存储一个布尔类型的婚姻状态
boolean marry;

//存储一个字符串类型的姓名
String name;

//声明多个同类型的变量
int a,b,c; //表示a,b,c三个变量都是int类型。

注意：变量的数据类型可以是基本数据类型，也可以是引用数据类型。

3.3.2 步骤2：变量的赋值

给变量赋值，就是把“值”存到该变量代表的内存空间中。同时，给变量赋的值类型必须与变量声明的类型一致或兼容。

变量赋值的语法格式：

变量名 = 值;

举例1：可以使用合适类型的常量值给已经声明的变量赋值

age = 18;
weight = 109;
gender = '女';

举例2：可以使用其他变量或者表达式给变量赋值

int m = 1;
int n = m;
        
int x = 1;
int y = 2;
int z = 2 * x + y;

3：变量可以反复赋值

//先声明，后初始化
char gender;
gender = '女';

//给变量重新赋值，修改gender变量的值
gender = '男';
System.out.println("gender = " + gender);//gender = 男

举例4：也可以将变量的声明和赋值一并执行

boolean isBeauty = true;
String name = "迪丽热巴";

内存结构如图：

4. 基本数据类型介绍

4.1 整数类型：byte、short、int、long

• Java各整数类型有固定的表数范围和字段长度，不受具体操作系统的影响，以保证Java程序的可移植性。

• 定义long类型的变量，赋值时需要以"l"或"L"作为后缀。

• Java程序中变量通常声明为int型，除非不足以表示较大的数，才使用long。

• Java的整型常量默认为 int 型。

计算机存储单位

• 字节（Byte）：是计算机用于计量存储容量的基本单位，一个字节等于8 bit。

• 位（bit）：是数据存储的最小单位。二进制数系统中，每个0或1就是一个位，叫做bit（比特），其中8 bit 就称为一个字节(Byte)。

• 转换关系：

  • 8 bit = 1 Byte
  • 1024 Byte = 1 KB
  • 1024 KB = 1 MB
  • 1024 MB = 1 GB
  • 1024 GB = 1 TB

4.2 浮点类型：float、double

• 与整数类型类似，Java 浮点类型也有固定的表数范围和字段长度，不受具体操作系统的影响。

• 浮点型常量有两种表示形式：
  • 十进制数形式。如：5.12 512.0f .512 (必须有小数点）
  • 科学计数法形式。如：5.12e2 512E2 100E-2
• float：单精度，尾数可以精确到7位有效数字。很多情况下，精度很难满足需求。
• double：双精度，精度是float的两倍。通常采用此类型。
• 定义float类型的变量，赋值时需要以"f"或"F"作为后缀。
• Java 的浮点型常量默认为double型。

4.2.1 关于浮点型精度的说明

• 并不是所有的小数都能可以精确的用二进制浮点数表示。二进制浮点数不能精确的表示0.1、0.01、0.001这样10的负次幂。

• 浮点类型float、double的数据不适合在不容许舍入误差的金融计算领域。如果需要精确数字计算或保留指定位数的精度，需要使用BigDecimal类。

• 测试用例：

//测试1：
System.out.println(0.1 + 0.2);//0.30000000000000004

//测试2：
float ff1 = 123123123f;
float ff2 = ff1 + 1;
System.out.println(ff1);
System.out.println(ff2);
System.out.println(ff1 == ff2);

4.3 字符类型：char

• char 型数据用来表示通常意义上“字符”（占2字节）

• Java中的所有字符都使用Unicode编码，故一个字符可以存储一个字母，一个汉字，或其他书面语的一个字符。

• 字符型变量的三种表现形式：

  • 形式1：使用单引号(’ ')括起来的单个字符。

    例如：char c1 = ‘a’; char c2 = ‘中’; char c3 = ‘9’;

  • 形式2：直接使用 Unicode值来表示字符型常量：‘\uXXXX’。其中，XXXX代表一个十六进制整数。

    例如：\u0023 表示 ‘#’。

  • 形式3：Java中还允许使用转义字符‘\’来将其后的字符转变为特殊字符型常量。

    例如：char c3 = ‘\n’; // '\n’表示换行符

  转义字符	说明	Unicode表示方式
  \n	换行符	\u000a
  \t	制表符	\u0009
  \"	双引号	\u0022
  \'	单引号	\u0027
  \\	反斜线	\u005c
  \b	退格符	\u0008
  \r	回车符	\u000d

• char类型是可以进行运算的。因为它都对应有Unicode码，可以看做是一个数值。

4.4 布尔类型：boolean

• boolean 类型用来判断逻辑条件，一般用于流程控制语句中：

  • if条件控制语句；
  • while循环控制语句；
  • for循环控制语句；
  • do-while循环控制语句；

• boolean类型数据只有两个值：true、false，无其它。

  • 不可以使用0或非 0 的整数替代false和true，这点和C语言不同。
  • 拓展：Java虚拟机中没有任何供boolean值专用的字节码指令，Java语言表达所操作的boolean值，在编译之后都使用java虚拟机中的int数据类型来代替：true用1表示，false用0表示。

• 举例：

boolean isFlag = true;

if(isFlag){
    //true分支
}else{  
    //false分支
}

经验之谈：

Less is More！建议不要这样写：if ( isFlag = = true )。关键也很容易写错成if(isFlag = true)，这样就变成赋值isFlag为true而不是判断！写法是if (isFlag)或者if ( !isFlag)。

5. 基本数据类型变量间运算规则

在Java程序中，不同的基本数据类型（只有7种，不包含boolean类型）变量的值经常需要进行相互转换。

转换的方式有两种：自动类型提升和强制类型转换。

5.1 自动类型提升

规则：将取值范围小（或容量小）的类型自动提升为取值范围大（或容量大）的类型 。

基本数据类型的转换规则如图所示：

（1）当把存储范围小的值（常量值、变量的值、表达式计算的结果值）赋值给了存储范围大的变量时

int i = 'A';//char自动升级为int，其实就是把字符的编码值赋值给i变量了
double d = 10;//int自动升级为double
long num = 1234567; //右边的整数常量值如果在int范围呢，编译和运行都可以通过，这里涉及到数据类型转换

//byte bigB = 130;//错误，右边的整数常量值超过byte范围
long bigNum = 12345678912L;//右边的整数常量值如果超过int范围，必须加L，显式表示long类型。否则编译不通过

（2）当存储范围小的数据类型与存储范围大的数据类型变量一起混合运算时，会按照其中最大的类型运算。

int i = 1;
byte b = 1;
double d = 1.0;

double sum = i + b + d;//混合运算，升级为double

（3）当byte,short,char数据类型的变量进行算术运算时，按照int类型处理。

byte b1 = 1;
byte b2 = 2;
byte b3 = b1 + b2;//编译报错，b1 + b2自动升级为int

char c1 = '0';
char c2 = 'A';
int i = c1 + c2;//至少需要使用int类型来接收
System.out.println(c1 + c2);//113 

5.2 强制类型转换

将3.14 赋值到int 类型变量会发生什么？产生编译失败，肯定无法赋值。

int i = 3.14; // 编译报错

想要赋值成功，只有通过强制类型转换，将double 类型强制转换成int 类型才能赋值。

规则：将取值范围大（或容量大）的类型强制转换成取值范围小（或容量小）的类型。

自动类型提升是Java自动执行的，而强制类型转换是自动类型提升的逆运算，需要我们自己手动执行。

转换格式：

数据类型1 变量名 = (数据类型1)被强转数据值;  //()中的数据类型必须<=变量值的数据类型

（1）当把存储范围大的值（常量值、变量的值、表达式计算的结果值）强制转换为存储范围小的变量时，可能会损失精度或溢出。

int i = (int)3.14;//损失精度

double d = 1.2;
int num = (int)d;//损失精度

int i = 200;
byte b = (byte)i;//溢出

（2）当某个值想要提升数据类型时，也可以使用强制类型转换。这种情况的强制类型转换是没有风险的，通常省略。

int i = 1;
int j = 2;
double bigger = (double)(i/j);

（3）声明long类型变量时，可以出现省略后缀的情况。float则不同。

long l1 = 123L;
long l2 = 123;//如何理解呢？ 此时可以看做是int类型的123自动类型提升为long类型

//long l3 = 123123123123; //报错，因为123123123123超出了int的范围。
long l4 = 123123123123L;


//float f1 = 12.3; //报错，因为12.3看做是double，不能自动转换为float类型
float f2 = 12.3F;
float f3 = (float)12.3;

问答：为什么标识符的声明规则里要求不能数字开头？

//如果允许数字开头，则如下的声明编译就可以通过：
int 123L = 12;
//进而，如下的声明中l的值到底是123？还是变量123L对应的取值12呢？ 出现歧义了。
long l = 123L;

5.3 基本数据类型与String的运算

5.3.1 字符串类型：String

• String不是基本数据类型，属于引用数据类型
• 使用一对""来表示一个字符串，内部可以包含0个、1个或多个字符。
• 声明方式与基本数据类型类似。例如：String str = “超人不会飞”;

5.3.2 运算规则

1、任意八种基本数据类型的数据与String类型只能进行连接“+”运算，且结果一定也是String类型

System.out.println("" + 1 + 2);//12

int num = 10;
boolean b1 = true;
String s1 = "abc";

String s2 = s1 + num + b1;
System.out.println(s2);//abc10true

//String s3 = num + b1 + s1;//编译不通过，因为int类型不能与boolean运算
String s4 = num + (b1 + s1);//编译通过

2、String类型不能通过强制类型()转换，转为其他的类型

String str = "123";
int num = (int)str;//错误的

int num = Integer.parseInt(str);//正确的，后面才能讲到，借助包装类的方法才能转

6. 计算机底层如何存储数据

计算机世界中只有二进制，所以计算机中存储和运算的所有数据都要转为二进制。包括数字、字符、图片、声音、视频等。

世界上有10种人 ，认识和不认识二进制的。

6.1 进制的分类

• 十进制（decimal）

  • 数字组成：0-9
  • 进位规则：满十进一

• 二进制（binary）

  • 数字组成：0-1
  • 进位规则：满二进一，以0b或0B开头

• 八进制（octal）：很少使用

  • 数字组成：0-7
  • 进位规则：满八进一，以数字0开头表示

• 十六进制

  • 数字组成：0-9，a-f
  • 进位规则：满十六进一，以0x或0X开头表示。此处的 a-f 不区分大小写

代码演示：

class BinaryTest {
	public static void main(String[] args) {
		
		int num1 = 123;		//十进制
		int num2 = 0b101;	//二进制
		int num3 = 0127;	//八进制
		int num4 = 0x12aF;	//十六进制

		System.out.println(num1);
		System.out.println(num2);
		System.out.println(num3);
		System.out.println(num4);

	}
}

6.2 进制的换算举例

十进制	二进制	八进制	十六进制
0	0	0	0
1	1	1	1
2	10	2	2
3	11	3	3
4	100	4	4
5	101	5	5
6	110	6	6
7	111	7	7
8	1000	10	8
9	1001	11	9
10	1010	12	a或A
11	1011	13	b或B
12	1100	14	c或C
13	1101	15	d或D
14	1110	16	e或E
15	1111	17	f或F
16	10000	20	10

7. 运算符（Operator）（掌握）

运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。

运算符的分类：

• 按照功能分为：算术运算符、赋值运算符、比较(或关系)运算符、逻辑运算符、位运算符、条件运算符、Lambda运算符

分类	运算符
算术运算符（7个）	+、-、*、/、%、++、–
赋值运算符（12个）	=、+=、-=、*=、/=、%=、>>=、<<=、>>>=、&=、|=、^=等
比较(或关系)运算符（6个）	>、>=、<、<=、==、!=
逻辑运算符（6个）	&、|、^、!、&&、||
位运算符（7个）	&、|、^、~、<<、>>、>>>
条件运算符（1个）	(条件表达式)?结果1:结果2
Lambda运算符（1个）	->

• 按照操作数个数分为：一元运算符（单目运算符）、二元运算符（双目运算符）、三元运算符 （三目运算符）

分类	运算符
一元运算符（单目运算符）	正号（+）、负号（-）、++、–、!、~
二元运算符（双目运算符）	除了一元和三元运算符剩下的都是二元运算符
三元运算符 （三目运算符）	(条件表达式)?结果1:结果2

7.1 算术运算符

7.1.1 基本语法

举例1：加减乘除模

public class ArithmeticTest1 {
	public static void main(String[] args) {
		int a = 3;
		int b = 4;
		
		System.out.println(a + b);// 7
		System.out.println(a - b);// -1
		System.out.println(a * b);// 12
		System.out.println(a / b);// 计算机结果是0，为什么不是0.75呢？
		System.out.println(a % b);// 3
        
        //结果与被模数符号相同
        System.out.println(5%2);//1
		System.out.println(5%-2);//1
		System.out.println(-5%2);//-1
		System.out.println(-5%-2);//-1		
		//商*除数 + 余数 = 被除数
		//5%-2  ==>商是-2，余数时1    (-2)*(-2)+1 = 5
		//-5%2  ==>商是-2，余数是-1   (-2)*2+(-1) = -4-1=-5
	}
}

举例2：“+”号的两种用法

• 第一种：对于+两边都是数值的话，+就是加法的意思
• 第二种：对于+两边至少有一边是字符串的话，+就是拼接的意思

public class ArithmeticTest2 {
	public static void main(String[] args) {
		// 字符串类型的变量基本使用
		// 数据类型 变量名称 = 数据值;
		String str1 = "Hello";
		System.out.println(str1); // Hello
		
		System.out.println("Hello" + "World"); // HelloWorld
		
		String str2 = "Java";
		// String + int --> String
		System.out.println(str2 + 520); // Java520
		// String + int + int
		// String		+ int
		// String
		System.out.println(str2 + 5 + 20); // Java520
	}
}

举例3：自加自减运算

理解：++ 运算，表示自增1。同理，-- 运算，表示自减1，用法与++ 一致。

1、单独使用

• 变量在单独运算的时候，变量前++和变量后++，是没有区别的。
• 变量前++ ：例如 ++a 。
• 变量后++ ：例如 a++ 。

public class ArithmeticTest3 {
	public static void main(String[] args) {
		// 定义一个int类型的变量a
		int a = 3;
		//++a;
		a++;
        // 无论是变量前++还是变量后++，结果都是4
		System.out.println(a);
	}
}

2、复合使用

• 和其他变量放在一起使用或者和输出语句放在一起使用，前++和后++就产生了不同。

• 变量前++ ：变量先自增1，然后再运算。
• 变量后++ ：变量先运算，然后再自增1。

public class ArithmeticTest4 {
	public static void main(String[] args) {
		// 其他变量放在一起使用
		int x = 3;
		//int y = ++x; // y的值是4，x的值是4，
		int y = x++; // y的值是3，x的值是4
		
		System.out.println(x);
		System.out.println(y);
		System.out.println("==========");
        
		// 和输出语句一起
		int z = 5;
		//System.out.println(++z);// 输出结果是6，z的值也是6
		System.out.println(z++);// 输出结果是5，z的值是6
		System.out.println(z);
        
	} 
}

7.2 赋值运算符

7.2.1 基本语法

• 符号：=

  • 当“=”两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理。
  • 支持连续赋值。

• 扩展赋值运算符： +=、 -=、*=、 /=、%=

  赋值运算符	符号解释
  +=	将符号左边的值和右边的值进行相加操作，最后将结果赋值给左边的变量
  -=	将符号左边的值和右边的值进行相减操作，最后将结果赋值给左边的变量
  *=	将符号左边的值和右边的值进行相乘操作，最后将结果赋值给左边的变量
  /=	将符号左边的值和右边的值进行相除操作，最后将结果赋值给左边的变量
  %=	将符号左边的值和右边的值进行取余操作，最后将结果赋值给左边的变量

public class SetValueTest1 {
	public static void main(String[] args) {
		int i1 = 10;
		long l1 = i1; //自动类型转换

		byte bb1 = (byte)i1; //强制类型转换

		int i2 = i1;

		//连续赋值的测试
		//以前的写法
		int a1 = 10;
		int b1 = 10;
		
		//连续赋值的写法
		int a2,b2;
		a2 = b2 = 10;
		
		int a3 = 10,b3 = 20;

		//举例说明+=  -=  *=  /=   %=  
		int m1 = 10;
		m1 += 5; //类似于 m1 = m1 + 5的操作，但不等同于。
		System.out.println(m1);//15
		
		//练习1：开发中，如何实现一个变量+2的操作呢？
		// += 的操作不会改变变量本身的数据类型。其他拓展的运算符也如此。
		//写法1：推荐
		short s1 = 10;
		s1 += 2; //编译通过，因为在得到int类型的结果后，JVM自动完成一步强制类型转换，将int类型强转成short
		System.out.println(s1);//12
		//写法2：
		short s2 = 10;
		//s2 = s2 + 2;//编译报错，因为将int类型的结果赋值给short类型的变量s时，可能损失精度
		s2 = (short)(s2 + 2);
		System.out.println(s2);


		//练习2：开发中，如何实现一个变量+1的操作呢？
		//写法1：推荐
		int num1 = 10;
		num1++;
		System.out.println(num1);

		//写法2：
		int num2 = 10;
		num2 += 1;
		System.out.println(num2);

		//写法3：
		int num3 = 10;
		num3 = num3 + 1;
		System.out.println(num3);

	}
}

7.3 比较(关系)运算符

• 比较运算符的结果都是boolean型，也就是要么是true，要么是false。

• > < >= <= ：只适用于基本数据类型（除boolean类型之外）

  == != ：适用于基本数据类型和引用数据类型

• 比较运算符“==”不能误写成“=”

举例：

class CompareTest {
	public static void main(String[] args) {
		int i1 = 10;
		int i2 = 20;
		
		System.out.println(i1 == i2);//false
		System.out.println(i1 != i2);//true
		System.out.println(i1 >= i2);//false


		int m = 10;
		int n = 20;
		System.out.println(m == n);//false
		System.out.println(m = n);//20

		boolean b1 = false;
		boolean b2 = true;
		System.out.println(b1 == b2);//false
		System.out.println(b1 = b2);//true
	}
}

思考：

boolean b1 = false;
//区分好==和=的区别。
if(b1 == true)  //if(b1 = true)
	System.out.println("结果为真");
else
	System.out.println("结果为假");

7.4 逻辑运算符

7.4.1 基本语法

• 逻辑运算符，操作的都是boolean类型的变量或常量，而且运算得结果也是boolean类型的值。

• 运算符说明：

  • & 和 &&：表示"且"关系，当符号左右两边布尔值都是true时，结果才能为true。否则，为false。
  • | 和 || ：表示"或"关系，当符号两边布尔值有一边为true时，结果为true。当两边都为false时，结果为false
  • ! ：表示"非"关系，当变量布尔值为true时，结果为false。当变量布尔值为false时，结果为true。
  • ^ ：当符号左右两边布尔值不同时，结果为true。当两边布尔值相同时，结果为false。
    • 理解：异或，追求的是“异”！

• 逻辑运算符用于连接布尔型表达式，在Java中不可以写成 3 < x < 6，应该写成x > 3 & x < 6 。

• 区分“&”和“&&”：

  • 相同点：如果符号左边是true，则二者都执行符号右边的操作

  • 不同点：& ： 如果符号左边是false,则继续执行符号右边的操作

  ​ && ：如果符号左边是false,则不再继续执行符号右边的操作

  • 建议：开发中，推荐使用 &&

• 区分“|”和“||”：

  • 相同点：如果符号左边是false，则二者都执行符号右边的操作

  • 不同点：| ： 如果符号左边是true，则继续执行符号右边的操作

    ​ || ：如果符号左边是true，则不再继续执行符号右边的操作

  • 建议：开发中，推荐使用 ||

代码举例：

public class LoginTest {
	public static void main(String[] args) {
		int a = 3;
		int b = 4;
		int c = 5;

		// & 与，且；有false则false
		System.out.println((a > b) & (a > c)); 
		System.out.println((a > b) & (a < c)); 
		System.out.println((a < b) & (a > c)); 
		System.out.println((a < b) & (a < c)); 
		System.out.println("===============");
		// | 或；有true则true
		System.out.println((a > b) | (a > c)); 
		System.out.println((a > b) | (a < c)); 
		System.out.println((a < b) | (a > c));
		System.out.println((a < b) | (a < c));
		System.out.println("===============");
		// ^ 异或；相同为false，不同为true
		System.out.println((a > b) ^ (a > c));
		System.out.println((a > b) ^ (a < c)); 
		System.out.println((a < b) ^ (a > c)); 
		System.out.println((a < b) ^ (a < c)); 
		System.out.println("===============");
		// ! 非；非false则true，非true则false
		System.out.println(!false);
		System.out.println(!true);
        
        //&和&&的区别
        System.out.println((a > b) & (a++ > c)); 
        System.out.println("a = " + a);
        System.out.println((a > b) && (a++ > c)); 
        System.out.println("a = " + a);
        System.out.println((a == b) && (a++ > c)); 
        System.out.println("a = " + a);
        
        //|和||的区别
        System.out.println((a > b) | (a++ > c)); 
        System.out.println("a = " + a);
        System.out.println((a > b) || (a++ > c)); 
        System.out.println("a = " + a);
        System.out.println((a == b) || (a++ > c)); 
        System.out.println("a = " + a);
	}
}

7.5 位运算符

7.5.1 基本语法

• 位运算符的运算过程都是基于二进制的补码运算

（1）左移：<<

运算规则：在一定范围内，数据每向左移动一位，相当于原数据*2。（正数、负数都适用）

【注意】当左移的位数n超过该数据类型的总位数时，相当于左移（n-总位数）位

3<<4  类似于  3*2的4次幂 => 3*16 => 48

-3<<4  类似于  -3*2的4次幂 => -3*16 => -48

（2）右移：>>

运算规则：在一定范围内，数据每向右移动一位，相当于原数据/2。（正数、负数都适用）

【注意】如果不能整除，向下取整。

69>>4  类似于  69/2的4次 = 69/16 =4

-69>>4  类似于  -69/2的4次 = -69/16 = -5

（3）无符号右移：>>>

运算规则：往右移动后，左边空出来的位直接补0。（正数、负数都适用）

69>>>4  类似于  69/2的4次 = 69/16 =4

-69>>>4   结果：268435451

（4）按位与：&

运算规则：对应位都是1才为1，否则为0。

• 1 & 1 结果为1

• 1 & 0 结果为0

• 0 & 1 结果为0

• 0 & 0 结果为0

9 & 7 = 1

-9 & 7 = 7

（5）按位或：|

运算规则：对应位只要有1即为1，否则为0。

• 1 | 1 结果为1

• 1 | 0 结果为1

• 0 | 1 结果为1

• 0 & 0 结果为0

9 | 7  //结果： 15

-9 | 7 //结果： -9

（6）按位异或：^

运算规则：对应位一个为1一个为0，才为1，否则为0。

• 1 ^ 1 结果为0

• 1 ^ 0 结果为1

• 0 ^ 1 结果为1

• 0 ^ 0 结果为0

9 ^ 7  //结果为14

-9 ^ 7 //结果为-16

（7）按位取反：~

运算规则：对应位为1，则结果为0；对应位为0，则结果为1。

• ~0就是1

• ~1就是0

~9  //结果：-10

~-9  //结果：8

7.5.2 举例

举例1：

举例2：体会 m = k ^ n = (m ^ n) ^ n

7.6 条件运算符

7.6.1 基本语法

• 条件运算符格式：

(条件表达式)? 表达式1:表达式2

• 说明：条件表达式是boolean类型的结果，根据boolean的值选择表达式1或表达式2

• 如果运算后的结果赋给新的变量，要求表达式1和表达式2为同种或兼容的类型

public static void main(String[] args) {
    int i = (1==2 ? 100 : 200);
    System.out.println(i);//200
    
    boolean marry = false;
	System.out.println(marry ? "已婚" : "未婚"  );
    
    double d1 = (m1 > m2)? 1 : 2.0;
	System.out.println(d1);
    
    int num = 12;
    System.out.println(num > 0? true : "num非正数");
}

7.6.3 与if-else的转换关系

• 凡是可以使用条件运算符的地方，都可以改写为if-else结构。反之，不成立。

• 开发中，如果既可以使用条件运算符，又可以使用if-else，推荐使用条件运算符。因为执行效率稍高。

//if-else实现获取两个数的较大值

int i1 = 10;
int i2 = 20;

int max;//声明变量max，用于记录i1和i2的较大值

if(i1 > i2){
    max = i1;
}else{
    max = i2;
}

System.out.println(max);

7.7 运算符优先级

运算符有不同的优先级，所谓优先级就是在表达式运算中的运算符顺序。

上一行中的运算符总是优先于下一行的。

优先级	运算符说明	Java运算符
1	括号	()、[]、{}
2	正负号	+、-
3	单元运算符	++、--、~、！
4	乘法、除法、求余	*、/、%
5	加法、减法	+、-
6	移位运算符	<<、>>、>>>
7	关系运算符	<、<=、>=、>、instanceof
8	等价运算符	==、!=
9	按位与	&
10	按位异或	^
11	按位或	`
12	条件与	&&
13	条件或	`
14	三元运算符	? :
15	赋值运算符	=、+=、-=、*=、/=、%=
16	位赋值运算符	&=、`

开发建议：

1. 不要过多的依赖运算的优先级来控制表达式的执行顺序，这样可读性太差，尽量使用()来控制表达式的执行顺序。
2. 不要把一个表达式写得过于复杂，如果一个表达式过于复杂，则把它分成几步来完成。例如：
   ​ (num1 + num2) * 2 > num3 && num2 > num3 ? num3 : num1 + num2;

8.代码整洁之道 有意义的命名

1.介绍

软件中随处可见命名。我们给变量、函数、参数、类和包命名。我们给源代码及源代码所在目录命名。

2.名副其实,见名知意

​ 变量名太随意，haha、list1、ok、theList 这些都没啥意义

3.避免误导

​ 包含List、import、java等类名、关键字或特殊字；
​ 字母o与数字0，字母l与数字1等
​ 提防使用不同之处较小的名称。比如：XYZControllerForEfficientHandlingOfStrings与XYZControllerForEfficientStorageOfStrings

4.做有意义的区分

​ 反面教材，变量名：a1、a2、a3
​ 避免冗余，不要出现Variable、表字段中避免出现table、字符串避免出现nameString，直接name就行，知道是字符串类型
​ 再比如：定义了两个类：Customer类和CustomerObject类，如何区分？
​ 定义了三个方法：getActiveAccount()、getActiveAccounts()、getActiveAccountInfo()，如何区分？

5.使用读得出来的名称

​ 不要使用自己拼凑出来的单词，比如：xsxm(学生姓名)；genymdhms(生成日期，年、月、日、时、分、秒)
​ 所谓的驼峰命名法，尽量使用完整的单词

6.使用可搜索的名称

​ 一些常量，最好不直接使用数字，而指定一个变量名，这个变量名可以便于搜索到.
​ 比如：找MAX_CLASSES_PER_STUDENT很容易，但想找数字7就麻烦了。

7.避免使用编码

• 匈牙利语标记法
  • 即变量名表明该变量数据类型的小写字母开始。例如，szCmdLine的前缀sz表示“以零结束的字符串”。
• 成员前缀
  • 避免使用前缀，但是Android中一个比较好的喜欢用m表示私有等，个人感觉比较
• 接口和实现
  • 不喜欢把接口使用I来开头，实现也希望只是在后面添加Imp

8.避免思维映射

​ 比如传统上惯用单字母名称做循环计数器。所以就不要给一些非计数器的变量命名为：i、j、k等

9.类名

​ 类名与对象名应该是名词与名词短语。如Customer、WikiPage、Account和AddressParser。避免使用Data或Info这样的类名。
​ 不能使动词。比如：Manage、Process

10.方法名

​ 方法名应当是动词或者动词短语。如postPayment、deletePage或save

11.别扮可爱

​ 有的变量名叫haha、banana
​ 别用eatMyShorts()表示abort()

12.每个概念对应一个词

​ 项目中同时出现controllers与managers，为什么不统一使用其中一种？
​ 对于那些会用到你代码的程序员，一以贯之的命名法简直就是天降福音。

13.别用双关语

​ 有时可能使用add并不合适，比例insert、append。add表示完整的新添加的含义。

14.使用解决方案领域名称

​ 看代码的都是程序员，所以尽量用那些计算机科学术语、算法名、模式名、数学术语，
​ 依据问题所涉领域来命名不算是聪明的做法。

15.使用源自所涉问题领域的名称

​ 如果不能用程序员熟悉的术语来给手头的工作命名，就采用从所涉问题领域而来的名称吧。
​ 至少，负责维护代码的程序员就能去请教领域专家了。

16.添加有意义的语境

​ 可以把相关的变量放到一个类中，使用这个类来表明语境。

17.不要添加没用的语境

​ 名字中带有项目的缩写，这样完全没有必要。比如有一个名为“加油站豪华版”（Gas Station Deluxe）的项目，在其中给每个类添加GSD前缀就不是什么好策略。