类

• 类和对象

类：类是模子，确定对象将会拥有的特征（属性）和行为（方法）
类的特点：类是对象的类型具有相同属性和方法的一组对象的集合
属性：对象具有的各种特征，每个对象的每个属性都拥有特定值
方法：对象执行的操作
类和对象的关系：类是抽象的概念，仅仅是模板，比如说‘手机’   对象是一个你能够看得到、摸得着的  
具体实体
类的重要性：所有java程序都以类class为组织单元 ，写面向对象的程序，必须先写一个类才会有对象
类：属性+方法
定义一个类的步骤：a. 定义类名  b. 编写类的属性    c. 编写类的方法

public class 类名 {
    //定义属性部分（成员变量）;
    属性1的类型   属性1；
    属性2的类型   属性2；
    ……. 
    属性n的类型  属性n;
    //定义方法部分;
    方法1；
    方法2;
    ……
    方法m;    
}
使用对象的步骤：
1. 创建对象：类名 对象名 = new 类名()；
2. 使用对象：引用对象的属性  对象名.属性     引用对象的方法： 对象名.方法名()
3. 成员变量：在类中定义，用来描述对象将要有什么，可以在本类的方法，或其他类的方法中使用，默认的  
成员变量值为0。
4. 局部变量：再类的方法中定义，在方法中临时保存数据，只能在定义它的方法中使用，java不会给局部  
变量赋予初始值，但是会给成员变量一个初始值。同一个方法中不允许有同名局部变量，而在不同方法中，  
可以有同名局部变量。
public class Telphone{
    变量类型  变量; //成员变量
    public 返回类型  方法(){
        变量类型  变量; //局部变量
    }
}
注：两类变量同名时，局部变量具有更高的优先级。

• 构造方法：1. 使用new+构造方法，创建一个新的对象。2. 构造方法是定义在java类中的一个用来初始化对象的方法，构造方法与类同名且没有返回值。

构造方法的语句格式：
//构造方法名与类名相同
public  构造方法名（）{
    //初始化代码
}
5. 当没有指定构造方法时，系统会自动添加无参的构造方法，初始化或默认执行的。
6. 当有指定构造方法，无论是有参、无参的构造方法，都不会自动添加无参的构造方法。
7. 构造方法的重载：方法名相同，但参数不同的多个方法，调用时会自动根据不同的参数选择相应的方法。
8. 构造方法不但可以给对象的属性赋值，还可以保证给对象的属性赋一个合理的值。

• 静态变量

Java 中被 static 修饰的成员称为静态成员或类成员。它属于整个类所有，而不是某个对象所有，即被类  
的所有对象所共享。静态成员可以使用类名直接访问，也可以使用对象名进行访问。当然，鉴于他作用的特  
殊性更推荐用类名访问。
使用 static 可以修饰变量、方法和代码块。
静态方法：与静态变量一样，我们也可以使用 static 修饰方法，称为静态方法或类方法。其实之前我们  
一直写的 main 方法就是静态方法。
注意”：1. 静态方法中可以直接调用同类中的静态成员，但不能直接调用非静态成员，可以通过创建类的  
对象，然后通过对象来访问非静态变量。
2. 在普通成员方法中，则可以直接访问同类的非静态变量和静态变量。
3.  静态方法中不能直接调用非静态方法，需要通过对象来访问非静态方法。
静态初始化块：静态初始化块只在类加载时执行，且只会执行一次，同时静态初始化块只能给静态变量赋值，  
不能初始化普通的成员变量。程序运行时静态初始化块最先被执行，然后执行普通初始化块，最后才执行  
构造方法，而且静态初始化块只在类加载时执行一次。

如何使用 Java 中的数组

1、 声明数组
语法：  数据类型[ ] 数组名 ; 或者 数据类型 数组名[ ]；
int[] scores;
double height[];
String[] names;
2、分配空间
int[] scores = new int[5];
3、赋值
scores[0] = 89;
4、另一种直接创建数组的方式，将声明数组、分配空间和赋值合并完成
int[] scores ={78,90,87,67};
等价于：int[] scores=new int[]{78,90,87,67};

使用 Arrays 类操作 Java 中的数组

