JAVA开发文档

           希西 JAVA开发文档

希西 JAVA开发文档 1
一、 变量 4
1． 基本类型之4类八种 4
2.常量与类型 5
3.变量使用注意事项 5
4.数据类型转换 5
二、 运算符 6
1.算数运算符++、–的使用 6
2.逻辑运算符 6
3.三元运算符 6
4.运算符优先级 6
三、 java基本语法-引用数据类型 7
1.Scanner类 7
2.随机数类Random 7
四、流程控制语句 8
1．循环语句for 8
2.循环语句do….while 8
3，跳转语句（break,continue） 8
五．数组 9
1.数组的定义（三种） 9
2.元素的默认值 10
3.数值的遍历 10
4.数组常见异常 10
5.二维数组 10
六、方法 11
1.重载 11
2.参数 11
七、ArrayList集合 12
1.集合的创建 12
2.集合常用的方法： 12
3.集合的遍历 13
八、Eclipse开发工具 13

1. Eclipse的下载、安装、卸载 13
   2.Eclipse的使用 13
   3.针对Eclipse空间的简单配置 14
   4.快捷键 19
   5.断点调试 19
   6项目的删除 21
   7.项目的导入 21
   九、类与对象、封装 22
   1.类与对象的区别 22
   2.局部变量和成员变量的区别 23
2. 封装概述 23
   十、继承和抽象类 23
   1.继承的格式&使用 23
   2继承-子父类中成员变量的特点 24
   3.继承-子父类中成员方法特点-重写&应用 24
   4.抽象类 25
   十一、接口 26
   1.类实现接口 26
   2.接口中成员变量的特点 26
3. 接口的多继承 27
   4．接口和抽象的区别 27
   十二、多态 28
   1.多态的定义与使用格式 28
   2.多态-成员的特点 28
4. instanceof关键字 28
   4.多态-转型 28
   十三、构造方法 29
   1.this关键字 29
   2.super关键字 30
   十三、变量函数的各种关键字 30
   1． Final 30
   2.static 30
   3.定义静态常量 31
   4.匿名对象 32
   5.内部类 32
   6.访问修饰符 34
   7.代码块（局部，静态，构造） 35
   十四、Eclipse的应用 36
   1.常用快捷键 36
   2.文档注释导出帮助文档 37
   3.项目的jar包导入与导出 38
   十五、API及Object类 39
   1.api 39
   2.object类 39
   3.String类 40
   4.StringBuffer类 41
   十六、正则表达式和日期 41
   1.正则表达式的匹配规则 41
5. 字符串类中涉及正则表达式方法 43
6. 常用的正则表达式常用 44
   4.日期类Date 44
   5.DateFormat 45
   6 Calendar日历类 46
   十七、基本类型包装类 47
   1.基本类型与字符串的转换 47
   2.基本类型和对象转换 48
   3.自动装箱拆箱 49
   4.system类 50
   5．Math类 51
7. Arrays类 51
8. 大数据运算 51
   十八、迭代器和增强for 51
   1.增强for 52
   2.迭代器 52
   十九、集合 53
   1.List接口 53
   2.ArrayList集合 55
9. LinkedList集合 55
10. Vector集合 56
11. Set接口 56
12. HashSet集合 56
    7.LinkedHashSet 57
    二十、Map接口 57
    1.Map接口中的常用方法 58
13. Map集合遍历键找值方式 58
    3.Entry键值对对象 60
    4．Map集合遍历键值对方式 60
    5．静态导入 62
    6.可变参数 62
14. Collections集合工具类 62
    二十一、异常 63
    二十二、File和递归 65
    1.file的构造函数 65
    2.File类的获取 65
15. 文件和文件夹的创建删除 66
    4，文件的过滤器 66
    5.递归 68
    二十三、IO流 68
    1.字节流 69
16. 字节输出流OutputStream 69
17. FileOutputStream类 69
18. IO异常的处理 70
    4.字节输入流InputStream 71
19. FileInputStream类 71
    2.字符流 72
    1.字符编码表 72
20. 字符输入流Reader 73
21. FileReader类 73
    4字符输出流Writer 74
    5 FileWriter类 74
    三十、mybatis 76
    1.mybatis入门 76
    （1）mybatis的概述 76
    （2）mybatis的环境搭建 77
    （3）mybatis入门案例 83
    （4）自定义mybatis框架 83
22. mybatis基本使用 83
    （1）mybatis的单表crud操作 83
    （2）mybatis的参数和返回值 83
    （3）mybatis的dao编写 83
    （4）mybatis配置的细节，几个标签的使用 83
    （5）mybatis的深入和多表 83
    （6）mybatis的连接池 83
    （7）mybatis的事务控制及设计的方法 83
    （8）mybatis的多表查询 83
    （9）mybatis的缓存和注解开发 83
    （10）mybatis中的加载时机（查询的时机） 83
    （11）mybatis中的一级缓存和二级缓存 83
    （12）mybatis的注解开发 83
    三十一、SpringMVC 84
23. idea常用的快捷键 84
    2.SpringMVC在三层架构的位置 87
    3、SpringMVC 和 Struts2 的优略分析 87
    三十三、bootstrap前端框架 88
    1.Bootstrap简介： 88
24. 响应式布局 89
25. CSS样式和JS插件 89

一、 变量
1． 基本类型之4类八种
四类 八种 字节数 数据表示范围
整型 byte 1 -128～127
short 2 -32768～32767
int 4 -2147483648～2147483648
long 8 -263～263-1
浮点型 float 4 -3.403E38～3.403E38
double 8 -1.798E308～1.798E308
字符型 char 2 表示一个字符，如(‘a’，‘A’，‘0’，‘家’)
布尔型 boolean 1 只有两个值true与false
2.常量与类型
Java中默认的整数类型是int类型，浮点类型是double类型
 3.14没有后缀，所以它是double类型；
 5.28D为double类型；
 1.26F为float类型。。
3.变量使用注意事项
 变量定义后可以不赋值，使用时再赋值。不赋值不能使用。
 变量使用时有作用域的限制。
 变量不可以重复定义。

4.数据类型转换
各种数据类型按照数据范围从小到大依次列出：
byte -> short -> int -> long -> float -> double
 自动类型转换
表示范围小的数据类型转换成范围大的数据类型，这种方式称为自动类型转换
自动类型转换格式：
范围大的数据类型 变量 = 范围小的数据类型值；
如：
int i = 100;
double d2 = i;

 强制类型转换
表示范围大的数据类型转换成范围小的数据类型，这种方式称为强制类型转换
强制类型转换格式：
范围小的数据类型 变量 = (范围小的数据类型) 范围大的数据类型值;
如：
int i = (int)6.718; //i的值为6

二、 运算符
1.算数运算符++、–的使用
++,–运算符后置时，先使用变量a原有值参与运算操作，运算操作完成后，变量a的值自增1或者自减1；

++，–运算符前置时，先将变量a的值自增1或者自减1，然后使用更新后的新值参与运算操作。
2.逻辑运算符
逻辑运算符，
它是用于布尔值进行运算的，运算的最终结果为布尔值true或false。
运算符 运算规则 范例 结果
& 与 false&true False
| 或 false|true True
^ 异或 true^flase True
! 非 !true Flase
&& 短路与 false&&true False
|| 短路或 false||true True

3.三元运算符
(条件表达式)？表达式1：表达式2；
String result = (a==b) ? “相等” : “不相等”;
System.out.println( 3>2 ? “正确” : “错误” );
4.运算符优先级
优先级 描述 运算符
1 括号 ()、[]
2 正负号 +、-
3 自增自减，非 ++、–、!
4 乘除，取余 、/、%
5 加减 +、-
6 移位运算 <<、>>、>>>
7 大小关系 >、>=、<、<=
8 相等关系 ==、!=
9 按位与 &
10 按位异或 ^
11 按位或 |
12 逻辑与 &&
13 逻辑或 ||
14 条件运算 ?:
15 赋值运算 =、+=、-=、=、/=、%=
16 位赋值运算 &=、|=、<<=、>>=、>>>=

三、 java基本语法-引用数据类型
1.Scanner类
++++++++++++++++引用数据类型的使用：
与定义基本数据类型变量不同，引用数据类型的变量定义及赋值有一个相对固定的步骤或格式。
数据类型 变量名 = new 数据类型();
每种引用数据类型都有其功能，我们可以调用该类型实例的功能。
变量名.方法名();

+++++++++++ Scanner使用步骤：
导包：import java.util.Scanner;
创建对象实例：Scanner sc = new Scanner(System.in);
调用方法：
int i = sc.nextInt(); 用来接收控制台录入的数字
String s = sc.next(); 用来接收控制台录入的字符串
2.随机数类Random
方法简介
public int nextInt(int maxValue) 产生[0,maxValue)范围的随机整数，包含0，不包含maxValue；
public double nextDouble() 产生[0,1)范围的随机小数，包含0.0，不包含1.0。
 Random使用方式:
 import导包：所属包java.util.Random
 创建实例格式：Random 变量名 = new Random();
四、流程控制语句
1．循环语句for
for（初始化表达式; 循环条件; 操作表达式）{
执行语句
………
}
for（① ; ② ; ③）{
④
}
第一步，执行①
第二步，执行②，如果判断结果为true，执行第三步，如果判断结果为false，执行第五步
第三步，执行④
第四步，执行③，然后重复执行第二步
第五步，退出循环

2.循环语句do….while
do {
执行语句
………
} while(循环条件);
3，跳转语句（break,continue）

++++++++Break语句
在switch条件语句和循环语句中都可以使用break语句。当它出现在switch条件语句中时，作用是终止某个case并跳出switch结构。当它出现在循环语句中，作用是跳出循环语句，执行后面的代码

+++++++标记
当break语句出现在嵌套循环中的内层循环时，它只能跳出内层循环，如果想使用break语句跳出外层循环则需要对外层循环添加标记。
public class BreakDemo02 {
public static void main(String[] args) {
int i, j; // 定义两个循环变量
itcast: for (i = 1; i <= 9; i++) { // 外层循环
for (j = 1; j <= i; j++) { // 内层循环
if (i > 4) { // 判断i的值是否大于4
break itcast; // 跳出外层循环
}
System.out.print(""); // 打印
}
System.out.print("\n"); // 换行
}
}
}

+++++++++continue
continue语句用在循环语句中，它的作用是终止本次循环，执行下一次循环
4.选择结构switch
switch (表达式){
case 目标值1:
执行语句1
break;
case 目标值2:
执行语句2
break;
．．．．．．
case 目标值n:
执行语句n
break;
default:
执行语句n+1
break;
}

五．数组
1.数组的定义（三种）
（1）数据类型[] 数组名 = new 数据类型[元素个数或数组长度];
int[] x = new int[100];
（2）类型[] 数组名 = new 类型[]{元素，元素，……};
（3）类型[] 数组名 = {元素，元素，元素，……};

