自己写的凌乱的笔记
c/s项目(javaSE) client server
b/s项目(javaEE)browaer server
ASP(2002~2003)
b/s对比c/s项目：
c/s对客户机比较高,
注册表：C++ C#中有其他的好处；升级麻烦。
b/s：不需要安装，升级很方便；
缺点：客户的体验差，操作麻烦：发展趋势WEB2.0的技术（ajax）
web服务器 tomcat web logic WebSphere
http://www.apache.org/
http://tomcat.apache.org/tomcat-9.0-doc/index.html
http://tomcat.apache.org/download-90.cgi
http://tomcat.apache.org/download-60.cgi
推荐版本
j2EE5+tomcat6+JDK1.6
c/s 三层架构
b/s：mvc架构——model（（biz 逻辑层）+数据访问 +dto+entity） view（JSP /html
运行结果） contller（servlet）
javaEE ==java2E
lib放jar包
web.xml权限的
mp.html欢迎页
<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
JAVA的
http://localhost:8080/
127.0.0.1:8080/web站点
协议 地址 端口 /web site name /目录名 /资源名
报404错误！目标资源没有找或者不存在！
（*jpg）（html）（JSP）（Servlet）
文件夹下拷贝
对象编程java 万物皆对象；
2.java语法：
class 类(不同类型 可以构造出来的不同的对象)
继承：子类可以使用父类的属性和方法
JAVAEE教程：
javaweb
http://localhost:8080/Wabapp/ap.jsp
地址名称
JAVA EE 5 library 类库
src java源程序
webRoot项目的根目录
index.jsp 资源文件
系统目录
context root 改目录
ap.jsp
jsp java Server pages 简化Servlet
jsp
asp.net
php
Lamp：liunx +apache+mysql+php
jsp：注释 指令 表达式 小脚本 声明 静态内容
jsp指令元素 page指令 页面属性
<%@ page 属性1="属性值"%>
属性：
language jsp的脚本语言 java
import 引用脚本语言使用到类文件 无
/* 实例化对象 */
ObjectReference = new Constructor();
/* 访问其中的变量 */
ObjectReference.variableName;
/* 访问类中的方法 */
ObjectReference.MethodName();
contentType jsp采用的编码方式 text/html,ISO-8859-1
<%--jsp注释客户端不可见--%>
<%--jsp注释客户端不可见--%>
<%//单行注释
/*多行注释*/
out.println("欢迎大家学习JAVAEE开发！
");
out.println("欢迎大家学习JAVAEE开发！
");
%>
<%! 声明变量%>
<%!
int num=100;//声明一个整形的变量
int add(int x,int y)//实现整形相加
{
return x+y;
}
%>
num=<%=num %>
10+15=<%=add(10,5)%>
language
include 外文件嵌入 解析页面
taglib指令 自定义标签 jsp启动定制的行为
默认首页
jsp基础语法:
配置JER
集成Tomcat服务器
MyEclipse：
contentType="text/html;
charset=UTF-8"
jsp生命周期
jspService（）方法调用
servlet始终驻留与内存
jsp
<%
date d=new date();
SimpleDateFormat sdf=new SimpleDateFromat("yyyy年MM月dd日")
String s=sdf.format(d);
%>
今天的时间<%=s%>
游戏引擎api
方法的声明
方法的参数
方法的返回值
方法的调用
方法:
把复用的业务代码抽取出来，形成独立的调用单元
实现比较复杂的逻辑
对具体实现进行隐藏/封装，只需调用关注结果，而不用关注其具体实现
语法：
[访问修饰符] 返回值类型 方法名([形式参数列表]){
程序代码;
[return 返回值;]
}
示例：
public void getAge() {
}
方法声明—注意事项:
访问修饰符：表示方法的访问权限，可以省略，建议写上
返回值类型：空返回为void，此时方法体中不需要return语句。若返回其他类型的值，则必须有返回对应类型值的return语句，且return有终止方法的作用，必须位于最后。
方法声明—注意事项:
形式参数(形参)：方法声明时规定的参数类型,数量,顺序
实际参数(实参)：调用方法时实际传递给方法的数据
返回值：方法执行完毕后返回给调用者的数据。
方法调用:
同一个类中
方法名 (形参列表)：
// 静态只能调用静态，非静态既可以调用非静态，还可以调用静态
对象名.方法名(形参列表)：
// 静态调用非静态
注意：不同类中的情况，会在面向对象，类的概念时一起讲解。
注意
被static关键字修饰的方法为静态方法(类和对象会再次讲解)
调用方法的实参列表必须和形参列表严格对应
方法应用
:定义一个静态方法，接收两个数和算术运算符，返回运算结果
定义方法，判断某年是否是闰年，闰年规则：
能被4整除，且不能被100整除
或者能被400整除
方法的重载overload:
定义：同一个类中，方法名相同，参数列表不同
作用：在同一类中，可以产生多个同名方法，从而实现不同的操作。调用时，根据匹配的实参列表，执行相对应的方法
方法的声明
方法的参数：形参，实参
方法的返回值：void，return
方法的调用：同一个类，不同类中
1.判断形参列表是否相同时，只看形参类型，不看变量名
2.是否重载与返回值类型无关
3.形参列表不同：个数不同，顺序不同
4.多态：重载是多态中的一种情况，静态多态
标识符:
Java标识符命名规则：
由字母、数字、下划线（_）和美元符号（$ 音：dollar）组成。
不能以数字开头。
区分大小写。
不能是Java中的保留字和关键字。
标识符命名习惯：见名知意
请判断以下标识符是否合法：
HelloWord、username2、user_name、_userName、
$abc_123、public、
2UserName、user#Name、Hello World关键字:Java中有特定含义，专门用途的字符串称为关键字（keyword），关键字全部小写
保留字：没有定义用途，但保留备用。goto、const扩展：编程命名规范:变量名、方法名：首字母小写，其余单词首字母大写
类名、项目名：首字母大写，其余单词首字母大写
包名：全部小写，用英文的.隔开
常量：全部大写，单词之间用_隔开
总体原则：驼峰式，见名知义，便于代码的统一及可读性
Java的数据类型:
数组(array)接口(interface)
类(class)
布尔型（boolean）:
boolean类型表示真假，一般用于逻辑运算、流程控制
boolean类型数据值：true或false，不可以用0、非0数字，大写代替。
示例：
boolean b = false;
boolean c = true;
基本数据类型：
Java中定义了4类/8种基本数据类型
布尔型---- boolean
字符型---- char
整数型---- byte, short, int, long
浮点数型---- float, double
Java中所有的基本数据类型都有固定的存储范围和所占内存空间的大小，而不受具体操作系统的影响，以保证Java程序的可移植性。
Java浮点类型有两种表示形式
十进制形式，必须含有小数点，例如：
3.14 314.0 0.314
科学记数法形式，如：
3.14e2 3.14E2 3E2
Java浮点型默认为double型，如要声明float型，则需在数字后面加f或F，如：
double d = 3.14; float f = 3.14f;
字符类型:char型数据用来表示通常意义上“字符”
char c = ‘A’; char gender= ‘女';
Java字符采用Unicode编码，每个字符占两个字节，因而可用十六进制编码形式表示(Unicode是全球语言统一编码)
char c1 = '\u0061'; //相当于a
char c2=97; //ASCII码，相当于a
Java语言中还可以使用转义字符'\'来将其后的字符转变为其它含义：
char c2 = '\t';
名称 描述
\n 换行 将光标移到下一行的第一格。
\t 水平制表 将光标移到下一个水平制表位置。
\' 单引号 产生一个单引号。
\" 双引号 产生一个双引号。
\\ 斜杠 产生一个斜杠。
数据类型 大小/位 可表示的数值范围
byte(字节型) 8 -128~127
short(短整数) 16 -215 ~ 215-1
int(整数) 32 -231 ~ 231-1
long(长整数) 64 -263~ 263-1
float(单精度) 32 -3.4E38~3.4E38
double(双精度) 64 -1.7E308~1.7E308
char(字符) 16 0-65535
boolean true/false
基本数据类型—类型转换:自动类型转换：取值范围小的自动转为取值范围大的
byte?short?int?long?float?double
char ? int?long?float?double
short,char不会互相转换
整个表达式的值不足int时，自动提升为int
强制类型转换：取值范围大的强制转为取值范围小的 如：
long l = 100L; int i = (int)l;
注意：有可能造成精度降低或数据溢出，使用时要注意
boolean 类型不能转换成任何其它基本数据类型
jsp内置对象
是web容器创建的一组对象，不使用new关键就是可以内置对象。
<%
int[] value={60,70,80};
for(int i:value){
out.println(i)
}
%>
九大内置
常使用：
page ： 1 作用范围仅限用户请求当前也页面 对page 对象引用通常存储在pagecontext对象中
out：
void: println() print() 打印
claer() ：清空缓冲区的内容 如果flush之后调用抛出异常
clearBuffer():清空缓冲区的内容 如果flush之后不会调用抛出异常
flush()将缓冲内容输出到客户端
getBufferSize（）：返回缓冲器以字节数大小 如不设置缓冲区为0
getRemaining()返回缓冲区还剩下多少可用
isAutoFlush（）返回缓冲区满时 自动清空还是抛出异常
close（）关闭输出流
request 2 请求代表用户一次请求 一个http请求的处理肯需要多个Servlet合作
String getParameter（String name）返回name指定名称参数值
response
session 3 同一浏览器对服务器多次访问 httpSession接口实现的
application 4 服务器启动到关闭整段时间
page pageconte
exxeption config
百度网盘： http://pan.baidu.com/share/link?shareid=427617690&uk=3979517138#list/path=%2FJava%2F%E6%AF%95%E5%90%91%E4%B8%9C-JAVA%E5%9F%BA%E7%A1%80%E5%BC%80%E5%8F%91%E8%A7%86%E9%A2%91
java字符串大写转小写，小写转大写
String test="ABC34cccddee";
System.out.println(test.toUpperCase());//小写转大写
String test="ABC34cccddee";
System.out.println(test.toLowerCase());小写转大写
链接：https://pan.baidu.com/s/1qY8nASO 密码：k9g2
链接：http://pan.baidu.com/s/1nvobfuD 密码：bw2l
链接：http://pan.baidu.com/s/1slHFasl 密码：n11d
链接：http://pan.baidu.com/s/1nvJOR2p 密码：0myz
2、 分配空间
简单地说，就是指定数组中最多可存储多少个元素
语法： 数组名 = new 数据类型 [ 数组长度 ];
其中，数组长度就是数组中能存放元素的个数，如：
话说，我们也可以将上面的两个步骤合并，在声明数组的同时为它分配空间，如：
3、 赋值
分配空间后就可以向数组中放数据了，数组中元素都是通过下标来访问的，例如向 scores 数组中存放学生成绩
4、 处理数组中数据
我们可以对赋值后的数组进行操作和处理，如获取并输出数组中元素的值
在 Java 中还提供了另外一种直接创建数组的方式，它将声明数组、分配空间和赋值合并完成，如
它等价于：
JSP Java Server Pages
是为了简化动态网页开发而发明的技术
运行时会被编译成Java代码
实际上JSP与后面要学习的Sevlet关系密切
JSP是非常古老的技术，和大家年龄差不多
JSP可以大大地帮我们偷懒<%@ page … %>
page指令：为JSP的编译提供一些信息
application对象
字面意思应用程序
可以提供整个应用程序的信息
out对象
字面意思是输出
可以向页面上输出文字等信息。
常说JSP有9大内置对象，我们后面会详细介绍
Object count = application.getAttribute("index-count");
Object 类型名
Java是强类型语言
Java中的数据是有类型的
Object是Java中最基本的类型
count 变量名
变量是一个符号，代表一个数据，本例中是访问次数
count的类型是Object
= 赋值
把右边的值赋给左边的变量
application.getAttribute(“index-count”);
application是内置对象
.getAttribute()调用内置对象的getAttribute方法，从应用对象中获取数据
“index-count”是调用函数的参数，指明要获取哪个数据，“”表示字符串类型
Java中有很多类型，整数如3，小数如3.14，表示真假的布尔类型如true
Java的代码需要英文分号;结尾
生活中有很多事情需要抉择，写代码也一样
if/else，基本分支判断
if () 括号中的值是true时执行if花括号中的代码
false时执行else花括号中的代码
> 大于 表达式 1 > 2 的值是 false
< 小于 表达式 1 < 2 的值是 true
== 等于 表达式 1 == 2 的值是 false
!= 不等于 表达式 1 != 2 的值是 true
null 表示没有任何值，是Java中特殊的值
count != null 用于判断count又没有有效值
out.println(value)
将value输出到页面上，后面还带换行
转换成整数
强类型语言需要转换成相应类型才能使用（相加）
将变量c自己加1
存储在应用程序对象中
带参数方法的返回值可以为 void
同一个类中,方法名相同,方法参数个数,顺序,类型
不同的方法称为方法的重载,
与方法的修饰符或返回值没有关系.
配置文件
/index.jsp配置首页
改端口
conf/server.xml
< Connector port="8080"
protocol="HTTP/1.1"
connectionTimeout="20000"
redirectPort="8443"
/>
默认继承 Object 的 toString( ) 方法，输出对象地址
private
setter
getter
com.imooc.music.MyClassMuisc
com.imooc.movie.MyClassMuisc
import com.imooc.movie.MyClassMuisc
包是小写的
继承
private不行
class子类extends父类
class Dog extends Ainmal
{
}
final 最终得含义
可以修饰类 方法 属性 变量
修饰的类 该类不允许被继承
修饰方法 不允许被覆盖
选其一
只能赋一次值
super
对象的内部使用 代表父类的对象
访问父类的属性
super.age
访问父类的方法
super.eat();
Object tostring()方法
哈希code码对象的地址字符串
重写tostring
equals（）方法
比较的是对象的（引用）是否指向同一块内存地址
接口中方法不能有方法体，同时方法的访问修饰符不能是 private 和 protected
abstract关键字修饰 则该类为抽象类
abstract定义抽象类
接口 可以为一种特殊的类，有局部常量和公共的抽象方法所组成的
不关心类的内部数据
interface关键字
继承 用public abstract 可以多继承很多父类
public static final修饰符 系统自动加上
impieme关键字
【修饰符】class类名 extends父类 implements接口1 接口2{
}
如果继承父类 继承父类必须在实现接口之前
接口在使用的过程当中 经常与匿名内部类配合使用
匿名内部类就是没有名字的内部类
多用于关注而不关注实现类的名称
Interface i=new Interface(){
public void method(){
System.out.println("匿名内部类实现接口的方法");
};
uml
统一建模语言
14用例图
uml工具
Visio Rational Rose PowerDesign
异常处理
throwable
error 终结者
Exception 异常 编码
RuntimeException ：
空指针异常
数组下标越界异常
类型转换异常
算数异常
检查异常
try-catch以及try-catch-finally
try{
//一些抛出异常方法
}catch（Exception e）{
//处理该异常的代码块
}
子到父异常处理
在需要频繁对字符串进行修改操作时使用 StringBuilder 的效率比 String 要高
jsp jcp 面向对象opp与c++相同
基本类型是不能调用方法的，而其包装类具有很多方法
集合框架 一种工具类 类的内部 对数据进行组织
简单而有效的搜索大量的条数
有的集合接口 提供一系列的排序的元素 并且可以在序列中快速插入和删除
有集合接口 提供了映射关系 可以通过关键字Key快速查找对应的唯一性对象 而且对于关键字可以是任意的类型
数组的长度固定 集合长度可变
数组只能通过下标访问元素 类型固定，而有的集合可以通过任意的类型查找所在的具体的对象
集合框架 collection：list：arraylist queue：linkedlist set：hashset
Map：hashMap key value entry键值对
collection接口：list set queue接口与父接口
定义可用于操作list set queue的方法--增删改查
list的接口 -----arraylist接口：数组序列
get post
使用request对象的getParameterValues（）方法实现复选框信息获取
请求重定向是客户器端行为而请求转发是服务器端行为
http://spring.io/
http://projects.spring.io/spring-framework/
什么是软件框架
为什么使用框架
易于上手
IOC及Bean容器
java8接口可以方法体
java接口及声明，声明一些方法对外公开的提供
结构设计 调用外层提供一组功能接口
IOC控制反转 控制权的转移，应用程序本身不负责依赖对象的创建和维护，而是由外部容器负责创建和维护
DI（依赖注入）是一种实现的方式Dependency
目的：创建对象并且组装之间的关系
接口： 是用于隐藏具体的实现和实现多台性的组件
IOC房屋中介
找IOC容器
容器返回对象
使用对象
iteratoriterator返回在此collection的元素进行迭代
泛型 ：规定某一个集合只存放特定的类型的对象
编译期间检查
泛型子类型
set接口 ：元素无序并且不可以重复的集合 被称为集
hashset：set的一个重要实现
OC是什么?ios 编码
会话保存在服务器的内存里
session的生命周期
当客户端第一次访问jsp或者Servlet时候，服务器为当前创建一个SeesionID，每一次客户端向服务器发送请求 都会SessionID带 服务器会对SeesionID进行校验
旧的在服务器 除非超时 销毁
10
//单位分钟
除非本次会话的所有页面都关闭后再重新访问某个JSP或者Servlet将会创建新的会话
application对象
实现了用户数据的共享，可放全局变量
开始服务器的启动，终止于服务器的关闭
在任何地方对application对象属性的操作 都将影响到其他用户的访问
服务器的启动和关闭决定了application对象的生命
application对象ServletContext类的实例
setAttribute方法参数第一个为字符串，第二个参数为需要保存的对象
page对象 类似this指针 java.lang.Object类
数据库
字符集GBK
系统的架构MVC
视图层----jsp页面
控制层------Servlet
模型层------------------javaBean设计--数据bean--处理bean 数据库设计
界面设计index.jsp
管理员首页admin_index.jsp
封装是把过程和数据包围起来，对数据的访问只能通过已定义的接口。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。封装是一种信息隐藏技术，在java中通过关键字private，protected和public实现封装。什么是封装？封装把对象的所有组成部分组合在一起，封装定义程序如何引用对象的数据，封装实际上使用方法将类的数据隐藏起来，控制用户对类的修改和访问数据的程度。 适当的封装可以让程式码更容易理解和维护，也加强了程式码的安全性。
例子
编辑
封装的简单例子：
先来个例子看看；
public class Man
{
//对属性的封装，一个人的姓名，年龄，妻子都是这个对象（人）的私有属性
private String name;
private int age;
private Woman wife;
//对该人对外界提供方法的封装，可以设定妻子，姓名，年龄也可以获得男人的姓名和年龄
// 方法封装
public void setWife(Woman wife) {
this.wife = wife;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
public class Woman {
// 属性封装
private String name;
private int age;
private Man husband;
// 方法封装
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Man getHusband() {
return husband;
}
public void setHusband(Man husband) {
this.husband = husband;
}
}
/**
* 仔细看就会发现，Man类没有提供getWife的方法，这是因为男人不想让自己的妻子被外界访问，
*
* 接下来呢，就是封装可以把一个对象的属性私有，而提供一些可以被外界访问的属性的方法，
*
* 比如说，name属性，Man和Woman类都有相应的get和set方法，外界都可以通过这些方法访问和修改
*
* 同时对一些对象不想让外界访问的属性，就不提供其方法，比如说Man的wife属性，就没有get方法
*
* 外界是不能得到Man类的wife属性的
*
*/
上面那例子可能没有突出封装的好处，下面来个超简单的表达下：
public class Show
{
public static void show(String str)
{
System.out.println(str);
}
}
上面就是对 System.out.println();的封装。
调用的时候 ：
public class Use
{
public static void main(String[] args)
{
Show.show("封装")；
}
}
这样用的时候就不用使：System.out.println("封装")；
equals(Object obj)
http://developer.amap.com/
tomcat容器
servlet的容器context容器 一个context对应web工程
servlet
继承httpservlet
重写doGet（）或者dopost（）方法
在web.xml中注册servlet
编写servlet
src new Servlet
重写doGet（）或者doPost（）
部署运行
localhost是服务器主机名，也可以是IP地址127.0.0.1；8080是tomcat服务器的端口号；helloapp是web工程的上下文地址ContexRoot（一般情况下与web工程名一致）；最后是
get方式请求helloServlet -----
生命周期
开始 servlet实例是否存在---> 装载Servlet类创建实例
调用init（Servlet）方法---->Servlet(Servlet Request Servlet Response)方法
服务器关闭
调用Destroy方法
编写Servlet的doPost方法时，需要抛出ServletExcpetion和IOException异常。
servlet容器启动自动 只需要在web.xml添加
1
数字越小优先级越高
init（）方法只能被调用一次
不同的字符串转换用SimpleDateFormate转换
不覆盖service()方法，不是因为该方法是空，而是因为sevrvice( )方法会调用doPost或者doGet方法
相对路径 相对于当前资源的路径
绝对路径 放之四海而皆准的路径
请求重定向的方式跳转test.jsp相当于ServletpatthDirection/servlet
respone.sendRedirect(request.getcontextPath（)+"text.jsp")
服务器内部跳转
request.getRequestDispatch（"/text.jsp"）.forward
(requset,responet)
Servlet的初始化参数是从ServletConfig中获得的。
运行：services.msc，打开服务管理器，找到“VisualSVNServer”。
2 在服务上，点击右键--属性，打开“登录”选项卡。将“此帐户”改成“本地系统帐户”。再回到安装程序弹出窗口处，选择"Retry"即可。
很多方法都尝试了不行，准备放弃的时候，不选择本地账户，选择此账户用administrator 管理员密码，结果retry成功
Java-Reflect专题
class类的使用
方法的反射
成员变量的反射
构造函数的反射
java类加载机制
class.forName("类的全称")
不仅表示了类的类类型 还代表的动态加载类
编译 运行
编译时刻加载类是静态加载类 运行时刻加载类是动态加载类
//软件动态升级
class Office{
public static void main（String[] args）{
//new创建对象 是静态加载类 在编译的时刻就需要加载所有的可能使用到的类
//通过动态加载类可以解决该问题
if("Word".equal（args[0]）){
Word w=new Word();
w.start();
}
if("Excel".equal（args[0]）){
Excel e=new Excel();
e.start();
}
}
class OfficeBetter{
public static void main(String[] args){
try{
//动态加载类，在运行时刻加载
class c= calss.forNmae(args[0])
//通过类类型 创建该类的对象
OfficeAble oa=(OfficeAble)c.newInstance();
oa.start();
}
catch(Exception e){
e.printStackTrace();
}
}
}
//创建一个标准
interface OfficeAble{
public void start();
}
//Word
class Word implements OfficeAble{
public void start()
{
System.out.println（"word...start...."）
}
}
Class c1=int.Class；
System.out.println（c1.getName（））
打印int类型
class c2=String.class；
System.out.println（c1.getSimpleName（））
不包含包名的类的名称
基本的数据类型
void关键字 都存在类类型
class api
package com.imooc.reffert;
public class ClassDem3 {
public static void main(String[] args) {
// TODO Auto-generated method stub
String s="hello";
ClassUtil.printClassMessage(s);
}
}
package com.imooc.reffert;
import java.lang.reflect.Method;
public class ClassUtil {
// 打印类的信息 包括类的成员函数 成员变量
public static void printClassMessage(Object obj) {
// TODO Auto-generated method stub
//获取类的信息 首先获取类的类类型
Class c=obj.getClass();//传递的那一个子类的对象 c就是该子类的类类型
//获取类名称
System.out.println("类的名称："+c.getName());
//Method类，方法的对象 一个成员方法就是一个Method对象
//getMethods()方法获取所有public函数 包括父类继承而来的
Method[] methods=c.getMethods();// c.getDeclaredMethod()
//c.getDeclaredMethod();getDeclaredMethod()h获取所有类的自己的声明的方法 不访问权限
for (int i = 0; i < methods.length; i++) {
//得到方法返回值类型的类类型
Class returnType=methods[i].getReturnType();
System.out.print(returnType.getName()+"(");
//方法的名称
System.out.print(methods[i].getName());
//获取参数类型
Class[] paramTypes=methods[i].getParameterTypes();
for (Class class1 : paramTypes) {
System.out.print(class1.getName()+",");
}
System.out.println(")");
}
}
}
类的名称：java.lang.String
boolean(equalsjava.lang.Object,)
java.lang.String(toString)
int(hashCode)
int(compareTojava.lang.String,)
int(compareTojava.lang.Object,)
int(indexOfjava.lang.String,int,)
int(indexOfjava.lang.String,)
int(indexOfint,int,)
int(indexOfint,)
java.lang.String(valueOfint,)
java.lang.String(valueOflong,)
java.lang.String(valueOffloat,)
java.lang.String(valueOfboolean,)
java.lang.String(valueOf[C,)
java.lang.String(valueOf[C,int,int,)
java.lang.String(valueOfjava.lang.Object,)
java.lang.String(valueOfchar,)
java.lang.String(valueOfdouble,)
char(charAtint,)
int(codePointAtint,)
int(codePointBeforeint,)
int(codePointCountint,int,)
int(compareToIgnoreCasejava.lang.String,)
java.lang.String(concatjava.lang.String,)
boolean(containsjava.lang.CharSequence,)
boolean(contentEqualsjava.lang.CharSequence,)
boolean(contentEqualsjava.lang.StringBuffer,)
java.lang.String(copyValueOf[C,)
java.lang.String(copyValueOf[C,int,int,)
boolean(endsWithjava.lang.String,)
boolean(equalsIgnoreCasejava.lang.String,)
java.lang.String(formatjava.util.Locale,java.lang.String,[Ljava.lang.Object;,)
java.lang.String(formatjava.lang.String,[Ljava.lang.Object;,)
void(getBytesint,int,[B,int,)
[B(getBytesjava.nio.charset.Charset,)
[B(getBytesjava.lang.String,)
[B(getBytes)
void(getCharsint,int,[C,int,)
java.lang.String(intern)
boolean(isEmpty)
java.lang.String(joinjava.lang.CharSequence,[Ljava.lang.CharSequence;,)
java.lang.String(joinjava.lang.CharSequence,java.lang.Iterable,)
int(lastIndexOfint,)
int(lastIndexOfjava.lang.String,)
int(lastIndexOfjava.lang.String,int,)
int(lastIndexOfint,int,)
int(length)
boolean(matchesjava.lang.String,)
int(offsetByCodePointsint,int,)
boolean(regionMatchesint,java.lang.String,int,int,)
boolean(regionMatchesboolean,int,java.lang.String,int,int,)
java.lang.String(replacechar,char,)
java.lang.String(replacejava.lang.CharSequence,java.lang.CharSequence,)
java.lang.String(replaceAlljava.lang.String,java.lang.String,)
java.lang.String(replaceFirstjava.lang.String,java.lang.String,)
[Ljava.lang.String;(splitjava.lang.String,)
[Ljava.lang.String;(splitjava.lang.String,int,)
boolean(startsWithjava.lang.String,int,)
boolean(startsWithjava.lang.String,)
java.lang.CharSequence(subSequenceint,int,)
java.lang.String(substringint,)
java.lang.String(substringint,int,)
[C(toCharArray)
java.lang.String(toLowerCasejava.util.Locale,)
java.lang.String(toLowerCase)
java.lang.String(toUpperCase)
java.lang.String(toUpperCasejava.util.Locale,)
java.lang.String(trim)
void(wait)
void(waitlong,int,)
void(waitlong,)
java.lang.Class(getClass)
void(notify)
void(notifyAll)
java.util.stream.IntStream(chars)
java.util.stream.IntStream(codePoints)
/*成员变量也是对象
java.lang.reflect.Field
Field类封装了关于成员变量操作
getField（）方法获取的是所有public成员变量的信息*/
// Field[] fsFields=c.getFields();
//getDeclaredFields()获取的是该类型自己的声明的成员变量的信息
Field[] fields=c.getDeclaredFields();
for (Field field : fields) {
//的到成员变量类型的类类型
Class fieldType=field.getType();
String typeName=field.getName();
//的到成员变量的名称
String filedName=field.getName();
System.out.println(typeName+""+typeName);
}
package com.imooc.reffert;
public class ClassDemo5 {
public static void main(String[] args) {
// TODO Auto-generated method stub
ClassUtil.printConMessage("hello");
ClassUtil.printConMessage(new Integer(1));
}
}
package com.imooc.reffert;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import javax.security.auth.callback.LanguageCallback;
public class ClassUtil {
// 打印类的信息 包括类的成员函数 成员变量
public static void printClassMessage(Object obj) {
// TODO Auto-generated method stub
//获取类的信息 首先获取类的类类型
Class c=obj.getClass();//传递的那一个子类的对象 c就是该子类的类类型
//获取类名称
System.out.println("类的名称："+c.getName());
//Method类，方法的对象 一个成员方法就是一个Method对象
//getMethods()方法获取所有public函数 包括父类继承而来的
Method[] methods=c.getMethods();// c.getDeclaredMethod()
//c.getDeclaredMethod();getDeclaredMethod()h获取所有类的自己的声明的方法 不访问权限
for (int i = 0; i < methods.length; i++) {
//得到方法返回值类型的类类型
Class returnType=methods[i].getReturnType();
System.out.print(returnType.getName()+"(");
//方法的名称
System.out.print(methods[i].getName());
//获取参数类型
Class[] paramTypes=methods[i].getParameterTypes();
for (Class class1 : paramTypes) {
System.out.print(class1.getName()+",");
}
System.out.println(")");
//pringFieldMessage(c);
}
}
// 成员变量
//private static void pringFieldMessage(Class c) {
public static void pringFieldMessage(Object object) {
Class c=object.getClass();
/*成员变量也是对象
java.lang.reflect.Field
Field类封装了关于成员变量操作
getField（）方法获取的是所有public成员变量的信息*/
// Field[] fsFields=c.getFields();
//getDeclaredFields()获取的是该类型自己的声明的成员变量的信息
Field[] fields=c.getDeclaredFields();
for (Field field : fields) {
//的到成员变量类型的类类型
Class fieldType=field.getType();
String typeName=field.getName();
//的到成员变量的名称
String filedName=field.getName();
System.out.println(typeName+""+typeName);
}
}
// 打印构造函数的信息
public static void printConMessage(Object obj){
Class c=obj.getClass();
// 构造函数也是对象
// java.lang.Constructor封装了构造信息
//getConstructors()获取public的构造函数
//getDeclaredConstructors得到所有的构造函数
//Constructor[] cs=c.getConstructors();
Constructor[] cs=c.getDeclaredConstructors();
for (Constructor constructor : cs) {
System.out.print(constructor.getName()+"(");
//获取构造函数参数列表--》得到参数列表的类类型
Class[] paramTypes=constructor.getParameterTypes();
for (Class class1 : paramTypes) {
System.out.print(class1.getName()+",");
}
System.out.println(")");
}
}
}
java.lang.String([B,int,int,)
java.lang.String([B,java.nio.charset.Charset,)
java.lang.String([B,java.lang.String,)
java.lang.String([B,int,int,java.nio.charset.Charset,)
java.lang.String([B,int,int,java.lang.String,)
java.lang.String([C,boolean,)
java.lang.String(java.lang.StringBuilder,)
java.lang.String(java.lang.StringBuffer,)
java.lang.String([B,)
java.lang.String([I,int,int,)
java.lang.String()
java.lang.String([C,)
java.lang.String(java.lang.String,)
java.lang.String([C,int,int,)
java.lang.String([B,int,)
java.lang.String([B,int,int,int,)
java.lang.Integer(int,)
java.lang.Integer(java.lang.String,)
方法的反射
获取方法
方法的名称和方法的参数列表才能唯一决定某一个方法
方法的反射操作
method.invoke（对象，参数列表）
package com.imooc.reffert;
import java.lang.reflect.Method;
public class Methoddemo1 {
private static Method m2;
public static void main(String[] args) {
// TODO Auto-generated method stub
//要获取print（int ，int）方法
//要获取一个方法就是获取类的信息 获取类的信息首先要获取类的类型
A a1=new A();
Class c=a1.getClass();
//getMethod获取的public的方法
//获取方法 必须要有名称与参数列表来决定
//c.getMethod(name, parameterTypes)
//getDeclaredMethod自己声明的方法
//c.getDeclaredMethod(name, parameterTypes);
/* try {
//Method m=c.getMethod("print", new Class[]{int.class,int.class});
} catch (NoSuchMethodException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SecurityException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}*/
try {
Method m=c.getMethod("print", int.class,int.class);
//方法反射操作
//方法的反射操作是用m对象来进行方法调用和a1.print调用效果完全相同
//方法如果没有返回值null 有返回值具体的返回值
Object o=m.invoke(a1,10,20);
//Object o=m.invoke(a1,new Object[]{10,20});
//a1.print(10, 20);
System.out.println("================");
//获取print(String,String)
Method m1=c.getMethod("print", String.class,String.class);
//用方法进行反射操作
//a1.print("hello", "world");
o=m1.invoke(a1, "hello","WORLD");
System.out.println("================");
//Method m2=c.getMethod("print", new Class[]{});
Method m2=c.getMethod("print");
//m2.invoke(a1, new Object[]{});
m2.invoke(a1);
} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
}
}
}
class A{
public void print(){
System.out.println("helloworld");
}
public void print(int a,int b){
System.out.println(a+b);
}
public void print(String a,String b){
System.out.println(a.toUpperCase()+","+b.toUpperCase());
}
}
30
================
HELLO,WORLD
================
helloworld
通过Class Method认识泛型的本质
package com.imooc.reffert;
import java.lang.reflect.Method;
import java.util.ArrayList;
public class MethodDemo4 {
public static void main(String[] args) {
// TODO Auto-generated method stub
ArrayList list=new ArrayList();
ArrayListlist1=new ArrayList();
list.add("hello") ;
//list1.add("hello")
Class class1=list.getClass();
Class class2=list1.getClass();
System.out.println(class1==class2);
//反射的操作都是编译之后的操作
//c1==c2结果返回true说明编译之后集合的泛型是去泛型化的
//java中集合的泛型，是防止错误输入的 值在编译阶段有效
//绕过编译就失效了
//验证 我们可以通过方法的反射来操作，绕过编译
try {
Method m=class1.getMethod("add", Object.class);
m.invoke(list1, 20);//绕过编译操作就绕过泛型
System.out.println(list1.size());
System.out.println(list1);
/* for (String string : list1) {
System.out.println(string);
}*/
//现在不能这样遍历 类型不对
} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
}
}
}
true
1
[20]
File类的使用
RandomAccessFile的使用
字节流的使用
字符流的使用
对象的序列化和反序列化
java.io.File类的文件项目
file类的表示（目录）的信息（名称 大小）不能用于文件内容的访问
IO流（输入流 输出流）
字节流 字符流
1>InputStream OutputStream
InputStream抽象了应用程序读取数据的方式
OutputStream抽象了应用程序写的数据的方式
2>
EOF=End 读到-1就读到结尾
3>输入流基本方法
int b=in.read（）;读取一个字节无符号填充到int低八位 -1是EOF
in.read（byte[] buf）读取的数据填充到字节数组buf
in.read（byte[] buf,int start ,int size）读取数据到字节数组buf从buf的start位置开始存放size的长度的数据
4>输入流基本方法
out.write（int b）写出一个byte到流 b的低八位
out.write（byte[] buf）将buf字节数组都写到流
out.write（byte[] buf，int start ，int size）
5>
FileInputStream-->具体实现了
float f_val=45.0f或者float f_val=45.0F
需求
分析需求 拆解需求
实现功能代码
分发各个模块功能
请求响应
客户端与浏览器交互
html缓存代码
JPA是什么？？
java虚拟机？？？
minfest-Version 版本1.0
Class-path：class路径 打jar包 引用jar包
js--->静态页面动起来
jquery--->代码少 类库 库
web App library 放入jar包
ftr 视图文件 放在WEB-INF
lib 放入jar包
Build Path
orader and Export导出
我们在卸载MySQL的时候，会发现有一个名为“Connector Net X.X.X”（如：Connector Net 6.9.3）软件总是卸载不成功，下面我们来看看解决方法：
1. 在C盘的目录下，有一个隐藏文件——ProgramData，进入C:\ProgramData\MySQL\，删除里面所有文件及文件夹；
2. 进入注册表（win7：开始-运行-regedit；win8:Ctrl+R，输入regedit）；
3. Ctrl+F，输入Connector Net X.X.X（根据自己的版本来），查找相关文件，并删除，循环此步骤，直到注册表中再也查不到Connector Net X.X.X;
到此为止，Connector Net X.X.X成功卸载。
web.xml
javascirpt
20170418课堂笔记知识点
web页面
html技术
HyperText Markup Language，超级文本标记语言。
“超文本”就是指页面内可以包含图片、链接，甚至音乐、程序等非文字元素。
超文本标记语言的结构包括“头”部分（英语：Head）、和“主体”部分（英语：Body），其中“头”部提供关于网页的信息，“主体”部分提供网页的具体内容。
CSS技术
Cascading Style Sheets，层叠样式表。
是用来表现HTML等文件样式的计算机语言。
JavaScript技术
缩写JS，脚本语言。
Java技术
功能强大，应用范围广。
作业：
安装火狐浏览器
改动视图：Windows——》Show View
-------------------------------------
Debug 调试
Eclipse 快捷键"Alt+/"
.sh后缀是liunx
javabean
就是符合特定的规范的java类 使用javabean的好处是解决代数的重复编写 减少代码的冗余。功能区的分明 提供代码的维护性
javabean的设计原则 公有类 无参的公有构造方法
属性私有
getter和setter方法封装
public class Student{
private String age；
private int age；
public Students（）{}
public void setName（String name）{this.name=name；}
public String getName（）{return this.name；}
public void setAge（int age）{this.age=age}
public int getAge（）{return this.age；}
}
jsp动作
jsp动作元素 动作元素为请求处理的阶段提供信息 动作元素遵循xml元素的语法 有一个包含元素名的开始标签 可以有属性 可选的内容 与开始标签匹配的结束标签
jsp中如何使用javabean
1.使用普通的Java类一样 创建Javabean实例
2.在jsp页面中通常使用jsp动作标签使用javabean
javabean的四个作用域范围
Model简介
注解
框架相关代码
代码
spring Mybatis
自定义注解
jdk自带注解
@Override @Deprecated @suppvisewarnings
第三方注解
Spring ：
@Autowired：
@Service ：
@Repository：
Mybatis：
@InsertProvider：
@UpdateProvider：
@Options：
@inherted允许子类继承
@Documented 生成javadoc时会包含注解
@interface 注解
成员类型受限制 合法的类型包括原始类型的及String Class Annotation Enumeration
如果注解只有一个成员 则成员必须取名为Vvalue（） 在使用可以忽略成员名与赋值好（=）
没有成员 元注解
注解分类
源码注解
编译注解.class文件中
运行注解
元注解
自定义注解
语法
@<注解名>（<成员名1>=<成员值1>,<成员名1>=<成员值1>）
持久层架构 用来替代HIbernate
注解的作用范围 @Target和生命周期@Retention
包 类 字段 方法 方的参数 局部变量
1．未部署Web应用
2．URL输入错误
a.查看URL的IP地址和端口号是否书写正确。
b.查看上下文路径是否正确 Project--------Properties------MyElipse-----Web----- Web Context-root检查这个路径名称是否书写正确。
c.检查一下文件名称是否书写正确。
3．目录不能被引用
在 Eclipse的“包资源管理器(Package Explorer)”检查文件存放的位置。由于META-INF WEB-INF文件夹下的内容无法对外发布，所以，如果你引用了带这两个目录的文件，肯定是不允许。
例如： http://localhost:8080/guestbook/WEB-INF/index.html就是错误的,文件位置存放错误
4． Tomcat服务器中web.xml中的问题
如果你的web应用程序有多个jsp页面的话，当你点击你web应用程序的虚拟根目录时可能会出现404错 误，只是你只需要修改Tomcat服务器中web.xml
listings
false(将其该为true)
5．WEB-INF下面必须要有几个固定的文件夹和文件
web.xml 该web app的配置文件
lib 该web app用到的库文件
classes存放编译好的servlet
请注意他们的名字，我曾经就由于把classes写成class，查错查了半宿还没解决，所以写这些的时候千万要仔细，否则浪费更多的精力去查错。
6． 如果要运行的不是.jsp文件，而是servlet（.class）文件，要配置web.xml(当然是WEB-INF下面的)，加上以下字段：
HelloWorldServlet
HelloWorldServlet
HelloWorldServlet
/HelloWorldServlet
其中的“HelloWorldServlet”改为你要运行的文件名
7．其他解决思路
以上方法无果,介于"HTTP Status 404(The requested resource is not available"异常发生情况的多样性,采用替换大法:
步骤:
a.找一份正常的相同环境(找同学同事相同开发环境机子或者网上下载的正常demo等)
b.依次替换问题项目文件,进行排除,定位.直到解决.
servlet
一、表单提交时出现乱码：
在进行表单提交的时候，经常提交一些中文，自然就避免不了出现中文乱码的情况，对于表单来说有两种提交方式：get和post提交方式。所以请求的时候便有get请求和post请求。以前我一直以为get请求和post请求方式出现的乱码的解决方式是一样的，但是今天才知道两种请求方式所产生的乱码的解决方式是不同的。每种方式都有着不同的解决方法，之所以出现乱码，原因就在于get请求时，其传递给服务器的数据是附加在URL地址之后的；而post的请求时，其传递给服务器的数据是作为请求体的一部分传递给服务器。这也就导致了对它们所产生的乱码的处理方式是不同的。
1、客户端的get请求
对于不同的请求方式，解决乱码的问题也是不一样的，对于客户端的get请求来说，服务器端处理要想不出现乱码，解决这个问题稍微复杂一些，需要用到String类型的构造函数，其中的一个构造函数就是用指定的编码方式去解码，一般都用“UTF-8”的方式。只要在服务器端将请求得到的参数重新构造成一个字符串就行了。如下所示：
String stuname = request.getParameter("stuname");
String str = new String(stuname.getBytes("ISO-8859-1"),"utf-8")
经过构造之后，客户端输入中文，且表单时get请求的情况下，str就变成了中文了。如果请求参数比较多，最好将它封装成一个工具类：
public class MyUtil
{
public static String getNewString(String str) throws UnsupportedEncodingException
{
return new String(str.getBytes("ISO-8859-1"),"UTF-8");
}
}
String stuname= MyUtil.getNewString(request.getParameter("stuname"));
2、客户端的post请求
对于客户端的post请求来说，处理乱码的问题就比较简单了，因为请求的数据时作为请求体的一部分传递给服务器的，所以只要修改请求内的编码就行了。只要在服务器端的最开始处将请求的数据设置为“UTF-8”就行了，输入如下语句：
request. setCharacterEncoding(“UTF-8”);
这样用户在服务器端获取到的中文数据就不再是乱码了。
二、超链接时出现乱码（低版本浏览器不行IE6）
在Web开发中，挺多的时候都是通过超链接去传递中文参数的，这也会导致在显示的时候也会出现乱码，对于超链接来说，它实际上是向服务器端发送了一个请求，而它发出的请求是属于get请求，所以对于超链接的乱码来说，它处理乱码的方式和表单的get请求出现乱码的方式是一样的。
String stuname= MyUtil.getNewString(request.getParameter("stuname"));
三、重定向时出现乱码（低版本浏览器不行IE6）
有时写上response的sendRedirect()方法进行重定向时也会出现乱码，重定向时实际上也是向服务器发送了一个请求，所以解决乱码的方法和和上面是一样的。
四、浏览器版本低导致的乱码
上网的时候，有时提交的一些信息在地址栏显示的是“%2C%C6%CC%C6”的字样，其实这都是防止出现乱码进行的解决方案，如果你的浏览器是IE6或以下版本，则我们的第二种情况和第三种情况会出现乱码(尤其是当中文是奇数的时候)，这就不好使了所以我们必须采用另一种比较实际的作法：
在Java.NET包中提供了URLEncoder类和URLDcoder类，这两个类又分别提供了encode和decode两个静态方法，分别用于进行编码和解码。我们将要传递的中文参数进行编码之后，在传递给服务器，服务器解码之后，就可以显示中文了。
进行编码：URLEncoder.encode(stuname,”UTF-8”)
传递给服务器：”>传递
进行解码：URLDecoder.decode(stuname,”UTF-8”);
这样就可以得到传递过来的中文参数了，我发现许多网站用的都是这种方式解决中参数的。
五、返回浏览器显示的乱码
在Servlet编程中，经常需要通过response对象将一些信息返回给浏览器，给我们的客户端，而我们在服务器端显示的中文，但是响应给客户端浏览器却是乱码，这主要是由于response对象的getWriter()方法返回的PrintWriter对象默认使用“ISO-8859-1”字符集编码进行Unicode字符串到字节数组的转换，由于ISO8859-1字符集中根本就没有包含中文字符，所以Java在进行转换的时候会将无效的字符编码输出给客户端，于是便出现了乱码，为此ServletResponse接口中便定义了setCharacterEncoding、setContentType等方法来指定getWriter方法返回的PrintWriter对象所使用的字符集编码，所以我们在写Servlet程序中，在调用getWriter方法之前设置这些方法的值。我们为了防止乱码，经常将以下两条语句一起写上：
response.setContentType(“text/html;charset=utf-8”);
response. setCharacterEncoding(“UTF-8”);
只要编写Servlet文件中含有响应给客户端的信息，那么就要写上这两句话。最好写上第二句话，因为它的优先级高，它的设置结果将覆盖setContentType等方法设置的字符编码集。
六、修改Tomcat的编码
在上述的get请求所导致乱码问题中，还有一种解决的方案，我们常用Tomcat作为运行Servlet和JSP的容器，而Tomcat内部默认的编码是ISO-8859-1，所以对于get请求方式，其传递的数据(URI)会附加在访问的资源后面，其编码是Tomcat默认的，如果修改该URI的编码，那么对于所有的get请求方式便不会出现乱码了包括上边说的重定向和超链接，在Tomcat的配置文件server.xml中找到修改Tomcat的端口的地方，在其内部加入URIEncoding属性，设置为和你的项目中所设的编码一样的值，这里全部都是UTF-8。如下所示：
七、使用MySQL数据库乱码
有时会用JDBC连接MySQL数据库，可能会出现乱码，所以要在连接之后加上如下的语句：
useUnicode=true&characterEncoding=UTF-8
这样就可以解决乱码问题了。
在编写Servlet和JSP的时候，为了避免出现乱码，最重要的就是：采用一致的编码，如果编码都一致了，肯定不会出现乱码。如果出现了乱码肯定那个地方不一致了。
css旧知识
table--表格
th----表格列--表头
tr----表行
td--表列
GET www.baidu.com/s?wd=java
post www.baidu.com
from 表单
input 表单 文本 密码 提交
Servlet
简单来说，Java的序列化机制是通过在运行时判断类的serialVersionUID来验证版本一致性的。在进行反序列化时，JVM会把传来的字节流中的serialVersionUID与本地相应实体（类）的serialVersionUID进行比较，如果相同就认为是一致的，可以进行反序列化，否则就会出现序列化版本不一致的异常。(InvalidCastException)
serialVersionUID有两种显示的生成方式： 一个是默认的1L，比如：private static final long serialVersionUID = 1L; 一个是根据类名、接口名、成员方法及属性等来生成一个64位的哈希字段，比如： private static final long serialVersionUID = xxxxL; 当你一个类实现了Serializable接口，如果没有显示的定义serialVersionUID，Eclipse会提供这个 提示功能告诉你去定义 。在Eclipse中点击类中warning的图标一下，Eclipse就会 自动给定两种生成的方式。如果不想定义它，在Eclipse的设置中也 可以把它关掉的，设置如下： Window ==> Preferences ==> Java ==> Compiler ==> Error/Warnings ==> Potential programming problems 将Serializable class without serialVersionUID的warning改成ignore即可。
当实现java.io.Serializable接口的实体（类）没有显式地定义一个名为serialVersionUID，类型为long的变量时，Java序列化机制会根据编译的class(它通过类名，方法名等诸多因素经过计算而得，理论上是一一映射的关系，也就是唯一的)自动生成一个serialVersionUID作序列化版本比较用，这种情况下，如果class文件(类名,方法明等)没有发生变化(增加空格,换行,增加注释,等等),就算再编译多次,serialVersionUID也不会变化的.
如果我们不希望通过编译来强制划分软件版本，即实现序列化接口的实体能够兼容先前版本，未作更改的类，就需要显式地定义一个名为serialVersionUID，类型为long的变量，不修改这个变量值的序列化实体都可以相互进行串行化和反串行化。
如果你没有考虑到兼容性问题时，就把它关掉，不过有这个功能是好的，只要任何类别实现了Serializable这个接口的话，如果没有加入 serialVersionUID，Eclipse都会给你warning提示，这个serialVersionUID为了让该类别 Serializable向后兼容。
问题一:假设有A端和B端,如果2处的serialVersionUID不一致,会产生什么错误呢?
问题二:假设2处serialVersionUID一致,如果A端增加一个字段,B端不变,会是什么情况呢?
问题三:假设2处serialVersionUID一致,如果B段增加一个字段,A端不变,会是什么情况呢?
问题四:假设2处serialVersionUID一致,如果A端减少一个字段,B端不变,会是什么情况呢?
问题五:假设2处serialVersionUID一致,如果B端减少一个字段,A端不变,会是什么情况呢?
例子如下:写2个类,类名相同,字段相同,方法相同.放在不同的包里,来模仿A端和B端.
实体类:在本例中,在测试类SerialTest执行前代表A端,然后,在测试类DeserialTest执行前代表B端.
package com.test; import java.io.Serializable;
public class Serial implements Serializable{ /** * */ private static final long serialVersionUID = 6977402643848374753L; int id; String name; public Serial(int id, String name) { this.id = id; this.name = name; } public String toString() { return "DATA: " + id + " " +name; } }
测试类,代表A端的序列化
package com.test.serializable;
import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.io.ObjectOutputStream;
public class SerialTest {
/** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub Serial serial1 = new Serial(1,"song"); System.out.println("Object Serial"+serial1); try { FileOutputStream fos = new FileOutputStream("serialTest.txt"); ObjectOutputStream oos = new ObjectOutputStream(fos); oos.writeObject(serial1); oos.flush(); oos.close(); } catch (FileNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } }
测试类,代表B端的反序列化
package com.test.serializable;
import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; import java.io.ObjectInputStream;
public class DeserialTest {
/** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub Serial serial2 ; try { FileInputStream fis = new FileInputStream("serialTest.txt"); ObjectInputStream ois = new ObjectInputStream(fis); serial2 = (Serial)ois.readObject(); ois.close(); System.out.println("Object Deserial"+serial2); } catch (FileNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (ClassNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } }
}
问题一:假设有A端和B端,如果2处的serialVersionUID不一致,会产生什么错误呢?
答案如下:
1)先执行测试类SerialTest,然后修改serialVersion值(或注释掉serialVersion并编译),再执行测试类DeserialTest,报错:
java.io.InvalidClassException: com.test.serializable.Serial; local class incompatible: stream classdesc serialVersionUID = 1, local class serialVersionUID = 11
2)A端和B端都没显示的写serialVersionUID,实体类没有改动(如果class文件(类名,方法明等)没有发生变化(增加空格,换行,增加注释,等等),).序列化,反序列化正常.
问题二:假设2处serialVersionUID一致,如果A端增加一个字段,B端不变,会是什么情况呢?
答案二: 序列化,反序列化正常,A端增加的字段丢失(被B端忽略).
问题五:假设2处serialVersionUID一致,如果B端减少一个字段,A端不变,会是什么情况呢?
答案:与问题二类似,序列化,反序列化正常,B端字段少于A端,A端多的字段值丢失(被B端忽略).
问题三:假设2处serialVersionUID一致,如果B段增加一个字段,A端不变,会是什么情况呢?
问题四:假设2处serialVersionUID一致,如果A端减少一个字段,B端不变,会是什么情况呢?(与问题三类似,四答案:序列化,反序列化正常,B端字段多余A端,B端多出的字段被赋予对应类型的默认值)
答案三: 序列化,反序列化正常,B端新增加的int字段被赋予了默认值0.
例子如下:
3)先执行SerialTest,然后在实体类增加一个字段age,再执行测试类DeserialTest.
package com.test.serializable;
import java.io.Serializable;
public class Serial implements Serializable {
/** * */ private static final long serialVersionUID = -2337937881709830076L;
/** * */ //private static final long serialVersionUID = 1L; int id;
String name; public Serial(int id, String name) { this.id = id; this.name = name; } public String toString() { return "DATA: " + id + " " +name; } public int age ;//在B端增加一个新字段 }
相应的修改测试类DeserialTest,打印出age的值.
package com.test.serializable;
import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; import java.io.ObjectInputStream;
public class DeserialTest {
/** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub Serial serial2 ; try { FileInputStream fis = new FileInputStream("serialTest.txt"); ObjectInputStream ois = new ObjectInputStream(fis); serial2 = (Serial)ois.readObject(); ois.close(); System.out.println("Object Deserial"+serial2+" age="+serial2.age); } catch (FileNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (ClassNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } }
}
打印结果如下:
Object DeserialDATA: 1 song age=0
1.创建一个变量
对象类型 变量
2.创建一个对象
new 对象类型（）
3.赋值
对象变量 类型
说明序列化,反序列化正常,B端新增加的int字段被赋予了默认值0.
Format是CString类的一个成员函数，它通过格式操作使任意类型的数据转换成一个字符串。
实上Format方法有两种形式，另外一种是三个参数的，主要区别在于它是线程安全的， 但并不多用，所以这里只对第一个介绍。Format参数是一个格式字符串，用于格式化Args里面的值的。Args是一个变量数组，即它里面可以有多个参数，而且每个参数可以不同。 例如：
Format("my name is %6s","wind");
JDBC:链接数据库
Java data base Connectivity（java数据库连接）
java应用
jdbc加载驱动程序 Class.forName（driverClass）
加载Mysql驱动 Class.forName（"com.mysql.jdbc.Driver"）
j加载Oracle驱动Class.forName （"oracle.jdbc.driver.OracleDriver"）
获取DriverMabager.getConnection （"jdbc:mysql://127.0.0.1:3306/imooc","root","root"）
创建Statement对象：conn.createStatement（）；
jdbc Oracle mysql SQLserver
jdbc常用的接口
jdbc编程步骤
view
contrl
model
db数据库（从下往上）
C
R：高级 报表 分页
U
D
执行的SQL语句
管理结果集
高级应用
分页：
高级查询 ：
高级函数使用：
/*public static void main(String[] args) throws Exception {
//加载驱动程序
Class.forName("com.mysql.jdbc.Driver");
//获得数据库的链接
Connection conn =DriverManager.getConnection(url, user, password);
//通过数据库的链接操作数据库 实现增删改查
Statement stmt=conn.createStatement();
ResultSet rs= stmt.executeQuery("select user_name,age from imooc_goddess");
while (rs.next()) {
System.out.println(rs.getString("user_name")+","+rs.getInt("age"));
}
}*/
Jdbc+odbc桥的方式
Jdbc+厂商的API形式
jdbc+厂商Database Connection
Server+DataBase的形式
特点 在Java与DataBase之间架起了一台专用于数据库连接的服务器（一般由数据库厂商提供）
Jdbc+Databesa
工具 mybatis hibernate
Servlet 通过调用 init () 方法进行初始化。
Servlet 调用 service() 方法来处理客户端的请求。
Servlet 通过调用 destroy() 方法终止（结束）。
最后，Servlet 是由 JVM 的垃圾回收器进行垃圾回收的。
init 方法被设计成只调用一次。它在第一次创建 Servlet 时被调用，在后续每次用户请求时不再调用。因此，它是用于一次性初始化，就像 Applet 的 init 方法一样。
Servlet 创建于用户第一次调用对应于该 Servlet 的 URL 时，但是您也可以指定 Servlet 在服务器第一次启动时被加载。
当用户调用一个 Servlet 时，就会创建一个 Servlet 实例，每一个用户请求都会产生一个新的线程，适当的时候移交给 doGet 或 doPost 方法。init() 方法简单地创建或加载一些数据，这些数据将被用于 Servlet 的整个生命周期
service() 方法是执行实际任务的主要方法。Servlet 容器（即 Web 服务器）调用 service() 方法来处理来自客户端（浏览器）的请求，并把格式化的响应写回给客户端。
每次服务器接收到一个 Servlet 请求时，服务器会产生一个新的线程并调用服务。service() 方法检查 HTTP 请求类型（GET、POST、PUT、DELETE 等），并在适当的时候调用 doGet、doPost、doPut，doDelete 等方法。
GET 请求来自于一个 URL 的正常请求，或者来自于一个未指定 METHOD 的 HTML 表单，它由 doGet() 方法处理。
POST 请求来自于一个特别指定了 METHOD 为 POST 的 HTML 表单，它由 doPost() 方法处理。
destroy() 方法只会被调用一次，在 Servlet 生命周期结束时被调用。destroy() 方法可以让您的 Servlet 关闭数据库连接、停止后台线程、把 Cookie 列表或点击计数器写入到磁盘，并执行其他类似的清理活动。
HelloWorld
HelloWorld
HelloWorld
/HelloWorld
Accept 这个头信息指定浏览器或其他客户端可以处理的 MIME 类型。值 image/png 或 image/jpeg 是最常见的两种可能值。
Accept-Charset 这个头信息指定浏览器可以用来显示信息的字符集。例如 ISO-8859-1。
Accept-Encoding 这个头信息指定浏览器知道如何处理的编码类型。值 gzip 或 compress 是最常见的两种可能值。
Accept-Language 这个头信息指定客户端的首选语言，在这种情况下，Servlet 会产生多种语言的结果。例如，en、en-us、ru 等。
Authorization 这个头信息用于客户端在访问受密码保护的网页时识别自己的身份。
Connection 这个头信息指示客户端是否可以处理持久 HTTP 连接。持久连接允许客户端或其他浏览器通过单个请求来检索多个文件。值 Keep-Alive 意味着使用了持续连接。
Content-Length 这个头信息只适用于 POST 请求，并给出 POST 数据的大小（以字节为单位）。
Cookie 这个头信息把之前发送到浏览器的 cookies 返回到服务器。
Host 这个头信息指定原始的 URL 中的主机和端口。
If-Modified-Since 这个头信息表示只有当页面在指定的日期后已更改时，客户端想要的页面。如果没有新的结果可以使用，服务器会发送一个 304 代码，表示 Not Modified 头信息。
If-Unmodified-Since 这个头信息是 If-Modified-Since 的对立面，它指定只有当文档早于指定日期时，操作才会成功。
Referer 这个头信息指示所指向的 Web 页的 URL。例如，如果您在网页 1，点击一个链接到网页 2，当浏览器请求网页 2 时，网页 1 的 URL 就会包含在 Referer 头信息中。
User-Agent 这个头信息识别发出请求的浏览器或其他客户端，并可以向不同类型的浏览器返回不同的内容。
始状态行 + 回车换行符（回车+换行）
零个或多个标题行+回车换行符
一个空白行，即回车换行符
一个可选的消息主体，比如文件、查询数据或查询输出
100 Continue 只有请求的一部分已经被服务器接收，但只要它没有被拒绝，客户端应继续该请求。
101 Switching Protocols 服务器切换协议。
200 OK 请求成功。
201 Created 该请求是完整的，并创建一个新的资源。
202 Accepted 该请求被接受处理，但是该处理是不完整的。
203 Non-authoritative Information
204 No Content
205 Reset Content
206 Partial Content
300 Multiple Choices 链接列表。用户可以选择一个链接，进入到该位置。最多五个地址。
301 Moved Permanently 所请求的页面已经转移到一个新的 URL。
302 Found 所请求的页面已经临时转移到一个新的 URL。
303 See Other 所请求的页面可以在另一个不同的 URL 下被找到。
304 Not Modified
305 Use Proxy
306 Unused 在以前的版本中使用该代码。现在已不再使用它，但代码仍被保留。
307 Temporary Redirect 所请求的页面已经临时转移到一个新的 URL。
400 Bad Request 服务器不理解请求。
401 Unauthorized 所请求的页面需要用户名和密码。
402 Payment Required 您还不能使用该代码。
403 Forbidden 禁止访问所请求的页面。
404 Not Found 服务器无法找到所请求的页面。.
405 Method Not Allowed 在请求中指定的方法是不允许的。
406 Not Acceptable 服务器只生成一个不被客户端接受的响应。
407 Proxy Authentication Required 在请求送达之前，您必须使用代理服务器的验证。
408 Request Timeout 请求需要的时间比服务器能够等待的时间长，超时。
409 Conflict 请求因为冲突无法完成。
410 Gone 所请求的页面不再可用。
411 Length Required "Content-Length" 未定义。服务器无法处理客户端发送的不带 Content-Length 的请求信息。
412 Precondition Failed 请求中给出的先决条件被服务器评估为 false。
413 Request Entity Too Large 服务器不接受该请求，因为请求实体过大。
414 Request-url Too Long 服务器不接受该请求，因为 URL 太长。当您转换一个 "post" 请求为一个带有长的查询信息的 "get" 请求时发生。
415 Unsupported Media Type 服务器不接受该请求，因为媒体类型不被支持。
417 Expectation Failed
500 Internal Server Error 未完成的请求。服务器遇到了一个意外的情况。
501 Not Implemented 未完成的请求。服务器不支持所需的功能。
502 Bad Gateway 未完成的请求。服务器从上游服务器收到无效响应。
503 Service Unavailable 未完成的请求。服务器暂时超载或死机。
504 Gateway Timeout 网关超时。
505 HTTP Version Not Supported 服务器不支持"HTTP协议"版本。
java mysql免安装方法
basedir =F:\mysql-5.6.24-win32
datadir =F:\mysql-5.6.24-win32\data
port =3306
#编码
character_set_server=UTF8
path ;F:\mysql-5.6.24-win32\bin
cmd mysql
mysql -install
提示成功
net start mysql
请求的服务启动
net stop mysql
服务停止
mysql -u root -p
关闭正在运行的MySQL。
2.打开DOS窗口，转到mysql\bin目录。
3.输入mysqld --skip-grant-tables回车。如果没有出现提示信息，那就对了。
4.再开一个DOS窗口(因为刚才那个DOS窗口已经不能动了)，转到mysql\bin目录。
5.输入mysql回车，如果成功，将出现MySQL提示符 >
6. 连接权限数据库>use mysql; (>是本来就有的提示符,别忘了最后的分号)
7.改密码：> update user set password=password("123456") where user="root";
8.刷新权限(必须的步骤)>flush privileges;
9.退出 > \q
regedit
"C:\Program Files\MySQL\MySQL Server 5.6\mysqld" MySQL
F:\mysql-5.6.24-win32替换C:\Program Files\MySQL\MySQL Server 5.6
mysql show databases； 展示数据库
create database First；创建数据库
drop database；删除数据库
show databases;
create database 名称;
drop database 名称;
select describe from test_table;
2. 解压MySQL压缩包
将以下载的MySQL压缩包解压到自定义目录下,我的解压目录是:
"D:\Program Files\MySQL\mysql-5.6.13-win32"
将解压目录下默认文件 my-default.ini 拷贝一份，改名 my.ini
复制下面的配置信息到 my.ini 保存
#如果没有my-default.ini,可自己新建my.ini或者从其他地方中获取
#########################################################
[client]
port=3306
default-character-set=utf8
[mysqld]
port=3306
character_set_server=utf8
basedir=D:\Program Files\MySQL\mysql-5.6.13-win32
#解压目录
datadir=D:\Program Files\MySQL\mysql-5.6.13-win32\data
#解压目录下data目录
sql_mode=NO_ENGINE_SUBSTITUTION,STRICT_TRANS_TABLES
[WinMySQLAdmin]
D:\Program Files\MySQL\mysql-5.6.13-win32\bin\mysqld.exe
#########################################################
3. 添加环境变量
操作如下：
1）右键单击我的电脑->属性->高级系统设置(高级)->环境变量
点击系统变量下的新建按钮
输入变量名：MYSQL_HOME
输入变量值：D:\Program Files\mysql-5.6.11-winx64
#即为mysql的自定义解压目录。
2）选择系统变量中的Path
点击编辑按钮
在变量值中添加变量值：%MYSQL_HOME%\bin
注意是在原有变量值后面加上这个变量，用;隔开，不能删除原来的变量值，
4. 将mysql注册为windows系统服务
1）从控制台进入到MySQL解压目录下的 bin 目录下：
2）输入服务安装命令：
mysqld install MySQL --defaults-file="D:\Program Files\MySQL\mysql-5.6.13-win32\my.ini"
#解压目录下修改的my.ini文件
安装成功后会提示服务安装成功。
#注：my.ini文件放在MySQL解压后的根目录下
#移除服务命令为：mysqld remove
5. 启动MySQL服务
方法一：
启动服务命令为：net start mysql
方法二：
打开管理工具 服务，找到MySQL服务。
通过右键选择启动或者直接点击左边的启动来启动服务。
6. 修改 root 账号的密码
刚安装完成时root账号默认密码为空，此时可以将密码修改为指定的密码。如：123456
c:>mysql –uroot
mysql>show databases;
mysql>use mysql;
mysql>UPDATE user SET password=PASSWORD("123456") WHERE user='root';
mysql>FLUSH PRIVILEGES;
mysql>QUIT
7. MySQL控制台快捷方式建立:
1）桌面右键->新建->快捷方式->对象位置输入：C:\Windows\System32\cmd.exe
快捷方式名称自己定义，确定，快捷方式建立成功
2）右键单击刚才建立的快捷方式->属性->把目标一栏修改成MySQL启动参数：
C:\Windows\System32\cmd.exe "D:\Program Files\MySQL\mysql-5.6.13-win32\bin" /k mysql -uroot -p inventory
解释:CMD路径 "MySQL路径bin目录" /k mysql -u用户名 -p密码 数据库名
3）修改完成后点击确定保存，直接双击快捷方式即可连接到MySQL数据库
update user set password=password('12345') where user='root';
练习代码
show tables;
select * from pepole;
drop table cars;
--创建表
create table cars(
name char(20),
skil char(20),
age int(20));
insert into cars values('蜘蛛侠','吐丝',21,'男');
insert into cars values('钢铁侠','飞翔',42,'男');
insert into cars values('猫女','爪子',32,'女');
insert into cars values('侠女','剑',32,'女');
select * from cars;
alter table cars add sex char(1);
desc cars;
--删除
delete from cars;
delete from cars where name='猫女';
delete from cars where sex='男';
delete from cars where age>30;
select * from cars where name like '蜘蛛侠';
select * from cars where name like '%侠%';
select * from cars where name like '%侠%'and age>40;
select * from cars where age<30 or age>40;
update cars set sex='女';
drop table cars;
--主键primary key 不能为空 不能重复
create table cars(
id int(20) primary key auto_increment,
name char(20),
age int(3)
);
insert into cars values(1,'张三',21);
insert into cars values(2,'李四',12);
insert into cars values(3,'王五',45);
insert into cars values(4,null,21);
insert into cars values(null,'asd',21);
select * from cars;
delete from cars where id=4;
insert into cars values(4,'www',21);
update cars set name='你好', age=15 where id=4;
drop table user;
create table user(
id int(12) primary key auto_increment,
name char(20) not null default '未命名',
password char(20),
age int(3) not null default 0
);
insert into user values(null,'张三','123',0);
insert into user values(null,'','123',0);
insert into user values(null,'',null);
insert into user values(null,default,'123');
insert into user values(null,'default',null,default);
select *from user;
create database school;
数据库（DataBase，DB）：指长期保存在计算机的存储设备上，按照一定规则组织起来，可以被各种用户或应用共享的数据集合。
Oracle：目前比较成功的关系型数据库管理系统。运行稳定、功能齐全、性能超群、技术领先。主要应用在大型的企业数据库领域。
DB2：IBM的产品。
SQL Server：Microsoft的产品。软件界面友好、易学易用，在操作性和交互性方面独树一帜。
PostgreSQL：加州大学伯克利分校以教学目的开发的数据库系统，支持关系和面向对象的数据库，属于自由数据库管理系统。
MySQL：免费的数据库系统。被广泛用于中小型应用系统。体积小、速度快、总体拥有成本低，开放源代码。2008年被SUN收购，2009年SUN被Oracle收购。所谓安装数据库服务器，只是在机器上装了一个数据库管理程序，这个管理程序可以管理多个数据库，一般开发人员会针对每一个应用创建一个数据库
为保存应用中实体的数据，一般会在数据库创建多个表，以保存程序中实体的数据。
数据库服务器、数据库和表的关系如图
登录MySQL mysql -uroot -p123456 – u用户名 –p密码
show databases; --查看安装的数据库
use database_name; --使用数据库
show tables; --查看数据库中的表
show columns form ‘表名’；
--显示数据表的属性，属性类型，主键信息 ，是否为 NULL，默认值等其他信息Structure Query Language。
DDL（Data Definition Language）：数据定义语言，用来定义数据库对象：库、表、列等；
create alter drop
DML（Data Manipulation Language）：数据操作语言，用来操作数据库表中的记录（数据）；
insert：
INSERT INTO t_student
VALUES('1','1','2016001001','王宝强','男','1985-08-30 00:00:00'); 插入的数据应与字段的数据类型相同。
-- 数据的大小应在列的规定范围内，例如：不能将一个长度为80的字符串加入到长度为40的列中。
-- 在values中列出的数据位置必须与被加入的列的排列位置相应
-- 字符和日期型数据应包含在单引号中。
-- 插入空值，不指定或insert into table value(null)update
delete
DQL（Data Query Language）：数据查询语言，用来查询记录（数据）。select
DCL（Data Control Language）：数据控制语言，用来定义访问权限和安全级别；
primary key
auto_increment
CREATE TABLE table_name (column_name column_type); --创建表
CREATE TABLE t_student (
id INT (11) NOT NULL PRIMARY KEY AUTO_INCREMENT, -- 主键自增
class_id INT (11) NOT NULL, --班级ID
student_no VARCHAR (10) NOT NULL, -- 学号 不能为空
student_name VARCHAR (10) NOT NULL, -- 姓名 不能为空
sex CHAR (2) DEFAULT NULL, -- 性别
birthday datetime DEFAULT NULL -- 生日 日期格式
)；
DROP TABLE table_name ; --删除表
删除列
ALTER TABLE table_name DROP column_name;
添加列
ALTER TABLE table_name ADD column_name INT;
修改列类型
ALTER TABLE table_name MODIFY column_name CHAR(10);
修改列名称
ALTER TABLE table_name CHANGE c1 c2 BIGINT;
修改字段默认值
ALTER TABLE table_name ALTER column_name SET DEFAULT 1;
修改表名
ALTER TABLE table_name RENAME TO new_table_name ;
使用 update语句修改表中数据
UPDATE t_student SET student_name='王宝强',sex='男' WHERE id=1使用 delete语句删除表中数据
DELETE FROM t_student WHERE student_name = '王宝强';
SELECT [DISTINCT] *|{column1, column2, column3..} FROM table;
SELECT指定查询哪些列的数据。
column指定列名。
*号代表查询所有列。
FROM指定查询哪张表。
DISTINCT可选，指显示结果时，是否剔除重复数据使用order by 子句排序查询结果
SELECT column1, column2. column3.. FROM table order by column asc|desc
Order by 指定排序的列，排序的列即可是表中的列名，也可以是select 语句后指定的列名。
Asc 升序、Desc 降序
ORDER BY 子句应位于SELECT语句的结尾
连接查询：
交叉连接（cross join）:不带on子句，返回连接表中所有数据行的笛卡儿积。内连接（inner join）：返回连接表中符合连接条件及查询条件的数据行。外连接：分为左外连接（left out join）、右外连接（right outer join）。与内连接不同的是，外连接不仅返回连接表中符合连接条件及查询条件的数据行，也返回左表（左外连接时）或右表（右外连接时）中仅符合查询条件但不符合连接条件的数据行。
子查询
联合查询
报表查询
show databases;
--显示数据表的属性，属性类型，主键信息 ，是否为 NULL，默认值等其他信息
show columns from user;
select * from user;
--创建mydb数据库
create database cook;
--删除mydb数据库
drop database cook;
select * from cook;
drop table cook;
delete from cook;
--primary key:不允许为空，不允许重复
--主键自动增长 auto_increment
--定义非空约束 not null
--Order by 指定排序的列，排序的列即可是表中的列名，也可以是select 语句后指定的列名。
--Asc 升序、Desc 降序
--ORDER BY 子句应位于SELECT语句的结尾。
create table cook(
id int(4) primary key auto_increment,
name char(20) ,
age int(3) ,
password char(20) ,
url char(200)
);
insert into cook values(1,'淘宝',2,'123456','www.taobao.com');
insert into cook values(2,'百度',1,'123456','www.baidu.com');
insert into cook values(3,'网易',4,'123456','http://www.wangye.com');
insert into cook values(4,'京东',3,'123456','http://www.jidong.com');
insert into cook values(5,'google',7,'123456','http://www.Google.com');
select * from cook;
select * from cook where name like '%宝%';
--SELECT语句中可使用as语句
--在SELECT语句中可使用表达式对查询的列进行运算
select from cook union;
SELECT id FROM cook
UNION ALL
SELECT id FROM user;
--连接查询的from子句的连接语法 TABLE1和TABLE2表示参与连接操作的表
--，TABLE1为左表，TABLE2为右表。on子句设定连接条件，where子句设定查询条件，
--join_type表示连接类型
select * from cook where age=2 and age>3;
alter table cook add county int(20);
--增加列 属性
alter table cook drop county;
--增加 列的类型
alter table cook modify country char(20);
--更新
update cook set country='中国' where id=1;
--删除主键
alter table cook drop primary key;
--交叉 查询CUSTOMER表和ORDERS表
select * from cook cross join user;
select * from cook,user;
--显示内连接 使用inner join关键字，在on子句中设定连接条件
select * from cook c inner join user o on c.id=o.id;
--隐式内连接 不包含inner join关键字和on关键字，在where子句中设定连接条件
select * from cook c,user o where c.id=o.id;
--右连接 使用right outer join关键字，在on子句中设定连接条件
select * from cook c right outer join user o on c.id=o.id;
--条件式右连接
SELECT * FROM user c RIGHT OUTER JOIN cook o ON c.id=o.id WHERE o.age>5;
--子查询 嵌套查询，是指在select子句或者where子句中又嵌入select查询语句,子查询的语句放在小括号之内
--所有订单
select * from cook where id=(select id from cook where name like '%宝%');
--左连接 使用left outer join关键字，在on子句中设定连接条件
select * from cook c left outer join user o on c.id=o.id;
--条件式左连接
SELECT * FROM user c left OUTER JOIN cook o ON c.id=o.id WHERE o.age>10;
--联合查询 两条查询语句的查询结果，去掉其中的重复数据行，然后返回没有重复数据行的查询结果。联合查询使用union关键字
select * from cook where age>15 union SELECT * FROM cook where name='ni';
--合计函数count sum avg MAX/MIN
Select count(age) from cook;
SELECT SUM(age) FROM cook;
SELECT MAX(age) FROM cook;
SELECT MIN(age) FROM cook;
---group by语句
--报表查询
select * from cook group by id order by 'date';
--备份单个数据库 mysqldump -u root -p mydb > D:\mydb_backup.sql
--备份多个数据库 mysqldump -u root -p mydb1，mydb2 > D:\mydb_backup.sql
--备份所有数据库 mysqldump -u root -p -all-databases > D:\mydb_backup.sql
--恢复数据库 mysql -u root -p
package com.imooc.www;
import java.io.IOException;
import java.io.PrintWriter;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.tomcat.util.descriptor.web.LoginConfig;
import sun.security.util.Password;
/**
* Servlet implementation class DengDmeo
*/
@WebServlet("/DengDmeo")
public class DengDmeo extends HttpServlet {
private static final long serialVersionUID = 1L;
/**
* @see HttpServlet#HttpServlet()
*/
public DengDmeo() {
super();
// TODO Auto-generated constructor stub
}
/**
* @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
*/
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// TODO Auto-generated method stub
response.setContentType("text/html;charset=UTF-8");
request.setCharacterEncoding("UTF-8");
//response.getWriter().append("欢迎！");
String name=request.getParameter("nam");
//response.getWriter().append(name);
String password=request.getParameter("password");
//response.getWriter().append(password);
String sql="insert into user values(null,'"+name+"','"+password+"');";
String content = searchDQL("select * from user where name = '"+name+"'and password='"+password+"' ");
insertSQL(sql);
searchDQL(content);
if(name != null && password != null&&content!=null )
{
if(!name.equals("")&&!password.equals("")){
//跳转到系统主页面
response.sendRedirect("c.jsp");
}
else{
//否则就提示登录错误
response.getWriter().write("帐号或密码不能为空字符串或请注册账号！");
}
}else if (name != null && password != null&&sql!=null) {
if(!name.equals("")&&!password.equals("")){
//跳转到系统主页面
response.sendRedirect("a.jsp");
}
else{
//否则就提示登录错误
response.getWriter().write("帐号或密码不能为空字符串或请注册账号！");
}
}
}
/*String sql="insert into user values(null,'"+name+"','"+password+"');";
insertSQL(sql);
String content = searchDQL("select * from user where name = '"+name+"'and password='"+password+"' ");
searchDQL(content);*/
private Object getString(String string) {
// TODO Auto-generated method stub
return null;
}
/**
* @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
*/
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// TODO Auto-generated method stub
doGet(request, response);
}
public void insertSQL(String sql){
try {
Class.forName("com.mysql.jdbc.Driver");
Connection connection=DriverManager.getConnection("jdbc:mysql://localhost:3306/test","root","123456");
Statement statement=connection.createStatement();
statement.execute(sql);
statement.close();
connection.close();
} catch (Exception e) {
// TODO: handle exception
}
}
public String searchDQL(String sql) {
String content = "";
try {
Class.forName("com.mysql.jdbc.Driver");
Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "123456");
Statement statement = connection.createStatement();
ResultSet set = statement.executeQuery(sql);
while (set.next()) {
int id = set.getInt("id");
String name = set.getString("nam");
String password = set.getString("password");
content += id;
content += name;
content += password;
}
set.close();
statement.close();
connection.close();
} catch (Exception e) {
// TODO: handle exception
}
return content;
}
}
Servlet 过滤器可以动态地拦截请求和响应，以变换或使用包含在请求或响应中的信息。
可以将一个或多个 Servlet 过滤器附加到一个 Servlet 或一组 Servlet。Servlet 过滤器也可以附加到 JavaServer Pages (JSP) 文件和 HTML 页面。调用 Servlet 前调用所有附加的 Servlet 过滤器。
Servlet 过滤器是可用于 Servlet 编程的 Java 类，可以实现以下目的：
在客户端的请求访问后端资源之前，拦截这些请求。
在服务器的响应发送回客户端之前，处理这些响应。
根据规范建议的各种类型的过滤器：
身份验证过滤器（Authentication Filters）。
数据压缩过滤器（Data compression Filters）。
加密过滤器（Encryption Filters）。
触发资源访问事件过滤器。
图像转换过滤器（Image Conversion Filters）。
日志记录和审核过滤器（Logging and Auditing Filters）。
MIME-TYPE 链过滤器（MIME-TYPE Chain Filters）。
标记化过滤器（Tokenizing Filters）。
XSL/T 过滤器（XSL/T Filters），转换 XML 内容。
过滤器通过 Web 部署描述符（web.xml）中的 XML 标签来声明，然后映射到您的应用程序的部署描述符中的 Servlet 名称或 URL 模式。
当 Web 容器启动 Web 应用程序时，它会为您在部署描述符中声明的每一个过滤器创建一个实例。
Filter的执行顺序与在web.xml配置文件中的配置顺序一致，一般把Filter配置在所有的Servlet之前
Cookie 是存储在客户端计算机上的文本文件，并保留了各种跟踪信息。Java Servlet 显然支持 HTTP Cookie。
识别返回用户包括三个步骤：
服务器脚本向浏览器发送一组 Cookie。例如：姓名、年龄或识别号码等。
浏览器将这些信息存储在本地计算机上，以备将来使用。
当下一次浏览器向 Web 服务器发送任何请求时，浏览器会把这些 Cookie 信息发送到服务器，服务器将使用这些信息来识别用户。
本章将向您讲解如何设置或重置 Cookie，如何访问它们，以及如何将它们删除。
Servlet Cookie 处理需要对中文进行编码与解码，方法如下：
String str = java.net.URLEncoder.encode("中文"，"UTF-8"); //编码
String str = java.net.URLDecoder.decode("编码后的字符串","UTF-8"); // 解码
Cookie 剖析
Cookie 通常设置在 HTTP 头信息中（虽然 JavaScript 也可以直接在浏览器上设置一个 Cookie）。设置 Cookie 的 Servlet 会发送如下的头信息：
HTTP/1.1 200 OK
Date: Fri, 04 Feb 2000 21:03:38 GMT
Server: Apache/1.3.9 (UNIX) PHP/4.0b3
Set-Cookie: name=xyz; expires=Friday, 04-Feb-07 22:03:38 GMT;
path=/; domain=w3cschool.cc
Connection: close
Content-Type: text/html
正如您所看到的，Set-Cookie 头包含了一个名称值对、一个 GMT 日期、一个路径和一个域。名称和值会被 URL 编码。expires 字段是一个指令，告诉浏览器在给定的时间和日期之后"忘记"该 Cookie。
如果浏览器被配置为存储 Cookie，它将会保留此信息直到到期日期。如果用户的浏览器指向任何匹配该 Cookie 的路径和域的页面，它会重新发送 Cookie 到服务器。浏览器的头信息可能如下所示：
GET / HTTP/1.0
Connection: Keep-Alive
User-Agent: Mozilla/4.6 (X11; I; Linux 2.2.6-15apmac ppc)
Host: zink.demon.co.uk:1126
Accept: image/gif, */*
Accept-Encoding: gzip
Accept-Language: en
Accept-Charset: iso-8859-1,*,utf-8
Cookie: name=xyz
Servlet 就能够通过请求方法 request.getCookies() 访问 Cookie，该方法将返回一个 Cookie 对象的数组
jsp servlet js登录与注册
LoginServlet.java
package com.zhiyou100.servlet;
import java.io.IOException;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* Servlet implementation class LoginServlet
*/
@WebServlet("/login")
public class LoginServlet extends HttpServlet {
private static final long serialVersionUID = 1L;
/**
* @see HttpServlet#HttpServlet()
*/
public LoginServlet() {
super();
// TODO Auto-generated constructor stub
}
/**
* @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
*/
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// TODO Auto-generated method stub
response.getWriter().append("Served at: ").append(request.getContextPath());
}
/**
* @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
*/
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
request.setCharacterEncoding("UTF-8");
response.setContentType("text/html; charset=UTF-8");
String username = request.getParameter("username");
String password = request.getParameter("password");
String dbPassword = null;
try {
Class.forName("com.mysql.jdbc.Driver");
Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test3", "root", "1230123");
Statement statement = conn.createStatement();
String sql = "select password from user where username = '" + username + "';";
ResultSet rs = statement.executeQuery(sql);
while(rs.next()) {
dbPassword = rs.getString("password");
}
rs.close();
conn.close();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
if (dbPassword == null) {
//帐号不存在
response.getWriter().append("帐号不存在");
}else if (dbPassword.equals(password)) {
//比较存储的密码和输入的密码是否一致
response.getWriter().append("登录成功");
}else {
response.getWriter().append("密码输入有误");
}
//输出 js 并执行，js 是 JavaScript 的简称和 Java 没有关系。
//HTML，框架
//CSS，装饰
//JS，让网页和用户进行互动
response.getWriter().append("");
//为了后期的修改和维护，我们需要把相同的代码封装到方法中。
//那么所有使用这段代码的地方，使用调用方法代替。
//相同的代码就只用去方法实现中写一遍即可。
//将来修改的时候，只需要去方法实现中修改一次，那么所有调用方法的地方都跟着发生变化。
//在编程经验不足的时候，优先实现功能，后考虑修改和优化。
//
}
}
RegisterServlet.java
package com.zhiyou100.servlet;
import java.io.IOException;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* Servlet implementation class RegisterServlet
*/
@WebServlet("/register")
public class RegisterServlet extends HttpServlet {
private static final long serialVersionUID = 1L;
/**
* @see HttpServlet#HttpServlet()
*/
public RegisterServlet() {
super();
// TODO Auto-generated constructor stub
}
/**
* @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
*/
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// TODO Auto-generated method stub
response.getWriter().append("Served at: ").append(request.getContextPath());
}
/**
* @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
*/
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
//1.统一编码格式
request.setCharacterEncoding("UTF-8");
response.setContentType("text/html; charset=UTF-8");
//2.获得用户在表单中输入的内容
String username = request.getParameter("username");
String password = request.getParameter("password");
//3.判断 username 是否可用
//3.0 假设这个 dbPassword 是从数据库中查询出来的 username 对应的 password。
String dbPassword = null;
//3.1 从数据库查找是否有 username 对应的 password
//3.1.1 建立数据库和表
try {
//3.1.2 加载驱动，拖 jar 包
Class.forName("com.mysql.jdbc.Driver");
//3.1.3 建立数据库链接
Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test3", "root", "1230123");
//3.1.4 创建执行 SQL 语句的 Statement 对象
Statement statement = conn.createStatement();
//3.1.5 拼装需要执行的 SQL 语句
String sql = "select password from user where username = '" + username + "';";
//3.1.6 执行 SQL 语句，获得查询结果放入 ResultSet
ResultSet rs = statement.executeQuery(sql);
//3.1.7 通过 while 循环取出 password 赋值提前声明好的变量 dbPassword
while(rs.next()) {
dbPassword = rs.getString("password");
}
//3.1.8 关闭 rs 和 conn
rs.close();
conn.close();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
//3.2 判断 dbPassword 是否存在
if (dbPassword == null) {
//说明数据库中没有 username 这一行，说明 username 可以使用。
//3.2.1 把 username 和 password 插入数据库
try {
Class.forName("com.mysql.jdbc.Driver");
Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test3", "root", "1230123");
Statement statement = conn.createStatement();
String sql = "insert into user values(null, '" + username + "', '" + password + "')";
statement.execute(sql);
conn.close();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
//3.2.2 告诉用户注册成功
response.getWriter().append("账号注册成功");
}else {
//说明数据库中有 username 这一行，说明 username 不可以使用。
//3.2.3 告诉用户用户名不可用
response.getWriter().append("用户名已被使用，请更换");
}
}
}
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
登录
点击去登录页面
page: 可以作用于单个页面
request: 可以作用于单个请求
session： 可以作用于整个会话
application： 可以作用于整个Web应用
Javabean既可以封装数据同时也可以封装业务逻辑。
眼高手低：
进度由慢到快
写代码 要代码量 写代码有感觉 写多了
1.白天老师做笔记 在不看代码与笔记 自己敲出来！创建自己新工程。
2.前一天失败的原因 自己写！晚上要练习！
3.写代码卡壳了的地方做笔记， 晚上复习与预习代码量。全部敲出来！
4.做好笔记，知识点，重要的知识点的笔记，没听懂的点，做笔记然后下课 ，搜一下资料！
b/s项目(javaEE)browaer server
ASP(2002~2003)
b/s对比c/s项目：
c/s对客户机比较高,
注册表：C++ C#中有其他的好处；升级麻烦。
b/s：不需要安装，升级很方便；
缺点：客户的体验差，操作麻烦：发展趋势WEB2.0的技术（ajax）
web服务器 tomcat web logic WebSphere
http://www.apache.org/
http://tomcat.apache.org/tomcat-9.0-doc/index.html
http://tomcat.apache.org/download-90.cgi
http://tomcat.apache.org/download-60.cgi
推荐版本
j2EE5+tomcat6+JDK1.6
c/s 三层架构
b/s：mvc架构——model（（biz 逻辑层）+数据访问 +dto+entity） view（JSP /html
运行结果） contller（servlet）
javaEE ==java2E
lib放jar包
web.xml权限的
mp.html欢迎页
<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
JAVA的
http://localhost:8080/
127.0.0.1:8080/web站点
协议 地址 端口 /web site name /目录名 /资源名
报404错误！目标资源没有找或者不存在！
（*jpg）（html）（JSP）（Servlet）
文件夹下拷贝
对象编程java 万物皆对象；
2.java语法：
class 类(不同类型 可以构造出来的不同的对象)
继承：子类可以使用父类的属性和方法
JAVAEE教程：
javaweb
http://localhost:8080/Wabapp/ap.jsp
地址名称
JAVA EE 5 library 类库
src java源程序
webRoot项目的根目录
index.jsp 资源文件
系统目录
context root 改目录
jsp java Server pages 简化Servlet
jsp
asp.net
php
Lamp：liunx +apache+mysql+php
jsp：注释 指令 表达式 小脚本 声明 静态内容
jsp指令元素 page指令 页面属性
<%@ page 属性1="属性值"%>
属性：
language jsp的脚本语言 java
import 引用脚本语言使用到类文件 无
/* 实例化对象 */
ObjectReference = new Constructor();
/* 访问其中的变量 */
ObjectReference.variableName;
/* 访问类中的方法 */
ObjectReference.MethodName();
contentType jsp采用的编码方式 text/html,ISO-8859-1
<%--jsp注释客户端不可见--%>
JSP页面
<%--jsp注释客户端不可见--%>
<%//单行注释
/*多行注释*/
out.println("欢迎大家学习JAVAEE开发！
");
out.println("欢迎大家学习JAVAEE开发！
");
%>
<%! 声明变量%>
<%!
int num=100;//声明一个整形的变量
int add(int x,int y)//实现整形相加
{
return x+y;
}
%>
num=<%=num %>
10+15=<%=add(10,5)%>
language
include 外文件嵌入 解析页面
taglib指令 自定义标签 jsp启动定制的行为
默认首页
jsp基础语法:
配置JER
集成Tomcat服务器
MyEclipse：
contentType="text/html;
charset=UTF-8"
jsp生命周期
jspService（）方法调用
servlet始终驻留与内存
jsp
<%
date d=new date();
SimpleDateFormat sdf=new SimpleDateFromat("yyyy年MM月dd日")
String s=sdf.format(d);
%>
今天的时间<%=s%>
游戏引擎api
方法的声明
方法的参数
方法的返回值
方法的调用
方法:
把复用的业务代码抽取出来，形成独立的调用单元
实现比较复杂的逻辑
对具体实现进行隐藏/封装，只需调用关注结果，而不用关注其具体实现
语法：
[访问修饰符] 返回值类型 方法名([形式参数列表]){
程序代码;
[return 返回值;]
}
示例：
public void getAge() {
}
方法声明—注意事项:
访问修饰符：表示方法的访问权限，可以省略，建议写上
返回值类型：空返回为void，此时方法体中不需要return语句。若返回其他类型的值，则必须有返回对应类型值的return语句，且return有终止方法的作用，必须位于最后。
方法声明—注意事项:
形式参数(形参)：方法声明时规定的参数类型,数量,顺序
实际参数(实参)：调用方法时实际传递给方法的数据
返回值：方法执行完毕后返回给调用者的数据。
方法调用:
同一个类中
方法名 (形参列表)：
// 静态只能调用静态，非静态既可以调用非静态，还可以调用静态
对象名.方法名(形参列表)：
// 静态调用非静态
注意：不同类中的情况，会在面向对象，类的概念时一起讲解。
注意
被static关键字修饰的方法为静态方法(类和对象会再次讲解)
调用方法的实参列表必须和形参列表严格对应
方法应用
:定义一个静态方法，接收两个数和算术运算符，返回运算结果
定义方法，判断某年是否是闰年，闰年规则：
能被4整除，且不能被100整除
或者能被400整除
方法的重载overload:
定义：同一个类中，方法名相同，参数列表不同
作用：在同一类中，可以产生多个同名方法，从而实现不同的操作。调用时，根据匹配的实参列表，执行相对应的方法
方法的声明
方法的参数：形参，实参
方法的返回值：void，return
方法的调用：同一个类，不同类中
1.判断形参列表是否相同时，只看形参类型，不看变量名
2.是否重载与返回值类型无关
3.形参列表不同：个数不同，顺序不同
4.多态：重载是多态中的一种情况，静态多态
标识符:
Java标识符命名规则：
由字母、数字、下划线（_）和美元符号（$ 音：dollar）组成。
不能以数字开头。
区分大小写。
不能是Java中的保留字和关键字。
标识符命名习惯：见名知意
请判断以下标识符是否合法：
HelloWord、username2、user_name、_userName、
$abc_123、public、
2UserName、user#Name、Hello World关键字:Java中有特定含义，专门用途的字符串称为关键字（keyword），关键字全部小写
保留字：没有定义用途，但保留备用。goto、const扩展：编程命名规范:变量名、方法名：首字母小写，其余单词首字母大写
类名、项目名：首字母大写，其余单词首字母大写
包名：全部小写，用英文的.隔开
常量：全部大写，单词之间用_隔开
总体原则：驼峰式，见名知义，便于代码的统一及可读性
Java的数据类型:
数组(array)接口(interface)
类(class)
布尔型（boolean）:
boolean类型表示真假，一般用于逻辑运算、流程控制
boolean类型数据值：true或false，不可以用0、非0数字，大写代替。
示例：
boolean b = false;
boolean c = true;
基本数据类型：
Java中定义了4类/8种基本数据类型
布尔型---- boolean
字符型---- char
整数型---- byte, short, int, long
浮点数型---- float, double
Java中所有的基本数据类型都有固定的存储范围和所占内存空间的大小，而不受具体操作系统的影响，以保证Java程序的可移植性。
Java浮点类型有两种表示形式
十进制形式，必须含有小数点，例如：
3.14 314.0 0.314
科学记数法形式，如：
3.14e2 3.14E2 3E2
Java浮点型默认为double型，如要声明float型，则需在数字后面加f或F，如：
double d = 3.14; float f = 3.14f;
字符类型:char型数据用来表示通常意义上“字符”
char c = ‘A’; char gender= ‘女';
Java字符采用Unicode编码，每个字符占两个字节，因而可用十六进制编码形式表示(Unicode是全球语言统一编码)
char c1 = '\u0061'; //相当于a
char c2=97; //ASCII码，相当于a
Java语言中还可以使用转义字符'\'来将其后的字符转变为其它含义：
char c2 = '\t';
名称 描述
\n 换行 将光标移到下一行的第一格。
\t 水平制表 将光标移到下一个水平制表位置。
\' 单引号 产生一个单引号。
\" 双引号 产生一个双引号。
\\ 斜杠 产生一个斜杠。
数据类型 大小/位 可表示的数值范围
byte(字节型) 8 -128~127
short(短整数) 16 -215 ~ 215-1
int(整数) 32 -231 ~ 231-1
long(长整数) 64 -263~ 263-1
float(单精度) 32 -3.4E38~3.4E38
double(双精度) 64 -1.7E308~1.7E308
char(字符) 16 0-65535
boolean true/false
基本数据类型—类型转换:自动类型转换：取值范围小的自动转为取值范围大的
byte?short?int?long?float?double
char ? int?long?float?double
short,char不会互相转换
整个表达式的值不足int时，自动提升为int
强制类型转换：取值范围大的强制转为取值范围小的 如：
long l = 100L; int i = (int)l;
注意：有可能造成精度降低或数据溢出，使用时要注意
boolean 类型不能转换成任何其它基本数据类型
jsp内置对象
是web容器创建的一组对象，不使用new关键就是可以内置对象。
<%
int[] value={60,70,80};
for(int i:value){
out.println(i)
}
%>
九大内置
常使用：
page ： 1 作用范围仅限用户请求当前也页面 对page 对象引用通常存储在pagecontext对象中
out：
void: println() print() 打印
claer() ：清空缓冲区的内容 如果flush之后调用抛出异常
clearBuffer():清空缓冲区的内容 如果flush之后不会调用抛出异常
flush()将缓冲内容输出到客户端
getBufferSize（）：返回缓冲器以字节数大小 如不设置缓冲区为0
getRemaining()返回缓冲区还剩下多少可用
isAutoFlush（）返回缓冲区满时 自动清空还是抛出异常
close（）关闭输出流
request 2 请求代表用户一次请求 一个http请求的处理肯需要多个Servlet合作
String getParameter（String name）返回name指定名称参数值
response
session 3 同一浏览器对服务器多次访问 httpSession接口实现的
application 4 服务器启动到关闭整段时间
page pageconte
exxeption config
百度网盘： http://pan.baidu.com/share/link?shareid=427617690&uk=3979517138#list/path=%2FJava%2F%E6%AF%95%E5%90%91%E4%B8%9C-JAVA%E5%9F%BA%E7%A1%80%E5%BC%80%E5%8F%91%E8%A7%86%E9%A2%91
java字符串大写转小写，小写转大写
String test="ABC34cccddee";
System.out.println(test.toUpperCase());//小写转大写
String test="ABC34cccddee";
System.out.println(test.toLowerCase());小写转大写
链接：https://pan.baidu.com/s/1qY8nASO 密码：k9g2
链接：http://pan.baidu.com/s/1nvobfuD 密码：bw2l
链接：http://pan.baidu.com/s/1slHFasl 密码：n11d
链接：http://pan.baidu.com/s/1nvJOR2p 密码：0myz
2、 分配空间
简单地说，就是指定数组中最多可存储多少个元素
语法： 数组名 = new 数据类型 [ 数组长度 ];
其中，数组长度就是数组中能存放元素的个数，如：
话说，我们也可以将上面的两个步骤合并，在声明数组的同时为它分配空间，如：
3、 赋值
分配空间后就可以向数组中放数据了，数组中元素都是通过下标来访问的，例如向 scores 数组中存放学生成绩
4、 处理数组中数据
我们可以对赋值后的数组进行操作和处理，如获取并输出数组中元素的值
在 Java 中还提供了另外一种直接创建数组的方式，它将声明数组、分配空间和赋值合并完成，如
它等价于：
JSP Java Server Pages
是为了简化动态网页开发而发明的技术
运行时会被编译成Java代码
实际上JSP与后面要学习的Sevlet关系密切
JSP是非常古老的技术，和大家年龄差不多
JSP可以大大地帮我们偷懒<%@ page … %>
page指令：为JSP的编译提供一些信息
application对象
字面意思应用程序
可以提供整个应用程序的信息
out对象
字面意思是输出
可以向页面上输出文字等信息。
常说JSP有9大内置对象，我们后面会详细介绍
Object count = application.getAttribute("index-count");
Object 类型名
Java是强类型语言
Java中的数据是有类型的
Object是Java中最基本的类型
count 变量名
变量是一个符号，代表一个数据，本例中是访问次数
count的类型是Object
= 赋值
把右边的值赋给左边的变量
application.getAttribute(“index-count”);
application是内置对象
.getAttribute()调用内置对象的getAttribute方法，从应用对象中获取数据
“index-count”是调用函数的参数，指明要获取哪个数据，“”表示字符串类型
Java中有很多类型，整数如3，小数如3.14，表示真假的布尔类型如true
Java的代码需要英文分号;结尾
生活中有很多事情需要抉择，写代码也一样
if/else，基本分支判断
if () 括号中的值是true时执行if花括号中的代码
false时执行else花括号中的代码
> 大于 表达式 1 > 2 的值是 false
< 小于 表达式 1 < 2 的值是 true
== 等于 表达式 1 == 2 的值是 false
!= 不等于 表达式 1 != 2 的值是 true
null 表示没有任何值，是Java中特殊的值
count != null 用于判断count又没有有效值
out.println(value)
将value输出到页面上，后面还带换行
转换成整数
强类型语言需要转换成相应类型才能使用（相加）
将变量c自己加1
存储在应用程序对象中
带参数方法的返回值可以为 void
同一个类中,方法名相同,方法参数个数,顺序,类型
不同的方法称为方法的重载,
与方法的修饰符或返回值没有关系.
配置文件
改端口
conf/server.xml
< Connector port="8080"
protocol="HTTP/1.1"
connectionTimeout="20000"
redirectPort="8443"
/>
默认继承 Object 的 toString( ) 方法，输出对象地址
private
setter
getter
com.imooc.music.MyClassMuisc
com.imooc.movie.MyClassMuisc
import com.imooc.movie.MyClassMuisc
包是小写的
继承
private不行
class子类extends父类
class Dog extends Ainmal
{
}
final 最终得含义
可以修饰类 方法 属性 变量
修饰的类 该类不允许被继承
修饰方法 不允许被覆盖
选其一
只能赋一次值
super
对象的内部使用 代表父类的对象
访问父类的属性
super.age
访问父类的方法
super.eat();
Object tostring()方法
哈希code码对象的地址字符串
重写tostring
equals（）方法
比较的是对象的（引用）是否指向同一块内存地址
接口中方法不能有方法体，同时方法的访问修饰符不能是 private 和 protected
abstract关键字修饰 则该类为抽象类
abstract定义抽象类
接口 可以为一种特殊的类，有局部常量和公共的抽象方法所组成的
不关心类的内部数据
interface关键字
继承 用public abstract 可以多继承很多父类
public static final修饰符 系统自动加上
impieme关键字
【修饰符】class类名 extends父类 implements接口1 接口2{
}
如果继承父类 继承父类必须在实现接口之前
接口在使用的过程当中 经常与匿名内部类配合使用
匿名内部类就是没有名字的内部类
多用于关注而不关注实现类的名称
Interface i=new Interface(){
public void method(){
System.out.println("匿名内部类实现接口的方法");
};
uml
统一建模语言
14用例图
uml工具
Visio Rational Rose PowerDesign
异常处理
throwable
error 终结者
Exception 异常 编码
RuntimeException ：
空指针异常
数组下标越界异常
类型转换异常
算数异常
检查异常
try-catch以及try-catch-finally
try{
//一些抛出异常方法
}catch（Exception e）{
//处理该异常的代码块
}
子到父异常处理
在需要频繁对字符串进行修改操作时使用 StringBuilder 的效率比 String 要高
jsp jcp 面向对象opp与c++相同
基本类型是不能调用方法的，而其包装类具有很多方法
集合框架 一种工具类 类的内部 对数据进行组织
简单而有效的搜索大量的条数
有的集合接口 提供一系列的排序的元素 并且可以在序列中快速插入和删除
有集合接口 提供了映射关系 可以通过关键字Key快速查找对应的唯一性对象 而且对于关键字可以是任意的类型
数组的长度固定 集合长度可变
数组只能通过下标访问元素 类型固定，而有的集合可以通过任意的类型查找所在的具体的对象
集合框架 collection：list：arraylist queue：linkedlist set：hashset
Map：hashMap key value entry键值对
collection接口：list set queue接口与父接口
定义可用于操作list set queue的方法--增删改查
list的接口 -----arraylist接口：数组序列
get post
使用request对象的getParameterValues（）方法实现复选框信息获取
请求重定向是客户器端行为而请求转发是服务器端行为
http://spring.io/
http://projects.spring.io/spring-framework/
什么是软件框架
为什么使用框架
易于上手
IOC及Bean容器
java8接口可以方法体
java接口及声明，声明一些方法对外公开的提供
结构设计 调用外层提供一组功能接口
IOC控制反转 控制权的转移，应用程序本身不负责依赖对象的创建和维护，而是由外部容器负责创建和维护
DI（依赖注入）是一种实现的方式Dependency
目的：创建对象并且组装之间的关系
接口： 是用于隐藏具体的实现和实现多台性的组件
IOC房屋中介
找IOC容器
容器返回对象
使用对象
iterator
泛型 ：规定某一个集合只存放特定的类型的对象
编译期间检查
泛型子类型
set接口 ：元素无序并且不可以重复的集合 被称为集
hashset：set的一个重要实现
OC是什么?ios 编码
会话保存在服务器的内存里
session的生命周期
当客户端第一次访问jsp或者Servlet时候，服务器为当前创建一个SeesionID，每一次客户端向服务器发送请求 都会SessionID带 服务器会对SeesionID进行校验
旧的在服务器 除非超时 销毁
10
除非本次会话的所有页面都关闭后再重新访问某个JSP或者Servlet将会创建新的会话
application对象
实现了用户数据的共享，可放全局变量
开始服务器的启动，终止于服务器的关闭
在任何地方对application对象属性的操作 都将影响到其他用户的访问
服务器的启动和关闭决定了application对象的生命
application对象ServletContext类的实例
setAttribute方法参数第一个为字符串，第二个参数为需要保存的对象
page对象 类似this指针 java.lang.Object类
数据库
字符集GBK
系统的架构MVC
视图层----jsp页面
控制层------Servlet
模型层------------------javaBean设计--数据bean--处理bean 数据库设计
界面设计index.jsp
管理员首页admin_index.jsp
封装是把过程和数据包围起来，对数据的访问只能通过已定义的接口。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。封装是一种信息隐藏技术，在java中通过关键字private，protected和public实现封装。什么是封装？封装把对象的所有组成部分组合在一起，封装定义程序如何引用对象的数据，封装实际上使用方法将类的数据隐藏起来，控制用户对类的修改和访问数据的程度。 适当的封装可以让程式码更容易理解和维护，也加强了程式码的安全性。
例子
编辑
封装的简单例子：
先来个例子看看；
public class Man
{
//对属性的封装，一个人的姓名，年龄，妻子都是这个对象（人）的私有属性
private String name;
private int age;
private Woman wife;
//对该人对外界提供方法的封装，可以设定妻子，姓名，年龄也可以获得男人的姓名和年龄
// 方法封装
public void setWife(Woman wife) {
this.wife = wife;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
public class Woman {
// 属性封装
private String name;
private int age;
private Man husband;
// 方法封装
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Man getHusband() {
return husband;
}
public void setHusband(Man husband) {
this.husband = husband;
}
}
/**
* 仔细看就会发现，Man类没有提供getWife的方法，这是因为男人不想让自己的妻子被外界访问，
*
* 接下来呢，就是封装可以把一个对象的属性私有，而提供一些可以被外界访问的属性的方法，
*
* 比如说，name属性，Man和Woman类都有相应的get和set方法，外界都可以通过这些方法访问和修改
*
* 同时对一些对象不想让外界访问的属性，就不提供其方法，比如说Man的wife属性，就没有get方法
*
* 外界是不能得到Man类的wife属性的
*
*/
上面那例子可能没有突出封装的好处，下面来个超简单的表达下：
public class Show
{
public static void show(String str)
{
System.out.println(str);
}
}
上面就是对 System.out.println();的封装。
调用的时候 ：
public class Use
{
public static void main(String[] args)
{
Show.show("封装")；
}
}
这样用的时候就不用使：System.out.println("封装")；
equals(Object obj)
http://developer.amap.com/
tomcat容器
servlet的容器context容器 一个context对应web工程
servlet
继承httpservlet
重写doGet（）或者dopost（）方法
在web.xml中注册servlet
编写servlet
src new Servlet
重写doGet（）或者doPost（）
部署运行
localhost是服务器主机名，也可以是IP地址127.0.0.1；8080是tomcat服务器的端口号；helloapp是web工程的上下文地址ContexRoot（一般情况下与web工程名一致）；最后是
get方式请求helloServlet -----
生命周期
开始 servlet实例是否存在---> 装载Servlet类创建实例
调用init（Servlet）方法---->Servlet(Servlet Request Servlet Response)方法
服务器关闭
调用Destroy方法
编写Servlet的doPost方法时，需要抛出ServletExcpetion和IOException异常。
servlet容器启动自动 只需要在web.xml添加
数字越小优先级越高
init（）方法只能被调用一次
不同的字符串转换用SimpleDateFormate转换
不覆盖service()方法，不是因为该方法是空，而是因为sevrvice( )方法会调用doPost或者doGet方法
相对路径 相对于当前资源的路径
绝对路径 放之四海而皆准的路径
请求重定向的方式跳转test.jsp相当于ServletpatthDirection/servlet
respone.sendRedirect(request.getcontextPath（)+"text.jsp")
服务器内部跳转
request.getRequestDispatch（"/text.jsp"）.forward
(requset,responet)
Servlet的初始化参数是从ServletConfig中获得的。
运行：services.msc，打开服务管理器，找到“VisualSVNServer”。
2 在服务上，点击右键--属性，打开“登录”选项卡。将“此帐户”改成“本地系统帐户”。再回到安装程序弹出窗口处，选择"Retry"即可。
很多方法都尝试了不行，准备放弃的时候，不选择本地账户，选择此账户用administrator 管理员密码，结果retry成功
Java-Reflect专题
class类的使用
方法的反射
成员变量的反射
构造函数的反射
java类加载机制
class.forName("类的全称")
不仅表示了类的类类型 还代表的动态加载类
编译 运行
编译时刻加载类是静态加载类 运行时刻加载类是动态加载类
//软件动态升级
class Office{
public static void main（String[] args）{
//new创建对象 是静态加载类 在编译的时刻就需要加载所有的可能使用到的类
//通过动态加载类可以解决该问题
if("Word".equal（args[0]）){
Word w=new Word();
w.start();
}
if("Excel".equal（args[0]）){
Excel e=new Excel();
e.start();
}
}
class OfficeBetter{
public static void main(String[] args){
try{
//动态加载类，在运行时刻加载
class c= calss.forNmae(args[0])
//通过类类型 创建该类的对象
OfficeAble oa=(OfficeAble)c.newInstance();
oa.start();
}
catch(Exception e){
e.printStackTrace();
}
}
}
//创建一个标准
interface OfficeAble{
public void start();
}
//Word
class Word implements OfficeAble{
public void start()
{
System.out.println（"word...start...."）
}
}
Class c1=int.Class；
System.out.println（c1.getName（））
打印int类型
class c2=String.class；
System.out.println（c1.getSimpleName（））
不包含包名的类的名称
基本的数据类型
void关键字 都存在类类型
class api
package com.imooc.reffert;
public class ClassDem3 {
public static void main(String[] args) {
// TODO Auto-generated method stub
String s="hello";
ClassUtil.printClassMessage(s);
}
}
package com.imooc.reffert;
import java.lang.reflect.Method;
public class ClassUtil {
// 打印类的信息 包括类的成员函数 成员变量
public static void printClassMessage(Object obj) {
// TODO Auto-generated method stub
//获取类的信息 首先获取类的类类型
Class c=obj.getClass();//传递的那一个子类的对象 c就是该子类的类类型
//获取类名称
System.out.println("类的名称："+c.getName());
//Method类，方法的对象 一个成员方法就是一个Method对象
//getMethods()方法获取所有public函数 包括父类继承而来的
Method[] methods=c.getMethods();// c.getDeclaredMethod()
//c.getDeclaredMethod();getDeclaredMethod()h获取所有类的自己的声明的方法 不访问权限
for (int i = 0; i < methods.length; i++) {
//得到方法返回值类型的类类型
Class returnType=methods[i].getReturnType();
System.out.print(returnType.getName()+"(");
//方法的名称
System.out.print(methods[i].getName());
//获取参数类型
Class[] paramTypes=methods[i].getParameterTypes();
for (Class class1 : paramTypes) {
System.out.print(class1.getName()+",");
}
System.out.println(")");
}
}
}
类的名称：java.lang.String
boolean(equalsjava.lang.Object,)
java.lang.String(toString)
int(hashCode)
int(compareTojava.lang.String,)
int(compareTojava.lang.Object,)
int(indexOfjava.lang.String,int,)
int(indexOfjava.lang.String,)
int(indexOfint,int,)
int(indexOfint,)
java.lang.String(valueOfint,)
java.lang.String(valueOflong,)
java.lang.String(valueOffloat,)
java.lang.String(valueOfboolean,)
java.lang.String(valueOf[C,)
java.lang.String(valueOf[C,int,int,)
java.lang.String(valueOfjava.lang.Object,)
java.lang.String(valueOfchar,)
java.lang.String(valueOfdouble,)
char(charAtint,)
int(codePointAtint,)
int(codePointBeforeint,)
int(codePointCountint,int,)
int(compareToIgnoreCasejava.lang.String,)
java.lang.String(concatjava.lang.String,)
boolean(containsjava.lang.CharSequence,)
boolean(contentEqualsjava.lang.CharSequence,)
boolean(contentEqualsjava.lang.StringBuffer,)
java.lang.String(copyValueOf[C,)
java.lang.String(copyValueOf[C,int,int,)
boolean(endsWithjava.lang.String,)
boolean(equalsIgnoreCasejava.lang.String,)
java.lang.String(formatjava.util.Locale,java.lang.String,[Ljava.lang.Object;,)
java.lang.String(formatjava.lang.String,[Ljava.lang.Object;,)
void(getBytesint,int,[B,int,)
[B(getBytesjava.nio.charset.Charset,)
[B(getBytesjava.lang.String,)
[B(getBytes)
void(getCharsint,int,[C,int,)
java.lang.String(intern)
boolean(isEmpty)
java.lang.String(joinjava.lang.CharSequence,[Ljava.lang.CharSequence;,)
java.lang.String(joinjava.lang.CharSequence,java.lang.Iterable,)
int(lastIndexOfint,)
int(lastIndexOfjava.lang.String,)
int(lastIndexOfjava.lang.String,int,)
int(lastIndexOfint,int,)
int(length)
boolean(matchesjava.lang.String,)
int(offsetByCodePointsint,int,)
boolean(regionMatchesint,java.lang.String,int,int,)
boolean(regionMatchesboolean,int,java.lang.String,int,int,)
java.lang.String(replacechar,char,)
java.lang.String(replacejava.lang.CharSequence,java.lang.CharSequence,)
java.lang.String(replaceAlljava.lang.String,java.lang.String,)
java.lang.String(replaceFirstjava.lang.String,java.lang.String,)
[Ljava.lang.String;(splitjava.lang.String,)
[Ljava.lang.String;(splitjava.lang.String,int,)
boolean(startsWithjava.lang.String,int,)
boolean(startsWithjava.lang.String,)
java.lang.CharSequence(subSequenceint,int,)
java.lang.String(substringint,)
java.lang.String(substringint,int,)
[C(toCharArray)
java.lang.String(toLowerCasejava.util.Locale,)
java.lang.String(toLowerCase)
java.lang.String(toUpperCase)
java.lang.String(toUpperCasejava.util.Locale,)
java.lang.String(trim)
void(wait)
void(waitlong,int,)
void(waitlong,)
java.lang.Class(getClass)
void(notify)
void(notifyAll)
java.util.stream.IntStream(chars)
java.util.stream.IntStream(codePoints)
/*成员变量也是对象
java.lang.reflect.Field
Field类封装了关于成员变量操作
getField（）方法获取的是所有public成员变量的信息*/
// Field[] fsFields=c.getFields();
//getDeclaredFields()获取的是该类型自己的声明的成员变量的信息
Field[] fields=c.getDeclaredFields();
for (Field field : fields) {
//的到成员变量类型的类类型
Class fieldType=field.getType();
String typeName=field.getName();
//的到成员变量的名称
String filedName=field.getName();
System.out.println(typeName+""+typeName);
}
package com.imooc.reffert;
public class ClassDemo5 {
public static void main(String[] args) {
// TODO Auto-generated method stub
ClassUtil.printConMessage("hello");
ClassUtil.printConMessage(new Integer(1));
}
}
package com.imooc.reffert;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import javax.security.auth.callback.LanguageCallback;
public class ClassUtil {
// 打印类的信息 包括类的成员函数 成员变量
public static void printClassMessage(Object obj) {
// TODO Auto-generated method stub
//获取类的信息 首先获取类的类类型
Class c=obj.getClass();//传递的那一个子类的对象 c就是该子类的类类型
//获取类名称
System.out.println("类的名称："+c.getName());
//Method类，方法的对象 一个成员方法就是一个Method对象
//getMethods()方法获取所有public函数 包括父类继承而来的
Method[] methods=c.getMethods();// c.getDeclaredMethod()
//c.getDeclaredMethod();getDeclaredMethod()h获取所有类的自己的声明的方法 不访问权限
for (int i = 0; i < methods.length; i++) {
//得到方法返回值类型的类类型
Class returnType=methods[i].getReturnType();
System.out.print(returnType.getName()+"(");
//方法的名称
System.out.print(methods[i].getName());
//获取参数类型
Class[] paramTypes=methods[i].getParameterTypes();
for (Class class1 : paramTypes) {
System.out.print(class1.getName()+",");
}
System.out.println(")");
//pringFieldMessage(c);
}
}
// 成员变量
//private static void pringFieldMessage(Class c) {
public static void pringFieldMessage(Object object) {
Class c=object.getClass();
/*成员变量也是对象
java.lang.reflect.Field
Field类封装了关于成员变量操作
getField（）方法获取的是所有public成员变量的信息*/
// Field[] fsFields=c.getFields();
//getDeclaredFields()获取的是该类型自己的声明的成员变量的信息
Field[] fields=c.getDeclaredFields();
for (Field field : fields) {
//的到成员变量类型的类类型
Class fieldType=field.getType();
String typeName=field.getName();
//的到成员变量的名称
String filedName=field.getName();
System.out.println(typeName+""+typeName);
}
}
// 打印构造函数的信息
public static void printConMessage(Object obj){
Class c=obj.getClass();
// 构造函数也是对象
// java.lang.Constructor封装了构造信息
//getConstructors()获取public的构造函数
//getDeclaredConstructors得到所有的构造函数
//Constructor[] cs=c.getConstructors();
Constructor[] cs=c.getDeclaredConstructors();
for (Constructor constructor : cs) {
System.out.print(constructor.getName()+"(");
//获取构造函数参数列表--》得到参数列表的类类型
Class[] paramTypes=constructor.getParameterTypes();
for (Class class1 : paramTypes) {
System.out.print(class1.getName()+",");
}
System.out.println(")");
}
}
}
java.lang.String([B,int,int,)
java.lang.String([B,java.nio.charset.Charset,)
java.lang.String([B,java.lang.String,)
java.lang.String([B,int,int,java.nio.charset.Charset,)
java.lang.String([B,int,int,java.lang.String,)
java.lang.String([C,boolean,)
java.lang.String(java.lang.StringBuilder,)
java.lang.String(java.lang.StringBuffer,)
java.lang.String([B,)
java.lang.String([I,int,int,)
java.lang.String()
java.lang.String([C,)
java.lang.String(java.lang.String,)
java.lang.String([C,int,int,)
java.lang.String([B,int,)
java.lang.String([B,int,int,int,)
java.lang.Integer(int,)
java.lang.Integer(java.lang.String,)
方法的反射
获取方法
方法的名称和方法的参数列表才能唯一决定某一个方法
方法的反射操作
method.invoke（对象，参数列表）
package com.imooc.reffert;
import java.lang.reflect.Method;
public class Methoddemo1 {
private static Method m2;
public static void main(String[] args) {
// TODO Auto-generated method stub
//要获取print（int ，int）方法
//要获取一个方法就是获取类的信息 获取类的信息首先要获取类的类型
A a1=new A();
Class c=a1.getClass();
//getMethod获取的public的方法
//获取方法 必须要有名称与参数列表来决定
//c.getMethod(name, parameterTypes)
//getDeclaredMethod自己声明的方法
//c.getDeclaredMethod(name, parameterTypes);
/* try {
//Method m=c.getMethod("print", new Class[]{int.class,int.class});
} catch (NoSuchMethodException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SecurityException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}*/
try {
Method m=c.getMethod("print", int.class,int.class);
//方法反射操作
//方法的反射操作是用m对象来进行方法调用和a1.print调用效果完全相同
//方法如果没有返回值null 有返回值具体的返回值
Object o=m.invoke(a1,10,20);
//Object o=m.invoke(a1,new Object[]{10,20});
//a1.print(10, 20);
System.out.println("================");
//获取print(String,String)
Method m1=c.getMethod("print", String.class,String.class);
//用方法进行反射操作
//a1.print("hello", "world");
o=m1.invoke(a1, "hello","WORLD");
System.out.println("================");
//Method m2=c.getMethod("print", new Class[]{});
Method m2=c.getMethod("print");
//m2.invoke(a1, new Object[]{});
m2.invoke(a1);
} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
}
}
}
class A{
public void print(){
System.out.println("helloworld");
}
public void print(int a,int b){
System.out.println(a+b);
}
public void print(String a,String b){
System.out.println(a.toUpperCase()+","+b.toUpperCase());
}
}
30
================
HELLO,WORLD
================
helloworld
通过Class Method认识泛型的本质
package com.imooc.reffert;
import java.lang.reflect.Method;
import java.util.ArrayList;
public class MethodDemo4 {
public static void main(String[] args) {
// TODO Auto-generated method stub
ArrayList list=new ArrayList();
ArrayList
list.add("hello") ;
//list1.add("hello")
Class class1=list.getClass();
Class class2=list1.getClass();
System.out.println(class1==class2);
//反射的操作都是编译之后的操作
//c1==c2结果返回true说明编译之后集合的泛型是去泛型化的
//java中集合的泛型，是防止错误输入的 值在编译阶段有效
//绕过编译就失效了
//验证 我们可以通过方法的反射来操作，绕过编译
try {
Method m=class1.getMethod("add", Object.class);
m.invoke(list1, 20);//绕过编译操作就绕过泛型
System.out.println(list1.size());
System.out.println(list1);
/* for (String string : list1) {
System.out.println(string);
}*/
//现在不能这样遍历 类型不对
} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
}
}
}
true
1
[20]
File类的使用
RandomAccessFile的使用
字节流的使用
字符流的使用
对象的序列化和反序列化
java.io.File类的文件项目
file类的表示（目录）的信息（名称 大小）不能用于文件内容的访问
IO流（输入流 输出流）
字节流 字符流
1>InputStream OutputStream
InputStream抽象了应用程序读取数据的方式
OutputStream抽象了应用程序写的数据的方式
2>
EOF=End 读到-1就读到结尾
3>输入流基本方法
int b=in.read（）;读取一个字节无符号填充到int低八位 -1是EOF
in.read（byte[] buf）读取的数据填充到字节数组buf
in.read（byte[] buf,int start ,int size）读取数据到字节数组buf从buf的start位置开始存放size的长度的数据
4>输入流基本方法
out.write（int b）写出一个byte到流 b的低八位
out.write（byte[] buf）将buf字节数组都写到流
out.write（byte[] buf，int start ，int size）
5>
FileInputStream-->具体实现了
float f_val=45.0f或者float f_val=45.0F
需求
分析需求 拆解需求
实现功能代码
分发各个模块功能
请求响应
客户端与浏览器交互
html缓存代码
JPA是什么？？
java虚拟机？？？
minfest-Version 版本1.0
Class-path：class路径 打jar包 引用jar包
js--->静态页面动起来
jquery--->代码少 类库 库
web App library 放入jar包
ftr 视图文件 放在WEB-INF
lib 放入jar包
Build Path
orader and Export导出
我们在卸载MySQL的时候，会发现有一个名为“Connector Net X.X.X”（如：Connector Net 6.9.3）软件总是卸载不成功，下面我们来看看解决方法：
1. 在C盘的目录下，有一个隐藏文件——ProgramData，进入C:\ProgramData\MySQL\，删除里面所有文件及文件夹；
2. 进入注册表（win7：开始-运行-regedit；win8:Ctrl+R，输入regedit）；
3. Ctrl+F，输入Connector Net X.X.X（根据自己的版本来），查找相关文件，并删除，循环此步骤，直到注册表中再也查不到Connector Net X.X.X;
到此为止，Connector Net X.X.X成功卸载。
web.xml
javascirpt
20170418课堂笔记知识点
web页面
html技术
HyperText Markup Language，超级文本标记语言。
“超文本”就是指页面内可以包含图片、链接，甚至音乐、程序等非文字元素。
超文本标记语言的结构包括“头”部分（英语：Head）、和“主体”部分（英语：Body），其中“头”部提供关于网页的信息，“主体”部分提供网页的具体内容。
CSS技术
Cascading Style Sheets，层叠样式表。
是用来表现HTML等文件样式的计算机语言。
JavaScript技术
缩写JS，脚本语言。
Java技术
功能强大，应用范围广。
作业：
安装火狐浏览器
改动视图：Windows——》Show View
-------------------------------------
Debug 调试
Eclipse 快捷键"Alt+/"
.sh后缀是liunx
javabean
就是符合特定的规范的java类 使用javabean的好处是解决代数的重复编写 减少代码的冗余。功能区的分明 提供代码的维护性
javabean的设计原则 公有类 无参的公有构造方法
属性私有
getter和setter方法封装
public class Student{
private String age；
private int age；
public Students（）{}
public void setName（String name）{this.name=name；}
public String getName（）{return this.name；}
public void setAge（int age）{this.age=age}
public int getAge（）{return this.age；}
}
jsp动作
jsp动作元素 动作元素为请求处理的阶段提供信息 动作元素遵循xml元素的语法 有一个包含元素名的开始标签 可以有属性 可选的内容 与开始标签匹配的结束标签
jsp中如何使用javabean
1.使用普通的Java类一样 创建Javabean实例
2.在jsp页面中通常使用jsp动作标签使用javabean
javabean的四个作用域范围
Model简介
注解
框架相关代码
代码
spring Mybatis
自定义注解
jdk自带注解
@Override @Deprecated @suppvisewarnings
第三方注解
Spring ：
@Autowired：
@Service ：
@Repository：
Mybatis：
@InsertProvider：
@UpdateProvider：
@Options：
@inherted允许子类继承
@Documented 生成javadoc时会包含注解
@interface 注解
成员类型受限制 合法的类型包括原始类型的及String Class Annotation Enumeration
如果注解只有一个成员 则成员必须取名为Vvalue（） 在使用可以忽略成员名与赋值好（=）
没有成员 元注解
注解分类
源码注解
编译注解.class文件中
运行注解
元注解
自定义注解
语法
@<注解名>（<成员名1>=<成员值1>,<成员名1>=<成员值1>）
持久层架构 用来替代HIbernate
注解的作用范围 @Target和生命周期@Retention
包 类 字段 方法 方的参数 局部变量
1．未部署Web应用
2．URL输入错误
a.查看URL的IP地址和端口号是否书写正确。
b.查看上下文路径是否正确 Project--------Properties------MyElipse-----Web----- Web Context-root检查这个路径名称是否书写正确。
c.检查一下文件名称是否书写正确。
3．目录不能被引用
在 Eclipse的“包资源管理器(Package Explorer)”检查文件存放的位置。由于META-INF WEB-INF文件夹下的内容无法对外发布，所以，如果你引用了带这两个目录的文件，肯定是不允许。
例如： http://localhost:8080/guestbook/WEB-INF/index.html就是错误的,文件位置存放错误
4． Tomcat服务器中web.xml中的问题
如果你的web应用程序有多个jsp页面的话，当你点击你web应用程序的虚拟根目录时可能会出现404错 误，只是你只需要修改Tomcat服务器中web.xml
5．WEB-INF下面必须要有几个固定的文件夹和文件
web.xml 该web app的配置文件
lib 该web app用到的库文件
classes存放编译好的servlet
请注意他们的名字，我曾经就由于把classes写成class，查错查了半宿还没解决，所以写这些的时候千万要仔细，否则浪费更多的精力去查错。
6． 如果要运行的不是.jsp文件，而是servlet（.class）文件，要配置web.xml(当然是WEB-INF下面的)，加上以下字段：
其中的“HelloWorldServlet”改为你要运行的文件名
7．其他解决思路
以上方法无果,介于"HTTP Status 404(The requested resource is not available"异常发生情况的多样性,采用替换大法:
步骤:
a.找一份正常的相同环境(找同学同事相同开发环境机子或者网上下载的正常demo等)
b.依次替换问题项目文件,进行排除,定位.直到解决.
servlet
一、表单提交时出现乱码：
在进行表单提交的时候，经常提交一些中文，自然就避免不了出现中文乱码的情况，对于表单来说有两种提交方式：get和post提交方式。所以请求的时候便有get请求和post请求。以前我一直以为get请求和post请求方式出现的乱码的解决方式是一样的，但是今天才知道两种请求方式所产生的乱码的解决方式是不同的。每种方式都有着不同的解决方法，之所以出现乱码，原因就在于get请求时，其传递给服务器的数据是附加在URL地址之后的；而post的请求时，其传递给服务器的数据是作为请求体的一部分传递给服务器。这也就导致了对它们所产生的乱码的处理方式是不同的。
1、客户端的get请求
对于不同的请求方式，解决乱码的问题也是不一样的，对于客户端的get请求来说，服务器端处理要想不出现乱码，解决这个问题稍微复杂一些，需要用到String类型的构造函数，其中的一个构造函数就是用指定的编码方式去解码，一般都用“UTF-8”的方式。只要在服务器端将请求得到的参数重新构造成一个字符串就行了。如下所示：
String stuname = request.getParameter("stuname");
String str = new String(stuname.getBytes("ISO-8859-1"),"utf-8")
经过构造之后，客户端输入中文，且表单时get请求的情况下，str就变成了中文了。如果请求参数比较多，最好将它封装成一个工具类：
public class MyUtil
{
public static String getNewString(String str) throws UnsupportedEncodingException
{
return new String(str.getBytes("ISO-8859-1"),"UTF-8");
}
}
String stuname= MyUtil.getNewString(request.getParameter("stuname"));
2、客户端的post请求
对于客户端的post请求来说，处理乱码的问题就比较简单了，因为请求的数据时作为请求体的一部分传递给服务器的，所以只要修改请求内的编码就行了。只要在服务器端的最开始处将请求的数据设置为“UTF-8”就行了，输入如下语句：
request. setCharacterEncoding(“UTF-8”);
这样用户在服务器端获取到的中文数据就不再是乱码了。
二、超链接时出现乱码（低版本浏览器不行IE6）
在Web开发中，挺多的时候都是通过超链接去传递中文参数的，这也会导致在显示的时候也会出现乱码，对于超链接来说，它实际上是向服务器端发送了一个请求，而它发出的请求是属于get请求，所以对于超链接的乱码来说，它处理乱码的方式和表单的get请求出现乱码的方式是一样的。
String stuname= MyUtil.getNewString(request.getParameter("stuname"));
三、重定向时出现乱码（低版本浏览器不行IE6）
有时写上response的sendRedirect()方法进行重定向时也会出现乱码，重定向时实际上也是向服务器发送了一个请求，所以解决乱码的方法和和上面是一样的。
四、浏览器版本低导致的乱码
上网的时候，有时提交的一些信息在地址栏显示的是“%2C%C6%CC%C6”的字样，其实这都是防止出现乱码进行的解决方案，如果你的浏览器是IE6或以下版本，则我们的第二种情况和第三种情况会出现乱码(尤其是当中文是奇数的时候)，这就不好使了所以我们必须采用另一种比较实际的作法：
在Java.NET包中提供了URLEncoder类和URLDcoder类，这两个类又分别提供了encode和decode两个静态方法，分别用于进行编码和解码。我们将要传递的中文参数进行编码之后，在传递给服务器，服务器解码之后，就可以显示中文了。
进行编码：URLEncoder.encode(stuname,”UTF-8”)
传递给服务器：”>传递
进行解码：URLDecoder.decode(stuname,”UTF-8”);
这样就可以得到传递过来的中文参数了，我发现许多网站用的都是这种方式解决中参数的。
五、返回浏览器显示的乱码
在Servlet编程中，经常需要通过response对象将一些信息返回给浏览器，给我们的客户端，而我们在服务器端显示的中文，但是响应给客户端浏览器却是乱码，这主要是由于response对象的getWriter()方法返回的PrintWriter对象默认使用“ISO-8859-1”字符集编码进行Unicode字符串到字节数组的转换，由于ISO8859-1字符集中根本就没有包含中文字符，所以Java在进行转换的时候会将无效的字符编码输出给客户端，于是便出现了乱码，为此ServletResponse接口中便定义了setCharacterEncoding、setContentType等方法来指定getWriter方法返回的PrintWriter对象所使用的字符集编码，所以我们在写Servlet程序中，在调用getWriter方法之前设置这些方法的值。我们为了防止乱码，经常将以下两条语句一起写上：
response.setContentType(“text/html;charset=utf-8”);
response. setCharacterEncoding(“UTF-8”);
只要编写Servlet文件中含有响应给客户端的信息，那么就要写上这两句话。最好写上第二句话，因为它的优先级高，它的设置结果将覆盖setContentType等方法设置的字符编码集。
六、修改Tomcat的编码
在上述的get请求所导致乱码问题中，还有一种解决的方案，我们常用Tomcat作为运行Servlet和JSP的容器，而Tomcat内部默认的编码是ISO-8859-1，所以对于get请求方式，其传递的数据(URI)会附加在访问的资源后面，其编码是Tomcat默认的，如果修改该URI的编码，那么对于所有的get请求方式便不会出现乱码了包括上边说的重定向和超链接，在Tomcat的配置文件server.xml中找到修改Tomcat的端口的地方，在其内部加入URIEncoding属性，设置为和你的项目中所设的编码一样的值，这里全部都是UTF-8。如下所示：
七、使用MySQL数据库乱码
有时会用JDBC连接MySQL数据库，可能会出现乱码，所以要在连接之后加上如下的语句：
useUnicode=true&characterEncoding=UTF-8
这样就可以解决乱码问题了。
在编写Servlet和JSP的时候，为了避免出现乱码，最重要的就是：采用一致的编码，如果编码都一致了，肯定不会出现乱码。如果出现了乱码肯定那个地方不一致了。
css旧知识
table--表格
th----表格列--表头
tr----表行
td--表列
GET www.baidu.com/s?wd=java
post www.baidu.com
from 表单
input 表单 文本 密码 提交
Servlet
简单来说，Java的序列化机制是通过在运行时判断类的serialVersionUID来验证版本一致性的。在进行反序列化时，JVM会把传来的字节流中的serialVersionUID与本地相应实体（类）的serialVersionUID进行比较，如果相同就认为是一致的，可以进行反序列化，否则就会出现序列化版本不一致的异常。(InvalidCastException)
serialVersionUID有两种显示的生成方式： 一个是默认的1L，比如：private static final long serialVersionUID = 1L; 一个是根据类名、接口名、成员方法及属性等来生成一个64位的哈希字段，比如： private static final long serialVersionUID = xxxxL; 当你一个类实现了Serializable接口，如果没有显示的定义serialVersionUID，Eclipse会提供这个 提示功能告诉你去定义 。在Eclipse中点击类中warning的图标一下，Eclipse就会 自动给定两种生成的方式。如果不想定义它，在Eclipse的设置中也 可以把它关掉的，设置如下： Window ==> Preferences ==> Java ==> Compiler ==> Error/Warnings ==> Potential programming problems 将Serializable class without serialVersionUID的warning改成ignore即可。
当实现java.io.Serializable接口的实体（类）没有显式地定义一个名为serialVersionUID，类型为long的变量时，Java序列化机制会根据编译的class(它通过类名，方法名等诸多因素经过计算而得，理论上是一一映射的关系，也就是唯一的)自动生成一个serialVersionUID作序列化版本比较用，这种情况下，如果class文件(类名,方法明等)没有发生变化(增加空格,换行,增加注释,等等),就算再编译多次,serialVersionUID也不会变化的.
如果我们不希望通过编译来强制划分软件版本，即实现序列化接口的实体能够兼容先前版本，未作更改的类，就需要显式地定义一个名为serialVersionUID，类型为long的变量，不修改这个变量值的序列化实体都可以相互进行串行化和反串行化。
如果你没有考虑到兼容性问题时，就把它关掉，不过有这个功能是好的，只要任何类别实现了Serializable这个接口的话，如果没有加入 serialVersionUID，Eclipse都会给你warning提示，这个serialVersionUID为了让该类别 Serializable向后兼容。
问题一:假设有A端和B端,如果2处的serialVersionUID不一致,会产生什么错误呢?
问题二:假设2处serialVersionUID一致,如果A端增加一个字段,B端不变,会是什么情况呢?
问题三:假设2处serialVersionUID一致,如果B段增加一个字段,A端不变,会是什么情况呢?
问题四:假设2处serialVersionUID一致,如果A端减少一个字段,B端不变,会是什么情况呢?
问题五:假设2处serialVersionUID一致,如果B端减少一个字段,A端不变,会是什么情况呢?
例子如下:写2个类,类名相同,字段相同,方法相同.放在不同的包里,来模仿A端和B端.
实体类:在本例中,在测试类SerialTest执行前代表A端,然后,在测试类DeserialTest执行前代表B端.
package com.test; import java.io.Serializable;
public class Serial implements Serializable{ /** * */ private static final long serialVersionUID = 6977402643848374753L; int id; String name; public Serial(int id, String name) { this.id = id; this.name = name; } public String toString() { return "DATA: " + id + " " +name; } }
测试类,代表A端的序列化
package com.test.serializable;
import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.io.ObjectOutputStream;
public class SerialTest {
/** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub Serial serial1 = new Serial(1,"song"); System.out.println("Object Serial"+serial1); try { FileOutputStream fos = new FileOutputStream("serialTest.txt"); ObjectOutputStream oos = new ObjectOutputStream(fos); oos.writeObject(serial1); oos.flush(); oos.close(); } catch (FileNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } }
测试类,代表B端的反序列化
package com.test.serializable;
import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; import java.io.ObjectInputStream;
public class DeserialTest {
/** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub Serial serial2 ; try { FileInputStream fis = new FileInputStream("serialTest.txt"); ObjectInputStream ois = new ObjectInputStream(fis); serial2 = (Serial)ois.readObject(); ois.close(); System.out.println("Object Deserial"+serial2); } catch (FileNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (ClassNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } }
}
问题一:假设有A端和B端,如果2处的serialVersionUID不一致,会产生什么错误呢?
答案如下:
1)先执行测试类SerialTest,然后修改serialVersion值(或注释掉serialVersion并编译),再执行测试类DeserialTest,报错:
java.io.InvalidClassException: com.test.serializable.Serial; local class incompatible: stream classdesc serialVersionUID = 1, local class serialVersionUID = 11
2)A端和B端都没显示的写serialVersionUID,实体类没有改动(如果class文件(类名,方法明等)没有发生变化(增加空格,换行,增加注释,等等),).序列化,反序列化正常.
问题二:假设2处serialVersionUID一致,如果A端增加一个字段,B端不变,会是什么情况呢?
答案二: 序列化,反序列化正常,A端增加的字段丢失(被B端忽略).
问题五:假设2处serialVersionUID一致,如果B端减少一个字段,A端不变,会是什么情况呢?
答案:与问题二类似,序列化,反序列化正常,B端字段少于A端,A端多的字段值丢失(被B端忽略).
问题三:假设2处serialVersionUID一致,如果B段增加一个字段,A端不变,会是什么情况呢?
问题四:假设2处serialVersionUID一致,如果A端减少一个字段,B端不变,会是什么情况呢?(与问题三类似,四答案:序列化,反序列化正常,B端字段多余A端,B端多出的字段被赋予对应类型的默认值)
答案三: 序列化,反序列化正常,B端新增加的int字段被赋予了默认值0.
例子如下:
3)先执行SerialTest,然后在实体类增加一个字段age,再执行测试类DeserialTest.
package com.test.serializable;
import java.io.Serializable;
public class Serial implements Serializable {
/** * */ private static final long serialVersionUID = -2337937881709830076L;
/** * */ //private static final long serialVersionUID = 1L; int id;
String name; public Serial(int id, String name) { this.id = id; this.name = name; } public String toString() { return "DATA: " + id + " " +name; } public int age ;//在B端增加一个新字段 }
相应的修改测试类DeserialTest,打印出age的值.
package com.test.serializable;
import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; import java.io.ObjectInputStream;
public class DeserialTest {
/** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub Serial serial2 ; try { FileInputStream fis = new FileInputStream("serialTest.txt"); ObjectInputStream ois = new ObjectInputStream(fis); serial2 = (Serial)ois.readObject(); ois.close(); System.out.println("Object Deserial"+serial2+" age="+serial2.age); } catch (FileNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (ClassNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } }
}
打印结果如下:
Object DeserialDATA: 1 song age=0
1.创建一个变量
对象类型 变量
2.创建一个对象
new 对象类型（）
3.赋值
对象变量 类型
说明序列化,反序列化正常,B端新增加的int字段被赋予了默认值0.
Format是CString类的一个成员函数，它通过格式操作使任意类型的数据转换成一个字符串。
实上Format方法有两种形式，另外一种是三个参数的，主要区别在于它是线程安全的， 但并不多用，所以这里只对第一个介绍。Format参数是一个格式字符串，用于格式化Args里面的值的。Args是一个变量数组，即它里面可以有多个参数，而且每个参数可以不同。 例如：
Format("my name is %6s","wind");
JDBC:链接数据库
Java data base Connectivity（java数据库连接）
java应用
jdbc加载驱动程序 Class.forName（driverClass）
加载Mysql驱动 Class.forName（"com.mysql.jdbc.Driver"）
j加载Oracle驱动Class.forName （"oracle.jdbc.driver.OracleDriver"）
获取DriverMabager.getConnection （"jdbc:mysql://127.0.0.1:3306/imooc","root","root"）
创建Statement对象：conn.createStatement（）；
jdbc Oracle mysql SQLserver
jdbc常用的接口
jdbc编程步骤
view
contrl
model
db数据库（从下往上）
C
R：高级 报表 分页
U
D
执行的SQL语句
管理结果集
高级应用
分页：
高级查询 ：
高级函数使用：
/*public static void main(String[] args) throws Exception {
//加载驱动程序
Class.forName("com.mysql.jdbc.Driver");
//获得数据库的链接
Connection conn =DriverManager.getConnection(url, user, password);
//通过数据库的链接操作数据库 实现增删改查
Statement stmt=conn.createStatement();
ResultSet rs= stmt.executeQuery("select user_name,age from imooc_goddess");
while (rs.next()) {
System.out.println(rs.getString("user_name")+","+rs.getInt("age"));
}
}*/
Jdbc+odbc桥的方式
Jdbc+厂商的API形式
jdbc+厂商Database Connection
Server+DataBase的形式
特点 在Java与DataBase之间架起了一台专用于数据库连接的服务器（一般由数据库厂商提供）
Jdbc+Databesa
工具 mybatis hibernate
Servlet 通过调用 init () 方法进行初始化。
Servlet 调用 service() 方法来处理客户端的请求。
Servlet 通过调用 destroy() 方法终止（结束）。
最后，Servlet 是由 JVM 的垃圾回收器进行垃圾回收的。
init 方法被设计成只调用一次。它在第一次创建 Servlet 时被调用，在后续每次用户请求时不再调用。因此，它是用于一次性初始化，就像 Applet 的 init 方法一样。
Servlet 创建于用户第一次调用对应于该 Servlet 的 URL 时，但是您也可以指定 Servlet 在服务器第一次启动时被加载。
当用户调用一个 Servlet 时，就会创建一个 Servlet 实例，每一个用户请求都会产生一个新的线程，适当的时候移交给 doGet 或 doPost 方法。init() 方法简单地创建或加载一些数据，这些数据将被用于 Servlet 的整个生命周期
service() 方法是执行实际任务的主要方法。Servlet 容器（即 Web 服务器）调用 service() 方法来处理来自客户端（浏览器）的请求，并把格式化的响应写回给客户端。
每次服务器接收到一个 Servlet 请求时，服务器会产生一个新的线程并调用服务。service() 方法检查 HTTP 请求类型（GET、POST、PUT、DELETE 等），并在适当的时候调用 doGet、doPost、doPut，doDelete 等方法。
GET 请求来自于一个 URL 的正常请求，或者来自于一个未指定 METHOD 的 HTML 表单，它由 doGet() 方法处理。
POST 请求来自于一个特别指定了 METHOD 为 POST 的 HTML 表单，它由 doPost() 方法处理。
destroy() 方法只会被调用一次，在 Servlet 生命周期结束时被调用。destroy() 方法可以让您的 Servlet 关闭数据库连接、停止后台线程、把 Cookie 列表或点击计数器写入到磁盘，并执行其他类似的清理活动。
Accept 这个头信息指定浏览器或其他客户端可以处理的 MIME 类型。值 image/png 或 image/jpeg 是最常见的两种可能值。
Accept-Charset 这个头信息指定浏览器可以用来显示信息的字符集。例如 ISO-8859-1。
Accept-Encoding 这个头信息指定浏览器知道如何处理的编码类型。值 gzip 或 compress 是最常见的两种可能值。
Accept-Language 这个头信息指定客户端的首选语言，在这种情况下，Servlet 会产生多种语言的结果。例如，en、en-us、ru 等。
Authorization 这个头信息用于客户端在访问受密码保护的网页时识别自己的身份。
Connection 这个头信息指示客户端是否可以处理持久 HTTP 连接。持久连接允许客户端或其他浏览器通过单个请求来检索多个文件。值 Keep-Alive 意味着使用了持续连接。
Content-Length 这个头信息只适用于 POST 请求，并给出 POST 数据的大小（以字节为单位）。
Cookie 这个头信息把之前发送到浏览器的 cookies 返回到服务器。
Host 这个头信息指定原始的 URL 中的主机和端口。
If-Modified-Since 这个头信息表示只有当页面在指定的日期后已更改时，客户端想要的页面。如果没有新的结果可以使用，服务器会发送一个 304 代码，表示 Not Modified 头信息。
If-Unmodified-Since 这个头信息是 If-Modified-Since 的对立面，它指定只有当文档早于指定日期时，操作才会成功。
Referer 这个头信息指示所指向的 Web 页的 URL。例如，如果您在网页 1，点击一个链接到网页 2，当浏览器请求网页 2 时，网页 1 的 URL 就会包含在 Referer 头信息中。
User-Agent 这个头信息识别发出请求的浏览器或其他客户端，并可以向不同类型的浏览器返回不同的内容。
始状态行 + 回车换行符（回车+换行）
零个或多个标题行+回车换行符
一个空白行，即回车换行符
一个可选的消息主体，比如文件、查询数据或查询输出
100 Continue 只有请求的一部分已经被服务器接收，但只要它没有被拒绝，客户端应继续该请求。
101 Switching Protocols 服务器切换协议。
200 OK 请求成功。
201 Created 该请求是完整的，并创建一个新的资源。
202 Accepted 该请求被接受处理，但是该处理是不完整的。
203 Non-authoritative Information
204 No Content
205 Reset Content
206 Partial Content
300 Multiple Choices 链接列表。用户可以选择一个链接，进入到该位置。最多五个地址。
301 Moved Permanently 所请求的页面已经转移到一个新的 URL。
302 Found 所请求的页面已经临时转移到一个新的 URL。
303 See Other 所请求的页面可以在另一个不同的 URL 下被找到。
304 Not Modified
305 Use Proxy
306 Unused 在以前的版本中使用该代码。现在已不再使用它，但代码仍被保留。
307 Temporary Redirect 所请求的页面已经临时转移到一个新的 URL。
400 Bad Request 服务器不理解请求。
401 Unauthorized 所请求的页面需要用户名和密码。
402 Payment Required 您还不能使用该代码。
403 Forbidden 禁止访问所请求的页面。
404 Not Found 服务器无法找到所请求的页面。.
405 Method Not Allowed 在请求中指定的方法是不允许的。
406 Not Acceptable 服务器只生成一个不被客户端接受的响应。
407 Proxy Authentication Required 在请求送达之前，您必须使用代理服务器的验证。
408 Request Timeout 请求需要的时间比服务器能够等待的时间长，超时。
409 Conflict 请求因为冲突无法完成。
410 Gone 所请求的页面不再可用。
411 Length Required "Content-Length" 未定义。服务器无法处理客户端发送的不带 Content-Length 的请求信息。
412 Precondition Failed 请求中给出的先决条件被服务器评估为 false。
413 Request Entity Too Large 服务器不接受该请求，因为请求实体过大。
414 Request-url Too Long 服务器不接受该请求，因为 URL 太长。当您转换一个 "post" 请求为一个带有长的查询信息的 "get" 请求时发生。
415 Unsupported Media Type 服务器不接受该请求，因为媒体类型不被支持。
417 Expectation Failed
500 Internal Server Error 未完成的请求。服务器遇到了一个意外的情况。
501 Not Implemented 未完成的请求。服务器不支持所需的功能。
502 Bad Gateway 未完成的请求。服务器从上游服务器收到无效响应。
503 Service Unavailable 未完成的请求。服务器暂时超载或死机。
504 Gateway Timeout 网关超时。
505 HTTP Version Not Supported 服务器不支持"HTTP协议"版本。
java mysql免安装方法
basedir =F:\mysql-5.6.24-win32
datadir =F:\mysql-5.6.24-win32\data
port =3306
#编码
character_set_server=UTF8
path ;F:\mysql-5.6.24-win32\bin
cmd mysql
mysql -install
提示成功
net start mysql
请求的服务启动
net stop mysql
服务停止
mysql -u root -p
关闭正在运行的MySQL。
2.打开DOS窗口，转到mysql\bin目录。
3.输入mysqld --skip-grant-tables回车。如果没有出现提示信息，那就对了。
4.再开一个DOS窗口(因为刚才那个DOS窗口已经不能动了)，转到mysql\bin目录。
5.输入mysql回车，如果成功，将出现MySQL提示符 >
6. 连接权限数据库>use mysql; (>是本来就有的提示符,别忘了最后的分号)
7.改密码：> update user set password=password("123456") where user="root";
8.刷新权限(必须的步骤)>flush privileges;
9.退出 > \q
regedit
"C:\Program Files\MySQL\MySQL Server 5.6\mysqld" MySQL
F:\mysql-5.6.24-win32替换C:\Program Files\MySQL\MySQL Server 5.6
mysql show databases； 展示数据库
create database First；创建数据库
drop database；删除数据库
show databases;
create database 名称;
drop database 名称;
select describe from test_table;
2. 解压MySQL压缩包
将以下载的MySQL压缩包解压到自定义目录下,我的解压目录是:
"D:\Program Files\MySQL\mysql-5.6.13-win32"
将解压目录下默认文件 my-default.ini 拷贝一份，改名 my.ini
复制下面的配置信息到 my.ini 保存
#如果没有my-default.ini,可自己新建my.ini或者从其他地方中获取
#########################################################
[client]
port=3306
default-character-set=utf8
[mysqld]
port=3306
character_set_server=utf8
basedir=D:\Program Files\MySQL\mysql-5.6.13-win32
#解压目录
datadir=D:\Program Files\MySQL\mysql-5.6.13-win32\data
#解压目录下data目录
sql_mode=NO_ENGINE_SUBSTITUTION,STRICT_TRANS_TABLES
[WinMySQLAdmin]
D:\Program Files\MySQL\mysql-5.6.13-win32\bin\mysqld.exe
#########################################################
3. 添加环境变量
操作如下：
1）右键单击我的电脑->属性->高级系统设置(高级)->环境变量
点击系统变量下的新建按钮
输入变量名：MYSQL_HOME
输入变量值：D:\Program Files\mysql-5.6.11-winx64
#即为mysql的自定义解压目录。
2）选择系统变量中的Path
点击编辑按钮
在变量值中添加变量值：%MYSQL_HOME%\bin
注意是在原有变量值后面加上这个变量，用;隔开，不能删除原来的变量值，
4. 将mysql注册为windows系统服务
1）从控制台进入到MySQL解压目录下的 bin 目录下：
2）输入服务安装命令：
mysqld install MySQL --defaults-file="D:\Program Files\MySQL\mysql-5.6.13-win32\my.ini"
#解压目录下修改的my.ini文件
安装成功后会提示服务安装成功。
#注：my.ini文件放在MySQL解压后的根目录下
#移除服务命令为：mysqld remove
5. 启动MySQL服务
方法一：
启动服务命令为：net start mysql
方法二：
打开管理工具 服务，找到MySQL服务。
通过右键选择启动或者直接点击左边的启动来启动服务。
6. 修改 root 账号的密码
刚安装完成时root账号默认密码为空，此时可以将密码修改为指定的密码。如：123456
c:>mysql –uroot
mysql>show databases;
mysql>use mysql;
mysql>UPDATE user SET password=PASSWORD("123456") WHERE user='root';
mysql>FLUSH PRIVILEGES;
mysql>QUIT
7. MySQL控制台快捷方式建立:
1）桌面右键->新建->快捷方式->对象位置输入：C:\Windows\System32\cmd.exe
快捷方式名称自己定义，确定，快捷方式建立成功
2）右键单击刚才建立的快捷方式->属性->把目标一栏修改成MySQL启动参数：
C:\Windows\System32\cmd.exe "D:\Program Files\MySQL\mysql-5.6.13-win32\bin" /k mysql -uroot -p inventory
解释:CMD路径 "MySQL路径bin目录" /k mysql -u用户名 -p密码 数据库名
3）修改完成后点击确定保存，直接双击快捷方式即可连接到MySQL数据库
update user set password=password('12345') where user='root';
练习代码
show tables;
select * from pepole;
drop table cars;
--创建表
create table cars(
name char(20),
skil char(20),
age int(20));
insert into cars values('蜘蛛侠','吐丝',21,'男');
insert into cars values('钢铁侠','飞翔',42,'男');
insert into cars values('猫女','爪子',32,'女');
insert into cars values('侠女','剑',32,'女');
select * from cars;
alter table cars add sex char(1);
desc cars;
--删除
delete from cars;
delete from cars where name='猫女';
delete from cars where sex='男';
delete from cars where age>30;
select * from cars where name like '蜘蛛侠';
select * from cars where name like '%侠%';
select * from cars where name like '%侠%'and age>40;
select * from cars where age<30 or age>40;
update cars set sex='女';
drop table cars;
--主键primary key 不能为空 不能重复
create table cars(
id int(20) primary key auto_increment,
name char(20),
age int(3)
);
insert into cars values(1,'张三',21);
insert into cars values(2,'李四',12);
insert into cars values(3,'王五',45);
insert into cars values(4,null,21);
insert into cars values(null,'asd',21);
select * from cars;
delete from cars where id=4;
insert into cars values(4,'www',21);
update cars set name='你好', age=15 where id=4;
drop table user;
create table user(
id int(12) primary key auto_increment,
name char(20) not null default '未命名',
password char(20),
age int(3) not null default 0
);
insert into user values(null,'张三','123',0);
insert into user values(null,'','123',0);
insert into user values(null,'',null);
insert into user values(null,default,'123');
insert into user values(null,'default',null,default);
select *from user;
create database school;
数据库（DataBase，DB）：指长期保存在计算机的存储设备上，按照一定规则组织起来，可以被各种用户或应用共享的数据集合。
Oracle：目前比较成功的关系型数据库管理系统。运行稳定、功能齐全、性能超群、技术领先。主要应用在大型的企业数据库领域。
DB2：IBM的产品。
SQL Server：Microsoft的产品。软件界面友好、易学易用，在操作性和交互性方面独树一帜。
PostgreSQL：加州大学伯克利分校以教学目的开发的数据库系统，支持关系和面向对象的数据库，属于自由数据库管理系统。
MySQL：免费的数据库系统。被广泛用于中小型应用系统。体积小、速度快、总体拥有成本低，开放源代码。2008年被SUN收购，2009年SUN被Oracle收购。所谓安装数据库服务器，只是在机器上装了一个数据库管理程序，这个管理程序可以管理多个数据库，一般开发人员会针对每一个应用创建一个数据库
为保存应用中实体的数据，一般会在数据库创建多个表，以保存程序中实体的数据。
数据库服务器、数据库和表的关系如图
登录MySQL mysql -uroot -p123456 – u用户名 –p密码
show databases; --查看安装的数据库
use database_name; --使用数据库
show tables; --查看数据库中的表
show columns form ‘表名’；
--显示数据表的属性，属性类型，主键信息 ，是否为 NULL，默认值等其他信息Structure Query Language。
DDL（Data Definition Language）：数据定义语言，用来定义数据库对象：库、表、列等；
create alter drop
DML（Data Manipulation Language）：数据操作语言，用来操作数据库表中的记录（数据）；
insert：
INSERT INTO t_student
VALUES('1','1','2016001001','王宝强','男','1985-08-30 00:00:00'); 插入的数据应与字段的数据类型相同。
-- 数据的大小应在列的规定范围内，例如：不能将一个长度为80的字符串加入到长度为40的列中。
-- 在values中列出的数据位置必须与被加入的列的排列位置相应
-- 字符和日期型数据应包含在单引号中。
-- 插入空值，不指定或insert into table value(null)update
delete
DQL（Data Query Language）：数据查询语言，用来查询记录（数据）。select
DCL（Data Control Language）：数据控制语言，用来定义访问权限和安全级别；
primary key
auto_increment
CREATE TABLE table_name (column_name column_type); --创建表
CREATE TABLE t_student (
id INT (11) NOT NULL PRIMARY KEY AUTO_INCREMENT, -- 主键自增
class_id INT (11) NOT NULL, --班级ID
student_no VARCHAR (10) NOT NULL, -- 学号 不能为空
student_name VARCHAR (10) NOT NULL, -- 姓名 不能为空
sex CHAR (2) DEFAULT NULL, -- 性别
birthday datetime DEFAULT NULL -- 生日 日期格式
)；
DROP TABLE table_name ; --删除表
删除列
ALTER TABLE table_name DROP column_name;
添加列
ALTER TABLE table_name ADD column_name INT;
修改列类型
ALTER TABLE table_name MODIFY column_name CHAR(10);
修改列名称
ALTER TABLE table_name CHANGE c1 c2 BIGINT;
修改字段默认值
ALTER TABLE table_name ALTER column_name SET DEFAULT 1;
修改表名
ALTER TABLE table_name RENAME TO new_table_name ;
使用 update语句修改表中数据
UPDATE t_student SET student_name='王宝强',sex='男' WHERE id=1使用 delete语句删除表中数据
DELETE FROM t_student WHERE student_name = '王宝强';
SELECT [DISTINCT] *|{column1, column2, column3..} FROM table;
SELECT指定查询哪些列的数据。
column指定列名。
*号代表查询所有列。
FROM指定查询哪张表。
DISTINCT可选，指显示结果时，是否剔除重复数据使用order by 子句排序查询结果
SELECT column1, column2. column3.. FROM table order by column asc|desc
Order by 指定排序的列，排序的列即可是表中的列名，也可以是select 语句后指定的列名。
Asc 升序、Desc 降序
ORDER BY 子句应位于SELECT语句的结尾
连接查询：
交叉连接（cross join）:不带on子句，返回连接表中所有数据行的笛卡儿积。内连接（inner join）：返回连接表中符合连接条件及查询条件的数据行。外连接：分为左外连接（left out join）、右外连接（right outer join）。与内连接不同的是，外连接不仅返回连接表中符合连接条件及查询条件的数据行，也返回左表（左外连接时）或右表（右外连接时）中仅符合查询条件但不符合连接条件的数据行。
子查询
联合查询
报表查询
show databases;
--显示数据表的属性，属性类型，主键信息 ，是否为 NULL，默认值等其他信息
show columns from user;
select * from user;
--创建mydb数据库
create database cook;
--删除mydb数据库
drop database cook;
select * from cook;
drop table cook;
delete from cook;
--primary key:不允许为空，不允许重复
--主键自动增长 auto_increment
--定义非空约束 not null
--Order by 指定排序的列，排序的列即可是表中的列名，也可以是select 语句后指定的列名。
--Asc 升序、Desc 降序
--ORDER BY 子句应位于SELECT语句的结尾。
create table cook(
id int(4) primary key auto_increment,
name char(20) ,
age int(3) ,
password char(20) ,
url char(200)
);
insert into cook values(1,'淘宝',2,'123456','www.taobao.com');
insert into cook values(2,'百度',1,'123456','www.baidu.com');
insert into cook values(3,'网易',4,'123456','http://www.wangye.com');
insert into cook values(4,'京东',3,'123456','http://www.jidong.com');
insert into cook values(5,'google',7,'123456','http://www.Google.com');
select * from cook;
select * from cook where name like '%宝%';
--SELECT语句中可使用as语句
--在SELECT语句中可使用表达式对查询的列进行运算
select from cook union;
SELECT id FROM cook
UNION ALL
SELECT id FROM user;
--连接查询的from子句的连接语法 TABLE1和TABLE2表示参与连接操作的表
--，TABLE1为左表，TABLE2为右表。on子句设定连接条件，where子句设定查询条件，
--join_type表示连接类型
select * from cook where age=2 and age>3;
alter table cook add county int(20);
--增加列 属性
alter table cook drop county;
--增加 列的类型
alter table cook modify country char(20);
--更新
update cook set country='中国' where id=1;
--删除主键
alter table cook drop primary key;
--交叉 查询CUSTOMER表和ORDERS表
select * from cook cross join user;
select * from cook,user;
--显示内连接 使用inner join关键字，在on子句中设定连接条件
select * from cook c inner join user o on c.id=o.id;
--隐式内连接 不包含inner join关键字和on关键字，在where子句中设定连接条件
select * from cook c,user o where c.id=o.id;
--右连接 使用right outer join关键字，在on子句中设定连接条件
select * from cook c right outer join user o on c.id=o.id;
--条件式右连接
SELECT * FROM user c RIGHT OUTER JOIN cook o ON c.id=o.id WHERE o.age>5;
--子查询 嵌套查询，是指在select子句或者where子句中又嵌入select查询语句,子查询的语句放在小括号之内
--所有订单
select * from cook where id=(select id from cook where name like '%宝%');
--左连接 使用left outer join关键字，在on子句中设定连接条件
select * from cook c left outer join user o on c.id=o.id;
--条件式左连接
SELECT * FROM user c left OUTER JOIN cook o ON c.id=o.id WHERE o.age>10;
--联合查询 两条查询语句的查询结果，去掉其中的重复数据行，然后返回没有重复数据行的查询结果。联合查询使用union关键字
select * from cook where age>15 union SELECT * FROM cook where name='ni';
--合计函数count sum avg MAX/MIN
Select count(age) from cook;
SELECT SUM(age) FROM cook;
SELECT MAX(age) FROM cook;
SELECT MIN(age) FROM cook;
---group by语句
--报表查询
select * from cook group by id order by 'date';
--备份单个数据库 mysqldump -u root -p mydb > D:\mydb_backup.sql
--备份多个数据库 mysqldump -u root -p mydb1，mydb2 > D:\mydb_backup.sql
--备份所有数据库 mysqldump -u root -p -all-databases > D:\mydb_backup.sql
--恢复数据库 mysql -u root -p
package com.imooc.www;
import java.io.IOException;
import java.io.PrintWriter;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.tomcat.util.descriptor.web.LoginConfig;
import sun.security.util.Password;
/**
* Servlet implementation class DengDmeo
*/
@WebServlet("/DengDmeo")
public class DengDmeo extends HttpServlet {
private static final long serialVersionUID = 1L;
/**
* @see HttpServlet#HttpServlet()
*/
public DengDmeo() {
super();
// TODO Auto-generated constructor stub
}
/**
* @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
*/
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// TODO Auto-generated method stub
response.setContentType("text/html;charset=UTF-8");
request.setCharacterEncoding("UTF-8");
//response.getWriter().append("欢迎！");
String name=request.getParameter("nam");
//response.getWriter().append(name);
String password=request.getParameter("password");
//response.getWriter().append(password);
String sql="insert into user values(null,'"+name+"','"+password+"');";
String content = searchDQL("select * from user where name = '"+name+"'and password='"+password+"' ");
insertSQL(sql);
searchDQL(content);
if(name != null && password != null&&content!=null )
{
if(!name.equals("")&&!password.equals("")){
//跳转到系统主页面
response.sendRedirect("c.jsp");
}
else{
//否则就提示登录错误
response.getWriter().write("帐号或密码不能为空字符串或请注册账号！");
}
}else if (name != null && password != null&&sql!=null) {
if(!name.equals("")&&!password.equals("")){
//跳转到系统主页面
response.sendRedirect("a.jsp");
}
else{
//否则就提示登录错误
response.getWriter().write("帐号或密码不能为空字符串或请注册账号！");
}
}
}
/*String sql="insert into user values(null,'"+name+"','"+password+"');";
insertSQL(sql);
String content = searchDQL("select * from user where name = '"+name+"'and password='"+password+"' ");
searchDQL(content);*/
private Object getString(String string) {
// TODO Auto-generated method stub
return null;
}
/**
* @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
*/
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// TODO Auto-generated method stub
doGet(request, response);
}
public void insertSQL(String sql){
try {
Class.forName("com.mysql.jdbc.Driver");
Connection connection=DriverManager.getConnection("jdbc:mysql://localhost:3306/test","root","123456");
Statement statement=connection.createStatement();
statement.execute(sql);
statement.close();
connection.close();
} catch (Exception e) {
// TODO: handle exception
}
}
public String searchDQL(String sql) {
String content = "";
try {
Class.forName("com.mysql.jdbc.Driver");
Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "123456");
Statement statement = connection.createStatement();
ResultSet set = statement.executeQuery(sql);
while (set.next()) {
int id = set.getInt("id");
String name = set.getString("nam");
String password = set.getString("password");
content += id;
content += name;
content += password;
}
set.close();
statement.close();
connection.close();
} catch (Exception e) {
// TODO: handle exception
}
return content;
}
}
Servlet 过滤器可以动态地拦截请求和响应，以变换或使用包含在请求或响应中的信息。
可以将一个或多个 Servlet 过滤器附加到一个 Servlet 或一组 Servlet。Servlet 过滤器也可以附加到 JavaServer Pages (JSP) 文件和 HTML 页面。调用 Servlet 前调用所有附加的 Servlet 过滤器。
Servlet 过滤器是可用于 Servlet 编程的 Java 类，可以实现以下目的：
在客户端的请求访问后端资源之前，拦截这些请求。
在服务器的响应发送回客户端之前，处理这些响应。
根据规范建议的各种类型的过滤器：
身份验证过滤器（Authentication Filters）。
数据压缩过滤器（Data compression Filters）。
加密过滤器（Encryption Filters）。
触发资源访问事件过滤器。
图像转换过滤器（Image Conversion Filters）。
日志记录和审核过滤器（Logging and Auditing Filters）。
MIME-TYPE 链过滤器（MIME-TYPE Chain Filters）。
标记化过滤器（Tokenizing Filters）。
XSL/T 过滤器（XSL/T Filters），转换 XML 内容。
过滤器通过 Web 部署描述符（web.xml）中的 XML 标签来声明，然后映射到您的应用程序的部署描述符中的 Servlet 名称或 URL 模式。
当 Web 容器启动 Web 应用程序时，它会为您在部署描述符中声明的每一个过滤器创建一个实例。
Filter的执行顺序与在web.xml配置文件中的配置顺序一致，一般把Filter配置在所有的Servlet之前
Cookie 是存储在客户端计算机上的文本文件，并保留了各种跟踪信息。Java Servlet 显然支持 HTTP Cookie。
识别返回用户包括三个步骤：
服务器脚本向浏览器发送一组 Cookie。例如：姓名、年龄或识别号码等。
浏览器将这些信息存储在本地计算机上，以备将来使用。
当下一次浏览器向 Web 服务器发送任何请求时，浏览器会把这些 Cookie 信息发送到服务器，服务器将使用这些信息来识别用户。
本章将向您讲解如何设置或重置 Cookie，如何访问它们，以及如何将它们删除。
Servlet Cookie 处理需要对中文进行编码与解码，方法如下：
String str = java.net.URLEncoder.encode("中文"，"UTF-8"); //编码
String str = java.net.URLDecoder.decode("编码后的字符串","UTF-8"); // 解码
Cookie 剖析
Cookie 通常设置在 HTTP 头信息中（虽然 JavaScript 也可以直接在浏览器上设置一个 Cookie）。设置 Cookie 的 Servlet 会发送如下的头信息：
HTTP/1.1 200 OK
Date: Fri, 04 Feb 2000 21:03:38 GMT
Server: Apache/1.3.9 (UNIX) PHP/4.0b3
Set-Cookie: name=xyz; expires=Friday, 04-Feb-07 22:03:38 GMT;
path=/; domain=w3cschool.cc
Connection: close
Content-Type: text/html
正如您所看到的，Set-Cookie 头包含了一个名称值对、一个 GMT 日期、一个路径和一个域。名称和值会被 URL 编码。expires 字段是一个指令，告诉浏览器在给定的时间和日期之后"忘记"该 Cookie。
如果浏览器被配置为存储 Cookie，它将会保留此信息直到到期日期。如果用户的浏览器指向任何匹配该 Cookie 的路径和域的页面，它会重新发送 Cookie 到服务器。浏览器的头信息可能如下所示：
GET / HTTP/1.0
Connection: Keep-Alive
User-Agent: Mozilla/4.6 (X11; I; Linux 2.2.6-15apmac ppc)
Host: zink.demon.co.uk:1126
Accept: image/gif, */*
Accept-Encoding: gzip
Accept-Language: en
Accept-Charset: iso-8859-1,*,utf-8
Cookie: name=xyz
Servlet 就能够通过请求方法 request.getCookies() 访问 Cookie，该方法将返回一个 Cookie 对象的数组
jsp servlet js登录与注册
LoginServlet.java
package com.zhiyou100.servlet;
import java.io.IOException;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* Servlet implementation class LoginServlet
*/
@WebServlet("/login")
public class LoginServlet extends HttpServlet {
private static final long serialVersionUID = 1L;
/**
* @see HttpServlet#HttpServlet()
*/
public LoginServlet() {
super();
// TODO Auto-generated constructor stub
}
/**
* @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
*/
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// TODO Auto-generated method stub
response.getWriter().append("Served at: ").append(request.getContextPath());
}
/**
* @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
*/
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
request.setCharacterEncoding("UTF-8");
response.setContentType("text/html; charset=UTF-8");
String username = request.getParameter("username");
String password = request.getParameter("password");
String dbPassword = null;
try {
Class.forName("com.mysql.jdbc.Driver");
Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test3", "root", "1230123");
Statement statement = conn.createStatement();
String sql = "select password from user where username = '" + username + "';";
ResultSet rs = statement.executeQuery(sql);
while(rs.next()) {
dbPassword = rs.getString("password");
}
rs.close();
conn.close();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
if (dbPassword == null) {
//帐号不存在
response.getWriter().append("帐号不存在");
}else if (dbPassword.equals(password)) {
//比较存储的密码和输入的密码是否一致
response.getWriter().append("登录成功");
}else {
response.getWriter().append("密码输入有误");
}
//输出 js 并执行，js 是 JavaScript 的简称和 Java 没有关系。
//HTML，框架
//CSS，装饰
//JS，让网页和用户进行互动
response.getWriter().append("");
//为了后期的修改和维护，我们需要把相同的代码封装到方法中。
//那么所有使用这段代码的地方，使用调用方法代替。
//相同的代码就只用去方法实现中写一遍即可。
//将来修改的时候，只需要去方法实现中修改一次，那么所有调用方法的地方都跟着发生变化。
//在编程经验不足的时候，优先实现功能，后考虑修改和优化。
//
}
}
RegisterServlet.java
package com.zhiyou100.servlet;
import java.io.IOException;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* Servlet implementation class RegisterServlet
*/
@WebServlet("/register")
public class RegisterServlet extends HttpServlet {
private static final long serialVersionUID = 1L;
/**
* @see HttpServlet#HttpServlet()
*/
public RegisterServlet() {
super();
// TODO Auto-generated constructor stub
}
/**
* @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
*/
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// TODO Auto-generated method stub
response.getWriter().append("Served at: ").append(request.getContextPath());
}
/**
* @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
*/
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
//1.统一编码格式
request.setCharacterEncoding("UTF-8");
response.setContentType("text/html; charset=UTF-8");
//2.获得用户在表单中输入的内容
String username = request.getParameter("username");
String password = request.getParameter("password");
//3.判断 username 是否可用
//3.0 假设这个 dbPassword 是从数据库中查询出来的 username 对应的 password。
String dbPassword = null;
//3.1 从数据库查找是否有 username 对应的 password
//3.1.1 建立数据库和表
try {
//3.1.2 加载驱动，拖 jar 包
Class.forName("com.mysql.jdbc.Driver");
//3.1.3 建立数据库链接
Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test3", "root", "1230123");
//3.1.4 创建执行 SQL 语句的 Statement 对象
Statement statement = conn.createStatement();
//3.1.5 拼装需要执行的 SQL 语句
String sql = "select password from user where username = '" + username + "';";
//3.1.6 执行 SQL 语句，获得查询结果放入 ResultSet
ResultSet rs = statement.executeQuery(sql);
//3.1.7 通过 while 循环取出 password 赋值提前声明好的变量 dbPassword
while(rs.next()) {
dbPassword = rs.getString("password");
}
//3.1.8 关闭 rs 和 conn
rs.close();
conn.close();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
//3.2 判断 dbPassword 是否存在
if (dbPassword == null) {
//说明数据库中没有 username 这一行，说明 username 可以使用。
//3.2.1 把 username 和 password 插入数据库
try {
Class.forName("com.mysql.jdbc.Driver");
Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test3", "root", "1230123");
Statement statement = conn.createStatement();
String sql = "insert into user values(null, '" + username + "', '" + password + "')";
statement.execute(sql);
conn.close();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
//3.2.2 告诉用户注册成功
response.getWriter().append("账号注册成功");
}else {
//说明数据库中有 username 这一行，说明 username 不可以使用。
//3.2.3 告诉用户用户名不可用
response.getWriter().append("用户名已被使用，请更换");
}
}
}
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
点击去登录页面
page: 可以作用于单个页面
request: 可以作用于单个请求
session： 可以作用于整个会话
application： 可以作用于整个Web应用
Javabean既可以封装数据同时也可以封装业务逻辑。
眼高手低：
进度由慢到快
写代码 要代码量 写代码有感觉 写多了
1.白天老师做笔记 在不看代码与笔记 自己敲出来！创建自己新工程。
2.前一天失败的原因 自己写！晚上要练习！
3.写代码卡壳了的地方做笔记， 晚上复习与预习代码量。全部敲出来！
4.做好笔记，知识点，重要的知识点的笔记，没听懂的点，做笔记然后下课 ，搜一下资料！