Java 快速入门与 Web 应用开发

competition java

第一部分 Java 语言快速入门

一、Java 语言的特点

• Java 语言是静态类型、编译型语言
• Java 语言源程序文件的扩展名是 .java
• Java 语言源程序需要用编译器（javac）编译成 Java 虚拟机（java）能够执行的字节码才能运行。
• 编译后的 Java 语言程序文件的扩展名是 .class，每个类都会被编译成一个单独的 .class 文件。
• Java 是纯粹的面向对象的编程语言。

二、第一个 Java 程序

在某个文件夹建立一个文件 MyApp.java。内容如下：

public class MyApp {
    public static void main(String[] args) {
        System.out.println("Hello");
    }
}

保存后，打开命令窗口，进入 MyApp.java 所在的文件夹（如：D:\work）：

D:\work>javac MyApp.java
D:\work>_
D:\work>java MyApp
Hello
D:\work>_

三、Java 程序的一些规定

• 一切都是类，所有代码都写在类中。
• 每个程序文件只能由一个公开类（public）,且这个公开类的名称必须与文件名（不含扩展名）完全一致。
• 只有带有（由 public static void 修饰的）main 函数的 Java 类才能被 Java 虚拟机直接载入执行。
• Java 以文件夹的层次结构来组织代码，一个叫 com.artmansoft.Util 的类，一定处于 com/artmansoft 文件夹下。
• Java 的软件包以 jar 压缩包的形式提供，其中是以文件夹层次结构来组织代码类的集合。
• 为了找到各个类，虚拟机需要知道如何搜索类，这是通过 classpath 来定义的。

四、Java 的类定义

/**
类的说明
...
*/
public class Student {
    // 属性
    public String name;
    public String gender;
    // 构造函数
    public Student(){
    }
    // 构造函数
    public Student(String name, String gender){
        this.name = name;
        this.gender = gender;
    }
    // 方法
    public void Greet(String someone){
        System.out.println("Hi, "+someone+"!");
    }
}

五、测试类定义

在某个文件夹中创建 MyApp.java 文件，内容如下：

public class MyApp {
    public static void main(String[] args){
        Student st; // 声明一个可装载 Student 对象的变量
        st = new Student(); // 生成一个对象给 st
        st.name = "Billy"; // 给对象的 name 赋值
        st.gender = "Male"; // 给对象的 gender 赋值
        System.out.println(st.name + " " + st.gender);
        // 传入参数给构造函数生成对象
        Student st2 = new Student("Tracy","Female");
        System.out.println(st2.name + " " + st2.gender);
        st2.greet("Tina"); // 调用 st2 对象的 greet 方法
    }
}
class Student {
    // 属性
    public String name;
    public String gender;
    // 空构造函数，可用 new Student() 的形式生成（构造）对象
    public Student(){}
    // 带参数的构造函数，可用 new Student("Tracy","Female") 的形式构造
    public Student(String name, String gender){
        this.name = name;
        this.gender = gender;
    }
    // 方法
    public void greet(String someone_name){
        System.out.println("Hello, "+someone_name+".");
    }
}

六、Java 内置的基本数据类型

Java语言提供了八种基本类型。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。

byte：
- byte 数据类型是8位、有符号的，以二进制补码表示的整数；
- 最小值是 -128（-2^7）；
- 最大值是 127（2^7-1）；
- 默认值是 0；
- byte 类型用在大型数组中节约空间，主要代替整数，因为 byte 变量占用的空间只有 int 类型的四分之一；
- 例子：byte a = 100，byte b = -50。

short：

• short 数据类型是 16 位、有符号的以二进制补码表示的整数
• 最小值是 -32768（-2^15）；
• 最大值是 32767（2^15 - 1）；
• Short 数据类型也可以像 byte 那样节省空间。一个short变量是int型变量所占空间的二分之一；
• 默认值是 0；
• 例子：short s = 1000，short r = -20000。

int：

• int 数据类型是32位、有符号的以二进制补码表示的整数；
• 最小值是 -2,147,483,648（-2^31）；
• 最大值是 2,147,483,647（2^31 - 1）；
• 一般地整型变量默认为 int 类型；
• 默认值是 0 ；
• 例子：int a = 100000, int b = -200000。

