一、.面向对象OOP
2.1 面向对象与面向过程
两者都是一种编程的思想
面向对象强调的是事情的结果，我们通过对象完成对应的功能
面向过程强调的是事情的过程，我们做任何事情，都要亲力亲为，经过每一个步骤
Java是一门面向对象的语言
2.2 类与对象
定义类通过关键字class来定义，类是一类事物的抽象，它是抽象的，它是模板
创建对象通过new关键字触发构造函数生成，对象是根据类创建出来的具体的内容
一个类可以创建出多个对象，对象是根据类的设计来创建的，所以对象具有类的所有属性与功能
对象之间是相互独立的，互不影响。我们把创建对象也称作“实例化”
2.3 面向对象的三大特性：封装
前提：为了保证数据的安全，也为了程序的使用者能够按照我们预先设计好的方式来使用资源
封装属性：用private修饰我们的属性
然后为属性提供对应的getXxx()【获取属性值】与setXxx()【设置属性值】
封装方法：用private修饰方法，被修饰的方法只能在本类中使用，所以我们在本类的公共方法里调用这个私有方法
外界如果想要使用这个私有方法的功能，只需要调用这个公共方法就可以了
2.4 面向对象的三大特性：继承
前提 ：继承可以实现程序的复用性，减少代码的冗余
我们通过extends关键字建立子类与父类的继承关系：格式：子类 extends 父类
继承相当于子类把父类的功能复制了一份，包括私有资源
注意：虽然私有资源继承了，但是私有资源不可用，原因是被private限制了访问，私有资源只能在本类使用
注意：构造方法不能继承，原因是：构造方法要求名字是本类的类名，我们不能在子类中出现父类名字的构造方法
继承是可以传递的：爷爷的功能会传给爸爸，爸爸的功能会传给孙子
注意：爸爸从爷爷那里继承的功能，也会一起传给孙子
Java的类是单继承的：一个子类只能有一个父类，但是一个父类可以有多个子类
子类在继承了父类以后，如果对父类的功能不满意
可以在不修改父类功能的【满足OCP原则】前提下，在子类中，重写继承过来的这个方法
重写需要满足的规则：两同 两小 一大，我们可以在重写的方法上加@Override注解验证是否写对
继承是一种is a的关系，强耦合，关联性特别强，而且类的继承机会只有一次，要谨慎使用
子类可以直接使用父类的所有非私有资源
2.5 面向对象的三大特性：多态
前提：为了忽略子类型之间的差异，统一看作父类类型，写出更加通用的代码
比如：把Cat看作Animal,把Dog看作Animal,把Bird看作Animal,如果方法需要设置传入的参数，可以buy(Animal a)
比如：把算术异常、输入不匹配异常都看作是Exception,统一捕获处理，只写一个解决方案
概念：在同一时刻，同一个对象，代表的类型不同,拥有多种形态
6.多态的要求：继承 + 重写
多态的口诀1：父类引用指向子类对象：父类型的引用类型变量保存的是子类对象的地址值
多态的口诀2：编译看左边，运行看右边：
父类中定义的功能，子类才能使用，否则报错
多态中，方法的定义看的是父类的，方法的实现看的是子类重写后的功能；

7.多态中资源的使用：
1）成员变量：使用的是父类的
2）成员方法：对于方法的定义看的都是父类的，对于方法实现，重写后使用的是子类的
3）静态资源：静态资源属于类资源，不存在重写的概念，在哪个类中定义的，就属于哪个类
向上造型与向下造型
1）这两种都属于多态，只不过是多态的两种不同的表现形式
2）向上造型【最常用】
可以把不同的子类型都看作是父类型，比如Parent p = new Child();
比如：花木兰替父从军，被看作是父类型，并且花木兰在从军的时候，不能使用自己的特有功能，比如化妆
3）向下造型
前提：必须得先向上造型，才能向下造型
子类的引用指向子类的对象，但是这个子类对象之前被看作是父类类型，所以需要强制类型转换
Parent p = new Child(); 然后：Child c = (Child) p;
比如：花木兰已经替她爸打完仗了，想回家织布，那么这个时候，一直被看作是父类型的花木兰必须经历“解甲归田”【强制类型转换】这个过程，才能重新被看作成子类类型，使用子类的特有功能
为什么有向下造型：之前被看作是父类类型的子类对象，想使用子类的特有功能，那就需要向下造型
2.7 this与super
this代表的是本类，super代表的是父类
当本类的成员变量与局部变量同名时，我们可以通过this.变量名指定本类的成员变量
当父类的成员变量与子类的变量同名时，我们可以通过super.变量名指定父类的成员变量
我们可以在本类构造函数的第一行
使用this();调用本类的无参构造 / 使用this(参数); 调用本类对应参数的构造方法
构造函数的调用只有这一种方式，或者创建对象时被动触发，不能在外面自己主动调用
构造函数直接不能互相调用，否则会死循环
我们可以在子类构造函数的第一行
使用super();调用父类的无参构造 / 使用super(参数); 调用父类对应参数的构造方法
注意：子类默认调用super();父类的无参构造，如果父类没有无参构造，需要手动指定调用哪个含参构造
2.9 方法的重写与重载
方法的重写：
继承后，子类想在不改变父类代码的前提下，修改或者拓展功能
重写的规则：两同 两小 一大
1. 子类与父类的方法名要保持一致
2. 子类与父类的方法的参数列表要保持一致
3. 子类的返回值类型小于等于父类方法的返回值，这里说的是继承关系，不是值的大小
4. 子类的抛出异常类型小于等于父类方法抛出的异常类型
5. 子类方法的修饰符大于等于父类方法的修饰符
6. 注意：我们可以使用@Override注解标记这是一个重写的方法

