## Java SE 基础知识体系梳理
----------day01-------------
(1)计算机的体系结构
(2)Java语言的概述
(3)开发环境的搭建和使用
1.计算机的体系结构(常识)
1.1 计算机的基本概念
计算机俗称“电脑”，是一种可以应用于高级计算等各个领域的设备。
计算机主要有两大部分组成：计算机硬件 + 计算机的软件。
1.2 常见的硬件
计算机中常见的硬件主要有：CPU、内存、硬盘、显卡、键盘、鼠标、显示器、…
CPU - 中央处理器，是计算机中最核心的部件，类似于人的大脑
- 主要用于解析和执行计算机的指令以及处理软件中的数据
内存 - 是计算机中的存储部件
- 主要用于临时存放CPU要访问的数据内容，CPU可以直接访问内存且效率高
- 容量比较小，一旦关机则会造成数据的丢失
- 时刻使用快捷键: ctrl+s 进行报错
硬盘 - 是计算机中的存储部件
- 容量比较大，一旦关机数据也不会丢失，也就是可以实现永久存储数据
- CPU不可以直接访问硬盘，若希望访问需要先加载到内存中
其中键盘叫做标准输入设备，其中显示器叫做标准输出设备
科普：
1Tb = 1024Gb
1Gb = 1024Mb
1Mb = 1024Kb
1Kb = 1024byte(字节) 通常一个英文字母占1个字节，一个汉字占2个字节
1byte = 8bit(二进制位) 计算机的底层识别0和1组成的二进制序列
思考：
目前主流的硬盘配置是：250G、320G、500G、1Tb、…为啥我的只有298G呢？
解析：
硬件厂商是采用1000作为进率，而操作系统是采用1024作为进率显示
1.3 常见的软件
计算中常见的软件主要有：系统软件 和 应用软件
其中系统软件主要指操作系统，目前主流的操作系统都有：
windows系列、Unix系列、linux系列、ios系列、Android系列
其中应用软件主要指安装在操作系统之上的软件，如：QQ、火狐浏览器、迅雷等
1.4 计算机的体系结构
使用者 => 应用软件 => 操作系统 => 硬件设备
=> 其中操作系统分为：外壳(Shell) 和 内核(Kernel)
2.Java语言的概述(常识)
2.1 Java语言的背景
Java语言诞生于1995年，该语言之父是詹姆斯-高斯林，该语言之前隶属于sun公司，现在隶属于oracle公司。
Java语言在编程语言排行榜占据重要的地位。
2.2 Java语言的主要版本
(1)Java SE（Java Platform, Standard Edition）
- 称之为“Java平台标准版”，主要用于学习Java语言的语法规则和编程基础。
(2)Java EE（Java Platform，Enterprise Edition） - 称之为“Java平台企业版”，主要用于学习Java语言的后台开发技术。
(3)Java ME （Java Platform，Micro Edition） - 称之为Java 平台微型版，随着Android智能平台的普及已经走向了淘汰。
3.开发环境的搭建和使用(重点)
3.1 jdk的下载和安装
(1)下载方式
方式一：直接从官网上下载 www.sun.com www.oracle.com
方式二：直接搜索下载 www.baidu.com www.sogou.com
(2)安装方式
若下载的是安装版，则一路点击下一步采用默认方式安装即可；
若下载的是绿色版，则直接解压即可；
切记安装路径中不要有中文！！！
3.2 相关的概念(记住)
jdk - Java开发工具包，只要做Java开发就需要下载和安装该软件，包含jre。
jre - Java运行时环境，只要运行Java程序就需要下载和安装该软件。
javac.exe - Java语言编译器，负责将Java源代码翻译成字节码文件。
java.exe - Java语言解释器，负责将Java字节码文件进行边解释边执行。
3.3 编写Java程序的流程
(1)新建一个文本文档，将xxx.txt修改为xxx.java；
(2)使用记事本的方式打开该文件，编写Java代码后进行保存；
(3)启动dos窗口，切换到xxx.java文件所在的目录中；
(4)使用javac xxx.java进行编译生成xxx.class的字节码文件；
(5)使用java xxx进行解释执行打印结果；
注意：
当文件后缀无法显示时的处理方式：组织 => 文件夹和搜索选项 => 查看 => 隐藏已知文件类型的扩展名 => 去掉勾选 => 确定
3.4 常用的快捷键
ctrl+s 保存 ctrl+c 复制 ctrl+v 粘贴 ctrl+x 剪切
ctrl+a 全选 ctrl+f 查找 ctrl+z 撤销
windows+d 回到桌面 windows+e 打开计算机 windows+l 锁屏
windows+tab 切换任务
windows+r 打开运行，输入cmd后回车就可以打开dos窗口
alt+tab 切换任务
ctrl+shift 切换输入法，一旦切换到中文输入法后就使用shift进行中英文切换
ctrl+alt+delete 启动任务管理器
3.5 环境变量的配置
(1)基本概念
通常情况下可执行文件只能在当前安装目录中使用，若希望该文件可以在任意路径中使用，则需要将该可执行文件的路径存放环境变量Path中。
(2)配置方式
计算机 => 鼠标右击，选择属性 => 高级系统设置 => 高级 => 环境变量 => 系统变量 => 找到Path后点击编辑，将javac.exe文件所在的路径放到Path变量值的最前面，加上英文版的分号 => 一路点击确定即可
切记Path变量原有的变量不要删，配置完毕后记得重启dos窗口
3.6 跨平台原理(记住)
对于同一份字节码文件来说，由于不同的操作系统中都提供了Java虚拟机负责翻译成对应平台的机器指令，因为使得同一份字节码文件赢得“一次编译，到处使用”的美名
--------------day02---------------------
今天内容：
(1)变量和注释
(2)数据类型
1.变量和注释(重中之重)
1.1 基本概念
当需要在Java程序中记录单个数据内容时，则需要声明一个变量，而声明变量的本质就是在内存中申请一块独立的存储单元，由于该存储单元中的数据可以改变，因此得名为"变量"。
由于存放的数据内容大小不同导致所需存储单元的大小不同，在Java语言中使用数据类型的概念加以描述，为了便于下次查找需要给该存储单元指定一个名称，叫做变量名。
1.2 声明方式
数据类型 变量名 = 初始值; - 其中=初始值可以省略，但分号不可以省略
如：
int age = 18;
1.3 标识符(变量名)的命名规则(笔试题)
(1)必须由字母、数字、下划线以及美元$等组成，其中数字不能开头(下午讲到)；
如：name、age、nianling、name2、name3等
(2)不能与Java语言的关键字同名，所谓关键字就是Java语言中用于代表特殊含义的单词
如：public、class、void、static等
(3)区分大小写，长度没有限制但不宜过长；
如：day 和 Day代表不同的标识符，不推荐使用
(4)尽量做到见名知意，支持中文但不推荐使用；
如：year、month、day、size、length等
1.4 常用的注释
// 单行注释，表示从//开始一直到本行结束的所有内容都是注释
/**/ 多行注释，表示/开始一直到/之间的所有内容都是注释
注意：
多行注释之间是不允许嵌套的
2.数据类型
2.1 基本分类
在Java语言中数据类型主要分为两大类：
(1)基本数据类型(记住)
byte、short、int、long、float、double、boolean、char
1 2 4 8 4 8 1 2
(2)引用数据类型(了解)
数组、类、接口、枚举、注解
2.2 常用的进制
在日常生活中采用十进制来进行数据的描述，逢十进一，权重：100、101、10^2 …
在计算机中采用二进制进行数据的描述，逢二进一，权重：20、21、2^2、…
由于十进制有正负数，为了使得计算机中能够存储，计算机中采用二进制的最高位(最左边)代表符号位，若是0则代表非负数，若是1则代表负数。
如：
10^3 10^2 10^1 10^0
千 百 十 个
1 2 3 4 => 读取：一千一百一十一
2.3 进制之间的转换(尽量理解)
(1)正十进制转换为二进制的方式
a.除二取余法，让十进制整数不断地出于2取出余数，直到商为0时将余数逆序排列
b.拆分法，将十进制整数拆分为若干个二进制权重的和，若有该权重下面写1否则写0
如：
45 = 32 + 8 + 4 + 1
二进制的权重： 128 64 32 16 8 4 2 1
0 0 1 0 1 1 0 1 => 0010 1101
(2)正二进制转换为十进制的方式
a.加权法，让二进制的每个数字乘以当前位的权重再累加起来。
如：
0010 1101 =>02^7 +02^6 +12^5 + 02^4 + 12^3 + 12^2 + 02^1 + 12^0
=> 0 + 0 + 32 + 0 + 8 + 4 + 0 + 1
=> 45
(3)负十进制转换为二进制的方式
a.先将十进制的绝对值转换为二进制，进行按位取反再加1。
如：
-45 绝对值转换为二进制：0010 1101
进行按位取反： 1101 0010
再加1： 1101 0011
-45 + 45 = 0;
-45: 1101 0011
45: 0010 1101 +
---------------------------
1 0000 0000 (高位溢出，也就是将1丢弃) => 0000 0000 => 0
扩展：
有余力的同学课下查询原码、反码以及补码的概念。
(4)负二进制转换为十进制的方式
a.先减1再按位取反，转换为十进制后添加负号。
如：
1101 0011 => 先减1： 1101 0010
=> 按位取反：0010 1101
=> 转十进制：45
=> 添加负号：-45
练习：
将整数58 和 -58 转换为二进制：
将整数83 和 -83 转换为二进制：
将正二进制0101 1101 和 0011 1110 转为十进制：
将负二进制1010 1010 和 1101 1101 转为十进制：
解析：
128 64 32 16 8 4 2 1
0 0 1 1 1 0 1 0
0 1 0 1 0 0 1 1
58 = 32 + 16 + 8 + 2 => 0011 1010
-58 => 0011 1010 => 1100 0101 => 1100 0110
83 = 64 + 16 + 2 + 1 => 0101 0011
-83 => 0101 0011 => 1010 1100 => 1010 1101
0101 1101 => 0 + 64 + 0 + 16 + 8 + 4 + 0 + 1 => 93
0011 1110 => 0 + 0 + 32 + 16 + 8 + 4 + 2 + 0 => 62
1010 1010 => 1010 1001 => 0101 0110 => 86 => -86
1101 1101 => 1101 1100 => 0010 0011 => 35 => -35
2.4 单个字节表示的整数范围(重中之重)
在计算机中单个字节表示8位二进制位，其中最高位代表符号位，若是0则表示非负数，若是1则表示负数，因此表示的整数范围如下：
非负数的范围：0000 0000 ~ 0111 1111 => 0 ~ 127 => 0 ~ 2^7-1
0111 1111 =>02^7 + 12^6 + 12^5 + 12^4 + 12^3 + 12^2 + 12^1 + 12^0
=> 0 + 64 + 32 + 16 + 8 + 4 + 2 + 1
=> 127
负数的范围：1000 0000 ~ 1111 1111 => -128 ~ -1 => -2^7 ~ -2^0
1000 0000 => 先减1: 0111 1111
=> 按位取反：1000 0000
=> 转十进制：128
=> 添加负号：-128
1111 1111 => 先减1： 1111 1110
=> 按位取反：0000 0001
=> 转十进制：1
=> 添加负号：-1
综上所述：
在计算机中单个字节所能表示的整数范围是：-2^7 ~ 2^7-1，也就是-128 ~ 127.
2.5 整数类型
在Java语言中用于描述整数数据的类型有：byte、short、int、long，推荐int类型。
其中byte类型在内存空间中占1个字节，表示的整数范围是：-2^7 ~ 2^7-1。
-128 ~ 127.
其中short类型在内存空间中占2个字节，表示的整数范围是：-2^15 ~ 2^15-1。
-32768 ~ 32767.
其中int类型在内存空间中占4个字节，表示的整数范围是：-2^31 ~ 2^31-1.
正负二十一亿之间
其中long类型在内存空间中占8个字节，表示的整数范围是：-2^63 ~ 2^63-1.
比int类型还大的数
在Java程序中直接写出的整数数据叫做直接量/字面值/常量，如：200等，而直接量默认是int类型，若希望表达long类型的直接量，则需要在直接量的后面加上l或者L，推荐使用L方式。
扩展:
在以后的开发中若希望表达比long类型范围还大的数，则借助java.math.BigInteger类型加以描述。
2.6 浮点类型
在Java语言中用于描述小数数据的类型有：float、double，推荐使用double类型
其中float类型在内存空间中占4个字节，叫做单精度浮点数，小数点后7位有效数字
其中double类型在内存空间中占8个字节，叫双精度返点数，小数点后15位有效数字
在Java程序中直接写出的小数数据叫做直接量/字面值/常量，如：3.14等，而直接量默认为double类型，若希望描述float类型的直接量，则需要在直接量后面加上f或者F.
扩展：
a.有余力的同学课下查询float类型的二进制结构(了解)
b.由于float和double类型运算时可能会有误差，为了实现精确运算可以直接java.math.BigDecimal类型加以描述。
练习：
提示用户输入下落时间t(整数)，使用公式0.59.8t*t来计算下落的位移并打印出来
2.7 布尔类型
在Java语言中用于描述真假数据的类型是：boolean，数值只有两个：true 和 false
其中boolean类型在内存空间中所占的字节没有明确的规定，通常认为是1个字节。
-------------------day03-------------------------
今天内容：
(1)数据类型
(2)运算符
(3)分支结构
1.数据类型
在Java语言中基本数据类型有：byte、short、int、long、float、double、boolean、char
1.1 字符类型
在Java语言中用于描述单个字符数据的类型是：char类型，如：‘1’、‘a’、'中’等
其中char类型在内存空间中占2个字节且没有符号位，表示范围是：0 ~ 65535.
由于现实生活中很少有数据可以用单个字符描述，因此以后的开发中很少使用char类型，而使用更多的是由多个字符串起来组成的字符串，使用String类型加以描述。
由于计算机的底层只识别0和1组成的二进制序列，因此像’a’这样的图案无法直接在计算机中存储，但现实生活中确实有这样的图案需要存储，为了使得这样的图案可以存储在计算机中就需要给该图案指定一个编号，将编号存储计算机中即可，这样的编号叫ASCII
要求大家记住的ASCII有：
‘a’ - 97 ‘A’ - 65 ‘0’ - 48 空格 - 32 换行符 - 10
要求大家记住的转义字符有：
" - " ’ - ’ \ - \ \n - 换行 \t - 制表符(tab键)
1.2 基本数据类型之间的转换
在Java语言中基本数据类型之间的转换有两种方式：
自动类型转换 - 主要指将小类型向大类型之间的转换。
强制类型转换 - 主要指将大类型向小类型之间的转换。
语法格式：目标类型 变量名 = (目标类型)源类型变量名
注意：
强转有风险，操作需谨慎！！！
2.运算符(重点)
2.1 算术运算符
- 表示加法运算符 - 表示减法运算符 * 表示乘法运算符
/ 表示除法运算符 % 表示取模/取余运算符
2.2 关系/比较运算符
表示是否大于运算符 >= 表示是否大于等于运算符
< 表示是否小于运算符 <= 表示是否小于等于运算符
== 表示是否等于运算符 != 表示是否不等于运算符
所有以关系运算符作为最终运算的表达式结果一定是boolean类型
2.3 自增减运算符
- 表示加法运算符 ++ 表示自增运算符，用于实现让变量自身的数值加1的效果
- 表示减法运算符 – 表示自减运算符，用于实现让变量自身的数值减1的效果
2.4 逻辑运算符
&& 表示逻辑与运算符，相当于汉语中"并且"，同真为真，一假为假。
|| 表示逻辑或运算符，相当于汉语中"或者"，一真为真，同假为假。
! 表示逻辑非运算符，相当于汉语中"取反"，真为假，假为真。
短路特性：
a.对于逻辑与运算符来说，若第一个条件为假则整个表达式为假，此时跳过第二个
条件不执行。
b.对于逻辑或运算符来说，若第一个条件为真则整个表达式为真，此时跳过第二个
条件不执行。
2.5 条件/三目运算符
条件表达式 ? 表达式1: 表达式2;
=> 判断条件表达式是否成立，若成立则执行表达式1，否则执行表达式2;
2.6 赋值运算符
(1)简单赋值
= 表示赋值运算符，用于将=右边的数据赋值给=左边的变量，覆盖变量原来的数值。
笔试题：
ia == 5; - 表示判断ia的数值是否等于5
5 == ia; - 表示判断5是否等于ia的数值，推荐该方式
ia = 5; - 表示将5赋值给变量ia，覆盖ia原来的数值
5 = ia; - 编译报错
(2)复合赋值
+=、 -=、 *=、 /=、 …
如：
int ia = 3;
ia = ia + 2; => ia = 5; 推荐该方式
ia += 2; => ia = 5;
2.7 运算符的优先级
a. ()的优先级极高；
b. =的优先级极低；
c. 若实在无法确认优先级，则使用()来确认即可；
--------------day04------------------
今天内容：
(1)分支结构
(2)循环结构
1.分支结构(重中之重)
1.1 基本概念
在某些特殊场合中需要进行条件判断并做出选择时，就需要使用分支结构。
1.2 if分支结构
(1)语法格式
if(条件表达式) {
语句块;
}
(2)执行流程
判断条件表达式是否成立
=> 若成立，则执行{}中的语句块;
=> 若不成立，则跳过{}中的代码不执行；
1.3 if-else分支结构
(1)语法格式
if(条件表达式) {
语句块1;
} else {
语句块2;
}
(2)执行流程
判断条件表达式是否成立
=> 若成立，则执行语句块1;
=> 若不成立，则执行语句块2;
1.4 if-else if-else分支结构
(1)语法格式
if(条件表达式1) {
语句块1;
}
else if(条件表达式2) {
语句块2;
}
…
else {
语句块n;
}
(2)执行流程
判断条件表达式1是否成立
=> 若成立，则执行语句块1
=> 若不成立，则判断条件表达式2是否成立
=> 若成立，则执行语句块2
=> 若不成立，则执行语句块n
2.循环结构(重中之重、难点)
2.1 基本概念
在某些特殊场合中，若希望重复执行一段代码时，则需要使用循环结构。
2.2 for循环
(1)语法格式
for(初始化表达式; 条件表达式; 修改初始值表达式) {
循环体;
}
(2)执行流程
执行初始化表达式 => 判断条件表达式是否成立
=> 若成立，则执行循环体 => 执行修改初始值表达式 => 判断条件表达式是否成立
=> 若不成立，则循环结束
2.3 break 和 continue关键字
break关键字用在循环中表示跳出当前循环；
continue关键字使用在循环中表示结束本次循环继续下一次循环(会用即可)；
2.4 特殊的循环
for(;😉 - 这种没有明确循环条件的循环叫做无限循环，俗称"死循环"。
该循环通常与break关键字搭配使用。
------------------------day05-----------------------
今天内容：
(1)循环结构
(2)一维数组
1.循环结构(重中之重)
1.1 for循环
(1)语法格式
for(初始化表达式; 条件表达式; 修改初始值表达式) {
循环体;
}
(2)执行流程
执行初始化表达式 => 判断条件表达式是否成立
=> 若成立，则执行循环体 => 执行修改初始值表达式 => 判断条件表达式是否成立 => 若不成立，则循环结束
1.2 双重for循环(难点)
(1)语法格式
for(初始化表达式1; 条件表达式2; 修改初始值表达式3) {
for(初始化表达式4; 条件表达式5; 修改初始值表达式6) {
循环体;
}
}
(2)执行流程
执行表达式1 => 判断表达式2是否成立
=> 若成立，则执行表达式4 => 判断表达式5是否成立
=> 若成立，则执行内层循环体 => 执行表达式6 => 判断表达式5是否成立 => 若不成立，则内层循环结束 => 执行表达式3 => 判断表达式2是否成立
=> 若不成立，则外层循环结束
(3)实际意义
在以后的开发中若希望打印多行多列的数据内容时，就应该使用双重for循环。
练习：
使用双重for循环分别打印以下星星图案：
***** * i=1时，1个* ***** i=1时，5个* *
***** ** i=2时，2个* **** i=2时，4个* ***
***** *** i=3时，3个* *** i=3时，3个* *****
***** **** i=4时，4个* ** i=4时，2个* *******
***** ***** i=5时，5个* * i=5时，1个* *********
i=1时，4个空格，1个* 空格：5-i
i=2时，3个空格，3个* : 2i-1
i=3时，2个空格，5个*
i=4时，1个空格，7个*
i=5时，0个空格，9个*
1.3 while循环(会用即可)
(1)语法格式
while(条件表达式) {
循环体;
}
(2)执行流程
判断条件表达式是否成立
=> 若成立，则执行循环体 => 判断条件表达式是否成立
=> 若不成立，则循环结束
(3)注意事项
a.while循环和for循环可以完全互换；
b.while循环主要用于明确循环条件但不明确循环次数的场合中；
for循环主要用于明确循环次数/范围的场合中；
c.while(true)和for(;;)都表示无限循环；
2.一维数组(重点)
2.1 基本概念
当需要在程序中记录单个数据内容时，则声明一个变量记录即可；
当需要在程序中记录多个类型相同的数据内容时，则声明一个一维数组即可；
一维数组本质上就是在内存空间中申请一段连续的存储单元；
2.2 声明方式
(1)语法格式
数据类型[] 数组名称 = new 数据类型[数组的长度];
如：
int[] arr = new int[3]; - 表示声明一个长度为3元素类型为int类型的一维数组
int num = 3; - 表示声明一个初始值为3元素类型为int类型的变量
int arr[] = new int[3]; - 不推荐使用
(2)元素的初始化
数据类型[] 数组名称 = {初始值1, 初始值2, …};
如：
int[] arr = {11, 22, 33}; - 声明一个长度为3元素类型为int类型的一维数组
--------------------day06--------------------
今天内容：
(1)二维数组
(2)面向对象编程的概念
(3)类和对象以及引用
(4)成员方法
1.二维数组(会用即可)
1.1 基本概念
当需要在程序中记录多个类型相同的数据内容时，则声明一个一维数组，而一维数组本质上就是在内存中申请一段连续的存储单元。
二维数组本质上就是由多个一维数组摞在一起组成的数组，也就是说二维数组中的每个元素是一个一维数组，而一维数组中的每个元素才是具体的数据内容。
1.2 声明方式
(1)语法格式
数据类型[][] 数组名称 = new 数据类型[行数][列数];
如：
int[][] arr = new int[2][3]; - 表示声明一个具有2行3列类型为int的二维数组
其中行下标范围是：0 ~ 1；
其中列下标范围是：0 ~ 2；
(2)元素的初始化
数据类型[][] 数组名称 = {{元素值1, 元素值2, …}, {元素值1,…},…};
如：
int[][] arr = {{1, 2, 3}, {4, 5, 6}}; - 表示声明一个2行3列的二维数组
2.面向对象编程的概念(理解)
2.1 什么是对象？
万物皆对象。
2.2 什么是面向对象？
所谓面向对象就是指以属性(特征)和行为的观点分析现实世界中事物的方式。
2.3 什么是面向对象编程？
所谓面向对象编程就是指先使用面向对象的思想进行分析，再使用面向对象的编程语言进行翻译的过程。
其中C语言是一门面向过程的编程语言。
其中C++语言是一门既面向过程又面向对象的编程语言。
其中Java语言是一门纯面向对象的编程语言。
3.类和对象以及引用(重中之重、难点)
如：
String name1 = “史梦龙”; …
String name2 = “闫雪松”; …
String name3 = “来国志”; …
…
人类：
特征：姓名、年龄
行为：吃饭、娱乐
3.1 类和对象的概念
对象主要指现实生活中客观存在的实体，在Java语言中体现为内存中的一块存储空间
类简单来说就是"分类"的含义，是对多个对象共性的抽象描述，在Java语言中体现为一种引用数据类型，里面包含了描述特征的成员变量和描述行为的成员方法。
3.2 类的定义
(1)类定义的语法格式
class 类名 {
类体;
}
如：
class Person {
}
注意：
当类名由多个单词组成时，通常要求每个单词的首字母都要大写。
(2)成员变量定义的语法格式
class 类名 {
数据类型 成员变量名 = 初始值; - 其中=初始值通常都省略，分号不可以省略
…
}
如：
class Person {
String name;
int age;
}
注意：
当成员变量名由多个单词组成时，通常要求第二个单词起首字母大写。
思考：
成员变量和局部变量有何区别？
解析：
局部变量主要指在方法体中定义的变量，作用范围从声明开始一直到方法体结束。
成员变量主要指在方法体外类体内定义的变量，作用范围从声明开始一直到类体结束
3.3 对象的创建
(1)语法格式
new 类名();
如：
new Person(); - 匿名对象
(2)注意事项
a.当一个类存在定义完毕后，可以使用new关键字来创建/构造该类的对象，
这个过程叫做类的实例化。
b.创建对象的本质就是在内存空间的堆区申请一块存储区域来存放该对象
独有的特征信息。
3.4 引用的定义
(1)基本概念
使用引用数据类型定义的变量叫做 引用型变量，简称为 “引用”。
定义引用本质就是在内存空间的栈区申请一块存储区域，来记录对象在堆区地址信息
(2)语法格式
类名 引用变量名;
如：
Person p; - 声明一个Person类型的引用变量p
Person p = new Person(); - 声明一个Person类型的引用指向Person类型的对象
引用变量名.成员变量名;
如：
p.name = “zhangfei”;
p.age = 30;
4.成员方法(重中之重)
4.1 语法格式
class 类名 {
返回值类型 成员方法名(形参列表) {
方法体;
}
}
如：
class Person {
void show() {
System.out.println(“没事秀出你的肌肉！！！”);
}
}
注意：
当成员方法名由多个单词组成时，通常要求从第二个单词起首字母大写。
4.2 成员方法的详解
(1)返回值类型
返回值主要指方法体内向方法体外返回的数值内容。
返回值类型主要指返回值的数据类型，可以是基本数据类型，也可以是引用数据类型
如：
当返回的数值内容是66时，则返回值类型写int即可；
当返回的数值内容是3.14时，则返回值类型写double即可；
当返回的数值内容是"hello"时，则返回值类型写String即可；
在方法体中使用return关键字可以返回具体的数值内容并结束当前方法。
如：
当返回的数值内容是66时，则方法体中写：return 66; 即可；
当返回的数值内容是"hello"时，则方法体中写：return “hello”; 即可；
当该方法不需要返回任何数据内容时，则返回值类型写void即可。
(2)形参列表
形式参数主要用于将方法体外的数据带入到方法体的内部。
形参列表主要指形式参数的列表，也就是多个形式参数，具体格式如下：
数据类型 形参变量名1, 数据类型 形参变量名2, …
如：
当该方法带入的数值内容是66时，则形参列表写：int i即可；
当该方法带入的数值内容是3.14时，则形参列表写：double d即可；
当该方法带入的数值内容是66和3.14时，则形参列表写：int i, double d即可；
当该方法带入的数值内容是66和"hello"时，则形参列表写：int i, String s即可
若该方法不需要带入任何数据内容时，则该方法的形参列表位置啥也不写即可。
(3)方法体的详解
方法体中主要用于编写描述该方法功能的语句。
4.3 方法的调用
(1)语法格式
引用变量名.成员方法名(实参列表);
如：
p.show(); - 表示使用引用变量p调用名字为show的成员方法
(2)注意事项
a.实际参数列表主要用于给形式参数列表进行初始化操作，因此实参列表的个数、
类型以及顺序等都必须与形参列表保持一致。
b.实际传递可以传递直接量、变量、表达式、方法的调用等。
--------------------day07-----------------------
今天内容：
(1)成员方法
(2)构造方法和方法重载
(3)this关键字
(4)方法的传参和递归调用
1.成员方法(重中之重)
练习：
编程实现Girl类，特征：姓名、年龄、是否有男朋友，行为有：打印所有特征的方法、修改姓名为参数指定数值的方法、修改年龄为参数指定数值的方法、修改是否有男朋友为参数指定数值的行为。
要求在main方法中声明Girl类型的引用指向Girl类型的对象并打印特征，通过调用方法的方式修改特征为"贺佳洋"、18、true后再次打印特征。
练习：
编程实现Circle类
， 特征有：横坐标、纵坐标、半径(整数)，
行为有：获取横坐标并返回的行为、
修改横坐标为参数指定数值的行为、
获取纵坐标并返回的行为
、修改纵坐标为参数指定数值的行为
、获取半径并返回的行为
、修改半径为参数指定数值的行为
、打印所有特征的行为。
要求在main方法中声明Circle类型的引用指向该类型的对象并打印特征
，通过调用方法的方式修改所有特征
再通过调用方法的方式获取所有特征并打印出来。
2.构造方法和方法重载
如：
Person p = new Person(); - 表示声明一个Person类型的引用指向Person类型对象
p.show(); - 表示调用名字为show的方法
2.1 构造方法(重中之重)
(1)语法格式
class 类名 {
类名(形参列表) {
构造方法体;
}
}
如：
class Person {
Person() {
}
}
(2)注意事项
a.要求方法名与类名相同且没有返回值类型，连void都不许有；
b.当使用new关键字创建对象时会自动调用构造方法来实现成员变量的初始化工作，
只有自定义构造方法才能在创建对象的同时来指定成员变量的数值；
(3)默认构造方法
a.当一个类中没有自定义构造方法时，编译器会提供一个无参的空构造方法，
叫做默认/缺省构造方法，如：Person(){}
b.若类中出现自定义构造方法，则编译器不再提供任何的构造方法。
练习：
编程实现Point类，特征有：横坐标和纵坐标，行为有：无参构造方法、有参构造方法、打印所有特征的方法。
要求在main方法中分别使用无参方式和有参构造方式构造对象并打印特征。
2.2 方法的重载(重点)
(1)基本概念
在Java语言中方法名相同、参数列表不同之间的方法构成重载关系(Overload).
(2)主要体现形式
方法重载的主要体现形式为：参数的个数不同、参数的类型不同以及参数的顺序不同
与形参变量名和返回值类型无关，但返回值类型最好相同。
判断方法能否重载的核心：调用时能否加以区分。
(3)实际意义
方法重载的实际意义在于调用者只需要记住一个方法名就可以调用各种不同的版本从而实现各种不同的效果。
如：
char c1 = ‘a’;
System.out.println©;
int i1 = 10;
System.out.println(i1);
double d1 = 3.14;
System.out.println(d1);
3.this关键字(原理、尽量理解)
3.1 基本概念
当this关键字出现在构造方法时，代表当前正在构造的对象；
当this关键字出现在成员方法时，代表当前正在调用的对象；
3.2 原理分析
当成员方法中访问成员变量时默认会加上this.的前缀，this.相当于汉语中"我的"，当不同的对象调用同一个方法时，由于正在调用该方法的对象不同就导致this的数值不同，而this的数值不同就导致this.访问的结果随之不同。
3.3 使用方式
(1)当成员变量名与形参变量名同名时，若希望在方法体中明确要求使用成员变量，
则需要在成员变量名的前面加上this.的前缀(重中之重)；
(2)在构造方法的第一行可以使用this(实参)的方式来调用本类中的其它构造方法(了解);
4.方法的传参过程和递归调用
4.1 方法的传参过程(原理分析)
(1)main方法是程序的入口，为main方法中的局部变量开辟内存空间并初始化；
(2)调用max方法时，为max方法的形参变量开辟内存空间并初始化；
(3)将实参变量的数值赋值给形参变量，执行max方法的方法体；
(4)当max方法执行完毕后，释放max方法中形参变量的内存空间；
(5)main方法中res得到max方法的返回值并继续向下执行；
要求大家掌握的内容：
a.当基本数据类型的变量作为参数传递时，通常形参变量的改变不会影响到实参变量
b.当引用数据类型的变量作为参数传递时，通常形参变量指向内容的改变会影响到
实参变量指向的内容。
c.当引用数据类型的变量作为参数传递时，通常形参变量改变指向后再改变指向的
内容时不会影响到实参变量指向的内容。
-----------------day08---------------------
今天内容：
(1)方法的递归调用
(2)封装
(3)static关键字
1.方法的递归调用(重点、难点)
案例：
自定义成员方法实现参数n阶乘的计算并返回。
解析：
5! = 5 * 4 * 3 * 2 * 1;
4! = 4 * 3 * 2 * 1;
3! = 3 * 2 * 1;
2! = 2 * 1;
1! = 1;
再次解析：
5! = 5 * 4!;
4! = 4 * 3!;
3! = 3 * 2!;
2! = 2 * 1!;
1! = 1;
n! = n * (n-1)!;
1.1 基本概念
递归就是指在一个方法体的内部调用当前方法自身的形式。
1.2 使用原则
a.使用递归必须有规律并且有退出条件；
b.使用递归必须使得问题简单化而不是复杂化；
c.递归可能会影响到程序的执行性能，此时使用递推取代之；
2.封装(重中之重、20遍)
2.1 基本概念
通常情况下在测试类中可以直接访问其它类中的成员变量，当成员变量的数值合法但不合理时，无论是编译阶段还是运行阶段都不会报错或者给出提示，此时与现实生活不符
为了避免上述问题的发生，就需要对类中的成员变量进行密封包装处理来保证成员变量的隐秘性和合理性，该机制就叫做封装，换句话说，封装就是保证成员变量值合理性的机制。
2.2 实现流程
(1)私有化成员变量，使用private关键字修饰；
(2)提供公有的get和set方法使用public关键字修饰，并在方法体中进行合理值的判断
(3)在构造方法中调用set方法进行合理值的判断；
练习：
编程实现Person类封装，特征有：姓名、年龄、国籍，要求提供打印所有特征的方法 编程实现PersonTest类，在main方法中使用有参方式构造两个对象并打印特征
3.static关键字(重点)
3.1 基本概念
通常情况下成员变量隶属于对象层级，每当创建一个对象时就会在堆区申请一块存储区域来存放该对象独有的成员变量信息，若所有对象中某个成员变量的信息一定相同却还在单独保存时，会造成内存空间的浪费。
为了解决该问题就需要使用static关键字来修饰成员变量表达静态的含义，此时该成员变量由对象层级提升为类层级被所有对象共享，与是否创建对象无关。
static关键字还可以修饰成员方法，推荐使用 类名. 的方式访问。
3.2 使用方式
(1)非静态的成员方法中既能访问非静态的成员也能访问静态的成员；
(成员：成员变量 + 成员方法，静态的成员被所有对象共享)
(2)静态的成员方法只能访问静态的成员不能访问非静态的成员；
(成员：成员变量 + 成员方法，调用静态方法时可能还没有创建对象)
(3)只有隶属于类层级并被所有对象共享的内容才可以使用static关键字修饰；
(也就是不能滥用static关键字)
案例:
编程实现Singleton类的封装；
编程实现SingletonTest类的实现，要求在main方法中能得到且只能得到Singleton类的一个对象。
3.3 单例设计模式(重中之重 20遍)
(1)基本概念
当一个类对外提供且只提供一个对象时，这样的类叫做单例类。
而设计单例类的思想和模式叫做单例设计模式。
(2)实现流程
a.私有化构造方法，使用private关键字修饰；
b.声明本类类型的引用指向本类类型的对象并使用private static关键字修饰；
c.提供公有的get方法负责将上述对象返回出去并使用public static关键字修饰；
(3)实现方式
单例设计模式主要有两种：饿汉式 和 懒汉式，在以后的开发中推荐使用饿汉式。
-----------------------day09---------------------
今天内容：
(1)继承
(2)访问控制
(3)final关键字
1.继承(重中之重 20遍)
人类：
特征：姓名、年龄
行为：吃饭、娱乐
学生类 吸收 人类：
特征：学号
行为：学习
教师类 吸收 人类：
特征：工号
行为：讲课
工人类 吸收 人类：
特征：薪水
行为：工作
… …
1.1 基本概念
当多个类之间有相同的特征和行为时，可以将相同的特征和行为提取出来组成一个公共类，让多个类分别吸收公共类中已有特征和行为而在公共类只需要编写自己独有特征和行为的机制，叫做继承。
使用继承提高了代码的复用性，可维护性以及可扩展性。
在Java语言中使用extends(扩展)关键字来表达继承关系，
如：
public class Worker extends Person{} - 表示Worker类继承自Person类
其中Person类是被继承的类，叫做超类、父类、基类。
其中Worker类是继承其它类的类，叫做派生类、子类、孩子类。
练习：
编程实现Person类的封装，特征有：姓名和年龄，要求提供打印所有特征的方法。
编程实现Worker类继承自Person类，Worker类内部暂时啥也不写即可
编程实现WorkerTest类，在main方法中使用无参方式构造对象Worker类型对象并打印
1.2 注意事项
(1)子类不可以继承父类的构造方法和私有方法，但私有特征可以继承只是不能使用；
(2)无论使用何种方式构造子类的对象时都会自动调用父类的无参构造方法来初始化从
父类中继承下来的成员变量，相当于在构造方法的第一行增加 super()的效果；
(3)使用继承必须满足逻辑关系：子类 is a 父类，也就是不能滥用继承；
(4)Java语言中支持单继承不支持多继承，也就是一个子类只能有一个父类，但一个
父类可以有多个子类；
1.3 方法的重写(Override)
(1)基本概念
从父类中继承下来的方法不足以满足子类的需求时，就需要在子类中重新写一个和父类基本一样的方法来覆盖从父类中继承的版本，这个过程就叫做方法的重写。
(2)重写的原则
a.要求方法名相同、参数列表相同及返回值类型相同，从jdk1.5开始允许返回子类类型
b.要求访问权限不能变小，可以相同或者变大；
c.要求不能抛出更大的异常(异常机制)；
练习：
编程实现Animal类的封装，特征有：名字，要求提供打印所有特征的方法；
编程实现Dog类封装继承自Animal类，特征有：牙齿数量，要求提供打印所有特征方法
集成开发环境：eclipse、MyEclipse、Idea、…
2.访问控制(笔试题)
2.1 常用的访问控制符
访问控制符 访问权限 本类内部 本包中的类 子类内部 其它包中的其它类
public 公开的 ok ok ok ok
protected 保护的 ok ok ok no
啥也不写 默认的 ok ok no no
private 私有的 ok no no no
要求大家掌握的内容：
a.public修饰的内容可以在任意位置使用；
b.private修饰的内容只能在本类的内部使用；
c.通常情况下，成员变量都采用private修饰，成员方法都采用public修饰；
2.2 包的定义
package 包名; - 用于定义单层包
package 包名1.包名2…包名n; - 用于定义多层包，为了便于管理和解决同名问题
3.final关键字(重点)
3.1 基本概念
final关键字本意为"最终的、最后的、不可改变的"，可以修饰类、成员方法以及成员变量等。
3.2 使用方式
使用final关键字修饰类体现在该类不能被继承。
- 主要为了防止滥用继承，如：java.lang.String等
使用final关键字修饰成员方法体现在该方法不能被重写但可以被继承。
- 主要为了防止不经意间造成方法的重写，如：java.text.DateFormat类中format 使用final关键字修饰成员变量表示该成员变量必须初始化且不能更改。
- 主要为了防止不经意间造成数值的改变，如：java.lang.Thread类MAX_PRIORITY
扩展：
在以后的开发中很少但是用static关键字或者final关键字来修饰成员变量，而是通常使用public static final关键字共同修饰成员变量来表达常量的含义，常量的命名规范是所有字母大写，不同单词之间采用下划线连接，如：
public static final double PI = 3.14;
----------------------day10---------------------
今天内容：
(1)多态
(2)抽象类
(3)接口
(4)匿名内部类
1.多态(重中之重、难点 20遍)
1.1 基本概念
多态主要指同一种事物表现出来的多种形态。
饮料：可乐、雪碧、脉动、红牛、乐虎、江小白、…
宠物：猫、狗、鸟、鱼、小强、…
人： 学生、教师、工人、保安、朋友、…
1.2 语法格式
父类类型 引用变量名 = new 子类类型();
如：
Person pw = new Worker();
pw.show();
解析：
编译阶段调用Person类中的show方法，运行阶段调用Worker类中的show方法
练习：
编程实现Person类的封装，特征有：姓名和年龄，要求提供打印所有特征的方法；
编程实现Worker类的封装继承Person类，特征有：薪水，要求提供打印所有特征方法
编程实现PersonWorkerTest类，在main方法中分别创建Person和Worker类型对象并打印各自的特征。
1.3 多态的效果
(1)当父类类型的引用指向子类类型的对象时，父类引用可以直接调用父类独有的方法；
(2)当父类类型的引用指向子类类型的对象时，父类引用不可以直接调用子类独有的方法
(3)对于父子类都拥有非静态方法来说，编译阶段调用父类版本，运行阶段调用子类版本
(4)对于父子类都拥有静态方法来说，编译和运行阶段都调用父类版本；
1.4 引用数据类型之间的转换
(1)在Java语言中引用类型之间的转换方式有两种：自动类型转换 和 强制类型转换。
其中自动类型转换主要指从小类型到大类型之间的转换，也就是子类到父类的转换；
其中强制类型转换主要指从大类型到小类型之间的转换，也就是父类到子类的转换；
(2)引用数据类型之间必须发生在父子类之间，否则编译报错；
(3)若强转的目标类型不是该引用变量真正指向的数据类型时，则编译阶段通过，
运行阶段发生类型转换异常；
1.5 实际意义
多态的实际意义在于屏蔽不同子类的差异性实现通用的编程从而代表不同的效果。
2.抽象类(重点)
2.1 抽象方法
抽象方法就是指不能具体实现并且使用abstract关键字修饰的方法。
语法格式如下：
访问权限 abstract 返回值类型 方法名称(形参列表);
public abstract void cry();
2.2 抽象类
抽象类就是指不能实例化对象并且使用abstract关键字修饰的类。
2.3 注意事项
(1)抽象类中可以有成员变量、成员方法以及构造方法。
(2)抽象类中可以没有抽象方法，也可以有抽象方法。
(3)拥有抽象方法的类必须是抽象类，因此真正意义上的抽象类应该是使用
abstract关键字修饰并且拥有抽象方法的类。
2.4 实际意义
抽象类的实际意义不在于实例化对象而在于被继承，当一个类继承抽象类后必须重写抽象方法，否则该类也得变成抽象类。
抽象类对子类具有强制性和规范性，因此叫做模板设计模式。
2.5 经验的分享
在以后的开发中推荐使用多态的语法格式，此时父类引用可以直接调用的所有方法一定是父类中拥有的方法，若希望更换子类时，只需要将new关键字后面的类型修改而其它地方无需修改立即生效，从而提高了代码的可维护性。
该方式的缺点是：父类引用不能直接调用子类独有的方法，若调用则需要强转。
3.接口(重点)
3.1 基本概念
接口本质上就是一种比抽象类还抽象的类，所有方法都是抽象方法。
定义抽象类的关键字是abstract class，而定义接口的关键字是interface。
如：
金属接口 货币接口 黄金类
练习：
自定义Runner接口，提供一个描述奔跑的抽象方法run；
自定义Hunter接口继承Runner接口，提供一个描述捕猎的抽象方法hunt；
自定义Chinese类实现Hunter接口并重写抽象方法，在main方法中使用多态的格式创建对象并调用方法测试。
3.2 类和接口之间的关系
类和类之间采用继承关系 使用extends关键字 支持单继承
类和接口之间采用实现关系 使用implements关键字 支持多实现
接口和接口之间采用继承关系 使用extends关键字 支持多继承
3.3 抽象类和接口之间的主要区别(笔试题)
(1)定义抽象类的关键字是abstract class，而定义接口的关键字是interface;
(2)继承抽象类的关键字是extends，而实现接口的关键字是implements;
(3)继承抽象类支持单继承，而实现接口支持多实现；
(4)抽象类中可以有构造方法，而接口不可以有构造方法；
(5)抽象类中可以有成员变量，而接口中只可以有常量；
(6)抽象类中可以有成员方法，而接口中只可以有抽象方法；
(7)抽象类中增加方法子类可以不用重写，而接口中增加方法基本都需要实现类重写；
(8)从jdk1.8开始允许接口中有非抽象方法，但必须使用default关键字修饰；
4.匿名内部类(重点、难点)
4.1 接口类型引用作为方法形参时实参的传递方式有两种：
(1)自定义类实现接口，然后创建自定义类的对象作为实参传递即可；
(2)使用匿名内部类的语法格式来得到接口类型的引用作为实参传递即可；
4.2 匿名内部类的语法格式
接口/父类类型 引用变量名 = new 接口/父类类型(){ 方法的重写 };
如：
class A {
class B {
}
}
----------------------day11--------------------
今天内容：
(1)Object类
(2)包装类和数学处理类
(3)String类
1.Object类
1.1 常用的包
java.lang包 - 该包是Java语言的核心包，该包中的内容由Java虚拟机自动导入
- 如：String类、System类等
java.util包 - 该包是Java语言的工具包，该包中提供了大量的工具类和集合类
- 如：Scanner类、Random类等
java.io包 - 该包是Java语言的输入输出包，该包中提供了大量读写文件的类
- 如：FileInputStream类、FileOutputStream类等
java.net包 - 该包是Java语言的网络包，该包中提供了大量网络编程的类
- 如：ServerSocket类、Socket类等
…
1.2 Object类
(1)基本概念
java.lang.Object类是类层次结构的根类，任何类都是该类的直接或间接子类。
(2)常用的方法(重点)
boolean equals(Object obj)
- 主要用于判断当前正在调用的对象是否与参数对象obj相等
- 该方法默认比较两个对象的地址，与 == 的结果一致。
- 为了使得该方法可以比较两个对象的内容需要重写该方法。
- 若该方法重写后应该重写hashCode方法来维护常规协定。
int hashCode()
- 主要用于获取调用对象的哈希码值(内存地址的编号)。
- 若两个对象调用equals方法相等，则各自调用hashCode方法必须相同
- 若两个对象调用equals方法不相等，则各自调用hashCode方法应该不同
- 若希望该方法的结果与equals方法保持一致，需要重写该方法
String toString()
- 主要用于返回调用对象的字符串形式
- 该方法默认返回：包名.类名@哈希码值的十六进制
- 当需要返回更有意义的数据内容时，需要重写该方法
- 使用print()/println()/字符串拼接 引用时，会自动调用toString方法
练习：
编程实现Student类的封装，特征有：学号和姓名，要求提供打印所有特征的方法
编程实现StudentTest类，在main方法中使用有参方式构造两个对象并分别打印
2.包装类和数学处理类(会用即可)
如：
Person p = new Person(); - 表示声明Person类型的引用指向Person类型的对象
int num = 10; - 表示声明一个int类型的变量num初始值为10
Java语言是一门纯面向对象的编程语言，万物皆对象！
class MyInt {
private int num = 10; // 成员变量
}
MyInt mi = new MyInt();
2.1 包装类的概念
在某些特殊场合(集合)中要求所有数据内容都必须是对象，而对于Java语言中的8种基本数据类型声明的变量来说不满足该需求，此时就需要对基本数据类型的变量进行密封包装处理成对象来使用，而密封包装处理的类就叫做包装类。
2.2 常用的包装类
int => java.lang.Integer类
char => java.lang.Character类
其它类型都是将首字母换成大写即可
2.3 Integer类
(1)基本概念
java.lang.Integer类是int类型的包装类，里面包含了一个int类型的成员变量。
(2)常用的方法
2.4 BigDecimal类
(1)基本概念
由于Java语言中的float类型和double类型在运算时可能会有误差，若希望实现精确结果则借助java.math.BigDecimal类加以描述。
(2)常用的方法
3.String类(重中之重)
3.1 基本概念
java.lang.String类主要用于描述字符串数据，Java程序中所有的字符串字面值都可以使用String类的对象加以描述，如："hello"等。
该类由final关键字修饰表示该类不能被继承。
该类描述的字符串内容是个常量，一旦创建则内容无法改变，
如：
String str1 = “abc”;
str1 = “123”; - 改变引用变量的指向，而不是指向的内容
3.2 常量池(原理)
由于String类型描述的字符串内容不可改变，因此可以将出现的字符串字面值放入常量池中，若下次出现重复的字符串则直接使用池中已有的字符串对象即可，从而提高性能
------------------------day12------------------
今天内容：
(1)String类
(2)StringBuffer类和StringBuilder类
(3)日期相关的类
1.String类(重中之重)
1.1 常用的方法(练熟、记住)
2.StringBuffer类和StringBuilder类(重点)
2.1 基本概念(笔试题)
String类描述的字符串内容是个常量，不可改变；
StringBuffer类和StringBuilder类描述的字符串内容是个可以改变的字符序列。
其中StringBuffer类是从jdk1.0就有的早期类，支持线程安全但效率比较低；
其中StringBuilder类是从jdk1.5开始有的类，不支持线程安全但效率比较高；
--------------------day13------------------------
今天内容：
(1)日期相关的类
(2)集合框架
(3)Collection集合
(4)List集合
(5)泛型机制
1.日期相关的类(会用即可)
1.1 Date类
(1)基本概念
java.util.Date类主要用于描述特定的瞬间，也就是年月日时分秒可以精确到毫秒。
1秒 = 1000毫秒
(2)常用的方法
1.2 SimpleDateFormat类
(1)基本概念
java.text.SimpleDateFormat类主要用于实现日期和文本类型之间的转换。
(2)常用的方法
1.3 Calendar类
(1)基本概念
java.util.Calendar类主要用于取代Date类型实现年月日时分秒的描述。
该类是个抽象类，因此不能创建对象。
(2)常用的方法
2.集合框架(重点)
2.1 集合的由来
当需要在程序中记录单个数据内容时，则声明一个变量即可；
当需要在程序中记录多个类型相同的数据内容时，则声明一个一维数组即可；
当需要在程序中记录多个类型不同的数据内容时，则构造一个对象即可；
当需要在程序中记录多个类型相同的对象数据时，则声明一个对象数组即可；
当需要在程序中记录多个类型不同的对象数据时，则声明一个集合即可；
2.2 集合的框架
Java语言中集合框架的顶层是：java.util.Collection集合 和 java.util.Map集合
其中Collection集合中存取元素的基本单位是：单个元素。
其中Map集合中存取元素的基本单位是：单对元素。
3.Collection集合(重点)
3.1 常用的方法(练熟、记住)
4.List集合(重中之重)
4.1 基本概念
java.util.List集合是Collection集合的子集合，元素有先后放入次序且允许重复。
该集合的主要实现类有：ArrayList类、LinkedList类、Stack类、Vector类。
其中ArrayList类的底层是采用动态数组来实现数据的管理，访问方便但增删不方便
其中LinkedList类的底层是采用双向链表来实现数据的管理，访问不方便但增删方便
其中Stack类的底层是采用动态数组来实现数据的管理，但该类主要用于描述具有后进先出特征的数据结构，叫做栈(last in first out LIFO)
其中Vector类的底层是采用动态数组实现数据的管理，与ArrayList类相比属于线程安全的类，因此效率比较低。
---------------------day14------------------
今天内容：
(1)泛型机制
(2)Queue集合
(3)Set集合
(4)Map集合
1.泛型机制(重点)
如：
List lt1 = new LinkedList();
lt1.add(“one”); // String类型
lt1.add(2); // Integer类型
lt1.add(new Student(1001, “zhangfei”, 30)); // Student类型
…
1.1 基本概念
通常情况下集合中可以存放不同类型的元素是因为全部看做Object类型放入的，因此从集合中取出元素时也是Object类型，为了表达元素的真实类型则需要强制类型转换，而该转换可能会引发类型转换异常。
为了避免上述异常的发生，从jdk1.5开始提出泛型机制，所谓泛型机制就是在集合名称的右侧使用<数据类型>的方式来明确要求该集合中可以存放的元素类型，若存放其它类型的元素则直接编译报错。
如：
List lt1 = new LinkedList();
1.2 泛型的本质
泛型的本质是参数化类型，也就是让数据类型作为参数传递，其中E相当于集合中的形式参数负责占位，而使用集合时<>中的数据类型相当于集合中的实际参数，实际参数用于给形式参数初始化。
由于实际参数支持非常广泛的数据类型，因此得名为"泛型"。
如：
// 其中i叫做形式参数，负责占位 其中E叫做形式参数，负责占位
// int i = 5; E = String;
// int i = 8; E = Student;
public void show(int i) { public interface List {
… …
} }
// 其中5叫做实际参数，用于给形参初始化 其中String叫做实际参数，用于形参…
show(5); List lt1 = …;
show(8); List lt2 = …;
2.Queue集合(重点)
2.1 基本概念
java.util.Queue集合是Collection集合的子集合，与List集合是平级关系。
该集合主要用于描述具有先进先出特征的数据结构，叫做队列(first in first out FIFO).
该集合的主要实现类是：LinkedList类，选择该类是因为增删比较方便。
2.2 常用的方法
3.Set集合(重点)
3.1 基本概念
java.util.Set集合是Collection集合的子集合，与List集合属于平级关系。
该集合中元素没有先后放入次序，并且该集合中不允许有重复的元素。
该集合的主要实现类有：HashSet类 和 TreeSet类。
其中HashSet类的底层是采用哈希表进行数据管理的。
其中TreeSet类的底层是采用二叉树进行数据管理的。
3.2 常用的方法
参考Collection集合中的方法即可！
3.3 增强版的for循环(for each结构)
(1)语法格式
for(元素类型 变量名 : 集合/数组名称) {
循环体;
}
(2)执行流程
不断地从集合/数组中取出一个元素赋值给变量名然后执行循环体，直到取完所有元素
4.Map集合(重点)
4.1 基本概念
java.util.Map<K,V>集合中存取元素的基本单位是：单对元素，而具体类型参数如下：
K - 此映射所维护的键(Key)的类型
V - 映射值(Value)的类型
该集合中不能包含重复的键，并且每个键只能对应一个值。
该集合的主要实现类是：HashMap类 和 TreeMap类。
--------------------day15---------------------
今天内容：
(1)异常机制
(2)File类
(3)I/O流
1.异常机制(重点、简单)
1.1 基本概念
异常就是"不正常"的含义，在Java语言中体现为运行阶段发生的错误。
java.lang.Throwable类是所有错误(Error类)和异常(Exception类)的超类。
其中Error类主要用于描述比较严重无法编码解决的错误，如：JVM挂了等。
其中Exception类主要用于描述比较轻微可以编码解决的错误，如：0作为除数等。
1.2 异常的分类
java.lang.Exception类是所有异常的超类，主要分为以下两类：
RuntimeException - 运行时异常，也叫作非检测性异常
IOException和其它异常 - 其它异常，也叫作检测性异常
- 所谓检测性异常就是指在编译阶段能够被编译器检测出来的异常
注意：
当程序执行过程中发生了异常但又没有手动处理时，由Java虚拟机采用默认方式处理，而默认处理的结果就是：打印异常名称、异常原因、异常发生的位置并终止程序。
1.3 异常的避免
在以后的开发中尽量使用if分支结构避免异常的发生。
1.4 异常的捕获
(1)语法格式
try {
可能发生异常的语句;
}
catch(异常类型 变量名) {
针对该类异常处理的代码;
}
…
finally {
编写无论是否发生异常都会执行的代码;
}
(2)注意事项
a.当编写多个catch分支时，切记小类型必须放在大类型的上面；
b.finall{}中主要用于编写善后处理的代码，如：关闭已经打开的文件等
(3)执行流程
try {
a;
b; - 可能发生异常的语句
c;
}
catch(){
d;
}
finally{
e;
}
当没有发生异常时的执行流程：a b c e;
当发生异常时的执行流程：a b d e;
1.5 异常的抛出
(1)基本概念
在程序的执行过程中某些异常不能处理或者不便于处理时，可以将这些异常转移给方法的调用者，这个过程就叫做异常的抛出。
(2)语法格式
访问权限 返回值类型 方法名称(形参列表) throws 异常类型1, 异常类型2, …{}
如：
public void show() throws IOException {}
1.6 自定义异常
(1)基本概念
虽然Java官方提供了大量的异常类，但没有提供针对年龄不合理的异常类型，若希望在开发中描述这种具备针对性的异常，则需要程序员自定义异常类。
(2)实现流程
a.自定义xxxException继承自Exception或者Exception的子类；
b.提供两个版本的构造方法：无参构造方法 和 字符串作为参数的构造；
2.File类(会用即可)
2.1 基本概念
java.io.File类主要用于描述硬盘上的文件或目录，可以获取文件或目录的属性信息
2.2 常用的方法
3.I/O流
3.1 基本概念
I/O就是Input/Output的简写，也就是输入/输出的含义。
I/O流就是指读写数据时像流水一样不间断，得名为"流"。
3.2 基本分类
根据读写数据的单位不同分为：字节流 和 字符流。
其中字节流主要指以字节为单位进行读写的流，可以读写任意类型的文件。
其中字符流主要指以字符(2个字节)为单位进行读写的流，只能读写文本文件。
根据数据流动的方向不同分为：输入流 和 输出流(站在程序的角度)。
其中输入流主要指将文件中的数据内容输入到程序中，也就是读文件。
其中输出流主要指将程序中的数据内容输出到文件中，也就是写文件。
3.3 FileOutputStream类(重中之重)
(1)基本概念
java.io.FileOutputStream类主要用于将图像数据之类的原始字节流写入到输出流中.
(2)常用的方法
3.4 FileInputStream类(重中之重)
(1)基本概念
java.io.FileInputStream类主要用于从输入流中读取图像数据之类的原始字节流。
--------------------day16-----------------------
今天内容：
(1)I/O流
(2)线程
1.I/O流
1.1 PrintStream类(重点)
(1)基本概念
java.io.PrintStream类主要用于方便地打印各种数据内容。
(2)常用的方法
1.2 BufferedReader类(重点)
(1)基本概念
java.io.BufferedReader类主要用于从字符输入流中读取单个字符、字符数组以及一行字符串内容。
(2)常用的方法
1.3 ObjectOutputStream类(重点)
(1)基本概念
java.io.ObjectOutputStream类主要用于将Java语言中的对象整体写入输出流中。
只能将支持 java.io.Serializable 接口的对象写入流中
类通过实现 java.io.Serializable 接口以启用其序列化功能。
所谓序列化就是指将对象中所有相关的数据内容有效地组织成字节序列的转化过程。
(2)常用的方法
1.4 ObjectInputStream类(重点)
(1)基本概念
java.io.ObjectInputStream类主要用于从输入流中将对象整体读取出来。
(2)常用的方法
经验分享：
当需要向输出流中写入多个对象时，可以先将多个对象放入一个集合中，然后将集合看做一个整体调用一次writeObject方法写入输出流中，此时只需要调用一次readObject方法就可以将整个集合读取出来。
2.线程
2.1 基本概念
程序 - 数据结构 + 算法，主要指存放在硬盘上的可执行文件。
进程 - 主要指运行在内存中的可执行文件。
目前主流的操作系统都支持多进程，为了让操作系统可以同时执行多个任务，但进程是重量级的，新建进程对系统资源的消耗比较大，因此进程的数量比较局限。
线程是进程内部的程序流，也就是说操作系统中支持多进程，而每个进程的内部又可以支持多线程，而且线程是轻量级的，新建线程会共享所在进程的资源，因此目前主流的开发都采用多线程结束。
多线程的底层是采用时间片轮转法来保证线程的并发执行，所谓并发就是指宏观并行微观串行的机制。
2.2 线程的创建(重中之重)
(1)线程的创建和启动方式
java.lang.Thread类用于描述线程，Java虚拟机允许应用程序并发地运行多个执行线程，具体方式如下：
a.自定义类继承Thread类并重写run方法，然后创建该类的对象调用start方法；
b.自定义类实现Runnable接口并重写run方法，然后创建该类的对象作为实参来
创建Thread类型的对象，最后使用Thread类型对象调用start方法；
(2)相关方法的解析
Thread() - 使用无参方式构造对象。
Thread(String name) - 根据参数指定的名字来构造对象。
Thread(Runnable target) - 根据参数指定的引用来构造对象。
Thread(Runnable target, String name) - 根据参数指定的引用和名称共同构造对象
void run()
- 若构造对象使用Runnable引用，则调用该方法的本质就是调用引用指向的run方法
- 若构造对象没有使用Runnable引用，则调用该方法的本质就是啥也不做
void start()
- 用于启动线程，Java虚拟机自动调用该线程中的run方法。
(3)原理分析
a.执行main方法的线程叫做主线程，执行run方法的线程叫做子线程；
b.对于start方法之前的代码来说，由主线程执行一次，当start方法调用成功后，
线程的个数由1个变成了2个，主线程继续向下执行，新启动的线程去执行run方法，
两个线程各自独立运行互不影响；
c.当main方法结束主线程结束，当run方法结束后子线程结束；
注意：
继承Thread类的方式代码简单，但Java语言中支持单继承，若该类继承Thread类后则无法继承该类真正的父类，而实现Runnable接口的方式虽然代码复杂，但不影响该类继承别的类以及实现别的接口，因此在以后的开发中推荐第二种方式。
2.3 线程的编号和名称(会用即可)
2.4 线程的常用方法(重点)
--------------------day17--------------------------
今天内容：
(1)线程的常用方法
(2)线程的同步机制
(3)网络编程的常识
(4)基于tcp协议的编程模型
1.线程的常用方法(重点)
2.线程的同步机制(重点)
2.1 基本概念
当多个线程同时访问同一种共享资源时，可能会造成数据的覆盖等不一致性问题，此时就需要进行线程之间的通信和协调，该机制就叫线程的同步机制。
2.2 解决方案
由程序结果可知：当两个线程同时执行取款操作后，最终的账户余额不正确
引发原因：线程一还没有取款结束，但线程二已经开始取款
解决方案：将取款操作线程的并发执行 改为 线程的 串行执行
2.3 实现方式
在Java语言中提供了一种内置的锁机制来保证代码执行的原子性，而实现该机制就需要借助synchronized关键字。
2.4 死锁的概念
线程一执行的代码：
public void run() {
synchronized(a) { // 持有对象锁a，等待对象锁b
synchronized(b) {
…
}
}
}
线程二执行的代码：
public void run() {
synchronized(b) { // 持有对象锁b，等待对象锁a
synchronized(a) {
…
}
}
}
注意：
在以后的开发中尽量不要使用同步代码块的嵌套结构。
3.网络编程的常识
目前主流的网络通讯软件有：QQ、微信、飞信、阿里旺旺、钉钉、YY、陌陌、探探…
在吗？
3.1 七层网络模型
为了数据传输的可靠性和安全性，ISO(国际标准委员会组织)将数据的传递从逻辑上划分为以下七层：
应用层、表示层、会话层、传输层、网络层、数据链路层、物理层
当发送数据时，会将发送的数据按照上述七层网络模型进行层层加包再发送出去；
当接收数据时，会将接收的数据按照上述七层网络模型相反的次序进行层层拆包；
3.2 IP地址
如：
192.168.1.1 - 是绝大多数路由器的登录地址，设置账号和密码等
IP地址是互联网中的唯一地址标识，也就是根据IP地址可以定位到具体某一台设备。
IP地址本质上是32位二进制组成的整数，叫做IPv4，当然也有128位二进制组成的整数，叫做IPv6，目前主流的还是IPv4.
日常生活中采用点分十进制表示法进行IP地址的描述，也就是将每个字节的二进制转换为一个十进制整数，不同的整数之间采用小数点隔开。
如：
真实的IP地址： 0000 0001 0000 0010 0000 0011 0000 0100 二进制
点分十进制表示法：1.2.3.4
3.3 端口号
IP地址可以定位到具体某一台设备，而端口号可以定位到设备中的具体某一个进程。
网络编程需要提供：IP地址 和 端口号
端口号本质上是16位二进制组成的整数，表示的范围是：0 ~ 65535，其中0 ~ 1024之间的端口号通常被系统占用，因此开发从1025开始使用。
4.基于tcp协议的编程模型(重点)
4.1 编程模型
服务器：
(1)创建ServerSocket类型的对象并提供端口号；
(2)等待客户端的连接请求，调用accept方法；
(3)使用输入输出流进行通信；
(4)关闭Socket并释放有关的资源；
客户端：
(1)创建Socket类型的对象并提供服务器的通信地址和端口号；
(2)使用输入输出流进行通信；
(3)关闭Socket并释放有关的资源；
------------------day18----------------------
今天内容：
(1)反射机制
(2)常用的设计原则
1.反射机制(重点、原理、难点、尽量理解)
如：
Person p = new Person(); - 表示声明Person类型的引用指向Person类型的对象
p.show(); - 表示调用名字为show的成员方法
1.1 基本概念
通常情况下，编写的代码以及该代码运行的结果都是固定不变的，若希望编写的代码可以带来不同的运行结果，此时就需要使用反射机制。
换句话说，反射机制就是用于动态创建对象以及动态调用方法的机制。
1.2 Class类
(1)基本概念
Class类的实例表示正在运行的Java应用程序中的类和接口，也就是说Class类型的对象不再单纯地代表堆区中的内存区域，而是用于代表Java语言中的一种数据类型。
Class没有公共构造方法。Class对象是在加载类时由 Java 虚拟机以及通过调用类加载器中的 defineClass 方法自动构造的。
(2)Class对象的获取方式
(3)常用的方法
1.3 Constructor类
(1)基本概念
java.lang.reflect.Constructor类主要用于描述获取到的单个构造方法信息。
(2)常用的方法
1.4 Field类
(1)基本概念
java.lang.reflect.Field类主要用于描述获取到的单个成员变量信息。
(2)常用的方法
1.5 Method类
(1)基本概念
java.lang.reflect.Method类主要用于描述获取到的单个成员方法信息。
(2)常用的方法
2.常用的设计原则(记住)
2.1 软件开发的流程
需求分析文档 => 概要设计文档 => 详细设计文档 => 编码和测试 => 安装和调试
=> 维护和升级
---------------------day19--------------------
今天内容：
(1)常用的设计原则
(2)常用的设计模式
(3)常用的查找算法
(4)常用的排序算法
(5)兄弟连在线考试系统
1.常用的设计原则
1.1 软件开发的流程
需求分析文档 => 概要设计文档 => 详细设计文档 => 编码和测试 => 安装和调试
=> 维护和升级
1.2 常用的设计原则(记住)
开闭原则 - 对扩展开放，对修改关闭
如：
public class Person {
private String name;
…
}
public class SubPerson extends Person {
private int age;
…
}
里氏代换原则 - 任何父类可以出现的地方，子类一定可以出现。
- 子类 is a 父类，多使用多态的方式。
如：
public static void draw(Shape s) {
s.show();
}
draw(new Shape());
draw(new Circle());
draw(new Rect());
依赖倒转原则 - 在以后的开发中尽量多依赖于抽象类和接口，而不是具体实现类。
- 因为抽象类和接口对子类具有强制性和规范性。
如：
public abstract class Account {
public abstract double getLixi();
}
public class FixedAccount extends Account {
public double getLixi() {}
}
接口隔离原则 - 在以后的开发中尽量使用小接口而不是大接口，避免接口的污染。
如：
public interface RunAnimal {
public abstract void run();
}
public interface FlyAnimal {
public abstract void fly();
}
public class Dog implements RunAnimal {
public void run() {}
}
迪米特法则/最少知道原则 - 一个实体应当尽量少于其它实体之间发生关联。
- 高内聚，低耦合
- 所谓高内聚就是指一个实体应当有的功能应该尽量聚集于该实体的内部
- 所谓低耦合就是指一个实体应当减少与其它实体之间的关联。
合成复用原则 - 在以后的开发中尽量多使用合成的方式，而不是继承的方式。
如：
public class A {
public void show() {}
}
pubiic class B extends A { - 不推荐
public void test() {
// 调用A类中的show方法
show();
}
}
pubiic class B { - 推荐
private A a;
public B(A a) {
this.a = a;
}
public void test() {
// 调用A类中的show方法
a.show();
}
}
2.常用的设计模式
2.1 基本概念
设计模式就是一种编写代码经验的总结，是一种用在固定场合的固定套路。
2.2 常用的设计模式(重点)
常用的设计模式：单例设计模式、模板设计模式、工厂方法模式、抽象工厂模式、…
3.常用的查找算法(重点)
3.1 线性(顺序)查找算法
(1)算法流程
3.2 二分(折半)查找算法
(1)算法流程
1 ~ 100 50 1 ~ 50 25 1 ~ 25 17
4.常用的排序算法
4.1 冒泡排序算法(重中之重)
(1)算法流程
---------------------day20--------------------
----------day01-------------
(1)计算机的体系结构
(2)Java语言的概述
(3)开发环境的搭建和使用
1.计算机的体系结构(常识)
1.1 计算机的基本概念
计算机俗称“电脑”，是一种可以应用于高级计算等各个领域的设备。
计算机主要有两大部分组成：计算机硬件 + 计算机的软件。
1.2 常见的硬件
计算机中常见的硬件主要有：CPU、内存、硬盘、显卡、键盘、鼠标、显示器、…
CPU - 中央处理器，是计算机中最核心的部件，类似于人的大脑
- 主要用于解析和执行计算机的指令以及处理软件中的数据
内存 - 是计算机中的存储部件
- 主要用于临时存放CPU要访问的数据内容，CPU可以直接访问内存且效率高
- 容量比较小，一旦关机则会造成数据的丢失
- 时刻使用快捷键: ctrl+s 进行报错
硬盘 - 是计算机中的存储部件
- 容量比较大，一旦关机数据也不会丢失，也就是可以实现永久存储数据
- CPU不可以直接访问硬盘，若希望访问需要先加载到内存中
其中键盘叫做标准输入设备，其中显示器叫做标准输出设备
科普：
1Tb = 1024Gb
1Gb = 1024Mb
1Mb = 1024Kb
1Kb = 1024byte(字节) 通常一个英文字母占1个字节，一个汉字占2个字节
1byte = 8bit(二进制位) 计算机的底层识别0和1组成的二进制序列
思考：
目前主流的硬盘配置是：250G、320G、500G、1Tb、…为啥我的只有298G呢？
解析：
硬件厂商是采用1000作为进率，而操作系统是采用1024作为进率显示
1.3 常见的软件
计算中常见的软件主要有：系统软件 和 应用软件
其中系统软件主要指操作系统，目前主流的操作系统都有：
windows系列、Unix系列、linux系列、ios系列、Android系列
其中应用软件主要指安装在操作系统之上的软件，如：QQ、火狐浏览器、迅雷等
1.4 计算机的体系结构
使用者 => 应用软件 => 操作系统 => 硬件设备
=> 其中操作系统分为：外壳(Shell) 和 内核(Kernel)
2.Java语言的概述(常识)
2.1 Java语言的背景
Java语言诞生于1995年，该语言之父是詹姆斯-高斯林，该语言之前隶属于sun公司，现在隶属于oracle公司。
Java语言在编程语言排行榜占据重要的地位。
2.2 Java语言的主要版本
(1)Java SE（Java Platform, Standard Edition）
- 称之为“Java平台标准版”，主要用于学习Java语言的语法规则和编程基础。
(2)Java EE（Java Platform，Enterprise Edition） - 称之为“Java平台企业版”，主要用于学习Java语言的后台开发技术。
(3)Java ME （Java Platform，Micro Edition） - 称之为Java 平台微型版，随着Android智能平台的普及已经走向了淘汰。
3.开发环境的搭建和使用(重点)
3.1 jdk的下载和安装
(1)下载方式
方式一：直接从官网上下载 www.sun.com www.oracle.com
方式二：直接搜索下载 www.baidu.com www.sogou.com
(2)安装方式
若下载的是安装版，则一路点击下一步采用默认方式安装即可；
若下载的是绿色版，则直接解压即可；
切记安装路径中不要有中文！！！
3.2 相关的概念(记住)
jdk - Java开发工具包，只要做Java开发就需要下载和安装该软件，包含jre。
jre - Java运行时环境，只要运行Java程序就需要下载和安装该软件。
javac.exe - Java语言编译器，负责将Java源代码翻译成字节码文件。
java.exe - Java语言解释器，负责将Java字节码文件进行边解释边执行。
3.3 编写Java程序的流程
(1)新建一个文本文档，将xxx.txt修改为xxx.java；
(2)使用记事本的方式打开该文件，编写Java代码后进行保存；
(3)启动dos窗口，切换到xxx.java文件所在的目录中；
(4)使用javac xxx.java进行编译生成xxx.class的字节码文件；
(5)使用java xxx进行解释执行打印结果；
注意：
当文件后缀无法显示时的处理方式：组织 => 文件夹和搜索选项 => 查看 => 隐藏已知文件类型的扩展名 => 去掉勾选 => 确定
3.4 常用的快捷键
ctrl+s 保存 ctrl+c 复制 ctrl+v 粘贴 ctrl+x 剪切
ctrl+a 全选 ctrl+f 查找 ctrl+z 撤销
windows+d 回到桌面 windows+e 打开计算机 windows+l 锁屏
windows+tab 切换任务
windows+r 打开运行，输入cmd后回车就可以打开dos窗口
alt+tab 切换任务
ctrl+shift 切换输入法，一旦切换到中文输入法后就使用shift进行中英文切换
ctrl+alt+delete 启动任务管理器
3.5 环境变量的配置
(1)基本概念
通常情况下可执行文件只能在当前安装目录中使用，若希望该文件可以在任意路径中使用，则需要将该可执行文件的路径存放环境变量Path中。
(2)配置方式
计算机 => 鼠标右击，选择属性 => 高级系统设置 => 高级 => 环境变量 => 系统变量 => 找到Path后点击编辑，将javac.exe文件所在的路径放到Path变量值的最前面，加上英文版的分号 => 一路点击确定即可
切记Path变量原有的变量不要删，配置完毕后记得重启dos窗口
3.6 跨平台原理(记住)
对于同一份字节码文件来说，由于不同的操作系统中都提供了Java虚拟机负责翻译成对应平台的机器指令，因为使得同一份字节码文件赢得“一次编译，到处使用”的美名
--------------day02---------------------
今天内容：
(1)变量和注释
(2)数据类型
1.变量和注释(重中之重)
1.1 基本概念
当需要在Java程序中记录单个数据内容时，则需要声明一个变量，而声明变量的本质就是在内存中申请一块独立的存储单元，由于该存储单元中的数据可以改变，因此得名为"变量"。
由于存放的数据内容大小不同导致所需存储单元的大小不同，在Java语言中使用数据类型的概念加以描述，为了便于下次查找需要给该存储单元指定一个名称，叫做变量名。
1.2 声明方式
数据类型 变量名 = 初始值; - 其中=初始值可以省略，但分号不可以省略
如：
int age = 18;
1.3 标识符(变量名)的命名规则(笔试题)
(1)必须由字母、数字、下划线以及美元$等组成，其中数字不能开头(下午讲到)；
如：name、age、nianling、name2、name3等
(2)不能与Java语言的关键字同名，所谓关键字就是Java语言中用于代表特殊含义的单词
如：public、class、void、static等
(3)区分大小写，长度没有限制但不宜过长；
如：day 和 Day代表不同的标识符，不推荐使用
(4)尽量做到见名知意，支持中文但不推荐使用；
如：year、month、day、size、length等
1.4 常用的注释
// 单行注释，表示从//开始一直到本行结束的所有内容都是注释
/**/ 多行注释，表示/开始一直到/之间的所有内容都是注释
注意：
多行注释之间是不允许嵌套的
2.数据类型
2.1 基本分类
在Java语言中数据类型主要分为两大类：
(1)基本数据类型(记住)
byte、short、int、long、float、double、boolean、char
1 2 4 8 4 8 1 2
(2)引用数据类型(了解)
数组、类、接口、枚举、注解
2.2 常用的进制
在日常生活中采用十进制来进行数据的描述，逢十进一，权重：100、101、10^2 …
在计算机中采用二进制进行数据的描述，逢二进一，权重：20、21、2^2、…
由于十进制有正负数，为了使得计算机中能够存储，计算机中采用二进制的最高位(最左边)代表符号位，若是0则代表非负数，若是1则代表负数。
如：
10^3 10^2 10^1 10^0
千 百 十 个
1 2 3 4 => 读取：一千一百一十一
2.3 进制之间的转换(尽量理解)
(1)正十进制转换为二进制的方式
a.除二取余法，让十进制整数不断地出于2取出余数，直到商为0时将余数逆序排列
b.拆分法，将十进制整数拆分为若干个二进制权重的和，若有该权重下面写1否则写0
如：
45 = 32 + 8 + 4 + 1
二进制的权重： 128 64 32 16 8 4 2 1
0 0 1 0 1 1 0 1 => 0010 1101
(2)正二进制转换为十进制的方式
a.加权法，让二进制的每个数字乘以当前位的权重再累加起来。
如：
0010 1101 =>02^7 +02^6 +12^5 + 02^4 + 12^3 + 12^2 + 02^1 + 12^0
=> 0 + 0 + 32 + 0 + 8 + 4 + 0 + 1
=> 45
(3)负十进制转换为二进制的方式
a.先将十进制的绝对值转换为二进制，进行按位取反再加1。
如：
-45 绝对值转换为二进制：0010 1101
进行按位取反： 1101 0010
再加1： 1101 0011
-45 + 45 = 0;
-45: 1101 0011
45: 0010 1101 +
---------------------------
1 0000 0000 (高位溢出，也就是将1丢弃) => 0000 0000 => 0
扩展：
有余力的同学课下查询原码、反码以及补码的概念。
(4)负二进制转换为十进制的方式
a.先减1再按位取反，转换为十进制后添加负号。
如：
1101 0011 => 先减1： 1101 0010
=> 按位取反：0010 1101
=> 转十进制：45
=> 添加负号：-45
练习：
将整数58 和 -58 转换为二进制：
将整数83 和 -83 转换为二进制：
将正二进制0101 1101 和 0011 1110 转为十进制：
将负二进制1010 1010 和 1101 1101 转为十进制：
解析：
128 64 32 16 8 4 2 1
0 0 1 1 1 0 1 0
0 1 0 1 0 0 1 1
58 = 32 + 16 + 8 + 2 => 0011 1010
-58 => 0011 1010 => 1100 0101 => 1100 0110
83 = 64 + 16 + 2 + 1 => 0101 0011
-83 => 0101 0011 => 1010 1100 => 1010 1101
0101 1101 => 0 + 64 + 0 + 16 + 8 + 4 + 0 + 1 => 93
0011 1110 => 0 + 0 + 32 + 16 + 8 + 4 + 2 + 0 => 62
1010 1010 => 1010 1001 => 0101 0110 => 86 => -86
1101 1101 => 1101 1100 => 0010 0011 => 35 => -35
2.4 单个字节表示的整数范围(重中之重)
在计算机中单个字节表示8位二进制位，其中最高位代表符号位，若是0则表示非负数，若是1则表示负数，因此表示的整数范围如下：
非负数的范围：0000 0000 ~ 0111 1111 => 0 ~ 127 => 0 ~ 2^7-1
0111 1111 =>02^7 + 12^6 + 12^5 + 12^4 + 12^3 + 12^2 + 12^1 + 12^0
=> 0 + 64 + 32 + 16 + 8 + 4 + 2 + 1
=> 127
负数的范围：1000 0000 ~ 1111 1111 => -128 ~ -1 => -2^7 ~ -2^0
1000 0000 => 先减1: 0111 1111
=> 按位取反：1000 0000
=> 转十进制：128
=> 添加负号：-128
1111 1111 => 先减1： 1111 1110
=> 按位取反：0000 0001
=> 转十进制：1
=> 添加负号：-1
综上所述：
在计算机中单个字节所能表示的整数范围是：-2^7 ~ 2^7-1，也就是-128 ~ 127.
2.5 整数类型
在Java语言中用于描述整数数据的类型有：byte、short、int、long，推荐int类型。
其中byte类型在内存空间中占1个字节，表示的整数范围是：-2^7 ~ 2^7-1。
-128 ~ 127.
其中short类型在内存空间中占2个字节，表示的整数范围是：-2^15 ~ 2^15-1。
-32768 ~ 32767.
其中int类型在内存空间中占4个字节，表示的整数范围是：-2^31 ~ 2^31-1.
正负二十一亿之间
其中long类型在内存空间中占8个字节，表示的整数范围是：-2^63 ~ 2^63-1.
比int类型还大的数
在Java程序中直接写出的整数数据叫做直接量/字面值/常量，如：200等，而直接量默认是int类型，若希望表达long类型的直接量，则需要在直接量的后面加上l或者L，推荐使用L方式。
扩展:
在以后的开发中若希望表达比long类型范围还大的数，则借助java.math.BigInteger类型加以描述。
2.6 浮点类型
在Java语言中用于描述小数数据的类型有：float、double，推荐使用double类型
其中float类型在内存空间中占4个字节，叫做单精度浮点数，小数点后7位有效数字
其中double类型在内存空间中占8个字节，叫双精度返点数，小数点后15位有效数字
在Java程序中直接写出的小数数据叫做直接量/字面值/常量，如：3.14等，而直接量默认为double类型，若希望描述float类型的直接量，则需要在直接量后面加上f或者F.
扩展：
a.有余力的同学课下查询float类型的二进制结构(了解)
b.由于float和double类型运算时可能会有误差，为了实现精确运算可以直接java.math.BigDecimal类型加以描述。
练习：
提示用户输入下落时间t(整数)，使用公式0.59.8t*t来计算下落的位移并打印出来
2.7 布尔类型
在Java语言中用于描述真假数据的类型是：boolean，数值只有两个：true 和 false
其中boolean类型在内存空间中所占的字节没有明确的规定，通常认为是1个字节。
-------------------day03-------------------------
今天内容：
(1)数据类型
(2)运算符
(3)分支结构
1.数据类型
在Java语言中基本数据类型有：byte、short、int、long、float、double、boolean、char
1.1 字符类型
在Java语言中用于描述单个字符数据的类型是：char类型，如：‘1’、‘a’、'中’等
其中char类型在内存空间中占2个字节且没有符号位，表示范围是：0 ~ 65535.
由于现实生活中很少有数据可以用单个字符描述，因此以后的开发中很少使用char类型，而使用更多的是由多个字符串起来组成的字符串，使用String类型加以描述。
由于计算机的底层只识别0和1组成的二进制序列，因此像’a’这样的图案无法直接在计算机中存储，但现实生活中确实有这样的图案需要存储，为了使得这样的图案可以存储在计算机中就需要给该图案指定一个编号，将编号存储计算机中即可，这样的编号叫ASCII
要求大家记住的ASCII有：
‘a’ - 97 ‘A’ - 65 ‘0’ - 48 空格 - 32 换行符 - 10
要求大家记住的转义字符有：
" - " ’ - ’ \ - \ \n - 换行 \t - 制表符(tab键)
1.2 基本数据类型之间的转换
在Java语言中基本数据类型之间的转换有两种方式：
自动类型转换 - 主要指将小类型向大类型之间的转换。
强制类型转换 - 主要指将大类型向小类型之间的转换。
语法格式：目标类型 变量名 = (目标类型)源类型变量名
注意：
强转有风险，操作需谨慎！！！
2.运算符(重点)
2.1 算术运算符
- 表示加法运算符 - 表示减法运算符 * 表示乘法运算符
/ 表示除法运算符 % 表示取模/取余运算符
2.2 关系/比较运算符
表示是否大于运算符 >= 表示是否大于等于运算符
< 表示是否小于运算符 <= 表示是否小于等于运算符
== 表示是否等于运算符 != 表示是否不等于运算符
所有以关系运算符作为最终运算的表达式结果一定是boolean类型
2.3 自增减运算符
- 表示加法运算符 ++ 表示自增运算符，用于实现让变量自身的数值加1的效果
- 表示减法运算符 – 表示自减运算符，用于实现让变量自身的数值减1的效果
2.4 逻辑运算符
&& 表示逻辑与运算符，相当于汉语中"并且"，同真为真，一假为假。
|| 表示逻辑或运算符，相当于汉语中"或者"，一真为真，同假为假。
! 表示逻辑非运算符，相当于汉语中"取反"，真为假，假为真。
短路特性：
a.对于逻辑与运算符来说，若第一个条件为假则整个表达式为假，此时跳过第二个
条件不执行。
b.对于逻辑或运算符来说，若第一个条件为真则整个表达式为真，此时跳过第二个
条件不执行。
2.5 条件/三目运算符
条件表达式 ? 表达式1: 表达式2;
=> 判断条件表达式是否成立，若成立则执行表达式1，否则执行表达式2;
2.6 赋值运算符
(1)简单赋值
= 表示赋值运算符，用于将=右边的数据赋值给=左边的变量，覆盖变量原来的数值。
笔试题：
ia == 5; - 表示判断ia的数值是否等于5
5 == ia; - 表示判断5是否等于ia的数值，推荐该方式
ia = 5; - 表示将5赋值给变量ia，覆盖ia原来的数值
5 = ia; - 编译报错
(2)复合赋值
+=、 -=、 *=、 /=、 …
如：
int ia = 3;
ia = ia + 2; => ia = 5; 推荐该方式
ia += 2; => ia = 5;
2.7 运算符的优先级
a. ()的优先级极高；
b. =的优先级极低；
c. 若实在无法确认优先级，则使用()来确认即可；
--------------day04------------------
今天内容：
(1)分支结构
(2)循环结构
1.分支结构(重中之重)
1.1 基本概念
在某些特殊场合中需要进行条件判断并做出选择时，就需要使用分支结构。
1.2 if分支结构
(1)语法格式
if(条件表达式) {
语句块;
}
(2)执行流程
判断条件表达式是否成立
=> 若成立，则执行{}中的语句块;
=> 若不成立，则跳过{}中的代码不执行；
1.3 if-else分支结构
(1)语法格式
if(条件表达式) {
语句块1;
} else {
语句块2;
}
(2)执行流程
判断条件表达式是否成立
=> 若成立，则执行语句块1;
=> 若不成立，则执行语句块2;
1.4 if-else if-else分支结构
(1)语法格式
if(条件表达式1) {
语句块1;
}
else if(条件表达式2) {
语句块2;
}
…
else {
语句块n;
}
(2)执行流程
判断条件表达式1是否成立
=> 若成立，则执行语句块1
=> 若不成立，则判断条件表达式2是否成立
=> 若成立，则执行语句块2
=> 若不成立，则执行语句块n
2.循环结构(重中之重、难点)
2.1 基本概念
在某些特殊场合中，若希望重复执行一段代码时，则需要使用循环结构。
2.2 for循环
(1)语法格式
for(初始化表达式; 条件表达式; 修改初始值表达式) {
循环体;
}
(2)执行流程
执行初始化表达式 => 判断条件表达式是否成立
=> 若成立，则执行循环体 => 执行修改初始值表达式 => 判断条件表达式是否成立
=> 若不成立，则循环结束
2.3 break 和 continue关键字
break关键字用在循环中表示跳出当前循环；
continue关键字使用在循环中表示结束本次循环继续下一次循环(会用即可)；
2.4 特殊的循环
for(;😉 - 这种没有明确循环条件的循环叫做无限循环，俗称"死循环"。
该循环通常与break关键字搭配使用。
------------------------day05-----------------------
今天内容：
(1)循环结构
(2)一维数组
1.循环结构(重中之重)
1.1 for循环
(1)语法格式
for(初始化表达式; 条件表达式; 修改初始值表达式) {
循环体;
}
(2)执行流程
执行初始化表达式 => 判断条件表达式是否成立
=> 若成立，则执行循环体 => 执行修改初始值表达式 => 判断条件表达式是否成立 => 若不成立，则循环结束
1.2 双重for循环(难点)
(1)语法格式
for(初始化表达式1; 条件表达式2; 修改初始值表达式3) {
for(初始化表达式4; 条件表达式5; 修改初始值表达式6) {
循环体;
}
}
(2)执行流程
执行表达式1 => 判断表达式2是否成立
=> 若成立，则执行表达式4 => 判断表达式5是否成立
=> 若成立，则执行内层循环体 => 执行表达式6 => 判断表达式5是否成立 => 若不成立，则内层循环结束 => 执行表达式3 => 判断表达式2是否成立
=> 若不成立，则外层循环结束
(3)实际意义
在以后的开发中若希望打印多行多列的数据内容时，就应该使用双重for循环。
练习：
使用双重for循环分别打印以下星星图案：
***** * i=1时，1个* ***** i=1时，5个* *
***** ** i=2时，2个* **** i=2时，4个* ***
***** *** i=3时，3个* *** i=3时，3个* *****
***** **** i=4时，4个* ** i=4时，2个* *******
***** ***** i=5时，5个* * i=5时，1个* *********
i=1时，4个空格，1个* 空格：5-i
i=2时，3个空格，3个* : 2i-1
i=3时，2个空格，5个*
i=4时，1个空格，7个*
i=5时，0个空格，9个*
1.3 while循环(会用即可)
(1)语法格式
while(条件表达式) {
循环体;
}
(2)执行流程
判断条件表达式是否成立
=> 若成立，则执行循环体 => 判断条件表达式是否成立
=> 若不成立，则循环结束
(3)注意事项
a.while循环和for循环可以完全互换；
b.while循环主要用于明确循环条件但不明确循环次数的场合中；
for循环主要用于明确循环次数/范围的场合中；
c.while(true)和for(;;)都表示无限循环；
2.一维数组(重点)
2.1 基本概念
当需要在程序中记录单个数据内容时，则声明一个变量记录即可；
当需要在程序中记录多个类型相同的数据内容时，则声明一个一维数组即可；
一维数组本质上就是在内存空间中申请一段连续的存储单元；
2.2 声明方式
(1)语法格式
数据类型[] 数组名称 = new 数据类型[数组的长度];
如：
int[] arr = new int[3]; - 表示声明一个长度为3元素类型为int类型的一维数组
int num = 3; - 表示声明一个初始值为3元素类型为int类型的变量
int arr[] = new int[3]; - 不推荐使用
(2)元素的初始化
数据类型[] 数组名称 = {初始值1, 初始值2, …};
如：
int[] arr = {11, 22, 33}; - 声明一个长度为3元素类型为int类型的一维数组
--------------------day06--------------------
今天内容：
(1)二维数组
(2)面向对象编程的概念
(3)类和对象以及引用
(4)成员方法
1.二维数组(会用即可)
1.1 基本概念
当需要在程序中记录多个类型相同的数据内容时，则声明一个一维数组，而一维数组本质上就是在内存中申请一段连续的存储单元。
二维数组本质上就是由多个一维数组摞在一起组成的数组，也就是说二维数组中的每个元素是一个一维数组，而一维数组中的每个元素才是具体的数据内容。
1.2 声明方式
(1)语法格式
数据类型[][] 数组名称 = new 数据类型[行数][列数];
如：
int[][] arr = new int[2][3]; - 表示声明一个具有2行3列类型为int的二维数组
其中行下标范围是：0 ~ 1；
其中列下标范围是：0 ~ 2；
(2)元素的初始化
数据类型[][] 数组名称 = {{元素值1, 元素值2, …}, {元素值1,…},…};
如：
int[][] arr = {{1, 2, 3}, {4, 5, 6}}; - 表示声明一个2行3列的二维数组
2.面向对象编程的概念(理解)
2.1 什么是对象？
万物皆对象。
2.2 什么是面向对象？
所谓面向对象就是指以属性(特征)和行为的观点分析现实世界中事物的方式。
2.3 什么是面向对象编程？
所谓面向对象编程就是指先使用面向对象的思想进行分析，再使用面向对象的编程语言进行翻译的过程。
其中C语言是一门面向过程的编程语言。
其中C++语言是一门既面向过程又面向对象的编程语言。
其中Java语言是一门纯面向对象的编程语言。
3.类和对象以及引用(重中之重、难点)
如：
String name1 = “史梦龙”; …
String name2 = “闫雪松”; …
String name3 = “来国志”; …
…
人类：
特征：姓名、年龄
行为：吃饭、娱乐
3.1 类和对象的概念
对象主要指现实生活中客观存在的实体，在Java语言中体现为内存中的一块存储空间
类简单来说就是"分类"的含义，是对多个对象共性的抽象描述，在Java语言中体现为一种引用数据类型，里面包含了描述特征的成员变量和描述行为的成员方法。
3.2 类的定义
(1)类定义的语法格式
class 类名 {
类体;
}
如：
class Person {
}
注意：
当类名由多个单词组成时，通常要求每个单词的首字母都要大写。
(2)成员变量定义的语法格式
class 类名 {
数据类型 成员变量名 = 初始值; - 其中=初始值通常都省略，分号不可以省略
…
}
如：
class Person {
String name;
int age;
}
注意：
当成员变量名由多个单词组成时，通常要求第二个单词起首字母大写。
思考：
成员变量和局部变量有何区别？
解析：
局部变量主要指在方法体中定义的变量，作用范围从声明开始一直到方法体结束。
成员变量主要指在方法体外类体内定义的变量，作用范围从声明开始一直到类体结束
3.3 对象的创建
(1)语法格式
new 类名();
如：
new Person(); - 匿名对象
(2)注意事项
a.当一个类存在定义完毕后，可以使用new关键字来创建/构造该类的对象，
这个过程叫做类的实例化。
b.创建对象的本质就是在内存空间的堆区申请一块存储区域来存放该对象
独有的特征信息。
3.4 引用的定义
(1)基本概念
使用引用数据类型定义的变量叫做 引用型变量，简称为 “引用”。
定义引用本质就是在内存空间的栈区申请一块存储区域，来记录对象在堆区地址信息
(2)语法格式
类名 引用变量名;
如：
Person p; - 声明一个Person类型的引用变量p
Person p = new Person(); - 声明一个Person类型的引用指向Person类型的对象
引用变量名.成员变量名;
如：
p.name = “zhangfei”;
p.age = 30;
4.成员方法(重中之重)
4.1 语法格式
class 类名 {
返回值类型 成员方法名(形参列表) {
方法体;
}
}
如：
class Person {
void show() {
System.out.println(“没事秀出你的肌肉！！！”);
}
}
注意：
当成员方法名由多个单词组成时，通常要求从第二个单词起首字母大写。
4.2 成员方法的详解
(1)返回值类型
返回值主要指方法体内向方法体外返回的数值内容。
返回值类型主要指返回值的数据类型，可以是基本数据类型，也可以是引用数据类型
如：
当返回的数值内容是66时，则返回值类型写int即可；
当返回的数值内容是3.14时，则返回值类型写double即可；
当返回的数值内容是"hello"时，则返回值类型写String即可；
在方法体中使用return关键字可以返回具体的数值内容并结束当前方法。
如：
当返回的数值内容是66时，则方法体中写：return 66; 即可；
当返回的数值内容是"hello"时，则方法体中写：return “hello”; 即可；
当该方法不需要返回任何数据内容时，则返回值类型写void即可。
(2)形参列表
形式参数主要用于将方法体外的数据带入到方法体的内部。
形参列表主要指形式参数的列表，也就是多个形式参数，具体格式如下：
数据类型 形参变量名1, 数据类型 形参变量名2, …
如：
当该方法带入的数值内容是66时，则形参列表写：int i即可；
当该方法带入的数值内容是3.14时，则形参列表写：double d即可；
当该方法带入的数值内容是66和3.14时，则形参列表写：int i, double d即可；
当该方法带入的数值内容是66和"hello"时，则形参列表写：int i, String s即可
若该方法不需要带入任何数据内容时，则该方法的形参列表位置啥也不写即可。
(3)方法体的详解
方法体中主要用于编写描述该方法功能的语句。
4.3 方法的调用
(1)语法格式
引用变量名.成员方法名(实参列表);
如：
p.show(); - 表示使用引用变量p调用名字为show的成员方法
(2)注意事项
a.实际参数列表主要用于给形式参数列表进行初始化操作，因此实参列表的个数、
类型以及顺序等都必须与形参列表保持一致。
b.实际传递可以传递直接量、变量、表达式、方法的调用等。
--------------------day07-----------------------
今天内容：
(1)成员方法
(2)构造方法和方法重载
(3)this关键字
(4)方法的传参和递归调用
1.成员方法(重中之重)
练习：
编程实现Girl类，特征：姓名、年龄、是否有男朋友，行为有：打印所有特征的方法、修改姓名为参数指定数值的方法、修改年龄为参数指定数值的方法、修改是否有男朋友为参数指定数值的行为。
要求在main方法中声明Girl类型的引用指向Girl类型的对象并打印特征，通过调用方法的方式修改特征为"贺佳洋"、18、true后再次打印特征。
练习：
编程实现Circle类
， 特征有：横坐标、纵坐标、半径(整数)，
行为有：获取横坐标并返回的行为、
修改横坐标为参数指定数值的行为、
获取纵坐标并返回的行为
、修改纵坐标为参数指定数值的行为
、获取半径并返回的行为
、修改半径为参数指定数值的行为
、打印所有特征的行为。
要求在main方法中声明Circle类型的引用指向该类型的对象并打印特征
，通过调用方法的方式修改所有特征
再通过调用方法的方式获取所有特征并打印出来。
2.构造方法和方法重载
如：
Person p = new Person(); - 表示声明一个Person类型的引用指向Person类型对象
p.show(); - 表示调用名字为show的方法
2.1 构造方法(重中之重)
(1)语法格式
class 类名 {
类名(形参列表) {
构造方法体;
}
}
如：
class Person {
Person() {
}
}
(2)注意事项
a.要求方法名与类名相同且没有返回值类型，连void都不许有；
b.当使用new关键字创建对象时会自动调用构造方法来实现成员变量的初始化工作，
只有自定义构造方法才能在创建对象的同时来指定成员变量的数值；
(3)默认构造方法
a.当一个类中没有自定义构造方法时，编译器会提供一个无参的空构造方法，
叫做默认/缺省构造方法，如：Person(){}
b.若类中出现自定义构造方法，则编译器不再提供任何的构造方法。
练习：
编程实现Point类，特征有：横坐标和纵坐标，行为有：无参构造方法、有参构造方法、打印所有特征的方法。
要求在main方法中分别使用无参方式和有参构造方式构造对象并打印特征。
2.2 方法的重载(重点)
(1)基本概念
在Java语言中方法名相同、参数列表不同之间的方法构成重载关系(Overload).
(2)主要体现形式
方法重载的主要体现形式为：参数的个数不同、参数的类型不同以及参数的顺序不同
与形参变量名和返回值类型无关，但返回值类型最好相同。
判断方法能否重载的核心：调用时能否加以区分。
(3)实际意义
方法重载的实际意义在于调用者只需要记住一个方法名就可以调用各种不同的版本从而实现各种不同的效果。
如：
char c1 = ‘a’;
System.out.println©;
int i1 = 10;
System.out.println(i1);
double d1 = 3.14;
System.out.println(d1);
3.this关键字(原理、尽量理解)
3.1 基本概念
当this关键字出现在构造方法时，代表当前正在构造的对象；
当this关键字出现在成员方法时，代表当前正在调用的对象；
3.2 原理分析
当成员方法中访问成员变量时默认会加上this.的前缀，this.相当于汉语中"我的"，当不同的对象调用同一个方法时，由于正在调用该方法的对象不同就导致this的数值不同，而this的数值不同就导致this.访问的结果随之不同。
3.3 使用方式
(1)当成员变量名与形参变量名同名时，若希望在方法体中明确要求使用成员变量，
则需要在成员变量名的前面加上this.的前缀(重中之重)；
(2)在构造方法的第一行可以使用this(实参)的方式来调用本类中的其它构造方法(了解);
4.方法的传参过程和递归调用
4.1 方法的传参过程(原理分析)
(1)main方法是程序的入口，为main方法中的局部变量开辟内存空间并初始化；
(2)调用max方法时，为max方法的形参变量开辟内存空间并初始化；
(3)将实参变量的数值赋值给形参变量，执行max方法的方法体；
(4)当max方法执行完毕后，释放max方法中形参变量的内存空间；
(5)main方法中res得到max方法的返回值并继续向下执行；
要求大家掌握的内容：
a.当基本数据类型的变量作为参数传递时，通常形参变量的改变不会影响到实参变量
b.当引用数据类型的变量作为参数传递时，通常形参变量指向内容的改变会影响到
实参变量指向的内容。
c.当引用数据类型的变量作为参数传递时，通常形参变量改变指向后再改变指向的
内容时不会影响到实参变量指向的内容。
-----------------day08---------------------
今天内容：
(1)方法的递归调用
(2)封装
(3)static关键字
1.方法的递归调用(重点、难点)
案例：
自定义成员方法实现参数n阶乘的计算并返回。
解析：
5! = 5 * 4 * 3 * 2 * 1;
4! = 4 * 3 * 2 * 1;
3! = 3 * 2 * 1;
2! = 2 * 1;
1! = 1;
再次解析：
5! = 5 * 4!;
4! = 4 * 3!;
3! = 3 * 2!;
2! = 2 * 1!;
1! = 1;
n! = n * (n-1)!;
1.1 基本概念
递归就是指在一个方法体的内部调用当前方法自身的形式。
1.2 使用原则
a.使用递归必须有规律并且有退出条件；
b.使用递归必须使得问题简单化而不是复杂化；
c.递归可能会影响到程序的执行性能，此时使用递推取代之；
2.封装(重中之重、20遍)
2.1 基本概念
通常情况下在测试类中可以直接访问其它类中的成员变量，当成员变量的数值合法但不合理时，无论是编译阶段还是运行阶段都不会报错或者给出提示，此时与现实生活不符
为了避免上述问题的发生，就需要对类中的成员变量进行密封包装处理来保证成员变量的隐秘性和合理性，该机制就叫做封装，换句话说，封装就是保证成员变量值合理性的机制。
2.2 实现流程
(1)私有化成员变量，使用private关键字修饰；
(2)提供公有的get和set方法使用public关键字修饰，并在方法体中进行合理值的判断
(3)在构造方法中调用set方法进行合理值的判断；
练习：
编程实现Person类封装，特征有：姓名、年龄、国籍，要求提供打印所有特征的方法 编程实现PersonTest类，在main方法中使用有参方式构造两个对象并打印特征
3.static关键字(重点)
3.1 基本概念
通常情况下成员变量隶属于对象层级，每当创建一个对象时就会在堆区申请一块存储区域来存放该对象独有的成员变量信息，若所有对象中某个成员变量的信息一定相同却还在单独保存时，会造成内存空间的浪费。
为了解决该问题就需要使用static关键字来修饰成员变量表达静态的含义，此时该成员变量由对象层级提升为类层级被所有对象共享，与是否创建对象无关。
static关键字还可以修饰成员方法，推荐使用 类名. 的方式访问。
3.2 使用方式
(1)非静态的成员方法中既能访问非静态的成员也能访问静态的成员；
(成员：成员变量 + 成员方法，静态的成员被所有对象共享)
(2)静态的成员方法只能访问静态的成员不能访问非静态的成员；
(成员：成员变量 + 成员方法，调用静态方法时可能还没有创建对象)
(3)只有隶属于类层级并被所有对象共享的内容才可以使用static关键字修饰；
(也就是不能滥用static关键字)
案例:
编程实现Singleton类的封装；
编程实现SingletonTest类的实现，要求在main方法中能得到且只能得到Singleton类的一个对象。
3.3 单例设计模式(重中之重 20遍)
(1)基本概念
当一个类对外提供且只提供一个对象时，这样的类叫做单例类。
而设计单例类的思想和模式叫做单例设计模式。
(2)实现流程
a.私有化构造方法，使用private关键字修饰；
b.声明本类类型的引用指向本类类型的对象并使用private static关键字修饰；
c.提供公有的get方法负责将上述对象返回出去并使用public static关键字修饰；
(3)实现方式
单例设计模式主要有两种：饿汉式 和 懒汉式，在以后的开发中推荐使用饿汉式。
-----------------------day09---------------------
今天内容：
(1)继承
(2)访问控制
(3)final关键字
1.继承(重中之重 20遍)
人类：
特征：姓名、年龄
行为：吃饭、娱乐
学生类 吸收 人类：
特征：学号
行为：学习
教师类 吸收 人类：
特征：工号
行为：讲课
工人类 吸收 人类：
特征：薪水
行为：工作
… …
1.1 基本概念
当多个类之间有相同的特征和行为时，可以将相同的特征和行为提取出来组成一个公共类，让多个类分别吸收公共类中已有特征和行为而在公共类只需要编写自己独有特征和行为的机制，叫做继承。
使用继承提高了代码的复用性，可维护性以及可扩展性。
在Java语言中使用extends(扩展)关键字来表达继承关系，
如：
public class Worker extends Person{} - 表示Worker类继承自Person类
其中Person类是被继承的类，叫做超类、父类、基类。
其中Worker类是继承其它类的类，叫做派生类、子类、孩子类。
练习：
编程实现Person类的封装，特征有：姓名和年龄，要求提供打印所有特征的方法。
编程实现Worker类继承自Person类，Worker类内部暂时啥也不写即可
编程实现WorkerTest类，在main方法中使用无参方式构造对象Worker类型对象并打印
1.2 注意事项
(1)子类不可以继承父类的构造方法和私有方法，但私有特征可以继承只是不能使用；
(2)无论使用何种方式构造子类的对象时都会自动调用父类的无参构造方法来初始化从
父类中继承下来的成员变量，相当于在构造方法的第一行增加 super()的效果；
(3)使用继承必须满足逻辑关系：子类 is a 父类，也就是不能滥用继承；
(4)Java语言中支持单继承不支持多继承，也就是一个子类只能有一个父类，但一个
父类可以有多个子类；
1.3 方法的重写(Override)
(1)基本概念
从父类中继承下来的方法不足以满足子类的需求时，就需要在子类中重新写一个和父类基本一样的方法来覆盖从父类中继承的版本，这个过程就叫做方法的重写。
(2)重写的原则
a.要求方法名相同、参数列表相同及返回值类型相同，从jdk1.5开始允许返回子类类型
b.要求访问权限不能变小，可以相同或者变大；
c.要求不能抛出更大的异常(异常机制)；
练习：
编程实现Animal类的封装，特征有：名字，要求提供打印所有特征的方法；
编程实现Dog类封装继承自Animal类，特征有：牙齿数量，要求提供打印所有特征方法
集成开发环境：eclipse、MyEclipse、Idea、…
2.访问控制(笔试题)
2.1 常用的访问控制符
访问控制符 访问权限 本类内部 本包中的类 子类内部 其它包中的其它类
public 公开的 ok ok ok ok
protected 保护的 ok ok ok no
啥也不写 默认的 ok ok no no
private 私有的 ok no no no
要求大家掌握的内容：
a.public修饰的内容可以在任意位置使用；
b.private修饰的内容只能在本类的内部使用；
c.通常情况下，成员变量都采用private修饰，成员方法都采用public修饰；
2.2 包的定义
package 包名; - 用于定义单层包
package 包名1.包名2…包名n; - 用于定义多层包，为了便于管理和解决同名问题
3.final关键字(重点)
3.1 基本概念
final关键字本意为"最终的、最后的、不可改变的"，可以修饰类、成员方法以及成员变量等。
3.2 使用方式
使用final关键字修饰类体现在该类不能被继承。
- 主要为了防止滥用继承，如：java.lang.String等
使用final关键字修饰成员方法体现在该方法不能被重写但可以被继承。
- 主要为了防止不经意间造成方法的重写，如：java.text.DateFormat类中format 使用final关键字修饰成员变量表示该成员变量必须初始化且不能更改。
- 主要为了防止不经意间造成数值的改变，如：java.lang.Thread类MAX_PRIORITY
扩展：
在以后的开发中很少但是用static关键字或者final关键字来修饰成员变量，而是通常使用public static final关键字共同修饰成员变量来表达常量的含义，常量的命名规范是所有字母大写，不同单词之间采用下划线连接，如：
public static final double PI = 3.14;
----------------------day10---------------------
今天内容：
(1)多态
(2)抽象类
(3)接口
(4)匿名内部类
1.多态(重中之重、难点 20遍)
1.1 基本概念
多态主要指同一种事物表现出来的多种形态。
饮料：可乐、雪碧、脉动、红牛、乐虎、江小白、…
宠物：猫、狗、鸟、鱼、小强、…
人： 学生、教师、工人、保安、朋友、…
1.2 语法格式
父类类型 引用变量名 = new 子类类型();
如：
Person pw = new Worker();
pw.show();
解析：
编译阶段调用Person类中的show方法，运行阶段调用Worker类中的show方法
练习：
编程实现Person类的封装，特征有：姓名和年龄，要求提供打印所有特征的方法；
编程实现Worker类的封装继承Person类，特征有：薪水，要求提供打印所有特征方法
编程实现PersonWorkerTest类，在main方法中分别创建Person和Worker类型对象并打印各自的特征。
1.3 多态的效果
(1)当父类类型的引用指向子类类型的对象时，父类引用可以直接调用父类独有的方法；
(2)当父类类型的引用指向子类类型的对象时，父类引用不可以直接调用子类独有的方法
(3)对于父子类都拥有非静态方法来说，编译阶段调用父类版本，运行阶段调用子类版本
(4)对于父子类都拥有静态方法来说，编译和运行阶段都调用父类版本；
1.4 引用数据类型之间的转换
(1)在Java语言中引用类型之间的转换方式有两种：自动类型转换 和 强制类型转换。
其中自动类型转换主要指从小类型到大类型之间的转换，也就是子类到父类的转换；
其中强制类型转换主要指从大类型到小类型之间的转换，也就是父类到子类的转换；
(2)引用数据类型之间必须发生在父子类之间，否则编译报错；
(3)若强转的目标类型不是该引用变量真正指向的数据类型时，则编译阶段通过，
运行阶段发生类型转换异常；
1.5 实际意义
多态的实际意义在于屏蔽不同子类的差异性实现通用的编程从而代表不同的效果。
2.抽象类(重点)
2.1 抽象方法
抽象方法就是指不能具体实现并且使用abstract关键字修饰的方法。
语法格式如下：
访问权限 abstract 返回值类型 方法名称(形参列表);
public abstract void cry();
2.2 抽象类
抽象类就是指不能实例化对象并且使用abstract关键字修饰的类。
2.3 注意事项
(1)抽象类中可以有成员变量、成员方法以及构造方法。
(2)抽象类中可以没有抽象方法，也可以有抽象方法。
(3)拥有抽象方法的类必须是抽象类，因此真正意义上的抽象类应该是使用
abstract关键字修饰并且拥有抽象方法的类。
2.4 实际意义
抽象类的实际意义不在于实例化对象而在于被继承，当一个类继承抽象类后必须重写抽象方法，否则该类也得变成抽象类。
抽象类对子类具有强制性和规范性，因此叫做模板设计模式。
2.5 经验的分享
在以后的开发中推荐使用多态的语法格式，此时父类引用可以直接调用的所有方法一定是父类中拥有的方法，若希望更换子类时，只需要将new关键字后面的类型修改而其它地方无需修改立即生效，从而提高了代码的可维护性。
该方式的缺点是：父类引用不能直接调用子类独有的方法，若调用则需要强转。
3.接口(重点)
3.1 基本概念
接口本质上就是一种比抽象类还抽象的类，所有方法都是抽象方法。
定义抽象类的关键字是abstract class，而定义接口的关键字是interface。
如：
金属接口 货币接口 黄金类
练习：
自定义Runner接口，提供一个描述奔跑的抽象方法run；
自定义Hunter接口继承Runner接口，提供一个描述捕猎的抽象方法hunt；
自定义Chinese类实现Hunter接口并重写抽象方法，在main方法中使用多态的格式创建对象并调用方法测试。
3.2 类和接口之间的关系
类和类之间采用继承关系 使用extends关键字 支持单继承
类和接口之间采用实现关系 使用implements关键字 支持多实现
接口和接口之间采用继承关系 使用extends关键字 支持多继承
3.3 抽象类和接口之间的主要区别(笔试题)
(1)定义抽象类的关键字是abstract class，而定义接口的关键字是interface;
(2)继承抽象类的关键字是extends，而实现接口的关键字是implements;
(3)继承抽象类支持单继承，而实现接口支持多实现；
(4)抽象类中可以有构造方法，而接口不可以有构造方法；
(5)抽象类中可以有成员变量，而接口中只可以有常量；
(6)抽象类中可以有成员方法，而接口中只可以有抽象方法；
(7)抽象类中增加方法子类可以不用重写，而接口中增加方法基本都需要实现类重写；
(8)从jdk1.8开始允许接口中有非抽象方法，但必须使用default关键字修饰；
4.匿名内部类(重点、难点)
4.1 接口类型引用作为方法形参时实参的传递方式有两种：
(1)自定义类实现接口，然后创建自定义类的对象作为实参传递即可；
(2)使用匿名内部类的语法格式来得到接口类型的引用作为实参传递即可；
4.2 匿名内部类的语法格式
接口/父类类型 引用变量名 = new 接口/父类类型(){ 方法的重写 };
如：
class A {
class B {
}
}
----------------------day11--------------------
今天内容：
(1)Object类
(2)包装类和数学处理类
(3)String类
1.Object类
1.1 常用的包
java.lang包 - 该包是Java语言的核心包，该包中的内容由Java虚拟机自动导入
- 如：String类、System类等
java.util包 - 该包是Java语言的工具包，该包中提供了大量的工具类和集合类
- 如：Scanner类、Random类等
java.io包 - 该包是Java语言的输入输出包，该包中提供了大量读写文件的类
- 如：FileInputStream类、FileOutputStream类等
java.net包 - 该包是Java语言的网络包，该包中提供了大量网络编程的类
- 如：ServerSocket类、Socket类等
…
1.2 Object类
(1)基本概念
java.lang.Object类是类层次结构的根类，任何类都是该类的直接或间接子类。
(2)常用的方法(重点)
boolean equals(Object obj)
- 主要用于判断当前正在调用的对象是否与参数对象obj相等
- 该方法默认比较两个对象的地址，与 == 的结果一致。
- 为了使得该方法可以比较两个对象的内容需要重写该方法。
- 若该方法重写后应该重写hashCode方法来维护常规协定。
int hashCode()
- 主要用于获取调用对象的哈希码值(内存地址的编号)。
- 若两个对象调用equals方法相等，则各自调用hashCode方法必须相同
- 若两个对象调用equals方法不相等，则各自调用hashCode方法应该不同
- 若希望该方法的结果与equals方法保持一致，需要重写该方法
String toString()
- 主要用于返回调用对象的字符串形式
- 该方法默认返回：包名.类名@哈希码值的十六进制
- 当需要返回更有意义的数据内容时，需要重写该方法
- 使用print()/println()/字符串拼接 引用时，会自动调用toString方法
练习：
编程实现Student类的封装，特征有：学号和姓名，要求提供打印所有特征的方法
编程实现StudentTest类，在main方法中使用有参方式构造两个对象并分别打印
2.包装类和数学处理类(会用即可)
如：
Person p = new Person(); - 表示声明Person类型的引用指向Person类型的对象
int num = 10; - 表示声明一个int类型的变量num初始值为10
Java语言是一门纯面向对象的编程语言，万物皆对象！
class MyInt {
private int num = 10; // 成员变量
}
MyInt mi = new MyInt();
2.1 包装类的概念
在某些特殊场合(集合)中要求所有数据内容都必须是对象，而对于Java语言中的8种基本数据类型声明的变量来说不满足该需求，此时就需要对基本数据类型的变量进行密封包装处理成对象来使用，而密封包装处理的类就叫做包装类。
2.2 常用的包装类
int => java.lang.Integer类
char => java.lang.Character类
其它类型都是将首字母换成大写即可
2.3 Integer类
(1)基本概念
java.lang.Integer类是int类型的包装类，里面包含了一个int类型的成员变量。
(2)常用的方法
2.4 BigDecimal类
(1)基本概念
由于Java语言中的float类型和double类型在运算时可能会有误差，若希望实现精确结果则借助java.math.BigDecimal类加以描述。
(2)常用的方法
3.String类(重中之重)
3.1 基本概念
java.lang.String类主要用于描述字符串数据，Java程序中所有的字符串字面值都可以使用String类的对象加以描述，如："hello"等。
该类由final关键字修饰表示该类不能被继承。
该类描述的字符串内容是个常量，一旦创建则内容无法改变，
如：
String str1 = “abc”;
str1 = “123”; - 改变引用变量的指向，而不是指向的内容
3.2 常量池(原理)
由于String类型描述的字符串内容不可改变，因此可以将出现的字符串字面值放入常量池中，若下次出现重复的字符串则直接使用池中已有的字符串对象即可，从而提高性能
------------------------day12------------------
今天内容：
(1)String类
(2)StringBuffer类和StringBuilder类
(3)日期相关的类
1.String类(重中之重)
1.1 常用的方法(练熟、记住)
2.StringBuffer类和StringBuilder类(重点)
2.1 基本概念(笔试题)
String类描述的字符串内容是个常量，不可改变；
StringBuffer类和StringBuilder类描述的字符串内容是个可以改变的字符序列。
其中StringBuffer类是从jdk1.0就有的早期类，支持线程安全但效率比较低；
其中StringBuilder类是从jdk1.5开始有的类，不支持线程安全但效率比较高；
--------------------day13------------------------
今天内容：
(1)日期相关的类
(2)集合框架
(3)Collection集合
(4)List集合
(5)泛型机制
1.日期相关的类(会用即可)
1.1 Date类
(1)基本概念
java.util.Date类主要用于描述特定的瞬间，也就是年月日时分秒可以精确到毫秒。
1秒 = 1000毫秒
(2)常用的方法
1.2 SimpleDateFormat类
(1)基本概念
java.text.SimpleDateFormat类主要用于实现日期和文本类型之间的转换。
(2)常用的方法
1.3 Calendar类
(1)基本概念
java.util.Calendar类主要用于取代Date类型实现年月日时分秒的描述。
该类是个抽象类，因此不能创建对象。
(2)常用的方法
2.集合框架(重点)
2.1 集合的由来
当需要在程序中记录单个数据内容时，则声明一个变量即可；
当需要在程序中记录多个类型相同的数据内容时，则声明一个一维数组即可；
当需要在程序中记录多个类型不同的数据内容时，则构造一个对象即可；
当需要在程序中记录多个类型相同的对象数据时，则声明一个对象数组即可；
当需要在程序中记录多个类型不同的对象数据时，则声明一个集合即可；
2.2 集合的框架
Java语言中集合框架的顶层是：java.util.Collection集合 和 java.util.Map集合
其中Collection集合中存取元素的基本单位是：单个元素。
其中Map集合中存取元素的基本单位是：单对元素。
3.Collection集合(重点)
3.1 常用的方法(练熟、记住)
4.List集合(重中之重)
4.1 基本概念
java.util.List集合是Collection集合的子集合，元素有先后放入次序且允许重复。
该集合的主要实现类有：ArrayList类、LinkedList类、Stack类、Vector类。
其中ArrayList类的底层是采用动态数组来实现数据的管理，访问方便但增删不方便
其中LinkedList类的底层是采用双向链表来实现数据的管理，访问不方便但增删方便
其中Stack类的底层是采用动态数组来实现数据的管理，但该类主要用于描述具有后进先出特征的数据结构，叫做栈(last in first out LIFO)
其中Vector类的底层是采用动态数组实现数据的管理，与ArrayList类相比属于线程安全的类，因此效率比较低。
---------------------day14------------------
今天内容：
(1)泛型机制
(2)Queue集合
(3)Set集合
(4)Map集合
1.泛型机制(重点)
如：
List lt1 = new LinkedList();
lt1.add(“one”); // String类型
lt1.add(2); // Integer类型
lt1.add(new Student(1001, “zhangfei”, 30)); // Student类型
…
1.1 基本概念
通常情况下集合中可以存放不同类型的元素是因为全部看做Object类型放入的，因此从集合中取出元素时也是Object类型，为了表达元素的真实类型则需要强制类型转换，而该转换可能会引发类型转换异常。
为了避免上述异常的发生，从jdk1.5开始提出泛型机制，所谓泛型机制就是在集合名称的右侧使用<数据类型>的方式来明确要求该集合中可以存放的元素类型，若存放其它类型的元素则直接编译报错。
如：
List lt1 = new LinkedList();
1.2 泛型的本质
泛型的本质是参数化类型，也就是让数据类型作为参数传递，其中E相当于集合中的形式参数负责占位，而使用集合时<>中的数据类型相当于集合中的实际参数，实际参数用于给形式参数初始化。
由于实际参数支持非常广泛的数据类型，因此得名为"泛型"。
如：
// 其中i叫做形式参数，负责占位 其中E叫做形式参数，负责占位
// int i = 5; E = String;
// int i = 8; E = Student;
public void show(int i) { public interface List {
… …
} }
// 其中5叫做实际参数，用于给形参初始化 其中String叫做实际参数，用于形参…
show(5); List lt1 = …;
show(8); List lt2 = …;
2.Queue集合(重点)
2.1 基本概念
java.util.Queue集合是Collection集合的子集合，与List集合是平级关系。
该集合主要用于描述具有先进先出特征的数据结构，叫做队列(first in first out FIFO).
该集合的主要实现类是：LinkedList类，选择该类是因为增删比较方便。
2.2 常用的方法
3.Set集合(重点)
3.1 基本概念
java.util.Set集合是Collection集合的子集合，与List集合属于平级关系。
该集合中元素没有先后放入次序，并且该集合中不允许有重复的元素。
该集合的主要实现类有：HashSet类 和 TreeSet类。
其中HashSet类的底层是采用哈希表进行数据管理的。
其中TreeSet类的底层是采用二叉树进行数据管理的。
3.2 常用的方法
参考Collection集合中的方法即可！
3.3 增强版的for循环(for each结构)
(1)语法格式
for(元素类型 变量名 : 集合/数组名称) {
循环体;
}
(2)执行流程
不断地从集合/数组中取出一个元素赋值给变量名然后执行循环体，直到取完所有元素
4.Map集合(重点)
4.1 基本概念
java.util.Map<K,V>集合中存取元素的基本单位是：单对元素，而具体类型参数如下：
K - 此映射所维护的键(Key)的类型
V - 映射值(Value)的类型
该集合中不能包含重复的键，并且每个键只能对应一个值。
该集合的主要实现类是：HashMap类 和 TreeMap类。
--------------------day15---------------------
今天内容：
(1)异常机制
(2)File类
(3)I/O流
1.异常机制(重点、简单)
1.1 基本概念
异常就是"不正常"的含义，在Java语言中体现为运行阶段发生的错误。
java.lang.Throwable类是所有错误(Error类)和异常(Exception类)的超类。
其中Error类主要用于描述比较严重无法编码解决的错误，如：JVM挂了等。
其中Exception类主要用于描述比较轻微可以编码解决的错误，如：0作为除数等。
1.2 异常的分类
java.lang.Exception类是所有异常的超类，主要分为以下两类：
RuntimeException - 运行时异常，也叫作非检测性异常
IOException和其它异常 - 其它异常，也叫作检测性异常
- 所谓检测性异常就是指在编译阶段能够被编译器检测出来的异常
注意：
当程序执行过程中发生了异常但又没有手动处理时，由Java虚拟机采用默认方式处理，而默认处理的结果就是：打印异常名称、异常原因、异常发生的位置并终止程序。
1.3 异常的避免
在以后的开发中尽量使用if分支结构避免异常的发生。
1.4 异常的捕获
(1)语法格式
try {
可能发生异常的语句;
}
catch(异常类型 变量名) {
针对该类异常处理的代码;
}
…
finally {
编写无论是否发生异常都会执行的代码;
}
(2)注意事项
a.当编写多个catch分支时，切记小类型必须放在大类型的上面；
b.finall{}中主要用于编写善后处理的代码，如：关闭已经打开的文件等
(3)执行流程
try {
a;
b; - 可能发生异常的语句
c;
}
catch(){
d;
}
finally{
e;
}
当没有发生异常时的执行流程：a b c e;
当发生异常时的执行流程：a b d e;
1.5 异常的抛出
(1)基本概念
在程序的执行过程中某些异常不能处理或者不便于处理时，可以将这些异常转移给方法的调用者，这个过程就叫做异常的抛出。
(2)语法格式
访问权限 返回值类型 方法名称(形参列表) throws 异常类型1, 异常类型2, …{}
如：
public void show() throws IOException {}
1.6 自定义异常
(1)基本概念
虽然Java官方提供了大量的异常类，但没有提供针对年龄不合理的异常类型，若希望在开发中描述这种具备针对性的异常，则需要程序员自定义异常类。
(2)实现流程
a.自定义xxxException继承自Exception或者Exception的子类；
b.提供两个版本的构造方法：无参构造方法 和 字符串作为参数的构造；
2.File类(会用即可)
2.1 基本概念
java.io.File类主要用于描述硬盘上的文件或目录，可以获取文件或目录的属性信息
2.2 常用的方法
3.I/O流
3.1 基本概念
I/O就是Input/Output的简写，也就是输入/输出的含义。
I/O流就是指读写数据时像流水一样不间断，得名为"流"。
3.2 基本分类
根据读写数据的单位不同分为：字节流 和 字符流。
其中字节流主要指以字节为单位进行读写的流，可以读写任意类型的文件。
其中字符流主要指以字符(2个字节)为单位进行读写的流，只能读写文本文件。
根据数据流动的方向不同分为：输入流 和 输出流(站在程序的角度)。
其中输入流主要指将文件中的数据内容输入到程序中，也就是读文件。
其中输出流主要指将程序中的数据内容输出到文件中，也就是写文件。
3.3 FileOutputStream类(重中之重)
(1)基本概念
java.io.FileOutputStream类主要用于将图像数据之类的原始字节流写入到输出流中.
(2)常用的方法
3.4 FileInputStream类(重中之重)
(1)基本概念
java.io.FileInputStream类主要用于从输入流中读取图像数据之类的原始字节流。
--------------------day16-----------------------
今天内容：
(1)I/O流
(2)线程
1.I/O流
1.1 PrintStream类(重点)
(1)基本概念
java.io.PrintStream类主要用于方便地打印各种数据内容。
(2)常用的方法
1.2 BufferedReader类(重点)
(1)基本概念
java.io.BufferedReader类主要用于从字符输入流中读取单个字符、字符数组以及一行字符串内容。
(2)常用的方法
1.3 ObjectOutputStream类(重点)
(1)基本概念
java.io.ObjectOutputStream类主要用于将Java语言中的对象整体写入输出流中。
只能将支持 java.io.Serializable 接口的对象写入流中
类通过实现 java.io.Serializable 接口以启用其序列化功能。
所谓序列化就是指将对象中所有相关的数据内容有效地组织成字节序列的转化过程。
(2)常用的方法
1.4 ObjectInputStream类(重点)
(1)基本概念
java.io.ObjectInputStream类主要用于从输入流中将对象整体读取出来。
(2)常用的方法
经验分享：
当需要向输出流中写入多个对象时，可以先将多个对象放入一个集合中，然后将集合看做一个整体调用一次writeObject方法写入输出流中，此时只需要调用一次readObject方法就可以将整个集合读取出来。
2.线程
2.1 基本概念
程序 - 数据结构 + 算法，主要指存放在硬盘上的可执行文件。
进程 - 主要指运行在内存中的可执行文件。
目前主流的操作系统都支持多进程，为了让操作系统可以同时执行多个任务，但进程是重量级的，新建进程对系统资源的消耗比较大，因此进程的数量比较局限。
线程是进程内部的程序流，也就是说操作系统中支持多进程，而每个进程的内部又可以支持多线程，而且线程是轻量级的，新建线程会共享所在进程的资源，因此目前主流的开发都采用多线程结束。
多线程的底层是采用时间片轮转法来保证线程的并发执行，所谓并发就是指宏观并行微观串行的机制。
2.2 线程的创建(重中之重)
(1)线程的创建和启动方式
java.lang.Thread类用于描述线程，Java虚拟机允许应用程序并发地运行多个执行线程，具体方式如下：
a.自定义类继承Thread类并重写run方法，然后创建该类的对象调用start方法；
b.自定义类实现Runnable接口并重写run方法，然后创建该类的对象作为实参来
创建Thread类型的对象，最后使用Thread类型对象调用start方法；
(2)相关方法的解析
Thread() - 使用无参方式构造对象。
Thread(String name) - 根据参数指定的名字来构造对象。
Thread(Runnable target) - 根据参数指定的引用来构造对象。
Thread(Runnable target, String name) - 根据参数指定的引用和名称共同构造对象
void run()
- 若构造对象使用Runnable引用，则调用该方法的本质就是调用引用指向的run方法
- 若构造对象没有使用Runnable引用，则调用该方法的本质就是啥也不做
void start()
- 用于启动线程，Java虚拟机自动调用该线程中的run方法。
(3)原理分析
a.执行main方法的线程叫做主线程，执行run方法的线程叫做子线程；
b.对于start方法之前的代码来说，由主线程执行一次，当start方法调用成功后，
线程的个数由1个变成了2个，主线程继续向下执行，新启动的线程去执行run方法，
两个线程各自独立运行互不影响；
c.当main方法结束主线程结束，当run方法结束后子线程结束；
注意：
继承Thread类的方式代码简单，但Java语言中支持单继承，若该类继承Thread类后则无法继承该类真正的父类，而实现Runnable接口的方式虽然代码复杂，但不影响该类继承别的类以及实现别的接口，因此在以后的开发中推荐第二种方式。
2.3 线程的编号和名称(会用即可)
2.4 线程的常用方法(重点)
--------------------day17--------------------------
今天内容：
(1)线程的常用方法
(2)线程的同步机制
(3)网络编程的常识
(4)基于tcp协议的编程模型
1.线程的常用方法(重点)
2.线程的同步机制(重点)
2.1 基本概念
当多个线程同时访问同一种共享资源时，可能会造成数据的覆盖等不一致性问题，此时就需要进行线程之间的通信和协调，该机制就叫线程的同步机制。
2.2 解决方案
由程序结果可知：当两个线程同时执行取款操作后，最终的账户余额不正确
引发原因：线程一还没有取款结束，但线程二已经开始取款
解决方案：将取款操作线程的并发执行 改为 线程的 串行执行
2.3 实现方式
在Java语言中提供了一种内置的锁机制来保证代码执行的原子性，而实现该机制就需要借助synchronized关键字。
2.4 死锁的概念
线程一执行的代码：
public void run() {
synchronized(a) { // 持有对象锁a，等待对象锁b
synchronized(b) {
…
}
}
}
线程二执行的代码：
public void run() {
synchronized(b) { // 持有对象锁b，等待对象锁a
synchronized(a) {
…
}
}
}
注意：
在以后的开发中尽量不要使用同步代码块的嵌套结构。
3.网络编程的常识
目前主流的网络通讯软件有：QQ、微信、飞信、阿里旺旺、钉钉、YY、陌陌、探探…
在吗？
3.1 七层网络模型
为了数据传输的可靠性和安全性，ISO(国际标准委员会组织)将数据的传递从逻辑上划分为以下七层：
应用层、表示层、会话层、传输层、网络层、数据链路层、物理层
当发送数据时，会将发送的数据按照上述七层网络模型进行层层加包再发送出去；
当接收数据时，会将接收的数据按照上述七层网络模型相反的次序进行层层拆包；
3.2 IP地址
如：
192.168.1.1 - 是绝大多数路由器的登录地址，设置账号和密码等
IP地址是互联网中的唯一地址标识，也就是根据IP地址可以定位到具体某一台设备。
IP地址本质上是32位二进制组成的整数，叫做IPv4，当然也有128位二进制组成的整数，叫做IPv6，目前主流的还是IPv4.
日常生活中采用点分十进制表示法进行IP地址的描述，也就是将每个字节的二进制转换为一个十进制整数，不同的整数之间采用小数点隔开。
如：
真实的IP地址： 0000 0001 0000 0010 0000 0011 0000 0100 二进制
点分十进制表示法：1.2.3.4
3.3 端口号
IP地址可以定位到具体某一台设备，而端口号可以定位到设备中的具体某一个进程。
网络编程需要提供：IP地址 和 端口号
端口号本质上是16位二进制组成的整数，表示的范围是：0 ~ 65535，其中0 ~ 1024之间的端口号通常被系统占用，因此开发从1025开始使用。
4.基于tcp协议的编程模型(重点)
4.1 编程模型
服务器：
(1)创建ServerSocket类型的对象并提供端口号；
(2)等待客户端的连接请求，调用accept方法；
(3)使用输入输出流进行通信；
(4)关闭Socket并释放有关的资源；
客户端：
(1)创建Socket类型的对象并提供服务器的通信地址和端口号；
(2)使用输入输出流进行通信；
(3)关闭Socket并释放有关的资源；
------------------day18----------------------
今天内容：
(1)反射机制
(2)常用的设计原则
1.反射机制(重点、原理、难点、尽量理解)
如：
Person p = new Person(); - 表示声明Person类型的引用指向Person类型的对象
p.show(); - 表示调用名字为show的成员方法
1.1 基本概念
通常情况下，编写的代码以及该代码运行的结果都是固定不变的，若希望编写的代码可以带来不同的运行结果，此时就需要使用反射机制。
换句话说，反射机制就是用于动态创建对象以及动态调用方法的机制。
1.2 Class类
(1)基本概念
Class类的实例表示正在运行的Java应用程序中的类和接口，也就是说Class类型的对象不再单纯地代表堆区中的内存区域，而是用于代表Java语言中的一种数据类型。
Class没有公共构造方法。Class对象是在加载类时由 Java 虚拟机以及通过调用类加载器中的 defineClass 方法自动构造的。
(2)Class对象的获取方式
(3)常用的方法
1.3 Constructor类
(1)基本概念
java.lang.reflect.Constructor类主要用于描述获取到的单个构造方法信息。
(2)常用的方法
1.4 Field类
(1)基本概念
java.lang.reflect.Field类主要用于描述获取到的单个成员变量信息。
(2)常用的方法
1.5 Method类
(1)基本概念
java.lang.reflect.Method类主要用于描述获取到的单个成员方法信息。
(2)常用的方法
2.常用的设计原则(记住)
2.1 软件开发的流程
需求分析文档 => 概要设计文档 => 详细设计文档 => 编码和测试 => 安装和调试
=> 维护和升级
---------------------day19--------------------
今天内容：
(1)常用的设计原则
(2)常用的设计模式
(3)常用的查找算法
(4)常用的排序算法
(5)兄弟连在线考试系统
1.常用的设计原则
1.1 软件开发的流程
需求分析文档 => 概要设计文档 => 详细设计文档 => 编码和测试 => 安装和调试
=> 维护和升级
1.2 常用的设计原则(记住)
开闭原则 - 对扩展开放，对修改关闭
如：
public class Person {
private String name;
…
}
public class SubPerson extends Person {
private int age;
…
}
里氏代换原则 - 任何父类可以出现的地方，子类一定可以出现。
- 子类 is a 父类，多使用多态的方式。
如：
public static void draw(Shape s) {
s.show();
}
draw(new Shape());
draw(new Circle());
draw(new Rect());
依赖倒转原则 - 在以后的开发中尽量多依赖于抽象类和接口，而不是具体实现类。
- 因为抽象类和接口对子类具有强制性和规范性。
如：
public abstract class Account {
public abstract double getLixi();
}
public class FixedAccount extends Account {
public double getLixi() {}
}
接口隔离原则 - 在以后的开发中尽量使用小接口而不是大接口，避免接口的污染。
如：
public interface RunAnimal {
public abstract void run();
}
public interface FlyAnimal {
public abstract void fly();
}
public class Dog implements RunAnimal {
public void run() {}
}
迪米特法则/最少知道原则 - 一个实体应当尽量少于其它实体之间发生关联。
- 高内聚，低耦合
- 所谓高内聚就是指一个实体应当有的功能应该尽量聚集于该实体的内部
- 所谓低耦合就是指一个实体应当减少与其它实体之间的关联。
合成复用原则 - 在以后的开发中尽量多使用合成的方式，而不是继承的方式。
如：
public class A {
public void show() {}
}
pubiic class B extends A { - 不推荐
public void test() {
// 调用A类中的show方法
show();
}
}
pubiic class B { - 推荐
private A a;
public B(A a) {
this.a = a;
}
public void test() {
// 调用A类中的show方法
a.show();
}
}
2.常用的设计模式
2.1 基本概念
设计模式就是一种编写代码经验的总结，是一种用在固定场合的固定套路。
2.2 常用的设计模式(重点)
常用的设计模式：单例设计模式、模板设计模式、工厂方法模式、抽象工厂模式、…
3.常用的查找算法(重点)
3.1 线性(顺序)查找算法
(1)算法流程
3.2 二分(折半)查找算法
(1)算法流程
1 ~ 100 50 1 ~ 50 25 1 ~ 25 17
4.常用的排序算法
4.1 冒泡排序算法(重中之重)
(1)算法流程
---------------------day20--------------------
205
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
