反射的学习

最新推荐文章于 2022-06-24 14:04:01 发布

珠小猪

最新推荐文章于 2022-06-24 14:04:01 发布

阅读量126

点赞数

本文链接：https://blog.csdn.net/luzhu1234/article/details/80607231

版权

什么是反射:
反射就是通过获取class字节码文件对象/Class的类对象,
获取该字节码文件对象中的成员变量,构造方法,和成员方法。

Field: 简称成员变量 (Field 提供有关类或接口的单个字段的信息，以及对它的动态访问权限。
反射的字段可能是一个类（静态）字段或实例字段。)
Constructor:简称构造方法:提供关于类的单个构造方法的信息以及对它的访问权限。
Method:简称成员方法:类或接口上单独某个方法（以及如何访问该方法）的信息

public class Person {
	
	private String name ;
	int age ;
	public String address ;
	
	//公共的无参
	public Person() {
	}
	
	//私有的带一个参数的构造方法
	private Person(String name) {
		this.name = name ;
	}
	
	//没有权限修饰符的带两个参数的构造方法
	Person(String name,int age){
		this.name = name ;
		this.age =age ;
	}
	
	//公共的带三个参数的构造方法
	public Person(String name,int age,String address) {
		this.name = name ;
		this.age =age ;
		this.address = address;
	}
	
	//成员方法
	//无参的,没有返回值
	public void show() {
		System.out.println("show Person");
	}
	
	//有参的,没有返回值的
	public void method(String s) {
		System.out.println("method"+s);
	}
	
	//有参的,并且有返回值的
	public String getString(String s,int i) {
		return s+i ;
	}
	
	//私有的
	private void function() {
		System.out.println("function Preson");
	}

	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + ", address=" + address + "]";
	}
}

public class ReflectDemo {
	
	public static void main(String[] args) throws ClassNotFoundException {
		
		//如何获取class字节码文件对象
		//创建Person对象
		Person p1 = new Person() ;
		Class c1 = p1.getClass() ;  //获取class字节码文件对象 
		
		Person p2 = new Person();
		Class c2 = p2.getClass() ;
		System.out.println(p1==p2);//false
		System.out.println(c1==c2);//true
		
		System.out.println("------------------");
		
		//数据类型的静态属性class
		Class c3 = Person.class ;
		System.out.println(c3==c2);
		
		
		//开发中常用使用第三种方式
		//public static Class<?> forName(String className)
		//java.lang.ClassNotFoundException: Person
		//Class c4 = Class.forName("Person") ;
		//org.westos_01.Person 
		//参数:类路径:包名.类名
		Class c4 = Class.forName("org.westos_01.Person") ;
		System.out.println(c4==c2);
		
	}
}

通过反射获取构造方法并使用

比如:有参构造的形式
Person p = new Person("高圆圆",27,"户县") ;

System.out.println(p) ;

public class ReflectDemo2 {
	
	public static void main(String[] args) throws Exception {
		
		//1)获取Person类的字节码文件对象
		Class c = Class.forName("org.westos_01.Person") ;
		
		//2)获取单个构造方法(公共的,带三个参数的)
		//public Constructor<T> getConstructor(Class<?>... parameterTypes)
		Constructor con = c.getConstructor(String.class,int.class,String.class) ;
//		System.out.println(con);
		
		//3)创建构造方法表示的该类的实例对象
		Object obj = con.newInstance("高圆圆",27,"户县") ;
		System.out.println(obj);
		//Person [name=高圆圆, age=27, address=户县]
		
	}
}

Person类中增加以下内容：

private Person(String name) {

this.name = name ;
}

Person p = new Person("高圆圆") ;

System.out.println(p) ;

我么可以看一下输出

public class ReflectDemo3 {