2.元素的默认值
表2-1 元素默认值
数据类型 默认初始化值
byte、short、int、long 0
float、double 0.0
char 一个空字符（空格），即’\u0000’
boolean false
引用数据类型 null，表示变量不引用任何对象
3.数值的遍历
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]); // 通过索引访问元素
}
4.数组常见异常
NullPointerException: 空指针异常
在使用变量引用一个数组时，变量必须指向一个有效的数组对象，如果该变量的值为null，则意味着没有指向任何数组，此时通过该变量访问数组的元素会出现空指针异常，
ArrayIndexOutOfBoundsException: 数组越界异常
5.二维数组
格式1：
数据类型[][] 数组名 = new 数据类型[m][n];
m: 代表二维数组中一维数组的个数
n: 代表每个一维数组中元素的个数
格式2：
数据类型[][] 数组名 = new 数据类型[m][];
m: 代表二维数组中一维数组的个数
每一个一维数组通过赋值来确定数组长度
格式3：
数据类型[][] 数组名 = {{元素值1，元素值2,…},{元素值1，元素值2,…},…};
六、方法
1.重载
Java允许在一个类中定义多个名称相同的方法，但是参数的类型或个数必须不同，这就是方法的重载。
下面的三个方法互为重载关系
 public static int add(int x,int y) {逻辑} //两个整数加法
 public static int add(int x,int y,int z) {逻辑} //三个整数加法
 public static int add(double x,double y) {逻辑} //两个小数加法
注意事项：
 重载方法参数必须不同：
参数个数不同，如method(int x)与method(int x,int y)不同
参数类型不同，如method(int x)与method(double x)不同g
参数顺序不同，如method(int x,double y)与method(double x,int y)不同
 重载只与方法名与参数类型相关与返回值无关
如void method(int x)与int method(int y)不是方法重载，不能同时存在
 重载与具体的变量标识符无关
如method(int x)与method(int y)不是方法重载，不能同时存在
2.参数

通过上面的两段程序可以得出如下结论：
 当调用方法时，如果传入的数值为基本数据类型（包含String类型），形式参数的改变对实际参数不影响
 当调用方法时，如果传入的数值为引用数据类型（String类型除外），形式参数的改变对实际参数有影响
七、ArrayList集合
1.集合的创建
它属于引用数据类型（类）。我们可以看作一个长度可变的数组。
导包：import java.util.ArrayList;
创建对象：与其他普通的引用数据类型创建方式完全相同，但是要指定容器中存储的数据类型：
ArrayList<要存储元素的数据类型> 变量名 = new ArrayList<要存储元素的数据类型>();
 集合中存储的元素，只能为<>括号中指定的数据类型元素；
 “<要存储元素的数据类型>”中的数据类型必须是引用数据类型，不能是基本数据类型；
下面给出8种基本数据类型所对应的引用数据类型表示形式:
基本数据类型 对应的引用数据类型表示形式
byte Byte
short Short
Int Integer
long Long
float Float
double Double
char Character
boolean Boolean

2.集合常用的方法：
方法声明 功能描述
boolean add（Object obj） 将指定元素obj追加到集合的末尾
Object get（int index） 返回集合中指定位置上的元素
int size（） 返回集合中的元素个数
方法声明 功能描述
boolean add（int index, Object obj） 将指定元素obj插入到集合中指定的位置
Object remve（int index） 从集合中删除指定index处的元素，返回该元素
void clear（） 清空集合中所有元素
Object set（int index, Object obj） 用指定元素obj替代集合中指定位置上的元素

3.集合的遍历
//遍历集合
for (int i = 0; i < list.size(); i++) {
//通过索引，获取到集合中每个元素
int n = list.get(i);
System.out.println(n);
}
八、Eclipse开发工具

1. Eclipse的下载、安装、卸载
    下载 http://www.eclipse.org
    安装 (只需要解压后就能使用)
    卸载（只需要将文件夹删除就可以了）
    注意： 开发软件的安装目录中，尽量不要出现空格与中文
   2.Eclipse的使用
   在当前阶段，我们只需要完成最基本的Java文件编写，其他功能跟随日常教学慢慢渗透学习。
   使用步骤：
    1.开启，选择工作空间，如下图
    工作空间：指的是将来编写的java源文件存放的位置
    下图中的复选框“□”，如果选中，表示使用当前工作空间为Eclipse的默认工作空间，以后启动Eclipse时，不在提示选择工作空间。

图1-1 选择工作空间
3.针对Eclipse空间的简单配置
 程序的编译环境和运行环境
 编译环境：Window – Preferences – Java - Compiler
 运行环境：Window – Preferences – Java - Installed JREs

图1-2 编译环境与运行环境配置
 如何显示行号与隐藏行号
 显示：在代码区域的左边空白区域，右键 – Show Line Numbers
 隐藏：将上面的操作再做一遍

图1-3 行号显示与隐藏
 如何更改字体大小与颜色
 修改java代码的字体大小与颜色
 Window – Preferences – General – Appearance – Colors and Fonts – Java – Java Editor Text Font选中后，点击Edit，进行修改
 修改其他字体大小与颜色
 Window – Preferences – General – Appearance – Colors and Fonts – Bacic – Text Font 选中后 点击Edit ,进行修改

图1-4 设置字体

 显示的窗口乱了，还原默认显示模式
 Window – Perspective – Reset Prespective

 如何去掉默认注释
 Window – Preferences – Java – Code Style – Code Templates – Comments – Methods，点击Edit ，将注释部分删除 (不建议删除)
 Window – Preferences – Java – Code Style – Code Templates – Code – Method body，点击Edit ，将注释部分删除

 切换工作空间
 File – Switch Workspace – 指定工作空间 – ok

4.快捷键
 内容辅助键 Alt+/
 自动补齐main方法 main 然后 Alt+/
 自动补齐输出语句 syso 然后 Alt+/
 格式化Ctrl+Shift+f
 代码区域右键 – Source – Format
 自动导包： Ctrl+Shift+o
 如果当前类在多个包中都存在，这时候，使用Ctrl+shift+o,进行选择一个包导入即可。
 注释
 单行注释
 加注释： 先选中需要注释的内容，然后 Ctrl+/
 取消注释：先选中需要取消注释的内容， 然后 Ctrl+/
 多行注释
 加注释： 先选中需要注释的内容，然后 Ctrl+Shift+/
 取消注释：先选中需要取消注释的内容， 然后 Ctrl+Shift+
5.断点调试
 断点： 就是一个标记
 如何设置断点
 代码区域左边的空白位置 双击即可
 在哪里加
 想看哪个语句的执行结果就在该语句前面加
 怎么运行断点的程序
 代码区域右键 – Debug as – Java Application
 显示一个页面，提示是否进入调试页面？ 是否记住当前操作？是(Yes)是（勾选复选框）

 弹出了断点页面

 点哪里
 点击 工具栏中的Step Over (执行下一行)
 快捷键F6 看到每一步程序的执行过程
 看哪里
 看代码区域： 对照看程序执行步骤
 看Debug区域： 对照看程序执行步骤
 看varable区域： 观察变量的创建、复制、销毁
 如何消除断点
 把设置断点的方式再执行一遍
 切换到Debug视图，选择 Breakpoints – Remove All Breakpoints 就是2个XX的图标
6项目的删除
 在项目区域删除
 在左侧PackageExplorer区域对指定项目右键，点击delete删除
 在硬盘上删除
 在左侧PackageExplorer区域对指定项目右键，点击delete删除,同时选中下面的在硬盘上删除(Delete project contents on disk)

图1-5 项目删除
7.项目的导入
 在左侧的PackageExplorer区域右键，选择 import
 选择 General – Existing Projects into Workspace
 选择后，点击 next
 在新的窗口中，点击 Browse 找到需要导入的项目（注意，找到项目的名字位置就可以了），选中要导入的项目，点击Copy复选框，点击Finish完成。
 注意事项
 Eclipse中已经存在的同名项目不能再次导入

图1-6 项目导入
九、类与对象、封装
1.类与对象的区别
类是对某一类事物的抽象描述，而对象用于表示现实中该类事物的个体。

2.局部变量和成员变量的区别
可以在成员变量名前面加上this.来区别成员变量和局部变量

区别一：定义的位置不同
定义在类中的变量是成员变量
定义在方法中或者{}语句里面的变量是局部变量
区别二：在内存中的位置不同
成员变量存储在对内存的对象中
局部变量存储在栈内存的方法中
区别三：声明周期不同
成员变量随着对象的出现而出现在堆中，随着对象的消失而从堆中消失
局部变量随着方法的运行而出现在栈中，随着方法的弹栈而消失
区别四：初始化不同
成员变量因为在堆内存中，所有默认的初始化值
局部变量没有默认的初始化值，必须手动的给其赋值才可以使用。
3. 封装概述
提起封装，大家并不陌生。前面我们学习方法时，就提起过，将具体功能封装到方法中，学习对象时，也提过将方法封装在类中，其实这些都是封装。
封装，它也是面向对象思想的特征之一。面向对象共有三个特征：封装，继承，多态。接下来我们具体学习封装。
 封装表现：
 1、方法就是一个最基本封装体。
 2、类其实也是一个封装体。
 从以上两点得出结论，封装的好处：
 1、提高了代码的复用性。
 2、隐藏了实现细节，还要对外提供可以访问的方式。便于调用者的使用。这是核心之一，也可以理解为就是封装的概念。
3、提高了安全性。
十、继承和抽象类
在Java中，类的继承是指在一个现有类的基础上去构建一个新的类，构建出来的新类被称作子类，现有类被称作父类，子类会自动拥有父类所有可继承的属性和方法。
1.继承的格式&使用
格式：
class 子类 extends 父类 {}
继承的好处：
1、继承的出现提高了代码的复用性，提高软件开发效率。
2、继承的出现让类与类之间产生了关系，提供了多态的前提。
在类的继承中，需要注意一些问题，具体如下：
 1、在Java中，类只支持单继承，不允许多继承，也就是说一个类只能有一个直接父类，例如下面这种情况是不合法的。
class A{}
class B{}
class C extends A,B{} // C类不可以同时继承A类和B类
 2、多个类可以继承一个父类，例如下面这种情况是允许的。
class A{}
class B extends A{}
class C extends A{} // 类B和类C都可以继承类A
 3、在Java中，多层继承是可以的，即一个类的父类可以再去继承另外的父类，例如C类继承自B类，而B类又可以去继承A类，这时，C类也可称作A类的子类。下面这种情况是允许的。
class A{}
class B extends A{} // 类B继承类A，类B是类A的子类
class C extends B{} // 类C继承类B，类C是类B的子类，同时也是类A的子类
 4、在Java中，子类和父类是一种相对概念，也就是说一个类是某个类父类的同时，也可以是另一个类的子类。例如上面的这种情况中，B类是A类的子类，同时又是C类的父类。
