作为一个前端，我很庆幸js是动态语言，这样就减少了类型检查，而java这种高级语言是如何做的呢?
1 什么是java反射机制？
当程序运行时，允许改变程序结构或变量类型，这种语言称为动态语言。我们认为java并不是动态语言，但是它却有一个非常突出的动态相关机制，俗称：反射。
话不多说看代码：
package Reflect;
/**
* 通过一个对象获得完整的包名和类名
* */
class Demo{
//other codes...
}
class hello{
public static void main(String[] args) {
Demo demo=new Demo();
System.out.println(demo.getClass().getName());
}
}
等等demo.getClass()是干嘛的。。。
在面向对象的世界里，万事万物皆是对象。而在java语言中，static修饰的东西不是对象，但是它属于类。普通的数据类型不是对象，例如：int a = 5;它不是面向对象，但是它有其包装类 Integer 或者分装类来弥补了它。除了以上两种不是面向对象，其余的包括类也有它的面向对象，类是java.lang.Class的实例化对象（注意Class是大写）。也就是说：Class A{}当我创建了A类，那么类A本身就是一个对象，谁的对象？java.lang.Class的实例对象。
这里的F的实例化对象就可以用f表达出来。同理F类也是一个实例化对象，Class类的实例化对象。我们可以理解为任何一个类都是Class类的实例化对象，这种实例化对象有三种表示方法：
public class Demo(){
F f=new F();
//第一种表达方式
Class c1=F.class;//这种表达方式同时也告诉了我们任何一个类都有一个隐含的静态成员变量class
//第二种表达方式
Class c2=f.getClass();//这种表达方式在已知了该类的对象的情况下通过getClass方法获取
try {
c3 = Class.forName("com.text.F");//类的全称
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
class F{}
到这里想必大家也知道反射到底是干嘛的，就是运行时获取该类本身的Class。
看一下如何通过c1创建F类的实例
Public class Demo1{
try {
Foo foo = (Foo)c1.newInstance();//foo就表示F类的实例化对象
foo.print();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}}
class F{
void print(){
}
}
注意这里c1.newInstance()出来的是Object类型，需要强转。
通过无参构造实例化对象
package Reflect;
class Person{
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;
}
@Override
public String toString(){
return "["+this.name+" "+this.age+"]";
}
private String name;
private int age;
}
class hello{
public static void main(String[] args) {
Class<?> demo=null;
try{
demo=Class.forName("Reflect.Person");
}catch (Exception e) {
e.printStackTrace();
}
Person per=null;
try {
per=(Person)demo.newInstance();
} catch (InstantiationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
per.setName("Rollen");
per.setAge(20);
System.out.println(per);
}
}
但是注意一下，当我们把Person中的默认的无参构造函数取消的时候，比如自己定义只定义一个有参数的构造函数之后，会出现错误：
public Person(String name, int age) {
this.age=age;
this.name=name;
}
上述代码会报错。。。那么问题来了，一个类总有有参构造函数把，碰到这种情况如何使用反射呢？
package Reflect;
import java.lang.reflect.Constructor;
class Person{
public Person() {
}
public Person(String name){
this.name=name;
}
public Person(int age){
this.age=age;
}
public Person(String name, int age) {
this.age=age;
this.name=name;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
@Override
public String toString(){
return "["+this.name+" "+this.age+"]";
}
private String name;
private int age;
}
class hello{
public static void main(String[] args) {
Class<?> demo=null;
try{
demo=Class.forName("Reflect.Person");
}catch (Exception e) {
e.printStackTrace();
}
Person per1=null;
Person per2=null;
Person per3=null;
Person per4=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(Exception e){
e.printStackTrace();
}
System.out.println(per1);
System.out.println(per2);
System.out.println(per3);
System.out.println(per4);
}
}
其实问题的关键是动态获取Person的构造函数，他是一个数组对象。
下面来几个例子给大家讲解下反射的实际应用：
1.获取类的全部属性
import java.lang.reflect.Modifier //这个类需要引入
class hello {
public static void main(String[] args) {
Class<?> demo = null;
try {
demo = Class.forName("Reflect.Person");
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("===============本类属性========================");
// 取得本类的全部属性
Field[] field = demo.getDeclaredFields();
for (int i = 0; i < field.length; i++) {
// 权限修饰符
int mo = field[i].getModifiers();
String priv = Modifier.toString(mo);
// 属性类型
Class<?> type = field[i].getType();
System.out.println(priv + " " + type.getName() + " "
+ field[i].getName() + ";");
}
}
同时再看java.lang.Class类中也有同样的一个方法：
int getModifiers()
返回此类或接口以整数编码的 Java语言修饰符。
2.获取类的全部方法
public class ClassUtil {
public static void printClassMethodMessage(Object obj){
//要获取类的信息》》首先我们要获取类的类类型
Class c = obj.getClass();
System.out.println("类的名称是:"+c.getName());
//如果我们要获得所有的方法，可以用getMethods()方法，这个方法获取的是所有的Public的函数，包括父类继承而来的。如果我们要获取所有该类自己声明的方法，就可以用getDeclaredMethods()方法，这个方法是不问访问权限的。
Method[] ms = c.getMethods();//c.getDeclaredMethods()
//接下来我们拿到这些方法之后干什么？我们就可以获取这些方法的信息，比如方法的名字。
//首先我们要循环遍历这些方法
for(int i = 0; i < ms.length;i++){
//然后可以得到方法的返回值类型的类类型
Class returnType = ms[i].getReturnType();
//得到方法的返回值类型的名字
System.out.print(returnType.getName()+" ");
//得到方法的名称
System.out.print(ms[i].getName()+"(");
//获取参数类型--->得到的是参数列表的类型的类类型
Class[] paramTypes = ms[i].getParameterTypes();
for (Class class1 : paramTypes) {
System.out.print(class1.getName()+",");
}
System.out.println(")");
}
}
}
obj.getClass().getMethods() 与 getDeclaredMethods()的区别，一个是获取所有包括继承的，一个是自身有的方法。
class Person{
public void eat(string str,integert ){
}
public string sing(string str){
}
}
printClassMethodMessage(new Person())
1 .java.lang.string eat java.lang.string java.lang.interger
2 .java.lang.string sing java.lang.string
3.如何动态调用方法
public Object invokeMethod(Object owner, String methodName, Object[] args) throws Exception {
Class ownerClass = owner.getClass();
Class[] argsClass = new Class[args.length];
for (int i = 0, j = args.length; i < j; i++) {
argsClass[i] = args[i].getClass();
}
Method method = ownerClass.getMethod(methodName,argsClass);
return method.invoke(owner, args);
}
我们上面定义了一个呼唤类实例方法的方法。
class Person{
public void say(string name,integert age ){
print 'i am' + name + 'age is' + age
}
}
invokeMethod(new Person(),'say',['sumail',18])
// i am sumail age is 18
注意传参列表为数组，获取方法是通过ownerClass.getMethod(methodName,argsClass)来得到。
最后来看一下一个用反射的工厂模式例子：
原始版本
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 fruit getInstance(String fruitName){
fruit f=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){
fruit f=Factory.getInstance("Orange");
f.eat();
}
}
反射版本
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 fruit getInstance(String ClassName){
fruit f=null;
try{
f=(fruit)Class.forName(ClassName).newInstance();
}catch (Exception e) {
e.printStackTrace();
}
return f;
}
}
class hello{
public static void main(String[] a){
fruit f=Factory.getInstance("Reflect.Apple");
if(f!=null){
f.eat();
}
}
}
好处就是我省略了一些判断语句，更加简洁。
好了，今天的讲解就到这里。。。
网友评论