黑马程序员----JAVA基础----IO流_3及反射

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

一、IO流_3

1，操作对象 ObjectInputStream和ObjectOutputStream

被操作的对象需要实现Serializable接口。

作用：将对象持久化，即从内存中保存到硬盘上。

ObjectOutputStream将Java对象的基本数据类型和图形写入OutputStream，实现对象的持久存储，如果是网络套接字流，

则可以在另一台主机上或另一个进程中重构对象。ObjectInputStream 对以前使用 ObjectOutputStream写入的基本数据和对象进行反序列化

对象默认序列化机制写入的内容是：对象的类，类签名，以及非瞬态和非静态字段的值。

一个类被序列化后（如果没有显示声明serialVersionUID）存储到obj.object文件，如果这个类上有改动，而未重新序列化，那么再反序列化obj.object文件时

则会抛出java.io.InvalidClassException。解决的办法是，在被序列化的类中显示声明serialVersionUID，这样原来的类中有改动时，仍然可以反序列化。

如果被序列化的类没有显示声明serialVersionUID，那么再序列化过程中会根据类的情况进行默认序列化，得到一个serialVersionUID，这个serialVersionUID

高度敏感，对类稍加修改，都会改变这个serialVersionUID,因此在反序列化时，会发现两个serialVersionUID不同，因此会抛出java.io.InvalidClassException。

注意：静态字段和被transient修饰的字段不会被序列化。

演示代码：