2继承-子父类中成员变量的特点
成员变量：如果子类父类中出现不同名的成员变量，这时的访问是没有任何问题。
当子父类中出现了同名成员变量时，在子类中若要访问父类中的成员变量，必须使用关键字super来完成。super用来表示当前对象中包含的父类对象空间的引用。
在子类中，访问父类中的成员变量格式：
super.父类中的成员变量
3.继承-子父类中成员方法特点-重写&应用
 子父类中成员方法的特点
当在程序中通过对象调用方法时，会先在子类中查找有没有对应的方法，若子类中存在就会执行子类中的方法，若子类中不存在就会执行父类中相应的方法。
 成员方法特殊情况——覆盖
子类中出现与父类一模一样的方法时，会出现覆盖操作，也称为override重写、复写或者覆盖。

注意事项：
重写需要注意的细节问题：
 子类方法覆盖父类方法，必须要保证权限大于等于父类权限。
class Fu(){
void show(){}
public void method(){}
}
class Zi() extends Fu{
public void show(){} //编译运行没问题
void method(){} //编译错误
}
 写法上稍微注意:必须一模一样:方法的返回值类型 方法名 参数列表都要一样。
总结：当一个类是另一个类中的一种时，可以通过继承，来继承属性与功能。如果父类具备的功能内容需要子类特殊定义时，进行方法重写
4.抽象类
方法功能声明相同，但方法功能主体不同。那么这时也可以抽取，但只抽取方法声明，不抽取方法主体。那么此方法就是一个抽象方法。
当定义了抽象函数的类也必须被abstract关键字修饰，被abstract关键字修饰的类是抽象类。

抽象方法定义的格式：
public abstract 返回值类型 方法名(参数);
抽象类定义的格式：
abstract class 类名 {
}

抽象类的特点：
1、抽象类和抽象方法都需要被abstract修饰。抽象方法一定要定义在抽象类中。
2、抽象类不可以直接创建对象，原因：调用抽象方法没有意义。
3、只有覆盖了抽象类中所有的抽象方法后，其子类才可以创建对象。否则该子类还是一个抽象类。
之所以继承抽象类，更多的是在思想，是面对共性类型操作会更简单。

抽象类的细节问题：
1、抽象类一定是个父类？
是的，因为不断抽取而来的。
2、抽象类中是否可以不定义抽象方法。
是可以的，那这个抽象类的存在到底有什么意义呢？不让该类创建对象,方法可以直接让子类去使用
3、抽象关键字abstract不可以和哪些关键字共存？
 1、private：私有的方法子类是无法继承到的，也不存在覆盖，而abstract和private一起使用修饰方法，abstract既要子类去实现这个方法，而private修饰子类根本无法得到父类这个方法。互相矛盾。
 2、final，暂时不关注，后面学
 3、static，暂时不关注，后面学

十一、接口
与定义类的class不同，接口定义时需要使用interface关键字。
定义接口所在的仍为.java文件，虽然声明时使用的为interface关键字的编译后仍然会产生.class文件。这点可以让我们将接口看做是一种只包含了功能声明的特殊类。
定义格式：
public interface 接口名 {
抽象方法1;
抽象方法2;
抽象方法3;
}
使用interface代替了原来的class，其他步骤与定义类相同：
 接口中的方法均为公共访问的抽象方法
 接口中无法定义普通的成员变量
总结：接口在开发中的它好处
1、接口的出现扩展了功能。
2、接口其实就是暴漏出来的规则。
3、接口的出现降低了耦合性，即设备与设备之间实现了解耦。
4、接口的出现避免了单继承的局限性。
1.类实现接口
class 类 implements 接口 {
重写接口中方法
}
在类实现接口后，该类就会将接口中的抽象方法继承过来，此时该类需要重写该抽象方法，完成具体的逻辑。
2.接口中成员变量的特点
1、接口中可以定义变量，但是变量必须有固定的修饰符修饰，public static final 所以接口中的变量也称之为常量，其值不能改变。后面我们会讲解static与final关键字
2、接口中可以定义方法，方法也有固定的修饰符，public abstract
3、接口不可以创建对象。
4、子类必须覆盖掉接口中所有的抽象方法后，子类才可以实例化。否则子类是一个抽象类。
interface Demo { ///定义一个名称为Demo的接口。
public static final int NUM = 3;// NUM的值不能改变
public abstract void show1();
public abstract void show2();
}

//定义子类去覆盖接口中的方法。类与接口之间的关系是 实现。通过 关键字 implements
class DemoImpl implements Demo { //子类实现Demo接口。
//重写接口中的方法。
public void show1(){}
public void show2(){}
}
3. 接口的多继承
interface Fu1{
void show();
}
interface Fu2{
void show1();
}
interface Zi extends Fu1,Fu2, {
void show3();
}
4．接口和抽象的区别
相同点:
 都位于继承的顶端,用于被其他类实现或继承;
 都不能直接实例化对象;
 都包含抽象方法,其子类都必须覆写这些抽象方法;
区别:
 抽象类为部分方法提供实现,避免子类重复实现这些方法,提高代码重用性;接口只能包含抽象方法;
 一个类只能继承一个直接父类(可能是抽象类),却可以实现多个接口;(接口弥补了Java的单继承)
 抽象类是这个事物中应该具备的你内容, 继承体系是一种 is…a关系
 接口是这个事物中的额外内容,继承体系是一种 like…a关系

二者的选用:
 优先选用接口,尽量少用抽象类;
 需要定义子类的行为,又要为子类提供共性功能时才选用抽象类;
十二、多态
父类引用变量可以指向子类对象。
多态的前提是必须有子父类关系或者类实现接口关系，否则无法完成多态。
在使用多态后的父类引用变量调用方法时，会调用子类重写后的方法。
1.多态的定义与使用格式
多态的定义格式：就是父类的引用变量指向子类对象
父类类型 变量名 = new 子类类型();
变量名.方法名();
2.多态-成员的特点
 多态成员变量
当子父类中出现同名的成员变量时，多态调用该变量时：
编译时期：参考的是引用型变量所属的类中是否有被调用的成员变量。没有，编译失败。
运行时期：也是调用引用型变量所属的类中的成员变量。
简单记：编译和运行都参考等号的左边。编译运行看左边
 多态成员方法
编译时期：参考引用变量所属的类，如果没有类中没有调用的方法，编译失败。
运行时期：参考引用变量所指的对象所属的类，并运行对象所属类中的成员方法。
简而言之：编译看左边，运行看右边。
3. instanceof关键字
我们可以通过instanceof关键字来判断某个对象是否属于某种数据类型。如学生的对象属于学生类，学生的对象也属于人类。
使用格式：
boolean b = 对象 instanceof 数据类型;
4.多态-转型
多态的转型分为向上转型与向下转型两种：
 向上转型：当有子类对象赋值给一个父类引用时，便是向上转型，多态本身就是向上转型的过程。
使用格式：
父类类型 变量名 = new 子类类型();
如：Person p = new Student();
 向下转型：一个已经向上转型的子类对象可以使用强制类型转换的格式，将父类引用转为子类引用，这个过程是向下转型。如果是直接创建父类对象，是无法向下转型的！
使用格式：
子类类型 变量名 = (子类类型) 父类类型的变量;
如:Student stu = (Student) p; //变量p 实际上指向Student对象
 什么时候使用向上转型：
当不需要面对子类类型时，通过提高扩展性，或者使用父类的功能就能完成相应的操作，这时就可以使用向上转型。
如：Animal a = new Dog();
a.eat();
 什么时候使用向下转型
当要使用子类特有功能时，就需要使用向下转型。
如：Dog d = (Dog) a; //向下转型
d.lookHome();//调用狗类的lookHome方法
 向下转型的好处：可以使用子类特有功能。
 弊端是：需要面对具体的子类对象；在向下转型时容易发生ClassCastException类型转换异常。在转换之前必须做类型判断。
如：if( !a instanceof Dog){…}
十三、构造方法
1.this关键字
可以在成员变量名前面加上this.来区别成员变量和局部变量

class Person {
// Person的成员属性
private int age;
private String name;

// 无参数的构造方法
Person() {
}

// 给姓名初始化的构造方法
Person(String nm) {
	name = nm;
}

// 给姓名和年龄初始化的构造方法
Person(String nm, int a) {
	// 由于已经存在给姓名进行初始化的构造方法 name = nm;因此只需要调用即可
	// 调用其他构造方法，需要通过this关键字来调用
	this(nm);
	// 给年龄初始化
	age = a;
}

}
2.super关键字
在创建子类对象时，父类的构造方法会先执行，因为子类中所有构造方法的第一行有默认的隐式super();语句。
格式：
调用本类中的构造方法
this(实参列表);
调用父类中的空参数构造方法
super();
调用父类中的有参数构造方法
super(实参列表);
十三、变量函数的各种关键字
1． Final
1,final的意思为最终，不可变。final是个修饰符，它可以用来修饰类，类的成员，以及局部变量。
2, final修饰类不可以被继承，但是可以继承其他类。
3. final修饰的变量称为常量，这些变量只能赋值一次。
4引用类型的变量值为对象地址值，地址值不能更改，但是地址内的对象属性值可以修改。
final Person p = new Person();
Person p2 = new Person();
p = p2; //final修饰的变量p，所记录的地址值不能改变
p.name = “小明”;//可以更改p对象中name属性值
p不能为别的对象，而p对象中的name或age属性值可更改。
5. 修饰成员变量，需要在创建对象前赋值，否则报错。
2.static
static它是静态修饰符，一般用来修饰类中的成员。
 被static修饰的成员变量属于类，不属于这个类的某个对象。（也就是说，多个对象在访问或修改static修饰的成员变量时，其中一个对象将static成员变量值进行了修改，其他对象中的static成员变量值跟着改变，即多个对象共享同一个static成员变量）

 被static修饰的成员可以并且建议通过类名直接访问。
访问静态成员的格式：
类名.静态成员变量名
类名.静态成员方法名(参数)
对象名.静态成员变量名 ------不建议使用该方式，会出现警告
对象名.静态成员方法名(参数) ------不建议使用该方式，会出现警告

static注意事项
 静态内容是优先于对象存在，只能访问静态，不能使用this/super。静态修饰的内容存于静态区。
 同一个类中，静态成员只能访问静态成员
class Demo {
//成员变量
public int num = 100;
//静态成员变量
public static int count = 200;
//静态方法
public static void method(){
//System.out.println(num); 静态方法中，只能访问静态成员变量或静态成员方法
System.out.println(count);
}
}

 main方法为静态方法仅仅为程序执行入口，它不属于任何一个对象，可以定义在任意类中
3.定义静态常量
public static final修饰的变量来完成定义。此时变量名用全部大写，多个单词使用下划线连接。
public static final 数据类型 变量名 = 值;

注意：
接口中的每个成员变量都默认使用public static final修饰。
所有接口中的成员变量已是静态常量，由于接口没有构造方法，所以必须显示赋值。可以直接用接口名访问。
4.匿名对象
匿名对象是指创建对象时，只有创建对象的语句，却没有把对象地址值赋值给某个变量。
创建一个普通对象
Person p = new Person();
创建一个匿名对象
new Person();

