1.计算机的常识：
计算机之父 -- 冯.诺依曼
计算机最大的奖项 -- 图灵奖，没有诺贝尔奖
Java之父 -- 詹姆斯.高斯林
Java1.8 / 8.0
计算机是由硬件和软件组成。硬件就是各种计算机的设备，软件是控制设备的代码。常见的计算机硬件包括： CPU(中央处理器)、内存、硬盘、主板、输入输出设备(键盘、鼠标、显示器)、机箱和电源等。CPU主要负责各种运算，是计算机的大脑；内存和硬盘都是存储设备，数据要从内存/硬盘中存取。主板是连接各种设备的，各种设备都需要接入主板。硬件曾经是计算机的绝对主流，硬件公司包括：英特尔、IBM早期等。硬件的价格非常的透明，全球化，因此硬件的赚钱很难。软件包括：系统软件和应用软件。
系统软件就是操作系统，应用软件就是除了操作系统以外的软件。操作系统包括：Windows系统(Win30/Win95/Win98/Windows2000/Win XP/Server2003
/Vista/Win7/Win8/Win10)、Unix系统(从70年开始，到今天)、类Unix系统(Linux)、其它系统，包括手机的安卓也是Linux系统之一。手机的操作系统：塞班、IOS、安卓、Windows phone等。应用软件就是其它的软件，比如：photoshop、word、excel等。我们程序员就是做软件开发的。
2.Java分为三个版本：
JavaSE -- Java标准版，Java核心的类库和基础环境都需要JAVASE
JavaEE -- Java企业版，Java开发的主流。
JavaME -- Java微缩版，目前被安卓替代。
计算机由软件和硬件组成，其中，硬件就是各种设备，包括：CPU(中央处理器)、内存、硬盘、主板、输入输出设备(键盘/鼠标/显示器)、机箱和电源等。软件包括：系统软件和应用软件。系统软件就是操作系统，应用软件就是其它软件的统称。操作系统分为：内核和外壳Shell。
主流的操作系统： Windows系列、Unix系列、类Unix(Linux)。
手机的操作系统： 塞班、安卓、IOS、Windows Phone。
3.Java的技术术语：
JDK -- Java开发工具包，Java开发必需下载安装jdk。
JRE -- Java运行环境，安装JDK后就可以有运行环境(需要配置环境变量)。
JVM -- Java虚拟机，Java的程序必须运行在Java虚拟机中。安装JDK后即可。
API -- 应用程序接口，Java的类库的说明文档。(查手册，写代码)
IDE -- 集成开发环境，就是大型的开发工具。
5. Java编程的步骤：
5.1 准备环境。
5.1.1 下载安装JDK，注意版本/操作系统/32位或64位系统都需要对应(绿色版也可以)。
5.1.2 配置环境变量。有些操作系统可以自动配置，但大多数还是需要配置。需要配置Path和CLASSPATH。
Path就是系统路径，默认情况下，命令都是需要带着目录一起才能被执行的；放入Path的目录下的命令可以去掉目录直接执行。
CLASSPATH就是类的路径，指明类在哪里。一般配置 . 就可以了。点代表当前目录。
右键点击 计算机或我的电脑，选 属性，点 高级系统设置或高级，点 环境变量 按钮。
在系统变量中 查找Path，然后双击Path或点 编辑 ，然后在变量值的最前面加上JDK安装目录的bin目录，我的是：C:\Program Files\Java\jdk1.7.0_09\bin; 然后用分号隔开。注意不要删除原来的值，然后一路确定就可以了。
CLASSPATH直接点新建，然后在变量名的位置敲CLASSPATH，在变量值的位置写一个 . 即可。
证明方式：启动DOS窗口(视窗键+R后敲cmd回车)，输入javac即可。
5.2 写代码，编译代码，运行代码。
如果使用记事本，需要去掉文件夹和搜索选项中的查看，去掉其中 隐藏已知文件类型的扩展名的勾选，否则只能建文本文件.txt。
5. 2.1 右键点新建 选文本文档，修改文件名为： xxx.java (Hello.java) 弹出确认窗口选是。
5. 2.2 用记事本打开Hello.java，然后写以下的代码：
public class Hello{
public static void main(String[] args){
System.out.println("Hello Java");
}
}
保存退出后，源代码完成了。
5.2.3 编译并运行代码。
cd 源文件所在的目录 (如果不在一个盘，先用E： D： 切换盘符)
javac Hello.java (编译，并生成字节码文件 .class)
java Hello (运行)
注: Java语言区分大小写。
main()方式是Java程序的主方法，Java程序只会执行main()。
JAVA语言可以实现跨平台，跨平台就是同样的class文件，Windows和Linux都可以识别。跨平台依赖JVM，不同的操作系统有不同的JVM，然后JVM负责把class解释成不同操作系统能识别的机器指令。
6.常见快捷键：
ctrl+C -- 复制文件/文本 还可以中止一些程序，比如死循环。
ctrl+V -- 粘贴文件/文本
ctrl+A -- 全选文件/文本
ctrl+S -- 保存文件
ctrl+X -- 剪切文件/文本
ctrl+Z -- 撤销一步(部分软件可以多步撤销)
ctrl+F -- 查找
ctrl+O -- 打开文件
ctrl+P -- 打印文件
视窗+R -- 运行窗口
视窗+E -- 资源管理器
视窗+L -- 锁定屏幕
视窗+D -- 回到桌面
alt+F4 -- 关闭
alt+tab -- 切换窗口
7.变量和注释(重点)
7.1 基本概念
计算机的主要硬件：内存、硬盘等。
变量本质上就是指系统为程序分配的一块存储单元，而且该存储单元中的数据是可变的
根据存储数据内容的不同，使用数据类型加以描述，为了后续访问该内存空间方便，则需要给该内存区域指定一个名字，叫做变量名。
7.2 声明方式
数据类型 变量名 [= 初始值]; - []括起来的内容表示可以省略。
- 其中;不可以省略的，使用;表示这条语句结束。
如：
int age = 18; - 推荐该方式，使用0替代之。
| | |
数据类型 变量名 初始值
int age;
7.3 注意事项
(1)使用变量之前必须要声明，也就是指定变量的数据类型。
(2)使用变量之前必须要初始化，也就是指定变量的初始值。
(3)每个变量只能声明一次，并且拥有自己独立的作用域和生命周期。
扩展：
在方法体中声明的变量叫做局部变量，该变量的作用域和生命周期就是从声明开始，一直到方法体结束为止。
7.4 标识符(变量名)的命名规则
(1)必须由字母、数字、下划线以及美元$组成，其中数字不能开头。
如：a-z A - Z 0 - 9 _ $ age age2
(2)区分大小写，也就是说大写字母和小写字母代表不同的标识符。
如：monday Monday 代表不同的标识符
(3)不能是java语言中关键字/保留字，如:public class static等。
(4)长度没有明确的规定，但不宜过长。
(5)可以是汉字，但不推荐使用。
(6)尽量做到见名知意。
扩展：
标识符不仅可以给变量命名，还可以给类/属性/方法/包进行命名。
7.5 注释
在java语言中主要有以下三种形式的注释：
// 表示单行注释，也就是从//开始一直到这行结束，所有内容都是注释。
/* */ 表示多行注释，也就是从/*开始一直到*/结束，中间的内容都是注释。
/** */ 表示多行注释，主要用于使用工具进行提取(了解)。
注意：
其中/**/表示的多行注释是不允许嵌套的。
8.数据类型
8.1 基本概念
在java语言中数据类型主要分为两大类：基本数据类型 和 引用数据类型。
其中基本数据类型主要有(8种)：
byte/short/int/long - 用于描述整数数据的，如：66。
float/double - 用于描述小数数据的，如：3.14。
boolean - 用于描述真假信息的，如：是否成年。
char - 用于描述字符信息的，如：'a'。
其中引用数据类型主要有：
数组、类、接口、枚举等。
要求大家掌握的类型：
int、double、boolean。
8.2 常用的进制
目前主流的进制有：十进制、二进制、八进制以及十六进制。
其中十进制表示逢十进1，表示十进制的数字范围是：0 ~ 9，而每个数字对应的权重都是10的次方，从右向左依次为：10^0、10^1、10^2、... ...
其中二进制表示逢二进1，表示二进制的数字范围是：0 ~ 1，而每个数字对应的权重都是2的次方，从右向左依次为：2^0、2^1、2^2、... ...
其中八进制表示逢八进1，表示八进制的数字范围是：0 ~ 7，而每个数字对应的权重都是8的次方，从右向左依次为：8^0、8^1、8^2、... ...
其中十六进制表示逢十六进1，表示十六进制的数字范围是：0 ~ 9 a ~ f，而每个数字对应的权重都是16的次方，从右向左依次为：16^0、16^1、16^2、... ...
在计算机的底层只识别二进制，而数据有正负数之分，因此二进制中的最高位(最左边)用于表示符号位，其中0作为符号位表示非负数，其中1作为符号位表示负数。
8.3 进制之间的转换
(1)十进制和二进制之间的转换
a.正十进制转换为二进制的方式
1)除2取余法，让十进制整数不断地除以2取出余数并记录，当商为0时停止运算，将
所有的余数反向排列(从下到上)。
2)拆分法，将十进制整数拆分为多个二进制权重的和，对于出现的权重下面写上1，
对于没有出现的权重下面写上0即可(重点)。
如：
45 => 0010 1101
45 => 32 + 8 + 4 + 1
128 64 32 16 8 4 2 1
0 0 1 0 1 1 0 1 => 0010 1101
b.正二进制转换为十进制的方式
1)加权法，让二进制的每一位数字乘以当前位的权重，然后累加起来即可(重点)。
如：
0010 1101 => 1*2^0 + 0*2^1 + 1*2^2 + 1*2^3 + 0*2^4 + 1*2^5 + 0*2^6 + 0*2^7
=> 1 + 0 + 4 + 8 + 0 + 32 + 0 + 0
=> 45
c.负十进制转换为二进制的方式
1)将负十进制的绝对值拆分为二进制，按位取反再加1(重点)。
如：
-45的绝对值拆分为二进制：0010 1101
按位取反：1101 0010
再加1：1101 0011
1101 0010
+ 1
---------------------
1101 0011
45:0010 1101
-45:1101 0011 +
---------------------
1 0000 0000 最高位1就会溢出，通俗来说就是丢失了，8个0的结果是0.
-1转换为二进制：1111 1111
d.负二进制转换为十进制的方式
1)按位取反再加1，然后合并成十进制整数，最后添加负号(重点)。
如：
1101 0011 进行按位取反：0010 1100
再加1：0010 1101
转换为十进制：45
添加负号：-45
练习：
35和68转换为二进制
35 => 0010 0011
68 => 0100 0100
-35和-68转换为二进制
-35 => 1101 1101
-68 => 1011 1100
0101 1101转换为十进制(正) => 93
0010 1110转换为十进制(正) => 46
1010 1110转换为十进制(负) => -82
1101 0101转换为十进制(负) => -43
(2)二进制和八进制之间的转换(了解)
a.二进制转换为八进制的方式
1)将每3位二进制合并为一位八进制，前面加0即可。
如：
000 = 0
111 = 7
0101 0011 => 01 010 011 => 0123
b.八进制转换为二进制的方式
1)将每一位八进制拆分为3位二进制即可。
如：
073 => 111 011 => 11 1011
(3)二进制和十六进制之间的转换(了解)
a.二进制转换为十六进制的方式
1)将每4位二进制合并为1位十六进制,前面加0x即可。
如：
0000 = 0
1111 = 15
0101 0011 => 0x53
b.十六进制转换为二进制的方式
1)将每1位十六进制拆分为4位二进制组成即可。
如：
0xa5 => 1010 0101
科普：
1Tb = 1024Gb
1Gb = 1024Mb
1Mb = 1024Kb
1Kb = 1024byte(字节)
1byte = 8bit(二进制位)
8.4 单个字节(8位二进制位)表示的范围(重中之重)
在计算机的底层都是二进制形式的，使用符号位1代表负数，使用符号位0代表非负数，那么单个字节的表示范围如下：
非负数的表示范围是：0000 0000 ~ 0111 1111 => 0 ~ 127 => 0 ~ 2^7-1
0000 0000转换为十进制是：0
0111 1111转换为十进制是：127
负数的表示范围是：1000 0000 ~ 1111 1111 => -128 ~ -1 => -2^7 ~ -2^0
1000 0000转换为十进制是：-128
1111 1111转换为十进制是：-1
综上所述：
对于单个字节来说，所表示的十进制范围是：-128 ~ 127。
9.数据类型
9.1 数据类型的分类
在java语言中数据类型主要分为两大类：基本数据类型 和 引用数据类型。
其中基本数据类型主要有(8种)：
byte/short/int/long - 用于描述整数数据的，如：66。
float/double - 用于描述小数数据的，如：3.14。
boolean - 用于描述真假信息的，如：是否成年。
char - 用于描述单个字符的，如：'a'。
其中引用数据类型主要有：
数组、类、接口、枚举等。
掌握的类型：
int、double、boolean。
9.2 整数类型(重点)
在java中用于描述整数的关键字主要有：byte、short、int、long，推荐首选int类型
其中byte类型在内存空间中占1个字节(8位)，表示的范围是：-128 ~ 127。
-2^7 ~ 2^7-1。
其中short类型在内存空间中占2个字节(16位)，表示的范围是：-32768 ~ 32767
-2^15 ~ 2^15-1
其中int类型在内存空间中占4个字节(32位)，表示的范围是：-2^31 ~ 2^31-1
(正负二十一亿之间)
其中long类型在内存空间中占8个字节(64位)，表示的范围是：-2^63 ~ 2^63-1
(比int还大的数)
在程序中直接写出的整数数据，叫做直接量/常量/字面值，如：66，默认int类型。
若希望描述long类型的直接量，则需要在直接量的后面加上l/L，推荐使用L。
扩展：
若long类型表示的范围还不足以描述时，可以使用java.math.BigInteger类型。
笔试题：
以下两种写法有区别吗？结果如何？
byte b1 = 100; // ok
int i1 = 100; // ok
byte b1 = i1; // error
9.3 浮点类型(重点)
在java中用于描述小数数据的关键字有：float和double，推荐首选double类型。
其中float类型在内存空间中占4个字节，属于单精度浮点数。
其中double类型在内存空间中占8个字节，属于双精度浮点数，比float精度更高。
默认的浮点数字面值为double类型，若希望表示float类型，则在字面值后面增加f/F
注意：
浮点数是不能进行精确计算的，若希望精确计算则使用java.math.BigDecimal类型。
9.4 布尔类型(重点)
在java中用于描述真假信息的关键字有：boolean。
该类型变量的数值只有两种：true(真) 和 false(假)。
该类型本质上使用一个二进制位足够表示了，但通常认为是1个字节。
9.5 字符类型(熟悉)
在java中用于描述字符类型数据的关键字有：char，如：'a' '1' '中'等。
其中char类型在内存空间中占2个字节(16位二进制)。
字符类型的数据通常都是使用一对单引号括起来的单个字符，若出现多个字符则叫做字符串，使用String类型加以描述。
为了使得单引号的字符在计算机中能够使用二进制进行表示，通常将该字符对应的编号(ASCII)保存在计算机中(要求背下来)。
'A' 'B' - 65 66 ... ...
'a' 'b' - 97 98 ... ...
'0' '1' - 48 49 ... ...
换行符 - 10
空格 - 32
常用的转义字符有(要求背下来)：
\n - 换行符，相当于换行的效果。
\t - 制表符，相当于按下tab键的效果。
\\ - 显示一个\
\" - 显示"
\' - 显示'
扩展：
实现字符串向整数类型的转换。
"12345" => 12345
'1' - '0' = 1;
'2' - '0' = 2; 1*10 + 2 = 12;
'3' - '0' = 3; 12*10 + 3 = 123;
'4' - '0' = 4; 123*10 + 4 = 1234;
'5' - '0' = 5; 1234*10 + 5 = 12345;
9.6 基本数据类型之间的转换(重点)
在java语言中基本数据类型之间转换主要有两种形式:自动类型类型 和 强制类型转换
其中自动类型转换主要指从小范围到大范围之间的转换。
其中强制类型转换主要指从大范围到小范围之间的转换。
在java中自动类型转换的规则是：
byte => short => int => long => float => double
char => int
boolean类型不参与任何类型转换。
强制类型转换的语法格式是：
目标类型 目标类型变量名 = (目标类型)源类型变量名;
如：
byte b1 = (byte)s1;
经验：
强制类型转换可能会造成数据的丢失，建议能不用则尽量不用强制类型转换。
10.运算符
10.1 算数运算符(重点)
+ 表示加法运算 - 表示减法运算
* 表示乘法运算 / 表示除法运算符
% 表示取余(取模)运算
注意：
a.当两个整数相除时，商只取整数部分，若希望有小数部分，则需要使用浮点数参与
int => double 发生自动类型转换
b.0不能做除数，0.0可以做除数，当0作为除数时会产生算数异常，当0.0作为除数
时结果是无穷大。
10.2 关系/比较运算符(重点)
> 表示是否大于 >= 表示是否大于等于
< 表示是否小于 <= 表示是否小于等于
== 表示是否等于 != 表示是否不等于
关系运算符的结果一定是boolean类型，只有两个值：true 和 false。
10.3 自增减运算符(重点)
+ 表示加法运算 ++ 表示自增运算
- 表示减法运算 -- 表示自减运算
如：
int ia = 10;
ia + 1 => 表达式的结果是11，ia的数值是10。
++ia <=> ia = ia + 1; 表达式的结果是11，ia的数值是11。
++ia 表示先++再参与其他运算。
ia++ 表示先参与其他运算再++。
--同上。
总结：
前++和后++若写成独立的语句，不参与其他运算，则效果是等价的(推荐)。
前++和后++若与其他运算写在一个表达式中，则遵循上述原则。
11.运算符
11.1 算数运算符
+ - * / %
11.2 比较/关系运算符
> >= < <= == !=
11.3 自增减运算符
++ --
++ia; 先++再参与其他运算
ia++; 先参与其他运算再++
注意：
推荐单独使用++/--运算，尽量不要与其他运算符一起使用。
11.4 逻辑运算符(重点)
&& - 逻辑与运算符，相当于“并且”，两侧的操作数都是结果为boolean的表达式。
- 同真为真，一假为假。
|| - 逻辑或运算符，相当于“或者”，两侧的操作数都是结果为boolean的表达式。
- 一真为真，同假为假。
! - 逻辑非运算符，相当于"非"，只有一个右侧的操作数，并且是结果为boolean的
- 真为假，假为真。
逻辑运算符的操作数都是boolean表达式，该运算符的结果也是boolean类型的。
练习：
提示用户输入一个正整数，判断该正整数是否为三位数并直接打印表达式的结果。
>=100 && <=999
短路特性：
a.对于逻辑与来说，当第一个条件表达式为假时则整个表达式一定为假，此时可以
省略对第二个条件表达式的判断。
b.对于逻辑或来说，当第一个条件表达式为真时则整个表达式一定为真，此时可以
省略对第二个条件表达式的判断。
11.5 条件/三元/三目运算符(重点)
?: - 三目运算符
条件表达式?表达式1:表达式2
判断条件表达式是否成立，若成立则直接执行表达式1；若不成立则直接执行表达式2
练习：
提示用户输入一个整数，使用三目运算符判断该整数是负数还是非负数？
11.6 赋值运算符(重点)
(1)简单赋值
= 赋值运算符，用于将=右边的数值/结果存放到=左边变量对应的内存空间中(右结合)
如：
int num;
num = 10;
(2)复合赋值(了解)
+= -= *= /= %= ... ...
如：
num = num + 1; //可读性更强，推荐使用
num += 1; //与上述代码的结果一样的。
笔试题：
ia = 0; 0 = ia; ia == 0; 0 == ia 分别表达什么意思？？？
解析：
ia = 0; //ok 将数值0赋值给变量ia，也就是放到ia对应的内存空间中。
0 = ia; //error 编译直接报错，0是个直接量/常量/字面值。
ia == 0; //判断ia是否等于0，结果是boolean类型的
0 == ia; //判断0是否等于ia，结果是boolean类型的
笔试题：
byte ib = 10;
ib = ib + 2; 和 ib += 2 之间有区别吗？
解析：
ib += 2; 编译运行都是正确的,真正等价的是 ib = (byte)(ib + 2);
ib = ib + 2; 编译报错，需要进行强制类型转换 ib + 2的结果是 int类型的。
11.7 字符串连接/拼接符(重点)
+ 字符串连接符
11.8 移位运算符(了解)
<< 左移运算符，表示将二进制位向左移动，右边填0。
>> 右移运算符，表示将二进制位向右移动，左边填符号位。
>>> 无符号右移运算符，表示将二进制位向右移动，左边填0。
11.9 位运算符(了解)
& 按位与运算符，同1为1，一0为0。
| 按位或运算符，一1为1，同0为0。
~ 按位取反运算符，0为1, 1为0。
^ 按位异或运算符，相同为0，不同为1。
12.分支结构(重中之重)
12.1 基本概念
分支结构就是指根据条件表达式进行判断，从而选择满足条件的分支进行执行的结构，也就是说若条件满足则执行该分支，若条件不满足则跳过该分支。
12.2 if条件分支
(1)语法格式
if(条件表达式){
语句块1; => 本质上就是多条语句的集合。
}
语句块2;
(2)执行流程
判断条件表达式是否成立
若成立 => 则执行语句块1 => 执行语句块2;
若不成立 => 执行语句块2;
12.3 if-else分支结构
(1)语法格式
if(条件表达式){
语句块1;
}
else{
语句块2;
}
语句块3;
(2)执行流程
判断条件表达式是否成立
若成立 => 执行语句块1 => 语句块3;
若不成立 => 执行语句块2 => 语句块3;
12.4 if-else if-else分支结构
(1)语法格式
if(条件表达式1){
语句块1;
}
else if(条件表达式2){
语句块2;
}
... ...
else{
语句块3;
}
语句块4;
(2)执行流程
判断条件表达式1是否成立
若成立 => 执行语句块1 => 执行语句块4;
若不成立 => 判断条件表达式2是否成立
若成立 => 执行语句块2 => 执行语句块4;
若不成立 => 执行语句块3 => 执行语句块4;
练习：
提示用户输入考试的成绩，对成绩进行分类打印：
[90 ~ 100] - 打印等级A
[80 ~ 90) - 打印等级B
[70 ~ 80) - 打印等级C
[60 ~ 70) - 打印等级D
[0 ~ 60) - 打印等级E
12.5 switch-case分支结构(熟悉)
(1)语法格式
switch(变量/表达式){
case 字面值1:语句块1;break;
case 字面值2:语句块2;break;
... ...
default:语句块3;
}
语句块4;
(2)执行流程
计算变量/表达式的结果 => 判断是否与字面值1相等
若相等 => 则执行语句块1 => break(跳出该结构) => 执行语句块4;
若不相等 => 判断是否与字面值2相等
若相等 => 则执行语句块2 => break => 执行语句块4;
若不相等 => 则执行语句块3 => 执行语句块4;
(3)注意事项
a.当case分支后没有break时，会继续执行下一个case对应的语句块，直到遇到break;
b.早期jdk中switch()中允许的数据类型有：byte、short、char、int，从jdk1.5
开始允许使用枚举类型，从jdk1.7开始允许使用String类型。
13.循环结构(重中之重)
13.1 for循环
(1)语法格式
for(表达式1; 条件表达式2; 表达式3){
循环体;
}
语句块;
(2)执行流程
执行表达式1 => 判断条件表达式2是否成立
若成立 => 则执行循环体 => 执行表达式3 => 判断条件表达式2是否成立
若不成立 => 执行语句块;;
13.2 break和continue关键字
break关键字可以用于switch-case结构 和 循环结构中，用于跳出当前多分支结构和循环结构(重点)。
continue关键字只能用于循环结构中，用于结束当前循环体继续下一次循环(熟悉)。
注意：
当程序中出现多层循环时，通常情况下，break和continue只对内层循环有效果。
13.3 特殊循环
for(;;) - 这样的循环叫做无限循环，俗称“死循环”。
通常情况下都与break关键字搭配使用。
13.4 二重循环
(1)语法格式
for(表达式1; 条件表达式2; 表达式3){
for(表达式4; 条件表达式5; 表达式6){
循环体;
}
}
语句块;
(2)执行流程
执行表达式1 => 判断条件表达式2是否成立
若成立 => 则执行表达式4 => 判断条件表达式5是否成立
若成立 => 则执行循环体 => 表达式6 => 判断条件表达式5是否成立
若不成立 => 表达式3 => 判断条件表达式2是否成立
若不成立 => 执行语句块;
练习：
***** * i = 0; 1个 列数实际上就是 行变量 + 1
***** ** i = 1; 2个
***** *** i = 2; 3个
***** **** i = 3; 4个
***** ***** i = 4; 5个
***** i = 1时，5个 *的个数其实就是 6 - i
**** i = 2时, 4个
*** i = 3时，3个
** i = 4时, 2个
* i = 5时，1个
13.5 while循环
(1)语法格式
while(条件表达式){
循环体;
}
语句块;
(2)执行流程
判断条件表达式是否成立
若成立 => 执行循环体 => 判断条件表达式是否成立
若不成立 => 执行语句块
(3)注意事项
a.while循环和for循环可以完全互换。
b.while(true)和for(;;)一样，都表示无限循环，俗称"死循环"。
c.while循环通常用于明确循环条件但不明确循环次数的场合中。
for循环通常用于明确循环次数的场合中。
13.6 do-while循环(熟悉)
(1)语法格式
do{
循环体;
}while(条件表达式);
语句块;
(2)执行流程
执行循环体 => 判断条件表达式是否成立
若成立 => 执行循环体 => 判断条件表达式是否成立
若不成立 => 执行语句块;
(3)注意事项
当循环条件一开始就不成立时，对于while循环来说，不会执行循环体；对于do-while循环来说，会执行一次循环体。
14.一维数组(重点)
14.1 基本概念
一维数组就是指内存空间中一段连续存储空间，用于存放多个数据类型相同元素/数据
数组 - 主要指存放数据元素的容器。
数组元素 - 主要指数组中存放的数据内容。
数组长度 - 主要指数组中最多可以存放的元素个数，使用数组名.length获取。
数组下标 - 主要指数组元素在数组中的索引位置，从0开始，到数组长度-1。
14.2 数组的声明
(1)语法格式
数据类型 变量名 = 初始值;
数据类型[] 数组变量名(引用) = new 数据类型[数组长度];
如：
int num = 66;
int[] arr = new int[6]; // 推荐使用
其中该数组的数组名为arr，数组长度为6，数组下标范围是：0 ~ 5。
int arr[] = new int[6]; // ok 不推荐使用
(2)默认初始化方式
当数组声明完毕之后，采用默认初始化方式进行，其中byte/short/char/int/long类型的默认初始值为0；float/double类型的默认初始值为0.0；boolean类型的默认初始值为false；引用类型的默认初始值为null。
(3)注意事项
当声明数组时，[]中的数字代表数组的长度，也就是数组元素的个数。
当使用数组时，[]中的数字代表数组的下标，也就是数组元素的索引位置。
(4)数组的初始化
当需要声明数组的同时指定初始值时，可以采用以下的语法格式：
数据类型[] 数组变量名(引用) = {初始值1, 初始值2, ... ...};
如：
int[] arr = {11, 22, 33, 44, 55};
该数组的长度是：5，下标范围是：0 ~ 4。
扩展：
java.lang.System类中的方法实现数组的拷贝：static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)，src表示源数组，srcPos表示源数组的起始下标位置，dest表示目的地数组，destPost表示存放数据的起始位置，length表示拷贝的元素个数。
java.util.Arrays类中提供大量的方法用于数组元素的处理。
15.二维数组(熟悉)
15.1 基本概念
一维数组本质上就是一段连续的内存空间，用于存放相同数据类型的多个数据。
二维数组本质上就是由一维数组组成的 一维数组，也就是说二维数组中的每一个元素
都是一个一维数组。
15.2 声明方式
(1)语法格式
数据类型[][] 数组变量名(引用) = new 数据类型[行数][列数];
如：
int[][] arr = new int[2][4];
该二维数组中一共有2行4列，其中行下标的范围是：0 ~ 1，列下标范围是:0 ~ 3。
思考：
arr代表什么？arr[0]代表什么？arr[0][0]代表什么？
解析：
arr代表二维数组这个容器自己。
arr[0]代表二维数组的第一行，也就是一维数组这个容器自己。
arr[0][0]代表二维数组的第一行第一列，也就是二维数组的第一个元素。
arr.length代表二维数组的长度，也就是行数。
arr[0].length代表二维数组第一行的长度，也就是列数。
16.面向对象编程的概念
16.1 什么是对象？
万物皆对象。
16.2 什么是面向对象？
面向对象就是指用属性(特性)和行为分析现实世界中事物的方法。
16.3 什么是面向对象编程？
面向对象编程就是指先用面向对象的观点进行分析，再采用面向对象的编程语言进行翻译/加以描述的过程。
主流的面向过程语言：C语言、C++等
主流的面向对象语言：Java、C++、C#等
16.4 为什么需要面向对象编程？
软件产业化发展的需求。
16.5 如何学好面向对象编程？
重点理解面向对象编程三大特征：封装、继承、多态。
17.类、对象以及引用(重中之重)
学生类：
属性(特性)：学号、姓名、年龄
行为：学习、吃饭、娱乐
教师类：
属性：工号、姓名、年龄
行为：讲课、吃饭、娱乐
... ..
17.1 类的基本概念
类就是“分类”的概念，是多个对象共性的提取。
类是用户可以自定义的引用数据类型，包括用于描述属性(特性)信息的成员变量，以及用于描述行为信息的成员方法，换句话说，类可以描述多种不同类型的数据。
类是一个抽象的概念，对象是客观存在的实体，类是对象创建的模板，而对象在程序中占用一块独立的内存空间，内部结构取决于类。
17.2 类的定义
(1)类定义的语法格式
class 类名{
类体;
}
如：
class Person{
}
注意：
通常情况下，当类名由多个单词组成时，每个单词的首字母都要大写。
(2)成员变量定义的语法格式
class 类名{
数据类型 成员变量名[ = 初始值]; - 可以省略的
}
如：
class Person{
String name;
int age;
}
注意：
通常情况下，当成员变量名由多个单词组成时，从第二个单词起的首字母大写。
补充：
变量根据所在位置的不同可以分为两种：
成员变量 - 主要指在类体中在方法体外声明的变量，在整个类中有效。
局部变量 - 主要指在方法体中声明的变量，在整个方法体中有效。
17.3 对象的创建
(1)语法格式
new 类名();
如：
new Person(); - 匿名对象，不便于再次访问。
(2)使用方式
当一个类定义完毕之后，可以通过new关键字去创建/构造对象，得到该类的一个实体，这个过程叫做类的实例化。
创建对象的实质就是在内存空间的堆区申请一块存储区域，用于记录该对象独有的成员变量信息。
17.4 引用的概念和定义
(1)基本概念
使用引用类型声明的变量，叫做引用类型变量，简称为 引用。
(2)语法格式
类类型 变量名;
如：
Person p;
(3)基本作用
引用类型的变量名通常用于记录对象在堆区中的内存地址信息，通过该引用可以访问堆区中的成员变量信息，访问方式使用 .进行。
如：
Person p = new Person();
p.name = "zhangfei";
18.成员方法(重中之重)
18.1 基本概念
成员方法就是指在类体中方法体外自定义的方法，换句话说，成员方法就是对多条语句的打包，用于描述该类的行为信息，使用成员方法可以提高代码的复用性和可维护性。
18.2 语法格式
class 类名{
返回值类型 方法名称(形参列表){
方法体语句; - 描述方法的功能语句。
}
}
如：
class Person{
void show(){
System.out.println("没事出来秀一下！");
}
}
注意：
当成员方法名由多个单词组成时，从第二个单词起每个单词的首字母大写。
18.3 成员方法的详解
(1)返回值类型
返回值就是指从方法体内向方法体外传递的数据内容。
返回值类型就是指返回值的数据类型，如：int、String等
当需要从方法体内向外传递66时，此时返回值类型写：int即可。
当需要从方法体内向外传递"hello"时，此时返回值类型写 String即可。
当需要在方法体中返回数据时，使用return关键字，表示返回数据并结束当前方法。
当返回66时，则方法体中写：return 66;
当返回"hello"时，则方法体中写：return "hello";
当返回变量的数值时，则方法体中写：int num = 66; return num(66);
当返回表达式的结果时，则方法体中写：return num+100(166);
当该方法没有需要返回的数据时，则返回值类型写 void即可。
(2)形式参数列表
形式参数就是指从方法体外向方法体内传入的数据内容。
形式参数列表的语法格式是：数据类型 形参名1, 数据类型 形参名2, ... ...
当需要向方法体内传入数据66时，则形参列表为：int i。
当需要向方法体内传入数据"hello"时，则形参列表为：String s。
当需要传递66和"hello"时，则形参列表为：int i, String s。
当该方法没有需要传入的数据时，则形参列表位置啥也不写即可。
18.4 方法的调用
(1)语法格式
引用/对象.方法名(实参列表);
如：
p.show();
(2)基本功能
调用方法的本质就是执行方法体中的语句，实际参数列表的本质就是用于给形参列表进行赋值，因此参数的类型、参数的个数以及参数的顺序都要保持一致。
实参可以传递字面值、变量、表达式等。
练习：
自定义Point类，有两个成员变量分别代表横纵坐标(x,y)，提供一个打印横纵坐标的方法、让横坐标加上参数(dx)值的方法，让纵坐标减去参数(dy)值的方法。
在main()方法中创建对象，并调用上述方法。
19.构造方法和方法重载(重中之重)
19.1 构造方法
如：
Person p = new Person();
(1)语法格式
class 类名{
类名(形参列表){
构造方法体;
}
}
构造方法的方法名称与类名完全相同，没有返回值类型，连void都不能有。
如：
class Person{
Person(){
System.out.println("这是无参构造方法");
}
}
(2)基本作用
当使用new关键字创建一个新对象时，会自动调用构造方法进行新对象的初始化，换句话说，就是通过构造方法的方法体来进行对象成员变量的初始化工作。
(3)默认构造方法
当一个类中没有自定义任何形式的构造方法时，编译器会自动添加一个无参的空构造方法，这样的构造方法叫做默认/缺省构造方法。
但类中只要出现自定义构造，无论何种版本，编译器都不再提供缺省构造方法。
(4)编程经验
a.当类中有非常量的成员变量时，通常提供两个版本的构造方法，一个是无参的构造方法，一个是有全属性做参数的构造方法。
b.当需要使用到无参构造方法时，尽量不要对编译器形成依赖，避免错误的发生。
c.当类中没有成员变量或者类中所有成员变量都是常量时，则不需要提供任何形式的构造方法。
19.2 方法的重载(Overload)
(1)基本概念
在同一个类中，方法名相同、参数列表不同之间的方法构成重载关系。
如：
Person(){} Person(String n, int a){} 构成重载。
(2)主要形式
方法重载的主要形式为：参数个数不同、参数类型不同以及参数顺序不同。
与形参变量名、返回值类型无关，但建议返回值类型最好相同。
判断是否重载的本质：是判断调用方法时能否区分。
如：
java.io.PrintStream类中的print()/println()方法都有大量的重载版本。
(3)实际意义
方法重载的意义在于调用方便，也就是说调用者只需要记住一个方法名就可以调用该方法的任意版本。
29.this关键字(重点)
20.1 基本概念
对于构造方法来说，this关键字就表示当前正在构造的对象。
对于普通方法来说，this关键字就表示当前正在调用的对象。
this关键字本质上就是构造方法和普通方法中一个隐含的参数，用于代表当前正在构造/正在调用的对象，当不同的对象被构造/调用方法时，this代表的对象也就随之不同。
当在构造方法/普通方法中访问成员变量时，虽然只写了成员变量名，但本质就是this.的方式在访问，而this.相当于汉语中"我的",不同的对象在堆区中拥有不同的内存空间，使用不同的对象调用方法时，this代表的对象不同，那么取出来的成员变量值也就随之不同。
20.2 使用方式
a.当成员变量名与形参变量名同名时，需要使用this.的方式明确指定使用的是成员变量，而不是形参变量(重点)。
b.使用this.的方式不仅可以访问成员变量，还可以调用成员方法(熟悉)。
c.使用this()的方式放在构造方法中的第一行，表示调用该类的其他构造方法(熟悉)
注意：
当使用空引用访问成员变量/调用方法时，则会产生空指针异常。
目前为止的异常：算数异常、数组下标越界异常、空指针异常。
21.方法的传参和递归调用
21.1 方法的传参原理(尽量理解)
(1)main()方法是程序的入口，先申请实参变量的内存空间，对于变量来说，在栈中申请内存，对于对象来说，在堆区中申请内存。
(2)当调用方法时，需要给该方法的形参申请内存空间。
(3)将实参变量的数值拷贝一份给新参变量，放置到形参变量的内存空间中。
(4)执行该方法的方法体，当方法调用结束时，回收形参变量对应的内存空间。
(5)将方法的返回值放入main()方法的实参变量中。
(6)当main()方法结束时，实参变量的内存空间也会被回收。
21.2 递归调用(重点、难点)
(1)基本概念
递归就是指在方法体内调用该方法自身的形式。
例子：
编程自定义一个方法，要求计算参数n的阶乘并传出最终的结果。
解析：
5! = 5 * 4 * 3 * 2 * 1;
4! = 4 * 3 * 2 * 1;
5! = 5 * 4!;
4! = 4 * 3!;
... ...
1! = 1;
(2)使用原则
a.寻找递归的规律，并指定递归的退出条件。
b.使用递归必须使得问题简单化，而不是复杂化。
c.使用递归需要注意程序的执行效率，某些情况下建议用递推的方式(循环)。
22.封装(重中之重 )
22.1 封装的由来
当自定义一个封装类时，若对类中的成员不做任何的限制，则在测试类中可以给封装类赋值一些合法但不合理的数值，为了避免这种情况的发生，则需要对封装类进行封装处理。
22.2 封装的流程
(1)私有化成员变量，使用private关键字修饰。
(2)提供公有的get和set成员变量方法，在方法体中进行成员变量值的合理性判断。
(3)在构造方法中调用公有的set成员变量方法。
22.3 封装的作用
(1)隐藏类内部的实现细节，使得代码更加安全。
(2)可以实现对成员变量合理值的判断。
(3)可以提高代码的复用性和可维护性。
23.static关键字(重点)
23.1 基本概念
通常情况下，成员变量和成员方法都隶属于对象层级，访问这些成员时需要使用对象/引用.的方式进行，当创建新的对象，每个对象都会在堆区申请一块独立的内存空间，用于保存该对象自己独有的成员变量值。
当多个对象中的成员变量值完全相同时，若还在每个对象中单独保存一份，则会造成内存空间的浪费，此时可以使用static关键字解决该问题，使用static关键字修饰的成员叫做静态的，表示该成员由对象层级提升到类层级，在整个类中只有一份，并且被所有对象共享，虽然可以使用对象/引用.的方式访问，但推荐使用类名.的方式进行。
静态成员随着类的加载而准备就绪，与是否创建对象无关。
23.2 使用方式
(1)在非静态的成员方法中，可以访问非静态的成员，也可以访问静态成员。
(成员：成员变量 + 成员方法)
(2)在静态的成员方法中，只能访问静态成员，不能访问非静态成员。
(静态成员方法中没有this关键字)
(3)当该成员确实被所有对象共享时才能使用static关键字修饰，否则不能修饰。
(static关键字不能随便使用)
23.3 构造块和静态语句块
构造块 - 主要指在类体中方法体外使用{}括起来的语句块。
静态语句块 - 主要指在类体中方法体外使用static{}括起来的语句块。
执行流程：
静态语句块 => 构造块 => 构造方法体
练习：
自定义一个Singleton类和TestSingleton类，要求在TestSingleton类中能得到且只能得到Singleton类的一个对象。
23.4 单例设计模式(重中之重 )
(1)基本概念
在某些特殊场合中，要求一个类能创建且只能创建一个对象，这样的类叫做单例类，设计单例类的编程经验总结叫做 单例设计模式。
(2)实现流程
a.私有化构造方法，使用private关键字修饰。
b.提供本类类型的对象作为本类的成员变量，使用private static关键字修饰。
c.提供静态公有的get方法，负责将本类中的对象返回出去。
(3)主要分类
单例设计模式主要分为两大类：饿汉式 和 懒汉式，以后的开发中推荐饿汉式。
24.继承(重中之重)
人类：
属性：姓名、年龄
行为：吃饭、娱乐
学生类 继承 人类：
属性：学号
行为：学习
教师类 继承 人类：
属性：工号
行为：讲课
24.1 继承的由来
当多个类之间有相同的成员变量和相同的成员方法时，则可以将相同的成员提取出来组成一个新类，让原来的多个类继承该新类即可，从而提高代码的复用性、可维护性以及可扩展性。
24.2 基本概念
继承就是指吸收现有类中已有的成员变量和成员方法，而在新类中只需要编写自己独有的成员变量和成员方法就可以的形式。
在java中使用extends关键字表达继承关系。
如：
class Student extends Person{} - 表示Student类继承自Person类。
其中Person类叫做 超类/基类/父类。
其中Student类叫做 派生类/子类。
练习：
编程实现Person类的封装，Person类的属性：姓名、年龄。
24.3 注意事项
(1)子类可以继承父类中的所有成员变量，包括私有的，但不能直接访问私有的。
子类不可以继承父类中的构造方法和私有成员方法。
(2)当创建子类的对象时，无论调用子类构造方法中的哪个版本，都会自动调用父类
中无参构造方法，用于实现对父类中成员变量的初始化工作，该效果的底层实现
就是在构造方法中的第一行自动添加代码：super()。
(3)java语言不支持多继承，也就是说一个子类只能有一个父类，而一个父类可以
有多个子类(单继承)。
(4)使用继承必须满足 子类 is a 父类 的逻辑关系才可以。
24.4 super关键字
(1)基本概念
this关键字 可以代表本类的对象。
super关键字 通常用于代表父类的对象。
(2)使用方式
使用this.的方式可以访问本类中的成员(成员变量和成员方法)。
使用super.的方式可以访问父类中的成员(成员变量和成员方法)。
使用this()的方式可以调用本类中的其他构造方法，要求写在构造方法第一行。
使用super()的方式可以调用父类中的无参构造方法，要求写在构造方法第一行。
因此this()和super()不能同时出现，当两个都不写时，默认增加super()。
要求大家重点掌握的用法：
a.使用this.的方式用于区分成员变量名和形参变量名。
b.使用super(实参)的方式可以调用父类的构造方法。
c.使用super.的方式可以调用父类中被重写的方法。
24.5 方法的重写(Override)
(1)基本概念
当使用父类中继承下来的方法不足以满足子类的需求时，则需要在子类中重写一个与父类一样(访问属性、返回值类型、方法名、参数列表)的方法进行调用，该方法就叫做对父类中继承下来方法的重写/覆盖。
(2)重写的原则
a.要求有相同的方法名、参数列表以及返回值类型，从jdk1.5起允许返回子类类型。
b.访问权限不能变小，可以变大。
c.不能抛出更大的异常。
25.访问控制
25.1 常用的访问控制符
public - 公开的
protected - 保护的
默认权限 - 采用默认方式进行访问的控制
private - 私有的
35.2 访问控制的级别
访问控制符 访问权限 本类内部 同一个包中的类 子类 其他类
-----------------------------------------------------------------------
public 公开的 ok ok ok ok
protected 保护的 ok ok ok no
默认权限 默认的 ok ok no no
private 私有的 ok no no no
要求大家掌握的内容：
public - 表示在任意有效位置都可以访问。
private - 表示只能在本类内部进行访问，其他任何位置都不能访问。
通常情况下，成员变量都用private修饰，成员方法都用public修饰。
25.3 包的定义
package 包名; - 表示创建一个包，为了便于管理和区分相同的类/文件。
package 包名1.包名2...包名n; - 表示创建多层包，也就是多层目录。
26.final关键字
26.1 基本概念
final本意为"最终的，不可更改的"，使用final关键字可以修饰类/成员方法/成员变量
26.2 基本作用(重点)
使用final修饰一个类表示该类不能被继承，如：java.lang.String/System类等
- 为了防止滥用继承。
使用final修饰一个方法表示该方法不能被重写。
- 为了防止不经意间造成的重写。
使用final修饰一个成员变量表示该成员变量必须被赋值，而且不能更改，不能依赖于默认初始化方式。
补充(重点)：
通常情况下，单独使用static和单独使用final的意义不大，以后的开发中更多的是用public static final共同修饰成员变量，表示常量的概念。
对于常量来说，要求所有字母都要大写，不同单词之间使用_连接。
如：
public static final int MAX_VALUE = 10;
public static final double PI = 3.14;
27.对象创建的过程(尽量理解，观察一下执行流程就行了)
27.1 单个对象的创建过程
(1)运行程序时首先需要将类的字节码文件加载到内存中的方法区，这个过程叫类加载
(2)当创建对象时需要在堆区申请内存空间，若指定了成员变量的初始值则使用指定的数值放入堆区内存，若没有指定初始值则使用默认初始化方式进行。
(3)执行构造块中的代码，可以实现对成员变量的更改。
(4)执行构造方法体中的代码，可以再次更改成员变量的数值。
(5)此时对象创建完毕，继续执行main()方法中后续的代码。
27.2 创建子类对象的执行流程
(1)运行程序时先进行类的加载，首先加载父类，因此先执行父类的静态语句块。
(2)加载子类的字节码文件，此时执行子类的静态语句块。
(3)当创建子类对象时，需要先创建子类对象中的父类小对象，因此执行父类的构造块和构造方法体。
(4)继续创建子类对象，执行子类的构造块和构造方法体。
(5)此时对象构造完毕，继续执行main()方法后面的代码。
28.多态(重中之重)
28.1 基本概念
多态就是同一种事物表现出来的多种形态。
如：
宠物：猫、狗、猴、鸟、小强、...
饮料：可乐、雪碧、红牛、加多宝、果啤、...
整数: byte b = 66; short s = 66; int i = 66; ...
方法重载：show(){} show(int i){} ...
... ...
28.2 语法格式
父类类型 引用变量名 = new 子类类型();
在编译阶段引用是父类类型的，只能调用父类中的show()方法；在运行阶段引用是子类类型的，最终调用子类中重写以后的show()方法。
练习：
编程实现Person类的封装(姓名、年龄)和Student类的封装(学号)继承Person类。
再写TestStudent的测试类，负责创建父类对象 子类的对象 调用show()方法
28.3 多态的效果
(1)父类的引用只能访问父类中的成员变量和成员方法。
(2)父类的引用不能直接访问子类中的成员变量和成员方法，若希望能够访问子类中的成员，则需要进行强制类型转换。
目标类型 目标类型的变量名 = (目标类型)源类型的变量名;
(3)对于非静态的方法来说，最终调用子类中重写以后的版本。
对于静态方法来说，最终调用父类自己的版本。
28.4 引用类型之间的转换
(1)引用类型之间的转换必须发生在父子类之间。
(2)子类向父类转换时只需要自动类型转换即可；
但父类向子类的转换需要进行强制类型转换。
(3)若没有父子类关系就进行强制类型转换，则编译阶段报错，执行不到运行阶段。
若拥有父子类关系进行强制类型转换，则编译阶段不报错，但目标类型若不是
该引用真正指向的子类类型，则在运行阶段产生类型转换异常。
(4)为了避免上述错误的产生，通常建议在类型转换之前先做一个类型的判断，具体
方式如下：
if(引用名 instanceof 数据类型){}
若引用指向的对象确实是后面的数据类型则返回true，否则返回false。
28.5 强制类型转换成功的条件（两个）：子父类关系，父类的引用指向指向子类。
练习：
自定义矩形类，成员变量主要有：横坐标、纵坐标、长度、宽度，成员方法有：打印所有成员变量的方法，实现矩形类的封装。
自定义圆形类，成员变量主要有：横坐标、纵坐标、半径，成员方法有：打印所有成员变量的方法，实现圆形类的封装。
自定义形状类，描述矩形类和圆形类的共性。
Rect Circle Shape x y len wid r
28.5 多态的作用
多态的作用主要在屏蔽不同子类之间的差异性，实现通用的编程，达到不同的效果。
29.抽象类(重点)
29.1 抽象方法的概念
抽象方法就是指不能具体实现的方法，并且使用abstract关键字修饰。
抽象方法的语法格式：
访问控制符 abstract 返回值类型 方法名(形参列表);
如：
public abstract void cry();
29.2 抽象类的概念
抽象类通常指使用abstract关键字修饰并且有抽象方法的类，抽象类是不能实例化对象
29.3 注意事项
(1)抽象类中可以有成员变量、成员方法以及构造方法。
构造方法存在的价值是为了让子类通过super()的方式调用，从而构造父类小对象。
(2)抽象类中可以有抽象方法，也可以没有抽象方法。
(3)拥有抽象方法的类必须声明为抽象类。
29.4 抽象类的意义
抽象类本身的意思不在于创建对象，而在于被继承，当一个类继承抽象类之后则必须要重写抽象类中的抽象方法，否则该类也变成抽象类，从而使得抽象类对子类实现了强制性和规范性。
这种设计的方式叫做模板设计模式。
经验分享：
在以后的开发中若没有明确的要求，推荐使用父类引用指向子类对象的方式，因为使用该方式编程时，该引用直接调用的所有方法必然都是父类中的方法，那么以后更改指向的对象时，只需要将子类类型修改即可，其他代码都不用改动，因此可维护性更强。
30.接口(重点)
30.1 基本概念
接口本质上就是一种比抽象类还抽象的类，里面的所有方法都是抽象方法。
定义抽象类使用class关键字，而定义接口使用interface关键字。
继承类使用extends关键字，而实现接口使用implements关键字。
30.2 使用方式
(1)接口中所有的属性都必须由public static final共同修饰，也就是常量。
(2)接口中所有的方法都必须由public abstract共同修饰，也就是抽象方法。
30.3 类和接口的比较
类和类之间的关系 使用extends关键字 支持单继承
类和接口之间的关系 使用implements关键字 支持多实现
接口和接口之间的关系 使用extends关键字 支持单继承
30.4 抽象类和接口的主要区别
(1)定义抽象类使用class关键字，定义接口使用interface关键字。
(2)继承抽象类使用extends关键字，实现接口使用implements关键字。
(3)继承抽象类只能是单继承，而实现接口可以是多实现。
(4)抽象类中可以有构造方法，接口中没有构造方法。
(5)接口中所有的属性都是常量，使用public static final共同修饰。
(6)接口中所有的方法都是抽象方法，使用public abstract共同修饰。
(7)接口中只要增加方法必然影响到子类，而抽象类可以不影响。
40.内部类(了解)
40.1 基本概念
将一个类的定义写在另外一个类的内部，该类就叫做内部类，所在的类叫外部类。
类的主要组成：成员变量、成员方法、构造方法、构造块、静态语句块、内部类。
40.2 语法格式
class 类名{
class 内部类名{
类体;
}
}
40.3 基本作用
当一个类存在的价值仅仅是为某一个类单独服务时，就可以将该类写成那个类的内部类，内部类可以直接访问外部类的成员，包括私有的，而不再需要提供公有的get/set方法
40.4 内部类的主要分类
普通内部类 - 直接将类的定义放在另外一个类的内部。
- 隶属于对象层级，需要使用外部类对象.的方式创建。
静态内部类 - 使用static关键字修饰的内部类。
- 外部类是不能使用static关键字修饰的。
局部内部类 - 直接将类的定义放在一个方法体中。
- 局部内部类只能在方法体内使用。
匿名内部类 - 没有名字的内部类，用于构造接口/父类类型的对象(重点)。
40.5 匿名内部类的语法格式(重点)
接口/父类类型 引用变量名 = new 接口/父类类型() { 方法的重写 };
经验分享：
当使用接口类型的引用作为方法的形参时，实参的传递有两种方式：a.自定义一个新类实现接口，然后创建新类的对象作为实参传递；b.直接使用匿名内部类去创建接口类型的对象作为实参传递。
41.Object类
41.1 常用的包
java.lang包 - 是java中的核心包，该包中的所有类由java虚拟机自动导入。
java.util包 - 是java中的工具包，该包中包括了各种工具类和集合类。
如：Scanner类、Random类以及List、Set接口等
java.io包 - 是java中输入输出包，该包包含了大量输入输出类，实现文件读写等
java.net包 - 是java中网络包，该包中包含了基于socket通信的实现类等。
java.sql包 - 是java中连接和处理数据的包。
... ...
41.2 Object类
(1)基本概念
java.lang.Object类是java类层次结构中的根类，是所有类的超类。
(2)常用的方法(重点)
Object() - 无参的构造方法，用于子类通过super()的方式进行调用。
boolean equals(Object obj) - 判断调用对象是否与参数对象相等。
- 形参是Object类型的引用，因此实参可以传递本类对象，也可以传递子类对象
- 默认比较的是两个对象的地址是否相等，效果等同于 == 。
- 具有自反性、对称性、传递性、一致性、非空性。
- 若希望该方法比较两个对象中的内容，则需要进行方法的重写。
- 只要重写了该方法则记得去重写hashCode()方法。
int hashCode() - 用于返回调用对象的哈希码值(内存地址的编号)。
- 只要equals()方法比较的信息没有修改，则调用该方法都应该返回相同的整数
- equals()比较两个对象相等，则两个对象调用该方法返回的整数相同。
- equals()比较不相等，则对象调用该方法返回的整数可以相同，但最好不相同
String toString() - 用于返回调用对象的字符串形式。
- 字符串格式为：包名.类名@哈希码的无符号十六进制形式。
- 若希望打印其他内容，则需要进行方法的重写。
- println()方法打印引用时，会自动调用toString()方法。
- 若使用+进行字符串连接时，也会自动调用toString()方法。
42.包装类和数学处理类
42.1 包装类的由来
java语言是一门纯面向对象的编程语言，万物皆对象。
如：
int num = 30;
Person p = new Person();
在某些特殊场合(集合)中，要求放入的所有数据都必须是对象，而对于基本类型的数据来说并不满足是对象的要求，因此不能直接放入，为了能够放入该类数据就需要对数据进行对象化处理，于是需要借助包装类。
42.2 常用的包装类
int => java.lang.Integer类(重点)
double => java.lang.Double类
float => java.lang.Float类
byte => java.lang.Byte类
short => java.lang.Short类
long => java.lang.Long类
boolean => java.lang.Boolean类
char => java.lang.Character类
42.3 Integer类(重点)
(1)基本概念
java.lang.Integer类被final关键字修饰，表示该类不能被继承。
该类内部包装了一个int类型的数据。
(2)常用的方法
Integer(int value) - 采用参数指定的整数来构造对象。
Integer(String s) - 采用参数指定的字符串来构造对象。
该类重写了equals()、hashCode()、toString()方法。
static int parseInt(String s) - 用于将字符串转换为int类型的整数。
- 使用类名.的方式调用
int intValue() - 将Integer类型对象中的整数值返回。
43.包装类和数学处理类
43.1 常用的包装类
int => java.lang.Integer类(重点)
double => java.lang.Double类
float => java.lang.Float类
byte => java.lang.Byte类
short => java.lang.Short类
long => java.lang.Long类
boolean => java.lang.Boolean类
char => java.lang.Character类
43.2 Integer类
java.lang.Integer类由final修饰，表示该类不能被继承。
43.3 装箱和拆箱
装箱就是指从基本数据类型到引用数据类型之间的转换，如：int => Integer类。
拆箱就是指从引用数据类型到基本数据类型之间的转换，如：Integer类 => int。
从jdk1.5开始，支持自动装箱和自动拆箱的功能。
43.4 自动装箱池(尽量理解)
从jdk1.5开始支持自动装箱和自动拆箱的功能，为了提供装箱的效率，Integer类的内部提供了一个自动装箱池，里面已经放好了-128 ~ 127之间的数据对象，当程序中需要对该范围中的数据进行装箱时，直接从装箱池中获取，否则才需要创建新的对象。
43.5 BigDecimal类(了解)
(1)基本概念
在java语言中描述浮点数使用float类型和double类型，但float类型和double类型都会有误差，为了实现精确计算，可以使用java.math.BigDecimal类加以描述。
(2)常用的方法
BigDecimal(String val) - 根据参数指定的字符串来构造对象。
BigDecimal add(BigDecimal augend) - 用于计算调用对象和参数对象的和并返回
BigDecimal subtract(BigDecimal subtrahend) - 计算调用对象减去参数对象的差
BigDecimal multiply(BigDecimal multiplicand) - 计算调用对象和参数对象的积
BigDecimal divide(BigDecimal divisor) - 计算调用对象和参数对象的商
43.6 BigInteger类(了解)
(1)基本概念
在java语言中描述整数首选int类型，若int类型范围不够则使用long类型，若long类型还是不够，则使用java.math.BigInteger类加以描述。
(2)常用的方法
参数BigDecimal类型即可。
44.String类(重中之重)
44.1 基本概念
java.lang.String类由final关键字修饰，表示该类不能被继承。
该类用于描述字符串对象，应用程序中所有的字符串字面值都可以使用该类实例描述。
该类描述的字符串内容是个常量，不可更改。
如：
String name = "zhangfei";
| | |
数据类型 引用变量名 字符串的字面值(常量)
name = "guanyu"; - 本质上就是在修改引用的指向，而不是指向的内容。
注意：
String str = ""; 有字符串对象，但没有字符串内容。
String str = null; 没有字符串对象。
44.2 字符串常量池(尽量理解)
为了提高字符串的使用效率，当程序中出现字符串常量时，首先去字符串常量池中进行查找，若存在则直接返回该对象，若不存在再创建对象并放入常量池中。
44.3 常用的方法(练熟)
(1)常用的构造方法
String() - 使用无参的形式构造对象。
String(byte[] bytes) - 根据参数指定的byte数组来构造字符串对象。
String(byte[] bytes, int offset, int length) - 使用数组中的一部分构造对象。
String(String original) - 使用字符串字面值来构造字符串对象。
String(StringBuffer buffer) - 用于将StringBuffer类型转换为String类型。
String(StringBuilder builder) - 用于将StringBuilder类型转换为String类型。
(2)常用的其他方法
char charAt(int index) - 用于返回当前字符串中参数指定索引位置的单个字符。
int length() - 用于返回当前字符串的长度。
int compareTo(String anotherString) - 比较调用字符串和参数字符串的大小。
- 若调用字符串比较大则返回正数；
- 若调用字符串比较小则返回负数；
- 若相等则返回0；
- 先比较相同索引位置的单个字符，后比较长度确定大小
int compareToIgnoreCase(String str) - 比较字符串的大小，不考虑大小写。
boolean equals(Object anObject) - 比较调用对象和参数对象是否相等。
boolean equalsIgnoreCase(String anotherString) - 比较是否相等时不考虑大小写
45.String类(重中之重)
45.1 常用的方法
String substring(int beginIndex)
- 用于获取当前字符串中从beginIndex位置(包括)开始一直到该字符串结尾的子串 String substring(int beginIndex, int endIndex)
- 用于获取当前字符串中从beginIndex位置(包括)开始到endIndex位置(不包括)
之间的子串。
boolean matches(String regex)
- 用于判断当前字符串是否满足参数指定的正则表达式规则。
String replaceAll(String regex, String replacement)
- 用于按照正则表达式进行字符串的全部替换。
String replaceFirst(String regex, String replacement)
- 用于替换满足正则表达式的第一个子字符串。
String[] split(String regex)
- 用于按照指定的正则表达式进行字符串的拆分。
45.2 正则表达式(记住)
(1)基本概念
正则表达式本质就是一个字符串，用于进行数据格式的验证。
通常情况下，正则表达式使用^开头，使用$结尾，可以省略，但推荐写上。
(2)常用的规则
[abc] - 表示可以出现a、b或c中的任意字符。
[^abc] - 表示可以出现任意字符，除了a、b以及c。
[a-zA-Z] - 表示可以出现a到z和A到Z之间的任意字符，也就是所有字母都可以出现。
\d - 表示可以出现任何数字，相当于[0-9]。
\D - 表示可以出现任何非数字，相当于[^0-9]。
\s - 表示可以出现任何空白字符，相当于[ \t\n\x0B\f\r]。
\S - 表示可以出现任何非空白字符，相当于[^\s]。
\w - 表示可以出现任何单词字符，相当于[a-zA-Z_0-9]。
\W - 表示可以出现任何非单词字符，相当于[^\w]。
X? - 表示X可以出现一次或一次也没有，相当于0 ~ 1次。
X* - 表示X可以出现零次或多次，相当于0 ~ n次。
X+ - 表示X可以出现一次或多次，相当于1 ~ n次。
X{n} - 表示X恰好出现 n 次。
X{n,} - 表示X至少出现 n 次，也就是 >= n。
X{n,m} - 表示X至少出现 n 次，但是不超过 m 次，也就是 >= n 并且 <= m。
46.StringBuilder类和StringBuffer类(查手册会用即可)
46.1 StringBuilder类和StringBuffer类的由来
在java中使用String类可以描述所有的字符串数据，但String类的对象一旦创建，则该对象中的字符序列就不可更改，当需要更改字符串内容时，需要拷贝出来多个副本并单独进行保存，因此对空间和时间的消耗比较大，为了解决该问题，可以用StringBuilder类和StringBuffer类，这两个类描述的字符序列可以直接更改。
StringBuilder类是后来增加的类，不支持线程同步/安全，因此效率比较高。
StringBuffer类是早期就有的类，支持线程同步/安全，因此效率比较低。
