Listado de la categoría: Java

El siguiente articulo es el primero de una serie de artículos en donde intentare expresar un conjunto de ideas de una arquitectura de aplicación que nos permita con el tiempo crear proyectos de software robustos. Para conseguir este objetivos tendremos que ver primero algunos tópicos avanzados en Java.

 

Accediendo a la información de la clase

El método getClass() se encuentra definido en Object como un método final, dicho método devuelve una representación en tiempo de ejecución de la clase del objeto sobre el cual podemos acceder a una serie de caracteristicas del objeto por ejemplo: el nombre de la clase, el nombre de su superclase y los nombres de los interfaces que implementa.

Mostrando el nombre de la clase

Observe el siguiente código de la clase PruebaNombre.java:

public class PruebaNombre {
	public String nombreClase() {
		return this.getClass().getSimpleName();
	}
	public static void main(String[] args) {
		PruebaNombre prueba = new PruebaNombre();
		System.out.print(prueba.nombreClase());
	}
}

Al ejecutar nos imprime PruebaNombre el cual es el nombre simple para la clase en cuestión, lo importante aquí es que accedemos a la clase por medio de this.getClass() y de ahí accedemos al nombre de la clase con el método getSimpleName, que es lo que devolvemos.

Accediendo a atributos

Ahora por medio de getClass vamos a crear un método para acceder a los atributos existentes en la clase para imprimir el nombre y valor de cada atributo:

import java.lang.reflect.Field;
public class PruebaAtributos {
	String atributo_1 = "valor 1";
	String atributo_2 = "valor 2";
	String valor_x = null;
	
	public void imprimirAtributos() {
		Field[] fields = this.getClass().getDeclaredFields();
		for(Field field : fields) {
                try {
                	String fieldName = field.getName();
                	Object fieldValue = field.get(this);
					System.out.println(fieldName + ":" + fieldValue);
				} catch (IllegalArgumentException | IllegalAccessException e) {
					e.printStackTrace();
				}
            }
	}
	public static void main(String[] args) {
		PruebaAtributos prueba = new PruebaAtributos();
		prueba.imprimirAtributos();
	}
}

En este caso el resultado del código es el siguiente:

atributo_1:valor 1
atributo_2:valor 2
valor_x:null

Accediendo al constructor, creando elementos dinámicos

Desde la instancia de clase también podemos acceder a los constructores de clase, para a partir de estos crear una nueva instancia dinámica del objeto en cuestión, observe el siguiente código:

import java.lang.reflect.InvocationTargetException;

public class PruebaNewInstance {
	public String atributo_1 = "valor default";
	/**
	 * Constructores normales
	 * 
	 * @param atributo_value
	 */
	public PruebaNewInstance(String atributo_value){
        this.atributo_1 = atributo_value;
    }
	public PruebaNewInstance(){}
	/**
	 * Devuelve una instancia de PruebaNewInstance dinamica a partir de un constructor con atributos
	 * @param atributo_value
	 * @return
	 */
	static public PruebaNewInstance constructor(String atributo_value) {
		try {
			return PruebaNewInstance.class.getConstructor(String.class).newInstance(atributo_value);
		} catch (InstantiationException | IllegalAccessException
				| IllegalArgumentException | InvocationTargetException
				| NoSuchMethodException | SecurityException e) {
			e.printStackTrace();
		}
		return null;
	}
	/**
	 * Devuelve una instancia de PruebaNewInstance dinamica a a patir del constructor vacio
	 * 
	 * @return
	 */
	static public PruebaNewInstance constructor() {
		try {
			return PruebaNewInstance.class.newInstance();
		} catch (InstantiationException | IllegalAccessException
				| IllegalArgumentException | SecurityException e) {
			e.printStackTrace();
		}
		return null;
	}

	public static void main(String[] args) {
		PruebaNewInstance prueba = new PruebaNewInstance("valor_atributo_1");
		System.out.println(prueba.atributo_1);
		// Creando un objeto desde un constructor dinamico
		PruebaNewInstance prueba2 = PruebaNewInstance.constructor("val_atrib_1 constructor Dinamico");
		System.out.println(prueba2.atributo_1);
		//
		PruebaNewInstance prueba3 = PruebaNewInstance.constructor();
		System.out.println(prueba3.atributo_1);
	}
}

El resultado del código anterior es:

valor_atributo_1
val_atrib_1 constructor Dinamico
valor default

Código completo

Dejo un enlace del código en cuestión: [ PruebaGetClass.java ]

Conclusiones

¿Se te ocurre algunas formas de utilizar estas características del lenguaje java?, bien esto lo podríamos utilizar para p.e. acceder a los nombres y atributos y a partir de esto realizar determinadas acciones.

¿Para donde vamos?

Podríamos crear un objeto abstracto Model el cual podría servir como un objeto persistencia del cual podríamos heredar en otros objetos p.e. PersonasModel debería de conectar a la tabla personas, también podríamos agregar atributos como prmary_key y a partir de estos valores realizar consultas SQL como INSERT, UPDATE, SELECT.