JavaWeb程序参考手册

第一基础技术篇
第Java语言基础 
字符串 
	//charAt方法——返回指定索引位置的char值 
		String string = "I LIKE JAVA";
		char str = string.charAt(2);
		System.out.println(str);
	//compareTo方法——比较两个字符串 
		String string = "I LIKE JAVA";
		String string1 = "I LIKE JAVA WEB";
		int compareTo = string.compareTo(string1);
		System.out.println(compareTo);
	//compareToIgnoreCase方法——不考虑大小写比较两个字符串 
		String string = "I LIKE JAVA";
		String string1 = "I LIKE JAVA WEB";
		int compareToIgnoreCase = string.compareToIgnoreCase(string1);
		System.out.println(compareToIgnoreCase);
	//contains方法——判断是否包含指定字符 
		String string = "I LIKE JAVA";
		boolean str = string.contains("JAVA");
		System.out.println(str);
	//copyValueOf方法——字符数组生成字符串 
		char[] array = {'网','导','信'};
		String str = String.copyValueOf(array);
		System.out.println(str);
	//endsWith方法——判断字符串是否以指定的后缀结束 
		String strCom = "string.java";
		boolean str = strCom.endsWith(".java");
		System.out.println(str);
	//equals方法——字符串比较 
		String str1 = "MN";
		String str2 = "mn";
		boolean str = str1.equals(str2);
		System.out.println(str);
	//equalsIgnoreCase方法——忽略大小写判断字符串相等 
		String str1 = "MN";
		String str2 = "mn";
		boolean str = str1.equalsIgnoreCase(str2);
		System.out.println(str);
	//format方法——格式化字符串 
		String str = String.format("%d", 400/2);
		System.out.println(str);
	//getBytes方法——获取字符串的字节数组 
		String strCom = "java";
		byte[] str = strCom.getBytes();
		for (int i = 0; i < str.length; i++) {
			System.out.println(str[i]);
		}
	//indexOf方法——返回第一次出现的索引位置 
		String strCom = "I LIKE JAVA";
		int index = strCom.indexOf(5);
		System.out.println(index);
	//isEmpty方法——判断字符串是否为空 
		String strCom = "I LIKE JAVA";
		boolean str = strCom.isEmpty();
		System.out.println(str);
	//lastIndexOf方法——返回最后一次出现的索引位置 
		String strCom = "I LIKE JAVA";
		int index = strCom.lastIndexOf("L");
		System.out.println(index);
	//length方法——获取字符串的长度 
		String strCom = "I LIKE JAVA";
		int length = strCom.length();
		System.out.println(length);
	//replace方法——字符串替换 
		String strCom = "I LIKE JAVA";
		String replace = strCom.replace("JAVA", "JAVA WEB");
		System.out.println(replace);
	//replaceAll方法——替换所有匹配的字符串 
		String strCom = "I LIKE JAVA";
		String replaceAll = strCom.replaceAll("JAVA", "JAVAWEB");
		System.out.println(replaceAll);
	//substring方法——求子字符串 
		String strCom = "I LIKE JAVA";
		String subString = strCom.substring(3);
		System.out.println(subString);
	//toCharArray方法——将字符串转换成一个字符数组 
		String strCom = "I LIKE JAVA";
		char[] str = strCom.toCharArray();
		for (int i = 0; i < str.length; i++) {
			System.out.println(str[i]);
		}
	//trim方法——去除字符串的前后空格 
		String strCom = "   I LIKE JAVA   ";
		String trim = strCom.trim();
		System.out.println(trim);
	//valueOf方法——返回数据的字符串表示形式 
		boolean strCom = true;
		String str = String.valueOf(strCom);
		System.out.println(str);
集合类 
	//List.add方法——向集合列表中添加对象 
		List<String> list = new ArrayList<String>();
		list.add("保护环境");
		list.add("爱护地球");
		list.add("从我做起");
		for (int i = 0; i < list.size(); i++) {
			System.out.println(list.get(i));
		}
	//List.addAll方法——添加所有元素到列表中 
		List<String> list = new ArrayList<String>();
		list.add("保护环境");
		list.add("爱护地球");
		list.add("从我做起");
		List<String> list_ad = new ArrayList<String>();
		list_ad.add("公益广告");
		System.out.println(list_ad.addAll(list));
		for (int i = 0; i < list_ad.size(); i++) {
			System.out.println(list_ad.get(i));
		}
	//List.clear方法——从列表中移除所有元素 
		List<String> list = new ArrayList<String>();
		list.add("保护环境");
		list.add("爱护地球");
		list.add("从我做起");
		list.clear();
		System.out.println(list.size());
	//List.contains方法——判断列表中是否包含指定元素 
		List<String> list = new ArrayList<String>();
		list.add("保护环境");
		list.add("爱护地球");
		list.add("从我做起");
		String o = "保护环境";
		System.out.println(list.contains(o));
	//List.get方法——获取列表指定位置的元素 
		List<String> list = new ArrayList<String>();
		list.add("保护环境");
		list.add("爱护地球");
		list.add("从我做起");
		String ret = list.get(1);
		System.out.println(ret);
	//List.isEmpty方法——判断集合对象是否为空 
		List<String> list = new ArrayList<String>();
		list.add("保护环境");
		list.add("爱护地球");
		list.add("从我做起");
		boolean empty = list.isEmpty();
		System.out.println(empty);
	//List.iterator方法——对列表元素进行迭代 
		List<String> list = new ArrayList<String>();
		list.add("保护环境");
		list.add("爱护地球");
		list.add("从我做起");
		Iterator<String> it = list.iterator();
		while (it.hasNext()) {
			System.out.println(it.next());
		}
	//List.remove方法——移出列表中的指定元素 
		List<String> list = new ArrayList<String>();
		list.add("保护环境");
		list.add("爱护地球");
		list.add("从我做起");
		String str = list.remove(1);
		System.out.println(str);
		Iterator<String> it = list.iterator();
		while (it.hasNext()) {
			System.out.println(it.next());
		}
	//List.removeAll方法——从列表中移除所有元素 
		List<String> list = new ArrayList<String>();
		list.add("保护环境");
		list.add("爱护地球");
		list.add("从我做起");
		List<String> list1 = new ArrayList<String>();
		list1.add("保护环境");
		list1.add("爱护地球");
		boolean ret = list1.removeAll(list);
		System.out.println(ret);
	//List.size方法——返回列表中元素的个数 
		List<String> list = new ArrayList<String>();
		list.add("第一个");
		list.add("第二个");
		list.add("第三个");
		int listSize = list.size();
		System.out.println(listSize);
	//List.subList方法——获取列表中指定范围的子列表 
		List<String> list = new ArrayList<String>();
		list.add("第一个");
		list.add("第二个");
		list.add("第三个");
		list.add("第四个");
		list.add("第五个");
		List<String> subList = list.subList(3, 5);
		Iterator<String> iterator = subList.iterator();
		while (iterator.hasNext()) {
			System.out.println(iterator.next());
		}
	//Map.clear方法——从Map集合中移除所有映射关系 
		Map map = new HashMap();
		map.put("昨天", "定制目录");
		map.put("今天", "开始写作");
		map.put("明天", "当然继续写作");
		System.out.println(map.size());
		map.clear();
		System.out.println(map.size());
	//Map.containsKey方法——判断Map集合对象中是否包含指定的键名 
		Map map = new HashMap();
		map.put("apple", "新鲜苹果");
		map.put("compiter", "配置优良的计算机");
		map.put("book", "推挤成山的图书");
		String key = "book";
		boolean contains = map.containsKey(key);
		System.out.println(contains);
	//Map.containsValue方法——判断Map集合中是否包含指定的键值 
		Map map = new HashMap();
		map.put("apple", "新鲜苹果");
		map.put("compiter", "配置优良的计算机");
		map.put("book", "推挤成山的图书");
		String value = "新鲜苹果";
		boolean contains = map.containsValue(value);
		System.out.println(contains);
	//Map.equals方法——判断Map集合是否与指定的对象相同 
		Map map = new HashMap();
		map.put("apple", "新鲜苹果");
		map.put("compiter", "配置优良的计算机");
		map.put("book", "推挤成山的图书");
		Map map2 = new HashMap();
		map2.put("apple", "新鲜苹果");
		map2.put("compiter", "配置优良的计算机");
		map2.put("book", "推挤成山的图书");
		boolean contains = map.equals(map2);
		System.out.println(contains);
	//Map.get方法——返回指定键所映射的值 
		Map map = new HashMap();
		map.put("apple", "新鲜苹果");
		map.put("compiter", "配置优良的计算机");
		map.put("book", "推挤成山的图书");
		Object get = map.get("apple");
		System.out.println(get);
	//Map.isEmpty方法——判断Map 集合对象是否包含内容 
		Map map = new HashMap();
		System.out.println("是否为空"+map.isEmpty());
		map.put("apple", "新鲜苹果");
		map.put("compiter", "配置优良的计算机");
		map.put("book", "推挤成山的图书");
		System.out.println("是否为空"+map.isEmpty());
	//Map.keySet方法——获取Map集合的所有键名 
		Map map = new HashMap();
		map.put("apple", "新鲜苹果");
		map.put("compiter", "配置优良的计算机");
		map.put("book", "推挤成山的图书");
		Set keySet = map.keySet();
		for (Object object : keySet) {
			System.out.println(object);
		}
	//Map.put方法——获取Map集合的所有键名 
		Map map = new HashMap();
		map.put("apple", "新鲜苹果");
		map.put("compiter", "配置优良的计算机");
		map.put("book", "推挤成山的图书");
		int size = map.size();
		System.out.println(size);
	//Map.putAll方法——追加一个Map对象到当前Map集合 
		Map map = new HashMap();
		map.put("apple", "新鲜苹果");
		map.put("compiter", "配置优良的计算机");
		map.put("book", "推挤成山的图书");
		Map map1 = new HashMap();
		map1.put("apple1", "新鲜苹果");
		map1.put("compiter1", "配置优良的计算机");
		map1.put("book1", "推挤成山的图书");
		map1.putAll(map);
		System.out.println(map1);
	//Map.values方法——获取Map集合中的所有键值对象 
		Map map = new HashMap();
		map.put("apple", "新鲜苹果");
		map.put("compiter", "配置优良的计算机");
		map.put("book", "推挤成山的图书");
		Collection values = map.values();
		for (Object object : values) {
			System.out.println(object);
		}
	//Set.add方法——向Set集合添加对象 
		HashSet set = new HashSet();
		set.add("a");
		set.add("b");
		set.add("c");
		int size = set.size();
		System.out.println(size);
	//Set.contains方法——判断Set集合是否包含指定的对象 
		HashSet set = new HashSet();
		set.add("a");
		set.add("b");
		set.add("c");
		boolean contains = set.contains("a");
		System.out.println(contains);
	//Set.isEmpty方法——判断Set集合对象是否为空 
		HashSet set = new HashSet();
		System.out.println("是否为空"+set.isEmpty());
		set.add("a");
		set.add("b");
		set.add("c");
		System.out.println("是否为空"+set.isEmpty());
	//Set.remove方法——移除Set集合中的指定对象 
		HashSet set = new HashSet();
		set.add("a");
		set.add("b");
		set.add("c");
		System.out.println(set.size());
		set.remove("a");
		System.out.println(set.size());
	//Set.toArray方法——用Set集合中的所有对象创建一个数组 
		HashSet set = new HashSet();
		set.add("a");
		set.add("b");
		set.add("c");
		Object[] toArray = set.toArray();
		System.out.println(toArray.length);