方法的重载：
在同一个类中，存在两个或者两个以上的方法，方法名相同，但参数列表不同的现象
作用：重载提高程序的灵活性，只要用户调用这个方法，不管传入什么参数，都能匹配的上
注意：方法是否构成重载，除了前两项以外，看的是参数的个数与类型，与方法的参数名字没关系

3.7 接口与抽象类的区别
接口是一种用interface定义的类型
抽象类是一种用class定义的类型
接口中的方法都是抽象方法
抽象类中的方法不做限制
接口中的都是静态常量
抽象类中可以写普通的成员变量
接口没有构造方法，不可实例化
抽象类有构造方法，但是也不可以实例化
接口是先天设计的结果，抽象是后天重构的结果
接口可以多继承
抽象类只能单继承

3.7 异常
异常的继承结构
异常层次结构中的根是Throwable
Error：目前我们编码解决不了的问题
Exception:异常
编译异常：未运行代码就报错了，强制要求处理
运行时异常RunTimeException：运行代码才报错，可以通过编译，不强制要求处理
异常的解决方案
捕获处理try-catch–自己解决

向上抛出throws–交给别人解决，在方法定义的两个小括号之间throws,可抛出多个异常，用逗号隔开

不能直接把异常抛给main(),因为调用main()是JVM，没人解决了
注意：是否抛出异常取决于自己的业务，比如暂时不处理或者处理不了需要交给别人处理

成员内部类
位置：类里方法外
1）被private修饰
被私有化的内部类在main()中是没有办法直接创建其对象的
可以在私有内部类所处的外部类中，创建一个公共的方法供外界调用，这个方法用来返回创建好的私有内部类对象
2) 被static修饰
静态内部类可以不创建外部类对象，直接创建静态内部类对象，格式：Outer3.Inner3 oi = new Outer3.Inner3();
如果静态内部类中还有静态方法，那么我们可以不创建对象
直接通过链式加载的方式调用:Outer3.Inner3.show2();//表示通过外部类名直接找到静态内部类，再找到静态方法

局部内部类
位置：方法里
直接创建外部类对象，调用局部内部类所处的方法，并不会触发局部内部类的功能
需要在外部类中创建局部内部类的对象并且进行调用局部内部类的功能,才能触发内部类的功能

匿名内部类
位置：可运行代码中，比如 main()中
匿名内部类通常与匿名对象【没有名字的对象】一起使用
格式：new Inter1(){ 我这个大括号其实是一个匿名内部类，我来实现方法 }.eat();
如果只是想使用一次接口/抽象类的某个功能，可以使用匿名内部类
匿名内部类+匿名对象的功能：创建实现类+实现方法+方法功能的一次调用【功能三合一】

1.equals和==的区别

等号比较的其实是地址值;

equals比较的是值是否相同，equals：1、先比较地址，通过返回true ,不通过再判断括号内的对象是不是string类型，如果不是string类型返回false，如果是string类型继续判断两个字符串的长度，如果长度不相等返回false，如果长度相等继续对字符串里面的每个字母进行对比，如果有一个字母不相同就返回false直到对比到最后一个字母都没有问题，然后返回true

3.2 String
String底层维护的是一个char[],而且String不可变，因为源码中的数组被final修饰了
创建方式：
char[] vlaues = {‘a’,‘b’,‘c’}; String s = new String(values);
String s = “abc”;有高效的效果，因为串存在堆中的常量池，第二次使用时就不再新建了