	public static void main(String[] args) throws Exception {
		//获取字节码文件对象
		Class c = Class.forName("org.westos_01.Person") ; 
		
		//现在获取的那个构造方法是私有的
		//public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)
		
		Constructor con = c.getDeclaredConstructor(String.class) ;
		
		//创建该类的实例,通过con对象创建
		// java.lang.IllegalAccessException: Class org.westos_02.ReflectDemo3 can not access a member of class org.westos_01.Person with modifiers "private"
		//				at sun.reflect.Reflection.ensureMemberAccess(Reflection.java:102)
	
		//public void setAccessible(boolean flag)
		//。值为 true 则指示反射的对象在使用时应该取消 Java 语言访问检查
		con.setAccessible(true);
		Object obj = con.newInstance("高圆圆") ;
		System.out.println(obj);
		//Person [name=高圆圆, age=0, address=null]
	}
}

通过反射获取成员变量,并使用

public class ReflectDemo {

	public static void main(String[] args) throws Exception {
		
		//获取Person类的字节码文件对象
		Class c = Class.forName("org.westos_01.Person");
		
		//获取当前字节码文件对象中的所有的公共的成员变量
		//public Field[] getDeclaredFields():获取当前字节码文件对象中所有的字段
		//public Field[] getFields()
//		Field[] fields = c.getFields() ;
		/*Field[] fields = c.getDeclaredFields();
		for(Field field:fields) {
			System.out.println(field);
		}*/
		
		/**
		 * 之前要给Person类中的address赋值
		 * Person p =new Person() ;
		 * p.address= "北京" ;
		 */
		//获取构造方法(Constructor)对象
		Constructor con = c.getConstructor() ;
		Object obj = con.newInstance() ;
//		System.out.println(obj);
		
		//获取Field类对象
		//public Field getField(String name):获取的是公共的字段
		//参数name:表示当前字段的名称
		Field addressFiled = c.getField("address") ;
		
		//public void set(Object obj,Object value)
		//参数1:表示给哪个对象设置当前字段的值
		//参数2:表示给当前获取的哪个Field对象的字段设置一个新的值
		addressFiled.set(obj, "北京");
		System.out.println(obj);
		
		System.out.println("-------------------------");
		
		//给name字段赋值
		//java.lang.NoSuchFieldException: name
		//name是私有的,必须指定方法获取
		//public Field getDeclaredField(String name):指定的字段
		Field nameField = c.getDeclaredField("name") ;
//		Field nameField = c.getField("name") ;
		// java.lang.IllegalAccessException: Class org.westos_03.ReflectDemo can not access a member of 
					//class org.westos_01.Person with modifiers "private"
		//因为是私有,应该取消Java语言访问检查
		nameField.setAccessible(true);
		nameField.set(obj, "高圆圆");
		System.out.println(obj);
		
		System.out.println("---------------------------");
		
		Field ageField = c.getDeclaredField("age") ;
		ageField.setAccessible(true);
		ageField.set(obj,27);
		System.out.println(obj);
		

	}
}

通过获取成员方法并使用

public class MethodReflectDemo {

	public static void main(String[] args)throws Exception {
		
		//通过反射获取Pereson字节码文件对象
		Class c = Class.forName("org.westos_01.Person") ;
		
		//获取当前字节码文件对象中的所有的公共的成员方法(包括父类中的)
//		public Method[] getMethods()
		//public Method[] getDeclaredMethods():所有的成员方法
//		Method[] methods = c.getMethods() ;
		/*Method[] methods = c.getDeclaredMethods() ;
		for(Method method:methods) {
			System.out.println(method);
		}*/
		
		/***
		 * 之前调用Person类中的show()
		 * Person p = new Person() ;
		 * p.show() ;
		 */
		
		//获取Constructor对象
		Constructor con = c.getConstructor() ;
		Object obj = con.newInstance() ;
		
		//获取单个的成员方法,Method  
		//调用public void show(){}
		//public Method getMethod(String name, Class<?>... parameterTypes)
		//参数1: 表示方法名
		//参数2:表示当前方法的参数数据类型的静态class属性
		Method m1 = c.getMethod("show") ;
//		obj.m1() ;
		
		//public Object invoke(Object obj, Object... args)
		//参数1:指定的哪个对象上调用底层invoke(),
		//参数2:表示的调用那个方法所传递的实际参数
		m1.invoke(obj) ; //在obj对象上调用m1对象所表示的成员方法
		System.out.println("--------------------");
		/**
		 * public void method(String s) {
				System.out.println("method"+s);
			}
		 */
		
		Method m2 = c.getMethod("method",String.class) ;
		
		//调用底层方法
		m2.invoke(obj, "hello") ;
		
		System.out.println("-----------------------");
		/**
		 * public String getString(String s,int i) {
					return s+i ;
				}
		 */
		
		Method m3 = c.getMethod("getString",String.class,int.class) ;
		//调用Method类中的invoke()方法,调用底层哪个字节码文件对象的对应的成员方法
		Object objgetString = m3.invoke(obj, "javaweb",100) ;
		System.out.println(objgetString);
		
		System.out.println("---------------------------");
		
		/**
		 * //私有的
			private void function() {
				System.out.println("function Preson");
				}		
		 */
		
		//public Method getDeclaredMethod(String name , Class<?>... parameterTypes)
		Method m4= c.getDeclaredMethod("function") ;
		
		//取消Java语言访问检查
		m4.setAccessible(true);
		//调用obj 对象中的底层的function()方法
		m4.invoke(obj) ;
		

		
		
		
		

	}
}

