01curso OO Objetos ObjetosYEstructurado

Curso de OO dirigido por Objetos y Estructurado, dos pensamientos distintos
la introduccin de ambigedad
1. Objetos y estructurado, dos pensamientos distintos
ndice
1. Objetos y estructurado, dos pensamientos distintos......................................................1

Sobre el captulo........................................................................................................2
Motivaciones.........................................................................................................2
Objetivos................................................................................................................2
Contenido..............................................................................................................2
1.1 El enfoque estructurado, una manera de pensar el software...................................3
Ejemplo, pintar un crculo.........................................................................................3
Un programa estructurado para pintar un crculo......................................................7
Ampliar la solucin, pintar varios crculos y recordarlos..........................................9
Ampliar el programa, pintar varios crculos............................................................12
1.2 Los objetos, otra manera de pensar el software.....................................................14
Una solucin orientada a objetos para pintar varios crculos..................................19
Definicin de los conjuntos de objetos................................................................19
Definicin de las operaciones..............................................................................20
La orden de inicio................................................................................................21
Un programa orientado a objetos para pintar varios crculos..................................23
1.3 Recapitulando, contrastes y semejanzas................................................................27
La diferencia de pensamiento, de conceptos.......................................................27
La diferencia de organizacin. La alotropa........................................................28
La diferencia para expresar ambigedad.............................................................29
Ninguno es ms natural que otro.........................................................................32
Se ampla la idea de variable software, pero...................................................32
El dilema de las bases de datos............................................................................33
1
Sobre el captulo
Motivaciones
En el mundo software, por lo general, se acostumbra a cambiar de lenguaje de
programacin sin cambiar de forma de pensar el software. Siguiendo esta costumbre los
objetos se perciben como otro cambio ms 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 trminos 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 trminos estructurados y se pierden las ventajas de ambos enfoques.
Objetivos
El presente captulo 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 ambigedad.
Contenido
La primera parte El enfoque estructurado, una manera de pensar el software
describe cmo se aborda la solucin de un problema, tomando como caso particular el
dibujo de figuras geomtricas en la pantalla del ordenador.
La segunda parte Los objetos, otra manera de pensar el software describe

cmo se aborda la solucin 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 podra denominar enfoque estructurado a la forma particular de pensar el
software en trminos de funciones de transformacin de datos. El universo de discurso
se disocia en funciones y datos, y cualquier tarea se interpreta como una transformacin
de datos.
Ejemplo, pintar un crculo

Por ejemplo, el enfoque estructurado resuelve el problema de pintar crculos en
la pantalla de la siguiente manera:
1. Utiliza como universo de discurso una definicin de crculo que est acorde con los
recursos del software; en particular, utiliza la expresin algebraica que define los
puntos de un crculo. 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 crculo en concreto.
Figura 1. 1 Definicin algebraica de crculo
2. Disocia la definicin de crculo en dos partes y las reinterpreta:
3
Considera que las constantes R, x0, y0 son datos para pintar el crculo y aade
uno ms, el color del crculo.
Convierte la expresin declarativa [1] en una funcin operativa que transforma

el conjunto de datos precedentes en el conjunto de datos (x, y, color) de todos los
pxeles para pintar el crculo en la pantalla.
Como resultado final se obtiene un sistema software capaz de pintar un crculo, en

trminos de un proceso de transformacin de datos. Figura 1.2.
Figura 1.2 Sistema software como una funcin de transformacin de datos
El sistema software se expresa como una funcin F(x) que transforma el

conjunto de datos X (radio, centro y color) de un crculo, en el conjunto de datos Y
de puntos (pxeles) que constituyen la figura del crculo en la pantalla: y = f(x). A este
tipo de esquema se le denomina diagrama de flujo de datos.
Detrs del esquema subyace la disociacin de la definicin algebraica de crculo

y la conversin de la expresin declarativa en un mecanismo de clculo: la funcin
software PintarCrculo(R, x0, y0, color), que transforma las constantes del crculo en los
valores de los puntos del crculo en la pantalla.
4
El software, en general, apela a la definicin algebraica de crculo porque es un

recurso compatible con los medios que dispone; carece de los recursos usuales de la
geometra (comps, cuerda, etc.) para pintar un crculo.
La particularidad del enfoque estructurado consiste en pensar la solucin como

una funcin que transforma datos y disociar la definicin algebraica de crculo para que
se acomode a esta forma de pensar.
Si los datos del crculo se deben recibir del exterior del sistema software
entonces se utiliza una funcin adicional para la recepcin y transformacin de los
datos. Esta funcin recibe los datos R, x0, y0, C, provenientes de los equipos
perifricos (teclado, ratn,), transforma su formato y los almacena en forma de
variables software: R, x0, y0, C. Figura 1.3.
Figura 1.3 Solucin del software estructurado
La Figura 1.3 muestra la sntesis de la funcin principal del sistema software a

travs de dos funciones: LeerDatos(R, x0, y0,C) y PintarCrculo(R, x0, y0,C).
El sistema est formado por las funciones de lectura y de dibujo, y el almacn de

datos del crculo (variables software). Ningn elemento software representa, por s solo,
el concepto de crculo.
5
Los diagramas de flujos de datos definen la funcin y el funcionamiento del

