Hola a todos:
El motivo de usar getter y setters para acceder a variables internas de una
clase, no es mas que cumplir con las bases de la encapsulaci�n.
Una norma dentro de la encapsulaci�n es que todo clase que acceda a otra, no
debe saber mas que una interfaz de uso b�sica, obligando a desconocer el
contenido interno de la clase o su funcionamiento.
Esto garantiza el bajo acoplamiento entre clases, una explicaci�n sobre el
concepto de acoplamiento est� en el post de www.code4net.com
llamado "Patrones?".
El acoplamiento, en resumen, es una manera de medir que conocimiento de una
clase ha de tener otra para poder usarla. Lo ideal en la programaci�n
orientado a objetos es que siempre haya el mas bajo acoplamiento posible entre
clases, de manera que usando un juego de m�todos fijo se permita la
utilizaci�n del objeto sin necesidad de conocer m�s, por ello el control de
acceso a propiedades, si una clase tiene acceso a las propiedades de otra,
esto obliga a que cualquier modificaci�n en la clase, tenga que llevarse a la
otra clase, aparte est�, claro, la validaci�n de datos dentro de una clase, de
manera que podemos, usando getter y setters, avalar la consistencia de datos,
adem�s, si dentro de la clase que tiene getter y setter se modifica "la
apariencia interna de los datos", controlas la devoluci�n de los mismos
igualandolos a la anterior representaci�n.
Imaginemos como ejemplo una clase Tiempo, esta sin comentar por que no tengo
mucho tiempo:
<code>
Tiempo = function (hora, minuto, segundo) {
this.estableceHora(hora, minuto, segundo);
};
Tiempo.prototype.estableceHora = function(hora, minuto, segundo) {
if (hora<24 && hora>0)
{
this.$hora = hora;
}
else
{
this.$hora = 0;
}
if (minuto<60 && minuto>0)
{
this.$minuto = minuto;
}
else
{
this.$minuto = 0;
}
if (segundo<60 && segundo>0)
{
this.$segundo = segundo;
}
else
{
this.$segundo = 0;
}
};
Tiempo.prototype.getHoraUniversal = function() {
if (this.$hora<10)
{
var texto = "0"+this.$hora+":";
}
else
{
var texto = this.$hora+":";
}
if (this.$minuto<10)
{
texto += "0"+this.$minuto+":";
}
else
{
texto += this.$minuto+":";
}
if (this.$segundo<10)
{
texto += "0"+this.$segundo;
}
else
{
texto += this.$segundo;
}
return texto;
};
Tiempo.prototype.getHoraEstandard = function() {
if (this.$hora == 0 || this.$hora == 12)
{
var texto = 12+":";
}
else
{
var texto = (this.$hora%12)+":";
}
if (this.$minuto<10)
{
texto += "0"+this.$minuto+":";
}
else
{
texto += this.$minuto+":";
}
if (this.$segundo<10)
{
texto += "0"+this.$segundo;
}
else
{
texto += this.$segundo;
}
if (this.$hora<12)
{
texto += " AM";
}
else
{
texto += " PM";
}
return texto;
};
prueba = new Tiempo(10, 13, 6);
trace(prueba.getHoraUniversal());
trace(prueba.getHoraEstandard());
</code>
Y ahora una clase Fecha, que usa la clase tiempo.
<code>
Fecha = function (dia, mes, anio, hora, minuto, segundo) {
this.estableceFecha(dia, mes, anio, hora, minuto, segundo);
};
Fecha.prototype.estableceFecha = function(dia, mes, anio, hora, minuto,
segundo) {
if (mes>1 && mes<12)
{
this.$mes = mes;
}
else
{
this.$mes = 1;
}
this.$anio = anio;
this.$dia = this.verificaDia(dia);
this.$hora = new Tiempo(hora, minuto, segundo);
};
Fecha.prototype.verificaDia = function(dia) {
var diasPorMes = new Array(0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31,
30, 31);
if (dia>0 && dia<=diaPorMes[this.$mes])
{
return dia;
}
if (this.$mes == 2 && dia == 29 && (this.$anio%400 == 0 || this.$anio%
4 == 0 && this.$anio%100 != 0))
{
return dia;
}
return 1;
};
Fecha.prototype.getUniversal = function() {
var mes = new Array
(0,"Enero", "Febrero","Marzo","Abril","Mayo","Junio","Julio","Agosto","Septiemb
re","Octubre","Noviembre","Diciembre");
var texto = this.$dia+" de "+mes[this.$mes]+"
de "+this.$anio+" "+this.$hora.getHoraUniversal();
return texto;
};
Fecha.prototype.getEstandard = function() {
var texto =
this.$dia+"/"+this.$mes+"/"+this.$anio+" "+this.$hora.getHoraEstandard();
return texto;
};
prueba = new Fecha (22,2,2003);
trace (prueba.getEstandard());
trace (prueba.getUniversal());
</code>
Si despues quisieramos almacenar tanto la clase tiempo, como la clase fecha en
milisegundos para ahorrar memoria en variables internas, s�lo tendriamos que
cambiar la implementaci�n interna, mientras que nuestras clases que la
utilizan, no deben cambiar en nada. (La implementaci�n en milisegundos se la
dejo a alguien que tenga ganas).
Evidentemente en proyectos peque�os, quiz�s no sea necesario.
Pero si nuestras clases son algo complejas internamente y tenemos clases
relaccionadas, cualquier modificaci�n en un futuro medio lejano, nos obliga
primero a recordar que clases enlazaban con ella, y desde luego, como lo hacia
para poder modificar tambi�n todas las clases que la utilizan. Si adem�s,
creas clases con el afan de reutilizarlas en tus proyectos, lo recomendable es
un bajo acoplamiento de todas ellas.
Sixto
-------------------------------------------------
This mail sent through IMP: http://horde.org/imp/
<!-------------------------------
Lista ASNativos:
subscripciones/desubscripciones
http://www.sidedev.net/asnativos
-------------------------------->
