J2EE反射

学习目标看一下

1  什么是反射

反射是java语言中的一种机制，通过这种机制可以动态的实例化对象，读写属性，调用方法

注：放一个学生实体类给大家做讲解

package com.lsy.model.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());
	}
}

 该类有很多公有，私有，无参，有参方法，放方便下面的讲解

2  类类（三种书写方法）

Class.forName(完整类型)

类名.class

对象.getClass()

三  反射实例化

getConstructor与getDeclaredConstructor的区别

两者的区别是一个可以获取有参无参的构造方法，一个可以获取私有构造方法

newInstance()方法

这个方法是调用了无参构造，因为在框架底层，是通过无参这个类来进行实例化

package com.lsy.model.reflect;

import java.lang.reflect.Constructor;

/**
 * 反射实例化
 * @author zjjt
 *
 */
public class Demo2 {
	public static void main(String[] args) throws Exception {
		//拿到类类的类实例  记住后面的类要点出来
		Class<Student> stuClz1=(Class<Student>)Class.forName("com.lsy.model.reflect.Student");
		Student stu1 = (Student)stuClz1.newInstance();
		stu1.hello();
		//在框架的底层，是通过无参一个类进行实例化
		
		//反射调用有参构造器
		//getConstructor与getDeclaredConstructor的区别
		Constructor<Student> c = stuClz1.getConstructor(String.class);
		Student s1=c.newInstance("s001");
		
		Constructor<Student> c2 = stuClz1.getConstructor(String.class,String.class);
		Student s2=c2.newInstance("s001","zs");
		
		Constructor<Student> c3 = stuClz1.getDeclaredConstructor(Integer.class);
		//打开访问权限
		c3.setAccessible(true);
		Student s3=c3.newInstance(26);
		//反射可以将有参，无参，私有构造器实例化
	}
}

注意一些报错：

java.lang.IllegalAccessException  这个报错是访问权限的问题，所以下一步我们要打开访问权限，

也就是setAccessIble()

四  反射动态方法调用

getDeclaredMethod()与getMethod()

package com.lsy.model.reflect;

import java.lang.reflect.Method;

/**
 * 反射动态方法调用
 * @author zjjt
 *
 */
public class Demo3 {
	public static void main(String[] args) throws Exception {
		Class<Student> stuClz1=(Class<Student>)Class.forName("com.lsy.model.reflect.Student");
		Student s = stuClz1.newInstance();
		Method m1 = stuClz1.getDeclaredMethod("hello");
		//invoke参数一：类实例，在这里指的是Student类实例
		//invoke参数二：当前被调用的方法，传递的参数值
		
		//invoke的返回值就是被反射调用的方法的返回值，如果被调用的方法是void，那么返回null
		System.out.println( m1.invoke(s));
		
		Method m2 = stuClz1.getDeclaredMethod("hello",String.class);
		System.out.println(m2.invoke(s, "zs"));
		//取私用方法
		Method m3 = stuClz1.getDeclaredMethod("add",Integer.class,Integer.class);
		//打开访问权限
		m3.setAccessible(true);
		System.out.println(m3.invoke(s, 10,5));
	
	}
}

五  反射读写属性

getDeclaredField()

package com.lsy.model.reflect;

import java.lang.reflect.Field;

/**
 * 反射读写属性
 * @author zjjt
 *
 */
public class Demo4 {
	public static void main(String[] args) throws Exception {
		Class<Student> stuClz1=(Class<Student>)Class.forName("com.lsy.model.reflect.Student");
		Student s=stuClz1.newInstance();
		Field f = stuClz1.getDeclaredField("sname");
		f.setAccessible(true);
		//反射写属性
		f.set(s, "zs");
		System.out.println(s.getSname());
		//反射读属性
		System.out.println(f.get(s));
		
		//比较oop与反射读取属性值的方式
		Student st=new Student("s002","ls");
		st.age=22;
		System.out.println(st.getSid());
		System.out.println(st.getSname());
		System.out.println(st.age);
		//以上是oop的获取方式
		
		System.out.println("----------------");
		//反射获取该对象所有属性值
		Field[] fields=stuClz1.getDeclaredFields();
		for (Field ff : fields) {
			ff.setAccessible(true);
			System.out.println(ff.getName()+"--"+ff.get(st));
		}
		
		
		
		
	}
}

f.set(s, “zs”);是反射写属性

f.get(s)；是反射读属性

getDeclaredFields()

可以通过遍历的方式获取类里面的每个属性，相比于oop来说，取值更方便