• Arrays 类是 Java 中提供的一个工具类，在 java.util 包中。该类中包含了一些方法用来直接操作数组，比如可直接实现数组的排序、搜索等

1、 排序   语法：Arrays.sort(数组名); 注：按升序排列
2、 将数组转换为字符串   语法：Arrays.toString(数组名);
   可以使用 toString( ) 方法将一个数组转换成字符串，该方法按顺序把多个数组元素连接在一起，  
多个元素之间使用逗号和空格隔开
注：使用Arrays类时必须导入包：import java.util.Arrays;

• 遍历数组

public static void main(String[] args) {
  String[] hobbys = {"java","php","iOS"};
  for (int i = 0; i < hobbys.lenght; i++){
      System.out.println(hobbys[i]);//for循环输出数组元素
  }

  for (String hobby : hobbys){
      System.out.println(hobby);//foreach循环输出数组元素
  }
}

二维数组

• 所谓二维数组，可以简单的理解为是一种“特殊”的一维数组，它的每个数组空间中保存的是一个一维数组。

1、声明数组并分配空间
int[][] num = new int[2][3];//定义一个两行三列的二维数组
2、赋值
num[0][0] = 12;//给第一行第一列的元素赋值
3、处理数组
int[][] num = {{1,2,3},{4,5,6}};
//定位行
for(int i = 0; i <num.length; i++){
    //定位每行的元素
    for(int j = 0; j<num[i].lenght; j++){
          //依次输出每个元素
          System.out.println(num[i][j]);
    }
    //实现换行
    System.out.println();
}

方法的使用

• 无参无返回值方法的使用

public void show() {
    System.out.println("java基础语法精粹！");
}

• 无参带返回值方法的使用

public int calcSum() {
    int a = 5;
    int b = 12;
    int sum = a+b;
    return sum;
}

• 带参无返回值方法的使用

public void show(String name) {
    System.out.println("参数为:" + name + "!");
}

• 带参带返回值方法的使用

public String show(String name) {
    return 返回的参数为:" + name + "!";
}

面向对象的三大特性：封装、继承、多态

• 封装

一、概念：将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对  
隐藏信息的操作和访问
二、好处：a. 只能通过规定的方法访问数据   b. 隐藏类的实例细节，方便修改和实现
封装的实现步骤：
1. 修改属性的可见性，设为private
2. 创建getter/setter 方法，用于属性的读写
3. 在getter/setter 方法中加入属性控制语句，对属性值的合法性进行判断
注：通过某个方法调用封装在类的隐藏属性，就像我把不同颜色的糖果封装在看不见的盒子里，你只有通过  
我特定的方法才能拿出来某个颜色的糖果，你看不见糖果 ，而且你不通过我你拿不到糖果 这就是封装

• 继承

子类拥有父类的所有属性和方法，当然private修饰的无效，实现代码的复用
语法规则：class 子类  extends  父类
例： class Dog extends Animal {
    ……
}
注意：
方法的重写：如果子类对继承父类的方法不满意，是可以重写父类继承的方法的，当调用方法时会优先调用  
子类的方法，注意语法规则：返回值类型、方法名、参数类型及个数都要与父类继承的方法相同，才叫方法  
的重写。
继承的初始化顺序：1. 初始化父类再初始化子类  2. 先执行初始化对象中属性，再执行构造方法 
中的初始化
创建一个子类对象，先创建父类对象的属性并初始化，再执行父类的构造方法；然后再执行子类的属性  
并初始化，最后再执行子类的构造方法

• 多态

可以创建父类的引用指向子类的对象

字符串基础

可变字符串

String是不可变得，程序运行时会额外创建对象，当频繁操作字符串时，会额外产生很多临时变量。
因此考虑使用StringBuilder和StringBuffer。StringBuilder线程安全、StringBuffer性能略高，  
创建内容可变的字符串对象，应优先考虑StringBuilder。
例：StringBuilder str = new StringBuilder("java基础");
   System.out.println(str);

String 类常用方法

String str = "学习 JAVA 编程";
str.toLowerCase //将字符串转换为小写
str.charAt(1) //获取索引为1的字符
str.indexOf("JAVA") //查找子字符串’JAVA‘的位置，如果找不到则返回-1