数据库 
	//Connection.close方法——关闭Connection对象 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		con.close();
	//Connection.commit方法——提交事务 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		con.setAutoCommit(false);
		Statement st = con.createStatement();
		String sql = "insert into users(username,password)values('xiaoli','123456')";
		st.execute(sql);
		con.commit();
	//Connection.createStatement方法——创建一个Statement对象 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		con.setAutoCommit(true);
		Statement st = con.createStatement();
	//Connection.getClientInfo方法——获取客户端信息属性集 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		Properties props = con.getClientInfo();
	//Connection.getMetaData方法——获取数据库的元数据 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		DatabaseMetaData metaData = con.getMetaData();
	//Connection.prepareCall方法——调用数据库存储过程 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		String sql = "{call saveuser(?,?)}";
		con.prepareCall(sql);
	//Connection. prepareStatement方法——创建一个预处理语句 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		String sql = "select * from users where password = 123456";
		PreparedStatement ps = con.prepareStatement(sql);
	//Connection. rollback方法——事务回滚 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		Statement st = con.createStatement();
		con.setAutoCommit(false);
		st.execute("delete from users where username = 'xiaoli'");
		con.rollback();
	//Connection. setAutoCommit方法——设置数据库连接的提交模式 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		Statement st = con.createStatement();
		con.setAutoCommit(false);
		st.execute("delete from users where username = 'xiaoli'");
		con.rollback();
	//DriverManager.deregisterDriver方法——删除一个驱动程序 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Driver driver = DriverManager.getDriver(url);
		DriverManager.deregisterDriver(driver);
	//DriverManager. getDriver方法——选择一个适当的驱动程序 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Driver driver = DriverManager.getDriver(url);
		DriverManager.deregisterDriver(driver);
	//DriverManager. getDrivers方法——获取全部已加载的驱动程序 
		Class.forName("com.mysql.jdbc.Driver");
		Enumeration<Driver> em = DriverManager.getDrivers();
		while (em.hasMoreElements()) {
			Driver d = em.nextElement();
			System.out.println(d.getClass().getName());
		}
	//DriverManager.getConnection方法——获取数据库连接 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		System.out.println("连接成功");
	//DriverManager. getLoginTimeout方法——获取连接数据库的等待时间 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		System.out.println(DriverManager.getLoginTimeout());
	//DriverManager.getLogWriter方法——获取日志的打印输出流 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		PrintWriter out = DriverManager.getLogWriter();
		if(out != null){
			out.print("得到信息");
			out.close();
		}
	//DriverManager. println方法——输出日志 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		DriverManager.println("获取驱动成功");
	//Statement. addBatch方法——添加批处理语句 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		String sql1 = "insert into users values('aaa','111')";
		String sql2 = "insert into users values('bbb','111')";
		String sql3 = "insert into users values('ccc','111')";
		Statement stmt = con.createStatement();
		stmt.addBatch(sql1);
		stmt.addBatch(sql2);
		stmt.addBatch(sql3);
		stmt.executeBatch();
		stmt.close();
	//Statement.clearBatch方法——清除批处理语句 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		String sql1 = "insert into users values('aaa','111')";
		String sql2 = "insert into users values('bbb','111')";
		Statement stmt = con.createStatement();
		stmt.addBatch(sql1);
		stmt.addBatch(sql2);
		stmt.clearBatch();
		stmt.close();
	//Statement.clearWarnings方法——清除所有警告 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		Statement stmt = con.createStatement();
		stmt.clearWarnings();
	//Statement.execute方法——执行SQL语句 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		String sql1 = "insert into users values('ddd','111')";
		Statement stmt = con.createStatement();
		boolean bool = stmt.execute(sql1);
		System.out.println(bool);
	//Statement.executeBath方法——执行批处理语句 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		String sql1 = "insert into users values('eee','111')";
		String sql2 = "insert into users values('fff','111')";
		String sql3 = "insert into users values('ggg','111')";
		Statement stmt = con.createStatement();
		stmt.addBatch(sql1);
		stmt.addBatch(sql2);
		stmt.addBatch(sql3);
		stmt.executeBatch();
		stmt.close();
		con.close();
	//Statement.executeUpdate方法——执行更新操作 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		String sql = "delete from users";
		Statement stmt = con.createStatement();
		stmt.addBatch(sql);
		stmt.executeUpdate(sql);
		stmt.close();
		con.close();
	//Statement.executeQuery方法——执行查询操作 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		String sql = "select * from users";
		Statement stmt = con.createStatement();
		ResultSet rs = stmt.executeQuery(sql);
		stmt.close();
		con.close();
	//Statement.getFetchSize方法——获取结果集的行数 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		Statement stmt = con.createStatement();
		System.out.println(stmt.getFetchSize());
		stmt.close();
		con.close();
	//Statement.getGeneratedKeys方法——获取自动生成的键 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		Statement stmt = con.createStatement();
		ResultSet rs = stmt.getGeneratedKeys();
		stmt.close();
		con.close();
	//Statement.getMoreResults方法——移动到Statement对象的下一个结果 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		Statement stmt = con.createStatement();
		if(stmt.getMoreResults()){
			System.out.println("下一个对象");
		}
		stmt.close();
		con.close();
	//Statement.getResultSet方法——获取结果集 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		Statement stmt = con.createStatement();
		String sql = "select * from users";
		ResultSet rs = stmt.executeQuery(sql);
		while (rs.next()) {
			System.out.println(rs.getString(1));
		}
		stmt.close();
		con.close();
	//Statement. setMaxRows方法——获取最大行数 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		Statement stmt = con.createStatement();
		stmt.setMaxRows(20);
		stmt.close();
		con.close();
	//PreparedStatement.clearParameters方法——立即清除当前参数值 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		String sql = "update users set username = ? where username= ? ";
		PreparedStatement ps = con.prepareStatement(sql);
		ps.setString(1, "ccc");
		ps.setString(2, "aaa");
		ps.clearParameters();
		ps.executeUpdate();
		con.close();
	//PreparedStatement.execute方法——执行SQL语句 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		String sql = "select * from users";
		PreparedStatement ps = con.prepareStatement(sql);
		boolean bool = ps.execute();
		System.out.println(bool);
		con.close();
	//PreparedStatement.executeQuery方法——执行查询语句 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		String sql = "select * from users";
		PreparedStatement ps = con.prepareStatement(sql);
		ResultSet rs = ps.executeQuery();
		con.close();
	//PreparedStatement.executeUpdate方法——执行更新语句 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		String sql = "insert into users values(?,?)";
		PreparedStatement ps = con.prepareStatement(sql);
		ps.setString(1, "ddd");
		ps.setString(2, "1111");
		int i = ps.executeUpdate();
		System.out.println(i);
		con.close();
	//PreparedStatement.getMetaData方法——获取ResultSet对象列的信息 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		String sql = "insert into users values(?,?)";
		PreparedStatement ps = con.prepareStatement(sql);
		ResultSetMetaData rsmd = ps.getMetaData();
		System.out.println(rsmd.getColumnName(0));
		con.close();
	//PreparedStatement. getParameterMetaData方法——获取参数信息 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		String sql = "insert into users values(?,?)";
		PreparedStatement ps = con.prepareStatement(sql);
		ParameterMetaData pmd = ps.getParameterMetaData();
		con.close();
	//PreparedStatement.setBigDecimal方法——设置大数字参数值 
		//设置大数字参数值
	//PreparedStatement.setBoolean方法——设置布尔型参数 
		//设置布尔型参数 
	//PreparedStatement.setByte方法——设置字节型参数 
		//设置字节型参数 
	//PreparedStatement.setCharacterStream方法——将指定参数设置为给定Reader对象 
		//将指定参数设置为给定Reader对象 
	//PreparedStatement.setDate方法——设置日期型参数 
		//设置日期型参数 
	//PreparedStatement.setInt方法——设置整型参数 
		//设置整型参数
	//PreparedStatement. setNString方法——设置String类型的参数 
		//设置String类型的参数
	//ResultSet.absolute方法——将光标移动到指定行 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		String sql = "select * from users";
		Statement st = con.createStatement();
		ResultSet rs = st.executeQuery(sql);
		boolean b = rs.absolute(5);
		System.out.println(b);
		con.close();
	//ResultSet.afterLast方法 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		String sql = "select * from users";
		Statement st = con.createStatement();
		ResultSet rs = st.executeQuery(sql);
		rs.afterLast();
		con.close();
	//ResultSet.beforeFirst方法——将光标移动到第一行之前 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		String sql = "select * from users";
		Statement st = con.createStatement();
		ResultSet rs = st.executeQuery(sql);
		rs.beforeFirst();
		con.close();
	//ResultSet.close方法——关闭ResultSet对象 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		String sql = "select * from users";
		PreparedStatement ps = con.prepareStatement(sql);
		rs.close();
		con.close();
	//ResultSet.deleteRow方法——删除当前行 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		String sql = "select * from users";
		PreparedStatement ps = con.prepareStatement(sql,ResultSet.TYPE_SCROLL_INSENSITIVE,ResultSet.CONCUR_UPDATABLE);
		ResultSet rs = ps.executeQuery();
		if(rs.next()){
			rs.deleteRow();
		}
		rs.close();
		con.close();
	//ResultSet.first方法——将光标移动到第一行 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		String sql = "select * from users";
		Statement st = con.createStatement();
		ResultSet rs = st.executeQuery(sql);
		boolean bool = rs.first();
		System.out.println(bool);
		rs.close();
		con.close();
	//ResultSet.getAsciiStream方法——获取指定列的ASCII字符流的值 
		//获取指定列的ASCII字符流的值
	//ResultSet.getByte方法——获取字节型的数据 
		//获取字节型的数据
	//ResultSet.getMetaData方法——获取对象的列信息 
		//获取对象的列信息 
	//ResultSet. getRow方法——获取当前行编号 
		//获取当前行编号 
	//ResultSet.getString方法——获取String类型的数据 
		//获取String类型的数据 
	//ResultSet. isAfterLast方法——判断光标是否位于最后一行之后 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		String sql = "select * from users";
		Statement st = con.createStatement();
		ResultSet rs = st.executeQuery(sql);
		System.out.println(rs.isAfterLast());
		rs.afterLast();
		System.out.println(rs.isAfterLast());
		rs.close();
		con.close();
	//ResultSet. isBeforeFirst方法——判断光标是否位于第一行之前 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		String sql = "select * from users";
		Statement st = con.createStatement();
		ResultSet rs = st.executeQuery(sql);
		System.out.println(rs.isBeforeFirst());
		rs.next();
		System.out.println(rs.isAfterLast());
		rs.close();
		con.close();
	//ResultSet.isFirst方法——判断光标是否位于第一行 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		String sql = "select * from users";
		Statement st = con.createStatement();
		ResultSet rs = st.executeQuery(sql);
		System.out.println(rs.isFirst());
		rs.first();
		System.out.println(rs.isFirst());
		con.close();
	//ResultSet. isLast方法——判断光标是否位于最后一行 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		String sql = "select * from users";
		Statement st = con.createStatement();
		ResultSet rs = st.executeQuery(sql);
		System.out.println(rs.isLast());
		rs.last();
		System.out.println(rs.isLast());
		con.close();
	//ResultSet.last方法——将光标移动到最后一行 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		String sql = "select * from users";
		Statement st = con.createStatement();
		ResultSet rs = st.executeQuery(sql);
		rs.last();
		con.close();
	//ResultSet.next方法——将光标从当前的位置向下移动一行 
		Class.forName("com.mysql.jdbc.Driver");
		String url = "jdbc:mysql:///java?username=root&password=root";
		Connection con = DriverManager.getConnection(url);
		String sql = "select * from users";
		Statement st = con.createStatement();
		ResultSet rs = st.executeQuery(sql);
		while (rs.next()) {
			System.out.println(rs.getString("username"));
		}
		rs.close();
		st.close();
		con.close();
