01Curso OO Objetos ObjetosYEstructurado

Curso de OO dirigido por Objetos y Estructurado, dos pensamientos distintosla introducción de ambigüedad

1. Objetos y estructurado, dos pensamientos distintos

Índice

1. Objetos y estructurado, dos pensamientos distintos......................................................1Sobre el capítulo........................................................................................................2

Motivaciones.........................................................................................................2Objetivos................................................................................................................2Contenido..............................................................................................................2

1.1 El enfoque estructurado, una manera de pensar el software...................................3Ejemplo, pintar un círculo.........................................................................................3Un programa estructurado para pintar un círculo......................................................7Ampliar la solución, pintar varios círculos y recordarlos..........................................9Ampliar el programa, pintar varios círculos............................................................12

1.2 Los objetos, otra manera de pensar el software.....................................................14Una solución orientada a objetos para pintar varios círculos..................................19

Definición de los conjuntos de objetos................................................................19Definición de las operaciones..............................................................................20La orden de inicio................................................................................................21

Un programa orientado a objetos para pintar varios círculos..................................231.3 Recapitulando, contrastes y semejanzas................................................................27

La diferencia de pensamiento, de conceptos.......................................................27La diferencia de organización. La alotropía........................................................28La diferencia para expresar ambigüedad.............................................................29Ninguno es más natural que otro.........................................................................32Se amplía la idea de variable software, pero…...................................................32El dilema de las bases de datos............................................................................33

1


Sobre el capítulo

Motivaciones

En el mundo software, por lo general, se acostumbra a cambiar de lenguaje de programación sin cambiar de forma de pensar el software. Siguiendo esta costumbre los objetos se perciben como otro cambio más de lenguaje. Es decir, como lo mismo que antes, pero con ropaje (sintaxis) distinto. Sin embargo, no es así. Los objetos son una manera cualitativamente distinta de pensar el software. Este hecho se ignora o se confunde porque el arraigo del pensamiento estructurado, en términos de funciones y datos, se niega a cambiar de perspectiva, consciente o inconscientemente. Cualquier idea acerca de los objetos se traduce al terreno estructurado de forma que los objetos se interpretan en términos estructurados y se pierden las ventajas de ambos enfoques.

Objetivos

El presente capítulo contrasta el enfoque de objetos y el enfoque estructurado. Sus objetivos principales son que los alumnos:

1) Comprendan las diferencias principales en forma de pensar el software.

2) Conozcan las diferencias en la capacidad de expresar ambigüedad.

Contenido

La primera parte “El enfoque estructurado, una manera de pensar el software” describe cómo se aborda la solución de un problema, tomando como caso particular el dibujo de figuras geométricas en la pantalla del ordenador.

La segunda parte “Los objetos, otra manera de pensar el software” describe cómo se aborda la solución al mismo problema desde la perspectiva de los objetos.

Y, por último, “Contrastes y semejanzas” se dedica a resumir las cualidades de cada manera de pensar el software y las compara.

2


1.1 El enfoque estructurado, una manera de pensar el software

Se podría denominar enfoque estructurado a la forma particular de pensar el

software en términos de funciones de transformación de datos. El universo de discurso

se disocia en funciones y datos, y cualquier tarea se interpreta como una transformación

de datos.

Ejemplo, pintar un círculo

Por ejemplo, el enfoque estructurado resuelve el problema de pintar círculos en

la pantalla de la siguiente manera:

1. Utiliza como universo de discurso una definición de círculo que esté acorde con los

recursos del software; en particular, utiliza la expresión algebraica que define los

puntos de un círculo. Figura 1. 1.

R2 ≤ (x – x0)2 + (y – y0)2 [1]

donde el radio R, y las coordenadas del centro x0 e y0 son las constantes que

especifican un círculo en concreto.

Figura 1. 1 Definición algebraica de círculo

2. Disocia la definición de círculo en dos partes y las reinterpreta:

3

R

X0, y0

Círculo

Circunferencia

R2 > (x – x0)2 + (y – y0)2

R2 = (x – x0)2 + (y – y0)2

R2 ≥ (x – x0)2 + (y – y0)2


Considera que las constantes R, x0, y0 son datos para pintar el círculo y añade

uno más, el color del círculo.

Convierte la expresión declarativa [1] en una función operativa que transforma

el conjunto de datos precedentes en el conjunto de datos (x, y, color) de todos

los píxeles para pintar el círculo en la pantalla.

Como resultado final se obtiene un sistema software capaz de pintar un círculo, en

términos de un proceso de transformación de datos. Figura 1.2.

Figura 1.2 Sistema software como una función de transformación de datos

El sistema software se expresa como una función F(x) que transforma el

conjunto de datos “X” (radio, centro y color) de un círculo, en el conjunto de datos “Y”

de puntos (píxeles) que constituyen la figura del círculo en la pantalla: y = f(x). A este

tipo de esquema se le denomina diagrama de flujo de datos.

Detrás del esquema subyace la disociación de la definición algebraica de círculo

y la conversión de la expresión declarativa en un mecanismo de cálculo: la función

software PintarCírculo(R, x0, y0, color), que transforma las constantes del círculo en los

valores de los puntos del círculo en la pantalla.

4

PintarCírculo(R…)

X: {R, x0, y0, C}

puntos del círculo

función de transformación de datos

datos de entrada

datos de salida

F(X)

(x2, y2, color)

(xn, yn, color)

(x1, y1, color)

…Y:

constantes del círculo

Y = F(X)


El software, en general, apela a la definición algebraica de círculo porque es un

recurso compatible con los medios que dispone; carece de los recursos usuales de la

geometría (compás, cuerda, etc.) para pintar un círculo.

La particularidad del enfoque estructurado consiste en pensar la solución como

una función que transforma datos y disociar la definición algebraica de círculo para que

se acomode a esta forma de pensar.

Si los datos del círculo se deben recibir del exterior del sistema software

entonces se utiliza una función adicional para la recepción y transformación de los

datos. Esta función recibe los datos R’, x0’, y0’, C’, provenientes de los equipos

periféricos (teclado, ratón,…), transforma su formato y los almacena en forma de

variables software: R, x0, y0, C. Figura 1.3.

LeerDatos(R…)


R, x0, y0, C

sistema softwarepuntos del círculo

función

función

almacén de datosR’, x’0, y’0, C’

Figura 1.3 Solución del software estructurado

La Figura 1.3 muestra la síntesis de la función principal del sistema software a

través de dos funciones: LeerDatos(R, x0, y0,C) y PintarCírculo(R, x0, y0,C).

El sistema está formado por las funciones de lectura y de dibujo, y el almacén de

datos del círculo (variables software). Ningún elemento software representa, por sí solo,

el concepto de círculo.

5


Los diagramas de flujos de datos definen la función y el funcionamiento del

