-Java basada reflexión y nueve clases internas anónimas

Como reflejo de diseño del marco es el alma
(previos La: obtenido debe ser representativa del código de bytes de clase, clase de clase se utiliza para representar los archivos .class (bytecodes))

Una visión general de reflexión

clase es la raíz de toda reflexión, el mecanismo de reflexión de Java está en el estado de funcionamiento, por cualquier y una clase, por la reflexión puede conocer todas las propiedades y métodos de esta clase; para cualquier objeto, son capaces de llamar a cualquiera de sus métodos y propiedades ; adquirido información reflexión, y este objeto llamada de función dinámica en movimiento método llamado lenguaje java
con el fin de la anatomía de una clase, primero debe obtener el código de bytes clase de objeto de archivo. Clase es el método utilizado por la clase de anatomía. Clase adquirió así primero cada tipo de objeto correspondiente al archivo de código de bytes.
I es sencillo de entender y clase clase Métodos transferido directamente por una cadena.

acto reflejo

Al acceder reflectantes propiedades, métodos y otros métodos de construcción objeto de Java

Reflexión mecanismo de Clase

Clases de Java asociados con el reflejo de la siguiente manera:

El nombre de la clase	uso
clase	En nombre de la clase de entidades en una aplicación Java que se ejecutan representar clases e interfaces
clase Field	En nombre de las variables miembro de clase (también conocido como variables miembro del atributo de clase)
clase de método	Método representa una clase de
constructor de clase	constructor de la clase representativa

Nota: subclase de la clase Object

El mecanismo básico de la reflexión

: Posible "nombre de cadena completo de la clase" Según una, la representación de la clase de la clase de objeto, entonces construye una instancia de un objeto real de esta clase de acuerdo con la clase de objeto
Class.forName disponible ( "clase nombre de paquete") método para dar una Clase categoría

String className = "cn.edu360.javase24.reflect.demo.SerivceOne";  // 通常这个字符串常常存在文件当中，用io流调用
Class<?> forName = Class.forName(className);   // 根据类名字符串“SerivceOne”获取class对象
SerivceOne o = (SerivceOne)forName.newInstance();  // 用class对象构造出这个类SerivceOne的实例对象
o.say();

A continuación, la reflexión se utiliza a menudo en las interfaces
como aquí tenemos una cogida interfaz, así como su clase de implementación FuckImpl, luego accedió a completar la clase de implementación nombre del paquete Parada en un archivo.
Entonces llamamos a esta interfaz cuando lo que puede

public class Menu {
	
public static void main(String[] args) throws Exception {

	// 从约定的文件中读取所需类的实现类全名
	BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("f:/a.txt")));
	String ClassName = br.readLine();   /将文件中的按行包名输出
	
	Class<?> forName = Class.forName(ClassName); // forName代表的是serviceClassName字符串所指定的类的类class模板
	
	// 根据类全名构造这个service实现类的实例
	Fuck fuck = (Fuck) forName.newInstance();`}}

En tercer lugar, el constructor de la clase adquirida por reflexión, propiedades y métodos

Class<?> forName = Class.forName(ClassName);
	
	// 根据类全名构造这个service实现类的实例
	Fuck fuck = (Fuck) forName.newInstance();`
	//methodName存的是方法名的字符串，从forName这个class模板中获取到指定的方法
	Method method=forName.getMethod(methodName) ;
	//让Method在对象上执行，（）中写对象和参数
	Object invoke=method.invoke(fuck,12);

-------------------------------------------------------------------------
//如果存在同名方法,则有参数的需要这样输入
   	Method method2=forName.getMethod(methodName,String.Class) ;
   	Object invoke=method.invoke(fuck,12);

Los usos del archivo de configuración aparatos Properties ()

El principal método de Propiedades

(1) carga (InputStream in-stream)

Este método se puede corresponder con el atributo de los .properties flujo de entrada de archivos, cargar la lista de la propiedad objeto de la clase de las propiedades. El siguiente código:

Properties pro = new Properties();
FileInputStream in = new FileInputStream("a.properties");
pro.load(in);
in.close();

(2) Tienda (OutputStream a cabo, los comentarios de Cuerda)

Este método guarda la lista de los atributos de clase de objeto Propiedades de la secuencia de salida. El siguiente código:

FileOutputStream oFile = new FileOutputStream(file, "a.properties");
pro.store(oFile, "Comment");
oFile.close();

Si los comentarios no están vacías, excepto los atributos de archivo primera línea es #comentarios, representa la información de comentario, y si no hay comentario está vacía.

anotación de información está detrás de la hora actual Guardar archivo de propiedades.

(3) getProperty / setProperty

Estos dos métodos se obtienen, respectivamente, e información de propiedad conjunto.

Carga y reflexión propiedades de los perfiles

Properties props = new Properties();
//加载xx.properties属性配置文件
props.load(Test.class.getClassLoader().getResourceAsStream("xx.properties"));
//取配置参数
String value = props.getProperty("key");
	
	Class<?> forName = Class.forName(value); // forName代表的是serviceClassName字符串所指定的类的类class模板
	
	// 根据类全名构造这个service实现类的实例
	Fuck fuck = (Fuck) forName.newInstance();`

A continuación, debe establecer *** *** archivo directamente con un paquete de
contenido es
en forma de clave = valor

ClassName=fuckMan
Method=fuck

clases internas anónimas

Anónimo clases internas es el nombre de la clase interna

Debido a que no hay ningún nombre, por lo que las clases internas anónimas sólo se pueden utilizar una vez, por lo general se utiliza para simplificar la escritura de código

Sin embargo, el uso de clases internas anónimas existe un requisito previo: debe heredar de una clase padre o implementar una interfaz
Ejemplo 1: no utilice las clases internas anónimas para implementar los métodos abstractos

abstract class Person {
    public abstract void eat();
}
 
class Child extends Person {
    public void eat() {
        System.out.println("eat something");
    }
}
 
public class Demo {
    public static void main(String[] args) {
        Person p = new Child();
        p.eat();
    }
}

Resultados de operación: comer algo

Se puede ver que hemos heredado con la clase de persona Niño, y luego implementar una instancia del Niño, que upcast referencia a la clase Persona

Sin embargo, si la clase hijo Aquí se usa sólo una vez, a continuación, se escribe como una categoría separada no sería un problema?

Esta vez en la introducción de clases internas anónimas

Ejemplo 1: no utilizar las clases internas anónimas para implementar los métodos abstractos

abstract class Person {
    public abstract void eat();
}
 
class Child extends Person {
    public void eat() {
        System.out.println("eat something");
    }
}
 
public class Demo {
    public static void main(String[] args) {
        Person p = new Child();
        p.eat();
    }
}

Resultados de operación: comer algo
se puede ver, hemos heredado clase de persona Niño, y luego implementar una instancia del Niño, que upcast referencia a la clase Persona

Sin embargo, si la clase hijo Aquí se usa sólo una vez, a continuación, se escribe como una categoría separada no sería un problema?

Esta vez en la introducción de una clase interna anónima
Ejemplo 2: clase interna básicamente anónimo

abstract class Person {
    public abstract void eat();
}
 
public class Demo {
    public static void main(String[] args) {
        Person p = new Person() {
            public void eat() {
                System.out.println("eat something");
            }
        };
        p.eat();
    }
}

Resultados de operación: comer algo
se puede ver, que en el método directo implementos persona de clase abstracta entre llaves

De manera que se puede omitir una clase de escritura

Además, las clases internas anónimas también se pueden utilizar en la interfaz

Ejemplo 3: clases internas uso anónimo en la interfaz

interface Person {
    public void eat();
}
 
public class Demo {
    public static void main(String[] args) {
        Person p = new Person() {
            public void eat() {
                System.out.println("eat something");
            }
        };
        p.eat();
    }
}

Resultados de operación: comer algo