J2EE基础之反射

一：反射

二：类类

三：反射实例化

四：反射动态方法的调用

五：反射读取属性：

今天与大家分享的是：反射，大多数时候我们不能直接拿到一个类的实例，而今天我跟大家分享反射之后，就能通过反射来拿到对象了。

一：反射

1、定义：反射是JAVA语言中一种机制通过该机制可以动态的实例化对象，读取属性，以及调用方法。
2、为什么要学反射？
java的反射机制就是增加程序的灵活性，避免将程序写死到代码里。

二：类类

1、什么是类类？
我将用一个列子来解释什么是类类，比如有一个类叫狗类，狗类的有一个实例化的列子是叫旺财，所以说旺财是狗类的一个实例化例子，而狗类又是Class的实例化例子。所以说Class是类类。
2、类类的类对象的三种获取方式：

这里我先拿 学生类 作为案例为大家讲解：

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

1、类名.class（）（以后是要作通用查询）

//1、类.class
		Class clz1=Student.class;

2、类实例.getClass()

//2、类实例.getClass()
//		确定本工程有这个类，才可以实例化
		Student stu=new Student();
//		本工程没有这个类，也可以编译通过，但是会在运行期报错
//		Object newInstance = Class.forName("com.ycx.reflect.Student").newInstance();
		Class clz2 = stu.getClass();

3、Class.forName()

//3、Class.forName("类的全路径名");
		Class clz3 = Class.forName("com.ycx.reflect.Student");

三：反射实例化：

大多数时候我们不能直接拿到一个类的实例，就能通过反射来拿到对象了。

* 反射实例化
* 1、无参数共有的构造方法
* 2、有参数共有的构造方法
* 3、有多个参数共有的构造方法
* 4、私有的构造方法
方法讲解：
1、.newInstance()：获取到该类的一个对象。
Student stu1 = stuClz1.newInstance();
2、getConstructor（）；调用类中的方法。其中括号里面是填的类型
Constructor<Student> c = stuClz1.getConstructor(String.class);
3、.getDeclaredConstructor（）；

                                调用类中的方法。

                                其中括号里面是填的类型
Constructor<Student> c2 = stuClz1.getConstructor(String.class,String.class);
4、getConstructor（）和getDeclaredConstructor（）的方法比较。
getConstructor（）：主要用于私有方法，
getDeclaredConstructor（）：主要用于公有方法，使用该方法时要设置访问权限。
c3.setAccessible(true);

看一个完整案例代码：

package com.ycx.reflect;

import java.lang.reflect.Constructor;

/**
 * 反射实例化
 * 1、无参数  共有的构造方法
 * 2、有参数  共有的构造方法
 * 3、有多个参数  共有的构造方法
 * 4、私有的构造方法
 * @author 杨总
 *
 */
public class Demo2 {
	public static void main(String[] args) throws Exception {
		Student stu1=new Student();
		Student stu2=new Student("s001");
		Student stu3 = new Student("s001", "杨总");
		
		/*********以下均为反射的方式实例化对象**********/
		//获取类类
		Class<? extends Student> clz1 = stu1.getClass();
		//默认调用无参的  共有的  构造函数
//		1、无参数  共有的构造方法
		Student stu4 = clz1.newInstance();
//		 2、有参数  共有的构造方法
//		拿到构造器对象  	三个.代表可以传1个2个..n个参数--->拿到一个参数为String的构造器对象
		Constructor<? extends Student> c1 = clz1.getConstructor(String.class);
		Student stu5=c1.newInstance("s001");
//		3、有多个参数  共有的构造方法  拿到有两个参数的构造器对象
		Constructor<? extends Student> c2 = clz1.getConstructor(String.class,String.class);
		Student stu6 = c2.newInstance("s001","颜大老婆");
//		4、私有的构造方法
//		getConstructor只能获取共有的构造方法 要获取私有的构造器:getDeclaredConstructor
		Constructor<? extends Student> c3 = clz1.getDeclaredConstructor(Integer.class);
//		打开访问权限
		c3.setAccessible(true);
		Student stu7 = c3.newInstance(18);

	}
}

运行效果如下：

四：反射动态方法的调用：

* 1、调用无参数的共有方法

	1、先拿到类类
		Class<Student> clz=Student .class;
//		name:方法名    parameterTypes:方法对应的参数
		Method m1 = clz.getMethod("hello");
//		调用对应的方法
//		第一个参数，那个类实例，第二个参数：方法调用时的实参
//		m1.invoke方法调用的返回值就是方法对象本身的返回值hello方法的返回值
		Object invoke = m1.invoke(clz.newInstance());
		System.out.println(invoke);

* 2、调用1个有参数的共有方法

//		调用1个有参数的 共有方法
		Method m2 = clz.getMethod("hello", String.class);
		Object invoke2 = m2.invoke(clz.newInstance(), "杨总");
		System.out.println(invoke2);

* 3、调用私有的方法

//		调用私有的方法
		Method m3 = clz.getDeclaredMethod("add", Integer.class,Integer.class);
		m3.setAccessible(true);
		Object invoke3 = m3.invoke(clz.newInstance(), 5,5);
		System.out.println(invoke3);

五：反射读取属性：

package com.ycx.reflect;

import java.lang.reflect.Field;

/**
 * 反射读写属性
 * @author 杨总
 *
 */
public class Demo4 {
	public static void main(String[] args) throws Exception {
		Student stu= new Student("s003","杨总");
		stu.age=20;
//		需求：要拿到这个学生所有的属性及属性值
		System.out.println("age:"+stu.age);
		System.out.println("sname:"+stu.getSname());
		System.out.println("sid:"+stu.getSid());
		
		/**
		 * 上述代码存在问题
		 * 1、你事先得知道这个类有哪些属性
		 * 2、假设student有三十个属性呢？
		 */
		
//		一切反射从类类开始
		Class<? extends Student> clz= stu.getClass();
//		当前类的所有属性对象
		Field[] fields = clz.getDeclaredFields();
		System.out.println(fields.length);
//		for循环中的f代表每一个属性对象
		for (Field f : fields) {
			//打开访问权限
			f.setAccessible(true);
//			通过属性对象拿到属性名称
			System.out.println(f.getName());
			//拿到当前的属性对象的属性值
			System.out.println(f.get(stu));
		}
	}
}

课外拓展：

如何判断类或变量、方法的修饰符，可以使用Java反射机制中，

Field的 getModifiers() 方法

（访问修饰符）

返回int类型值表示该字段的修饰符，
即这个方法就是返回一个int型的返回值，代表类、成员变量、方法的修饰符。

其中，该修饰符是java.lang.reflect.Modifier的静态属性。（简单了解即可）

今天的分享就到这里了。如有缺漏，希望大神多多指点。

一：反射

二：类类

三： 反射实例化：

四：反射动态方法的调用：

五：反射读取属性：

课外拓展：

猜你喜欢

三：反射实例化：