1、加载数据库驱动。（JDBC本身并不能直接访问数据库，它需要依赖于JDBC驱动程序。）

    2、与数据库建立连接。（格式：DriverManager.getConnection("jdbc:mysql://localhost＜或写127.0.0.1＞:端口号/数据库名","用户名", "进入数据库的密码");）

    3、发送查询或更新语句到数据库。

    4、执行查询并返回查询结果。

看一下下面的小例子。

/**
* DriverManager 驱动程序管理器  在数据库和相应驱动程序之间建立连接
* Connection 对象代表与数据库的连接，也就是在已经加载的Driver和数据库之间建立连接
* Statement 提供在基层连接上运行SQL语句，并且访问结果
* ResultSet 在Statement执行SQL语句时，有时会返回ResultSet结果集，包含的是查询的结果集
*/
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class Tester {

    public static void main(String[] args) {   
            query();

    }   
    public static void query(){   
            Connection conn = null;   
            try {
                    //1.加载数据库驱动
                    Class.forName("com.mysql.jdbc.Driver");   
                    //DriverManager 驱动程序管理器  在数据库和相应驱动程序之间建立连接
                    //2.获得数据库连接
                    conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/jdbc_db", "root", "1234");   
                    //3.创建语句
                    String sql = "select * from UserTbl";   
                    //返回一个执行SQL的句柄
                    Statement stmt = conn.createStatement(); 
                    //返回查询的
                    //4.执行语句
                    ResultSet rs = stmt.executeQuery(sql);
                    //5.遍历结果集
                    while(rs.next()){   
                            int id = rs.getInt(1);   
                            String username = rs.getString(2);   
                            String password = rs.getString(3);   
                            int age = rs.getInt(4);   
                            System.out.println(id+":"+username+":"+password+":"+age);   
                    }   
            } catch (Exception e) {   
                    e.printStackTrace();   
            }finally{   
                    if(conn!=null){   
                            try {    //关闭数据库连接
                                    conn.close();   
                            } catch (SQLException e) {   
                                    conn = null;   
                                    e.printStackTrace();   
                            }   
                    }   
            }   
    }
}

运行结果：

      要注意的是在获得数据库连接时根据你所用的数据库种类选择加载的connector。加载方法先将连接数据库的jar包放进你的Project的一个Folder内，然后右击选择build path-----add  to build path就可以了。第三步创建的SQL应根据你具体的需要编写。

      获得数据库连接还可以通过下面两种方法：

