Mostrando entradas con la etiqueta atributos. Mostrar todas las entradas
Mostrando entradas con la etiqueta atributos. Mostrar todas las entradas

miércoles, 23 de octubre de 2013

Anotaciones en Java (Una notita para ayudarme)


Java es un lenguaje muy maduro y se ha dado a conocer por ofrecer posibilidades que otros lenguajes un poco más complejos no ofrecen, y una de las cosas que me han parecido más interesantes es la posibilidad de usar anotaciones para añadir meta-datos a un código fuente y que estos estén disponibles en tiempo de ejecución. Mediante esta herramienta es posible dejar en algunos casos de lado el uso de XML.


Okay, pero ¿Qué es una anotación?
Una anotación es una linea de código que se pone atrás de la sentencia, el método, la clase, el campo, el parámetro o el paquete al que se le quieren agregar los meta-datos, esta inicia con un carácter arroba (@) seguida de una interfaz para anotación y finalmente los parámetros de la anotación, mediante los cuales se asignan los meta-datos. Esto se ve así:

package test;

@SuppressWarnings("deprecation")
public class MiClase{

    @InicializadorDeArreglo(longitud=20,valorInicial="Hola")
    String miArreglo;

    @Override
    public void toString(){
        return "MiClase...";
    }
}

Como podemos ver en el ejemplo anterior hay dos anotaciones, una para la clase y otra para método, la primera (Linea 3) remueve las alertas generadas por código obsoleto, la segunda es una anotación creada como ejemplo y la tercera (Linea 9) se usa para especificar que un método no es propio de la clase actual, y que esta siendo reescrito (sobrecargado).

¿Y como creó mis propias anotaciones?
Una anotación no es más que una interfaz, pero tiene algo extra que permite que sea usada como anotación. veamos un ejemplo:
package test;

@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface InicializadorDeArreglo{
    int longitud();
    Object valorInicial() default null;
}

Como vemos en el ejemplo una anotación se crea de la misma manera que una interfaz, pero se usa la palabra reservada @interfaz. Además se pueden usar valores por defecto para los atributos mediante la palabra reservada default. Una de las cosas que se deben tener en cuenta a la hora de hacer una anotación es para que tipo de campos se debe poder usar, en este caso la anotación solo sera usada para atributos de clase, por eso se pone como target ElementType.FIELD. La sentencia @Retention(RetentionPolicy.RUNTIME) determina cuanto tiempo deben estar disponibles los datos de la anotación, para el caso RetentionPolicy.RUNTIME la anotación estará disponible a lo largo de toda la ejecución de la aplicación.

Muy bien, pero ¿Cómo accedo a los meta-datos?
Para aceder a los meta-datos es necesario usar Java Reflection, a continuación veremos un metodo que usa Reflection para inicializar los atributos con la anotación @InicializadorDeArreglo:

package test;


public class Inicializador{

    public static void inicializar(Object obj){
        Field[] f = obj.getClass().getDeclaredFields();
        for (Field a : f) {
            InicializadorDeArreglo i = a.getAnnotation(
                             InicializadorDeArreglo.class);
            if (i != null) {
                a.setAccessible(true);
                try {
                    String []array = new String[i.longitud()];
                    for(int it=0; it<i.longitud(); it++)
                        array[it] = i.valorInicial();
                    a.set(obj, array);
                } catch (Exception e) {
                    System.err.println("Error: " + e.getMessage());
                }
            }
        }
    }

}

Como vemos en el ejemplo lo que se hace es tomar mediante Java Reflection los atributos de la clase y filtrar aquellos que tengan un tipo especifico de anotación (lineas 9, 10 y 11), para este caso la clase de la anotación es InicializadorDeArreglo. Luego creamos el valor que sera asignado al atributo (linea 14), después se asigna el valor por defecto a cada celda del arreglo (lineas 15 y 16 ) y finalmente se asigna el valor (17). El proceso de asignación se ejecuta adentro de un try-catch para que si el tipo del atributo de destino es diferente de el valor a asignar no se detenga toda la aplicación.

Espero que les sea útil, si les ha gustado compartan y comentes, hasta una próxima publicación.

martes, 23 de julio de 2013