反射会应用在配置文件上,因为Class的forName("字符串形式的类路径")

public class Student {
	
	public void love() {
		System.out.println("学生爱生活,爱Java...");
	}
}

public class Woker {
	
	public void love() {
		System.out.println("工人爱生活,爱老婆...");
	}
}

public class Teacher {

	public void love() {
		System.out.println("老师爱生活,爱高圆圆");
	}
}

public class Test {

	public static void main(String[] args)
			throws IOException, ClassNotFoundException, NoSuchMethodException, SecurityException,
			InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {

		// 反射之前的做法
		// 符合:Java设计元素:开闭原则:对修改关闭,对扩展开放
		/*
		 * Student s = new Student() ; s.love(); Teacher t = new Teacher() ; t.love();
		 * Woker w = new Woker() ; w.love();
		 */

		// 反射:可以将类路径作为配置文件

		// 创建属性集合类对象
		Properties prop = new Properties();
		// 需要将class.txt的内容加载到属性集合类中
		Reader r = new FileReader("class.txt");
		prop.load(r);
		r.close();

		// 属性集合类中有数据类
		String className = prop.getProperty("className");
		String classMethod = prop.getProperty("classMethod");

		// 创建Class类对象
		Class c = Class.forName(className);

		// 创建Constructor
		Constructor con = c.getConstructor();
		Object obj = con.newInstance();
		
		//获取Method类对象
		Method m = c.getMethod(classMethod) ;
		
		//调用obj对象中的底层的love()方法
		m.invoke(obj) ;

	}
}

给你ArrayList<Integer>的一个对象，我想在这个集合中添加一个字符串数据，如何实现呢？

public class ArrayListDemo {
	
	public static void main(String[] args) throws Exception{
		
		ArrayList<Integer>  array = new ArrayList<Integer>() ;
		
		//给集合中添加元素
		array.add(100) ;
//		array.add("hello") ;
		
		//可以通过,获取arrray对象所在的字节码文件对象
		Class c = array.getClass() ;
		
		//可以通过字节码文件对象可以调用底层的add() 
		//先通过Class类的对象获取Method对象
		//公共的有参成员方法 add(Object obj)
		Method m = c.getMethod("add",Object.class) ;
		
		//通过调用array对象中的底层的哪个invoke
		m.invoke(array,"hello") ;
		m.invoke(array,"world") ;
		m.invoke(array,"java") ;
		
		System.out.println(array);
	}
}

需求:写一个方法，

public void setProperty(Object obj, String propertyName, Object value){}，

此方法可将obj对象中名为propertyName的属性的值设置为value。

