// 整数类型
byte  a = 127;                    // 字节
short b = 10000;                  // 短整型
int   c = 1000000000;             // 整型
long  d = 1000000000000000000L;   // 长整型，末尾加 L

// 浮点类型
float  e = 1.111f;   // 单精度，末尾加 f
double f = 1.222;    // 双精度

// 字符类型
char g = '牢';       // 存单个字符，可通过 Unicode 编码转为 int
c = g;
System.out.println(c); // 输出对应 Unicode 数值

// 布尔类型
boolean h = true;
boolean i = 5 > 3;   // 可以直接存逻辑运算的结果
System.out.println(i); // true

String j = "张三";   // 字符串
// 还有类类型、数组等

int  i1 = 20;
byte i2 = 10;

i2 = (byte) i1;   // 强制转换：大转小
System.out.println(i2); // 20

// 赋值运算符
int a = 10;

// 算数运算符：+ - * / % += -= ++ --
int c = a++;     // 先把 a 的值赋给 c，再自增
System.out.println(a); // 11
System.out.println(c); // 10

// 关系运算符：> < >= <= != ==（结果都是布尔值）

// 逻辑运算符：&& || !
boolean f  = 1 < 2 && 2 > 1;   // true
boolean f1 = 2 == 3 || 1 == 1; // true
boolean f2 = !(1 < 2);         // false

String s1 = "aa";
String s2 = "aa";
boolean s3 = s1.equals(s2);
System.out.println("s3：" + s3); // s3：true

// 单分支
if (true) {
    System.out.println("成立时执行");
}

// 双分支
if (true) {
    System.out.println("成立");
} else {
    System.out.println("不成立");
}

// 多分支
int score = 90;
if (score >= 90) {
    System.out.println("优秀");
} else if (score >= 80) {
    System.out.println("良好");
} else if (score >= 70) {
    System.out.println("中等");
} else if (score >= 60) {
    System.out.println("及格");
} else {
    System.out.println("不及格");
}

int s = 9;
int sex = 0; // 0：男，-1：女

if (s < 10) {
    if (sex == 0) {
        System.out.println("男子组");
    } else {
        System.out.println("女子组");
    }
} else {
    System.out.println("out");
}

int i = 1;
switch (i) {
    case 1:
        System.out.println("周一");
        break;
    case 2:
        System.out.println("周二");
        break;
    // ...
    default:
        System.out.println("无效的日期");
}

int a = 1;
while (a < 10) {
    System.out.println(a);
    a++;
}

int a = 1;
do {
    System.out.println(a);
    a++;
} while (a < 10);

for (int a = 1; a < 10; a++) {
    System.out.println(a);
}

public class Dog {
    // 静态特征：属性
    String name;    // 昵称
    String strain;  // 品种
    double weight;  // 体重

    // 动态特征：方法
    public void show() {
        System.out.println("我的狗的名字是：" + name + " 品种是：" + strain + " 体重是：" + weight + "KG");
    }
}

class Dog {
    String name;
    String strain;
    double weight;

    public void show() {
        System.out.println("我的狗的名字是：" + name + " 品种是：" + strain + " 体重是：" + weight + "KG");
    }
}

// 类名 对象名 = new 类名();
Dog dog = new Dog();

// 调用属性赋值
dog.name = "kobe";
dog.strain = "拉得不多";
dog.weight = 5.45;

// 调用方法
dog.show();

public 返回值类型 方法名() {
    // 方法体
    return 表达式;
}

public class Student {
    String name;
    double score;

    public void study() {
        System.out.println(name + "的语文成绩为" + score);
    }

    public double sum() {
        double a = 350.00;
        return a * 1.2;  // 返回计算结果
    }
}

public 返回值类型 方法名(参数1类型 参数1名, 参数2类型 参数2名) {
    方法体;
}

public class Cal {
    // 计算两个数的和，有返回值
    public int sum(int a, int b) {
        int c = a + b;
        return c;
    }

    // 计算两个数的差，无返回值
    public void gap(int a, int b) {
        int c = a - b;
        System.out.println(c);
    }
}

// 调用
Cal cal = new Cal();
int result = cal.sum(10, 20); // 传入实参
System.out.println(result);

// 声明包，写在第一行
package team.shiro;