Entendiendo Javascript (III)


Objetos por aquí, objetos por allá, muy bonito, muy bonito, pero de que sirve esto sin la Herencia?

Herencia
Retomando, JavaScript nos provee ciertas herramientas para poder usar programación orientada a objetos, entre estas los prototipos, de esta manera podemos hacer gala de nuestras habilidades con este paradigma, pero aún hace falta una de las mas importantes herramientas, la herencia.
La herencia en JavaScript se hace al igual que las clases mediante el prototipo, pero hay dos maneras de implementarla:

Herencia Mediante Cadena de Prototipos:
Este tipo de herencia se hace mediante el uso del prototipo de los objetos, de esta manera:

// Ejemplo de Herencia por prototipos

// clase padre
function Mamifero(medio, num_extremidades, sonido){
    this.medio = medio; 
    this.extremidades = num_extremidades;
    this.saludo = function(){console.log(sonido)};
}

// clase hija
function Perro(raza){
    this.raza = raza;
}
// especificamos cual es la clase padre
Perro.prototype = new Mamifero("terrestre", 4, "Guauu, Guauu...");
fluffy = new Perro("Doberman");
fluffy.saludo()
// Fin del ejemplo

Lo que acabamos de ver se llama cadena de prototipos, y esta se basa en que una clase hija lo que hace es reemplazar su prototipo por una instancia de la clase padre, por esto se hace la asignación de una instancia de la clase padre al prototipo como vemos en la linea 15.

Herencia mediante llamado al Constructor del Padre:
Este tipo de herencia hace uso del constructor de la clase padre de manera directa, se hace así:
// Ejemplo de Herencia por prototipos

// clase padre
function Mamifero(medio, num_extremidades, sonido){
    this.medio = medio; 
    this.extremidades = num_extremidades;
    this.saludo = function(){console.log(sonido)};
}

// clase hija
function Gato(raza){
    Mamifero.call(this,"terrestre", 4, "Miauu, Miauu...");
    this.raza = raza;
}
// insatancia de la clase
jack = new Gato("Angora")
jack.saludo()
// Fin del ejemplo

Lo que acabamos de ver fue otra manera de usar herencia en JavaScript, esta es más interesante por que encapsula todo dentro del mismo bloque de código. Lo que se está haciendo es que se llama el constructor de la clase padre pero se especifica que los atributos y métodos de la clase padre deben ser establecidos en la clase actual, lo anterior se lleva a cabo mediante el método call, usado en la linea 12, el cual recibe como primer parámetro la referencia al objeto en construcción.

lunes, 15 de julio de 2013

Entendiendo Javascript (II)


Ya en el articulo anterior entendimos un poco mejor que es JavaScript, ahora ya es necesario aclarar muchas de las cosas maravillosas que podemos hacer con este lenguaje.

Prototipos
Debemos recordar que en JavaScript es un lenguaje basado en prototipos, es decir, el no crea instancias de objetos, en vez de esto clona un objeto que usamos como nos sea conveniente, pero ¿Como como crear una clase con JavaScript?. Para esto podríamos tener en cuenta la siguiente tabla:

Programación Orientada a Objetos Programación mediante Prototipos
Objeto Prototipo
Atributo Variable
Metodo Función

Aun así no queda muy claro donde y como hacer un prototipo, para esto debemos tener en cuenta que todo objeto creado en JavaScript por defecto tiene un atributo llamado prototype, para poder entender como se usa veamos el siguiente ejemplo:

/* Ejemplo de prototipo */
function Automovil(nombre, modelo){
    this.nombre = nombre;   // este es un atributo
    this.modelo = modelo;   // este es otro atributo
    // la palabra reservada this hace que la variable
    // pertenezca al contexto de la función que
    // representa la clase, si no se usa la variable es local
    // y desaparece al terminar la ejecución de la función.
}
Automovil.prototype.encender = function(){ // uso de prototype
    console.log("run, run..."); // escribimos un mensaje en consola
}

// ejemplo de creacion de un objeto
auto = new Automovil("BMW","X6"); // la palabra new clona el objeto
auto.encender(); // llamado del metodo encender
/* Fin del Ejemplo */