java web开发入门学习笔记（手打超细版）

我刚实习的时候写的，先分享分享吧，当时写的也不容易。有错的话请指出，博主会修正，适合入门小白当资料使用。包括包括java基础、数据库、js、jQuery、css、html等等知识点。

详细笔记内容如下：

面向对象

封装：属性私有化，实现细节私有化，对外提供公共的访问方式。

属性私有化，对外提供操作该属性的方法。

提高了代码的复用性，提高了安全性。

封装原则：把不需要对外提供的内容都隐藏起来，把属性隐藏，提供公共的方法访问。

Private:可以修饰成员变量和成员方法，被修饰的变量或者方法，只能在本类中被使用。

this：调用当前类的属性和方法，跟外部传入的值或者属性做区别引入了该关键字。

 

继承：子类继承父类，扩展父类的功能。1.7及以下的，单继承，多层继承，不支持多重继承，子类只能继承父类的非私有成员和非构造方法

父类实例化可以调用子类进行实例化。

1如果父类对象使用本类的构造函数进行实例化，在方法调用的时候就只能调用本类类中的方法，并且最终执行的也是本类中的方法。

2如果父类对象使用子类的构造函数进行实例化，在方法调用的时候也只能调用本类中的方法，但是最终执行的确实子类中重写的方法。

3如果子类对象使用本类的构造函数进行实例化，在方法调用的时候既能调用父类中所有的菲斯有成员方法，也能调用本类中所有的非私有方法。

多态：

同一行为的不同实现。

 

对象的多态：主要体现在父类子类对象的转换，父类转换子类，需要强制转换；子类转换父类不需要强制转换。

方法的多态：方法的重载（overioad）（方法名相同，参数不同）和重写（override）（子类继承父类，（重写）在子类里重新定义一个和父类完全相同的方法）

 

类：是一组相关的属性和行为的集合，是一个抽象的概念。（成员变量和成员方法）

对象：是该类事物具体表现的形式，具体存在的个体。

成员变量和局部变量的区别：

成员变量：类中方法外、在堆内存中，随着对象的创建而存在，随着对象的消失而消失。有默认初始化值。

局部变量：在方法定义中或者方法声明上，在栈内存中，随着方法的创建而存在，随着方法的调用完毕而消失。没有默认初始化值，必须定义，赋值才能使用。

局部变量和成员变量名称可以一样，在方法中使用的时候采用就近原则调用。

 

抽象类：抽象类不可实例化，只能由子类去创建。（关键字是Abstarct）

 

抽象方法：

属于一种不完整的方法，只含有一个声明，没有方法主体，含有抽象方法的类叫做抽象类。

如果从一个抽象类继承，而且想生成新类型的一个对象，就必须为基础类中的所有抽象方法提供方法定义

abstract class在Java语言中表示的是一种继承关系，一个类只能使用一次继承关系。但是，一个类却可以实现多个interface

如果从一个抽象类继承， 必须对所有抽象方法进行覆盖 , 否则导出类也是抽象的

 

类：是对某一类事物的描述。

 

接口：把class关键字改为 interface 接口中只能有抽象类 接口中没有成员变量

实现类实现接口implements 接口名，接口名，可实现多个接口。实现类里的方法和接口中的一样  接口对象实现只能通过他实现类的构造函数进行实例化，实现类只需要进行本身进行实例化就行可以。被实例化后的接口对象调用的只能是本身所定义的方法，而实现的确实实现类的方法。

匿名对象：Student t = new Student();

Student();     //这就是一个匿名对象，仅能调用一次，调用结束之后就会变成垃圾被回收

匿名参数可以作为实际参数被传递。

 

java数据类型：（四类八种）

基础数据类型和引用数据类型

基础：byte、short、int、long0、float、double、char、boolean

八种数据类型的封装类：

常量表示的是在程序中不能被修改的数据。

变量与常量的相同点是在声明之前都指定变量的数据类型，变量无final关键字声明。

基本数据类型：整数型，浮点型，字符型，布尔型

引用数据类型：类，接口，数组

整数默认是int类型

浮点数默认是double类型

长整型后加上L标记

单精度浮点数用F标记

 

使用变量的时候需要注意的问题：（变量就是属性，属性就是性别，年龄之类的）

A：作用域

变量只在当前的大括号内有效，并且在同一个大括号内不能同时定义同名的变量

B:初始化值

没有初始化值的变量不能使用。

只要在使用前给值就行，不一定非要在定义的时候立即给值（推荐定义的时候就给值）

建议一行只定义一个变量

 

进制的转换：

0b开头的是二进制  0开头的是八进制 0x开头的是十六进制

 

任意的进制转换为十进制的方法：  

基数：自身的进制

每一位上的系数*基数^权次幂，然后分别相加

 

十进制转换为任意的进制的方法：

基数（需要转换到的进制数）

除基取余，直到商为0，余数反转

8421码

1   1   1   1   1   1  1  1

128 64  32  16  8   4  2  1

二进制到十进制：1010100 = 64 + 16 + 4 = 84

十进制到二进制：100 = 0b110000

二进制到八进制：0b1011001 = 001 + 011 +001 =1 + 3 +1 =0131（拆分组合法）

如果任意进制到任意进制的转换，则需要用十进制作为桥梁。   

 

数组:

同一类对象(变量常量）的组合（可以存储基本数据类型和引用数据类型）

数据类型 [] 数组名；

数组必须先初始化才能使用。

初始化：为数组中的数组元素分配内存地址，为每个数组元素赋值

数组初始化方式：

静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度

数据类型[]数组名 = new 数组类型[]{数据}   数据类型[]数组名 ={1,2,3..}

 

动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。

数据类型[]数组名 = new 数组类型[数组长度]

数组中每个元素都是有编号的，叫索引

 

不要一个声明中有动态和静态两种声明方法

5个内存空间：

栈：局部变量( int [] arr )

特点：每一个new出来的东西都有地址值

  每个变量都有默认值：byte，short，int，long 默认值是0

  Float,double 默认值是0.0

  Char 默认值是 ‘/u0000’  代表一个空字符

  Boolean 默认值是 false

使用完毕就变成了垃圾，但是并没有立即被回收。会在垃圾回收器空闲的时候被回收

栈内存的两个引用指向同一个堆内存空间，不管是谁的操作，都是针对同一个堆内存

 

堆：所有new出来的东西    ( new int[3] )

方法区：（面向对象）

本地方法区：（与系统相关）

寄存器：（CPU使用）

局部变量：在方法定义中或者方法声明上的变量

运算符：分为算数运算符，关系运算符和逻辑运算符、位运算符还有赋值运算符。

&&是短路与  只要第一个条件不满足，后面就不会继续运行

&是与 即使第一个条件不满足后面继续运行

||是短路或，只要满足第一个条件就不再往下进行判断

|是与，要对所有的条件进行判断

算术运算符：+ - * / %  关系运算符：== != > < >= <=   逻辑运算符：&& || !  位运算符：& |~  

与 同真为真，一假为假。或 有真则真 同假为假。异或 相同为假 不同为真。非 结果相反

Int c =a++; 先传值给c后，自身在进行a++      int c = ++a；先进行++a，然后再传值给c  

S +=1；不是等价于s = s + 1; 而是等于s = （s的数据类型）（s + 1）；   

 %得到的是除法操作的余数，/得到的是除法操作的商    ++对变量进行自增  

--对变量进行自减

整数相除，只能得到整数，想要得到小数，需要把其中的任意一个数据类型变为浮点数。

整数默认是int类型，浮点型默认是double类型

一般来说，运算的时候，要求参与运算的数据类型必须一致。

Boolean类型不能转换为其他的数据类型

变量是先提升类型后计算结果。常量是先计算出结果，然后看结果是否在范围内，如果在就不报错。

Ackii码

‘A’=65     ‘a’=97      ‘0’=48

‘A’+1=67   ‘a’+1=98    ‘0’+1=49

 

三元运算符能实现的，都可以采用if语句实现，反则不成立。Int c = ( (a>b) ? a: b );

因为三元运算符是一个运算符，运算符操作完毕就应该有一个结果，而不是一个输出

If语句是可以嵌套使用的。

 

 

Switch语句：

Int x = 1;

Switch ( x ){

Case value: value只能是常量，不能是变量

表达式1

Break；

 

Case value: 多个case的值不允许重复

表达式2

Break；

 

Default： default可以省略，但是建议不省略

表达式n

Break；             break 可以省略，但是结果可能不对，会出现case穿透

}                       最后一条的break可以省略并且不影响结果。

 

X可以为byte，不可以为long，jdk7以后可以为string

 

Java循环语句结构：

 

while（循环条件）

    循环体

    }

 

 do{

    循环体；

    }while（循环条件）；

 

for（初始化语句；循环条件；迭代语句）{

    循环体；

}

 

If（循环条件）{

语句；

}else{

语句；

}

if循环计数用count++

For循环和while循环的区别：

for循环结束后，变量就会及早的从内存中消失，可以提高内存的使用效率，如果想在循环结束后依旧使用那个变量，那么推荐使用while循环。否则用for循环，不知道的话用for循环。

For循环适合一个范围的判断，while循环适合次数不明的判断。

三种循环语句的区别：

Do...while至少要执行一次循环体，而for循环和while先判断条件是否成立，然后决定是否执行循环语句。

/t tab键的位置

/r 回车

/n 换行

Break ：跳出单层循环，终结本次循环。循环到此为止

Continue：跳过本次循环，外部循环正常进行

Return：结束整个方法，并不只作用于循环

 

If语句和switch语句的区别：

If语句：

1.针对结果是Boolean类型的判断

2.针对一个范围的判断

3.针对几个常量值的判断

Switch语句：

1.针对几个常量值的判断

 

方法：完成特定功能的代码块（在其他语言中也叫函数）

修饰符 返回值类型 方法名 （参数类型 参数名1，参数类型 参数名2...）{

方法体语句；

Return 返回值；

}

返回值就是方法运行之后的结果

实际参数：实际参与运算的参数

形式参数：方法上定义的，用于接收实际参数的

参数类型：参数的数据类型

参数名：变量名

方法体：就是执行功能的代码

Return：结束方法

返回值：就是方法执行的结果，由return带给调用者

写好一个方法必须明确：返回值类型和参数类型

方法的执行特点是：

方法不调用不执行，main方法是jvm调用的

方法和方法之间是平级关系不能嵌套使用

方法定义的时候参数列表用逗号隔开

方法调用的时候不用再传递数据类型

如果有明确的返回值，一定要return带回一个值

 

有明确返回值的调用：单独调用没有意义

输出调用

赋值调用：

无明确返回值的调用：只能单独调用，其他两种调用报错

 

方法重载：在同一个类中，方法名相同，参数列表不同。与返回值类型无关       

参数列表不同：参数类型或者参数个数不同        

特点：与返回值类型无关，只看方法名和参数列表，在调用时虚拟机根据参数列表的不同来区分同名方法。

 

StringBuffer和String的区别

String类是字符串常量，是不可更改的常量。只可以重新创建对象然后赋值，旧的值被垃圾回收机制回收，因此在执行效率上，要比Stringbuffer慢。

 

而StringBuffer是字符串变量，它的对象是可以扩充和修改的。

Stringbuilder与Stringbuffer的区别，

前者是非安全线程，后者是安全线程，都是字符串变量，都是可改变的对象，他们对字符串进行操作时，实际上是在一个对象上操作的，不像String一样创建一些对象进行操作，所以速度就快一些。

操作数据量少用String,单线程操作字符串缓冲区下操作大量数据用StringBuilder，多线程操作字符串缓冲区下操作大量数据用Stringbuffer

 

String类下的常用方法：

toUpperCase方法返回一个字符串，该字符串中的所有字母都被转换为大写。

toLowerCase方法返回一个字符串，该字符串中的所有字母都被转换为小写。

Concat方法返回字符串值，该值包含了两个或者多个提供的字符串连接值，在原有的字符串后面追加一个新的字符串。

Search方法返回与正则表达式查找内容匹配的第一个字符串的内容的位置。

indexOf方法放回String对象内第一次出现子字符串位置，如果未找到的话则返回-1.

lastindexOF方法返回String对象中字符串最后出现的位置，如果没有匹配值的话，则返回-1.

Substr方法返回一个从指定的位置开始的指定长度的子字符串。

 

变量：就是在程序的执行过程中，其值是可以在一定范围内发生改变的量。

变量的组成规则：

A：必须对其进行限定

B：变量名

C：初始化值

数据类型 变量名 = 初始化值 ；

字符串：

字符串是常量，一旦被赋值就无法被改变

 

运行时异常:能正常编译，运行时异常；    一般异常：编译报错

 

String 类包括的方法可用于检查序列的单个字符、比较字符串、搜索字符串、提取子字符串、创建字符串副本并将所有字符全部转换为大写或小写

 

集合：

 

集合类型主要有3种:set(集)、list(列表)和map(映射)。

 

1. （排列顺序）Set实现的基础是Map(HashMap);list集合中允许有多个相同的元素。

2. (过滤重复字段)Set中的元素是不能重复的（允许有多个相同的元素），如果使用add(Object obj)方法添加已经存在的对象，则会覆盖前面的对象

set集合输出的数据的顺序是随机的。

 

在集合内元素类型确定的时候可以使用foreach循环。

 

1、List,Set都是继承自Collection接口

2、List特点：元素有放入顺序，元素可重复 ，Set特点：元素无放入顺序，元素不可重复

（注意：元素虽然无放入顺序，但是元素在set中的位置是由该元素的HashCode决定的，其位置其实是固定的）

3、List接口有三个实现类：LinkedList，ArrayList，Vector ，Set接口有两个实现类：HashSet(底层由HashMap实现)，LinkedHashSet

集合的实例需要用实现类（ArrayList HashSet等）来实现。

Map的实现类：

 

 

集合的使用步骤:

A:创建集合对象

B:创建元素对象

C:把元素添加到集合

D:遍历集合

        三小步：a：通过集合器对象获取迭代器对象

b：通过迭代器对象的hasNext（）方法判断是否有元素

c：通过迭代器对象的next（）方法获取元素并移动到下一个位置

 

迭代器：对容器中的元素进行遍列，每次取出一个元素，然后对元素进行操作。

 

 

 

IO流：

按流向分：

输入流：向程序中输出数据

输出流：由程序输出程序

 

按数据类型分：

字节流：处理的数据以字节为单位

字符流：处理的数据以字符为单位

 

字符流有两个抽象类：Writer：输出流    Reader：输入流

字节流有两个抽象类：InputStream:输入流 OutputStream：输出流

 

File 功能：

A：创建功能

B：删除功能

C：重命名功能

D:判断功能

E:获取功能

F:高级获取功能

G:过滤器功能

 

多线程

程序：某段代码

进程：代码运行之后，动态执行，从开始到结束就是进程。正在进行中的程序。其实进程就是一个应用程序运行时的内存分配空间。

线程：cpu调度和分配的基本单位。 其实就是进程中一个程序执行控制单元，一条执行路径。进程负责的是应用程序的空间的标示。线程负责的是应用程序的执行顺序。

※jvm在启动的时，首先有一个主线程，负责程序的执行，调用的是main函数。主线程执行的代码都在main方法中。

当产生垃圾时，收垃圾的动作，是不需要主线程来完成，因为这样，会出现主线程中的代码执行会停止，会去运行垃圾回收器代码，效率较低，所以由单独一个线程来负责垃圾回收。

垃圾回收机制是独立的由另外一个非主线程的线程运行。

 

随机性的原理：因为cpu的快速切换造成，哪个线程获取到了cpu的执行权，哪个线程就执行。

 

返回当前线程的名称：Thread.currentThread().getName()

 

线程的名称是由：Thread-编号定义的。编号从0开始。

线程要运行的代码都统一存放在了run方法中。

 

线程要运行必须要通过类中指定的方法开启。start方法。（启动后，就多了一条执行路径）

start方法：1）、启动了线程；2）、让jvm调用了run方法。

 

创建线程的第一种方式：继承Thread ，由子类复写run方法。

步骤：

1，定义类继承Thread类；

2，目的是复写run方法，将要让线程运行的代码都存储到run方法中；

3，通过创建Thread类的子类对象，创建线程对象；

4，调用线程的start方法，开启线程，并执行run方法。

 

因为实现Runnable接口可以避免单继承的局限性。

 

线程状态：

被创建：start()

运行：具备执行资格，同时具备执行权；

冻结：sleep(time),wait()—notify()唤醒；线程释放了执行权，同时释放执行资格；

临时阻塞状态：线程具备cpu的执行资格，没有cpu的执行权；

消亡：stop()

 

多线程状态：

新建（New）状态-就绪（Runnable）状态-运行（Running）状态-阻塞状态-死亡状态

 

静态代理：

1：目标类和代理类要实现相同的接口。

2：代理类中药持有被代理对象的引用。

3：要将目标类的实例注入到代理类中被代理对象的引用上。

 

死亡状态：外部干预终止线程的方法

1：需要定义一个标识，用于终止线程。

2：在该线程体中使用这个标识。

3：提供对外改变该标识的方法。

 

 

 

 

 

数据库

将数据以表的形式保存到数据库中，然后通过工具使用数据。

Sql关键字执行顺序：从先到后分别为：

form，On 连接关键字，where，group by，聚合函数，having，select，distinct，order by

 

UPDATE sys_user SET user_name='cai1' WHERE id = 8;      //修改

DELETE FROM sys_user WHERE id=12; //删除

INSERT sys_user (NAME,user_name,pass_word,sex,phone)

VALUES('菜007','c02','1234567','01','12345678999');     //增加

SELECT name,user_name,sex FROM sys_user;   //查询部分字段

SELECT * FROM sys_user;      //查询表中的所有数据

SELECT id AS'编号',NAME AS '姓名' FROM student AS s; //查询时指定别名（as） as可省略写成空格 ；在多表查询时经常使用到表的别名

SELECT t.id FROM sys_user t; //查询指定列

SELECT t.* FROM sys_user t WHERE t.sex = '00' AND t.age = 10;    //过滤性别为00和年龄为10的数据（where的用法）

DELETE FROM sys_user WHERE id in(1,3); //删除id为1和id为3的数据

DELETE FROM sys_user WHERE id not in(1,3); //删除除了id为1和id为3的以外的所有数据

SELECT name,user_name,sex,'java课程'AS '名称' FROM sys_user; //在查询sys_user表时添加一个常量列

ALTER TABLE sys_use ADD chengji INT; //在表sys_use中加一列成绩，数据类型为INT

