2015秋-《面向对象程序设计》-实验指导书

《面向对象程序设计》实验指导书

实验一：类的继承和封装

1.1实验性质

验证性实验（4学时）

1.2实验目的

Java是完全面向对象（OOP，Object Oriented Programming）的编程语言，任何程序都是基于类，Java中所有的代码都写于类的内部。面向对象编写的程序则是由对象组成的，这些对象有自己的属性和能够执行的操作。本实验目的在于通过编程和上机实验进一步理解Java 语言是如何体现面向对象编程基本思想，了解类的封装方法，以及如何创建类和对象，了解成员变量和成员方法的特性，掌握OOP 方式进行程序设计的方法，了解类的继承性和多态性的作用。深化类的定义，类的继承，及相关语法规则，深化对类成员的使用，理解类的封装。

1.3实验任务

1) 2) 3) 4) 5) 6) 7) 8)

观察简单类的运行过程

体会类集成的机制以及思路

查看高级类（抽象类）的使用方法

编写一个复数类，实现复数的加、减、乘运算 编写一个银行账户类，实现简单的存取 编写一个矩形类，并由该类继承出方形类 编写一个图形类，完成面积计算 回答思考问题

1.4实验准备

将以下代码输入NetBeans中，若代码存在错误请进行修改，查看输出成果，并对各行语句进行解释，将解释内容和运行结果写入实验报告。 1）简单类示例 //EmployeeTest.java import java.util.*; public class EmployeeTest { public static void main(String[] args) { // 将三个员工对象的数据赋值给职工数组 Employee[] staff = new Employee[3]; staff[0] = new Employee(\张三\ staff[1] = new Employee(\李四\ staff[2] = new Employee(\王五\ for (int i = 0; i < staff.length; i++) staff[i].raiseSalary(5);//每个员工的工资增长5% for (int i = 0; i < staff.length; i++)// 打印输出员工信息 { Employee e = staff[i]; System.out.println(\姓名=\ + \工资=\ + \工作日期=\ } } } class Employee { private String name; private double salary; private Date hireDay; public Employee(String n, double s, int year, int month, int day) { name = n; salary = s; GregorianCalendar calendar = new GregorianCalendar(year, month - 1, day); // GregorianCalendar 计算月份从0开始 hireDay = calendar.getTime(); } public String getName() { return name; } public double getSalary() { return salary; } public Date getHireDay() { return hireDay; } public void raiseSalary(double byPercent) { double raise = salary * byPercent / 100; salary += raise; } } 2）类的继承 import java.util.*; public class ManagerTest { public static void main(String[] args) { // 创建一个新的经理并设置他的奖金 Manager boss = new Manager(\陈鹏\ 1987, 12, 15); boss.setBonus(5000); Employee[] staff = new Employee[3]; // 建立员工数组和经理一起填充 staff[0] = boss; staff[1] = new Employee(\何恒\ staff[2] = new Employee(\童同\ // print out information about all Employee objects for (int i = 0; i < staff.length; i++) { Employee e = staff[i]; System.out.println(\ + \ } } } class Employee { public Employee(String n, double s, int year, int month, int day) { name = n; salary = s; GregorianCalendar calendar = new GregorianCalendar(year, month - 1, day); // GregorianCalendar 方法计算月份从0开始 hireDay = calendar.getTime(); } public String getName() { return name; } public double getSalary() { return salary; } public Date getHireDay() { return hireDay; } public void raiseSalary(double byPercent) { double raise = salary * byPercent / 100; salary += raise; } private String name; private double salary; private Date hireDay; } class Manager extends Employee { /** 变量n是员工姓名 变量 s t员工工资 填充工龄的年、月、日 */ public Manager(String n, double s, int year, int month, int day) { super(n, s, year, month, day); bonus = 0; } public double getSalary() { double baseSalary = super.getSalary(); return baseSalary + bonus; } public void setBonus(double b) { bonus = b; } private double bonus; } 3）类的高级属性：抽象类的使用 // Employee.java // 抽象类Employee public abstract class Employee { private String firstName; private String lastName; // 构造函数 public Employee( String first, String last ) { firstName = first; lastName = last; } // 返回姓 public String getFirstName() { return firstName; } // 返回名 public String getLastName() { return lastName; } public String toString() { return firstName + ' ' + lastName; } // Employee抽象方法earnings(); //将被其每个子类以实例继承 public abstract double earnings(); } // Boss 类是Employee继承 public final class Boss extends Employee { private double weeklySalary; // 经理Boss类的构造函数 public Boss( String first, String last, double s) { super( first, last ); // call superclass constructor setWeeklySalary( s ); } // 经理Boss类的工资 public void setWeeklySalary( double s ) { weeklySalary = ( s > 0 ? s : 0 ); } // 确定Boss的薪水 public double earnings() { return weeklySalary; } // 打印姓名 public String toString() { return \经理: \ } } 1.5实验过程

