一.继承
1.继承（优点：代码复用方便修改）
    1.1 继承的关键字:extends
    1.2 实现继承步骤（1.编写父类 2.编写子类继承父类）
    1.3 调用父类方法的关键字：super
    1.4 继承条件下构造方法和属性的调用
        1.4.1 调用父类构造方法：super（）; super（实参）;必须写在构造方法第一行
        1.4.2 调用父类的属性和方法：super.属性   super.方法名（）;
        1.4.3 父类中的资源使用了private修饰的子类不能继承
2.方法重写
    2.1 重写的规则（1.方法名相同 2.参数列表相同 3.返回值类型相同或者是其子类 4.访问权限不能严于父类）
    2.2 重写和重载的区别（重写是发生在继承关系下，重载是发生在一个类中，其概念不一样）
3.抽象类
    3.1 抽象类和抽象方法的关键字：abstract
    3.2 抽象类和抽象方法的特点
        3.2.1 都是使用abstract修饰的
        3.2.2 抽象类中可以不写抽象方法
        3.2.3 抽象方法没有方法体
        3.2.4 抽象类不能使用new实例化
        3.2.5 子类继承抽象类，子类必须重写父类的抽象方法，否则子类也是抽象类
4.final修饰符
    4.1 用法
        4.1.1 修饰类，不能被继承，一般用于工具类
        4.1.2 修饰方法，不能被重写    
        4.1.3 修饰属性=》常量， 必须赋初始值
二.集合框架

1：集合框架的优点：性能优良，使用方便，弥补了数组的缺陷，比数组更灵活，更实用，不同的集合可以适用于不同场合。
1:分为两大接口【Collection】【Map】
2:Collection（接口）:存储一组不唯一、允许重复、无序的对象。
    2.1：List(接口):继承Collection，存储一组不唯一、允许重复、有序的对象。
        2.1.1：ArrayList(类)：继承List,遍历和随机访问效率高，插入删除效率低。
            ArrayList list = new ArrayList();
            常用方法：
                2.1.1.1：添加一个对象：add(Object)：list.add("a");    [a]  
                2.1.1.2：在指定位置添加一个对象：add(int index,Object o)：list.add(0,"b");        [b,a]
                2.1.1.3：获取大小：size()：list.size();    2
                2.1.1.4：获取一个对象：get(int index)：list.get(0);
                2.1.1.5：判断是否存在：contains(Object o)：list.contains("a");
                2.1.1.6：移除对象：remove(Object o),remove(int index)
        2.1.2：LinkedList(类)：继承List,遍历和随机访问效率低，插入删除效率高。
            LinkedList list = new LinkedList();
            常用方法：
                2.1.2.1：在首位添加：addFirst(Object o)：list.addFirst("a");    [a]
                2.1.2.1：在末位添加：addLast(Object o)：list.addLast("b");    [a,b]
                2.1.2.1：获取：getFirst(),getLast(),
                2.1.2.1：移除：removeFirst(),removeLast()
    2.2：Set(接口)：继承Collection，存储一组唯一、不允许重复、无序的对象。
        
3:Map(接口)：存储一组成对的键-值对象，提供key(键值)到value（值）的映射。
    3.1：HashMap(类)：继承Map。
        HashMap map = new HashMap();
        常用方法：
            3.1.1：添加一个对象：put(Object key,Object value)：map.put("颜色1","红色");
            3.1.2：获取一个对象：get(Object key)：map.get("颜色1");
            3.1.3：移除一个对象：remove(Object key)：map.remove("颜色1")；
            3.1.4：判断是否存在指定映射：containsKey(Object key)：map.containsKey("颜色1");
            3.1.4：size(),keySet(),values(),isEmpty(),clear()
            
    3.2：TreeMap(类)：继承Map,
4:Iterator(迭代器)：集合接口和类的遍历交给迭代器Iterator完成。
    常用方法：
        4.1：hasNext()：判断是否存在另一个可访问的元素。
        4.2：next()：返回要访问的下一个元素。
        4.3：示例：
            Collection coll = new ArrayList();
            coll.add("abc1");
            coll.add("abc2");
            coll.add("abc3");
            Iterator it = coll.iterator();
            while(it.hasNext()){
                System.out.println(it.next());
            }
5.泛型集合：在使用集合储存对象时用泛型集合，指定了集合中元素的类型，避免在取值时强转。
    5.1：List    list = new List();                List<dog> list = new List<dog>();
        添加：list.add(dog1);                添加值：list.add(dog1);正确
        获取：Dog dog = (Dog)list.get(0);                                   list.add(cat1);错误
                                获取值：Dog dog = list.get(0);

三.表单验证