// 第一种方法
    public Connection getConnection(String driver, String url, String user,
            String password) {
        Connection conn = null;
        try {
            // Class.forName加载驱动
            Class.forName(driver);
            // DriverManager获得连接
            conn = DriverManager.getConnection(url, user, password);
            return conn;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    // 第二种方法
    public Connection openConnection() {
        String driver = "";
        String url = "";
        String user = "";
        String password = "";
        Properties prop = new Properties();
        Connection conn = null;
        try {
            // 加载属性文件
            prop.load(this.getClass().getClassLoader().getResourceAsStream(
                    "DBConfig.properties"));
            driver = prop.getProperty("driver");
            url = prop.getProperty("url");
            user = prop.getProperty("user");
            password = prop.getProperty("password");
            // Class.forName加载驱动
            Class.forName(driver);
            // DriverManager获得连接
            conn = DriverManager.getConnection(url, user, password);
            return conn;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}

第二种方法比较常用，因为做修改的时候不需要对程序进行大的修改，只要在配置文件中进行增、删、改就可以了。

写一下关于数据库表的操作SQL，内容不重要，重要的是理解结构和含义哈。

//有自增的语句

CREATE TABLE person(
id INT PRIMARY KEY NOT NULL AUTO_INCREMENT ,
name VARCHAR(20) NOT NULL ,
age INT
) ;

/*创建学生表*/
create table Student(
                     Sno char(9) primary key,/*列级玩整性约束条件，Sno是主码*/
                     Sname char(20) unique,   /*Sname 取唯一值*/
                     Ssex char(2),
                     Sage smallint,
                     Sdept char (20),
                   );

/*创建课程表*/
create table Course(
                    Cno char(4) primary key,  /*列表完整性约束条件，Cno是主码*/
                    Cname char(40),
                    Cpno char(4),    /*Cpno的含义是先修课*/
                    Ccredit smallint,
                    foreign key (Cpno) references Course(Cno)
                    /*表级完整性的约束条件，Cpno是外码，被参照表是Course，被参照列式Cno*/
                   );

/*创建学生课程表*/
create table SC(
                Sno char (9),
                Cno char(4),
                Grade smallint,
                primary key(Sno,Cno),/*主码由两个属性构成，必须作为表级完整性进行定义*/
                foreign key (Sno) references Student(Sno),/*表级完整性约束条件，Sno是外码，被参照表是Student*/
                foreign key (Cno) references course(Cno),/*表级完整性约束条件，Sno是外码，被参照表是Student*/
                );

/*向Student表增加“入学时间”列   */
alter table Student add S_entrance date;

/*修改Student中Sage的属性*/
alter table Student alter column Sage int;

/*修改Course表中Cname为唯一值*/
alter table Course add unique (Cname);

/*删除表Student*/
Drop Table Student Cascade；（cascade 删除表是该表没有限制条件，在删除基本表的同时，相关的依赖对象,例如 视图等，都被删除
                              restrict删除的表不能被其他约束所引用，不能有视图，触发器。存储过程或函数等 ）

                                   /***     表的索引    ***/

/*在Student表的Sname列上建立一个聚族索引*/
create cluster intdex Stusname on Student(Sname);

/*在三个表中建立唯一索引*/
create unique index Stuno on Student(Sno);
create unique index Coucno on Course(Cno);
create unique index SCno on SC(Sno ASC, Cno DESC);

/*删除Student表中stusname索引*/
drop index Student;

                                /***        数据查询           ***/
一、普通查询

//查询全体学生的详细记录
select *
from Student;

//查询经过计算的值
select Sname ，2004-Sage
from Student;

//查询全体学生的姓名、出生年份和所在的院系，要求用小写的字母表示所有系名
1、select Sname,'year of birth:' birth, 2004-Sage birthday,LOWER(Sdept) departement
   from Student;
2、select Sname,'year of birth:', 2004-Sage ,LOWER(Sdept)
   from Student;

//查询选修课程的学生学号
select （all）Sno
from SC;

//查询选修课程的学生学号（消除取值重复的行）
select distinct Sno
from SC;

二、条件查询

//查询全体计算机系的所有学生   
select Sname
from Student
where Sdept='CS';

//查询所有年龄在20岁以下的学生姓名和年龄
select Sname Sage
from Student
where Sage<20;

//成绩有不及格学生的学号
select distinct Sno
from SC
where Grade<60;

//年里不在20到30岁之间的学生姓名、系别、和年龄
select  Sname,Sdept,Sage
from Student
where Sage not between 20 and 23;

//查询在CS、MA、IS学生的姓名和性别
select  Sname,Ssex
from Student
where Sdept in('CS','MA','IS');

//查询不在CS、MA、IS学生的姓名和性别
select  Sname,Ssex
from Student
where Sdept not in('CS','MA','IS');

//查询学号200215121的学生详细情况
select *
from Student
where Sno like '200215121';  （like 可用=替换）

//查询所有姓刘的学生姓名和性别
select *
from Student
where Sname like '刘%';  （%   等符号的含义）
//删除年龄大于25岁的
delete from Student where age>25;

代码：

class MyThread4 implements Runnable{
    private int ticket = 8;//定义8张票
    public  void run(){
        for(int i=0;i<100;i++){
                if(this.ticket>0){
                    try{
                        Thread.sleep(100);
                    }catch(Exception e){}
                    System.out.println(Thread.currentThread().getName()+"号窗口"+

                     "==>On sael#######"+(ticket--));
                }
        }
    }
}

public class Tongbukuai {
    public static void main(String [] args){
        MyThread4 mt = new MyThread4();//共享同一资源
        Thread t1 = new Thread(mt);//
        Thread t2 = new Thread(mt);//三个线程代表三个售票窗口
        Thread t3 = new Thread(mt);//
        t1.start();
        t2.start();
        t3.start();
    }

}

运行结果：

      这怎么可以？2号和1号窗口卖出了两张8号票，而且卖出的票的总数是不正常的。这是因为多个线程同时进入取票的循环，而程序还没来得及把票数减一；后面的0号和-1号票的出现是因为当ticket 数为1的时候0号、1号和2号三个线程进入循环里，0号取得了1号票，此时应该停止买票了，但是1号、2号线程还在循环里，所以就依次取出了0号和-1号票。

      这种情况的处理办法就是为资源加上一把“锁”。每次只允许一个线程进入，当前的线程结束操作后才允许下一个线程进入。实现加同步锁的操作有两种方法：1、同步块  2、同步方法。两种方法都要用到synchronized关键字。

      代码及运行结果如下：

同步块：

class MyThread4 implements Runnable{
    private int ticket = 8;//定义8张票
    public  void run(){
        for(int i=0;i<8;i++){

            synchronized(this){
                if(this.ticket>0){
                    try{
                        Thread.sleep(100);
                    }catch(Exception e){}
                    System.out.println(Thread.currentThread().getName()+"号窗口"+

                     "==>On sael#######"+(ticket--));
                }
            }
        }
    }
}

public class Tongbukuai {
    public static void main(String [] args){
        MyThread4 mt = new MyThread4();//共享同一资源
        Thread t1 = new Thread(mt);//
        Thread t2 = new Thread(mt);//三个线程代表三个售票窗口
        Thread t3 = new Thread(mt);//
        t1.start();
        t2.start();
        t3.start();
    }

}

运行结果：

同步方法：

class MyThread4 implements Runnable{
    private int ticket = 8;//定义8张票
    public void run(){
        for(int i=0;i<8;i++){
            try{
                Thread.sleep(100);
            }catch(Exception e){}
            this.sale();
        }
    }
     public synchronized void sale(){
         {
                if(ticket>0)
                {
                    System.out.println(Thread.currentThread().getName()+"号窗口"+this.ticket--+"号票");
                }
        }
    }
}

public class Tongbukuai {
    public static void main(String [] args){
        MyThread4 mt = new MyThread4();//共享同一资源
        Thread t1 = new Thread(mt);//
        Thread t2 = new Thread(mt);//三个线程代表三个售票窗口
        Thread t3 = new Thread(mt);//
        t1.start();
        t2.start();
        t3.start();
    }

}

运行结果：

注意synchronized的位置，不要放错位置哦！

我的这个就放错了= =！！

class MyThread4 implements Runnable{
    private int ticket = 8;//定义8张票
    public  void run(){
        synchronized(this){   //一个窗口全部卖完
        for(int i=0;i<8;i++){
                if(this.ticket>0){
                    try{
                        Thread.sleep(100);
                    }catch(Exception e){}
                    System.out.println(Thread.currentThread().getName()+"号窗口"+"==>On sael#######"+(ticket--));
                }
        }
        }
    }
}

public class Tongbukuai {
    public static void main(String [] args){
        MyThread4 mt = new MyThread4();//共享同一资源
        Thread t1 = new Thread(mt);//
        Thread t2 = new Thread(mt);//三个线程代表三个售票窗口
        Thread t3 = new Thread(mt);//
        t1.start();
        t2.start();
        t3.start();
    }

}

看看结果：

     虽然没卖重号的票，也没多卖出0、-1号的，但是却全都是一个窗口--0号窗口卖出去的。因为在ti也就是0号线程start的时候调用run()方法，然后0号就悲剧的被错位的synchronized锁在了里面，所以只能一个窗口全部卖完了。

     提醒一下大家，不要犯类似的错误。

     线程本身的数据通常只有寄存器数据和程序执行时的堆栈段，所以线程的切换比进程的负担要小。线程不能自动运行，必须跻身在某一进程中，由进程触发。一个进程可以有多个线程且进程间不共用线程。

     实现多线程有两种方法，一是继承Thread类，二是实现Runnable接口。

     继承Thread类创建线程时，首先要定义一个Thread类的子类，并在该子类中重写run（）方法。run（）方法是线程体，说明该线程的具体操作。需要创建线程时，只需创建该子类的对象在调用其start（）方法即可。

     实现Runnable接口创建线程必须重写该接口的run（）方法（Runnable接口只有一个run（）方法）。

     由于Java是单继承语言，不直接支持多继承，如果一个类已经是其他类的子类，就不能在继承Thread方法使该类成为线程类，这时就要采用实现Runnable接口的方式。

     两种方法创建的线程中具有相同目标对象的线程可以共享内存单元，但是实现Runnable接口的线程去创建目标对象的类可以是某个特定类的子类，因此实现Runnable接口创建线程比继承Thread类创建线程更灵活。

     举几个小例子来看一下哈

     继承Thread类实现的多线程：

class MyThread1  extends Thread{
     private String name;
     public MyThread1(String name){
         this.name= name;
     }
     public void run(){
         for(int i=0;i<15;i++){
             System.out.println(this.name+"---->Is Running");
         }
     }

}
public class ThreadDemo01{
     public static void main(String[] args){
        Runnable r1 = new MyThread1("线程A");
        Runnable r2 = new MyThread1("线程B");
        Runnable r3 = new MyThread1("线程C");
        Runnable r4 = new MyThread1("线程D");
        Thread t1 = new Thread (r1);
        Thread t2 = new Thread (r2);
        Thread t3 = new Thread (r3);
        Thread t4 = new Thread (r4);
        t1.start();
        t2.start();
        t3.start();
        t4.start();

//也可以这样写
        /* MyThread mt1 = new MyThread("线程A");
         MyThread mt2 = new MyThread("线程B");
         MyThread mt3 = new MyThread("线程C");
         MyThread mt4 = new MyThread("线程D");
         mt1.start();

         mt2.start();
         mt3.start();
         mt4.start();*/
     }
}

0.0！！运行结果好长，就不截图了哈，可以自己试试。

     实现Runnable接口的多线程（实现了共享资源）：

class MyThread2 implements Runnable{
    //定义十张票

    private int ticket=10;
    public void run(){
        for(int i=0;i<500;i++){
            if(this.ticket>0){
                System.out.println("卖票-------"+(this.ticket--));
            }
        }
    }
}
public class ThreadDemo02 {
    public static void main(String[] args){
        MyThread2 mt =new MyThread2();

        //共享同一资源
        Thread mt1 = new Thread(mt);
        Thread mt2 = new Thread(mt);
        Thread mt3 = new Thread(mt);
        mt1.start();
        mt2.start();
        mt3.start();
    }

}

运行结果：

     对流的类型可以从三个角度进行分类。

     按数据流的方向不同可以分为输入流和输出流。（以程序的角度考虑）

     按处理数据的单位不同分为字节流（以byte为单位8位）和字符流（16位）。

     按功能的不同可以分为节点流和处理流。

     下表中的是输入输出的抽象类，是不能进行实例化的。

     以下的是上面抽象类比较常用的的子类，在实现父类方法的同时都定义了自身特有的功能。

FileInputStream/FileOutputStream//以File开头，节点流，用来操作文件，字节流。

FileReader\FileWriter //以File开头，处理流，用来操作文件，字符流。

BufferedInputStream/BufferedOutputStream//带缓冲的，处理流，字节流。

BufferedReader\BufferedWriter //带缓冲的，处理流，字符流。

     不难看出以Stream结尾的是字节流，以Reader、Writer结尾的是字符流。

     缓冲流要套接在相应的节点流上，将读写的数据先放在内存中进行缓存，提高了镀锡效率，同时扩展了一些方法。使用flush方法可以使内存中数据立刻写出。

     处理流要套接在节点流或者处理流上，通过对数据的处理增强程序的读写功能。

     举一部分例子：

     用File创建文件

1.

import java.io.File;
import java.io.IOException;

public class IODemo1 {
    public static void main(String[] args) throws IOException{
        File f = null;
        f = new File("f:"+File.separator+"demo.txt");//或写成("f:\\demo.txt")
        System.out.println(f.createNewFile());//当不存在具有此抽象路径名指定名称的文件时，创建一个新的空文件。
        System.out.println(f.getPath());//获取文件目录
        System.out.println(f.isDirectory());//判断文件是否是一个目录
    }
}

运行结果

2.

import java.io.File;

public class IODemo2 {
    public static void main(String[] args){
        File f = null;
        f = new File("f:"+File.separator+"demo01.txt");
        if(f.exists()){//如果文件存在则删除
            f.delete();
        }
        else{
            try{
                System.out.println(f.createNewFile()+"文件已创建");//文件不存在则创建
            }catch(Exception e){}
        }
    }

}

运行结果提示文件已创建。

3.

import java.io.File;

public class IODemo3 {
    public static void main(String[] args){
        File f = new File("F:");
        File file[] = f.listFiles();//将F盘的文件和目录名存在数组中
        for(int i=0;i<file.length;i++){
            System.out.println(file[i]);
        }
        String str[] = f.list();//将F盘的文件存在数组中
        for(int i=0;i<str.length;i++){
            System.out.println(str[i]);
        }
    }
}

额  F盘文件太多了，就不截图了哈，可以自己试一下！^_^

     InputStream的例子：

import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;

public class IODemo8 {
    public static void main(String[] args) {
        File f = new File("e:" + File.separator + "demo.txt");// 要输入到的文件
        InputStream input = null;
        try {
            input = new FileInputStream(f);
        } catch (Exception e) {
        }
        byte b[] = new byte[9];
        for (int i = 0; i < b.length; i++) {
            try {
                b[i] = (byte) input.read();
            } catch (Exception e) {
            }
        }
        try {
            input.close();
        } catch (Exception e) {
        }
        // 输出读入的内容
        System.out.println(new String(b));
    }

}

因为定义的数组长度是1024，所以后面跟了N多个空格。

FileInputStrea的例子：

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class IODemo13 {
    public static void main(String[] args){
        int b=0;
        FileInputStream in = null;
        try{
            in = new FileInputStream("e:"+File.separator+"demo1.txt");
        }catch(FileNotFoundException e){
            e.printStackTrace();
        }
        long num  = 0;
        try{
            while((b=in.read())!=-1){//到文件尾得到-1，结束循环
                System.out.print((char)b);
                num++;
            }
            in.close();
        }catch(IOException e){e.printStackTrace();}
        System.out.println("共读取了"+num+"个字节");
    }

}

Reader的例子：

import java.io.File;
import java.io.FileReader;
import java.io.Reader;

public class IODemo11 {
    public static void main(String[] args){
        File f=new File("e:"+File.separator+"demo.txt");
        Reader r =null;
        try{
            r = new FileReader(f);
        }catch(Exception e){}
        char c[] = new char[1024];
        int count = 0;
        try{
            count = r.read(c);
        }catch(Exception e){}
        System.out.println(new String(c,0,count));
    }

}

运行结果^_^

FileWriter的例子：

import java.io.File;
import java.io.FileWriter;

public class IODemo12 {
    public static void main(String[] args){
        File f =new File("e:"+File.separator+"demo02.txt");//要写入到的文件
        FileWriter out = null;
        try{
            out = new FileWriter(f);
        }catch(Exception e){}
        try{
            out.write("Hello fly—");//写入的内容
        }catch(Exception e){}
        try{
            out.close();
        }catch(Exception e){}
    }

}

额 这个在E盘生成了一个文件demo02，里面有以句话Hello fly—。

BufferedReader的例子：

import java.io.BufferedReader;
import java.io.InputStreamReader;

public class IODemo17 {
    public static void main(String[] args){
        BufferedReader buf = null;
        buf = new BufferedReader(new InputStreamReader(System.in));//从键盘获取输入的内容
        String str = null;
        System.out.print("请输入内容：");
        try{str = buf.readLine();//读取输入的内容
        buf.close();
        }catch(Exception e){}
        System.out.println("输入的内容："+str);
    }

}

就举这些例子吧！有错的请指出来哈^_^！

      运行程序显示结果如下：

1、添加记录：

2、修改记录：

3、浏览记录：

4、退出系统：

各类之间调用关系如下图所示：

程序代码如下：

import com.dr.demo.menu.Menu;

public class Main {   
        public static void main(String[] args) {   
                new Menu();   
        }   
}

public class Menu {
    InputData input = null;
    public Menu(){
        this.input = new InputData();
        //循环出现菜单
        while(true){
            this.show();
        }
    }
    //要定义的菜单的内容
    public void show(){
        System.out.println("\t\t\t\t1~增加人员信息");
        System.out.println("\t\t\t\t2~修改人员信息");
        System.out.println("\t\t\t\t3~浏览人员信息");
        System.out.println("\t\t\t\t4~退出本系统！");
        System.out.println("\n\n请选择要使用的操作：（1.2.3.4）");
        int temp = input.getInt();
        switch(temp){
        case 1:{//增加人员信息
            new PersonOperate().add();//业务处理层
                break;
        }
        case 2:{//修改人员信息
            new PersonOperate().update();
                break;
        }
        case 3:{//浏览人员信息
            new PersonOperate().show();
                break;
        }
        case 4:{//退出系统
            System.out.println("选择的是退出本系统！");
            System.out.println("成功退出本系统！");
            System.exit(1);
        }
        default:{
            System.out.println("输入的内容不正确，请重新输入！");
            break;
        }
        }
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class InputData {
    public BufferedReader buf = null;
    public InputData(){
        buf = new BufferedReader(new InputStreamReader(System.in));
    }
    public String getString(){
        String str = null;
        try {
            str = buf.readLine();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return str;
    }
    public  int getInt(){
        int temp = 0;
        String str = null;
        boolean flag = true;
        while(flag){
            //输入数据
            str = this.getString();
            if(!(str.matches("\\d+"))){
                //输入的不是1-4的数，提示重新输入
                System.out.println("输入的数字有误，请重新输入！（必须是整数1-4）");
            }
            else {//数据输入正确，进行转换
                temp = Integer.parseInt(str);
                //退出循环
                flag = false;
            }
        }
        return temp;
    }
    public String getpsString(){
        String str = null;
        try {
            str = buf.readLine();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return str;
    }
    public float getFloat(){
        float f = 0;
        String str = null;
        boolean flag = true;
        while(flag){
            str = this.getString();
            if(!(str.matches("\\d+?.\\d{1,2}"))){
                //如果输入的不是两位的小数则提示重新输入
                System.out.println("输入的数必须是float类型，请重新输入！");
            }
            else{
                f = Float.parseFloat(str);
                flag = false;//退出循环哈
            }
        }       
        return f;
    }

}

public class PersonOperate {
    private InputData input = null;
    public PersonOperate(){
        this.input = new InputData();
    }
    //增加记录
    public void add(){
        String name = null;
        int age = 0;
        String position = null;
        float salary = 0;
        System.out.println("请输入姓名：");
        name = this.input.getString();
        System.out.println("请输入年龄：");
        age = this.input.getInt();
        System.out.println("请输入职位：");
        position = this.input.getpsString();
        System.out.println("请输入薪酬：");
        salary = this.input.getFloat();
        //生成对象并保存在文件中
        Person p = new Person(name,age,position,salary);
        try{
            new FileOperate().save(p);//IO操作层
            System.out.println("数据保存成功！");
        }catch(Exception e){
        System.out.println("数据保存失败！");
        }
    }
    //浏览记录
    public void show(){
        Person p = null;
        try{
            p = (Person)new FileOperate().read();
        }catch(Exception e){
            System.out.println("显示数据失败，请检查数据是否存在！");
        }
        if(p!= null){
            System.out.println(p);
        }
    }
    //修改记录
    public void update(){
        Person p = null;
        try{
            p = (Person)new FileOperate().read();
        }catch(Exception e){
            System.out.println("显示数据失败，请检查数据是否存在！");
        }
        if(p!=null){
            String name = null;
            int age = 0;
            String position = null;
            float salary = 0.0f;
            System.out.println("请输入新姓名：（原姓名："+p.getName()+"）");
            name = this.input.getString();
            System.out.println("请输入新年龄：（原年龄"+p.getAge()+"）");
            age = this.input.getInt();
            System.out.println("请输入新职位：（原职位"+p.getPosition()+"）");
            position = this.input.getpsString();
            System.out.println("请输入新工资：（原工资"+p.getSalary()+"）");
            salary = this.input.getFloat();
            //信息重置
            p.setName(name);
            p.setAge(age);
            p.setPosition(position);
            p.setSalary(salary);
            try{
                new FileOperate().save(p);
                System.out.println("数据更新成功！");
            }catch(Exception e){
                System.out.println("数据更新失败！");   
            }
        }
    }
}

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class FileOperate {
    public  static final String FILENAME = "e:"+File.separator+"person.ser";
    //把对象保存在文件中
    public void save(Object obj){
        ObjectOutputStream  out = null;
        try{
            out = new ObjectOutputStream(new FileOutputStream(new File(FILENAME)));
            //写入对象
            out.writeObject(obj);
        }catch(Exception e){
            try{
                throw e;
            }catch(Exception e1){}
        }finally{
            try{
                out.flush();
                out.close();
            }catch(Exception e){}
        }
    }
    //从文件中读出对象
    public Object read() throws Exception{
        Object obj = null;
        ObjectInputStream input =null;
        try{
            input = new ObjectInputStream(new FileInputStream(new File(FILENAME)));
            obj = input.readObject();
        }catch(Exception e){
            throw e;
        }finally{
            try{
                input.close();
            }catch(Exception e){}
        }
        return obj;
    }
}

import java.io.Serializable;

public class Person implements Serializable{
    public String toString(){
        return "姓名："+this.name+"\t年龄："+this.age+"   \t职位："+this.position+"\t薪酬："+this.salary;
    }
    private String name;
    private int age;
    private String position;
    private float salary;
    public Person(){}
    public Person(String name,int age,String position,float salary){
        this.name = name;
        this.age = age;
        this.position = position;
        this.salary = salary;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getPosition() {
        return position;
    }
    public void setPosition(String position) {
        this.position = position;
    }
    public float getSalary() {
        return salary;
    }
    public void setSalary(float salary) {
        this.salary = salary;
    }
}

     本程序优点在于各层之间耦合性不大，独立性比较强，重在理解Menu层、文件操作层、IO操作层三层之间的调用关系。存在的缺陷希望读者可以完善。

上面的只是比较常用的一部分，并不全面，欢迎你补充。有错误的话请指出来哈。

      1.病人挂号使用的客户端：在界面上选择想选择的专家对应的专家号，屏幕上提示挂号成功，同时将该病人添加到他所选的专家对应的病人队列中。

      2.医院工作人员使用的客户端：在界面上单击相应的专家号就会在其对应的病人队列中取出一位病人，在屏幕上显示该病人对应的id和名字（防止出现重名的尴尬）并提示到对应的专家处就诊。当没有病人时，做出提示。

封装医生类

public class Doctor {
    private String ID;

    public String getID() {
        return ID;
    }

    public void setID(String iD) {
        ID = iD;
    }

}

封装病人类

public class Patient {
    private String id;
    private String name;
    private String doctorID;//病人选择的专家的ID
    public String getDoctorID() {
        return doctorID;
    }
    public void setDoctorID(String doctorID) {
        this.doctorID = doctorID;
    }
    public String getid() {
        return id;
    }
    public void setid(String id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

挂号服务器类

import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Queue;

public class Hospitalserver {
    public Map<String,Queue<Patient>> specialistList = new HashMap<String,Queue<Patient>>();
    Queue<Patient> doc1Queue = new LinkedList<Patient>();
    Queue<Patient> doc2Queue = new LinkedList<Patient>();
    Queue<Patient> doc3Queue = new LinkedList<Patient>();
    List<Patient>  allPatient = new LinkedList<Patient>();
    public void init(){
        //实例化三个医生，其ID就是对应的专家号
        Doctor doc1 = new Doctor();
        doc1.setID("01");
        Doctor doc2 = new Doctor();
        doc2.setID("02");
        Doctor doc3 = new Doctor();
        doc3.setID("03");
        //实例化6个病人,并添加到对应的专家队列中
        Patient aa = new Patient();
        aa.setid("001");
        aa.setName("joe a");
        aa.setDoctorID("01");
        doc1Queue.add(aa);
        Patient bb = new Patient();
        bb.setid("002");
        bb.setName("joe b");
        aa.setDoctorID("01");
        doc1Queue.add(bb);
        //********************************************
        Patient cc = new Patient();
        cc.setid("003");
        cc.setName("joe c");
        aa.setDoctorID("02");
        doc2Queue.add(cc);
        Patient dd = new Patient();
        dd.setid("004");
        dd.setName("joe d");
        aa.setDoctorID("02");
        doc2Queue.add(dd);
        //********************************************
        Patient ee = new Patient();
        ee.setid("005");
        ee.setName("joe e");
        aa.setDoctorID("03");
        doc3Queue.add(ee);
        Patient ff = new Patient();
        ff.setid("006");
        ff.setName("joe f");
        aa.setDoctorID("03");
        doc3Queue.add(ff);
        specialistList.put(doc1.getID(), doc1Queue);
        specialistList.put(doc2.getID(), doc2Queue);
        specialistList.put(doc3.getID(), doc3Queue);
    }
}

病人使用的客户端

import java.util.Queue;

import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Text;

public class HospitalPatientUI {
    public static void main(String[] args) {
        final Display display = Display.getDefault();
        final Shell shell = new Shell();
        shell.setMaximized(true);
        shell.setText("医院排队之病人使用的客户度端");
        // ------------------新插入的界面核心代码------------------------
        Hospitalserver hospatient = new Hospitalserver();// 实例化类
        hospatient.init();// 初始化队列服务器
        final Queue<Patient> doc1Queue = hospatient.specialistList.get("01");
        final Queue<Patient> doc2Queue = hospatient.specialistList.get("02");
        final Queue<Patient> doc3Queue = hospatient.specialistList.get("03");

        final Text patient1Txt = new Text(shell, SWT.MULTI);
        patient1Txt.setBounds(100, 50, 200, 150);

        final Button patient1button = new Button(shell, SWT.Activate);
        patient1button.addSelectionListener(new SelectionAdapter() { // 加一个选择监听器
                    public void widgetSelected(SelectionEvent e) {
                        //实例化一个病人，并添加到他选择的专家的队列中
                        Patient patient1 = new Patient();
                        doc1Queue.add(patient1);
                        patient1Txt.setText("欢迎您选择一号专家\n请在等待区稍等\n另外请关注广播和屏幕通知！");
                    }
                });

        patient1button.setBounds(100, 330, 200, 75); // 设置按钮位置
        patient1button.setFont(new Font(display, "宋体", 12, SWT.BOLD));
        patient1button.setText("一号专家");// 设置按钮上的文字

        // *****************************************************************

        final Text patient2Txt = new Text(shell, SWT.MULTI);
        patient2Txt.setBounds(400, 50, 200, 150);

        final Button patient2button = new Button(shell, SWT.Activate);
        patient2button.addSelectionListener(new SelectionAdapter() { //
                    public void widgetSelected(SelectionEvent e) {
                        Patient patient2 = new Patient();
                        doc1Queue.add(patient2);
                        patient2Txt.setText("欢迎您选择二号专家\n请在等待区稍等\n另外请关注广播和屏幕通知！");
                    }
                });
        patient2button.setBounds(400, 330, 200, 75); // 设置按钮位置
        patient2button.setFont(new Font(display, "宋体", 12, SWT.BOLD));
        patient2button.setText("二号专家");// 设置按钮上的文字

        // ***************************************************

        final Text patient3Txt = new Text(shell, SWT.MULTI);
        patient3Txt.setBounds(700, 50, 200, 150);

        final Button patient3button = new Button(shell, SWT.Activate);
        patient3button.addSelectionListener(new SelectionAdapter() {
                    public void widgetSelected(SelectionEvent e) {
                        Patient patient3 = new Patient();
                        doc1Queue.add(patient3);
                        patient3Txt.setText("欢迎您选择三号专家\n请在等待区稍等\n另外请关注广播和屏幕通知！");
                    }
                });
        patient3button.setBounds(700, 330, 200, 75); // 设置按钮位置
        patient3button.setFont(new Font(display, "宋体", 13, SWT.BOLD));
        patient3button.setText("三号专家");// 设置按钮上的文字

        // ------------------END---------------------------------------------
        shell.layout();
        shell.open();
        while (!shell.isDisposed()) {
            if (!display.readAndDispatch())
                display.sleep();
        }

    }
}

运行结果：

医院工作人员使用的客户端：

import java.util.Queue;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Text;

public class HospitalWorkerUI {
        public static void main(String[] args) {
            final Display display = Display.getDefault();
            final Shell shell = new Shell();
            shell.setMaximized(true);
            shell.setText("医院排队之医院工作人员使用的客户端");
            // ------------------新插入的界面核心代码------------------------
            Hospitalserver qs = new Hospitalserver();//实例化类
            qs.init();//初始化队列服务器
            final Queue<Patient> doc1Queue=qs.specialistList.get("01");
            final Queue<Patient> doc2Queue=qs.specialistList.get("02");
            final Queue<Patient> doc3Queue=qs.specialistList.get("03");

            final Text doc1Txt = new Text(shell,SWT.MULTI);
            doc1Txt.setBounds(100, 50, 200, 150);
            final Button doc1button = new Button(shell, SWT.Activate);
            doc1button.addSelectionListener(new SelectionAdapter() { // 加一个选择监听器
                        public void widgetSelected(SelectionEvent e) {
                                        Patient one=doc1Queue.poll();
                                        if(one!=null)
                                        {
                                            doc1Txt.setText("请"+one.getid()+"号病人"+one.getName()+"到一号专家处就诊，请其他病人稍等。");
                                        }
                                        else
                                        {
                                            doc1Txt.setText("暂时没有病人了，请您稍作休息。");
                                        }
                                    }
                                });

            doc1button.setBounds(100, 330, 200, 75); // 设置按钮位置
            doc1button.setFont(new Font(display,"宋体",12,SWT.BOLD));
            doc1button.setText("一号专家");// 设置按钮上的文字
            //*****************************************************************

            final Text doc2Txt = new Text(shell,SWT.MULTI);
            doc2Txt.setBounds(400, 50, 200, 150);
            final Button doc2button = new Button(shell, SWT.Activate);
            doc2button.addSelectionListener(new SelectionAdapter() { // 加一个�?择监听器
                        public void widgetSelected(SelectionEvent e) {

                            Patient two=doc2Queue.poll();
                            if(two!=null)
                            {
                                doc2Txt.setText("请"+two.getid()+"号病人"+two.getName()+"请到二号专家处就诊，请其他病人稍等。");
                            }
                            else
                            {
                                doc2Txt.setText("暂时没有病人了，请您稍作休息。");
                            }
                        }
                    });
            doc2button.setBounds(400, 330, 200, 75); // 设置按钮位置
            doc2button.setFont(new Font(display,"宋体",12,SWT.BOLD));
            doc2button.setText("二号专家");// 设置按钮上的文字
            //***************************************************

            final Text doc3Txt = new Text(shell,SWT.MULTI);
            doc3Txt.setBounds(700, 50, 200, 150);
            final Button doc3button = new Button(shell, SWT.Activate);
            doc3button.addSelectionListener(new SelectionAdapter() { // 加一个�?择监听器
                        public void widgetSelected(SelectionEvent e) {
                             Patient three=doc3Queue.poll();
                                if(three!=null)
                                {
                                    doc3Txt.setText("请"+three.getid()+"号病人"+three.getName()+"请到三号专家处就诊，请其他病人稍等。");
                                }
                                else
                                {
                                    doc3Txt.setText("暂时没有病人了，请您稍作休息。");
                                }
                            }
                        });
            doc3button.setBounds(700, 330, 200, 75); // 设置按钮位置
            doc3button.setFont(new Font(display,"宋体",13,SWT.BOLD));
            doc3button.setText("三号专家");// 设置按钮上的文字

            // ------------------END---------------------------------------------
            shell.layout();
            shell.open();
            while (!shell.isDisposed()) {
                if (!display.readAndDispatch())
                    display.sleep();
            }
        }
}

运行结果：

     不足之处：没有实现自动判断病人选择的专家号；没有实现病人使用的客户端和医院工作人员使用的客户端的同步更新。当然还有一些其他的不足，期待您指出并提出完善意见。

      1.银行工作人员使用的客户端实现功能：每次单击Button“下一个”，窗口上会显示提示X号顾客去y号窗口办理业务；当顾客队列里没有顾客时对工作人员作出提示。

      2.顾客使用的客户端实现功能：每当有顾客单击Button“个人业务”，窗口上会显示当前顾客在队伍中的位置以及他的前面还有多少位顾客，当排在当前顾客前面的顾客人数超过50人时提示前面已经有50个人，是否继续等候。关于这个金卡通道嘛，现在流行各种会员啊VIP啦等等，这个金卡通道当然就是为银行的VIP准备的。当单击Button“金卡通道”时，将当前Waiter添加到顾客队列的首位并在窗口上显示无需等待~~。

代码如下：

      封装顾客类。

public class Waiter {

    private int num;         //顾客号
    private int frontNum;  //排在前面的人数
    private int flag;          //卡类型

    public int getFlag() {
        return flag;
    }

    public void setFlag(int flag) {
        this.flag = flag;
    }

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }

    public int getFrontNum() {
        return frontNum;
    }

    public void setFrontNum(int frontNum) {
        this.frontNum = frontNum;
    }
}

初始化顾客队列（30个人）。

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

public class QueueServer {

    LinkedList<Waiter> waiterList = new LinkedList<Waiter>();
    public LinkedList<Waiter> init(){
        for(int i=1;i<=30;i++){
            Waiter w = new Waiter();
            w.setNum(i);
            w.setFrontNum(i-1);
            waiterList.offer(w);
        }
        return waiterList;
    }
}

顾客使用的客户端：

import java.util.LinkedList;

import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Text;

public class Swtgoldcard {
        public static void main(String[] args) {
            final Display display = Display.getDefault();
            final Shell shell = new Shell();
            shell.setMaximized(true);
            shell.setText("银行排队系统之金卡插队");
            // ------------------新插入的界面核心代码------------------------
            QueueServer qs = new QueueServer();//实例化顾客队列类
            final LinkedList<Waiter> waiterList = qs.init();//初始化队列服务器
            final Text txt = new Text(shell,SWT.MULTI);
            txt.setBounds(40, 50, 500, 450);
            final Button button = new Button(shell, SWT.Activate);
            button.addSelectionListener(new SelectionAdapter() { // 加一个选择监听器
                        public void widgetSelected(SelectionEvent e) {
                            //System.out.println("############### " + waiterList.size());
                            Waiter waiter = new Waiter();                       
                            waiter.setNum(waiterList.size()+1);
                            waiter.setFrontNum(waiterList.size());
                            waiterList.offer(waiter);
                            if(waiterList.size() <= 50){
                                txt.setText( "您现在排在"+waiter.getNum()+"位置上\n您前面有"+waiter.getFrontNum()+"个人\n请您耐心等候！");
                            }else{
                                txt.setText("您前面已经排50个人\n请考虑是否继续等待！\n"+"您现在排在"+waiter.getNum()+"位置上\n您前面有"+waiter.getFrontNum()+"个人\n请您耐心等候！");
                            }
                        }
            });
            button.setBounds(180, 530, 200, 75); // 设置按钮位置
            button.setFont(new Font(display,"宋体",12,SWT.BOLD));
            button.setText("个人业务");// 设置按钮上的文字

            //金卡通道
            final Text goldTxt = new Text(shell,SWT.MULTI);
            goldTxt.setBounds(900, 50, 500, 450);
            final Button goldButton = new Button(shell, SWT.Activate);
            goldButton.addSelectionListener(new SelectionAdapter() { // 加一个选择监听器
                        public void widgetSelected(SelectionEvent e) {
                            Waiter goldWaiter = new Waiter();
                            goldWaiter.setFlag(1);
                            waiterList.addFirst(goldWaiter);                       
                            goldTxt.setText("您是金卡用户＼ｎ可以优先接受服务＼ｎ无需等待！\n"+"您现在排在"+goldWaiter.getNum()+"位置上，\n您前面有"+goldWaiter.getFrontNum()+"个人");
                        }
            });
            goldButton.setBounds(1060, 530, 200, 75); // 设置按钮位置
            goldButton.setFont(new Font(display,"宋体",12,SWT.BOLD));
            goldButton.setText("金卡通道");// 设置按钮上的文字

            // ------------------END---------------------------------------------
            shell.layout();
            shell.open();
            while (!shell.isDisposed()) {
                if (!display.readAndDispatch())
                    display.sleep();
            }
        }

        }

运行结果：

当等待队列中人数超过50人时显示结果：

银行工作人员使用的客户端：

import java.util.Queue;

import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Text;

public class BankWorkerUI {
    public static void main(String[] args) {
        final Display display = Display.getDefault();
        final Shell shell = new Shell();
        shell.setSize(352, 253);
        shell.setText("银行排队系统之工作人员客户端");
        // ------------------新插入的界面核心代码------------------------
        QueueServer qs = new QueueServer();//实例化类
        final Queue<Waiter> waiterList = qs.init();//初始化队列服务器
        final Text txt = new Text(shell,SWT.MULTI);
        txt.setBounds(65, 30, 220, 70);
        final Button button = new Button(shell, SWT.Activate);
        button.addSelectionListener(new SelectionAdapter() { // 加一个选择监听器
                    public void widgetSelected(SelectionEvent e) {
                        //System.out.println("############### " + waiterList.size());
                        Waiter waiter= waiterList.poll();
                        if(waiter!= null){
                          txt.setText(waiter.getNum()+"号顾客请到1号窗口办理业务");
                        }else{
                            txt.setText("暂时没有顾客要办理业务，您可以休息一下！\n ");
                        }
                    }
                });
        button.setBounds(120, 141, 100, 25); // 设置按钮位置
        button.setText("下一个");// 设置按钮上的文字

        // ------------------END---------------------------------------------
        shell.layout();
        shell.open();
        while (!shell.isDisposed()) {
            if (!display.readAndDispatch())
                display.sleep();
        }
    }
}

运行结果：

这个程序还有缺陷，没有用到数据库，无法实现工作人员所用的客户端与顾客所用的客户端同步更新，请高手指点完善。

      1封装性

      封装性是一种信息隐蔽技术，它体现于类的说明，是对象重要的特性。封装使数据和操作该数据的方法（函数）封装为一个整体，形成独立性很强的模块，使得用户只能看到对象的外部特性（对象可以接受哪些信息，可以进行何种处理），而对象的内部特性（内部private的属性和实现处理能力的算法）用户是看不到的。简言之就是封装使对象的设计者和对象的使用者分开，使用者只要知道对象可以做什么，无需知道是怎么做出来的。借助封装有助于提高类和系统的安全性。

      看一下下面的例子：

没有封装的程序：

class Person{

String name;

int age;

public void say(){

System.out.println(“NAME:***”+name+”   AGE:***”+age);

}

}

public class Demo01{

public static void main(String arg[]){

Person p=new Person();

p.name=“Michael”;

p.age  = –26;

p.say();

}

}

　　运行结果：

　　未封装时程序可以通过编译运行也没有问题，但是年龄是不可以为负值的。这就是属性直接对外可见造成的笑话。

封装后的程序：

class Person{

private String name;

private int age;

public void say(){

System.out.println(“NAME:***”+name+”   AGE:***”+age);

}

}

public class Demo02{

public static void main(String arg[]){

Person p=new Person();

p.name=“Michael”;

p.age=-26;

p.say();

}

}

　　运行结果：

　　由于进行了封装，属性对外不可见，所以编译时提示上图灰色区域中的内容。

　　对于封装的属性的设置和取得应该通过setter和getter方法，通过Setter和Getter方法设置封装的属性并对年龄值进行检查的程序如下：

class Person{

    private String name;

    private int age;

    public void setName(String n){

    name=n;

    }

    public String getName(){

    return name;

    }

    public void setAge(int a){ //Setter是入口，Getter是出口，在setter方法处检查年龄是否在允许的范围内。

    if(a>=0&&a<120){

    age=a;

    }else{

    age = -1;
    System.out.println("年龄非法");//提示年龄非法;

    }

    }

    public int getAge(){

    return age;

    }

    public void say(){

    System.out.println("NAME:***"+name+"   AGE:***"+age);

    }

    }

    public class Demo04{

    public static void main(String arg[])

    {

    Person p=new Person();

    p.setName("Michael");

    p.setAge(-26);

    p.say();

    }

    }

　　此时运行后提示年龄非法：

　　２继承性

　　继承是一种由已有类创建新类的机制，利用继承，可以先创建一个共有属性的一般类，根据这个一般类再创建具有特殊属性的新类。新类继承一般类的方法并根据需要增加它自己的新方法。有继承而得到的类称为子类，被继承的类称为父类（超类），当然子类也可以成为父类。如下图，由下向上看，双炸飞机类和歼击机类都继承了战斗机类的特点但又分别具有自己新的功能，同样，战斗机类和民用机类都具有飞机类所有的特点也都扩展了属于自己的新功能。也就是说双炸飞机和歼击机既具有飞机的全部特点又拥有战斗机的全部特点。

用程序说明一下：

class Person{
    String name;
    int age;
    public String getInfo()
    {
        return "姓名：---"+this.name+"\n"+"年龄：---"+this.age;

    }
}

／／Student类继承Person类

class Student extends Person

{
      String school;／／Student类中扩展的属性
}

public class Demo01 {
        public static void main(String args[])
        {
            Student s = new Student();

　　　　／／在 Person  类中为属性赋值       

  s.name = "Michael";
            s.age = 25;

　　　　／／在 Student  类中为属性赋值
            s.school = "Camoridge University " ;
            System.out.println(s.getInfo()+"\n"+"学校：---"+s.school);

            }
        }

运行结果如下

　　３多态性

　　同一个信息被不同的对象接收到时可能产生完全不同行为，这就是多态性。通过继承过程中的方法重写就可以实现多态。多态可以改善程序的组织构架，提高程序的可读性，也是程序更容易扩充。

用下面的程序说明一下：

class A   
{
        public void fun1()
        {
                System.out.println("使用父类方法!");
        }
}
class B extends A
{
        // 此方法重写父类中的fun1()方法
        public void fun1()
        {
                System.out.println("父类方法已被子类方法重写！"+"\n"+"使用子类方法");
        }
}
public class Overrid
{
        public static void main(String args[])
        {
                A a = new A();
                B b = new B();
                a.fun1();
                b.fun1();
        }
}

运行结果如下：

同样使用了fun1()方法，在父类和子类中产生了完全不同的结果。

　　在此简单说明一下重写和重载的区别。重写（Override）是发生在子类和父类之间，为满足需要，子类对从父类中继承来的方法进行重写，方法的名称和参数类型或个数相同但是子类方法的访问权限不可以比父类更严格。而重载（Overloading）只发生在同一个类中，方法的名称相同，但是参数的个数或者类型不同。