特点：
 创建匿名对象直接使用，没有变量名。
new Person().eat() //eat方法被一个没有名字的Person对象调用了。

 匿名对象在没有指定其引用变量时，只能使用一次。
new Person().eat(); 创建一个匿名对象，调用eat方法
new Person().eat(); 想再次调用eat方法，重新创建了一个匿名对象

 匿名对象可以作为方法接收的参数、方法返回值使用
5.内部类
 什么是内部类
将类写在其他类的内部，可以写在其他类的成员位置和局部位置，这时写在其他类内部的类就称为内部类。其他类也称为外部类。
 什么时候使用内部类
在描述事物时，若一个事物内部还包含其他可能包含的事物，比如在描述汽车时，汽车中还包含这发动机，这时发动机就可以使用内部类来描述。
 内部类的分类
内部类分为成员内部类与局部内部类。
我们定义内部类时，就是一个正常定义类的过程，同样包含各种修饰符、继承与实现关系等。在内部类中可以直接访问外部类的所有成员。
（1）成员内部类
成员内部类，定义在外部类中的成员位置。与类中的成员变量相似，可通过外部类对象进行访问
 定义格式
class 外部类 {
修饰符 class 内部类 {
//其他代码
}
}
 访问方式
外部类名.内部类名 变量名 = new 外部类名().new 内部类名();

（2）局部内部类
局部内部类，定义在外部类方法中的局部位置。与访问方法中的局部变量相似，可通过调用方法进行访问
 定义格式
class 外部类 {
修饰符 返回值类型 方法名(参数) {
class 内部类 {
//其他代码
}
}
}
 访问方式
在外部类方法中，创建内部类对象，进行访问

 局部内部类代码演示
定义类
class Party {//外部类，聚会
public void puffBall(){// 吹气球方法
class Ball {// 内部类，气球
public void puff(){
System.out.println(“气球膨胀了”);
}
}
//创建内部类对象，调用puff方法
new Ball().puff();
}
}

访问内部类
public static void main(String[] args) {
//创建外部类对象
Party p = new Party();
//调用外部类中的puffBall方法
p.puffBall();
}

（3）内部类的实际使用——匿名内部类
匿名内部类概念
内部类是为了应对更为复杂的类间关系。查看源代码中会涉及到，而在日常业务中很难遇到，这里不做赘述。
最常用到的内部类就是匿名内部类，它是局部内部类的一种。
定义的匿名内部类有两个含义：
 临时定义某一指定类型的子类
 定义后即刻创建刚刚定义的这个子类的对象
定义匿名内部类的作用与格式
作用：匿名内部类是创建某个类型子类对象的快捷方式。
格式：
new 父类或接口(){
//进行方法重写
};

 代码演示
//已经存在的父类：
public abstract class Person{
public abstract void eat();
}
//定义并创建该父类的子类对象，并用多态的方式赋值给父类引用变量
Person p = new Person(){
public void eat() {
System.out.println(“我吃了”);
}
};
//调用eat方法
p.eat();
使用匿名对象的方式，将定义子类与创建子类对象两个步骤由一个格式一次完成，。虽然是两个步骤，但是两个步骤是连在一起完成的。
匿名内部类如果不定义变量引用，则也是匿名对象。代码如下：
new Person(){
public void eat() {
System.out.println(“我吃了”);
}
}.eat();
6.访问修饰符
public protected default private
同一类中 √ √ √ √
同一包中(子类与无关类) √ √ √
不同包的子类 √ √
不同包中的无关类 √
归纳一下：在日常开发过程中，编写的类、方法、成员变量的访问
 要想仅能在本类中访问使用private修饰；
 要想本包中的类都可以访问不加修饰符即可；
 要想本包中的类与其他包中的子类可以访问使用protected修饰
 要想所有包中的所有类都可以访问使用public修饰。
 注意：如果类用public修饰，则类名必须与文件名相同。一个文件中只能有一个public修饰的类。
7.代码块（局部，静态，构造）

 代码块：
局部代码块：定义在方法中的，用来限制变量的作用范围
构造代码块：定义在类中方法外，用来给对象中的成员初始化赋值
静态代码块：定义在类中方法外，用来给类的静态成员初始化赋值
（1）局部代码块
局部代码块是定义在方法或语句中
特点：
 以”{}”划定的代码区域，此时只需要关注作用域的不同即可
 方法和类都是以代码块的方式划定边界的
class Demo{
public static void main(String[] args) {
{
int x = 1;
System.out.println(“普通代码块” + x);
}
int x = 99;
System.out.println(“代码块之外” + x);
}
}
结果：
普通代码块1
代码块之外99

（2）构造代码块
构造代码块是定义在类中成员位置的代码块
特点：
 优先于构造方法执行，构造代码块用于执行所有对象均需要的初始化动作
 每创建一个对象均会执行一次构造代码块。
public class Person {
private String name;
private int age;

 //构造代码块
{
	System.out.println("构造代码块执行了");
}
Person(){
	System.out.println("Person无参数的构造函数执行");
}
Person(int age){
	this.age = age;
	System.out.println("Person（age）参数的构造函数执行");
}

}
class PersonDemo{
public static void main(String[] args) {
Person p = new Person();
Person p1 = new Person(23);
}
}

（3）静态代码块
静态代码块是定义在成员位置，使用static修饰的代码块。
特点：
 它优先于主方法执行、优先于构造代码块执行，当以任意形式第一次使用到该类时执行。
 该类不管创建多少对象，静态代码块只执行一次。
 可用于给静态变量赋值，用来给类进行初始化。
public class Person {
private String name;
private int age;
//静态代码块
static{
System.out.println(“静态代码块执行了”);
}
}

十四、Eclipse的应用
1.常用快捷键
 Ctrl+T：查看所选中类的继承树
 查看所选中类的源代码
Ctrl+滑动鼠标点击类名，或者选中类名后，按F3键查看所选中类的源代码
 Eclipse中的JRE System Library是默认的Eclipse依赖JRE中的类库。在该位置可以查找到平常使用的String类、Random类、Math类等。
2.文档注释导出帮助文档
在eclipse使用时，可以配合文档注释，导出对类的说明文档，从而供其他人阅读学习与使用。
通过使用文档注释，将类或者方法进行注释用@简单标注基本信息。如@author 作者、@version代码版本、@param方法参数、@return方法返回值等。
package cn.itcast;
/**

• 我的工具类
• @author Li
• @version 1.0版本
  /
  public class Tool {
  /*
  • 返回两个整数的累加和
  • @param num1 第一个数
  • @param num2 第二个数
  • @return 返回累加和
    */
    public static int getSum(int num1, int num2){
    return num1 + num2;
    }
    }

使用Eclipse导出javadoc文档即可，操作步骤如下图：

3.项目的jar包导入与导出
jar包是一个可以包含许多.class文件的压缩文件。我们可以将一个jar包加入到项目的依赖中，从而该项目可以使用该jar下的所有类；也可以把项目中所有的类打包到指定的jar包，提供给其他项目使用。
 导出jar包：即把项目中所有类，打包到指定的jar包中，步骤如下图：

 导入jar包：即把指定的jar包，加入到指项目中，提供给项目使用。
导入jar包的过程是将jar包加入到项目的.classpath文件中去，让项目识别，便可以使用jar包中所有的.class文件类。以下是加入步骤：
1：项目根文件夹下创建lib文件夹，用于同一管理所有的jar文件
2：把jar文件复制到lib文件夹中
3：右键点击jar文件，点击Build Path，选择Add to Build Path，此时查看项目根文件夹下的.classpath文件，发现新加入的jar包路径被配置到了该文件中。说明可以使用jar包中所有类了。

 注意：
Jar包加入后，必须Add to Build Path才能使用
Jar包加入后，加入的类也必须导包，如果加入的类其包名与现有类包名相同，则视作在同一个包下。(不常见)
十五、API及Object类
1.api

2.object类
1．

在复写Object中的equals方法时，一定要注意public boolean equals(Object obj)的参数是Object类型，在调用对象的属性时，一定要进行类型转换，在转换之前必须进行类型判断。
//判断传递进来的对象是否是Person类型
if(!(obj instanceof Person)){
return false;
}

toString方法返回该对象的字符串表示，其实该字符串内容就是对象的类型+@+内存地址值。
由于toString方法返回的结果是内存地址，而在开发中，经常需要按照对象的属性得到相应的字符串表现形式，因此也需要重写它。
class Person extends Object{
int age ;
//根据Person类的属性重写toString方法
public String toString() {
return “Person [age=” + age + “]”;
}
}
3.String类

4.StringBuffer类

十六、正则表达式和日期
1.正则表达式的匹配规则
字符：x
含义：代表的是字符x

字符：\
含义：代表的是反斜线字符’’

字符：\t
含义：制表符
字符：\n
含义：换行符
字符：\r
含义：回车符
字符类：[abc]
含义：代表的是字符a、b 或 c

字符类：[^abc]
含义：代表的是除了 a、b 或 c以外的任何字符

字符类：[a-zA-Z]
含义：代表的是a 到 z 或 A 到 Z，两头的字母包括在内

字符类：[0-9]
含义：代表的是 0到9数字，两头的数字包括在内

字符类：[a-zA-Z_0-9]
含义：代表的字母或者数字或者下划线(即单词字符)

预定义字符类：.
含义：代表的是任何字符

预定义字符类：\d
含义：代表的是 0到9数字，两头的数字包括在内，相当于[0-9]

预定义字符类：\w
含义：代表的字母或者数字或者下划线(即单词字符)，相当于[a-zA-Z_0-9]

边界匹配器：^
含义：代表的是行的开头
例如：匹配规则为¹[0-9]$ ，那么需要匹配的内容从[abc]这个位置开始, 相当于左双引号

边界匹配器：$
含义：代表的是行的结尾
例如：匹配规则为²[0-9]$ ，那么需要匹配的内容以[0-9]这个结束, 相当于右双引号

边界匹配器：\b
含义：代表的是单词边界
例如：匹配规则为"\b[abc]\b" ，那么代表的是字母a或b或c的左右两边需要的是非单词字符([a-zA-Z_0-9])

数量词：X?
含义：代表的是X出现一次或一次也没有
例如：匹配规则为"a?"，那么需要匹配的内容是一个字符a，或者一个a都没有

数量词：X*
含义：代表的是X出现零次或多次
例如：匹配规则为"a*" ，那么需要匹配的内容是多个字符a，或者一个a都没有

数量词：X+
含义：代表的是X出现一次或多次
例如：匹配规则为"a+"，那么需要匹配的内容是多个字符a，或者一个a

数量词：X{n}
含义：代表的是X出现恰好 n 次
例如：匹配规则为"a{5}"，那么需要匹配的内容是5个字符a

