java是一种可以撰写跨平台应用软件的面向对象的程序设计语言,是由Sun Microsystems公司于1995年5月推出的Java程序设计语言和Java平台(即JavaEE, JavaME, JavaSE)的总称。本站提供基于Java框架struts,spring,hibernate等的桌面应用、web交互及移动终端的开发技巧与资料

保持永久学习的心态,将成就一个优秀的你,来 继续搞起java知识。

本篇文章依旧采用小例子来说明,因为我始终觉的,案例驱动是最好的,要不然只看理论的话,看了也不懂,不过建议大家在看完文章之后,在回过头去看看理论,会有更好的理解。

下面开始正文。

【案例1】通过一个对象获得完整的包名和类名

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

package
Reflect;

/**
*通过一个对象获得完整的包名和类名

**/
class
Demo{

//othercodes...
}

class
hello{
public
static
void
main(String[]args){

Demodemo=
new
Demo();
System.out.println(demo.getClass().getName());

}
}

【运行结果】:Reflect.Demo

添加一句:所有类的对象其实都是Class的实例。【案例2】实例化Class类对象

12

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

package
Reflect;

class
Demo{
//othercodes...

}
class
hello{

public
static
void
main(String[]args){

Class<?>demo1=
null
;
Class<?>demo2=
null
;

Class<?>demo3=
null
;
try
{

//一般尽量采用这种形式
demo1=Class.forName(
"Reflect.Demo"
);

}
catch
(Exceptione){
e.printStackTrace();

}
demo2=
new
Demo().getClass();

demo3=Demo.
class
;

System.out.println(
"类名称"
&#43;demo1.getName());
System.out.println(
"类名称"
&#43;demo2.getName());

System.out.println(
"类名称"
&#43;demo3.getName());
}

}

【运行结果】:

类名称Reflect.Demo

类名称Reflect.Demo

类名称Reflect.Demo

【案例3】通过Class实例化其他类的对象

通过无参构造实例化对象

12

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

package
Reflect;

class
Person{
public
StringgetName(){

return
name;
}
public
void
setName(Stringname){

this
.name=name;
}
public
int
getAge(){

return
age;
}
public
void
setAge(
int
age){

this
.age=age;
}
@Override

public
StringtoString(){
return
"["
&#43;
this
.name&#43;
""
&#43;
this
.age&#43;
"]"
;

}
private
Stringname;

private
int
age;
}
class
hello{
public
static
void
main(String[]args){

Class<?>demo=
null
;
try
{
demo=Class.forName(
"Reflect.Person"
);

}
catch
(Exceptione){
e.printStackTrace();
}

Personper=
null
;
try
{
per=(Person)demo.newInstance();

}
catch
(InstantiationExceptione){

//TODOAuto-generatedcatchblock
e.printStackTrace();
}
catch
(IllegalAccessExceptione){

//TODOAuto-generatedcatchblock
e.printStackTrace();
}
per.setName(
"Rollen"
);

per.setAge(
20
);
System.out.println(per);

}
}

【运行结果】:

[Rollen20]

但是注意一下,当我们把Person中的默认的无参构造函数取消的时候,比如自己定义只定义一个有参数的构造函数之后,会出现错误:

比如我定义了一个构造函数:

12

3

4

public
Person(Stringname,
int
age){

this
.age=age;
this
.name=name;

}

然后继续运行上面的程序,会出现:

java.lang.InstantiationException:Reflect.Person

atjava.lang.Class.newInstance0(Class.java:340)

atjava.lang.Class.newInstance(Class.java:308)

atReflect.hello.main(hello.java:39)

Exceptioninthread"main"java.lang.NullPointerException

atReflect.hello.main(hello.java:47)

所以大家以后再编写使用Class实例化其他类的对象的时候,一定要自己定义无参的构造函数

【案例】通过Class调用其他类中的构造函数(也可以通过这种方式通过Class创建其他类的对象)

12

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

package
Reflect;

import
java.lang.reflect.Constructor;
class
Person{

public
Person(){

}
public
Person(Stringname){

this
.name=name;
}

public
Person(
int
age){
this
.age=age;

}
public
Person(Stringname,
int
age){

this
.age=age;
this
.name=name;
}
public
StringgetName(){
return
name;

}
public
int
getAge(){

return
age;
}
@Override
public
StringtoString(){

return
"["
&#43;
this
.name&#43;
""
&#43;
this
.age&#43;
"]"
;

}
private
Stringname;
private
int
age;

}
class
hello{

public
static
void
main(String[]args){

Class<?>demo=
null
;
try
{
demo=Class.forName(
"Reflect.Person"
);
}
catch
(Exceptione){

e.printStackTrace();
}

Personper1=
null
;
Personper2=
null
;

Personper3=
null
;
Personper4=
null
;

//取得全部的构造函数
Constructor<?>cons[]=demo.getConstructors();

try
{
per1=(Person)cons[

0

].newInstance();

per2=(Person)cons[
1
].newInstance(
"Rollen"
);
per3=(Person)cons[
2
].newInstance(
20
);

per4=(Person)cons[
3
].newInstance(
"Rollen"
,
20
);
}
catch
(Exceptione){

e.printStackTrace();
}
System.out.println(per1);

System.out.println(per2);
System.out.println(per3);

System.out.println(per4);
}
}

【运行结果】:

[null0]

[Rollen0]

[null20]

[Rollen20]

【案例】

返回一个类实现的接口:

12

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

package
Reflect;

interface
China{
public
static
final
Stringname=
"Rollen"
;

public
static
int
age=
20
;
public
void
sayChina();

public
void
sayHello(Stringname,
int
age);

}
class
Person
implements
China{

public
Person(){

}
public
Person(Stringsex){

this
.sex=sex;
}
public
StringgetSex(){

return
sex;
}
public
void
setSex(Stringsex){

this
.sex=sex;
}
@Override
public
void
sayChina(){

System.out.println(
"hello,china"
);
}
@Override

public
void
sayHello(Stringname,
int
age){

System.out.println(name&#43;
""
&#43;age);
}
private
Stringsex;

}
class
hello{
public
static
void
main(String[]args){

Class<?>demo=
null
;
try
{
demo=Class.forName(
"Reflect.Person"
);
}
catch
(Exceptione){

e.printStackTrace();
}

//保存所有的接口
Class<?>intes[]=demo.getInterfaces();

for
(
int
i=

0

;i<intes.length;i&#43;&#43;){

System.out.println(
"实现的接口"
&#43;intes[i].getName());
}
}

}

【运行结果】:

实现的接口Reflect.China

(注意,以下几个例子,都会用到这个例子的Person类,所以为节省篇幅,此处不再粘贴Person的代码部分,只粘贴主类hello的代码)

【案例】:取得其他类中的父类

12

3

4

5

6

7

8

9

10

11

12

13

class
hello{

public
static
void
main(String[]args){

Class<?>demo=
null
;
try
{
demo=Class.forName(
"Reflect.Person"
);

}
catch
(Exceptione){
e.printStackTrace();
}
//取得父类

Class<?>temp=demo.getSuperclass();
System.out.println(
"继承的父类为:"
&#43;temp.getName());

}
}

【运行结果】

继承的父类为:java.lang.Object

【案例】:获得其他类中的全部构造函数

这个例子需要在程序开头添加importjava.lang.reflect.*;然后将主类编写为:

12

3

4

5

6

7

8

9

10

11

12

13

14

class
hello{

public
static
void
main(String[]args){

Class<?>demo=
null
;
try
{
demo=Class.forName(
"Reflect.Person"
);
}
catch
(Exceptione){

e.printStackTrace();
}
Constructor<?>cons[]=demo.getConstructors();
for
(
int
i=

0

;i<cons.length;i&#43;&#43;){

System.out.println(
"构造方法:"
&#43;cons[i]);
}
}

}

【运行结果】:

构造方法:publicReflect.Person()

构造方法:publicReflect.Person(java.lang.String)

但是细心的读者会发现,上面的构造函数没有public或者private这一类的修饰符

下面这个例子我们就来获取修饰符

12

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

class
hello{

public
static
void
main(String[]args){

Class<?>demo=
null
;
try
{
demo=Class.forName(
"Reflect.Person"
);
}
catch
(Exceptione){

e.printStackTrace();
}
Constructor<?>cons[]=demo.getConstructors();

for
(
int
i=

0

;i<cons.length;i&#43;&#43;){

Class<?>p[]=cons[i].getParameterTypes();
System.out.print(
"构造方法:"
);

int
mo=cons[i].getModifiers();
System.out.print(Modifier.toString(mo)&#43;
""
);

System.out.print(cons[i].getName());
System.out.print(
"("
);

for
(
int
j=

0

;j<p.length;&#43;&#43;j){
System.out.print(p[j].getName()&#43;
"arg"
&#43;i);

if
(j<p.length-
1
){
System.out.print(
","
);

}
}

System.out.println(
"){}"
);
}
}

}

【运行结果】:

构造方法:publicReflect.Person(){}

构造方法:publicReflect.Person(java.lang.Stringarg1){}

有时候一个方法可能还有异常,呵呵。下面看看:

12

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

class
hello{

public
static
void
main(String[]args){

Class<?>demo=
null
;
try
{
demo=Class.forName(
"Reflect.Person"
);
}
catch
(Exceptione){

e.printStackTrace();
}
Methodmethod[]=demo.getMethods();

for
(
int
i=

0

;i<method.length;&#43;&#43;i){
Class<?>returnType=method[i].getReturnType();

Class<?>para[]=method[i].getParameterTypes();
int
temp=method[i].getModifiers();

System.out.print(Modifier.toString(temp)&#43;
""
);
System.out.print(returnType.getName()&#43;
""
);

System.out.print(method[i].getName()&#43;
""
);
System.out.print(
"("
);
for
(
int
j=

0

;j<para.length;&#43;&#43;j){

System.out.print(para[j].getName()&#43;
""
&#43;
"arg"
&#43;j);

if
(j<para.length-
1
){
System.out.print(
","
);
}
}

Class<?>exce[]=method[i].getExceptionTypes();
if
(exce.length>

0

){

System.out.print(
")throws"
);
for
(
int
k=

0

;k<exce.length;&#43;&#43;k){

System.out.print(exce[k].getName()&#43;
""
);
if
(k<exce.length-
1
){

System.out.print(
","
);
}
}

}
else
{
System.out.print(
")"
);

}
System.out.println();

}
}

}

【运行结果】:

publicjava.lang.StringgetSex()

publicvoidsetSex(java.lang.Stringarg0)

publicvoidsayChina()

publicvoidsayHello(java.lang.Stringarg0,intarg1)

publicfinalnativevoidwait(longarg0)throwsjava.lang.InterruptedException

publicfinalvoidwait()throwsjava.lang.InterruptedException

publicfinalvoidwait(longarg0,intarg1)throwsjava.lang.InterruptedException

publicbooleanequals(java.lang.Objectarg0)

publicjava.lang.StringtoString()

publicnativeinthashCode()

publicfinalnativejava.lang.ClassgetClass()

publicfinalnativevoidnotify()

publicfinalnativevoidnotifyAll()

【案例】接下来让我们取得其他类的全部属性吧,最后我讲这些整理在一起,也就是通过class取得一个类的全部框架

12

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

class
hello{

public
static
void
main(String[]args){

Class<?>demo=
null
;
try
{
demo=Class.forName(
"Reflect.Person"
);
}
catch
(Exceptione){
e.printStackTrace();

}
System.out.println(
"===============本类属性========================"
);

//取得本类的全部属性
Field[]field=demo.getDeclaredFields();

for
(
int
i=

0

;i<field.length;i&#43;&#43;){

//权限修饰符
int
mo=field[i].getModifiers();

Stringpriv=Modifier.toString(mo);
//属性类型

Class<?>type=field[i].getType();
System.out.println(priv&#43;
""
&#43;type.getName()&#43;
""

&#43;field[i].getName()&#43;
";"
);
}
System.out.println(
"===============实现的接口或者父类的属性========================"
);

//取得实现的接口或者父类的属性
Field[]filed1=demo.getFields();

for
(
int
j=

0

;j<filed1.length;j&#43;&#43;){

//权限修饰符
int
mo=filed1[j].getModifiers();

Stringpriv=Modifier.toString(mo);
//属性类型
Class<?>type=filed1[j].getType();

System.out.println(priv&#43;
""
&#43;type.getName()&#43;
""

&#43;filed1[j].getName()&#43;
";"
);
}
}

}

【运行结果】:

===============本类属性========================

privatejava.lang.Stringsex;

===============实现的接口或者父类的属性========================

publicstaticfinaljava.lang.Stringname;

publicstaticfinalintage;

【案例】其实还可以通过反射调用其他类中的方法:

12

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

class
hello{

public
static
void
main(String[]args){

Class<?>demo=
null
;
try
{
demo=Class.forName(
"Reflect.Person"
);
}
catch
(Exceptione){
e.printStackTrace();

}
try
{

//调用Person类中的sayChina方法
Methodmethod=demo.getMethod(
"sayChina"
);

method.invoke(demo.newInstance());
//调用Person的sayHello方法

method=demo.getMethod(
"sayHello"
,String.
class
,
int
.
class
);
method.invoke(demo.newInstance(),
"Rollen"
,
20
);

}
catch
(Exceptione){

e.printStackTrace();
}

}
}

  【运行结果】:

hello,china

Rollen20

【案例】调用其他类的set和get方法

12

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

class
hello{

public
static
void
main(String[]args){

Class<?>demo=
null
;
Objectobj=
null
;

try
{
demo=Class.forName(
"Reflect.Person"
);
}
catch
(Exceptione){
e.printStackTrace();

}
try
{

obj=demo.newInstance();
}
catch
(Exceptione){
e.printStackTrace();

}
setter(obj,
"Sex"
,
"男"
,String.
class
);

getter(obj,
"Sex"
);
}
/**

*@paramobj
*操作的对象

*@paramatt
*操作的属性

**/
public
static
void
getter(Objectobj,Stringatt){

try
{
Methodmethod=obj.getClass().getMethod(
"get"
&#43;att);

System.out.println(method.invoke(obj));
}
catch
(Exceptione){
e.printStackTrace();
}
}

/**
*@paramobj

*操作的对象
*@paramatt

*操作的属性
*@paramvalue

*设置的&#20540;
*@paramtype

*参数的属性
**/

public
static
void
setter(Objectobj,Stringatt,Objectvalue,

Class<?>type){
try
{
Methodmethod=obj.getClass().getMethod(
"set"
&#43;att,type);

method.invoke(obj,value);
}
catch
(Exceptione){
e.printStackTrace();
}
}

}
//endclass

【运行结果】:

【案例】通过反射操作属性

12

3

4

5

6

7

8

9

10

11

12

13

14

class
hello{

public
static
void
main(String[]args)
throws
Exception{

Class<?>demo=
null
;
Objectobj=
null
;
demo=Class.forName(
"Reflect.Person"
);
obj=demo.newInstance();

Fieldfield=demo.getDeclaredField(
"sex"
);
field.setAccessible(
true
);

field.set(obj,
"男"
);
System.out.println(field.get(obj));

}
}
//endclass

【案例】通过反射取得并修改数组的信息:

12

3

4

5

6

7

8

9

10

11

12

import
java.lang.reflect.*;

class
hello{
public
static
void
main(String[]args){

int
[]temp={
1
,
2
,
3
,
4
,
5
};
Class<?>demo=temp.getClass().getComponentType();

System.out.println(
"数组类型:"
&#43;demo.getName());
System.out.println(
"数组长度"
&#43;Array.getLength(temp));

System.out.println(
"数组的第一个元素:"
&#43;Array.get(temp,

0

));
Array.set(temp,

0

,
100
);

System.out.println(
"修改之后数组第一个元素为:"
&#43;Array.get(temp,

0

));
}
}

【运行结果】:

数组类型:int

数组长度5

数组的第一个元素:1

修改之后数组第一个元素为:100

【案例】通过反射修改数组大小

12

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

class
hello{

public
static
void
main(String[]args){

int
[]temp={
1
,
2
,
3
,
4
,
5
,
6
,
7
,
8
,
9
};
int
[]newTemp=(
int
[])arrayInc(temp,
15
);

print(newTemp);
System.out.println(
"====================="
);

String[]atr={
"a"
,
"b"
,
"c"
};
String[]str1=(String[])arrayInc(atr,
8
);

print(str1);
}
/**

*修改数组大小
**/
public
static
ObjectarrayInc(Objectobj,
int
len){

Class<?>arr=obj.getClass().getComponentType();
ObjectnewArr=Array.newInstance(arr,len);

int
co=Array.getLength(obj);
System.arraycopy(obj,

0

,newArr,

0

,co);

return
newArr;
}
/**

*打印
**/
public
static
void
print(Objectobj){

Class<?>c=obj.getClass();
if
(!c.isArray()){

return
;
}
System.out.println(
"数组长度为:"
&#43;Array.getLength(obj));

for
(
int
i=

0

;i<Array.getLength(obj);i&#43;&#43;){

System.out.print(Array.get(obj,i)&#43;
""
);
}
}

}

【运行结果】:

数组长度为:15

123456789000000=====================

数组长度为:8

abcnullnullnullnullnull

动态代理

【案例】首先来看看如何获得类加载器:

12

3

4

5

6

7

8

9

class
test{

}
class
hello{
public
static
void
main(String[]args){

testt=
new
test();
System.out.println(
"类加载器"
&#43;t.getClass().getClassLoader().getClass().getName());

}
}

【程序输出】:

类加载器sun.misc.Launcher$AppClassLoader

其实在java中有三种类类加载器。1)BootstrapClassLoader此加载器采用c++编写,一般开发中很少见。

2)ExtensionClassLoader用来进行扩展类的加载,一般对应的是jre\lib\ext目录中的类3)AppClassLoader加载classpath指定的类,是最常用的加载器。同时也是java中默认的加载器。

如果想要完成动态代理,首先需要定义一个InvocationHandler接口的子类,已完成代理的具体操作。

12

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

package
Reflect;

import
java.lang.reflect.*;
//定义项目接口

interface
Subject{
public
Stringsay(Stringname,
int
age);

}
//定义真实项目

class
RealSubject
implements
Subject{

@Override
public
Stringsay(Stringname,
int
age){

return
name&#43;
""
&#43;age;

}
}

class
MyInvocationHandler
implements
InvocationHandler{

private
Objectobj=
null
;
public
Objectbind(Objectobj){

this
.obj=obj;
return
Proxy.newProxyInstance(obj.getClass().getClassLoader(),obj

.getClass().getInterfaces(),
this
);
}
@Override
public
Objectinvoke(Objectproxy,Methodmethod,Object[]args)

throws
Throwable{
Objecttemp=method.invoke(
this
.obj,args);

return
temp;
}
}

class
hello{
public
static
void
main(String[]args){

MyInvocationHandlerdemo=
new
MyInvocationHandler();
Subjectsub=(Subject)demo.bind(
new
RealSubject());

Stringinfo=sub.say(
"Rollen"
,
20
);
System.out.println(info);

}
}

【运行结果】:

Rollen20

类的生命周期在一个类编译完成之后,下一步就需要开始使用类,如果要使用一个类,肯定离不开JVM。在程序执行中JVM通过装载,链接,初始化这3个步骤完成。

类的装载是通过类加载器完成的,加载器将.class文件的二进制文件装入JVM的方法区,并且在堆区创建描述这个类的java.lang.Class对象。用来封装数据。但是同一个类只会被类装载器装载以前链接就是把二进制数据组装为可以运行的状态。

链接分为校验,准备,解析这3个阶段校验一般用来确认此二进制文件是否适合当前的JVM(版本),

准备就是为静态成员分配内存空间,。并设置默认值解析指的是转换常量池中的代码作为直接引用的过程,直到所有的符号引用都可以被运行程序使用(建立完整的对应关系)

完成之后,类型也就完成了初始化,初始化之后类的对象就可以正常使用了,直到一个对象不再使用之后,将被垃圾回收。释放空间。当没有任何引用指向Class对象时就会被卸载,结束类的生命周期

将反射用于工厂模式

先来看看,如果不用反射的时候,的工厂模式吧:

/content/3573466.html

12

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

/**

*@authorRollen-Holt设计模式之工厂模式
*/

interface
fruit{
public
abstract
void
eat();

}
class
Apple
implements
fruit{

public
void
eat(){
System.out.println(
"Apple"
);

}
}

class
Orange
implements
fruit{
public
void
eat(){

System.out.println(
"Orange"
);
}
}

//构造工厂类
//也就是说以后如果我们在添加其他的实例的时候只需要修改工厂类就行了

class
Factory{
public
static
fruitgetInstance(StringfruitName){

fruitf=
null
;
if
(
"Apple"
.equals(fruitName)){

f=
new
Apple();
}
if
(
"Orange"
.equals(fruitName)){

f=
new
Orange();
}
return
f;

}
}

class
hello{
public
static
void
main(String[]a){

fruitf=Factory.getInstance(
"Orange"
);
f.eat();

}
}

这样,当我们在添加一个子类的时候,就需要修改工厂类了。如果我们添加太多的子类的时候,改的就会很多。

现在我们看看利用反射机制:

12

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

package
Reflect;

interface
fruit{
public
abstract
void
eat();
}
class
Apple
implements
fruit{

public
void
eat(){
System.out.println(
"Apple"
);
}
}

class
Orange
implements
fruit{
public
void
eat(){
System.out.println(
"Orange"
);

}
}

class
Factory{
public
static
fruitgetInstance(StringClassName){

fruitf=
null
;
try
{
f=(fruit)Class.forName(ClassName).newInstance();

}
catch
(Exceptione){
e.printStackTrace();
}

return
f;
}
}

class
hello{
public
static
void
main(String[]a){

fruitf=Factory.getInstance(
"Reflect.Apple"
);
if
(f!=
null
){

f.eat();
}
}

}

现在就算我们添加任意多个子类的时候,工厂类就不需要修改。

上面的爱吗虽然可以通过反射取得接口的实例,但是需要传入完整的包和类名。而且用户也无法知道一个接口有多少个可以使用的子类,所以我们通过属性文件的形式配置所需要的子类。

下面我们来看看:结合属性文件的工厂模式

首先创建一个fruit.properties的资源文件,

内容为:

12
apple=Reflect.Apple

orange=Reflect.Orange

 然后编写主类代码:

12

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

package
Reflect;

import
java.io.*;
import
java.util.*;

interface
fruit{
public
abstract
void
eat();
}
class
Apple
implements
fruit{

public
void
eat(){
System.out.println(
"Apple"
);
}
}

class
Orange
implements
fruit{
public
void
eat(){
System.out.println(
"Orange"
);
}
}

//操作属性文件类
class
init{

public
static
PropertiesgetPro()
throws
FileNotFoundException,IOException{

Propertiespro=
new
Properties();
Filef=
new
File(
"fruit.properties"
);

if
(f.exists()){
pro.load(
new
FileInputStream(f));

}
else
{
pro.setProperty(
"apple"
,
"Reflect.Apple"
);

pro.setProperty(
"orange"
,
"Reflect.Orange"
);
pro.store(
new
FileOutputStream(f),
"FRUITCLASS"
);

}
return
pro;

}
}
class
Factory{

public
static
fruitgetInstance(StringClassName){

fruitf=
null
;
try
{
f=(fruit)Class.forName(ClassName).newInstance();

}
catch
(Exceptione){

e.printStackTrace();
}

return
f;
}
}
class
hello{

public
static
void
main(String[]a)
throws
FileNotFoundException,IOException{

Propertiespro=init.getPro();
fruitf=Factory.getInstance(pro.getProperty(
"apple"
));

if
(f!=
null
){
f.eat();

}
}

}

【运行结果】:Apple

==============================================================================

我喜欢程序员,他们单纯、固执、容易体会到成就感;面对压力,能够挑灯夜战不眠不休;面对困难,能够迎难而上挑战自我。他们也会感到困惑与傍徨,但每个程序员的心中都有一个比尔盖茨或是乔布斯的梦想“用智慧开创属于自己的事业”。我想说的是,其实我是一个程序员

==============================================================================

本文转自:http://www.cnblogs.com/rollenholt/archive/2011/09/02/2163758.html

java反射动态代理工厂模式

因为水平有限,难免有疏忽或者不准确的地方,希望大家能够直接指出来,我会及时改正。一切为了知识的分享。

后续会有更多的精彩的内容分享给大家。