INSERT  INTO sys_use VALUES ('58','老赵','男','1班',100)       //添加一整行数据用关键字INSERT  INTO，并可以省略表头的书写

 

 

table1 table2

 

 

数据库基本的查询方式：

 

子查询： SELECT t2.* FROM t_student t2 WHERE t2.class_id in (SELECT t1.id FROM t_class t1 WHERE t1.class_num in('001','002'));    //查询出来的结果当成条件使用，放在in后面作为条件使用

 

嵌套查询 ： SELECT t1.id FROM （SELECT * FROM t_student WHERE sex = '00'）t1  WHERE t1.age>10;            //查询出来的结果当成范围使用，放在form后面

 

 

连接查询：

 

 

内连接：

SELECT t1.*，t2.class_num,t2.class_name FROM t_student t1,t_class t2 WHERE t1.class_id = t2.id //把两张有关联的表合并为一张新表，相同的部分展示，无关联的部分不展示

explorer

外连接：

（返回包括左表中的所有记录和右表中联结字段相等的记录 ）

左外连接 SELECT t1.*，t2.class_num,t2.class_name FROM t_student t1 LEFT JOIN t_class t2 ON t1.class_id = t2.id; //左表所有数据都会显示出来，而右表只显示符合查询条件的部分  以左表为基础，右表中则返回为null

（返回包括右表中的所有记录和左表中联结字段相等的记录）

右外连接 SELECT t1.*，t2.class_num,t2.class_name FROM t_student t1 RIGHT JOIN t_class t2 ON t1.class_id = t2.id; //右表所有数据都会显示出来，而左表只显示符合查询条件的部分  以右表为基础，左表中则返回为null

全连接   SELECT t1.*，t2.class_num,t2.class_name FROM t_student t1 FULL JOIN t_class t2 ON t1.class_id = t2.id ;}         //mysql不支持 互相查询，没有匹配的值得时候，则会在另外一个表中显示为null

等值连接   INNER JOIN  并不以谁为基础，只显示符合条件的数据 ，只返回两个表中联结字段相等的行

交叉连接 SELECT t1.*，t2.class_num,t2.class_name FROM t_student t1 CROSS JOIN t_class t2 ON t1.class_id = t2.id;           //结果和内连接一样，但是过程不一样 

 

联合查询   UNION 合并两个查询结果为一个合集

 

自连接查询  SELECT * FROM t_dep t1 LEFT JOIN t_dep t2 ON t1.pid=t2.id;   //同一张表连接查询

 

SELECT DISTINCT(DEPART) FROM teacher t;   //用于去掉重复的数据的，只能针对某一个字段使用

 

排序函数：SELECT * FROM t_student ORDER BY age DESC,class_id ASC;            //按照年龄大小升序，班级id降序 前面的优先级较高，越往后优先级越低

分组函数：SELECT class_id,COUNT(id) FROM t_student GROUP BY class_id HAVING class_id in(1,3); //分组查询   追加条件时要用HAVING,用法和WHERE一样 查询班级id为1和3的所有班级

 

 

分页函数：SELECT * FROM t_student LIMIT 0,3; //查询前三条数据     {前面（0）动态赋值，后面数据不变，分页原理}

 

 

 

 

 

 

 

 

JDBC 连接数据库并操作数据库的标准，提供大量的接口。

 

 

 

 

 

 

JDBC的操作步骤

加载驱动程序，将驱动程序配置到classpath中

连接数据库，通过Connertion接口和DrverManager类完成。

操作数据库，通过Statement、PreparedStatement、ResultSet三个接口完成

关闭数据库 开发中资源有限，操作完之后必须关闭

 

 

 

数据库事务有四个特性，

数据库的四个特性为ACID，既原子性（Atomicity），一致性（Consistency），隔离性（Isolation），持久性（Durability）。

原子性，整个事务是不可分割的，要么全部执行，要么全部不执行；

一致性，事务的执行结构也要与业务的逻辑保持一致；（事务执行的结果必须是使数据库从一个一致性状态变到另一个一致性状态）

隔离性，多个事务之间隔离开来，互不影响；

持久性，一旦事务执行完毕，执行后的结果会永久的保存下来。

 

 

视图：视图是虚表，是从一个或几个基本表（或视图）中导出的表，在系统的数据字典中仅存放了视图的定义，不存放视图对应的数据。

 

作用：多对一或者一对多，多对多的话通过一张中间表（视图）转换为一对多或者多对一。而且查询效率会提高，不再编译整条语句，只编译剩下的语句。

 

函数：过程，相当于程序中的一个代码块。可以进行循环语句的构建。

数据库中的if语句： if NOW()>STR_TO_DATE('2016-07-01','%Y-%m-%d') THEN

DELETE FROM sys_user;

END IF;

 

执行数据库中的函数：CALL proc_test();

 

数据库中while循环插入100条数据。（先判断再执行）

BEGIN

DECLARE i INT;     //声明一个int变量

SET i=0;        //赋值

 

WHILE i<100 DO           //do执行

  

INSERT INTO sys_user(name) VALUES (CONCAT('菜',i));    //插入数据

SET i=i+1;                  //自增

END WHILE;                      //结束循环

 

END

 

 

 

数据库中repeat循环插入100条数据（先执行再判断）

REPEAT

  INSERT INTO sys_user(name) VALUES (CONCAT('菜',i));

  SET i=i+1;

  UNTIL i>=100

  END REPEAT

 

数据库中loop循环插入100条数据（最常用的方式，使用方式比较灵活）

loop_test:LOOP

IF i>=100 THEN

LEAVE loop_test;

END IF;

INSERT INTO sys_user(name) VALUES(CONCAT('菜',i));

SET i=i+1;

END LOOP;

 

 

Tomcat 是符合JAVAEE标准的一个最小web容器

 

 静态 web服务插件 web服务器 文件系统 web容器  

 动态   web容器   web服务器 文件系统

 

 

 

javaweb开发 两个组件 javabean 和 servlet

必须是私有属性和set，get方法  必须无参的构造方法，可省略

所有的javabean都必须放在同一个包下。

优点：将html和java代码分开，方便了开发和维护，  将常用的程序写成javabean可减少重复代码的编写 。

 

 

 servlet:处理和响应请求的作用

 

 

 

 

 

html组件的书写方法：

 

<form action= "http://127.0.0.1:8080/web_lesson1/test" method="post">

    <!-- 文本框 -->

            文本框：<input type="text" name="username"value= ""/><br/>

    <!-- 密码域  -->

    密码域:<input type="passwprd"name="password"value=""/><br/>

         <!-- 单选框 -->

           单选框<input type="radio"name="r"value="1">是

          <input type="radio"name="r"value="0">否<br/>

          <!-- 复选框 -->

          复选框:<input type="checkbox"name="c"value="01">这是第一个选项

          <input type="checkbox"name="c"value="02">这是第二个选项

          <input type="checkbox"name="c"value="03">这是第三个选项<br/>

       <!-- 大文本域 -->>   

     大文本域:<textarea name="ta"cols="10"row="10"></textarea><br/>

   <!-- 文件域 -->

   <!-- 文本域:<input type="file" name="f"> -->

   <!-- 下拉列表 -->

       单选 下拉列表：<select name="se">

   <option value="0">我是一个人</option>

   <option value="1">我是一个神</option>

   <option value="2"selected="selected>我是一个仙</option>

   <option value="3">我是一个兵</option>

   <option value="4">我是一个选手</option>

   </select></br>

    多选下拉列表：<select name="se"multiple="multiple"size="5">

   <option value="0">我是一个人</option>

   <option value="1">我是一个神</option>

   <option value="2">我是一个仙</option>

   <option value="3">我是一个兵</option>

   <option value="4">我是一个选手</option>

   </select></br>

    </form>

 

 

404 资源找不到

405 找不到对应的方法

500 执行的方法出错

 

servlet 生命周期

 

加载Servlet：web容器负责加载servlet，当web容器启动或者第一次使用这个Servlet的时候，容器会负责创建Servlet实例，但是用户必须通过部署描述符（web.xml）指定Servlet 的位置。成功加载之后立即，web容器会通过反射的方式对servlet进行实例化。

 

初始化：当一个servlet被实例化后，容器将调用init()方法初始化这个对象，初始化的目的是为了让servlet对象在处理客户端请求前完成一些初始化工作。

 

处理服务：当有请求提交时，servlet将调用service（）方法（常用的是doget（）或dopost）进行处理。将封装的request对象传到servlet。

 

销毁：当web容器关闭或者检测到一个servlet要从容器中被删除时，会自动调用destory方法以释放掉该实例所占用的资源。

 

卸载：当一个servlet调用完destory（）方法后，此实例会被垃圾回收器回收。

 

容器赋值叫注入

servlet的作用：响应和处理请求 转发或者重定向其他地方而不响应。

重定向：只能写绝对路径。

转发：用responce对象（request），由web进行封装。

任意一个线程都可以访问servlet，post安全，get不安全，推荐使用前者。

 

 

 

jsp(java server page) 创建动态web内容的技术

客户端发送http请求给jspservlet，分析请求查找a.jsp，然后javaservlet读取文件，接着jspservlet翻译jsp中的内容，翻译为servlet，a.java,然后编译为 .class文件，由类加载器加载编译，执行servlet实例，返回客户端响应

 

 

 

 

 

 

 

 

 

 

 

 

 

获取servlet转发过来的数据，通过EL表达式去获取。  表达式写法：${    }

 

 

js小脚本（用于展示数据的）

静态请求，不是对文件进行请求

<%

声明变量

int = 0;

 

%>

 

 

<%=

输出一个结果

int = 0;

%>

 

 

 

<%!

书写方法(可定义无参或者有参的方法)

public String test(){

system.out.print("test")

return "test";

}

class A{

public String test_A(){

return "test";

    }

    }

%>

 

jsp 注释

<!--   -->    显示的注释

<%--   -->    隐示的注释

 

jsp的九大内置对象（java小脚本里可以使用，部分在其他地方也可以使用）

可直接使用，由容器进行实例化。不需要预先声明就可以在脚本代码和表达式中随意使用。

request            请求对象　      类型 javax.servlet.ServletRequest        作用域 Request
response          响应对象        类型 javax.servlet.SrvletResponse       作用域  Page
pageContext    页面上下文对象     类型 javax.servlet.jsp.PageContext      作用域    Page
session            会话对象        类型 javax.servlet.http.HttpSession       作用域    Session
application   应用程序对象 类型 javax.servlet.ServletContext          作用域    Application
out                   输出对象      类型 javax.servlet.jsp.JspWriter             作用域    Page
config              配置对象       类型 javax.servlet.ServletConfig            作用域    Page
page               页面对象       类型 javax.lang.Object                            作用域    Page
exception        例外对象       类型 javax.lang.Throwable                     作用域    page

四个作用域（用于传递值）都能用el表达式获取值。（可直接指明作用域）

pageContext, 一个页面  (page里的变量没法从index.jsp传递到test.jsp。只要页面跳转了，它们就不见了。)优先级最高，范围最小

request, 一次请求(request里的变量可以跨越forward前后的两页。但是只要刷新页面，它们就重新计算了。)

session,一次会话（浏览器关闭则无效） 存储用户信息

session和application里的变量一直在累加，开始还看不出区别，只要关闭浏览器，再次重启浏览器访问这页，session里的变量就重新计算了。

Application，跟web容器生命周期保持一致  优先级最低，范围最大

 

优先级：范围越大优先级越低。

 

 

可视化视图

视图模型控制器分离

Model :javabean（业务逻辑与业务顺序）

Controller:service(逻辑处理)和控制层(跟视图做数据交换，搬运和转发数据，)（控制器，负责程序的流程控制），接收到用户请求，根据业务逻辑执行情况，返回响应的结果。

View：视图(显示逻辑)将数据按照用户的要求显示出来。

Mvc的思想

 

好处：各司其职。

代码可重复使用。

Servlet：（1）能够接受所有用户的请求，（2）能根据请求的不同，调用不同的处理（javabean）

 

HTML：

元素:从一个标签开始到一个结束，这之间所有的内容。

属性：在标签中写的内容

标签：w3c制定的，  <   >  都需要成对的出现。

正文中的标签都是用<h1><h2>，从h1到h6文字显示内容是越来越小，等表示的，放在     <body>这是一个标题</body>     中，段落标签用

<p>这是一段文本内容</p> 表示，会自动换行，  

<b>这是一段文本</b>：加粗文本内容   

<big>这是一段文本内容</big>：加大字体    

<small>这是一段文本内容</small>：缩小字体

table

布局的标签

表格<table  border=”1” > <tr>  <td>ce111</td>  </tr></table>       t r: 行  td: 单元格

<td colspan=”2”></td> 单元格长度为2，<td rowspan=”2”></td> 单元格宽度为2.

<th>姓名</th>： 横行显示 表头  

列表：有序列表，无序列表，自定义列表。

无序列表<ul>   <li> </li>   <li> </li>   <li></li> <ul>

有序列表<ol>    <li></li>   <li></li>   <li></li> <ol>

自定义列表<dl>  <dt>< img src=”./catch.png”  alt=”这是一张图片” height=”150” width=”200”>  </img>  </dt>  <dd>这是描述信息</dd>    <dt>这是一个图片</dt>  <dd>这是描述信息</dd>   <dt>这是一个图片</dt>  <dd>这是描述信息</dd>    </dl>   dt和dd为一组完整的标签

表单

以上着重记忆

<li><a href=”http://baidu.com” target=”_blank”> 这是个超链接</a></li>  在新选项卡中打开百度  

<a  a href=”#a4”> 指向a4</a>  用来定位页面元素的。

 

 

Html 中用于布局的元素

<span></span>                <div></div>

 

 

<html

<head>

<titic></titic>

<style type="text/css">

<!-- 标签选择器   -->三种css中基本的选择器

div{         

 

  }

 

（id选择器）#div1{         

 

  }

（类选择器）.div_1{         

 

  }

(属性选择器) [title]{

 

}

[title=1]{

 

}

 

</style>

 

</head>

<body>

<div  id=”div1” class=”div_1”  style="color:blue;">

<span>这是个标签</span>

<span style=”color:red:font=size:32px”>这是个span标签！</span>

<div style=”color:blue;”></div>

</body>

</html>

Css的作用：

背景，颜色，

 

<html

<head>

<titic></titic>

<style type="text/css">

.content{  

Height:700px;

Width:700px;

Background-image: url(“.catch.png”);

Background-repeat:repeat;

}

</style>

<body>

<div class=”content”>

 

</div>

</body>

</html>

 

 

 

 

 

 

 

<html

<head>

<titic></titic>

<style type="text/css">

.content{  

Height: 100px;

Width: 100px;

Background-image: url("./catch.png");（添加图片）

Background-repeat:repeat;（覆盖，重复）

Background-position:50%  50%;(偏移量)

Border-width:1px;

Border-color:red;

Border-style:solid;

Border-radius:50%;(圆形)

Border-top-left-radius:50px;(切割左上角为圆角)

}

.content.text{    

font-family:"宋体";(字体类型)

font-size:22px;（字体大小）

font-weight:bolder;（字体粗细）

font-style:normal;（字体样式）

color:red;（字体颜色）

vertical-align:middle;(字体对齐方式)

}

 

</style>

<body>

<div class="content">

<span class="text">这不是个span标签</span>

 

</div>

</body>

</html>

 

 

 

<html

<head>

<titic></titic>

<style type="text/css">

.box1,.box2{

Height:200px;

Width:200px;

}

.box1{

background-color:blue;

Margin-bottom:32px;

}

.box2{

background-color:red;

Margin-top:32px;

}

 

.box1 .subbox1{

height:50px;

width:50px;

background-color:black;

margin-top:50px;

}

 

</style>

<body>

<div class="box1"></div>

<div class="box2"></div>

</body>

</html>

 

 

 

解决浏览器兼容问题

加上相应的标识符 火狐 -moz- 谷歌 -webkit-  欧朋 -o-

 

 

<html>

<head>

<title></title>

</head>

<body>

<script type=”text/javascript”>

Document.write(“这是用javascript写入的内容”)；

</script>

 

</body>

</html>

 

 

 

Js系统的讲解

 

匿名函数：

Var test2 = function(i){

Alert(i);

}

Test2(2);

 

(function(i){

Alert(i);

})(1);

 

 

Function test1(){

 

}

 

Var fun = function test(){

Alert(1);

}

Var test1 = new function(‘i’,’return i;’);

Alert(typeof(fun))；

 

内层函数可以调用外层函数的所有的变量，即便是外层函数执行完毕，内层函数依然可以调用外层函数的变量。

 

setTimeout(function(){

Alert(1);

},5000);

//定时5秒后刷新一遍，输出1

 

Function testClosure(){

Var str = “这是一个字符串”;

Var inner = function(){

Alert(str);

}

Return inner;

}

Var i =testClosure();

i();

 

闭包官方解释：

一个拥有许多变量和绑定了这些变量的环境表达式，因而这些变量也是表达式的一部分。

闭包的特点：

1.作为一个函数变量的一个引用，当函数返回时，即处于激活状态

2.一个闭包就相当于函数返回时，没有释放资源的栈区。

3.闭包函数不会对全局变量造成污染。

 

Function test1(){

I=1;

}

Function test2(){

Alert(1);

}

 

Test1();

Test2();

 

 

Var i = 0;

(function(k){

K=1

})(i);

 

 

Jquery里的各种选择器：

//id选择器

alert($("#d1").get(0));

//类选择器

$(".div1");

//标签选择器

$("div");

//属性选择器

$("[attr]");

$("[attr=1]");

//选择器混用

$("div[attr]");

$("div[attr=1]");

//子选择器

$("ul li:first-child");

$("ul li:last-child");

$("ul li:nth-child(2)");

 

 

 

 

 

 

 

框架

hibernate主键 八种生成策略：最常用的为红色

 

Identity  mysql数据库/sql server数据库

Squence  oracle数据库中使用sequence生成主键

Native  几乎适用于所有数据库 自动识别，然后匹配第一或者第二种策略（数据库主键设置为自增）数据库维护主键

Uuid.hex 由hibernate进行维护、生成一个32位随机字符串充当主键

Foreign 使用外部表字段作为hibernate主键

Uuid.string  由hibernate进行维护、生成一个32位随机字符串充当主键

Assigend （自动维护主键，其他的即使自己手动赋值也会被覆盖）

Increment  对long,short或int的数据列生成自增长主键

 

 

 

 

 

一、hibernate的优缺点

优点：移植性好

提高开发效率

轻量级，侵入性较小

解决了阻抗不匹配的问题

缺点：适合操作单个对象，不适合批量操作多个对象

