第二章 Java 基础语法

1、注释

​ 所谓注释，就是对代码的解释和说明。其目的是让人们能够更加轻松地了解代码。为代码添加注释，是十分必须要的，它不影响程序的编译和运行。

​ Java 中有三种注释：单行注释、多行注释、文档注释，其语法如下：

  1. 单行注释，用 // 双斜杠进行表示，其中的注释内容只能写在一行，而不能进行换行
1
// 这里写注释内容，注释内容不能换行
  1. 多行注释，用 /* 和 */ 两个符号将注释内容包裹起来，注释内容可以写不只一行
1
2
3
4
5
/*
	第一行注释
	第二行注释
	第三行注释
*/
  1. 文档注释，用 /** 开头，用 */ 结尾，将注释内容包裹起来，它可以写多行注释，不同的是，文档注释可以被用于生成 Java API 文档，因为其中包含了标准化的注释说明，比如一段代码的作者是谁，可以用 @autor 进行标注。
1
2
3
4
5
6
7
8
9
10
11
12
/**
文档注释演示
@author TAO
*/
public class Comments{
	/**
	Java程序的入口
	*/
    public static void main(String[] args){
        System.out.println("hello");
    }
}

2、关键字

​ 关键字是指，在 Java 中已经定义好的，在程序中具有特殊作用的单词，这些单词因为具有不同的功能而有其规定的使用方式，不可以随意使用。

​ Java 中的关键字有如下50个：

  • 在之前的 HelloWorld 案例中，public 、class 、 static 、 void 等都是关键字，这些单词已经被 Java 定义好。
  • 这些关键太多，不需要死记，等学到之后慢慢记忆即可。
  • 关键字全部都是小写。
  • 其中比较特殊的是，const 和 goto 是保留字，表示它们是 Java 预留的关键字，防止以后某些功能的需要，要求目前的程序中不能够使用这两个单词。

3、标识符

​ 除了关键字以外，其他都是程序员可以自己命名的英文单词，我们把它们叫做标识符。简单的说，凡是程序员自己命名的部分都可以称为标识符。例如，在 HelloWorld 案例中，类名是我们可以自己命名的，则类名就是一个标识符。但是，标识符的命名也需要遵守一定的规范。

标识符的命名规则

  1. 必须遵守的硬性规则
  2. Java 的标识符只能使用26个英文字母大小写，0-9的数字，下划线 _ ，美元符号 $
  3. 不能使用 Java 的关键字（包含保留字）和特殊值
  4. 数字不能开头
  5. 不能包含空格
  6. 严格区分大小写

标识符的命名规范

  1. 建议遵守的软性规则，否则容易被鄙视😜
  2. 要能够见名知意
  3. 类名、接口名等：每个单词的首字母都大写，形式：XxxYyyZzz，例如：HelloWorld，String，System 等
  4. 变量、方法名等：从第二个单词开始首字母大写，其余字母小写，形式：xxxYyyZzz，例如：age , name , bookName , main
  5. 包名等：每一个单词都小写，单词之间使用点.分割，形式：xxx.yyy.zzz，例如：java.lang
  6. 常量名等：每一个单词都大写，单词之间使用下划线 _ 分割，形式：XXX_YYY_ZZZ，例如：MAX_VALUE , PI

出现了一些不认识的名词，没关系，先过过眼，等学到之后再回来看看命名规范

4、数据类型

​ Java 的数据类型分为两大类：基本数据类型和引用数据类型。

4.1、基本数据类型

​ 每一类数据都会有一个专门表示它的关键字，比如 int 关键字表示-128到127之间的整数类型的数据，那么对于整数 100，我们就可以说这是一个 int 类型的数据。

基本数据类型总览：

整数类型

​ 通常所说的整型，实际指的是如下4种类型。

  • byte：一个 byte 类型整数在内存里占8位，表数范围是：-128～127。
  • short：一个 short 类型整数在内存里占16位，表数范围是：-32768～32767。
  • int：一个 int 类型整数在内存里占32位，表数范围是：-2 147 483 648～2 147 483 64。
  • long：一个 long 类型整数在内存里占64位，表数范围是：-9 223 372 036854 775 808～9 223 372 036 854 775 807。若要将一个整数数值表示为 long 类型数值时，需要在数据结尾加上 L ，如 520L 。

如：18，187，-29283948 等整数都是整型数据。