long：

• long 数据类型是 64 位、有符号的以二进制补码表示的整数；
• 最小值是 -9,223,372,036,854,775,808（-2^63）；
• 最大值是 9,223,372,036,854,775,807（2^63 -1）；
• 这种类型主要使用在需要比较大整数的系统上；
• 默认值是 0L；
• 例子： long a = 100000L，Long b = -200000L。
• "L"理论上不分大小写，但是若写成"l"容易与数字"1"混淆，不容易分辩。所以最好大写。

float：

• float 数据类型是单精度、32位、符合IEEE 754标准的浮点数；
• float 在储存大型浮点数组的时候可节省内存空间；
• 默认值是 0.0f；
• 浮点数不能用来表示精确的值，如货币；
• 例子：float f1 = 234.5f。

double：

• double 数据类型是双精度、64 位、符合IEEE 754标准的浮点数；
• 浮点数的默认类型为double类型；
• double类型同样不能表示精确的值，如货币；
• 默认值是 0.0d；
• 例子：double d1 = 123.4。

boolean：

• boolean数据类型表示一位的信息；
• 只有两个取值：true 和 false；
• 这种类型只作为一种标志来记录 true/false 情况；
• 默认值是 false；
• 例子：boolean one = true。

char：

• char类型是一个单一的 16 位 Unicode 字符；
• 最小值是 \u0000（即为0）；
• 最大值是 \uffff（即为65,535）；
• char 数据类型可以储存任何字符；
• 例子：char letter = 'A';。

七、引用其它类

在某个目录下，比如 D:\LearnJava 下，创建一个名为 Student.java 的文件，内容如下：

public class Student {
    public String name;
    public String gender;
    public Student(){}
    public Student(String name, String gender){
        this.name = name;
        this.gender = gender;
    }
    public void greet(String someone_name){
        System.out.println("Hello, "+someone_name+".");
    }
}

然后再在此目录下创建一个名为 MyApp.java 的文件，内容如下：

public class MyApp {
    public static void main(String[] args){
        Student st;
        st = new Student();
        st.name = "Billy";
        st.gender = "Male";
        System.out.println(st.name + " " + st.gender);
        Student st2 = new Student("Tracy","Female");
        System.out.println(st2.name + " " + st2.gender);
        st2.greet("Tina");
    }
}

接着在命令窗口中：

D:\LearnJava> javac *.java
D:\LearnJava>_
D:\LearnJava> java MyApp
[输出]
D:\LearnJava>_

结论： MyApp 类运行时，能从当前文件夹找到 Student.class 类程序文件。

八、创建软件包

打开命令窗口，输入以下命令（如果没有D盘，可替换为C盘）：

mkdir d:\java_lib\com\yntc\school

然后在创建的 school 文件夹下创建 Studeny.java 文件，内容如下：

package com.yntc.school; // 指定命名空间
public class Student {
    public String name;
    public String gender;
    public Student(){}
    public Student(String name, String gender){
        this.name = name;
        this.gender = gender;
    }
    public void greet(String someone_name){
        System.out.println("Hello, "+someone_name+".");
    }
}

然后到命令窗口：

cd /d d:\java_lib\com\yntc\school
D:\java_lib\com\yntc\school>_
D:\java_lib\com\yntc\school>javac *.java
D:\java_lib\com\yntc\school>cd ..\..\..
D:\java_lib>_
D:\java_lib>jar cvf school.jar com\yntc\school\*.class

这时，D:\java_lib 文件夹下会有一个 school.jar 文件，这就是我们创建的软件包。

九、引用软件包

在某个文件夹（比如 D:\LearnJava）中，创建 MyApp.java 文件，内容如下：

import com.yntc.school.*; // 引入 com\yntc\school 下的所有 .calss 文件。
public class MyApp {
    public static void main(String[] args){
        Student st;
        st = new Student();
        st.name = "Billy";
        st.gender = "Male";
        System.out.println(st.name + " " + st.gender);
        Student st2 = new Student("Tracy","Female");
        System.out.println(st2.name + " " + st2.gender);
        st2.greet("Tina");
    }
}

