欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

反射(一)

程序员文章站 2022-06-18 10:53:55
...

1.什么是反射

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

反射的优点

反射提高了程序的灵活性和扩展性,降低耦合性,提高自适应能力。它允许程序创和控制任何类的对象,无需提前硬编码目标类

反射的缺点

性能问题,使用反射基本上是一种解释操作,用于字段和方法接入时要远慢于直接代码。因此反射机制主要应用在对灵活性和扩展性要求很高的系统框架上,普通程序不建议使用

2. 类类

所有狗 狗类 Dog 狗对象 旺财
所有猫 猫类 Cat 猫对象 肥波
所有类 类类 java.lang.Class 类对象 特定类

java.lang.Class
java.lang.reflect.Method
java.lang.reflect.Field
java.lang.reflect.construct

(Dog.java , Cat.java…).java文件我们能不能描述成一种事物呢?
java.lang.Class这个类就是描述Dog.java,Cat,java这些东西的
具体的.java文件就是描述java.lang.Class这个类的一个具体的实例

类组成部分:
类属性 java.lang.reflect.Field (都是以java面向对象的思想对它进行封装了)
类方法 java.lang.reflect.Method

3.一切反射相关的代码都从获得java.lang.Class类对象开始

3.1 Class.forName(完整类名)
3.2 类名.class
3.3 对象.getClass()

4. 反射三大作用(java.lang.reflect.*)

4.1获取类对象的三种方式

代码演示:
创建一个Student

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

Demo1:

package com.myy.reflect;

/**
 * 获取类对象的方式
 *  通过java提供的反射机制获取到com.myy.reflect.Student.class
 *  1.Class.forName("全路径名");   jdbc/自定义mvc框架调用
 *  2.类名.class 结合泛型做通用分页查询方法会用
 *  3.类java.lang.Class(实例的类)实例(Student.class)的类实例getClass()获取  通用的增删改结合泛型使用
 *  
 * @author myy
 *
 */
public class Demo1 {
  public static void main(String[] args) throws Exception {
//	 1.Class.forName("全路径名");   jdbc/自定义mvc框架调用
	Class stuClz = Class.forName("com.myy.reflect.Student");
	System.out.println("------------");
	
//	 2.类名.class 结合泛型做通用分页查询方法会用
	Class stuClz1 = Student.class;
	System.out.println(stuClz1);
	System.out.println("-------------");
	
	Student stu = new Student();
//	3.类java.lang.Class(实例的类)实例(Student.class)的类实例getClass()获取  通用的增删改结合泛型使用
	Class stuClz2 =  stu.getClass();
	System.out.println(stuClz2);//并且还调用了无参构造器
	
	
}
	
}

运行结果:
反射(一)

4.2反射实例化对象

代码演示:
Demo2:

package com.myy.reflect;

/**
 * 利用反射进行对象的实例化
 *    之前:通过new关键字进行实例化
 *    现在:通过java.lang.reflect.construct来实例化对象
 *    
 * @author myy
 *
 */
public class Demo2 {
    public static void main(String[] args) throws Exception, Exception {
		Student stu = new Student();
		Class stuClz = stu.getClass();
//		newInstance这个方法默认是使用无参构造器去实例化对象
		Student stu2 = (Student) stuClz.newInstance();
		System.out.println(stu2);//如果不是空就意味着创建出来
	}
}

运行结果:
反射(一)
提问:假设没有无参构造器运行会不会报错
代码演示:
首先,先把Student类的无参构造器注释掉
反射(一)
然后,修改一下Demo2的代码

 public static void main(String[] args) throws Exception, Exception {
//		Student stu = new Student();
//		Class stuClz = stu.getClass();
    	Class stuClz = Student.class;
//		newInstance这个方法默认是使用无参构造器去实例化对象
		Student stu2 = (Student) stuClz.newInstance();
		System.out.println(stu2);//如果不是空就意味着创建出来
	}

如图所示运行会报错:
反射(一)

答:由上面代码演示我们得知当没有无参构造器的时候运行会报错。
运行报错的原因是:没有找到匹配方法,因为它默认找的是默认无参构造器。
注意:一定要提供无参构造器

优势:

  1. 能够对未知的对象进行实例化
  2. 能够对私有的构造器实例化对象

1.1代码演示:

 public static void main(String[] args) throws Exception, Exception {
    	Class stuClz = Student.class;
//		调用有参构造器去实例化对象
    	Constructor<Student> constructor = stuClz.getConstructor(String.class);
    	Student stu2 = (Student)constructor.newInstance("张三");
    	
	}

运行结果:
反射(一)
1.2代码演示

public static void main(String[] args) throws Exception, Exception {
    	Class stuClz = Student.class;
//		调用有参构造器去实例化对象(两个参数的)
    	Constructor<Student> constructor = stuClz.getConstructor(String.class,String.class);
    	Student stu2 = (Student)constructor.newInstance("t003","张三");
    	
	}

运行结果:
反射(一)
2.1如果按照以上的操作进行代码演示

 public static void main(String[] args) throws Exception, Exception {
    	Class stuClz = Student.class;
//    	调用私有构造器去实例化对象
    	Constructor<Student> constructor = stuClz.getConstructor(Integer.class);
    	Student stu2 = (Student)constructor.newInstance(18);
    	
	}