数量词：X{n,}
含义：代表的是X出现至少 n 次
例如：匹配规则为"a{5, }"，那么需要匹配的内容是最少有5个字符a

数量词：X{n,m}
含义：代表的是X出现至少 n 次，但是不超过 m 次
例如：匹配规则为"a{5,8}"，那么需要匹配的内容是有5个字符a 到 8个字符a之间
案例：

规则：“1[34578][0-9]{9}”
该规则需要匹配的内容是：11位的手机号码，第1位为1，第2位为3、4、5、7、8中的一个，后面9位为0到9之间的任意数字。

2. 字符串类中涉及正则表达式方法

举例：校验手机号码
1：要求为11位数字
2：第1位为1，第2位为3、4、5、7、8中的一个，后面9位为0到9之间的任意数字。
代码演示：
String phone = “18800022116”;
String regex = “1[34578][0-9]{9}”;
boolean flag = phone.matches(regex);

 public String[] split(String regex) //根据给定正则表达式的匹配规则，拆分此字符串
举例：分割出字符串中的的数字
代码演示：
String s = “18-22-40-65”;
String regex = “-”;
String[] result = s.split(regex);

 public String replaceAll(String regex,String replacement) //将符合规则的字符串内容，全部替换为新字符串
举例：把文字中的数字替换成*
代码演示：
String s = “Hello12345World6789012”;
String regex = “[0-9]”;
String result = s.replaceAll(regex, “*”);
3. 常用的正则表达式常用
 匹配正确的数字
匹配规则：
匹配正整数：”\d+”
匹配正小数：”\d+\.\d+”
匹配负整数：”-\d+”
匹配负小数：”-\d+\.\d+”
匹配保留两位小数的正数：”\d+\.\d{2}”
匹配保留1-3位小数的正数：”\d+\.\d{1,3}”

 匹配合法的邮箱
匹配规则：
”[a-zA-Z_0-9]+@[a-zA-Z_0-9]+(\.[a-zA-Z_0-9]+)+”
”\w+@\w+(\.\w+)+”
4.日期类Date
构造函数可以把毫秒值转成日期对象。

//创建日期对象，把当前的毫秒值转成日期对象
Date date = new Date(1607616000000L);
System.out.println(date);
//打印结果：Fri Dec 11 00:00:00 CST 2020

 把日期对象转换成对应的时间毫秒值
5.DateFormat
DateFormat 是日期/时间格式化子类的抽象类，它以与语言无关的方式格式化并解析日期或时间。日期/时间格式化子类（如 SimpleDateFormat类）允许进行格式化（也就是日期 -> 文本）、解析（文本-> 日期）和标准化。
 构造方法

 DateFormat类方法

代码演示：
//创建日期格式化对象,在获取格式化对象时可以指定风格
DateFormat df= new SimpleDateFormat(“yyyy-MM-dd”);//对日期进行格式化
Date date = new Date(1607616000000L);
String str_time = df.format(date);
System.out.println(str_time);//2020年12月11日
 DateFormat类的作用：即可以将一个Date对象转换为一个符合指定格式的字符串，也可以将一个符合指定格式的字符串转为一个Date对象。
指定格式的具体规则我们可参照SimpleDateFormat类的说明，这里做简单介绍，规则是在一个字符串中，会将以下字母替换成对应时间组成部分，剩余内容原样输出：
 当出现y时，会将y替换成年
 当出现M时，会将M替换成月
 当出现d时，会将d替换成日
 当出现H时，会将H替换成时
 当出现m时，会将m替换成分
 当出现s时，会将s替换成秒

 format方法，用来将Date对象转换成String
 parse方法，用来将String转换成Date（转换时，该String要符合指定格式，否则不能转换）。
代码演示：
练习一：把Date对象转换成String
Date date = new Date(1607616000000L);//Fri Dec 11 00:00:00 CST 2020
DateFormat df = new SimpleDateFormat(“yyyy年MM月dd日”);
String str = df.format(date);
//str中的内容为2020年12月11日

练习二：把String转换成Date对象
String str = ”2020年12月11日”;
DateFormat df = new SimpleDateFormat(“yyyy年MM月dd日”);
Date date = df.parse( str );
//Date对象中的内容为Fri Dec 11 00:00:00 CST 2020
6 Calendar日历类
该类将所有可能用到的时间信息封装为静态成员变量，方便获取。

 Calendar类静态方法

Calendar c = Calendar.getInstance(); //返回当前时间

Calendar类常用方法

 public static Calendar getInstance() //获取日期对象
 public int get(int field) //获取时间字段值，字段参见帮助文档
 YEAR 年
 MONTH 月，从0开始算起，最大11；0代表1月，11代表12月。
 DATE 天
 HOUR 时
 MINUTE分
 SECOND秒
 代码演示：
 Calendar c = Calendar.getInstance();
 int year = c.get(Calendar.YEAR);
 public void add(int field,int amount) //指定字段增加某值
代码演示：
Calendar c = Calendar.getInstance();
//修改当前时间为3天后
c.add(Calendar.DATE, 3);
//修改当前时间为5小时后
c.add(Calendar.HOUR, 5);

 public final void set(int field,int value)//设置指定字段的值
代码演示：
Calendar c = Calendar.getInstance();
//设置时间为2020年5月20日
c.set(Calendar.YEAR, 2020);
c.set(Calendar.MONTH, 4);
c.set(Calendar.DATE, 20);

 public final Date getTime() //获取该日历对象转成的日期对象
代码演示：
Calendar c = Calendar.getInstance();
Date d = c.getTime();
注意事项
西方星期的开始为周日，中国为周一。
在Calendar类中，月份的表示是以0-11代表1-12月。
日期是有大小关系的，时间靠后，时间越大。
十七、基本类型包装类

1.基本类型与字符串的转换
基本数据类型对象包装类特点：用于在基本数据和字符串之间进行转换。
 将字符串转成基本类型：

System.out.println(Integer.parseInt(“123”) + 2);
//打印结果为 125
 将基本数值转成字符串有3种方式：
 基本类型直接与””相连接即可；34+""
 调用String的valueOf方法；String.valueOf(34) ；
 调用包装类中的toString方法；Integer.toString(34) ；
2.基本类型和对象转换
使用int类型与Integer对象转换进行演示，其他基本类型转换方式相同。
 基本数值---->包装对象

Integer i = new Integer(4);//使用构造函数函数
Integer ii = new Integer(“4”);//构造函数中可以传递一个数字字符串

Integer iii = Integer.valueOf(4);//使用包装类中的valueOf方法
Integer iiii = Integer.valueOf(“4”);//使用包装类中的valueOf方法

 包装对象---->基本数值

int num = i.intValue();
3.自动装箱拆箱
在需要的情况下，基本类型与包装类型可以通用。有些时候我们必须使用引用数据类型时，可以传入基本数据类型。
比如：
基本类型可以使用运算符直接进行计算，但是引用类型不可以。而基本类型包装类作为引用类型的一种却可以计算，原因在于，Java”偷偷地”自动地进行了对象向基本数据类型的转换。
相对应的，引用数据类型变量的值必须是new出来的内存空间地址值，而我们可以将一个基本类型的值赋值给一个基本类型包装类的引用。原因同样在于Java又”偷偷地”自动地进行了基本数据类型向对象的转换。
 自动拆箱：对象转成基本数值
 自动装箱：基本数值转成对象
Integer i = 4;//自动装箱。相当于Integer i = Integer.valueOf(4);
i = i + 5;//等号右边：将i对象转成基本数值(自动拆箱) i.intValue() + 5; 加法运算完成后，再次装箱，把基本数值转成对象。

 自动装箱(byte常量池)细节的演示
当数值在byte范围之内时，进行自动装箱，不会新创建对象空间而是使用医来已有的空间。
Integer a = new Integer(3);
Integer b = new Integer(3);
System.out.println(a==b);//false
System.out.println(a.equals(b));//true

System.out.println("---------------------");
Integer x = 127;
Integer y = 127;
//在jdk1.5自动装箱时，如果数值在byte范围之内，不会新创建对象空间而是使用原来已有的空间。
System.out.println(x==y); //true
System.out.println(x.equals(y)); //true
4.system类

 arraycopy方法，用来实现将源数组部分元素复制到目标数组的指定位置
5．Math类

6. Arrays类

7. 大数据运算
   17天
   十八、迭代器和增强for
   Day18看视频

1.增强for

2.迭代器

十九、集合
有序的 collection（也称为序列）。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。是所有集合的接口

 List与Set集合的区别？
List:
它是一个有序的集合(元素存与取的顺序相同)
它可以存储重复的元素
Set:
它是一个无序的集合(元素存与取的顺序可能不同)
它不能存储重复的元素
 List集合中的特有方法
 void add(int index, Object element) 将指定的元素，添加到该集合中的指定位置上
 Object get(int index)返回集合中指定位置的元素。
 Object remove(int index) 移除列表中指定位置的元素, 返回的是被移除的元素
 Object set(int index, Object element)用指定元素替换集合中指定位置的元素,返回值的更新前的元素
 ArrayList:
底层数据结构是数组，查询快，增删慢
 LinkedList:
底层数据结构是链表，查询慢，增删快
 HashSet:
元素唯一，不能重复
底层结构是 哈希表结构
元素的存与取的顺序不能保证一致
如何保证元素的唯一的？
重写hashCode() 与 equals()方法
 LinkedHashSet:
元素唯一不能重复
底层结构是 哈希表结构 + 链表结构
元素的存与取的顺序一致

1.List接口
List接口：
 它是一个元素存取有序的集合。例如，存元素的顺序是11、22、33。那么集合中，元素的存储就是按照11、22、33的顺序完成的）。
 它是一个带有索引的集合，通过索引就可以精确的操作集合中的元素（与数组的索引是一个道理）。
 集合中可以有重复的元素，通过元素的equals方法，来比较是否为重复的元素。

List接口的常用子类有：
 ArrayList集合
 LinkedList集合

List接口中常用的方法

Iterator的并发修改异常
在list集合迭代元素中，对元素进行判断，一旦条件满足就添加一个新元素。代码如下
public class IteratorDemo {
//在list集合迭代元素中，对元素进行判断，一旦条件满足就添加一个新元素
public static void main(String[] args) {
//创建List集合
List list = new ArrayList();
//给集合中添加元素
list.add(“abc1”);
list.add(“abc2”);
list.add(“abc3”);
list.add(“abc4”);
//迭代集合，当有元素为"abc2"时，集合加入新元素"itcast"
Iterator it = list.iterator();
while(it.hasNext()){
String str = it.next();
//判断取出的元素是否是"abc2"，是就添加一个新元素
if(“abc2”.equals(str)){
list.add(“itcast”);// 该操作会导致程序出错
}
}
//打印容器中的元素
System.out.println(list);
}
}
运行上述代码发生了错误 java.util.ConcurrentModificationException这是什么原因呢？
在迭代过程中，使用了集合的方法对元素进行操作。导致迭代器并不知道集合中的变化，容易引发数据的不确定性。
并发修改异常解决办法：在迭代时，不要使用集合的方法操作元素。
那么想要在迭代时对元素操作咋办？通过ListIterator迭代器操作元素是可以的，ListIterator的出现，解决了使用Iterator迭代过程中可能会发生的错误情况。
2.ArrayList集合
ArrayList集合数据存储的结构是数组结构。元素增删慢，查找快，由于日常开发中使用最多的功能为查询数据、遍历数据，所以ArrayList是最常用的集合。
3. LinkedList集合
LinkedList集合数据存储的结构是链表结构。方便元素添加、删除的集合。实际开发中对一个集合元素的添加与删除经常涉及到首尾操作，而LinkedList提供了大量首尾操作的方法。如下图