然后：

D:\LearnJava> javac -cp .;d:\java_lib\school.jar MyApp.java
D:\LearnJava>_
D:\LearnJava> java -cp .;d:\java_lib\school.jar MyApp
[输出]
D:\LearnJava>_

-cp 告诉 java 虚拟机，在当前位置（.）和 d:\java_lib\school.jar 软件包中搜索类文件（.class 文件）。

十、Java 面向对象编程 —— 继承

在面向对象编程（Obejct-Oriented Programming, OOP）中，所有涉及的事物都被分了类（class）。有时候，一些类可能有较多的共同点——共同的属性、共同的方法（行为）。这样，在定义这些类时，会出现重复代码。比如以下“学生”类和“教师”类。

学生类
D:\LearnJava\Student.java

import java.time.*;
import java.time.format.*;
public class Student {
    public String studentNo; 
    public String name;
    public String gender;
    public LocalDate dateOfBirth;
    public Student(){}
    // 此构造函数可能抛出错误：DateTimeParseException
    public Student(String studentNo, String name, String gender, String dateOfBirth) throws DateTimeParseException{
        this.studentNo = studentNo;
        this.name = name;
        this.gender = gender;
        try{
            this.dateOfBirth = LocalDate.parse(dateOfBirth);
        }
        catch(DateTimeParseException e){
            System.out.println("Parse Date Error On: " + e.getParsedString());
            throw e;
        }
    }
    // 获取年龄
    public int getYearsOld(){
        return this.dateOfBirth.until(LocalDate.now()).getYears();
    }
}

教师类
D:\LearnJava\Teacher.java

import java.time.*;
import java.time.format.*;
public class Teacher {
    public String name;
    public String gender;
    public LocalDate dateOfBirth;
    punlic String level;  // 职称
    public Teacher(){}
    // 此构造函数可能抛出错误：DateTimeParseException
    public Teacher(String name, String gender, String dateOfBirth, String level) throws DateTimeParseException{
        this.name = name;
        this.gender = gender;
        try{
            this.dateOfBirth = LocalDate.parse(dateOfBirth);
        }
        catch(DateTimeParseException e){
            System.out.println("Parse Date Error On: " + e.getParsedString());
            throw e;
        }
        this.level = level
    }
    // 获取年龄
    public int getYearsOld(){
        return this.dateOfBirth.until(LocalDate.now()).getYears();
    }
}

这时，可将他们共性的部分抽取出来，作为一个新类，如：“个人”，Person。

个人类

import java.time.*;
import java.time.format.*;
public class Person {
    public String name;
    public String gender;
    public LocalDate dateOfBirth;
    public Person(){}
    // 此构造函数可能抛出错误：DateTimeParseException
    public Person(String name, String gender, String dateOfBirth) throws DateTimeParseException{
        this.name = name;
        this.gender = gender;
        try{
            this.dateOfBirth = LocalDate.parse(dateOfBirth);
        }
        catch(DateTimeParseException e){
            System.out.println("Parse Date Error On: " + e.getParsedString());
            throw e;
        }
    }
    // 获取年龄
    public int getYearsOld(){
        return this.dateOfBirth.until(LocalDate.now()).getYears();
    }
}

然后，让“学生”类和“教师”类都继承（扩展：extends）“个人”类。

学生类

import java.time.*;
public class Student extends Person {
    public String studentNo;
    public Student(){}
    // 此构造函数可能抛出错误：DateTimeParseException
    public Student(String studentNo, String name, String gender, String dateOfBirth) throws DateTimeParseException{
        super(name,gender,dateOfBirth); // 调用父类构造函数
        this.studentNo = studentNo;
    }
}

教师类

import java.time.*;
public class Teacher extends Person {
    public String level;
    public Teacher(){}
    // 此构造函数可能抛出错误：DateTimeParseException
    public Teacher(String name, String gender, String dateOfBirth, String level) throws DateTimeParseException{
        super(name,gender,dateOfBirth); // 调用父类构造函数
        this.level = level;
    }
}