1. 常用方法：

int hashCode() 返回此字符串的哈希码。
boolean equals(Object anObject) 将此字符串与指定的对象比较,比较的是重写后的串的具体内容
String toString() 返回此对象本身（它已经是一个字符串！）。

 int length() 返回此字符串的长度。
String toUpperCase() 所有字符都转换为大写。
String toLowerCase() 所有字符都转换为小写
boolean startsWith(String prefix) 测试此字符串是否以指定的元素开头。
boolean endsWith(String suffix) 测试此字符串是否以指定的字符串结束。

char charAt(int index) 返回指定索引/下标处的 char 值/字符
int indexOf(int ch) 返回指定字符在此字符串中第一次出现处的索引。
int lastIndexOf(int ch) 返回指定字符在此字符串中最后一次出现处的索引。
String concat(String str) 将指定字符串连接/拼接到此字符串的结尾,注意:不会改变原串
String[] split(String regex) 根据给定元素来分隔此字符串。

String trim() 返回去除首尾空格的字符串
byte[] getBytes() 把字符串存储到一个新的 byte 数组中
String substring(int beginIndex) 返回一个新子串,从指定下标处开始,包含指定下标
String substring(int beginIndex, int endIndex) 返回一个新子串,从执定下标开始,到结束下标为止,但不包含结束下标
static String valueOf(int i) 把int转成String

3.3 StringBuilder与StringBuffer

String的:

特点：
创建之后长度内容是不可变的，每次拼接字符串，都会产生新的对象
优缺点：
优点：String类提供了丰富的关于操作字符串的方法，比如：拼接、获取对应下标处的字符、截取子串等等
缺点：在进行字符串拼接+=的时候，效率比较低
String转StringBuilder：
String s = “abc”; StringBuilder sb = new StringBuilder(s);

StringBuilder的：

特点：
StringBuilder是一个长度可变的字符串序列，在创建的时候，会有一个长度为16的默认空间
当拼接字符串的时候，是在原对象的基础之上进行拼接，如果长度不够就扩容
所以StringBuilder在创建之后，对应的操作一直是用一个对象
创建方式：
StringBuilder sb = new StringBuilder();//创建一个长度为16的StringBuilder对象
StringBuilder sb = new StringBuilder(“abc”);//以指定字符串内容为“abc”的方式创建一个StringBuilder对象
优缺点：
优点：在拼接的时候，不会产生新的对象，就避免了因为拼接频繁生成对象的问题，提高了程序的效率，使用的是append()
缺点：对于字符串的操作，不太方便
StringBuilder转String：
StringBuilder sb = new StringBuilder();
sb.append(“abc”);
String s = sb.toString();
总结一句话，拼接多用StringBuilder,用完转回String用String丰富的方法

在线程安全上 :
–StringBuffer是线程安全的。
–StringBuilder是线程不安全的。
2. 在执行效率上，StringBuilder > StringBuffer > String
3.源码体现：只不过Buffer把代码加了同步关键字，使得程序可以保证线程安全问题。

List接口的特点

1. 1. List集合是有下标的
   2. List集合是有顺序的
   3. List集合可以存放重复的数据

List接口的两个常用实现类
ArrayList的特点：
1）底层的数据结构是数组，内存空间是连续的
2）元素有下标，通常可以根据下标进行操作
3）增删操作比较慢，查询操作比较快【数据量大时】
linkedList的特点：
1）底层的数据结构是链表，内存空间是不连续的
2）元素有下标，但是通常首尾节点操作比较多
3）增删操作比较快，查询操作比较慢【数据量大时】
注意：linkedList查询慢也不是都慢，首尾操作还是比较快的

Map接口的特点

1. map集合的结构是：键值对、KEY与VALUE、Map.Entry的映射关系
2. map中key值不允许重复，如果重复，对应的value会被覆盖
3. map中的映射关系是无序的
4. map没有自己的迭代器，所以迭代时通常需要转成set集合来迭代

Set接口的特点

1. set集合没有重复的元素
2. set集合的元素是无序的
3. set集合可以存null值，并且null最多有一个
4. 我们自定义对象如果想去重，需要在自定义类中添加重写的equals()与hashCode()

