JAVA 内部类 反射机制Reflection.docx
《JAVA 内部类 反射机制Reflection.docx》由会员分享，可在线阅读，更多相关《JAVA 内部类 反射机制Reflection.docx（26页珍藏版）》请在冰点文库上搜索。
JAVA内部类反射机制Reflection
内部类:
成员内部类、静态嵌套类、方法内部类、匿名内部类。
为什么需要内部类
典型的情况是，内部类继承自某个类或实现某个接口，内部类的代码操作创建其的外围类的对象。
所以你可以认为内部类提供了某种进入其外围类的窗口。
使用内部类最吸引人的原因是：
每个内部类都能独立地继承自一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对于内部类都没有影响。
如果没有内部类提供的可以继承多个具体的或抽象的类的能力，一些设计与编程问题就很难解决。
从这个角度看，内部类使得多重继承的解决方案变得完整。
接口解决了部分问题，而内部类有效地实现了“多重继承”。
匿名内部类的声明格式如下：
New接口名/类名（）{
...//内部类的定义
}[1]
在使用匿名内部类时，要记住以下几个原则：
·匿名内部类不能有构造方法。
·匿名内部类不能定义任何静态成员、静态方法。
·匿名内部类不能是public,protected,private,static。
·只能创建匿名内部类的一个实例。
·一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类。
·因匿名内部类为局部内部类，所以局部内部类的所有限制都对其生效。
//classOuter{
//privateStringstr="hello";//外部类的成员变量;
//
//classInner{
//publicvoidfun（）{
//System.out.println（""+str）;//内部类可以访问外部类的私有变量;
//show（）;
//}
//
//}
//publicvoidshow（）{
//System.out.println（"外部类的方法"）;
//Innerin=newInner（）;
//in.fun（）;
//}
//
//}
//
//publicclassDemo{
//
//publicstaticvoidmain（String[]args）{
////TODOAuto-generatedmethodstub
//Outerout=newOuter（）;
//out.show（）;
//}
//
//}
//classOuter{
//privateStringstr="hello";//外部类的成员变量;
//
//classInner{
//publicvoidfun（）{
//System.out.println（""+str）;//内部类可以访问外部类的私有变量;
//show（）;
//}
//
//}
//publicvoidshow（）{
//System.out.println（"外部类的方法"）;
////Innerin=newInner（）;
////in.fun（）;
//}
//
//}
//publicclassDemo1{
//publicstaticvoidmain（String[]args）{
//Outerout=newOuter（）;//实例化外部类
//Outer.Innerin=out.newInner（）;//实例化内部类;
////外部类.内部类内部类对象=外部类对象.new内部类（）;
//in.fun（）;
//
//}
//
//}
//classOuter{
//privatestaticStringstr="hello";//外部类的成员变量;
//
//staticclassInner{
//publicvoidfun（）{
//System.out.println（""+str）;//内部类可以访问外部类的私有变量;
//show（）;
//}
//publicstaticvoidfun2（）{};
//
//}
//publicstaticvoidshow（）{
//System.out.println（"外部类的方法"）;
//Innerin=newInner（）;
//in.fun（）;//非静态的需要实例化，
//Inner.fun2（）;//直接访问静态方法；
//}
//
//}
//publicclassDemo2{
//
//publicstaticvoidmain（String[]args）{
////TODOAuto-generatedmethodstub
//
//}
//
//}
classOuter{
privateStringstr="hello";//外部类的成员变量;
publicvoidshow（finalinttemp）{
System.out.println（"外部类的方法"）;
//Innerin=newInner（）;//出错，未声明，就使用；
classInner{//局部内部类;
publicvoidfun（）{
System.out.println（""+temp）;//内部类可以访问外部类的私有变量;
//show（20）;
}
}
Innerin=newInner（）;
in.fun（）;
}
}
publicclassDemo3{
publicstaticvoidmain（String[]args）{
//TODOAuto-generatedmethodstub
Outerout=newOuter（）;
out.show（454）;
}
}
//interfaceA{
//publicvoidshow（）;
//}
//classBimplementsA{
//publicvoidshow（）{
//System.out.println（"hello"）;
//}
//}
//classX{
//publicvoidfun（）{
//this.fun2（newB（））;//匿名对象
//}
//publicvoidfun2（Aa）{
//a.show（）;
//}
//}
//publicclassDemo4{
//publicstaticvoidmain（String[]args）{
////TODOAuto-generatedmethodstub
//newX（）.fun（）;
//}
//
//}
interfaceA{
publicvoidshow（）;
}
classBimplementsA{
publicvoidshow（）{
System.out.println（"hello"）;
}
}
classX{
publicvoidfun（）{//匿名内部类；只使用一次;
this.fun2（newA（）{
publicvoidshow（）{
System.out.println（"匿名内部类方法"）;
}
}）;//匿名对象
}
publicvoidfun2（Aa）{
a.show（）;
}
}
publicclassDemo5{
publicstaticvoidmain（String[]args）{
//TODOAuto-generatedmethodstub
newX（）.fun（）;
}
}
JAVA——反射机制（Reflection）
一.反射是什么？
反射它允许运行中的Java程序对自身进行检查，或者说“自审”，并能直接操作程序的内部属性。
二.分析类的构成？
1.获取Class对象：
Classc=Class.forName（"java.lang.String"）;
Classc=int.class;
Classc=Integer.TYPE;
*它们可获得基本类型的类信息。
其中后一种方法中访问的是基本类型的封装类（如Integer）中预先定义好的TYPE字段。
2.获取类的方法
packageoracle;
importjava.lang.reflect.*;
publicclassTest{
privateintf1（Objectp,intx）throwsNullPointerException{
if（p==null）
thrownewNullPointerException（）;
returnx;
}
publicstaticvoidmain（Stringargs[]）{
try{
Classcls=Class.forName（"oracle.Test"）;
Methodmethlist[]=cls.getDeclaredMethods（）;
for（inti=0;i Methodm=methlist[i];
System.out.println（"name="+m.getName（））;
System.out.println（"declclass="+m.getDeclaringClass（））;
Classpvec[]=m.getParameterTypes（）;
for（intj=0;j System.out.println（"param#"+j+""+pvec[j]）;
Classevec[]=m.getExceptionTypes（）;
for（intj=0;j System.out.println（"exc#"+j+""+evec[j]）;
System.out.println（"returntype="+m.getReturnType（））;
System.out.println（"-----"）;
}
}catch（Throwablee）{
System.err.println（e）;
}
}
}
输出的结果如下：
name=f1
declclass=classoracle.Test
param#0classjava.lang.Object
param#1int
exc#0classjava.lang.NullPointerException
returntype=int
-----
name=main
declclass=classoracle.Test
param#0class[Ljava.lang.String;
returntype=void
-----
3.获取构造器
packageoracle;
importjava.lang.reflect.*;
publicclassTest{
publicTest（）{}
protectedTest（inti,doubled）{
}
publicstaticvoidmain（Stringargs[]）{
try{
Classcls=Class.forName（"oracle.Test"）;
Constructorctorlist[]=cls.getDeclaredConstructors（）;
for（inti=0;i Constructorct=ctorlist[i];
System.out.println（"name="+ct.getName（））;
System.out.println（"declclass="+
ct.getDeclaringClass（））;
Classpvec[]=ct.getParameterTypes（）;
for（intj=0;j System.out.println（"param#"+j+""+pvec[j]）;
Classevec[]=ct.getExceptionTypes（）;
for（intj=0;j System.out.println（"exc#"+j+""+evec[j]）;
System.out.println（"-----"）;
}
}catch（Throwablee）{
System.err.println（e）;
}
}
}
这个程序运行的结果是：
name=oracle.Test
declclass=classoracle.Test
-----
name=oracle.Test
declclass=classoracle.Test
param#0int
param#1double
-----
4.获取类的属性字段（域字段）
packageoracle;
importjava.lang.reflect.*;
publicclassTest{
privatedoubled;
publicstaticfinalinti=37;
Strings="testing";
publicstaticvoidmain（Stringargs[]）{
try{
Classcls=Class.forName（"oracle.Test"）;
Fieldfieldlist[]=cls.getDeclaredFields（）;
for（inti=0;i Fieldfld=fieldlist[i];
System.out.println（"name="+fld.getName（））;
System.out.println（"declclass="+fld.getDeclaringClass（））;
System.out.println（"type="+fld.getType（））;
intmod=fld.getModifiers（）;
System.out.println（"modifiers="+Modifier.toString（mod））;
System.out.println（"-----"）;
}
}catch（Throwablee）{
System.err.println（e）;
}
}
}
这个程序的输出是：
name=d
declclass=classoracle.Test
type=double
modifiers=private
-----
name=i
declclass=classoracle.Test
type=int
modifiers=publicstaticfinal
-----
name=s
declclass=classoracle.Test
type=classjava.lang.String
modifiers=
-----
三.如何动态调用
（要动态调用就要创建实例）
Classcls=Class.forName（"oracle.Test"）;
Objectobj=cls.newInstance（）;
*使用反射机制的主流框架都是默认调用无参的public构造器，所以我们不能改类的构造器。
四.设计实现javaBean功能
importjava.lang.reflect.Field;
importjava.lang.reflect.Method;
importjava.util.HashMap;
importjava.util.Map;
publicclassJavaBean{
privatestaticObject myJavaBean（Mapmap,Classcls）throwsException{
//得到类中所有字段
Fieldfs[]=cls.getDeclaredFields（）;
//new一个实例
Objectobj=cls.newInstance（）;
for（inti=0;i //得到字段名
Objectv=map.get（fs[i].getName（））;
if（v!
=null）{
//只有一个参数
Classpartypes[]=newClass[1];
partypes[0]=fs[i].getType（）;
//拼setter方法
Methodmeth=cls.getMethod（"set"
+fs[i].getName（）.substring（0,1）.toUpperCase（）
+fs[i].getName（）.substring
（1）,partypes）;
Objectarglist[]=newObject[1];
arglist[0]=v;
meth.invoke（obj,arglist）;
}
}
returnobj;
}
publicstaticvoidmain（String[]args）throwsException{
Mapmap=newHashMap（）;
map.put（"userId","1234"）;
map.put（"name","4321"）;
map.put（"ddd","dddddddd"）;
Objectobj=myJavaBean（map,AModel.class）;
AModelam=（AModel）obj;
System.out.println（"am.userId="+am.getUserId（）+",name="+am.getName（））;
}
}
classAModel{
privateStringuserId,name;
publicStringgetUserId（）{
returnuserId;
}
publicvoidsetUserId（StringuserId）{
this.userId=userId;
}
publicStringgetName（）{
returnname;
}
publicvoidsetName（Stringname）{
this.name=name;
}
}
泛型
publicclassPoint{//坐标
privateObjectx;
privateObjecty;
publicObjectgetX（）{
returnx;
}
publicvoidsetX（Objectx）{
this.x=x;
}
publicObjectgetY（）{
returny;
}
publicvoidsetY（Objecty）{
this.y=y;
}
}
publicclassDemo{
publicstaticvoidmain（String[]args）{
//TODOAuto-generatedmethodstub
Pointp=newPoint（）;
p.setX（30）;
p.setY（60）;
Pointp1=newPoint（）;
p1.setX（"东径30度"）;
p1.setY（"北纬60度"）;
Pointp2=newPoint（）;
p2.setX（30.5）;
p2.setY（75.3）;
System.out.println（"X坐标:
="+p2.getX（））;
System.out.println（"y坐标:
="+p2.getY（））;
}
}
2.
publicclassPoint{//坐标T类型,任意类型
privateTx;
privateTy;
publicTgetX（）{
returnx;
}
publicvoidsetX（Tx）{
this.x=x;
}
publicTgetY（）{
returny;
}
publicvoidsetY（Ty）{
this.y=y;
}
}
publicclassDemo{
publicstaticvoidmain（String[]args）{
Pointp=n
升级会员 