以下测试。

D:\LearnJava\MyApp.java

import java.time.*;
public class MyApp {
    public static void main(String[] args){
        Student st;
        try{
            st = new Student("S001","Billy","Male","1982-10-10");
            System.out.printf("%s's StudentNo is %s and  is %d years old.\n", st.name,st.studentNo, st.getYearsOld()); 
        }
        catch(DateTimeParseException e){
            System.out.println("Parse Date Error! Create Student Object Failed!");
        }
        Teacher te;
        try{
            te = new Teacher("Tina","Female","1996-03-28","Senior");
            System.out.printf("%s' level is %s  and is %d years old.\n", te.name, te.level,te.getYearsOld()); 
        }
        catch(DateTimeParseException e){
            System.out.println("Parse Date Error! Create Teacher Object Failed!");
        }
    }
}

十一、Java 面向对象编程 —— 继承（方法覆盖）

在继承中，子类（继承者）可以覆盖父类（被继承者）的方法。

public class MyApp {
    public static void main(String[] args) {
        Parent p = new Parent();
        p.doSomething();
        Child c = new Child();
        c.doSomething();
    }
}
class Parent{
    public void doSomething(){
        System.out.println("Parent");
    }
}
class Child extends Parent{
    @Override
    public void doSomething(){
        System.out.println("Child");
    }
}

如果继承的是抽象类（abstract class, 一种不能被实例化，即不能生成对象的类）, 其中的抽象方法就必须被覆盖。如下例：

public class MyApp {
    public static void main(String[] args) {
        // Shape s = new Shape(); // error!
        Circle c = new Circle(10);
        System.out.printf("The circle's area is: %.2f\n",c.getArea());
        System.out.println(c.getName()); // "Shape"
    }
}
abstract class Shape{
    abstract public float getArea(); //抽象方法没有函数体
    public String getName(){
        return "Shape";
    }
}
class Circle extends Shape {
    public float radius;
    public Circle(float radius){
        this.radius = radius;
    }
    // 自己不是抽象类，就必须覆盖父类的抽象方法
    @Override 
    public float getArea(){
        return 3.14f * radius * radius;
    }
}

十二、Java 面向对象编程 —— 继承（接口）

为不使问题复杂化，Java 语言的采用的是单继承，即一个类最多只能继承一个类。如果要实现从多个类继承的效果，可用接口（interface）替代类。一个类“实现(implement)”多个接口，意味着它就具有了所有这些接口的特征。
接口是一种“契约”，当一个类声称自己“实现（implement）”了某个接口时，就必须实现该接口。

一个类可以实现多个接口：

public class MyApp{
    public static void main(String[] args){
        HouseCar houseCar = new HouseCar();
        houseCar.clean();
        houseCar.lock();
        houseCar.start();
        houseCar.stop();
    }
}
interface House {
    public void clean();
    public void lock();
}
interface Car {
    public void start();
    public void stop();
}
class HouseCar implements House, Car {
    @Override
    public void clean(){
        System.out.println("Cleaning...")
    }
    public void lock(){
        System.out.println("Locking...")
    }
    public void start(){
        System.out.println("Starting...")
    }
    public void stop(){
        System.out.println("Stopped.")
    }
}

一个接口可以继承多个接口:

public class MyApp{
    public static void main(String[] args){
        HouseCar houseCar = new HouseCar();
        houseCar.clean();
        houseCar.lock();
        houseCar.start();
        houseCar.stop();
    }
}
interface House {
    public void clean();
    public void lock();
}
interface Car {
    public void start();
    public void stop();
}
interface IHouseCar extends House, Car{
    public void move();
}
class HouseCar implements IHouseCar {
    public void clean(){
        System.out.println("Cleaning...");
    }
    public void lock(){
        System.out.println("Locking...");
    }
    public void start(){
        System.out.println("Starting...");
    }
    public void stop(){
        System.out.println("Stopped.");
    }
    public void move(){
        System.out.println("Moving...");
    }
}

