JavaSE从零开始的学习笔记(更新至MySQL)
2021-07-08 17:44:01 18 举报AI智能生成
登录查看完整内容
java笔记，每日跟随自己学习的进度进行更新，直到我die了
作者其他创作
大纲/内容
重载（Overload）：一个类中定义多个相同名称的方法
方法名称相同
参数列表不同
与访问修饰符，返回值类型无关
要求
调用带有重载的方法时，需要根据传入的实参去找到与之匹配的方法
好处：屏蔽使用差异，灵活、方便
只是参数名称的不同并不能构成方法的重载
用的最多的是构造方法，和工具类方法
什么时候该用，当你发现行为是相同的，但是实现过程不同
方法重载
当父类提供的方法无法满足子类需求时，可在子类中定义和父类相同的方法进行覆盖（override）
方法名称、参数列表、返回值类型必须与父类相同，返回值类型或者是他的子类
访问修饰符可与父类相同或是比父类更广泛
方法覆盖原则
子类覆盖父类方法后，调用时优先执行子类覆盖后的方法
方法覆盖的执行
方法名被约束了，参数列表、返回值也被约束了保证了所有子类都可以使用相同的方法
方法重写是带有约束的
方法重写/覆盖
方法重载和方法重写
在局部内部类中使用局部变量，该变量必须为常量jdk1.8及以后java默认给使用在局部内部类的变量加上final关键字
1.8新特性
在子类中，可以通过super.的形式访问父类的属性和方法，可解决一定的属性遮蔽、方法覆盖后的父类成员调用问题
super()或super(实参)表示在子类代码的首行调用父类的构造方法
在子类的方法中使用super.的形式访问父类的属性和方法
如果在子类构造方法中，没有显示定义super()或super(实参)，则默认提供super()
同一个子类构造方法中，super()、this()不可同时存在
注意
super关键字
调用本类中的实例属性、实例方法如：this.name this.sayHi()
this 第一种用法
必须在构造方法的首行(也就是只可以有一个)，仅可在构造方法中而不能在普通方法中
调用本类中的构造方法 如：this();this(形参);
this 第二种用法
this 代表”当前实例“，即时模板中的当前对象，模板服务于哪个对象，this就指向哪个对象
this 关键字
this与super
new String()创建了几个对象
final修饰类，方法，常量
finalize垃圾回收的调用方法，用于标记对象是否进入垃圾回收队列
finally不管是否出现异常最终都是执行，异常处理中使用，基本用于资源的回收、
final、finalize、finally区别
面试
概念：在一个类的内部，在定义一个完整的类
1.编译之后可生成独立的字节码文件，名字为类名$其他名字
2.内部类可直接访问外部类的私有成员，而不破坏封装
3.可以为外部类提供比压迫的内部功能组件
特点
概念：在类的内部定义，与实例变量、实例方法同级别的类
语法 外部类类名 变量名= new 外部类类名（） 外部类.内部类 变量名 = 外部类变量名.new 内部类名（）
但外部类、内部类存在重名属性时，有限访问内部类属性，同过外部类类名.this.外部类实例属性
内部类是非静态的，除了要依靠外部类实例，还要依赖内部类实例，静态常量是不要类实例的，在编译时就分配好了内存，且final类型可以离开实例存活一段时间。所以非静态内部类只能有静态的final型常量。
成员内部类不可以定义静态成员
成员内部类可以使用三种修饰符，
成员内部类
概念：在类的内部定义，与外部类、外部类的静态属性，静态方法等同级别
静态内部类可以直接使用外部类的静态成员，而不能直接使用外部类的非静态成员 如果需要使用，可以在静态内部类实例化外部类，进而用外部类类名.外部类成员来使用外部类的成员
语法：静态类类名 变量名 = new 外部类类名.内部类类名（）
实例化之后可以用静态类类名.静态类成员；来使用其属性和方法可以当作写在内部的外部类
静态内部类
概念：定义在外部类的方法中，作用范围和创建对象的范围仅限当前方法中
局部内部类访问外部类局部变量时，因无法保障变量的生命周期与自身相同，所以修饰为final
作用：隐藏类的信息、限制类的使用范围
局部内部类
没有类名的局部内部类
必须继承一个父类或实现一个接口
定义类、实现类、创建对象的语法合并，只能创建一个该类的对象
优点：减少代码量，书写的思路流畅，更符合程序员的书写规律
缺点：可读性较差
匿名内部类(局部内部类的简化版)
分类
内部类
超类、基类，所有类的直接或间接父类，位于继承树的最顶层
任何类，如果没有书写extends显示继承某个类，都默认直接继承object类，否则为间接继承
object类中所定义的方法，是所有对象都具备的方法
作为参数，可接受任何对象
作为返回值，可返回任何对象
object类型可以存储任何对象
概念
返回引用中存储的实际对象类型，通常应用于判断两个引用中实际存储对象类型是否一致
public final Class<?>getClass(){}
一个对象的整数表现形式(整数类型的名字)返回该对象的十进制哈希码值即哈希算法根据对象的地址或字符串或数字计算出来的int类型的值哈希码并不唯一，可保证相同对象返回相同哈希码，尽量保证不同对象返回不同哈希码
public int hashCode(){}
返回该对象的字符串表示(表现形式)
可以根据程序需求覆盖该方法，比如：展示对象的各个属性值
public String toString(){}
默认实现this == obj，比较两个对象地址是否相同
可以进行覆盖比较两个对象的内容是否相同
public boolean equals(object obj){}
比较两个引用是否指向同一个对象(即判断地址是否相同)
判断obj(但是通过下一步可以排除判断obj为空的过程)
判断两个引用指向的实际对象类型是否相同(通过instanceof)
强制类型转换
依次比较各个属性值是否相同
覆盖equal的顺序
当对象被判定为垃圾对象时，由jvm自动调用此方法，用以标记垃圾对象，进入回收队列
垃圾对象：即没有有效引用指向此对象时，为垃圾对象
垃圾回收：由gc销毁垃圾对象，释放数据存储空间
自动回收机制：jvm的内存耗尽，一次性回收所有的垃圾对象
手动回收机制：使用system.gc()通知jvm执行垃圾回收
protected void finalize()throws Throwable//了解，面试题中可能有坑
常用方法
object类
八种基本类型不是对象，但是八种基本类型的包装类都是对象，符合了万物皆对象的概念
概念：八个基本类型各自的对象（引用数据类型）
六种数字型的包装类父类都是number，父类提供了六种转型的方法
包装类型里有封装了对印的基本类型、赋值取值的基本方法，常用的一些方法（比如转型）
杂类
object可统一所有数据，包装类的默认值是null
8种包装类提供不同类型间的转换方法：Number父类中提供的6个共性方法parse数据类型（）静态方法valueOf（）静态方法
注意：需要保证类型兼容，否则抛出NumberFirmatException异常character 没有parse方法
jdk5.0之后，自动装箱、拆箱。基本数据类型和包装类自动转换
valueOf:基础数据类型转换为包装类
基础数据类型Value:包装类转回基础数据类型
parse基础数据类型：字符串转化为基础数据类型
valueof转换为引用数据类型
基础数据类型与包装类进行运算判断时，永远都是包装类自动拆箱为基础数据类型进行运算或者判断
类型转换与装箱、拆箱
可以被object统一数据，且每一个都是对象其中还有很多方法可以使用
方便之处
Java预先创建了256个常用的整数包装类型对象，在实际应用当中会对已创建的对象进行复用
整数缓冲区
字符串是常量，创建之后不可以改变
字符串字面值存储在字符串池中可以共享
String s = \"hello\";产生一个对象，字符串池中存储
String s = new String(\"hello\")产生两个对象，堆中池中各存储一个
xx.charAt(下标)，把字符串对应下标的字符提取
判断用户名黑名单
xx.contains(\"字符串\")，判断字符串内是否有包含你查询的字符串。返回布尔值
与length的区别一个属性一个是方法，带有小括号的都是方法
xx.length()，获取字符串长度
判断用户名黑名单是否为空
判断文件类型
xx.endsWith(字符串)，判断字符串是否以字符串结尾
xx.startsWith(字符串)，判断字符串是否以字符串开头
String重写了equals方法，只比较字面值，严格区分大小写equalsIgnoreCase则不区分daxiaoxie
StringBuilder(jdk5.0推出，速度快，线程不安全建议首选)
StringBuffer(jdk1.0推出，速度慢，线程安全)
可变长字符串
字符串相加就是自动利用Stringbuilder拼接新开空间，如果是字面值相加则就不会新开空间直接是字面值拼接
String
在java.math中
最好用字符来创建，因为字符创建的才是最精确的
创建语法：BigDecimal 变量名 =new BigDecimal（值）
+：add
-：subtract
*：multiply
进行除法时，如果无法除尽可以指定精确到几位以及按照自己制定的取舍模式
BigDecimel（除的数，取小数点后几位，四舍五入为UP）
/：divide
+-*/
BigDecimal
包装类
不管什么语言，不管什么数据库都会有毫秒这个单位
日期类型Date
calender是一个抽象类，无法被实例化，但是它提供了一个方法getinstance来获得一个calendar对象得到的calendar由当前时间初始化
获取时间
日期类型Calender
因为国内外时间规定不同，存减取加
4
通过声明new SimpleDateFormat（格式）来使用各种方法进行符合格式的字符串与日期的互相转换
format()，日期转换为字符串
parse()，字符串转日期
SimpleDateFormat
日期类型
常用类
概念：对象的容器，定义了对多个对象进行操作的常用方法，可实现数组的功能
数组长度固定，集合长度不固定
数组可以存储基本数据类型和引用数据类型，集合只能存储引用数据类型
与数组的区别
java.util.*包里面
位置
collection父接口：该体系结构的根接口，代表一组对象称为集合，每个对象都是该集合的元素
特点：有序、有下标、元素是可重复的
继承父接口提供的共性方法，同时定义了一些独有的与下标操作相关的操作方法
实际初始长度是0
首次添加元素时，需要实际分配数组空间，执行数组扩容操作
真正像数组中插入数据
赋值add方法，取值1：foreach遍历取值，取值2：while(hasNext)循环，hasNext判断当前是否为有效元素，next()取值之后指针游标往下移动
Arraylist没有自身好用的独有方法，所以一般arraylist都是使用list接口来接受实例方便进行多态和替换
1.Objecr[] elementData//Arrayslist底层源码使用数组进行数据的保存
2.DEFAULT_CAPACITY =10//默认的容量可以存储多少个值
3.刚开始创建的时候，长度为0
4.当arraylist使用.add()方法进行存值的时候，该方法内会有进行扩容的判断
第一次存值默认扩容10，之后每次扩容1.5倍
Arraylist源码分析
查询快，增删慢
JKD8的Arraylist，
与arraylist一样，区别在于一个快一个慢线程安全与不安全
vector
独有方法addlast，addfrist，getlast，geifrist，存取首位值
取第一个值之后把值拿走了，集合里对应的值也被删掉了
poll()（弹栈方法）
以链表形式存储
查询慢增删快
linkedlist
实现类
list接口
set接口的特点：无序、无下标，元素不可重复当插入新元素时，如果新元素与已有元素进行equals比较，结果为true时，则拒绝新元素的插入
1.基于hashcode实现元素不重复
2.当存入元素的哈希码相同时会调用==或.equals来进行确认，结果为true拒绝元素存入
存储方式数组加单向链表
可以通过重写hashcode与equals来重新更改判内容重复
hashset
链表实现的hashset，按照链表进行存储，即可保留元素的插入顺序，但是没有下标
linkedHashSet
基于排列顺序实现元素不重复
实现了sortset接口，对集合元素自动排序
元素对象的类型必须实现comparable接口，指定排序规则
通过conpareto的方法返回作为0确定是否为重复元素
底层为红黑树
TreeSet
方法全部都是继承collection中的方法
set接口
子接口为list与set
特点：代表一组任意类型的对象，无序、无下标
boolean add(object obj):添加一个对象
add all(cikection c)将一个集合中的所有对象添加到此集合中
clear()清空此集合中所有对象
就是equals比较地址
containsall，一样遍历再用contains比较
contains(object obj)检查此集合是否包含obj对象
size()集合的元素个数而不是长度
equals(object o)比较此集合是否与指定对象相等
isempty()判断此集合是否为空
remove(object o )在此集合中移除o对象
Object[] toArray()将此集合转换成数组
迭代器每次使用都需要迭代器名=集合名.iterator初始化
iterator()获取迭代器Iterator类型接口接收
方法
collection父接口
collection集合
当map的key值重复就会出现value值被覆盖的情况===>修改
拿到任何一个对象，通过hash(key)做运算，key>>>16(除以16)，只可能的到0-15之间的一个数组作为插入的数组下标
hashmap算法
hashmap的线程安全版本
hashtable的子类，主要用于存储key和value都是字符串的情况常在读取配置文件之后，保存文件中的键值对。反射jdbc
properties
hashtable
自动对key做排序，根据compareto的返回值去重
treemap
keyset()：获得map集合中所有的键。返回的时set集合
values():获得map集合中所有的值。返回的是collection集合
enteyset():返回的是map.entry(node)包含了getkey和getvalue。直接输出是调用tostring打印键值对
map集合的遍历
Map父接口
概念：参数化类型、类型安全的集合，强制集合元素的类型必须一致
特点：编译时即可检查，而非运行时抛出异常访问时，不必类型转换（拆箱）
泛型类创建对象时指明，泛型接口在实现接口时指明，都叫实例泛型（创建对象实现接口指明的泛型）
public static <T extends Number> void method(T t)//只接受数字public static<T extends Animal> void method( T t)//只接受animal类型或其子类
静态泛型加载方法上static后面添加
泛型集合
java泛型是jdk1.5中引入的一个新特性，其本质是参数化类型，把类型作为参数传递
常见形式有泛型类、泛型接口、泛型方法
语法<T...>T为类型占位符
泛型不可以被实例化
高级类别的知识，熟练应用需要时间、经验的积累（常用名称：Eelement/T=Type/K=Key/V=Value）
约束-规范类型
类：创建对象时，为类所定义的泛型；进行参数化赋值
接口：实现接口时，为接口所定义的泛型，进行参数化赋值
实例泛型
定义在方法的返回值前面：<T><T extends Comparable<T>>可应用在形参列表、返回值类型两种常见、不单单可以规范化泛型还可以语义化返回值
定义在方法的形参列表中<?>、<?extends Object>不支持使用&只能应用在形参列表上，规范泛型
静态泛型
定义泛型
使用泛型的场景
泛型
概念：集合工具类定义了除了存取以外的集合常用方法
publicstatic<TextendsComparable<?superT>>voidsort(List<T>list)//排序要求必须实现comparable，必须可与自身类型比，以及父类类型比
publicstaticvoidreverse(List<?>list)//反转、倒置元素
publicstaticvoidshuffle(List<?>list)//随机重置顺序配合poll弹栈可以模拟抽奖
collections工具类
集合
程序在运行过程中出现的特殊情况(报错)
异常处理的必要性：任何程序都可能存在大量未知问题、错误；如果不对这些问题进行正确处理，则可能导致程序的中断，造成不必要的损失
异常的概念
Error：JVM、硬件、执行逻辑错误，不能手动处理
RuntimeException：运行时异常，可处理，可不处理
CheckedException：受查异常，必须处理，不处理编译不通过
Exception：程序在运行和配置过程中产生的问题，可处理
Throwable：可抛出的，一切错误或异常的父类，位于Java.lang包中
异常的分类
自动抛出异常：当程序在运行时遇到不符合规范的代码或结果时，会产生异常
手动抛出异常：throw new 异常类型(\"实际参数\")
一旦产生异常结果：相当于执行return语句，导致程序因异常而终止
异常的产生
按照方法调用链反向传递，如果最终都没有处理异常，最终交由我们的jvm进行默认异常处理（打印堆栈跟踪信息）
受查异常：throws声明异常，生命位置：修饰在方法参数列表的后端
运行时异常：因其可处理，可不处理无需声明
异常的传递
I.try{//可能出现异常的代码}catch(Exceptione){//捕获异常后，对异常处理的相关代码。处理方案：1、自定义2、printStackTrace();3、getMessage();}finally{//无论是否出现异常，都需要执行的代码。常用于释放资源.}
异常的处理
try{}catch（）{}
try{}catch(){}catch(){}
try{}catch(){}finally{}
Try{}catch(){}catch(){}finally{}
try{}finally{}
注意：在多重catch下，遵循从子到父的顺序，父类异常在最后捕获
最好按照精确的异常捕获来做，但是在多重catch最后要加上exception
常见异常处理结构
继承Exception(受查异常)或Exception的子类常用runtimeexception（运行时异常）
无参构造方法
string message参数的构造方法。定义异常原因信息
必要提供的内容
通过调用父类的构造
自定义异常
方法名、参数列表、返回值类型必须与父类相同
子类的访问修饰符和父类相同或比父类更宽泛
子类中的方法，不能抛出比父类更宽泛的异常
异常方法覆盖
反编译：javap-verbose文件名称（是.class）>自定义文件名称.bytecode
方法执行中字节码操作指令
扩充
异常处理最大的作用就是不让我的程序终止以至于造成更大的损失
异常Exception
jvm、硬件、执行逻辑错误，不能手动处理
错误Error
throwable(可抛出的异常)
程序是静止的，只有真正运行时的程序才被称为进程
单核CPU在任何时间点上，只能运行一个程序；宏观并行、微观串行
程序是啥
线程又称轻量级进程，程序中的一个顺序控制流程，同时也是cpu的基本调度单位。进程由多个线程组成，彼此间完成不同的工作，交替执行称为多线程
cpu类似公司，部门类似进程，线程类似部门的员工，时间片类似公司分配给部门，部门交给员工的任务时间，员工就开始打架抢时间片，任务做完就会自杀，在java中线程争取时间片采用抢的形式，实际工作的是线程
main方法就是主线程，同过其他的方法可以创建子线程，与主线程并发执行
java是抢占式的资源，a资源多a先运行，然后b把a资源抢了比a资源多b就运行循环往复
什么是线程
进程是操作系统分配资源的基本单位，而线程是CPU的基本调度单位
一个程序运行后至少有一个进程
一个进程可以包含多个线程，但是至少需要有一个线程
进程间不能共享数据短地址，但同进程的线程之间可以
进程与线程的区别
cpu时间片：操作系统会为每个线程分配执行时间。
堆空间：存储线程需要使用的对象，多个线程可以共享堆中的对象
栈空间：存储线程需使用的局部变量，每个线程都有独立的栈
运行数据（决定线程操作的数据）
线程的逻辑代码（线程做的事）
所有线程都具有基本的组成部分
线程的组成
继承thread类，重写run方法，run方法内就是子线程运行的内容
调用采用.start()方法启动子线程的调用
如果直接.run()则主线程直接运行
thread.currentthread().getid()//获取线程idthread.currentthread().getname()//获取线程名
子线程因为继承了thread所以可以直接使用getid与getname方法
第一种继承thread
实现runnable接口，重写run方法，run方法内就是子线程运行的内容
接口里面只有run方法，所以只有thread类能够启动线程
实例化runnable的实现类，创建thread对象，提供runnable的实现给予thread去启动线程执行。即把runnable的实现类当参数传进thread
如果这个线程做的事情只有使用一次，可以直接使用匿名内部类来实现，写法会更简洁
好处不占用继承的名额且可以做到数据的共享还可以使用匿名内部类
第二种实现接口runnable
线程的创建
线程对象被创建，即为初始状态，只在堆中开辟内存，与常规对象无异
New初始状态
等待OS(系统)选中并分配时间片
调用start()后变成ready就绪状态
timed waiting(限期等待)，等待完毕回到就绪状态
sleep(x)
限期等待
waiting(无限期等待)满足条件回到就绪状态
join()
无限期等待
线程进入运行状态没有锁标记进入不了代码块进入阻塞状态等待获取锁标记，获得锁标记时回到就绪状态等待时间片
blocked阻塞状态
OS选中后变为Running运行状态时间片到期后变为Ready就绪状态
主线程main（）或独立线程run（）结束进入终止状态，并释放持有的时间片
run()结束变为Terminated终止状态
在给定时间点上，线程只能处于一种状态
注意：jdk5开始就绪与运行状态统称为runnable
线程的基本状态
当前线程主动休眠毫秒
当直接类名点sleep时，代码属于那个线程哪个线程就睡一会
休眠sleep(毫秒)
当前线程主动放弃时间片，回到就绪状态，竞争下一次时间片
放弃yield()
将发起点的线程加入到所在线程中等待发起点的线程结束后再执行
允许其他线程加入当前线程中并优先执行
加入当前线程，他会阻塞当前的线程直到自身线程任务完成
括号可以传递参数，表示等待运行时间
join方法必须在线程start方法调用之后才有意义
多个join运行则使用join的抢，当前线程不会抢
结合join()
setpriority，默认级别5上下限为1-10
优先级别设置，只是几率（垃圾）
线程的基本方法都是与线程暂停有关
临界资源：被多线程共享的对象，一次仅允许一个线程使用才可保证其正确性
关于共享数据的操作都是原子操作
原子操作：不可分割的多个步骤，被视作一个整体，其顺序和步骤不可打乱或缺少
线程不安全：当多线程并发访问临界资源时，如果破坏原子操作，可能会造成数据不一致
可以新建一个object对象作为标记
每个对象都有一个互斥锁标记，用来分配给线程
只有拥有对象互斥锁标记的线程，才能进入对该对象加锁的同步代码块
线程退出同步代码块时才会释放相应的锁标记
synchronized（临界资源对象）{对临界资源加锁代码原子操作}
同步代码块（锁）
synchronized加在返回值前面
整个方法都被锁住，不管静态还是实例方法，只有一个进程可以进来
同步方法
新建一个私有对象作为锁对象
私有锁
括号填this当前对象作为锁
对象锁
类名.class 作为条件
类锁
互斥关系不一样
锁类型
只有在调用包含同步代码块的方法或同步方法时，才需要对象的锁标记
如调用不包含同步代码块的方法或普通方法时，则不需要锁标记，可直接调用
同步规则
解决线程不安全方法
当第一个线程拥有a对象锁标记并等待b对象锁标记同时第二个线程拥有b对象锁标记，并等待a对象锁标记时产生死锁
一个线程可以同时拥有多个对象的锁标记，当线程阻塞时，不会释放已经拥有的锁标记，由此可能造成死锁
产生原因
public final void wait（）
public final void wait（long timeout）
必须在对obj加锁的同步代码块中。在一个线程中调用obj.wait()时此线程会释放其所拥有的所有锁标记，同时此线程因obj处在无限期等待的状态中释放锁进入等待队列
等待
public final void notify()
public final void notifyall()
必须在对obj加锁的同步代码块中。从obj的waiting中释放一个或全部线程对自身没有任何影响
通知
生产者与消费者
解决方法：线程通信
互斥
占有且等待
不可抢占
循环等待
形成死锁的四个条件
死锁
线程的安全问题
多线程
线程是宝贵的内存资源、单个线程约占1mb空间过多分配容易造成内存溢出
频繁的创建及销毁线程会增加虚拟机回收频率、资源开销，造成程序性能下降
现有问题
线程容器，可设定线程分配数量上限
将预先创建的线程对象存入池中，并重用线程池中的线程对象
避免频繁的创建及销毁
将任务提交给线程池，由线程池分配线程、运行任务并在当前任务结束后复用线程
原理
Executor:线程池的顶级接口，只能使用runnable
ExecutorService：线程池接口，可通过submit(Runnable task)提交任务代码不仅支持父类接口的runnable还支持功能更强大的callable
Executors工厂类：通过此类可以获得一个线程池
通过newfixed thread poll(int nthreads)获取固定数量的线程池。参数：指定线程池中线程的数量
通过newcachedthreadpool()；获得动态数量的线程池，如不够则创建新的，没有上限，更灵活但不适合资源过少的场景
常用的线程池接口和类（所在包java.util.concurrent）
获取方法
线程池
public interface Callable<V>{ public V call() throw Exception}
jdk5加入，与Runnable接口类似，实现之后代表一个线程任务
callable具有泛型返回值、可以声明异常
callable 接口
概念：异步接受ExecutorService.submit()所返回的状态结果，当中包含了call()的返回值
方法 ： V get()以阻塞形式等待Future中的异步处理结果(call()的返回值)
Future接口
形容一次方法调用，同步一旦开始，调用者必须等待该方法返回，才能继续
单条执行路径
同步
形容一次执行方法调用，异步一旦开始，像是一次消息传递，调用者告知后立刻返回，二者竞争时间片，并发执行
多条执行路径
异步
异步与同步
JDK5加入，与synchronized比较，显示定义，结构更灵活
提供更多实用性方法功能更强大，性能更优越
lock接口的实现类，与synchronized一样具有互斥锁功能
Lock locker = new reentrantlock()locker.lock()locker.unlock()
reentrant lock
重入锁
一种支持一写多读的同步锁，读写分离可分别分配读锁、写锁
支持多次分配读锁，多个读锁操作可以并发执行
互斥规则：写-写：互斥、阻塞 读-写：互斥、读阻塞写，写阻塞读 读-读：不互斥、不阻塞在读操作远远大于写操作的环境中，可以保障线程安全的情况下提高运行效率
Reentrantreadwritelock
读写锁
lock接口与其实现类
常用集合
线程安全的集合
高级多线程
内存与存储设备之间传输数据的通道
水借助管道传输；数据借助流传输
即流就是通道
什么是流
输入流：将存储设备中的内容读入到内存中
输出流：将内存中的内容写入到存储设备中
按方向分
字节流：以字节为单位，可以读写所有数据(包括图片视频)
字符流：以字符为单位，只能读写文本数据(一字节等于二字符，所以读文本数据快)
按单位
节点流：具有实际传输数据的读写功能
过滤流：在节点流的基础之上增强功能
按功能
流的分类
read
available获取当前流读取了多少可读的字节数
inputstream：字节输入流
write
构造方法重载第二参数布尔值默认为flase(覆盖内容)改成true则文件内容追加
文件不存在会自动创建，文件夹不存在则报错
output steam：字节输出流
父类（抽象类）
file output steam：write(btye[] b)一次写多个字节将b数组中所有字节写入输出流
fileinputstream：read(byte[] b)从流中读取多个字节，将读取内容存入b数组返回实际读到的字节数；如果达到文件尾部返回-1
子类字节节点流
字节流
注意：所有的流有开就有关，即tryfinally必须要有关.close关闭流方法
提高io效率，减少访问磁盘的次数
数据存储在缓冲区中，flush是将缓存区的内容写入文件中，也可以直接close
缓冲流buffered开头的outin
增强了缓冲区功能
增强了读写8种基本数据类型和字符串功能
readobjectwriteobject
增强了读写对象的功能
细节：对象到硬盘序列化，反之反序列化
对象必须转成二级制，机器码或者.class等计算机可以看懂的
需要实现标识性接口serializeable才可以序列化
对象流不能追加，想让它正常追加只能重写也可以在读取后的数据进行覆盖
必须保证其所有属性均可序列化
tansient修饰为临时属性，不参与序列化
读取到文件尾部标志：java.io.EOFException
对象序列化
对象流object开头的outin
字节过滤流
ISO-8859-1收录出ascii外，还包括西欧、希腊语、泰语等
utf-8
gb2312简体中文
gbk简体中文扩充
big5台湾，繁体中文
注意如果工作前端传数据过来是乱码，先检查字符编码
基础的字符编码
reader：字符输入流
writer：字符输出流
父类抽象类
前面加file
字符节点流
只要是文本文件优先使用字符流，如果是图片视频音频等等全部都要使用字节流’
字符流
与字节过滤流一模一样
while判断从-1改成null
支持输入换行符，可以一次写一行读一行
字符过滤流
封装了print()/println()方法，支持写入后换行
支持数据原样打印
printwriter：输出流
字符打印流
input stream reader
outputsteamwriter
概念：代表物理盘符中的一个文件或者文件夹
createNewFile创建一个新文件
MKdir创建一个新目录
Delete删除文件或空目录
Exists判断File对象所对象所代表的对象是否存在
getAbsolutePath获取文件的绝对路径
getName取得名字
getParent获取文件目录所在目录
isDirectory是否是目录
isFile是否是文件
length获得文件的长度
listFiles列出目录中的所有内容
renameTo修改文件名为
子主题
FileFilter接口
File类
多个服务端可以多个线程，每个功能不同的服务端接口都不一样
IO流思路
IO流
由点和线构成，表示诸多对象之间的互相联系
什么是网络
为实现资源的共享和信息传递，通过通信线路连接起来的若干主机(host)
最重要的就是资源共享和信息传递
互联网（internet）点与点相连
万维网（www-worldwideweb）端与端连接
物联网（lot-internetofehings）物与物相连
网络编程：让计算机与计算机之间建立连接、建立通信
什么是计算机网络
第一层：物理层，设备之间的数据通信提供传输信号和物理介质（双绞线、光导纤维）
第二层：链路层：在物理层上，通过规程和协议（差错控制）来控制传输数据的正确性（mac）
第三层：网络层：负责定义了能够标识所有网络节点的逻辑地址（IP地址）
第四层：传输层负责是否先择差错恢复协议，数据流重用，错误顺序重排（tcp、udp）
第五层：会话层负责使应用建立和维持绘画，使通信在失效时继续恢复通信（断点续传）
第六层：表示层负责定义转换数据格式及加密、允许选择以二进制或ASCII格式传输
第七层：应用层负责文件访问和管理、可靠运输服务、远程操作服务（http、ftp、smtp）
osi
第四层应用层负责传送各种最终形态的数据，是直接与用户打交道的层，典型协议是HTTP/ftp等
五六七合并应用层
第三层传输层负责传送文本数据，主要协议是TCP、udp协议
第二层网络层负责分配地址和传送二进制数据、主要协议是ip协议
接口层负责建立电路连接，是整个网络的物理基础，典型的协议包括以太网ADSL等
一二合并网络接口层
是一种面向连接的、可靠的、基于字节流的传输层通信协议数据大小无限制。建立连接的过程需要三次握手，断开连接的过程需要四次挥手
传输控制协议
是一种无连接的传输层协议，提供面向事物的简单不可靠信息传送服务，每个包的大小64kb
用户数据报协议
tcp协议tranmissioncontrolprotocolUDP协议：UserDatagramProtocol
分配给互联网设备的数字标签(唯一标识)
4字节32位整数，分成四段8位的二进制数，每8位之间用圆点隔开，每8位整数可以转换为一个0-255的十进制整数D.D.D.D例如255.255.255.255
A类政府机构：1.0.0.1-126.255.255.254
B类中型企业：128.0.0.1-191.255.255.254
C类个人用户：192.0.0.1-223.255.255.254
D类用于组播：224.0.0.1-239.255.255.254
E类用于实验：240.0.0.1-255.255.255.254
回环地址：127.0.0.1，指本机，一般用于测试使用
查看ip命令：ipconfig
测试ip命令：ping D.D.D.D
ipv4
16字节128位整数，分成8段16进制数，每16位之间用圆点隔开，每16位整数可以转换为0-65535的十进制数X.X.X.X.X.X.X.X例如FFFF.FFFF.FFFF.FFFF.FFFF.FFFF.FFFF.FFFF
ipv6
Ip地址分两种
IP协议：Internet Protocol Address
tcp/ip协议
在通信实体上进行网络通讯的程序的唯一标识
公认端口：0-1023
注册端口：1024-49151
动态或私有端口：49152-65535
端口分类
MySQL：3306
Oracle：1521
tomcat：8080
SMTP：25
web服务器：80
ftp服务器：21
常用端口
port端口号
概念：表示互联网协议（IP）地址对象，封装了
inet address
socket（套接字）是网络中的一个通信节点
分为客户端socket与服务器sever socket
通信要求：IP地址+端口号
创建sever socket，指定端口号
调用accept等待客户端接入
建立通信连接（会话）
创建socket，指定服务器ip+端口号
使用输出流，发送请求数据给服务器
使用输入流，接受响应数据到客户端
客户端请求服务器
使用输出流，发送请求数据给客户端
使用输入流，接受响应数据到服务器
服务器响应客户端
开发步骤
socket编程
基于tcp的网络编程
网络模型
网络编程
概念：基于某个类new出来的对象，也称为实例对象
类加载的产物，封装了一个类的所有信息（类名、父亲、接口、属性、方法、构造方法）
什么是类对象
1.通过类的对象获取类对象Class c = 类的实例.getClass()
2.通过类名获取类对象Class c = 类名.Class
3.通过静态方法获取类对象Class c = Class.ForName(全限定名(\"包名.类名\"))
获取类对象的三种方法
getName获取全限定名
getpackage获取包名
getsuperclass获取父类名字
getfeld获取所有可见属性
获取所有公开的构造方法constructor<?>[] x = class.getconstructors()获取所有的包括非公开使用getdeclareconstructors方法
获取指定的构造方法，class.getconstructor(参数)
调用无参构造方法获取对象object、 newinstance = constructor.newinstance()
获取类中所有的公开方法，包括父类的方法methon[] methods=class.getmethods()非公开使用getdeclaredmethods()
获取指定方法method method = class.getmethod(方法名)
获取类中的公开属性field[] fields = class.getfields();
反射可以获取类里面所有的东西，不管私有还是公开
一套被反复使用、被多数人知晓、经过分类编目的、代码设计经验的总结
可以简单理解为特定问题的固定解决方法
什么是设计模式
使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码的可靠性、重要性
好处
在Gof的设计模式书中描述了23种设计模式
开发中有一个非常重要的开闭原则、对拓展开放、对修改关闭
工厂模式主要负责对象创建的问题
可通过反射进行工厂模式的设计，完成动态的对象创建
工厂设计模式
直接在类里私有静态最终实例化
构造方法私人化
对外提供一个可访问的静态方法
使用直接用反射获取对象的实例对象类型 对象名 = 对象类型.getinstance()然后对象名.方法使用
类加载即可创建，占用内存高，存在时间久，但是线程安全
饿汉式
直接在类里私有静态实例化
对外提供唯一的可访问的静态方法
方法里判断对象是否为空，为空就实例化并返回
消耗资源少，保存时间短，线程不安全，但是可以加锁哇
懒汉式
建立私有静态内部类里面创建静态对象
使用时创建，线程安全
懒汉式究极体
一般使用饿汉和究极体，最好时究极体
单例设计模式
典型两个
设计模式
枚举就是个常量类，只能定义字符串，变量名和值都是同一个使用方式直接通过枚举名称点常量名
枚举里面的值都是静态的常量
枚举是一个引用类型，枚举是一个规定了取值范围的数据类型
枚举变量不能使用其他的数据，只能使用枚举中的常量
枚举
反射
jdk8(又称jdk1.8)是java语言开发的一个主要版本Oracle公司于2014年3月18日发布Java8
支持lambda表达式
函数式接口
新的stream api
新的日期API
其他特性
概述
lambda表达式是特殊的匿名内部类，语法更简洁
lambda表达式允许把函数作为一个方法的参数(函数作为方法的传递)将代码像数据一样传递
<函数式接口><变量名> = (参数1，参数2)->{//方法体[};
（）代表的是方法的参数列表->箭头函数，只是一种指向，代码前面的参数列表的变量式应用在后面的{}代码
语法
演示案例
只能用在函数式接口，只有一个必须要实现方法的接口
基本使用
Lambda表达式
如果一个接口只有一个抽象方法，则该接口称之为函数式接口
函数式接口可以使用Lambda表达式，lambda表达式会被匹配到这个抽象方法上ps:@Functionallnterface 注解检测接口是否符合函数式接口规范
consumer<T>消费型接口，无返回值，一个参数Taccept(T t)对参数进行操作
Supplier<T>供给型接口，有返回值，无参数T.get返回类型为T的对象
Predicate<T>断言型接口boolean test(T t)确定类型为T的对象是否满足条件并返回boolean值
常见函数式接口
方法引用时Lambda表达式的一种简写形式
如果Lambda表达式方法体中只是调用一个特点的已经存在的方法，则可以使用方法引用
对象::实例方法
类::静态方法
类::实例方法
类::new
常见形式
方法引用
流与集合类似，但集合中保存的是数据，而Stream中保存对集合或数组数据的操作
stream自己不会存储元素
stream不会改变源对象。相反，他们会返回一个持有结果的新stream
stream操作是延迟执行的，会等到需要结果的时候才执行
新建一个流
创建
在一个或多个步骤中，将初始stream转化到另一个stream流的中间操作
中间操作
使用一个终止操作来产生一个结果。该操作会强制之前的延迟操作立即执行，在此之后，该Stream就不能使用了
终止操作
使用步骤
同过collection对象的stream或parallestream方法
通过Arrays类的stream方法
通过stream接口的og、iterate、generate方法
通过intstream、longstream、Doublestream接口中的of、range、rangeclosed方法
创建stream的方法
filter过滤
limit限制
skip跳过
distinct去掉重复
sorted排序
中间步骤
stream
之前时间API存在问题：线程安全问题、设计混乱
只有年月日，没有时分秒
LocalDate
LocalTime
不是new出来，调用其静态方法now输出当前时间
LocalDateTime
本地化日期时间API
获取格林威治的时间
instant时间戳
systemdefault返回当前时区
zoneid时区
新时间API
jdk8新特性
一门使用标记或标签来描述网页展示信息给用户的语言
页面内可以包含图片连接音乐程序等非文字元素
超文本
标签，不同的标签实现不同的功能
标记
人与计算机的交互工具
语言
超文本标记语言
93年6月html1.0
95年11月2.0
97年1月3.2
97年12月4.0
99年12月4.01
14年10月5.0
HTML版本
HTML标签是以尖括号包围的关键字
Html标签通常是成对出现的，又开始就有结束
格式：属性=\"属性值\"
多个属性之间空格隔开
HTML通常都有属性
在HTML标签内不区分大小写，建议小写
书写规范
HTML简介
根标签
<html>
头标签
<head>
标题标签
<title>
正文
<body>
结构标签
用于实现简单的页面布局
<!--注释内容-->
注释标签
<br/>
换行标签
<p></p>
段落标签
width:水平线的长度
size:水平线的粗细像素表示，例如：10px
color:水平线的颜色
align:水平线的对齐方式
<hr/>
水平线标签
随着数字增大文字逐渐变小，字体是加粗的，内置字号，默认占据一行
h1-h6由大到小
使用DIV+CSS是现下流行的一种布局方式
div:行级块标签，独占一行，换行
span:行内块标签，所有内容都在同一行
块标签
font标签处理网页中文字的显示方式
size：用于设置字体的大小，最小1号最大7号
color:用于设置字体的颜色
face：用于设置字体的样式
文字标签
格式化标签实现内容的简单样式处理
b：粗体标签
strong：加粗
em：强调字体
sub：上标标签
sbp：下标标签
del：删除线
文本格式化标签
排版标签
HTML标签
综合案例
使用一组无序的符号定义，标签为<ul></ul>
type = \"circle\"
circle :空心园
disc:实心圆
square：黑色方块
无序列表
使用一组有序的符号定义，标签为<ol></ol>
1
A
a
i
I
有序列表
无序列表与有序列表相互嵌套使用】
列表嵌套
在页面指定位置处中引入一副图片
src:引入图片的地址
width：图片的宽度
height：图片的宽度
align：对齐显示方式
alt：提示信息
hspace在图片左右设定空白
vspace在图片上下设定空白
图片标签
连接标签为<a>文本或图片</a>
在页面使用链接标签跳转到另一页面
href：跳转到页面的地址(跳转到外网需要协议)
_blank:新窗口中打开
_self：自身空口中打开
parent：在父窗口中打开
_top：在顶级窗口中打开
target：设置跳转页面时的打开方式
定义位置<a name=\"名称\"></a>
指向：<a href=\"#名称\"></a>
指向同一页面中指定位置
链接标签
表格标签用来在页面中规则整齐的显示数据
table:定义一个表格
tr:定义行
td：定义列
th：定义列标题加粗显示
标签
border：设置表格边框
width、height：设置表格的宽度或和高度
align、valign：设置单元格的水平或垂直对齐
用表示颜色的英文单词
用十六进制表示i颜色
颜色表示方式
bgcolor：设置表格的背景颜色
列合并：cols
行合并：rows
表格常用属性
表格标签
action：将表单的数据提交到该地址上处理
method：get：不安全、post：相对安全
application/x-www-from-urlencoded:默认、普通表单
multipart/from-data:文件上传使用
enctype
from标签定义表单
input元素
表单元素
表单标签：表单用于收集不同类型的用户输入数据
表单标签
使用框架可以在同一个游览器窗口中显示不只一个页面
每份HTML文档称为一个框架，并且每个框架都独立于其他的框架
框架
row/columns：规定了每行或每列占据屏幕的面积
frameborder：是否有框架边框
frameset
noresize=\"noresize\"：不能调整大小
frame
框架标签
meta：定义网页元信息
link：链接样式表
script：定义js代码
 ：空格
>：>
<:<
®：注册符号
":双引号
¥：人民币
特殊字符
其他标签
HTML
是一种用来表现HTML或XML等文件样式的计算机语言
CSS可以修饰美化网页
CSS可以配合各种脚本语言动态地对网页各元素进行格式化
内容与表现分离，页面外观维护的更加容易
层叠样式表
CSS规则有两个重要的部分构成：选择器以及一条或多条声明
选择器通常时您需要改变样式的HTML元素
每条声明由一个属性和一个值组成
基本语法
把CSS样式嵌入到HTML标签当中，类似属性的用法
内联方式
在head标签中使用style标签引入CSS
内部方式
将CSS样式抽成一个单独.css文件，使用link标签引入或@import导入
<link rel=\"stylesheet\" type =\"test/css\" href=\"div.css\"><link>
rel:代表当前页面与href所指定文档的关系
type:文件类型，告诉游览器使用css解析器去解析
href:css文件地址
link标签
<style>@import url(\"地址\")</style>
css2.1特有的
@import方式
外部方式
导入方式
作用：选择页面上的某一个或者某一类元素
选择一类标签
标签选择器
选择所有class属性一致的标签，跨标签.类名{}
格式.class的名称{}好处是同一个class可以复用
类选择器
全局唯一#id名{}
与类相同.换成#不可以复用id只能有一个且不可以以数字开头
不遵循就近原则，固定的
id选择器
id选择器>class选择器>标签选择器
三种基本选择器
在某个元素后面 祖爷爷 爷爷 爸爸 你
body p{}
子孙后代都改变
后代选择器
body>p{}
只有后面的第一代才有
子选择器
.类名 +标签{}
只有下面的一个会变
相邻兄弟选择器
.类名~标签名{}
选择元素下面所有兄弟元素
通用选择器
层次选择器
伪类 ：
结构伪类选择器
属性选择器
高级选择器
选择器
CSS
解释性脚本语言，是一种动态类型、弱类型、基于原型继承的语言，内置支持类型
解释器成为JavaScript引擎，作为浏览器的一部分
用来给HTML网页增加动态功能，定义网页的行为
ECMAScript语法
文档对象模型（DOM）
游览器对象模型（BOM）
组成
可以在网页任何地方编写
在<script>标签中编写
需要使用<script src=\"\"></script>关联
在外部JS文件中编写
<button onclick=\"\">按钮</button>
在事件属性中编写
使用方式
JS中变量都用var关键字来声明，var是variable的缩写
var是声明关键字，num是变量名，语句以分号结尾；分号可以省略（建议不要省略）
包含字母、数字、下划线和美元符号
不能以数字开头
变量名不能是关键字
命名规范
变量
Number、String、Boolean、Undefined、Null五种
使用typeof运算符检测一个变量的类型
使用方式：typeof(表达式)或typeof变量名
基本类型
object表示任何对象
var person = {\"name\":\"张三\
使用JSON表示法创建对象
对象类型
和java数组概念一直，而在JavaScript中使用Array类型
var arr =[\"a\
注意创建数组时可以不用指定长度
使用JSON表示法创建数组
数组类型
引用类型
数据类型
与java一样
==比较的是指与数据类型无关
===要求数据类型一样，值也一样
==与===的区别
运算符
概念：封装特定任务功能的 代码块
定义：JavaScript函数通过function关键词进行定义
调用：当事件发生时调用或者通过代码调用、自调用
只能点击确定按钮的弹窗
值为undefined类型
alert()
可以点击确定或者取消的弹窗
确定值为true，取消值为false
confirm()
可以输入文本内容的弹窗
第一个参数是提示信息，第二个参数是用户输入的默认值
点击确定返回用户输入内容，点击取消或者关闭，返回null、
prompt()
弹窗函数
解析一个字符串并返回一个整数
parseint()
解析一个字符串并返回一个浮点数
parseFloat()
检查某个值是否为数字，是返回false，不是返回true
isnan()
系统函数
函数
HTML元素内容改变
onchange
用户点击HTML元素
onclick
用户将鼠标移入一个HTML元素中
onmouseover
用户在一个HTML元素上移动鼠标
onmousemove
用户从一个HTML元素上移开鼠标
onmouseout
按下键盘弹起
onkeyup
按下键盘
onkeydown
浏览器已完成页面的加载
onload
表单提交
onsubmit
常用事件
概念：正则表达式是描述字符模式的对象
用于对字符串模式匹配及检索替换
是对字符串执行模式匹配的强大工具
作用
var patt =/pattern/modifiers
i：执行对大小写不敏感的匹配
g：执行全局匹配（查找所有匹配而非在找到第一个匹配后停止）
m：执行多行匹配
修饰符
[abc]：查找方括号之间的任何字符
[^abc]查找任何不在方括号之间的内容
[0-9]查找任何从0-9的数字
[a-z][A-Z][A-z]同上
（x|y|z）查找x或y或z
字符
.查找单个字符，出了换行和行结束符
\\w查找单词字符
\\W查找非单词字符
\\d查找数字
\\D查找非数字
\\s查找空白字符
\\S查找非空白字符
元字符
用于表示重复次数的含义
n+匹配任何包含至少一个n的字符串
n*匹配任何包含零个或多个n的字符串
n？匹配任何零个或一个n的字符串
n{x}匹配包含x个n的序列的的字符串
n{x，y}x和y为正整数，前面的n连续出现至少x次，至多y次匹配
量词
complie：编译正则表达式
exec：检索字符串中指定的值，返回找到的值，并确定其位置
test：检索字符串中指定的值，返回true与false
refexp对象方法
search：检索与正则表达式相匹配的值
match：找到一个或多个正则表达式的匹配
replace：替换与正则表达式匹配的子串
split：把字符串分割为字符串数组
String对象方法
正则表达式
通过HTML DOM，可访问JavaScriptHTML文档的所有元素
当网页被加载时，游览器会创建页面的文档对象模型（DOM）
getelementbyid：通过id找到html元素
getelementbytagname：通过签名找到HTML元素
getelementsbyclassname：通过类名找到HTML元素
查找HTML元素
document.write():可用于直接向HTML输出流写内容
innerHTML属性：获取或设置HTML内容，HTML标签会被解析
innertext：获取或设置HTML内容，HTML标签会作为普通文本
修改HTML内容
对象.attribute：获取或设置dom对象的属性
使用方法：getAttribute(\"att\
修改html属性
getcomputedstyle（）
currentstyle
获取
实例
对象.style.property=新样式
将property替换成真实的属性名
设置
改变css
通过dom对象设置事件属性
语法：dom对象.onxxx=function(){...}
设置DOM事件
addEventListener:向指定元素添加事件，不会覆盖已存在的事件
event：事件类型
function：事件触发后调用的函数
usecapture：用于描述事件是冒泡还是捕获，默认false冒泡、true捕获
removeEventListener：移除事件
EventListener
document.createElement(\"标签\");
追加appendchild()
添加：insertbefore()
新建元素
删除子元素：removechild()
删除元素：remove()
删除元素
新建、删除元素
DOM
游览器对象模型（BOM）使JavaScript有能力与游览器对话
现代游览器实现了和JavaScript交互性方面的相同方法和属性，因此常被认为是BOM的方法和属性
所有游览器都支持window对象，它表示游览器窗口
JavaScript全局对象、函数以及变量均自动成为window对象的成员
window.innerheight:内部高度，包括滚动条
window.innerwidth：内部宽度，包括滚动条
属性
open():打开新的窗口
close():关闭窗口
window对象
表示当前屏幕对象
screen.availwidth：可用的屏幕宽度
screen.availheight：可用的屏幕高度
screen对象
location对象用于获得当前页面的地址(URL)，并把游览器重新定向到新的页面
location.href:返回当前页面的URL
location.hostname:返回web主机的域名
location.protocol:返回所使用的web协议
location.port:返回web主机的端口
reload()重新加载页面
location对象
包含用户在游览器窗口中访问过得URL
length：返回浏览器历史列表中的URL数量
back()加载histor列表中的前一个URL
forwa():加载history列表中的下一个URL
go()加载history列表中的某个具体页面
history对象
navigator对象包含有关游览器的信息
appname：返回游览器的名称
appversion：返回游览器的代码名
platform：返回运行游览器的操作系统平台
useragent：有客户机发送服务器的user-agent头部的值
navigator对象
setinterval每间隔固定毫秒值就执行一次函数
settimeout在固定时间之后执行一次调用函数
clearinterval（定时器id）清楚定时执行
cleartimeout（定时器id）清除延时执行
定时器函数
JavaScript定时器
BOM
JavaScript
前端web基础
具有独特的链式语法
支持高效灵活的css选择器
用用丰富的插件
兼容各种主流游览器
引言
$(function(){})
$(匿名函数)表示页面dom加载完毕则执行，比onload事件执行早，并且可以写多个，$是jQuery函数的简写
选择符(select)表示查找html元素
jQuery的action()执行对元素的操作
$(selector).action()通过选取HTML元素并对选取的元素执行某些操作
$(this).hide():隐藏当前元素
$(\"p\").hide()隐藏所有<p>元素
$(\"p.test\").hide()隐藏所有class=test的<p>元素
$(\"#test\").hide()隐藏所有id为test的元素
基本实例
jQuery元素选择器基于元素名称选取元素
$(\"元素名称例如p，button等等\")
元素选择器
jQuery#id 选择器通过选择HTML元素的id属性选取指定的元素
页面中元素的id应该是唯一的，所以你要在页面中选取唯一的元素需要通过#id选择器
$(\"#id\").事件
jQuery类选择器可以通过指定的class查找元素
$(\".类名\")
class选择器
jQuery选择器
页面对不同访问者的响应
什么是事件
事件处理程序指的是当html中发生某些事情时所调用的方法
比如在元素上移动鼠标，点击的
click
dblclick双击事件
mouseenter鼠标进入
mouseleave鼠标离开
鼠标事件
keypress按下的过程触发只会触发字符键
keydown被按下触发
keyup被松开触发
键盘事件
submit提交触发
change元素变动触发
focus聚焦
blur失焦
表单事件
load页面加载完成事件
resize调整窗口大小事件
scroll元素滚动条滚动触发时间
unload离开页面触发
文档/窗口事件
常见dom事件
事件以及常用事件方法
jQuery
Ajax
layUI
bootstrap
前端web进阶
软件的半成品，解决的软件开发过程当中得普适性问题，从而简化的开发步骤，提供了开发的效率
什么是框架
ORM对象关系映射，将程序中的一个对象与表中的一行数据一一对应
ORM框架提供了持久化类与表的映射关系，在运行时参照映射文件的信息，把对象持久化到数据库中
什么是ORM框架
存在大量冗余代码
手工创建connection、statement等
手工将结果集封装成实体对象
查询效率低，没有对数据访问进行过优化
使用JDBC完成ORM操作的缺点
框架概念
MyBatis是一个优秀的基于java持久层的框架(持久层类似于dao层)支持自定义SQL，存储过程和高级映射
MyBatis对原有JDBC操作进行了封装，几乎消除了所有JDBC代码，使开发者只需关注SQL本身
MyBatis可以使用简单的xml或annotation来配置执行SQL并自动完成orm操作将执行结果返回
mybatis框架
工具与框架
&运算符，直接比较两边的2进制数值，两边为一就为一，否则为0
|异或运算符，两个都是相同的值的时候结果为0，不同的时候结果为1
|或运算符，至少一边为1就为1，两边为0才为0
<<左位移，二进制上的数全部往左一两位，多的舍弃
>>右位移，二进制上的数全部往右一两位，多的舍弃
&与运算符，|或运算符，^异或运算符，<<左位移，>>右位移
直接操作01的运算符
对扩展开放，对修改关闭
开闭原则
线表需要开辟连续空间，查询快，增删慢
线性是有序的存储，但是分配空间一样的，会有很多碎片空间
链表无需开辟连续空间，查询慢，但是增删快
链表则是利用复用有限的碎片空间进行存储
线性数组存储与链表存储的区别
在类里重写用this
判断地址相同
instanceof判断类型是否是对象类型
进行强转
开始判断规则
equals重写
显而易见灵感来自于笔记本电脑一类的适配器
在软件开发中采用类似于电源适配器的设计和编码技巧被称为适配器模式
通常情况下，客户端可以通过目标类的接口访问它所提供的的服务，有时候现有的类可以满足客户类的需要，但是它所提供的接口不一定是客户类所期望的，这可能是因为现有类中方法名和目标类中定义的方法名不一致等原因所导致的
在这种情况下，现有的接口需要转化为客户类期望的接口，这样保证了对现有类的重用如果不进行这样的转化，客户类就不能利用现有类所提供的功能，适配器模式可以完成这样的转化
n接口在适配器模式中可以定义一个包装类，包装不兼容接口的对象，这个包装类值得就是适配器，他所包装的对象就是适配者，即被适配的类n适配器提供客户类需要的接口，适配器的实现就是把客户类的请求转化为对适配者的相应接口的调用，也就是说：当客户类调用适配器的方法时，客户类并不直接访问适配者类，因此，适配器可以使由于接口不兼容而不能交互的类可以一起工作，这就是其模式动机
模式动机
适配器模式：将一个接口转换成客户希望的另一个接口，适配器模式，使接口不兼容的那些类可以一起工作，其别名为包装器，适配器模式可以作为类结构模式，也可以作位对象结构模式
模式定义
适配器模式
优先适配器模式
代理模式
建造者模式
模式
两表关联时，外键一定在多的一方要用那个表的数据，那个表的外键一定在使用的哪一方
课外补充
JDK工具包下载，Oracle官网
只可以写在源文件的第一行
package 包名;
-d 表示是带包翻译，.表示在当前文件夹
自动生成目录结构
带包编译 javac -d . 源文件名称.java
包名.类名又称为全限定名
带包运行java 包名.类名
带包编译只可以带包运行
packa包
层级之间必须缩进（一个tab制表位）
一行只写一句代码
书写格式
单行注释//通常都是解释下面的代码
多行注释/**/字数太多的话单行注释不够用的话就用多行
javadoc -d . 源文件名.java生成外部文档
文档注释/** */类类属性类方法的注释必须使用
注释规范
标识符就是类名，名字等等
可以用数字，字母，_，$组成，但是不可以以下划线开头
不可以与关键字，保留字重名
标识符命名
望文生义，见名知意
类名由一个或多个单词组成，每个字母的首字母都要大写
函数名由一个或多个单词组成，首单词小写，拼接词首字母大写
包名全小写，以.连接
约定俗成
编码规范
概述环境与搭建
计算机内存中的一块储存空间，是储存数据的基本单位
变量名
值
组成部分
数据类型 变量名；变量名 = 值；
先声明在赋值
声明并赋值
同时声明赋值多个同类型变量
声明方式
1字节
-2^7~2^7-1
byte
2字节
-2^15~2^15-1
short
4字节
-2^31~2^31-1
默认是int类型
int
8字节
-2^63~2^63-1
long
整数
float
默认是double类型
double
浮点数
true
false
boolean
布尔
\\\\
\\'
\\\"
\\t
转义字符\\
char
基本数据类型
字符串
数组
对象
引用数据类型
两种类型兼容且目标类型大于源类型
自动类型转换
两种类型兼容且目标类型小于源类型
整数长度足够，数据完整
整数长度不够，数据截断
小数强转整数，小数部分截断
保证正整数转换成字符可以正常显示
字符整数互转，数据完整
boolean类型不可以与其他类型转换
转换规则
类型的转换
+，-，*，/，%
算数预算符
=，+=，-=，*=，/=，%=
赋值运算符
关系运算符
&&注意，如果&&前面的表达式结果为false，则后面的表达式不会运行
||注意，如果||前面的表达式为true，贼后面的表达式不运行
即后面运行的话，自增i++，++i，等等这些都不会生效
&&，||，！
逻辑运算符
布尔表达式结果为真时取结果1，反之结果2
一个公式（算式）得出的结果为true或false
布尔表达式？结果1：结果2
布尔运算符
字面值就是没有任何变量接受，直接写出的值
使用运算符连接的变量或字面值，并可以的到一个最终结果。
表达式
两个操作数有一个为double，计算结果提升为double；
如果操作数中没有double，有一个为float，其计算结果提升为float；
如果操作数中没有float，有一个为long，其计算结果提升为long；
如果操作数中没有long，有一个为int，其计算结果自动提升为int；
如果操作数中没有int，均为short或byte，计算结果仍提升为int；
算数运算时
任何类型与String相加（+）时，实为拼接，其结果自动提升为String
特殊情况
自动类型提升
程序运行中，可在控制台（终端）手动录入数据，再让程序继续运行
import 包名.类名;//将外部class文件功能引入到自身文件中
导包语法
1.导入java.util.Scanner。\timport java.util.Scanner; inport 关键字的声明，写在package之后
2.声明一个Scanner类型的变量 Scanner 变量名 = new Scanner(System.in);
使用Scanner类中对应得函数（区分类型）：
使用顺序
.nextInt();获得整数
.nextDouble();获得浮点数
.next();获得字符串
.next().charAt(0);获得输入的首个字符
使用Scanner类中对应的函数（区分类）
控制台输入
语言基础
规定的什么就能用什么，没有规定的绝对不能用
Java语言规范
规定怎么用就支持怎么用，没有规定的随便用，支持自我创造
Java虚拟机规范
语法层面
概念：根据已知条件进行落尽判断，满意条件后执行相应的操作
判断布尔表达式为真则执行代码1，然后跳出整个结构再执行后续代码
当你需要判断，并且只会执行一个选择的时候
if（布尔表达式）{ 代码块1}后续代码
if选择结构
注意，代码1和代码2一定会执行一个
当你需要判断，并且只会执行选择是二选一的时候
if（布尔表达式1）{ 代码块1 }else{ 代码块2}后续代码
if else选择结构
判断布尔表达式1为真时执行代码块1，在跳出整个结构执行后续代码反之判断布尔表达式2以此类推
注意相互排斥，当有一个条件为true时，其他均不再执行，使用与区间判断（区间条件，遵循从大到小或从小到大）
当你需要判断，发现会有多个判断条件存在的时候，适用于多个区间判断的时候
if（布尔表达式1）{ 代码块1 }else if（布尔表达式2）{ 代码块2}else if（布尔表达式3）{ 代码块3}等等、
多重if选择结构
可判断的byte，short，int，char，String（JDK7+）
switch中case的取值不可以相同
switch有自动向下贯穿的特性，如需要在加载某个选项后终止，需要追加break关键字
switch分支结构
概念：函数内部的变量必须先赋值才可以使用
作用范围：从定义的所在行开始到代码块结束
注意：如果是多个变量在重合的作用范围内不可以出现变量的重名
局部变量
嵌套if
选择与分支结构
概念：通过某个条件，重复的执行一段逻辑代码
语法：while（布尔表达式）{ 逻辑代码（循环操作）}
执行流程：1.先对布尔表达式进行判断，结果为true，则执行逻辑代码。 2.本次执行完毕后，再次进行判断，结果仍旧为true，则再次执行逻辑代码 3.直至布尔表达式的结果为false时，才会退出循环结构，执行后续代码
循环的组成：1.初始部分：用以判断的变量 2.循环条件：决定是否继续循环的依据 3.循环操作：单次执行的逻辑代码或任务 4.迭代部分：控制循环条件改变的增量
约定俗成：一般定义变量都用i
特点：首次既有入口条件，先判断再执行，适用于循环次数明确的情况
while循环
语法：do{逻辑代码（循环操作）}while（布尔表达式）
执行流程：先执行一次循环操作之后，在进行布尔表达式判断 如果结果为true，则再次执行循环操作 如果结果为false，才会退出循环结构执行后续代码
特点：首次没有入口条件，先执行在判断，判断满足在循环，不满足则至少循环1次，适用于循环次数不明确的情况
do while循环
其中初始部分，循环条件，迭代部分都可以省略，会默认为true
语法： for(初始部分 ；循环条件； 迭代部分){循环操作}
执行流程：1.首次执行初始部分（仅一次） 2.对布尔表达式进行判断，结果为true，则执行逻辑代码 3.本次执行完毕后，执行迭代部分，再次判断，结果仍为true则再次执行逻辑代码 4.直至布尔表达式的结果为false时，才会退出循环结构，执行后续代码
for循环与while循环相同，首次判断不满足则一次都不会执行，首次即有入口条件，先判断再执行，适用于循环次数明确的情况下
for循环
break：终止，跳出switch，循环结构
continue：结束本次、进入下一次循环
流程控制
概念：在一个完整的循环当中，嵌套另一个完整的循环
经验：打印图形，外层控制行数，内层控制列数 打印其他：外层控制循环次数，内层控制单次循环操作
嵌套循环
循环
概念：实现特定功能的一段代码，可反复使用
定义的位置：定义在类的内部，与main函数并列。多数情况下，定义在main函数的下面
定义：public static void 函数名称（）{ 函数的主题 }
调用：函数名（）；
执行顺序：函数调用时，优先执行函数内部代码，结束后返回到函数的调用处，然后继续向下执行
定义返回值类型：基本数据类型，引用数据类型，void
return value；//函数可以返回一个结果，类型必须与函数定义的返回值类型一致
一个函数只能由一个返回值，如果函数中包含分支，需要保证所有的分支都有正确的返回值
return value；//表示结束当前函数，并伴有返回值，返回函数调用处（有具体的返回值类型）
return；//表示结束当前函数，直接返回函数调用处（返回值类型是void）
return的两种用法
注意：一个类中可以定义多个函数，函数之间属于并列关系，不可嵌套
经验：一个函数只做一件事
好处减少代码冗余，提高复用性，可读性，可维护性，方便分工合作
总结：
返回值与返回值类型
实际再发中，递归可以解决一些具有既定规律的问题
当需要解决的问题可以拆分成若干个小问题，大问题、小问题的解决方法相同，有特点的规律，函数自己调用自己
设置有效的出口条件，避免无穷递归
递归
定义语法：public static void 函数名称（形式参数）{ 函数主体 }
就是函数内部的局部变量，等价于局部变量的声明
形参
调用的时候：函数名称（实际参数）
实参等价于局部变量内给形式参数的赋值赋值
实参
调用带参函数时，依次传入实参，类型，个数，顺序，必须与形参对应
== 比较的是地址，比较字符串时，==不够准确，应该采用 字符串1.equals(字符串2) 来准确的比较字符串内容，当比较两个字符串不相同是可以使用！字符串1.equals（字符串2）来比较
补充
参数定义：形式参数 实参
参数：多数情况下，函数与调用者之间需要数据的交互；调用者必须提供必要的数据，才能使函数完成相应的功能 调用函数时，所传入的数据被称为参数
参数
数组中每个数据格被称为数组元素
对每个元素进行赋值或取值的操作被称为元素的访问
访问元素时，需要使用下标，（从0开始，依次＋1，自动生成）
访问的语法：数组名【下标】；//例如 存：a[0] = 10;取:a[0];
概念：一组连续的存储空间，存储多个相同数据类型的值
所有整数数组的默认值都是0，但是随着整数类型不同，默认值0的类型也不同
浮点数0.0
字符 空格
布尔 false
所有引用类型都是 null，表示没有在堆中打开空间，代表引用类型为空
数组的遍历
创建数组时，必须显示指定长度，创建之后不可以更改长度
创建长度大于原数组的新数组
将原数组中的数据依次复制到新数组当中
扩容的思路
循环将原数组的所有元素数据逐一赋值给新数组
System.arraycopu(原数组，原数组起始位置，新数组，新数组起始位置，长度)
数组类型的变量 = java.util.Arrays.copyOf(原数组，新长度)；//根据长度创建新数组，并将原数组中的数据赋值给新数组
数组的复制
数组的扩容
基本数据储存的是值
基本数据类型的变量储存的是值
引用数据类型的变量储存的是地址
num = newNum 将新数组的地址赋值给num变量，进而在后续操作num时，则操作更大的新数组
地址的替换
引用数据类型储存的是地址
基本数据类型和引用数据类型的区别
基本数据类型是值的传递，一方改变，不会影响另一方
引用数据类型的传递，是地址的传递，一方改变会影响另一方
数组类型的参数
概念：可以接受多个同类型的实参，个数不限，使用方式与数组相同
语法：数据类型... 形参名//必须定义在参数列表的最后，且只能有一个，支持0~n的参数
可边长参数，是对数组的一种便利写法的补充
可变长参数
比较相邻的两个值大小，互换位置
记忆，外层length-1；内层length-1-i
补充：嵌套循环约定俗称的变量命名，一重循环i，二重循环j，三重循环k
冒泡排序
固定值与其他值依次的的比较大小，互换位置
记忆，外层length-1；同时外层的i做为固定值；内层的j=i+1作为其他值的起始
选择排序
java.util.Arrays.sort(原数组);固定是升序
JDK排序
for(int i = 1; i<a.length;i++){ if(a[i]<a[i-1]){//如果本来有序就跳过 int temp = a[i]; int j; for(int j = i-1;temp<a[j];j++){ a[j+1]=a[j] } a[j+1] =temp; }}
优化版
for(int i = 1; i <a.length;i++){ int temp = a[i];暂存要插入的数据 int j ；声明j，方便 后续使用 for(j = i-1; j >=0;j--){ if(temp<a[j]){ a[j+1] = a[j];}else{ break;如果值小于temp，则终止循环}} a[j+1]=temp;}
插入排序
冒泡排序效率最低，选择效率第二低，插入排序效率最高
char和string类型的数组也可以排序，一个根据ASCII码来排序，一个根据万国码来排序
排序
概念：一维数组中的一维数组，数组中的元素还是数组
高位数组中的每一个元素保存了低维数组的地址，访问高位数组等于访问低维数组的地址
访问元素的方式：数组名[高维下标][低维下标]
创建语法：数组类型[][]数组名=new数据类型[高维下标][低维下标]
int [][] a = new int [line][];\t\tfor(int i =0;i<line;i++) {\t\t\ta[i] = new int[i+1];\t\t\tfor(int j =0 ;j<=i;j++) {\t\t\t\tif(j==0||j==i) {\t\t\t\t\ta[i][j] = 1;\t\t\t\t}else {\t\t\t\t\ta[i][j] =a[i-1][j-1]+a[i-1][j];\t\t\t\t}\t\t\t}\t\t}
杨辉三角
二维数组
自动遍历
for(数组类型 自定义名称：数组名){ System.out.println(自定义名称)}
将数组名里的值第一个赋值给自定义名称，然后输出，然后继续循环
如果需要修改其中数据的话，不要使用这个
只应用于数组或者集合
for each循环（增强for）
普通
二分查找法
现实世界中，都是对象，程序中也应有对象
首先，在程序当中，必须具有和现实中相同的对象，用于模拟现实世界
然后，使用程序的对象代表现实中的对象，并执行操作，进而解决现实问题
如何使用程序模拟现实世界解决现实问题
手机->工厂->图纸（模板）
现实中的对象从哪里来
汽车设计图纸规定了该款汽车所有的组成部分，包括外观形状、内部结构、发动机型号、安全参数等具体的信息。这即为现实对象的模板。程序中的模板也有相同的作用，称之为”类“
按照设计图纸创造出来的汽车，才是真实存在、切实可用的实体，所以汽车实体被称为现实中的对象。而通过程序中的模板创造出来的实体，即为程序中的对象，称之为”对象“
在一组相同或类似的对象中，抽取出共性的特征和行为，保留所关注的部分
类的抽取
方法：通过函数表示，又称实例方法
语法：public 返回值类型 方法名（形参）{//方法的主体}不在书写static
类的定义：
类：定义了对象应具有的特征和行为，类是对象的模板
对象：拥有多个特征和行为的实体，对象是类的实例
类与对象的关系
什么是类
1.堆内存中开辟对象空间
1.为各个属性赋予初始值
2.执行构造方法中的逻辑代码
2.构造方法执行
3.[ 将构造后对象的地址赋值给变量
对象类型 变量名 = new 对象名()
对象的创建过程
概念：类中的特殊方法，主要用于创建对象
名称与类名完全相同（包括大小写），没有返回值类型，即啥也不写
创建对象时（new 对象时），触发构造方法的调用，不可通过句点的形式手工调用
注意：如果没有在类中显示定义过构造方法，则编译器默认提供无参构造方法如果已经手动添加过有参的构造方法，则无参构造方法不在默认提供，可结合需求自行添加（建议：必须手动添加无参构造方法）
构造方法也可以重载，遵循方法重载规则
一般用于给属性赋值
构造方法
概念：尽可能隐藏对象的内部实现细节，控制对象的修改及访问的权限
以访问方法的形式进行赋值与取值的操作
里面可以添加限制非法参数的代码
get/set方法是外界访问对象私有属性的唯一通道，方法内部可对数据进行检测和过滤
命名规范 赋值：setXxx()//使用方法参数实现赋值取值：getXxx()//使用方法返回值实现取值方法名是get加首字母大写的属性名
公共的访问方法
封装
程序中的继承，是类与类之间特征和行为的一种赠与或获得
两个类之间的继承关系，必须满足\"is a\"的关系
功能越精细，重合点越多，越接近直接父类，反之越接近object类（万物皆对象）
可根据程序需要使用到的多个具体类，进行共性抽取进而定义父类 在一组相同或类似的类中，抽取出共性的特征和行为，定义在父类中实现重用
Java只有单继承，一个类只能由一个直接父亲，但可以多级继承，属性和方法逐级叠加
构造方法：类中的构造方法吗，只负责创建本类对象，不可继承
然是还是可以使用父类提供的set/get方法
private修饰的属性和方法
父子类不在同一个package中时，default修饰的属性和方法（什么都不写的就是默认访问修饰符default）
不可继承
继承特点
在具有继承关系的对象创建中，构建子类对象会先构建父类对象
由于父类的共性内容，叠加子类的都有内容组合成完整的子类对象
构建父类对象
初始化自身属性
执行构造方法中的逻辑代码
创建流程
对象创建，
父类的构造方法，用private修饰的属性和方法，其他包默认值修饰的都不可以被继承
继承
概念：父类引用指向子类对象，从而产生多种形态
二者之间具有直接或间接的继承关系时，父类引用可指向子类对象，即形成多态
父类引用仅可调用父类所声明的属性和方法，不可调用子类独有的属性和方法
实际运行过程中，依旧遵循覆盖原则，如果子类覆盖了父类中的方法，则执行子类中覆盖后的方法，否则执行父类中的方法
多态中的方法覆盖
调用方法时，可传递的实参类型包括：本类型对象+其所有的子类对象
场景一：使用父类作为方法形参，实现多态
调用方法后，可得到的结果类型包括：本类型对象+其所有的子类对象。
场景二：使用父类作为方法返回值实现多态，是方法可以返回不同子类对象
注意：仅可调用父类中所声明的属性和方法
父类引用中保存真实子类对象，称为向上转型（即多态核心概念）
向上转型（装箱）
将父类引用中的真实子类对象，强转回子类本身类型，称为向下转型
向下转型时，如果父类引用中的子类对象类型和目标类型不匹配，则会发生类型转换异常
向下转型前，应判断引用中对象的真实类型，保证类型转换的正确性
语法 父类引用 instanceof 类型//返回Boolean类型结果
instanceof
向下转型（拆箱）
使用方法
屏蔽子类间的差异
灵活，耦合度低
多态
你的类不想被实例，不想被new出来
你需要定义抽象方法的时候
你判断我们要做的业务功能或者说这个类后面开发会使用到抽象方法的时候
按生活中没有实际存在的时候，就可以考虑把他作为抽象类
应用场景，
抽象类
在抽象类中父类必须满足一个条件
当你发现这个方法不是大部分的子类都适用的时候
当你发现这个方法是所有子类都必须要完成的方法，即必须要重写实现的时候
应用场景
抽象方法
意思：抽象的，似是而非的，像却又不是，具备某种对象的特征，但不完整
即为抽象类不可以独立new对象
可以被子类继承对子类提供共性的属性和方法
可声明引用，更纯粹的使用多态
修饰类，意为不够完整，不够具体，不该独立存在
abstract:
抽象
三大特性()
不能设置类为私有类
private 本类
default本类，同包
也不可以使用受保护的类
protected 本类，同包，非同包子类
public 本类，同包，非同包子类，其他
实例属性是每个对象各自持有的独立空间（多份），对象单方面修改，不会影响其他对象
静态属性是整个类共同持有的共享空间（一份），任何对象修改都会影响其他对象
与实例的区别
static可以修饰属性和方法，即为静态属性（类属性）、静态方法（类方法）
静态成员是全类所有对象共享的，全类只有一份，不因创建多个对象而产生多份
不必创建对象，也可通过类名，直接访问静态成员
经验：访问静态属性和方法时，可直接通过”类名.静态属性名“以及”类名。静态方法名“（推荐）
静态方法允许直接访问静态成员
静态方法不能直接访问非静态成员
静态方法中不允许使用this或super关键字
静态方法可以继承，不能覆盖没有多态
jvm首次使用某个类时，将该类的.class文件加载到内存中进行保存
创建对象
创建子类对象
调用静态属性和方法
class.forName(\"全限定名\");//主动的加载一个类
加载时机
类加载
类加载时，触发静态代码块的执行（仅一次）
执行地位：静态属性初始化之后
作用：可为静态属性赋值，或必要的初始行为
静态代码块
static修饰的成员为静态成员，无需创建对象，可直接通过类名范围跟
静态方法中不可以使用this和super
静态方法可以继承、不能重写、没有多态
静态代码块在类加载时被执行，且只执行一次
总结
static（静态）
修饰类：此类不可以被继承
修饰方法：此方法不能被覆盖
局部常量：显示初始化
实例常量赋值最终期限：在构造方法完成之前为实例常量赋值即可
如果在构造方法中为实例常量赋值，必须保证所有的构造方法都可正确赋值
实例常量的赋值：显式初始化，动态代码块、构造方法
修饰变量：此变量不可改变即常量（无初始值、只允许赋值依次）
基本数据类常量：值不可变
引用数据类型常量：地址不可变
不同常量类型的特点
final
访问修饰符
程序是为了模拟现实世界。解决现实问题而使用计算机语言编写的一系列有序的指令
面向对象思想：世界是由无数个对象组成的。
初期：看得见摸得着真实存在
对象是什么：一切客观存在的事物都是对象，万物皆对象
特征：称之为属性一般为名词，代表对象都有什么
行为：称之为方法，一般为动词，代表对象能做什么
颜色品牌价格型号重量尺寸材质
分析一个对象有什么（属性）
打电话（拨号->发射）拍照上网（app聊天、游戏）
分析一个对象能做什么（方法）
比如手机
任何对象一定有自己的特征和行为
面向对象（oop）
接口的定义：代表了某种能力
方法的定义：能力的具体要求
接口是一种能力和约定
接口支持多实现、可为类扩充多种能力
Java为单继承，当父类的方法种类无法满足子类需求时可实现接口扩充子类能力
经验
微观概念
接口是一种标准
耦合度：模块与模块之间的关联程度，关联的越密切，耦合度越高，关联的越松散，耦合越低
宏观概念
概念：接口相当于特殊的抽象类，定义方式、组成部分与抽象类类似。使用interface关键字定义接口。
没有构造方法，不可以创建对象
只能定义：公开静态常量、公开抽象方法
可编译成字节码文件
不能创建对象
可以作为引用类型
具备object类中所定义的方法
相同点
所有属性都是公开静态常量、隐式使用pubic static final修饰
所有方法都是公开抽象方法、隐式使用public abstract
没有构造方法、动态代码块、静态代码块
不同点
与抽象类的区别
任何类在实现接口时，必须实现接口中所有的抽象方法，否则此类为抽象类
实现接口中的抽象方法时，访问修饰符必须是public，具体原因参考方法重写
规范
同父类一样，接口也可以声明为引用，并指向实现类对象
仅可调用接口中所声明的方法，不可调用实现类中独有的方法
可强转回实现类的本身类型，进行独有的属性和方法的调用（强转前通过instanceof判断）
引用
与继承的多态不同，继承关注类型，接口则关注行为
类与类：单继承，extends 父类名称
类与接口：多实现，implements 接口名称1、接口名称2、。。。
接口与接口：多继承，extends 父接口名称1、父接口名称2、、、
常见关系
将多个常用于表示状态和固定值的变量，以公开静态常量的形式定义在接口中统一管理，提高代码的可读性
常量接口
先有接口的使用者，后有接口的实现者
接口回调原理
接口
Java程序存储数据(变量、对象、数组、集合)，数据保存在内存中，属于瞬时状态存储
文件(file)存储数据，保存在硬盘上，属于持久状态存储
现有的数据存储方式有哪些
没有数据类型的区分
存储数据量级较小
没有访问安全限制
没有备份、恢复机制
以上存储方式存在哪些缺点
数据库是\"按照数据结构来组织、存储和管理数据的仓库、是一个长期存储在计算机内的、有组织的、有共享的、统一管理的数据集合\"
网状结构数据库：美国通用电气公司IDS，以节点形式存储和访问
层次结构数据库：IBM公司IMS定向有序的树状结构实现存储和访问
关系结构数据库：Oracle、DB2、MySQL、SQL Server，以表格存储，多表间建立关联方式，通过分类、合并、连接、选取等运算实现访问
非关系型数据库：ElastecSearch、MongoDB、Redis，多数使用哈希表，表中以键值对的方式实现特定的键和一个指针指向的特定数据
数据库的分类
数据库
数据库管理系统(DBMS):指一种操作和管理数据库的大型软件，用于建立、使用和维护数据库，对数据库进行统一管理和控制，以保证数据库的安全性和完整性。用户通过数据库管理系统访问数据库中的数据
Oracle：被认为是业界目前比较成功的关系型数据库管理系统。Oracle数据库可以运行在Unix、Windows等主流操作系统平台，完全支持所有的工业标准，并获得最高级别的ISO标准安全性认证
DB2：IBM公司的产品，DB2数据库系统采用多线程多线索体系结构，其功能足以满足大中公司的需要，并可灵活的服务于中小型电子商务解决方案
SQL Server：Microsoft公司推出的关系型数据库管理系统，具有使用方便可伸缩性好与相关软件集成程度高等优点
SQLLITE：应用在手机端的数据库
常见数据库管理系统
数据库管理系统
数据库基本概念
简介：MySQL是一个关系型数据库管理系统，由瑞典MySQL AB公司开发，属于Oracle旗下产品MySQL是最流行的关系型数据库管理系统之一，在web应用方面，MySQL是最好的RDBMS(关系数据库管理系统)应用软件之一
官网：http://www.mysql.com/下载地址：http://www.mysql.com/downloads/mysql/
概念：SQL结构化查询语言，用于存取数据、更新、查询和管理关系数据库系统的程序设计语言
经验：通常执行对数据库的增删改查，简称C(Create)R(Read)U(Update)D(Delete)
对于数据库的操作，需要在进入MySQL环境下进行指令输入，并在一句指令的末尾使用；结束
MySQL应用
mysql>SHOW DATABASES;显示当前MySQL中包含的所有数据库
information_schema:信息数据库其中保存着关于所有数据库的信息(元数据)元数据是关于数据的数据，如数据库名或表明，列的数据类型、或访问权限等
mysql：核心数据库，主要负责存储数据库的用户、权限设置、关键字等，以及需要使用的控制和管理信息，不可以删除
performance_schema：性能优化的数据库，MySQL5.5版本中新增的一个性能优化的引擎
sys：系统数据库，MySQL5.7版本中新增的可以快速了解元数据信息的系统库便于发现数据库的多样信息，解决性能瓶颈问题
数据库名称
基本命令
Navicate是一套快速、可靠并价格相宜的数据库管理工具，专为简化数据库的管理及降低系统管理成本而设他的设计符合数据库管理员、开发人员及中小企业的需要、Navicate是以直觉化的图形用户界面而建的，让你可以以安全并且简单的方式创建、组织、访问并共用信息
Navicate
MySQL可能是世界上最流行的开源数据库引擎，但是使用基于文本的工具和配置文件可能很难进行管理SQLyog提供了完整的图形界面，即使初学者也可以轻松使用MySQL的强大功能。其拥有广泛的预订义工具和查询、友好的视觉界面、类似Excel的查询结果编辑界面的等优点
SQLyog
客户端工具
select 列名from 表名where 条件group by 分组having 过滤条件order by 排序列(ASC|DESC)limit 起始行，总条数
SQL语句编写顺序
FROM:指定数据来源表where:对查询数据做第一次过滤group by 分组having 对分组后的数据进行第二次过滤select 查询各字段的值order by 排序limit 限定查询结果
SQL语句执行顺序
表中的一行数据代表一个实体，实体完整性的作用即是标识每一行数据不重复、实体唯一
primary key 唯一，标识表中的一行数据，此列的值不可重复，且不能为null
主键约束
unique 唯一，标示表中的一行数据，不可重复，可以为null
唯一约束
auto_increment 自动增长，给主键数值列添加自动增长，从1开始，每次加1，不能单独使用，必须和主键配合
自动增长列
实体完整性约束
限制列的单元格的数据正确性
not null 非空，此列必须有值
非空约束
default 值 为此列赋予默认值，当新增数据不指定值时，书写default，已制定的默认值进行填充
默认值约束
constraint 引用名 foreign key(列名) references 被引用表名(列名)foreign key引用外部表的某个列的值，新增数据时，约束此列的值必须时引用表中存在的数据
注意当两张表存在引用关系时，要执行删除操作，一定要先删除从表(引用表)，再删除主表(被引用表)
创建关系表时，一定要先创建主表，在创建从表
引用完整性约束
域完整性约束
约束
事务是一个原子操作，是一个最小执行单元，可以由一个或多个SQL语句组成，在同一个事务当中所有的SQL语句都成功执行时，整个事务成功，有一个SQL语句执行失败，整个事务都执行失败
开始：连接到数据库，执行一条dml语句，上一个事务结束后，以后输入了一条dml语句，即事务的开始
事务的边界
表示一个事务内的所有操作是一个整体，要么全部成功要么全部失败
atomicity(原子性)
表示一个事务内有一个操作失败时，所有更改过得数据都必须回到修改前状态
consistency(一致性)
事务查看数据操作时数据所处的状态，要么是另一并发事务修改它之前的状态，要么是另一事务修改它之后的状态，事务不会查看中间状态的数据
lsolation(隔离性)
持久性事务完成之后，他对系统的影响是永久性的
Durability(持久性)
事物的特性
事务
mysql>select database() 查看当前使用的数据库
查看当前所使用的数据库
数据查询语言DQL基本结构是由SELECT子句，FROM子句，WHERE子句组成的查询块： SELECT <字段名表> FROM <表或视图名> WHERE <查询条件>
关系结构数据库是以表格进行数据存储，表格有行和列组成
经验：执行查询语句返回的结果集是一张虚拟表
数据库表的基本结构
语法：SELECT列名 FROM表名
SELECT:指定要查询的列
FROM：指定要查询的表
关键字
生产环境下，优先使用列名查询
*的方式需转换成全列名，效率低，可读性差
运算符与java一样区别在于%是占位符并非模运算
列 AS '别名'
也可以AS换成空格
别名
distinct 列名
查询结果去重
基本理解
基本查询
语法SELCET 列名 FROM 表名 ORDER BY 排序列[排序规则]
asc：升序
desc：降序
排序规则
可以多列排序每个以逗号隔开，每个条件都有单独的排序规则
对查询的结果进行排序
排序查询
语法：SELECT 列名 FROM 表名 WHERE 条件
注意与java不同，mysql中等值判断使用=
区间判断(BETWEEN 小值 AND 大值)区间判断小值在前，大值在后，反之得不到正确结果
列名 is null
列名 is not null
null值判断
枚举查询 (in(值1，值2，值3))注意in 的查询效率较低，可以通过多条件拼接
列名 LIKE '_'单个任意字符
列名 LIKE '%'多个任意字符
注意：模糊查询只能和like关键字结合使用
模糊查询(LIKE 通配符)
语法：case when条件一 then结果一else 结果2end
通过使用case end进行条件判断，每条数据对应一个结果
类似java中的多重选择结构
分支结构查询
条件查询
sysdate：当前系统时间
curdate：获取当前日期
curtime：获取当前时间
week(date())：获取为一年中的第几周
year(date):获取年份
hour(time())获取小时
minute(time)获取分钟
语法select 时间函数(参数列表)
执行时间函数查询，会自动生成一张虚拟表(一行一列)
时间查询
lower转小写
upper转大写
select 字符串函数([参数列表])
执行字符串函数查询会自动生成一张虚拟表(一行一列)
字符串查询
sum():求所有行中单列结果的综合
avg():平均值
max()最大值
min()最小值
count():总行数
select 聚合函数(列名) from表名
会自动生成一张虚拟表
聚合函数
select 列名 from 表名 where 条件 group by 分组依据(列)
分组查询中，select显示的列只能是分组依据列，或者聚合函数列，不能出现其他列
分组查询
select 列名 from 表名 where 条件 group by 分组依据(列) having 过滤规则
having 是对分组之后的数据做过滤
分组过滤查询
select 列名 from 表名 limit 起始行，查询行数
起始行是从0开始，代表第一行，第二个参数代表的是从指定行开始查询几行
限定查询
重点：数据查询
select 列名 from 表名 where 条件(子查询结果)
一行一列的结果才能作为外部查询的等值判断或不等值条件判断
作为条件判断
select 列名 from 表名 where 列名 in(子查询结果)
将子查询多行一列的结果作为外部查询的枚举查询条件，做第二次查询
当子查询结果集形式为多行单列时可以使用any或all关键字
作为枚举查询条件
select 列名 from (子查询的结果集) where 条件
将子查询多行多列的结果作为外部查询的一张表作第二次查询
子查询作为临时表必须为其赋予一个临时表名
作为一张表
子查询
select *from t1 union select *from t2
合并两张表的结果(去除重复数据，有默认排序效率低)
select *from t1 union all select *from t2<br>
合并两张表的结果(保留重复记录，无默认排序效率高)
注意：合并结果的两张表，列数必须相同，列的数据类型可以不同
使用union合并结果集，会去除掉两张表中的重复的数据
合并查询(了解)
select 列名 from 表1 连接方式 表2 on 连接条件
sql标准select *from 表1 inner join 表2 on 条件
mysql标准select *from 表1 ，表2 where 条件
SQL标准其他数据库通用
内连接查询(inner join on)
多表连接查询：套娃
以左表为主表，依次向右匹配，匹配到，返回结果，反之以null值填充
左外连接(left join on)
以右表为主表，依次向左匹配，匹配到，返回结果，反之以null值填充
右外连接(right join on)
表连接查询
select，where，order by，group by，having
数据查询语言DQL
数据定义语言DDL用来创建数据库中的各种对象-----表、视图、索引、同义词、聚簇等如： CREATE TABLE/VIEW/INDEX/SYN/CLUSTER
数据定义语言，这些语句定义了不同的数据段、数据库、表、列、索引等数据库对象的定义。常用的语句关键字主要包括 create、drop、alter等
mysql>CREATE DATABASE mydb1:创建mydb数据库
mysql>CREATE DATABASE mydb2 CHARACTER SET gbk：创建数据库并设置编码格式为gbk
mysql>CREATE DATABASE IF NOT EXISTS mydb4：如果mydb4数据库不存在，则创建，反之则不创建
创建自定义数据库
mysql> SHOW CREATE DATABASE mydb2：查看创建数据库时的基本信息
查询数据库创建信息
mysql支持多种类型，大致分为三类：数值，日期时间和字符串字符类型，对于我们约束数据有很大帮主
数值类型:int ，double，decimal
日期类型:date(yyyy-mm-dd) time(hh:mm:ss) year(yyyy)datetime(yyyy-mm-dd hh:mm:ss) timestamp(yyyymmddhhmmss)
字符串类型:char(定长字符串)varchar(变长字符串)blob(二进制长文本数据，图片等等)text(长文本数据)
char与varchar类型类似，但他们保存和检索的方式不同，他们最大长度和是否尾部空格被保留等方面也不同在存储或检索过程中不进行大小写转换
bolo是一个二进制大对象，可以容纳可变数量的数据有四种类型tinyblob，blob，mediumblob，longblob，只是容纳长度不同
create table表名(列名 数据类型 [约束])[charset utf8]
注意最后一列末尾不加都好，可以根据需要指定表的字符编码集
数据表的创建(create)
add增加
modify修改修改表中的某列时，也要些全列的名字，数据类型，约束
drop删除删除列时，每次只能删除一列
change修改列名修改列名时，再给定新列名称时，要指定列的类型和约束
rename修改表名
alter table 表名 操作
数据表的修改(ALTER)
drop table 表名
数据表的删除(drop)
数据表操作
数据定义语言DDL
数据操纵语句，用于添加、删除、更新和查询数据库记录，并检查数据完整性，常用的语句关键字主要包括 insert、delete、udpate 和select 等。(增添改查）
数据操纵语言DML主要有三种形式： 1) 插入：INSERT 2) 更新：UPDATE 3) 删除：DELETE主要对数据库数据进行写入和读取
DML：数据操作语言
对数据表的增，删，改操作
insert into 表名(列1，列2，列3...) values(值1，值2，值3...)
插入
update 表名 set 列1 =新值1....where条件
set后多个列名=值
绝大多数情况下都要加where条件指定修改，否则为整表更新
更新
delete from 表名 where条件
删除时，如不加where删除的是整张表的数据
删除
数据操纵语言DML
commit rollback提交与回滚
事务处理语言TPL
crant ，revork 授权与取消
数据控制语言DCL用来授予或回收访问数据库的某种特权，并控制数据库操纵事务发生的时间及效果，对数据库实行监视等。如： 1) GRANT：授权。2) ROLLBACK [WORK] TO [SAVEPOINT]：回退到某一点。回滚---ROLLBACK 回滚命令使数据库状态回到上次最后提交的状态。其格式为：SQL>ROLLBACK
数据控制语言DCL
SQL语言分类
SQL语言
视图即虚拟表，从一个表或多个表中查询出来的表，作用和真实表一样
作用和真实表一样，包含一系列带有行和列的数据
视图中，用户可以使用select语句查询数据，也可以使用dml操作记录
视图可以使用户操作方便，并保障数据库安全
简单化，数据所见即所得
安全性，用户只能查询或修改他们所能见得到的数据
优点
性能相对较差，简单的查询也会变得稍显复杂
修改不方便，特别是复杂的聚合视图基本无法修改
与存储过程一样移植性较差
缺点
优缺点
create view 视图名 AS 查询数据源表语句
创建视图
alter view 视图名 as 修改后的查询语句
create view 视图名 AS 查询数据源表语句如果视图存在则替换，反之新建
修改
drop view 视图名
注意：视图的删除不会影响原表
视图不会独立存储数据，原表发生改变，视图也会发生改变
没有优化任何查询性能
如果视图包含以下结构中的一种，则视图不可更新
聚合函数，distinct去重后的结果，group by分组后的结果having 筛选过滤后的结果 union，union all 联合后的结果
注意事项
视图
mysql 5.0版本开始支持存储过程
存储过程是一种在数据库中存储复杂程序，以便外部程序调用的一种数据库对象
他是为了完成特定功能的SQL语句集，经编译创建并保存在数据库中，用户可通过指定存储过程的名字并给定参数(需要时)来调用执行
存储过程思想上较为简单，就是数据库SQL语言层面的代码封装与重用
什么是存储过程
存储过程就是具有名字的一段代码，用来完成一个特定的功能
创建的存储过程保存在数据库的数据字典中
存储过程的创建与调用
存储过程体包含了在过程调用时必须执行的语句，例如dml，ddl语句if-then-else和while-do语句、声明变量的declare语句等
过程体格式：以begin开始，以end结束(可嵌套)
其中每个嵌套块及其中的每条语句，必须以分号结束，表示过程体结束的begin-end块又叫符合语句compound statement，则不需要分号
存储过程体
DELIMITER:定义结束符号
CREATE PROCEDURE:声明存储过程与名字类似java的方法声明
begin开始符号类似java方法的{
DECLATE 声明变量
SET 给变量设置
end结束符号类型java方法的}
调用存储过程需要使用call关键字
关键字解析
基本使用语法示例
声明语句结束符可以使用delimiter来自定义
使用create procedure 存储过程名()来声明
结束符：默认情况下mysql的命令是以分号结束的，当在遇到mysql时，就会执行命令mysql中的delimiter会告诉mysql解释器，命令的结束符是什么，然后mysql解释器，当碰到delimiter指定的结束符才会开始执行命令因为存储过程中会使用大量sql可能会有很多分号结束符，不能让mysql在中间就执行sql，所以才需要自定义结束符
关键语法
存储过程可封装，并隐藏复杂的商业逻辑
存储过程可以回传值，并可以接受参数
存储过程无法使用select指令来运行，因为他是子程序，与查看表，数据表或用户定义函数不同
存储过程可以用在数据检验，强行实行商业逻辑等。
存储过程往往定制化与特定的数据库上，因为支持的编程语言不同，当切换到其他厂商的数据库系统时，需要重写原有的存储过程，移植性较差
存储过程的性能调校与撰写，受限于各种数据库系统
变量定义：局部变量声明一定要放在存储过程体的开始
通过declare 变量名 数据类型声明变量通过set来给变量赋值
作用范围为存储过程的begin到end语句块之间
变量名需要使用@开头
可以直接使用set声明并赋值，默认值为null
跟mysql客户端是绑定的，设置的变量，只对当前用户使用的客户端生效也叫会话变量
作用范围为mysql客户端
用户变量
存储过程的变量
mysql存储过程的参数用在存储过程的定义，共有三种参数类型，in，out，inout，形式
存储过程名(in | out | inout ) 参数名 数据类型
in输入参数：表示调用者向过程传入值(传入值可以是字面量或变量)
out输出参数:表示过程向调用者传出值(可以返回多个值)(传出值只能是变量)
inout输入输出参数：即表示调用者向过程传入值，又表示过程向调用者传出值(值只能是变量)
mysql还不提供对已存在的存储过程的代码修改，只能先删然后重新创建
存储过程的参数
示例DELIMITER $$ CREATE PROCEDURE demo9(IN num DOUBLE) BEGIN DECLARE result VARCHAR(20); IF num > 10000 THEN SET result='有钱人'; ELSEIF num>5000 THEN SET result='一般人'; ELSESET result='穷人'; -- if结束一定要写end if 每个分支都有;结束 END IF; SELECT result; END $$ CALL demo9(8000);
if-then-else
等值判断示例DELIMITER $$ CREATE PROCEDURE demo10(IN num INT) BEGIN DECLARE result VARCHAR(20); CASE num WHEN 1 THEN SET result = '星期一'; WHEN 2 THEN SET result = '星期二'; WHEN 3 THEN SET result = '星期三'; WHEN 4 THEN SET result = '星期四'; WHEN 5 THEN SET result = '星期五'; WHEN 6 THEN SET result = '星期六'; ELSE SET result = '星期七'; END CASE; SELECT result; END $$ CALL demo10(4);
不等值判断示例DELIMITER $$ CREATE PROCEDURE demo10(IN num INT) BEGIN DECLARE result VARCHAR(20); CASE WHEN num=1 THEN SET result = '星期一'; WHEN num=2 THEN SET result = '星期二'; WHEN num=3 THEN SET result = '星期三'; WHEN num=4 THEN SET result = '星期四'; WHEN num=5 THEN SET result = '星期五'; WHEN num=6 THEN SET result = '星期六'; ELSE SET result = '星期七'; END CASE; SELECT result; END $$ CALL demo10(4);
case、
条件判断
while...end while
iterate相当于java的continueleave相当于java的break
loop.....endloop
循环语句
要处理存储过程中的结果集，请使用游标
游标可以获得结果集，逐行进行处理，相当于java的iterator
只读：无法通过游标指针更新修改表中的数据
不可滚动：只能按照select语句确定的顺序获取行，不能反顺序获取行，不能跳过行或跳到结果集中的其他行
敏感：有两种游标：敏感游标和不敏感游标。敏感游标指向实际数据，不敏感游标使用数据的临时副本。敏感游标比一个不敏感的游标执行得更快，因为它不需要临时拷贝数据。MySQL游标是敏感的。
MySQL游标为只读，不可滚动和敏感
什么是游标
declare 游标名 cursor for 查询声明(查询哪张表)
注意：游标声明必须在变量声明之后。如果在变量声明之前声明游标，MySQL将会发出一个错误。游标必须始终与select语句相关联。
声明游标
declare continue handler for not fount set 变量名 = 1 为产生的notfound进行赋值作为结束条件
在mysql中必须声明一个not found条件判断来处理，游标找不到任何行时的情况。在每次调用fetch语句时，游标会尝试读取结果集中的下一行。当游标到达结果集的末尾时，它将无法获得数据并产生一个notfound
处理not found情况
open 游标名
open语句初始化游标的结果集，因此你必须在从结果集中提取行之前调用open语句
打开游标
fetch 游标名 into 提取的变量名
fetch语句来检索游标指向的下一行，并将游标移动到结果集中的下一行，以检查是否有任何行记录可用，然后再提取它
fetch相当于java的iterator里面的hasnext()
检索游标指向数据行
close 游标名
当游标不在使用时，应该使用close语句来停用游标并释放与之关联的内存
关闭游标
游标语法
游标
SQL编程(存储过程)
触发器是一种与表操作有关的数据库对象，当触发器所在表上出现指定事件时将调用该对象，即表的操作事件触发表上的触发器的执行
类似JavaScript的事件
create trigger 触发器名称标识触发时机，取值为before或after标识触发事件，取值为insert，update或deleteon 标识建立触发器的表名，即在哪张表上建立触发器for each row触发程序体，可以是一句SQL语句，或者用begin end包含的多条语句
可以建立六种触发器 即：BEFORE INSERT、BEFORE UPDATE、BEFORE DELETE、AFTER INSERT、AFTER UPDATE、AFTER DELETE
限制：不能同时在一个表上建立2个相同类型的触发器
创建触发器
触发器
MySQL（触发器还没写完）
jdbc是java链接数据库的规范
使用jdbc完成crud操作
Java中定义了访问数据库的接口，可以为多种关系型数据库提供统一的访问方式
由数据库厂商提供驱动实现类(Driver数据库驱动)
核心思想
驱动：所有的数据库驱动都是以jar包的形式存在，jar包当中有很多.class文件这些文件就是对jdbc接口的实现驱动不是sun公司提供的，是各大数据库厂家负责提供，下载驱动jar包需要去数据库官网下载
因为每一个数据库的底层实现原理都不一样
Oracle数据库有自己的原理mysql等等都有自己的原理
为什么sun制订一套jdbc接口呢
mysql数据库驱动
在项目下新建lib文件夹，用于存放jar文件
将mysql驱动mysql-connector-java-5.1复制到文件夹中
选中lib文件夹右键add as libraay点击ok
环境搭建
jdbc是sun公司制定的一套接口(interface)
接口都有调用者和实现者
面向接口调用、面向接口写实现类这都属于面向接口编程
解耦合：降低程序的耦合度，提高程序的扩展力
多态机制就是非常典型的面向抽象编程
为什么要面向接口编程？
jdbc的本质
初识
使用Class.forname(“com.mysql.jdbc.driver”)手动加载字节码文件到JVM中
1.注册驱动/加载驱动
2.连接数据库
statement s = con.createstatement()通过connection对象获取statement对象用于对数据库进行通用访问
3.获取发送SQL的对象
s.executeupdate(sql)//DML语句增删改，用int接收返回的是影响的行数
s.executequery(sql)//DQL语句查询，用resultset来接收查询的结果
注意：在编写dml语句时，一定要注意字符串参数的符号是单引号
4.执行SQL语句并接收结果
核心resultset.next()当获取到数据返回true
受影响行数：逻辑判断、方法返回
查询结果集：迭代、依次获取
5.处理结果
遵循先开后关原则，释放所使用的资源对象
6.释放资源
概念：在执行查询SQL后，存放查询到的结果集数据
接收结果集：resultset 名字 = statement.execuleQuery(sql)
注意：作用就是完成了查询结果的存储功能，而且只能读取一次，不能够来回的滚动读取
resultset以表结构进行临时结果的存储，通过jdbc api将其中数据进行依次获取
next() 返回值类型boolean 数据行指针，没调用一次，指针向下移动一行结果为true，表示当前行有数据
getstring(编号) 返回值类型string代表根据列的编号顺序获得，从1开始
getstring(列名) 返回值类型string代表根据列名获得
经验：getxx方法可以获取的类型有：基本数据类型和引用数据类型
遍历resultset
常见错误
用户输入的数据中有SQL关键字或语法并且参与了SQL语句的编译，导致SQL语句编译后的条件含义为true，一直得到正确的结果，这种现象称为SQL注入
原因
由于编写的SQL语句是在用户输入数据，整合后在进行编译
我们要使SQL语句在用户输入数据前就已编译成完整的SQL语句在进行填充数据
如何避免
SQL注入
preparedstatement继承了statement接口，执行SQL语句的方法无异
预编译SQL语句，效率高
安全，避免SQL注入
可以动态的填充数据，执行多个同构的SQL语句
预编译SQL语句，参数使用？占位preparedstatement pstmt = null;pstmt = conn.preparestatement(\"select*from user where uname=?and pwd=?\")
应用
jdbc中的所有参数都由？符号占位，这被称为参数标记
在执行SQL语句之前，必须为每个参数提供值
preparedstatement(定义预准备的对象)
在jdbc的使用中，连接数据库、关闭连接等存在大量的重复代码
把传统的jdbc代码进行重构，抽取出通用的jdbc工具类
背景
封装获取连接方法public static connection getconnection(){}
重用性方法
重用性方案中的参数都是硬编码，当驱动、URL等参数需要更换时，需要重新编译
通过配置文件读取配置信息，使用软编码方式，更灵活的方案
创建properties配置文件
public static final properties prop = new properties()
创建properties集合
静态代码块中，使用输入流，读取配置文件
跨平台方案
配置文件
object relational mapping：对象关系映射
对结果集(resultset)遍历时，取出的都是零散的数据
在实际应用开发的，我们需要将零散的数据进行封装整理
一行数据中，多个零散的数据进行整理
通过entity的规则对表中的数据进行对象的封装
表名=类名；列名= 属性名；提供各个属性的get、set方法
提供无参构造方法(视情况添加有参构造)
实体类(Entity)
orm(对象关系映射)
data access object：数据访问对象
dao实现了业务逻辑与数据库访问相分离
对同一张表的所有操作封装在xxxdaoimpl对象中
根据增删改查提供具体的方法(insert/update/delete/select/selectall)
DAO(数据访问对象)
封装工具类
代表用户完成的一个业务功能，可以由一个或多个DAO的调用组成
软件所提供的的一个功能叫业务
什么是业务
service
事务是一个原子操作，是一个最小执行单元，可以由一个或多个SQL语句组成，在同一个事务当中<br>所有的SQL语句都成功执行时，整个事务成功，有一个SQL语句执行失败，整个事务都执行失败
在JDBC中，先获得connection对象
开始事务：conn.setautocommit(false)
手动提交事务：conn.commit()
手动回滚事务：conn.rollback()
在service中，调用了多次DAO操作。每一个业务功能都要控制事务
resultset(结果集)
支持所有jdbc兼容的数据库，包括Oracle
Druid连接池
数据库连接池
jdbc
java与数据库技术
除了实现Servlet接口，还可以通过继承GenericServlet或HttpServlet类完成编写
Servlet核心的接口和类
请求地址控制<a></a><from></from>
请求方式控制post/get
请求参数控制<a></a>表单域标签[input/select/textares]
既可以由前端工程师负责，也可以由服务端工程师负责
开发人员负责控制游览器请求行为【三要素】
控制游览器采用对于编译器将接收二进制数据转换为【文字、图片、视频、命令】
控制游览器将编译后命令进行执行或者将接收数据在游览器窗口展示【全局刷新展示/局部刷新展示】
控制用户与游览器展示内容之间交流【JavaScript--->jquery】【前端/服务端】
开发人员控制游览器接收响应数剧行为【服务端工程师】
游览器
请求：得到emp.frm文件数据行带着http请求协议包往下走
服务端计算机
一脸懵逼背不住无法就业
servlet规范来自于javaee规范中的一种
在servlet规范中指定【动态资源文件】开发步骤
指定HTTP服务器调用动态资源文件规则
指定http服务器管理动态资源文件实例对象规则
servlet接口来自于servlet规范下一个接口，这个接口存在http服务器提供的jar包
Tomcat服务器下lib文件有一个servlet-api.jar存放servlet接口
servlet规范中认为http服务器能调用的【动态资源文件】必须是一个servlet接口实现类
servlet接口实现类
第一步创建Java类继承httpservlet父类，
第二步重写httpservlet父类两个方法。diget或者dopost游览器以什么方式发送请求，就用什么方法
第三部将servlet接口实现类信息【注册】到Tomcat服务器
servlet开发步骤
降低接口实现类对接口实现过程难度将接口中不需要使用抽象方法教给抽象类进行完成这样接口实现类只需要对接口需要方法进行重写
抽象类的作用
通过父类决定在何种情况下调用子类中方法
设计模式(模板设计模式)
意外收获
网站中所有的servlet接口实现类的实例对象，只能由http服务器负责创建开发人员不能手动创建servlet接口实现类的实例对象
在默认的情况下http服务器接收到对于当前servlet接口实现类第一次请求时自动创建这个servlet接口实现类的实例对象在手动配置情况下，要求http服务器在启动时自动创建某个servlet接口实现类的实例对象
在http服务器运行期间，一个servlet接口实现类只能被创建出一个实例对象
在http服务器关闭时刻，自动将网站中所有的servlet对象进行销毁
servlet对象声明周期
servlet接口
Servlet核心
来自于servlet规范中，在tomcat中存在servlet-api.jar
实现类由http服务器负责提供
负责将doget/dopost方法执行结果写入到【响应体】交给游览器
开发人员习惯于将该接口修饰的对象称为【响应对象】
介绍
将执行结果以二进形式写入到【响应体】
设置响应头中的[content-type]属性值，从而控制游览器使用对应编辑器将响应体二进制数据编译为【文字，图片，视频，命令】
设置响应头中的【location】属性，将一个请求地址赋值给location从而控制浏览器向指定服务器发送请求
主要功能
httpservletresponse接口
超文本传输协议
是互联网上应用最为广泛的一种网络协议
是一个基于请求与响应模式、无状态的、应用层的协议，运行于TCP协议基础之上
支持客户端(游览器)/服务器模式
简单快速
灵活
无状态
无连接
客户端与服务器建立连接(三次握手)
客户端向服务器发送请求
服务器接收请求，并根据请求返回相应的文件作为应答
客户与服务器关闭连接(四次挥手)
通信流程
当游览器向Web服务器发出请求时，向服务器传递了一个数据块，就是请求报文
HTTP请求报文
当web服务器收到游览器的请求后，服务器要对报文做出响应，就是响应报文
HTTP响应报文
报文
客户端请求成功
200
临时重定向
302
服务器收到请求，但是拒绝提供服务服务器通常会在响应正文中给出不提供服务的原因
403
请求的资源不存在，例如输入错误的URL
404
服务器发生不可预期的错误，导致无法完成客户端请求
500
常见状态码
HTTP协议
转发的作用在服务端
将请求发送给服务器上的其他资源，以共同完成一次请求的处理
request.getRequestDispatcher(\"/目标YRL-pattern\
实现
使用forward跳转时，实在服务器内部跳转，地址栏不发生变化属于同一次请求
forward表示一次请求
是在服务器内部跳转，可以共享同一次request作用域中的数据
数据传递
拥有存储数据的空间，作用范围是一次请求有效
存储数据
request.getAttribute(key);
获取数据
request作用域
转发是服务器行为
转发是游览器只做了一次访问请求
转发游览器地址不变
转发两次跳转之间传输的信息不会丢失，所以可以通过request进行数据的传递
转发只能将请求转发给同一个web应用中的组件
转发特点
转发
重定向作用在客户端
客户端请求服务器，服务器响应给客户端一个新的请求地址，客户端重新发送新请求
response.sendredirect(\"目标uri\")
用来表示服务器中定位的一个资源，资源在web项目中的路劲()
URI
使用redirect跳转时，是在客户端跳转，地址栏发生变化，属于多次请求
sendredirect跳转时，地址栏发生改变，代表客户端重新发送的请求，属于两次请求
response没有作用域，量词request请求中的数据无法共享
数据传递问题
可以通过URI的拼接进行数据传递(?username=value)
获取数据：request.getParameter(\"username\")
实现数据传递
重定向是客户端行为
游览器做了至少两次的访问请求
浏览器地址改变
两次跳转之间传输的信息会丢失(request范围)
包括当前应用程序中的其他资源、同一个站点上的其他应用程序中的资源、其他站点的资源
可以指向任何的资源
重定向
当需要传递数据时，选择forward转发，不建议使用sendredlirect进行数据传递
转发与重定向
servlet从创建到销毁的整个过程
创建实例化，只执行一次
1.instance实例化
调用init方法
调用init方法，初始化Servlet，init()方法只执行一次
2.initialize初始化
接受请求
当客户端发送请求时，执行Service对请求做处理及响应操作
3.service服务
容器停止
当容器停止或重启，执行destory方法destroy方法只执行一次
4.destroy销毁
整个过程
servlet生命周期
servlet在访问之后，会创建一个Servlet对象
Tomcat容易可以同时多个线程并发访问年同一个Servlet
如果在方法中对成员变量做修改操作，就会有线程安全的问题
线程安全
synchronized
实现SingleThreadMode接口
尽可能使用局部变量
如何保住线程安全
Servlet特性
http协议是无状态的，不能保证每次提交的信息
客户端发送一个新的请求，服务器无法知道它是否与上次的请求有联系
对于需要多次提交数据才能完成的Web操作，比如登录来说，较为麻烦
将游览器与web服务器之间多次交互当作一个整体来处理
将多次交互所涉及的数据(即状态)保存下来
客户端状态管理技术：将状态保存在客户端，代表性的是cookie技术(缓存)
服务器状态管理技术：将状态保存在服务器端，代表性的是Session技术(会话)
web服务器在http响应消息头中附带传送给游览器的一小段数据
当游览器保存cookie，之后每次访问该服务器时，会通过请求头回传该cookie数据
cookie主要由表示该信息的名称(name)和值(value)组成
cookie不是客户端有的东西，而是服务器写给我们浏览器的
cookie cookie = new cookie(\"name\"，value)
创建cookie
cookie.setPath(\"/webs\")
设置cookie的路径即作用范围
cookie.setMaxAge(-1)
取值有三种：>0有效期单位秒；=0游览器关闭 <0内存存储，默认-1永久保存
设置cookie的生命周期
response.addCookie(cookie)
响应给客户端
cookie[] cks = request.getcookies()
获取所有cookie
for(cookie ck : cks){if(ck.getName().equals(\"code\")){记录cookie的值code=ck.getvalue()break}}
循环遍历检索出自己的cookie
获取cookie
只要保证cookie的名的路径一致即可修改
注意：如果改变cookie的name和有效路径会新建cookie，而改变cookie的值，有效期会覆盖原来cookie
修改cookie
cookie默认不支持中文，只能包含ASCII字符，所以cookie需要对Unicode字符进行编码，否则会出现乱码
使用中文的cookie.name与value都是用utf-8编码cookie cookie =new cookie(编码方法(\"name\
创建带中文cookie
String name = 解码方法(\"name\
读取带中文cookie
cookie编码与解码
可配置到期规则
简单性：cookie是一种基于文本的轻量结构，可以包含简单的键值对
数据持久性：cookie默认在过期之前是可以一直存在客户端游览器上的
大小收到限制：大多数游览器对cookie的大小有4k8k字节的限制
用户配置为禁用：有些用户禁用了浏览器或客户端设备接收cookie的能力，因此限制了这一功能
潜在的安全风险：cookie可能会被篡改，会对安全性造成潜在风险或者导致依赖于cookie的应用程序失败
cookie的优点和缺点
服务器在默认情况下会使用cookie的方式将sessionid发送给游览器
如果用户禁止cookie，则sessionid不会被游览器保存
访问服务器上的某个地址时，对地址做重写即在地址后加上sessionid
URL重写
解决方案
response.encodeRedirectURL(String url)生成重写的url
cookie禁用解决方案
cookie
session用于记录用户的状态
session指的是在一段时间内，单个客户端与web服务器的一连串相关的交互过程
在一个session中，客户可能会多次请求访问同一个资源或不同的服务器资源
服务器会为每一次会话分配一个session对象
同一个游览器发起的多次请求，同属于一次会话(session)
首次使用到session时，服务器会自动创建session，并创建cookie存储sessionid发送会客户端
session是由服务器创建的
session原理
拥有存储数量的空间作用范围是一次会话有效
一次会话时使用同一游览器发送的多次请求，一旦游览器关闭，则结束会话
可以将数据存入session中，再一次会话的任意位置进行获取
可以传递任何数据(基本数据类型、对象、集合、数组)
session作用域
session是服务器自动创建的，通过request对象获取
HttpSession session = request.getsession()//唯一标记
获取session
setAttribute(属性名，object)保存数据到session中
session.setAttribute(\"key\
session保存数据
session.getAttribute(\"key\")//通过String类型的Key访问object类型的value
session获取数据
removeattribute(属性名)从session中删除数据
session.removeattribute(\"key\")//通过键移除session作用域中的值
session移除数据
覆盖就好
session修改数据
session.invalidate();
清空的是session对象
session清空数据
session使用
request是一次请求有效，请求改变则request改变
session是一次会话有效，浏览器改变，则session改变
session与request应用区别
第一次使用到session的请求产生，则创建session
开始
游览器关闭，则失效看游览器设置，有的设置了退出清缓存
session超时，则失效，默认30分钟session.setMaxinactiveinterval(seconds);//设置最大有效时间秒
手工销毁，则失效session.invalidate()登录退出、注销
结束
session的生命周期
session
状态管理
全局对象，拥有作用域，对应一个Tomcat中的web应用
当web服务器启动时，会为每一个web应用程序创建一块共享的存储区域
servletcontext在web服务器启动时创建，服务器关闭时销毁
this.getservletcontext()
获取servletcontext
servletcontext.getrealpath(\"/\")
out文件下里面的部署包。即tomcat运行是部署包
获取项目真实路径
sout.servletcontext.getcontextpath
获取应用上下文路径
servletcontext拥有作用域，可以存储数据到全局容器中
servletcontext.setattribute(\"name\
servletcontext.getattribute(\"name\")
servletcontext.removeAttribute(\"name\")
移除数据
全局容器
唯一性，一个应用对应一个servletcontext
生命周期，只要容器不关闭或应用不卸载，servletcontext一直存在
一次请求，请求响应之前有效
httpservletrequest
一次会话开始，游览器不关闭或不超时之前有效，全局使用
httpsession
服务器启动之后，关闭之前有效，全局使用
servletcontext
作用域总结
在以往的servlet中，有许多冗余的代码，多个servlet都要进行编写
过滤器(Filter)是处于客户端与服务器目标资源之间的一道过滤技术
执行地位在servlet之前，客户端发送请求时，会先经过filter在到达目标servlet中响应时会根据执行流程再次反向执行filter
可以解决多个servlet共性代码的冗余问题(例如乱码处理，登录验证)
过滤器作用
servlet api中提供了一个filter接口，开发人员编写了一个java类实现了这个接口即可这个Java类称之为过滤器
编写过滤器
编写Java类实现filter'接口
在dofilter方法中编写拦截逻辑
设置拦截路径
实现过程
在自定义的filter类上使用注解@webfilter(value=\"过滤目标资源\")
注解配置
与servlet一样将servlet改成filter
xml配置
过滤器的过滤路径共有三种方式
精确过滤/name
后缀过滤*.jsp/*.jpg
通配符匹配/aaa/*
过滤器路径
过滤器配置
客户端对服务器请求之后服务器调用servlet之前会执行一组过滤器(多个)那么这组过滤器就称为一条过滤器链
每个过滤器实现某个特点的功能，当第一个filter的dofilter方法被调用时，web服务器会创建一个代表filter链的filterchain对象传递该方法，在dofilter方法中开发人员如果调用了filterchain对象的dofilter方法，则web服务器会检查filterchain对象中是否还有filter，如果有，则调用第二个filter如果每有则调用目标资源
过滤器链
注解则按类全名称的字符串顺序决定作用顺序
如果web.xml，按照filter mapping注册顺序，从上到下
web.xml配置高于注解方式
如果注解和web.xml同时配置，会创建多个过滤器对象，造成过滤多次
优先级
解决编码
权限验证
过滤器链与优先级
过滤器
servlet
简化的servlet设计，在html标签中嵌套java代码，用以高效开发web应用的动态网页
替换显示页面部分的servlet(使用.jsp文件替换java)
在web目录新建.jsp问你件(与web-inf平级)
创建jsp
使用<%%>java脚本标签编写java代码
使用<%= %>输出标签
在游览器中输入http://ip:port/项目路径/资源名称
jsp开发
JSP文件在容器中会转换成servlet执行
JSP是对servlet的一种高级封装，本质还是servlet
关系
与servlet相比，JSP可以很方便的编写或者修改HTML网页而不用去面对大量println语句
区别
JSP与Servlet
tomcat服务器会将jsp文件转换成java代码编译成class文件，最终运行结果通过response响应给客户端
使用IDEA开发工具，tomcat编译后的jsp文件(xxx_jsp.java)的存放地点
jsp.java源文件存放目录
实现原理
脚本可以编写Java语句，变量，方法或表达式
语法<%java代码%>
普通脚本可以使用所有的java语法，除了定义函数
注意：脚本与脚本之间，与HTML标签之间都不可以嵌套
普通脚本
语法<%!定义变量，函数%>
声明脚本声明的变量是全局变量
声明脚本的内容必须在普通脚本<%%>中使用
如果声明脚本中的函数具有返回值，可以使用输出脚本调用<%= %>
声明脚本
语法<%=表达式%>
输出脚本可以输出带有返回值的函数
输出脚本中不能加
输出脚本
脚本
主要有两个作用为脚本代码作注释以及HTML内容注释
<%--注释--%>jsp注释，注释内容不会被发送至游览器甚至不会被编译
<!--注释-->HTML注释，通过游览器查看网页源代码时可以看见注释内容
JSP注释
JSP指令用来设置与整个JSP页面相关的属性
定义页面的依赖属性，比如脚本语言，error页面，缓存需求等等
contenttype：指定当前jsp页面的HTML类型和字符编码格式
errorpage：指定当jsp页面发生异常时需要转向的错误处理页面
iserrorpage：指定当前页面是否可以作为另一个jsp页面的错误处理页面
ioport：导入需要使用的java类
language：定义jsp页面所用的脚本语言默认java
session：指定jsp页面是否使用session，默认为true立即创建，false为使用时创建
pageencoding：指定jsp界面的解码格式
<%@page...%>
page指令
<%@indlude file=\"被包含的指定jsp路径\"%>
通过include指令来包含其他文件
被包含的文件可以是jsp文件、html文件或文本文件，包含的文件就好像是当前jsp文件的一部分，会被同时编译执行(静态包含)相当于复制粘贴内容一样
可能会有重名的风险
include指令
<%@taglib uri =外部标签库路径 prefix=前缀%>
引入jsp的标准标签库
taglib指令
指令
<jsp:actiuon_name attribute=value/>
动作标签指的是jsp页面在运行期间的命令
会将外部文件输出结果包含在jsp中(动态包含)
<jsp:include page=相对URL地址>
相当于方法的返回值
注意，include指令是将外部文件的输出代码复制到了当前jsp文件中include动作标签则是将输出结果引入到当前jsp文件中
include
<jsp:usebean id=''' class=\"对象地址\"/>
在类载入后，我们可以通过jsp:setproperty与jsp:getproperty来修改获取bean的属性
相当于new对象
usebean
可以在jsp:usebean之后进行属性的赋值
name：是必须的他表示要设置属性的是哪个bean，类
property：是必须的他表示要设置那个值，属性
value：是可选的该属性用来指定bean属性的值，值
setproper
提取指定bean的值，转换成字符串然后输出
name：要检索的bean属性名称，bean必须已定义
property：表示提取bean的值
getproperty
jsp:forward page=\"相对URL地址\"
jsp:forward动作把请求转到另外的页面
类似转发
forward
jsp:param name=\"\" value=\"\"
在转发的动作内部使用，做参数传递
param
内容
动作标签
由jsp自动创建的对象，可以直接使用
request
response
application
大量包含jsp的相关配置
config
iserrorpage=\"false\"开关
exception
out
页面对象
pagecontext
相当于java的this
page
jsp有四大域对象，存储数据和获取方式一样，不同的是取值的范围有差别
用于获取其他八个内置对象或者操作其他对象的作用域get对象名
当前jsp页面范围
pagecontext对象拥有作用域，用来代表整个jsp页面当前页面的作用域对象，一旦跳转则失效
通过setattribute(\"name\
通过getattribute(\"name\")获取值
基本不会使用它存数据
基本
pagecontext.setattribute(\"name\
request_scope
session_scope
application_scope
page_scope
域范围
从四个域中依次查找：pagecontext，request，session，application找到位置
如果都没有则返回null
pagecontext.findattribute(\"name\")
操作其他内置对象的作用域
一次请求有效
一次会话有效(关闭游览器失效)
整个web应用有效(服务器重启或关闭失效)
四大域对象
内置对象
JSP指令
EL使jsp写起来更简单、简洁。主要用于获取作用域中的数据
用于替换：域对象.getattribute(\"name\")
${scop.name}获取具体某个作用域中的数据
${name}获取作用域中的数据，逐级查找
注意：从域中取数据钱，必须先把数据放入域中
<%=requset.getattribute(nume)%>没有找到返回null
${name}没找到返回\"\"空
el表达式对用户更友好
EL和JSP脚本的区别
${name.属性}
必须要有getset方法
获取对象数据
${name[下标]}
$(name[下标].属性)
获取数组集合数据
${name.key}
${name[key]}
获取map类集合数据
获取引用类型的数据
判断是否为空
empty
==相当于eq
>相当于gt
<相当于lt
空字符串也是0 \"\" null
<=相当于le
>=相当于ge
!=相当于ne
/相当于div
%相当于mod
字母版
EL表达式可以使用各种运算符
EL表达式语言定义了11个隐式对象
pagescope：page作用域
requestscope：request作用域
sessionscope：session作用域
applicationscope：session作用域
与楼下一样获取url参数，？传参的参数
param：request对象的参数，字符串
paramvalues：request对象的参数，字符串集合
header：http信息头，字符串
headervalues：http信息头，字符串集合
initparam：上下文初始化参数
cookie：cookie值
pagecontext.servletcontext.contextpath获取上级目录
配合herf拼接路径，保证路径不会出错
可以确定文件的路径，自动进行字符串拼接
pagecontext：当前页面的pagecontext
<%=request.getcontextpath()%>
${pagecontext.request.contextpath}
获得应用上下文
${cookie.cookiename}
${cookie.cookiename.value}获取cookie的value值
获取cookie对象
隐式对象
EL表达式(重要)
全称java server pages Standard tag Library
JSP标准标签库(JSTL)是一个JSP标签集合
什么是JSTL
可以对EL获取到的数据进行逻辑操作
可与EL合作完成数据的展示
JSTL的作用
导入两个jar文件：standard.jar和jstl.jar文件拷贝到/web-inf/lib/下
在jsp页面引入标签库<%@taglib uri=\"http://java.sun.con/jsp/jstl/core\" prefix=\"c\">
JSTL使用
语法：<c:if test=\"条件\"></c:if>
注意：test属性中是条件，但是条件需要使用EL表达式来书写
if判断
语法：<c:choose><c:when test=\"条件1\">结果1<c:/when>...<c:otherwise>结果4</c:otherwise></c:choose>
多条件choose判断
条件标签
语法<c:foreach var=\"变量名\"items=\"集合\" begin=\"起始下标\" end=\"结束下标\" step=\"间隔长度\" varstatus=\"遍历状态\"></c:foreach>
迭代foreach标签
在cookie禁用的状态下，通过重写URL拼接jsessionid来传递id值，便于下一次访问时仍可查找到上一次的session对象
经验：所有涉及到页面跳转或者重定向跳转时，都应该使用URL重写
url标签
核心标签
要有一个form标签，method=post请求
表示提交的数据以多段(每一个表单项为一个数据段)的形式进行拼接然后以二进制流的形式发送给服务器
Content-Type：表示提交的数据类型
boundary表示每段数据的分隔符
---------------------------28359286838911458633044697036是由游览器每次随机生成，它就是每段数据的分界符
form标签的enctype属性值必须为multipart/form-data值
在form标签中使用input type=file添加上传的文件
编写服务器代码接收，处理上传的数据
文件的上传和下载
JSTL
模型层(Mode;)
视图(View)
控制器(Controller)
mvc又称为编程模式，是一种软件设计思想，将数据操作、页面展示、业务逻辑分为三个层级(模块)，独立完成，相互调用
MVC概念
视图：视图即用户看到并与之交互的页面，比如html(静态资源)jsp(动态资源)等等
控制器：控制器即是控制请求的处理逻辑，对请求进行处理，负责流程跳转(转发和重定向)
模型：对客观世界的一种代表和模拟(业务模拟，对象模拟)
MVC并不是Java独有的，现在几乎所有的B/S架构都采用了MVC模式
视图层：jsp收集并展示信息
控制器：收参，调用业务方法，流程跳转
模型层：Service+Dao+Entity
层级属性
MVC模式详解
低耦合性：模块与模块之间的关联性不强，不与某一种具体实现产生密不可分的关系
高维护性：基于低耦合性，可做到不同层级的功能模块灵活更换、插拔
高重用性：相同的数据操作，可以服务于不同的业务处理，将数据作为独立模块，提高重用性
MVC模式广泛用于Java的各种框架中，比如Struts2，springMVC等等都用到了这种思想
MVC在框架中应用
收集用户数据
调用业务逻辑，完成业务方法
展示数据，展示操作结果
VIEW(表示|界面层)
开启事务
调用DAO层
处理数据
提交或回滚
service(业务逻辑层)
查询相关业务逻辑的数据
根据相关业务逻辑修改的数据
DAO层(数据访问层)
三层架构
MVC强调的是视图和业务代码的分离，严格说MVC其实关注的是Web层。View就是单独的页面，比如就是JSP、HTML等，不负责业务处理，只负责数据的展示，而数据封装到model里，有controller负责在VM之间传递，MVC强调业务和视图的分离
三层架构是数据访问层、业务逻辑层、表示层，指的是代码之间的解耦，方便维护和复用
MVC与三层架构的区别
三层架构与MVC
MVC框架(Model-View-Controller)
分页是Web应用程序非常重要的一个技术。数据库中的数据可能是成千上万的，不可能把这么多的数据一次显示在游览器上面一般根据每行数据在页面上所占的空间设置每页显示若干行，比如一般20行是一个比较理想的显示状态
对于海量的数据查询，需要多少就取多少，显然是最佳的方法
select*from表名 limit 0，20；//第一页
分页实现思路
分页
jsp
git
method参数后的值作为方法名称
方法的返回字符串如果是以forward开头，表示是以转发进行跳转如果以redirect开头，则以重定向跳转
方法定义的形参要与请求参数的名字一样
项目的约定俗成
Javaee，web开发
前端
JavaSE知识内容
0 条评论
回复 删除
下一页
