Programación Orientada a Objetos

es posible que este tema no vaya aquí así que os pido al goblal que me corrija sino

En este post les enseñare como aprender a programar orientado a objetos es muy fácil:

Comencemos por reconocer que para quienes venimos de la programación funcional es bastante difícil digerir los nuevos conceptos, por la sencilla razón de que estamos acostumbrados a la idea de que las entidades del mundo real que tratamos de modelar en nuestros programas son representadas por un conjunto de datos relacionados con las características de estas entidades (relevantes para nuestras aplicaciones), y simplemente escribimos instrucciones que actúan sobre estos datos para realizar cálculos, ordenaciones, almacenamiento/recuperación, etc. Resumiendo podríamos decir que un programa es algo representado en esta pequeña ecuación:


Para ilustrar esta idea me remonto a la época en la que programábamos en BASIC. Uno de los primeros programas que escribimos debe haber sido algo tan simple como esto:




En este pequeño programa, que calcula el Area de un Triángulo cualquiera, podemos ver:

Los datos (modelos de las características que nos interesan del Triángulo) son las variables H, B (dimensiones) y A (área).

La instrucción que realiza el cálculo es: LET A = (H * B) / 2.

Adentrándonos más en el conocimiento de aquella versión de este lenguaje aprendimos que era posible crear subrutinas que hacían algún trabajo especial sobre los datos, dentro de una comunidad donde todo el mundo se conocía (datos y rutinas), y se esperaba que todas estos conjuntos de instrucciones tuvieran siempre el mejor comportamiento, y que futuras modificaciones no crearan problemas en lo anteriormente desarrollado (pero el tiempo demostró que los problemas sí surgieron y el código se complicó muchas veces hasta extremos intolerables).

Por otro lado, podemos ver que aun cuando el programa hace el trabajo de calcular correctamente el área, el concepto de Triángulo realmente no existe en el mismo. Sólo suponemos que estamos calculando el Area de un Triańgulo cualquiera dadas su Altura y su Base.

- o -


Si avanzamos un poco en el conocimiento de los lenguajes de programación de alto nivel tenemos a Pascal. Una de las herramientas que nos proveía este lenguaje era la de los datos estructurados, entre los cuales había un elemento que permitía crear un conjunto de datos asociados a un concepto (un record o registro), elevando el nivel de modelado de la realidad.

Así, mediante su uso, nos sería posible mejorar un tanto este pequeño programa de cálculo de promedio de Area, introduciendo (al menos en lo que respecta a datos) el concepto de lo que es un Triángulo. El código (en Pascal) podría ser:




En el inicio de este segundo programa podemos ver la definición del tipo TTriangulo,

type

TTriangulo = record

altura : real;

base : real;

end;

que tiene asociadas las características relevantes de un triángulo, para efectos de nuestra aplicación: Altura y Base. Ahora podemos crear una variable Triangulo, del tipo TTriangulo anteriormente definido, además de otra variable Area para almacenar el resultado del cálculo.

var

Triangulo : TTriangulo;

Area : real;

Seguidamente tenemos una rutina que tomando nuestro triángulo solicita al usuario del programa la altura y la base para poder calcular el área.

procedure LeerDatos(var triang : TTriangulo);



Luego tenemos la rutina que, tomando nuestro triángulo, calcula el área dadas la altura y la base, y devuelve el valor calculado

function CalcularArea(var triang : TTriangulo) : real;

Finalmente tenemos el cuerpo principal del programa, que llama las rutinas LeerDatos y CalcularArea, y les envía el triángulo para que realicen su trabajo

LeerDatos(Triangulo);

Area := CalcularArea(Triangulo);

Si comparamos este código con el del programa en aquella vieja versión de BASIC, podemos ver que en Pascal es posible colocar en el programa el concepto de Triángulo (al menos en lo que respecta a datos). No obstante, aún tenemos que escribir rutinas externas con respecto al concepto, pero que pueden trabajar sobre el mismo para capturar los datos esenciales y realizar el cálculo para el que ha sido diseñado el programa. Esto nos permitiría elaborar una nueva ecuación, parecida a la que vimos al inicio, pero con un nuevo nivel de abstracción:


Yendo un poco más allá en este paradigma, la idea era crear montones de rutinas de carácter más o menos general que pudieran incluso ser reutilizadas en otras aplicaciones que desarrolláramos a futuro. Estas constituirían librerías de rutinas atesoradas en nuestros “cofres” de programadores. Por otro lado, los conceptos apoyados en el uso de los records (un Triángulo en este caso) proveían una forma de proteger los datos decidiendo cómo y cuándo pasarlos a las rutinas para que actuaran sobre ellos.