十三、Java 面向对象编程 —— 封装

封装，是指控制类和类成员的访问权限。
一个类是 public 的，那么，这个类可以为全世界使用。
一个类没有 public 修饰，那么这个类就只能被在同一个包中的其它类访问。

类的属性和方法可以有四个等级的访问权限：

• private，私有，只能在自己类中访问；
• protected，被保护的，只能在自己和自己各级子类中访问；
• public，公开的，能被全世界访问；
• 默认（不写以上三种修饰符），同一个包内的类可以访问。

如果一个类的属性是 private 或 protected 的，为了让外界能够访问，就需要编写一些 public 的方法来对这些属性进行存（set）取（get）。在这些方法中，可用程序逻辑对存取进行合理控制（如：存的值的合法性检查、取值者的身份核验等。）

public class MyApp{
    public static void main(String[] args){
        Person p = new Person("Tina","Female");
        System.out.println("Name: " + p.getName() + ", Gender: " + p.getGender()); 
    }
}
class Person {
    protected String name;
    protected String gender;
    public Person(String name, String gender){
        this.setName(name);
        this.setGender(gender);
    }
    // setter
    public void setName(String name){
        // 这里可插入 name 值合法性检查的代码
        this.name = name;
    }
    // getter
    public String getName(){
        // 这里可插入读取 name 的权限检查的代码
        return this.name;
    }
    public void setGender(String gender){
        // 这里可插入 gender 值合法性检查的代码
        this.gender = gender;
    }
    public String getGender(){
        // 这里可插入读取 gender 的权限检查的代码
        return this.gender;
    }
}

十四、Java 面向对象编程 —— 多态

在 Java 中，用父类声明的变量可以用来装载其各级子类的对象，但只能访问到子类从父类继承过去的成员（属性和方法）。因为装载的对象的子类的不同，从而造成访问某个被子类重写的方法时，表现有所不同。
如：学生、老师都继承自“个人”类，“个人”类中有一个“work”的方法，在学生、老师类中都进行了重写。当用以“个人”类声明的一个变量 person 来装载学生和老师的对象时，同样的 person.work() 表现就不同。

用接口声明的变量，可以装载实现了该接口的类的对象，但只能访问到该接口拥有的方法。由于装载的对象的类的不同，访问同一个方法，表现有所不同。
如：有一些类都实现了 IPerson 接口，其中有一个方法是 work。由于类的不同，实现的这个方法也不同。当用 IPerson 声明的变量 person 来装载这些类的对象时，由于类的不同，同样的 person.work()表现也就不同。

以上两个现象就是多态——同样类事物（对象）的同一个方法，可能得到不同的行为。

子类的例子：

public class MyApp{
    public static void main(String[] args){
        Person person;
        person = new Student();
        person.work();
        person = new Teacher();
        person.work();
    }
}
abstract class Person {
    public String name;
    abstract public void work();
}
class Student extends Person{
    @Override
    public void work(){
        System.out.println("Studying...");
    }
}
class Teacher extends Person{
    @Override
    public void work(){
        System.out.println("Teaching...");
    }
}

接口的例子：

public class MyApp{
    public static void main(String[] args){
        IPerson person;
        person = new Student();
        person.work();
        person = new Teacher();
        person.work();
    }
}
interface IPerson {
    public void work();
}
class Student implements IPerson{
    public void work(){
        System.out.println("Studying...");
    }
}
class Teacher implements IPerson{
    public void work(){
        System.out.println("Teaching...");
    }
}

第二部分 Java Servlet 与 JSP Web 应用开发

一、Web 应用的结构

Web 应用由两部分组成：一是用户用于交互的用户代理（User agent），通常是浏览器；二是用于提供信息服务的 web 服务器。双方通过 HTTP 协议进行 请求/响应 模式的通信。

二、HTTP请求与响应

HTTP/1.1 （版本 1.1）的请求和响应都是特定格式的字符串。

1、请求

样例：