char c = "编";
str.indexOf(c) //查找字符’编‘的位置

String[] arr = str.split(" ");
Arrays.toString(arr) //按空格把字符串拆分成一个数组

str.substring(3,7) //获取索引位置[3,7)之间的子串


“==” 和 equals() 区别:
==: 判断两个字符串在内存中首地址是否相同，即判断是否是同一个字符串对象
equals(): 比较存储在两个字符串对象中的内容是否一致

Java 中基本类型和字符串之间的转换

基本类型转换为字符串有三种方法：

1. 使用包装类的 toString() 方法
2. 使用String类的 valueOf() 方法
3. 用一个空字符串加上基本类型，得到的就是基本类型数据对应的字符串

   int c = 10;
   String str1 = Integer.toString(c);//方法1
   String str2 = String.valueOf(c);//方法2
   String str3 = c + "";//方法3

字符串转换为基本类型转换有两种方法：

1. 调用包装类的 parseXxx 静态方法
2. 调用包装类的 valueOf() 方法转换为基本类型的包装类，会自动拆箱

String str = "8";
int d = Integer.parseInt(str);//方法1
int e = Integer.valueOf(str);//方法2

基本类型和包装类之间的转换：

• 基本数据类型是不具备对象的特性的，比如基本类型不能调用方法、功能简单...，为了让基本数据类型也具备对象的特性， Java 为每个基本数据类型都提供了一个包装类，这样我们就可以像操作对象那样来操作基本数据类型。以Integer为例：

Integer a = new Integer(3);//定义Integer包装类对象，值为3
int b = a + 5;//将对象和基本类型运算

• 在 JDK1.5 引入自动装箱和拆箱的机制后，包装类和基本类型之间的转换就更加轻松便利了。

int i = 10;
Integer x = new Integer(i);//手动装箱
Integer y = i;//自动装箱

Integer j = new Integer(8);
int m = j.intValue();//手动拆箱为int类型
int n = j;//自动拆箱为int类型

Java中的集合框架

Java中的集合类：是一种工具类，就像是容器，储存任意数量的具有共同属性的对象

• 集合的作用

1. 在类的内部，对数据进行组织；
2. 简单而快速的搜索大数量的条目；
3. 有的集合接口，提供了一系列排列有序的元素，并且可以在序列中间快速的插入或者删除有关元素；
4. 有的集合接口，提供了映射关系，可以通过关键字（key）去快速查找到对应的唯一对象，而这个关键字  
可以是任意类型。
5. 集合是无序的

• 与数组的对比--为何选择集合而不是数组

1. 数组的长度固定，集合的长度可变
2. 数组只能通过下标访问元素，类型固定，而有的集合可以通过任意类型查找所映射的具体对象

• Java集合框架体系结构

• Collection接口、子接口以及实现类

Collection接口：
是List、Set和Queue接口的父接口
定义了可用于操作List、Set和Queue的方法-增删改查
-List接口及其实现类--ArrayList
  List是元素有序并且可以重复的集合，被称为序列
  List可以精确的控制每个元素的插入位置，或删除某个位置元素
  ArrayList---数组序列，是List的一个重要实现类
  ArrayList底层是由数组实现的

• 泛型

集合中的元素，可以是任意类型的对象（对象的引用）
如果把某个对象放入集合，则会忽略它的类型，而把它当做Object处理
泛型则是规定了某个集合只可以存放特定类型的对象
会在编译期间进行类型检查
可以直接按指定类型获取集合元素

• Map和HashMap

1. Map接口：
  Map提供了一种映射关系，其中的元素是以键值对（key-value）的形式存储的，能够实现根据key快速  
查找value
  Map中的键值对以Entry类型的对象实例形式存在
  键（key值）不可重复，value值可以
  每个键最多只能映射到一个值
  Map接口提供了分别返回key值集合、value值集合以及Entry（键值对）集合的方法
  Map支持泛型，形式如：Map<K,V>
2. HashMap类
  HashMap是Map的一个重要实现类，也是最常用的，基于哈希表实现
  HashMap中的Entry对象是无序排列的
  key值和value值都可以为null，但是一个HashMap只能有一个key值为null的映射（key值不可重复）