sistema software. Es decir, definen que la funcin del sistema es la transformacin de un
conjunto datos de entrada en datos de salida y adems, definen cmo se sintetiza esta
funcin mediante otras funciones. El diagrama de flujo de datos es un esquema
asncrono (no expresa secuencias); las flechas slo indican los flujos de datos, no el
orden de ejecucin.
Figura 1.4. Definicin y sntesis del sistema software
La Figura 1.4 muestra la definicin de la funcin del sistema software en

trminos de entrada y salida, y la sntesis de esta funcin mediante dos funciones. Por
razones histricas, a menudo se utiliza la palabra anlisis para referirse a esta sntesis.
En trminos de pseudocdigo, el sistema software podra expresarse de la

siguiente manera:
Variables: radio, x0, y0, color
LeerDatos (radio, x0, y0, color)
PintarCrculo (radio, x0, y0, color)
La secuencia de ejecucin se aprecia directamente de la lectura del

pseudocdigo: primero se leen los datos y despus, se pinta el crculo.
6
Un programa estructurado para pintar un crculo

Los sistemas estructurados se programan en lenguajes estructurados, pero
tambin se programan en lenguajes de objetos, como Java. Programar en Java no
asegura programar con el enfoque de objetos. A continuacin se muestra la
programacin del sistema estructurado precedente usando el lenguaje Java. El entorno
grfico de ventanas distorsiona un poco la simplicidad de la idea de pintar un crculo
porque obliga a trabajar con las ventanas, pero se mantiene la esencia. El pseudocdigo
sera algo as:
Variables: radio, x0, y0, color
CrearVentana
PintarVentana vaca
LeerDatos(radio, x0, y0, color) datos del crculo que se pintar dentro de la ventana
RepintarVentana funcin que invoca a PintarCrculo (radio, x0, y0, color)
El cdigo completo puede verse en el Anexo. Seguidamente se muestra el cdigo

del programa principal. Las notas en negrita se corresponden con el pseudocdigo.
Importamos el API swing