// 导入包，写在 package 后
import java.util.*;

// 声明方式
int[] a;
int b[];

// 声明时指定大小
int[] c = new int[5];

// 声明时直接赋值
int[] d = {1, 2, 3, 4, 5};

// 分配空间
a = new int[5];

// 通过下标存取元素
a[0] = 10;
a[0] = a[0] + 10;

import java.util.Scanner;

Scanner input = new Scanner(System.in);
double[] arr = new double[5];
double[] defaults = {12.5, 36.0, 18.8, 7.5, 20.0};
double sum = 0.0;

for (int i = 0; i < arr.length; i++) {
    System.out.println("请输入第 " + (i + 1) + " 笔金额");
    if (input.hasNextDouble()) {
        arr[i] = input.nextDouble();
    } else {
        arr[i] = defaults[i];
    }
    sum += arr[i];
}

System.out.println("序号\t\t金额");
for (int i = 0; i < arr.length; i++) {
    System.out.println((i + 1) + "\t\t" + arr[i]);
}
System.out.println("总金额\t" + sum);

import java.util.Arrays;

int[] a = {4, 8, 2, 9, 1, 6, 7, 3};
Arrays.sort(a);
// 排序后：[1, 2, 3, 4, 6, 7, 8, 9]

int[] arr = {8, 4, 2, 1, 23, 344, 12};
int min = arr[0];

for (int i = 1; i < arr.length; i++) {
    if (min > arr[i]) {
        min = arr[i];
    }
}
System.out.println(min); // 1

int[][] scores = {
    {90, 88, 95},
    {76, 80, 72},
    {100, 98}
};

// 外层循环控制行，内层循环控制每一行中的列
for (int i = 0; i < scores.length; i++) {
    for (int j = 0; j < scores[i].length; j++) {
        System.out.print(scores[i][j] + "\t");
    }
    System.out.println();
}

int[][][] data = {
    {
        {1, 2, 3},
        {4, 5, 6}
    }
};

System.out.println(data[0][1][2]); // 6

// 语法
public 类名(参数) {
    // 初始化逻辑
}

public class Car {
    String color;
    double speed;
    int num;

    // 无参构造（自己写了有参构造后需要手动补上）
    public Car() {
        System.out.println("空构造");
    }

    // 有参构造
    public Car(String color) {
        this.color = color;
    }

    public Car(String color, double speed) {
        this.color = color;
        this.speed = speed;
    }

    public Car(String color, double speed, int num) {
        this.color = color;
        this.speed = speed;
        this.num = num;
    }
}

public class Employee {
    String id;
    String name;
    int age;
    String phone;
    double sal;

    public void input() {
        System.out.println("姓名：" + this.name + " 电话：" + this.phone + " 工资：" + this.sal);
    }

    public void show() {
        input(); // 也可以写 this.input();
        System.out.println("工号：" + this.id);
    }

    public Employee() {}

    public Employee(String id) {
        this.id = id;
    }

    public Employee(String id, String name) {
        this(id);         // 调用上面的单参构造，必须第一行
        this.name = name;
    }

    public Employee(String id, String name, int age) {
        this(id, name);   // 链式调用构造方法
        this.age = age;
    }

    public Employee(String id, String name, int age, String phone, double sal) {
        this(id, name, age);
        this.phone = phone;
        this.sal = sal;
    }
}

public class Cal {
    // 重载：参数类型不同
    public void sum(int a, int b) {
        System.out.println(a + b);
    }

    public double sum(double a, double b) {
        return a + b;
    }

    // 重载：参数个数不同
    public void sum(int a, int b, int c) {
        System.out.println(a + b + c);
    }
}

// 父类
public class Pet {
    String name;
    int health;

    public void eat() {
        System.out.println(name + "在吃东西");
    }
}

// 子类
public class Dog extends Pet {
    String strain; // 子类特有属性

    public void work() {
        System.out.println(name + "能看大门"); // 继承自父类的属性
    }
}

// 使用
Dog dog = new Dog();
dog.name   = "kobe";
dog.health = 60;
dog.eat();   // 调用继承来的方法
dog.work();  // 调用子类自己的方法

public class Dog extends Pet {
    String name = "man"; // 子类同名属性