• tomcat服务器的目录结构：

/bin ：存放各种平台下启动和停止tomcat的命令文件，如startup.bat，shutdown.bat
/conf：存放tomcat的各种配置文件
/lib：存放tomcat服务器所需的各种jar文件
/log：存放在tomcat的日志文件
/temp：tomcat运行时用于存放临时文件
/webapps：当发布web应用时，默认会将web应用的文件发布到此目录中
/work：tomcat把由jsp生成的servlet放在此目录下

• Web应用程序

手工编写第一个web程序：
  1. 在WebApps创建项目目录
  2. 编写index.jsp
  3. 创建爱你WEB-INF目录
  4. 测试运行
WEB-INF目录结构
  1. WEB-INF是Java的WEB应用的安全目录。所谓安全就是客户端无法访问，只有服务端可以访问的目录。
  2. web.xml，项目部署文件。如：
<welcome-file-list>
       <welcome-file>haha.jsp</welcome-file>
  </welcome-file-list>
  3. classes文件夹，用以放置*.class文件。
  4. lib文件夹，用于存放需要的jar包。

• JSP简介

JSP全名为Java Server Pages，其根本是一个简化的Servlet设计，他实现了在Java当中使用HTML  
标签。JSP是一种动态网页技术，标准也是JavaEE标准。JSP与Servlet一样，是在服务器端执行的。
JSP页面元素构成：
  指令、表达式、小脚本、声明、注释、静态内容
JSP指令：
  1. page指令：通常位于jsp页面的顶端，同一个页面可以有多个page指令。
  2. include指令：将一个外部文件嵌入到当前jsp文件中，同时解析这个页面中的jsp语句。
  3. taglib指令：使用标签库定义新的自定义标签，在jsp页面中启用定制行为。

• JSP脚本

JSP脚本：在JSP页面中执行的Java代码。
  语法：<% Java代码 %>
JSP声明：在JSP页面中定义变量或者方法。
  语法：<%! Java代码%>
注：在<%! %>中声明的变量，是全局变量
       在<% %>中声明的变量，是局部变量
JSP表达式：在JSP页面中执行的表达式
  语法：<%= 表达式%>//注意：表达式不以分号结束
附注：
  - JSP最终是编译成Servlet来执行的，在编译前会生成一个Java类：
  - JSP声明<%！ %>会被用来生成成员变量，如int i=i+1; String str = "张三"; 
  - JSP脚本<% %>会被用来生成JSPService方法里面的方法代码, 包括局部变量声明。
  - JSP表达式也会被用来生成"输出到业务“的方法代码，例如out.print(“你好 + str）。

• JSP页面生命周期

用户发出请求index.jsp -> 是否是第一次请求？ (是-> JSP引擎把该JSP文件转换成为Servlet，生成字  
节码文件，并执行jspInit() ) 否? -> 生成的字节码文件 -> 解析生成，jspService()。
注：jspService()方法被调用来处理客户端的请求。对每一个请求，jsp引擎创建一个新的线程来处理  
该请求。如果有多个客户端同时请求该jsp文件，则jsp引擎会创建多个线程。每个客户端请求对应一个线程  
。以多线程方式执行可以大大降低对系统的资源需求，提高系统的并发量及响应时间，但也要注意多线程的 
编程带来的同步问题，由于该Servlet始终驻于内存，所以响应非常快。

• JSP内置对象

  内置对象简介：JSP内置对象是web容器创建的一组对象，不使用new关键字就可以使用的内置对象。如：
  <%
    int[] value = {60,70,80};
        for(int i:value){
            out.println(i);
        }
  %>
  内置对象常用的有：out、request、response、session、application（page、pageContext、  
exception、config）。
  缓冲区：Buffer，所谓缓冲区就是内存的一块区域用来保存临时数据。
  out对象：是jspWriter类的实例，是向客户端输出内容常用的对象。常用方法：
      1. void println() 向客户端打印字符串
      2. void clear() 清除缓冲区的内容，如果在flush之后调用会抛出异常
      3. void clearBuffer() 清除缓冲区内容，如果在flush之后调用不会抛出异常
      4. void flush() 将缓冲区内容输出到客户端
      5. int getBufferSize() 返回缓冲区以字节的大小
      6. int getRemaining() 返回缓冲区还剩余多少可用
      7. boolean isAutoFlush() 返回缓冲区满时，是自动请看还是抛出异常
      8. void close() 关闭输出流