第Ajax必备 
HTML语言 
	//<a>标记——超级链接标记 
		<a href="#" hreflang="language" name="bookname" type="mimeTypes" charset="code"
		shape="area" coords="coordinate" target="target" tabindex="value" accesskey="key"></a>
		href		指定连接地址，可绝对地址，可相对地址
		hreflang	指定连接位置所使用的语言
		name		指定连接标识
		type		指定连接位置使用MIME类型
		charset		指定连接位置使用的编码方式
		target		指定连接目标窗口
		tabindex	指定按下TAB时移动顺序
		linkcontent	指定设置连接内容
		accesskey	连接设置快捷键
		target属性中的参数
			_parent	在上一级窗口中打开
			_blank	在新窗口中打开
			_self	在同一个窗口中打开
			_top	在浏览器整个窗口中打开
	//<area>标记——设置热点区域标记 
		<area shape="value" coords="坐标" href="url" alt="描述文字" tabindex="value" >
		shape	指定热点地图操作区域的形状，可选default全体区域、rect矩形、circle圆形、poly多边形
		coords	根据shape的取值不同，相应坐标的设置不同
		href	指定连接地址，可以是绝对，也可以相对
		alt		指定当无法显示图片时显示的文字
		tabindex 指定按下TAB时移动顺序，从属性最小的开始移动
	//<b>标记——文字粗体标记 
		<b>文字</b>
	//<bgsound>标记——嵌入多种格式的音乐文件标记 
		<bgsound loop="value" src="uri" volume="value" balance="value"/>
		loop	设置播放次数，若无限次循环播放，可将属性设置为-1
		src		指定播放背景音乐来源的URI
		volume	设置音乐播放的声音
		balance	设置音乐播放时左右声道音量
	//<blockquote>标记——标识文件中的内容是引用数据的标记 
		<blockquote cite="uri">引用内容</blockquote>
		cite	指定引用数据的来源
	//<body>标记——HTML的主体标记 
		<body background="URL" bgcolor="Color" bgproperties="Fixed" link="Color" alink="Color"
		vlink="Color" text="Color" leftmargin="n" topmargin="n" bottommargin="n" rightmargin="n"
		Event="action"></body>
		background		指定页面的背景图片
		bgcolor			设置网页的背景颜色
		bgproperties	设置网页文本滚动时，背景图片是否随之滚动
		link			设置网页的超级链接颜色
		alink			设置网页正在被单击的超级链接颜色
		vlink			设置网页已访问的超级链接的颜色
		text			设置网页文本的颜色
		leftmargin		设置网页的左边距
		topmargin		设置网页的顶边距
		bottommargin	设置网页的底边距
		rightmargin		设置网页的右边距
		Event			Event事件句柄，可以是onBlur、onError、onFocus、onLoad、onResize、onUnload等
	//<br>标记——换行标记 
		<br>
	//<center>标记——居中标记 
		<center></center>
	//<dd>标记——定义列表中列表项的解释标记 
		<dd>内容</dd>
	//<dir>标记——显示目录列表标记 
		<dir>内容</dir>
	//<div>标记——块级元素标记 
		<div align="value" id="id" class="stylename" style="style">内容</div>
		align	指定起始标签和结束标签对应的方向，常用取值left居左对齐（默认）、center居中对齐、right居右对齐
		id		用于div的唯一标识
		class	设置css样式，通过类别选择器设置的样式
		style	设置css样式，直接使用样式属性设置
	//<dl>标记——显示定义列表标记 
		<dl>内容</dl>
	//<dt>标记——显示定义列表中的列表项标记 
		<dt>内容</dt>
	//<embed>标记——嵌入多媒体文件标记 
		<embed src="file_url" width="value" height="value" hidden="hidden_value" autostart="auto_value" loop="loop_value"
		type="value" pluginspage="value"></embed>
		src			指定多媒体文件的来源URI
		width		以百分比或像素指定对象的宽度
		height		以百分比或像素指定对象的高度
		hidden		指定对象是否隐藏，可选true或者false
		type		指定对象MIME类型，例如swf文件对象的类型application/x-shockwave-flash
		pluginspage	指定插件位置，如果浏览器没有安装可以自动下载安装
		loop		指定是否循环播放，可选值true或者false，默认false
		autostart	指定是否自动播放，可选值true或false，默认true
	//<font>标记——字体标记 
		<font color="value" face="font_name_list" size="value">
		color	指定文字颜色
		value	可以是用6个16进制数，还可以使用HTML给定的常量 black white等
		face	指定字体
		size	指定字号
	//<form>标记——表单标记 
		<form name="form_name" method="method" action="url" enctype="value" target="target_win">
		</form>
		name	指定表单名称
		method	指定表单数据提交方式，值为post或者get。默认是get
		action	指定表单数据提交地址
		enctype	指定表单数据传送的数据类型
		target	指定提交数据的目标窗口
	//<frame>标记——框架标记 
		<frame name="name" src="uri" bordercolor="color" frameborder="value" scrolling="value" nosize="nosize"
		marginheight="value" marginwidth="value" longdesc="info"/>
		name		指定框架名称
		src			指定框架的内容文件
		bordercolor	指定边框的颜色，可以用6个十六进制，还可以使用HTML给定的常量
		frameborder	指定是否显示框架的边框线
		scrolling	指定是否显示滚动条，取值auto自动，默认，yes显示，no不显示
		nosize		指定不允许动态改变框架的大小，取值为空值或者Nosize
		marginheight指定框架的左右留白空间，单位是像素
		marginwidth	指定框架的上下留白空间，单位是像素
		longdesc	指定框架详细说明的uri，如果只是剪短的说明请改用title
	//<frameset>标记——框架集标记 
		<frameset rows="height" cols="width" frameborder="value" framespacing="value" bordercolor="color"
		border="value"></frameset>
		rows			指定框架的高度，属性值默认为100%
		cols			指定框架的宽度，属性默认为100%
		bordercolor		指定框架边框颜色，可以使用6位十六进制数也可以使用html常量
		border			指定框架边框线的宽度
		framespacing	指定框架与框架的距离
		frameborder		指定是否显示框架的边界线，1表示有边界线，0表示无边界线
	//<h>标记——标题标记 
		<h1 align="value"></h1>
		<h2 align="value"></h2>
		align	指定标题文字的对齐方式，默认为left
	//<head>标记——头部标记 
		<head></head>
		<head>标签的子标签
			<base>		当前文档的URL全称
			<basefont>	设定基准的文字字体，字号，颜色
			<title>		设置网页的标题
			<meta>		有关文档本身的元信息
			<style>		设置CSS样式表的内容
			<link>		设定外部文件的连接
			<script>	设置网页中程序脚本的内容
	//<hr>标记——水平线标记 
		<hr align="value" width="value" size="value" noshade color="value">
		align	设置水平线在水平方向上的对齐方式
		width	设置水平线的宽度
		size	设置水平线的高度
		noshade	设置显示实心水平线并且不带阴影
		color	设置水平线颜色
	//<html>标记——标识HTML文档标记 
		<html></html>
	//<i>标记——文字斜体标记 
		<i></i>
	//<iframe>标记——浮动框架标记 
		<iframe src="uri" width="value" height="value" id="id" frameborder="value" scrolling="value" marginheight="value" 
		marginwidth="value"></iframe>
		src				指定框架内容
		width			指定框架宽度
		height			指定框架高度
		id				指定框架ID
		frameborder		指定是否显示框架的边框线
		marginheight	指定框架上下留白空间
		marginwidth		指定框架左右留白空间
		scrolling		指定框架是否出现滚动条
		name			指定框架名称
	//<img>标记——插入图片标记 
		<img src="uri" width="value" height="value" border="value" alt="提示文字" dynsrc="uri" loop="value" start="fileopen/mouseover"
		hspace="digit" vspace="digit" name="value" usemap="uri" lowsrc="uri">
		src		指定图片来源
		width	指定图片宽度
		height	指定图片高度
		border	指定图片外边框
		alt		指定图片无法显示时显示文字
		dynsrc	指定要播放的多媒体文件
		loop	指定循环播放的次数，无限次循环是-1
		start	指定何时播放多媒体文件，可选fileopen文件打开时播放和mouseover鼠标移动到当前对象时播放
		hspace	指定图片左右的空白宽度
		vspace	指定图片上下的空白宽度
		name	用于图片对象指定一个名字
		usemap	图片设置热点地图，属性值为URI
		lowsrc  指定预览图片的来源，当现在错误时，用来替代图片
	//<input>标记——输入字段标记 
		<input type="image" disabled="disabled" checked="checked" width="digit" height="digit" maxlength="digit" readonly=""
		size="digit" src="uri" usemap="uri" alt="" name="checkbox" value="checkbox">
		type		指定添加的是哪种输入字段
		disabled	指定输入字段不可用
		checked		指定输入字段是否处于被选中状态
		width		指定输入字段的宽度
		height		指定输入字段的高度
		maxlength	指定输入字段可输入文字的个数
		readonly	指定输入字段是否为只读
		size		指定图片的宽度
		src			指定图片的来源
		usemap		为图片设置热点地图，只有当type属性为image时有效
		alt			指定当图片无法显示时显示文字
		name		指定输入字段的名称
		value		指定输入字段默认数据值，当type属性为checkbox和radio时，不可省略此属性。
		type属性的可选值
			text		文本框
			password	密码域
			file		文件域
			radio		单选按钮
			checkbox	复选框
			submit		提交按钮
			reset		重置按钮
			button		普通按钮
			hidden		隐藏域
			image		图像域	
	//<li>标记——添加列表项标记 
		<li type="type" value="digit"></li>
		type:设置项目符号种类，可选circle空心圆，square实心方块，disc实心圆点
		value:属性为正数，指定编号的起始值
	//<link>标记——链接外部文件标记 
		<link chartset="characterSet" href="URI" hreflang="languageCode" media="descriptorlist" 
		rel="linktypes" src="URL" type="MIMEType">
		charset		定义编码格式
		href		指定链接文件URI地址
		hreflang	定义语言编码格式
		media		定义输出设备
		rel			定义链接的类型
		src			指定链接的URL
		type		指定链接文件类型
	//<map>标记——设置热点地图标记 
		<map name="value" id="value"></map>
		name	指定元素的标记名
		id		指定元素的ID
	//<marquee>标记——实现跑马灯效果标记 
		<marquee behavior="value" bgcolor="rgb" direction="value" scrollamount="value" scrolledlay="value" 
		truespeed="truespeed" loop="digit" height="value" width="value" hspace="value" vspace="value">文字或图片</marquee>
		behavior		指定跑马灯效果，可选scroll滚动，slide滑动,alternate交替
		bgcolor			指定跑马灯效果区域的背景颜色
		direction		指定跑马灯效果的移动方向，可选left向左,right向右，up向上，down向下
		scrollamount	指定每次移动的距离
		scrolldelay		指定每次移动延迟的时间
		truespeed		指定跑马灯效果的速度
		loop			指定跑马灯效果的运行次数
		height			指定跑马灯效果区域的高度
		width			指定跑马灯效果区域的宽度
		hspace			指定跑马灯效果区域左右的留白宽度
		vspace			指定跑马灯效果区域上下的留白宽度
	//<menu>标记——菜单列表标记 
		<menu>内容</menu>
	//<meta>标记——元数据标记 
		<meta http-equiv="value" content="value">
		http-equiv	生成一个HTTP标题域，相应取值有conntent确定
		content		指定“关键字/取值”的内容
	//<noframes>标记——设置不支持框架时替代内容的标记 
		<noframes></noframes>
	//<object>标记——将各种类型的数据配置到文件中的标记 
		<object data="uri" type="type" width="digit" height="digit" classid="value"></object>
		data	指定数据来源URI
		type	指定date属性所指定的数据的MIME类型
		width	指定媒体播放器的宽度
		height	指定媒体播放器的高度
		classid	指定使用的浏览器的插件
	//<ol>标记——有序列表标记 
		<ol type="type" start="digit"></ol>
		type	设置项目编号的样式，可选值1整数，a小写英文字母，A大写英文字母，i小写罗马数字，I大写罗马数字，默认1
		start	属性为正整数，指定编号的起始值
	//<optgroup>标记——建立选项分组标记 
		<optgroup label="labelname" disabled="disabled"></optgroup>
		label		设置选项组的名称
		disabled	设置选项组不可用
	//<option>标记——添加选项标记 
		<option value="value" label="label" disabled="disabled" selected="selected">标记内容</option>
		value		指定选项实际值
		label		指定选项的显示内容
		disabled	指定当前选项不可用
		selected	做东当前选项已被选中
	//<p>标记——段落标记 
		<p align="value">标记内容</p>
		align	指定对齐方式
	//<param>标记——指定参数标记 
		<param name="paramName" value="value" valuetype="value" type="type"/>
		name		指定参数名称
		value		指定name属性所指参数值
		valuetype	指定value属性值的数据类型
		type		指定value属性所指定的数据的MIME类型
	//<pre>标记——预格式化标记 
		<pre width="value"></pre>
		width	指定一行的宽度
	//<s>标记——删除线标记 
		<s>文字</s>
	//<script>标记——设定网页中程序脚本的内容的标记 
		<script language="value" src="URL" type="value"></script>
		language	指定程序脚本使用的脚本语言
		src			指定引入脚本文件的地址
		type		指定脚本文件的类型
	//<select>标记——列表框标记 
		<select name="name" size="digit" multiple="multiple" disabled="disabled"></select>
		name		指定列表框的名称
		size		指定列表框中显示的选项数量
		disabled	指定当前列表框不可用
		multiple	用于让多行列表框支持多选
	//<span>标记——在行内定义一个区域的标记 
		<span id="id" style="style" class="classname">文字</span>
		id		ID标识
		style	设置CSS样式
		class	通过类选择器设置CSS样式
	//<strike>标记——删除线标记 
		<strike>文字</strike>
	//<strong>标记——文字粗体标记 
		<strong>文字</strong>
	//<style>标记——设置样式标记 
		<style type="text/css" media="value"></style>
		type	指定样式的MIME类型，css的MIME类型为text/css
		media	指定输出的媒体，可选值all所有类型，aural声音输出，braille点字机，handheld掌上电脑，print打印机，screen屏幕
	//<sub>标记——设置下标字标记 
		<sub>文字</sub>
	//<sup>标记——设置上标字标记 
		<sup>文字</sup>
	//<table>标记——表格标记 
		<table width="value" border="digit" cellspacing="value" cellpadding="value" height="value" background="uri" bordercolor="rgb"
		bordercolordark="rgb" bordercolorlight="rgb" bgcolor="rgb" frame="value" rules="value"></table>
		width				指定宽度	
		height				指定高度
		border				指定表格边框的宽度
		cellspacing			指定单元格与单元格之间的间距
		cellpadding			指定单元格间的间距
		bordercolor			指定表格整体边框线的颜色
		bordercolordark		指定表格整体暗面边框线的颜色
		bordercolorlight	指定表格整体亮面边框线的颜色
		background			指定表格的背景图案
		bgcolor				指定表格的背景颜色，background属性优先
		frame				指定在显示表格时所用的外部框线
		rules				指定在显示表格时所用的内部框线
		frame属性的可选值
			above	显示上边框
			below	显示下边框
			border	显示上下左右边框
			box		与border一样
			hsides	显示上下边框
			lhs		显示左边框
			rhs		显示右边框
			void	不显示表框
			vsides	显示左右边框
		rules属性的可选值
			all		显示所有内部边框
			cols	仅显示行边框
			groups	显示介于行列间的边框
			none	不显示内部边框
			rows	仅显示列边框
	//<td>标记——表格的单元格标记 
		<td width="digit" height="digit" bgcolor="rgb" background="uri" align="value" nowrap="nowrap"
		rowspan="digit" colspan="digit" valign="value"></td>
		width		指定单元格的宽度
		height		指定单元格的高度
		bgcolor		指定单元格的背景颜色
		background	指定单元格的背景图案
		align		指定单元格内容的水平对齐方式
		nowrap		指定单元格内文字自动换行
		rowspan		指定单元格垂直合并的行数
		colspan		指定单元格水平合并的行数
		valign		指定单元格内容对齐方式
	//<textarea>标记——多行文本框标记 
		<textarea cols="digit" rows="digit" name="name" disabled="disabled" readonly="readonly"
		wrap="value">默认值</textarea>
		name		指定多行文本框的名称
		cols		指定多行文本框显示的列数
		rows		指定多行文本框显示的行数
		disabled	指定当前多行文本框不可用
		readonly	指定当前多行文本框为只读
		wrap		设置多行文本中的文字是否自动换行
		wrap的可选值
			hard	默认值，自动换行
			soft	自动换行
			off		不自动换行
	//<th>标记——表格的标题栏标记 
		<th width="digit" height="digit" bgcolor="rgb" background="uri" align="value" nowrap="nowrap" rowspan="digit"
		colspan="digit" valign="value"></th>
	//<title>标记——文档标题标记 
		<title>文字</title>
	//<tr>标记——表格行标记 
		<tr align="value" valign="value" bgcolor="rgb" height="digit"></tr>
	//<u>标记——下划线标记 
		<u>文字</u>
	//<ul>标记——无序列表标记 
		<ul type="type"></ul>
