1. 什么是反射
反射java语言中的一种机制，通过这种机制可以动态的实例化对象、读写属性、调用方法。
2、如和获取类对象（三种方式）
* 1、Class.forName(“完整类名”); jdbc、自定义mvc框架要用
* 2、类名.Class 做通用的查询
* 3、类(Class类类的类对象)实例.getClass() 通用的增删改
1、首先导入一个类：Student.java
package com.zking.reflect;
public class Student {
private String sid;
private String sname;
public Integer age;
static{
System.out.println("加载进jvm中！");
}
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);
}
@SuppressWarnings("unused")
private Integer add(Integer a, Integer b) {
return new Integer(a.intValue() + b.intValue());
}
@Override
public String toString() {
return "Student [sid=" + sid + ", sname=" + sname + ", age=" + age + "]";
}
}
2、类类Class的类对象获取方式
创建一个类：Demo1.java
package com.zking.reflect;
/*
* 如和获取类对象
* 1、Class.forName("");jdbc、自定义mvc框架要用
* 2、类名.Class 做通用 的查询
* 3、类(Class类类的类对象)实例.getClass() 通用的增删改
*
*
*/
public class Demo1 {
public static void main(String[] args) throws ClassNotFoundException {
// Class<?> clz=Class.forName("com.zking.reflect.Student");
// Class<?> clz=Student.class;
Student stu=new Student();
Class<?> clz=stu.getClass();
System.out.println(clz);
}
// java.sql.Driver
/*
* 为什么jdbc要使用Class.forName("com.jdbc.mysql.Driver");
* 无论是mysql的驱动Driver还是Oracle的驱动......;它必然需要实现jdbc的一个驱动接口;
* java.sql.Driver d=Class.forName("com.jdbc.mysql.Driver");
*
*
*
*
* web.xml
* <servlet>
* <servlet-name>xxx<servlet-name>
* <servlet-class>com.zking.servlet<servlet-class>
* <servlet>
* .......
*
*
* com.zking.servlet extends httpServlet
* Class<?> clz=Class.forName("com.zking.servlet");
* httpServlet httpServlet= clz.newInstanse();
*
* servlet实例
* new servlet();
*/
}
3、* 反射实例化
* 1、能够实例化未知的类
* 2、能过通过私有构造创建
创建一个类：Demo2.java
package com.zking.reflect;
import java.lang.reflect.Constructor;
/*
* 反射实例化
* 1、能够实例化未知的类
* 2、能过通过私有构造创建
*/
public class Demo2 {
public static void main(String[] args) throws Exception {
Class clz=Student.class;
//反射调用无参构造方法创建了一个学生对象
// Student stu=(Student)clz.newInstance();
//调用带一个的构造方法创建了一个学生对象
//要拿到构造器类
// Constructor con= clz.getConstructor(String.class);
//通过构造器实例化对象
// Student stu=(Student)con.newInstance("s001");
//java.lang.NoSuchMethodException(getConstructor只能寻找到public修饰的构造器,getDeclaredConstructor可以寻找到任何修饰符修饰的构造器)
// Constructor con= clz.getConstructor(Integer.class);
//Class com.zking.reflect.Demo2 can not access a member of class com.zking.reflect.Student with modifiers "private"
Constructor con= clz.getDeclaredConstructor(Integer.class);
con.setAccessible(true);
//通过构造器实例化对象
Student stu=(Student)con.newInstance(12);
}
}
3、反射调用方法
创建一个类：Demo3.java
package com.zking.reflect;
import java.lang.reflect.Method;
/*
* 反射调用的方法
* AddOrderservlet
* Delorderservlet
*
* -->OrderSevlet
* jsp-->methodName
* dopost
* string methodName=red.getparameter("methodName");
* if("add".equals(methodName)){
*
* }else if("del".equals(methodName)){
* del(req,resp);
* }
*
* --->
* 上面的代码全部都不需要了
* del(req,resp);
* add(req,resp);
*
*/
public class Demo3 {
public static void main(String[] args) throws Exception {
Student stu=new Student();
// stu.hello();
Class clz=stu.getClass();
// Method m= clz.getDeclaredMethod("hello" );
// m.invoke(stu);
// Method m= clz.getDeclaredMethod("hello",String.class );
//// m.invoke(stu, "zs");
// System.out.println(m.invoke(stu, "zs"));
// Method m= clz.getDeclaredMethod("add" ,Integer.class,Integer.class);
// m.setAccessible(true);
// //invoke:如果反射动态调用的方法是被void所修饰，那么返回的就是null
// //如果反射动态调用的方法是不被void所修饰，那么返回的就是调用的方法的返回值
// Object invoke=m.invoke(stu,20,5);
// System.out.println(invoke);
}
}
4、反射读写属性
创建一个类：Demo4.java
package com.zking.reflect;
import java.lang.reflect.Field;
/*
* 反射属性赋值取直
* jsp
* --->uname，sex，age，password.phone,address.......
* servlet
* String uname=req.getparameter("uname");
* String sex=req.getparameter("sex");
* .....
* User u-new User();
* u.setName(uname);
* u.setSex(sex);
* ......
*
*
* -->
* 反射能够将jsp传递过来的参数直接封装到实体类中
*/
public class Demo4 {
public static void main(String[] args) throws Exception {
Student stu=new Student("s002","ls");
// stu.setSid("s001");
stu.age=22;
//// System.out.println(stu.age);
// System.out.println(stu);
Class clz=stu.getClass();
// Field field= clz.getDeclaredField("sid");
// field.setAccessible(true);
// field.set(stu, "s002");
// System.out.println(stu);
// System.out.println(field.get(stu));
Field[] fields=clz.getDeclaredFields();
for(Field field:fields) {
field.setAccessible(true);
System.out.println(field.getName()+":"+field.get(stu));
}
}
}