（1）定义一个复数类，可以通过构造函数给复数对象赋值，实部和虚部是该类的私有属性，必须有获取和修改属性的方法，并定义它与复数、实数相加和相减及复数间乘的方法。

（2）定义一个类实现银行帐户的概念，包括的变量有“帐号”和“存款余额”，包括的方法有“存款”、“取款”和“查询余额”。定义主类，创建帐户类的对象，并完成相应操作。提示：关键代码如下： public int getleftmoney(){ return leftmoney; }

public void savemoney(double money){ leftmoney+=money; }

public void getmoney(double money){ if(money<=leftmoney) leftmoney-=money; else

System.out.println(\只能取：\} …

bankaccount ba=new bankaccount(123456,1000); ba.savemoney(2000);

System.out.println(\存入2000元后余额为：\ba.getmoney(1500);

System.out.println(\元后余额为：\

（3）定义一个矩形类，再定义接口EqualDiagonal，其中包含方法getDiagonal()；由矩形类派生出一个正方形类，自行扩充成员变量和方法，并实现此接口EqualDiagonal。

（4）利用Java继承机制。编写一个抽象的图形类Shape,里面有方法getArea()计算面积以及方法displayArea()显示面积，编写子类矩形类和三角型类分别实现两个方法。

1.6思考问题

（1） （2） （3） （4） （5） （6） （7） （8）

类的定义，什么是对象，两者之间的区别与联系？

什么是构造函数，如何调用？父类与子类的构造函数关系如何？ 什么是继承？子类从父类继承了什么？ 什么是重载函数，如何体现多态性？ 什么是包，如何打包？

类的高级属性总结如静态、抽象、final等。 类的四种访问修饰符总结。 什么是接口？如何实现接口？

实验二：异常的使用

2.1实验性质

验证性实验（4学时）

2.2实验目的

异常是面向对象语言非常重要的一个特性，良好的异常设计对程序的可扩展性、可维护性、健壮性都起到至关重要。本实验的目的子啊鱼掌握异常的概念和 Java 异常处理机制、了解 Java 异常类的继承和派生关系；掌握 try-catch-finally 结构、抛出异常。在实验室请注意（1）try、catch、finally三个语句块均不能单独使用，三者可以组成 try...catch...finally、try...catch、try...finally三种结构，catch语句可以有一个或多 个，finally语句最多一个。（2）try、catch、finally三个代码块中变量的作用域为代码块内部，分别独立而不能相互访问。如果要在三个块中都可以访问，则需要将变量定 义到这些块的外面。（3）多个catch块时候，只会匹配其中一个异常类并执行catch块代码，而不会再执行别的catch块，并且匹配catch语句的顺序是由上到下。

2.3实验任务

1) 2) 3) 4) 5)

体会try...catch...finally基本的语法结构和编程方法 掌握自定义异常的编写和使用 编写程序捕获数组访问超界异常

编程对ArithmeticException异常进行处理，掌握异常的逐步抛出机制 回答思考问题

2.4实验准备