    public void work() {
        System.out.println(this.name);  // 先找子类：man
        System.out.println(super.name); // 找父类：kobe
    }
}

public class Employee extends Person {
    double sal;

    public Employee(String name, int age, double sal) {
        super(name, age); // 调用父类构造方法，必须第一行
        this.sal = sal;
    }

    public void work() {
        super.show(); // 调用父类方法
        System.out.println("工资：" + this.sal);
    }
}

public class Person {
    public void run() {
        System.out.println("人类会跑步");
    }
}

public class Employee extends Person {
    @Override
    public void run() {       // 重写父类方法
        System.out.println("员工竞走");
    }
}

public abstract class Users {
    // 抽象方法，没有方法体
    public abstract void show();

    // 普通方法，可以有实现
    public void hello() {
        System.out.println("你好");
    }
}

// 子类必须实现所有抽象方法
public class BookUsers extends Users {
    @Override
    public void show() {
        System.out.println("书籍用户");
    }
}

// 使用
// Users u = new Users(); // 错误，抽象类不能实例化
BookUsers bu = new BookUsers();
bu.show();

class Pet {
    public void eat() {
        System.out.println("宠物吃东西");
    }

    public void run() {
        System.out.println("宠物会跑");
    }
}

class Dog extends Pet {
    @Override
    public void eat() {
        System.out.println("狗吃东西");
    }

    public void work() {
        System.out.println("狗能看大门");
    }
}

// 父类引用 = 子类对象（自动转型）
Pet p = new Dog();
p.eat(); // 调用的是 Dog 重写后的 eat()
p.run();

// 通过父类引用调用不到子类特有的方法
// p.work(); // 错误，Pet 中没有 work()

class Pet {
}

class Dog extends Pet {
    public void work() {
        System.out.println("狗能看大门");
    }
}

Pet p = new Dog();

// 强制转换，大转小
Dog d = (Dog) p;
d.work(); // 可以调用 Dog 的特有方法

class Pet {
}

class Dog extends Pet {
    public void work() {
        System.out.println("狗能看大门");
    }
}

class Cat extends Pet {
    public void play() {
        System.out.println("猫会玩耍");
    }
}

Pet p = new Dog();

if (p instanceof Dog) {
    Dog dog = (Dog) p;
    dog.work();
} else if (p instanceof Cat) {
    Cat cat = (Cat) p;
    cat.play();
}

class Person {
    public void show() {
        System.out.println("Person");
    }
}

class Student extends Person {
    @Override
    public void show() {
        System.out.println("Student");
    }
}

class Teacher extends Person {
    @Override
    public void show() {
        System.out.println("Teacher");
    }
}

Person p = new Student();
p.show(); // 执行 Student 的 show()

p = new Teacher();
p.show(); // 执行 Teacher 的 show()

class Pet {
    public void eat() {
        System.out.println("宠物吃东西");
    }
}

class Dog extends Pet {
    @Override
    public void eat() {
        System.out.println("狗吃东西");
    }
}

class Cat extends Pet {
    @Override
    public void eat() {
        System.out.println("猫吃东西");
    }
}

public class Master {
    // 形参为父类，实参传子类对象
    public void food(Pet pet) {
        pet.eat();
    }
}

Master ma = new Master();
ma.food(new Dog()); // 匿名对象
ma.food(new Cat());

class Pet {
    public void eat() {
        System.out.println("宠物吃东西");
    }
}

class Dog extends Pet {
    @Override
    public void eat() {
        System.out.println("狗吃东西");
    }
}

public class PetAgree {
    public Pet buy() {
        return new Dog(); // 返回子类对象
    }
}

PetAgree pa = new PetAgree();
Pet pet = pa.buy();
pet.eat(); // 调用 Dog 的 eat()

Object[] arr = new Object[4];
arr[0] = "张三";
arr[1] = 18;       // int 自动装箱为 Integer
arr[2] = 98.5;
arr[3] = new Dog();

for (Object item : arr) {
    System.out.println(item);
}

public interface USB {
    void work();
}

public class MouseUSB implements USB {
    @Override
    public void work() {
        System.out.println("鼠标开始工作");
    }
}

public class DiskUSB implements USB {
    @Override
    public void work() {
        System.out.println("U 盘开始工作");
    }
}