LinkedList是List的子类，List中的方法LinkedList都是可以使用，这里就不做详细介绍，我们只需要了解LinkedList的特有方法即可。在开发时，LinkedList集合也可以作为堆栈，队列的结构使用。

4. Vector集合
   Vector集合数据存储的结构是数组结构，为JDK中最早提供的集合。Vector中提供了一个独特的取出方式，就是枚举Enumeration，它其实就是早期的迭代器。此接口Enumeration的功能与 Iterator 接口的功能是类似的。Vector集合已被ArrayList替代。枚举Enumeration已被迭代器Iterator替代。
    Vector常见的方法：

 Enumeration枚举常见的方法：

 Vector集合对ArrayList集合使用的对比

5. Set接口
   学习Collection接口时，记得Collection中可以存放重复元素，也可以不存放重复元素，那么我们知道List中是可以存放重复元素的。那么不重复元素给哪里存放呢？那就是Set接口，它里面的集合，所存储的元素就是不重复的。
6. HashSet集合
   （1）查阅HashSet集合的API介绍：此类实现Set接口，由哈希表支持（实际上是一个 HashMap集合）。HashSet集合不能保证的迭代顺序与元素存储顺序相同。
   （2）HashSet集合，采用哈希表结构存储数据，保证元素唯一性的方式依赖于：hashCode()与equals()方法。
   （3）给HashSet中存储JavaAPI中提供的类型元素时，不需要重写元素的hashCode和equals方法，因为这两个方法，在JavaAPI的每个类中已经重写完毕，如String类、Integer类等
   7.LinkedHashSet
   我们知道HashSet保证元素唯一，可是元素存放进去是没有顺序的，那么我们要保证有序，怎么办呢？
   在HashSet下面有一个子类LinkedHashSet，它是链表和哈希表组合的一个数据存储结构。
   演示代码如下：
   public class LinkedHashSetDemo {
   public static void main(String[] args) {
   Set set = new LinkedHashSet();
   set.add(“bbb”);
   set.add(“aaa”);
   set.add(“abc”);
   set.add(“bbc”);
   Iterator it = set.iterator();
   while (it.hasNext()) {
   System.out.println(it.next());
   }
   }
   }
   输出结果如下，LinkedHashSet集合保证元素的存入和取出的顺序：
   bbb
   aaa
   abc
   bbc

二十、Map接口
 Collection中的集合称为单列集合，Map中的集合称为双列集合。
 需要注意的是，Map中的集合不能包含重复的键，值可以重复；每个键只能对应一个值。
 Map中常用的集合为HashMap集合、LinkedHashMap集合。
 HashMap<K,V>：存储数据采用的哈希表结构，元素的存取顺序不能保证一致。由于要保证键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。
 LinkedHashMap<K,V>：HashMap下有个子类LinkedHashMap，存储数据采用的哈希表结构+链表结构。通过链表结构可以保证元素的存取顺序一致；通过哈希表结构可以保证的键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。

1.Map接口中的常用方法

2. Map集合遍历键找值方式
   1.获取Map集合中所有的键，由于键是唯一的，所以返回一个Set集合存储所有的键

2.遍历键的Set集合，得到每一个键
3.根据键，获取键所对应的值

public class MapDemo {
public static void main(String[] args) {
//创建Map对象
Map<String, String> map = new HashMap<String,String>();
//给map中添加元素
map.put(“邓超”, “孙俪”);
map.put(“李晨”, “范冰冰”);
map.put(“刘德华”, “柳岩”);
//获取Map中的所有key
Set keySet = map.keySet();
//遍历存放所有key的Set集合
Iterator it =keySet.iterator();
while(it.hasNext()){
//得到每一个key
String key = it.next();
//通过key获取对应的value
String value = map.get(key);
System.out.println(key+"="+value);
}
}
}

对于单列集合collection集合的遍历一定要使用迭代器Iterator，Map集合也是通过将键值转化成set存储，再通过迭代器获得键值再去遍历的
3.Entry键值对对象
Entry将键值对的对应关系封装成了对象。即键值对对象，这样我们在遍历Map集合时，就可以从每一个键值对（Entry）对象中获取对应的键与对应的值。

 Entry是Map接口中提供的一个静态内部嵌套接口。

 getKey()方法：获取Entry对象中的键
 getValue()方法：获取Entry对象中的值

 entrySet()方法：用于返回Map集合中所有的键值对(Entry)对象，以Set集合形式返回。
4．Map集合遍历键值对方式
1.获取Map集合中，所有的键值对(Entry)对象，以Set集合形式返回。

2.遍历包含键值对(Entry)对象的Set集合，得到每一个键值对(Entry)对象
3.通过键值对(Entry)对象，获取Entry对象中的键与值。

public class MapDemo {
public static void main(String[] args) {
//创建Map对象
Map<String, String> map = new HashMap<String,String>();
//给map中添加元素
map.put(“邓超”, “孙俪”);
map.put(“李晨”, “范冰冰”);
map.put(“刘德华”, “柳岩”);
//获取Map中的所有key与value的对应关系
Set<Map.Entry<String,String>> entrySet = map.entrySet();
//遍历Set集合
Iterator<Map.Entry<String,String>> it =entrySet.iterator();
while(it.hasNext()){
//得到每一对对应关系
Map.Entry<String,String> entry = it.next();
//通过每一对对应关系获取对应的key
String key = entry.getKey();
//通过每一对对应关系获取对应的value
String value = entry.getValue();
System.out.println(key+"="+value);
}
}
}
注意：Map集合不能直接使用迭代器或者foreach进行遍历。但是转成Set之后就可以使用了。

5．静态导入
在导包的过程中我们可以直接导入静态部分，这样某个类的静态成员就可以直接使用了。在源码中经常会出现静态导入。
静态导入格式：
import static XXX.YYY; 导入后YYY可直接使用。

import static java.util.Map.Entry;
//Set<Map.Entry<Student, String>> entrySet = map.entrySet();
Set<Entry<Student, String>> entrySet = map.entrySet();

6.可变参数
修饰符 返回值类型 方法名(参数类型… 形参名){ }
其实这个书写完全等价与
修饰符 返回值类型 方法名(参数类型[] 形参名){ }
如果在方法书写时，这个方法拥有多参数，参数中包含可变参数，可变参数一定要写在参数列表的末尾位置。
7. Collections集合工具类
Collections是集合工具类，用来对集合进行操作。部分方法如下：

 public static void sort(List list) // 集合元素排序
//排序前元素list集合元素 [33,11,77,55]
Collections.sort( list );
//排序后元素list集合元素 [11,33,55,77]

 public static void shuffle(List<?> list) // 集合元素存储位置打乱
//list集合元素 [11,33,55,77]
Collections.shuffle( list );
//使用shuffle方法后，集合中的元素为[77,33,11,55]，每次执行该方法，集合中存储的元素位置都会随机打乱

二十一、异常
异常中常用方法
在Throwable类中为我们提供了很多操作异常对象的方法，常用的如下：

 getMessage方法：返回该异常的详细信息字符串，即异常提示信息
 toString方法：返回该异常的名称与详细信息字符串
 printStackTrace：在控制台输出该异常的名称与详细信息字符串、异常出现的代码位置

---

 异常：就是程序中出现的不正常的现象(错误与异常)
 异常的继承体系:
Throwable: 它是所有错误与异常的超类（祖宗类）
|- Error 错误，修改java源代码
|- Exception 编译期异常, javac.exe进行编译的时候报错
|- RuntimeException 运行期异常, java出现运行过程中出现的问题
 异常处理的两种方式：
 1，出现问题，自己解决 try…catch…finally
try{
可能出现异常的代码
} catch(异常类名 对象名){
异常处理代码
} finally {
异常操作中一定要执行的代码
}
 2，出现问题，别人解决 throws
格式：
修饰符 返回值类型 方法名(参数) throws 异常类名1,异常类名2,…{}
public void method() throws Exception{}

 异常分类
异常的根类是Throwable，其下有两个子类：Error与Exception，平常所说的异常指Exception。
 严重错误Error，无法通过处理的错误
 编译时异常Exception，编译时无法编译通过。如日期格式化异常
 运行时异常RuntimeException，是Exception的子类，运行时可能会报错，可以不处理。如空指针异常

 异常基本操作
 创建异常对象
 抛出异常
 处理异常：
 捕获处理，将异常获取，使用try/catch做分支处理
try{
需要检测的异常；
} catch(异常对象) {
通常我们只使用一个方法：printStackTrace打印异常信息
}
 声明抛出处理，出现异常后不处理，声明抛出给调用者处理。
方法声明上加throws 异常类名
 注意：异常的处理，指处理异常的一种可能性，即有了异常处理的代码，不一定会产生异常。如果没有产生异常，则代码正常执行，如果产生了异常，则中断当前执行代码，执行异常处理代码。

 异常注意事项
 多异常处理
捕获处理：
1多个异常可以分别处理
2多个异常一次捕获多次处理
3多个异常一次捕获，采用同一种方式处理
声明抛出异常：
声明上使用,一次声明多个异常

 运行时异常被抛出可以不处理。即不捕获也不声明抛出
 如果父类抛出了多个异常,子类覆盖父类方法时,只能抛出相同的异常或者是他的子集
 父类方法没有抛出异常，子类覆盖父类该方法时也不可抛出异常。此时子类产生该异常，只能捕获处理，不能声明抛出
 当多异常处理时，捕获处理，前边的类不能是后边类的父类

 自定义异常
如果Java没有提供你需要的异常，则可以自定义异常类。
定义方法：编译时异常继承Exception，运行时异常继承RuntimeException。

二十二、File和递归
1.file的构造函数

2.File类的获取

3. 文件和文件夹的创建删除

文件都存放在目录（文件夹）中，那么如何获取一个目录中的所有文件或者目录中的文件夹呢？那么我们先想想，一个目录中可能有多个文件或者文件夹，那么如果File中有功能获取到一个目录中的所有文件和文件夹，那么功能得到的结果要么是数组，要么是集合。

注意：在获取指定目录下的文件或者文件夹时必须满足下面两个条件
1，指定的目录必须是存在的，
2，指定的必须是目录。否则容易引发返回数组为null，出现NullPointerException
4，文件的过滤器