POST /cgi-bin/process.cgi HTTP/1.1
User-Agent: Mozilla/4.0 (compatible; MSIE5.01; Windows NT)
Host: www.tutorialspoint.com
Content-Type: application/x-www-form-urlencoded
Content-Length: 49
Accept-Language: en-us
Accept-Encoding: gzip, deflate
Connection: Keep-Alive
licenseID=string&content=string&/paramsXML=string

第 1 行为请求行，包含了请求方法（POST），请求的资源相对地址：/cgi-bin/process.cgi，以及请求所用的协议及其版本号：HTTP/1.1；

第 2 ～ 8 行为请求头，第行说明不同的内容；
第 9 行为一个空行，是请求头和请求体的分界线（有的请求没有请求体，如 GET 请求)；
第 10 行为请求体。（请求体内容可以很长，头部：Content-Length 说明了请求体的字节数）。

2、响应

样例：

HTTP/1.1 200 OK
Date: Mon, 27 Jul 2009 12:28:53 GMT
Server: Apache/2.2.14 (Win32)
Last-Modified: Wed, 22 Jul 2009 19:15:56 GMT
Content-Length: 88
Content-Type: text/html
Connection: Closed
<html>
<body>
<h1>Hello, World!</h1>
</body>
</html>

第 1 行为响应行，说明了协议及其版本号：HTTP/1.1，响应状态编码：200，响应结果信息：OK；
第 2 ～ 7 行为响应头；
第 8 行为空行，作为响应头与响应体的分界；
第 9 行开始为响应体。（字节数由响应头 Content-Length 决定）

三、Cookie 和 Session

HTTP 协议是无状态协议，如果要记住访问服务器的用户，则可采用 Session 和 Cookie 技术。

1、Cookie

Cookie 是在客户端保存用户信息的方法，它要保存的信息由响应头带回来，并保存在用户的计算机中。浏览器在访问某个网址时，会将这个网址保存在本地的 Cookie 信息（如果有的话）带给服务器。这样服务器就可通过读取 Cookie 信息了解该用户了。

2、Session

与 Cookie 不同，Session 是将用户信息保存到服务器的技术。服务器保存了用户信息后，会分配给该用户一个 ID ，并将该 ID 传回客户端进行保存（Cookie 或其它方法）。当该用户再次访问该网站时，ID 会被送回服务器（通过 Cookie 或其它手段）。服务器得到用户的 ID 后，即可从保存的 Session 信息中查阅该用户（比如是否已登录等）。

四、用 jsp 开发一个联系人的增、删、改、查 Web 应用

1、首先建立联系人数据库和表

用以下命令进入 MySql 数据库服务器

mysql -uroot -p

然后，建立数据库 contact_db 和数据表 contacts:

create database contact_db default charset utf8;
use contact_db;
create table contacts(id serial primary key, name varchar(50) not null, gender varchar(10) not null, mobile varchar(30) not null);

插入几条样例数据：

insert into contacts values (1,'Billy','Male','13098098767'),(2,'Tina','Female','13908876785');
select * from contacts;

2、在 eclipse 中新建一个 Dynamic Web Application，在 Java Resources 的 src 下建立一个 package: net.yntc.contact。

3、在 net.yntc.contact 包中新建一个 Class，名为 Contact，内容如下：

package net.yntc.contact;
public class Contact {
    private int id;
    private String name;
    private String gender;
    private String mobile;  
}

然后，利用 Eclispe 自动生成构造函数及 getter 和 setter。