sistema software. Es decir, definen que la función del sistema es la transformación de un

conjunto datos de entrada en datos de salida y además, definen cómo se sintetiza esta

función mediante otras funciones. El diagrama de flujo de datos es un esquema

asíncrono (no expresa secuencias); las flechas sólo indican los flujos de datos, no el

orden de ejecución.

Figura 1.4. Definición y síntesis del sistema software

La Figura 1.4 muestra la definición de la función del sistema software en

términos de entrada y salida, y la síntesis de esta función mediante dos funciones. Por

razones históricas, a menudo se utiliza la palabra “análisis” para referirse a esta síntesis.

En términos de pseudocódigo, el sistema software podría expresarse de la

siguiente manera:

Variables: radio, x0, y0, color

LeerDatos (radio, x0, y0, color)

PintarCírculo (radio, x0, y0, color)

La secuencia de ejecución se aprecia directamente de la lectura del

pseudocódigo: primero se leen los datos y después, se pinta el círculo.

6

Definición inicial del sistema software

puntos del círculo


F(x)

y

x

puntos del círculo

F(x)y

x

zf1(x)

f2(z)

y = f1(x) + f2(z)


Síntesis del sistema software

y = F(x)


Un programa estructurado para pintar un círculo

Los sistemas estructurados se programan en lenguajes estructurados, pero

también se programan en lenguajes de objetos, como Java. Programar en Java no

asegura programar con el enfoque de objetos. A continuación se muestra la

programación del sistema estructurado precedente usando el lenguaje Java. El entorno

gráfico de ventanas distorsiona un poco la simplicidad de la idea de pintar un círculo

porque obliga a trabajar con las ventanas, pero se mantiene la esencia. El pseudocódigo

sería algo así:

Variables: radio, x0, y0, color

CrearVentana

PintarVentana “vacía”

LeerDatos(radio, x0, y0, color) “datos del círculo que se pintará dentro de la ventana”

RepintarVentana “función que invoca a PintarCírculo (radio, x0, y0, color)”

El código completo puede verse en el Anexo. Seguidamente se muestra el

código del programa principal. Las notas en negrita se corresponden con el

pseudocódigo.

import javax.swing.*;import java.awt.*;import java.awt.event.*;

public class PintarCirculoEstructurado extends JFrame { private int centrox, centroy, radio; private Color color; private boolean haydatos=false; public PintarCirculoEstructurado() { } //Asignar el Look&Feel de la ventana private void asignarLookAndFeel() { //Forzar el Look and Feel de la ventana al del sistema operativo String laf = UIManager.getSystemLookAndFeelClassName(); try { UIManager.setLookAndFeel(laf); } catch (UnsupportedLookAndFeelException exc) {System.err.println("Unsupported: " + laf);} catch (Exception exc)

7

Declaramos las variables radio, x0,y0 y color. (A x0 le hemos llamado centrox y a y0 centroy)

haydatos es una variable auxiliar

Función para asignar a la ventana el look&feel o apariencia que tenga el sistema operativo (p.ejm: en Windows las ventanas tienen la barra de títulos en azul con texto en blanco y el panel tiene el fondo gris)

Importamos el API swing de Java para construir interfaces gráficas


{System.err.println("Error cargando: " + laf);} }

//Incluir botón cerrar ventana private void setCloseClick() { //Controlar el cierre de la ventana addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e) {System.exit(0);} });}