不适合特定的数据库操作

不适合操作关系复杂的对象

 

 

 

二、hibernate使用步骤

1、新建java工程

2、添加hibernate相关jar包

3、创建hibernate配置文件hibernat.cfg.xml

4、创建实体类

5、创建实体类的映射文件

6、将实体类映射文件加入到hibernate.cfg.xml配置文件中

 

 

 

五个核心接口的用法，查询、缓存

Configuration  读取和加载配置文件并启动hibernate

SessionFactory  存储数据库的连接信息以及初始化的配置信息（每一个数据库对应一个sessionfactory）

Session 接口负责执行被持久化对象的CRUD操作

Transcation 控制事务的（手动控制）

Query 用来提供查询的

 

 

Hibernate里对象的三种状态：

1、瞬时状态对象   在数据库中没有与之对应的记录   没有被session纳入管理

2、持久状态对象   在数据库中有与之对应的记录  纳入了session的管理

  当对象发生变化时，会自动同步到数据库中

3、游离状态对象   在数据库中有与之对应的记录  没有被session纳入管理

 

 

Hibernate的查询

1.标准化对象查询（Criteria）

2.Hibernate的语句查询（HQL语句）使用Query接口

3.原生的sql语句查询（使用SqlQuery接口）

4.外置命名查询（类似于mybatis/ibatis）使用Query接口

 

 

1 标准化对象查询

*以对象的方式进行查询，将查询语句封装成对象。

 

2-1 HQL语句查询中实体对象查询

*如果首次查询使用Query接口中的iterate（）方法进行查询，会发出N+1条sql语句，

--首先发出一条sql语句查询对象的主键集合

--根据主键到数据库中去进行查询，会发出N条查询语句

*如果不是首次查询使用Query接口中的iterate（）方法进行查询，可能会发出N+1条sql语句，

--首先发出一条sql语句查询对象的主键集合

--根据主键到缓存列表中进行查询，如果缓存列表中没有与之匹配的记录，则会发出一条对应的sql语句去数据库中进行查询Query接口中list（）方法与interate（）方法的区别：

相同点：都会在查询结束后把查询出来的结果放到一级缓存中。

不同点：iterate（）使用缓存中的数据，list（）方法不使用缓存中的数据，每次都会去数据库进行查询

Iterate（）方法返回的是一个迭代器对象，list（）方法返回的是一个list对象集合。

*hql语句写法：

--hql语句是针对对象以及属性进行操作

--把sql语句中的表名替换为对象名，SQL语句中的字段名替换为属性名

注:hql语句中没有select*这种写法

*查询条件拼接方法：

--可以采用字符串拼接的方式把查询条件直接拼接在hql语句上

--可以采用通配符？来传递参数进行查询（索引是从0开始）

--可以采用：参数名来传递参数进行查询

注：分页参数与mysql中limit函数传递的参数一致（起始位置，分页大小），分别用setFirstResult（）与setMaxResult（）来表示。

 

2-2 HQL语句中的简单属性查询

*单一属性查询

*多个属性查询，返回的集合元素是对象数组（Object[]）,数组的长度与查询的属性个数一致，数组中的元素与查询的属性值一一对应

*可以采用构造函数的方式把查询出来的属性值构造成一个实体对象。

 

2-3 原生SQL语句查询

*参见SimpleNativeQueryTest.java

 

2-4 外置命名查询：

*在任意映射文件中采用<query>标签来定义hql语句，或者采用<sql-query>标签来定义sql查询语句，<query>标签与<sql-query>标签要写在<class>外，具体格式参见SysUser.hbm.xml文件。

*在程序中采用getNamedQuery方法获取定义的HQL或SQL语句，并返回Query对象，用Query接口中的List（）方法或者iterate（）方法获取查询的结果集（对象集合），参见SimpleNameQueryTest.java

 

 

计算机存储单位：

1B（byte）=8b（bit位）

1KB = 1024B

1MB = 1024KB

1GB = 1024MB

1TB = 1024GB

1PB = 1024TB

1EB = 1024PB

1ZB = 1024EB

1YB = 1024ZB

 

 

Hibernate一级缓存：

*与session的生命周期一致，所以也叫session级缓存。（对数据库的一次访问）

*一级缓存中存放的只能是对象或者对象集合，属性查询不会保存到一级缓存中去

*用session接口进行的CRUD（增删改查）操作，其操作的对象都会保存到一级缓存中

*不可配置，可以通过clear（）或evict（）方法进行管理，防止内存溢出

注：如果数据量特别大，建议放弃hibernate操作，采用jdbc进行操作

 

 

Hibernate二级缓存：

*二级缓存也叫SessionFactory级缓存，二级缓存可以被所有的session共享

*二级缓存的生命周期和SessionFactory生命周期一致，SessionFosctory可以管理二级缓存

 

*二级缓存的配置和使用（此处以EhCache为例）

--开启二级缓存（默认就为开启状态），修改hibernate.cfg.xml配置文件

<property name=”hibernate.cache.use_level_cache”>true</property>

--指明缓存产品提供商（hibernate默认实现了一套基于hashtable的一套缓存产品，该产品仅用于开发阶段，不适用生产阶段）

修改hibernate.cfg.xml配置文件

<property name=”hibernate.cache.region.factory_class”>org.hibernate.cache.EhcacheRegionFactory”</property>

--将ehcache.xml配置文件拷入工程中，配置缓存策略（可以使用全局缺省配置，也可以指定某个对象进行单独的缓存策略配置）

--需要指明使用二级缓存的类（两种方式指明）：

1，在该类对应的映射文件中，采用<cache>标签来配置，<cache>标签位置位于<class>标签内，<class>开始标签的后边

2，在hibernate.cfg.xml配置文件中采用<class-cache>标签来配置，<class-cache>标签的位置位于<session-factory>标签内，所有的<mapping>标签之后

*二级缓存中存放的也是实体对象或者对象集合，不能是普通属性集合

 

 

hibernate查询缓存

*查询缓存是针对普通属性结果集进行缓存

对实体对象的结果集只缓存实体对象ID（主键）

*多个session可以共享查询缓存，与SessionFactory绑定

*查询缓存的生命周期,不确定,当关联的表发生修改时,那么查询缓存的生命周期结束

查询缓存的配置和使用:

*在hibernate.cfg.xml配置文件中启用查询缓存,

<property name="hibernate.cache.use_query_cache">true</property>

*需要指明缓存产品提供商，如果已经指明缓存产品提供商，就不需要额外配置，若没有指明二级缓存产品提供商，需要在单独指明查询缓存的缓存产品提供商

*还需要在程序中手动开启查询缓存,调用query.setCacheable(true);方法来启用

注：iterator()方法不支持查询缓存

 

 

Spring框架

 

轻量级的控制反转（IOC）和面向切面（AOP）的容器框架

初始化bean容器方法

第一种方式：读取本地文件初始化bean容器

 

第二种方式：读取ClassPath目录下的配置文件初始化bean容器

 

第三种方式：使用spring提供的监听器，借助web容器的全局方式

 

Spring容器可以管理任意一个类

 

注解标签（对代码比较有侵入性，比较方便，利于代码书写）

 

Spring容器中注册管理bean的标签

一 用来注册bean的，需要在spring配置文件中启用<context:component.scan>标签开启注解扫描

    @Componet(通用的组件注册注解标签)

@Repository(用于注册DAO层的类)

@Service(用于注册Survice层的类)

@Controller(用于注册Controller层的类)

 

 

 

 

用来管理bean之间的依赖关系，通过自动注入的方式实现bean的注入

 

@Autowrired(自动注入，通过bean的类型进行注入)

@Qualifer

@Resoerce(自动注入，通过bean的id进行注入)

 

 

二 @Configurition @Bean @Import

 

 

AOP面向切面编程

切面（Aspect）：一个关注点的模块化，在这个关注点横切与多个对象

连接点（JoinPoit）：程序中的某个特定的点

通知:（advice）：在切面上的某个特定连接点上执行的动作

切点（PointCut）：匹配连接点的表达式

 

AOP业务代码与关注点代码分离，好处？

关注点代码写一次即可；

开发者只需要关注核心业务；

运行时期，执行核心业务代码时候动态植入关注点代码；

 

通知的种类：

Before Advice：（前置通知）

After returning Advice：（返回后通知）

After Throwing A dvice：（抛出异常后通知）

After Advice：（后置通知）

Around Advice：（环绕通知）

 

声明事务的配置方式：

第一大类：支持当前事务

REQUIRED:支持当前事务，如果当前存在事务，就是用当前的事务，如果当前不存在事务，则开启一个新的事务。

MANDATORY：支持当前事务，如果当前存在事务，则使用当前事务，如果当前不存在事务，就抛出异常

SUPPORTS：支持当前事务，如果当前存在事务，则使用当前事务，如果当前不存在事务，就以非事务方式运行

 

第二类：不支持当前事务

NAVER：不支持当前事务，始终以非事务方式运行，如果当前存在事务，就抛出异常

NOT_SUPPORTED：不支持当前事务，始终以非事务方式运行，如果当前存在事务，则把当前的事务挂起

 

第三类：嵌套事务

NESTED：

 

 

 

 

 

Spring-mybatis

 

整合CRUD操作：三种方案

第一种方案：使用salSessionTemplate

第二种方案：使用映射器按照映射规则创建指定接口的实现类并放入spring容器中进行管理

第三种方案：批量按照映射规则生成指定接口的实现类并放入spring容器中管理，bear的id默认为该接口名称首字母小写

 

 

 

Spring  七 大模块

最基础的是spring core，所有模块都是基于这个模块进行的开发。

  Spring aop

  Spring web mvc：spring对于mvc的实现

  Spring orm：基于框架对于jdbc的实现

  Spring dao：

  Spring web:

  Spring context:

 

 

 

框架整合

Spring需要的包：

Core包

Bean

Context包

 

Tx标签组件对事物进行扩展

Test单元测试组件

Spring—aop

Spring—aspcet

Spring—orm仅仅针对hibernate，没有对没有batis进行整合

Mybatis的核心包

spring—jdbc

Mybatis—spring

Webmvc

 

 

Mybatis的包

Mybatis

Mysql—connector—java

 

Java.servlet.api

Java.servlet.jsp

 

Jstl

这个包

 

Commons—fileupload等 的一些工具类包

Log4j 一些工具类的包

 

 

初始化的配置信息

写配置文件时从spring开始写

 

 

建资源文件夹src main webapp            configs

四个配置文件 mvc_dispatcher spring-root

 后面被替代之后删掉  Mybatis_config 先配置数据库连接  datasource type POOLED 连接驱动 用户名 密码 连接地址   需要手动去写一个事务管理器 jdbc管理器

加载映射文件  <mapper resource=” com/yrrj/mapper/sysusemapper .xml“><mapper>

Spring容器初始化的三种方式 相当于启动spring容器

读取classclass   操作本地的某个资源文件  监听器执行某个构造函数完成，启动web容器的时候就会执行监听器 spring容器里的所有

 

整合mybatis的操作（替代mybatis主配置文件）

写在spring-root 里的

Bean id datasource class org.spring framework.......

Name driverclassname

Name url

Name username

Name password

上面的值下载一个资源文件中，前缀为jdbc

引入资源文件 context property placeholder  location =”classpath:config.properties”

 

bean sqlsessionfactory  org.mybatis.spring.sqlsessionfactorybean

Property  datasource  

整合mybatis-crud 操作

第一种方案：

整合sqlsession

使用构造器来注入

Bean id sqlsession class aqlsessiontemplate

Constructor-arg name sqlsessionfactory ref sqlsessionfactory  

 

第二种方案

映射文件中的映射，相当于执行sql语句

Bean id userdao class org..........mapper.mapperfactorybean

Property name mapperinter

 

第三种方案

 

 

 

 

配置事务管理器

Bean id datasourcetransactionmanager class

Property name data source ref datasource

 

声明事务第一种方式：开启事务注解驱动

Tx：annotation-drivern transaction-manager data....manager

 

声明第二种方式：通过切面配置

Tx:advice transaction-manager  data....manager

 

Tx method name”save”propagation required

               Insert

               Update

               Del

............

...........

.............

...........

Mvc-dispatcher.xml文件中

注册所有的controller，注册到spring webmvc容器中

扩充注解驱动

静态资源映射

配置视图解析器

 

 

 

Spring容器和 spring mvc 容器是父子关系，子容器可以访问父容器的任何资源，而父容器访问不到子容器的任何资源

所有的curd都是dispatcher去间接调用的

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

面向对象

封装：属性私有化，实现细节私有化，对外提供公共的访问方式。

属性私有化，对外提供操作该属性的方法。

提高了代码的复用性，提高了安全性。

封装原则：把不需要对外提供的内容都隐藏起来，把属性隐藏，提供公共的方法访问。

Private:可以修饰成员变量和成员方法，被修饰的变量或者方法，只能在本类中被使用。

this：调用当前类的属性和方法，跟外部传入的值或者属性做区别引入了该关键字。

 

继承：子类继承父类，扩展父类的功能。1.7及以下的，单继承，多层继承，不支持多重继承，子类只能继承父类的非私有成员和非构造方法

父类实例化可以调用子类进行实例化。

1如果父类对象使用本类的构造函数进行实例化，在方法调用的时候就只能调用本类类中的方法，并且最终执行的也是本类中的方法。

2如果父类对象使用子类的构造函数进行实例化，在方法调用的时候也只能调用本类中的方法，但是最终执行的确实子类中重写的方法。

3如果子类对象使用本类的构造函数进行实例化，在方法调用的时候既能调用父类中所有的菲斯有成员方法，也能调用本类中所有的非私有方法。

多态：

同一行为的不同实现。

 

对象的多态：主要体现在父类子类对象的转换，父类转换子类，需要强制转换；子类转换父类不需要强制转换。

方法的多态：方法的重载（overioad）（方法名相同，参数不同）和重写（override）（子类继承父类，（重写）在子类里重新定义一个和父类完全相同的方法）

 

类：是一组相关的属性和行为的集合，是一个抽象的概念。（成员变量和成员方法）

对象：是该类事物具体表现的形式，具体存在的个体。

成员变量和局部变量的区别：

成员变量：类中方法外、在堆内存中，随着对象的创建而存在，随着对象的消失而消失。有默认初始化值。

局部变量：在方法定义中或者方法声明上，在栈内存中，随着方法的创建而存在，随着方法的调用完毕而消失。没有默认初始化值，必须定义，赋值才能使用。

局部变量和成员变量名称可以一样，在方法中使用的时候采用就近原则调用。

 

抽象类：抽象类不可实例化，只能由子类去创建。（关键字是Abstarct）

 

抽象方法：

属于一种不完整的方法，只含有一个声明，没有方法主体，含有抽象方法的类叫做抽象类。

如果从一个抽象类继承，而且想生成新类型的一个对象，就必须为基础类中的所有抽象方法提供方法定义

abstract class在Java语言中表示的是一种继承关系，一个类只能使用一次继承关系。但是，一个类却可以实现多个interface

如果从一个抽象类继承， 必须对所有抽象方法进行覆盖 , 否则导出类也是抽象的

 

类：是对某一类事物的描述。

 

接口：把class关键字改为 interface 接口中只能有抽象类 接口中没有成员变量

实现类实现接口implements 接口名，接口名，可实现多个接口。实现类里的方法和接口中的一样  接口对象实现只能通过他实现类的构造函数进行实例化，实现类只需要进行本身进行实例化就行可以。被实例化后的接口对象调用的只能是本身所定义的方法，而实现的确实实现类的方法。

匿名对象：Student t = new Student();

Student();     //这就是一个匿名对象，仅能调用一次，调用结束之后就会变成垃圾被回收

匿名参数可以作为实际参数被传递。

 

java数据类型：（四类八种）

基础数据类型和引用数据类型

基础：byte、short、int、long0、float、double、char、boolean

八种数据类型的封装类：

常量表示的是在程序中不能被修改的数据。

变量与常量的相同点是在声明之前都指定变量的数据类型，变量无final关键字声明。

基本数据类型：整数型，浮点型，字符型，布尔型

引用数据类型：类，接口，数组

整数默认是int类型

浮点数默认是double类型

长整型后加上L标记

单精度浮点数用F标记

 

使用变量的时候需要注意的问题：（变量就是属性，属性就是性别，年龄之类的）

A：作用域

变量只在当前的大括号内有效，并且在同一个大括号内不能同时定义同名的变量

B:初始化值

没有初始化值的变量不能使用。

只要在使用前给值就行，不一定非要在定义的时候立即给值（推荐定义的时候就给值）

建议一行只定义一个变量

 

进制的转换：

0b开头的是二进制  0开头的是八进制 0x开头的是十六进制

 

任意的进制转换为十进制的方法：  

基数：自身的进制

每一位上的系数*基数^权次幂，然后分别相加

 

十进制转换为任意的进制的方法：

基数（需要转换到的进制数）

除基取余，直到商为0，余数反转

8421码

1   1   1   1   1   1  1  1

128 64  32  16  8   4  2  1

二进制到十进制：1010100 = 64 + 16 + 4 = 84

十进制到二进制：100 = 0b110000

二进制到八进制：0b1011001 = 001 + 011 +001 =1 + 3 +1 =0131（拆分组合法）

如果任意进制到任意进制的转换，则需要用十进制作为桥梁。   

 

数组:

同一类对象(变量常量）的组合（可以存储基本数据类型和引用数据类型）

数据类型 [] 数组名；

数组必须先初始化才能使用。

初始化：为数组中的数组元素分配内存地址，为每个数组元素赋值

数组初始化方式：

静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度

数据类型[]数组名 = new 数组类型[]{数据}   数据类型[]数组名 ={1,2,3..}

 

动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。

数据类型[]数组名 = new 数组类型[数组长度]

数组中每个元素都是有编号的，叫索引

 

不要一个声明中有动态和静态两种声明方法

5个内存空间：

栈：局部变量( int [] arr )

特点：每一个new出来的东西都有地址值

  每个变量都有默认值：byte，short，int，long 默认值是0

  Float,double 默认值是0.0

  Char 默认值是 ‘/u0000’  代表一个空字符

  Boolean 默认值是 false

使用完毕就变成了垃圾，但是并没有立即被回收。会在垃圾回收器空闲的时候被回收

栈内存的两个引用指向同一个堆内存空间，不管是谁的操作，都是针对同一个堆内存

 

堆：所有new出来的东西    ( new int[3] )

方法区：（面向对象）

本地方法区：（与系统相关）

寄存器：（CPU使用）

局部变量：在方法定义中或者方法声明上的变量

运算符：分为算数运算符，关系运算符和逻辑运算符、位运算符还有赋值运算符。

&&是短路与  只要第一个条件不满足，后面就不会继续运行

&是与 即使第一个条件不满足后面继续运行

||是短路或，只要满足第一个条件就不再往下进行判断

|是与，要对所有的条件进行判断

算术运算符：+ - * / %  关系运算符：== != > < >= <=   逻辑运算符：&& || !  位运算符：& |~  

与 同真为真，一假为假。或 有真则真 同假为假。异或 相同为假 不同为真。非 结果相反

Int c =a++; 先传值给c后，自身在进行a++      int c = ++a；先进行++a，然后再传值给c  

S +=1；不是等价于s = s + 1; 而是等于s = （s的数据类型）（s + 1）；   

 %得到的是除法操作的余数，/得到的是除法操作的商    ++对变量进行自增  

--对变量进行自减

整数相除，只能得到整数，想要得到小数，需要把其中的任意一个数据类型变为浮点数。

整数默认是int类型，浮点型默认是double类型

一般来说，运算的时候，要求参与运算的数据类型必须一致。

Boolean类型不能转换为其他的数据类型

变量是先提升类型后计算结果。常量是先计算出结果，然后看结果是否在范围内，如果在就不报错。

Ackii码

‘A’=65     ‘a’=97      ‘0’=48

‘A’+1=67   ‘a’+1=98    ‘0’+1=49

 

三元运算符能实现的，都可以采用if语句实现，反则不成立。Int c = ( (a>b) ? a: b );

因为三元运算符是一个运算符，运算符操作完毕就应该有一个结果，而不是一个输出

If语句是可以嵌套使用的。

 

 

Switch语句：

Int x = 1;

Switch ( x ){

Case value: value只能是常量，不能是变量

表达式1

Break；

 

Case value: 多个case的值不允许重复

表达式2

Break；

 

Default： default可以省略，但是建议不省略

表达式n

Break；             break 可以省略，但是结果可能不对，会出现case穿透

}                       最后一条的break可以省略并且不影响结果。

 

X可以为byte，不可以为long，jdk7以后可以为string

 

Java循环语句结构：

 

while（循环条件）

    循环体

    }

 

 do{

    循环体；

    }while（循环条件）；

 

for（初始化语句；循环条件；迭代语句）{

    循环体；

}

 

If（循环条件）{

语句；

}else{

语句；

}

if循环计数用count++

For循环和while循环的区别：

for循环结束后，变量就会及早的从内存中消失，可以提高内存的使用效率，如果想在循环结束后依旧使用那个变量，那么推荐使用while循环。否则用for循环，不知道的话用for循环。

For循环适合一个范围的判断，while循环适合次数不明的判断。

三种循环语句的区别：

Do...while至少要执行一次循环体，而for循环和while先判断条件是否成立，然后决定是否执行循环语句。

/t tab键的位置

/r 回车

/n 换行

Break ：跳出单层循环，终结本次循环。循环到此为止

Continue：跳过本次循环，外部循环正常进行

Return：结束整个方法，并不只作用于循环

 

If语句和switch语句的区别：

If语句：

1.针对结果是Boolean类型的判断

2.针对一个范围的判断

3.针对几个常量值的判断

Switch语句：

1.针对几个常量值的判断

 

方法：完成特定功能的代码块（在其他语言中也叫函数）

修饰符 返回值类型 方法名 （参数类型 参数名1，参数类型 参数名2...）{

方法体语句；

Return 返回值；

}

返回值就是方法运行之后的结果

实际参数：实际参与运算的参数

形式参数：方法上定义的，用于接收实际参数的

参数类型：参数的数据类型

参数名：变量名

方法体：就是执行功能的代码

Return：结束方法

返回值：就是方法执行的结果，由return带给调用者

写好一个方法必须明确：返回值类型和参数类型

方法的执行特点是：

方法不调用不执行，main方法是jvm调用的

方法和方法之间是平级关系不能嵌套使用

方法定义的时候参数列表用逗号隔开

方法调用的时候不用再传递数据类型

如果有明确的返回值，一定要return带回一个值

 

有明确返回值的调用：单独调用没有意义

输出调用

赋值调用：

无明确返回值的调用：只能单独调用，其他两种调用报错

 

方法重载：在同一个类中，方法名相同，参数列表不同。与返回值类型无关       

参数列表不同：参数类型或者参数个数不同        

特点：与返回值类型无关，只看方法名和参数列表，在调用时虚拟机根据参数列表的不同来区分同名方法。

 

StringBuffer和String的区别

String类是字符串常量，是不可更改的常量。只可以重新创建对象然后赋值，旧的值被垃圾回收机制回收，因此在执行效率上，要比Stringbuffer慢。

 

而StringBuffer是字符串变量，它的对象是可以扩充和修改的。

Stringbuilder与Stringbuffer的区别，

前者是非安全线程，后者是安全线程，都是字符串变量，都是可改变的对象，他们对字符串进行操作时，实际上是在一个对象上操作的，不像String一样创建一些对象进行操作，所以速度就快一些。

操作数据量少用String,单线程操作字符串缓冲区下操作大量数据用StringBuilder，多线程操作字符串缓冲区下操作大量数据用Stringbuffer

 

String类下的常用方法：

toUpperCase方法返回一个字符串，该字符串中的所有字母都被转换为大写。

toLowerCase方法返回一个字符串，该字符串中的所有字母都被转换为小写。

Concat方法返回字符串值，该值包含了两个或者多个提供的字符串连接值，在原有的字符串后面追加一个新的字符串。

Search方法返回与正则表达式查找内容匹配的第一个字符串的内容的位置。

indexOf方法放回String对象内第一次出现子字符串位置，如果未找到的话则返回-1.

lastindexOF方法返回String对象中字符串最后出现的位置，如果没有匹配值的话，则返回-1.

Substr方法返回一个从指定的位置开始的指定长度的子字符串。

 

变量：就是在程序的执行过程中，其值是可以在一定范围内发生改变的量。

变量的组成规则：

A：必须对其进行限定

B：变量名

C：初始化值

数据类型 变量名 = 初始化值 ；

字符串：

字符串是常量，一旦被赋值就无法被改变

 

运行时异常:能正常编译，运行时异常；    一般异常：编译报错

 

String 类包括的方法可用于检查序列的单个字符、比较字符串、搜索字符串、提取子字符串、创建字符串副本并将所有字符全部转换为大写或小写

 

集合：

 

集合类型主要有3种:set(集)、list(列表)和map(映射)。

 

1. （排列顺序）Set实现的基础是Map(HashMap);list集合中允许有多个相同的元素。

2. (过滤重复字段)Set中的元素是不能重复的（允许有多个相同的元素），如果使用add(Object obj)方法添加已经存在的对象，则会覆盖前面的对象

set集合输出的数据的顺序是随机的。

 

在集合内元素类型确定的时候可以使用foreach循环。

 

1、List,Set都是继承自Collection接口

2、List特点：元素有放入顺序，元素可重复 ，Set特点：元素无放入顺序，元素不可重复

（注意：元素虽然无放入顺序，但是元素在set中的位置是由该元素的HashCode决定的，其位置其实是固定的）

3、List接口有三个实现类：LinkedList，ArrayList，Vector ，Set接口有两个实现类：HashSet(底层由HashMap实现)，LinkedHashSet

集合的实例需要用实现类（ArrayList HashSet等）来实现。

Map的实现类：

 

 

集合的使用步骤:

A:创建集合对象

B:创建元素对象

C:把元素添加到集合

D:遍历集合

        三小步：a：通过集合器对象获取迭代器对象

b：通过迭代器对象的hasNext（）方法判断是否有元素

c：通过迭代器对象的next（）方法获取元素并移动到下一个位置

 

迭代器：对容器中的元素进行遍列，每次取出一个元素，然后对元素进行操作。

 

 

 

IO流：

按流向分：

输入流：向程序中输出数据

输出流：由程序输出程序

 

按数据类型分：

字节流：处理的数据以字节为单位

字符流：处理的数据以字符为单位

 

字符流有两个抽象类：Writer：输出流    Reader：输入流

字节流有两个抽象类：InputStream:输入流 OutputStream：输出流

 

File 功能：

A：创建功能

B：删除功能

C：重命名功能

D:判断功能

E:获取功能

F:高级获取功能

G:过滤器功能

 

多线程

程序：某段代码

进程：代码运行之后，动态执行，从开始到结束就是进程。正在进行中的程序。其实进程就是一个应用程序运行时的内存分配空间。

线程：cpu调度和分配的基本单位。 其实就是进程中一个程序执行控制单元，一条执行路径。进程负责的是应用程序的空间的标示。线程负责的是应用程序的执行顺序。

※jvm在启动的时，首先有一个主线程，负责程序的执行，调用的是main函数。主线程执行的代码都在main方法中。

当产生垃圾时，收垃圾的动作，是不需要主线程来完成，因为这样，会出现主线程中的代码执行会停止，会去运行垃圾回收器代码，效率较低，所以由单独一个线程来负责垃圾回收。

垃圾回收机制是独立的由另外一个非主线程的线程运行。

 

随机性的原理：因为cpu的快速切换造成，哪个线程获取到了cpu的执行权，哪个线程就执行。

 

返回当前线程的名称：Thread.currentThread().getName()

 

线程的名称是由：Thread-编号定义的。编号从0开始。

线程要运行的代码都统一存放在了run方法中。

 

线程要运行必须要通过类中指定的方法开启。start方法。（启动后，就多了一条执行路径）

start方法：1）、启动了线程；2）、让jvm调用了run方法。

 

创建线程的第一种方式：继承Thread ，由子类复写run方法。

步骤：

1，定义类继承Thread类；

2，目的是复写run方法，将要让线程运行的代码都存储到run方法中；

3，通过创建Thread类的子类对象，创建线程对象；

4，调用线程的start方法，开启线程，并执行run方法。

 

因为实现Runnable接口可以避免单继承的局限性。

 

线程状态：

被创建：start()

运行：具备执行资格，同时具备执行权；

冻结：sleep(time),wait()—notify()唤醒；线程释放了执行权，同时释放执行资格；

临时阻塞状态：线程具备cpu的执行资格，没有cpu的执行权；

消亡：stop()

 

多线程状态：

新建（New）状态-就绪（Runnable）状态-运行（Running）状态-阻塞状态-死亡状态

 

静态代理：

1：目标类和代理类要实现相同的接口。

2：代理类中药持有被代理对象的引用。

3：要将目标类的实例注入到代理类中被代理对象的引用上。

 

死亡状态：外部干预终止线程的方法

1：需要定义一个标识，用于终止线程。

2：在该线程体中使用这个标识。

3：提供对外改变该标识的方法。

 

 

 

 

 

数据库

将数据以表的形式保存到数据库中，然后通过工具使用数据。

Sql关键字执行顺序：从先到后分别为：

form，On 连接关键字，where，group by，聚合函数，having，select，distinct，order by

 

UPDATE sys_user SET user_name='cai1' WHERE id = 8;      //修改

DELETE FROM sys_user WHERE id=12; //删除

INSERT sys_user (NAME,user_name,pass_word,sex,phone)

VALUES('菜007','c02','1234567','01','12345678999');     //增加

SELECT name,user_name,sex FROM sys_user;   //查询部分字段

SELECT * FROM sys_user;      //查询表中的所有数据

SELECT id AS'编号',NAME AS '姓名' FROM student AS s; //查询时指定别名（as） as可省略写成空格 ；在多表查询时经常使用到表的别名

SELECT t.id FROM sys_user t; //查询指定列

SELECT t.* FROM sys_user t WHERE t.sex = '00' AND t.age = 10;    //过滤性别为00和年龄为10的数据（where的用法）

DELETE FROM sys_user WHERE id in(1,3); //删除id为1和id为3的数据

DELETE FROM sys_user WHERE id not in(1,3); //删除除了id为1和id为3的以外的所有数据

SELECT name,user_name,sex,'java课程'AS '名称' FROM sys_user; //在查询sys_user表时添加一个常量列

ALTER TABLE sys_use ADD chengji INT; //在表sys_use中加一列成绩，数据类型为INT

INSERT  INTO sys_use VALUES ('58','老赵','男','1班',100)       //添加一整行数据用关键字INSERT  INTO，并可以省略表头的书写

 

 

table1 table2

 

 

数据库基本的查询方式：

 

子查询： SELECT t2.* FROM t_student t2 WHERE t2.class_id in (SELECT t1.id FROM t_class t1 WHERE t1.class_num in('001','002'));    //查询出来的结果当成条件使用，放在in后面作为条件使用

 

嵌套查询 ： SELECT t1.id FROM （SELECT * FROM t_student WHERE sex = '00'）t1  WHERE t1.age>10;            //查询出来的结果当成范围使用，放在form后面

 

 

连接查询：

 

 

内连接：

SELECT t1.*，t2.class_num,t2.class_name FROM t_student t1,t_class t2 WHERE t1.class_id = t2.id //把两张有关联的表合并为一张新表，相同的部分展示，无关联的部分不展示

explorer

外连接：

（返回包括左表中的所有记录和右表中联结字段相等的记录 ）

左外连接 SELECT t1.*，t2.class_num,t2.class_name FROM t_student t1 LEFT JOIN t_class t2 ON t1.class_id = t2.id; //左表所有数据都会显示出来，而右表只显示符合查询条件的部分  以左表为基础，右表中则返回为null

（返回包括右表中的所有记录和左表中联结字段相等的记录）

右外连接 SELECT t1.*，t2.class_num,t2.class_name FROM t_student t1 RIGHT JOIN t_class t2 ON t1.class_id = t2.id; //右表所有数据都会显示出来，而左表只显示符合查询条件的部分  以右表为基础，左表中则返回为null

全连接   SELECT t1.*，t2.class_num,t2.class_name FROM t_student t1 FULL JOIN t_class t2 ON t1.class_id = t2.id ;}         //mysql不支持 互相查询，没有匹配的值得时候，则会在另外一个表中显示为null

等值连接   INNER JOIN  并不以谁为基础，只显示符合条件的数据 ，只返回两个表中联结字段相等的行

交叉连接 SELECT t1.*，t2.class_num,t2.class_name FROM t_student t1 CROSS JOIN t_class t2 ON t1.class_id = t2.id;           //结果和内连接一样，但是过程不一样 

 

联合查询   UNION 合并两个查询结果为一个合集

 

自连接查询  SELECT * FROM t_dep t1 LEFT JOIN t_dep t2 ON t1.pid=t2.id;   //同一张表连接查询

 

SELECT DISTINCT(DEPART) FROM teacher t;   //用于去掉重复的数据的，只能针对某一个字段使用

 

排序函数：SELECT * FROM t_student ORDER BY age DESC,class_id ASC;            //按照年龄大小升序，班级id降序 前面的优先级较高，越往后优先级越低

分组函数：SELECT class_id,COUNT(id) FROM t_student GROUP BY class_id HAVING class_id in(1,3); //分组查询   追加条件时要用HAVING,用法和WHERE一样 查询班级id为1和3的所有班级

 

 

分页函数：SELECT * FROM t_student LIMIT 0,3; //查询前三条数据     {前面（0）动态赋值，后面数据不变，分页原理}

 

 

 

 

 

 

 

 

JDBC 连接数据库并操作数据库的标准，提供大量的接口。

 

 

 

 

 

 

JDBC的操作步骤

加载驱动程序，将驱动程序配置到classpath中

连接数据库，通过Connertion接口和DrverManager类完成。

操作数据库，通过Statement、PreparedStatement、ResultSet三个接口完成

关闭数据库 开发中资源有限，操作完之后必须关闭

 

 

 

数据库事务有四个特性，

数据库的四个特性为ACID，既原子性（Atomicity），一致性（Consistency），隔离性（Isolation），持久性（Durability）。

原子性，整个事务是不可分割的，要么全部执行，要么全部不执行；

一致性，事务的执行结构也要与业务的逻辑保持一致；（事务执行的结果必须是使数据库从一个一致性状态变到另一个一致性状态）

隔离性，多个事务之间隔离开来，互不影响；

持久性，一旦事务执行完毕，执行后的结果会永久的保存下来。

 

 

视图：视图是虚表，是从一个或几个基本表（或视图）中导出的表，在系统的数据字典中仅存放了视图的定义，不存放视图对应的数据。

 

作用：多对一或者一对多，多对多的话通过一张中间表（视图）转换为一对多或者多对一。而且查询效率会提高，不再编译整条语句，只编译剩下的语句。

 

函数：过程，相当于程序中的一个代码块。可以进行循环语句的构建。

数据库中的if语句： if NOW()>STR_TO_DATE('2016-07-01','%Y-%m-%d') THEN

DELETE FROM sys_user;

END IF;

 

执行数据库中的函数：CALL proc_test();

 

数据库中while循环插入100条数据。（先判断再执行）

BEGIN

DECLARE i INT;     //声明一个int变量

SET i=0;        //赋值

 

WHILE i<100 DO           //do执行

  

INSERT INTO sys_user(name) VALUES (CONCAT('菜',i));    //插入数据

SET i=i+1;                  //自增

END WHILE;                      //结束循环

 

END

 

 

 

数据库中repeat循环插入100条数据（先执行再判断）

REPEAT

  INSERT INTO sys_user(name) VALUES (CONCAT('菜',i));

  SET i=i+1;

  UNTIL i>=100

  END REPEAT

 

数据库中loop循环插入100条数据（最常用的方式，使用方式比较灵活）

loop_test:LOOP

IF i>=100 THEN

LEAVE loop_test;

END IF;

INSERT INTO sys_user(name) VALUES(CONCAT('菜',i));

SET i=i+1;

END LOOP;

 

 

Tomcat 是符合JAVAEE标准的一个最小web容器

 

 静态 web服务插件 web服务器 文件系统 web容器  

 动态   web容器   web服务器 文件系统

 

 

 

javaweb开发 两个组件 javabean 和 servlet

必须是私有属性和set，get方法  必须无参的构造方法，可省略

所有的javabean都必须放在同一个包下。

优点：将html和java代码分开，方便了开发和维护，  将常用的程序写成javabean可减少重复代码的编写 。

 

 

 servlet:处理和响应请求的作用

 

 

 

 

 

html组件的书写方法：

 