注意：int 是最常用的整数类型，因此在通常情况下，一个 Java 整数常量默认就是 int 类型

字符类型

​ 字符型通常用于表示单个的字符，字符常量必须使用单引号（’）括起来。字符型常量有如下3种表示形式：

  1. 字符类型的数据用 char 关键字来进行表示
  2. 直接通过单个字符来指定字符型常量，例如’A’、’9’和’0’等。
  3. 通过转义字符表示特殊字符型常量，例如’\n’、’\t’等。
  4. char 类型的值也可直接作为整数类型的值来使用，但它是一个16位的无符号整数，即全部是正数，表数范围是0～65535。例如：例如：’A’ 是编码为 65 所对应的字符常量，所以 ‘A’ 这个字符也可以用 65 表示，这些值的对应通常根据 ASCII 标准来进行。

对于 ASCII ，网上会有字符与数值的对应表，搜索 ASCII 即可。

浮点类型

​ Java的浮点类型有两种：float 和 double。简单来说，浮点类型的数据就是带有小数点的小数数据，如 1.5，10.25 等等。而 double 类型的小数比 float 类型的小数精度更高，即可以精确到小数点后更多位。

  • double 类型代表双精度浮点数，float 类型代表单精度浮点数。一个 double 类型的数值占8个字节，即64位，一个 float 类型的数值占4个字节，即32位。
  • Java 语言的浮点类型默认是 double 类型，如果希望 Java 把一个浮点类型值当成 float 类型处理，应该在这个浮点类型值后紧跟 f 或 F ，即 13.2f 或者 13.2F 是 float 类型，13.2 后面没有 f 或 F 则表示是 double 类型。
  • 浮点数必须包含一个小数点，否则会被当成 int 类型处理，即浮点数52，必须写成 52.0，而不能写成 52。

布尔类型

​ 布尔型只有一个 boolean 类型，用于表示逻辑上的“真”或“假”。在 Java 语言中，boolean 类型的数值只能是 true 或 false。boolean 类型的值或变量主要用做标志来进行流程控制。

4.2、引用类型数据

​ 包括数组、 类、接口、枚举、注解。

​ 暂时不做解释，因为目前还用不到。

5、字面常量值

​ 字面常量值，就是我们直接在代码中直接写出来使用，并且在程序执行过程中无法变化的数据。

类型 举例
整数常量值 12，-23, 1567844444557L
浮点常量值 12.34F，12.34
字符常量值 ‘a’，’0’，‘尚’
布尔常量值 true，false
字符串常量值 ”HelloWorld“

  • 整数常量值，超过 int 范围的必须加 L 或 l（小写L）

  • 小数常量值，无论多少，不加F，就是double类型。要表示float类型，必须加F或f

  • char 常量值，必须使用单引号

  • String 字符串常量值，必须使用双引号。String 字符串可以理解为由多个字符组成的单词或者一句话，简单说来就是 String 表示的是一段文本。

    字面常量值通常直接使用：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class ConstantDemo {
	public static void main(String[] args) {		
		//输出整数常量值
		System.out.println(12);
		System.out.println(-23);
        System.out.println(2352654566L);
		
		//输出小数常量值
        System.out.println(12.34F);
		System.out.println(12.34);
		
		//输出字符常量值
		System.out.println('a');
		System.out.println('0');
        System.out.println('尚');
		
		//输出布尔常量值
		System.out.println(true);
		System.out.println(false);
        
        //输出字符串常量值
		System.out.println("HelloWorld");
	}
}

6、变量

6.1、变量的概念

​ 所谓变量，在程序执行的过程中，其值可以发生改变的量。变量的实现其实就是，计算机在内存中划了一块空间，这块空间可以存储特定类型的数据，并且这一块空间中的数据可以被读取和更改。

6.2、变量的声明

​ 变量的声明格式：数据类型 变量名。

​ 变量名代表了计算机给我们划分的那块空间，声明不同的数据类型会造成空间的大小也不同，比如声明数据类型为 int 类型，占 4 个字节，这块空间就划分 4 个字节的大小给我们，然后我们就可以往这个空间中存储任意 int 类型的数值了，这块空间的值可以反复被覆盖变化，所以称为变量。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//存储一个整数类型的年龄
int age; 

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

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

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

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

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

6.3、变量的赋值

​ 那么我们应该怎么往划分的空间中存储数据呢？首先我们应该找到代表那片空间的名字，即变量名。然后用 = 号存储我们需要存储的数据，这个行为我们称为变量的赋值。示例如下：

