黑马程序员----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.class
		Object 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
		// 标准存储文件的后缀名一般是object
		ObjectOutputStream 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 stub
		PipedInputStream 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;
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		try {
			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 block
			e.printStackTrace();
		}
	}
	
}

class Output implements Runnable{
	private PipedOutputStream out;

	public Output(PipedOutputStream out) {
		super();
		this.out = out;
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		try {
			out.write("hi,管道来了".getBytes());
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.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 stub
		writeData();
		readData();
	}

	/**
	 * @throws FileNotFoundException
	 * @throws IOException
	 */
	private static void readData() throws FileNotFoundException, IOException {
		DataInputStream dis = new DataInputStream(new FileInputStream("data.txt"));
		String str = dis.readUTF();	// 该方法用来解析writeUTF
		System.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 stub
		ByteArrayInputStream 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 stub
		for(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 stub
		String 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++;
			else
				break;
		}
		if(count%2==0)
			return new String(buf,0,len,"gbk");
		else
			return 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++;
			else
				break;
		}
		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");
		else
			return 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);	// 获得带参构造函数并创建对象--1
		show3(clazz);	// 获得带参构造函数并创建对象--2
		show4(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 stub
		String 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();
		// 因为字段是私有的，需要进行暴力访问，否则会引起IllegalAccessException
		field.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只能调用公有的字段
		// 如果字段不是公有的，会引起NoSuchFieldException
		Field 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 stub
		String 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 stub
		MainBoard 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{

	@Override
	public void open() {
		// TODO Auto-generated method stub
		System.out.println("sound open...");
	}

	@Override
	public void close() {
		// TODO Auto-generated method stub
		System.out.println("sound close...");
	}
	
}
class NetCard implements PCI{

	@Override
	public void open() {
		// TODO Auto-generated method stub
		System.out.println("netcard open...");
		System.out.println("netcard working for 5 minutes...");
	}

	@Override
	public void close() {
		// TODO Auto-generated method stub
		System.out.println("netcard.close..");
	}
	
}

配置文件：

The End