public class Tool {
	public void setProperty(Object obj, String propertyName, Object value) throws
					NoSuchFieldException, SecurityException,
					IllegalArgumentException, 
					IllegalAccessException{
		
		//作用:就是给对象的字段(成员变量)赋值,value
		//获取当前类的的字节码文件对象
		Class c = obj.getClass() ;
		//如果不知道字段的权限的修饰,用public Field getDeclaredField(String name)
		//已经声明的字段(包括私有...)
		Field field = c.getDeclaredField(propertyName) ;
		//取消Java语言访问检查
		field.setAccessible(true);
		//赋值
		field.set(obj, value);
	}
}

public class ToolDemo {
	
	public static void main(String[] args) throws NoSuchFieldException,
	SecurityException, IllegalArgumentException, 
	IllegalAccessException {
		
		//创建Tool类对象
		Tool t = new Tool() ;
		//现在需要给Person类的name和age赋值
		Person p = new Person() ;
		
		t.setProperty(p, "name", "高圆圆");
		t.setProperty(p, "age", 27);
		System.out.println(p);
		
		System.out.println("--------------");
		
		Dog d = new Dog() ;
		
		t.setProperty(d, "name", "小白");
		t.setProperty(d, "price",800.0);
		System.out.println(d);
	}
}
class Dog{
	private String name ;
	double price;
	@Override
	public String toString() {
		return "Dog [name=" + name + ", price=" + price + "]";
	}
	
	
}

class Person{
	private String name ;
	public int age ;
	
	public String toString() {
		return name+"----"+age;
	}
}

public interface StudentDao {

	//登录
	public abstract void login() ;
	
	//注册
	public abstract void register() ;
}

public class StudentDaoImpl implements StudentDao {

	@Override
	public void login() {
		System.out.println("登录功能");
	}

	@Override
	public void register() {
		System.out.println("注册功能");
	}

}

针对用户操作的接口

提供了增删改查的方法

public interface UserDao {

	public abstract void add() ;//增加
	public abstract void delete() ;//删除
	public abstract void update() ;//修改
	public abstract void find() ;//查询
}

public class UserDaoImpl implements UserDao {

	@Override
	public void add() {
		System.out.println("调用了增加功能");
	}

	@Override
	public void delete() {
		System.out.println("调用了删除功能");
	}

	@Override
	public void update() {
		System.out.println("调用了修改功能");
	}

	@Override
	public void find() {
		System.out.println("调用了查询功能");
	}

}

public class UserDaoImpl2 implements UserDao {

	@Override
	public void add() {
		System.out.println("权限校验");
		System.out.println("增加功能");
		System.out.println("日志记录");
	}

	@Override
	public void delete() {
		System.out.println("权限校验");
		System.out.println("删除功能");
		System.out.println("日志记录");
	}

	@Override
	public void update() {
		System.out.println("权限校验");
		System.out.println("修改功能");
		System.out.println("日志记录");
	}

public class UserTest {
	
	public static void main(String[] args) {
		
		//创建UserDao类对象,调用底层功能
		UserDao ud = new UserDaoImpl() ;
		ud.add();
		ud.delete();
		ud.update();
		ud.find(); 
		//权限校验
		//add()
		//日志记录
		System.out.println("------------------");
		UserDao ud2 = new UserDaoImpl2() ;
		ud2.add();
		ud2.delete();
		ud2.update();
		ud2.find(); 
		System.out.println("------------------");
		//又一写模块:学生登录和注册的功能
		StudentDao sd = new StudentDaoImpl() ;
		sd.login();
		sd.register();
		
	}
}

代理: 在程序的执行过程中,通过一个类Proxy和接口invacationHandler(处理程序)实现动态代理

Proxy类中的方法创建动态代理类对象 public static Object newProxyInstance(ClassLoader
loader,Class<?>[] interfaces,InvocationHandler h) 最终会调用InvocationHandler的方法
InvocationHandler Object invoke(Object proxy,Method method,Object[] args)

参数1:loader:类加载器 public ClassLoader getClassLoader() 参数2:public Class<?>[]
getInterfaces()

针对用户操作的接口

提供了增删改查的方法

public interface UserDao {

	public abstract void add() ;//增加
	public abstract void delete() ;//删除
	public abstract void update() ;//修改
	public abstract void find() ;//查询
}

public class UserDaoImpl implements UserDao {