import javax.swing.*; de Java para construir
import java.awt.*; interfaces grficas
import java.awt.event.*;
public class PintarCirculoEstructurado extends JFrame {
private int centrox, centroy, radio;

Declaramos las variables radio,
x0,y0 y color. (A x0 le hemos
private Color color;
llamado centrox y a y0 centroy)
private boolean haydatos=false;
haydatos es una variable auxiliar
public PintarCirculoEstructurado() {
}
//Asignar el Look&Feel de la ventana

private void asignarLookAndFeel()
{ Funcin para asignar a la
//Forzar el Look and Feel de la ventana al del sistema operativo ventana el look&feel o
String laf = UIManager.getSystemLookAndFeelClassName(); apariencia que tenga el sistema
try { operativo (p.ejm: en Windows
UIManager.setLookAndFeel(laf); las ventanas tienen la barra de
} ttulos en azul con texto en
blanco y el panel tiene el fondo
catch (UnsupportedLookAndFeelException exc) gris)
{System.err.println("Unsupported: " + laf);}
catch (Exception exc)
{System.err.println("Error cargando: " + laf);}
}
7
//Incluir botn cerrar ventana Funcin para incluir

private void setCloseClick() en la ventana el
{ botn para cerrarla
//Controlar el cierre de la ventana
addWindowListener(new WindowAdapter()
{ public void windowClosing(WindowEvent e)
{System.exit(0);}
});
}
public void paint (Graphics g) Funcin para pintar la ventana.

{ Para usar el API swing, el
super.paint(g); nombre de la funcin tiene que
ser obligatoriamente
//Si el usuario ha introducido los datos pinta el crculo paint(Graphics g)
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) { Programa principal
// 1. Crear la ventana y pintarla vaca

PintarCirculoEstructurado ventana = new PintarCirculoEstructurado();
ventana.setTitle("Pintar Circulo Estructurado");
ventana.asignarLookAndFeel(); CrearVentana
ventana.setCloseClick(); PintarVentana vaca
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();
LeerDatos
// 3. Obtener los datos introducidos por el usuario (radio, x0, y0,
ventana.centrox=formulario.obtenerCentrox(); color)
ventana.centroy=formulario.obtenerCentroy();
ventana.radio=formulario.obtenerRadio();
ventana.color=formulario.obtenerColor();
ventana.haydatos=true;
RepintarVentana
//4. Repintar la ventana con el circulo
ventana.repaint(); //repaint invoca internamente al mtodo "paint(Graphics g)"
8
Ampliar la solucin, pintar varios crculos y recordarlos

Las consecuencias de la disociacin que produce el enfoque estructurado sobre
los elementos del discurso se aprecian mejor cuando se aaden ms elementos, por
ejemplo crculos. Ahora se quiere pintar varios crculos y despus, actuar sobre ellos de
forma selectiva, digamos borrar el segundo crculo que se pint.
El sistema para pintar un crculo podra pintar varios crculos si se le aade un

mecanismo de bucle, pero slo recordara las constantes (datos) del ltimo crculo
porque los datos se rescribiran unos sobre otros.
Para recordar todos crculos habra que aadir tantas variables como crculos se
quiera recordar con el objetivo de retener cada conjunto de constantes. El siguiente
sistema (expresado en pseudocdigo) es capaz de pintar y recordar dos crculos:
Variables: radio1, x10, y10, color1,
radio2, x20, y20, color2
LeerDatos (radio1, x10, y10, color1)
PintarCrculo (radio1, x10, y10, color1)
LeerDatos (radio2, x20, y20, color2)
PintarCrculo (radio2, x20, y20, color2)
Se leen los datos de un crculo y se pinta el crculo, despus se leen los datos del
segundo y se pinta.
El nuevo sistema software es una duplicacin del sistema para un crculo. Por
tanto, comparte la misma esencia. El diagrama de flujo de datos slo ha engrosado el
almacn de datos como se aprecia en la Figura 1.5.
9
Figura 1.5. Solucin estructurada para ms de un crculo
Gracias a la capacidad de recordar las constantes de varios crculos, el sistema

nuevo permite actuar selectivamente sobre los crculos pintados, por ejemplo borrar,
ampliar y mover, agregando funciones destinadas a tal fin. Para ampliar el segundo
crculo se hara actuar la funcin Ampliar(zoom, radio, x0, y0, color) sobre las constantes
del segundo crculo (radio2, x20, y20, color2). Para borrar el primero se hara actuar la
funcin Borrar(radio, x0, y0, color) sobre las constantes del primer crculo.
Y tambin, gracias a esta capacidad para recordar las constantes de varios

crculos se aprecia mejor la disociacin de los crculos. El almacn de datos contiene las
constantes de los crculos en forma de variables software y la funcin PintarCrculo
contiene el mecanismo para pintar un crculo. Una vez ms, a ningn elemento del
sistema se le pueden asociar por completo las propiedades de un crculo en particular.
En general, cualquier concepto que no encaje directamente con dato o funcin de

transformacin de datos tendr que ser ajustado (distorsionado) para su tratamiento
software desde la perspectiva del enfoque estructurado. El caso de los crculos, slo es
un caso ms. Pero este hecho pasa inadvertido porque el uso frecuente del enfoque
estructurado, o de cualquier otro enfoque, se convierte en unas gafas automticas que
transforman todo en trminos del enfoque habitual, sin tener conciencia de la
transformacin.
10
La disociacin de los conceptos provoca la mezcla de partes de distintos

conceptos. Por ejemplo, se pueden mezclar datos de crculos, tringulos, rectngulos,
con funciones para pintar cada una de estas figuras. De manera que conviene distinguir,
con nombres diferentes, los datos y las funciones que actan sobre unos u otros datos.
Figura 1.6.
Figura 1.6. Mezcla de partes de conceptos
Por ejemplo, el color del crculo debe ser Cc, para distinguirlo del color del
rectngulo Cr. Los vrtices de los rectngulos debern denominarse VR, para
distinguirlos de los vrtices de los tringulos VT. Las funciones tambin debern tener
distintos nombres: PintarCrculo(radio, x0, y0, Cc), PintarRectngulo(VRs, VRi, Cr),
BorrarTringulo(VT1, VT2, VT3 ), etc.
Pero, como sucede siempre, no todo es malo. La disgregacin de los conceptos

en datos y funciones tiene efectos benficos. Por ejemplo, permite trabajar directamente
con la idea de base de datos o archivo, que existe en el mundo mucho antes de la
informtica. La coleccin permanente de datos desempea el papel de base de datos.
11
Ampliar el programa, pintar varios crculos

Veamos el cdigo Java del programa para pintar dos crculos. Los cambios sobre
el programa anterior aparecen resaltados en negrita. En las notas, los textos en negrita
corresponden al pseudocdigo.
import javax.swing.*;
import java.awt.*;
public class PintarDosCirculos extends JFrame{
private int centrox1, centroy1, radio1, centrox2, centroy2, radio2;

Declaramos las variables radio1,
private Color color1, color2; x10,,y10, y color1 de circulo1 y las
private boolean haydatos1=false; variables radio2, x20,,y20, y color2
de circulo2)
private boolean haydatos2=false;
Ahora necesitamos dos variables
public PintarDosCirculos() { auxiliares haydatos1 y haydatos2.
}

{
//Forzar el Look and Feel de la ventana al del sistema
String laf = UIManager.getSystemLookAndFeelClassName();
try {
UIManager.setLookAndFeel(laf);
}
catch (UnsupportedLookAndFeelException exc)

}
private void setCloseClick()

{
{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
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();
}
Programa principal
public static void main(String[] args) {
// 1. Crear la ventana y pintarla vaca

PintarDosCirculos ventana = new PintarDosCirculos();
ventana.setTitle("Pintar Dos Circulos");
ventana.asignarLookAndFeel();
ventana.setCloseClick();
ventana.setVisible(true);
// 2. Mostrar el formulario para obtener los datos del primer crculo

JDialog dialog=new JDialog(ventana, "Introduzca los datos del primer circulo", true);
dialog.pack();
dialog.show();
LeerDatos (radio1, x10,
// 3. Obtener los datos introducidos por el usuario
ventana.centrox1=formulario.obtenerCentrox(); y10, color1)
ventana.centroy1=formulario.obtenerCentroy();
ventana.radio1=formulario.obtenerRadio();
ventana.color1=formulario.obtenerColor();
ventana.haydatos1=true;
RepintarVentana
//4. Repintar la ventana con el primer crculo
// 5. Mostrar el formulario para obtener los datos del segundo crculo

formulario= new FormularioCirculo();
dialog=new JDialog(ventana, "Introduzca los datos del segundo circulo", true);
dialog.pack();
dialog.show();
LeerDatos (radio2, x20,
// 6. Obtener los datos introducidos por el usuario y20, color2)
ventana.centrox2=formulario.obtenerCentrox();
ventana.centroy2=formulario.obtenerCentroy();
ventana.radio2=formulario.obtenerRadio();
ventana.color2=formulario.obtenerColor();
RepintarVentana
ventana.haydatos2=true;
//7. Repintar la ventana con el segundo crculo

13
1.2 Los objetos, otra manera de pensar el software

Se podra denominar enfoque de objetos a la forma particular de pensar el
software en trminos de cosas que colaboran entre s para realizar tareas. Es una forma
de pensar ms 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 crculos, el enfoque de objetos tiene los mismos

recursos y restricciones que el enfoque estructurado para pintar los crculos. Pero piensa
la solucin de una forma diferente y en vez de disgregar las propiedades de los crculos
asocia ntegramente cada crculo 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 crculos y los formularios que recogen las constantes de los
crculos desde el exterior del sistema software. Cada elemento software contiene las
propiedades ntegras de cada elemento del discurso. El elemento crculo1 contiene sus
constantes y los mecanismos para pintarse y crearse como elemento. Igual sucede con el
14
crculo2, ventana y los formularios. Estos elementos software son variables software en
un sentido ms amplio que las variables del enfoque estructurado.
En el caso del problema de pintar los crculos, el enfoque de objetos piensa:
1. en variables software capaces de recordar las constantes de un crculo,

capaces de pintar el crculo y, adems, capaces de crearse a s misma como
variables. Es decir, piensa en unas variables cualitativamente distintas de las
variables estructuradas que slo recuerdan datos. A estas nuevas variables se
le podra denominar crculo1 y crculo2, definidas a travs del nombre y sus
propiedades:
crculo1 {radio, centro, color, crear, pintar}
crculo2 {radio, centro, color, crear, pintar}
2. que la ventana, que contiene los crculos, y los formularios, para leer las
constantes, podran ser otras variables software denominadas,
respectivamente, ventana y formulario:
ventana {crculo1, crculo2, crear, pintar}
formulario {crear, leer}
3. el sistema software en trminos de la interaccin de estas variables, dadas

sus respectivas capacidades para ejecutar operaciones. Es decir, cmo
relacionar todas las variables para conseguir que se realice la tarea de pintar
crculos.
La Figura 1.8 muestra el sistema software. Se aprecian las relaciones entre las
variables software que ejecutan la tarea de pintar crculos. 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 alotrpicas, por ejemplo el diamante y el grafito que son
qumicamente iguales, pero fsicamente muy diferentes. Despus se estudiarn con
detalle las diferencias de propiedades.
15
Figura 1.8. Sistema software con enfoque de objetos
El enfoque de objetos ampla la idea de variable software y la hace ms

abstracta, con capacidad para expresar cualquier cosa, incluso una operacin. 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), tambin 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 smbolos prximos a la notacin estndar UML, pero sin
rigor por razones de simplicidad y conveniencia pedaggica. Las cajas indican objetos y
las flechas relaciones entre ellos. En ningn caso sealan secuencias, ni flujos de datos,
entradas o salidas. Las diferencias entre flechas continuas y discontinuas sern vistas
con posterioridad.
El sistema software de la Figura 1.8 podra funcionar de la siguiente manera.

Comienza creando una variable (objeto) ventana que establece sus propias
particularidades y se pinta. Despus, este objeto ventana solicita la creacin de los
objetos crculo1 y crculo2. Cada objeto crculo, a su vez, crea un objeto formulario que
solicita en la pantalla los valores de radio, centro, color, y los asigna al objeto crculo
16
que lo cre. Al final, el objeto ventana se pinta a s mismo y le solicita a los objetos
crculo1 y crculo2 que se pinten.
Se denomina mensaje a la solicitud a un objeto para que ejecute una operacin o,

como tambin se dice, realice un servicio. Por ejemplo, la solicitud que hace el objeto
ventana a los objetos crculo1 y crculo2 para se pinten. Un mensaje es la invocacin de
una rutina contenida en un objeto, que a su vez es una variable. Por tanto, un mensaje
manifiesta una carga de ambigedad que lo diferencia profundamente de la invocacin
tradicional a una rutina. Los mensajes constituyen el mecanismo de interaccin 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 crculos) 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 disear el software,
cualitativamente distinta, que organiza el sistema y lo hace funcionar de otro modo.
Las gafas de visin estructurada podran hacer creer que pensar en objetos es lo
mismo que pensar en mdulos; que el sistema de Figura 1.8 es un sistema estructurado
dividido en mdulos, pero las gafas engaan. Los mdulos estructurados no son
variables software. Mientras que ventana, crculo1, crculo2 y formulario son variables
software que se crean y destruyen dinmicamente; 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 adems, tiene la capacidad adicional de
ejecutar operaciones. Un objeto software, no es ni dato, ni funcin, ni la suma de datos y
funciones. Un objeto es un elemento software cualitativamente distinto capaz de
expresar un concepto ms amplio, ms ambiguo: cosa.
Gracias a la ambigedad del significado (capacidad para expresar alternativas),

los objetos software pueden representar o estar asociados con cualquier cosa: crculo,
ventana, cuenta bancaria, vuelo, habitacin, regla de negocio, Los objetos software
son variables software mucho ms libres, gracias a la ambigedad, que las variables
17
software estructuradas, limitadas a la idea de dato. Las operaciones en los objetos

tambin son ms libres porque son variables, mientras que en el enfoque estructurado
son constantes.
La libertad de interpretacin 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 expresin copiar la realidad carece de sentido en trminos absolutos
y que adems, puede ser contraproducente.
En general, el software resuelve problemas, no los modela, salvo que el objetivo

sea la simulacin. La forma que el software resuelve los problemas difiere, por lo
comn, 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 geometra los crculos carecen de la propiedad de dibujarse, ni tampoco son datos
o funciones de transformacin de datos.
Los objetos crculo1 y crculo2, son piezas de la solucin software al problema

de pintar crculos. Cada uno de estos objetos software est asociado con un crculo
particular, pero no lo representa porque un objeto software es distinto de un crculo
geomtrico. Los objetos crculo1 y crculo2 son piezas del engranaje software para
resolver el problema de pintar crculos.
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
representacin (modelado) exige imitar las cualidades de lo representado. Ms adelante
se volver sobre este controvertido tema en el universo software.
La ausencia de los conceptos de dato y funcin de transformacin 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; slo hay
objetos y mensajes. Por tanto, se ha inventado la idea de objeto persistente, para
conseguir un efecto equivalente al que ofrece la coleccin permanente de datos del
enfoque estructurado. Pero esto es otra historia, para ms adelante.
18
Una solucin orientada a objetos para pintar varios crculos

La diferencia en la forma de pensar el software de objetos se refleja en los
diagramas de diseo y en el cdigo. El enfoque estructurado organiza el sistema segn
el flujo de transformacin de datos; su cdigo realza la secuencia de pasos de la tarea.
El enfoque de objetos organiza el sistema segn los elementos que participan en la
ejecucin de la tarea. Su cdigo realza estos elementos; la secuencia de pasos para la
realizacin de la tarea queda disuelta en la definicin de las operaciones
(comportamientos) de los objetos.
Por ejemplo, el programa de los crculos, consistira en:
1. definir los conjuntos de objetos que participan en la realizacin de la tarea,
2. definir las operaciones que pueden ejecutar los objetos,
3. dar la orden de iniciar la accin.
Visto en detalle:
Definicin de los conjuntos de objetos
La mayora de los lenguajes comerciales de programacin de objetos, exigen la

definicin de conjuntos de objetos, en vez de definir los objetos uno por uno. En el caso
de los crculos, los conjuntos de objetos seran, por ejemplo, Crculo, Ventana y
Formulario (para leer las constantes de los crculos).
En cada definicin se enuncian las propiedades particulares del conjunto en

trminos de atributos y operaciones. Los atributos pueden ser objetos o variables
software tradicionales. Las operaciones son rutinas, funciones, procedimientos, en fin,
cdigo capaz de ejecutar acciones. Se acostumbra denominar clase a la definicin de un
conjunto de objetos y mtodo a una operacin.
Crculo {
radio, x0, y0 : reales atributos de tipo real

color : texto atributo de tipo texto
Crculo operacin para crear objetos crculos; equivale al Crear de la Figura 1.8
Pintar operacin para pintar el crculo
19
Leer operacin para leer los atributos

}
Ventana {
crculo 1, crculo 2 : Crculo los atributos pertenecen al conjunto Crculo
Ventana operacin para crear objetos ventana; equivale al Crear de la Figura 1.8
Comienzo operacin que inicia el funcionamiento del sistema
Pintar operacin para pintar la ventana
}
Formulario {
Formulariooperacin para crear objetos formulario; equivale al Crear de la Figura 1.8
Obtener_radio operacin para leer radio
Obtener_x0 operacin para leer x0
Obtener_y0 operacin para leer y0
Obtener_color operacin para leer color
Las operaciones homnimas con los conjuntos (Crculo, Ventana y Formulario),

son operaciones especializadas en la creacin dinmica de objetos. Tienen el mismo
nombre de los conjuntos para facilitar la lectura del cdigo. Por ejemplo, v
nuevoFormulario es una lnea de pseudocdigo que crea un objeto del conjunto
Formulario y lo asigna a la variable v.
Definicin de las operaciones

Las operaciones o mtodos de los objetos se definen asociadas al conjunto. Por
ejemplo,
Crculo::Crculo {
Leer se invoca el mtodo Leer del propio objeto

}
Crculo::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 lnea radio v.Obtener_radio expresa un mensaje de un objeto crculo a un
objeto formulario para que suministre el valor del radio y lo asigne a la variable radio.
El resto de lneas sucesivas tambin expresan mensajes, de un objeto crculo a un objeto
formulario representado por la variable v. Para mantener el hilo de la explicacin se ha
simplificado el pseudocdigo.
La orden de inicio
El sistema inicia el funcionamiento cuando el intrprete o el ejecutor del
lenguaje activa la operacin Comienzo. En este curso se ha usado la palabra Comienzo
para denominar a la operacin 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 operacin Comienzo contiene slo el cdigo que inicia el funcionamiento del

sistema. Por ejemplo:
Ventana::Comienzo {
nuevaVentana crear una ventana

}
Al crearse el objeto ventana se ejecuta el cdigo definido en la siguiente
operacin:
Ventana::Ventana {
caracterizar y pintar la ventana vaca instrucciones internas
crculo1 nuevoCrculo crear el objeto crculo1
crculo2 nuevoCrculo crear el objeto crculo2
repintar la ventana pinta el contenido de la ventana llamando a la operacin pintar
}
Al llamar a la operacin pintar se ejecuta el cdigo para pintar los crculos
21
Ventana::Pintar {
pintar fondo ventana instrucciones internas
crculo1.pintar se pide a crculo1 que se pinte
crculo2.pintar se pide a crculo2 que se pinte
}
En este caso se ha colocado la operacin de comienzo en el objeto ventana, pero
podra estar situado en otro objeto, destinado especficamente a iniciar del sistema. A
menudo este objeto de inicio recibe el nombre de Principal por rmora o confusin 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 dilogos 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 ms difcil 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 pblico y a los actores para que
comience la funcin.
El enfoque de objetos utiliza una forma de programar muy distinta a la forma

tradicional. Y, efectivamente, es mucho ms complicada, al menos para los que piensan
en trminos estructurados. El cambio del modo de pensar el software es un reto difcil
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 ambigedad del mundo de los objetos para simplificar la
complejidad y facilitar los cambios en el software, como se ver despus.
22
Un programa orientado a objetos para pintar varios crculos

Veamos como se implementara el pseudocdigo anterior en lenguaje Java.
import javax.swing.*;
import java.awt.*;
public class Ventana extends JFrame{ Definicin de Ventana
private Circulo circulo1; atributos de Ventana

private Circulo circulo2;
//Crea una nueva instancia de ventana

public Ventana() {
operacin para crear
//Pintar la ventana vaca
setTitle("Pintar Circulos ");
asignarLookAndFeel();
setCloseClick();
setExtendedState(MAXIMIZED_BOTH);
setVisible(true);
//Crear un circulo y aadirlo a la ventana

circulo1=new Circulo(); Mensaje a circulo1 para que se cree
getContentPane().add(circulo1);
//Crear otro circulo y aadirlo a la ventana

circulo2=new Circulo();
getContentPane().add(circulo2); Mensaje a circulo2 para que se cree
//Repintar la ventana con los dos circulos

pack();
setExtendedState(MAXIMIZED_BOTH);
repaint(); //repaint invoca internamente al mtodo paint(g)
}

{
//Forzar el Look and Feel de la ventana al del sistema
String laf = UIManager.getSystemLookAndFeelClassName();
try {
UIManager.setLookAndFeel(laf);
}
catch (UnsupportedLookAndFeelException exc)

}
private void setCloseClick()

{
{System.exit(0);}
23
});
}
operacin para pintar
{
super.paint(g);
if (circulo1!=null)
circulo1.paint(g); Mensaje a circulo1 para que se pinte
if (circulo2!=null)
circulo2.paint(g); Mensaje a circulo2 para que se pinte
}
public static void main(String[] args) { operacin comienzo
new Ventana();
}
}
Definicin de Crculo
public class Circulo extends JComponent{
//Coordenada x del centro

private int centrox;
//Coordenada y del centro

private int centroy;
atributos de Crculo
//Radio
private int radio;
//Color
private boolean haydatos=false;

operacin para crear
// Crea una nueva instancia de Circulo
public Circulo() {
// Mostrar el formulario para obtener los datos del circulo

JDialog dialog =new JDialog();
dialog.setTitle("Introduzca los datos del circulo");
dialog.setModal(true);
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;
}
operacin para pintar
{
//Si el usuario ha introducido los datos pintar el crculo

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
public class FormularioCirculo extends JPanel { Definicin de Formulario

//Valores de los cuadros de texto
private int centrox;
private int centroy;
private int radio;
//Etiquetas de los campos de texto

private JLabel centroxLabel;
private JLabel centroyLabel; atributos de Formulario
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() {
operacin para crear
//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);
25
fieldPane.add(radioTextField);
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()
{ operacin para leer color
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(){
operacin para leer xo
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(){
operacin para leer yo
if (centroyTextField.getText()!= null)
return Integer.parseInt(centroyTextField.getText());
else
return 0;
}
//Obtiene el Radio introducido por el usuario

public int obtenerRadio(){
operacin para leer el radio
if (radioTextField.getText()!= null)
return Integer.parseInt(radioTextField.getText());
else
return 0;
}
}
26
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 expresin 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 trminos de datos y funciones de transformacin de datos. Y se considera
objetos a la forma de pensar el software en trminos 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

funcin F(X) que transforma un conjunto X de datos de entrada en otro conjunto Y de
datos de salida. Aunque F(X) es ms bien una relacin, se le acostumbra a llamar
funcin 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 travs 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
El enfoque de objetos supone un sistema software como un grupo de objetos

(cosas) que se interrelacionan para realizar tareas. La interaccin 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, ms
amplia, de cosas que realizan tareas naci asociada con la simulacin por ordenador,
pero ha desbordado ese marco por la necesidad de afrontar problemas ms complejos.
La diferencia de organizacin. La alotropa

Cada uno de estos enfoques organiza (disea) 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 alotrpicas
El cuadrado se aproxima a la organizacin interna del grafito y el tringulo a la

organizacin del diamante. En este caso, y tambin 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
conocen, por ejemplo, en los lados. El tringulo no se puede deformar en ninguna

direccin porque todos sus componentes se conocen entre ellos. Esto es lo que sucede,
aproximadamente, en el diamante.
El grafito y el diamante son variedades alotrpicas del carbono. Ambos

materiales tienen las mismas propiedades qumicas, por ejemplo ambos arden, porque
estn compuestos del mismo elemento qumico. Pero, desde el punto de vista fsico, sus
propiedades son diferentes.
Por analoga, se podra decir que un diseo estructurado y un diseo de objetos

son variantes alotrpicas de un mismo algoritmo. El diseo estructurado se asemeja al
diamante y el diseo de objetos al grafito. Desde el punto de vista de la facilidad de
modificacin, conviene disear software con la plasticidad del cuadrado y no con la
rigidez del tringulo. La plasticidad y otras propiedades alotrpicas de los diseos
software son, generalmente, ms importantes para los productores que para los clientes,
aunque stos tambin se benefician o perjudican con esas propiedades.
Un diseo estructurado y un diseo de objetos son diferentes, aun cuando

ejecuten el mismo algoritmo, porque tienen propiedades tan diferentes como el
diamante y el grafito. No se trata slo de ropaje o del lenguaje de programacin.
La diferencia para expresar ambigedad

Una de las diferencias prcticas ms 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, ambigedad. Durante el curso se estudiarn las diversas
causas de esta profunda, aunque inadvertida, diferencia. La causa primaria est en la
semntica de los elementos que se derivaron del origen de cada enfoque.
El enfoque estructurado utiliza dato y funcin de transformacin 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 diseo

estructurado con ropaje de objetos. Sin embargo, no es posible hacer lo contrario, es
decir, un diseo de objetos con ropaje estructurado. Ni los datos, ni las funciones de
29
transformacin de datos son capaces de expresar cualquier objeto porque tienen un

significado ms restringido.
El llamado tipo abstracto de dato (tad) es dato, an cuando sea la asociacin de

un tipo de dato con unas rutinas. Los objetos son ms; son cosas, que no estn
comprometidas a desempear la funcin de dato, ni de nada en particular.
La mayor capacidad para expresar ambigedad de los objetos tiene varias

consecuencias importantes que tambin sern 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 ms tolerantes para expresar la idea general de funcin, como
la funcin de una casa, que el enfoque estructurado obligado a expresar esa funcin en
trminos de entrada, proceso y salida. No obstante, esta mayor libertad de expresin
tampoco es gratis siempre. A menudo, hay que aceptar cualidades extraas como la
capacidad de pintarse, ampliarse, moverse, borrarse, etc. que tienen los crculos
software, para ajustarse al enfoque.
La ambigedad del enfoque de objetos, tambin, facilita que un elemento

software, por s solo, exprese completamente un concepto, por ejemplo crculo.
Mientras que el enfoque estructurado obliga, muchas veces, a disociarlos en funciones y
datos.
La ambigedad 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 simultneo de los elementos del sistema y beneficia el mantenimiento, pero
no lo hace de forma automtica; hay que conseguirlo con diseo.
La poca capacidad de ambigedad que tiene el enfoque estructurado, por su

concepcin del software, limita las facilidades de desarrollo simultneo de los
elementos del sistema y las facilidades de mantenimiento. Cuando el enfoque
estructurado intenta obtener estas facilidades introduce ambigedad en el diseo y,
entonces, se aproxima al enfoque de objetos.
La elevada dosis de ambigedad potencial de los objetos representa un salto

cualitativo en la evolucin del software en su camino hacia la solucin de problemas
ms complejos. La ambigedad es un poderoso recurso de simplificacin de la
30
complejidad descriptiva, como sucede en la abstraccin que simplifica por ambigedad,

y tambin es un recurso de simplificacin de la complejidad de incertidumbre, porque
facilita la adopcin de variantes. Dicho de otro modo, el enfoque de objetos es un
recurso ms eficaz, que sus predecesores para enfrentar problemas complejos.
Figura 1.11 Aumento de la capacidad de ambigedad en los elementos software
La Figura 1.11 muestra la evolucin del software hacia el aumento de la

capacidad de ambigedad de sus elementos primarios. Por una lado las variables, por
otro el cdigo y juntos, despus formando elementos ms complejos. Cada paso
adelante ha representado un aumento de la ambigedad potencial del elemento y,
consecuentemente, del modelo software.
Las clases y dems elementos por encima de los objetos son parte tambin del
enfoque de objetos y multiplican de manera notable la ambigedad potencial. Por tanto,
multiplican la eficacia del enfoque de objetos. La presencia de esos elementos y la
ambigedad asociada ayudan a simplificar los problemas, pero aaden complejidad al
enfoque de objetos. Es una herramienta ms eficaz, pero ms difcil de manejar. En
ingeniera, casi nada es gratis.
Las clases, clases abstractas e interfaces sern estudiadas en los prximos

captulos junto con sus beneficios e inconvenientes.
31
Ninguno es ms natural que otro

El enfoque de objetos permite a los objetos expresar un universo ms amplio, sin
demasiada distorsin, dada su ambigedad potencial. Los elementos software no tienen
que ser interpretados en trminos de dato y funcin de transformacin de datos. Sin
embargo, a pesar de esta diferencia en capacidad expresiva no se puede decir, en
trminos absolutos, que un enfoque es ms natural que otro. Quien est acostumbrado al
enfoque estructurado ver la solucin en trminos de datos y funciones de
transformacin de datos, sin darse cuenta que, por ejemplo, ha disociado el concepto de
crculo.
Tanto el enfoque estructurado como el enfoque de objetos exigen expresar

cualquier idea en sus respectivos trminos. Datos y funciones, para el estructurado;
objetos y mensajes, para los objetos. Es decir, cualquier concepto debe adoptar una de
esas formas, segn sea el enfoque. Los conceptos que no encajen directamente con los
trminos del enfoque debern ser ajustados (distorsionados) para su tratamiento en el
sistema software. Pero los que estn acostumbrados a un enfoque no percibirn, en
general, la distorsin.
Gracias a la mayor capacidad expresiva de los objetos se dice a menudo que los
objetos reflejan mejor la realidad. Pero esta idea perjudica, ms que beneficia porque
reflejar la realidad:
No es el propsito de los sistemas software, salvo que sean de simulacin.
Dificulta los cambios en los sistemas software
Qu significa? La realidad vara segn el espectador.
Se ampla 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, adems, con capacidad para ejecutar operaciones, por ejemplo pintar, leer,
Mientras que en el enfoque estructurado las variables slo 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

matemtica. Pero la idea de variable matemtica 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 posicin de memoria, capaz de recordar informacin. Para el
enfoque de objetos, la variable software es tambin una posicin de memoria capaz de
recordar informacin, pero en sentido ms amplio porque recuerda operaciones y las
condiciones de ejecucin. La variable matemtica es un smbolo que representa a un
conjunto de valores, sin capacidad para recordar, ni ejecutar nada. Un ejemplo de
diferencia entre variable matemtica y variable software se aprecia en el caso de los
crculos, donde las variables software son las constantes matemticas de los crculos,
mientras que las variables matemticas pasan inadvertidas en el mecanismo de dibujar
los crculos. La diferencia ms marcada es la operacin de asignacin, frecuente en
software e inexistente en la matemtica. Por ejemplo: i i + 1.
El dilema de las bases de datos

La organizacin 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
aparicin de los conceptos de objeto persistente y de base de datos orientada a objetos,
para manejar el conjunto de objetos persistentes.
33

01curso OO Objetos ObjetosYEstructurado

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

01curso OO Objetos ObjetosYEstructurado

Uploaded by

Copyright:

Available Formats

Curso de OO dirigido por Objetos y Estructurado, dos pensamientos distintos

1. Objetos y estructurado, dos pensamientos distintos

1. Objetos y estructurado, dos pensamientos distintos......................................................1

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

2) Conozcan las diferencias en la capacidad de expresar ambigedad.

La segunda parte Los objetos, otra manera de pensar el software describe

Y, por ltimo, Contrastes y semejanzas se dedica a resumir las cualidades de

1.1 El enfoque estructurado, una manera de pensar el

Ejemplo, pintar un crculo

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

Figura 1. 1 Definicin algebraica de crculo

2. Disocia la definicin de crculo en dos partes y las reinterpreta:

Convierte la expresin declarativa [1] en una funcin operativa que transforma

Como resultado final se obtiene un sistema software capaz de pintar un crculo, en

Figura 1.2 Sistema software como una funcin de transformacin de datos

El sistema software se expresa como una funcin F(x) que transforma el

Detrs del esquema subyace la disociacin de la definicin algebraica de crculo

El software, en general, apela a la definicin algebraica de crculo porque es un

La particularidad del enfoque estructurado consiste en pensar la solucin como

Figura 1.3 Solucin del software estructurado

La Figura 1.3 muestra la sntesis de la funcin principal del sistema software a

El sistema est formado por las funciones de lectura y de dibujo, y el almacn de

Los diagramas de flujos de datos definen la funcin y el funcionamiento del

Figura 1.4. Definicin y sntesis del sistema software

La Figura 1.4 muestra la definicin de la funcin del sistema software en

En trminos de pseudocdigo, el sistema software podra expresarse de la

Variables: radio, x0, y0, color

LeerDatos (radio, x0, y0, color)

PintarCrculo (radio, x0, y0, color)

La secuencia de ejecucin se aprecia directamente de la lectura del

Un programa estructurado para pintar un crculo

Variables: radio, x0, y0, color

RepintarVentana funcin que invoca a PintarCrculo (radio, x0, y0, color)

El cdigo completo puede verse en el Anexo. Seguidamente se muestra el cdigo

Importamos el API swing

public class PintarCirculoEstructurado extends JFrame {

private int centrox, centroy, radio;

//Asignar el Look&Feel de la ventana

//Incluir botn cerrar ventana Funcin para incluir

public void paint (Graphics g) Funcin para pintar la ventana.

public static void main(String[] args) { Programa principal

// 1. Crear la ventana y pintarla vaca

// 2. Mostrar el formulario para obtener los datos del circulo

Ampliar la solucin, pintar varios crculos y recordarlos

El sistema para pintar un crculo podra pintar varios crculos si se le aade un

Variables: radio1, x10, y10, color1,

radio2, x20, y20, color2

LeerDatos (radio1, x10, y10, color1)

PintarCrculo (radio1, x10, y10, color1)

LeerDatos (radio2, x20, y20, color2)

PintarCrculo (radio2, x20, y20, color2)

Figura 1.5. Solucin estructurada para ms de un crculo

Gracias a la capacidad de recordar las constantes de varios crculos, el sistema

Y tambin, gracias a esta capacidad para recordar las constantes de varios

En general, cualquier concepto que no encaje directamente con dato o funcin de

La disociacin de los conceptos provoca la mezcla de partes de distintos

Figura 1.6. Mezcla de partes de conceptos

Pero, como sucede siempre, no todo es malo. La disgregacin de los conceptos

Ampliar el programa, pintar varios crculos

public class PintarDosCirculos extends JFrame{

private int centrox1, centroy1, radio1, centrox2, centroy2, radio2;

private void asignarLookAndFeel()

catch (UnsupportedLookAndFeelException exc)