get与post的区别：
  <form name="regForm" action="动作" method="提交方式">
</form>
表单有两种提交方式：get与post
  1. get：以明文的方式通过URL提交数据，数据在URL中可以看到。提交的数据最多不超过2kb。安全性  
较低但效率比post方式高。适合提交数据量不大，安全性不高的数据。比如：搜索、查询等功能。
  2. post：将用户提交的信息封装在HTML HEADER内。适合提交数据量大，安全性高的信息。比如：注册、  
修改、上传等功能。
request对象：
  客户端的请求信息被封装在request对象中，通过它才能了解到客户的需求，然后做出响应。它是  
HttpServletRequest类的实例。request对象具有请求域，即完成客户端的请求之前，该对象一直有效。  
常用方法：
  1. String getParameter(String name) 返回name指定参数的参数值
  2. String[] getParameterValues(String name) 返回包含参数name的所有值的数组
  3. void setAttribute(String,Object) 存储此请求中的属性
  4. void getAttribute(String name) 返回指定属性的属性值
  5. String getContentType() 得到请求体的MIME类型
  6. String getProtocol() 返回请求用的协议类型及版本号
  7. String getServerName() 返回接受请求的服务器主机名
response对象：
  response对象包含了响应客户请求的有关信息，但在jsp中很少直接用到它，它是HttpServletResponse  
类的实例。response对象具有页面作用域，即访问一个页面时，该页面内的response对象只能对这次访问  
有效，其他页面的response对象对当前页面无效。常用方法：
  1. String getCharacterEncoding() 返回响应用的是何种字符编码
  2. void setContentType(String type) 设置响应的MIME类型
  3. PrintWriter getWriter() 返回可以向客户端输出字符的一个对象（注意比较：printWriter与内  
置out对象的区别）
  4. sendRedirect(java.lang.String location) 重新定向客户端的请求
附：重定向与转发的区别
请求重定向：客户端行为，response.sendRedirect()，从本质上讲等同于两次请求，前一次的请求对象  
不会保存，地址栏的URL地址会改变。
请求转发：服务器行为，response.getRequestDispatcher().forward(req,resp)；是一次请求，转发  
后请求对象会保存，地址栏的URL地址不会改变。
  假如你去办理某个护照
  重定向：你先去了A局，A局的人说不归他们管，让你去B局，然后你自己退了出来，自己乘车去了B局。
  转发：你先去了A局，A局的人知道应该由B局的人管，但是他们没有把你退出来，而是让你坐一会，自己  
到后面办公室联系了B局的人，让他们办好后送过来。

• 什么是session

session表示客户端与服务器的一次会话
web中的session指的是用户在浏览某个网站时，从进入网站到浏览器关闭所经过的这段时间，也就是用户  
浏览这个网站所花费的时间
从上述定义中可以看出：session实际是一个特定的时间概念
在服务器的内存中保存着不同用户的session。

• session对象

session对象是一个jsp内置对象，在第一个jsp页面被装载时自动创建，完成会话期管理，从一个客户打开  
浏览器并连接到服务器开始，到客户关闭浏览器离开这个服务器结束，被称为一个会话。
当一个客户访问一个服务器时，可能会在服务器的几个页面之间切换，服务器应当通过某种办法知道这是一  
个客户，就需要session对象
session对象是HttpSession类的实例
session对象常用方法：
  long getCreationTime() 返回session创建时间
  public String getId() 返回session创建时jsp引擎为它设的唯一id号
  public Object setAttribute(String name,Object value) 使用指定名称将对象绑定到此会话
   public Object getAttribute(String name) 返回与此会话中的指定名称绑定在一起的对象，如果没  
有对象绑定在该名称下，则返回null
  String[] getValueNames() 返回一个包含此session中所有可用属性的数组
  int getMaxInactiveInterval() 返回两次请求间隔多长时间此session被取消（单位秒）

