2021-07-21反射

今日份学习：

反射

获取类对象的三种形式

通过类的对象，

Student s=new Student();
Class c=s.getClass();

通过类名

Class c=类名.class;

通过静态方法

Class c=Class.forName("包名.类名");

设计模式

一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。
可以简单理解为特定问题的固定解决方法。

单例模式

只允许创建一个该类的对象
重点记方式三，静态内部类写法

public class SingleTon3{
	private SingleTon3(){}
	private static class Holder{
		static SingleTon3 instance=new SingleTon3();
	}
	public static SingleTon3 getInstance(){
		return Holder.instance;
	}
}

枚举

枚举是一个引用类型，枚举是一个规定了取值范围的数据类型。

注解

是代码里的特殊标记, 程序可以读取注解，一般用于替代配置文件。开发人员可以通过注解告诉类如何运行。

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Arrays;

public class TestPerson {
	public static void main(String[] args) throws Exception {
		//通过对象类获取类对象
		Person zhangsan=new Person();
		Class class1=zhangsan.getClass();
		System.out.println(class1.hashCode());
		//使用类名.class属性
		Class class2=Person.class;
		System.out.println(class2.hashCode());	
		//使用静态方法（最好）
		Class class3=Class.forName("Demo.Person");
		System.out.println(class3.hashCode());	
	}
	//使用反射类获取类的名字，包名，父类，接口
	public static void reflectOpe1() throws Exception {
		//获取类对象
		Class class1=Class.forName("Demo.Person");
		//getName();
		System.out.println(class1.getName());
		//getPackage();
		System.out.println(class1.getPackage().getName());
		//getSuperClass();
		System.out.println(class1.getSuperclass().getName());
		//getInterfaces();
		Class[] classes=class1.getInterfaces();
		System.out.println(Arrays.toString(classes));
		System.out.println(class1.getSimpleName());
		System.out.println(class1.getTypeName());
	}
	//使用反射获取类的构造方法，创建对象
	public static void reflectOpe2() throws Exception {
		//获取类的类对象
		Class class1=Class.forName("Demo.Person");
		//获取类的构造方法
		Constructor[] cons=class1.getConstructors();
		for(Constructor con:cons) {
			System.out.println(con.toString());
		}
		//获取类中的无参构造方法
		Constructor con =class1.getConstructor();
		Person zhangsan=(Person)con.newInstance();
		Person lisi=(Person)con.newInstance();
		System.out.println(zhangsan.toString());
		System.out.println(lisi.toString());
		//简便方法类对象
		Person wangwu=(Person)class1.newInstance();
		System.out.println(wangwu.toString());
		//获取类中带参构造方法
		Constructor con2=class1.getConstructor(String.class,int.class);
		Person xiaoli=(Person)con2.newInstance("晓丽",20);
		System.out.println(xiaoli.toString());	
	}	
	//使用反射获取类中的方法，并调用方法
	public static void reflectOpe3() throws Exception{
		//获取类对象
		Class class1=Class.forName("Demo.Person");
		Method[] methods=class1.getDeclaredMethods();
		for(Method method:methods) {
			System.out.println(method.toString());
		}
		Method eatMethod=class1.getMethod("eat");
		Person zhangsan=(Person)class1.newInstance();
		eatMethod.invoke(zhangsan);
		System.out.println("===============");
		//toString 
		Method toStringMethod=class1.getMethod("toString");
		Object result=toStringMethod.invoke(zhangsan);
		System.out.println(result);
		System.out.println("==============");
		//带参的eat
		Method eaMethod2=class1.getMethod("eat",String.class);	
		eatMethod.invoke(zhangsan, "鸡腿");
		//获取私有方法
		Method privateMethod=class1.getDeclaredMethod("privateMethod");
		//设置访问权限无效
		privateMethod.setAccessible(true);
		privateMethod.invoke(zhangsan);
		//获取静态方法
		Method staticMathod=class1.getMethod("staticMethod");
		//正常调用
		staticMathod.invoke(null);	
	}	
	public static Object invokeAny(Object obj,String methodName,Class[] types,Object...args)throws Exception{
		Class class1=obj.getClass();
		Method method =class1.getMethod(methodName, types);
		return method.invoke(obj, args);			
	}
	public static void rfflectOpe4() throws Exception{
		Class class1=Class.forName("Demo.Person");
		Field[] fields=class1.getDeclaredFields();
		System.out.println(fields.length);
		for(Field field:fields) {
			System.out.println(field.toString());
		}
		Field namefield=class1.getDeclaredField("name");
		namefield.setAccessible(true);
		Person zhangsan=(Person)class1.newInstance();
		namefield.set(zhangsan, "张三");
		System.out.println(namefield.get(zhangsan));
	}
}