赋值的语法格式：变量名 = 值

1
2
3
4
5
int age = 18;
double weight = 44.4;
char gender = '女';
boolean flag = true;
String name = "古力娜扎";
  • 给变量赋值，变量名必须在 = 号左边，值必须在 = 号右边
  • 给变量赋的值类型必须与变量声明的类型一致
  • long类型：如果赋值的常量整数超过int范围，那么需要在数字后面加 L。
  • float类型：如果赋值为常量小数，那么需要在小数后面加 F。
  • char类型：使用单引号 ''
  • String类型：使用双引号 ""

6.4、变量值的输出

​ 我们除了往变量的空间中存储数据，还可以读取其中的数据。比如，使用打印方法打印变量，将下面的代码加到刚刚的赋值代码后面：

1
2
3
4
5
6
7
//输出变量的值
System.out.println(age);

//输出变量的值
System.out.println("年龄：" + age);
System.out.println("age：" + age);
System.out.println("name" + name + ",age = " + age + "，gender = " + gender + ",weight = " + weight +",marry = " + marry);
  • 使用 + 可以将多个要输出的内容拼接起来一起输出
  • 输出变量中的值时，可以通过变量名代表其空间中的值
  • 变量可以反复赋值，变量的第一次赋值我们叫做初始化，再赋值称为修改变量的值。变量的好处之一是，当我们更改 age 中的值时，在上述代码中的5，6，7行输出的 age 会一起改变。
  • 其中的 "年龄：" 是我们之前学习的字面常量值。

6.5、变量的三要素

1、数据类型

  • 变量的数据类型决定了在内存中开辟多大空间
  • 变量的数据类型也决定了该变量可以存什么值

2、变量名

  • 用来代表一块内存空间
  • 取名时见名知意非常重要
  • 变量名不能重名，后续章节会出现可重名的情况，但目前不可以。

3、变量的值

  • 基本数据类型的变量：存储的数据值
  • 引用数据类型的变量：存储的数据的地址值，即对象的首地址。例如：String类型的变量存储的是字符串对象的首地址（关于对象后面章节再详细讲解）

6.6、final 常量

​ final 常量是通过在声明变量的数据类型前面加 final 的方式实现的，所以也叫最终变量。加 final 修饰后，这个变量的值就不能修改了，一开始赋值多少，就是多少，所以此时的变量名通常称为常量名。常量名通常所有字母都大写，每一个单词之间使用下划线分割，从命名上和变量名区分开来。这样做的好处，就是可以见名知意，便于维护。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class FinalVariableDemo {
	public static void main(String[] args){
        //定义常量
        final int FULL_MARK = 100;//满分
       // FULL_MARK = 150;//错误，final修饰的变量，是常量，不能重新赋值
        
        //输出常量值
        System.out.println("满分：" + FULL_MARK);
        
        //小王的成绩比满分少1分
        int wang = FULL_MARK - 1;
        //小尚得了满分
        int shang = FULL_MARK;
        //小刘得了一半分
        int liu = FULL_MARK/2;
        
        //输出变量值
        System.out.println("小王成绩：" + wang);
        System.out.println("小尚成绩：" + shang);
        System.out.println("小刘成绩：" + liu);
	}
}

7、基本数据类型的转换

​ 在 Java 程序中，不同的基本数据类型的值经常需要进行相互转换。Java 语言所提供的七种数值类型之间可以相互转换，基本数据类型转换有两种转换方式：自动类型转换和强制类型转换。boolean类型不参与。

7.1、自动类型转换（隐式）

​ 自动转换：将取值范围小的类型自动提升为取值范围大的类型 。

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

会进行自动转换的几种情况：

  1. 当把存储范围小的值（常量值、变量的值、表达式计算的结果值）赋值给了存储范围大的变量时。
1
2
3
4
5
6
7
int i = 'A'; //char自动升级为 int，其实就是把字符的编码值赋值给 i 变量了
double d = 10; //int自动升级为 double

byte b = 127; //右边的整数常量值必须在 -128~127 范围内
//byte bigB = 130; //错误，右边的整数常量值超过 byte 范围
long num = 1234567; //右边的整数常量值如果在 int 范围呢，编译和运行都可以通过，这里涉及到数据类型转换
long bigNum = 12345678912L;//右边的整数常量值如果超过 int 范围，必须加 L，否则编译不通过
  1. 当存储范围小的数据类型与存储范围大的数据类型一起混合运算时，会按照其中最大的类型运算。
