java反射机制

Java反射机制

1. 什么是反射
它是java语言的一种内置的机制，通过这个机制可以动态的 创建对象、读写属性、调用方法

简单的来说，反射机制指的是程序在运行时能够获取自身的信息，在Java中，只要给定类的名字，那么就可以通过反射的机制来获得类的所有信息。

2.哪里用到反射机制

 有些时候，我们用过一些知识，但是并不知道它的专业术语是什么，在刚刚学jdbc时用过一行代码， 
 Class.forName("com.mysql.jdbc.Driver.class").newInstance();但是那时候只知道那行代码是生成驱动对象实例，并不知道它的具体含义。听了反射机制这节课后，才知道，原来这就是反射，现在很多开 框架都用到反射机制，hibernate、struts都是用反射机制实现的。 

3.Java反射的优点和缺点

为什么要用反射机制？直接创建对象不就可以了吗，这就涉及到了动态与静态的概念， 
静态编译：在编译时确定类型，绑定对象,即通过。 

动态编译：运行时确定类型，绑定对象。动态编译最大限度发挥了java的灵活性，体现了多态的应用，有以降低类之间的藕合性。 

一句话，反射机制的优点就是可以实现动态创建对象和编译，体现出很大的灵活性，特别是在J2EE的开发中，它的灵活性就表现的十分明显。比如，一个大型的软件，不可能一次就把把它设计的很完美，当这个程序编 译后，发布了，当发现需要更新某些功能时，我们不可能要用户把以前的卸载，再重新安装新的版本，假如这样的话，这个软件肯定是没有多少人用的。采用静态的话，需要把整个程序重新编译一次才可以实现功能 的更新，而采用反射机制的话，它就可以不用卸载，只需要在运行时才动态的创建和编译，就可以实现该功 能。 

它的缺点是对性能有影响。使用反射基本上是一种解释操作，我们可以告诉JVM，我们希望做什么并且它 满足我们的要求。这类操作总是慢于只直接执行相同的操作。 

一、首先创建一个学生类

public class Student {
// static{
// System.out.println("work...");
// }
private String sid;
private String sname;
public Integer age;
public static final int TYPE=10;

public Student() {
super();
System.out.println("调用无参构造方法创建了一个学生对象");
}
public Student(String sid) {
super();
this.sid = sid;
System.out.println("调用带一个参数的构造方法创建了一个学生对象");
}
public Student(String sid, String sname) {
super();
this.sid = sid;
this.sname = sname;
System.out.println("调用带二个参数的构造方法创建了一个学生对象");
}
@SuppressWarnings("unused")
private Student(Integer age) {
System.out.println("调用Student类私有的构造方法创建一个学生对象");
this.age = age;
}
public String getSid() {
return sid;
}
public void setSid(String sid) {
this.sid = sid;
}
public String getSname() {
return sname;
}
public void setSname(String sname) {
this.sname = sname;
}
public void hello() {
System.out.println("你好！我是" + this.sname);
}
public void hello(String name) {
System.out.println(name + "你好！我是" + this.sname);
}
@Override
public String toString() {
return "Student [age=" + age + ", sid=" + sid + ", sname=" + sname
+ "]";
}
@SuppressWarnings("unused")
private Integer add(Integer a, Integer b) {
return new Integer(a.intValue() + b.intValue());
}
}

4.如何获得类对象

   4.1：一切反射相关的代码，都是从获得类对象开始

   4.2：如何获得类对象： Class.forName(完整类名)

   4.3：类对象的作用：模子

   4.4：同一类的类对象只加载一次

5. 创建对象
  5.1 公共无参构造方法(回顾Serlvet,Filter配置完整类名)
  5.2 公共有参构造方法
  5.3 私有无参构造方法
  5.4 遍历所有的构造方法
/**
 * 创建对象
 * @author king
 *
 */
public class Demo2 {
public static void main(String[] args) throws Exception {
//Class c1=Class.forName("test.Employee");
Class c1=Class.forName("test.Student");

//传统的方式创建对象
//Student s=new Student();

//反射方式动态创建对象
//公共的、无参数的 构造方法
Object obj=c1.newInstance();
System.out.println(obj);

//公共的、有参数的 构造方法（getConstructor是指可见的）
Constructor constructor=c1.getConstructor(String.class);
Student s1=(Student)constructor.newInstance("安生");
System.out.println(s1);

//公共的、两个参数的 构造方法
Constructor constructor2=c1.getConstructor(new Class[]{String.class,String.class});
Student s2=(Student)constructor2.newInstance("s001","安生");
System.out.println(s2);

//私有的、带一个参数的 构造方法（getDeclaredConstructor是指只要是定义了的）
Constructor constructor3=c1.getDeclaredConstructor(Integer.class);
constructor3.setAccessible(true);//关闭访问权限
Student s3=(Student)constructor3.newInstance(19);
System.out.println(s3);

System.out.println("ok");

//遍历所有的方法(getDeclared得到所有定义了的)
for (Constructor cs : c1.getDeclaredConstructors()) {
System.out.println(cs);
}
}
}

6. 属性的读写
  6.1 反射机制读写公共属性
  6.2 反射机制读写私有属性
  6.3 遍历所有属性
import java.lang.reflect.Field;


/**
 * 读写属性
 * @author king
 *
 */
public class Demo3 {
public static void main(String[] args) throws Exception {
Student s=new Student();
// s.age=10;//写
// System.err.println(s.age);//读

//公共属性
Class c=Class.forName("test.Student");
Field ageField=c.getField("age");
ageField.set(s, 20);
System.out.println(ageField.get(s));

//私有属性
Field sidField=c.getDeclaredField("sid");//只要想调私有的方法或者属性就要调用getDeclared的方法
sidField.setAccessible(true);
sidField.set(s, "s001");
System.out.println(ageField.get(s));



}
}


7.方法的调用
  7.1 调用公共无参方法
  7.2 调用公共有参数方法
  7.3 调用私有有参方法
  7.4 遍历所有方法

import java.lang.reflect.Method;

/**
 * 调用方法
 * @author king
 *
 */
public class Demo4 {
public static void main(String[] args) throws Exception {
Student s=new Student();
s.setSname("小明");
s.hello();

Class c=Class.forName("test.Student");
Method helloMethod=c.getMethod("hello");
helloMethod.invoke(s);

helloMethod=c.getMethod("hello",String.class);
Object o=helloMethod.invoke(s, "wwww");
System.out.println(o);

Method addMethod=c.getDeclaredMethod("add", Integer.class,Integer.class);
addMethod.setAccessible(true);
Integer n=(Integer)addMethod.invoke(s, 10,20);
System.out.println(n);
}
}

//如果还有什么不懂的，大家可以到我的资源库下载学习

总节一下：

总的来说，java反射机制是一个很好用的东西，用它可以解决很多死的东西，因为反射机制的灵活行很大，有了他，我们就不要花太多的时间来写操做数据库的代码了，而是方法更多的时间在项目的逻辑功能上，这个可以很大的减少开发时间，而且代码的可读性好。先在的很多开源框架都是才用的反射机制，它只要配置文件，然后按规则来调用他的方法就可以了。

---------------------------------------敬请期待下一节哦！