需要掌握的内容：
标识符
关键字
字面值
变量
数据类型
运算符：
- 算术运算符
- 关系运算符
- 逻辑运算符
- 赋值类运算符
- 字符串连接运算符
- 三元运算符
- 赋值运算符
- 字符串连接运算符
控制语句
- 选择结构
- if,if..else
- switch
- 循环结构
- for
- while
- do..while()
- 控制循环的语句
- break
- continue
- 选择结构
1、标识符：
1、在java程序当中，使用EditPlus工具进行代码编写的时候，
有一些单词是蓝色，有的是红色，有的绿色，有的是黑色，有
的是紫色，有的是粉色….
2、注意：在java源代码当中，在EditPlus工具中显示的高亮颜色为黑色时，
这个单词属于标识符。
3、标识符可以标识什么？
可以标识：
- 类名
- 方法名
- 变量名
- 接口名
- 常量名
- ……
4、到底什么是标识符呢？
一句话搞定：凡是程序员自己有权利命名的单词都是标识符。
5、标识符可以随意编写吗，有命名规则吗？有
什么是命名规则？
命名规则属于语法机制，必须遵守，不遵守命名规则标识不符合语法，
这样，编译器会报错。
规则1：标识符只能由数字、字母（包括中文）、下划线_、美元符号$组成，
不能含有其它符号。规则2：标识符不能以数字开头
规则3：关键字不能做标识符。例如：public class static void 这些蓝色的字体
都是关键字，关键字是不能做标识符的。
规则4：标识符是严格区分大小写的。大写A和小写a不一样。
规则5：标识符理论上是没有长度限制的。
6、注意的点：
class 123ABC{
}
编译报错，错误信息是：
错误: 需要<标识符>
错误原因：编译器检测到class这个单词，那么编译器会从class这个
单词后面找类名，而类名是标识符，编译器找了半天没有找到标识符，
因为123ABC不是标识符，所以编译器提示的错误信息是：需要<标识符>
解决办法：
将123ABC修改为合法的标识符。
class Hello World{
}
类名是标识符，标识符“中”不能有空格
编译器错误信息是：
错误: 需要’{‘
编译器检测到class，然后找class后面的标识符，编译器找到了一个合法的标识符
叫做“Hello”，然后编译器继续往后找“{”，结果没有找到“{”，所以报错了。
解决办法：
办法1：是把World删除
办法2：把空格删除
class public {
}
关键字不能做标识符
编译器错误信息是：
错误: 需要<标识符>
这个可以，因为 public1 不是关键字，可以用
class public1 {
}
* 虽然java中的标识符严格区分大小写
* 但是对于类名来说，如果一个java源文件中同时出现了：A类和a类
* 那么谁在前就生成谁。大家以后最好不要让类名“相同”。
* 最好类名是不同的。7、题目：
创建一个java文件，起名 123.java可以吗？
可以，完全可以，在windows操作系统中文件名叫做：123.java没毛病。
123其实并不是标识符。只是一个文件名。
只不过在123.java文件中无法定义public的类。
8、命名规范：
1、命名规则和命名规范有什么区别？
命名规则是语法，不遵守就会编译报错。
命名规范只是说，大家尽量按照统一的规范来进行命名，不符合规范也行，
代码是可以编译通过的，但是你的代码风格和大家不一样，这个通常也是不允许的。
规则类似于：现实世界中的法律。
规范类似于：现实世界中的道德。
统一按照规范进行的话，代码的可读性很好。代码很容易让其它开发人员理解。
2、具体的命名规范是哪些？
- 规范1：见名知意（这个标识符在起名的时候，最好一看这个单词就知道啥意思。）
- 规范2：遵循驼峰命名方式，什么是驼峰（一高一低，一高一低…）
驼峰有利于单词与单词之间很好的进行分隔
BiaoShiFuTest，这个很好，一眼就能看出来是4个单词。 - 规范3：类名、接口名有特殊要求
类名和接口名首字母大写，后面每个单词首字母大写。
StudentTest、UserTest ，这是类名、接口名。 - 规范4：变量名、方法名有特殊要求
变量名和方法名首字母小写，后面每个单词首字母大写。
nianLing/age（NianLing这样就不符合了。）
mingZi/name（MingZi这样也不符合了。） - 规范5：所有“常量”名：全部大写，并且单词和单词之间采用下划线衔接。
USER_AGE ：用户年龄
MATH_PI：固定不变的常量3.1415926…..
2、关键字：
关键字:
在SUN公司开发Java语言的时候，提前定义好了一些具有特殊含义的单词，这些单词全部小写，具有特殊含义，不能用作标识符。凡是在EditPlus中以蓝色字体形式存在的都是关键字，具有特殊含义。
切记：
java语言中的所有关键字都是全部小写。
注意：java语言中是严格区分大小写的。
public和Public不一样。
Class和class不一样。
static和Static也不一样。
重点：string不是java关键字！！！
Java关键字(50个)的大致含义(运用记忆)：
1 | 关键字 含义 |
3、字面量：
关于程序当中的数据
开发软件是为了解决现实世界中的问题。
而现实世界当中，有很多问题都是使用数据进行描述的。
所以软件执行过程中最主要就是对数据的处理。
软件在处理数据之前需要能够表示数据，在java代码中怎么去表示数据呢？在java中有这样的一个概念：字面量。
注意：在java语言中“数据”被称为“字面量”。
10
1.23
true
false
‘a’
“abc”
以上这些都是数据，在程序中都被叫做“字面量”。
字面量可以分为很多种类：
整数型字面量：1 2 3 100 -100 -20 ….
浮点型字面量：1.3 1.2 3.14…..
布尔型字面量：true、false没有其它值了，表示真和假,true表示真，false表示假
字符型字面量：’a’、’b’、’中’
字符串型字面量：”abc”、”a”、”b”、”中国”
其中字符型和字符串型都是描述了现实世界中的文字：
需要注意的是：
所有的字符型只能使用单引号括起来。
所有的字符串型只能使用双引号括起来。
字符型一定是单个字符才能成为“字符型”
在语法级别上区分字符型和字符串型：
主要看是双引号还是单引号。
单引号的一定是字符型。
双引号的一定是字符串型。
4、变量：
变量的定义：
变量其实就是内存当中存储数据的最基本的单元。
变量就是一个存储数据的盒子。
在java语言当中任何数据都是有数据类型的，其中整数型是：int
当然，在java中除了数据类型int之外，还有其它的类型，例如带小数的：double等
数据类型有什么用呢？
重点：不同的数据类型，在内存中分配的空间大小不同。
也就是说，Java虚拟机到底给这个数据分配多大的空间，主要还是看这个变量的数据类型。
根据不同的类型，分配不同大小的空间。
对于int这种整数类型，JVM会自动给int分配4个字节大小的空间。
1个字节=8个比特位
1个比特位就是一个1或0. 注意：比特位是二进制位。
int是占用多少个二进制位？1个int占有32个二进制位（bit位）
int i = 1; 实际上在内存中是这样表示的：
00000000 00000000 00000000 00000001
int i = 2;
00000000 00000000 00000000 00000010
二进制位就是：满2进1位（0 1 10 11 100 101….）
十进制位就是：满10进1位（1 2 3 4 5 6 7 8 9 10）
对于一个变量来说，包括三要素：
- 变量的数据类型
- 变量的名字
- 变量中保存的值
类型+名字+值
类型决定空间的大小。
起个名字是为了以后方便访问。（以后在程序中访问这个数据是通过名称来访问的。）
值是变量保存的数据。
变量名属于标识符
- 变量名命名规范
- 首字母小写，后面每个单词首字母大写，遵循驼峰命名方式，见名知意。
变量声明/定义的语法格式
数据类型 变量名;
例如：
int nianLing;
在java语言中有一个规定，变量必须先声明，再赋值才能访问。（没有值相当于这个空间没有开辟。）
在java语言中给一个变量赋值呢的语法格式
重点：使用一个运算符，叫做“=”，这个运算符被称为赋值运算符。
赋值运算符“=”的运算特点是：等号右边先执行，执行完之后赋值给左边的变量。
变量声明的时候可以同时进行赋值。
一行同时声明多个变量。
重点：在同一个域当中，变量名不能重名，不能重复声明（和类型没有关系。不能同名。）。
变量可以重新赋值，但在同一个域当中，不能重复声明。
关于变量的一个分类：
变量根据出现的位置进行划分：
在方法体当中声明的变量：局部变量。
在方法体之外，类体内声明的变量：成员变量。
重点依据是：声明的位置。
注意：局部变量只在方法体当中有效，方法体执行结束该变量的内存就释放了。
变量的作用域：
- 作用域的定义:
变量的有效范围。 - 关于变量的作用域，可以记住一句话：
出了大括号就不认识了。 - java中有一个很重要的原则：
就近原则。（不仅java中是这样，其它编程语言都有这个原则。）
哪个离我近，就访问哪个。
5、数据类型：
数据类型有什么用？
数据类型用来声明变量，程序在运行过程中根据不同的数据类型分配不同大小的空间。
int i = 10;
double d = 1.23;
i变量和d变量类型不同，空间大小不同。
总述
- 数据类型在java语言中包括两种：
- 基本数据类型
基本数据类型又可以划分为4大类8小种：- 整数型
byte,short,int,long （没有小数的） - 浮点型
float,double （带有小数的） - 布尔型
boolean：只有两个值true和false，true表示真，false表示假 - 字符型
char：java中规定字符型字面量必须使用单引号括起来。属于文字。 - 8小种：
- byte,short,int,long
- float,double
- boolean
- char
- 整数型
- 引用数据类型
字符串型String属于引用数据类型。 String字符串不属于基本数据类型范畴。 java中除了基本数据类型之外，剩下的都是引用数据类型。 引用数据类型后期面向对象的时候才会接触。
- 基本数据类型
8种基本数据类型中
整数型：byte short int long有什么区别？
浮点型：float和double有什么区别？
区别：占用的空间大小不同。
关于计算机存储单位？
计算机只能识别二进制。（1001101100…）
1字节 = 8bit（8比特）–> 1byte = 8bit
1bit就是一个1或0.
1KB = 1024byte
1MB = 1024KB
1GB = 1024MB
1TB = 1024GB
? byte b = 2; 在计算机中是这样表示的：00000010
? short s = 2; 在计算机中是这样表示的：00000000 00000010
? int i = 2;在计算机中是这样表示的：00000000 00000000 00000000 00000010
? …
? 类型 占用字节数量(byte)
? byte 1
? short 2
? int 4
? long 8
? float 4
? double 8
? boolean 1 (1byte的1或0，00000001(true)或00000000(false))
? char 2
关于二进制：
1 2 3 4 5 6 7
1 10 11 100 101 110 111 ….
十进制转换成二进制
125 转换成二进制：
办法：除以2，然后余数逆序输出：1111101
二进制转换成十进制
2的2次方 2的1次方 2的0次方
1 1 1
4 2 1
14 + 12 + 1*1 = 7
? 2的2次方 2的1次方 2的0次方
? 1 0 1
? 4 2 1
? 14 + 02 + 1*1 = 5
byte类型的取值范围：
byte是 [-128 ~ 127] 共可以标识256个不同的数字。
byte类型的最大值是怎么计算出来的？
byte是1个字节，是8个比特位，所以byte可以存储的最大值是：01111111
注意：在计算机当中，一个二进制位最左边的是符号位，当为0时表示正数，
当为1时表示负数。所以byte类型最大值是：01111111
那么是不是2的7次方-1呢？
是不是：10000000（前边是一个二进制） - 1
byte类型最大值是：2的7次方 - 1.
有几个取值范围需要大家记住：
(1个字节)byte: [-128 ~ 127]
(2个字节)short:[-32768 ~ 32767] 可以表示65536个不同的数字
(4个字节)int: [-2147483648 ~ 2147483647]
(2个字节)char: [0~65535] 可以表示65536个不同的数字
short和char实际上容量相同，不过char可以表示更大的数字。
因为char表示的是文字，文件没有正负之分，所以char可以表示更大的数字。
对于8种基本数据类型来说：
其中byte,short,int,long,float,double,boolean，这7种类型计算机表示起来比较容易，因为他们都是数字。其中布尔类型只有两个值true和false，实际上true和false分别在C++中对应的是1和0，1为true，false为0。
对于char类型来说计算机表示起来比较麻烦，因为char对应的是文字，每一个国家的文字不一样，文字不能直接通过“自然算法”转换成二进制。这个时候怎么办？字符编码诞生了。
什么是字符编码？
字符编码是人为的定义的一套转换表。
在字符编码中规定了一系列的文字对应的二进制。
字符编码其实本质上就是一本字典，该字段中描述了文字与二进制之间的对照关系。
字符编码是人为规定的。（是某个计算机协会规定的。）
字符编码涉及到编码和解码两个过程，编码和解码的时候必须采用同一套字符编码方式，不然就会出现乱码。
关于字符编码的发展过程？
起初的时候计算机是不支持文字的，只支持科学计算。实际上计算机起初是为了
战争而开发的，计算导弹的轨道….
? 后来随着计算机的发展，计算机开始支持文字，最先支持的文字是英文，英文
? 对应的字符编码方式是：ASCII码。
? ASCII码采用1byte进行存储，因为英文字母是26个。（键盘上所有的键全部算上也
? 超不过256个。1byte可以表示256种不同的情况。所以英文本身在计算机方面就占有
? 优势。）
? ‘a’ –(采用ASCII码进行编码)-> 01100001
? 01100001 –(采用ASCII码进行解码)-> ‘a’
? 如果编码和解码采用的不是同一个编码方式，会出现乱码。
? ‘b’ —> 98
? ‘c’ —> 99…
? ‘a’ —> 97
? ‘A’ —> 65
? ‘B’ —> 66
? …
? ‘0’ —> 48 （这个’0’不是那个0，是文字’0’）
? ‘1’ —> 49
?
? 随着计算机语言的发展，后来国际标准组织制定了ISO-8859-1编码方式，
? 又称为latin-1编码方式，向上兼容ASCII码。但不支持中文。
? 后来发展到亚洲，才支持中文，日文，韩文….
? 中文这块的编码方式：GB2312<GBK<GB18030 （容量的关系）
? 以上编码方式是简体中文。
? 繁体中文：big5（台湾使用的是大五码。）
? 在java中，java语言为了支持全球所有的文字，采用了一种字符编码方式
? 叫做unicode编码。unicode编码统一了全球所有的文字，支持所有文字。
? 具体的实现包括：UTF-8 UTF-16 UTF-32….
需要记住：
ASCII（’a’是97 ‘A’是65 ‘0’是48…）
ISO-8859-1（latin-1）
GB2312
GBK
GB18030
Big5
unicode（utf8 utf16 utf32）
布尔型bollean：
1、在java语言中boolean类型只有两个值，没有其他值：
true和false。
不像C或者C++，C语言中1和0也可以表示布尔类型
2、boolean类型在实际开发中使用在哪里呢？
使用在逻辑判断当中，通常放到条件的位置上（充当条件）
字符型char：
1、char占用2个字节。
char可以存储1个汉字吗？
可以的，汉字占用2个字节，java中的char类型占用2个字节，正好。
2、char的取值范围：[0-65535]
3、char采用unicode编码方式。
4、char类型的字面量使用单引号括起来。
5、char可以存储一个汉字。
6、转义字符：
java语言中“\”负责转义。
\t 表示制表符tab
\n 表示制表符回车
System.out.println(); 换行
System.out.print(); 不换行
' 表示一个普通不能再普通的单引号字符 ‘（'联合起来表示一个普通的 ‘）
\ 表示一个“普通的反斜杠字符
// 双引号括起来的是字符串
System.out.println(“test”);
// 希望输出的结果是：”test”
// 错误: 需要’)’
//System.out.println(“”test””);
System.out.println(““test””); //内部的双引号我用中文的行吗？可以。
7、整数能否直接赋值给char
char x = 97;
这个java语句是允许的，并且输出的结果是’a’
经过这个测试得出两个结论：
- 当一个整数赋值给char类型变量的时候，会自动转换成char字符型，最终的结果是一个字符。
- 当一个整数没有超出byte short char的取值范围的时候，这个整数可直接赋值给byte short char类型的变量。
浮点型float/double:
浮点型包括：
float 4个字节
double 8个字节
float是单精度
double是双精度
double更精确
比如说：
10.0 / 3 如果采用float来存储的话结果可能是：3.33333
10.0 / 3 如果采用double来存储的话结果可能是：3.3333333333333
但是需要注意的是，如果用在银行方面或者说使用在财务方面，double
也是远远不够的，在java中提供了一种精度更高的类型，这种类型专门
使用在财务软件方面：java.math.BigDecimal （不是基本数据类型，属于
引用数据类型。）
float和double存储数据的时候都是存储的近似值。
因为现实世界中有这种无线循环的数据，例如：3.3333333333333….
数据实际上是无限循环，但是计算机的内存有限，用一个有限的资源
表示无限的数据，只能存储近似值。
long类型占用8个字节。
float类型占用4个字节。
注意：任意一个浮点型都比整数型空间大。
float容量 > long容量。
java中规定，任何一个浮点型数据默认被当做double来处理。
如果想让这个浮点型字面量被当做float类型来处理，那么
请在字面量后面添加F/f。
1.0 那么1.0默认被当做double类型处理。
1.0F 这才是float类型。（1.0f）
整型byte/short/int/long：
整数型在java语言中共4种类型：
byte 1个字节 最大值127
short 2个字节 最大值32767
int 4个字节 2147483647是int最大值，超了这个范围可以使用long类型。
long 8个字节
1个字节 = 8个二进制位
1byte = 8bit
对于以上的四个类型来说，最常用的是int。
在java语言中整数型字面量有4种表示形式：
十进制：最常用的。
二进制
八进制
十六进制
在java中有一条非常重要的结论，必须记住：
在任何情况下，整数型的“字面量/数据”默认被当做int类型处理。
如果希望该“整数型字面量”被当做long类型来处理，需要在“字面量”后面添加L/l
建议使用大写L，因为小写l和1傻傻分不清。
1 | // 错误: 整数太大 |
在java中，整数型字面量一上来编译器就会将它看做int类型
而2147483648已经超出了int的范围，所以在没有赋值之前就出错了。
记住，不是e放不下2147483648，e是long类型，完全可以容纳2147483648
只不过2147483648本身已经超出了int范围。
解决问题：
long e = 2147483648L;
- 小容量可以直接赋值给大容量，称为自动类型转换。
- 大容量不能直接赋值给小容量，需要使用强制类型转换符进行强转。
但需要注意的是：
加强制类型转换符之后，虽然编译通过了，但是运行的时候可能会损失精度。
大容量转换成小容量，要想编译通过，必须加强制类型转换符，进行强制类型转换。
但是要记住：编译虽然过了，但是运行时可能损失精度。
java中有一个语法规则：
当这个整数型字面量没有超出byte的取值范围，那么这个整数型字面量可以直接赋值给byte类型的变量。
当整数型字面量没有超出short类型取值范围的时候，该字面量可以直接赋值给short。
这种语法机制是为了方便写代码，而存在的。
byte、char、short做混合运算的时候，各自先转换成int再做运算。
计算机的数据存储方式：
- 计算机在任何情况下都只能识别二进制
- 计算机在底层存储数据的时候，一律存储的是“二进制的补码形式”
计算机采用补码形式存储数据的原因是：补码形式效率最高。 - 补码：
实际上是这样的，二进制有：原码 反码 补码 - 记住：
对于一个正数来说：二进制原码、反码、补码是同一个，完全相同。 - 分析 byte b = (byte)150; //-106
这个b是多少？
int类型的4个字节的150的二进制码是什么？
00000000 00000000 00000000 10010110
将以上的int类型强制类型转为1个字节的byte，最终在计算机中的二进制码是：
10010110
千万要注意：计算机永远存储的都是二进制补码形式。也就是说上面
10010110 这个是一个二进制补码形式，你可以采用逆推导的方式推算出
这个二进制补码对应的原码是啥！！！！！！
10010110 —> 二进制补码形式
10010101 —> 二进制反码形式
11101010 —> 二进制原码形式
计算机数据的自动转换：
在类型转换的时候需要遵循规则
- 八种基本数据类型中，除 boolean 类型不能转换，剩下七种类型之间都可以进行转换；
- 如果整数型字面量没有超出 byte,short,char 的取值范围，可以直接将其赋值给byte,short,char 类型的变 量；
- 小容量向大容量转换称为自动类型转换，容量从小到大的排序为：
byte < short(char) < int < long < float < double，其中 short和 char
都占用两个字节，但是char 可以表示更大的正整数； - 大容量转换成小容量，称为强制类型转换，编写时必须添加“强制类型转换符”，但运行时可能出现精度损失，谨慎使用；
- byte,short,char 类型混合运算时，先各自转换成 int 类型再做运算；
- 多种数据类型混合运算，各自先转换成容量最大的那一种再做运算；
多种数据类型做混合运算的时候，最终的结果类型是“最大容量”对应的类型。
boolean < (char/short/byte)int < float < double
char+short+byte 这个除外。
因为char + short + byte混合运算的时候，会各自先转换成int再做运算。
java中规定，int类型和int类型最终的结果还是int类型(最终取整)。
6、java中的输入和输出：
输出信息到控制台：
System.out.println(…);
在java中怎么接收键盘的输入呢？
前提：java.util.Scanner s = new java.util.Scanner(System.in);
接收一个整数：
int num = s.nextInt();
接收一个字符串：
String str = s.next();
import java.util.Scanner;
Scanner s = new Scanner(System.in);
7、运算符：
1、算术运算符：
+ : 求和
- : 相减
* : 乘积
/ : 商
% : 求余数（求模）
++ : 自加1
-- : 自减1
对于++运算符来说：
可以出现在变量前，也可以出现在变量后。
不管出现在变量前还是后，总之++执行结束之后，变量的值一定会自加1。
* ++出现在变量后：
语法：当++出现在变量后，会先做赋值运算，再自加1
* ++出现在变量前：
语法：当++出现在变量前的时候，会先进行自加1的运算，然后再赋值。
2、关系运算符：
> 大于
>= 大于等于
< 小于
<= 小于等于
== 等于
!= 不等于
一定要记住一个规则：
所有的关系运算符的运算结果都是布尔类型，
不是true就是false，不可能是其他值。
在java语言中:
= ： 赋值运算符
== ：关系运算符，判断是否相等。
注意：关系运算符中如果有两个符号的话，两个符号之间不能有空格。
>= 这是对的, > = 这是不对的。
== 这是对的，= = 这是不对的。
3、逻辑运算符：
& 逻辑与（可以翻译成并且）
| 逻辑或（可以翻译成或者）
! 逻辑非（取反）
&& 短路与
|| 短路或
用普通话描述的话：100 大于 99 并且 100 大于 98 ，有道理
用代码描述的话：100 > 99 & 100 > 98 --> true
true & true --> true
非常重要：
逻辑运算符两边要求都是布尔类型，并且最终的运算结果也是布尔类型。
这是逻辑运算符的特点。
100 & true 不行，语法错误。
100 & 200 不行，没有这种语法。
true & false 这样可以。
100 > 90 & 100 > 101 --> false
& 两边都是true，结果才是true
| 有一边是true，结果就是true
关于短路与 &&，短路或 ||（以短路与为例）
* 短路与&& 和 逻辑与& 的区别
首先这两个运算符的运算结果没有任何区别，完全相同。
只不过“短路与&&”会发生短路现象。
* 短路现象
右边表达式不执行，这种现象叫做短路现象。
* 什么时候使用&&，什么时候使用& ？
从效率方面来说，&&比&的效率高一些。
因为逻辑与&不管第一个表达式结果是什么，第二个表达式一定会执行。(&&更智能)
以后的开发中，短路与&&和逻辑与还是需要同时并存的。
大部分情况下都建议使用短路与&&
只有当既需要左边表达式执行，又需要右边表达式执行的时候，才会
选择逻辑与&。
* 什么时候会发生短路？
int x = 10;
int y = 11;
// 逻辑与&什么时候结果为true（两边都是true，结果才是true）
// 左边的 x>y 表达式结果已经是false了，其实整个表达式的结
// 果已经确定是false了，按道理来说右边的表达式不应该执行。
System.out.println(x > y & x > y++);
// 通过这个测试得出：x > y++ 这个表达式执行了。
System.out.println(y); // 12
//测试短路与&&
int m = 10;
int n = 11;
// 使用短路与&&的时候，当左边的表达式为false的时候，右边的表达式不执行
// 这种现象被称为短路。
System.out.println(m > n && m > n++);
System.out.println(n); // 11
什么时候发生短路或现象(|| 短路或)？
// “或”的时候只要有一边是true，结果就是true。
// 所以，当左边的表达式结果是true的时候，右边的表达式不需要执行，此时会短路。
4、赋值运算符：
1、赋值运算符包括“基本赋值运算符”和“扩展赋值运算符”：基本的、扩展的。
2、基本赋值运算符
=
3、扩展的赋值运算符
+=
-=
*=
/=
%=
注意：扩展赋值运算符在编写的时候，两个符号之间不能有空格。
+ = 错误的。
+= 正确的。
4、很重要的语法机制：
使用扩展赋值运算符的时候，永远都不会改变运算结果类型。
byte x = 100;
x += 1;
x自诞生以来是byte类型，那么x变量的类型永远都是byte。不会变。
不管后面是多大的数字。
5、赋值运算符“=”右边优先级比较高，先执行右边的表达式
然后将表达式执行结束的结果放到左边的“盒子”当中。（赋值）
6、研究：
// i += 10 和 i = i + 10 真的是完全一样吗？
// 答案：不一样，只能说相似，其实本质上并不是完全相同。
byte x = 100; // 100没有超出byte类型取值范围，可以直接赋值
System.out.println(x); // 100
// 分析：这个代码是否能够编译通过？
// 错误: 不兼容的类型: 从int转换到byte可能会有损失
//x = x + 1; // 编译器检测到x + 1是int类型，int类型可以直接赋值给byte类型的变量x吗？
// 使用扩展赋值运算符可以吗？
// 可以的，所以得出结论：x += 1 和 x = x + 1不一样。
// 其实 x += 1 等同于：x = (byte)(x + 1);
x += 1;
System.out.println(x); // 101
// 早就超出byte的取值范围了。
x += 199; // x = (byte)(x + 199);
System.out.println(x); // 44 （当然会自动损失精度了。）
5、条件运算符（三目运算符）：
语法格式：
布尔表达式 ? 表达式1 : 表达式2
执行原理
布尔表达式的结果为true时，表达式1的执行结果作为整个表达式的结果。
布尔表达式的结果为false时，表达式2的执行结果作为整个表达式的结果。
6、+ 运算符：
1、+ 运算符在java语言中有两个作用：
作用1：求和
作用2：字符串拼接
2、什么时候求和？什么时候进行字符串的拼接呢？
当 + 运算符两边都是数字类型的时候，求和。
当 + 运算符两边的“任意一边”是字符串类型，那么这个+会进行字符串拼接操作。
3、一定要记住：字符串拼接完之后的结果还是一个字符串。
4、示例：
int a = 100;
int b = 200;
// 注意：当一个表达式当中有多个加号的时候
// 遵循“自左向右”的顺序依次执行。（除非额外添加了小括号，小括号的优先级高）
// 第一个+先运算，由于第一个+左右两边都是数字，所以会进行求和。
// 求和之后结果是300，代码就变成了：System.out.println(300 + "110");
// 那么这个时候，由于+的右边是字符串"110"，所以此时的+会进行字符串拼接。
System.out.println(a + b + "110"); // 最后一定是一个字符串："300110"
// 先执行小括号当中的程序：b + "110"，这里的+会进行字符串的拼接，
// 拼接之后的结果是："200110"，这个结果是一个字符串类型。
// 代码就变成了：System.out.println(a + "200110");
// 这个时候的+还是进行字符串的拼接。最终结果是："100200110"
System.out.println(a + (b + "110"));
// 在控制台上输出"100+200=300"
System.out.println(a + "+" + b + "=" + c);
在java语言中定义字符串类型的变量
// String是字符串类型，并且String类型不属于基本数据类型范畴，属于引用类型。
// name是变量名，只要是合法的标识符就行。
// "jack" 是一个字符串型字面量。
String name = "jack";
// 口诀：加一个双引号""，然后双引号之间加两个加号："++"，然后两个加号中间加变量名："+name+"
System.out.println("登录成功欢迎"+name+"回来");8、控制语句：
选择结构
- if,if..else
if语句的语法结构以及运行原理
if语句是分支语句，也可以叫做条件语句。
if语句的语法格式：
第一种写法：
int a = 100;
int b = 200;
if(布尔表达式){
java语句;
java语句;
}
这里的一个大括号{} 叫做一个分支。
if 这个单词翻译为如果，所以又叫做条件语句。
该语法的执行原理是：
如果布尔表达式的结果是true，则执行大括
号中的程序，否则大括号中代码不执行。
第二种写法：
if(布尔表达式){ // 分支1
java语句;
}else{ // 分支2
java语句;
}
执行原理：
如果布尔表达式的结果是true，则执行分支1，分支2不执行。
如果布尔表达式的结果是false， 分支1不执行，执行分支2.
以上的这个语句可以保证一定会有一个分支执行。
else表示其它。
第三种写法：
if(布尔表达式1){ // 分支1
java语句;
}else if(布尔表达式2){ // 分支2
java语句;
}else if(布尔表达式3){
java语句;
}else if(布尔表达式4){
java语句;
}....
以上if语句的执行原理：
先判断“布尔表达式1”，如果“布尔表达式1”为true，则执行分支1，
然后if语句结束了。
当“布尔表达式1”结果是false，那么会继续判断布尔表达式2的结果，
如果布尔表达式2的结果是true，则执行分支2，然后整个if就结束了。
从上往下依次判断，主要看第一个true发生在哪个分支上。
第一个true对应的分支执行，只要一个分支执行，整个if结束。
第四种写法：
if(布尔表达式1){ // 分支1
java语句;
}else if(布尔表达式2){ // 分支2
java语句;
}else if(布尔表达式3){
java语句;
}else if(布尔表达式4){
java语句;
}else{
java语句; // 以上条件没有一个成立的。这个else就执行了。
}?
注意：
1、对于if语句来说，在任何情况下只能有1个分支执行，不可能
存在2个或者更多个分支执行。if语句中只要有1个分支执行了，
整个if语句就结束了。（对于1个完整的if语句来说的。）
2、以上4种语法机制中，凡是带有else分支的，一定可以保证会有
一个分支执行。以上4种当中，第一种和第三种没有else分支，这样
的语句可能会导致最后一个分支都不执行。第二种和第四种肯定会有
1个分支执行。
3、当分支当中“java语句;”只有1条，那么大括号{}可以省略，但为了
可读性，最好不要省略。
4、控制语句和控制语句之间是可以嵌套的，但是嵌套的时候大家最好
一个语句一个语句进行分析，不要冗杂在一起分析。
if(true){
//窍门：分析外面if语句的时候，里面的这个if语句可以看做是普通的一堆java代码。
if(true){
if(false){
}else{
....最终走这里了。
}
}else{
}
}else{
}
if(){
// 窍门：分析外面if时，里面的for循环当做普通java代码来看。
for(){
if(){
for(){
}
}
}
}else{
while(){
if(){
for(){
}
}
}
}
示例1：
业务要求：
1、从键盘上接收一个人的年龄。
2、年龄要求为[0-150]，其它值表示非法，需要提示非法信息。
3、根据人的年龄来动态的判断这个人属于生命的哪个阶段？
[0-5] 婴幼儿
[6-10] 少儿
[11-18] 少年
[19-35] 青年
[36-55] 中年
[56-150] 老年
4、请使用if语句完成以上的业务逻辑。
String str = "老年"; // 字符串变量默认值是“老年”
if(age < 0 || age > 150){
System.out.println("对不起，年龄值不合法");
//return;
} else if(age <= 5){
str = "婴幼儿";
} else if(age <= 10){
str = "少儿";
} else if(age <= 18){
str = "少年";
} else if(age <= 35){
str = "青年";
} else if(age <= 55){
str = "中年";
}
System.out.println(str);
示例2：
业务要求：
1、系统接收一个学生的考试成绩，根据考试成绩输出成绩的等级。
2、等级：
优：[90~100]
良：[80~90)
中：[70-80)
及格：[60~70)
不及格：[0-60)
3、要求成绩是一个合法的数字，成绩必须在[0-100]之间，成绩可能带有小数。
java.util.Scanner s = new java.util.Scanner(System.in);
System.out.print("请输入您的考试成绩：");
// 考试成绩带有小数
double score = s.nextDouble();
// 判断考试成绩
String str = "优";
if(score < 0 || score > 100){
str = "成绩不合法!!!";
}else if(score < 60){
str = "不及格";
}else if(score < 70){
str = "及格";
}else if(score < 80){
str = "中";
}else if(score < 90){
str = "良";
}
System.out.println(str);
- switch
switch语句：
1、switch语句也是选择语句，也可以叫做分支语句。
2、switch语句的语法格式
switch(值){
case 值1:
java语句;
java语句;...
break;
case 值2:
java语句;
java语句;...
break;
case 值3:
java语句;
java语句;...
break;
default:
java语句;
}
以上是一个完整的switch语句：
其中：break;语句不是必须的。default分支也不是必须的。
switch语句支持的值:
支持int类型以及String类型。
但一定要注意JDK的版本，JDK8之前不支持String类型，只支持int。
在JDK8之后，switch语句开始支持字符串String类型。
switch语句本质上是只支持int和String，但是byte,short,char也可以
使用在switch语句当中，因为byte short char可以进行自动类型转换。
switch语句中“值”与“值1”、“值2”比较的时候会使用“==”进行比较。
3、switch语句的执行原理
拿“值”与“值1”进行比较，如果相同，则执行该分支中的java语句，
然后遇到"break;"语句，switch语句就结束了。
如果“值”与“值1”不相等，会继续拿“值”与“值2”进行比较，如果相同，
则执行该分支中的java语句，然后遇到break;语句，switch结束。
注意：如果分支执行了，但是分支最后没有“break;”，此时会发生case
穿透现象。
所有的case都没有匹配成功，那么最后default分支会执行。
switch中的case可以合并。
示例：
1、系统接收一个学生的考试成绩，根据考试成绩输出成绩的等级。
2、等级：
优：[90~100]
良：[80~90)
中：[70-80)
及格：[60~70)
不及格：[0-60)
3、要求成绩是一个合法的数字，成绩必须在[0-100]之间，成绩可能带有小数。
必须使用switch语句来完成。
// 提示用户输入学生成绩
java.util.Scanner s = new java.util.Scanner(System.in);
System.out.print("请输入学生成绩：");
double score = s.nextDouble();
//System.out.println(score);
if(score < 0 || score > 100){
System.out.println("您输入的学生成绩不合法，再见！");
return;
}
// 程序能够执行到这里说明成绩一定是合法的。
// grade的值可能是：0 1 2 3 4 5 6 7 8 9 10
// 0 1 2 3 4 5 不及格
// 6 及格
// 7 中
// 8 良
// 9 10 优
int grade = (int)(score / 10); // 95.5/10结果9.55，强转为int结果是9
String str = "不及格";
switch(grade){
case 10: case 9:
str = "优";
break;
case 8:
str = "良";
break;
case 7:
str = "中";
break;
case 6:
str = "及格";
}
System.out.println("该学生的成绩等级为：" + str);
* 循环结构（循环语句的出现就是为了解决代码的复用性）
- for
1、for循环的语法机制以及运行原理：
语法机制：
for(初始化表达式; 条件表达式; 更新表达式){
循环体; // 循环体由java语句构成
java语句;
java语句;
java语句;
java语句;
....
}
注意：
第一：初始化表达式最先执行，并且在整个循环中只执行一次。
第二：条件表达式结果必须是一个布尔类型，也就是：true或false
执行原理：
先执行初始化表达式，并且初始化表达式只执行1次。
然后判断条件表达式的结果，如果条件表达式结果为true，
则执行循环体。
循环体结束之后，执行更新表达式。
更新完之后，再判断条件表达式的结果，
如果还是true，继续执行循环体。
直到更新表达式执行结束之后，再次判断条件时，条件为false，
for循环终止。
更新表达式的作用是：控制循环的次数，换句话说，更新表达式会更新
某个变量的值，这样条件表达式的结果才有可能从true变成false，从而
终止for循环的执行，如果确实更新表达式，很有可能会导致死循环。
2、嵌套使用：
* 所有合法的“控制语句”都可以嵌套使用。
* for循环嵌套一个for循环执行原理：
for(){
//在分析外层for循环的时候，把里面的for就当做一段普通的java语句/代码.
for(){}
}
示例：
九九乘法表
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
....
......
1*9=9 2*9=18.............................9*9=81
以上九九乘法表的特点：
第一个特点：共9行。
第二个特点：第1行1个。第2行2个。第n行n个。
// 9行，循环9次。
for(int i = 1; i <= 9; i++){ // 纵向循环
//System.out.println(i); // i是行号（1~9）
// 负责输出一行的。（内部for循环负责将一行上的全部输出。）
for(int j = 1; j <= i; j++){ // i是行号
System.out.print(j + "*" + i + "=" + i * j + " ");
}
// 换行
System.out.println();
}
- while
1、while循环的语法机制以及执行原理
语法机制：
while(布尔表达式){
循环体;
}
执行原理：
判断布尔表达式的结果，如果为true就执行循环体，
循环体结束之后，再次判断布尔表达式的结果，如果
还是true，继续执行循环体，直到布尔表达式结果
为false，while循环结束。
2、while循环有没有可能循环次数为0次？（与do...while区分开）
可能。
while循环的循环次数是：0~n次。
- do...while()
do..while循环语句的执行原理以及语法机制：
语法机制：
do {
循环体;
}while(布尔表达式);
注意：do..while循环最后的时候别漏掉“分号”
执行原理：
先执行循环体当中的代码，执行一次循环体之后，
判断布尔表达式的结果，如果为true，则继续执行
循环体，如果为false循环结束。
对于do..while循环来说，循环体至少执行1次。循环体的执行次数是：1~n次。
对于while循环来说，循环体执行次数是：0~n次。
* 控制循环的语句
- break
1、break;语句比较特殊，特殊在：break语句是一个单词成为一个完整的java语句。
另外：continue也是这样，他俩都是一个单词成为一条语句。
2、break 翻译为折断、弄断。
3、break;语句可以用在哪里呢？
用在两个地方，其它位置不行
第一个位置：switch语句当中，用来终止switch语句的执行。
用在switch语句当中，防止case穿透现象，用来终止switch。
第二个位置：break;语句用在循环语句当中，用来终止循环的执行。
用在for当中
用在while当中
用在do....while..当中。
4、break;语句的执行并不会让整个方法结束，break;语句主要是用来终止离它最近
的那个循环语句。
5、怎么用break;语句终止指定的循环呢？（很少用）
第一步：你需要给循环起一个名字，例如：
a: for(){
b:for(){
}
}
第二步：终止：break a;
- continue
1、continue翻译为：继续
2、continue语句和break语句要对比着学习
3、continue语句的作用是：
终止当前"本次"循环，直接进入下一次循环继续执行。
for(){
if(){ // 当这个条件成立时，执行continue语句
continue; //当这个continue语句执行时，continue下面的代码不执行，直接进入下一次循环执行。
}
// 以上的continue一旦执行，以下代码不执行，直接执行更新表达式。
code1;
code2;
code3;
code4;
}
4、continue语句后面也可以指定循环
a:for(;;更新表达式1){
b:for(;;更新表达式2){
if(){
continue a;
}
code1;
code2;
code3;
}
}
break;语句和return;语句的区别：
不是一个级别。
break;用来终止switch和离它最近的循环。
return;用来终止离它最近的一个方法。