------<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