需要掌握的内容：
-
标识符
-
关键字
-
字面值
-
变量
-
数据类型
-
运算符：
- 算术运算符
- 关系运算符
- 逻辑运算符
- 赋值类运算符
- 字符串连接运算符
- 三元运算符
- 赋值运算符
- 字符串连接运算符
-
控制语句
- 选择结构
- 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个)的大致含义(运用记忆)：
关键字 含义
abstract 表明类或者成员方法具有抽象属性
assert 用来进行程序调试
boolean 基本数据类型之一，布尔类型
break 提前跳出一个块
byte 基本数据类型之一，字节类型
case 用在switch语句之中，表示其中的一个分支
catch 用在异常处理中，用来捕捉异常
char 基本数据类型之一，字符类型
class 类
const 保留关键字，没有具体含义
continue 回到一个块的开始处
default 默认，例如，用在switch语句中，表明一个默认的分支
do 用在do-while循环结构中
double 基本数据类型之一，双精度浮点数类型
else 用在条件语句中，表明当条件不成立时的分支
enum 枚举
extends 表明一个类型是另一个类型的子类型，这里常见的类型有类和接口
final 用来说明最终属性，表明一个类不能派生出子类，或者成员方法不能被覆盖，或者成员 域的值不能被改变，用来定义常量
finally 用于处理异常情况，用来声明一个基本肯定会被执行到的语句块
float 基本数据类型之一，单精度浮点数类型
for 一种循环结构的引导词
goto 保留关键字，没有具体含义
if 条件语句的引导词
implements 表明一个类实现了给定的接口
import 表明要访问指定的类或包
instance of 用来测试一个对象是否是指定类型的实例对象
int 基本数据类型之一，整数类型
interface 接口
long 基本数据类型之一，长整数类型
native 用来声明一个方法是由与计算机相关的语言(如C/C++/FORTRAN语言)实现的
new 用来创建新实例对象
package 包
private 一种访问控制方式:私用模式
protected 一种访问控制方式:保护模式
public 一种访问控制方式:共用模式
return 从成员方法中返回数据
short 基本数据类型之一,短整数类型
static 表明具有静态属性
strictfp 用来声明FP_strict(单精度或双精度浮点数)表达式遵循IEEE 754算术规范
super 表明当前对象的父类型的引用或者父类型的构造方法
switch 分支语句结构的引导词
synchronized 表明一段代码需要同步执行
this 指向当前实例对象的引用
throw 抛出一个异常
throws 声明在当前定义的成员方法中所有需要抛出的异常
transient 声明不用序列化的成员域
try 尝试一个可能抛出异常的程序块
void 声明当前成员方法没有返回值
volatile 表明两个或者多个变量必须同步地发生变化
while 用在循环结构中
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傻傻分不清。
// 错误: 整数太大
long e = 2147483648;
在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);
6、运算符：
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也是这样，他俩都是一个单词成为一条语句。
break 翻译为折断、弄断。
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;
}
continue语句后面也可以指定循环
a:for(;;更新表达式1){
b:for(;;更新表达式2){
if(){
continue a;
}
code1;
code2;
code3;
}
}
break;语句和return;语句的区别：
不是一个级别。
break;用来终止switch和离它最近的循环。
return;用来终止离它最近的一个方法。
6348
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