	@Override
	public void add() {
		System.out.println("调用了增加功能");
	}

	@Override
	public void delete() {
		System.out.println("调用了删除功能");
	}

	@Override
	public void update() {
		System.out.println("调用了修改功能");
	}

	@Override
	public void find() {
		System.out.println("调用了查询功能");
	}

}

public class MyInvacationHandler implements InvocationHandler {

	//给哪个对象生成代理  (目标对象)
	private Object target ;
	public MyInvacationHandler(Object target) {
		this.target = target ;
	}
	
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		//实现代理的程序
		System.out.println("权限校验");
		Object obj = method.invoke(target, args) ;
		System.out.println("日志记录");
		return obj;//返回的就是代理对象
	}

}

public class Test {

	public static void main(String[] args) {

		// 创建UserDao对象
		UserDao ud = new UserDaoImpl();
		ud.add();
		ud.delete();
		ud.update();
		ud.find();

		System.out.println("------------------");

		// 针对UserDao对象ud给它生产一个代理对象
		// 调用处理程序,接口实现类中产生代理
		MyInvacationHandler handler = new MyInvacationHandler(ud);

		UserDao ud2 = (UserDao) Proxy.newProxyInstance(ud.getClass().getClassLoader(), ud.getClass().getInterfaces(),
				handler);
		ud2.add();
		ud2.delete();
		ud2.update();
		ud2.find();
	}
}

public class Direction {
	
	//传统方式:在类中创建该类实例对象
	//在这个类中创建Direction的实例对象
	//自定义
	public static final Direction FRONT = new Direction() ;
	public static final Direction BEHIND = new Direction() ;
	public static final Direction LEFT = new Direction() ;
	public static final Direction RIGHT = new Direction() ;
	
	
	//构造方法私有
	private Direction() {
		
	}
}

public class Direction2 {
	
	
	public static final Direction2 FRONT = new Direction2("前") ;
	public static final Direction2 BEHIND = new Direction2("后") ;
	public static final Direction2 LEFT = new Direction2("左") ;
	public static final Direction2 RIGHT = new Direction2("右") ;
	
	private String name ;
	
	private Direction2(String name) {
		this.name = name ;
	}
	
	//通过公共的访问方法获取实例变量的参数
	public String getString() {
		return name ;
	}
	
}

public abstract class Direction3 {

	// 成员位置创建该类是类
	public static final Direction3 FRONT = new Direction3("前") {

		@Override
		public void show() {
			System.out.println("前");
		}
	};

	public static final Direction3 BEHIND = new Direction3("后") {

		@Override
		public void show() {
			System.out.println("后");
		}
	};

	public static final Direction3 LEFT = new Direction3("左") {

		@Override
		public void show() {
			System.out.println("左");
		}
	};
	public static final Direction3 RIGHT = new Direction3("右") {

		@Override
		public void show() {
			System.out.println("右");
		}
	};
	
	private String name ;
	private Direction3(String name) {
		this.name = name ;
	}
	
	//获取传入参数的值
	public String getString() {
		return name ;
	}
	

	// 抽象方法
	public abstract void show();
}

public class DirectionDemo {
	
	public static void main(String[] args) {
//		Direction d= new Direction() ;
		Direction d = Direction.FRONT ;
		System.out.println(d);//MusicPhoneDecorate.java
		
		System.out.println("---------------------");
		
		Direction2 d2 = Direction2.BEHIND ;
		System.out.println(d2);
		String name = d2.getString() ;
		System.out.println(name);
		d2 = Direction2.FRONT ;
		System.out.println(d2);
		String name2 = d2.getString() ;
		System.out.println(name2);
		
		System.out.println("-----------------------");
		
		Direction3 d3 = Direction3.LEFT ;
		System.out.println(d3);
		d3.show();
		String d3Name = d3.getString() ;
		System.out.println(d3Name);
	}
}

public enum Direction {
	
	FRONT ,BEHIND,LEFT,RIGHT;
}

public enum Direction2 {
	
	FRONT("前"),BEHTIND("后"),LEFT("左"),RIGHT("右") ;
	
	
	private String name ;
	private Direction2(String name) {
		this.name = name ;
	}
	
