第八次总结

小题：

1.CSS常用的选择器
1）标签选择器
选中所有同名标签
	标签名称{
	样式代码
	}
	<style>{
		div{
		font-size:30px;
		color:blank;
		}.class{}
	}
	<style />
2）class类选择器
可以选中页面标签中所有的同名属性
	.class{属性}
类选择器大于标签选择器
3）id选择器
在页面标签中必须指定唯一的id属性值
	id属性值不能重复
	格式：
	#选择器名{
	属性
	}
交集选择器--子元（后代）素选择器
	选择1 选择2{
		css样式代码
	}
	选中当前标签下所有标签
	#d1 span{
	属性
	}
	<div>
		<span>
			<span>
	选中div下的所有子标签
通用选择器
	*：通配符
	*{
		属性
	}
2.CSS浮动属性和边框属性
	float：left：左浮动（当前浮动的元素就会脱离文档流）
			right；右浮动
	边框属性：
		border：border-width border-style border-color
		简写操作
3.JDBC的原生操作步骤
1）导入jar包---在java工程下创建lib目录---将所有第三方的jar包放进来
2）注册驱动    获取数据库连接
	注册驱动：Clsaa.forName("com.mysql.jdbc.Driver");
	创建对象：
	java.sql 类 DriverManager：驱动管库类
		Connection conn=DriverManager.getConnection(url,user,password)
		url：jdbc：mysql：//localhost:3306/mydb_05"
		user:"root"
		password:"123456"
3）准备sql语句
	STring sql="update account set balance = balance +500 where id=1;"
4）通过数据库连接对象获取执行对象
5）执行sql语句，向数据库服务器发送指令
6）返回结果
7）释放资源
4. PreparedStatement和Statement的区别
PreparedStatement：预编译对象：执行sql的语句都是参数化sql
	执行效率相对于Statement来说，效率高
	能够有效防止sql注入----不存在字符串拼接问题
Statement：执行静态sql语句
	相对于PreparedStatement，执行效率低
	由于存在sql字符串拼接，或造成sql注入，不安全
5.多表联合查询，左外链接法
语法格式：
	select * from 表名1，表名2；
	存在问题，产生了笛卡尔乘积：A表中有n条数据，B表中有m条数据，若直接查询，----共有m*n条数据
	解决方案：1）查询哪个表--员工表和部门表
			2）查询每个表中的那些字段--查询所有
			3）这些表的连接条件--员工表的dept_id依赖于部门表的主键id
			外连接
				左连接：left outer join
					select 字段列表 from 左表 left outer join 右表 on 连接条件

CSS盒子模型

盒子模型：万物皆盒子
	将任意标签看成一个盒子
	属性：
		将任意元素使用div包裹
		边框：border
		内边距：padding
		外边距：margin

CSS定位属性

pasition属性：定位
			left
			top
绝对定位：absolate
相对定位：relative//针对原来的位置进行移动
固定定位：fixed//针对当前显示页面固定，不随着页面滚动
pasition：absolate；
left：10px；
top：20px；
根据它的父元素来进行移动

Javascript（js）

弱类型语言：语法结构没有像强类型语言严谨
语法规则：
1）变量的定义以及数据类型
2）预算符号/流程控制语句（switch中case语句：js中case后可以跟变量）
3）函数的定义以及调用
4）js的内置对象
	Date：日期对象
	String：字符串对象
	Boolean：布尔对象

1）获取标签对象img标签
	getElelemntByid（“id属性值”）
		function imgClick（）{
			alert（“我点击了。”）；//点击后弹出一个单击框
			var img=document。getElementByid（“图片的id”）；//点击后切换图片
			img.src=“图片路径”；
		}
使用方式1：
	内部方式：指定srcipt标签。书写js代码
	外部方式：在js文件夹下去创建xxx.js文件，文件中使用js代码
		在当前页面中使用link标签，引入js文件（src属性引入js文件）
	1）js中定义变量使用var来定义，var可以省略
	2）js是弱类型语言，所以可以重复定义同名变量的值，后面的变量将会将前面的变量值覆盖
	3）使用var定义任意数据类型
	4）数据类型的查看：typeof（）
		无论是小数还是整数，都是number类型---Js内置对象Number
		无论是字符串还是单一字符，都是string类型---
		boolean类型-----Js内置
		object类型---Js内置：Object（代表所有js对象模板）
		undefined未定义数据类型