将以下代码输入NetBeans中，若代码存在错误请进行修改，查看输出成果，并对各行语句进行解释，将解释内容和运行结果写入实验报告。 (1)异常语法示例 import java.io.*; public class app12_2 { public static void main(String args[]) { try // 检查这个程序块的程序代码 { char c=(char)System.in.read(); int arr[]=new int[5]; arr[13]=7; } catch(Exception e) { System.out.println(e.toString()); } finally // 这个块的程序代码一定会执行 { System.out.println(\ } System.out.println(\ }} (2)自定义异常 class CCircleException extends Exception // 定义自己的异常类 { public CCircleException(string msg) { Super(msg); } } class CCircle // 定义类CCircle { private double radius=-2d; public void setRadius(double r) throws CCircleException { if(r<0){ throw new CCircleException(); // 抛出异常 } else radius=r; } public void show(){ System.out.println(\ } } public class app12_8 { public static void main(String args[]) { CCircle cir=new CCircle(); try{ cir.setRadius(-2.0); //捕捉由setRadius()抛出的异常 } catch(CCircleException e){ System.out.println(e+\ } cir.show(); } } 2.5实验过程

（1）用Java 异常处理机制实现一个处理数组索引是否越界程序。

（2）建一个Example类，该类有一个result() 方法，在result()方法内部有两个多项式A=4x-4， B=2*x*x-4*x*y+y*y；C=A/B ，最后返回C的值。

要求：x和y的值作为该方法的形参，在计算C值以前，先判断A和B的值，当A或B等于零时抛出一个ArithmeticException异常，使用ArithmeticException捕获该异常，在创建ArithmeticException异常时须使用其带形参的构造函数，给形参赋值为“A 或 B =0”，使用getMessage()显示该字符串。

当A、B都不等于零时抛出一个Exception异常，使用Exception捕获该异常，在创建Exception异常时也须使用其带形参的构造函数，给形参赋值为“program is ok!”,使用getMessage()显示该字符串。

最后不管A、B是否等于零，都须显示”program is end”（注：使用finally）

为这个类创建一个main()方法，生成两个20以内的整形随机数，调用result（）方法，将这两个随机数赋给x和y.，显示最后结果。

2.6思考问题

（1） （2） （3） （4）

什么是异常？列举一二个常见的异常。 如何处理异常？为什么要处理？ 如何自定义异常类？ 常见的异常类有哪些？

实验三：图形用户界面设计

3.1实验性质

验证性实验（4学时）

3.2实验目的

Swing是Java基础类库 (JFC)的组成部分，它实现一组新的GUI组件，具有可插接的外观感觉效果。Swing是以100%纯Java实现的，且以JDK1.1 Lightweight UI框架为基础。可插接的外观感觉效果使您只需要设计一个GUI组件集，就可以自动得到与任意OS平台相吻合的外观感觉效果。Swing 组件包含两个已有AWT组件集的100%纯Java版本，外加一个高级组件的全集。本实验的目的在于掌握 Java 的 GUI 设计技术，熟悉 AWT 和 Swing（重点）的应用技巧。

3.3实验任务

1) 2) 3) 4) 5) 6) 7) 8) 9) 10) 11)

回顾AWT的应用方法

体会格网布局方案及其应用

观察可视化组件的事件监听机制和处理方法 查看基本的Swing用法

体验JTable组件的运用机制 编写一个带有条目的列表框 创建一个菜单

制作一个图书证信息输入窗体和一个借用物品窗体 编写基本的事件处理，交换窗体背景色彩

利用合适的布局和Swing控件完成一个简单的数据计算任务 回答思考问题

3.4实验准备