线程的几种状态以及线程状态之间的切换
1）新建状态：创建线程对象，申请PCB,对应的是new线程对象
2）就绪状态/可运行状态：万事俱备，只欠CPU,刚刚创建好的线程对象所有资源已经准备好，并且加入到了就绪队列之中
唯有等待操作系统的调度，只要分配了CPU,也就是时间片，当前线程可立即执行，对应的是start()
注意：调用start()并不会立即执行线程对象，这个是由OS的调度规则决定的。我们控制不了
3）执行/运行状态：就绪队列中的线程对象被OS选中，分配了时间片，正在执行
注意：只有就绪状态才能变成运行状态
4）阻塞状态：线程在执行过程中遇到了问题，比如锁阻塞、休眠阻塞、等待阻塞…
注意：我们的阻塞状态，等问题解决了以后/获取了临界资源【要抢占的公共资源】后
是加入到就绪队列中的，转为就绪状态，而不是转为运行状态直接执行
5）终止状态：线程成功执行完毕，释放资源，归还PCB
6）线程的挂起：正在运行中的线程，由于CPU分配的时间片已经用完，所以需要冻结当前线程运行的状态与各项信息
把它插入到就绪队列中，直到下次这个线程被调度执行时，重新恢复现场，继续执行

4、事务

事务是一个业务,也可以看成是一个逻辑工作单元,是为了保证业务的完整,数据的正确而推出的一种控制机制,原则上来讲,事务必须要满足ACID四个特性(原子性,一致性,隔离性,持久性)。

事务4个特性ACID
一般来说，事务是必须满足4个条件（ACID）：原子性（Atomicity，或称不可分割性）、一致性（Consistency）、隔离性（Isolation，又称独立性）、持久性（Durability）。

原子性：一个事务（transaction）中的所有操作，要么全部完成，要么全部不完成，不会结束在中间某个环节。事务在执行过程中如果发生错误，会被回滚（Rollback）到事务开始前的状态，就像这个事务从来没有执行过一样。
一致性：在事务开始之前和事务结束以后，数据库的完整性没有被破坏。这表示写入的资料必须完全符合所有的预设规则，这包含资料的精确度、串联性以及后续数据库可以自发性地完成预定的工作。
隔离性：数据库允许多个并发事务同时对其数据进行读写和修改的能力，隔离性可以防止多个事务并发执行时由于交叉执行而导致数据的不一致。
持久性：事务处理结束后，对数据的修改就是永久的，即便系统故障也不会丢失。

隔离级别
事务隔离分为不同级别，包括

读未提交（Read uncommitted） 安全性最差,可能发生并发数据问题,性能最好
读提交（read committed） Oracle默认的隔离级别
可重复读（repeatable read）MySQL默认的隔离级别,安全性较好,性能一般
串行化（Serializable） 表级锁，读写都加锁，效率低下,安全性高,不能并发

SQL语句优化

• 索引是数据库优化
• 表的主键会默认自动创建索引
• 每个字段都可以被索引
• 大量降低数据库的IO磁盘读写成本，极大提高了检索速度
• 索引事先对数据进行了排序，大大提高了查询效率

SpringBoot

好处:
1.简化了Maven的操作,以前自己找jar包的坐标,现在直接创建springboot工程勾选你要的功能
2.SpringBoot项目可以快速启动/关闭,就是像服务器(Tomcat)一样的操作.被整合了
3.简单快速整合其他技术

SpringMVC框架 –1,概述

是Spring团队的产品,遵循MVC设计模式
MVC设计模式: 最终实现松耦合
M是Model是模型层,用来封装数据
V是View是视图层,用来展示数据
C是Controller是控制层, 接受浏览器发来的请求,并做出数据的响应
SpringMVC框架用来接受请求 + 做出响应

--2,工作原理
涉及五个组件:
1,前端控制器DispatcherServlet: 接受请求,并且调度
2,处理器映射器HandlerMapping: 根据地址栏的写法,找到能处理这次请求的类和方法
3,处理器适配器HandlerAdapter: 真正开始找到方法,执行方法体处理业务,并返回结果
4,视图解析器ViewResolver: 找到能够展示数据的页面
5,视图渲染View: 把数据展示在页面上

Spring框架

1,概述
Spring框架可以和其他技术无缝衔接
BeanFactory: bean工厂, spring框架认为所有类都是bean. 从bean工厂可以获取每个bean
IOC: 控制反转, 不需要程序员来创建对象了,交给Spring框架来管理对象(从初始化…销毁).程序员可以直接从 Spring框架中获取Bean的对象
DI: 依赖注入,使用Spring框架明确两个对象间的依赖关系
AOP: 面向切面编程,是一种思想,解决了OOP的不足