USB usb = new MouseUSB();
usb.work();

usb = new DiskUSB();
usb.work();

public interface SuperA {
    void a();
}

public interface SuperB {
    void b();
}

public interface SuperC {
    void c();
}

public class ImpClass implements SuperA, SuperB, SuperC {
    @Override
    public void a() {
        System.out.println("实现 a");
    }

    @Override
    public void b() {
        System.out.println("实现 b");
    }

    @Override
    public void c() {
        System.out.println("实现 c");
    }
}

public interface Person {
    void setName(String name);
    String getName();
}

public interface BizAgent extends Person {
    void speakWork();
}

public interface Programmer extends Person {
    void writeWork();
}

public class SoftEngineer implements BizAgent, Programmer {
    private String name;

    @Override
    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String getName() {
        return name;
    }

    @Override
    public void speakWork() {
        System.out.println("工程师可以讲解业务");
    }

    @Override
    public void writeWork() {
        System.out.println("工程师可以写程序");
    }
}

public interface Paper {
    String getPaperSize();
}

public interface InkBox {
    String getInkBoxType();
}

public class A4Paper implements Paper {
    @Override
    public String getPaperSize() {
        return "A4";
    }
}

public class ColorBox implements InkBox {
    @Override
    public String getInkBoxType() {
        return "彩色";
    }
}

public class Print {
    public void input(Paper paper, InkBox inkBox) {
        System.out.println("使用" + paper.getPaperSize() + "大小的纸打印" + inkBox.getInkBoxType() + "色的内容");
    }
}

Print printer = new Print();
Paper paper = new A4Paper();
InkBox inkBox = new ColorBox();
printer.input(paper, inkBox);

Scanner input = new Scanner(System.in);
System.out.println("请输入两个整数");

int a = input.nextInt();
int b = input.nextInt();
System.out.println(a / b); // b 为 0 时会出现 ArithmeticException

import java.util.InputMismatchException;
import java.util.Scanner;

Scanner input = new Scanner(System.in);

try {
    System.out.println("请输入第一个整数");
    int a = input.nextInt();

    System.out.println("请输入第二个整数");
    int b = input.nextInt();

    System.out.println("商：" + a / b);
} catch (InputMismatchException e) {
    System.out.println("输入的不是整数");
} catch (ArithmeticException e) {
    System.out.println("除数不能为 0");
} catch (Exception e) {
    System.out.println("出现未知错误：" + e.getMessage());
} finally {
    input.close();
    System.out.println("计算结束");
}

public static int divide(int a, int b) throws ArithmeticException {
    if (b == 0) {
        throw new ArithmeticException("除数不能为 0");
    }
    return a / b;
}

public static void main(String[] args) {
    try {
        System.out.println(divide(10, 0));
    } catch (ArithmeticException e) {
        System.out.println(e.getMessage());
    }
}

public class MyException extends Exception {
    public MyException() {
    }

    public MyException(String message) {
        super(message);
    }
}

public static void checkAge(int age) throws MyException {
    if (age < 0 || age > 150) {
        throw new MyException("年龄不合法");
    }
}

public static int test() {
    try {
        return 1;
    } finally {
        System.out.println("finally 仍然会执行");
    }
}

Collection（单列集合）      Map（双列集合，键值对）
├── List（有序可重复）        ├── HashMap（哈希表）
│   ├── ArrayList            └── TreeMap（红黑树，有序）
│   └── LinkedList
└── Set（无序不重复）
    ├── HashSet
    └── TreeSet（红黑树，有序）

import java.util.ArrayList;
import java.util.List;

Dog d1 = new Dog("小黑", "白色");
Dog d2 = new Dog("小白", "黑色");
Dog d3 = new Dog("小花", "黄色");

// 使用泛型指定元素类型，省去强制转换
List<Dog> list = new ArrayList<>();
list.add(d1);
list.add(d2);
list.add(1, d3); // 在索引 1 处插入，后面的元素自动后移

// 普通 for 循环
for (int i = 0; i < list.size(); i++) {
    Dog dog = list.get(i);
    System.out.println(dog.getName());
}

// 增强 for 循环（forEach）
for (Dog dog : list) {
    System.out.println(dog.getName());
}