	public String getString(){
		return name ;
	}
}

public enum Direction3 {

	FRONT("前") {

		@Override
		public void show() {
			System.out.println("前");
		}

	},

	BEHIND("后") {

		@Override
		public void show() {
			System.out.println("后");
		}

	},

	LEFT("左") {

		@Override
		public void show() {
			System.out.println("左");
		}

	},
	RIGHT("右") {

		@Override
		public void show() {
			System.out.println("右");
		}

	};

	public abstract void show();

	private String name;

	private Direction3(String name) {
		this.name = name;
	}

	public String getString() {
		return name;
	}
}

public class DirectionDemo {
	
	public static void main(String[] args) {
		Direction d = Direction.BEHIND ;
		System.out.println(d);//BEHIND
		System.out.println("--------------------------");
		
		Direction2 d2 = Direction2.BEHTIND ;
		System.out.println(d2);
		String name = d2.getString() ;
		System.out.println(name);
		
		System.out.println("--------------------------");
		
		Direction3 d3 = Direction3.RIGHT ;
		System.out.println(d3);
		d3.show();
		String name3 = d3.getString() ;
		System.out.println(name3);
		
		
		//枚举它对象都可以去调用toString()方法,返回声明实例的常量名
		String str = d3.toString() ;
		System.out.println(str);
		
	}
}

给手机增加打电话听音乐彩铃功能

//规则
public interface Phone {
	
	//电话电话的功能
	public abstract void call() ;
}

//具体类
public class IPhone implements Phone {

	@Override
	public void call() {
		System.out.println("手机可以打电话了...");
	}

}

public abstract class PhoneDecoreate implements Phone {
	private Phone p ;
	
	public PhoneDecoreate(Phone p) {
		this.p = p ;
	}
	
	@Override
	public void call() {
		this.p.call();
	}

}

public class MusicPhoneDecorate extends PhoneDecoreate {

	public MusicPhoneDecorate(Phone p) {
		super(p);
	}
	
	@Override
	public void call() {
		super.call();
		System.out.println("手机可以听音乐了...");
	}

}

public class RingPhoneDecorate extends PhoneDecoreate {

	public RingPhoneDecorate(Phone p) {
		super(p);
	}
	
	@Override
	public void call() {
		System.out.println("手机可以听彩铃了....");
		super.call();
	}

}

//测试类
public class PhoneDemo {
	
	public static void main(String[] args) throws FileNotFoundException {
		
		//创建Phone对象
		Phone p = new IPhone() ;
		p.call();
		System.out.println("-----------------");
		//需求:打电话之前,先听彩铃....
		PhoneDecoreate pd = new RingPhoneDecorate(p) ;
		pd.call();
		
		System.out.println("--------------------");
		
		//需求:打完电话之后,听音乐
		pd = new MusicPhoneDecorate(p) ;
		pd.call();
		
		System.out.println("---------------------");
		
		//需求:先听彩铃,打电话--->听音乐
		//装饰类
		pd = new RingPhoneDecorate(new MusicPhoneDecorate(p)) ;
		pd.call();
		
		
		//装饰者设计模式:一定有装饰者抽象类(过滤器 解决参数乱码问题:使用的模式就是装饰者设计模式)
		//常见的装饰者设计的类
		//常见的流
		BufferedReader br = new BufferedReader(
				new InputStreamReader(System.in)) ;
		BufferedInputStream bis = new BufferedInputStream(new FileInputStream("..")) ;
	
		Scanner sc = new Scanner(System.in) ;
 	}
}

珠小猪

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
反射的学习

什么是反射: 反射就是通过获取class字节码文件对象/Class的类对象, 获取该字节码文件对象中的成员变量,构造方法,和成员方法。 Field: 简称成员变量 (Field 提供有关类或接口的单个字段的信息，以及对它的动态访问权限。反射的字段可能是一个类（静态）字段或实例字段。) Constructor:简称构造方法:提供关于类的单个构造方法的信息以及对它的访问权限。 Metho...
复制链接

扫一扫