<form action= "http://127.0.0.1:8080/web_lesson1/test" method="post">

    <!-- 文本框 -->

            文本框：<input type="text" name="username"value= ""/><br/>

    <!-- 密码域  -->

    密码域:<input type="passwprd"name="password"value=""/><br/>

         <!-- 单选框 -->

           单选框<input type="radio"name="r"value="1">是

          <input type="radio"name="r"value="0">否<br/>

          <!-- 复选框 -->

          复选框:<input type="checkbox"name="c"value="01">这是第一个选项

          <input type="checkbox"name="c"value="02">这是第二个选项

          <input type="checkbox"name="c"value="03">这是第三个选项<br/>

       <!-- 大文本域 -->>   

     大文本域:<textarea name="ta"cols="10"row="10"></textarea><br/>

   <!-- 文件域 -->

   <!-- 文本域:<input type="file" name="f"> -->

   <!-- 下拉列表 -->

       单选 下拉列表：<select name="se">

   <option value="0">我是一个人</option>

   <option value="1">我是一个神</option>

   <option value="2"selected="selected>我是一个仙</option>

   <option value="3">我是一个兵</option>

   <option value="4">我是一个选手</option>

   </select></br>

    多选下拉列表：<select name="se"multiple="multiple"size="5">

   <option value="0">我是一个人</option>

   <option value="1">我是一个神</option>

   <option value="2">我是一个仙</option>

   <option value="3">我是一个兵</option>

   <option value="4">我是一个选手</option>

   </select></br>

    </form>

 

 

404 资源找不到

405 找不到对应的方法

500 执行的方法出错

 

servlet 生命周期

 

加载Servlet：web容器负责加载servlet，当web容器启动或者第一次使用这个Servlet的时候，容器会负责创建Servlet实例，但是用户必须通过部署描述符（web.xml）指定Servlet 的位置。成功加载之后立即，web容器会通过反射的方式对servlet进行实例化。

 

初始化：当一个servlet被实例化后，容器将调用init()方法初始化这个对象，初始化的目的是为了让servlet对象在处理客户端请求前完成一些初始化工作。

 

处理服务：当有请求提交时，servlet将调用service（）方法（常用的是doget（）或dopost）进行处理。将封装的request对象传到servlet。

 

销毁：当web容器关闭或者检测到一个servlet要从容器中被删除时，会自动调用destory方法以释放掉该实例所占用的资源。

 

卸载：当一个servlet调用完destory（）方法后，此实例会被垃圾回收器回收。

 

容器赋值叫注入

servlet的作用：响应和处理请求 转发或者重定向其他地方而不响应。

重定向：只能写绝对路径。

转发：用responce对象（request），由web进行封装。

任意一个线程都可以访问servlet，post安全，get不安全，推荐使用前者。

 

 

 

jsp(java server page) 创建动态web内容的技术

客户端发送http请求给jspservlet，分析请求查找a.jsp，然后javaservlet读取文件，接着jspservlet翻译jsp中的内容，翻译为servlet，a.java,然后编译为 .class文件，由类加载器加载编译，执行servlet实例，返回客户端响应

 

 

 

 

 

 

 

 

 

 

 

 

 

获取servlet转发过来的数据，通过EL表达式去获取。  表达式写法：${    }

 

 

js小脚本（用于展示数据的）

静态请求，不是对文件进行请求

<%

声明变量

int = 0;

 

%>

 

 

<%=

输出一个结果

int = 0;

%>

 

 

 

<%!

书写方法(可定义无参或者有参的方法)

public String test(){

system.out.print("test")

return "test";

}

class A{

public String test_A(){

return "test";

    }

    }

%>

 

jsp 注释

<!--   -->    显示的注释

<%--   -->    隐示的注释

 

jsp的九大内置对象（java小脚本里可以使用，部分在其他地方也可以使用）

可直接使用，由容器进行实例化。不需要预先声明就可以在脚本代码和表达式中随意使用。

request            请求对象　      类型 javax.servlet.ServletRequest        作用域 Request
response          响应对象        类型 javax.servlet.SrvletResponse       作用域  Page
pageContext    页面上下文对象     类型 javax.servlet.jsp.PageContext      作用域    Page
session            会话对象        类型 javax.servlet.http.HttpSession       作用域    Session
application   应用程序对象 类型 javax.servlet.ServletContext          作用域    Application
out                   输出对象      类型 javax.servlet.jsp.JspWriter             作用域    Page
config              配置对象       类型 javax.servlet.ServletConfig            作用域    Page
page               页面对象       类型 javax.lang.Object                            作用域    Page
exception        例外对象       类型 javax.lang.Throwable                     作用域    page

四个作用域（用于传递值）都能用el表达式获取值。（可直接指明作用域）

pageContext, 一个页面  (page里的变量没法从index.jsp传递到test.jsp。只要页面跳转了，它们就不见了。)优先级最高，范围最小

request, 一次请求(request里的变量可以跨越forward前后的两页。但是只要刷新页面，它们就重新计算了。)

session,一次会话（浏览器关闭则无效） 存储用户信息

session和application里的变量一直在累加，开始还看不出区别，只要关闭浏览器，再次重启浏览器访问这页，session里的变量就重新计算了。

Application，跟web容器生命周期保持一致  优先级最低，范围最大

 

优先级：范围越大优先级越低。

 

 

可视化视图

视图模型控制器分离

Model :javabean（业务逻辑与业务顺序）

Controller:service(逻辑处理)和控制层(跟视图做数据交换，搬运和转发数据，)（控制器，负责程序的流程控制），接收到用户请求，根据业务逻辑执行情况，返回响应的结果。

View：视图(显示逻辑)将数据按照用户的要求显示出来。

Mvc的思想

 

 

 

 

 

 

 

 

 

 

 

 

好处：各司其职。

代码可重复使用。

Servlet：（1）能够接受所有用户的请求，（2）能根据请求的不同，调用不同的处理（javabean）

 

HTML：

元素:从一个标签开始到一个结束，这之间所有的内容。

属性：在标签中写的内容

标签：w3c制定的，  <   >  都需要成对的出现。

正文中的标签都是用<h1><h2>，从h1到h6文字显示内容是越来越小，等表示的，放在     <body>这是一个标题</body>     中，段落标签用

<p>这是一段文本内容</p> 表示，会自动换行，  

<b>这是一段文本</b>：加粗文本内容   

<big>这是一段文本内容</big>：加大字体    

<small>这是一段文本内容</small>：缩小字体

table

布局的标签

表格<table  border=”1” > <tr>  <td>ce111</td>  </tr></table>       t r: 行  td: 单元格

<td colspan=”2”></td> 单元格长度为2，<td rowspan=”2”></td> 单元格宽度为2.

<th>姓名</th>： 横行显示 表头  

列表：有序列表，无序列表，自定义列表。

无序列表<ul>   <li> </li>   <li> </li>   <li></li> <ul>

有序列表<ol>    <li></li>   <li></li>   <li></li> <ol>

自定义列表<dl>  <dt>< img src=”./catch.png”  alt=”这是一张图片” height=”150” width=”200”>  </img>  </dt>  <dd>这是描述信息</dd>    <dt>这是一个图片</dt>  <dd>这是描述信息</dd>   <dt>这是一个图片</dt>  <dd>这是描述信息</dd>    </dl>   dt和dd为一组完整的标签

表单

以上着重记忆

<li><a href=”http://baidu.com” target=”_blank”> 这是个超链接</a></li>  在新选项卡中打开百度  

<a  a href=”#a4”> 指向a4</a>  用来定位页面元素的。

 

 

Html 中用于布局的元素

<span></span>                <div></div>

 

 

<html

<head>

<titic></titic>

<style type="text/css">

<!-- 标签选择器   -->三种css中基本的选择器

div{         

 

 }

 

（id选择器）#div1{         

 

 }

（类选择器）.div_1{         

 

 }

(属性选择器) [title]{

 

}

[title=1]{

 

}

 

</style>

 

</head>

<body>

<div  id=”div1” class=”div_1”  style="color:blue;">

<span>这是个标签</span>

<span style=”color:red:font=size:32px”>这是个span标签！</span>

<div style=”color:blue;”></div>

</body>

</html>

Css的作用：

背景，颜色，

 

<html

<head>

<titic></titic>

<style type="text/css">

.content{  

Height:700px;

Width:700px;

Background-image: url(“.catch.png”);

Background-repeat:repeat;

}

</style>

<body>

<div class=”content”>

 

</div>

</body>

</html>

 

 

 

 

 

 

 

<html

<head>

<titic></titic>

<style type="text/css">

.content{  

Height: 100px;

Width: 100px;

Background-image: url("./catch.png");（添加图片）

Background-repeat:repeat;（覆盖，重复）

Background-position:50%  50%;(偏移量)

Border-width:1px;

Border-color:red;

Border-style:solid;

Border-radius:50%;(圆形)

Border-top-left-radius:50px;(切割左上角为圆角)

}

.content.text{    

font-family:"宋体";(字体类型)

font-size:22px;（字体大小）

font-weight:bolder;（字体粗细）

font-style:normal;（字体样式）

color:red;（字体颜色）

vertical-align:middle;(字体对齐方式)

}

 

</style>

<body>

<div class="content">

<span class="text">这不是个span标签</span>

 

</div>

</body>

</html>

 

 

 

<html

<head>

<titic></titic>

<style type="text/css">

.box1,.box2{

Height:200px;

Width:200px;

}

.box1{

background-color:blue;

Margin-bottom:32px;

}

.box2{

background-color:red;

Margin-top:32px;

}

 

.box1 .subbox1{

height:50px;

width:50px;

background-color:black;

margin-top:50px;

}

 

</style>

<body>

<div class="box1"></div>

<div class="box2"></div>

</body>

</html>

 

 

 

解决浏览器兼容问题

加上相应的标识符 火狐 -moz- 谷歌 -webkit-  欧朋 -o-

 

 

<html>

<head>

<title></title>

</head>

<body>

<script type=”text/javascript”>

Document.write(“这是用javascript写入的内容”)；

</script>

 

</body>

</html>

 

 

 

Js系统的讲解

 

匿名函数：

Var test2 = function(i){

Alert(i);

}

Test2(2);

 

(function(i){

Alert(i);

})(1);

 

 

Function test1(){

 

}

 

Var fun = function test(){

Alert(1);

}

Var test1 = new function(‘i’,’return i;’);

Alert(typeof(fun))；

 

内层函数可以调用外层函数的所有的变量，即便是外层函数执行完毕，内层函数依然可以调用外层函数的变量。

 

setTimeout(function(){

Alert(1);

},5000);

//定时5秒后刷新一遍，输出1

 

Function testClosure(){

Var str = “这是一个字符串”;

Var inner = function(){

Alert(str);

}

Return inner;

}

Var i =testClosure();

i();

 

闭包官方解释：

一个拥有许多变量和绑定了这些变量的环境表达式，因而这些变量也是表达式的一部分。

闭包的特点：

1.作为一个函数变量的一个引用，当函数返回时，即处于激活状态

2.一个闭包就相当于函数返回时，没有释放资源的栈区。

3.闭包函数不会对全局变量造成污染。

 

Function test1(){

I=1;

}

Function test2(){

Alert(1);

}

 

Test1();

Test2();

 

 

Var i = 0;

(function(k){

K=1

})(i);

 

 

Jquery里的各种选择器：

//id选择器

alert($("#d1").get(0));

//类选择器

$(".div1");

//标签选择器

$("div");

//属性选择器

$("[attr]");

$("[attr=1]");

//选择器混用

$("div[attr]");

$("div[attr=1]");

//子选择器

$("ul li:first-child");

$("ul li:last-child");

$("ul li:nth-child(2)");

 

 

 

 

 

 

 

框架

hibernate主键 八种生成策略：最常用的为红色

 

Identity  mysql数据库/sql server数据库

Squence  oracle数据库中使用sequence生成主键

Native  几乎适用于所有数据库 自动识别，然后匹配第一或者第二种策略（数据库主键设置为自增）数据库维护主键

Uuid.hex 由hibernate进行维护、生成一个32位随机字符串充当主键

Foreign 使用外部表字段作为hibernate主键

Uuid.string  由hibernate进行维护、生成一个32位随机字符串充当主键

Assigend （自动维护主键，其他的即使自己手动赋值也会被覆盖）

Increment  对long,short或int的数据列生成自增长主键

 

 

 

 

 

一、hibernate的优缺点

优点：移植性好

提高开发效率

轻量级，侵入性较小

解决了阻抗不匹配的问题

缺点：适合操作单个对象，不适合批量操作多个对象

不适合特定的数据库操作

不适合操作关系复杂的对象

 

 

 

二、hibernate使用步骤

1、新建java工程

2、添加hibernate相关jar包

3、创建hibernate配置文件hibernat.cfg.xml

4、创建实体类

5、创建实体类的映射文件

6、将实体类映射文件加入到hibernate.cfg.xml配置文件中

 

 

 

五个核心接口的用法，查询、缓存

Configuration  读取和加载配置文件并启动hibernate

SessionFactory  存储数据库的连接信息以及初始化的配置信息（每一个数据库对应一个sessionfactory）

Session 接口负责执行被持久化对象的CRUD操作

Transcation 控制事务的（手动控制）

Query 用来提供查询的

 

 

Hibernate里对象的三种状态：

1、瞬时状态对象   在数据库中没有与之对应的记录   没有被session纳入管理

2、持久状态对象   在数据库中有与之对应的记录  纳入了session的管理

  当对象发生变化时，会自动同步到数据库中

3、游离状态对象   在数据库中有与之对应的记录  没有被session纳入管理

 

 

Hibernate的查询

1.标准化对象查询（Criteria）

2.Hibernate的语句查询（HQL语句）使用Query接口

3.原生的sql语句查询（使用SqlQuery接口）

4.外置命名查询（类似于mybatis/ibatis）使用Query接口

 

 

1 标准化对象查询

*以对象的方式进行查询，将查询语句封装成对象。

 

2-1 HQL语句查询中实体对象查询

*如果首次查询使用Query接口中的iterate（）方法进行查询，会发出N+1条sql语句，

--首先发出一条sql语句查询对象的主键集合

--根据主键到数据库中去进行查询，会发出N条查询语句

*如果不是首次查询使用Query接口中的iterate（）方法进行查询，可能会发出N+1条sql语句，

--首先发出一条sql语句查询对象的主键集合

--根据主键到缓存列表中进行查询，如果缓存列表中没有与之匹配的记录，则会发出一条对应的sql语句去数据库中进行查询Query接口中list（）方法与interate（）方法的区别：

相同点：都会在查询结束后把查询出来的结果放到一级缓存中。

不同点：iterate（）使用缓存中的数据，list（）方法不使用缓存中的数据，每次都会去数据库进行查询

Iterate（）方法返回的是一个迭代器对象，list（）方法返回的是一个list对象集合。

*hql语句写法：

--hql语句是针对对象以及属性进行操作

--把sql语句中的表名替换为对象名，SQL语句中的字段名替换为属性名

注:hql语句中没有select*这种写法

*查询条件拼接方法：

--可以采用字符串拼接的方式把查询条件直接拼接在hql语句上

--可以采用通配符？来传递参数进行查询（索引是从0开始）

--可以采用：参数名来传递参数进行查询

注：分页参数与mysql中limit函数传递的参数一致（起始位置，分页大小），分别用setFirstResult（）与setMaxResult（）来表示。

 

2-2 HQL语句中的简单属性查询

*单一属性查询

*多个属性查询，返回的集合元素是对象数组（Object[]）,数组的长度与查询的属性个数一致，数组中的元素与查询的属性值一一对应

*可以采用构造函数的方式把查询出来的属性值构造成一个实体对象。

 

2-3 原生SQL语句查询

*参见SimpleNativeQueryTest.java

 

2-4 外置命名查询：

*在任意映射文件中采用<query>标签来定义hql语句，或者采用<sql-query>标签来定义sql查询语句，<query>标签与<sql-query>标签要写在<class>外，具体格式参见SysUser.hbm.xml文件。

*在程序中采用getNamedQuery方法获取定义的HQL或SQL语句，并返回Query对象，用Query接口中的List（）方法或者iterate（）方法获取查询的结果集（对象集合），参见SimpleNameQueryTest.java

 

 

计算机存储单位：

1B（byte）=8b（bit位）

1KB = 1024B

1MB = 1024KB

1GB = 1024MB

1TB = 1024GB

1PB = 1024TB

1EB = 1024PB

1ZB = 1024EB

1YB = 1024ZB

 

 

Hibernate一级缓存：

*与session的生命周期一致，所以也叫session级缓存。（对数据库的一次访问）

*一级缓存中存放的只能是对象或者对象集合，属性查询不会保存到一级缓存中去

*用session接口进行的CRUD（增删改查）操作，其操作的对象都会保存到一级缓存中

*不可配置，可以通过clear（）或evict（）方法进行管理，防止内存溢出

注：如果数据量特别大，建议放弃hibernate操作，采用jdbc进行操作

 

 

Hibernate二级缓存：

*二级缓存也叫SessionFactory级缓存，二级缓存可以被所有的session共享

*二级缓存的生命周期和SessionFactory生命周期一致，SessionFosctory可以管理二级缓存

 

*二级缓存的配置和使用（此处以EhCache为例）

--开启二级缓存（默认就为开启状态），修改hibernate.cfg.xml配置文件

<property name=”hibernate.cache.use_level_cache”>true</property>

--指明缓存产品提供商（hibernate默认实现了一套基于hashtable的一套缓存产品，该产品仅用于开发阶段，不适用生产阶段）

修改hibernate.cfg.xml配置文件

<property name=”hibernate.cache.region.factory_class”>org.hibernate.cache.EhcacheRegionFactory”</property>

--将ehcache.xml配置文件拷入工程中，配置缓存策略（可以使用全局缺省配置，也可以指定某个对象进行单独的缓存策略配置）

--需要指明使用二级缓存的类（两种方式指明）：

1，在该类对应的映射文件中，采用<cache>标签来配置，<cache>标签位置位于<class>标签内，<class>开始标签的后边

2，在hibernate.cfg.xml配置文件中采用<class-cache>标签来配置，<class-cache>标签的位置位于<session-factory>标签内，所有的<mapping>标签之后

*二级缓存中存放的也是实体对象或者对象集合，不能是普通属性集合

 

 

hibernate查询缓存

*查询缓存是针对普通属性结果集进行缓存

对实体对象的结果集只缓存实体对象ID（主键）

*多个session可以共享查询缓存，与SessionFactory绑定

*查询缓存的生命周期,不确定,当关联的表发生修改时,那么查询缓存的生命周期结束

查询缓存的配置和使用:

*在hibernate.cfg.xml配置文件中启用查询缓存,

<property name="hibernate.cache.use_query_cache">true</property>