CSS样式表 
	//background属性——设置背景 
		background: background-color background-image background-repeat background-attachment background-position;
	//background-attachment属性——设置背景图片是否固定 
		background-attachment: scroll/fixed;
	//background-color属性——设置背景颜色 
		background-color: 属性值;
	//background-image属性——设置背景图片 
		background-image:属性值;
	//background-position属性——设置背景图片的显示位置 
		background-position: top/center/bottom/left/right;
	//background-repeat属性——指定背景图片的排列方式 
		background-repeat: repeat/no-repeat/repeat-x/repeat-y;
	//border属性——设置边框属性 
		border: border-width border-style border-color;
	//border-color属性——设置边框的颜色 
		border-color: 属性值;
	//border-style属性——设置边框的样式 
		border-style: none/hidden/dotted/dashed/solid/double/groove/ridge/inset/outset;
	//border-width属性——指定边框的宽度 
		border-width: medium/thin/thick/length;
	//bottom属性——设置底边的距离 
		bottom: 属性值;
	//clear属性——设置不允许有浮动对象的边 
		clear: none/left/right/both;
	//color属性——指定文本的颜色 
		color: 属性值;
	//cursor属性——设置鼠标指针的形状 
		cursor: auto/crosshair/default/hand/move/help/wait/text/w-resize/s-resize/n-resize/e-resize/ne-resize/sw-resize/
		s-resize/n-resize/e-resize/ne-resize/sw-resize/se-resize/nw-resize/pointer;
	//display属性——设置对象的显示形式 
		display: block/none/inline/marker/inline-table/list-item/run-in/table/table-caption/table-cell/table-column/table-colum-group/
		table-footer-group/table-header-group/table-row/table-row-group;
	//float属性——指定对象是否及如何浮动 
		float: none/left/right;
	//font属性——字体属性 
		font:font-style/font-variant/font-weight/font-size/line-height/font-family;
	//font-family属性——指定字体名称 
		font-family: 字体名称;
	//font-size属性——指定文字大小 
		font-size: absolute-size/relative-size/length;
	//font-style属性——指定文字的样式 
		font-style: normal/italic/oblique;
	//font-weight属性——指定文字字体的粗细 
		font-weight: normal/bold/bloder/lighter/number;
	//height属性——指定对象的高度 
		height: auto/length;
	//left属性——指定左边的距离 
		left: 属性值;
	//letter-spacing属性——指定字符间距 
		letter-spacing: normal/length;
	//line-height属性——指定对象的行高 
		line-height: normal/length;
	//list-style属性——指定项目符号的样式 
		list-style: list-style-image/list-style-position/list-style-type;
	//margin属性——指定对象的外边距 
		margin: auto/length;
	//overflow属性——指定内容超过显示范围的处理方式 
		overflow: visible/auto/hidden/scroll;
	//padding属性——指定对象的内边距 
		padding: length;
	//position属性——指定对象的定位方式 
		position: static/absolute/fixed/relative;
	//right属性——指定右边的距离 
		right: 属性值;
	//text-align属性——指定文本的对齐方式 
		text-align: left/right/center/justify;
	//text-decoration属性——为文字加上装饰效果 
		text-decoration: none/underline/blink/overline/line-through;
	//text-indent属性——设置文本的缩进 
		text-indent: length;
	//top属性——设置顶边的距离 
		top:属性值;
	//white-space属性——设置对象内空格、Tab和换行的处理方式 
		white-space: normal/pre/nowrap;
	//width属性——指定对象的宽度 
		width: auto/length;
	//z-index属性——指定对象的层叠次序 
		z-index: auto/number;