public class FileDemo2 {
public static void main(String[] args) {
//获取扩展名为.java所有文件
//创建File对象
File file = new File(“E:\code\day11_code”);
//获取指定扩展名的文件,由于要对所有文件进行扩展名筛选，因此调用方法需要传递过滤器
File[] files = file.listFiles(new MyFileFilter());
//遍历获取到的所有符合条件的文件
for (File f : files) {
System.out.println(f);
}
}
}
 自定类继承FilenameFilter过滤器接口
//定义类实现文件名称FilenameFilter过滤器
class MyFileFilter implements FilenameFilter{
public boolean accept(File dir, String name) {
return name.endsWith(".java");
}
}

在查阅API时，我们发现，在listFiles(FileFilter filter) 也可以接受一个FileFilter过滤器，它和我们讲的FilenameFilter有啥区别呢？

FilenameFilter过滤器中的accept方法接受两个参数，一个当前文件或文件夹所在的路径，一个是当前文件或文件夹对象的名称。
FileFilter 过滤器中的accept方法接受一个参数，这个参数就当前文件或文件夹对象
当我们需要过滤文件名称时就可以使用FilenameFilter这个过滤器，当我们想对当前文件或文件夹进行过滤，就可以使用FileFilter ，比如需要当前目录下的所有文件夹，就可以使用FileFilter 过滤器。
 测试类
public class FileDemo2 {
public static void main(String[] args) {
//获取扩展名为.java所有文件
//创建File对象
File file = new File(“E:\code\day11_code”);
//获取指定目录下的文件夹
File[] files = file.listFiles(new FileFileterByDir());
//遍历获取到的所有符合条件的文件
for (File f : files) {
System.out.println(f);
}
}
}
 自定义类继承FileFilter过滤器接口
//文件过滤器
class FileFileterByDir implements FileFilter{
public boolean accept(File pathname) {
return pathname.isDirectory();
}
}
5.递归
 递归： 方法定义中调用方法本身的现象
 直接递归
public void methodA(){
methodA();
}
 间接递归
public void metohdB(){
methodC();
}
public void methodC(){
methodB();
}
 递归注意实现
 要有出口，否则就是死递归
 次数不能太多，否则就内存溢出
二十三、IO流
 IO流的分类
|- 字节流
|- 字节输入流 InputStream 抽象类
|- FileInputStream 操作文件的字节输入流
|- 字节输出流 OuputStream抽象类
|- FileOutputStream 操作文件的字节输出流
|- 字符流
|- 字符输入流 Reader抽象类
|- InputStreamReader 输入操作的转换流
|- FileReader 用来操作文件的字符输入流（简便的流）
|- 字符输出流 Writer抽象类
|- OutputStreamWriter 输出操作的转换流
|- FileWriter 用来操作文件的字符输出流（简便的流）

1.字节流

1. 字节输出流OutputStream
   OutputStream此抽象类，是表示输出字节流的所有类的超类操作的数据都是字节，定义了输出字节流的基本共性功能方法。

2. FileOutputStream类
   OutputStream有很多子类，其中子类FileOutputStream可用来写入数据到文件。
   FileOutputStream类，即文件输出流，是用于将数据写入 File的输出流。

 构造方法

public class FileOutputStreamDemo {
public static void main(String[] args) throws IOException {
//需求：将数据写入到文件中。
//创建存储数据的文件。
File file = new File(“c:\file.txt”);
//创建一个用于操作文件的字节输出流对象。一创建就必须明确数据存储目的地。
//输出流目的是文件，会自动创建。如果文件存在，则覆盖。
FileOutputStream fos = new FileOutputStream(file);
//调用父类中的write方法。
byte[] data = “abcde”.getBytes();
fos.write(data);
//关闭流资源。
fos.close();
}
}

我们直接new FileOutputStream(file)这样创建对象，写入数据，会覆盖原有的文件，那么我们想在原有的文件中续写内容怎么办呢？
继续查阅FileOutputStream的API。发现在FileOutputStream的构造函数中，可以接受一个boolean类型的值，如果值true，就会在文件末位继续添加。
 构造方法

 给文件中续写数据和换行，代码演示：
public class FileOutputStreamDemo2 {
public static void main(String[] args) throws Exception {
File file = new File(“c:\file.txt”);
FileOutputStream fos = new FileOutputStream(file, true);
String str = “\r\n”+“itcast”;
fos.write(str.getBytes());
fos.close();
}
}
3. IO异常的处理
在前面编写代码中都发生了IO的异常。我们在实际开发中，对异常时如何处理的，我们来演示一下。
public class FileOutputStreamDemo3 {
public static void main(String[] args) {
File file = new File(“c:\file.txt”);
//定义FileOutputStream的引用
FileOutputStream fos = null;
try {
//创建FileOutputStream对象
fos = new FileOutputStream(file);
//写出数据
fos.write(“abcde”.getBytes());
} catch (IOException e) {
System.out.println(e.toString() + “----”);
} finally {
//一定要判断fos是否为null，只有不为null时，才可以关闭资源
if (fos != null) {
try {
fos.close();
} catch (IOException e) {
throw new RuntimeException("");
}
}
}
}
}
4.字节输入流InputStream
。InputStream此抽象类，是表示字节输入流的所有类的超类。，定义了字节输入流的基本共性功能方法。

 int read():读取一个字节并返回，没有字节返回-1.
 int read(byte[]): 读取一定量的字节数，并存储到字节数组中，返回读取到的字节数。
5. FileInputStream类
InputStream有很多子类，其中子类FileInputStream可用来读取文件内容。
FileInputStream 从文件系统中的某个文件中获得输入字节。

 构造方法

FileInputStream类读取数据read方法

在读取文件中的数据时，调用read方法，实现从文件中读取数据

 从文件中读取数据，代码演示：
public class FileInputStreamDemo {
public static void main(String[] args) throws IOException {
File file = new File(“c:\file.txt”);
//创建一个字节输入流对象,必须明确数据源，其实就是创建字节读取流和数据源相关联。
FileInputStream fis = new FileInputStream(file);
//读取数据。使用 read();一次读一个字节。
int ch = 0;
while((ch=fis.read())!=-1){
System.out.pr }intln(“ch=”+(char)ch);

	// 关闭资源。
	fis.close();
}

}
2.字符流
1.字符编码表
编码表：其实就是生活中字符和计算机二进制的对应关系表。
1、ascii： 一个字节中的7位就可以表示。对应的字节都是正数。0-xxxxxxx
2、iso-8859-1:拉丁码表 latin，用了一个字节用的8位。1-xxxxxxx 负数。
3、GB2312:简体中文码表。包含6000-7000中文和符号。用两个字节表示。两个字节第一个字节是负数,第二个字节可能是正数
GBK:目前最常用的中文码表，2万的中文和符号。用两个字节表示，其中的一部分文字，第一个字节开头是1，第二字节开头是0
GB18030：最新的中文码表，目前还没有正式使用。
1、unicode：国际标准码表:无论是什么文字，都用两个字节存储。
 Java中的char类型用的就是这个码表。char c = ‘a’;占两个字节。
 Java中的字符串是按照系统默认码表来解析的。简体中文版 字符串默认的码表是GBK。
5、UTF-8:基于unicode，一个字节就可以存储数据，不要用两个字节存储，而且这个码表更加的标准化，在每一个字节头加入了编码信息(后期到api中查找)。
能识别中文的码表：GBK、UTF-8；正因为识别中文码表不唯一，涉及到了编码解码问题。
对于我们开发而言；常见的编码 GBK UTF-8 ISO-8859-1
文字—>(数字) ：编码。 “abc”.getBytes() byte[]
(数字)—>文字 : 解码。 byte[] b={97,98,99} new String(b)
2. 字符输入流Reader
上述程序中我们读取拥有中文的文件时，使用的字节流在读取，那么我们读取到的都是一个一个字节。只要把这些字节去查阅对应的编码表，就能够得到与之对应的字符。API中是否给我们已经提供了读取相应字符的功能流对象，Reader，读取字符流的抽象超类。

 read():读取单个字符并返回
 read(char[]):将数据读取到数组中，并返回读取的个数。
3. FileReader类
查阅FileInputStream的API，发现FileInputStream 用于读取诸如图像数据之类的原始字节流。要读取字符流，请考虑使用 FileReader。
打开FileReader的API介绍。用来读取字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是适当的
 构造方法

public class CharStreamDemo {
public static void main(String[] args) throws IOException {
//给文件中写中文
writeCNText();
//读取文件中的中文
readCNText();
}
//读取中文
public static void readCNText() throws IOException {
FileReader fr = new FileReader(“D:\test\cn.txt”);
int ch = 0;
while((ch = fr.read())!=-1){
//输出的字符对应的编码值
System.out.println(ch);
//输出字符本身
System.out.println((char)ch);
}
}
//写中文
public static void writeCNText() throws IOException {
FileOutputStream fos = new FileOutputStream(“D:\test\cn.txt”);
fos.write(“a传智播客欢迎你”.getBytes());
fos.close();
}
}
4字符输出流Writer
Writer是写入字符流的抽象类。其中描述了相应的写的动作。

5 FileWriter类
 构造方法

public class FileWriterDemo {
public static void main(String[] args) throws IOException {
//演示FileWriter 用于操作文件的便捷类。
FileWriter fw = new FileWriter(“d：\text\fw.txt”);
fw.write(“你好谢谢再见”);//这些文字都要先编码。都写入到了流的缓冲区中。
fw.flush();
fw.close();
}
}

flush()和close()的区别？

flush():将流中的缓冲区缓冲的数据刷新到目的地中，刷新后，流还可以继续使用。
close():关闭资源，但在关闭前会将缓冲区中的数据先刷新到目的地，否则丢失数据，然后在关闭流。流不可以使用。如果写入数据多，一定要一边写一边刷新，最后一次可以不刷新，由close完成刷新并关闭。

三十、mybatis
1.mybatis入门
（1）mybatis的概述
1.什么是框架
他是我们软件开发中的一套解决方案，不同的框架解决的是不同的问题。
使用框架的好处：
框架封装了很多细节，使开发者可以使用极简的方式实现功能，大大提高卡法效率
2.三层架构
表现层：是用来展示数据
业务层：是处理业务需求
持久层：是和数据和交互的

3.持久层技术解决方案
Jdbc技术：
Connection
PreparedStatement
ResultSet
Spring的JdbcTemplate:
Spring中对jdbc的简单封装
Apache的DBUtils:
它和Spring的JdbcTemplate很像，也是对Jdbc的简单封装
以上这些都不是框架
JDBC是规范
Spring的JdbcTemplate和Apache的DBUtils都只是工具类