session的生命周期：
  1.创建 当客户端第一次访问某个jsp或者Servlet时候，服务器会为当前会话创建一个SessionId，每次  
客户端向服务端发送请求时，都会将此SessionId携带过去，服务端会对此SessionId进行校验。
  2.活动 
      某次会话当中通过超链接打开的新页面属于同一次会话
      只要当前会话页面没有全部关闭，重新打开新的浏览器窗口访问同一项目资源时属于同一次会话
      除非本次会话的所哟页面都关闭后再重新访问某个jsp或者Servlet将会创建新的会话。
        注意事项：注意原有会话还存在，只是这个旧的SessionId仍然存在于服务端，只不过再也没有客  
户端会携带它然后交予服务端校验。
  3.销毁 session的销毁只有三种方式：
      调用session.invalidate()方法
      session过期（超时）
      服务器重启

附：
Tomcat默认session超时时间为30分钟，社会自session超时有两种方式：
  1.session.setMaxInactiveInterval(时间)//单位是秒
  2.在web.xml配置
      <session-config>
      <session-timeout>
            10
      </session-timeout>
      </session-cnfig>

• application对象

application对象实现了用户间数据的共享，可存放全局变量
application开始于服务器的启动，终止于服务器的关闭
在用户的前后连接或不同用户之间的连接中，可以对application对象的同一属性进行操作。
在任何地方对application对象属性的操作，都将影响到其他用户对此的访问
服务器的启动和关闭决定了application对象的生命
application对象睡觉哦ServletContext类的实例

常用方法：
  public void setAttribute(String name,Object value)使用指定名称将对象绑定到此会话
  public Object getAttribute(String name) 返回与此会话中的指定名称绑定到一起的对象，如果没  
有对象绑定在该名称下，则返回null
  Enumeration getAttributeNames() 返回所有可用属性名的枚举
  String getServerInfo() 返回JSP（SERVLET）引擎名及版本号

• page对象

  page对象就是指当前JSP页面本身，有点像js中类的this指针，它是java.lang.Object类的实例。  
常用方法：
    class getClass() 返回此Object的类
    int hashCode() 返回此Object的hash码
    boolean equals(Object obj) 判断此Object是否与指定的Object对象相等
    void copy(Object obj)把此Object拷贝到指定的Object对象中
    Object clone() 克隆此Object对象
    String toString() 把此Object对象转换成String类的对象
    void notify() 唤醒一个等待的线程
    void notifyAll() 唤醒所有等待的线程
    void wait(int timeout) 使一个线程处于等待直到timeout结束或被唤醒
    void wait() 使一个线程处于等待直到被唤醒

• pageContext对象

  pageContext对象提供了对JSP页面内所有的对象及名字空间的访问
  pageContext对象可以访问到本页所在的session，也可以取本页面所在的application的某一属性值
  pageContext对象相当于页面中所有功能的集大成者
  pageContext对象的本类名也叫pageContext

• Config对象

  config对象是在一个Servlet初始化时，JSP引擎向它传递信息用的，此信息包括Servlet初始化时所  
要用到的参数（通过属性名和属性值构成）以及服务器的有关信息（通过传递一个ServletContext对象）  
常用方法：
    ServletContext getServletContext() 返回含有服务器相关信息的ServletContext对象
    String getInitParameter(String name) 返回初始化参数的值
    Enumeration getInitParameterNames() 返回Servlet初始化所需所有参数的枚举

• Exception对象

  exception对象是一个异常对象，当一个页面在运行过程中发生了异常，就产生这个对象。如果一个JSP  
页面要应用此对象，就必须把isErrorPage设置为true，否则无法编译。它实际上是  
java.lang.Throwable的对象，常用方法：
    String getMessage() 返回描述异常的信息
    String toString() 返回关于异常的简短描述信息
    void printStackTrace() 显示异常及其栈轨迹
    Throwable FillInStackTrace() 重写异常的执行栈轨迹

• Javabean简介

  Javabean就是符合某种特定的规范的Java类。使用Javabean的好处是解决代码重复编写，减少代码  