JavaScript语言 
	//date.getDate()方法——返回日期对象中的日 
		var date=new Date();
		day=date.getDate();
		alert(day);
	//date.getDay()方法——返回日期对象中的星期 
		var date=new Date();
		week=date.getDay();
		alert(week);
	//date.getFullYear()方法——返回日期对象中的完整年份 
		var date=new Date();
		year=date.getFullYear();
		alert(year);
	//date.getHours()方法——返回日期对象中的小时 
		var date=new Date();
		hours=date.getHours();
		alert(hours);
	//date.getMilliseconds()方法——返回日期对象中的毫秒部分 
		var date=new Date();
		milliseconds=date.getMilliseconds();
		alert(milliseconds);
	//date.getMinutes()方法——返回日期对象中的分钟部分 
		var date=new Date();
		minutes=date.getMinutes();
		alert(minutes);
	//date.getMonth()方法——返回日期对象中的月份 
		var date=new Date();
		month=date.getMonth();
		alert(month);
	//date.getSeconds()方法——返回日期对象中的秒钟部分 
		var date=new Date();
		seconds=date.getSeconds();
		alert(seconds);
	//date.getTime()方法——返回日期对象的毫秒数 
		var date=new Date();
		time=date.getTime();
		alert(time);
	//date.toLocaleDateString()方法——返回本地日期 
		var date=new Date();
		localeDateString=date.toLocaleDateString();
		alert(localeDateString);
	//date.toLocaleTimeString()方法——返回本地时间 
		var date=new Date();
		localeTimeString=date.toLocaleTimeString();
		alert(localeTimeString);
	//document.getElementById()方法——通过元素的ID属性获取元素 
		<div id="clock">获取时间</div>
		<script language="javascript">
			object=document.getElementById("clock");
			alert(object.innerHTML);
		</script>
	//document.getElementsByName()方法——通过元素的name属性获取元素 
		<div name="clock">获取时间</div>
		<script language="javascript">
			object=document.getElementsByName("clock")[0];
			alert(object.innerHTML);
		</script>
	//document.getElementsByTagName()方法——通过元素的标记名获取元素 
		<div name="clock">获取时间</div>
		<script language="javascript">
			object=document.getElementsByTagName("div");
			alert(object[0].innerHTML);
		</script>
	//form.action属性——获取或设置表单提交的URL地址 
		<form name="form1" action="deal.jsp"></form>
		<script language="javascript">
			url=form1.action;
			alert(url);
		</script>
	//form.reset()方法——重置表单 
		<form name="form1" action="deal.jsp"></form>
		<script language="javascript">
			form1.reset();
		</script>
	//form.submit()方法——提交表单 
		<form name="form1" action="deal.jsp"></form>
		<script language="javascript">
			form1.submit();
		</script>
	//Global对象eval()方法——计算JavaScript代码串 
		eval(month+1);
	//Global对象isNaN()方法——判断是否是非数字的值 
		isNaN(0/0);
	//Global对象parseFloat()方法——从字符串中解析一个浮点数 
		parseFloat("3.14f");
	//Global对象parseInt()方法 
		parseInt("0x529E");
	//history.back()方法——返回到前一个URL 
		history.back();
	//location.href属性——查看或设置当前网页的URL 
		window.location.href
	//location.reload()方法——刷新页面 
		location.reload();
	//regExp.exec()方法——执行模式（正则表达式）匹配 
		regExp.exec(str);
	//regExp.test()方法——执行模式（正则表达式）匹配 
		regExp.test(str);
	//string.charAt()方法——获取字符串中指定位置处的字符 
		var word=new String("I LIKE JAVA");
		var code=word.charAt(5);
	//string.charCodeAt()方法——获取字符串中指定位置字符的Unicode编码 
		var word=new String("I LIKE JAVA");
		var code=word.charCodeAt(5);
	//string.indexof()方法——返回第一次出现子字符串的位置 
		var word=new String("I LIKE JAVA");
		var code=word.indexof("L");
	//string.lastIndexOf()方法——最后一次出现子字符串的位置 
		var word=new String("I LIKE JAVA");
		var code=word.lastIndexOf("L");
	//string.length属性——获取字符串的长度 
		var word=new String("I LIKE JAVA");
		var len=word.length;
	//string.replace()方法——替换一个与正则表达式匹配的子串 
		var word=new String("I LIKE JAVA");
		var regExp="JAVA";
		var code=word.replace(regExp,"JAVAWEB");
	//string.split()方法——分割字符串为数组 
		var word=new String("I-LIKE-JAVA");
		var arr=word.split("-");
	//string.substr()方法——求子字符串 
		var word=new String("I LIKE JAVA");
		var code=word.substr(2,5);
	//string.substring()方法——返回指定位置的子字符串 
		var word=new String("I LIKE JAVA");
		var code=word.substring(2,5);
	//string.toLowerCase()方法——转换成小写字母 
		var word=new String("I LIKE JAVA");
		var code=word.toLowerCase();
	//string.toUpperCase()方法——转换成大写字母 
		var word=new String("i like java");
		var code=word.toUpperCase();
	//window.alert()方法——弹出提示对话框 
		alert("欢迎");
	//window.clearIntervale()方法——停止周期执行指定的代码 
		window.clearIntervale(timer)；
	//window.clearTimeout()方法——取消对指定代码的延迟执行 
		window.clearTimeout(timer)；
	//window.close()方法——关闭浏览器窗口 
		window.close()；
	//window.confirm()方法——弹出一个询问对话框 
		window.confirm("确认要关闭？")；
	//window.defaultStatus属性——设置状态栏默认文本 
		<body onload="window.defaultStatus='欢迎'"></body>
	//window.open()方法——打开一个新的浏览器窗口 
		window.open();
	//window.setInterval()方法——周期地执行指定的代码 
		window.setInterval("function()",1000)
	//window.setTimeout()方法——延迟代码的执行 
		window.setTimeout("function(),1000")
	//window.status属性——设置状态栏的信息 
		<body onload="window.status='欢迎'"></body>