运行结果:
反射(一)
getConstructor与getDeclaredConstructoe的区别
getConstructor只能获取被public修饰的构造器
getDeclaredConstructoe被所有关键字修饰的构造器

所以私有的要用getDeclaredConstructoe

如代码演示:

 public static void main(String[] args) throws Exception, Exception {
    	Class stuClz = Student.class;
//    	调用私有构造器去实例化对象
    	Constructor<Student> constructor = stuClz. stuClz.getDeclaredConstructor(Integer.class);
    	Student stu2 = (Student)constructor.newInstance(18);
    	
	}

运行结果:
反射(一)

Class com.myy.reflect.Demo2 can not access a member of class com.myy.reflect.Student with modifiers "private"

该错误原因是:找到了私有的构造器,但不能调用因为没有权限

则要对代码进行给予权限如代码演示:

 public static void main(String[] args) throws Exception, Exception {
    	Class stuClz = Student.class;
//    	调用私有构造器去实例化对象
    	Constructor<Student> constructor = stuClz. stuClz.getDeclaredConstructor(Integer.class);
constructor.setAccessible(true);//默认为false    
	Student stu2 = (Student)constructor.newInstance(18);
    	
	}

运行结果:
反射(一)

4.3 反射动态调用方法

Demo3:
无参的代码演示:

package com.myy.reflect;

import java.lang.reflect.Method;

/**
 * 动态方法调用
 *  构造方法是不是方法
 * 
 * @author myy
 *
 */
public class Demo3 {
 public static void main(String[] args) throws Exception, SecurityException {
	Student stu = new Student();
	Class<? extends Student> stuClz = stu.getClass();//泛型里的上限定
//无参
	Method m= stuClz.getDeclaredMethod("hello");
	m.invoke(stu);
}
}

运行结果:
反射(一)
有参的代码演示:

public static void main(String[] args) throws Exception, SecurityException {
	Student stu = new Student();
	Class<? extends Student> stuClz = stu.getClass();//泛型里的上限定
	//有参的
	Method m= stuClz.getDeclaredMethod("hello", String.class);
	m.invoke(stu, "张三");
}

运行结果:
反射(一)
私有的代码演示:

 public static void main(String[] args) throws Exception, SecurityException {
	Student stu = new Student();
	Class<? extends Student> stuClz = stu.getClass();//泛型里的上限定
	//私有的
	Method m = stuClz.getDeclaredMethod("add", Integer.class,Integer.class);
   m.setAccessible(true);
	//	Method.invoke的返回值是被动态调用的方法的返回值
	Object invoke = m.invoke(stu, 11,9);
	System.out.println(invoke);
}

运行结果:
反射(一)

4.4 反射读写属性

Demo4:
代码演示:

package com.myy.reflect;

import java.lang.reflect.Field;

/**
 * 反射读写属性
 *  自定义标签库,通用分页,自定义mvc也要用
 * @author myy
 *
 */
public class Demo4 {
public static void main(String[] args) throws Exception {
	Student stu = new Student("t003","张三");
	stu.age = 18;
	System.out.println(stu.getSid());
    System.out.println(stu.getSname());	
	Class<? extends Student> stuClz = stu.getClass();
	//私有的
	Field f = stuClz.getDeclaredField("sname");
	f.setAccessible(true);
	System.out.println(f.get(stu));
	
//	获取当前Student实例中的stu私有属性及其属性值
	Field[] fields = stuClz.getDeclaredFields();
	for (Field field : fields) {
		field.setAccessible(true);
		System.out.println(field.getName()+":"+field.get(stu));
	}
}
}

运行结果:
反射(一)

5.访问修饰符

如何判断类或变量、方法的修饰符,可以使用Java反射机制中,Field的 getModifiers() 方法返回int类型值表示该字段的修饰符,

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

该修饰符是java.lang.reflect.Modifier的静态属性

对应表如下:
PUBLIC: 1
PRIVATE: 2
PROTECTED: 4
STATIC: 8
FINAL: 16
SYNCHRONIZED: 32
VOLATILE: 64
TRANSIENT: 128
NATIVE: 256
INTERFACE: 512
ABSTRACT: 1024
STRICT: 2048

Modifier提供了很多静态方法,对类和成员访问修饰符进行解码。
如代码演示:

package com.myy.reflect;

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

/**
 *   Modifier.isAbstract(int mod) 
 *   Modifier.isFinal(int mod) 
 *   Modifier.isInterface(int mod)
 *   Modifier.isNative(int mod)
 *   Modifier.isPrivate(int mod)
 *   Modifier.isProtected(int mod) 
 *   Modifier.isStatic(int mod)
 *   Modifier.isStrict(int mod)
 *   Modifier.isSynchronized(int mod)  
 *   Modifier.isTransient(int mod)
 *   Modifier.isVolatile(int mod) 
 *   
 * @author myy
 *
 */
public class Demo5 {
public static void main(String[] args) {
     Field[] fileds = Student.class.getDeclaredFields();
     for (Field field : fileds) {
		System.out.println(field.getName()+"  访问修饰符是否包括private:"+Modifier.isPrivate(field.getModifiers()));
	    System.out.println(field.getName()+"  访问修饰符是否包括static:"+Modifier.isStatic(field.getModifiers()));
	    System.out.println(field.getName()+"  访问修饰符是否包括public:"+Modifier.isPublic(field.getModifiers()));
     }
}
}

运行结果:
反射(一)

相关标签: 反射