IOC的注解方式

常用的IOC注解有四个: 功能都一样,都是交给spring框架创建对象
@Component @Service @Controller @Repository

AOP

1, 切面Aspect: 就是一个类
2, 通知Advice: 类里的方法,分类:
前置通知, 是指调用业务方法前会被执行的功能(适用于权限管理,缓存管理)
后置通知, 是指调用业务方法后会被执行的功能(适用于释放资源)
环绕通知, 是指调用业务方法的前 后 会被执行的功能(适用于事务管理,性能分析)
返回后通知, 是指调用业务方法并返回了结果后 会被执行的功能
异常通知, 是指调用业务方法并抛出异常后 会被执行的功能
3,切点PointCut: 触发通知执行的那个方法的时间点

 properties语法说明

语法说明:
1. 数据结构 key=value
2. value中前后不要有空格
3. properties文件 程序默认读取采用ISO-8859-1编码结构 中文必定乱码.
4. pro文件中key的名称不能复用.

YML语法说明

语法说明:
1. 数据结构 key:(空格)value
2. key的关键字有层级缩进效果, 注意缩进.
3. YML文件默认采用UTF-8编码格式 所以对中文友好.
4. value中不要有多余的空格
5. YML文件中key的前缀可以复用. 注意层级

注解说明:

@RestController = @Controller + @ResponseBody
效果:  1. @Controller 将当前类交给Spring容器管理
      2. @ResponseBody 前后端交互时,将后端服务器返回的对象转化为JSON
         前后端交互媒介 http协议 传输的数据都是字符串
         JSON: 有特殊格式的字符串

@Value("${cgbname}")

用:从Spring容器中获取数据,需要指定key , $ springel spel表达式.

Spring容器如何理解
 关于IOC的说明
IOC: 控制反转
具体含义: 将对象创建的权利交给Spring容器管理.
原因: 如果将对象自己管理,则必然出现耦合性高的现象. 不方便扩展
容器: 是一种数据结构类型 Map集合
KEY: 类名首字母小写
Value: Spring为当前的类创建的对象.
只要程序启动成功,则Map集合中(容器),里边包含了所有的IOC管理的对象

@Bean注解

注解说明: @Bean注解是Spring 专门为管理自定义对象 研发的注解.
用法区域: 在配置类文件中使用

功能: 被@Bean修饰的方法,将方法名当做key--user,将返回值对象当做值value * 根据Key-value 存储到Map集合中 交给Spring容器管理 * Map

Mybatis

MyBatis 是一款优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。

总结: MyBatis 是一款优秀的持久层框架,利用ORM思想实现了数据库持久化操作.
补充说明: 也有人把mybatis称之为半自动化的ORM映射框架.

ORM思想

对象关系映射（英语：Object Relational Mapping，简称ORM，或O/RM，或O/R mapping），是一种程序设计技术，用于实现面向对象编程语言里不同类型系统的数据之间的转换。

关系映射:
1. 对象映射-------映射表
2. 对象中有属性-------表中有字段
总结: 以对象的方式操作数据库.

   resultType:
            要求: 对象的属性名称与表中的字段一一对应.
            对象: User(id,name,age,sex)
            表:   demo_user(id,name,age,sex)
            总结: resultType适合单表映射,并且属性名称一致.

    resultMap:
             功能: 如果发现表中的字段与属性名称不一致时,使用resultMap映射
             对象: Dog(dogId,dogName)
             表:   dog(dog_id,dog_name) 属性不匹配.所以映射失败

总结 : 
1.Mybatis 的集合操作
1.1 数组 foreach collection=“array”
1.2 list集合 foreach collection=“list”
1.3 Map集合 foreach collection=“map中的KEY”
2. foreach 用法
1.collection 表示遍历的集合类型
1.1 数组 关键字 array
1.2 List集合 关键字 list
1.3 Map集合 关键字 Map中的key
2. open 循环开始标签
close 循环结束标签 包裹循环体
3. separator 分割符
4. item 当前循环遍历的数据的变量

1. 动态Sql
   1. where-if

 核心思想: 自动判断是否为null,
                如果为null,该字段不参与sql
        动态Sql规则:
            1.         
                    true: 会拼接 字段条件
                    false: 不会拼接字段条件
            2. 多余的关键字
                由于动态sql拼接必然会导致多余的and 或者 or
            3. where标签说明 可以去除 where后边多余的and 或者 or

2. set-if set标签用法: 去除set条件中多余的,号

3. choose-when-otherwise 标识都是互斥事件,只有一个有效.