XMLHttpRequest对象 
	//abort()方法——停止或放弃当前异步请求 
		http_request=new XMLHttpRequest();
		http_request.abort();
	//getAllResponseHeaders()方法——返回完整的HTTP头信息 
		http_request=new XMLHttpRequest();
		http_request.getAllResponseHeaders();
	//getResponseHeader()方法——返回指定的HTTP头信息 
		http_request=new XMLHttpRequest();
		http_request.getResponseHeader();
	//onreadystatechange属性——指定一个事件处理器 
		http_request=new XMLHttpRequest();
		http_request.onreadystatechange()=function(){
		};
	//open()方法——用于设置进行异步请求目标 
		http_request=new XMLHttpRequest();
		http_request.open("GET","deal.jsp",true);
	//readyState属性——用于获取请求状态 
		http_request=new XMLHttpRequest();
		http_request.readyState==4;
	//responseText属性——获取字符串格式的服务器响应 
		http_request=new XMLHttpRequest();
		http_request.responseText;
	//responseXML属性——用于获取XML格式的服务器响应 
		http_request=new XMLHttpRequest();
		http_request.responseXML;
	//send()方法——向服务器发送请求 
		http_request=new XMLHttpRequest();
		http_request.send(param);
	//setRequestHeader()方法——为请求的HTTP头设置值 
		http_request=new XMLHttpRequest();
		http_request.setRequestHeader("Content-Type","application/x-www-form-urlencoded");
	//statusText属性——返回HTTP状态码对应的文本 
		http_request=new XMLHttpRequest();
		http_request.statusText=="OK";
	//status属性——返回服务器的HTTP状态码 
		http_request=new XMLHttpRequest();
		http_request.status==200;
第二JSP技术篇
第JSP指令 
	//include指令——包含文件的指令 
		<%@include file="index.jsp?name=123"%>
	//Page指令——页面指令 
		<%@page autoFlush="true"%>
		//autoFlush:默认值true,当缓冲区满时，自动输出到客户端
		//buffer:设置out，使用缓冲区大小，设置none，表示不使用缓冲
		//contentType:设置页面响应MIME类型，设置text/html
		//errorPage:当前页面调用错误时所调用的页面
		//extends:JSP页面转为Servlet后继承的类
		//import:jsp导入需要用到的包
		//info:设置为任意字符，如当前的作者或其他有关的页面信息
		//isErrorPage:设置true，当前页面可以使用exception异常对象
		//isELIgnored:通过该属性设置，可以使JSP容器忽略表达式语言“${}”
		//isThreadSafe:设置true.表示当前JSP页面被转换为servlet后，会以多线程的方式来处理来自多个用户的请求
		//language:设置当前页面中编写JSP脚本使用的语言，默认值为“java”
		//pageEncoding:设置JSP页面字符的编码，默认值“ISO-8859-1”
		//session:设置是否需要使用服务器内置的session对象，默认值true，表示当前页面支持session
	//taglib指令——引入标签库指令 
		<%@ taglib uri="tagURI" prefix="tagPrefix" %>
		//uri:指定了JSP在WEB.XML文件中查找的标签库描述符
		//prefix:指定一个在页面中使用由uri属性的标签库的前缀
	//第JSP动作标签 
	//jsp:fallback——提示信息标签 
		<jsp:plugin type="applet" code="com.source.MyApplet.class" codebase=".">
			<jsp:fallback>加载Applet失败</jsp:fallback>
		</jsp:plugin>
	//jsp:forward——请求转发标签 
		<jsp:forward page="url">
			<jsp:param name=“name” value="value">
		</jsp:forward>
		//page:属性指定了目标的路径
	//jsp:getProperty——数据获取标签 
		<jsp:getProperty name="bean name" property="property"/>
	//jsp:include——页面包含标签 
		<jsp:include>
			<jsp:param name="name" valude="valude"/>
		</jsp:include>
	//jsp:param——赋值标签 
		<jsp:param name="name" value="value"/>
	//jsp:params——多参数赋值标签 
		<jsp:params>
			<jsp:param name="name" value=“value”/>
		</jsp:params>
	//jsp:setProperty——属性值设定标签 
		<jsp:setProperty name="bean name"/>
	//jsp:useBean——在页面Bean中引入标签 
		
第JSP内置对象 
application对象 
	//getAttribute方法——获取属性值 
	<%
        application.getAttribute("user");
    %>	
	//getAttributeNames方法——获取所有的属性名 
	<%
        Enumeration names = application.getAttributeNames();
        while (names.hasMoreElements()){
            out.print(names.nextElement()+"<br>");
        }
    %>	
	//getContextPath方法——返回当前Web应用的路径 
	<%
        String path = application.getContextPath();
        out.print(path);
    %>	
	//getMajorVersion方法——返回服务器支持的Servlet API最大版本号 
	<%
        int i = application.getMajorVersion();
        out.print(i);
    %>	
	//getMimiType方法——返回指定文件的MIME类型 
	<%
        String mimeType = application.getMimeType("photo.jpg");
        out.print(mimeType);
    %>	
	//getMinorVersion方法——返回服务器支持的Servlet API最小版本号 
	<%
        int minorVersion = application.getMinorVersion();
        out.print(minorVersion);
    %>	
	//getNamedDispatcher方法——根据指定参数名返回RequestDispatcher对象 
	<%
        RequestDispatcher rd = application.getNamedDispatcher("test2");
        rd.forward(request,response);
    %>	
	//getRealPath方法——获取虚拟路径的真实路径 
	<%
        String path = application.getRealPath("index.jsp");
        out.print(path);
    %>	
	//getRequestDispatcher方法——根据指定路径名返回RequestDispatcher对象 
	<%
        RequestDispatcher rd = application.getRequestDispatcher("/index.jsp");
        rd.forward(request,response);
    %>	
	//getResource方法——获取指定资源的URL路径 
	<%
        URL url = application.getResource("index.jsp");
        out.print(url);
    %>	
	//getResourceAsStream方法——返回指定资源的输入流对象 
	<%
        InputStream in = application.getResourceAsStream("index.jsp");
    %>
	//getResourcePaths方法——返回指定目录下的所有文件 
	<%
        Set set = application.getResourcePaths("/");
        for (Iterator it = set.iterator();it.hasNext()){
            out.print(it.hasNext() + "<br>");
        }
    %>	
	//log方法——写入信息到Servlet的日志文件 
	<%
        application.log("message");
    %>	
	//getServletInfo方法——获取servlet容器的名称和当前版本 
	<%
        String info = application.getServerInfo();
        out.print(info);
    %>	
	//removeAttribute方法——移除指定属性 
	<%
        application.setAttribute("user","lzw");
        application.removeAttribute("user");
    %>	
	//setAttribute方法——设置属性 
	<%
        application.setAttribute("user","lzw");
        Date now = new Date();
        application.setAttribute("now",now);
    %>
	
config对象 
	//getInitParameter方法——获取初始参数的值 
	<%
        String name = config.getInitParameter("fork");
        out.print(name);
    %>	
	//getInitParameterNames方法——获取所有的初始参数的名字 
	<%
        Enumeration names = config.getInitParameterNames();
        while (names.hasMoreElements()){
            out.print(names.nextElement()+"<br>");
        }
    %>	
	//getServletContext方法——获取Servlet上下文 
	<%
        ServletContext sc = config.getServletContext();
    %>	
	//getServletName方法——获取Servlet的名字 
	<%
        String name = config.getServletName();
        out.print(name);
    %>
	