将以下代码输入NetBeans中，若代码存在错误请进行修改，查看输出成果，并对各行语句进行解释，将解释内容和运行结果写入实验报告。 （1）AWT简单示例 import java.awt.*; public class AwtDemo extends Frame{ Label lblname,lblage,lbladdr; TextField txtname,txtage; TextArea txtaddr; AwtDemo (String s) { super(s); setLayout(new FlowLayout()); lblname=new Label(\姓名:\ lblage=new Label(\年龄:\ lbladdr=new Label(\地址\ txtname=new TextField(15); txtage=new TextField(15); txtaddr=new TextArea(\北京\\n海淀区\\n982号\ add(lblname); add(txtname); add(lblage); add(txtage); add(lbladdr); add(txtaddr); } public static void main(String[] arg) { guidemo obj=new guidemo(\正在测试组件\ obj.setSize(400,300); obj.show(); } } （2）网格布局示例 import java.awt.*; import javax.swing.*; public class GridLayoutDemo { public static void main(String args[]) { JFrame frame=new JFrame(\布局\ Container c=frame.getContentPane(); GridLayout g=new GridLayout(3,2,5,5); c.setLayout(g); c.add(new JButton(\ c.add(new JButton(\ c.add(new JButton(\ c.add(new JButton(\ c.add(new JButton(\ c.add(new JButton(\ frame.setSize(200,250); frame.setVisible(true); } } （3）简单事件示例 import java.awt.*; import java.awt.event.*; public class eventdemo extends Frame implements ActionListener{ TextField txtf; TextArea txta; eventdemo(String title) { super(title); setLayout(new FlowLayout()); txtf=new TextField(20); txta=new TextArea(6,20); add(txtf); add(txta); txtf.addActionListener(this); addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e) { System.exit(0); } }); setSize(200,200); setVisible(true); } public void actionPerformed(ActionEvent e) { txta.setText(txtf.getText()); } public static void main(String[] arg) { eventdemo obj=new eventdemo(\事件示例\ } } （4）Swing示例 import java.awt.*; import java.awt.event.*; import javax.swing.*; import javax.swing.event.*; public class JListDemo implements ListSelectionListener { JList list = null; JLabel label = null; String[] s = { \美国\中国\英国\法国\意大利\澳洲\韩国\ public JListDemo() { JFrame f = new JFrame(\ Container contentPane = f.getContentPane(); contentPane.setLayout(new BorderLayout()); label = new JLabel(); list = new JList(s); list.setVisibleRowCount(5); // 设定列表方框的可见栏数 list.setBorder(BorderFactory .createTitledBorder(\您最喜欢到哪个国家玩呢？\ list.addListSelectionListener(this); contentPane.add(label, BorderLayout.NORTH); // 给列表方框添加滚动栏 contentPane.add(new JScrollPane(list), BorderLayout.CENTER); f.pack(); f.show(); f.addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e) { System.exit(0); } }); } public void valueChanged(ListSelectionEvent e) { int tmp = 0; String stmp = \您目前选取：\ //利用JList类所提供的getSelectedIndices()方法可得到用户所选取的所有项目 int[] index = list.getSelectedIndices(); //index值，这些index值由一个int array返回. for (int i = 0; i < index.length; i++) { tmp = index[i]; stmp = stmp + s[tmp] + \ \ } label.setText(stmp);

实验四：输入输出系统

4.1实验性质

验证性实验（4学时）

4.2实验目的

Java I/O处理中，最常见的是对文件流的操作，java.io包中有关文件处理的类有：File、FileInputStream、FileOutputStream、RamdomAccessFile和FileDescriptor；接口有：FilenameFilter。这一系列基础类良好辅助了编程对文件的管理，实现了一般应用程序的输入输出。本实验的目的在于掌握 Java 如何对流进行操作，如何使用数如输出系统。

4.3实验任务

1) 2) 3) 4) 5) 6) 7)

观察标准输入输出过程 体会文件的读取与显示 查看文件的复制方法

查看文件相关处理函数和目录函数的应用方法 编写程序读取学生个人信息并记录到文件

编写程序列取特定位置文件夹下的文件的属性内容 回答思考问题

4.4实验准备

将以下代码输入NetBeans中，若代码存在错误请进行修改，查看输出成果，并对各行语句进行解释，将解释内容和运行结果写入实验报告。 (1)利用标准输入输出 import java.io.*; public class StandardIO { public static void main(String[] args) { //IO操作必须捕获IO异常。 try { //先使用System.in构造InputStreamReader，再构造BufferedReader。 BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in)); //读取并输出字符串。 System.out.print(\ System.out.println(stdin.readLine()); //读取并输出整型数据。 System.out.print(\//将字符串解析为带符号的十进制整数。 int number1 = Integer.parseInt(stdin.readLine()); System.out.println(number1); //读取并输出double类型数据。 System.out.print(\//将字符串解析为带符号的double类型数据。 double number2 = Double.parseDouble(stdin.readLine()); System.out.println(number2); } catch (IOException e) { System.err.println(\ } } } (2)读取文件 import java.io.BufferedReader; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.IOException; import java.io.InputStreamReader; public class CatFile { public static void main(String[] av) { CatFile c = new CatFile(); if (av.length == 0) c.process(new BufferedReader(new InputStreamReader(System.in))); else for (int i = 0; i < av.length; i++) try { c.process(new BufferedReader(new FileReader(av[i]))); } catch (FileNotFoundException e) { System.err.println(e); } } /** print one file, given an open BufferedReader */ public void process(BufferedReader is) { try { String inputLine; while ((inputLine = is.readLine()) != null) { System.out.println(inputLine); } is.close(); } catch (IOException e) { System.out.println(\ } } } (3)复制文件 import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; public class CopyBytes { public static void main(String[] args) throws IOException { File inputFile = new File(\ File outputFile = new File(\ FileInputStream in = new FileInputStream(inputFile); FileOutputStream out = new FileOutputStream(outputFile); int c; while ((c = in.read()) != -1) out.write(c); in.close(); out.close(); } } (4)文件操作 import java.io.File; public class Delete { public static void main(String[] args) { String fileName = \ // A File object to represent the filename File f = new File(fileName); // Make sure the file or directory exists and isn't write protected if (!f.exists()) throw new IllegalArgumentException( \ if (!f.canWrite()) throw new IllegalArgumentException(\ + fileName); // If it is a directory, make sure it is empty if (f.isDirectory()) { String[] files = f.list(); if (files.length > 0) throw new IllegalArgumentException( \ } // Attempt to delete it boolean success = f.delete(); if (!success) throw new IllegalArgumentException(\ } } (5)目录操作 import java.io.File; import java.io.IOException; public class FileUtil { public static void main(String[] a)throws IOException{ showDir(1, new File(\ } static void showDir(int indent, File file) throws IOException { for (int i = 0; i < indent; i++) System.out.print('-'); System.out.println(file.getName()); if (file.isDirectory()) { File[] files = file.listFiles(); for (int i = 0; i < files.length; i++) showDir(indent + 4, files[i]); } } } 4.5实验过程

(1)根据示例，编写输入整数、实数、字符串、字符等有关操作。

(2)编写一个学生信息录入程序，将学生信息写到一个文件中，每行一个学生记录 学生信息为：姓名、学号、地址、出生日期及联系方式。

(3)读取C:\\根目录下的所有文件,并把文件的有关属性（文件名、文件创建日期、文件大小）输出。

4.6思考问题

（1） 如何从控制台输入值给变量？ （2） 如何读写文本文件？ （3） 如何处理文件的拷贝、删除、移动？如何处理目录的相关操作？

实验五：多线程应用

5.1实验性质

验证性实验（4学时）

5.2实验目的

线程是程序运行的基本执行单元。当操作系统（不包括单线程的操作系统，如微软早期的DOS）在执行一个程序时，会在系统中建立一个进程，而在这个进程中，必须至少建立一个线程（这个线程被称为主线程）来作为这个程序运行的入口点。因此，在操作系统中运行的任何程序都至少有一个主线程。Java中实现多线程有两种途径：继承Thread类或者实现Runnable接口。Runnable是接口，建议用接口的方式生成线程，因为接口可以实现多继承，况且Runnable只有一个run方法，很适合继承。在使用Thread的时候只需继承Thread，并且new一个实例出来，调用start()方法即可以启动一个线程。本实验的目的在于掌握线程的生命周期及状态迁移，学会如何创建线程，掌握线程的调度策略、线程优先级和线程同步。

5.3实验任务

1) 2) 3) 4) 5) 6) 7)

查看简单线程的运行过程

体会从Runnable接口创建线程的方法 观察优先级对线程的影响 查看线程同步的实现及其应用 编程实现两个线程交互式输出 编写一个有关存款的多线程应用 回答思考问题

5.4实验准备

将以下代码输入NetBeans中，若代码存在错误请进行修改，查看输出成果，并对各行语句进行解释，将解释内容和运行结果写入实验报告。 （1）简单线程示例 public class TwoThread extends Thread { public void run() { for (int i = 0; i < 10; i++) { System.out.println(\ } } public static void main(String[] args) { TwoThread tt = new TwoThread(); tt.start(); for (int i = 0; i < 10; i++) { System.out.println(\ } } } （2）从Runnable创建线程 public class RunnableThread implements Runnable { private int countDown = 5; public String toString() {

return \ \ } public void run() { while(true) { System.out.println(this); if(--countDown == 0) return; } } public static void main(String[] args) { for(int i = 1; i <= 5; i++) new Thread(new RunnableThread(), \ // Output is like SimpleThread.java } } （3）线程优先级 public class SetPriority extends Object { private static Runnable makeRunnable() { Runnable r = new Runnable() { public void run() { for (int i = 0; i < 5; i++) { Thread t = Thread.currentThread(); System.out.println(\ + \ try { Thread.sleep(2000); } catch (InterruptedException x) { } } } }; return r; } public static void main(String[] args) { Thread threadA = new Thread(makeRunnable(), \ threadA.setPriority(8); threadA.start(); Thread threadB = new Thread(makeRunnable(), \ threadB.setPriority(2); threadB.start(); Runnable r = new Runnable() { public void run() { Thread threadC = new Thread(makeRunnable(), \ threadC.start(); } }; Thread threadD = new Thread(r, \ threadD.setPriority(7); threadD.start(); try { Thread.sleep(3000); } catch (InterruptedException x) { } threadA.setPriority(3); System.out.println(\ + threadA.getPriority()); } } （4）线程同步 public class StaticSync extends Object { private static int nextSerialNum = 10001; public static synchronized int getNextSerialNum() { int sn = nextSerialNum; try { Thread.sleep(1000); } catch ( InterruptedException x ) { } nextSerialNum++; return sn; } private static void print(String msg) { String threadName = Thread.currentThread().getName(); System.out.println(threadName + \ } public static void main(String[] args) { try { Runnable r = new Runnable() { public void run() { print(\ getNextSerialNum()); } }; Thread threadA = new Thread(r, \ threadA.start(); Thread.sleep(1500); Thread threadB = new Thread(r, \ threadB.start(); Thread.sleep(500); Thread threadC = new Thread(r, \ threadC.start(); Thread.sleep(2500); Thread threadD = new Thread(r, \ threadD.start(); } catch ( InterruptedException x ) { // ignore } } } 5.5实验过程

(1)编写线程实现两个线程，交互输出输出顺序不定，参考如下

(2)要求编写一个多线程的应用程序，有两个客户（Custemer）向银行同一个帐号存款，每人分三次每次存100元，帐号原来的余额为0元，要求两个客户存款的动作可以同时执行（以多线程方式执行），并且最终的帐号余额为600元（采用多线程同步的方法，同步的关键字为：synchronized） 程序框架如下： class CBank //银行类 {

private static int sum=0; //表示帐号余额

①编写 add(int n)方法，实现向帐号存款 }

class CCustomer extends Thread // CCustomer类，继承自Thread类 {

②重新编写线程类void run()方法，调用银行类的add方法 }

public class Demo {

public static void main(String args[]) {

③编写代码，启动两个客户线程 } }

运行界面参考：

5.6思考问题

（1） 什么是线程，为什么要多线程？ （2） 线程的两种创建方法总结。 （3） 线程同步问题总结。 （4） 探讨几个经典线程问题，生产者---消费者问题、哲学家思考问题。

实验六：综合应用实验

6.1实验性质

综合性实验（4学时）

6.2实验目的

JDBC（Java Data Base Connectivity,java数据库连接）是一种用于执行SQL语句的Java API，可以为多种关系数据库提供统一访问，它由一组用Java语言编写的类和接口组成。JDBC提供了一种基准，据此可以构建更高级的工具和接口，使数据库开发人员能够编写数据库应用程序。本实验的目的在于理解和掌握 JDBC 的结构以及 JDBC 与数据库应用编成之间的关系，掌握 DriverManage、Connection、Statement等数据库类的常用方法。重点是在此基础之上编写一个带有数据库访问、具有综合服务功能的小型信息系统，在系统中实现数据的录入、修改、删除等操作，使学生进一步掌握Java应用编程的方法。

6.3实验任务

1) 2) 3) 4) 5)

观察如何利用ODBC-JDBC桥访问数据库 体会如何进行数据库相关的update操作 查看Statement的使用方法

编写一个具有增加、删除、修改功能，带有GUI界面的订单管理程序 回答思考问题

6.4实验准备

按照以下操作方式设计数据库访问，并将代码输入NetBeans中，若代码存在错误请进行修改，查看输出成果，并对各行语句进行解释，将解释内容和运行结果写入实验报告。 (1)利用ODBC-JDBC桥读取Access数据库 实现Java读取Access数据库。首先设置ODBC，在“控制面板”的“管理工具”中找到“数据源(ODBC)”，在出现的“ODBC数据源管理器”窗口中选择“系统DSN”(必须是系统DSN)。

单击“添加”按钮，在“创建新数据源”对话框中选择“Microsoft Access Driver”，如下图。

设置系统DSN

本文来源：https://www.bwwdw.com/article/m6oa.html