*需要指明缓存产品提供商，如果已经指明缓存产品提供商，就不需要额外配置，若没有指明二级缓存产品提供商，需要在单独指明查询缓存的缓存产品提供商

*还需要在程序中手动开启查询缓存,调用query.setCacheable(true);方法来启用

注：iterator()方法不支持查询缓存

 

 

Spring框架

 

轻量级的控制反转（IOC）和面向切面（AOP）的容器框架

初始化bean容器方法

第一种方式：读取本地文件初始化bean容器

 

第二种方式：读取ClassPath目录下的配置文件初始化bean容器

 

第三种方式：使用spring提供的监听器，借助web容器的全局方式

 

Spring容器可以管理任意一个类

 

注解标签（对代码比较有侵入性，比较方便，利于代码书写）

 

Spring容器中注册管理bean的标签

一 用来注册bean的，需要在spring配置文件中启用<context:component.scan>标签开启注解扫描

    @Componet(通用的组件注册注解标签)

@Repository(用于注册DAO层的类)

@Service(用于注册Survice层的类)

@Controller(用于注册Controller层的类)

 

 

 

 

用来管理bean之间的依赖关系，通过自动注入的方式实现bean的注入

 

@Autowrired(自动注入，通过bean的类型进行注入)

@Qualifer

@Resoerce(自动注入，通过bean的id进行注入)

 

 

二 @Configurition @Bean @Import

 

 

AOP面向切面编程

切面（Aspect）：一个关注点的模块化，在这个关注点横切与多个对象

连接点（JoinPoit）：程序中的某个特定的点

通知:（advice）：在切面上的某个特定连接点上执行的动作

切点（PointCut）：匹配连接点的表达式

 

AOP业务代码与关注点代码分离，好处？

关注点代码写一次即可；

开发者只需要关注核心业务；

运行时期，执行核心业务代码时候动态植入关注点代码；

 

通知的种类：

Before Advice：（前置通知）

After returning Advice：（返回后通知）

After Throwing A dvice：（抛出异常后通知）

After Advice：（后置通知）

Around Advice：（环绕通知）

 

声明事务的配置方式：

第一大类：支持当前事务

REQUIRED:支持当前事务，如果当前存在事务，就是用当前的事务，如果当前不存在事务，则开启一个新的事务。

MANDATORY：支持当前事务，如果当前存在事务，则使用当前事务，如果当前不存在事务，就抛出异常

SUPPORTS：支持当前事务，如果当前存在事务，则使用当前事务，如果当前不存在事务，就以非事务方式运行

 

第二类：不支持当前事务

NAVER：不支持当前事务，始终以非事务方式运行，如果当前存在事务，就抛出异常

NOT_SUPPORTED：不支持当前事务，始终以非事务方式运行，如果当前存在事务，则把当前的事务挂起

 

第三类：嵌套事务

NESTED：

 

 

 

 

 

Spring-mybatis

 

整合CRUD操作：三种方案

第一种方案：使用salSessionTemplate

第二种方案：使用映射器按照映射规则创建指定接口的实现类并放入spring容器中进行管理

第三种方案：批量按照映射规则生成指定接口的实现类并放入spring容器中管理，bear的id默认为该接口名称首字母小写

 

 

 

Spring  七 大模块

最基础的是spring core，所有模块都是基于这个模块进行的开发。

  Spring aop

  Spring web mvc：spring对于mvc的实现

  Spring orm：基于框架对于jdbc的实现

  Spring dao：

  Spring web:

  Spring context:

 

 

 

框架整合

Spring需要的包：

Core包

Bean

Context包

 

Tx标签组件对事物进行扩展

Test单元测试组件

Spring—aop

Spring—aspcet

Spring—orm仅仅针对hibernate，没有对没有batis进行整合

Mybatis的核心包

spring—jdbc

Mybatis—spring

Webmvc

 

 

Mybatis的包

Mybatis

Mysql—connector—java

 

Java.servlet.api

Java.servlet.jsp

 

Jstl

这个包

 

Commons—fileupload等 的一些工具类包

Log4j 一些工具类的包

 

 

初始化的配置信息

写配置文件时从spring开始写

 

 

建资源文件夹src main webapp            configs

四个配置文件 mvc_dispatcher spring-root

 后面被替代之后删掉  Mybatis_config 先配置数据库连接  datasource type POOLED 连接驱动 用户名 密码 连接地址   需要手动去写一个事务管理器 jdbc管理器

加载映射文件  <mapper resource=” com/yrrj/mapper/sysusemapper .xml“><mapper>

Spring容器初始化的三种方式 相当于启动spring容器

读取classclass   操作本地的某个资源文件  监听器执行某个构造函数完成，启动web容器的时候就会执行监听器 spring容器里的所有

 

整合mybatis的操作（替代mybatis主配置文件）

写在spring-root 里的

Bean id datasource class org.spring framework.......

Name driverclassname

Name url

Name username

Name password

上面的值下载一个资源文件中，前缀为jdbc

引入资源文件 context property placeholder  location =”classpath:config.properties”

 

bean sqlsessionfactory  org.mybatis.spring.sqlsessionfactorybean

Property  datasource  

整合mybatis-crud 操作

第一种方案：

整合sqlsession

使用构造器来注入

Bean id sqlsession class aqlsessiontemplate

Constructor-arg name sqlsessionfactory ref sqlsessionfactory  

 

第二种方案

映射文件中的映射，相当于执行sql语句

Bean id userdao class org..........mapper.mapperfactorybean

Property name mapperinter

 

第三种方案

 

 

 

 

配置事务管理器

Bean id datasourcetransactionmanager class

Property name data source ref datasource

 

声明事务第一种方式：开启事务注解驱动

Tx：annotation-drivern transaction-manager data....manager

 

声明第二种方式：通过切面配置

Tx:advice transaction-manager  data....manager

 

Tx method name”save”propagation required

               Insert

               Update

               Del

............

...........

.............

...........

Mvc-dispatcher.xml文件中

注册所有的controller，注册到spring webmvc容器中

扩充注解驱动

静态资源映射

配置视图解析器

 

 

 

Spring容器和 spring mvc 容器是父子关系，子容器可以访问父容器的任何资源，而父容器访问不到子容器的任何资源

所有的curd都是dispatcher去间接调用的

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

面向对象

封装：属性私有化，实现细节私有化，对外提供公共的访问方式。

属性私有化，对外提供操作该属性的方法。

提高了代码的复用性，提高了安全性。

封装原则：把不需要对外提供的内容都隐藏起来，把属性隐藏，提供公共的方法访问。

Private:可以修饰成员变量和成员方法，被修饰的变量或者方法，只能在本类中被使用。

this：调用当前类的属性和方法，跟外部传入的值或者属性做区别引入了该关键字。

 

继承：子类继承父类，扩展父类的功能。1.7及以下的，单继承，多层继承，不支持多重继承，子类只能继承父类的非私有成员和非构造方法

父类实例化可以调用子类进行实例化。

1如果父类对象使用本类的构造函数进行实例化，在方法调用的时候就只能调用本类类中的方法，并且最终执行的也是本类中的方法。

2如果父类对象使用子类的构造函数进行实例化，在方法调用的时候也只能调用本类中的方法，但是最终执行的确实子类中重写的方法。

3如果子类对象使用本类的构造函数进行实例化，在方法调用的时候既能调用父类中所有的菲斯有成员方法，也能调用本类中所有的非私有方法。

多态：

同一行为的不同实现。

 

对象的多态：主要体现在父类子类对象的转换，父类转换子类，需要强制转换；子类转换父类不需要强制转换。

方法的多态：方法的重载（overioad）（方法名相同，参数不同）和重写（override）（子类继承父类，（重写）在子类里重新定义一个和父类完全相同的方法）

 

类：是一组相关的属性和行为的集合，是一个抽象的概念。（成员变量和成员方法）

对象：是该类事物具体表现的形式，具体存在的个体。

成员变量和局部变量的区别：

成员变量：类中方法外、在堆内存中，随着对象的创建而存在，随着对象的消失而消失。有默认初始化值。

局部变量：在方法定义中或者方法声明上，在栈内存中，随着方法的创建而存在，随着方法的调用完毕而消失。没有默认初始化值，必须定义，赋值才能使用。

局部变量和成员变量名称可以一样，在方法中使用的时候采用就近原则调用。

 

抽象类：抽象类不可实例化，只能由子类去创建。（关键字是Abstarct）

 

抽象方法：

属于一种不完整的方法，只含有一个声明，没有方法主体，含有抽象方法的类叫做抽象类。

如果从一个抽象类继承，而且想生成新类型的一个对象，就必须为基础类中的所有抽象方法提供方法定义

abstract class在Java语言中表示的是一种继承关系，一个类只能使用一次继承关系。但是，一个类却可以实现多个interface

如果从一个抽象类继承， 必须对所有抽象方法进行覆盖 , 否则导出类也是抽象的

 

类：是对某一类事物的描述。

 

接口：把class关键字改为 interface 接口中只能有抽象类 接口中没有成员变量

实现类实现接口implements 接口名，接口名，可实现多个接口。实现类里的方法和接口中的一样  接口对象实现只能通过他实现类的构造函数进行实例化，实现类只需要进行本身进行实例化就行可以。被实例化后的接口对象调用的只能是本身所定义的方法，而实现的确实实现类的方法。

匿名对象：Student t = new Student();

Student();     //这就是一个匿名对象，仅能调用一次，调用结束之后就会变成垃圾被回收

匿名参数可以作为实际参数被传递。

 

java数据类型：（四类八种）

基础数据类型和引用数据类型

基础：byte、short、int、long0、float、double、char、boolean

八种数据类型的封装类：

常量表示的是在程序中不能被修改的数据。

变量与常量的相同点是在声明之前都指定变量的数据类型，变量无final关键字声明。

基本数据类型：整数型，浮点型，字符型，布尔型

引用数据类型：类，接口，数组

整数默认是int类型

浮点数默认是double类型

长整型后加上L标记

单精度浮点数用F标记

 

使用变量的时候需要注意的问题：（变量就是属性，属性就是性别，年龄之类的）

A：作用域

变量只在当前的大括号内有效，并且在同一个大括号内不能同时定义同名的变量

B:初始化值

没有初始化值的变量不能使用。

只要在使用前给值就行，不一定非要在定义的时候立即给值（推荐定义的时候就给值）

建议一行只定义一个变量

 

进制的转换：

0b开头的是二进制  0开头的是八进制 0x开头的是十六进制

 

任意的进制转换为十进制的方法：  

基数：自身的进制

每一位上的系数*基数^权次幂，然后分别相加

 

十进制转换为任意的进制的方法：

基数（需要转换到的进制数）

除基取余，直到商为0，余数反转

8421码

1   1   1   1   1   1  1  1

128 64  32  16  8   4  2  1

二进制到十进制：1010100 = 64 + 16 + 4 = 84

十进制到二进制：100 = 0b110000

二进制到八进制：0b1011001 = 001 + 011 +001 =1 + 3 +1 =0131（拆分组合法）

如果任意进制到任意进制的转换，则需要用十进制作为桥梁。   

 

数组:

同一类对象(变量常量）的组合（可以存储基本数据类型和引用数据类型）

数据类型 [] 数组名；

数组必须先初始化才能使用。

初始化：为数组中的数组元素分配内存地址，为每个数组元素赋值

数组初始化方式：

静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度

数据类型[]数组名 = new 数组类型[]{数据}   数据类型[]数组名 ={1,2,3..}

 

动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。

数据类型[]数组名 = new 数组类型[数组长度]

数组中每个元素都是有编号的，叫索引

 

不要一个声明中有动态和静态两种声明方法

5个内存空间：

栈：局部变量( int [] arr )

特点：每一个new出来的东西都有地址值

  每个变量都有默认值：byte，short，int，long 默认值是0

  Float,double 默认值是0.0

  Char 默认值是 ‘/u0000’  代表一个空字符

  Boolean 默认值是 false

使用完毕就变成了垃圾，但是并没有立即被回收。会在垃圾回收器空闲的时候被回收

栈内存的两个引用指向同一个堆内存空间，不管是谁的操作，都是针对同一个堆内存

 

堆：所有new出来的东西    ( new int[3] )

方法区：（面向对象）

本地方法区：（与系统相关）

寄存器：（CPU使用）

局部变量：在方法定义中或者方法声明上的变量

运算符：分为算数运算符，关系运算符和逻辑运算符、位运算符还有赋值运算符。

&&是短路与  只要第一个条件不满足，后面就不会继续运行

&是与 即使第一个条件不满足后面继续运行

||是短路或，只要满足第一个条件就不再往下进行判断

|是与，要对所有的条件进行判断

算术运算符：+ - * / %  关系运算符：== != > < >= <=   逻辑运算符：&& || !  位运算符：& |~  

与 同真为真，一假为假。或 有真则真 同假为假。异或 相同为假 不同为真。非 结果相反

Int c =a++; 先传值给c后，自身在进行a++      int c = ++a；先进行++a，然后再传值给c  

S +=1；不是等价于s = s + 1; 而是等于s = （s的数据类型）（s + 1）；   

 %得到的是除法操作的余数，/得到的是除法操作的商    ++对变量进行自增  

--对变量进行自减

整数相除，只能得到整数，想要得到小数，需要把其中的任意一个数据类型变为浮点数。

整数默认是int类型，浮点型默认是double类型

一般来说，运算的时候，要求参与运算的数据类型必须一致。

Boolean类型不能转换为其他的数据类型

变量是先提升类型后计算结果。常量是先计算出结果，然后看结果是否在范围内，如果在就不报错。

Ackii码

‘A’=65     ‘a’=97      ‘0’=48

‘A’+1=67   ‘a’+1=98    ‘0’+1=49

 

三元运算符能实现的，都可以采用if语句实现，反则不成立。Int c = ( (a>b) ? a: b );

因为三元运算符是一个运算符，运算符操作完毕就应该有一个结果，而不是一个输出

If语句是可以嵌套使用的。

 

 

Switch语句：

Int x = 1;

Switch ( x ){

Case value: value只能是常量，不能是变量

表达式1

Break；

 

Case value: 多个case的值不允许重复

表达式2

Break；

 

Default： default可以省略，但是建议不省略

表达式n

Break；             break 可以省略，但是结果可能不对，会出现case穿透

}                       最后一条的break可以省略并且不影响结果。

 

X可以为byte，不可以为long，jdk7以后可以为string

 

Java循环语句结构：

 

while（循环条件）

    循环体

    }

 

 do{

    循环体；

    }while（循环条件）；

 

for（初始化语句；循环条件；迭代语句）{

    循环体；

}

 

If（循环条件）{

语句；

}else{

语句；

}

if循环计数用count++

For循环和while循环的区别：

for循环结束后，变量就会及早的从内存中消失，可以提高内存的使用效率，如果想在循环结束后依旧使用那个变量，那么推荐使用while循环。否则用for循环，不知道的话用for循环。

For循环适合一个范围的判断，while循环适合次数不明的判断。

三种循环语句的区别：

Do...while至少要执行一次循环体，而for循环和while先判断条件是否成立，然后决定是否执行循环语句。

/t tab键的位置

/r 回车

/n 换行

Break ：跳出单层循环，终结本次循环。循环到此为止

Continue：跳过本次循环，外部循环正常进行

Return：结束整个方法，并不只作用于循环

 

If语句和switch语句的区别：

If语句：

1.针对结果是Boolean类型的判断

2.针对一个范围的判断

3.针对几个常量值的判断

Switch语句：

1.针对几个常量值的判断

 

方法：完成特定功能的代码块（在其他语言中也叫函数）

修饰符 返回值类型 方法名 （参数类型 参数名1，参数类型 参数名2...）{

方法体语句；

Return 返回值；

}

返回值就是方法运行之后的结果

实际参数：实际参与运算的参数

形式参数：方法上定义的，用于接收实际参数的

参数类型：参数的数据类型

参数名：变量名

方法体：就是执行功能的代码

Return：结束方法

返回值：就是方法执行的结果，由return带给调用者

写好一个方法必须明确：返回值类型和参数类型

方法的执行特点是：

方法不调用不执行，main方法是jvm调用的

方法和方法之间是平级关系不能嵌套使用

方法定义的时候参数列表用逗号隔开

方法调用的时候不用再传递数据类型

如果有明确的返回值，一定要return带回一个值

 

有明确返回值的调用：单独调用没有意义

输出调用

赋值调用：

无明确返回值的调用：只能单独调用，其他两种调用报错

 

方法重载：在同一个类中，方法名相同，参数列表不同。与返回值类型无关       

参数列表不同：参数类型或者参数个数不同        

特点：与返回值类型无关，只看方法名和参数列表，在调用时虚拟机根据参数列表的不同来区分同名方法。

 

StringBuffer和String的区别

String类是字符串常量，是不可更改的常量。只可以重新创建对象然后赋值，旧的值被垃圾回收机制回收，因此在执行效率上，要比Stringbuffer慢。

 

而StringBuffer是字符串变量，它的对象是可以扩充和修改的。

Stringbuilder与Stringbuffer的区别，

前者是非安全线程，后者是安全线程，都是字符串变量，都是可改变的对象，他们对字符串进行操作时，实际上是在一个对象上操作的，不像String一样创建一些对象进行操作，所以速度就快一些。

操作数据量少用String,单线程操作字符串缓冲区下操作大量数据用StringBuilder，多线程操作字符串缓冲区下操作大量数据用Stringbuffer

 

String类下的常用方法：

toUpperCase方法返回一个字符串，该字符串中的所有字母都被转换为大写。

toLowerCase方法返回一个字符串，该字符串中的所有字母都被转换为小写。

Concat方法返回字符串值，该值包含了两个或者多个提供的字符串连接值，在原有的字符串后面追加一个新的字符串。

Search方法返回与正则表达式查找内容匹配的第一个字符串的内容的位置。

indexOf方法放回String对象内第一次出现子字符串位置，如果未找到的话则返回-1.

lastindexOF方法返回String对象中字符串最后出现的位置，如果没有匹配值的话，则返回-1.

Substr方法返回一个从指定的位置开始的指定长度的子字符串。

 

变量：就是在程序的执行过程中，其值是可以在一定范围内发生改变的量。

变量的组成规则：

A：必须对其进行限定

B：变量名

C：初始化值

数据类型 变量名 = 初始化值 ；

字符串：

字符串是常量，一旦被赋值就无法被改变

 

运行时异常:能正常编译，运行时异常；    一般异常：编译报错

 

String 类包括的方法可用于检查序列的单个字符、比较字符串、搜索字符串、提取子字符串、创建字符串副本并将所有字符全部转换为大写或小写

 