exception对象 
	//fillInStackTrace方法——在异常堆栈跟踪中填充 
	//getCause方法——返回产生异常的原因 
	//getMessage方法——获取异常消息文本 
	//getLocalizedMessage方法——获取本地化语言的异常错误 
	//getStackTrace方法——返回堆栈跟踪元素的数组 
	//initCause方法——设置初始化的异常信息 
	//printStackTrace方法——输出异常的栈跟踪轨迹 
	//setStackTrace方法——设置堆栈跟踪元素 
	//toString方法——返回异常的简短描述 
out输出对象 
	//clear方法——清除缓冲区中的数据 
	<%
        out.print("JAVA web");
    %>	
	//clearBuffer方法——清除缓冲区中的数据并输出到客户端 
	<%
        out.print("JAVA");
        out.clearBuffer();
    %>	
	//close方法——关闭JSP的输出流 
	<%
        out.print("JAVA");
        out.close();
    %>	
	//flush方法——清空当前缓冲区 
	<%
        out.print("JAVA");
        out.flush();
    %>	
	//getBufferSize方法——获得输出流缓冲区的大小 
	<%
        int size = out.getBufferSize();
        out.print(size);
    %>	
	//getRemaining方法——获得缓冲区的剩余空间 
	<%
        int size = out.getRemaining();
        out.print(size);
    %>	
	//isAutoFlush方法——判断缓冲区是否自动刷新 
	<%
        int size = out.getRemaining();
        out.print(out.isAutoFlush());
    %>	
	//newLine方法——写入一个行分隔符 
	<%
        out.print("JAVA");
        out.newLine();
        out.print("java web");
    %>	
	//print方法——输出数据到JSP页面 
	<%
        out.print("JAVA");
    %>	
	//println方法——输出空字符串和换行符号 
	<%
        out.println("JAVA");
    %>	
	
page对象 
	//equals方法——比较两个对象 
	<%
        boolean b = page.equals(page);
        out.print(b);
    %>	
	//getClass方法——获得page对象 
	<%
        out.print(page.getClass());
    %>	
	//hashCode方法——返回对象的哈希码值 
	<%
        out.print(page.hashCode());
    %>
	
pageContext对象 
	//forward方法——转发页面 
	<%
        pageContext.forward("/index.jsp");
    %>	
	//getErrorData方法——返回包含错误信息的ErrorData对象 
	<%
        pageContext.getErrorData();
    %>	
	//getAttribute方法——在指定范围内检索属性 
	<%
        pageContext.getAttribute("user",pageContext.SESSION_SCOPE);
    %>	
	//getPage方法——返回当前Page对象 
	<%
        pageContext.getPage();
    %>	
	//getRequest方法——获取当前的Request对象 
	<%
        HttpServletRequest req = (HttpServletRequest) pageContext.getRequest();
        String name = req.getParameter("name");
    %>	
	//getResponse方法——获取当前的Response对象 
	<%
        HttpServletResponse res = (HttpServletResponse) pageContext.getResponse();
        res.setHeader("refresh","1");
        out.print(new Date());
    %>	
	//getServletConfig方法——获取当前页面的ServletConfig对象 
	<%
        ServletConfig conf = pageContext.getServletConfig();
        String servletName = conf.getServletName();
        out.print(servletName);
    %>	
	//getServletContext方法——返回ServletContext的实例 
	<%
        ServletContext sc = pageContext.getServletContext();
    %>	
	//getSession方法——返回当前的Session对象 
	<%
        HttpSession s = pageContext.getSession();
        s.setAttribute("user","明日科技");
    %>	
	//include方法——在页面中包含文件 
	<%
        pageContext.include("/index.jsp");
    %>	
	//initialize方法——初始化PageContext对象 
	<%
        pageContext.initialize(this,request,response,"index.jsp",true,8,true);
    %>	
	//release方法——释放相关资源 
	<%
        pageContext.release();
    %>	
	//removeAttribute方法——移除指定范围对象中的属性 
	<%
        pageContext.removeAttribute("user",pageContext.APPLICATION_SCOPE);
    %>
	//setAttribute方法——设置属性 
	<%
        pageContext.setAttribute("user","lzw",pageContext.APPLICATION_SCOPE);
    %>	
	
request对象 
	//getAttribute方法——获取指定的属性值 
	<%
        Object date = request.getAttribute("time");
        out.print(date);
    %>	
	//getAttributeNames方法——返回所有属性的名字集合 
	<%
        Object date = request.getAttribute("time");
        Enumeration e = request.getAttributeNames();
        while (e.hasMoreElements()){
            out.print(e.nextElement());
        }
    %>	
	//getAuthType方法——返回保护servlet的认证方案名 
	<%
        out.print(request.getAuthType());
    %>	
	//getCookies方法——获取cookie对象 
	<%
        Cookie[] cookies = request.getCookies();
        out.print(cookies.length);
    %>	
	//getCharacterEncoding方法——返回字符编码格式 
	<%
        String encoding = request.getCharacterEncoding();
        out.print(encoding);
    %>	
	//getContentLength方法——获取请求的Body的长度 
	<%
        int len = request.getContentLength();
        out.print(len);
    %>	
	//getContextPath方法——返回当前Web所在的目录 
	<%
        out.print(request.getContextPath());
    %>	
	//getDateHeader方法——获取构建Date对象的long值 
	<%
        out.print(request.getDateHeader("Expires"));
    %>	
	//getHeader方法——获得Http协议定义的文件头 
	<%
        String ct = request.getHeader("content-type");
        out.print("Content-type:"+ct);
    %>	
	//getHeaders方法——返回指定名字的request header的所有值 
	<%
        Enumeration cts = request.getHeaders("accept-encoding");
        while (cts.hasMoreElements()){
            out.print("accpet-encoding="+cts.nextElement());
        }
    %>	
	//getHeadersNames方法——返回所有request header的名字 
	<%
        Enumeration cts = request.getHeaderNames();
        while (cts.hasMoreElements()){
            out.print(cts.nextElement());
        }
    %>	
	//getInputStream方法——获取request对象的输入流 
	<%
        ServletInputStream is = request.getInputStream();
    %>	
	//getIntHeader方法——获取客户端请求中对应的头信息 
	<%
        out.print(request.getIntHeader("Expires"));
    %>	
	//getMethod方法——获取客户端向服务器传送数据的方法 
	<%
        String mName = request.getMethod();
        out.print(mName);
    %>	
	//getParameter方法——获得客户端传送给服务器端的参数值 
	<%
        String name = request.getParameter("name");
        out.print(name);
    %>	
	//getParameterValues方法——获得指定参数的所有值 
	<%
        String[] likes = request.getParameterValues("like");
        if (likes == null) return;
            out.print("用户的爱好包括");
        for (int i=0;i<likes.length;i++) {
            out.print(likes[i]);
        }
    %>	
	//getPathInfo方法——返回客户请求URL的路径信息 
	<%
        out.print(request.getPathInfo());
    %>	
	//getPathTranslated方法——获取URL的路径信息 
	<%
        out.print(request.getPathTranslated());
    %>	
	//getProtocol方法——获取客户端向服务器传送的协议名称 
	<%
        String p = request.getProtocol();
        out.print(p);
    %>	
	//getQueryString方法——获得查询字符串 
	<%
        String p = request.getQueryString();
        out.print(p);
    %>	
	//getRemoteUser方法——获取请求用户的登录信息 
	<%
        out.print(request.getRemoteUser());
    %>	
	//getRequestURI方法——获得客户端访问网站的相对路径 
	<%
        String p = request.getRequestURI();
        out.print(p);
    %>	
	//getRequestURL方法——获得客户端访问网站的绝对路径 
	<%
        StringBuffer p = request.getRequestURL();
        out.print(p);
    %>	
	//getRemoteAddr方法——获取请求客户端的IP地址 
	<%
        String p = request.getRemoteAddr();
        out.print(p);
    %>	
	//getRemoteHost方法——获取客户端的机器名称 
	<%
        String p = request.getRemoteHost();
        out.print(p);
    %>	
	//getRequestedSessionId方法——获得客户端访问网站的sessionid值 
	<%
        String p = request.getRequestedSessionId();
        out.print(p);
    %>	
	//getSession方法——获取和请求相关的session对象 
	<%
        HttpSession p = request.getSession(true);
        out.print(p.getId());
    %>	
	//getServerName方法——获取服务器的名字 
	<%
        String serName = request.getServerName();
        out.print(serName);
    %>	
	//getServerPath方法——获取客户端所请求页面的文件路径 
	<%
        String path = request.getServletPath();
        out.print(path);
    %>	
	//getServerPort方法——获取服务器的端口号 
	<%
        int port = request.getServerPort();
        out.print(port);
    %>	
	//getUserPrincipal方法——返回java.security.Principal对象 
	<%
        Principal p = request.getUserPrincipal();
    %>	
	//isRequestedSessionIdFromCookie方法——判断session ID是否从Cookie中获得 
	<%
        out.print(request.isRequestedSessionIdFromCookie());
    %>	
	//isRequestedSessionIdFromURL方法——判断session ID是否从URL中获得 
	<%
        out.print(request.isRequestedSessionIdFromURL());
    %>	
	//isRequestedSessionIdValid方法——返回session是否有效 
	<%
        out.print(request.isRequestedSessionIdValid());
    %>
	//isUserInRole方法——判断认证后的用户是否属于role中的成员 
	<%
        out.print(request.isUserInRole("lzw"));
    %>	
	//removeAttribute方法——删除请求中的一个属性 
	<%
        request.removeAttribute("user");
    %>		
	//setAttribute方法——设置request对象的属性 
	<%
        String name = "user";
        request.setAttribute("name",name);
    %>	
	