运算符：
	算术运算符
	赋值运算符
	比较运算符
	逻辑运算符
	三元运算符
流程控制语句：
	顺序结构语句
		在script中由上而下依次进行加载
	选择结构语句
		if语句
		switch语句
			注意：case后不仅仅是常量，也可以是变量
	循环结构语句
		for
		while
		do while
	for-in语句

js中的with语句

简化了for循环语句
			// with(document){
			// 	for(条件判断){
			// 		for(){
			// 			with("* ")
			// 		}
			//		with("<br />");
			// 	}
			// }

js中的函数

在js中使用function 函数名称（形参列表）{
	....
}
调用函数：
单独调用：函数名称（实际参数列表）
赋值调用：在函数中科院使用return语句
注意：
	1）函数名称后的参数列表中不需要带数据类型（var）
	2）定义函数的时候，不需要返回值类型，直接书写函数名称
		而且方法体中可以有return语句
	3）js中不存在方法重载的概念，如果函数名一样，后面的函数直接将前面的函数覆盖
	4）当下面的函数将上面的函数覆盖掉后，实际参数的个数小于形式参数个数，函数依然可以被调用，但是值为NaN，空值。

事件编程三要素：
	1）事件源：作用在哪个标签上
	2）编写事件监听器：编写一个函数
	3）绑定事件监听器：一些属性绑定
		onclick
		onfoucs
		onblur

for-in语句

自定义对象
	定义一个函数
		function 函数名称（属性）{
			给属性赋值；
		}
	创建对象
		var 对象名=new 函数名（实际参数列表）；
	for-in语句格式：遍历自定义对象的属性或者数组

js之自定义对象

1）类似于java中的有参构造
2）类似于无参构造
3）利用Object（模板对象）
4）字面量值的方式（json串）

定义对象
	function 函数名称（）{
		追加方法，
		追加属性
	}
	创建对象
	var 对象名称=new 函数名称（）；
3）给对象追加方法：
	对象.方法名=function（）{
		方法体
	}
4）var 变量名={
	变量赋值：
	“name”：“xx”，
	“age”：12，
	“方法名”：function（）{
		方法体
	}
}

小题：

1. JS自定义变量的定义以及数据类型的划分
定义：var可以定义任何类型数据
数据类型：number--->JS内置对象Number
		string---->JS内置对象String
		boolean---->Boolean对象
		object----->JS所以内对象的模板Object
		undefind
2. JS自定义对象的方式有几种
	1）类似于java的有参构造
		function 函数名（形参列表）{
			追加属性；
			追加方法
		}
	2）类似于java的无参构造
		function 函数名（）{...}
		创建对象
		var 对象名=new 函数名（）；
		对象名.属性=值；
		对象名.方法名=function（）{....}
	3）利用Object
		var 对象名=new Object（）；
		对象名.属性=值；
		对象名.方法名=function（）{...}
	4）字面量值的方式：json串
		var 对象名={
			“key1”：value1,
			“key2”：value2；
		}；
	事件编程三要素：
		事件源
		事件监听器
		绑定事件监听器
3. 多态的前提条件以及成员特点
	有继承关系
	存在方法重写
	父类引用指向子类对象
特点：
	1）成员变量：编译看左，运行看左
    2）成员方法：编译看左，运行看右
    3）构造方法：分层初始化
    4）静态方法：编译看左，运行看左
4. JS函数的定义以及如何调用
	函数定义：
		function 函数名（形式参数）{
			输出内容/return 语句；
		}
	调用：
		单独调用
			函数名（实参列表）
        赋值调用
        	var 变量名=函数名（实参列表）；
5. JDBC的元素操作步骤
1）导入核心jar包
2）注册驱动
3）获取数据库连接
4）准备sql语句
String sql=“insert into 表名 values(?,?)”
5）预编译sql
PreparedStatement stmt=conn.preparStatement（sql）；
6）参数赋值
stmt.setxxx(1,赋值);
stmt.setxxx(2,赋值);
7）返回结果
8）关闭资源

js内置对象