public void paint (Graphics g) { super.paint(g); //Si el usuario ha introducido los datos pinta el círculo if (haydatos){ g.setColor(color); g.drawOval(centrox-radio, centroy-radio,2*radio,2*radio); g.fillOval(centrox-radio, centroy-radio,2*radio,2*radio); g.dispose(); } } public static void main(String[] args) {

// 1. Crear la ventana y pintarla vacía PintarCirculoEstructurado ventana = new PintarCirculoEstructurado(); ventana.setTitle("Pintar Circulo Estructurado"); ventana.asignarLookAndFeel(); ventana.setCloseClick(); ventana.setExtendedState(MAXIMIZED_BOTH); ventana.setVisible(true);

// 2. Mostrar el formulario para obtener los datos del circulo FormularioCirculo formulario= new FormularioCirculo(); JDialog dialog=new JDialog(ventana, "Introduzca los datos del circulo", true); dialog.setContentPane(formulario); dialog.pack(); dialog.show(); // 3. Obtener los datos introducidos por el usuario ventana.centrox=formulario.obtenerCentrox(); ventana.centroy=formulario.obtenerCentroy(); ventana.radio=formulario.obtenerRadio(); ventana.color=formulario.obtenerColor(); ventana.haydatos=true;

//4. Repintar la ventana con el circulo ventana.setExtendedState(MAXIMIZED_BOTH); ventana.repaint(); //repaint invoca internamente al método "paint(Graphics g)" } }

8

Función para incluir en la ventana el botón para cerrarla

Función para pintar la ventana. Para usar el API swing, el nombre de la función tiene que ser obligatoriamente “paint(Graphics g)”

Programa principal

CrearVentanaPintarVentana “vacía”

LeerDatos (radio, x0, y0, color)

RepintarVentana


Ampliar la solución, pintar varios círculos y recordarlos

Las consecuencias de la disociación que produce el enfoque estructurado sobre

los elementos del discurso se aprecian mejor cuando se añaden más elementos, por

ejemplo círculos. Ahora se quiere pintar varios círculos y después, actuar sobre ellos de

forma selectiva, digamos borrar el segundo círculo que se pintó.

El sistema para pintar un círculo podría pintar varios círculos si se le añade un

mecanismo de bucle, pero sólo recordaría las constantes (datos) del último círculo

porque los datos se rescribirían unos sobre otros.

Para recordar todos círculos habría que añadir tantas variables como círculos se

quiera recordar con el objetivo de retener cada conjunto de constantes. El siguiente

sistema (expresado en pseudocódigo) es capaz de pintar y recordar dos círculos:

Variables: radio1, x10, y10, color1,

radio2, x20, y20, color2

LeerDatos (radio1, x10, y10, color1)

PintarCírculo (radio1, x10, y10, color1)


PintarCírculo (radio2, x20, y20, color2)

Se leen los datos de un círculo y se pinta el círculo, después se leen los datos del

segundo y se pinta.

El nuevo sistema software es una duplicación del sistema para un círculo. Por

tanto, comparte la misma esencia. El diagrama de flujo de datos sólo ha engrosado el

almacén de datos como se aprecia en la Figura 1.5.

9


Figura 1.5. Solución estructurada para más de un círculo

Gracias a la capacidad de recordar las constantes de varios círculos, el sistema

nuevo permite actuar selectivamente sobre los círculos pintados, por ejemplo borrar,

ampliar y mover, agregando funciones destinadas a tal fin. Para ampliar el segundo

círculo se haría actuar la función Ampliar(zoom, radio, x0, y0, color) sobre las constantes

del segundo círculo (radio2, x20, y20, color2). Para borrar el primero se haría actuar la

función Borrar(radio, x0, y0, color) sobre las constantes del primer círculo.

Y también, gracias a esta capacidad para recordar las constantes de varios

círculos se aprecia mejor la disociación de los círculos. El almacén de datos contiene las

constantes de los círculos en forma de variables software y la función PintarCírculo

contiene el mecanismo para pintar un círculo. Una vez más, a ningún elemento del

sistema se le pueden asociar por completo las propiedades de un círculo en particular.

En general, cualquier concepto que no encaje directamente con dato o función de

transformación de datos tendrá que ser ajustado (distorsionado) para su tratamiento

software desde la perspectiva del enfoque estructurado. El caso de los círculos, sólo es

un caso más. Pero este hecho pasa inadvertido porque el uso frecuente del enfoque

estructurado, o de cualquier otro enfoque, se convierte en unas gafas automáticas que

transforman todo en términos del enfoque habitual, sin tener conciencia de la

transformación.

10

LeerDatos(R…)


sistema software

puntos del círculo

función

función

almacén de datos

R2’, x2’0, y2’0, C2’

R1’, x1’0, y1’0, C1’

R1, x10, y10, C1

R2, x20, y20, C2


La disociación de los conceptos provoca la mezcla de partes de distintos

conceptos. Por ejemplo, se pueden mezclar datos de círculos, triángulos, rectángulos,

con funciones para pintar cada una de estas figuras. De manera que conviene distinguir,

con nombres diferentes, los datos y las funciones que actúan sobre unos u otros datos.

Figura 1.6.

Figura 1.6. Mezcla de partes de conceptos

Por ejemplo, el color del círculo debe ser Cc, para distinguirlo del color del

rectángulo Cr. Los vértices de los rectángulos deberán denominarse VR, para

distinguirlos de los vértices de los triángulos VT. Las funciones también deberán tener

distintos nombres: PintarCírculo(radio, x0, y0, Cc), PintarRectángulo(VRs, VRi, Cr),

BorrarTriángulo(VT1, VT2, VT3 ), etc.

Pero, como sucede siempre, no todo es malo. La disgregación de los conceptos

en datos y funciones tiene efectos benéficos. Por ejemplo, permite trabajar directamente

con la idea de base de datos o archivo, que existe en el mundo mucho antes de la

informática. La colección permanente de datos desempeña el papel de base de datos.

11

LeerDatosCírculo(R,…)

PintarCírculo(R,…)

sistema software

R, x0, y0, Cc

LeerDatosRectángulo(VRs,…)

PintarRectángulo(VRs,…)

VRs, VRi, Cr


Ampliar el programa, pintar varios círculos

Veamos el código Java del programa para pintar dos círculos. Los cambios sobre

el programa anterior aparecen resaltados en negrita. En las notas, los textos en negrita

corresponden al pseudocódigo.


public class PintarDosCirculos extends JFrame{ private int centrox1, centroy1, radio1, centrox2, centroy2, radio2; private Color color1, color2; private boolean haydatos1=false; private boolean haydatos2=false; public PintarDosCirculos() { } private void asignarLookAndFeel() { //Forzar el Look and Feel de la ventana al del sistema String laf = UIManager.getSystemLookAndFeelClassName(); try { UIManager.setLookAndFeel(laf); } catch (UnsupportedLookAndFeelException exc) {System.err.println("Unsupported: " + laf);} catch (Exception exc) {System.err.println("Error cargando: " + laf);} } private void setCloseClick() { //Controlar el cierre de la ventana addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e) {System.exit(0);} });}

public void paint (Graphics g) { super.paint(g); //Si el usuario ha introducido los datos pintar el circulo1 if (haydatos1){ g.setColor(color1); g.drawOval(centrox1-radio1, centroy1-radio1,2*radio1,2*radio1); g.fillOval(centrox1-radio1, centroy1-radio1,2*radio1,2*radio1); }

//Si el usuario ha introducido los datos pintar el circulo2 if (haydatos2){

12

Declaramos las variables radio1, x10,,y10, y color1 de circulo1 y las variables radio2, x20,,y20, y color2 de circulo2)

Ahora necesitamos dos variables auxiliares haydatos1 y haydatos2.


g.setColor(color2); g.drawOval(centrox2-radio2, centroy2-radio2,2*radio2,2*radio2); g.fillOval(centrox2-radio2, centroy2-radio2,2*radio2,2*radio2); } g.dispose(); } public static void main(String[] args) { // 1. Crear la ventana y pintarla vacía PintarDosCirculos ventana = new PintarDosCirculos(); ventana.setTitle("Pintar Dos Circulos"); ventana.asignarLookAndFeel(); ventana.setCloseClick(); ventana.setExtendedState(MAXIMIZED_BOTH); ventana.setVisible(true); // 2. Mostrar el formulario para obtener los datos del primer círculo FormularioCirculo formulario= new FormularioCirculo(); JDialog dialog=new JDialog(ventana, "Introduzca los datos del primer circulo", true); dialog.setContentPane(formulario); dialog.pack(); dialog.show(); // 3. Obtener los datos introducidos por el usuario ventana.centrox1=formulario.obtenerCentrox(); ventana.centroy1=formulario.obtenerCentroy(); ventana.radio1=formulario.obtenerRadio(); ventana.color1=formulario.obtenerColor(); ventana.haydatos1=true; //4. Repintar la ventana con el primer círculo ventana.setExtendedState(MAXIMIZED_BOTH); ventana.repaint(); //repaint invoca internamente al método "paint(Graphics g)"

// 5. Mostrar el formulario para obtener los datos del segundo círculo formulario= new FormularioCirculo(); dialog=new JDialog(ventana, "Introduzca los datos del segundo circulo", true); dialog.setContentPane(formulario); dialog.pack(); dialog.show(); // 6. Obtener los datos introducidos por el usuario ventana.centrox2=formulario.obtenerCentrox(); ventana.centroy2=formulario.obtenerCentroy(); ventana.radio2=formulario.obtenerRadio(); ventana.color2=formulario.obtenerColor(); ventana.haydatos2=true; //7. Repintar la ventana con el segundo círculo ventana.setExtendedState(MAXIMIZED_BOTH); ventana.repaint(); //repaint invoca internamente al método "paint(Graphics g)" } }

13

Programa principal

RepintarVentana


RepintarVentana



1.2 Los objetos, otra manera de pensar el software

Se podría denominar enfoque de objetos a la forma particular de pensar el

software en términos de cosas que colaboran entre sí para realizar tareas. Es una forma

de pensar más abstracta que facilita expresar cualquier elemento sin necesidad de

disociarlo o clasificarlo en datos o funciones. Para quienes aprecian el software como

funciones y datos, el enfoque de objetos presenta la dificultad de un cambio radical de

pensamiento.

Volviendo al ejemplo de los círculos, el enfoque de objetos tiene los mismos

recursos y restricciones que el enfoque estructurado para pintar los círculos. Pero piensa

la solución de una forma diferente y en vez de disgregar las propiedades de los círculos

asocia íntegramente cada círculo a un elemento software. Hace lo mismo con el resto de

elementos del discurso.

Figura 1.7. Elementos del discurso asociados a elementos software

La Figura 1.7 muestra los elementos software que se asocian a elementos del

discurso: la ventana, los dos círculos y los formularios que recogen las constantes de los

círculos desde el exterior del sistema software. Cada elemento software contiene las

propiedades íntegras de cada elemento del discurso. El elemento círculo1 contiene sus

constantes y los mecanismos para pintarse y crearse como elemento. Igual sucede con el

14

radiocentro colorPintarCrear

círculo1

formularioCir

CrearLeer


círculo2

formularioCir

CrearLeer

ventana

círculo1círculo2CrearPintar

Elementos software


círculo2, ventana y los formularios. Estos elementos software son variables software en

un sentido más amplio que las variables del enfoque estructurado.

En el caso del problema de pintar los círculos, el enfoque de objetos piensa:

1. en variables software capaces de recordar las constantes de un círculo,

capaces de pintar el círculo y, además, capaces de crearse a sí misma como

variables. Es decir, piensa en unas variables cualitativamente distintas de las

variables estructuradas que sólo recuerdan datos. A estas nuevas variables se

le podría denominar círculo1 y círculo2, definidas a través del nombre y sus

propiedades:

círculo1 ≡ {radio, centro, color, crear, pintar}

círculo2 ≡ {radio, centro, color, crear, pintar}

2. que la ventana, que contiene los círculos, y los formularios, para leer las

constantes, podrían ser otras variables software denominadas,

respectivamente, ventana y formulario:

ventana ≡ {círculo1, círculo2, crear, pintar}

formulario ≡ {crear, leer}

3. el sistema software en términos de la interacción de estas variables, dadas

sus respectivas capacidades para ejecutar operaciones. Es decir, cómo

relacionar todas las variables para conseguir que se realice la tarea de pintar

círculos.

La Figura 1.8 muestra el sistema software. Se aprecian las relaciones entre las

variables software que ejecutan la tarea de pintar círculos. Este sistema realiza la misma

tarea que el sistema estructurado, aplica el mismo algoritmo, pero está organizado de

forma diferente. Por tanto, tiene propiedades diferentes. Algo semejante a lo que sucede

con las sustancias alotrópicas, por ejemplo el diamante y el grafito que son

químicamente iguales, pero físicamente muy diferentes. Después se estudiarán con

detalle las diferencias de propiedades.

15


Figura 1.8. Sistema software con enfoque de objetos

El enfoque de objetos amplía la idea de variable software y la hace más

abstracta, con capacidad para expresar cualquier cosa, incluso una operación. A estas

variables software, capaces de ejecutar operaciones, se les denomina objetos y a la

forma de pensar el software en objetos, se le denomina en general, enfoque orientado a

objetos.

Como sucede frecuentemente en el universo software (donde existen muchas

palabras para el mismo significado), también hay otras formas de referirse o clasificar el

mundo de los objetos, pero carecen de utilidad, al menos, a los efectos del curso.

La Figura 1.8 utiliza símbolos próximos a la notación estándar UML, pero sin

rigor por razones de simplicidad y conveniencia pedagógica. Las cajas indican objetos y

las flechas relaciones entre ellos. En ningún caso señalan secuencias, ni flujos de datos,

entradas o salidas. Las diferencias entre flechas continuas y discontinuas serán vistas

con posterioridad.

El sistema software de la Figura 1.8 podría funcionar de la siguiente manera.

Comienza creando una variable (objeto) ventana que establece sus propias

particularidades y se pinta. Después, este objeto ventana solicita la creación de los

objetos círculo1 y círculo2. Cada objeto círculo, a su vez, crea un objeto formulario que

solicita en la pantalla los valores de radio, centro, color, y los asigna al objeto círculo

16


círculo1

ventana

círculo1círculo2CrearPintar

formularioCir

CrearLeer


círculo2

formularioCir

CrearLeer

sistema software


que lo creó. Al final, el objeto ventana se pinta a sí mismo y le solicita a los objetos

círculo1 y círculo2 que se pinten.

Se denomina mensaje a la solicitud a un objeto para que ejecute una operación o,

como también se dice, realice un servicio. Por ejemplo, la solicitud que hace el objeto

ventana a los objetos círculo1 y círculo2 para se pinten. Un mensaje es la invocación de

una rutina contenida en un objeto, que a su vez es una variable. Por tanto, un mensaje

manifiesta una carga de ambigüedad que lo diferencia profundamente de la invocación

tradicional a una rutina. Los mensajes constituyen el mecanismo de interacción de los

objetos y la clave del funcionamiento del sistema.

A la luz estructurada, el funcionamiento del sistema de objetos parece raro, pero

como se dijo, el sistema de objetos hace la misma tarea (pintar círculos) y aplica el

mismo algoritmo que el sistema estructurado. Exteriormente, no hay diferencias entre el

sistema estructurado y el sistema de objetos; ambos muestran el mismo

comportamiento. La diferencia es interior, en la forma de pensar y diseñar el software,

cualitativamente distinta, que organiza el sistema y lo hace funcionar de otro modo.

Las gafas de visión estructurada podrían hacer creer que pensar en objetos es lo

mismo que pensar en módulos; que el sistema de Figura 1.8 es un sistema estructurado

dividido en módulos, pero las gafas engañan. Los módulos estructurados no son

variables software. Mientras que ventana, círculo1, círculo2 y formulario son variables

software que se crean y destruyen dinámicamente; son variables con capacidad para

actuar y recordar.

La idea de objeto software extiende la idea de variable software tradicional,

restringida a la capacidad de recordar y al concepto de dato. El objeto software es una

variable software que recuerda, pero que además, tiene la capacidad adicional de

ejecutar operaciones. Un objeto software, no es ni dato, ni función, ni la suma de datos y

funciones. Un objeto es un elemento software cualitativamente distinto capaz de

expresar un concepto más amplio, más ambiguo: cosa.

Gracias a la ambigüedad del significado (capacidad para expresar alternativas),

los objetos software pueden representar o estar asociados con cualquier cosa: círculo,

ventana, cuenta bancaria, vuelo, habitación, regla de negocio,… Los objetos software

son variables software mucho más libres, gracias a la ambigüedad, que las variables

17


software estructuradas, limitadas a la idea de dato. Las operaciones en los objetos

también son más libres porque son variables, mientras que en el enfoque estructurado

son constantes.

La libertad de interpretación de las variables software, que ofrece el enfoque de

objetos, se utiliza a menudo para decir que los objetos “copian mejor la realidad”, como

si copiar la realidad fuese una cualidad importante del software. Durante el curso se

demostrará que la expresión “copiar la realidad” carece de sentido en términos absolutos

y que además, puede ser contraproducente.

En general, el software resuelve problemas, no los modela, salvo que el objetivo

sea la simulación. La forma que el software resuelve los problemas difiere, por lo

común, de la forma que se resuelven los problemas en el mundo exterior al software,

porque el software y ese mundo tienen propiedades distintas. Por ejemplo, en el mundo

de la geometría los círculos carecen de la propiedad de dibujarse, ni tampoco son datos

o funciones de transformación de datos.

Los objetos círculo1 y círculo2, son piezas de la solución software al problema

de pintar círculos. Cada uno de estos objetos software está asociado con un círculo

particular, pero no lo representa porque un objeto software es distinto de un círculo

geométrico. Los objetos círculo1 y círculo2 son piezas del engranaje software para

resolver el problema de pintar círculos.

Si se piensa que un objeto software representa a un elemento del discurso se

puede pensar en imitar propiedades que no convienen o no se pueden conseguir en el

software. Es preferible pensar que un objeto software se asocia a un elemento del

discurso porque, si conviene, se puede asociar cualquier cosa, mientras que la

representación (modelado) exige imitar las cualidades de lo representado. Más adelante

se volverá sobre este controvertido tema en el universo software.

La ausencia de los conceptos de dato y función de transformación de datos, en el

mundo de los objetos, tiene una consecuencia desfavorable. La idea de base de datos no

encaja directamente en ese mundo porque no existe el concepto de dato; sólo hay

objetos y mensajes. Por tanto, se ha inventado la idea de objeto persistente, para

conseguir un efecto equivalente al que ofrece la colección permanente de datos del

enfoque estructurado. Pero esto es otra historia, para más adelante.

18


Una solución orientada a objetos para pintar varios círculos

La diferencia en la forma de pensar el software de objetos se refleja en los

diagramas de diseño y en el código. El enfoque estructurado organiza el sistema según

el flujo de transformación de datos; su código realza la secuencia de pasos de la tarea.

El enfoque de objetos organiza el sistema según los elementos que participan en la

ejecución de la tarea. Su código realza estos elementos; la secuencia de pasos para la

realización de la tarea queda disuelta en la definición de las operaciones

(comportamientos) de los objetos.

Por ejemplo, el programa de los círculos, consistiría en:

1. definir los conjuntos de objetos que participan en la realización de la tarea,

2. definir las operaciones que pueden ejecutar los objetos,

3. dar la orden de iniciar la acción.

Visto en detalle:

Definición de los conjuntos de objetos

La mayoría de los lenguajes comerciales de programación de objetos, exigen la

definición de conjuntos de objetos, en vez de definir los objetos uno por uno. En el caso

de los círculos, los conjuntos de objetos serían, por ejemplo, Círculo, Ventana y

Formulario (para leer las constantes de los círculos).

En cada definición se enuncian las propiedades particulares del conjunto en

términos de atributos y operaciones. Los atributos pueden ser objetos o variables

software tradicionales. Las operaciones son rutinas, funciones, procedimientos, en fin,

código capaz de ejecutar acciones. Se acostumbra denominar clase a la definición de un

conjunto de objetos y método a una operación.

Círculo ≡ {

radio, x0, y0 : reales “atributos de tipo real”

color : texto “atributo de tipo texto”

Círculo “operación para crear objetos círculos; equivale al Crear de la Figura 1.8”

Pintar “operación para pintar el círculo”

19


Leer “operación para leer los atributos”

}

Ventana ≡ {

círculo 1, círculo 2 : Círculo “los atributos pertenecen al conjunto Círculo”

Ventana “operación para crear objetos ventana; equivale al Crear de la Figura 1.8”

Comienzo “operación que inicia el funcionamiento del sistema”

Pintar “operación para pintar la ventana”

}

Formulario ≡ {

Formulario“operación para crear objetos formulario; equivale al Crear de la Figura 1.8”

Obtener_radio “operación para leer radio”

Obtener_x0 “operación para leer x0”

Obtener_y0 “operación para leer y0”

Obtener_color “operación para leer color”

}

Las operaciones homónimas con los conjuntos (Círculo, Ventana y Formulario),

son operaciones especializadas en la creación dinámica de objetos. Tienen el mismo

nombre de los conjuntos para facilitar la lectura del código. Por ejemplo, v

nuevoFormulario es una línea de pseudocódigo que crea un objeto del conjunto

Formulario y lo asigna a la variable v.

Definición de las operaciones

Las operaciones o métodos de los objetos se definen asociadas al conjunto. Por

ejemplo,

Círculo::Círculo ≡ {

Leer “se invoca el método Leer del propio objeto”

}

Círculo::Leer ≡ {

v es Formulario “el atributo v es un objeto (por concretar) del conjunto Formulario”

v nuevoFormulario “se crea un objeto formulario y se asigna a v”

20


radio v.Obtener_radio “se pide al formulario que obtenga el radio y se asigna a radio”

x0 v.Obtener_x0 “se pide al formulario que obtenga x0 y se asigna a x0”

y0 v.Obtener_y0 “se pide al formulario que obtenga y0 y se asigna a y0”

color v.Obtener_color “se pide al formulario que obtenga el color y se asigna a color”

}

La línea radio v.Obtener_radio expresa un mensaje de un objeto círculo a un

objeto formulario para que suministre el valor del radio y lo asigne a la variable radio.

El resto de líneas sucesivas también expresan mensajes, de un objeto círculo a un objeto

formulario representado por la variable v. Para mantener el hilo de la explicación se ha

simplificado el pseudocódigo.

La orden de inicio

El sistema inicia el funcionamiento cuando el intérprete o el ejecutor del

lenguaje activa la operación Comienzo. En este curso se ha usado la palabra Comienzo

para denominar a la operación de inicio, pero en general debe ser una palabra clave

designada de antemano en el lenguaje. Por ejemplo, los lenguajes C++ y Java utilizan la

palabra Main.

La operación Comienzo contiene sólo el código que inicia el funcionamiento del

sistema. Por ejemplo:

Ventana::Comienzo ≡ {

nuevaVentana “crear una ventana”

}

Al crearse el objeto ventana se ejecuta el código definido en la siguiente

operación:

Ventana::Ventana ≡ {

caracterizar y pintar la ventana vacía “ instrucciones internas”

círculo1 nuevoCírculo “crear el objeto círculo1”

círculo2 nuevoCírculo “crear el objeto círculo2”

repintar la ventana “pinta el contenido de la ventana llamando a la operación pintar”

}

Al llamar a la operación pintar se ejecuta el código para pintar los círculos

21


Ventana::Pintar ≡ {

pintar fondo ventana “ instrucciones internas”

círculo1.pintar “se pide a círculo1 que se pinte”

círculo2.pintar “se pide a círculo2 que se pinte”

}

En este caso se ha colocado la operación de comienzo en el objeto ventana, pero

podría estar situado en otro objeto, destinado específicamente a iniciar del sistema. A

menudo este objeto de inicio recibe el nombre de Principal por rémora o confusión del

enfoque estructurado, pero su única tarea es dar comienzo al funcionamiento del sistema

software; no contiene el algoritmo principal, como sucede en el enfoque estructurado.

Pensando en el teatro, los objetos son los actores de la obra y los mensajes son

los diálogos entre ellos. El programa describe a los actores, lo que tienen que decir y

hacer. El desarrollo de la obra, que resalta el enfoque estructurado, queda aquí disperso

entre los guiones de los objetos. Es más difícil ver la secuencia de pasos en un sistema

software de objetos que en un sistema estructurado. Volviendo al teatro, la única tarea

del mal llamado objeto principal es convocar al público y a los actores para que

comience la función.

El enfoque de objetos utiliza una forma de programar muy distinta a la forma

tradicional. Y, efectivamente, es mucho más complicada, al menos para los que piensan

en términos estructurados. El cambio del modo de pensar el software es un reto difícil

como advierte la literatura software y como se aprecia en la experiencia diaria. Pero es

un reto necesario si lo importante del software son los actores. Y un reto conveniente, si

se quiere aprovechar la ambigüedad del mundo de los objetos para simplificar la

complejidad y facilitar los cambios en el software, como se verá después.

22


Un programa orientado a objetos para pintar varios círculos

Veamos como se implementaría el pseudocódigo anterior en lenguaje Java.


public class Ventana extends JFrame{ private Circulo circulo1; private Circulo circulo2;

//Crea una nueva instancia de ventana public Ventana() { //Pintar la ventana vacía setTitle("Pintar Circulos "); asignarLookAndFeel(); setCloseClick(); setExtendedState(MAXIMIZED_BOTH); setVisible(true); //Crear un circulo y añadirlo a la ventana circulo1=new Circulo(); getContentPane().add(circulo1); //Crear otro circulo y añadirlo a la ventana circulo2=new Circulo(); getContentPane().add(circulo2); //Repintar la ventana con los dos circulos pack(); setExtendedState(MAXIMIZED_BOTH); repaint(); //repaint invoca internamente al método paint(g) } private void asignarLookAndFeel() { //Forzar el Look and Feel de la ventana al del sistema String laf = UIManager.getSystemLookAndFeelClassName(); try { UIManager.setLookAndFeel(laf); } catch (UnsupportedLookAndFeelException exc) {System.err.println("Unsupported: " + laf);} catch (Exception exc) {System.err.println("Error cargando: " + laf);} } private void setCloseClick() { //Controlar el cierre de la ventana addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e) {System.exit(0);} });

23

Definición de Ventana

atributos de Ventana

operación para crear

Mensaje a circulo1 para que se cree

Mensaje a circulo2 para que se cree


} public void paint (Graphics g) { super.paint(g); if (circulo1!=null) circulo1.paint(g); if (circulo2!=null) circulo2.paint(g); } public static void main(String[] args) { new Ventana(); } }

public class Circulo extends JComponent{ //Coordenada x del centro private int centrox; //Coordenada y del centro private int centroy; //Radio private int radio; //Color private Color color; private boolean haydatos=false; // Crea una nueva instancia de Circulo public Circulo() { // Mostrar el formulario para obtener los datos del circulo FormularioCirculo formulario= new FormularioCirculo(); JDialog dialog =new JDialog(); dialog.setTitle("Introduzca los datos del circulo"); dialog.setModal(true); dialog.setContentPane(formulario); dialog.setDefaultCloseOperation(javax.swing.WindowConstants.HIDE_ON_CLOSE); dialog.pack(); dialog.show(); // Obtener los datos introducidos por el usuario centrox=formulario.obtenerCentrox(); centroy=formulario.obtenerCentroy(); radio=formulario.obtenerRadio(); color=formulario.obtenerColor(); haydatos=true; } public void paint (Graphics g) { //Si el usuario ha introducido los datos pintar el círculo if (haydatos){ g.setColor(color); g.drawOval(centrox-radio, centroy-radio,2*radio,2*radio); g.fillOval(centrox-radio, centroy-radio,2*radio,2*radio); } }}

24

Mensaje a circulo1 para que se pinte

Mensaje a circulo2 para que se pinte

operación para pintar

operación comienzo

Definición de Círculo

atributos de Círculo


operación para pintar


public class FormularioCirculo extends JPanel { //Valores de los cuadros de texto private int centrox; private int centroy; private int radio; private Color color; //Etiquetas de los campos de texto private JLabel centroxLabel; private JLabel centroyLabel; private JLabel radioLabel; private JLabel colorLabel; //Textos de las etiquetas private static String centroxString = "Coordenada x del centro: "; private static String centroyString = "Coordenada y del centro: "; private static String radioString = "Radio: "; private static String colorString = "Color: "; //Campos de texto y combo para introducir los datos private JTextField centroxTextField; private JTextField centroyTextField; private JTextField radioTextField; private JComboBox colorField; //Crea una nueva instancia de FormularioCirculo public FormularioCirculo() { //crear las etiquetas centroxLabel = new JLabel(centroxString); centroyLabel= new JLabel(centroyString); radioLabel= new JLabel(radioString); colorLabel= new JLabel(colorString); //crear los campos de texto centroxTextField = new JTextField(5); centroyTextField= new JTextField(5); radioTextField= new JTextField(5); //crear el combo de colores String [] colorValues= {"Azul","Naranja","Verde","Rojo","Amarillo","Gris"}; colorField = new JComboBox(colorValues); colorField.setEditable(false); //Asignar las etiquetas a los campos de texto centroxLabel.setLabelFor(centroxTextField); centroyLabel.setLabelFor(centroyTextField); radioLabel.setLabelFor(radioTextField); colorLabel.setLabelFor(colorField); //Distribuir las etiqueta en un panel JPanel labelPane = new JPanel(); labelPane.setLayout(new GridLayout(0, 1)); labelPane.add(centroxLabel); labelPane.add(centroyLabel); labelPane.add(radioLabel); labelPane.add(colorLabel); //Distribuir los campos de texto en otro panel. JPanel fieldPane = new JPanel(); fieldPane.setLayout(new GridLayout(0, 1)); fieldPane.add(centroxTextField); fieldPane.add(centroyTextField); fieldPane.add(radioTextField);

25

Definición de Formulario

atributos de Formulario



fieldPane.add(colorField); //Poner los dos paneles en un nuevo panel, las etiquetas a la izquierda, //los campos de texto a la derecha. JPanel contentPane = new JPanel(); contentPane.setBorder(BorderFactory.createEmptyBorder(20, 20, 20, 20)); contentPane.setLayout(new BorderLayout()); contentPane.add(labelPane, BorderLayout.CENTER); contentPane.add(fieldPane, BorderLayout.EAST); add(contentPane); } //Obtiene el Color seleccionado por el usuario public Color obtenerColor() { String string=(String)colorField.getSelectedItem(); Color color; if (string.equals("Azul")) color=Color.BLUE; else if (string.equals("Verde")) color=Color.GREEN; else if (string.equals("Naranja")) color=Color.ORANGE; else if (string.equals("Rojo")) color=Color.RED; else if (string.equals("Amarillo")) color=Color.YELLOW; else if (string.equals("Gris")) color=Color.GRAY; else color=Color.BLACK; return color; } //Obtiene la coordenada x del centro introducida por el usuario public int obtenerCentrox(){ if (centroxTextField.getText()!= null) return Integer.parseInt(centroxTextField.getText()); else return 0; } //Obtiene la coordenada y del centro introducida por el usuario public int obtenerCentroy(){ if (centroyTextField.getText()!= null) return Integer.parseInt(centroyTextField.getText()); else return 0; } //Obtiene el Radio introducido por el usuario public int obtenerRadio(){ if (radioTextField.getText()!= null) return Integer.parseInt(radioTextField.getText()); else return 0; }}

26

operación para leer color

operación para leer xo

operación para leer yo

operación para leer el radio


1.3 Recapitulando, contrastes y semejanzas

El enfoque estructurado y el enfoque de objetos se confunden por el arraigo

estructurado y por la libertad de expresión de los objetos, sin embargo son radicalmente

distintos.

La diferencia de pensamiento, de conceptos

Los enfoques estructurado y de objetos son dos formas distintas de pensar los

sistemas software. En este curso se considera estructurado a la forma de pensar el

software en términos de datos y funciones de transformación de datos. Y se considera

objetos a la forma de pensar el software en términos de objetos software y mensajes.

Figura 1. 9.

Figura 1. 9. Enfoque estructurado y enfoque de objetos

Desde la perspectiva del enfoque estructurado, cualquier sistema software es una

función F(X) que transforma un conjunto X de datos de entrada en otro conjunto Y de

datos de salida. Aunque F(X) es más bien una relación, se le acostumbra a llamar

función en el universo software. Las funciones y los datos son los elementos esenciales

del enfoque estructurado. Se acostumbra a expresar los requisitos del sistema a través de

de los conjuntos de entrada y salida de datos. La idea de procesar datos deviene de la

saga de ábacos y calculadoras que produjo los ordenadores o computadoras para obtener

cartas marinas y otros productos similares

27

ventana

círculo1

círculo2

sistemaX

f1

f2F(X)

X’

Y

estructurado objetos


El enfoque de objetos supone un sistema software como un grupo de objetos

(cosas) que se interrelacionan para realizar tareas. La interacción se realiza mediante

mensajes, es decir, mediante la solicitud de servicios u operaciones variables de un

objeto a otro. Los objetos y los mensajes son los elementos software esenciales del

enfoque de objetos. Los requisitos del sistema software se acostumbran a expresar

mediante tareas en sentido general, no necesariamente de procesar datos. La idea, más

amplia, de cosas que realizan tareas nació asociada con la simulación por ordenador,

pero ha desbordado ese marco por la necesidad de afrontar problemas más complejos.

La diferencia de organización. La alotropía

Cada uno de estos enfoques organiza (diseña) los sistemas software de forma

diferente y obtiene, por tanto, sistemas con propiedades diferentes aun cuando apliquen

el mismo algoritmo. La Figura 1.10 muestra dos figuras compuestas de los mismos tipos

de elementos, pero organizadas de manera distinta.

Figura 1.10. Propiedades de las formas alotrópicas

El cuadrado se aproxima a la organización interna del grafito y el triángulo a la

organización del diamante. En este caso, y también en el software, las propiedades

cambian porque cambian las relaciones entre los elementos. El cuadrado es deformable,

sin rotura, en las direcciones de incertidumbre donde los elementos se desconocen (no

se relacionan de forma directa), por ejemplo en las diagonales. Sin embargo, no es

posible deformar el cuadrado en las direcciones de certeza donde los elementos se

28

F

F

F

F

Plasticidad del cuadrado

Rigidez del triángulo

F

FF

propiedades de las formas alotrópicas


conocen, por ejemplo, en los lados. El triángulo no se puede deformar en ninguna

dirección porque todos sus componentes se conocen entre ellos. Esto es lo que sucede,

aproximadamente, en el diamante.

El grafito y el diamante son variedades alotrópicas del carbono. Ambos

materiales tienen las mismas propiedades químicas, por ejemplo ambos arden, porque

están compuestos del mismo elemento químico. Pero, desde el punto de vista físico, sus

propiedades son diferentes.

Por analogía, se podría decir que un diseño estructurado y un diseño de objetos

son variantes alotrópicas de un mismo algoritmo. El diseño estructurado se asemeja al

diamante y el diseño de objetos al grafito. Desde el punto de vista de la facilidad de

modificación, conviene diseñar software con la plasticidad del cuadrado y no con la

rigidez del triángulo. La plasticidad y otras propiedades “alotrópicas” de los diseños

software son, generalmente, más importantes para los productores que para los clientes,

aunque éstos también se benefician o perjudican con esas propiedades.

Un diseño estructurado y un diseño de objetos son diferentes, aun cuando

ejecuten el mismo algoritmo, porque tienen propiedades tan diferentes como el

diamante y el grafito. No se trata sólo de ropaje o del lenguaje de programación.

La diferencia para expresar ambigüedad

Una de las diferencias prácticas más importantes entre el enfoque estructurado y

el enfoque de objetos es la capacidad superior de los objetos para expresar alternativas o

significados diversos, es decir, ambigüedad. Durante el curso se estudiarán las diversas

causas de esta profunda, aunque inadvertida, diferencia. La causa primaria está en la

semántica de los elementos que se derivaron del origen de cada enfoque.

El enfoque estructurado utiliza dato y función de transformación de datos como

elementos del sistema software, mientras el enfoque de objetos utiliza los elementos

objeto, con el significado de cosa, y mensaje con el significado de solicitud de servicio a

una variable.

El significado ambiguo de cosa, que tienen los objetos, admite el diseño

estructurado con ropaje de objetos. Sin embargo, no es posible hacer lo contrario, es

decir, un diseño de objetos con ropaje estructurado. Ni los datos, ni las funciones de

29


transformación de datos son capaces de expresar cualquier objeto porque tienen un

significado más restringido.

El llamado tipo abstracto de dato (tad) es dato, aún cuando sea la asociación de

un tipo de dato con unas rutinas. Los objetos son más; son cosas, que no están

comprometidas a desempeñar la función de dato, ni de nada en particular.

La mayor capacidad para expresar ambigüedad de los objetos tiene varias

consecuencias importantes que también serán estudiadas durante el curso. Por ejemplo,

el enfoque de objetos se acomoda mejor a la diversidad de problemas que aborda el

software. Los objetos son más tolerantes para expresar la idea general de función, como

la función de una casa, que el enfoque estructurado obligado a expresar esa función en

términos de “entrada, proceso y salida”. No obstante, esta mayor libertad de expresión

tampoco es gratis siempre. A menudo, hay que aceptar cualidades “extrañas” como la

capacidad de pintarse, ampliarse, moverse, borrarse, etc. que tienen los círculos

software, para ajustarse al enfoque.

La ambigüedad del enfoque de objetos, también, facilita que un elemento

software, por sí solo, exprese completamente un concepto, por ejemplo círculo.

Mientras que el enfoque estructurado obliga, muchas veces, a disociarlos en funciones y

datos.

La ambigüedad del enfoque de objetos favorece la plasticidad del sistema, como

sucede en la estructura del cuadrado. Por tanto, el enfoque de objetos ayuda el

desarrollo simultáneo de los elementos del sistema y beneficia el mantenimiento, pero

no lo hace de forma automática; hay que conseguirlo con diseño.

La poca capacidad de ambigüedad que tiene el enfoque estructurado, por su

concepción del software, limita las facilidades de desarrollo simultáneo de los

elementos del sistema y las facilidades de mantenimiento. Cuando el enfoque

estructurado intenta obtener estas facilidades introduce ambigüedad en el diseño y,

entonces, se aproxima al enfoque de objetos.

La elevada dosis de ambigüedad potencial de los objetos representa un salto

cualitativo en la evolución del software en su camino hacia la solución de problemas

más complejos. La ambigüedad es un poderoso recurso de simplificación de la

30


complejidad descriptiva, como sucede en la abstracción que simplifica por ambigüedad,

y también es un recurso de simplificación de la complejidad de incertidumbre, porque

facilita la adopción de variantes. Dicho de otro modo, el enfoque de objetos es un

recurso más eficaz, que sus predecesores para enfrentar problemas complejos.

Figura 1.11 Aumento de la capacidad de ambigüedad en los elementos software

La Figura 1.11 muestra la evolución del software hacia el aumento de la

capacidad de ambigüedad de sus elementos primarios. Por una lado las variables, por

otro el código y juntos, después formando elementos más complejos. Cada paso

adelante ha representado un aumento de la ambigüedad potencial del elemento y,

consecuentemente, del modelo software.

Las clases y demás elementos por encima de los objetos son parte también del

enfoque de objetos y multiplican de manera notable la ambigüedad potencial. Por tanto,

multiplican la eficacia del enfoque de objetos. La presencia de esos elementos y la

ambigüedad asociada ayudan a simplificar los problemas, pero añaden complejidad al

enfoque de objetos. Es una herramienta más eficaz, pero más difícil de manejar. En

ingeniería, casi nada es gratis.

Las clases, clases abstractas e interfaces serán estudiadas en los próximos

capítulos junto con sus beneficios e inconvenientes.

31

ambigüedad en el modelo

variables

tipos abstractos de datos

rutinas

alternativas

recursiónlistasvectoressimples

objetos (cosas)

clases

clases abstractas

interfaces

ambigüedad

(capacidad para expresar alternativas)


Ninguno es más natural que otro

El enfoque de objetos permite a los objetos expresar un universo más amplio, sin

demasiada distorsión, dada su ambigüedad potencial. Los elementos software no tienen

que ser interpretados en términos de dato y función de transformación de datos. Sin

embargo, a pesar de esta diferencia en capacidad expresiva no se puede decir, en

términos absolutos, que un enfoque es más natural que otro. Quien está acostumbrado al

enfoque estructurado verá la solución en términos de datos y funciones de

transformación de datos, sin darse cuenta que, por ejemplo, ha disociado el concepto de

círculo.

Tanto el enfoque estructurado como el enfoque de objetos exigen expresar

cualquier idea en sus respectivos términos. Datos y funciones, para el estructurado;

objetos y mensajes, para los objetos. Es decir, cualquier concepto debe adoptar una de

esas formas, según sea el enfoque. Los conceptos que no encajen directamente con los

términos del enfoque deberán ser ajustados (distorsionados) para su tratamiento en el

sistema software. Pero los que están acostumbrados a un enfoque no percibirán, en

general, la distorsión.

Gracias a la mayor capacidad expresiva de los objetos se dice a menudo que los

objetos reflejan mejor la realidad. Pero esta idea perjudica, más que beneficia porque

reflejar la realidad:

No es el propósito de los sistemas software, salvo que sean de simulación.

Dificulta los cambios en los sistemas software

¿Qué significa? La realidad varía según el espectador.

Se amplía la idea de variable software, pero…

El enfoque de objetos enriquece el concepto de variable software porque admite

variables software (objetos) con capacidad para recordar particularidades, por ejemplo r,

x0,… y, además, con capacidad para ejecutar operaciones, por ejemplo pintar, leer, …

Mientras que en el enfoque estructurado las variables sólo son elementos pasivos, con

capacidad para recordar, que se dejan transformar por funciones.

Es frecuente confundir la idea de variable software con la idea de variable

matemática. Pero la idea de variable matemática no coincide en general con la idea de

32


variable software, en ninguno de los dos enfoques. Para el enfoque estructurado la

variable software es una posición de memoria, capaz de recordar información. Para el

enfoque de objetos, la variable software es también una posición de memoria capaz de

recordar información, pero en sentido más amplio porque recuerda operaciones y las

condiciones de ejecución. La variable matemática es un símbolo que representa a un

conjunto de valores, sin capacidad para recordar, ni ejecutar nada. Un ejemplo de

diferencia entre variable matemática y variable software se aprecia en el caso de los

círculos, donde las variables software son las constantes matemáticas de los círculos,

mientras que las variables matemáticas pasan inadvertidas en el mecanismo de dibujar

los círculos. La diferencia más marcada es la operación de asignación, frecuente en

software e inexistente en la matemática. Por ejemplo: i i + 1.

El dilema de las bases de datos

La organización diferente del software (estructurado y objetos) provoca otra

diferencia notable. El concepto de base de datos encaja perfectamente dentro del

enfoque estructurado, pero no en el enfoque de objetos porque carece del concepto de

dato. Esta diferencia y la necesidad de trabajar con bases de datos han provocado la

aparición de los conceptos de objeto persistente y de base de datos orientada a objetos,

para manejar el conjunto de objetos persistentes.

33

Documents

01Curso OO Objetos ObjetosYEstructurado