Reflexión: Diseño Alma marco
-
Marco: semielaborado software. El software puede ser desarrollado en el marco de base, una codificación simplificada
-
Reflexión: Los diversos componentes de las clases de contenedor para otros objetos, esto es el reflejo
- beneficios:
- El programa puede ser durante el funcionamiento , el funcionamiento de estos objetos.
- Puede ser desacoplada para mejorar el programa de escalabilidad .
- beneficios:
-
Obtiene el objeto Class maneras:
Class.forName("全类名"): El archivo de código de bytes de carga en la memoria, la clase de retorno de objetos- Se utiliza para el archivo de configuración , el nombre de la clase se define en el archivo de configuración. Leer el archivo, cargar la clase
类名.class: Obtener clase de atributo por el nombre de la clase- Se utiliza para pasar parámetros
对象.getClass(): GetClass () métodos definidos en la clase Object.- Se utiliza para obtener el objeto de código de bytes de manera
public class ReflectDemo1 {
/**
获取Class对象的方式：
1. Class.forName("全类名")：将字节码文件加载进内存，返回Class对象
2. 类名.class：通过类名的属性class获取
3. 对象.getClass()：getClass()方法在Object类中定义着。
*/
public static void main(String[] args) throws Exception {
//1.Class.forName("全类名")
Class cls1 = Class.forName("cn.itcast.domain.Person");
System.out.println(cls1);
//2.类名.class
Class cls2 = Person.class;
System.out.println(cls2);
//3.对象.getClass()
Person p = new Person();
Class cls3 = p.getClass();
System.out.println(cls3);
//== 比较三个对象
System.out.println(cls1 == cls2);//true
System.out.println(cls1 == cls3);//true
Class c = Student.class;
System.out.println(c == cls1);//false
}
}
- Conclusión: Los
mismos archivos de código de bytes (* .class) durante la ejecución de un programa, sólo se cargará una vez, independientemente de la forma adquirida por los objetos de la clase son los mismos.
public class Student {
public void sleep(){
System.out.println("sleep...");
}
}
public class Person {
private String name;
private int age;
public String a;
protected String b;
String c;
private String d;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
", a='" + a + '\'' +
", b='" + b + '\'' +
", c='" + c + '\'' +
", d='" + d + '\'' +
'}';
}
public void eat(){
System.out.println("eat...");
}
public void eat(String food){
System.out.println("eat..."+food);
}
}
- función de objeto Clase:
- función de adquisición:
- La adquisición de las variables miembro se
-
El campo [] getFields (): Obtiene todas las variables miembro públicas modificados
-
El campo getField (String name) se modifican para especificar el nombre de las variables miembro públicas
-
El campo [] getDeclaredFields () obtiene todas las variables miembro, independientemente de modificadores
-
El campo getDeclaredField (String name)
-
- La adquisición de las variables miembro se
- función de adquisición:
public static void main(String[] args) throws Exception {
//0.获取Person的Class对象
Class personClass = Person.class;
/*
1. 获取成员变量们
* Field[] getFields()
* Field getField(String name)
* Field[] getDeclaredFields()
* Field getDeclaredField(String name)
*/
//1.Field[] getFields()获取所有public修饰的成员变量
Field[] fields = personClass.getFields();
for (Field field : fields) {
System.out.println(field);
}
System.out.println("------------");
//2.Field getField(String name)
Field a = personClass.getField("a");
//获取成员变量a 的值
Person p = new Person();
Object value = a.get(p);
System.out.println(value);
//设置a的值
a.set(p,"张三");
System.out.println(p);
System.out.println("===================");
//Field[] getDeclaredFields()：获取所有的成员变量，不考虑修饰符
Field[] declaredFields = personClass.getDeclaredFields();
for (Field declaredField : declaredFields) {
System.out.println(declaredField);
}
//Field getDeclaredField(String name)
Field d = personClass.getDeclaredField("d");
//忽略访问权限修饰符的安全检查
d.setAccessible(true);//暴力反射
Object value2 = d.get(p);
System.out.println(value2);
}
- Obtiene constructor que
- Constructor <?> [] GetConstructors ()
- Constructor getConstructor (类 <?> ... parameterTypes)
- Constructor getDeclaredConstructor (类 <?> ... parameterTypes)
- Constructor <?> [] GetDeclaredConstructors ()
public static void main(String[] args) throws Exception {
//0.获取Person的Class对象
Class personClass = Person.class;
/*
2. 获取构造方法们
* Constructor<?>[] getConstructors()
* Constructor<T> getConstructor(类<?>... parameterTypes)
* Constructor<T> getDeclaredConstructor(类<?>... parameterTypes)
* Constructor<?>[] getDeclaredConstructors()
*/
//Constructor<T> getConstructor(类<?>... parameterTypes)
Constructor constructor = personClass.getConstructor(String.class, int.class);
System.out.println(constructor);
//创建对象
Object person = constructor.newInstance("张三", 23);
System.out.println(person);
System.out.println("----------");
Constructor constructor1 = personClass.getConstructor();
System.out.println(constructor1);
//创建对象
Object person1 = constructor1.newInstance();
System.out.println(person1);
Object o = personClass.newInstance();
System.out.println(o);
//constructor1.setAccessible(true);
}
- La adquisición de los métodos de miembro son:
- Método [] getMethods ()
- Método getMethod (String nombre, 类 <?> ... parameterTypes)
- Método [] getDeclaredMethods ()
- Método getDeclaredMethod (String nombre, 类 <?> ... parameterTypes)
- Obtener el nombre completo de la clase
* Cadena getName ()
public static void main(String[] args) throws Exception {
//0.获取Person的Class对象
Class personClass = Person.class;
/*
3. 获取成员方法们：
* Method[] getMethods()
* Method getMethod(String name, 类<?>... parameterTypes)
* Method[] getDeclaredMethods()
* Method getDeclaredMethod(String name, 类<?>... parameterTypes)
*/
//获取指定名称的方法
Method eat_method = personClass.getMethod("eat");
Person p = new Person();
//执行方法
eat_method.invoke(p);
Method eat_method2 = personClass.getMethod("eat", String.class);
//执行方法
eat_method2.invoke(p,"饭");
System.out.println("-----------------");
//获取所有public修饰的方法
Method[] methods = personClass.getMethods();
for (Method method : methods) {
System.out.println(method);
String name = method.getName();
System.out.println(name);
//method.setAccessible(true);
}
//获取类名
String className = personClass.getName();
System.out.println(className);//cn.itcast.domain.Person
}
-
Campo: variables miembro
* Operación:
1. Valor de ajuste
* nulo el SET (Object obj, el valor del objeto)
2. Obtiene el valor
* GET (Object obj)
3. ignora los controles de seguridad modificadores de acceso
* setAccessible (verdadero): Violencia reflexión -
Constructor: constructor
* Crear Objeto:
* T el newInstance (Objeto ... los initargs suministrado)
* Si se crea el objeto con un constructor sin argumentos vacía, la operación se puede simplificar: métodos de objeto de clase newInstance -
Método: Método de objeto
* método de ejecución:
* Objeto de la invocación (Object obj, objeto ... args)
* método de adquisición Nombre:
* Cadena getNombre: nombre del método de adquisición -
caso:
- Requisitos: Se debe anotar un "marco" y no puede cambiar ningún código en la clase de la premisa, puede ayudarnos a crear objetos de clases arbitrarias, y llevar a cabo cualquiera de los métodos
- Implementación:
1. Perfil
2. Reflector - Paso:
1. El nombre completo de la clase y crear las necesidades de objetos para llevar a cabo el método definido en el archivo de configuración
2. En el programa lee el archivo de configuración se carga
3. técnica de reflexión para cargar los archivos de clase en la memoria
4. Crear objeto
5. Ejecutar método
//pro.properties配置文件
className=cn.itcast.domain.Student
methodName=sleep
/**
* 框架类
*/
public class ReflectTest {
public static void main(String[] args) throws Exception {
//可以创建任意类的对象，可以执行任意方法
/*
前提：不能改变该类的任何代码。可以创建任意类的对象，可以执行任意方法
*/
/* Person p = new Person();
p.eat();*/
/*
Student stu = new Student();
stu.sleep();*/
//1.加载配置文件
//1.1创建Properties对象
Properties pro = new Properties();
//1.2加载配置文件，转换为一个集合
//1.2.1获取class目录下的配置文件
ClassLoader classLoader = ReflectTest.class.getClassLoader();
InputStream is = classLoader.getResourceAsStream("pro.properties");
pro.load(is);
//2.获取配置文件中定义的数据
String className = pro.getProperty("className");
String methodName = pro.getProperty("methodName");
//3.加载该类进内存
Class cls = Class.forName(className);
//4.创建对象
Object obj = cls.newInstance();
//5.获取方法对象
Method method = cls.getMethod(methodName);
//6.执行方法
method.invoke(obj);
}
}