- o -


La experiencia con el mundo de los objetos llegó a través de Visual Basic, pero no acerca de crear objetos sino de utilizarlos. Con Visual Basic empezamos a notar las grandes ventajas que ofrecía el uso de propiedades y métodos de objetos como formularios, botones, cajas de texto, etc. Sin embargo, aún no entendíamos los conceptos básicos de la programación orientada a objetos, ni para qué realmente servía.

Lecturas iban y venían, indecisiones sobre lenguajes (si C++ o Java), pero el camino de Pascal llevó a Object Pascal, y a Delphi. Entonces decidimos trabajar de acuerdo a la ecuación que acabamos de ver (programa = datos estructurados + rutinas), usando punteros también; pero las otras estructuras de datos asociadas a los elementos visuales (treeviews, listboxes, combos, etc.) forzaban el cambio de paradigma al mundo de los objetos, y, por supuesto, había que crear objetos.

Llegado a este punto (no pudiendo resistir más los vientos de cambio) nos adentramos en el estudio del tema de los objetos: encapsulación, herencia, polimorfismo, patrones, y un largo etc.

Entonces, ¿qué son objetos?

Como hemos venido viendo en esta breve evolución, en la prehistoria -de la programación de alto nivel-, con BASIC, los datos y las instrucciones estaban “sueltos” en el programa (aunque en nuestra mente formaran una unidad); luego en la Edad Media, con Pascal, vimos que era posible incluir conceptos en los programas que, al menos en datos, formaban elementos que modelaban mejor sus contra-partes del mundo real, pero aún escribíamos rutinas externas que actuaban sobre y/o con los datos. Asimismo vimos cómo pasamos de tener un “campo abierto”, sin fronteras que protegieran a los datos de instrucciones que crearan problemas, a un nivel básico de protección con el uso de tipos record. Bien, en la Edad Moderna los objetos, esencialmente constituyen la unión de datos y rutinas dentro de un concepto, en un nivel de abstracción más elevado. Un objeto representa de manera bastante fiel a un elemento del mundo real (físico o no), conteniendo en sí mismo los datos correspondientes a las características relevantes de tal elemento y a las rutinas que actúan sobre estos datos para realizar el trabajo encomendado al programa. Adicionalmente a esto, los datos asociados al concepto generalmente están protegidos dentro del mismo, y es posible definir formas de acceso a estos de manera que sean leídos y/o modificados sus valores. Se dice entonces que los datos están encapsulados dentro del objeto y que los accesos constituyen la interfaz del mismo, para efectos de comunicación con el exterior.



Comparando esta idea con un reproductor de video, la interfaz pública está constituida por los botones en la carcasa del aparato, y en el control remoto, a través de los cuales nos es posible iniciar o parar la reproducción, adelantar o atrasar segmentos, etc, sin tener en ningún momento que tocar cables o circuitos (la implementación).

Ahora bien, ¿qué es elaborar un programa orientado a objetos?, o, ¿cómo creamos los objetos que necesitamos para modelar el mundo real?

Acá entra el concepto de Clase. Cuando escribimos un programa orientado a objetos en lenguajes como Object Pascal, C++, Java, C#, etc., diseñamos y definimos clases que permiten crear luego los objetos, que son instancias (ejemplos) de esas clases. Una clase es una especie de molde del cual podemos extraer objetos que tendrán por supuesto la forma del molde (características o datos, y operaciones) pero que serán distintos unos de otros, con su propia identidad.




De hecho, un Objeto tiene un Estado el cual es simplemente el conjunto de valores de sus características (datos). Por ejemplo, en la Clase L de la ilustración habríamos definido una característica llamada Color, la cual tendría el valor “amarillo” en el primer Objeto L; y, “azul” en el segundo. Una operación (o método de comportamiento) podría ser CambiarColor, la cual, por ejemplo, nos mostraría una forma de seleccionar el nuevo color.

Ahora veamos todo esto en acción en la versión orientada a objetos de nuestro programa que calcula el área de un triángulo:




En este código (escrito en C#, el lenguaje de programación creado por el mismo autor principal de Turbo Pascal y Delphi) encontramos primero la definición de la Clase Triángulo, la cual comienza con la palabra clave class seguida del nombre de la clase, es decir Triangulo.

class Triangulo {

Seguidamente está la lista de datos que modela las características relevantes del elemento Triangulo de la vida real. Esto es sus dimensiones y su área

private double ancho;

private double altura;

private double area;

La palabra private indica que los datos son privados, es decir que están protegidos dentro del objeto y no es posible tener acceso a ellos desde el código cliente.

Sin embargo, luego viene la definición de los métodos de acceso a estos datos, a través de las Propiedades correspondientes: Altura, Ancho y Area.

public double Altura {

get {

return this.altura;

}

set {

altura = value;

}

}

public double Ancho {

get {

return this.ancho;

}

set {

ancho = value;

}

}

En el caso de Altura y Ancho los elementos get y set indican cómo es posible leer y escribir los datos protegidos. La sección get contiene la instrucción return this.altura / return this.ancho, la cual indica que devuelve el valor del dato altura/ancho del elemento this, que es la palabra que identifica a un objeto cualquiera de la clase que estamos programando (en este caso Triangulo). Por otro lado, la sección set contiene la instrucción altura = value / ancho = value, siendo el elemento value la representación del valor que escribimos en el dato altura/ancho. Entonces si escribimos, por ejemplo, una sentencia a = unTriangulo.Altura, realmente se ejecutará dentro del código de la clase la instrucción return this.altura, que nos devolverá el valor de la altura del Triangulo y lo asignará a la variable a. Por otro lado, si la sentencia es unTriangulo.Altura = 5, el valor 5 será asignado a la variable value, la cual a su vez lo asignará al dato altura dentro de la clase a través de la instrucción altura = value.

public double Area {

get {

return this.area;

}

}

Para el dato area la definición de la propiedad Area (en C++, Java y C# los nombres son sensibles a mayúsculas y minúsculas, por lo tanto area no es lo mismo que Area) solamente tiene la sección get, lo cual indica que sólo es posible leer el valor del dato más no modificarlo.

public void CalcularArea() {

this.area = (this.ancho * this.altura) / 2;

}

El valor del dato area es obtenido mediante la llamada a la operación CalcularArea. Esta operación, o Método de la clase Triangulo, actúa tomando los valores de las dimensiones ancho y altura, multiplicándolos y dividiéndolos entre 2, como hemos visto en las versiones BASIC y Pascal de este mismo programa, pero con la salvedad de que no se trata de una rutina externa al concepto de triángulo sino que pertenece a la representación de este concepto, es parte de nuestra definición del concepto dentro del programa.


Finalmente tenemos la clase principal del programa, class MainClass, que tiene dos rutinas o métodos: LeerDatos(Triangulo triang) y Main (string[] args). El primero toma el objeto Triangulo y solicita al usuario las dimensiones del mismo (parecido a la rutina que vimos en la versión en Pascal, sólo que aquella no pertenecía a clase alguna sino que era un elemento “suelto” dentro del programa principal). El segundo método (Main) es el inicio de la aplicación. Lo primero que hace es crear una instancia de la clase Triangulo sobre la cual trabajar. Esto lo realiza mediante la sentencia

Triangulo unTriangulo = new Triangulo()

Una vez que se tiene la instancia creada se procede a invocar el método que solicita las dimensiones del triángulo mediante

LeerDatos(unTriangulo)

A continuación se invoca al método del objeto que efectúa el cálculo a través de la sentencia

unTriangulo.CalcularArea()

la cual a su vez ejecuta la instrucción

this.area = (this.ancho * this.altura) / 2

definida en la clase.

Por último se muestra el resultado mediante el acceso al dato privado area que provee la propiedad Area del objeto

Console.WriteLine(“El area es: {0}”, unTriangulo.Area)

Analizado este código, podemos crear nuevas ecuaciones, con niveles superiores de abstracción que las anteriormente vistas

(programa = datos + instrucciones y programa = datos estructurados + instrucciones)



Siguiendo este nuevo paradigma la idea es diseñar y programar clases cuyas instancias (objetos) sean representación de sus contra-partes del mundo real de acuerdo a lo que intentamos modelar. Sin embargo, aun cuando la programación orientada a objetos provee herramientas para crear aplicaciones robustas y fáciles de mejorar, no es algo mágico que resuelve todos los problemas sin esfuerzo. En sí la programación de aplicaciones no es una actividad trivial: requiere de estudio, práctica y mucha imaginación. No todos los programadores hacemos las cosas de la misma manera y no todo el conocimiento y la experiencia personal conforman algo inmutable, sino que siempre es posible aprender y/o desarrollar mejores formas de crear aplicaciones. Eso es lo que hace esta actividad algo tan fascinante y gratificante cuando vemos nuestras creaciones funcionando y resolviendo problemas.


Milaras21