集合：

 

集合类型主要有3种:set(集)、list(列表)和map(映射)。

 

1. （排列顺序）Set实现的基础是Map(HashMap);list集合中允许有多个相同的元素。

2. (过滤重复字段)Set中的元素是不能重复的（允许有多个相同的元素），如果使用add(Object obj)方法添加已经存在的对象，则会覆盖前面的对象

set集合输出的数据的顺序是随机的。

 

在集合内元素类型确定的时候可以使用foreach循环。

 

1、List,Set都是继承自Collection接口

2、List特点：元素有放入顺序，元素可重复 ，Set特点：元素无放入顺序，元素不可重复

（注意：元素虽然无放入顺序，但是元素在set中的位置是由该元素的HashCode决定的，其位置其实是固定的）

3、List接口有三个实现类：LinkedList，ArrayList，Vector ，Set接口有两个实现类：HashSet(底层由HashMap实现)，LinkedHashSet

集合的实例需要用实现类（ArrayList HashSet等）来实现。

Map的实现类：

 

 

集合的使用步骤:

A:创建集合对象

B:创建元素对象

C:把元素添加到集合

D:遍历集合

        三小步：a：通过集合器对象获取迭代器对象

b：通过迭代器对象的hasNext（）方法判断是否有元素

c：通过迭代器对象的next（）方法获取元素并移动到下一个位置

 

迭代器：对容器中的元素进行遍列，每次取出一个元素，然后对元素进行操作。

 

 

 

IO流：

按流向分：

输入流：向程序中输出数据

输出流：由程序输出程序

 

按数据类型分：

字节流：处理的数据以字节为单位

字符流：处理的数据以字符为单位

 

字符流有两个抽象类：Writer：输出流    Reader：输入流

字节流有两个抽象类：InputStream:输入流 OutputStream：输出流

 

File 功能：

A：创建功能

B：删除功能

C：重命名功能

D:判断功能

E:获取功能

F:高级获取功能

G:过滤器功能

 

多线程

程序：某段代码

进程：代码运行之后，动态执行，从开始到结束就是进程。正在进行中的程序。其实进程就是一个应用程序运行时的内存分配空间。

线程：cpu调度和分配的基本单位。 其实就是进程中一个程序执行控制单元，一条执行路径。进程负责的是应用程序的空间的标示。线程负责的是应用程序的执行顺序。

※jvm在启动的时，首先有一个主线程，负责程序的执行，调用的是main函数。主线程执行的代码都在main方法中。

当产生垃圾时，收垃圾的动作，是不需要主线程来完成，因为这样，会出现主线程中的代码执行会停止，会去运行垃圾回收器代码，效率较低，所以由单独一个线程来负责垃圾回收。

垃圾回收机制是独立的由另外一个非主线程的线程运行。

 

随机性的原理：因为cpu的快速切换造成，哪个线程获取到了cpu的执行权，哪个线程就执行。

 

返回当前线程的名称：Thread.currentThread().getName()

 

线程的名称是由：Thread-编号定义的。编号从0开始。

线程要运行的代码都统一存放在了run方法中。

 

线程要运行必须要通过类中指定的方法开启。start方法。（启动后，就多了一条执行路径）

start方法：1）、启动了线程；2）、让jvm调用了run方法。

 

创建线程的第一种方式：继承Thread ，由子类复写run方法。

步骤：

1，定义类继承Thread类；

2，目的是复写run方法，将要让线程运行的代码都存储到run方法中；

3，通过创建Thread类的子类对象，创建线程对象；

4，调用线程的start方法，开启线程，并执行run方法。

 

因为实现Runnable接口可以避免单继承的局限性。

 

线程状态：

被创建：start()

运行：具备执行资格，同时具备执行权；

冻结：sleep(time),wait()—notify()唤醒；线程释放了执行权，同时释放执行资格；

临时阻塞状态：线程具备cpu的执行资格，没有cpu的执行权；

消亡：stop()

 

多线程状态：

新建（New）状态-就绪（Runnable）状态-运行（Running）状态-阻塞状态-死亡状态

 

静态代理：

1：目标类和代理类要实现相同的接口。

2：代理类中药持有被代理对象的引用。

3：要将目标类的实例注入到代理类中被代理对象的引用上。

 

死亡状态：外部干预终止线程的方法

1：需要定义一个标识，用于终止线程。

2：在该线程体中使用这个标识。

3：提供对外改变该标识的方法。

 

 

 

 

 

数据库

将数据以表的形式保存到数据库中，然后通过工具使用数据。

Sql关键字执行顺序：从先到后分别为：

form，On 连接关键字，where，group by，聚合函数，having，select，distinct，order by

 

UPDATE sys_user SET user_name='cai1' WHERE id = 8;      //修改

DELETE FROM sys_user WHERE id=12; //删除

INSERT sys_user (NAME,user_name,pass_word,sex,phone)

VALUES('菜007','c02','1234567','01','12345678999');     //增加

SELECT name,user_name,sex FROM sys_user;   //查询部分字段

SELECT * FROM sys_user;      //查询表中的所有数据

SELECT id AS'编号',NAME AS '姓名' FROM student AS s; //查询时指定别名（as） as可省略写成空格 ；在多表查询时经常使用到表的别名

SELECT t.id FROM sys_user t; //查询指定列

SELECT t.* FROM sys_user t WHERE t.sex = '00' AND t.age = 10;    //过滤性别为00和年龄为10的数据（where的用法）

DELETE FROM sys_user WHERE id in(1,3); //删除id为1和id为3的数据

DELETE FROM sys_user WHERE id not in(1,3); //删除除了id为1和id为3的以外的所有数据

SELECT name,user_name,sex,'java课程'AS '名称' FROM sys_user; //在查询sys_user表时添加一个常量列

ALTER TABLE sys_use ADD chengji INT; //在表sys_use中加一列成绩，数据类型为INT

INSERT  INTO sys_use VALUES ('58','老赵','男','1班',100)       //添加一整行数据用关键字INSERT  INTO，并可以省略表头的书写

 

 

table1 table2

 

 

数据库基本的查询方式：

 

子查询： SELECT t2.* FROM t_student t2 WHERE t2.class_id in (SELECT t1.id FROM t_class t1 WHERE t1.class_num in('001','002'));    //查询出来的结果当成条件使用，放在in后面作为条件使用

 

嵌套查询 ： SELECT t1.id FROM （SELECT * FROM t_student WHERE sex = '00'）t1  WHERE t1.age>10;            //查询出来的结果当成范围使用，放在form后面

 

 

连接查询：

 

 

内连接：

SELECT t1.*，t2.class_num,t2.class_name FROM t_student t1,t_class t2 WHERE t1.class_id = t2.id //把两张有关联的表合并为一张新表，相同的部分展示，无关联的部分不展示

explorer

外连接：

（返回包括左表中的所有记录和右表中联结字段相等的记录 ）

左外连接 SELECT t1.*，t2.class_num,t2.class_name FROM t_student t1 LEFT JOIN t_class t2 ON t1.class_id = t2.id; //左表所有数据都会显示出来，而右表只显示符合查询条件的部分  以左表为基础，右表中则返回为null

（返回包括右表中的所有记录和左表中联结字段相等的记录）

右外连接 SELECT t1.*，t2.class_num,t2.class_name FROM t_student t1 RIGHT JOIN t_class t2 ON t1.class_id = t2.id; //右表所有数据都会显示出来，而左表只显示符合查询条件的部分  以右表为基础，左表中则返回为null

全连接   SELECT t1.*，t2.class_num,t2.class_name FROM t_student t1 FULL JOIN t_class t2 ON t1.class_id = t2.id ;}         //mysql不支持 互相查询，没有匹配的值得时候，则会在另外一个表中显示为null

等值连接   INNER JOIN  并不以谁为基础，只显示符合条件的数据 ，只返回两个表中联结字段相等的行

交叉连接 SELECT t1.*，t2.class_num,t2.class_name FROM t_student t1 CROSS JOIN t_class t2 ON t1.class_id = t2.id;           //结果和内连接一样，但是过程不一样 

 

联合查询   UNION 合并两个查询结果为一个合集

 

自连接查询  SELECT * FROM t_dep t1 LEFT JOIN t_dep t2 ON t1.pid=t2.id;   //同一张表连接查询

 

SELECT DISTINCT(DEPART) FROM teacher t;   //用于去掉重复的数据的，只能针对某一个字段使用

 

排序函数：SELECT * FROM t_student ORDER BY age DESC,class_id ASC;            //按照年龄大小升序，班级id降序 前面的优先级较高，越往后优先级越低

分组函数：SELECT class_id,COUNT(id) FROM t_student GROUP BY class_id HAVING class_id in(1,3); //分组查询   追加条件时要用HAVING,用法和WHERE一样 查询班级id为1和3的所有班级

 

 

分页函数：SELECT * FROM t_student LIMIT 0,3; //查询前三条数据     {前面（0）动态赋值，后面数据不变，分页原理}

 

 

 

 

 

 

 

 

JDBC 连接数据库并操作数据库的标准，提供大量的接口。

 

 

 

 

 

 

JDBC的操作步骤

加载驱动程序，将驱动程序配置到classpath中

连接数据库，通过Connertion接口和DrverManager类完成。

操作数据库，通过Statement、PreparedStatement、ResultSet三个接口完成

关闭数据库 开发中资源有限，操作完之后必须关闭

 

 

 

数据库事务有四个特性，

数据库的四个特性为ACID，既原子性（Atomicity），一致性（Consistency），隔离性（Isolation），持久性（Durability）。

原子性，整个事务是不可分割的，要么全部执行，要么全部不执行；

一致性，事务的执行结构也要与业务的逻辑保持一致；（事务执行的结果必须是使数据库从一个一致性状态变到另一个一致性状态）

隔离性，多个事务之间隔离开来，互不影响；

持久性，一旦事务执行完毕，执行后的结果会永久的保存下来。

 

 

视图：视图是虚表，是从一个或几个基本表（或视图）中导出的表，在系统的数据字典中仅存放了视图的定义，不存放视图对应的数据。

 

作用：多对一或者一对多，多对多的话通过一张中间表（视图）转换为一对多或者多对一。而且查询效率会提高，不再编译整条语句，只编译剩下的语句。

 

函数：过程，相当于程序中的一个代码块。可以进行循环语句的构建。

数据库中的if语句： if NOW()>STR_TO_DATE('2016-07-01','%Y-%m-%d') THEN

DELETE FROM sys_user;

END IF;

 

执行数据库中的函数：CALL proc_test();

 

数据库中while循环插入100条数据。（先判断再执行）

BEGIN

DECLARE i INT;     //声明一个int变量

SET i=0;        //赋值

 

WHILE i<100 DO           //do执行

  

INSERT INTO sys_user(name) VALUES (CONCAT('菜',i));    //插入数据

SET i=i+1;                  //自增

END WHILE;                      //结束循环

 

END

 

 

 

数据库中repeat循环插入100条数据（先执行再判断）

REPEAT

  INSERT INTO sys_user(name) VALUES (CONCAT('菜',i));

  SET i=i+1;

  UNTIL i>=100

  END REPEAT

 

数据库中loop循环插入100条数据（最常用的方式，使用方式比较灵活）

loop_test:LOOP

IF i>=100 THEN

LEAVE loop_test;

END IF;

INSERT INTO sys_user(name) VALUES(CONCAT('菜',i));

SET i=i+1;

END LOOP;

 

 

Tomcat 是符合JAVAEE标准的一个最小web容器

 

 静态 web服务插件 web服务器 文件系统 web容器  

 动态   web容器   web服务器 文件系统

 

 

 

javaweb开发 两个组件 javabean 和 servlet

必须是私有属性和set，get方法  必须无参的构造方法，可省略

所有的javabean都必须放在同一个包下。

优点：将html和java代码分开，方便了开发和维护，  将常用的程序写成javabean可减少重复代码的编写 。

 

 

 servlet:处理和响应请求的作用

 

 

 

 

 

html组件的书写方法：

 

<form action= "http://127.0.0.1:8080/web_lesson1/test" method="post">

    <!-- 文本框 -->

            文本框：<input type="text" name="username"value= ""/><br/>

    <!-- 密码域  -->

    密码域:<input type="passwprd"name="password"value=""/><br/>

         <!-- 单选框 -->

           单选框<input type="radio"name="r"value="1">是

          <input type="radio"name="r"value="0">否<br/>

          <!-- 复选框 -->

          复选框:<input type="checkbox"name="c"value="01">这是第一个选项

          <input type="checkbox"name="c"value="02">这是第二个选项

          <input type="checkbox"name="c"value="03">这是第三个选项<br/>

       <!-- 大文本域 -->>   

     大文本域:<textarea name="ta"cols="10"row="10"></textarea><br/>

   <!-- 文件域 -->

   <!-- 文本域:<input type="file" name="f"> -->

   <!-- 下拉列表 -->

       单选 下拉列表：<select name="se">

   <option value="0">我是一个人</option>

   <option value="1">我是一个神</option>

   <option value="2"selected="selected>我是一个仙</option>

   <option value="3">我是一个兵</option>

   <option value="4">我是一个选手</option>

   </select></br>

    多选下拉列表：<select name="se"multiple="multiple"size="5">

   <option value="0">我是一个人</option>

   <option value="1">我是一个神</option>

   <option value="2">我是一个仙</option>

   <option value="3">我是一个兵</option>

   <option value="4">我是一个选手</option>

   </select></br>

    </form>

 

 

404 资源找不到

405 找不到对应的方法

500 执行的方法出错

 

servlet 生命周期

 

加载Servlet：web容器负责加载servlet，当web容器启动或者第一次使用这个Servlet的时候，容器会负责创建Servlet实例，但是用户必须通过部署描述符（web.xml）指定Servlet 的位置。成功加载之后立即，web容器会通过反射的方式对servlet进行实例化。

 

初始化：当一个servlet被实例化后，容器将调用init()方法初始化这个对象，初始化的目的是为了让servlet对象在处理客户端请求前完成一些初始化工作。

 

处理服务：当有请求提交时，servlet将调用service（）方法（常用的是doget（）或dopost）进行处理。将封装的request对象传到servlet。

 

销毁：当web容器关闭或者检测到一个servlet要从容器中被删除时，会自动调用destory方法以释放掉该实例所占用的资源。

 

卸载：当一个servlet调用完destory（）方法后，此实例会被垃圾回收器回收。

 

容器赋值叫注入

servlet的作用：响应和处理请求 转发或者重定向其他地方而不响应。

重定向：只能写绝对路径。

转发：用responce对象（request），由web进行封装。

任意一个线程都可以访问servlet，post安全，get不安全，推荐使用前者。

 

 

 

jsp(java server page) 创建动态web内容的技术

客户端发送http请求给jspservlet，分析请求查找a.jsp，然后javaservlet读取文件，接着jspservlet翻译jsp中的内容，翻译为servlet，a.java,然后编译为 .class文件，由类加载器加载编译，执行servlet实例，返回客户端响应

 

 

 

 

 

 

 

 

 

 

 

 

 

获取servlet转发过来的数据，通过EL表达式去获取。  表达式写法：${    }

 

 

js小脚本（用于展示数据的）

静态请求，不是对文件进行请求

<%

声明变量

int = 0;

 

%>

 

 

<%=

输出一个结果

int = 0;

%>

 

 

 

<%!

书写方法(可定义无参或者有参的方法)

public String test(){

system.out.print("test")

return "test";

}

class A{

public String test_A(){

return "test";

    }

    }

%>

 

jsp 注释

<!--   -->    显示的注释

<%--   -->    隐示的注释

 

jsp的九大内置对象（java小脚本里可以使用，部分在其他地方也可以使用）

可直接使用，由容器进行实例化。不需要预先声明就可以在脚本代码和表达式中随意使用。

request            请求对象　      类型 javax.servlet.ServletRequest        作用域 Request
response          响应对象        类型 javax.servlet.SrvletResponse       作用域  Page
pageContext    页面上下文对象     类型 javax.servlet.jsp.PageContext      作用域    Page
session            会话对象        类型 javax.servlet.http.HttpSession       作用域    Session
application   应用程序对象 类型 javax.servlet.ServletContext          作用域    Application
out                   输出对象      类型 javax.servlet.jsp.JspWriter             作用域    Page
config              配置对象       类型 javax.servlet.ServletConfig            作用域    Page
page               页面对象       类型 javax.lang.Object                            作用域    Page
exception        例外对象       类型 javax.lang.Throwable                     作用域    page

四个作用域（用于传递值）都能用el表达式获取值。（可直接指明作用域）

pageContext, 一个页面  (page里的变量没法从index.jsp传递到test.jsp。只要页面跳转了，它们就不见了。)优先级最高，范围最小

request, 一次请求(request里的变量可以跨越forward前后的两页。但是只要刷新页面，它们就重新计算了。)

session,一次会话（浏览器关闭则无效） 存储用户信息

session和application里的变量一直在累加，开始还看不出区别，只要关闭浏览器，再次重启浏览器访问这页，session里的变量就重新计算了。

Application，跟web容器生命周期保持一致  优先级最低，范围最大

 

优先级：范围越大优先级越低。

 

 

可视化视图

视图模型控制器分离

Model :javabean（业务逻辑与业务顺序）

Controller:service(逻辑处理)和控制层(跟视图做数据交换，搬运和转发数据，)（控制器，负责程序的流程控制），接收到用户请求，根据业务逻辑执行情况，返回响应的结果。

View：视图(显示逻辑)将数据按照用户的要求显示出来。

Mvc的思想

 

 

 

 

 

 

 

 

 

 

 

 

好处：各司其职。

代码可重复使用。

Servlet：（1）能够接受所有用户的请求，（2）能根据请求的不同，调用不同的处理（javabean）

 

HTML：

元素:从一个标签开始到一个结束，这之间所有的内容。

属性：在标签中写的内容

标签：w3c制定的，  <   >  都需要成对的出现。

正文中的标签都是用<h1><h2>，从h1到h6文字显示内容是越来越小，等表示的，放在     <body>这是一个标题</body>     中，段落标签用

<p>这是一段文本内容</p> 表示，会自动换行，  

<b>这是一段文本</b>：加粗文本内容   

<big>这是一段文本内容</big>：加大字体    

<small>这是一段文本内容</small>：缩小字体

table

布局的标签

表格<table  border=”1” > <tr>  <td>ce111</td>  </tr></table>       t r: 行  td: 单元格

<td colspan=”2”></td> 单元格长度为2，<td rowspan=”2”></td> 单元格宽度为2.