4.mybatis的概述
（1）mybatis是一个优秀的基于 java 的持久层框架，它内部封装了 jdbc，使开发者只需要关注 sql语句本身， 而不需要花费精力去处理加载驱动、创建连接、创建 statement 等繁杂的过程。 mybatis通过xml 或注解的方式将要执行的各种statement配置起来，并通过java对象和statement 中 sql 的动态参数进行映射生成最终执行的 sql 语句，最后由 mybatis 框架执行 sql 并将结果映射为 java 对象并 返回。
（2）采用 ORM 思想解决了实体和数据库映射的问题，对 jdbc进行了封装，屏蔽了 jdbc api 底层访问细节，使我 们不用与 jdbc api 打交道，就可以完成对数据库的持久化操作。

ORM:
Object Relational Mappging 对象关系映射
简单的说：
就是把数据库表和实体类及实体类的属性对应起来
让我们可以操作实体类就实现操作数据库表
实体类的中属性和数据库表的字段名称保持一致。
user User
id Id
user_name user_name

（2）mybatis的环境搭建
第一步：创建maven工程并导入坐标

（2）建立数据库、表
（3）配置 文件

第二步：创建实体类和dao的接口

第三步：创建Mybatis的主配置文件
SqlMapConfig.xml

<?xml version="1.0" encoding="UTF-8"?>

第四步：创建映射配置文件
IUserDao.xml

<?xml version="1.0" encoding="UTF-8"?> select * from user;

环境搭建的注意事项：
1.创建IUserDao.xml和IUserDao.java时名称是为了和我们之前的知识保持一致，在Mybatis中它把持久层的操作接口名称和映射文件也叫做：Mapper
所以IUserDao和IUserMapper是一样的
2，在idea中创建目录的时候，它和包是不一样的
包在创建时：com.itheima.dao它是三级结构
目录在创建时：com.itheima.dao是一级目录
3.，mybatis的映射配置文件位置必须和dao接口的包结构相同
4，映射配置文件的mapper标签namespace属性的取值必须是dao接口的全限定类名
5.映射配置文件的操作配置（select）,id属性的取值必须是dao接口的方法名
当我们遵从了第三，四，五点之后，我们在开发中就无须再写dao的实现类

（3）mybatis入门案例
（4）自定义mybatis框架
2. mybatis基本使用
（1）mybatis的单表crud操作
（2）mybatis的参数和返回值
（3）mybatis的dao编写
（4）mybatis配置的细节，几个标签的使用
（5）mybatis的深入和多表
（6）mybatis的连接池
（7）mybatis的事务控制及设计的方法
（8）mybatis的多表查询
（9）mybatis的缓存和注解开发
（10）mybatis中的加载时机（查询的时机）
（11）mybatis中的一级缓存和二级缓存
（12）mybatis的注解开发
三十一、SpringMVC

1. idea常用的快捷键

解决maven项目创建过慢的问题:
archetypeCatalog
internal

idea常用的快捷键

Alt+回车 导入包,自动修正
Ctrl+N 查找类

Ctrl+Shift+N 查找文件

Ctrl+Alt+L 格式化代码

Ctrl+Alt+O 优化导入的类和包

Alt+Insert 生成代码(如get,set方法,构造函数等)

Ctrl+E或者Alt+Shift+C 最近更改的代码

Ctrl+R 替换文本

Ctrl+F 查找文本

Ctrl+Shift+Space 自动补全代码

Ctrl+空格 代码提示

Ctrl+Alt+Space 类名或接口名提示

Ctrl+P 方法参数提示

Ctrl+Shift+Alt+N 查找类中的方法或变量

Alt+Shift+C 对比最近修改的代码

Shift+F6 重构-重命名

Ctrl+Shift+先上键

Ctrl+X 删除行

Ctrl+D 复制行

Ctrl+/ 或 Ctrl+Shift+/ 注释（// 或者/…/ ）

Ctrl+J 自动代码

Ctrl+E 最近打开的文件

Ctrl+H 显示类结构图

Ctrl+Q 显示注释文档

Alt+F1 查找代码所在位置

Alt+1 快速打开或隐藏工程面板

Ctrl+Alt+ left/right 返回至上次浏览的位置

Alt+ left/right 切换代码视图

Alt+ Up/Down 在方法间快速移动定位

Ctrl+Shift+Up/Down 代码向上/下移动。

F2 或Shift+F2 高亮错误或警告快速定位

代码标签输入完成后，按Tab，生成代码。

选中文本，按Ctrl+Shift+F7 ，高亮显示所有该文本，按Esc高亮消失。

Ctrl+W 选中代码，连续按会有其他效果

选中文本，按Alt+F3 ，逐个往下查找相同文本，并高亮显示。

Ctrl+Up/Down 光标跳转到第一行或最后一行下

Ctrl+B 快速打开光标处的类或方法

Intellij IDEA最常用快捷键

1.Ctrl＋E，可以显示最近编辑的文件列表

2.Shift＋Click可以关闭文件

3.Ctrl＋[或]可以跳到大括号的开头结尾

4.Ctrl＋Shift＋Backspace可以跳转到上次编辑的地方

5.Ctrl＋F12，可以显示当前文件的结构

6.Ctrl＋F7可以查询当前元素在当前文件中的引用，然后按F3可以选择

7.Ctrl＋N，可以快速打开类

8.Ctrl＋Shift＋N，可以快速打开文件

9.Alt＋Q可以看到当前方法的声明

10.Ctrl＋W可以选择单词继而语句继而行继而函数

11.Alt＋F1可以将正在编辑的元素在各个面板中定位

12.Ctrl＋P，可以显示参数信息

13.Ctrl＋Shift＋Insert可以选择剪贴板内容并插入

14.Alt＋Insert可以生成构造器/Getter/Setter等

15.Ctrl＋Alt＋V 可以引入变量。例如把括号内的SQL赋成一个变量

16.Ctrl＋Alt＋T可以把代码包在一块内，例如try/catch

17.Alt＋Up and Alt＋Down可在方法间快速移动
2.SpringMVC在三层架构的位置

MVC 全名是 Model View Controller，是模型(model)－视图(view)－控制器(controller)的缩写， 是一种用于设计创建 Web 应用程序表现层的模式。MVC 中每个部分各司其职： Model（模型）通常指的就是我们的数据模型。作用一般情况下用于封装数据。
View（视图）：通常指的就是我们的 jsp 或者 html。作用一般就是展示数据的。通常视图是依据模型数据创建的。
Controller（控制器）：是应用程序中处理用户交互的部分。作用一般就是处理程序逻辑的。
3、SpringMVC 和 Struts2 的优略分析
共同点： 1它们都是表现层框架，都是基于 MVC 模型编写的。
2它们的底层都离不开原始 ServletAPI。 它们处理请求的机制都是一个核心控制器。
区别： 1.Spring MVC 的入口是 Servlet, 而 Struts2 是 Filter
2. Spring MVC 是基于方法设计的，而 Struts2 是基于类，Struts2 每次执行都会创建一个动作类。所 以 Spring MVC 会稍微比 Struts2 快些。
3.Spring MVC 使用更加简洁,同时还支持 JSR303, 处理 ajax 的请求更方便 (JSR303 是一套 JavaBean 参数校验的标准，它定义了很多常用的校验注解，我们可以直接将这些注 解加在我们 JavaBean 的属性上面，就可以在需要校验的时候进行校验了。)
4.Struts2 的 OGNL 表达式使页面的开发效率相比 Spring MVC 更高些，但执行效率并没有比 JSTL 提 升，尤其是 struts2 的表单标签，远没有 html 执行效率高。
三十三、bootstrap前端框架
1.Bootstrap简介：
《具体查看：https://www.bootcss.com/》bootstrap中文网，直接copy使用修改
1. 概念： 一个前端开发的框架，Bootstrap，来自 Twitter，是目前很受欢迎的前端框架。Bootstrap 是基于 HTML、CSS、JavaScript 的，它简洁灵活，使得 Web 开发更加快捷。
* 框架:一个半成品软件，开发人员可以在框架基础上，在进行开发，简化编码。
* 好处：
1. 定义了很多的css样式和js插件。我们开发人员直接可以使用这些样 式和插件得到丰富的页面效果。
2. 响应式布局。
* 同一套页面可以兼容不同分辨率的设备。

2. 快速入门
	1. 下载Bootstrap
	2. 在项目中将这三个文件夹复制
	3. 创建html页面，引入必要的资源文件


	<!DOCTYPE html>
	<html lang="zh-CN">
	<head>
	    <meta charset="utf-8">
	    <meta http-equiv="X-UA-Compatible" content="IE=edge">
	    <meta name="viewport" content="width=device-width, initial-scale=1">
	    <!-- 上述3个meta标签*必须*放在最前面，任何其他内容都*必须*跟随其后！ -->
	    <title>Bootstrap HelloWorld</title>
	
	    <!-- Bootstrap -->
	    <link href="css/bootstrap.min.css" rel="stylesheet">
	
	
	    <!-- jQuery (Bootstrap 的所有 JavaScript 插件都依赖 jQuery，所以必须放在前边) -->
	    <script src="js/jquery-3.2.1.min.js"></script>
	    <!-- 加载 Bootstrap 的所有 JavaScript 插件。你也可以根据需要只加载单个插件。 -->
	    <script src="js/bootstrap.min.js"></script>
	</head>
	<body>
	<h1>你好，世界！</h1>
	
	</body>
	</html>

2. 响应式布局

   • 同一套页面可以兼容不同分辨率的设备。

   • 实现：依赖于栅格系统：将一行平均分成12个格子，可以指定元素占几个格子

   • 步骤：

     1. 定义容器。相当于之前的table、
        • 容器分类：
          1. container：两边留白
          2. container-fluid：每一种设备都是100%宽度
     2. 定义行。相当于之前的tr 样式：row
        3. 定义元素。指定该元素在不同的设备上，所占的格子数目。
           样式：col-设备代号 -格子数目
        • 设备代号：
          1. xs：超小屏幕 手机 (<768px)：col-xs-12
          2. sm：小屏幕 平板 (≥768px)
          3. md：中等屏幕 桌面显示器 (≥992px)
          4. lg：大屏幕 大桌面显示器 (≥1200px)
     • 注意：
       1. 一行中如果格子数目超过12，则超出部分自动换行。
   2. 栅格类属性可以向上兼容。栅格类适用于与屏幕宽度大于或等于分界点大小的设备。
   3. 如果真实设备宽度小于了设置栅格类属性的设备代码的最小值，会一个元素沾满一整行。

3. CSS样式和JS插件

   1. 全局CSS样式：
      • 按钮：class=“btn btn-default”
      • 图片：
        • class=“img-responsive”：图片在任意尺寸都占100%
        • 图片形状
          • ：方形
          • ： 圆形
          • ：相框
      • 表格
        • table
        • table-bordered
        • table-hover
      • 表单
        • 给表单项添加：class=“form-control”
   2. 组件：
      • 导航条
      • 分页条
   3. 插件：
      • 轮播图

---

1. abc ↩︎

2. abc ↩︎