package net.yntc.contact;
public class Contact {
    private int id;
    private String name;
    private String gender;
    private String mobile;
    public Contact(int id, String name, String gender, String mobile) {
        super();
        this.id = id;
        this.name = name;
        this.gender = gender;
        this.mobile = mobile;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getGender() {
        return gender;
    }
    public void setGender(String gender) {
        this.gender = gender;
    }
    public String getMobile() {
        return mobile;
    }
    public void setMobile(String mobile) {
        this.mobile = mobile;
    }
}

4、创建数据处理类

将 mysql 驱动的 jar 包复制到 WebContent\WEB_INF\lib 文件夹下。
接着，在同一个包中新建一个名为 ContactDAO 的 Class，内容如下：

package net.yntc.contact;
import java.sql.*;
import java.util.ArrayList;
public class ContactDAO {
    // 数据库连接
    private java.sql.Connection conn;
    public ContactDAO(String db, String user, String pass) {
        try {
            // 加载数据库驱动类
            Class.forName("com.mysql.jdbc.Driver");
            // 获取到数据库的连接
            this.conn = DriverManager.getConnection(db,user,pass);
            // 用于测试
            System.out.println("Connection to DB established!");
        } catch (ClassNotFoundException | SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            this.conn = null;
        }
    }
    /*
     * 获取联系人(参数 key 为姓名过滤关键字)
     * @param key
     * @return ArrayList<Contact>
     */
    public ArrayList<Contact> getAll(String key){
        if(conn==null) {
            return null;
        }
        try {
            // 新建一个数组集合，用于装载联系人
            ArrayList<Contact> contacts = new ArrayList<Contact>();
            // 用连接创建一个语句对象
            java.sql.Statement st = conn.createStatement();
            // 用语句对象执行查询语句，获取结果集
            ResultSet rs = st.executeQuery("select * from contacts");
            // 取出下一条结果，没有则为 null(false)
            while(rs.next()) {
                // 生成一个联系人对象
                Contact c = new Contact(
                        rs.getInt("id"),
                        rs.getString("name"),
                        rs.getString("gender"),
                        rs.getString("mobile")
                        );
                // 把联系人对象加到联系人集合
                contacts.add(c);
            }
            return contacts;
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            return null;
        }
    }
    /**
     * 获取一个联系人对象
     * @param id 联系人编号
     * @return 联系人对象或空对象
     */
    public Contact get(int id) {
        if(conn==null) return null;
        try {
            java.sql.Statement st = conn.createStatement();
            ResultSet rs = st.executeQuery("select * from contacts where id="+id);
            if(rs.next()) {
                Contact c = new Contact(
                        rs.getInt("id"),
                        rs.getString("name"),
                        rs.getString("gender"),
                        rs.getString("mobile")
                        );
                return c;
            }
            return null;
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            return null;
        }       
    }
    /**
     * 删除联系人
     * @param id  联系人编号
     * @return 成功为真，失败为假
     */
    public boolean delete(int id) {
        if(conn==null) return false;
        try {
            java.sql.Statement st = conn.createStatement();
            return st.execute("delete from contacts where id="+id);
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            return false;
        }
    }
    /**
     * 插入或更新数据库记录
     * @param c，联系人对象
     * @return 成功为真，失败为假
     */
    public boolean save(Contact c) {
        if(conn==null) return false;
        if(c.getId()>0) { // update
            String sql = "update contacts set name=?, gender=?, mobile=? where id=?";
            try {
                java.sql.PreparedStatement ps = conn.prepareStatement(sql);
                //设置第一个 ? 号为字符串值，联系人的姓名
                ps.setString(1, c.getName());
                ps.setString(2, c.getGender());
                ps.setString(3, c.getMobile());
                ps.setInt(4, c.getId());
                return ps.execute();
            } catch (SQLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
                return false;
            }
        }
        else {  // insert
            String sql = "insert into contacts values(null,?,?,?)";
            try {
                java.sql.PreparedStatement ps = conn.prepareStatement(sql);
                ps.setString(1, c.getName());
                ps.setString(2, c.getGender());
                ps.setString(3, c.getMobile());
                return ps.execute();
            } catch (SQLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
                return false;
            }   
        }
    }
}

5、配置项目 Build Path, 把 Tomcat 服务器 lib 目录下的 servlet-api.jar 加到项目的 classpath。

6、在 WenContent 目录下分别创建以下 jsp 文件

1、index.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@ page import="net.yntc.contact.*,java.util.*" %>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>联系人列表</title>
</head>
<body>
<% 
request.setCharacterEncoding("utf-8");
response.setCharacterEncoding("utf-8");
String key = request.getParameter("key");
key = key!=null? key:"";
key = new String(key.getBytes("ISO-8859-1"),"utf-8");
System.out.println(key);
%>
<h1>联系人管理</h1>
<a href="add.jsp">添加联系人</a>
<br><br>
<form action="index.jsp">
    <input type="text" name="key" value="<%= key %>" placeholder="输入姓名关键字">
    <input type="submit" value="搜索 "/>
</form>
<br><br>
<table>
    <thead>
        <tr>
            <th>编号</th>
            <th>姓名</th>
            <th>性别</th>
            <th>手机</th>
            <th></th>
        </tr>
    </thead>
    <tbody>
        <%! ContactDAO dao = new ContactDAO("jdbc:mysql://127.0.0.1:3306/contact_db?useUnicode=true&characterEncoding=utf8","root","");%>
        <%      
            ArrayList<Contact> cts = dao.getAll(key);
            Iterator<Contact> it = cts.iterator();
            while(it.hasNext()){
                Contact c = it.next();  
        %>
        <tr>
            <td id="contact_id"><%= c.getId() %></td>
            <td><%= c.getName() %></td>
            <td><%= c.getGender() %></td>
            <td><%= c.getMobile() %></td>
            <td>
            <a href="edit.jsp?id=<%= c.getId() %>">编辑</a>
            <a href="#" onclick="needConfirm(<%= c.getId() %>)">删除</a>
            </td>
        </tr>
        <% } %>
    </tbody>
</table>
<script>
    function needConfirm(id){
        if(confirm("你确实要删除编号为："+id+" 的联系人吗？")){
            window.location="delete.jsp?id="+id;
        }
    }
    </script>
</body>
</html>

2、add.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
<h1>新增联系人</h1>
<form action="save.jsp" method="post">
姓名：<input type="text" name="name"><br><br>
性别：<select name="gender">
    <option value="M">男</option>
    <option value="F">女</option>
</select>
<br><br>
手机：<input type="text" name="mobile">
<br><br>
<input type="submit" value="保存" />
</form>
</body>
</html>

3、edit.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
    <%@ page import="net.yntc.contact.*,java.util.*" %>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
<%! ContactDAO dao = new ContactDAO("jdbc:mysql://127.0.0.1:3306/contact_db","root","");%>
<% 
int id = Integer.parseInt(request.getParameter("id"));
Contact c = dao.get(id);
%>
<h1>新增联系人</h1>
<form action="save.jsp" method="post">
<input type="hidden" name="id" value="<%= id %>" />
姓名：<input type="text" name="name" value="<%= c.getName() %>"><br><br>
性别：<select name="gender">
    <option value="M" <% if(c.getGender().startsWith("M")){ %> selected <% } %>>男</option>
    <option value="F" <% if(c.getGender().startsWith("F")){ %> selected <% } %>>女</option>
</select>
<br><br>
手机：<input type="text" name="mobile" value="<%= c.getMobile() %>">
<br><br>
<input type="submit" value="保存" />
</form>
</body>
</html>

4、save.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@ page import="net.yntc.contact.*" %>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
<%! ContactDAO dao = new ContactDAO("jdbc:mysql://127.0.0.1:3306/contact_db?useUnicode=true&characterEncoding=utf8","root","");%>
<% 
String str_id = request.getParameter("id");
str_id = str_id==null?"0":str_id;
int id = Integer.parseInt(str_id);
request.setCharacterEncoding("utf-8");
String name = new String(request.getParameter("name").getBytes("ISO-8859-1"),"utf-8");
String gender = new String(request.getParameter("gender").getBytes("ISO-8859-1"),"utf-8");
String mobile = new String(request.getParameter("mobile").getBytes("ISO-8859-1"),"utf-8");
Contact c = new Contact(id,name,gender,mobile);
dao.save(c);
%>
<% response.sendRedirect("index.jsp"); %>>
</body>
</html>

5、delete.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@ page import="net.yntc.contact.*" %>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
<%! ContactDAO dao = new ContactDAO("jdbc:mysql://127.0.0.1:3306/contact_db","root","");%>
<% 
int id = Integer.parseInt(request.getParameter("id"));
dao.delete(id); 
response.sendRedirect("index.jsp");
%>
</body>
</html>

7、在 Tomcat 上运行项目。