import java.io.FileInputStream;import java.io.FileNotFoundException;import java.io.FileOutputStream;import java.io.IOException;import java.io.ObjectInputStream;import java.io.ObjectOutputStream;public class ObjectOutputStreamDemo {public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {//writeObj();readObj();}/** * @throws IOException * @throws FileNotFoundException * @throws ClassNotFoundException */private static void readObj() throws IOException, FileNotFoundException, ClassNotFoundException {/* * ObjectInputStream 对以前使用 ObjectOutputStream写入的基本数据和对象进行反序列化 */ObjectInputStream ois = new ObjectInputStream(new FileInputStream("obj.object"));// 读取obj。object文件还需要该类的字节码文件Person.classObject obj = ois.readObject();Person p = (Person)obj;System.out.println(p.getName()+"---"+p.getAge());}/** * @throws IOException * @throws FileNotFoundException */private static void writeObj() throws IOException, FileNotFoundException {// 将对象写入OutputStream// 标准存储文件的后缀名一般是objectObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("obj.object"));// 对象作为参数进行传递，但是该类需要实现Serializable接口（启用序列化功能）oos.writeObject(new Person("xiaoqiang",30));}}

被序列化的类：

import java.io.Serializable;public class Person implements Serializable/*标记接口*/{/** * Serializable用于给被序列化的类加入序列号，用于判断类和对象是否是同一版本 * 如果没有现实化声明serialVersionUID，则会综合多个方面计算该类的默认的serialVersionUID * 强烈建议显示声明serialVersionUID。 */private static final long serialVersionUID = 1L;// 被transient修饰的字段不会被序列化private transient String name;private int age;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 Person(String name, int age) {super();this.name = name;this.age = age;}public Person() {super();// TODO Auto-generated constructor stub}}

2，随机访问文件--RandomAccessFile

构造函数RandomAccessFile（File file，String mode）RandomAccessFile（String name，String mode）

不是IO体系中的子类，该类的实例支持对随机访问文件的读取和写入

特点：a，该类对象既可以读又可以写

    b，该对象内部维护了一个大型byte数组，并通过指针可以操作数组中的元素

    c，可以通过getFilePointer方法获取指针的位置，seek方法设置指针的位置

    d，该类将字节输入/输出流进行了封装

    e，该对象的目的或源只能是文件，不能是流

该类在写文件时，如果文件不存在，则创建；存在，则不创建。

RandomAccessFile 类中write方法写整数时，只写最低8位，为了能够正常写入整数（32位）可以使用readInt方法

同理，readInt方法一次读取4个字节（32位）。此外有两个重要的方法getFilePoiter和seek方法，前者可以获得指针

的当前位置，后者可以重置指针的位置。

RandomAccessFile 类在写数据时，默认从0角标开始，如果0角标开始有数据，则会被覆盖，使用seek方法，可以将

指针位置设置到已有内容的下一个角标，这样就相当于续写。

RandomAccessFile类可以和多线程技术结合，实现对同一文件的不同部分同步读取。

演示代码如下：

import java.io.FileNotFoundException;import java.io.IOException;import java.io.RandomAccessFile;// public class RandomAccessFileDemo {public static void main(String[] args) throws IOException {/* * 该类不是IO体系的子类 * 特点：1，该对象，既能读又能写 * 2，该对象内部维护了一个byte数组，并通过指针可以操作数组中的元素 * 3，可以通过getFilePointer获取指针位置，通过seek方法设置指针的位置 * 4，该对象就是将字节输入流和输出流进行了封装 * 5，该类的源和目的只能是文件，不可以是流 */writeFile();readFile();randomWrite();}/** * @throws FileNotFoundException * @throws IOException */private static void randomWrite() throws FileNotFoundException, IOException {RandomAccessFile raf = new RandomAccessFile("random.txt","rw");// 如果不设置指针位置，则默认从0角标开始，如果原来起始位置有数据，则会被覆盖raf.seek(3*8);raf.write("小明".getBytes());raf.writeInt(92);System.out.println("pointer positon:"+raf.getFilePointer());// 写完后，通过打印指针位置可以看出指针置于了32角标，用seek方法将其置于24角标，并打印新输入的内容raf.seek(3*8);byte[] buf = new byte[4];raf.read(buf);String name = new String(buf);// 读4个字节并转化为整数int age = raf.readInt();System.out.println("name:"+name);System.out.println("age:"+age);raf.close();}/** * @throws FileNotFoundException * @throws IOException */private static void readFile() throws FileNotFoundException, IOException {RandomAccessFile raf = new RandomAccessFile("random.txt","rw");byte[] buf = new byte[4];raf.seek(1*8);//随机读取，只需指定指针位置即可raf.read(buf);String name = new String(buf);// 读4个字节并转化为整数int age = raf.readInt();System.out.println("name:"+name);System.out.println("age:"+age);// 获得指针的当前位置System.out.println("pointer positon:"+raf.getFilePointer());raf.close();}/** * @throws FileNotFoundException * @throws IOException */private static void writeFile() throws FileNotFoundException, IOException {// 如果文件不存在，则创建；存在，则不创建RandomAccessFile raf = new RandomAccessFile("random.txt","rw");raf.write("张三".getBytes());// 写入整数用writeInt用writeInt方法，write方法只写了最低字节//raf.write(97);raf.writeInt(97);// 按四个字节写入文件raf.write("小强".getBytes());raf.writeInt(99);raf.close();}}

3，管道流 PipedInputStream和PipedOutputStream

管道流与传统的IO不同，该流不需要用数组中转，可以直接对接。两个流的连接有两种方法，一个是通过构造函数，另一种

是通过connect方法。管道输入流应该连接到管道输出流，管道输入流提供要写到管道输出流的所有数据字节。

该流通常与多线程结合应用。

演示代码：

import java.io.IOException;import java.io.PipedInputStream;import java.io.PipedOutputStream;public class PipedDemo {public static void main(String[] args) throws IOException {// TODO Auto-generated method stubPipedInputStream input = new PipedInputStream();PipedOutputStream output = new PipedOutputStream();/*两种方法使两个流建立联系 * 1,通过构造函数 * 2，通过connect方法x */input.connect(output);new Thread(new Input(input)).start();;new Thread(new Output(output)).start();}}class Input implements Runnable{private PipedInputStream in;public Input(PipedInputStream in) {super();this.in = in;}@Overridepublic void run() {// TODO Auto-generated method stubtry {byte[] buf = new byte[1024];int len = in.read(buf);String str = new String(buf,0,len);System.out.println("str = "+str);in.close();} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}class Output implements Runnable{private PipedOutputStream out;public Output(PipedOutputStream out) {super();this.out = out;}@Overridepublic void run() {// TODO Auto-generated method stubtry {out.write("hi,管道来了".getBytes());} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}

4，IO包中的其他类

DataInputStream和DataOutputStream：数据输出流允许应用程序以适当方式将基本 Java 数据类型写入输出流中。

然后，应用程序可以使用数据输入流将数据读入。

import java.io.DataInputStream;import java.io.DataOutputStream;import java.io.FileInputStream;import java.io.FileNotFoundException;import java.io.FileOutputStream;import java.io.IOException;public class DataStreamDemo {public static void main(String[] args) throws IOException {// TODO Auto-generated method stubwriteData();readData();}/** * @throws FileNotFoundException * @throws IOException */private static void readData() throws FileNotFoundException, IOException {DataInputStream dis = new DataInputStream(new FileInputStream("data.txt"));String str = dis.readUTF();// 该方法用来解析writeUTFSystem.out.println(str);}/** * @throws FileNotFoundException * @throws IOException */private static void writeData() throws FileNotFoundException, IOException {DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.txt"));dos.writeUTF("你好");dos.close();}}

操作数组的流：ByteArrayInputStream、ByteArrayOutputStream、CharArrayInputStream、CharArrayOutputStream、StringReader、StringWriter等

在内存中读写很快，不用缓冲区。此外，不需要关闭流。用这些流操作的数据不宜太大。

如果源是内存，则可以直接建立这些类的对象操作即可。

演示代码：

import java.io.ByteArrayInputStream;import java.io.ByteArrayOutputStream;public class ByteArrayStreamDemo {public static void main(String[] args) {// TODO Auto-generated method stubByteArrayInputStream bis = new ByteArrayInputStream("abcdefg".getBytes());ByteArrayOutputStream bos = new ByteArrayOutputStream();int ch=0;while((ch=bis.read())!=-1){bos.write(ch);}System.out.println(bos.toString());//不用关流//bos.close();//不建议写}}

5，编码表

由来：为了方便应用计算机，让它可以识别各个国家的文字。将这些文字用数字表示，并一一对应，形成一张表，就是编码表。

常见编码表：ASCII、ISO8859-1、GB2312、GBK、Unicode、UTF

getByte()方法使用“GBK"作为默认的编码表。在对文字编码解码过程中，要使用同一码表。如果使用错误的码表进行解码，则会

出错，可以应用这个错误的码表再编码，再通过正确的码表解码即可。当然并不是所有情况都满足，用UTF-8来解码中文会出错，

即使用UTF-8编码，再通过GBK解码也会错，因为UTF-8在解码过程中，使用同一个码来表示所有的中文。

”联通“这两个中文字符因其码表恰好符合UTF-8规则，因此记事本在解析过程中会出现乱码。

演示代码：

import java.io.UnsupportedEncodingException;public class EncodeDemo {public static void main(String[] args) throws UnsupportedEncodingException {// TODO Auto-generated method stub// 编码//show1();// 说明默认的编码表为GBK// 解码//show2();// 解码与编码的字符集要一致/* * 如果用a码表解析错了，再用a码表编码，之后再用其他码表解码 * 不是所有的码表都满足这一情况 * 即编码对了，解码错了，有可能有救 * 比如UTF-8解码中文，如果解码错了，再使用UTF-8编码也无效 * 因为UTF-8在解码过程中，用同一未知字符表示所有的中文 */show3();// 联通问题String str = "联通";byte[] buf = str.getBytes();for(byte b:buf){System.out.print(Integer.toBinaryString(b&255)+" ");// b&255  取最后8位}// 打印结果 11000001 10101010 11001101 10101000  正好满足UTF-8规范，因此用UTF-8解码，因此出错}/** * @throws UnsupportedEncodingException */private static void show3() throws UnsupportedEncodingException {// 解码结果了，再编码解码成功String str = new String("你好");byte[] buf = str.getBytes("GBK");// 使用GBK编码String s1 = new String(buf,"iso8859-1");// 使用iso8859-1解码System.out.println("s1 = "+s1);byte[] buf2 = s1.getBytes("iso8859-1");// 再重新用iso8859-1编码String s2 = new String(buf2,"GBK");// 再使用GBK解码，得到正确结果System.out.println(s2);// 解码解错了，再编码解码也无效String s3 = new String(buf,"UTF-8");System.out.println("s3 = "+s3);byte[] buf3 = s3.getBytes("UTF-8");System.out.println(new String(buf3,"GBK"));}/** * @throws UnsupportedEncodingException */private static void show2() throws UnsupportedEncodingException {System.out.println();String str = "你好";byte[]buf = str.getBytes("UTF-8");String s1 = new String(buf,"GBK");String s2 = new String(buf,"UTF-8");System.out.println("GBK = "+s1+"......"+"UTF-8 = "+s2);}/** * @throws UnsupportedEncodingException */private static void show1() throws UnsupportedEncodingException {String str = "你好";byte[]buf = str.getBytes();print(buf);System.out.println();buf =str.getBytes("GBK");print(buf);}private static void print(byte[] buf) {// TODO Auto-generated method stubfor(byte b:buf){System.out.print(b+" ");}}}

练习：
 在java中，字符串“abcd”与字符串“ab你好”的长度是一样的，都是4个字符
 但对应的字节数却不同，因为一个汉字占用两个字节
 定义一个方法，按最大字节数取字符串
 如：ab你好 取3个字节，那么子串就是ab与“你”字的半个，那么这半个就要舍去
 如果是4个字节就是“ab你”，5个也是“ab你”

字符与二进制之间是有对应关系的。这个转换过程叫编码，逆过程叫解码。
Java语言，字符在内存中采用的是Unicode双字节定长编码。
但是，你要是输出到文件中，就会存在一个编码转换的过程。
一般WinXP系统，简体中文版的默认编码是GB2312编码，而不是Unicode编码，
并且，你在使用FileWriter对象的时候，并没有指定具体的编码，那么默认编码就是操作系统的默认编码。
所以，文件中的字符，采用的是GB2312编码，汉字占2个字节，ASCII字符占1个字节。

import java.io.IOException;public class IOTestDemo {public static void main(String[] args) throws IOException {// TODO Auto-generated method stubString str = "ab你好cd谢谢";//int len = str.getBytes("gbk").length;//for(int x=0; x<len; x++){//System.out.println("截取"+(x+1)+"个字节数"+cutStringByByte(str, x+1));//}int len = str.getBytes("UTF-8").length;System.out.println(len);for(int x=0; x<len; x++){System.out.println("截取"+(x+1)+"个字节数"+cutStringByByte2(str, x+1));}}private static String cutStringByByte(String str,int len) throws IOException{byte[] buf = str.getBytes("GBK");int count = 0;for(int x=len-1; x>0; x--){if(buf[x]<0)count++;elsebreak;}if(count%2==0)return new String(buf,0,len,"gbk");elsereturn new String(buf,0,len-1,"gbk");}private static String cutStringByByte2(String str,int len) throws IOException{byte[] buf = str.getBytes("UTF-8");int count = 0;for(int x=len-1; x>0; x--){if(buf[x]<0)count++;elsebreak;}if(count%3==0)return new String(buf,0,len,"UTF-8");else if(count%3==1)return new String(buf,0,len-1,"UTF-8");elsereturn new String(buf,0,len-2,"UTF-8");}}

二、反射

Java反射机制是在运行状态中，对于任意一个类（class文件），都能够知道这个类的所有属性和方法。

对于 任意一个对象，都能够调用它的任意一个方法和属性。这种动态获取信息以及动态调用对象方法的

功能称为java语言的反射机制。

毕老师：动态获取类中信息，就是反射，可以理解为时对类的解剖。

Class类是用来描述字节码文件的，对外提供了获取字节码文件内容的方法，比如名称、字段、构造函数、

一般函数，反射就是依靠该类来完成对对象的动态调用的。

获得一个类的字节码文件对象有三种：以Person类为例

a，Person.class  b，new Person（）.getClass（假设有空参构造函数）c，Class.forName(”包名.Person")

下面代码依次为获得构造函数、字段、和一般函数

对于构造函数，由空参构造函数构造对象较为特殊，可由字节码对象.newInstance()实现

对于带参构造函数，应先得到构造函数的对象，再由构造函数对象创建对象

获得构造函数对象有4种方法：getConstructor、getConstructors、getDeclaredConstructor、getDeclaredConstructors

需要指定其参数列表。

代码如下：

import java.lang.reflect.Constructor;import java.lang.reflect.InvocationTargetException;/* * 异常说明： * ClassNotFoundException:如果找不到类名字符串对应的类，则会抛出此异常 * InstaniationException:若果类中没有某个构造函数，会引起此异常 * IllegalAccessException:如果构造函数被私有化，会引起此异常 */public class ReflectTestDemo {public static void main(String[] args) throws Exception {String className = "Reflect.Person";Class clazz = Class.forName(className);show1(clazz);// 获得空参构造函数并创建对象show2(clazz);// 获得带参构造函数并创建对象--1show3(clazz);// 获得带参构造函数并创建对象--2show4(clazz);// 获得本类中所有的构造函数，包括公共、保护。默认和私有show5(clazz);// 获得本类中所有的公共的构造函数}/** * @param clazz */private static void show5(Class clazz) {// 获得本类中所有公共的构造函数Constructor[] csts = clazz.getConstructors();for(Constructor cst:csts){System.out.println(cst);}}/** * @param clazz */private static void show4(Class clazz) {// 获得本类中所有的构造参数，包括公有、保护、默认和私有构造参数Constructor[] csts = clazz.getDeclaredConstructors();for(Constructor cst:csts){System.out.println(cst);}}/** * @param clazz * @throws NoSuchMethodException * @throws InstantiationException * @throws IllegalAccessException * @throws InvocationTargetException */private static void show3(Class clazz)throws NoSuchMethodException, InstantiationException, IllegalAccessException, InvocationTargetException {// 得到指定构造函数Constructor cs = clazz.getDeclaredConstructor(int.class);// 如果构造函数是私有的，可以通过以下方法进行访问，又称暴力访问cs.setAccessible(true);// 创建对象Object obj = cs.newInstance(33);}/** * @param clazz * @throws NoSuchMethodException * @throws InstantiationException * @throws IllegalAccessException * @throws InvocationTargetException */private static void show2(Class clazz)throws NoSuchMethodException, InstantiationException, IllegalAccessException, InvocationTargetException {// 建立带参构造函数的对象Constructor cs = clazz.getConstructor(String.class,int.class);// 创建对象Object obj2 = cs.newInstance("XiaoMing",23);}/** * @param clazz * @throws InstantiationException * @throws IllegalAccessException */private static void show1(Class clazz) throws InstantiationException, IllegalAccessException {// 建立空参构造函数的对象,直接带哦用newInstance方法Object obj1 = clazz.newInstance();}}

对于字段对象的获得也有4种方法，分别是：getField、getFields、getDeclaredField、getDeclaredFields

对于私有的字段，可有setAccessible（true）来实现暴力访问，此外在进行字段获得或修改时，应建立在对象

的基础之上，即在获得和修改前，先创建该类的对象

代码如下：

import java.lang.reflect.Field;public class ReflectTestDemo2 {public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, SecurityException, InstantiationException, IllegalAccessException {// TODO Auto-generated method stubString className = "Reflect.Person";Class clazz = Class.forName(className);show1(clazz);// 获得公有字段show2(clazz);// 获得指定字段show3(clazz);// 获得本类中所有的字段，包括公有。私有、默认、静态等show4(clazz);// 获得本类中公有的字段}/** * @param clazz */private static void show4(Class clazz) {Field[]fields = clazz.getFields();for(Field field:fields){System.out.println(field);}}/** * @param clazz */private static void show3(Class clazz) {// 获得所有的字段，包括公有、私有、默认、静态等Field[] fields = clazz.getDeclaredFields();for(Field field:fields){System.out.println(field);}}/** * @param clazz * @throws NoSuchFieldException * @throws InstantiationException * @throws IllegalAccessException */private static void show2(Class clazz) throws NoSuchFieldException, InstantiationException, IllegalAccessException {// 该方法可以获得指定的字段，包括私有Field field = clazz.getDeclaredField("name");// 字段是由对象来调用的，因此在对字段进行任何修改之前，应先明确该类对象Object obj = clazz.newInstance();// 因为字段是私有的，需要进行暴力访问，否则会引起IllegalAccessExceptionfield.setAccessible(true);// 获得字段的值System.out.println(field.get(obj));// 对字段的值修改并打印field.set(obj, "xiaoqiang");System.out.println(field.get(obj));}/** * @param clazz * @throws NoSuchFieldException * @throws InstantiationException * @throws IllegalAccessException */private static void show1(Class clazz) throws NoSuchFieldException, InstantiationException, IllegalAccessException {// 获取指定的字段,getField只能调用公有的字段// 如果字段不是公有的，会引起NoSuchFieldExceptionField field = clazz.getField("height");// 字段是由对象来调用的，因此在对字段进行任何修改之前，应先明确该类对象Object obj = clazz.newInstance();// 获得字段并打印System.out.println(field.get(obj));// 修改字段并打印field.set(obj, 1.85);System.out.println(field.get(obj));}}

对于一般函数对象的获得由4种方法，分别是：getMethod、getMethods、getDeclaredMethod、getDeclaredMethods

获取一般函数与获取构造函数略有不同，获取一般构造函数不仅要指定参数列表，还要指定函数名。

同字段一样，函数需要由该类对象调用，因此在调用方法之前，应先建立该类对象。

调用静态方法略有疑问！！！

代码如下：

import java.lang.reflect.Constructor;import java.lang.reflect.InvocationTargetException;import java.lang.reflect.Method;public class ReflectTestDemo3 {public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {// TODO Auto-generated method stubString className = "Reflect.Person";Class clazz = Class.forName(className);show1(clazz);// 获得指定的函数，可以是私有的，并使用对象调用 //show2(clazz);// 获得公有的空参和带参函数，并使用对象调用//show3(clazz);// 获得本类及父类中所有的公共的方法//show4(clazz);// 获得本类中所有的方法，包括公共、保护、私有、默认权限的方法}/** * @param clazz * @throws NoSuchMethodException * @throws InstantiationException * @throws IllegalAccessException * @throws InvocationTargetException */private static void show1(Class clazz)throws NoSuchMethodException, InstantiationException, IllegalAccessException, InvocationTargetException {// 可以获得指定的函数，包括私有Method method = clazz.getDeclaredMethod("showx", null);// 对私有函数进行暴力访问method.setAccessible(true);// 使用空参构造函数创建对象Object obj = clazz.newInstance();// 调用方法method.invoke(obj, null);// 获得静态方法，由字节码文件对象调用method = clazz.getDeclaredMethod("staticmethod", null);//method.invoke(Person, null);// 此方法不可以，为什么？ method.invoke(Person.class, null);method.invoke(obj, null);method.invoke(clazz, null);}/** * @param clazz * @throws NoSuchMethodException * @throws InstantiationException * @throws IllegalAccessException * @throws InvocationTargetException */private static void show2(Class clazz)throws NoSuchMethodException, InstantiationException, IllegalAccessException, InvocationTargetException {// 获得空参数方法// 与构造函数不同的是，获得方法时，要指定方法名及其参数列表Method method = clazz.getMethod("show", null);// 使用空参构造函数对象调用方法Object obj = clazz.newInstance();method.invoke(obj, null);// 使用带参构造函数创建对象并调用方法Constructor cs = clazz.getConstructor(String.class,int.class);obj = cs.newInstance("wangcai",23);method.invoke(obj, null);// 获得带参数方法method = clazz.getMethod("paraMethod", String.class,int.class);method.invoke(obj, "xiaoqiang",22);}/** * @param clazz */private static void show4(Class clazz) {Method[] methods = clazz.getDeclaredMethods();for(Method method:methods){System.out.println(method);}}/** * @param clazz * @return */private static Method[] show3(Class clazz) {Method[] methods = clazz.getMethods();for(Method method:methods){System.out.println(method);}return methods;}}

反射可以结合配置文件（用到Properties集合）可以实现对类的动态加载：

代码如下：

import java.io.File;import java.io.FileInputStream;import java.util.Properties;public class ReflectTest {public static void main(String[] args) throws Exception {// TODO Auto-generated method stubMainBoard mb = new MainBoard();mb.run();// 每次添加设备，都需要修改代码传递一个新创建的对象//mb.usePCI(new SoundCard());/* * 如何不修改代码就可以完成传递新对象的动作呢？ * 不用new完成，而是只获取其class文件，在内部实现创建对象的动作 */File confile = new File("PCI.properties");Properties prop = new Properties();FileInputStream fis = new FileInputStream(confile);prop.load(fis);for(int x=0; x<prop.size(); x++){String pciName = prop.getProperty("pci"+(x+1));Class clazz = Class.forName(pciName);PCI p = (PCI)clazz.newInstance();mb.usePCI(p);}}}class MainBoard{public void run(){System.out.println("MainBoard run...");}public void usePCI(PCI p){p.open();p.close();}}interface PCI{public abstract void open();//public abstract void working();public abstract void close();}interface Electricity{public abstract void useEle();}class SoundCard implements PCI{@Overridepublic void open() {// TODO Auto-generated method stubSystem.out.println("sound open...");}@Overridepublic void close() {// TODO Auto-generated method stubSystem.out.println("sound close...");}}class NetCard implements PCI{@Overridepublic void open() {// TODO Auto-generated method stubSystem.out.println("netcard open...");System.out.println("netcard working for 5 minutes...");}@Overridepublic void close() {// TODO Auto-generated method stubSystem.out.println("netcard.close..");}}

配置文件：

The End