常用的：
	String对象
		valueof（）比较的是对象的原始值是否相同
		chartAt（index）：返回指定索引处
		conat（otherstring）：字符串拼接功能
		fontcolor（颜色）
		indexOf（num）：当前某个字符第一次在字符串中出现的位置
		substr（start，length）:从指定位置开始，截取指定长度
		substring（star，end）从指定位置开始截取到指定位置结束
		toUpperCae（）；将字符串转为大写
		toLowerCae（）：转小写
	Date对象：日期和时间
		var date=new Date（）；
		alert（date）
		获取年份：
			getYear（）：方法过时，当前年份与1900年的差值：getFullYear（）
			getMonth（）：获取月份，从0开始，需要+1
			getDate（）：获取月中日期值
			getHours（）：小时数
			getMinutes（）：分钟数
			getSeconds（）：秒数
			对象.innerText=“”；//不会渲染标签
			对象.innerHTML="";//会渲染标签，比如h1，标题标签
		网页定时器：
		window可以省略不写
			window.setInterval（“任务函数（）”，时间毫秒）；经过一定毫秒后执行这个任务，执行一次
			window.setTimeout(“任务函数（）”，时间毫秒)；每经过一定毫秒重复执行这个任务
	Array对象
		var 数组名=[任意数据类型]；
		var 数组名=new Array（size）；
		创建数组：
			1）var 数组名=new Array（）；
			2）var 数组名=new Array（指定长度）；
			3）var 数组名=[具体的元素]；
		方法：
			1）join（“”）:将数组中的元素使用分割符号拼接炒年糕字符串
			数组对象.join（“--“）；//元素之间用--拼接起来
			2）reverse（）：将数组元素反转
			数组对象.reverse（）；
		js中---inload：页面载入事件
			将body中的内容加载完毕，才能触发这个事件
			window.onload=function（）{//放在body前的<script>中
				//操作
				var images=document.getEl..("images");
				var path=["img/1.jpg....];
				var btn=document.getE...(button);
				var index=0;
				//点击上一张：点击下一张
				btn[0].onclink=function(){
					index--;
					if(index==0){：index》path。length
						index=path.length-1;：index=0；
					}
					images.src=path[index];
				};
				
			}
	Number对象

js中的每一个内置对象都存在prototype：原型属性
作用：
	1）就是为了给内置对象追加额外的功能
	2）原型属性的操作：相当于在内置对象中创建了一个原型对象，通过原型对象追加额外方法，这个方法会自动追加到内置对象中
	原理：
		js内置对象
		function Array（）{
			内置方法:
			this.join=function(){
			...
			}
			//原型属性---new Prototype（）
			this.prototype=new Prototype（）；
			
		}

BOM编程（了解）/DOM编程（重点）

BOM（Browser Object Model）：基于浏览器对象模型编程
js引擎解析html页面的时候，将页面整个部分封装成相关对象：
1）window对象
	方法：open（url，“打开这个创建的方式”，“宽高”）
		alert（“提示框”）//放在confirm中使用
		confirm（“消息字符串”）//弹出确认框 var flag=window.confrim("are you year?")
											if(flag){
												alert("yes");
											}else{
												alet("no");
											}
		prompt（“消息框”）
			
2）历史记录：history对象
3）地址栏：location对象
	href：加载另一个url
4）屏幕对象：screen对象
	weith/heigth：获取跟当前屏幕相关的分辨率
	前面加avai：获取除去任务栏的屏幕分辨率

DOM（Document Object Model）：基于文档对象模型编程
浏览器在加载html页面时，js引擎将html页面每一个标签封装成对象

事件编程三要素：
	1）事件源：作用在哪个标签上
	2）编写事件监听器：编写一个函数
	3）绑定事件监听器：一些属性绑定
点击相关事件：
	click 单击
	dbcclik双击
与焦点相关的事件：
	focus：获取焦点
	blur：失去焦点
和选项卡发送变化的事件：
	change：下拉菜单
				select
和鼠标经过移出事件：
	mosueover
	mosueout
和页面载入相关事件：
	load
按键按下：
	keydown：按下那一时刻
	keypress：按压的状态
按键抬起：
	keyup

js原型属性

给js内置对象添加额外方法
简写：
	Array.peototype.额外方法名=function（参数）{
		业务
	}
String.prototype.额外方法名=function（参数）{
...
}	

小题：

1.什么是JS的BOM编程
	基于浏览器对象的模型编程
	js引擎在编写html页面的时候，将整个页面封装成相关对象
		window对象
			弹框相关方法
			定时器相关方法
				setInterval（“任务（）”，毫秒值）
				setTimeout（“任务（）”，毫秒值）
			open（“url”，“打开方式”，“指定链接所在页面的宽高”）
		history对象
			forwar（）
			back（）
			go（正负整数）
		location对象
			href属性
			reloda：重新载入当前url：刷新
		screen对象
2.JS事件编程的三要素
	1）事件源
	2）编写事件监听器 
	3）绑定事件监听器
3.单击事件和焦点事件，选项卡发生变化的事件
点击相关事件：
	click 单击
	dbcclik双击
与焦点相关的事件：
	focus：获取焦点
	blur：失去焦点
和选项卡发送变化的事件：
	change：下拉菜单
				select
4.throw和throws的区别
两者都是抛出一样
书写位置不同
	throw：书写在方法体中，后面跟异常类对象，一般都是匿名对象
	throws：书写在方法声明上，后面跟异常类名，可以跟多个异常类名
表达含义不同
	throw：异常的处理交给逻辑语句，表示抛出异常的肯定性
	throws：异常的处理交给调用者，表示抛出异常的一种可能性
5.sleep和wait的区别
两者都是一种阻塞方法
1）来源不同
	sleep（）来源于Thread类，线程睡眠
	wait（）来源于Object类，跟锁对象有关系
2）是否释放锁
	wait（）方法调用，会立即释放锁
	sleep（）方法调用：线程的某一种状态，不会释放锁
3）两个方法都抛出一个中断异常interrupedExcetion

其他事件分类

鼠标经过和鼠标移出
mouseover mouseout
onmousover=“弹窗方法”//鼠标经过绑定方法
onmousout=“弹窗方法”//鼠标移出绑定方法

按键事件：
	按键按下 keydown
		onkeydown=“绑定的方法名（event）”
			function 方法名（event）{//获取输入框内容
				if（event.keyCode==65）{//满足判断条件
				alert（“消息提升”）
				}
			}
	按键按压 keupress
	按键抬起 keyup
		按键keycide属性
页面载入事件
load	一般用在body标签：将body中的内容全部加载完毕才知执行这个函数，反正js中某个标签对象获取不到
<body onload=init()>
window.onload=function（）{}

DOM编程

基于文档对象：document 模型编程--将html页面中的每一个标签分装成标签---“标签对象”
在运行html页面的时候。js引擎将html页面中的每一个标签都封装成标签对象。形成一种树状结构
开发步骤
	1）通过不同的方式可以获取标签对象
		1）：通过document集合属性
		2）通过查询节点关系获取
			parentNode：父节点
			childNode：所有子节点
			previousSibling：上一个兄弟节点
			......
		3）通过document对象方法获取
		方式1）
			getElementById（“id属性”）
				2）	ByClassName（“class属性值”）：通过class获取标签对象
						varusername=document.getE...ByClassName（“classInp”）//Inp为输入对象
				3）	ByTagName（“标签名称”）：通过标签名称获取标签对象
						var username=document.get..ByTagName（“input”）[0];
				4） 	ByName（“name属性值”）：通过标签的name属性获取标签对象
			....
placeholder=“输入内容”//放在input标签中，透明的提示，不占文本内容

正则表达式

定义一个规则：正则语法 来校验我们表单中的一些用户输入的参数

使用js正则表达式+dom操作：完成元素js的表单验证

语法：
定义正则规则：
	var xxx=/正则表达式/
		举例：var s=“aaaaa”；
	判断当前 用户输入的字符串内容是否符合规则
	正则表达式.test（字符串内容）{
		//匹配成功
	}else{
		//匹配失败
	}
	js正则表达式不带^(以xxx开头)和$(以xxx结尾)：边界匹配符号
	/^ 正则语法 $/
		例子：（有漏洞，不完全匹配）
			var str=“12”；
			var reg=/[0-9]{2}/;//  /^[0-9]{2}&/
			if(reg.test(str)){
				alert(“匹配成功”)；
			}else{
				alert(“匹配失败”)；
			}
	
	x{n}//x恰好出现n次
	x---表示任意字符
	x+：表示x字符出现一次或者多次
	x？：表示x字符出现0次或者1次
	x*：表示x字符出现0次或者多次
	x{n，}：x字符至少出现n次
	x{n，m}：x字符至少出现n次，不超过m次
	\d:匹配数字0-9
	本身这个字符就是.----需要转义：\.

Tomcat

web应用服务器：
	tomcat：开源，免费，轻量级的应用服务器
		理论并发量500个
	http服务器
		nginx--理论并发量5万个
	apache服务器
	
	tomcat服务器
		将压缩包解压
			重要目录：
				bin：执行目录
				conf：核心配置目录
				webapps：存放一些网站（文件夹）
				work：存储jsp编译文件以及xxx.class文件
	可能造成tomcat启动失败的原因
	
	闪屏
		点击startup.bat 没有原因
		1）是否配置了jdk环境变量
		2）是否配置jre
	启动如果出现中文乱码，进入tomcat解压目录中的解压目录 conf目录
		logging.properties文件中，
			48行的utf-8修改为gbk即可
	

小题：

1.通过document方法获取的标签对象有哪些
	getElementById（“id属性”）
			ByClassName（“同名的class属性”）
			ByTagName（“同名的标签名称”）
			ByName（“同名的name属性值”）
2.原生JDBC的操作步骤
1）导入核心jar包
2）注册驱动
3）获取数据库连接对象
4）准备sql语句
5）获取预编译对象发送sql
6）参数赋值
7）执行操作
8）关闭资源
3.final，finally，finalize的区别
final：状态修饰符，表示唯一的
	修饰成员变量：成员变量是常量，不可被更改
	修饰成员方法：方法不可被重写
	修饰类：该类不能被继承
finally：捕获异常的一种标准写法：try...catch...finaly 释放资源
							try...finally
	funally中的代码一定会执行
finalize：
	跟GC垃圾回收器有关，启动gc会调用finalize（）方法来回收没有更多引用的对象
4.线程的状态有几种
	6种
		NEW		新建
		RUNABLE	运行
		BLOCK	阻塞
		WATING	死死等待
		TIMED_WATING	超时等待
		TERMINED	终止
5.多线程实现方式
	1）继承关系Thread类
	2）实现Runnable接口---静态代理
	3)线程池
		工厂Executors
			newFixedThreadPool（int nThread）
			submit（Callable接口 call）
			自定义类implements Callable
			重写call方法
			参数数据
				corePoolSoze：线程的核心线程数量
				maximumPoolSize：最大线程数量
				unit：线程空间的计量单位
				workQuene：工作队列
							将提交的异步任务---存储到工作队列中
				ThreadFactory：工厂----管理每一个线程