// contains & remove
System.out.println(list.contains(d2));  // true
list.remove(d2);                        // 删除指定对象
Dog removed = list.remove(0);           // 删除索引 0，返回被删除的对象

import java.util.LinkedList;
import java.util.List;

List<Dog> list = new LinkedList<>();
list.add(d1);
list.add(d2);

// LinkedList 独有方法，需要声明为 LinkedList 类型才能调用
LinkedList<Dog> l = new LinkedList<>();
l.add(d1);
l.add(d2);
l.add(d3);

l.addFirst(d1);        // 插入到头部
l.addLast(d3);         // 插入到尾部
System.out.println(l.getFirst().getName()); // 获取第一个元素
System.out.println(l.getLast().getName());  // 获取最后一个元素

import java.util.HashSet;
import java.util.Set;

Set<Dog> set = new HashSet<>();
set.add(d1);
set.add(d2);
set.add(d3);

System.out.println(set.size()); // 3

for (Dog dog : set) {
    System.out.println(dog.getName()); // 顺序不固定
}

import java.util.Set;
import java.util.TreeSet;

Set<Integer> set = new TreeSet<>();
set.add(5);
set.add(1);
set.add(3);
set.add(2);
set.add(4);

for (int n : set) {
    System.out.print(n + " "); // 1 2 3 4 5（自动升序）
}

Set<String> names = new TreeSet<>();
names.add("张三");
names.add("李四");
names.add("王五");

for (String name : names) {
    System.out.println(name); // 按字典序输出
}

import java.util.Iterator;

// 遍历 List
List<Dog> list = new ArrayList<>();
list.add(d1);
list.add(d2);
list.add(d3);

Iterator<Dog> it = list.iterator();
while (it.hasNext()) {       // 是否还有下一个元素
    Dog dog = it.next();     // 取出下一个元素
    System.out.println(dog.getName());
}

import java.util.HashMap;
import java.util.Map;

Map<Integer, String> map = new HashMap<>();
map.put(100000, "北京市");
map.put(200000, "上海市");
map.put(510000, "广州市");

System.out.println(map.get(100000));           // 北京市
System.out.println(map.containsKey(200000));   // true
System.out.println(map.size());                // 3

for (String key : map.keySet()) {
    System.out.println(key + " -> " + map.get(key));
}

for (Map.Entry<Integer, String> entry : map.entrySet()) {
    System.out.println("邮政编码：" + entry.getKey() + ", 地区：" + entry.getValue());
}

1. 加载驱动
2. 创建连接
3. 编写 SQL 语句
4. 预编译 SQL
5. 执行 SQL
6. 处理结果
7. 关闭资源

import com.mysql.jdbc.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;

// 1. 加载驱动
try {
    Class.forName("com.mysql.jdbc.Driver");
} catch (ClassNotFoundException e) {
    e.printStackTrace();
}

// 2. 创建连接
Connection con = null;
try {
    con = (Connection) DriverManager.getConnection(
        "jdbc:mysql://localhost:3306/数据库名", "root", "123456");
} catch (SQLException e) {
    e.printStackTrace();
}

// 3. 编写 SQL（字符串变量可以用 + 拼接，但推荐用占位符 ?）
String sql = "insert into student(id, name, age) values(1, '张三', 18)";

// 4. 预编译
PreparedStatement ps = null;
try {
    ps = con.prepareStatement(sql);
} catch (SQLException e) {
    e.printStackTrace();
}

// 5. 执行（增删改用 executeUpdate，返回受影响行数）
int rows = 0;
try {
    rows = ps.executeUpdate();
} catch (SQLException e) {
    e.printStackTrace();
}

// 6. 处理结果
if (rows > 0) {
    System.out.println("添加成功");
}

// 7. 关闭资源（先开后关）
try { ps.close(); } catch (SQLException e) { e.printStackTrace(); }
try { con.close(); } catch (SQLException e) { e.printStackTrace(); }

// 删除
String sql = "delete from student where name = '张三'";

// 修改
String sql = "update student set name = '李四' where id = 1";

import java.sql.ResultSet;

// 执行查询
String sql = "select * from student";
PreparedStatement ps = con.prepareStatement(sql);
ResultSet rs = ps.executeQuery();