response对象 
	//addCookie方法——添加cookie对象 
	<%
        Cookie cookie = new Cookie("user", "lzw");
        response.addCookie(cookie);
    %>
	//addDateHeader方法——加入对应名称的日期头信息 
	<%
        long date = System.currentTimeMillis();
        response.addDateHeader("Expires",date);
    %>	
	//addHeader方法——添加HTTP文件头信息 
	<%
        response.addHeader("Refresh","1");
    %>	
	//addIntHeader方法——添加对应名称的int属性 
	<%
        response.addIntHeader("Expires",10);
    %>	
	//containsHeader方法——判断指定名字的HTTP文件头是否已经存在 
	<%
        response.addHeader("Refresh","1");
        boolean b = response.containsHeader("Refresh");
        out.print("Refresh:"+b);
    %>	
	//getCharacterEncoding方法——获得响应的字符编码类型 
	<%
        String encode = response.getCharacterEncoding();
        out.print("响应客户端的编码格式:"+encode);
    %>	
	//getOutputStream方法——获取JSP应答对象的输出流 
	<%
        ServletOutputStream os = response.getOutputStream();
        os.write("<b>编程词典</b>".getBytes());
        os.close();
    %>	
	//sendError方法——向客户端发送错误信息 
	<%
        response.sendError(404);
    %>	
	//sendRedirect方法——重定向响应 
	<%
        response.sendRedirect("www.baidu.com");
    %>	
	//setContentType方法——设置响应对象的MIME类型 
	<%
        response.setContentType("video/X-msvideo");
    %>	
	//setDateHeader方法——设置响应头信息 
	<%
        long date = System.currentTimeMillis();
        response.setDateHeader("Expires",date);
    %>	
	//setHeader方法——设置头信息 
	<%
        out.println(new Date());
        response.setHeader("Refresh","1");
    %>	
	//setStatus方法——设置响应的状态编码 
	<%
        response.setStatus(200);
    %>
	
session对象 
	//getAttribute方法——根据属性名获取属性值 
	<%
        session.getAttribute("user");
    %>	
	//getAttributeNames方法——获取session对象的所有属性名称 
	<%
        session.getAttribute("user");
        Enumeration names = session.getAttributeNames();
        while (names.hasMoreElements()){
            out.print(names.nextElement()+"<br>");
        }
    %>	
	//getCreationTime方法——获取session对象被创建的时间 
	<%
        session.setAttribute("user","lzw");
        long timenum = session.getCreationTime();
        out.print("Session创建时间:"+timenum);
    %>	
	//getId方法——获取唯一的ID标识 
	<%
        String ID = session.getId();
        out.print("这个session的ID是："+ID);
    %>	
	//getLastAccessedTime方法——获取session最后的访问时间 
	<%
        long timeNum = session.getLastAccessedTime();
        Date data = new Date(timeNum);
        out.print("这个session最后访问时间:"+data);
    %>	
	//getMaxInactiveInterval方法——获取session的有效时间 
	<%
        int timeNum = session.getMaxInactiveInterval();
        out.print("这个session的有效时间是"+timeNum);
    %>	
	//getServletContext方法——返回session所属的ServletContext对象 
	<%
        ServletContext sc = session.getServletContext();
    %>	
	//invalidate方法——销毁session对象 
	<%
        session.invalidate();
    %>	
	//isNew方法——判断当前用户是否为新用户 
	<%
        out.print(session.isNew());
    %>	
	//setAttibute方法——设置指定名称的属性值 
	<%
        session.setAttribute("information","向session中保存数据");
        response.sendRedirect("index.jsp");
    %>	
	//setMaxInactiveInterval方法——设置session的有效期 
	<%
        session.setMaxInactiveInterval(30);
    %>	
	//removeAttribute方法——移除指定的session属性 
	<%
        session.removeAttribute("user");
    %>
	
第EL表达式 
运算符 
	//“[]”运算符——存取数据 
		${object[param]}
	//“.”运算符——取得对象的属性 
		${object.param}
	//“+”运算符——加法运算 
		${expression1+expression2}
	//“-”运算符——减法运算 
		${expression1-expression2}
	//“*”运算符——乘法运算 
		${expression1*expression2}
	//“/”或“div”运算符——除法运算 
		${expression1/expression2}
	//“%”或“mod”运算符——求余运算 
		${expression1%expression2}
	//“==”与“eq”运算符——判断两个表达式是否相等 
		${expression1==expression2}
	//“!=”与“ne”运算符——判断两个表达式是否不等 
		${expression1!=expression2}
	//“<”与“It”运算符——用于进行小于运算 
		${expression1<expression2}
	//“>”与“gt”运算符——用于进行大于运算 
		${expression1>expression2}
	//“<=”与“le”运算符——用于进行小于等于运算 
		${expression1<=expression2}
	//“>=”与“ge”运算符——用于进行大于等于运算 
		${expression1>=expression2}
	//“&&”与“and”运算符——与运算 
		${expression1&&expression2}
	//“||”与“or”运算符——或运算 
		${expression1||expression2}
	//“!”与“not”运算符——非运算 
		${expression1!expression2}
	//empty运算符——判断是否为null或空 
		${empty expression}
		
EL表达式中的隐含对象 
	//applicationScope对象——访问application作用域范围的隐含对象 
		${application.expression}
	//cookie对象——访问由请求设置的cookie名称 
		${cookie expression}
	//header对象——获取HTTP请求的一个具体header值 
		${header.expression}
	//headerValues对象——获取HTTP请求的全部header值 
		${headerValues.expression}
	//initParam对象——获取Web应用初始化参数的值 
		${initParam.expression}
	//PageContext对象——访问JSP内置对象 
		${PageContext.request[expression]}
	//param对象——获取请求参数的值 
		${param.value}
	//paramValues对象——获取请求参数的值 
		${paramValues.value}
	//requestScope对象——访问request作用域范围的隐含对象 
		${requestScope.expression}
	//sessionScope对象——访问session作用域范围的隐含对象 
		${sessionScope.expression}
		
第JSTL标签库 
JSTL核心标签库 
	//<c:catch>标签——捕获异常标签 
		<c:catch [var="var"]>
		</c:catch>
	//<c:choose>标签——选择标签 
		<c:choose>
			<c:when>
			</c:when>
			<c:otherwise>
			</c:otherwise>
		</c:choose>
	//<c:forEach>标签——对对象进行迭代输出标签 
		<c:forEach items="data" var="name" begin="start" end="finish" step="step" varStatus="statusName">
		</c:forEach>
	//<c:forTokens>标签——对字符串进行迭代输出标签 
		<forTokens delims="char" items="data" var="name" begin="start" end="finish" step="step" varStatus="statusName">
		//delims:分割符
	//<c:if>标签——条件判断标签 
		<c:if test="condition" var="name" [scope=""] />
	//<c:import>标签——文件导入标签 
		<c:import  url="" [context=""] [var=""] [scope=""] [charEncoding=""]></c:import>
	//<c:otherwise>标签——指定默认处理逻辑标签 
		<c:otherwise>
		</c:otherwise>
	//<c:out>标签——输出标签 
		<c:out value="" [escapeXml="true"] [defailt="defalultValue"]>
		</c:out>
	//<c:param>标签——参数传递标签 
		<c:param name="" value=""/>
	//<c:remove>标签——移除标签 
		<c:remove var="" [scope=""] />
	//<c:redirect>标签——重定向标签 
		<c:redirect url="" [context=""]>
		<c:redirect>
	//<c:set>标签——设置标签 
		<c:set var="" [scope=""]
		</c:set>
	//<c:url>标签——生成URL地址标签 
		<c:url value="" [var="name"] [scope=""] [ context=""]/>
	//<c:when>标签——条件标签 
		<c:when test="">
		</c:when>
		
JSTL的格式化与国际化标签库 
	//<fmt:bundle>标签——读取绑定消息资源 
	//<fmt:formatDate>标签——格式化时间 
	//<fmt:formatNumber>标签——格式化数字 
	//<fmt:message>标签——读取本地消息 
	//<fmt:param>标签——指定资源参数 
	//<fmt:parseNumber>标签——转换为数字 
	//<fmt:parseDate>标签——转换为时间 
	//<fmt:requestEncoding>标签——设置编码 
	//<fmt:setBundle>标签——指定消息资源 
	//<fmt:setTimeZone>标签——格式化时区 
	//<fmt:setLocale>标签——设置语言区域 
	//<fmt:timeZone>标签——格式化时区 
		
JSTL的SQL标签库 
	//<sql:dateParam>标签——填充日期型参数 
	//<sql:param>标签——指定SQL参数 
	//<sql:query>标签——通过SQL语句查询 
	//<sql:setDataSource>标签——设置数据源 
	//<sql:transaction>标签——事务处理 
	//<sql:update>标签——更新数据 
		
JSTL的XML标签库 
	//<x:choose>标签——完成条件判断 
	//<x:forEach>标签——遍历XML文件 
	//<x:if>标签——XPath条件执行JSP代码 
	//<x:otherwise>标签——不满足条件执行 
	//<x:out>标签——输出XML信息 
	//<x:param>标签——定义参数 
	//<x:parse>标签——解析指定的XML内容 
	//<x:set>标签——保存XML节点 
	//<x:transform>标签——XML到XSLT转换 
	//<x:when>标签——根据条件执行代码