Httpselect

自定义一个类，继承自httpservlet类
	父类：GenericServlet
	父类：Httpservlet（抽象类，不能实例化）extends GenericeServlet
		生命周期
			服务方法：service（HttpS...Rquest request,HttpS...Rwspones respones）
				同步不同步提交方式，完成不同的业务
				get提交--doGet（）
				post提交方式---doPost（）
	MyFristServlet excents HttpServlet{
		业务操作
	}

servlet执行流程

1）http://localhost:8080/servlet_01/frist
给tomcat服务器发送请求
请求行：
	GET/servlet_01/frist(URL) HTTP/1.1
	url-pattern--->frist
	就会在项目下的web.html中找是否存在url-pattern
通过url-pattern查询得到MyFristServlet
在通过这个名字---->servlet基本配置信息 servlet-name
name中有全限定名称，这就是反射技术
tomcat服务器就能创建该类对象。
然后调用doGet方法

servlet生命周期：对象创建----初始化---服务方法----销毁
对象的创建以及初始化都是执行一次：是单例的
    多次访问servlet---只是调用service（）方法
	这个方法就是servlet的程序入口
	开发中，需要覆盖具体的方法
servlet销毁
	public void 

servlet全局对象：三个作用
	1）可以获取web工程的路径
	 public ServletContext getServletContext() ：获取全局对象
	 	ServletcContext cont=this.getServletContext();
	 public String getContextPath()：可以直接拿到全局对象，用全局对象.此方法，返回一个String值
		String path=cont.getContextPath();//获取到上下文路径
	2）可以作为域对象去使用：//创建两个类，都用到全局对象
		获取全局对象（第一步有）
		cont.setAttribute（“name“，”值”）：设置属性以及绑定属性值
		//下面的request
	获取全局对象：（cont）
	通过域对象中设置的属性名称获取设置的属性以及绑定的值
	String s=（String）cont.getAttribute（“name”）；
	3）请求转发
		获取servletContextpath对象
			public RequestDispatcher getRequestDispatcher(String path)
		ServletContext cont=this.getServletContext（）
		获取请求转发对象
		RequstDispatcher rd=cont.getRequesDispatcher（“/adv.html”）;
		rd.forward(resquest,response);
		//简写：
		request.getRequestDispatcher（“/avd.html”）.forward（request，response）；
		（上面赋值的cont）