1
2
3
4
5
int i = 1;
byte b = 1;
double d = 1.0;

double sum = i + b + d;//混合运算，升级为double
  1. 当 byte , short , char 数据类型进行算术运算时，按照 int 类型处理。
1
2
3
4
5
6
7
byte b1 = 1;
byte b2 = 2;
byte b3 = b1 + b2;//编译报错，b1 + b2自动升级为int

char c1 = '0';
char c2 = 'A';
System.out.println(c1 + c2);//113

7.2、强制类型转换（显示）

​ 如果我们将 1.5 赋值到 int 类型变量中会发生什么？会产生编译失败的结果，肯定无法赋值。

1
int i = 1.5  //产生错误

​ 但是，有时候就是只想要一个小数的整数部分，就是需要一个小数转换为整数，那我们怎么做呢？我们只有通过强制类型转换，将double 类型强制转换成int 类型才能赋值。强制类型转换是将取值范围大的类型强制转换成取值范围小的类型。

强制转换需要我们手动进行，转换格式为：

1
数据类型 变量名 = （想要转换成的数据类型）被强转数据值;  //()中的数据类型的取值范围必须 小于等于 变量的数据类型，一般是等于

强制转换的案例如下：

  1. 当把存储范围大的值（常量值、变量的值、表达式计算的结果值）赋值给了存储范围小的变量时，需要强制类型转换，有风险，可能会损失精度或溢出，因为占用空间被拦腰斩断。
1
2
3
4
5
6
7
int i = (int)3.14;//强制类型转换，损失精度

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

int i = 200;
byte b = (byte)i;//溢出
  1. 当某个值想要提升数据类型时，也可以使用强制类型转换，这个情况的强制类型转换是没有风险的。
1
2
3
int i = 1;
int j = 2;
double shang = (double)i/j;

7.3、基本数据类型与字符串的转换

  1. 任意数据类型的数据与 String 类型进行 “+” 运算时，结果一定是 String 类型。
1
System.out.println("" + 1 + 2);//12
  1. 但是 String 类型不能通过强制类型 () 转换，转为其他的类型。
1
2
String str = "123";
int num = (int)str;//错误的

8、运算符

​ 在 Java 中，一共有38个运算符。

运算符的分类：算术运算符、赋值运算符、比较运算符、逻辑运算、条件运算符。

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

8.1、算术运算符

算术运算符 符号解释
+ 加法运算，字符串连接运算，正号
- 减法运算，负号
* 乘法运算
/ 除法运算，整数/整数结果还是整数
% 求余运算，余数的符号只看被除数
++ 、 -- 自增自减运算

加减、乘除、模（取余）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class OperatorDemo01 {
	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
	}
}

加号拼接

  • 如果在加号的两边中，至少有一边是字符串时，此时的加号表示字符串拼接
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class OperatorDemo02 {
	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
	}
}

自加自减运算

理解：++ 运算，变量自己的值加1**。反之，-- 运算，变量自己的值减少1，用法与++ 一致。

  1. 单独使用
  • 变量在单独运算的时候，变量前++和变量后++，变量的是一样的；
  • 变量前++ ：例如 ++a 。
  • 变量后++ ：例如 a++ 。
1
2
3
4
5
6
7
8
9
10
public class OperatorDemo3 {
	public static void main(String[] args) {
		// 定义一个int类型的变量a
		int a = 3;
		//++a;
		a++;
        // 无论是变量前++还是变量后++，结果都是4
		System.out.println(a);
	}
}
  1. 复合使用
  • 和其他变量放在一起使用或者和输出语句放在一起使用，前++ 和 后++ 就产生了不同。
  • 变量前++ ：变量先自身加1，然后再取值。
  • 变量后++ ：变量先取值，然后再自身加1。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class OperatorDemo04 {
	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);
	} 
}

8.2、比较运算符

比较运算符 符号解释
< 比较符号左边的数据是否小于右边的数据，如果小于结果是true。
> 比较符号左边的数据是否大于右边的数据，如果大于结果是true。
<= 比较符号左边的数据是否小于或者等于右边的数据，如果大于结果是false。
>= 比较符号左边的数据是否大于或者等于右边的数据，如果小于结果是false。
== 比较符号两边数据是否相等，相等结果是true。
!= 不等于符号 ，如果符号两边的数据不相等，结果是true。
  • 比较运算符，是两个数据之间进行比较的运算，运算结果一定是 boolean 值true或者false 。
  • 其中 > , < , >= , <= 不支持 boolean，String 类型，== 和 != 支持 boolean 和 String。
