Un compañero, no hace mucho, mientras le explicaba una refactorización que había propuesto para el código de unas modificaciones que se estaban haciendo en un determinado Proyecto, me recordó una refactorización que se había perdido por el baúl de mis recuerdos: "Introducir objetos nulos".
Esta refactorización tiene su aplicación cuando realizamos verificaciones del tipo:
for (Producto producto:compra) {
if (producto != null) {
precio += producto.getPrecio();
}
}En estos casos, puede ser preferible introducir una clase ProductoNull y aprovechar el polimorfismo:
class ProductoNull extends Producto {
...
public Double getPrecio() {return new Double(0);}
...
}De esta manera, el código original nos quedaría:
for (Producto producto:compra) {
precio += producto.getPrecio();
}Lo cual es un código mucho más 'limpio', ¿no te parece?
El código es más limpio. Sin embargo no se me ocurre un caso donde metas objetos nulos en una lista de la compra. Podrías poner otro ejemplo?
ResponderEliminarSaludos. :)
Hola Raúl,
ResponderEliminarNo lo llego a entender del todo, si pudieras explicar con otro ejemplo, sería genial.
Saludos desde Perú.
Hola "Su Antidad",
ResponderEliminarMás que un ejemplo donde se están metiendo objetos nulos en una lista de la compra, piensa que estos objetos nulos se metieran en dicha lista como resultado de borrar un producto... es como si nos hacemos una lista de la compra en un papel:
· patatas
· huevos
· XXXXXXXXXXX (se ha tachado "filetes")
· tomates
· XXXXXXXXXXX (se ha tachado "naranjas")
· fresas
Esos elemento que en el papel 'tachamos', al pasarlo a código podría optarse, por ejemplo, por insertar en dicha posición de la lista un objeto nulo...
De todas formas piensa que esto es sólo un ejemplo 'tonto', voy a ver si se me ocurre otro más cercano a la realidad [guiño]
Luis Miguel, no creas que me había olvidado de ti. Te pongo otro ejemplo:
ResponderEliminarImagina que tenemos una factoría que, a partir del identificador de un tipo de datos, nos retorna una clase para gestionar dicho tipo de datos, si dicho tipo de datos está dentro de un conjunto de tipos soportado:
class Factoria {
public Manejador getManejador(String idTipo) {
Manejador retorno = null;
if (manejadores.getKey(idTipo)) {
retorno = manejadores.get(idTipo);
}
return retorno;
}
}
Esta factoría la podríamos usar, por ejemplo:
Manejador manejador;
for (Elemento elemento:elementos) {
manejador = factoria.getManejador(elemento.getIdTipo);
if (manejador!=null) {
manejador.pinta(elemento);
}
}
Si te fijas, si en vez de que la factoría retorne null cuando no hay un manejador, retorna un 'objeto nulo' (una instancia de un manejador por defecto que no haga nada), el código anterior nos quedaría como:
Manejador manejador;
for (Elemento elemento:elementos) {
manejador = factoria.getManejador(elemento.getIdTipo);
manejador.pinta(elemento);
}
Con lo que habríamos eliminado una condición (un if) innecesaria.
Pero es que además, en este caso, incluso podríamos simplificar (limpiar) más el código:
for (Elemento elemento:elementos) {
factoria.getManejador(elemento.getIdTipo).pinta(elemento);
}
¡Saludos!
Hola Luis Miguel, no te creas que me había olvidado de ti, el problema es que un comentario que había subido parece que se perdió (parece que la semana pasada hubo problemas aquí en 'blogger')... te pongo otro ejemplo:
ResponderEliminarImagina que tenemos una factoría que nos permite obtener instancias de objetos 'manejadores' para tratar unos objetos de unos 'tipos' determinados:
class Factoria {
HashMap manejadores = ...;
getManejador(String idTipo) {
//si idTipo == null o idTipo no está mapeada retornará 'null'
return = manejadores.get(idTipo);
}
}
En cada lugar del código donde queremos manejar una colección de objetos, haríamos algo parecido a esto:
Manejador manejador = null;
for (Objeto objeto:objetos) {
manejador = factoria.getManejador(objeto.getIdTipo());
if (manejador!=null) {
manejador.maneja(objeto);
}
}
Sin embargo, si la factoría se prepara para retornar un objeto nulo, en vez de 'null' cuando no tenga mapeado un determinado 'idTipo', el anterior código nos quedaría:
for (Objeto objeto:objetos) {
factoria.getManejador(objeto.getIdTipo()).maneja(objeto);
}