url-pattern

映射路径的配置----不能重名
精确匹配：
	/名称
可以进行模糊匹配，但是不推荐
/*：后面跟随意的字符
/*.html:以.html结尾的地址

小题：

1. ServletContext的作用有哪些
1）可以获取上下文路径
	web应用程序的“上下文”	/web工程名称
	request.getContextpath（）
2）可以作为域对象---在不同的服务端进行数据传输
通用方法：
	域对象.setAttribute（“属性名称"，Object obj）；
	通过域对象.getAttribute（“属性名称”）；---Object obj
	jsp：java Server Page	本质是Servlet
	ferrmarker：网页静态化（模板引擎）
3）请求转发
	RequestDispatcher rd=this.getServletContext（）.getRequestDispatcher（“/xxx”）；
	rd.forward（request，response）；
2. 四个域对象并且从大到小的范围
	PageContext	page域	在当前jsp页面中有效
	HTTPServletRequest	request域	在一次请求中有效
	HTTPSession		session		在一次会话中有效
	ServletContext	全局对象		在整个web工程有效
3. Servklet的执行流程
	1）用户输入请求地址：http://localhost:8080/web application/url-patten
	2）tomcat服务器解析用户请求的地址信息
		解析url-patten地址---在整个web。xml是否存在这个路径
			如果存在--找到对应servlet名称
		进入servlet基本配置
			找到：servlet-name
				servlet-class
		通过全限定名称：反射的方式创建该类实例对象
			通过获取当前servlet中doXXX（）所在的Method
		Method m=节码文件对象.getDeclaredMethod（“doGet“，HTTPServletRequest.class......)
		m.invoke（实例，request，response）；
3）将信息进行展示----向浏览器输出内容
4. Servlet的生命周期
对象创建---初始化---服务方法---销毁
5. Servlet的本质是什么
本质：实现Servlet接口的子实现类

RR（request/response–规定了什么）

在浏览器中：产生一些请求信息
一堆请求头
key：value
...
..

响应信息：response Meader
http协议版本1.1  响应状态码：200
响应头
key：value
...
..

请求头以及响应头

response------>重定向操作
重定向原理：
	location响应头+3.2状态码
面试题：请求转发和重定向的区别

注解中规定里面的属性（其实本身就是当前接口中的抽象方法名）
	String 属性名（）；
	Enum类型 属性名（）；
	注解类型 属性名（）；
	以上类型的数组
元注解
	@Target：当前注解的使用范围
		ElementType value（）：规定当前@Trget注解范围
			用在类上，方法上，成员变量
		ElementType：枚举类型
注解的本质：就是一个接口
	
重定向和请求转发的区别：
请求转发：
	1）地址栏没有变化
	2）请求转发的整个过程：中间的请求对象是一致的
	3）请求转发只能在本工程下页面跳转
	4）请求转发会携带数据
重定向：
	1）地址栏有明显变化
	2）重定向的整个过程：中间的两次request对象不一样
	3）重定向：既能访问本工程下面的资源文件/也可以访问外部资源文件
	4）重定向：不会携带数据

会话管理

cookie：浏览器
	在分布式系统
		很多集群：单点登录：用户在相互信任系统之间只需要登录一次
			用户系统
			搜索系统
			详情系统
			订单系统
Session：服务器端
	验证码
	session