1
2
3
4
5
6
7
8
9
10
11
12
13
public class OperatorDemo05 {
	public static void main(String[] args) {
		int a = 3;
		int b = 4;

		System.out.println(a < b); // true
		System.out.println(a > b); // false
		System.out.println(a <= b); // true
		System.out.println(a >= b); // false
		System.out.println(a == b); // false
		System.out.println(a != b); // true
	}
}

8.3、逻辑运算符

​ 逻辑运算符，是用来计算两个布尔类型值的运算符，运算结果也是 boolean 值 true 或者 false 。

逻辑运算符 符号解释 符号特点
& 与，且 有false则false
` ` 或
^ 异或 相同为false，不同为true
! 非 非false则true，非true则false
&& 双与，短路与 左边为false，则右边就不看
` ` 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
public class OperatorDemo06 {
	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);
	}
}

&&和&区别，||和|区别：

  • &&和&区别：
    • &&和&结果一样，&&有短路效果，左边为false，右边不执行；&左边无论是什么，右边都会执行。
  • ||和|区别：
    • ||和|结果一样，||有短路效果，左边为true，右边不执行；|左边无论是什么，右边都会执行。

8.4、条件运算符

  • 条件运算符格式：
1
条件表达式？结果1：结果2
  • 条件运算符计算方式：
    • 条件判断的结果是true，条件运算符整体结果为结果1，赋值给变量。
    • 判断条件的结果是false，条件运算符整体结果为结果2，赋值给变量。
1
2
3
4
5
6
public static void main(String[] args) {
    int i = (1==2 ? 100 : 200);
    System.out.println(i);//200
    int j = (3<=4 ? 500 : 600);
    System.out.println(j);//500
}

8.5、位运算符

位运算符 符号解释
& 按位与，当两位相同时为1时才返回1
` `
~ 按位非，将操作数的每个位（包括符号位）全部取反
^ 按位异或。当两位相同时返回0，不同时返回1
<< 左移运算符
>> 右移运算符

注：区分是位运算还是逻辑运算主要是看要运算的数是数值还是布尔值

进行位运算时，数值会被转换为用二进制进行表示，比如 10 用二进制表示为 0110

  1. &，与运算的规则为：同时为1，结果为1，任意一方为 0 时，结果为 0
1
2
1&1=1    1&0=0
0&1=0    0&0=0

举个例子，1010 & 1101结果为 1000：即表示 12 & 16 = 8

  1. |，或运算的规则为：同时为0，结果为0，任意一方为1时，结果为1
1
2
1|1=1    1|0=1
0|1=1    0|0=0

举个例子，1010 | 1101 结果为 1111

  1. ~，每位二进制数取相反的数，0变1，1变0，例如 ~10101010 结果为 01010101
  2. ^，异或运算的规则为：不同则为1，相同则为0，如 1010 ^ 1110 结果为 0100
  3. <<，二进制数左移 n 位，如 0110 << 1，结果为 1100，0110 << 2 结果为 11000，可见每移一位值会变为原来的2倍
  4. >>，右移 n 位，如 0110 >> 1 结果为 0011，每右移一位，会是值变为原来的一半

8.6、赋值运算符

运算符 符号解释
= 将右边的常量值/变量值/表达式的值，赋值给左边的变量
+= a += b 与 a = a + b 相同
-= a -= b 与 a = a - b相同
*= a *= b 与 a = a * b 相同
/= a /= b 与 a = a / b 相同
%= a %= b 与 a = a % b 相同
<<= a <<= b 与 a = a << b 相同
>>= a >>= b 与 a = a >> b 相同
&= a &= b 与 a = a & b 相同
|= a |= b 与 a = a | b 相同
^= a ^= b 与 a = a ^ b 相同 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class OperatorDemo07 {
	public static void main(String[] args) {
		int a = 3;
		int b = 4;
        int c = a + b;        
        
		b += a;// 相当于 b = b + a ; 
		System.out.println(a); // 3
		System.out.println(b); // 7	
        System.out.println(c); //7
        
        int m = 1;
        m <<= 2;
        System.out.println(m);
	}
}

8.7、运算符的优先级