<th>姓名</th>： 横行显示 表头  

列表：有序列表，无序列表，自定义列表。

无序列表<ul>   <li> </li>   <li> </li>   <li></li> <ul>

有序列表<ol>    <li></li>   <li></li>   <li></li> <ol>

自定义列表<dl>  <dt>< img src=”./catch.png”  alt=”这是一张图片” height=”150” width=”200”>  </img>  </dt>  <dd>这是描述信息</dd>    <dt>这是一个图片</dt>  <dd>这是描述信息</dd>   <dt>这是一个图片</dt>  <dd>这是描述信息</dd>    </dl>   dt和dd为一组完整的标签

表单

以上着重记忆

<li><a href=”http://baidu.com” target=”_blank”> 这是个超链接</a></li>  在新选项卡中打开百度  

<a  a href=”#a4”> 指向a4</a>  用来定位页面元素的。

 

 

Html 中用于布局的元素

<span></span>                <div></div>

 

 

<html

<head>

<titic></titic>

<style type="text/css">

<!-- 标签选择器   -->三种css中基本的选择器

div{         

 

  }

 

（id选择器）#div1{         

 

  }

（类选择器）.div_1{         

 

  }

(属性选择器) [title]{

 

}

[title=1]{

 

}

 

</style>

 

</head>

<body>

<div  id=”div1” class=”div_1”  style="color:blue;">

<span>这是个标签</span>

<span style=”color:red:font=size:32px”>这是个span标签！</span>

<div style=”color:blue;”></div>

</body>

</html>

Css的作用：

背景，颜色，

 

<html

<head>

<titic></titic>

<style type="text/css">

.content{  

Height:700px;

Width:700px;

Background-image: url(“.catch.png”);

Background-repeat:repeat;

}

</style>

<body>

<div class=”content”>

 

</div>

</body>

</html>

 

 

 

 

 

 

 

<html

<head>

<titic></titic>

<style type="text/css">

.content{  

Height: 100px;

Width: 100px;

Background-image: url("./catch.png");（添加图片）

Background-repeat:repeat;（覆盖，重复）

Background-position:50%  50%;(偏移量)

Border-width:1px;

Border-color:red;

Border-style:solid;

Border-radius:50%;(圆形)

Border-top-left-radius:50px;(切割左上角为圆角)

}

.content.text{    

font-family:"宋体";(字体类型)

font-size:22px;（字体大小）

font-weight:bolder;（字体粗细）

font-style:normal;（字体样式）

color:red;（字体颜色）

vertical-align:middle;(字体对齐方式)

}

 

</style>

<body>

<div class="content">

<span class="text">这不是个span标签</span>

 

</div>

</body>

</html>

 

 

 

<html

<head>

<titic></titic>

<style type="text/css">

.box1,.box2{

Height:200px;

Width:200px;

}

.box1{

background-color:blue;

Margin-bottom:32px;

}

.box2{

background-color:red;

Margin-top:32px;

}

 

.box1 .subbox1{

height:50px;

width:50px;

background-color:black;

margin-top:50px;

}

 

</style>

<body>

<div class="box1"></div>

<div class="box2"></div>

</body>

</html>

 

 

 

解决浏览器兼容问题

加上相应的标识符 火狐 -moz- 谷歌 -webkit-  欧朋 -o-

 

 

<html>

<head>

<title></title>

</head>

<body>

<script type=”text/javascript”>

Document.write(“这是用javascript写入的内容”)；

</script>

 

</body>

</html>

 

 

 

Js系统的讲解

 

匿名函数：

Var test2 = function(i){

Alert(i);

}

Test2(2);

 

(function(i){

Alert(i);

})(1);

 

 

Function test1(){

 

}

 

Var fun = function test(){

Alert(1);

}

Var test1 = new function(‘i’,’return i;’);

Alert(typeof(fun))；

 

内层函数可以调用外层函数的所有的变量，即便是外层函数执行完毕，内层函数依然可以调用外层函数的变量。

 

setTimeout(function(){

Alert(1);

},5000);

//定时5秒后刷新一遍，输出1

 

Function testClosure(){

Var str = “这是一个字符串”;

Var inner = function(){

Alert(str);

}

Return inner;

}

Var i =testClosure();

i();

 

闭包官方解释：

一个拥有许多变量和绑定了这些变量的环境表达式，因而这些变量也是表达式的一部分。

闭包的特点：

1.作为一个函数变量的一个引用，当函数返回时，即处于激活状态

2.一个闭包就相当于函数返回时，没有释放资源的栈区。

3.闭包函数不会对全局变量造成污染。

 

Function test1(){

I=1;

}

Function test2(){

Alert(1);

}

 

Test1();

Test2();

 

 

Var i = 0;

(function(k){

K=1

})(i);

 

 

Jquery里的各种选择器：

//id选择器

alert($("#d1").get(0));

//类选择器

$(".div1");

//标签选择器

$("div");

//属性选择器

$("[attr]");

$("[attr=1]");

//选择器混用

$("div[attr]");

$("div[attr=1]");

//子选择器

$("ul li:first-child");

$("ul li:last-child");

$("ul li:nth-child(2)");

 

 

 

 

 

 

 

框架

hibernate主键 八种生成策略：最常用的为红色

 

Identity  mysql数据库/sql server数据库

Squence  oracle数据库中使用sequence生成主键

Native  几乎适用于所有数据库 自动识别，然后匹配第一或者第二种策略（数据库主键设置为自增）数据库维护主键

Uuid.hex 由hibernate进行维护、生成一个32位随机字符串充当主键

Foreign 使用外部表字段作为hibernate主键

Uuid.string  由hibernate进行维护、生成一个32位随机字符串充当主键

Assigend （自动维护主键，其他的即使自己手动赋值也会被覆盖）

Increment  对long,short或int的数据列生成自增长主键

 

 

 

 

 

一、hibernate的优缺点

优点：移植性好

提高开发效率

轻量级，侵入性较小

解决了阻抗不匹配的问题

缺点：适合操作单个对象，不适合批量操作多个对象

不适合特定的数据库操作

不适合操作关系复杂的对象

 

 

 

二、hibernate使用步骤

1、新建java工程

2、添加hibernate相关jar包

3、创建hibernate配置文件hibernat.cfg.xml

4、创建实体类

5、创建实体类的映射文件

6、将实体类映射文件加入到hibernate.cfg.xml配置文件中

 

 

 

五个核心接口的用法，查询、缓存

Configuration  读取和加载配置文件并启动hibernate

SessionFactory  存储数据库的连接信息以及初始化的配置信息（每一个数据库对应一个sessionfactory）

Session 接口负责执行被持久化对象的CRUD操作

Transcation 控制事务的（手动控制）

Query 用来提供查询的

 

 

Hibernate里对象的三种状态：

1、瞬时状态对象   在数据库中没有与之对应的记录   没有被session纳入管理

2、持久状态对象   在数据库中有与之对应的记录  纳入了session的管理

  当对象发生变化时，会自动同步到数据库中

3、游离状态对象   在数据库中有与之对应的记录  没有被session纳入管理

 

 

Hibernate的查询

1.标准化对象查询（Criteria）

2.Hibernate的语句查询（HQL语句）使用Query接口

3.原生的sql语句查询（使用SqlQuery接口）

4.外置命名查询（类似于mybatis/ibatis）使用Query接口

 

 

1 标准化对象查询

*以对象的方式进行查询，将查询语句封装成对象。

 

2-1 HQL语句查询中实体对象查询

*如果首次查询使用Query接口中的iterate（）方法进行查询，会发出N+1条sql语句，

--首先发出一条sql语句查询对象的主键集合

--根据主键到数据库中去进行查询，会发出N条查询语句

*如果不是首次查询使用Query接口中的iterate（）方法进行查询，可能会发出N+1条sql语句，

--首先发出一条sql语句查询对象的主键集合

--根据主键到缓存列表中进行查询，如果缓存列表中没有与之匹配的记录，则会发出一条对应的sql语句去数据库中进行查询Query接口中list（）方法与interate（）方法的区别：

相同点：都会在查询结束后把查询出来的结果放到一级缓存中。

不同点：iterate（）使用缓存中的数据，list（）方法不使用缓存中的数据，每次都会去数据库进行查询

Iterate（）方法返回的是一个迭代器对象，list（）方法返回的是一个list对象集合。

*hql语句写法：

--hql语句是针对对象以及属性进行操作

--把sql语句中的表名替换为对象名，SQL语句中的字段名替换为属性名

注:hql语句中没有select*这种写法

*查询条件拼接方法：

--可以采用字符串拼接的方式把查询条件直接拼接在hql语句上

--可以采用通配符？来传递参数进行查询（索引是从0开始）

--可以采用：参数名来传递参数进行查询

注：分页参数与mysql中limit函数传递的参数一致（起始位置，分页大小），分别用setFirstResult（）与setMaxResult（）来表示。

 

2-2 HQL语句中的简单属性查询

*单一属性查询

*多个属性查询，返回的集合元素是对象数组（Object[]）,数组的长度与查询的属性个数一致，数组中的元素与查询的属性值一一对应

*可以采用构造函数的方式把查询出来的属性值构造成一个实体对象。

 

2-3 原生SQL语句查询

*参见SimpleNativeQueryTest.java

 

2-4 外置命名查询：

*在任意映射文件中采用<query>标签来定义hql语句，或者采用<sql-query>标签来定义sql查询语句，<query>标签与<sql-query>标签要写在<class>外，具体格式参见SysUser.hbm.xml文件。

*在程序中采用getNamedQuery方法获取定义的HQL或SQL语句，并返回Query对象，用Query接口中的List（）方法或者iterate（）方法获取查询的结果集（对象集合），参见SimpleNameQueryTest.java

 

 

计算机存储单位：

1B（byte）=8b（bit位）

1KB = 1024B

1MB = 1024KB

1GB = 1024MB

1TB = 1024GB

1PB = 1024TB

1EB = 1024PB

1ZB = 1024EB

1YB = 1024ZB

 

 

Hibernate一级缓存：

*与session的生命周期一致，所以也叫session级缓存。（对数据库的一次访问）

*一级缓存中存放的只能是对象或者对象集合，属性查询不会保存到一级缓存中去

*用session接口进行的CRUD（增删改查）操作，其操作的对象都会保存到一级缓存中

*不可配置，可以通过clear（）或evict（）方法进行管理，防止内存溢出

注：如果数据量特别大，建议放弃hibernate操作，采用jdbc进行操作

 

 

Hibernate二级缓存：

*二级缓存也叫SessionFactory级缓存，二级缓存可以被所有的session共享

*二级缓存的生命周期和SessionFactory生命周期一致，SessionFosctory可以管理二级缓存

 

*二级缓存的配置和使用（此处以EhCache为例）

--开启二级缓存（默认就为开启状态），修改hibernate.cfg.xml配置文件

<property name=”hibernate.cache.use_level_cache”>true</property>

--指明缓存产品提供商（hibernate默认实现了一套基于hashtable的一套缓存产品，该产品仅用于开发阶段，不适用生产阶段）

修改hibernate.cfg.xml配置文件

<property name=”hibernate.cache.region.factory_class”>org.hibernate.cache.EhcacheRegionFactory”</property>

--将ehcache.xml配置文件拷入工程中，配置缓存策略（可以使用全局缺省配置，也可以指定某个对象进行单独的缓存策略配置）

--需要指明使用二级缓存的类（两种方式指明）：

1，在该类对应的映射文件中，采用<cache>标签来配置，<cache>标签位置位于<class>标签内，<class>开始标签的后边

2，在hibernate.cfg.xml配置文件中采用<class-cache>标签来配置，<class-cache>标签的位置位于<session-factory>标签内，所有的<mapping>标签之后

*二级缓存中存放的也是实体对象或者对象集合，不能是普通属性集合

 

 

hibernate查询缓存

*查询缓存是针对普通属性结果集进行缓存

对实体对象的结果集只缓存实体对象ID（主键）

*多个session可以共享查询缓存，与SessionFactory绑定

*查询缓存的生命周期,不确定,当关联的表发生修改时,那么查询缓存的生命周期结束

查询缓存的配置和使用:

*在hibernate.cfg.xml配置文件中启用查询缓存,

<property name="hibernate.cache.use_query_cache">true</property>

*需要指明缓存产品提供商，如果已经指明缓存产品提供商，就不需要额外配置，若没有指明二级缓存产品提供商，需要在单独指明查询缓存的缓存产品提供商

*还需要在程序中手动开启查询缓存,调用query.setCacheable(true);方法来启用

注：iterator()方法不支持查询缓存

 

 

Spring框架

 

轻量级的控制反转（IOC）和面向切面（AOP）的容器框架

初始化bean容器方法

第一种方式：读取本地文件初始化bean容器

 

第二种方式：读取ClassPath目录下的配置文件初始化bean容器

 

第三种方式：使用spring提供的监听器，借助web容器的全局方式

 

Spring容器可以管理任意一个类

 

注解标签（对代码比较有侵入性，比较方便，利于代码书写）

 

Spring容器中注册管理bean的标签

一 用来注册bean的，需要在spring配置文件中启用<context:component.scan>标签开启注解扫描

    @Componet(通用的组件注册注解标签)

@Repository(用于注册DAO层的类)

@Service(用于注册Survice层的类)

@Controller(用于注册Controller层的类)

 

 

 

 

用来管理bean之间的依赖关系，通过自动注入的方式实现bean的注入

 

@Autowrired(自动注入，通过bean的类型进行注入)

@Qualifer

@Resoerce(自动注入，通过bean的id进行注入)

 

 

二 @Configurition @Bean @Import

 

 

AOP面向切面编程

切面（Aspect）：一个关注点的模块化，在这个关注点横切与多个对象

连接点（JoinPoit）：程序中的某个特定的点

通知:（advice）：在切面上的某个特定连接点上执行的动作

切点（PointCut）：匹配连接点的表达式

 

AOP业务代码与关注点代码分离，好处？

关注点代码写一次即可；

开发者只需要关注核心业务；

运行时期，执行核心业务代码时候动态植入关注点代码；

 

通知的种类：

Before Advice：（前置通知）

After returning Advice：（返回后通知）

After Throwing A dvice：（抛出异常后通知）

After Advice：（后置通知）

Around Advice：（环绕通知）

 

声明事务的配置方式：

第一大类：支持当前事务

REQUIRED:支持当前事务，如果当前存在事务，就是用当前的事务，如果当前不存在事务，则开启一个新的事务。

MANDATORY：支持当前事务，如果当前存在事务，则使用当前事务，如果当前不存在事务，就抛出异常

SUPPORTS：支持当前事务，如果当前存在事务，则使用当前事务，如果当前不存在事务，就以非事务方式运行

 

第二类：不支持当前事务

NAVER：不支持当前事务，始终以非事务方式运行，如果当前存在事务，就抛出异常

NOT_SUPPORTED：不支持当前事务，始终以非事务方式运行，如果当前存在事务，则把当前的事务挂起

 

第三类：嵌套事务

NESTED：

 

 

 

 

 

Spring-mybatis

 

整合CRUD操作：三种方案

第一种方案：使用salSessionTemplate

第二种方案：使用映射器按照映射规则创建指定接口的实现类并放入spring容器中进行管理

第三种方案：批量按照映射规则生成指定接口的实现类并放入spring容器中管理，bear的id默认为该接口名称首字母小写

 

 

 

Spring  七 大模块

最基础的是spring core，所有模块都是基于这个模块进行的开发。

  Spring aop

  Spring web mvc：spring对于mvc的实现

  Spring orm：基于框架对于jdbc的实现

  Spring dao：

  Spring web:

  Spring context:

 

 

 

框架整合

Spring需要的包：

Core包

Bean

Context包

 

Tx标签组件对事物进行扩展

Test单元测试组件

Spring—aop

Spring—aspcet

Spring—orm仅仅针对hibernate，没有对没有batis进行整合

Mybatis的核心包

spring—jdbc

Mybatis—spring

Webmvc

 

 

Mybatis的包

Mybatis

Mysql—connector—java

 

Java.servlet.api

Java.servlet.jsp

 

Jstl

这个包

 

Commons—fileupload等 的一些工具类包

Log4j 一些工具类的包

 

 

初始化的配置信息

写配置文件时从spring开始写

 

 

建资源文件夹src main webapp            configs

四个配置文件 mvc_dispatcher spring-root

 后面被替代之后删掉  Mybatis_config 先配置数据库连接  datasource type POOLED 连接驱动 用户名 密码 连接地址   需要手动去写一个事务管理器 jdbc管理器

加载映射文件  <mapper resource=” com/yrrj/mapper/sysusemapper .xml“><mapper>

Spring容器初始化的三种方式 相当于启动spring容器

读取classclass   操作本地的某个资源文件  监听器执行某个构造函数完成，启动web容器的时候就会执行监听器 spring容器里的所有

 

整合mybatis的操作（替代mybatis主配置文件）

写在spring-root 里的

Bean id datasource class org.spring framework.......

Name driverclassname

Name url

Name username

Name password

上面的值下载一个资源文件中，前缀为jdbc

引入资源文件 context property placeholder  location =”classpath:config.properties”

 

bean sqlsessionfactory  org.mybatis.spring.sqlsessionfactorybean

Property  datasource  

整合mybatis-crud 操作

第一种方案：

整合sqlsession

使用构造器来注入

Bean id sqlsession class aqlsessiontemplate

Constructor-arg name sqlsessionfactory ref sqlsessionfactory  

 

第二种方案

映射文件中的映射，相当于执行sql语句

Bean id userdao class org..........mapper.mapperfactorybean

Property name mapperinter

 

第三种方案

 

 

 

 

配置事务管理器

Bean id datasourcetransactionmanager class

Property name data source ref datasource

 

声明事务第一种方式：开启事务注解驱动

Tx：annotation-drivern transaction-manager data....manager

 

声明第二种方式：通过切面配置

Tx:advice transaction-manager  data....manager

 

Tx method name”save”propagation required

               Insert

               Update

               Del

............

...........

.............

...........

Mvc-dispatcher.xml文件中

注册所有的controller，注册到spring webmvc容器中

扩充注解驱动

静态资源映射

配置视图解析器

 

 

 

Spring容器和 spring mvc 容器是父子关系，子容器可以访问父容器的任何资源，而父容器访问不到子容器的任何资源

所有的curd都是dispatcher去间接调用的

 

上传备注：这些笔记都是零零碎碎的，有需要的可以查一下知识点，算是很全的笔记了，我自己整理了很久。转载请联系博主：350267662，请勿盗取，手打上万字很辛苦的。