// 遍历结果集
while (rs.next()) {
    int id     = rs.getInt("id");
    String name = rs.getString("name");
    int age    = rs.getInt("age");
    System.out.println(id + " - " + name + " - " + age);
}

// 关闭资源（rs 也要关，顺序：rs → ps → con）
rs.close();
ps.close();
con.close();

// 占位符从 1 开始计数
String sql = "insert into student values(?, ?, ?)";
PreparedStatement ps = con.prepareStatement(sql);

ps.setInt(1, 3);          // 第1个 ? 设置为整数 3
ps.setString(2, "王五");  // 第2个 ? 设置为字符串
ps.setInt(3, 19);         // 第3个 ? 设置为整数 19

ps.executeUpdate();

String sql = "select * from student where id > ?";
PreparedStatement ps = con.prepareStatement(sql);
ps.setInt(1, 5);
ResultSet rs = ps.executeQuery();

import com.mysql.jdbc.Connection;
import java.sql.*;

public class BaseDao {
    protected Connection con = null;
    protected PreparedStatement ps = null;
    protected ResultSet rs = null;

    public void openCon() {
        try {
            Class.forName("com.mysql.jdbc.Driver");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        try {
            con = (Connection) DriverManager.getConnection(
                "jdbc:mysql://localhost:3306/数据库名", "root", "123456");
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    public void closeAll() {
        try {
            if (rs  != null) rs.close();
            if (ps  != null) ps.close();
            if (con != null) con.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

public class EmpCRUD extends BaseDao {

    public void addEmp() {
        try {
            openCon();
            String sql = "insert into employee(e_name, e_age, e_loc) values(?, ?, ?)";
            ps = con.prepareStatement(sql);
            ps.setString(1, "高八");
            ps.setInt(2, 21);
            ps.setString(3, "四川");
            int rows = ps.executeUpdate();
            if (rows > 0) System.out.println("添加成功");
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            closeAll(); // 无论成功与否都关闭
        }
    }

    public void findAll() {
        try {
            openCon();
            String sql = "select * from employee";
            ps = con.prepareStatement(sql);
            rs = ps.executeQuery();
            while (rs.next()) {
                System.out.println(
                    rs.getInt("e_no") + " - " +
                    rs.getString("e_name") + " - " +
                    rs.getInt("e_age") + " - " +
                    rs.getString("e_loc")
                );
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            closeAll();
        }
    }
}

// 按 id 查单条，返回 Employee 对象
public Employee findById(int id) {
    openCon();
    Employee emp = null;
    try {
        String sql = "select * from employee where e_no = ?";
        ps = con.prepareStatement(sql);
        ps.setInt(1, id);
        rs = ps.executeQuery();
        if (rs.next()) {
            emp = new Employee();
            emp.setE_no(rs.getInt("e_no"));
            emp.setE_name(rs.getString("e_name"));
            emp.setE_age(rs.getInt("e_age"));
            emp.setE_loc(rs.getString("e_loc"));
        }
    } catch (SQLException e) {
        e.printStackTrace();
    } finally {
        closeAll();
    }
    return emp;
}

// 查多条，返回 List
public List<Employee> findByAge(int minAge) {
    List<Employee> list = new ArrayList<>();
    try {
        openCon();
        String sql = "select * from employee where e_age > ?";
        ps = con.prepareStatement(sql);
        ps.setInt(1, minAge);
        rs = ps.executeQuery();
        while (rs.next()) {
            Employee emp = new Employee();
            emp.setE_no(rs.getInt("e_no"));
            emp.setE_name(rs.getString("e_name"));
            emp.setE_age(rs.getInt("e_age"));
            emp.setE_loc(rs.getString("e_loc"));
            list.add(emp);
        }
    } catch (SQLException e) {
        e.printStackTrace();
    } finally {
        closeAll();
    }
    return list;
}

// 查询姓"王"的员工，取前 5 条
String sql = "select * from employee where e_name like ? limit ?, ?";
ps = con.prepareStatement(sql);
ps.setString(1, "王%");   // % 表示任意字符
ps.setInt(2, 0);           // 从第 0 条开始（offset）
ps.setInt(3, 5);           // 取 5 条（count）
rs = ps.executeQuery();