冗余，功能区分明确，提高了代码的维护性。
  Javabean的设计原则：
      公有类、无参的公有构造方法、属性私有、getter和setter方法
例如：
  public class Students
  {
        private String name;
        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动作元素（action elements），动作元素为请求处理阶段提供信息。动作元素遵循XML元素的语法  
有一个包含元素名的开始标签，可以有属性、可选的内容、与开始标签匹配的结束标签。
第一类是与存取JavaBean有关的，包括：
  <jsp:useBean><jsp:setProperty><jsp:getProperty>
第二类是jsp1.2就开始有的基本元素，包括六个动作元素
  <jsp:include><jsp:forward><jsp:param><jsp:plugin><jsp:params><jsp:fallback>
第三类是jsp2.0新增加的元素，主要与jsp Document有关，包括六个元素
  <jsp:root><jsp:declaration><jsp:scriptlet><jsp:expression><jsp:text><jsp:output>
第四类是jsp2.0新增的动作元素，主要是用来动态生成XML标签元素的值，包括3个动作
  <jsp:attribute><jsp:body><jsp:element>
第五类是jsp2.0新增的动作元素，主要是用在Tag File中，有2个元素
  <jsp:invoke><jsp:dobody>

• 在jsp页面中如何使用JavaBean

在Model1中，由Jsp页面去调用Javabean。
Javabean既可以封装数据同时也可以封装业务逻辑。
1.像使用普通Java类一样，创建JavaBean实例 
2.在jsp页面中通常使用jsp动作标签使用JavaBean
  useBeans动作
  setProperty动作
  getProperty动作
<jsp:useBeans> 作用：在jsp页面中实例化或者在指定范围内使用JavaBean
<jsp:useBean id="标示符" class="java类名" scope="作用范围" />

<jsp:setProperty>
作用：给已经实例化的JavaBean对象的属性赋值，一共有四种方式。
  <jsp:setProperty name = "JavaBean实例名" property = "*" />（跟表单关联）
  <jsp:setProperty name = "JavaBean实例名" property = "JavaBean属性名" />（跟表单关联）
  <jsp:setProperty name = "JavaBean实例名" property = "JavaBean属性名"  
 value = "BeanValue"/>（手工设置）
  <jsp:setProperty name = "JavaBean实例名" property = "propertyName"   
param = "request对象中的参数名"/>（跟request参数关联）
<jsp:getProperty>
作用：获取指定JavaBean对象的属性值
  <jsp:getProperty name = "JavaBean实例名" proper = "属性名" />

JavaBean的四个作用域范围
说明：使用useBeans的scope属性可以用来指定JavaBean的作用范围
  page //仅在当前页面有效
  request //可以通过HttpRequest.getAttribute() 方法取得JavaBean对象
  session //可以通过HttpSession.getAttribute() 方法取得JavaBean对象
  application //可以通过application.getAttribute() 方法取得JavaBean对象

• Model 1

Model 1模型出现前，整个Web应用的情况：几乎全部由jsp页面组成，jsp页面接收处理客户端请求，对请求  
处理后直接做出响应。
弊端：在界面层充斥着大量的业务逻辑的代码和数据访问层的代码，Web程序的可扩展性和可维护性非常差。
JavaBean的出现可以使jsp页面中使用JavaBean封装的数据或者调用JavaBean的业务逻辑代码，这样大大提  
升了程序的可维护性。
附：
  Model1：jsp+javabean，其中jsp为表示层和控制层，javabean为模式层
  Model2：jsp+servlet+javabean，jsp为表示层，servlet为控制层，javabean为模式层
  模式层Model，表示层View，控制层Control，合起来即为MVC。

• JSP状态管理

http协议的无状态性
  无状态是指，当浏览器发送请求给服务器的时候，服务器响应客户端请求，但是当同一个浏览器再次发送  
请求给服务器的时候，服务器并不知道它就是刚才那个浏览器，简单的说，就是服务器不会去记得你，所以  
就是无状态协议。

• Cookie

Cookie是WEB服务器保存到客户端的文本想信息。典型应用：判断注册用户是否已经登录；购物车处理。
Cookie 存在客户端，Session保存在服务器端。
Cookie的作用：
  对特定对象的追踪
  保存用户网页浏览记录与习惯
  简化登陆
安全风险：容易泄露用户信息。

JSP中创建与使用Cookie
  创建Cookie对象：
      Cookie newCookie = new Cookie(String key,Object value);
     写入Cookie对象
        response.addCookie(newCookie);
    读取Cookie对象
        Cookie[] cookies = request.getCookies();

Cookie常用方法：
  void setMaxAge(int expiry) //设置Cookie的有效期，以秒为单位
  void setValue(String value) //在Cookie创建后，对Cookie进行赋值
  String getName() //获取Cookie的名称
  String getValue() //获取Cookie的值
  int getMaxAge() //获取Cookie的有效时间，以秒为单位
Cookie中对保存对象的大小是有限制的。

• include指令与include动作比较

include指令：
  语法格式：<%@ include file="..." %>
  发生作用的时间：页面转换期间
  包含的内容：文件的实际内容
  转换成的Servlet：主页面和包含页面转换为一个Servlet
  编译时间：较慢-资源必须被解析
  执行时间：稍快
  <jsp:include>动作在编译期间被执行，而include指令在页面请求期间被执行。
  页面内容经常变化时更适合使用<jsp:include>动作。
  页面内容不经常变化时更适合使用include指令。
  <jsp:include>动作包含的是执行结果，而include指令包含的是文件内容

jsp:include动作
  语法：<jsp:include page="...">
  作用时间：请求期间
  包含内容：页面的输出
  转换成的Servlet：主页面和包含页面转换为独立的Servlet
  编译时间：较快
  执行时间：较慢--每次资源必须被解析

• forward动作

语法：<jsp:forward page = "URL" />
等同于：request.getRequestDispatcher("/url").forward(request,response);

• param动作

语法：<jsp:param name = "参数名" value = "参数值">
常与<jsp:forward>一起使用，作为其的子标签，起到传参的作用。如：
<body>
    <jsp:forward page = "user.jsp">
          <jsp:param value = "admin@123.com" name = "email">//新增参数
          <jsp:param value = "66666" name = "password">//修改存在的参数的值
    </ jsp:forward>
</body>

• Servlet

  servlet是在服务器上运行的小程序。它就是一个java类，并且可以通过  请求－响应 编程模型来访问的  
这个驻留在服务器内存里的servlet程序。
  Servlet是在服务器端运行以处理客户端请求而做出的响应的程序。servlet生命周期阶段包括初始化、  
加载、实例化、服务和销毁。
  编写Servlet的doPost方法时，需要抛出ServletExcpetion和IOException异常。

Servlet生命周期“
  在下列时刻Servlet容器装载Servlet：
      Servlet容器时自动装载某些Servlet，实现它只需要在web.xml文件中的<Servlet></Servlet>之  
间添加如下代码：<loadon-startup>1</loadon-startup>数字越小表示优先级越高。

• Tomcat容器等级

Tomcat的容器分为四个等级：
  Tomcat - Container - Engine - HOST - Servlet
Servlet的容器管理Context容器，一个Context对应一个web工程。

• 手工编写第一个Servlet

1. 继承HttpServlet
2. 重写doGet() 或者doPost()方法
3. 在web.xml 中注册Servlet（主要定义两个标签）
  <servlet>
      <servlet-name></servlet-name>
      <servlet-class></servlet-class>
  </servlet>
  <servlet-mapping>
      <servlet-name></servlet-name>
      <url-pattern></url-pattern>
  </servlet-mapping>

• Servlet 路径跳转

绝对路径：放之四海而皆准的路径
相对路径：相对于当前资源的路径
  注：eclipse+tomcat8不需要生成web.xml
直接在servlet类里使用注解
@WebServlet(name="HelloServlet", urlPatterns={"/HelloServlet"})
另外，index.jsp中相对路径和绝对路径中都不需要加servlet
<a href="HelloServlet">相对路径跳转访问HelloServlet...</a><br>
<a href="<%=path %>/HelloServlet">绝对路径跳转访问HelloServlet...</a><br>

ServletConfig可以获得Servlet的初始化参数：
  getInitParmeter();