1.表单验证（减轻服务器的负担，在客户端验证输入数据是否正确）
2.验证方法
    2.1 非空验证
        2.1.1 (例：获取值 var name = $("#name").val(); 判断为空 if(name==""){//为空处理})
    2.2 长度验证
        2.2.1 (例：var pwd = $("#password").val(); if(pwd<需要的长度){//长度不足处理})
    2.3 验证是否为数字
        2.3.1 (例：var num = $("#num").var(); if(!isNaN(num)){//非数字处理})
    2.4 验证是否包含某个字符
        2.4.1 (例: var test = $("#test").var(); if(test.indexOf("包含的字符")==-1){//未包含字符处理})
3.正则表达式(验证数据是否合法)
    3.1 常用符号
        3.1.1 /.../：代表一个模式的开始和结束。
              ^：匹配字符串的开始。
              $：匹配字符串的结束。
              \s：任何空白字符。
              \S：任何非空白字符。
              \d：匹配一个数字,等价于[0~9]。
              \D：匹配除了数字之外的任何字符,等价于[^0~9]。
              \w：匹配一个 数字、下划线字母字符,等价于[A~Za~z0~9]。
              .：除了换行符之外的任意字符。
    3.2 正则表达式的重复字符
        3.2.1 {n}：匹配前一项n次。
              {n,}：匹配前一项n次，或者更多次。
              {n,m}：匹配前一项n次，但不能超过m次。
              *：匹配前一项0次或多次，等价于{0,}。
              +：匹配前一项1次或多次，等价于{1,}。
              ?：匹配前一项0次或一次，等价于{0,1}。
    3.3 使用正则表达式验证
        3.3.1 验证年龄为0~120岁： var age=/^120$|^((1[0,1]|[1-9])?\d)$/
4.表单选择器(选择表单元素)
    4.1 表单选择器 语法： :input :匹配所有input、textarea、select和button元素。
                         :text  :匹配所有单行文本框。
                         :password :匹配所有密码框。
                         :radio  :匹配所有单选按钮。
                         :checkbox :匹配所有复选框。
                         :submit  :匹配所有提交按钮。
                         :image   :匹配所有图像域。
                         :reset   :匹配所有重置按钮。
                         :button  :匹配所有按钮。
                         :file    :匹配所有文件域。
                         :hidden  :匹配所有不可见元素，或者type为hidde的元素。
    4.2 表单属性过滤器 语法： :enabled  :匹配所有可用元素。
                              :disabled :匹配所有不可用元素。
                              :checked  :匹配所有被选中元素。
                              :selected :匹配所有选中的option元素。

《使用jQuery快速高效制作网页交互特效》
四、 JavaScript基础
1. JavaScript概述
    1.1 JavaScript简介
        JavaScript是一种基于对象和事件驱动的脚本语言，它与HTML一起，与Web客户实现交互
    1.2 JavaScript组成
        1.2.1 ECMAScript标准
            JavaScript语法、变量和数据类型、运算符、逻辑控制语句、关键字和对象
        1.2.2 浏览器对象模型
            独立于内容与浏览器窗口进行交互的对象，以便与HTML交互。
        1.2.3 文档对象模型
            HTML文档对象模型定义的一套标准方法，用来操作HTML文档。
    1.3 JavaScript基本结构
        使用<script>标签将JavaScript嵌入到HTML中，基本结构：
        <script type="text/javascript">
            <!--
                // JavaScript语句
            -->
        </script>
    1.4 引用JavaScript的方式
        1.4.1 使用script标签
            将JavaScript代码嵌入到script标签中，如：
            <script type="text/javascript">
                alert("hello");
            </script>
        1.4.2 使用外部JavaScript标签
            通过script标签的src属性引入外部JavaScript文件，如：
            <script type="text/javascript" src="hello.js"></script>
        1.4.3 在HTML标签中使用
            在HTML标签的特定属性中嵌入JavaScript代码，如：
            <input type="button" οnclick="javascript:alert('hello');" />
    
2. JavaScript核心语法
    2.1 变量的声明和赋值
        声明变量的语法：var 合法的变量名 = 初始值;
        如：var num = 0;
    2.2 数据类型
        JavaScript是一种弱类型语言，定义变量时不需要设置变量的数据类型，变量的数据类型由变量的值决定
        javaScript的数据类型有：
            undefined 未定义类型 (定义变量时的默认值，访问一个对象不存在的属性值的类型，没有返回值的函数的返回值类型)
            null 空类型 (null值的类型，表示空值)
            number 数值类型 (用来保存整数和浮点数的数据类型)
            String 字符串类型 (用来保存字符串的数据类型)
            boolean 布尔类型 (用来保存逻辑的数据类型，其值只有true和false)
            function 函数 (用来保存函数)
            object 对象 (用来保存自定义类型的数据)
    2.3 数组
        创建创建指定长度的数组：var 数组名 = new Array(数组长度);
        根据元素内容创建数组：var 数组名 = newArray(值列表);
        访问数组元素：数组名[下标]

3. JavaScript函数
    3.1 常用系统函数
        parseInt() 解析字符串，返回int类型，如：parseInt("1"); // 返回数值1
        parseFloat() 解析字符串，返回浮点数，如：parseFloat("2.3"); // 返回数值2.3
        isNaN() 检查参数是否是非数字，如：isNaN("12"); // 返回false
        alert() 弹出提示框，如：alert("hello"); // 弹出一个提示框，提示消息为“hello·”
        prompt() 弹出带有输入框的提示框，如：prompt("请输入一个数", ""); // 弹出一个带有输入框的提示框，提示消息为“请输入一个数”，返回输入的内容
        confirm() 弹出带有确定和取消的提示框，如：confirm("确定删除？"); // 弹出一个带有确定和取消按钮的对话框，提示信息为“确定删除？”，如果点击确定按钮则返回true，否则返回false
    3.2 自定义函数
        自定义函数的语法：
        function 函数名(参数列表) {
            // JavaScript语句
            [return 返回值]
        }
    3.3 变量的作用域
        全局变量 在所有函数外声明的变量
        局部变量 在函数体内部声明的变量

五、 JavaScript对象
1. window对象
    BOM是JavaScript的组成之一，window对象是整个BOM的核心，通过BOM可以对浏览器窗口进行相关操作
    1.1 window对象的常用方法
        open() 打开一个新的浏览器窗口，加载指定的URL
        close() 关闭浏览器窗口
    1.2 window对象的常用事件
        onload 页面加载完成
    
2. history对象
    history对象记录用户记录的URL列表，通过history对象可以实现前进、后退等操作
    2.1 history对象的常用方法
        back() 加载history对象列表的前一个URL
        forward() 加载history对象列表的后一个URL
        go() 加载history对象列表的某个具体的URL
    
3. location对象
    location对象记录用户当前的URL的相关信息，通过location对象可以获取当前访问的URL或从新加载URL
    3.1 location对象的常用属性
        host 设置或获取主机名和当前的URL的端口号
        hostname 设置或返回URL的主机名
        href 设置或返回完整的URL
    3.2 location对象的常用方法
        reload() 重新加载当前文档
        replace() 用新的文档替换当前文档
    
4. document对象
    document对象代表整个HTML文档，通过document对象可以操作HTML文档的元素
    4.1 document对象的常用方法
        getElementById() 返回对拥有指定id的第一个对象的引用
        getElementsByName() 返回带有指定名称的对象的数组
        getElementsByTagName() 返回带有指定标签名的对象的数组
        write() 向文档写文本、HTML表达式或JavaScript代码
    
5. JavaScript内置对象
    5.1 Date对象
        保存或操作日期的对象
        5.1.1 Date对象的常用方法
            getFullYear() 返回Date对象所保存的日期的年份，其值是4位整数
            getMonth() 返回Date对象所保存的日期的月份，其值是0~11
            getDate() 返回Date对象所保存的日期的号数，其值是1~31
            getDay() 返回Date对象所保存的日期的星期数
            getHours() 返回Date对象所保存的日期的小时数
            getMinutes() 返回Date对象所保存的日期的分钟数
            getSeconds() 返回Date对象所保存的日期的秒数
            getTime() 返回Date对象所保存的日期与1970年1月1日相差的毫秒数
    5.2 Math对象
        提供一些与数学相关的操作，不需要创建该对象，可以直接使用该对象的方法
        5.2.1 Math对象的常用方法
            ceil() 对一个浮点数进行向上舍入
            floor() 对一个浮点数进行向下舍入
            round() 把一个浮点数进行四舍五入
            random() 返回0~1之间的随机数
6. 定时函数
    6.1 常用定时函数
        setTimeout() 在指定的毫秒数后调用函数或计算表达式，如：setTimeout("func", 3000); // 在等待3秒后调用名为func的函数
        setInterval() 按照指定的周期来调用函数或计算表达式，如：setInterval("func", 3000); // 每3秒调用一次名为func的函数
        clearTimeout() 清除setTimeout设置的定时器，如：var timer = setTimeout("func", 2000); clearTimeout(timer);
        clearInterval() 清除setInterval设置的定时器，如：var timer = setInterval("func", 2000); clearInterval(timer);

《使用JSP/Servlet技术开发新闻发布系统》
六、 JSP开发业务应用
1. JSP分页显示数据
    1.1 实现分页的步骤
        1.1.1 确定每页显示的数据量
            根据实际的页面设计来决定，也可以由客户决定
        1.1.2 计算显示的总页数
            根据数据库中的总数据量、每页显示的数据量，计算出显示的总页数
        1.1.3 编写SQL语句
            根据每页显示的数据量和当前需要显示的页码来编写查询相应数据的SQL语句
        1.1.4 封装分页数据
            将分页业务的相关数据封装到一个page类中，其中包括每页显示的数据量、数据的总数据量、显示的总页数、当前页码、当前页显示的数据的集合

2. 文件上传
    2.1 Commons-FileUpload简介
        Apache开放源代码组织的一个Java子项目，主要用于文件上传、命令行处理、数据库连接池等。
        Commons-FileUpload组件的特点：使用简单、能够全程控制上传内容、能够对上传文件的大小、类型进行控制
    2.2 文件上传的步骤
        2.2.1 表单属性的设置
            要实现文件上传，需要对文件域所在的表单的enctype属性进行设置，其属性值有：
                application/x-www-form-urlencoded：默认值，对表单的所有字段的值进行默认编码
                multipart/form-data：上传二进制数据，不对表单的各个字段编码，若要上传文件，则需要设置为此值
                text/plain 向服务器传输大量的文本数据，比较适用于电子邮件
        2.2.2 引入相关的程序文件
            要使用Commons-FileUpload组件，需要引入commons-fileupload.jar和commons-io-2.4.jar文件。
        2.2.3 通过Commons-FIleUpload组件的API提供的相关方法实现文件上传
            2.2.3.1 Commons-FileUpload组件的API
                2.2.3.1.1 ServletFileUpload类
                    用于实现文件上传操作
                    ServletFileUpload类的常用方法
                        setSizeMax() 设置请求信息实体内容的最大允许的字节数
                        parseRequest() 解析form表单中每个字符的数据，返回一个FileItem对象的集合
                        isMultipartContent() 判断请求信息的内容是否是“multipart/form-data”类型
                        setHeaderEncoding() 设置转换时所使用的字符编码
                2.2.3.1.2 FileItem接口
                    封装单个表单字段元素的数据，一个表单字段元素对应一个FileItem对象
                    FileItem接口常用的方法
                        isFormField() 判断FileItem对象封装的字段类型，普通表单字段返回true，文件表单字段返回false
                        getName() 获取文件上传字段中的文件名，普通表单字段返回null
                        getFieldName() 返回表单字段元素的name属性值
                        write() 将FileItem对象中保存的主体内容保存到指定的文件中
                        getString() 将FileItem对象中保存的主体内容以一个字符串返回
                        getSize() 返回单个上传文件的字节数
                2.2.3.1.3 FileItemFactory接口
                    FileUpload对象的创建需要依赖FileItemFactory工厂，将获得的上传文件FIleItem对象保存至服务器硬盘
                    FileItemFactory类常用的方法
                        setSizeThreshold() 设置缓冲区的大小
                        setRepositoryPath() 设置临时文件存放的目录
            2.2.3.2 使用Commons-FileUpload组件的API提供的相应的方法实现文件上传
                1. 创建文件项工厂
                    DiskFileItemFactory factory = new DiskFileItemFactory();
                2. 创建解析工具
                    ServletFileUpload upload = new ServletFileUpload(factory);
                3. 解析表单中的每个字符的数据
                    List<FileItem> items = upload.parseRequest(request);
                4. 查找字段，将文件表单字段的数据保存到服务器硬盘
                    item.write(saveFile);

第7章 Servlet基础
1. Servlet简介
    Servlet是一个符合特定规范的Java程序，是一个Web组件，用于生成动态的内容。
    
2. Servlet API
    编写Servlet需要符合的规范
    2.1 Servlet接口
        常用方法：
        init() Servlet对象在处理客户请求前所要完成的初始化操作
        service() 处理客户端的请求
        destory() 释放Servlet对象所使用的资源
        getServletConfig() 获取初始化参数
        getServletInfo() 获取Servlet的相关信息
    2.2 HttpServlet类
        常用方法：
        doPost() 处理以post方式提交的数据
        doGet() 处理以get方式提交的数据
    2.3 ServletContext对象
        web应用的上下文
        常用方法
            getInitParameter() 获取初始化参数
            setAttribute() 设置指定名称的属性
            getAttribute() 获取指定名称的属性
            getRealPath() 获取服务器的真实路径
            log() 记录日志信息
    2.4 ServletRequest接口
        用于封装客户的请求信息
        常用方法
            setAttribute() 设置指定名称的属性
            getAttribute() 获取指定名称的属性
            removeAttribute() 删除指定名称的属性
    2.5 HttpServletRequest接口
        继承ServletRequest接口，用于HTTP传输协议
        常用方法
            getContextPath() 获取URI中表示请求上下文的路径
            getCookies() 获取客户端在此次请求中所发送的所有cookie数据
            getSession() 获取和此次请求相关联的session
            getMethod() 返回此次请求所使用的HTTP方法的名字，如GET或POST
    2.6 ServletResponse接口
        用于封装相应客户端的数据
        常用方法：
            getWriter() 返回PrintWriter对象，用于向客户端发送文本
            getCharacterEncoding() 获取在相应中发送的正文所使用的字符编码
            setCharacterEncoding() 设置发送到客户端的相应的字符编码
            setContentType() 设置发送到客户端响应的内容类型
    2.7 HttpServletResponse接口
        继承ServletResponse接口，用于HTTP传输协议
        常用方法：
            addCookie() 向客户端添加cookie
            addHeader() 将相应报头添加到相应对象中
            sendRedirect() 发送一个重定向的响应到客户端，让客户端访问新的URL
            
3. Servlet的生命周期
    Servlet运行需要部署到Servlet容器中，由容器管理Servlet，调用Servlet的相应方法，Servlet的生命周期由Servlet容器管理
    3.1 加载和实例化
        当Servlet容器启动或当客户端发送一个请求时，Servlet容器首先检查是否存在该Servlet的示例，如果不存在，则创建一个实例，如果存在，则直接使用该实例
    3.2 初始化
        在Servlet容器完成实例化以后，将调用init()方法进行初始化，在处理客户端请求时完成一些初始化工作
    3.3 服务
        当Servlet初始化完成后，就处于就绪状态，能够响应客户端的请求。当客户端发出请求时，Servlet调用响应的方法处理请求，将处理结果响应到客户端
    3.4 销毁
        当Servlet容器判断一个Servlet是否应当被释放时，容器会调用Servlet的destory()方法，该方法可以指明哪些资源可以被释放，然后由Servlet释放响应的对象
        
4. Servlet的应用
    4.1 创建Servlet
        创建一个自定义类，继承HttpServlet类，重写doPost()和doGet()
    4.2 部署Servlet
        在Servlet所在的web应用的web.xml配置文件的根节点中添加子节点servlet和servlet-mapping，其中servlet子节点中需要servlet-name节点和servlet-class节点，
        servlet-class节点的文本是Servlet类的全名，servlet-那么节点的文本值自定义；servlet-mapping子节点需要servlet-name和url-pattern，servlet-name同样自定义，
        但需要与servlet节点中的servlet-name节点的值保持一致，url-pattern为Servlet绑定相对于当前web应用的url，在客户端访问该url，便可访问部署好的Servlet
        
5. 使用Servlet实现控制器
    Servlet与JSP相比，擅长逻辑控制，但数据展示方面不足，所以Servlet可以作为控制器调用程序其他层的方法来获取数据，将数据保存到相应的作用域中，
    让JSP页面更加方便的展示数据；同样可以处理JSP页面表单提交的数据，处理后调用业务逻辑层的相关方法，将数据存入数据库

第8章 JSTL和EL
1. EL表达式
    1.1 EL表达式简介
        javaScript和XPath的表达式语言，用于方便的访问特定作用域的对象，简化JSP页面代码
    1.2 EL表达式语法
        ${EL表达式}
        1.2.1 点操作符
            访问某个对象的属性，如：${person.name} // 访问person对象的name属性的值
        1.2.2 []操作符
            访问某个对象的属性的值或访问数组中某个元素的值，如：${person["name"]} // 访问person对象的name属性的值
        1.2.3 关系操作符
            判断两个值或表达式的大小关系，关系操作符有：>, <, ==, !=, >=, <=;
        1.2.4 逻辑操作符
            判断两个条件表达式或布尔值的逻辑关系，逻辑操作符有：&&, ||, !
        1.2.5 Empty操作符
            判断指定的对象是否为空，如：${empty obj} // 判断特定作用域中是否存在对象obj
    1.3 EL表达式隐式对象
        无需声明便可直接使用，通过这些隐式对象可以访问特定的对象
        1.3.1 作用域对象
            必须将变量保存到特定的作用域中，才能使用EL表达式访问。其作用域对象有：
            pageScope 当前页面作用域
            requestScope 请求对象作用域
            sessionScope 会话作用域
            applicationScope 当前web应用作用域
        1.3.2 参数访问对象
            param 按照参数名称访问单一请求值的Map对象
            paramValues 按照参数名称访问数组请求值的Map对象
        1.3.3 JSP隐式对象
            pageContext 提供对JSP内置对象的访问

2 JSTL标签
    2.1 JSTL标签简介
        JSP标准标签库，这些标签代替了在JSP页面中嵌入的java逻辑控制语句，从而简化JSP页面
    
    2.2 JSTL核心标签库
        2.2.1 通用标签库
            2.2.2.1 <c:set>标签
                用于设置范围变量的值或者JavaBean对象的属性
                语法：
                <c:set var="variable" value="v" scope="scope" />
                var 设置的变量名
                value 赋予变量的值
                scope 变量的作用域,可选值有page,request,session和application
            2.2.2.2 <c:out>标签
                用于将计算表达式结果输出显示
                语法：
                <c:out value="value" default="default">
                value 要输出的值
                default 默认值
            2.2.2.3 <c:remove>标签
                与<c:set>标签的作用相反,<c:remove>用于移出指定范围的变量
                语法：
                <c:remove var="value" scope="scope">
                var属性是指待移出的变量的名称
                scope属性是指移出的变量所在的范围，可选项有page,request,session,application,如果没有指定,则默认为page
        2.2.2 条件标签库
            2.2.2.1 <c:if>标签
                用于实现Java语言中if语句的功能
                语法：
                <c:if test="condition" var="varName" scope="scope">
                    主体内容
                </c:if>
                test属性是判断条件,当condition(可以用EL表达式表示)的结果true时,会执行主体内容,如果false则不会执行
                var属性定义变量，该变量存在判断以后的结果，该属性可以省略
                scope属性是指var定义变量的存储范围,可选值有page,request,session和application
            2.2.2.2 <c:choose>标签将
                <c:choose>,<c:when>,<c:otherwise>一起实现互斥条件的执行,类似于java语言的if-else
                语法：
                <c:choose var="varName" scope="scope">
                    <c:when test="condition">
                        主体内容
                    </c:when>
                    <c:otherwise>
                        主体内容
                    </c:otherwise>
                </c:if>
        2.2.3迭代标签库
            2.2.3.1 遍历集合对象的成员
                语法：
                <c:forEach var="varName" items="collectionName" varStatus="varStatusName"
                        begin="beginIndex" end="endIndex" step="step">
                    主体内容
                </c:forEach>
                var 属性是对当前成员的引用
                items 指被迭代的对象
                varStatus 属性用于存在var引用的成员的相关信息，如索引等.
                begin 属性表示开始位置，默认为0，该属性可以省略
                end 属性表示结束的位置，该属性可以省略
                step 表示循环的步长，默认为1，该属性可以省略
            2.2.3.2 指定语句的执行次数
                <c:forEach var="varName" varStatus="varStatusName">
                        begin="beginIndex" end="endIndex" step="step"
                    主体内容
                </c:forEach>
一、面向对象
    1.1 面向对象设计：
        1.发现类
        2.发现类的属性
        3.发现类的方法
    1.2 类和对象
        1.2.1 构造方法及其重载（定义）
            1.2.1.1 构造方法：定义及使用。
            1.2.1.2 方法重载：定义及使用。
        1.2.2 static修饰符
            1.2.2.1 定义：static所修饰的类和方法称为类属性，类方法
            1.2.2.2 作用：static所修饰的变量属于这个类所有，
                          即由这个类创建的所有队形共用同一个static变量
            1.2.2.3 注意：静态方法中不能使用this和super关键字；
                          方法里不可以定义static变量；
            1.2.2.4 静态域 ：static{
                                    }
    1.3 封装
        1.3.1 封装的步骤：私有化属性，公开对成员属性的存取操作方法
        1.3.2 封装的优势：隐藏累的实现细节；让使用者只能通过特定方法访问数据；
                            方便加入存取数据，限制不合理操作。
    
二、JSP开发业务应用
    1.分页显示（）
        为什么需要分页：数据量很大的时候，能按照指定格式显示，布局清晰，不受信息数量的限制
        1.1步骤
            1.1.1 确定每页的显示数量
            1.1.2 计算总页数
            1.1.3 编写SQL语句
                起始行的下标 = （当前页页码-1）* 每页显示的数据量
    2.Commons-FileUpload （文件操作）
        2.1 简介
            使用简单
            能够全程控制上传内容
            能够对上传文件、类型进行控制
        2.2 表单的属性设置
            添加属性enctype，而且method属性必须取值为"post"
            <form enctype = "multipart/form-data" method="post">
        2.3 使用 File 控件选择文件        
            <input type="file" name="nfile">
        2.4 API
            导入组件所使用的类库:<%@ page import="org.apache.commons.fileupload.*" %>
            2.4.1 ServletFileUpload 类
            2.4.2 FileItem 接口
            2.4.3 FileItemFactory 接口与实现类
        2.5 应用
            2.5.1 导入所需的类
            2.5.2 判断请求信息中的内容是否是multipart类型
            2.5.3 通过工厂对象实例化ServletFileUpload对象
            2.5.4 调用parserRuquest()将表单中对象解析成FileItem对象的集合
            2.5.5 通过迭代依次处理每个文件
        2.6 控制文件上传
            2.6.1 控制类型(P157)
                //通过Arrays类的asList()方法创建固定长度的集合
                //判断文件类型是否在允许范围内
            2.6.2 控制文件上传的大小（P158）
                //首先设置缓冲区大小
                //然后设置上传文件用到临时文件存放路径
                //再设置单个文件的最大限制
                //最后利用try-catch捕获异常    
            
三、Servlet
    1.Servlet的定义；Servlet是使用Java Servlet应用程序设计接口及相关类和方法的Java程序。
        2.使用Servlet：
            2.1 优势：高效、方便、功能强大、可移植性好、节省投资
            2.2 注意：1.导入所需的servlet包 2.继承HttpServlet 3.需实现doGet()或doPost()方法；
        4.Servlet与JSP的关系
            4.1 servlet是Java编程语言中的一个类，它被用来扩展服务器的性能，
                服务器上驻留着可以通过“请求-响应”编程模型来访问的应用程序
        5.Servlet与JSP
            5.1 区别：1.jsp经编译后就变成了Servlet
                      2.jsp更擅长表现于页面显示,servlet更擅长于逻辑控制
                      3.Jsp是Servlet的一种简化，使用Jsp只需要完成程序员需要输出到客户端的内容，
                        Jsp中的Java脚本如何镶嵌到一个类中，由Jsp容器完成。而Servlet则是个完整的Java类，
                        这个类的Service方法用于生成对客户端的响应。
        6.Servlet API
            6.1 Servlet 接口
                6.1.1：方法：init(ServletConfig fonfig)-->由servlet容器调用，完成客户请求前的初始化操作。
                             service(ServletRequesst req,ServletResponse res)-->由servlet容器调用，处理客户请求。
                             destroy()-->由servlet容器调用，释放servlet对象所使用的资源
                             ServletConfig getServletConfig()-->返回ServletConfig对象，包含初始化参数和启动参数。传递给init()方法
                             String getServletInfo()-->返回有关servlet的信息
            6.2 抽象类HttpServlet
                6.2.1 方法：service(...)-->调用GenericServlet类中service()方法的实现
                            doXXX(...)-->根据请求方式，调用相应的处理方法，如doGet()或doPost();
            6.3 ServletContext 对象
                6.3.1 方法：getInitParameter(String name)-->获取名称为name的系统范围内的初始化参数；
                            setAttribute(String name,Object object)-->设置名称为name的属性；
                            getAttribute(String name)-->获取名称为name的属性；
                            getRealPath(String path)-->返回参数所代表目录的真实路径；
                            log(String message)-->记录一般日志信息；
            6.4 ServletRequest 和 HttpServletRequest 接口
                6.4.1 ServletRequest
                    6.4.1.1 方法：setAttribute(String name,Object object)-->设置名称为name的属性；
                                    getAttribute(String name)-->获取名称为name的属性；
                                  removeAttribute(String name)-->移除名称为name的属性；
                6.4.2 HttpServletRequest
                    6.4.2.1 方法：getContextPath()-->返回请求URI中表示请求上下文路径；
                                  Cookie[] getCookies()-->返回客户端在此次请求中发送的所有cooki对象
                                  HttpSession getSession()-->返回此次请求相关联的session；如果没有，则新建一个session
            6.5 ServletResponse 和 HttpServletResponse 接口
                6.5.1 ServletResponse
                    6.5.1.1 方法：printWriter getWriter()-->返回printWriter对象，用于向客户端发送文本；
                                  getCharacterEncoding()-->返回相应的正文所使用的字符编码；
                                  setcharacterEncoding()-->设置发送到客户端的响应的字符编码；
                                  setContentType(String type)-->设置发送到客户端的响应的内容类型；
                6.5.2 HttpServletResponse
                    6.5.2.1 方法：addCookie(Cookie cookie)-->增加一个cookie到响应中，可多次调用；
                                  addHeader(String name,String value)-->将一个名称为name，值为value的响应报头添加到响应中；
                                  sendRedirect(String location)-->发送一个临时的重定向响应到客户端，以便访问新的URL
                                  encodeURL(String url)-->使用session ID 对用于重定向的URL进行编码；
        7.Servlet生命周期
            7.1 加载与实列化-->servlet容器创建servlet的实例
            7.2 初始化-->该容器调用init()方法
            7.3 服务-->如果请求servlet，则容器调用service()方法
            7.4 销毁-->销毁实例之前调用destroy()方法
        8.Servlet的应用
            8.1 Servlet的编译和部署
            8.2 创建Servlet
            8.3 部署Servlet
            8.4 启动Tomcat访问

四、JSTL与EL
    1.EL表达式（为什么使用：减少在JSP页面中大量java代码,可读性高；
                      特点：自动转换类型、使用简单；
                  适用范围：page/request/session/application；）
        1.1 语法
            ${EL 表达式}
        1.2 操作符
            1.2.1 点操作符
                1.2.1.1    对象
                1.2.1.2    属性
            1.2.2 []操作符
                1.2.2.1    访问特殊字符
                1.2.2.2    访问数组
            1.2.3 关系操作符
                1.2.3.1 ==（eq）
                1.2.3.2 !=（ne）
                1.2.3.3 < （lt）
                1.2.3.4 > （gt）
                1.2.3.5 <=（le）
                1.2.3.6 >=（ge）
            1.2.4 逻辑操作符
                1.2.4.1 &&（and）
                1.2.4.2 ||（or）
                1.2.4.3 ！（not）
            1.2.5 Empty操作符（检测值是否为null或者empty）
        1.3 表达式隐式对象
            1.3.1 作用域访问对象
                1.3.1.1 pageScope（页面作用域 page）
                1.3.1.2 requestScope（请求作用域 request）
                1.3.1.3 sessionScope（会话作用域 session）
                1.3.1.4 applicationScope（应用程序作用域 application）
            1.3.2 参数访问对象
                1.3.2.1 param（单一请求值）
                1.3.2.2 paramValues（数组请求值）
            1.3.3 JSP隐式对象
                1.3.3.1 pageContext（页面信息和JSP内置对象的访问）
    2.JSTL（什么是JSTL：即JSP标准标签库；
            如何使用：引用jar包和标签库描述符文件、使用taglib指令导入标签库描述符文件；）
        2.1 标签库
            2.1.1 通用标签库
                2.1.1.1 <c:set>（设置范围范围变量、属性的值或JavaBean对象的属性）
                2.1.1.1.1 语法
                2.1.1.1.1.1 <c:set var="variable" value="v" scope="scope"/>
                            （将value值存储到范围为scope的变量variable中
                                var:变量名
                                value:变量的值
                                scope:变量的作用域）
                2.1.1.1.1.2 <c:set value="value" target="target" property="property"/>
                            （将value值设置到对象的属性中
                                target:操作的JavaBean对象
                                property：JavaBean对象的属性名
                                value:JavaBean对象属性值）
                2.1.1.2 <c:out>（将计算的表达式结果输出显示）
                2.1.1.2.1 语法
                2.1.1.2.2.1 <c:out value="value"/>
                            （不指定默认值
                                value:需要输出变量的值）
                2.1.1.2.2.2 <c:out value="value" default="default"/>
                            （指定默认值
                                default:value值为空时输出的默认值）
                2.1.1.3 <c:remove>（移除指定范围的变量）
                2.1.1.3.1 语法
                2.1.1.3.1.1 <c:remove var="value" scope="scope"/>
                            （var:待移除的变量名称
                              scope:移除的变量所在的范围）
            2.1.2 条件标签库
                2.1.2.1 <c:if>（实现java中if语句的功能）
                2.1.2.1.1 语法
                2.1.2.1.1.1 <c:if test="condition" var="varName" scope="scope">
                                主体内容
                            </c:if>
                            （test:判断条件
                              var:定义变量,存放结果,可省略
                              scope:var值得存储范围,可省略）
                2.1.2.2 <c:choose>（类似java中的if-else语句,与<c:when>/<c:otherwise>一起实现互拆条件的执行）
                2.1.2.2.1 语法
                2.1.2.2.2.1 <c:choose var="varName" scope="scope">
                                <c:when test="condition">
                                    主体内容
                                </c:when>
                                <c:otherwise>
                                    主体内容
                                </c:otherwise>
                            </c:if>
            2.1.3 迭代标签库
                2.1.3.1 <c:forEach>
                2.1.3.2 语法
                2.1.3.2.1 <c:forEach var="varName" items="collectionName" varStatus="varStatusName" begin="beginIndex" end="endIndex" step="step">
                                主体内容
                          </c:forEach>
                          （遍历集合对象的成员
                                var:对当前成员的引用
                                items:被迭代的集合对象
                                varStatus:存放var引用的成员的相关信息
                                begin:表示开始位置,可省略
                                end:表示结束位置,可省略
                                step:表示循环的步长,可省略）
                2.1.3.2.2 <c:forEach var="varName" varStatus="varStatusName" begin="beginIndex" end="endIndex" step="step">
                                主体内容
                          </c:forEach>
                          （指定语句循环次数
                                var:对当前成员的引用
                                varStatus:存放var引用的成员的相关信息
                                begin:表示开始位置,可省略
                                end:表示结束位置,可省略
                                step:表示循环的步长,可省略）

一.多态
1.0  多态的定义
    根据发送对象的不同而采用多种不同的行为方式。
1.1  多态的作用
    消除类型之间的耦合关系。

1.2 子类到父类的转型，自动类型转换，向上转型
      
    1.2.1 规则：
        1.将一个父类的引用指向一个子类对象
        2.通过父类的引用变量调用的方法是子类覆盖或继承子类方法
        3.通过父类的应用无法调用子类特有的方法
    
1.3 多态存在的三个必要条件
    1、要有继承；
    2、要有重写；
    3、父类引用指向子类对象。

1.4 实现多态的两种方式：
    1.4.1 使用父类作为方法形参实现多态
        语法
            父类  对象 = 子类的实例
          例子：    Pet pet = new Dog();
        好处：
            1.减少代码量
            2.提高代码的重用性
             3.便于维护
            4.可扩展性
    1.4.2 使用父类作为对象返回值实现多态；
1.5 父类到子类的转型，强制类型转换，向下转型
    例如：
          Pet pet  = new Dog("欧欧","雪纳瑞");
        Dog dog = (Dog)Pet;     //正确
        Penguin pgn = (Penguin)pet;    //错误

1.5.1 instanceof 运算符
      作用：用来判断一个对象是否属于一个类或者实现了一个接口
    
    语法：
    对象 instanceof 类或接口
    例子：Pet instanceof Dog
    特点:instanceof,保证数据转换，增加代码的健壮性
    
二.使用jQuery操作DOM
1.1 DOM操作（优势：简化了传统JavaScript操作DOM是繁冗的代码，更加解决了平台之间的兼容性，并使用户与计算机交互更加便捷，更加多样。）

1.1.1 DOM操作的分类
1.1.1.1 DOM Core（核心）
    首先任何一种支持DOM的编程语言都可以使用DOM Core它的用途不仅限于处理一种使用性标记语言编写出来的文档，如:HTML
JavaScript中的getElementById()，getElementByName()等方法都是DOM Core的组成部分，例如，使用document.getElementById("p")可以获取页面中的<P>元素。
1.1.1.2 HTML-DOM
    在使用JavaScript和DOM为HTML文件编写脚本时，有许多专属于HTML-DOM的属性。HTML-DOM 出现的比DOM Core更早，它提供了一些简明的标记来描述各种
HTML元素的属性，如：document.froms,获取表单对象。
1.1.1.3 CSS-DOM
    CSS-DOM 是针对CSS的操作。在JavaScript中，CSS-DOM的技术主要是获取和设置style对象的各种属性，即CSS属性。通过style对象的各种属性，可以使网
页呈现出各种不同的效果，如：element.style.color="red",设置文本为绿色。

1.1.2 jQuery 中的DOM操作
    jQuery中的DOM操作主要可分为样式操作，文本操作和value属性值操作，节点操作，节点操作中又包含属性操作，节点遍历和CSS-DOM操作。其中最核心的
部分是节点操作和节点遍历。

1.2 样式操作

1.2.1 直接设置样式
语法：
    css(name,value) //设置单个属性
    或者
    css({name:value,name:value,name:value...}) //设置多个属性
css()方法的参数说明（name:css属性的名称，如font-size，background等，value:css属性值，#0000,24px等）

1.2.2 追加样式和移除样式
1.2.2.1 追加样式
语法：
    addClass(class)    //追加单个样式
class为类样式的名称，可以增加多个类样式，各个类样式之间以空格隔开。
或者
    addClass(class1 class2 class3...classN)    //追加多个样式
1.2.2.2 移除样式
语法：
    removeClass(class) //移除单个样式
或
    removeClass(class1 class2 class3...classN) //移除多个样式

1.2.3 切换样式
在jQuery使用toggle()方法可以切换元素的可见状态，toggleClass()方法可以切换不同的元素类样式。
语法：
    toggleClass(class)     //切换可见样式

1.3 内容操作

1.3.1 HTML代码操作
    在jQuery中，可以使用html()对HTML代码进行操作。
语法:
    html([content])
html()方法参数说明
content可选表示该参数可以包含HTML标签，无参数时，表示获取被选元素的文本内容。

1.3.2 标签内容操作
语法：
    text([content])
text()方法参数说明
content可选表示该参数可以包含HTML标签，无参数时，表示获取被选元素的文本内容。

text()与html()区别
html()获取读一个匹配元素的HTML内容或文本内容
text()获取所有匹配元素的文本内容

1.3.3 属性值操作
语法：
    val([value])
val()方法的参数说明
value：可选 返回第一被选元素的value属性值

1.4 节点与属性操作

1.4.1 节点操作
1.4.1.1 节点操作
1.4.1.2 创建节点元素
语法：
    $(selector)    //选择器。使用jQuery选择器匹配元素
或
    $(element)    //DOM元素。以DOM元素来创建jQuery对象
或
    $(html)        //HTML代码。使用HTML字符串创建jQUery对象
1.4.1.3 插入节点
内部插入（
    append(content)        //向所选择的元素内部插入内容
    appendTo(content)    //把所选择的元素追加到另一个指定的元素集合中
    prepend(content)     //向每个选择的元素内部前置内容
    prependTo(content)     //将所有匹配元素前置点指定的元素中
）
外部插入（
    after(content)         //在每个匹配的元素之后插入内容
    inertAfter(content)    //将所有匹配元素插入到指定元素的后面
    before(content)        //向所选择的元素外部前面插入内容
    inertBefore(content)    //将所有匹配的元素插入到指定元素前面
）
1.4.1.4 删除节点
语法：
    $(selector).remove([expr])    //可删除指定元素
    $(selector).empty()        //清空
1.4.1.5 替换节点
语法：
    $(selector).replaceWith()    //替换节点元素
或
    $(selector).replaceAll()
1.4.1.6 复制节点
    $(selector).clone([includeEvents])
clone()参数为可选值为：布尔值（true/false）

1.4.2 属性操作
1.4.2.1 获取与设置元素属性
语法：
    $(selector).attr([name])  //获取属性值
或者
    $(selector).attr({[name1:value1],[name2:value2]...[nameN:valueN]})    //获取多个属性值
1.4.2.2 删除元素属性
语法：
    $(selector).removeAttr()    //删除节点属性

1.5 节点遍历
1.5.1 遍历子元素
语法：
    $(selector).chiledren([expr])    //遍历子元素
expr:为可选，用于过滤子元素
1.5.2 遍历同辈元素
    next()         //用于获取紧邻匹配元素之后元素
    prev()        //用于获取紧邻匹配元素之前元素
    sibling()    //用于获取匹配元素前后的所有同辈元素
1.5.3 遍历前辈元素
    $(selector).parent()    //获取当前匹配元素的父级元素
    $(selector).parents()    //获取当前匹配元素的祖级元素
1.6 CSS-DOM操作
    css()        //设置或返回匹配元素的样式属性
    height()    //设置或返回匹配元素的高度
    width()        //舍子或返回匹配元素的宽度
    offset()    //返回以像素为单位的top和left坐标
    offsetParent()    //返回最近的以定位祖先元素
    scrollLeft()    //设置或返回匹配元素相对滚动条左侧的偏移    
    scrollTop()    //设置或返回匹配元素相对滚动条顶部的偏移
    
三.动态网页基础
1.1 动态网页基础
    1.1.1 什么是动态网页(指在服务器端运行的，使用程序语言设计的交互式网页)
    1.1.2 动态网页的优势是什么(交互性，自动更新，随机性)
    1.1.3 C/S架构（客户端 服务器，维护成本高）
        1.1.3.1 适用场合(企业内部的信息管理系统,金融证劵管理系统)
    1.1.4 B/S架构（浏览器 服务器，开发成本高 维护成本低）
        1.1.4.1 适用场合(企业网站,售后服务,物流信息的查询系统)
        1.1.4.2 工作原理(①浏览器接收用户的输入②浏览器向服务器端发送请求③数据处理④发送响应)
    1.1.5 什么是URL(统一资源定位符)
    1.1.6 URL的组成(①协议②服务器域名或IP③端口号④路径)

1.2 部署简单的Web应用
    1.2.1 Tomcat的获取和安装
    1.2.2 Tomcat目录结构
    1.2.3 Tomcat端口号的配置(conf/server.xml/<Connector>)
    1.2.4 Web应用的目录结构(WEB-INF/web.xml)
    1.2.5 配置起始访问页面(web.xml/<welcome-file-list>)

1.3 JSP简介
    1.3.1 什么是JSP(一种动态网页技术标准)
    1.3.2 JSP优点(跨平台性,易维护性,易管理性...)
    1.3.3 JSP的执行过程(①翻译阶段(.java)②编译阶段(.class)③执行阶段)

1.4 JSP页面组成(静态内容,指令,表达式,小脚本,声明,标准动作,注释等元素构成)
    1.4.1 静态内容(HTML)
    1.4.2 JSP中注释(<!--HTML注释-->,<%--JSP注释--%>,<% 脚本 %>)
    1.4.3 JSP指令元素("<%@ "开始,以" %>"结束)
        1.4.3.1 为什么需要page指令(通过import关键字引入java.util包和java.text包中的类)
        1.4.3.2 什么是page指令(指针对当前页面进行设置的一种指令,通常位于JSP页面的顶端)
        1.4.3.3 page语法(<%@ page 属性 1="属性值"属性 2="属性值1,属性值2"...... 属性n="属性值"%>)
        1.4.3.4 page指令常用属性(language,import,contentType)
    1.4.4 JSP脚本元素(表达式，小脚本,声明)
        1.4.4.1 什么是小脚本(小脚本可以包含任意的java片段,形式比较灵活,通过在JSP页面中编写小脚本可以执行复杂的操作和业务处理)
        1.4.4.2 什么是表达式(表达式是对数据的表示，系统将其作为一个值进行计算和显示)
        1.4.4.3 JSP声明语法(<%! Declaration;[ Declaration;]......%>)

1.5 使用集成开发工具创建Web应用
    1.5.1 创建Web项目(File--New--Web Project)
    1.5.2 部署Web项目(Window --> Preferences)
    1.5.3 Web程序的调试与排错(未启动Tomcat服务,未部署Web应用,URL输入错误,目录不能被引用)

四.《Servlet》基础
1.Servlet简介
        Servlet 是一个 Java程序，是在服务器上运行以处理客户端请求并做出响应的程序
2.Servlet体系结构
     2.1 Servlet接口
        常用方法：
        init() Servlet对象在处理客户请求前所要完成的初始化操作
        service() 处理客户端的请求
        destory() 释放Servlet对象所使用的资源
        getServletConfig() 获取初始化参数
        getServletInfo() 获取Servlet的相关信息
    2.2 HttpServlet类
        常用方法：
        doPost() 处理以post方式提交的数据
        doGet() 处理以get方式提交的数据
    2.3 ServletContext对象
        web应用的上下文
        常用方法
            getInitParameter() 获取初始化参数
            setAttribute() 设置指定名称的属性
            getAttribute() 获取指定名称的属性
            getRealPath() 获取服务器的真实路径
            log() 记录日志信息
    2.4 ServletRequest接口
        用于封装客户的请求信息
        常用方法
            setAttribute() 设置指定名称的属性
            getAttribute() 获取指定名称的属性
            removeAttribute() 删除指定名称的属性
    2.5 HttpServletRequest接口
        继承ServletRequest接口，用于HTTP传输协议
        常用方法
            getContextPath() 获取URI中表示请求上下文的路径
            getCookies() 获取客户端在此次请求中所发送的所有cookie数据
            getSession() 获取和此次请求相关联的session
            getMethod() 返回此次请求所使用的HTTP方法的名字，如GET或POST
    2.6 ServletResponse接口
        用于封装相应客户端的数据
        常用方法：
            getWriter() 返回PrintWriter对象，用于向客户端发送文本
            getCharacterEncoding() 获取在相应中发送的正文所使用的字符编码
            setCharacterEncoding() 设置发送到客户端的相应的字符编码
            setContentType() 设置发送到客户端响应的内容类型
    2.7 HttpServletResponse接口
        继承ServletResponse接口，用于HTTP传输协议
        常用方法：
            addCookie() 向客户端添加cookie
            addHeader() 将相应报头添加到相应对象中
            sendRedirect() 发送一个重定向的响应到客户端，让客户端访问新的URL

3.servlet 生命周期
    3.1实例化
        Servlet 容器创建 Servlet 的实例
    3.2初始化
        该容器调用 init()方法   （init方法只能被调用一次）
    3.3服务
        如果请求 Servlet，则容器调用 service()方法
    3.4销毁
        销毁实例之前调用 destroy()方法
        
4.Servlet应用
    4.1创建servlet
        实现doPost()或doGet()方法
    4.2部署Servlet
        编辑部署描述文件web.xml（添加<servlet>和<servlet-mapping>）
    4.3启动Tomcat，访问Servlet
        打开浏览器输入http://localhost:8080/web.xml设置访问的URL
        
    4.4 获取Servlet初始化参数
        预先对Servlet进行初始化设置，修改web.xml文件在<Servlet>元素中添加<inti-param>
        
            <web-app>
            <servlet>
                <servlet-name>HelloServlet</servlet-name>
                <servlet-class>org.jbit.servlet.HelloServlet</servlet-class>
                
                <init-param>
                    <param-name>initParam</param-name>
                    <param-value>Hello Servlet</param-value>
                </init-param>
                
            </servlet>
            <servlet-mapping>
                <servlet-name>HelloServlet</servlet-name>
                <url-pattern>/HelloServlet</url-pattern>
            </servlet-mapping>
            </web-app>
    4.5获得上下文参数
        修改web.xml文件在<Servlet>元素中添加<context-param> 注意：<context-param>元素必须出现在所有Servlet配置元素之前
            <web-app>
            <context-param>
                <param-name>contextParam</param-name>
                <param-value>Hello Servlet</param-value>
            </context-param>
            <!--省略其他配置-->
            </web-app>
            
5.使用Servlet实现控制器
    
五.JSTL和EL
1.1 EL表达式
    1.1.1 为什么需要使用EL表达式(JSP中嵌入java代码使代码结构混乱,可读性差,不易维护)
    1.1.2 什么是EL表达式(javaScript和XPath的表达式语言)
    1.1.3 EL表达式的特点和使用范围(自动类型转换 使用简单,page request session application)
    1.1.4 EL表达式语法(${EL 表达式},点操作符,[]操作符)
        1.1.4.1 点操作符
        1.1.4.2 []操作符(使用[]操作符访问对象属性时,需牢记属性名加上双引号或单引号)
        1.1.4.3 关系操作符(eq,!=,<,>,<=,>=)
        1.1.4.4 逻辑操作符(&&,||,!)
        1.1.4.5 Empty操作符(${empty a})
    1.1.5 EL表达式隐式对象(page,request,session,application,pageContext)
        1.1.5.1 作用域访问对象(pageScope,requestScope,sessionScope,applicationScope)
        1.1.5.2 参数访问对象(param,paramValues)
        1.1.5.3 JSP隐式对象(pageContext)
1.2 JSTL标签
    1.2.1 为什么使用JSTL(为了简化JSP页面的开发难度)
    1.2.2 什么是JSTL(JSP标准标签库,通用标签,条件标签,迭代标签)
    1.2.3 如何使用JSTL(导入taglib指令)
1.3 JSTL核心标签库(通用标签库,条件标签库,迭代标签库)
    1.3.1 通用标签库
        1.3.1.1 <c:set>标签(用于设置范围变量的值或者JavaBean对象的属性)
            语法：
            <c:set var="variable" value="v" scope="scope" />
            var属性的值是设置的变量名
            value属性的值是赋予变量的值
            scope属性对应的是变量的作用域,可选值有page,request,session和application
        1.3.1.2 <c:out>标签(用于将计算表达式结果输出显示)
            语法：
            (1)不指定默认值
            <c:out value="value">
            (2)指定默认值
            <c:out value="value" default="default">
        1.3.1.3 <c:remove>标签(与<c:set>标签的作用相反,<c:remove>用于移出指定范围的变量)
            语法：
            <c:remove var="value" scope="scope">
            var属性是指待移出的变量的名称
            scope属性是指移出的变量所在的范围，可选项有page,request,session,application,如果没有指定,则默认为page
    1.3.2 条件标签库
        1.3.2.1 <c:if>(用于实现Java语言中if语句的功能)
            语法：
            <c:if test="condition" var="varName" scope="scope">
                主体内容
            </c:if>
            test属性是判断条件,当condition(可以用EL表达式表示)的结果true时,会执行主体内容,如果false则不会执行
            var属性定义变量，该变量存在判断以后的结果，该属性可以省略
            scope属性是指var定义变量的存储范围,可选值有page,request,session和application
        1.3.2.2 <c:choose>(<c:choose>,<c:when>,<c:otherwise>一起实现互斥条件的执行,类似于java语言的if-else)
            语法：
            <c:choose var="varName" scope="scope">
                <c:when test="condition">
                    主体内容
                </c:when>
                <c:otherwise>
                    主体内容
                </c:otherwise>
            </c:if>
    1.3.3迭代标签库
        1.3.3.1 遍历集合对象的成员
            语法：
                <c:forEach var="varName" items="collectionName" varStatus="varStatusName"
                        begin="beginIndex" end="endIndex" step="step">
                    主体内容
                </c:forEach>
                var 属性是对当前成员的引用
                items 指被迭代的对象
                varStatus 属性用于存在var引用的成员的相关信息，如索引等.
                begin 属性表示开始位置，默认为0，该属性可以省略
                end 属性表示结束的位置，该属性可以省略
                step 表示循环的步长，默认为1，该属性可以省略
        1.3.3.2 指定语句的执行次数
            <c:forEach var="varName" varStatus="varStatusName">
                    begin="beginIndex" end="endIndex" step="step"
                主题内容
            </c:forEach>