programacion orientada a objetos(tesis)

Tesis Héctor César Lazzarini

1

UUUNNNIIIVVVEEERRRSSSIIIDDDAAADDD NNNAAACCCIIIOOONNNAAALLLDDDEEE MMMIIISSSIIIOOONNNEEESSS

FFFAAACCCUUULLLTTTAAADDD DDDEEECCCIIIEEENNNCCCIIIAAASSS EEECCCOOONNNOOOMMMIIICCCAAASSS

MMMAAAEEESSSTTTRRRIIIAAA EEENNNIIINNNFFFOOORRRMMMÁÁÁTTTIIICCCAAA YYY CCCOOOMMMPPPUUUTTTAAACCCIIIÓÓÓNNN

CCCOOONNNVVVEEENNNIIIOOO CCCOOONNN LLLAAA UUUNNNIIIVVVEEERRRSSSIIIDDDAAADDD DDDEEECCCAAANNNTTTAAABBBRRRIIIAAA

TTTEEESSSIIISSS

PPPRRROOOGGGRRRAAAMMMAAACCCIIIOOONNN OOORRRIIIEEENNNTTTAAADDDAAA AAAOOOBBBJJJEEETTTOOOSSS

DDDiiirrreeeccctttooorrraaa::: MMMaaagggiiisssttteeerrr GGGlllaaadddyyysss NNNoooeeemmmííí DDDaaapppooozzzoooMMMaaaeeessstttrrraaannndddooo::: HHHéééccctttooorrr CCCééésssaaarrr LLLaaazzzzzzaaarrriiinnniii

Dirección Postal: Moreno 155 – P3600KAC Formosa – Formosa – Argentina Dirección electrónica: [email protected]


3

TABLA DE CONTENIDOS

TABLA DE CONTENIDOS........................................................................................................ 1 Agradecimientos:........................................................................................................................... 7 Prólogo .......................................................................................................................................... 9 Capitulo 1 .................................................................................................................................... 11

INTRODUCCIÓN A LA PROGRAMACIÓN ORIENTADA A OBJETOS (POO) ..................... 11 Un poco de historia de la POO........................................................................................... 11 Ideas básicas de la POO.................................................................................................... 14 Ventajas e inconvenientes de la orientación a objetos ...................................................... 15 El modelo OO ..................................................................................................................... 15 Definiciones básicas ........................................................................................................... 16 Diferencia entre el modelado por descomposición funcional y el OO................................ 17 Descomposición OO........................................................................................................... 18

Capitulo 2. ................................................................................................................................... 19 PROGRAMACIÓN ORIENTADA A OBJETOS – FIJANDO CONCEPTOS ........................... 19

Introducción. ....................................................................................................................... 19 Información ......................................................................................................................... 19 Sistemas de información. ................................................................................................... 20 Profundizando el concepto de Objeto. ............................................................................... 20 Demonios............................................................................................................................ 23 Abstracción. ........................................................................................................................ 24 Modularidad. ....................................................................................................................... 24 Encapsulación de objetos................................................................................................... 24 Reutilización. ...................................................................................................................... 25 Clase................................................................................................................................... 25 Herencia.............................................................................................................................. 26 Polimorfismo. ...................................................................................................................... 27 Jerarquías. .......................................................................................................................... 27 Mensajes............................................................................................................................. 28

Capitulo 3. ................................................................................................................................... 29 JAVA Y LA PROGRAMACIÓN ORIENTADA A OBJETOS.................................................... 29

Introducción. ¿Porqué Java?.............................................................................................. 29 Origen de Java. .................................................................................................................. 29 Características de Java ...................................................................................................... 31

Capitulo 4. ................................................................................................................................... 37 PROFUNDIZANDO CONCEPTOS DE POO – ejemplos con JAVA ...................................... 37

1. Herencia.......................................................................................................................... 38 2. Sobrescritura de métodos............................................................................................... 38 3. La clase base y la clase derivada................................................................................... 38

En Java disponemos de los paquetes básicos: ............................................................. 39 La clase base object. ...................................................................................................... 45 Métodos que pueden ser redefinidos por el programador. ............................................ 45 Concretando: .................................................................................................................. 48

4. Redefinición de métodos heredados .............................................................................. 48 Modificador final:............................................................................................................. 49

5. Clases y métodos abstractos ......................................................................................... 49 6. Polimorfismo ................................................................................................................... 49

Métodos (funciones miembro). ....................................................................................... 52 Métodos sobrecargados (overloaded)............................................................................ 54

7. Vinculación, Ligadura o Binding ..................................................................................... 49 8. Redefinición .................................................................................................................... 55

Sobrecarga de Constructores......................................................................................... 55 Objetos como parámetros .............................................................................................. 56 Paso de argumentos. ..................................................................................................... 56 El operador static............................................................................................................ 57 Las variables static ......................................................................................................... 57 Los métodos static.......................................................................................................... 58


4

El operador final.............................................................................................................. 59 9. Interfases. ....................................................................................................................... 59

¿Qué diferencia hay entre una interfase y una clase abstract?..................................... 59 Definición de interfases. ................................................................................................. 60 Utilización de interfases.................................................................................................. 60 Conceptos Útiles............................................................................................................. 61 La llamada a super. ........................................................................................................ 61

10. Permisos de acceso en java......................................................................................... 61 Accesibilidad de los Packages (paquetes)..................................................................... 61 Accesibilidad de las Variables y Métodos Miembros de una Clase. .............................. 62 Resumen de los permisos de acceso de Java............................................................... 62

11. Transformaciones de tipo: casting................................................................................ 63 Conversión de tipos primitivos........................................................................................ 63

12. Sincronización de threads (hilos). ................................................................................ 63 Capítulo 5. ................................................................................................................................... 65

Implementación de los conceptos de oo con JAVA................................................................ 65 Implementado el concepto Jerarquía ................................................................................. 65

La clase Figura ............................................................................................................... 66 La clase Rectángulo ....................................................................................................... 66 La clase Círculo .............................................................................................................. 67

Uso de la jerarquía de clases. ............................................................................................ 67 Enlace dinámico o binding.................................................................................................. 68

Ejemplo de polimorfismo. ............................................................................................... 68 Ampliación de la jerarquía de clases.................................................................................. 70

La clase Triangulo. ......................................................................................................... 71 El operador instanceof........................................................................................................ 72 En resumen:........................................................................................................................ 72 Clases y Métodos Finales................................................................................................... 73 Interfases. ........................................................................................................................... 74 Diferencias entre una Interfase y una Clase Abstracta. ..................................................... 75 Las interfases y el Polimorfismo......................................................................................... 76 Herencia simple. ................................................................................................................. 76 Composición. ...................................................................................................................... 79

La clase punto ................................................................................................................ 80 La clase Rectangulo ....................................................................................................... 81

Definiendo Clases............................................................................................................... 83 Uso de Atributos. ................................................................................................................ 85 Uso de la Definición de Clase............................................................................................. 86 Diseño e Implementación de Clases. ................................................................................. 86 Diseño de la clase: ............................................................................................................. 87 Implementación de la clase: ............................................................................................... 88

Primer Ejemplo Completo: Clase para Entrada/Salida Interactiva (InteractiveIO)......... 88 Segundo Ejemplo Completo: Clase Nombre.................................................................. 92 Programa Hello world ! Revisado ................................................................................. 100

Capítulo 6. ................................................................................................................................. 101 Calidad del Software......................................................................................................... 102 Objetivo de la Calidad en los Sistemas ............................................................................ 103 Control de la Calidad ........................................................................................................ 103 Control de Calidad del Software....................................................................................... 104 Administración de la Calidad ............................................................................................ 108 Calidad por Etapas ........................................................................................................... 110 Estándares y Modelos de Calidad en la Ingeniería de Software...................................... 111 La Norma ISO 9000.......................................................................................................... 112 El Modelo Tick IT .............................................................................................................. 114 El Modelo CMM ................................................................................................................ 115 El Modelo BOOTSTRAP................................................................................................... 118 El Modelo ISO/SPICE....................................................................................................... 120

Conclusiones......................................................................................................................... 123


5

La elección del Lenguaje de Programación ..................................................................... 123 Perspectivas a futuro ............................................................................................... 125

Bibliografía ............................................................................................................................ 131 PROGRAMAS EJEMPLO DE LOS TEMAS TRATADOS. ................................................... 133

Redefinición de métodos .................................................................................................. 133 /*Programa 1 - Versión 1*/ ........................................................................................ 133 /*Programa 1 - Versión 2*/ ........................................................................................ 134 /*Programa 1 - Versión 3*/ ........................................................................................ 135 /* Programa 2 */ .......................................................................................................... 137

Sobrecarga de métodos ................................................................................................... 138 /*Programa 1 - Versión 1*/ ........................................................................................ 138 /*Programa 1 - Versión 2*/ ........................................................................................ 139 /** Programa 2 */........................................................................................................... 141 /*Programa 3 */ ............................................................................................................. 143

Explicación del Algoritmo.................................................................................................. 144 /*Programa 4 */ ............................................................................................................. 145

Clases abstractas ............................................................................................................. 147 /** Programa 1 */........................................................................................................... 147 /**Programa 2 – versión 1*/.......................................................................................... 148 /**Programa 2 – versión 2*/.......................................................................................... 149

Polimorfismo ..................................................................................................................... 151 /*Programa 1 – versión1 */ ........................................................................................... 151 /*Programa 2 – versión 1 */ .......................................................................................... 153 /**Programa 2 – versión 2 */......................................................................................... 156 /**Programa 3 */ /**subprograma 1*/............................................................................ 160 /** subprograma 2*/ ...................................................................................................... 160 /** subprograma 3*/ ...................................................................................................... 160

Ligaduras dinámicas......................................................................................................... 163 /** Programa 1 */ /** Subprograma 1*/ ......................................................................... 163 /**Subprograma 2*/ ...................................................................................................... 164


6


7

Agradecimientos:

A toda la gente me alentó para que termine este trabajo.

A todos los profesores de España, realmente es imposible dejar de recordarlos, por su calidez humana y profesional.

A todos: un “GRACIAS” sincero.

Formosa, 14 de mayo de 2005

Introducción

9

Prólogo

Los objetivos de este trabajo son establecer las pautas básicas para introducir a los alumnos en el mundo de la Programación Orientada a Objetos (POO), en el marco de la materia PROGRAMACIÓN IV de la carrera Licenciatura en Sistemas de Información.

En este libro se enseñaran los conceptos de la Programación Orientada a Objetos con abundantes ejemplos basados en el lenguaje JAVA. Muchos de estos ejemplos van incorporando progresivamente cada nuevo concepto que se enseña, para, de esta manera, facilitar la incorporación de un nuevo concepto con un ejemplo ya visto.

He tratado, en este trabajo, de compatibilizar ambas cosas. Puntualmente, y tal lo

afirmado en el Proyecto original de esta Tesis, necesito formar a los alumnos con un concepto “entendible” de la POO, porque no debemos perder de vista que es una materia con la cual estos se reciben de Programadores Universitarios, por lo que deben aplicar inmediatamente estos conceptos.

Debo indicar que he escogido el lenguaje JAVA como soporte para explicar los

conceptos a enseñar por su popularidad comercial y su aplicación actual en Internet. Este trabajo de Tesis se ha estructurado de la siguiente manera:

� Introducción histórica. � Explicación conceptual de los temas planteados. No se incluyen ejemplos

de ningún tipo. � Explicación de los conceptos con ejemplos básicos. Se revisan los

conceptos brevemente y se aplica a un ejemplo preciso. � Presentación de programas en Java que aplican puntualmente los

conceptos impartidos. Se trata de programas que funcionan autónomamente.

� Presentación de diversos programas más genéricos que combinan varios conceptos combinados.

� Conclusiones y perspectivas a futuro. � Bibliografía utilizada. � Glosario � Listado de códigos de programas desarrollados donde se analiza cada

concepto en particular.

Capítulo 1 – Introducción a la Programación Orientada a Objetos.

11

Capitulo 1

INTRODUCCIÓN A LA PROGRAMACIÓN ORIENTADA A OBJETOS (POO)

Un poco de historia de la POO.

La programación de computadoras es una actividad humana que se ha desarrollado casi enteramente durante la segunda mitad del siglo XX. Por lo tanto podemos suponer que aún está en sus orígenes y que el futuro traerá todavía grandes adelantos técnicos y teóricos que mejorarán sus resultados.

En su corta historia, la programación ha sufrido importantes cambios, diríamos

“casi revoluciones”. Los primeros avances metodológicamente ordenados, fueron protagonizados principalmente por Wirth, Dijstra y de forma menos teórica pero quizás con más impacto por Kernighan y Ritchie. Es lo que se denominó la programación estructurada.

Los primeros lenguajes de programación eran simplemente instrucciones que se le podían dar a un autómata como una computadora, para que realizara ciertas operaciones. Así un programa no era sino una lista de instrucciones encaminadas a realizar algún cálculo.

A medida que las computadoras fueron haciéndose más sofisticadas, sus

lenguajes propios o lenguajes de máquina iban cambiando y surgió la necesidad de crear unos lenguajes intermedios que cualquier usuario pudiera aprender y que no dependieran de la máquina concreta en la que se iban a ejecutar los programas. Así surgieron varios lenguajes que se hicieron famosos y también surgieron los primeros compiladores. Un compilador es un programa que traduce las instrucciones de un lenguaje más o menos humano, a las de una máquina.

La aparición de estos lenguajes intermedios y sus compiladores marca el comienzo

de la programación como una nueva ciencia. El tremendo éxito que las computadoras tuvieron a lo largo de los años 60 fue llevando a la creación de programas cada vez más complejos que llegaban a tener miles de líneas de código.

Hacer correcciones a este tipo de programas y agregarles mejoras se fue

convirtiendo en una labor muy ardua. Ante este problema que amenazaba con convertir las computadoras en máquinas estériles, surgió un grupo de científicos de la computación, de los cuales Dijstra y Wirth son dos de los más destacados. Estos propusieron una serie de ideas que llevaron a la creación de ese nuevo concepto indicado al inicio: la programación estructurada.

Otros científicos experimentaron ideas similares creando diversos lenguajes de programación orientada a objetos como Smalltalk. En ellos se experimentó con otras ideas útiles como la definición de subclases que heredan las propiedades de su superclase o sea de la clase de la que se derivan, pero agregando variables y funciones nuevas. También surgió una idea que ayudaría a evitar los difíciles problemas que surgían en el manejo de la memoria dinámica: los constructores y destructores de objetos.


12

A principios de los 90 se popularizó un nuevo lenguaje orientado a objetos. Se trata del C++ creado por Bjarne Stroustrup. La idea de Bjarne Stroustrup fue crear un lenguaje orientado a objetos que heredara prácticamente toda la sintaxis y posibilidades del lenguaje que en ese momento era más popular entre los programadores, el lenguaje C. Este truco ayudó a popularizar la programación orientada a objetos y preparó el camino para la aparición del Java.

Los creadores de Java aprendieron bien la lección de Bjarne Stroustrup. Un nuevo

lenguaje para tener éxito debía ser muy parecido al que en el momento de su lanzamiento fuese el más popular. Así, Java se creó con un gran parecido al C++.

Pero Java es un lenguaje más puro de programación orientada a objetos, conserva

un poco del C original, pero se parece más al C++. Puede verse al C++ como un paso intermedio en la transición de la programación estructurada del C a la programación orientada a objetos más pura del Java. Microsoft está tratando de impulsar un nuevo lenguaje llamado C# (C sharp) que promete ser aún más puro como lenguaje orientado a objetos, adopta prácticamente todas las mejoras de Java y agrega algunas nuevas. Habrá que estar pendientes una vez lanzado a los programadores de sus posibles ventajas y probables desventajas (en computación nunca se gana algo sin perder otra cosa, lo importante es que en promedio las cosas vayan mejorando).

Hacia los 80’s el paradigma orientado a objetos comenzaba a madurar como un

enfoque concreto de desarrollo de software. En los últimos años esta metodología ha experimentado un gran progreso, tanto en el desarrollo de programas como en la forma de presentar las aplicaciones del sistema al usuario.

Actualmente la Tecnología Orientada a Objetos (TOO) no solo se aplica a los

lenguajes de programación, sino que también se ha propagado a los métodos de análisis y diseño y a otras áreas, tales como las bases de datos y/o las comunicaciones. Por lo tanto, para hacer desarrollo de sistemas de software basados en la TOO, hay que entender bien todos los conceptos del modelo de objetos que está detrás de ella y sus antecedentes históricos.

Uno de los defectos de la programación imperativa es que las variables globales

pueden ser utilizadas y modificar sus contenidos, desde cualquier punto del programa. Los programas que carecen de disciplina para acceder a variables globales tienden a ser inmanejables. La razón es que los módulos que acceden a estas variables no se pueden comprender completamente, de forma independiente, de todos aquellos otros módulos que también acceden a las mismas variables globales, es decir, todo está relacionado con todo.

Este problema fue detectado alrededor de 1970 por David L. Parnas, quien propuso la norma de ocultar información como solución. Su idea era encapsular cada una de las variables globales del programa en un módulo junto con sus operaciones asociadas, sólo mediante las cuales se podía tener acceso a estas variables. El resto de los módulos podrían acceder a las variables sólo de forma indirecta mediante las operaciones diseñadas a tal efecto. En la actualidad denominamos objetos a este tipo de módulos.

El primer lenguaje que introdujo los conceptos de orientación a objetos fue SIMULA 67 creado en Noruega, por un grupo de investigadores dirigido por O. J. Dahl y K. Nygaard, con el fin de realizar simulaciones discretas de sistemas reales.


13

En estos tiempos no existían lenguajes de programación que se ajustaran a sus necesidades, así que se basaron en el lenguaje ALGOL 60 y lo extendieron con conceptos de objetos, clases, herencia, el polimorfismo por inclusión (que se obtiene introduciendo la herencia de clases) y procedimientos virtuales.

El lenguaje fue utilizado sobre todo en Europa y no tuvo mucho impacto comercial, sin embargo los conceptos que se definieron en él, se volvieron sumamente importantes para el futuro del desarrollo de software.

La programación estructurada propone dos ideas básicas: no repetir código y

proteger las variables que una parte del programa usa, de que sean modificadas accidentalmente por otras partes del programa. Una sola repetición de código es fuente probable de errores y dificulta el mantenimiento de un programa. Para no repetir código hay que escribir funciones o procedimientos que se encarguen de realizar siempre lo que las diferentes repeticiones realizarían. Para proteger las variables hay que desarrollar lenguajes que permitan definir variables locales, es decir, que sólo pueden ser utilizadas dentro de una función o procedimiento. De esta manera ninguna otra función del programa puede cambiarla.

Como consecuencia de estas ideas disminuye considerablemente el tamaño de los

programas y éstos se hacen más confiables y más fáciles de corregir o mejorar. Para facilitar la programación estructurada, aparecen nuevos lenguajes, notoriamente el Pascal y el C, son los dos lenguajes de programación estructurada más conocidos.

Wirth, creador del Pascal, nunca quedó satisfecho con este lenguaje. En su

constante análisis de los hábitos de programación encontraba que todavía había muchas cosas que mejorar. Una década después del Pascal publicó otro lenguaje llamado Modula2 en el que presentaban algunas de sus ideas más recientes. Los módulos de Modula2 pretendían representar objetos o clases. Dentro de un módulo se definían variables que representaban el estado del objeto y se definían procedimientos que describían su comportamiento. Las variables y los procedimientos de un módulo podían ser de uso público o privado, exclusivos de la clase, según lo decidiera el creador del módulo. Con todo esto se mejoraba notoriamente lo instituido por el Pascal donde el concepto de procedimientos o funciones privadas no existía y se daba un paso importante hacia la programación de clases o programación orientada a objetos.

Alrededor de los años 70’s fue desarrollado el lenguaje de programación OO llamado SMALLTALK en los laboratorios Xerox en Palo Alto, EE.UU. Éste lenguaje adoptó los conceptos nombrados anteriormente como su fundamento. El hecho de ser creado en EE.UU., ayudó a que se introdujera a escala mundial el término de Orientación a Objetos (Object Oriented OO) y que cobrara importancia entre los diseñadores de lenguajes de programación.

Los puntos importantes de este lenguaje fueron, por un lado, adoptar el concepto de objeto y clase como núcleo del lenguaje y la programación interactiva, incorporando las ideas ya conocidas de lenguajes funcionales. Es decir que se tuviese un lenguaje interpretado y no compilado.

En 1985, Bjarne Stroustrup extendió el lenguaje de programación C a C++, es decir C con conceptos de clases y objetos, cerca de esta fecha, 1986, se creó desde sus bases el lenguaje EIFFEL por B. Meyer. Ambos manejan conceptos de objetos y herencia de clases. La herencia es múltiple, y se introduce pensando en dar mayor


14

flexibilidad a los desarrolladores. Sin embargo, actualmente la herencia múltiple se ha evitado por agregar complejidad en las estructuras de clases.

Ambos lenguajes tuvieron importancia entre 1985 y hasta la primera mitad de los 90’s.

En 1995 apareció JAVA, el más reciente lenguaje OO, desarrollado por la empresa

SUN Microsystems, que hereda conceptos de C++, pero los simplifica y evita la herencia múltiple. En su lugar se introduce el término de interfaz, y la herencia múltiple de interfases. Obtiene una rápida aceptación gracias a los applets, que son programas en JAVA insertados en páginas WEB dentro del código HTML.

Estos programas pueden viajar a través de la Internet y brindarle al usuario mayor interactividad con las páginas WEB. JAVA introduce también, la programación concurrente y distribuida. El lenguaje es mitad compilado y mitad interpretado dando como resultado la portabilidad a distintas plataformas. JAVA aun sigue evolucionando y se espera que en los próximos años logre la madurez adecuada para convertirse en un lenguaje de desarrollo de mayor importancia.

Ideas básicas de la POO La programación orientada a objetos es una metodología que descansa en el

concepto de objeto para imponer la estructura modular de los programas. Permite comprender el dominio del problema a resolver, al intentar construir un modelo del mundo real que envuelve nuestro sistema. Es decir, la representación de este mundo mediante la identificación de los objetos que constituyen el vocabulario del dominio del problema, su organización y la representación de sus responsabilidades.

El paradigma orientado a objetos se basa en los tres métodos de organización que utilizamos desde nuestra infancia y en los que basamos todo nuestro pensamiento:

a) la diferencia entre un objeto y sus atributos (por ejemplo, entre una

manzana y su sabor o peso), b) la diferencia entre un objeto y sus componentes (por ejemplo, entre una

manzana y su piel o semillas) y

c) la formación y distinción entre clases de objetos (por ejemplo, entre manzanas rojas, manzanas verdes, etc.)

La idea de manejar objetos reales como contenedores de estados y

comportamientos, es mucho más atractiva desde el punto de vista del usuario. De esta manera no tendrá que batallar con construcciones orientadas al computador, sino que podrá manejar objetos (y operaciones) que se asemejen más a sus equivalentes en el mundo real. La elevación del nivel de abstracción es sin duda un objetivo deseable.

Las técnicas orientadas a objetos usan un mismo modelo conceptual para el análisis, el diseño y la programación. La transición desde el análisis al diseño es tan natural que es difícil especificar donde comienza uno y donde acaba el otro.


15

Ventajas e inconvenientes de la orientación a objetos Entre las ventajas más importantes podemos destacar:

� Favorece la comunicación entre analistas, diseñadores, programadores y usuarios finales al utilizar todos los mismos modelos conceptuales.

� Esto se traduce en un aumento de la productividad, ya que la comunicación es uno de los puntos críticos en las primeras fases del proyecto.

� Se facilita la representación de estructuras complejas sin necesidad de adaptarnos a normas y modelos, ya que lo que manejamos son objetos del mundo real, lo que facilita la tarea del analista.

� La semántica de estas técnicas es más rica (al ser más natural); al usuario final le es más fácil comprender lo que el analista representa en sus modelos (ya que representa los objetos que lo rodean habitualmente)

� Favorece la modularidad, la reusabilidad y el mantenimiento del software.

� Estas técnicas son más resistentes al cambio que las tradicionales técnicas de análisis orientadas a flujos de datos.

Algunas de sus desventajas:

� Hay que ser muy cuidadosos en la creación de los objetos, ya que de ello dependerá el éxito de nuestro proyecto. Un error en estas primeras definiciones podría resultar catastrófico. Precisamente el secreto de esta técnica está en la correcta definición inicial de los objetos.

� Los estándares en este tipo de técnicas están en continua evolución, lo que exige una actualización permanente.

� Los analistas, diseñadores y desarrolladores del proyecto deben conocer las

reglas del juego y poseer suficiente experiencia en programación.

El modelo OO

Podemos indicar que se apoya en cuatro conceptos básicos:

� objeto � clase � herencia � envío de mensajes

Los primeros tres conceptos se refieren a la parte estructural o estática del modelo

y el cuarto, que corresponde a mensajes, se refiere a la parte del comportamiento dinámico.


16

Definiciones básicas

Definición de Objeto: En términos más generales, un objeto es una abstracción conceptual del mundo real que se puede traducir a un lenguaje computacional o de programación OO.

La abstracción de objeto se caracteriza por tener una identidad única que lo distingue de otros objetos.

También tiene un estado, que permite informar lo que éste representa y su

comportamiento, es decir lo que él sabe hacer. Hablando en términos computacionales, la identidad del objeto se puede interpretar como la referencia. El estado de objeto es una lista de variables conocidas como sus atributos, cuyos valores representan el estado que caracteriza al objeto.

El comportamiento es una lista de métodos, procedimientos, funciones u

operaciones que un objeto puede ejecutar a solicitud de otros objetos. Los objetos también se conocen como instancias.

Definición de Clase: Es una colección de objetos similares. Estos objetos deben

tener los mismos atributos con valores posiblemente diferentes asignados a estos, y el mismo conjunto de métodos que definen su comportamiento.

Por otro lado también se puede ver una clase como un molde, esquema o un

patrón que define la forma de sus objetos. O bien, como la estructura estática que define:

a) el esquema de estados, y b) el comportamiento que van a tener los objetos A partir de ese esquema, dinámicamente durante la ejecución de un programa, se

van a ir creando objetos que pertenezcan a esa clase. Definición de Herencia: Una clase puede heredar sus atributos y métodos a

varias subclases (la clase que hereda es llamada superclase). Esto significa que una subclase, aparte de los atributos y métodos propios, tiene incorporados los atributos y métodos heredados de la superclase.

Una subclase puede a su vez comportarse como una superclase y heredar a otras

clases, creando de esta manera la jerarquía de herencia. Cuando una clase hereda de más de una superclase se conoce como herencia múltiple.

Definición de Envío de Mensajes: ¿Qué sucede cuando los objetos desean

comunicarse entre sí?. Un objeto recibe un estímulo externo de solicitud de un servicio que se traduce en la invocación de un método de éste objeto.

Al ejecutarse el método, el objeto puede solicitar servicios de otros objetos,

enviándoles mensajes que implican a su vez la invocación de sus métodos, y dentro de estos, nuevamente invocar servicios de otros objetos y así sucesivamente. Este envío de mensajes en cascada representa el comportamiento dinámico del modelo de objetos.


17

Haciendo un paréntesis, es importante diferenciar entre lenguajes OO y lenguajes que no lo son. Tenemos lenguajes:

Base-objetos: Lenguajes que no tienen herencia. Presentan un concepto parecido a clase y alguna forma de crear objetos a partir de ésta.

Orientado a objetos: Presentan el concepto de objetos, clases y herencia de clases.

Diferencia entre el modelado por descomposición funcional y el OO. Veamos la diferencia con un ejemplo Problema: Hacer bife criollo

Resolución según la Descomposición funcional: Se declara una lista de datos, los cuales se encuentran en un espacio común. El

algoritmo divide al problema en sub-problemas o funciones, partiendo de las más complejas hasta llegar a las acciones más sencillas de realizar, llamadas también atómicas.

En todo momento la descomposición del problema se hará identificando las

acciones (verbos) que se deben realizar. Hacer bife criollo acompañado de papa se divide en dos subproblemas:

freír bifes con cebollas añadir acompañamiento

Freír bifes con cebollas presenta tres subdivisiones:

freír bifes preparar salsa con cebolla, perejil y pimientos verdes juntar bifes con la salsa

Freír bifes y juntar bifes con la salsa son actividades que ya se saben realizar

(atómicas). Sin embargo, el caso de preparar salsa con pimientos verdes aún podemos

aclararlo más:

Rehogar cebolla, el pimiento verde y el perejil Agregar 1 ajo picado chico freír la salsa

que ya son actividades atómicas.

Para el caso de añadir acompañamiento se particiona en dos actividades atómicas

añadir papa cocida


18

añadir perejil Si se deseara ahora preparar bife criollo con salsa de pimiento rojo, se tendría que

buscar cuales actividades hay que modificar. En este caso sería la parte de los datos y preparar salsa verde, rehogar cebolla pimiento verde y perejil, en el caso de nuestro ejemplo.

Sin embargo, lo complicado no termina en modificarlos, ya que no se sabe si en

alguna otra parte del sistema se puedan referenciar y entonces esto traiga problemas.

Descomposición OO La modelación de esta solución se realiza a través de los sustantivos que definen

al problema. En este caso los sustantivos (nombres) más importantes son: Bife_Criollo, Salsa_Verde, Ingredientes, Licuadora, Sartén y Acompañamiento. Todos estos van a ser nuestros objetos que internamente van a integrar datos y

operaciones, que podemos asociarlos de manera lógica a cada uno de sus conceptos. Cuando se pide haz_bife_criollo al objeto Bife_Criollo, este debe tener un método

que sabe hacer bife criollo apoyándose en el objeto Freír_Bifes_Con_Cebolla, que tiene bifes como dato y saber freír bifes cómo método.

Para el caso de Salsa de pimiento verde, Bife_Criollo le envía un mensaje

diciéndole prepárate y entonces se preparará enviando mensajes a Ingredientes que los Rehoga, Licuadora que los pica y finalmente llama a Sartén para que los fría. Finalmente Bife_Criollo le va a enviar un mensaje a Acompañamiento, para que se añada la papa y el perejil, y quede finalmente preparado nuestro plato Bife Criollo.

Es importante notar que los datos se encuentran implícitos formando parte de los

objetos. Si en este modelo se desea hacer el Bife Criollo con Salsa de Pimientos Rojos,

solo bastaría sustituir el objeto Salsa de Pimientos Verdes por el objeto Salsa de Pimientos Rojos, que se preparará, enviando mensajes a Ingredientes, Licuadora y Sartén, sin modificar nada más.

Capítulo 2 – Programación Orientada a Objetos – Fijando Conceptos.

19

Capitulo 2.

PROGRAMACIÓN ORIENTADA A OBJETOS – FIJANDO CONCEPTOS

Introducción. La Orientación a Objetos (OO) promete mejoras de amplio alcance en la forma de

diseño, desarrollo y mantenimiento del software proponiendo una solución a largo plazo a los problemas y preocupaciones que han existido desde el comienzo en el desarrollo de software:

� la falta de portabilidad del código y reusabilidad, � código que es difícil de modificar, � ciclos de desarrollo largos, y � técnicas de codificación no intuitivas.

Un lenguaje orientado a objetos que ataca estos problemas, tiene 3 características

básicas:

� debe estar basado en objetos, � debe estar basado en clases, y � ser capaz de tener herencia de clases.

Muchos lenguajes cumplen uno o dos de estos puntos; muchos menos cumplen

los tres. La barrera más difícil de sortear es usualmente la herencia. Dado que la Programación Orientada a Objetos (POO) se basa en la idea natural

de la existencia de un mundo lleno de objetos y que la resolución del problema se realiza en términos de objetos, un lenguaje se dice que está basado en objetos si soporta objetos como una característica fundamental del mismo.

El elemento fundamental de la POO es, como su nombre lo indica, el objeto. Podemos definir un objeto como un conjunto de datos y programas que poseen

estructura y forma parte de una organización. Esta definición especifica varias propiedades importantes de los objetos. En primer

lugar, un objeto no es un dato simple, sino que contiene en su interior cierto número de componentes bien estructurados. En segundo lugar, cada objeto no es un ente aislado, sino que forma parte de una organización jerárquica o de otro tipo.

Información La Información es una colección de datos que entra, fluye, se procesa y sale de un

Sistema. El dato es una representación de la información con la estructura más adecuada

para su tratamiento o proceso.


20

Sistemas de información. Un Sistema es un conjunto de objetos ordenadamente relacionados entre sí, con

arreglo a unas reglas que cooperan para aportar los procesos necesarios para el cumplimento de una función o finalidad determinada.

Un Sistema de Información se caracteriza porque sus procesos son la adquisición,

manipulación, uso, producción, almacenamiento y distribución de información.

Profundizando el concepto de Objeto. Las personas tienen una idea clara de lo que es un objeto: conceptos adquiridos

que nos permiten sentir y razonar acerca de las cosas del mundo. Un objeto podría ser real o abstracto, por ejemplo una organización, una factura, una figura en un graficador, una pantalla de usuario, un avión, un vuelo de avión, etc.

En el análisis y diseño orientados a objetos (OO), interesa el comportamiento del

objeto. Si se construye software, los módulos de software OO se basan en los tipos de objetos.

El software que implanta el objeto contiene estructuras de datos y operaciones que

expresan dicho comportamiento. Las operaciones se codifican como métodos. Entonces, dentro del software orientado a objeto, un objeto es cualquier cosa, real

o abstracta, acerca de la cual almacenamos datos y los métodos que controlan dichos datos.

Un objeto puede estar compuesto por otros objetos. Estos últimos a su vez

también pueden estar compuestos por otros objetos. Esta intrincada estructura es la que permite construir objetos muy complejos.

Tipo de objeto.

Los conceptos que poseemos se aplican a tipos determinados de objetos. Por ejemplo, “empleado” se aplica a los objetos que son personas empleadas por alguna organización. Algunas instancias de empleado podrían ser Juan Pérez, José Martínez, etc.

En el análisis orientado a objetos, estos conceptos se llaman tipos de objetos; las

instancias se llaman objetos. Así, un tipo de objeto es una categoría de objeto, mientras que un objeto es una

instancia de un tipo de objeto. En el mundo de las bases de datos existen los tipos de entidad, como cliente o

empleado. Existen muchas instancias de cada tipo de entidad (como Juan Pérez o José Martínez para el tipo de entidad empleado). Del mismo modo, en OO se define tipos de objetos e instancias de tipo de objeto.


21

Sin embargo, el término objeto tiene diferencias fundamentales con el término entidad, ya que la entidad sólo se refiere a los datos, mientras que objeto se refiere a los datos y a los métodos mediante los cuales se controlan a los propios datos.

En OO, la estructura de datos y los métodos de cada tipo de objeto se manejan

juntos. No se puede tener acceso o control de la estructura de datos excepto mediante los métodos que forman parte del tipo de objeto. Estructura de un objeto.

Un objeto puede considerarse como una especie de cápsula dividida en tres partes:

� Relaciones � Propiedades � Métodos

Cada uno de estos componentes desempeña roles totalmente independientes:

� Las relaciones permiten que el objeto se inserte en la organización y están formadas esencialmente por punteros a otros objetos.

� Las propiedades distinguen un objeto determinado de los restantes que forman parte de la misma organización y tiene valores que dependen de la propiedad de que se trate. Las propiedades de un objeto pueden ser heredadas a sus descendientes en la organización.

� Los métodos son las operaciones que pueden realizarse sobre el objeto, que normalmente estarán incorporados en forma de programas (código) que el objeto es capaz de ejecutar y que también pone a disposición de sus descendientes a través de la herencia.

Veamos en detalle estos 3 conceptos:

1) Las relaciones entre objetos son, precisamente, los enlaces que permiten a un

objeto relacionarse con aquellos que forman parte de la misma organización.

Las hay de dos tipos fundamentales:

� Relaciones jerárquicas. Son esenciales para la existencia misma de la aplicación porque la construyen. Son bidireccionales, es decir, un objeto es padre de otro cuando el primer objeto se encuentra situado inmediatamente encima del segundo en la organización en la que ambos forman parte; asimismo, si un objeto es padre de otro, el segundo es hijo del primero. Una organización jerárquica simple puede definirse como aquella en la que un objeto puede tener un solo padre, mientras que en una organización jerárquica compleja un hijo puede tener varios padres.

� Relaciones semánticas. Se refieren a las relaciones que no tienen nada que ver con la organización de la que forman parte los objetos que las establecen. Sus propiedades y consecuencias solo dependen de los


22

objetos en sí mismos (de su significado) y no de su posición en la organización.

Veámoslo con un ejemplo: supongamos que vamos a construir un diccionario

informatizado que permita al usuario obtener la definición de una palabra cualquiera. Supongamos que, en dicho diccionario, las palabras son objetos y que la organización jerárquica es la que proviene de forma natural de la estructura de nuestros conocimientos sobre el mundo.

La raíz del diccionario podría llamarse TEMAS. De éste término genérico,

descenderán 3 grandes ramas de objetos llamadas VIDA, MUNDO y HOMBRE. El primero (VIDA) comprenderá las ciencias biológicas: Biología y Medicina. El segundo (MUNDO), las ciencias de la naturaleza inerte: las Matemáticas, la Física, la Química y la Geología. El tercero (HOMBRE) comprenderá las ciencias humanas: la Geografía, la Historia, etc.

Aplicamos el ejemplo: establecemos la relación trabajo entre los objetos NEWTON

y ÓPTICA y la interpretaremos diciendo que significa que Newton trabajó en Óptica. La relación es, evidentemente, semántica, pues no establece ninguna connotación jerárquica entre NEWTON y ÓPTICA y su interpretación depende exclusivamente del significado de ambos objetos.

La existencia de esta relación nos permitirá responder a preguntas como: ¿Quién trabajó en óptica?, ¿En qué trabajó Newton?, ¿Quién trabajó en Física? Las dos primeras se deducen inmediatamente de la existencia de la relación

trabajo. Para la tercera observamos que si Newton trabajó en Óptica automáticamente sabemos que trabajó en Física, por ser óptica una rama de la Física (en nuestro diccionario, el objeto ÓPTICA es hijo del objeto FÍSICA). Entonces gracias a la POO podemos responder a la tercera pregunta sin necesidad de establecer una relación entre NEWTON y FÍSICA, apoyándonos sólo en la relación definida entre NEWTON y ÓPTICA y en que ÓPTICA es hijo de FÍSICA. De este modo se elimina toda redundancia innecesaria y la cantidad de información que tendremos que definir para todo el diccionario será mínima.

2) Propiedades. Todo objeto puede tener cierto número de propiedades, cada una

de las cuales tendrá, a su vez, uno o varios valores. En POO, las propiedades corresponden a las clásicas “variables” de la

programación estructurada. Son, por lo tanto, datos encapsulados dentro del objeto, junto con los métodos (programas) y las relaciones (punteros a otros objetos).

Las propiedades de un objeto pueden tener un valor único o pueden contener un

conjunto de valores más o menos estructurados (matrices, vectores, listas, etc.). Además, los valores pueden ser de cualquier tipo (numérico, alfabético, etc.) si el sistema de programación lo permite.

Pero existe una diferencia con las "variables", y es que las propiedades se pueden

heredar de unos objetos a otros. En consecuencia, un objeto puede tener una propiedad de maneras diferentes:


23

� Propiedades propias. Están formadas dentro de la cápsula del objeto.

� Propiedades heredadas. Están definidas en un objeto diferente, antepasado de éste (padre, abuelo, etc.). A veces a estas propiedades se les llama “propiedades miembro” porque el objeto las posee por el mero hecho de ser miembro de una clase.

3) Métodos. Los métodos especifican la forma en que se controlan los datos de

un objeto. Los métodos, en un tipo de objeto sólo hacen referencia a la estructura de datos de ese tipo de objeto. No deben tener acceso directo a las estructuras de datos de otros objetos. Para utilizar la estructura de datos de otro objeto, deben enviar un mensaje a éste.

Un objeto entonces es “una cosa” cuyas propiedades están representadas por

tipos de datos y su comportamiento por métodos.

El método es una operación que realiza el acceso a los datos. Podemos definir método como un programa procedimental o procedural escrito en cualquier lenguaje, que está asociado a un objeto determinado y cuya ejecución sólo puede desencadenarse a través de un mensaje recibido por éste o por sus descendientes.

Sinónimos de “método”, son todos aquellos términos que se han aplicado tradicionalmente a los programas, como procedimiento, función, rutina, etc. Sin embargo, es conveniente utilizar el término “método” para que se distingan claramente las propiedades especiales que adquiere un programa en el entorno POO, que afectan fundamentalmente a la forma de invocarlo (únicamente a través de un mensaje) y a su campo de acción, limitado a un objeto y a sus descendientes, aunque posiblemente no a todos.

Los métodos son programas, por lo tanto, tienen argumentos o parámetros. Como los métodos pueden heredarse de unos objetos a otros, un objeto puede

disponer de un método de dos maneras diferentes:

� Métodos propios. Están incluidos dentro de la cápsula del objeto.

� Métodos heredados. Están definidos en un objeto diferente, antepasado de éste (padre, abuelo, etc.). A veces estos métodos se llaman métodos miembro porque el objeto los posee por el mero hecho de ser miembro de una clase.

Demonios. Es un tipo especial de métodos, relativamente poco frecuente en los sistemas de

POO, que se activa automáticamente cuando sucede algo especial. Es decir, es un programa, como los métodos ordinarios, pero se diferencia de estos porque su ejecución no se activa con un mensaje, sino que se desencadena automáticamente cuando ocurre un suceso determinado: la asignación de un valor a una propiedad de un objeto, la lectura de un valor determinado, etc.


24

Los demonios, cuando existen, se diferencian de otros métodos por que no son heredables y porque a veces están ligados a una de las propiedades de un objeto, más que al objeto entero.

Abstracción. La Abstracción es una descripción especial simplificada de un sistema que hace

énfasis en ciertos rasgos y suprime otros. La buena abstracción es aquella que logra hacer énfasis en los detalles

significativos o relevantes de la solución y discrimina cualquier otra característica. Con esto se consigue un mapeo de los objetos del mundo real a los objetos del sistema.

Por ejemplo, la perspectiva de ver a un gato es muy distinta entre una abuela

amorosa y un médico veterinario. La abuela hará una abstracción fijándose en rasgos afectivos y de cuidado mientras que el veterinario lo verá como un objeto anatómico-fisiológico de estudio.

Modularidad. La Modularidad es una partición funcional de todo el sistema. Cada módulo o parte

del sistema debe contar tanto con una funcionalidad clara y relativamente sencilla como con una facilidad de combinarse con otros módulos.

Condicionantes tales como limitación de memoria, o las características de los

compiladores o lenguajes particulares, inducen a la modularidad, pero el principio en la Tecnología Orientada a Objetos, es dividir funcionalmente buscando la interrelación más rica entre módulos.

Una división temática de los módulos es una manera muy conveniente de

equilibrar la modularización. De esta manera, un módulo puede ser el de los cálculos numéricos mientras que otro, el de las operaciones con cadenas, o bien, un módulo puede ser el de las variables generales y de arranque y configuración de un sistema, Un segundo módulo alojará las clases primitivas, de las cuales se derivarán siempre para su uso otras clases y un tercer módulo tendrá las clases que usan a las primitivas.

En el caso de nuestro gato, lo veríamos descompuesto en unidades funcionales.

Su corazón funciona muy bien, al igual su cuello y cola, cada parte debe ensamblar perfectamente con las de su entorno para formar un gato completo.

Encapsulación de objetos. En forma sucinta y concreta, podemos decir que es el “principio por el cual se

deben modelar al mismo tiempo y de forma inseparable Métodos y Datos”. La Interfaz representa la frontera y el lugar de paso en la comunicación del objeto

con el mundo exterior.


25

El empaque conjunto de datos y métodos se llama encapsulado. El objeto esconde sus datos de los demás objetos y permite el acceso a los datos mediante sus propios métodos. Esto recibe el nombre de “ocultamiento de información”.

El encapsulamiento evita la corrupción de los datos de un objeto. Si todos los programas pudieran tener acceso a los datos de cualquier forma que quisieran los usuarios, los datos se podrían corromper o utilizar de mala manera. El encapsulado protege los datos del uso arbitrario o accidental.

El encapsulado oculta los detalles de su implantación interna a los usuarios de un objeto. Los usuarios se dan cuenta de las operaciones que puede solicitar del objeto, pero desconocen los detalles de cómo se lleva a cabo la operación. Todos los detalles específicos de los datos del objeto y la codificación de sus operaciones están fuera del alcance del usuario.

Así, encapsulado es el resultado (o acto) de ocultar los detalles de implantación de un objeto respecto de su usuario.

El encapsulado, al separar el comportamiento del objeto de su implantación, permite la modificación de ésta sin que se tengan que modificar las aplicaciones que lo utilizan.

Esto no quiere decir, sin embargo, que sea imposible conocer lo necesario respecto a un objeto y a lo que él contiene. Si así fuera, no se podría hacer gran cosa con él. Lo que sucede es que las peticiones de información a un objeto deben realizarse a través de mensajes dirigidos a él, con la orden de realizar la operación pertinente. La respuesta a estas órdenes será la información requerida, siempre que el objeto considere que quien envía el mensaje está autorizado para obtenerla.

Reutilización. El hecho de que cada objeto sea una cápsula, facilita enormemente que un objeto

determinado pueda ser transportado a otro punto de la organización, o incluso a otra organización totalmente diferente que precise de él. Si el objeto ha sido bien construido, sus métodos seguirán funcionando en el nuevo entorno sin problemas. Esta cualidad hace que la POO sea muy apta para la reutilización de programas.

Clase. La clase es una colección de objetos con características comunes. Las clases son

entidades conceptuales que sirven para abstraer y modelizar un sistema. Toda clase posee 2 tipos o clases de componentes:

� Una estática: los datos. Caracterizan los posibles estados que pueden adoptar los Objetos de la Clase en un instante determinado.

� Otra dinámica: los métodos. Caracterizan los posibles comportamientos de los Objetos de la Clase a lo largo de su existencia.


26

Los criterios de clasificación de una Clase son:

� Atributos: Variables que tomarán ciertos valores (Datos) en un estado del Objeto. Definen la estructura o componente estática de los Objetos.

� Eventos: Estímulos ante los que reaccionan los Objetos cambiando de

Estado.

� Funciones: Ante un evento, actúan sobre los datos haciendo que el Objeto cambie de estado. Determinan la componente dinámica de los Objetos.

Así, una clase es una creación de un tipo de objeto. Especifica una estructura de

datos y los métodos operativos permisibles que se aplican a cada uno de sus objetos.

Herencia.

Es una relación transitiva entre clases, que permite a un objeto de una clase utilizar como propios los datos y métodos definidos en otra clase. Por ejemplo: La clase cliente hereda de la clase persona sus métodos y datos.

La clase padre se suele denominar superclase.

La clase hija se suele denominar subclase, descendiente, derivada,

especialización o heredada.

La Subclase consta de dos tipos de características:

� Estructura o comportamiento heredado de la superclase. � Estructura o comportamiento propios.

La subclase se especializa de las siguientes formas:

� Enriquecimiento: Estructura o comportamiento añadidos como propios. � Ocultación: Estructura o comportamiento heredado y anulado � Sustitución: Estructura o comportamiento heredado y redefinido

Ejemplos de herencia.

Dijimos que un tipo de objeto de alto nivel puede especializarse en tipos de objetos de bajo nivel.

Por ejemplo, el tipo de objeto persona, puede tener subtipos estudiante y

empleado. A su vez, el tipo de objeto estudiante puede tener como subtipo estudiante de pre-grado y estudiante de post-grado, mientras que empleado puede tener como subtipo a académico y administrativo. Existe de este modo una jerarquía de tipos, subtipos, sub-subtipos, etc.

Entonces, una clase implanta el tipo de objeto. Una subclase hereda propiedades

de su clase padre; una sub-subclase hereda propiedades de las subclases; etc.


27

Una subclase puede heredar la estructura de datos y los métodos de su superclase. También tiene sus propios métodos e incluso sus propios tipos de datos.

Tipos de herencia.

� Simple: Se hereda de una sola clase. � Múltiple: Se hereda de dos o más clases.

Polimorfismo.

Una de las características fundamentales de la POO es el polimorfismo, que no es otra cosa que la posibilidad de construir varios métodos con el mismo nombre, pero con relación a la clase a la que pertenece cada uno, con comportamientos diferentes.

Esto conlleva la habilidad de enviar un mismo mensaje a objetos de clases

diferentes. Estos objetos recibirían el mismo mensaje global pero responderían a él de formas diferentes; por ejemplo, un mensaje "+" a un objeto ENTERO significaría suma, mientras que para un objeto STRING significaría concatenación.

Jerarquías. Organización de los objetos

En principio, los objetos forman siempre una organización jerárquica, en el sentido de que ciertos objetos son superiores a otros de cierto modo. Existen varios tipos de jerarquías: serán simples cuando su estructura pueda ser representada por medio de un "árbol". En otros casos puede ser más compleja.

En cualquier caso, sea la estructura simple o compleja, podrán distinguirse en ella

3 niveles de objetos:

� La raíz de la jerarquía: Se trata de un objeto único y especial. Este se caracteriza por estar en el nivel más alto de la estructura y suele recibir un nombre muy genérico, que indica su categoría especial, como por ejemplo objeto madre, raíz o entidad.

� Los objetos intermedios: Son aquellos que descienden directamente de la raíz y que a su vez tienen descendientes. Representan conjuntos o clases de objetos, que pueden ser muy generales o muy especializados, según la aplicación. Normalmente reciben nombres genéricos que denotan al conjunto de objetos que representan, por ejemplo, VENTANA, CUENTA, FICHERO.

� Los objetos terminales: Son todos aquellos que descienden de una clase o

subclase y no tienen descendientes. Suelen llamarse casos particulares,instancias o ítem, porque simbolizan los elementos del conjunto representado, por la clase o subclase a la que pertenecen.

La jerarquía es el orden por niveles de todas las abstracciones.


28

Las dos partes más importantes de la jerarquía son la estructura de clases y la estructura de objetos. La primera establece todas las relaciones de herencia en sus modalidades permitidas, la segunda, la dinámica de mensajes.

La organización de todas las abstracciones logradas en un sistema está en un

orden riguroso que categoriza objetos de un mismo o semejante tipo dentro de una misma categoría.

Así al hablar de manzanas, podremos hablar de las amarillas, las rojas, o las

verdes, pero en otra categoría hablaremos de sus componentes, pulpa, piel, semilla, y posiblemente en una categoría más inferior de sus tejidos. Ni los tejidos sabrán a qué componente pertenecen ni los componentes a qué manzana pertenecen.

La abstracción superior no sabe de sus constituyentes ínfimos y viceversa. Cada

abstracción debe connotar un nivel.

Mensajes Para que un objeto haga algo, le enviamos una solicitud. Esta hace que se

produzca una operación. La operación ejecuta el método apropiado y, de manera opcional, produce una respuesta. El mensaje que constituye la solicitud contiene el nombre del objeto, el nombre de una operación y, a veces, un grupo de parámetros.

La programación orientada a objetos es una forma de diseño modular en la que con frecuencia el mundo se piensa en términos de objetos, operaciones, métodos y mensajes que se transfieren entre tales objetos. Un mensaje es una solicitud para que se lleve a cabo la operación indicada y se produzca el resultado.

Los objetos pueden ser muy complejos, puesto que pueden contener muchos sub-objetos, éstos a su vez pueden contener otros, etc. La persona que utilice el objeto no tiene que conocer su complejidad interna, sino la forma de comunicarse con él y la forma en que le responde.

29

Capitulo 3.

JAVA Y LA PROGRAMACIÓN ORIENTADA A OBJETOS

Introducción. ¿Porqué Java? Java es un lenguaje puro Orientado a Objetos, es decir cumple perfectamente el

paradigma de OO. Se ha elegido este lenguaje para ejemplificar los siguientes conceptos de PPO:

� Objetos � Clase � Modularidad � Herencia � Jerarquías � Abstracción � Encapsulación � Ligaduras Dinámicas o Binding � Mensajes. � Polimorfismo o Sobrecarga � Redefinición

Es un lenguaje de programación relativamente joven, a pesar de ello, desde su aparición hasta nuestros días, el crecimiento de su uso ha sido vertiginoso. Esto se debe en gran parte a la naturaleza misma del lenguaje, que ha permitido a los creadores de Java añadir al lenguaje bibliotecas de clases que pueden ser fácilmente adaptadas a las necesidades del desarrollador de software.

Sun Microsystems, es la empresa que ha desarrollado el lenguaje Java, en un

intento de resolver simultáneamente todos los problemas que se le plantean a los desarrolladores de software por la proliferación de arquitecturas incompatibles, tanto entre las diferentes máquinas como entre los diversos sistemas operativos y sistemas de ventanas que funcionaban sobre una misma máquina, añadiendo la dificultad de crear aplicaciones distribuidas en una red como Internet.

Origen de Java. Entre las “leyendas” más difundidas, respecto del origen del lenguaje Java, se

encuentra aquella que dice que: En enero de 1991, James Gosling, Mike Sheridan, Chris Warth, Ed Frank y Patrick

Naughton, entre otros, de Sun Microsystems, se reúnen y toman la idea de que el futuro de la Informática pasa porque todos los electrodomésticos y productos de consumo estén controlados por un ordenador. Muchos han colaborado en el diseño y evolución del lenguaje: Bill Joy, Arthur van Hoff, Jonathan Payne, Frank Yellin y Tim Lindholm, por citar algunos de ellos.

Tras unos comienzos dudosos, Sun decidió crear una filial, denominada

FirstPerson Inc., para dar margen de maniobra al equipo responsable del proyecto.

Capítulo 3 – Java y la Programación Orientada a Objetos.

30

El mercado, inicialmente previsto para los programas de FirstPerson, eran los equipos domésticos: microondas, tostadoras y, fundamentalmente, televisión interactiva. Este mercado, dada la falta de pericia de los usuarios para el manejo de estos dispositivos, requería interfases mucho más cómodos e intuitivos que los sistemas de ventanas que proliferaban en el momento.

Otros requisitos importantes a tener en cuenta eran la fiabilidad del código y la

facilidad de desarrollo. James Gosling, el miembro del equipo con más experiencia en lenguajes de

programación, decidió que las ventajas aportadas por la eficiencia de C++ no compensaban el gran coste de pruebas y depuración. James Gosling había estado trabajando en su tiempo libre en un lenguaje de programación que él había llamado Oak, el cual, aún partiendo de la sintaxis de C++, intentaba remediar las deficiencias que iba observando.

Los lenguajes como C o C++, deben ser compilados para un chip, y si se cambia el

chip, todo el software debe compilarse de nuevo. Esto encarece mucho los desarrollos y el problema es especialmente sentido en el campo de la electrónica de consumo. La aparición de un chip más barato y, generalmente, más eficiente, conduce inmediatamente a los fabricantes a incluirlo en las nuevas series de sus cadenas de producción, por pequeña que sea la diferencia en precio ya que, multiplicada por la tirada masiva de los aparatos, supone un ahorro considerable. Por tanto, Gosling decidió mejorar las características de Oak y utilizarlo.

El primer proyecto en que se aplicó este lenguaje recibió el nombre de Proyecto

Verde (Green Project) y consistía en un sistema de control completo de los aparatos electrónicos y el entorno de un hogar. Para ello se construyó un ordenador experimental denominado *7 (Star Seven), estamos hablando del año 1992. El sistema presentaba una interfaz basada en la representación de la casa de forma animada y el control se llevaba a cabo mediante una pantalla sensible al tacto. En el sistema aparecía Duke, la actual mascota de Java (esa especie de pingüinito de cabeza negra, cuerpo blanco y nariz roja). Posteriormente se aplicó a otro proyecto denominado VOD (Video On Demand) en el que se lo empleaba como interfaz para la televisión interactiva. Ninguno de estos proyectos se convirtió nunca en un sistema comercial, pero fueron desarrollados enteramente en un Java primitivo y fueron como su bautismo de fuego.

En 1993, la compañía de TV, Time Warner, pretende introducirse en el mercado de

la televisión interactiva. Sun y Silicon Graphics compiten para hacerse con el proyecto. Lo consigue Sun. Una vez que en Sun se dieron cuenta de que a corto plazo la televisión interactiva no iba a ser un gran éxito, urgieron a FirstPerson a desarrollar con rapidez nuevas estrategias que produjeran beneficios. No lo consiguieron y FirstPerson cerró en la primavera de 1994. Los miembros del equipo, al que pertenece James Gosling, pasan a Sun Interactive, otra filial de Sun creada en 1994.

En paralelo, aparece en 1993 el navegador NCSA Mosaic, que facilitará el acceso interactivo a la Internet. El número de usuarios de la Internet crece exponencialmente. En 1994, Bill Joy decide escribir un navegador (WebRunner, tipo Mosaic) en código Oak, en principio, sólo como una demo, que se convertirá más adelante en HotJava en septiembre de dicho año. James Gosling escribe un compilador de Java. Hoffman escribe otro en Java.


31

En marzo de 1995, la versión “1.0a” sale al mundo exterior y el código fuente de Java se distribuye en Internet.

Y bueno ...., a partir de allí el uso intensivo de Java no ha parado de crecer. Lo mejor será hacer caso omiso de las historias que pretenden dar carta de

naturaleza a la clarividencia industrial de sus protagonistas; porque la cuestión es si, independientemente de su origen y entorno comercial, Java ofrece soluciones a nuestras expectativas. Porque tampoco vamos a desechar la penicilina aunque haya sido su origen fruto de la casualidad.

Recomiendo leer en Internet, una muy completa historia de Java en la siguiente

dirección: http://ei.cs.vt.edu/~wwwbtb/book/chap1/java_hist.html

Características de Java Es importante ver las características del lenguaje Java, para decidir si lo utilizamos

o no, según el tipo de trabajo que debemos encarar. Estas características seguramente son opinables según el punto de vista que se las analice. Algunas de ellas son:

Tamaño reducido

Simplicidad

Portabilidad

Interpretado

Distribuido

Robusto

Seguro

Programación concurrente y distribuida

Dinámico

Liberación de memoria no utilizada

Manejo de Arreglos

Manejo de excepciones

Analicemos estas características individualmente:

� Reducido: Todo el paquete de desarrollo que incluye la librería de clases, los programas de compilación, interpretación, depuración, aplicaciones, Applets ejemplo, etc., ocupa aproximadamente 10 Mb en disco.

� Simple: Porque, prácticamente sin saber mucho de programación, se aprende a hacer Applets y aplicaciones fácilmente; pudiéndose obtener resultados en poco tiempo. Java ofrece toda la funcionalidad de un lenguaje


32

potente, pero sin las características menos usadas y más confusas de éstos.

C++ es un lenguaje que adolece de falta de seguridad, pero es muy difundido, por ello, Java se diseñó para ser parecido a C++ y así facilitar un rápido y fácil aprendizaje.

Java elimina muchas de las características de otros lenguajes como C++, para mantener reducidas las especificaciones del lenguaje y añadir características muy útiles como el reciclador de memoria dinámica (ver explicación detallada más abajo).

Java reduce en un 50% los errores más comunes de programación con lenguajes como C y C++ al eliminar muchas de las características de éstos, entre las que destacan:

a. aritmética de punteros

b. no existen referencias

c. registros (struct)

d. definición de tipos (typedef)

e. macros (#define)

f. necesidad de liberar memoria (free)

� Portable, Interpretado: este era el principal objetivo que Sun buscaba, pues permite interpretar los programas Java desde cualquier plataforma de programación. Y es un lenguaje de plataforma independiente, tanto, al nivel de código fuente, como al nivel binario.

Podemos escribir código Java en una plataforma y marcharnos a otra con la garantía de que ésta también entenderá el código fuente sin necesidad de tener que rescribirlo.

Por otro lado, los archivos binarios Java resultado de la ejecución, conocidos por bytecodes, podrán ejecutarse desde cualquier plataforma sin necesidad de ninguna recompilación. Los bytecodes equivalen a código máquina pero sin ser específicos de ningún procesador. Esto es así porque para ejecutar los programas en Java se hacen dos operaciones:

1) la compilación obteniendo los bytecodes (usando el compilador javac.exe) y

2) la interpretación de estos desde cada plataforma con el intérprete Java (usando java.exe).

El inconveniente del uso de bytecodes, como tenemos ocasión de ver cuando cargamos un Applet desde una página web, es la pérdida de velocidad de ejecución.

� Robusto, Seguro: permite la transferencia y el manejo de datos sin errores aparentes; siempre será posible la caída de la red o de nuestra maquina. Cada vez que se transfiere al ordenador de un usuario un programa, se corre el riesgo de recibir un virus, caballos de Troya, etc.

Además, existen otros programas maliciosos contra los que hay que protegerse: estos programas pueden recoger información privada del usuario como números de tarjetas de crédito, cuentas bancarias y palabras


33

de acceso que pueden ser obtenidas analizando el contenido del sistema de ficheros local de la computadora cliente.

Java establece un cortafuegos (firewall) entre una aplicación de red y la computadora local: cuando se carga desde el navegador de un usuario una página web que contiene un applet Java, no hay ningún peligro de ser infectados por un virus o a recibir intentos de accesos malintencionados. Java consigue esto creando un entorno de ejecución aislado para ese applet, que no tiene acceso a los recursos locales de la máquina cliente. Ésta es una de las grandes ventajas de Java, en cuanto a seguridad se refiere.

� Concurrente: permite ejecutar varios programas Java (applets) a la vez en el navegador. Java al ser multitareas (multithreaded), permite muchas actividades simultáneas en un programa. Los threads (a veces llamados, procesos ligeros o hilos), son básicamente pequeños procesos o piezas independientes de un gran proceso.

Al estar los threads construidos en el lenguaje, son más fáciles de usar y más robustos que sus homólogos en C o C++. El beneficio de ser multithreaded consiste en un mejor rendimiento interactivo y mejor comportamiento en tiempo real.

Aunque el comportamiento en tiempo real está limitado a las capacidades del sistema operativo subyacente (Unix, Windows, etc.), aún supera a los entornos de flujo único de programa (single-threaded), tanto en facilidad de desarrollo, como en rendimiento.

Como ejemplo de todo esto, supongamos la visualización de una imagen desde Internet. Con Java, esta imagen se puede ir trayendo en un thread independiente, permitiendo que el usuario pueda acceder a la información en la página sin tener que esperar por el navegador.

� Distribuido: Java se ha construido con extensas capacidades de interconexión TCP/IP (Transmission Control Protocol/Internet Protocol).Existen librerías de rutinas para acceder e interactuar con protocolos como http y ftp. Esto permite a los programadores acceder a la información a través de la red con tanta facilidad como a los ficheros locales.

Java en sí no es distribuído, sino que proporciona las librerías y herramientas para que los programas puedan ser distribuidos, es decir, que se ejecuten en varias máquinas, interactuando.

Como ejemplo, Java también tiene la posibilidad de que los objetos puedan ejecutar procedimientos remotos; esta facilidad se llama RMI (Remote Method Invocation). Esto le aporta más características del modelo cliente/servidor.

� Dinámico: por su capacidad de interactuar con el usuario, Java se beneficia todo lo posible de la tecnología orientada a objetos. Java no intenta conectar todos los módulos que comprenden una aplicación hasta el tiempo de ejecución. Las librerías nuevas o actualizadas no paralizarán las aplicaciones actuales (siempre que mantengan el API (Application Programming Interface)). La siguiente figura muestra las diferencias entre un navegador convencional y uno con Java.


34

� Java también simplifica el uso de protocolos nuevos o actualizados. Si nuestro ejecuta una aplicación Java sobre la red y encuentra una pieza de la aplicación que no sabe manejar, es capaz de traer automáticamente cualquiera de esas piezas que el sistema necesita para funcionar, desde el servidor remoto.

� Java, para evitar tener que ir descargando módulos de byte-codes, objetos o nuevas clases, implementa las opciones de persistencia, para que no se eliminen cuando se limpie la caché de la máquina.

� Administrador de Memoria: Es una tarea de la cual el programador no debe preocuparse. Java elimina muchas de las características de otros lenguajes como C++, para mantener reducidas las especificaciones del lenguaje y añadir características muy útiles como el garbage collector (reciclador de memoria dinámica). No es necesario preocuparse de liberar memoria, el reciclador se encarga de ello y como es un thread de baja prioridad, cuando entra en acción, permite liberar bloques de memoria muy grandes, lo que reduce la fragmentación de la memoria.

� Administrador de Arreglos: Posee un eficiente sistema de administración de arreglos (array), que permite almacenar gran cantidad de datos en


35

memoria, con un acceso directo a ellos. Implementa los arrays auténticos, en vez de listas enlazadas de punteros, con comprobación de límites, para evitar la posibilidad de sobreescribir o corromper memoria resultado de punteros que señalan a zonas equivocadas.

� Excepciones: Se dispone de una buena batería de métodos que controlan los posibles errores que pudiesen ocurrir durante la ejecución del programa, los que evitan, estando bien utilizados, que el programa cancele su ejecución.

Una excepción es una condición anormal que surge en una secuencia de código durante la ejecución de un programa. Es decir, es un "error de ejecución".

En los lenguajes de programación que no tienen gestión de excepciones, hay que controlar los posibles errores de ejecución del programa manualmente, usando códigos de error. Sin embargo, Java posee gestión de excepciones, y lleva el problema de la gestión del error en tiempo de ejecución al mundo orientado a objetos.

En Java, cuando surge una condición excepcional, se crea un objeto que representa la excepción y se envía al método que provocó esta excepción. Este método puede elegir gestionar la excepción él mismo o pasarla. Pero en algún punto, la excepción es capturada y procesada.

Las excepciones pueden ser generadas por el intérprete de Java o pueden ser generadas por el propio código. Las excepciones generadas por Java están relacionadas con errores que violan las reglas del lenguaje Java o las restricciones del entorno de ejecución de Java. Las excepciones generadas manualmente se suelen utilizar para informar de algún error al método llamante.

Capítulo 4 – Conceptos de Orientación a Objetos.

37

Capitulo 4.

PROFUNDIZANDO CONCEPTOS DE POO – EJEMPLOS CON JAVA

En este capítulo se analizarán los siguientes conceptos de la POO, pero aplicados a ejemplos básicos utilizando el lenguaje de programación JAVA.

1. Herencia 2. Sobrescritura de métodos 3. La clase base y la clase derivada 4. Redefinición de Métodos Heredados 5. Clases y Métodos Abstractos 6. Sobrecarga/Polimorfismos 7. Ligaduras Dinámicas ó Binding 8. Redefinición 9. Interfases 10. Permisos de Accesos 11. Transformaciones de tipos ó Casting 12. Sincronización

1. Herencia.

La herencia, concepto ya creado por Dahl y Nygaar en 1965, es una propiedad esencial de la Programación Orientada a Objetos que consiste en la creación de nuevas clases a partir de otras ya existentes

Es el mecanismo mediante el cual un objeto adquiere (o hereda) las propiedades

de otro. De esta forma se consigue la clasificación jerárquica. Si no se hiciera una clasificación jerárquica de los objetos, cada objeto debería definir todas sus características explícitamente, y esto no sería viable.

Sin embargo, utilizando la herencia, un objeto puede heredar sus atributos

generales de otro objeto (su padre), y definir explícitamente sólo aquellas cualidades que lo hacen único dentro de su clase. Por tanto, la herencia es el mecanismo que permite a un objeto ser una instancia específica de un caso más general.

Una clase que hereda de otra, se denomina subclase, y aquella clase de la que se

hereda, se denomina superclase. Por ejemplo, supongamos que se define una clase para describir a los animales;

se podría definir otra clase para describir a los mamíferos. La clase "mamíferos" heredaría todos los atributos de la clase "animales", pero además definiría una serie de atributos específicos de los mamíferos, como el tipo de dientes, o las glándulas mamarias. En este caso, la clase "mamíferos" es subclase de "animales", y la clase "animales" es superclase de "mamíferos".

Una subclase hereda todos los atributos de cada uno de sus antecesores en la

jerarquía de clases. Esta característica permite a los programas orientados a objetos crecer en complejidad de manera lineal en vez de geométrica.


38

La herencia es la característica fundamental que distingue un lenguaje orientado a objetos, como el C++, Smalltalk, Eiffel o Java, de otro convencional como C, BASIC, etc. Herencia en Java.

La herencia permite las clasificaciones jerárquicas. En Java, para heredar una

clase, se utiliza la palabra reservada extends.

Por ejemplo, si la clase B hereda la clase A (B es subclase de A, A es superclase de B), la declaración de la clase B sería así:

class B extends A {

// variables de instancia // métodos

}

Así, la clase B hereda todas las variables de instancia y métodos de la clase A, y además define sus propias variables de instancia y métodos. Pero hay una excepción: una subclase no puede acceder a aquellos miembros de la superclase que han sido declarados como private.

2. Sobrescritura de métodos. En una jerarquía de clases, cuando un método de una subclase tiene el mismo

nombre y tipo que un método de su superclase, entonces se dice que el método de la subclase sobrescribe al método de la superclase.

Y cuando se llama a un método sobrescrito dentro de una subclase, siempre se

refiere a la versión del método definida en la subclase. La versión del método definida por la superclase está oculta.

Y la llamada a una función sobrescrita se resuelve en tiempo de ejecución, en

lugar de durante la compilación; esto se denomina selección de método dinámica.La selección de método dinámica es la forma que tiene Java de implementar el polimorfismo durante la ejecución.

Así, combinando la herencia con la sobrescritura de métodos, una superclase

puede definir la forma general de los métodos que serán utilizados por todas sus subclases. Por otra parte, este polimorfismo dinámico es uno de los mecanismos más poderosos que ofrece el diseño orientado a objetos para soportar la reutilización del código y la robustez.

3. La clase base y la clase derivada. La herencia ofrece una ventaja importante, permite la reutilización del código. Una

vez que una clase ha sido depurada y probada, el código fuente de dicha clase no necesita modificarse. Su funcionalidad se puede cambiar derivando una nueva clase que herede la funcionalidad de la clase base y le añada otros comportamientos.


39

La programación en los entornos gráficos, en particular Windows, con el lenguaje C++, es un ejemplo ilustrativo. Los compiladores como los de Borland y Microsoft proporcionan bibliotecas de clases cuyas clases describen el aspecto y la conducta de las ventanas, controles, menús, etc.

Una de estas clases denominada TWindow describe el aspecto y la conducta de

una ventana, tiene una función miembro denominada Paint, que no dibuja nada en el área de trabajo de la misma.

Definiendo una clase derivada de TWindow, podemos redefinir en ella la función

Paint para que dibuje una figura. Aprovechamos de este modo la ingente cantidad y complejidad del código

necesario para crear una ventana en un entorno gráfico. Solamente, tendremos que añadir en la clase derivada el código necesario para dibujar un rectángulo, una elipse, etc.

La base de la POO fue este tipo de programación, en entornos de ventanas, de

hecho SmallTalk se hizo para eso.

En el lenguaje Java, todas las clases derivan implícitamente de la clase base Object, por lo que heredan las funciones miembro definidas en dicha clase.

En Java disponemos de los paquetes básicos:

� java.lang: Clases propias del lenguaje, clase Object, clase String, clase System y clases para los tipos asociados a las primitivas.

� java.util: Clases para las utilidades, clase Date, clase Vector y clase

Hashtable.

� java.io: Clases para la E/S y para el manejo de ficheros.

� java.net: Clases para el soporte de redes; clases Socket y clase URL.

� java.awt: Clases para la interfase gráfica, incluyendo las clases Window, Menu, Button, Font, CheckBox.

� java.applet: Clases que implementan las Applets de Java, incluyendo la clase Applet y la interfase AudioClip.

La clase base. Algunas de las típicas ocasiones en las que nos vemos obligados a crear clases

bases son, por ejemplo: � En la fase de análisis, nos damos cuenta que diversos tipos de datos tienen

algo en común, por ejemplo en el juego del ajedrez: peones, alfiles, rey, reina, caballos y torres, son piezas del juego. Creamos, por lo tanto, una clase base pieza y derivamos cada pieza individual a partir de dicha clase base.


40

� En otra ocasión, precisamos ampliar la funcionalidad de un programa, sin tener que modificar el código existente.

Ejemplos de aplicación del presente concepto los vemos en los programas:

Ventana.java, VentanaTitulos.java y VentanaApp.java. Vamos a poner un ejemplo del segundo tipo, (ampliar la funcionalidad de un

programa) que simule la utilización de librerías de clases para crear una interfase gráfica de usuario como Windows 3.1 o Windows 95.

Supongamos que tenemos una clase que describe la conducta de una ventana

muy simple, aquella que no dispone de título en la parte superior, por lo tanto no puede desplazarse, pero si cambiar de tamaño actuando con el ratón en los bordes derecho e inferior.

La clase Ventana tendrá las siguientes variables miembros:

� la posición x e y de la ventana, de su esquina superior izquierda, y � las dimensiones de la ventana: ancho y alto.

public class Ventana { protected int x; protected int y; protected int ancho; protected int alto;

//constructor de la Clase Base

public Ventana(int x, int y, int ancho, int alto) { this.x=x; this.y=y; this.ancho=ancho; this.alto=alto; }}

Constructor (Ventana)

� Nombre del constructor = nombre de la clase � Se encarga de todas las operaciones de inicialización necesarias. � No tiene valor de retorno.

Las funciones miembro, además del constructor serán las siguientes:

� la función mostrar que simula una ventana en un entorno gráfico, aquí solamente nos muestra la posición y las dimensiones de la ventana.

public void mostrar(){

System.out.println("posición : x =" + x + ", y


41

=" + y); System.out.println("dimensiones: ancho =" + ancho

+ ", alto =" + alto); }

� La función cambiarDimensiones (de forma relativa) que simula el cambio en la anchura y altura de la ventana.

public void cambiarDimensiones(int dancho, int

dalto){ ancho += dancho; alto += dalto;

} Objetos de la clase base.

Como vemos en el código, el constructor de la clase base inicializa los cuatro miembros dato. Llamamos al constructor creando un objeto de la clase Ventana (Java invoca al constructor al crear el objeto).

La instanciación (new) reserva el lugar de almacenamiento e invoca al constructor

Ventana ventana=new Ventana (0, 0, 20, 30); Desde el objeto ventana podemos llamar a las funciones miembro públicas

ventana.mostrar(); ventana.cambiarDimensiones(10, 10);

La clase derivada Podemos incrementar la funcionalidad de la clase Ventana definiendo una clase

derivada denominada VentanaTitulo.

Los objetos de dicha clase tendrán todas las características de los objetos de la clase base, pero además tendrán un título, y se podrán desplazar (se simula el desplazamiento de una ventana con el ratón).

La clase derivada heredará las variables miembros de la clase base y las funciones

miembro, y tendrá una variable miembro más, el título de la ventana.

public class VentanaTitulo extends Ventana{ protected String titulo; public VentanaTitulo(int x, int y, int ancho, int

alto, String nombre) { super(x, y, ancho, alto); titulo = nombre;

}}

extends es la palabra reservada que indica que la clase VentanaTitulo deriva, o es una subclase, de la clase Ventana.


42

La primera sentencia del constructor de la clase derivada es una llamada al constructor de la clase base mediante la palabra reservada super.

La llamada super(x, y, ancho, alto); inicializa los cuatro miembros dato de la clase base Ventana:( x, y, ancho, alto)

A continuación, se inicializan las variables miembros de la clase derivada, y se realizan las tareas de inicialización que sean necesarias. Si no se llama explícitamente al constructor de la clase base Java lo realiza por nosotros, llamando al constructor por defecto si existe.

La función miembro denominada desplazar cambia la posición de la ventana,

añadiéndole el desplazamiento.

public void desplazar(int dx, int dy){ x+=dx; y+=dy; }

Ahora redefinimos la función miembro mostrar para mostrar una ventana con un título.

public void mostrar(){

super.mostrar(); System.out.println("titulo : "+titulo);

}

En la clase derivada se define una función que tiene el mismo nombre y los mismos parámetros que la de la clase base. (redefinimos la función mostrar en la clase derivada).

La función miembro mostrar de la clase derivada VentanaTitulo hace una

llamada a la función mostrar de la clase base Ventana, mediante

super.mostrar(); De este modo aprovechamos el código ya escrito, y le añadimos el código que

describe la nueva funcionalidad de la ventana (por ejemplo, que muestre el título). Si nos olvidamos de poner la palabra reservada super llamando a la función

mostrar, tendríamos una función recursiva. (La función mostrar llamaría a mostrar indefinidamente.)

public void mostrar(){ //¡ojo!,función recursiva

System.out.println("titulo : "+titulo); mostrar(); }

Objetos de la clase derivada.


43

Creamos un objeto ventana de la clase derivada VentanaTitulo

VentanaTitulo ventana=new VentanaTitulo(0, 0, 20, 30, "Principal");

Mostramos la ventana con su título, llamando a la función mostrar, redefinida en la

clase derivada

ventana.mostrar(); Desde el objeto ventana de la clase derivada llamamos a las funciones miembro

definidas en dicha clase

ventana.desplazar(4, 3); Desde el objeto ventana de la clase derivada podemos llamar a las funciones

miembro definidas en la clase base.

ventana.cambiarDimensiones(10, -5); Para mostrar la nueva ventana desplazada y cambiada de tamaño escribimos

ventana.mostrar();

Modificadores de acceso.

En la herencia, surge un nuevo control de acceso denominado protected.

Hemos puesto protected delante de las variables miembros x e y de la clase base Ventana

public class Ventana { protected int x; protected int y;

//... }

En la clase derivada, la función miembro desplazar accede a dichas variables miembros

public class VentanaTitulo extends Ventana{ //... public void desplazar(int dx, int dy){ x+=dx; y+=dy; }}


44

Si cambiamos el modificador de acceso de los miembros x e y de la clase base Ventana de protected a private, el compilador nos informará que los miembros x e y no son accesibles.

Los miembros ancho y alto se pueden poner con acceso private, sin

embargo, es mejor dejarlos como protected ya que podrían ser utilizados por alguna función miembro de otra clase derivada de VentanaTitulo.

Dentro de una jerarquía pondremos un miembro con acceso private, si estamos seguros de que dicho miembro solamente va a ser usado por dicha clase.

Como vemos hay cuatro modificadores de acceso a los miembros dato y a los

métodos:

1. private, las variables y métodos de instancia privados sólo pueden ser accedidos desde dentro de la clase. No son accesibles desde las subclases.

2. protected, sólo las subclases de la clase y nadie más, puede acceder a las variables y métodos de instancia protegidos

3. public, cualquier clase desde cualquier lugar puede acceder a las variables y métodos de instancia públicos

4. friendly, por defecto, si no se especifica el control de acceso, las variables y métodos de instancia se declaran friendly (amigas), lo que significa que son accesibles por todos los objetos dentro del mismo paquete, pero no por los externos al paquete. Es lo mismo que protected.

Veamoslo resumido en los siguientes cuadros:

Clases dentro del mismo paquete:

Modificador de acceso

Heredado Accesible

Default Si Si Private No No Protected Si Si Public Si Si

Clases en distintos paquetes:

Modificador de acceso

Heredado Accesible

Default No No Private No No Protected Si No Public Si Si


45

Desde el punto de vista práctico, cabe reseñar que no se heredan los miembros privados, ni aquellos miembros (dato o función) cuyo nombre sea el mismo en la clase base y en la clase derivada.

La clase base object. La clase Object es la clase raíz de la cual derivan todas las clases. Esta

derivación es implícita. La clase Object define una serie de funciones miembro que heredan todas las

clases. Las más importantes son las siguientes:

public class Object { public boolean equals(Object obj) {

return (this == obj); }

protected native Object clone() throws CloneNotSupportedException;

public String toString() { return getClass().getName() + "@" +

Integer.toHexString(hashCode()); }

protected void finalize() throws Throwable { } //otras funciones miembro...

}

Métodos que pueden ser redefinidos por el programador. Igualdad de dos Objetos:

El método equals de la clase Object compara dos objetos uno que llama a la función y otro es el argumento de dicha función.

equals() Indica si dos objetos son o no iguales. Devuelve true si son iguales,

tanto si son referencias al mismo objeto como si son objetos distintos con iguales valores de las variables miembro.

Entonces, boolean objeto.equals(Object), demuestra si el objeto dado

como parámetro es igual al objeto actual. Esta implementación comprueba si ambas referencias son iguales. Podemos

simplificar la consulta utilizando el operador = = (igualdad). Las distintas clases de la librería de Java suelen sobrescribirlo para comprobar si

los contenidos de la instancia son los mismos.


46

Por ejemplo, cuando String sobrescribe este método compara si las cadenas contenidas en ambas instancias son iguales.

Representación en forma de texto de un objeto:

El método toString() devuelve un String que contiene una representación

del objeto como cadena de caracteres, por ejemplo para imprimirlo o exportarlo. El método toString imprime por defecto el nombre de la clase a la que

pertenece el objeto y su código (hash). Esta función miembro se redefine en la clase derivada para mostrar la información

que nos interese acerca del objeto. La función toString se llama automáticamente siempre que pongamos un

objeto como argumento de la función System.out.println o concatenado con otro string.

public String toString() { return getClass().getName() + "@" +

Integer.toHexString(hashCode()); }

Entonces: String objeto.toString()devuelve una representación del objeto en formato de cadena de caracteres, es llamado automáticamente por Java cuando necesita convertir el objeto en cadena. Esta implementación devuelve una cadena que contiene el nombre de la clase del objeto, seguido de una arroba y del código hash del mismo.

Duplicación de objetos:

El método clone crea un objeto duplicado (clónico) de otro objeto, es decir, clone() crea un objeto a partir de otro objeto de la misma clase.

El método original heredado de Object lanza una

CloneNotSupportedException.

Si se desea clonar una clase hay que implementar la interfase Cloneable yredefinir el método clone().

Este método debe hacer una copia miembro a miembro del objeto original. No debería llamar al operador new ni a los constructores.

Entonces: Object objeto.clone() copia el objeto. La intención es que, al sobreescribirlo, creemos un objeto nuevo cuyas

propiedades tengan el mismo valor que las del objeto a copiar. Es decir, que x.clone.equals(x) sea cierto.


47

Finalización: El método finalize se llama cuando va a ser liberada la memoria que ocupa el

objeto por el recolector de basura (garbage collector). Normalmente, no es necesario redefinir este método en las clases, solamente en contados casos especiales. Por ejemplo, si una clase mantiene un recurso que no es de Java como un descriptor de archivo o un tipo de letra del sistema de ventanas, o cuando se han abierto varios archivos durante la vida de un objeto, y se desea que los archivos estén cerrados cuando dicho objeto desaparece, entonces sería acertado el utilizar la finalización para asegurar que los recursos se liberan. Es similar a los destructores de C++.

La forma en la que se redefine este método es el siguiente.

class CualquierClase{ //..

protected void finalize() trows Throwable{ super.finalize(); //código que libera recursos externos }}

La primera sentencia que contenga la redefinición de finalize ha de ser una llamada a la función del mismo nombre de la clase base, y a continuación le añadimos cierta funcionalidad, habitualmente, la liberación de recursos, cerrar un archivo, etc.

Entonces: void objeto.finalize()es llamado por el recolector de basura

antes de eliminar el objeto. Esta implementación no hace nada, debe ser el programador el que sobreescriba este método en caso de que quiera realizar algo en especial antes de eliminar el objeto de la memoria.

Métodos que NO pueden ser Redefinidos:

� getClass() devuelve un objeto de la clase class, al cual se le pueden

aplicar métodos para determinar el nombre de la clase, su superclase, las interfases implementadas, etc.

Se puede crear un objeto de la misma clase que otro sin saber de qué clase es. Entonces: Class objeto.getClass() devuelve un objeto de tipo class que

identifica el tipo de objeto que tenemos. Por ejemplo podemos comprobar si x e y son del mismo tipo con:

x.getClass() = = y.getClass()

� int objeto.hashCode() devuelve el código Hash del objeto. Este código se utiliza para las tablas Hash, que son la manera más eficiente de

almacenar objetos. Para que dichas tablas funcionen necesitan que cada objeto almacenado tenga un código numérico que se mantenga durante toda la ejecución del


48

programa y que sea el mismo para dos objetos si dichos objeto son iguales según el método equals(). Un ejemplo sería, para las cadenas, devolver la longitud de la misma.

� notify(), � notifyAll() Son métodos relacionados con las threads � wait()

Concretando: Se puede construir una clase a partir de otra mediante el mecanismo de la

herencia. Para indicar que una clase deriva de otra se utiliza la palabra extends,

class ClaseHija extends ClasePadre { ...

}

Cuando una clase deriva de otra, hereda todas sus variables y métodos. Estas funciones y variables miembro pueden ser redefinidas (overridden) en la

clase derivada, que puede también definir o añadir nuevas variables y métodos. En cierta forma es como si la sub-clase (la clase derivada) “contuviera” un objeto

de la super-clase; en realidad lo “amplía” con nuevas variables y métodos. Java permite múltiples niveles de herencia, pero no permite que una clase derive

de varias (no es posible la herencia múltiple). Se pueden crear tantas clases derivadas de una misma clase como se quiera.

Todas las clases de Java creadas por el programador tienen una super-clase.

Cuando no se indica explícitamente una super-clase con la palabra extends, la clase deriva de java.lang.Object, que es la clase raíz de toda la jerarquía de clases de Java. Como consecuencia, todas las clases tienen algunos métodos que han heredado de Object.

4. Redefinición de métodos heredados Una clase puede redefinir cualquiera de los métodos heredados de su super-clase

que no sean final. El nuevo método sustituye al heredado para todos los efectos en la clase que lo ha redefinido.

Los métodos de la super-clase que han sido redefinidos pueden ser todavía

accedidos por medio de la palabra super desde los métodos de la clase derivada, aunque con este sistema sólo se puede subir un nivel en la jerarquía de clases.


49

Los métodos redefinidos pueden ampliar los derechos de acceso de la super-clase (por ejemplo ser public, en vez de protected o package), pero nunca restringirlos.

Los métodos de clase static no pueden ser redefinidos en las clases derivadas.

Modificador final: Si declaramos un método como final, indicaremos que no puede ser

sobreescrito en clases heredadas, por lo que mantendrá su implementación. Si es la clase la que lleva el modificador (final), entonces nos aseguramos que nadie pueda heredar de dicha clase

Por último, si declaramos una propiedad como final, crearemos una constante,

ya que dicha variable se puede inicializar, pero no modificar. Este último caso presenta un uso más habitual de este modificador:

class Dias { static final int LUNES=0, MARTES=1, MIERCOLES=2,

JUEVES=3, VIERNES=4, SABADO=5, DOMINGO=6; }

5. Clases y métodos abstractos Una clase abstracta (abstract) es una clase de la que no se pueden crear

objetos. Su utilidad es permitir que otras clases deriven de ella, proporcionándoles un marco o modelo que deben seguir y algunos métodos de utilidad general. Las clases abstractas se declaran anteponiéndoles la palabra abstract, por ejemplo:

public abstract class NombreClase { ... } Una clase abstract puede tener métodos declarados como abstract, en

cuyo caso no se da definición del método. Si una clase tiene algún método abstract es obligatorio que la clase sea abstract.

En cualquier sub-clase este método deberá ser redefinido o volver a declararse como abstract (el método y la sub-clase). Una clase abstract puede tener métodos que no son abstract.

Aunque no se puedan crear objetos de esta clase, sus sub-clases heredarán el método completamente a punto para ser utilizado.

Debemos tener en cuenta que como los métodos static no pueden ser

redefinidos, un método abstract no puede ser static.

6. Polimorfismo Esta palabra que significa "muchas formas", es una característica del lenguaje

Java que permite a una interfase ser usada por una clase general de acciones. En


50

términos más generales, el concepto de polimorfismo a menudo se expresa por la frase "una interfaz, múltiples métodos". Esto significa que es posible diseñar una interfaz genérica para un grupo de actividades relacionadas.

Es evidente que esta forma de trabajar ayuda a reducir la complejidad del diseño,

pues permite usar una misma interfaz para especificar un conjunto de acciones similares. Será el compilador el que tendrá que seleccionar la acción concreta (esto es, el método) para aplicar en cada situación. Como programadores, nosotros sólo tenemos que conocer la interfaz general.

Más detalladamente, funciona así: cuando se llama a un método, el código generado por el compilador consulta una tabla oculta de punteros a funciones que dispone cada clase. La dirección de la función llamada no se asigna en tiempo de compilación como ocurre con el enlace estático del C sino que se obtiene la dirección de la función llamada justo en el momento antes de ejecutarse.

Repasando, el polimorfismo consiste en poder definir métodos con la misma firma (nombre del método más argumentos) en diferentes niveles de la jerarquía de clases, y, que durante la ejecución el programa, sepa discernir a qué método llamar en cada caso.

Podemos entender el sobrepaso fácilmente con un modelo simplificado. Durante la

ejecución, cuando un mensaje es pasado a un objeto, la firma del mensaje es comparada con la firma de los mensajes de la clase a la que pertenece dicho objeto. Si se encuentra una igualdad el método correspondiente es ejecutado. Si no la firma del mensaje es comparada con la firma de los mensajes de la superclase. El proceso se repite hasta que una igualdad se encuentre. Una igualdad es garantizada, ya que el compilador de Java hubiera generado un error en el tiempo de compilación si la firma del mensaje invocado sobre un objeto no corresponde a ninguna firma dentro de la clase a la que pertenece este o alguna superclase.

La idea básica es que una referencia a un objeto de una determinada clase es

capaz de servir de referencia o de nombre a objetos de cualquiera de sus clases derivadas.

ClasePadre objeto1, objeto2; objeto1= new ClaseHija(parámetros); objeto2= new ClaseHija2(parámetros);

Análogamente una referencia a un objeto de una determinada Interfase es capaz

de servir de referencia o de nombre a objetos de cualquiera de las clases que implementan dicha interfase.

Interface objeto1, objeto2; objeto1= new Clase (parámetros); objeto2= new Clase2 (parámetros);

Es decir, permite tratar de un modo unificado objetos distintos, aunque

pertenecientes a distintas sub-clases o bien a clases que implementan dicha interfase.


51

El polimorfismo tiene que ver con la relación que se establece entre la llamada a un método y el código que efectivamente se asocia con dicha llamada. A esta relación se llama vinculación o ligadura (binding).

7. Vinculación, Ligadura o Binding.

La vinculación puede ser:

� temprana (en tiempo de compilación) � tardía (en tiempo de ejecución).

Con funciones normales o sobrecargadas se utiliza generalmente vinculación

temprana. Con funciones redefinidas se utiliza siempre vinculación tardía, excepto si el método es final.

La vinculación tardía hace posible que, con un método declarado en una clase

base (o en una interfase) y redefinido en las clases derivadas (o en clases que implementan esa interfase), sea el tipo de objeto y no el tipo de la referencia lo que determine qué definición del método se va a utilizar. El tipo del objeto al que apunta una referencia sólo puede conocerse en tiempo de ejecución, y por eso el polimorfismo necesita evaluación tardía.

El polimorfismo permite a los programadores separar las cosas que cambian de las

que no cambian, y de esta manera hacer más fácil la ampliación, el mantenimiento y la reutilización de los programas.

El polimorfismo puede hacerse con referencias de super-clases abstractas, super-

clases normales, e interfases. Las interfases permiten ampliar muchísimo las posibilidades del polimorfismo por

su mayor flexibilidad y por su independencia de la jerarquía de clases estándar.

Conversión de objetos El polimorfismo visto previamente está basado en utilizar referencias de un tipo

más “amplio” que los objetos a los que apuntan. Las ventajas del polimorfismo son evidentes, pero hay una importante limitación: el tipo de la referencia (clase abstracta, clase base o interfase) limita los métodos que se pueden utilizar y las variables miembro a las que se pueden acceder.

Por ejemplo, un objeto puede tener una referencia cuyo tipo sea una interfase,

aunque sólo en el caso en que su clase o una de sus super-clases implementen dicha interfase. Un objeto cuya referencia es un tipo interfase sólo puede utilizar los métodos definidos en dicha interfase. Dicho de otro modo, ese objeto no puede utilizar las variables y los métodos propios de su clase.

De esta forma las referencias de tipo interfase definen, limitan y unifican la forma

de utilizarse de objetos pertenecientes a clases muy distintas (que implementan dicha interfase).

Si se desea utilizar todos los métodos y acceder a todas las variables que la clase

de un objeto permite, hay que utilizar un cast (lanzamiento) explícito, que convierta su


52

referencia más general en la del tipo específico del objeto. De aquí una parte importante del interés del cast entre objetos (más bien entre referencias).

Para la conversión entre objetos de distintas clases, Java exige que dichas clases

estén relacionadas por herencia (una deberá ser subclase de la otra). Se realiza una conversión implícita o automática de una subclase a una superclase siempre que se necesite, ya que el objeto de la subclase siempre tiene toda la información necesaria para ser utilizado en lugar de un objeto de la superclase.

La conversión en sentido contrario debe hacerse de modo explícito y puede

producir errores por falta de información o de métodos. Si falta información, se obtiene una ClassCastException. No se puede acceder a las variables exclusivas de la sub-clase a través de una referencia de la super-clase. Sólo se pueden utilizar los métodos definidos en la super-clase, aunque la definición utilizada para dichos métodos sea la de la sub-clase.

Por ejemplo, supóngase que se crea un objeto de una sub-clase B y se referencia

con un nombre de una super-clase A,

A a = new B(); en este caso el objeto creado dispone de más información de la que la referencia a

le permite acceder (podría ser, por ejemplo, una nueva variable miembro j declarada en B). Para acceder a esta información adicional hay que hacer un cast explícito en la forma (B)a.

System.out.println( ((B)a).j ); //imprime la variable j Un cast de un objeto a la super-clase puede permitir utilizar variables -no métodos-

de la super-clase, aunque estén redefinidos en la sub-clase. Considérese el siguiente ejemplo: La clase C deriva de B y B deriva de A. Las tres

definen una variable x. En este caso, si desde el código de la sub-clase C se utiliza:

x // se accede a la x de C this.x // se accede a la x de C super.x // se accede a la x de B. Sólo se puede

// subir un nivel ((B)this).x // se accede a la x de B ((A)this).x // se accede a la x de A

Métodos (funciones miembro). Los métodos son funciones definidas dentro de una clase. Salvo los métodos

static o de clase, se aplican siempre a un objeto de la clase por medio del operador punto (.). Dicho objeto es su argumento implícito. Los métodos pueden además tener otros argumentos explícitos que van entre paréntesis, a continuación del nombre del método.


53

La primera línea de la definición de un método se llama declaración (header), y el código comprendido entre las llaves {…} es el cuerpo (body) del método.

public Float método() {

// header y comienzo del método sentencias // body o cuerpo

return valor } // final del método

El header consta del cualificador de acceso (public, en este caso), del tipo del valor de retorno (Float en este ejemplo, void si no tiene), del nombre de la función y de una lista de argumentos explícitos entre paréntesis, separados por comas. Si no hay argumentos explícitos se dejan los paréntesis vacíos.

Los métodos tienen visibilidad directa de las variables miembro del objeto que es

su argumento implícito, es decir, pueden acceder a ellas sin cualificarlas con un nombre de objeto y el operador punto. De todas formas, también se puede acceder a ellas mediante la referencia this (this.variable) o sí, alguna variable local o argumento las oculta.

El valor de retorno (return) puede ser un valor de un tipo primitivo o una

referencia. En cualquier caso no puede haber más que un único valor de retorno (que puede ser un objeto o un arreglo). Se puede devolver también una referencia a un objeto por medio de un nombre de interfase. El objeto devuelto debe pertenecer a una clase que implemente esa interfase. Se puede devolver como valor de retorno un objeto de la misma clase que el método o de una sub-clase, pero nunca de una super-clase.

Los métodos pueden definir variables locales. Su visibilidad llega desde la

definición al final del bloque en el que han sido definidas. No hace falta inicializar las variables locales en el punto en que se definen, pero el compilador no permite utilizarlas sin haberles dado un valor. A diferencia de las variables miembro, las variables locales no se inicializan por defecto.

Si en el header del método se incluye la palabra native

public native void metodo(); no hay que incluir el código o implementación del método. Este código deberá

estar en una librería dinámica (Dynamic Link Library o DLL). Estas librerías son ficheros de funciones compiladas normalmente en lenguajes distintos de Java (C, C++, Fortran, etc.). Es la forma de poder utilizar conjuntamente funciones realizadas en otros lenguajes desde código escrito en Java.

Un método también puede declararse como synchronized

public synchronized double metodo(){...}


54

Estos métodos tienen la particularidad de que sobre un objeto no pueden ejecutarse simultáneamente dos métodos que estén sincronizados.

Métodos sobrecargados (overloaded)

Otra de las ventajas de este lenguaje de programación es que nos permite definir dos o más métodos dentro de la misma clase con el mismo nombre, siempre que la declaración de sus parámetros sea diferente. En este caso se dice que el método está sobrecargado y el proceso de definir un método así se conoce como sobrecarga del método. La sobrecarga de métodos es una de las maneras en que Java implementa el polimorfismo.

Cuando se llama a un método sobrecargado, el compilador actúa justo sobre la

versión cuyo tipo de parámetros coincida con los de la llamada. Así, se podría definir la siguiente clase "SumaGenerica" que aglutinará las sumas de todos los tipos primitivos:

class SumaGenerica {

int suma (int a, int b) { return a+b;

}double suma (double a, double b) {

return a+b; }

... }

Realmente no sería necesario definir el método suma() para todos los tipos de datos, pues aquí también interviene el casting implícito que hace Java. Por ejemplo, una suma de float, llamaría automáticamente al método que devuelve double siempre y cuando no esté definido el método que devuelve float, claro está.

No existe una regla exacta para saber si un método se debe sobrecargar o no.

Realmente, la idea es aprovechar las ventajas que ofrece esta forma de polimorfismo, así que lo normal es sobrecargar aquellos métodos que estén intrínsicamente relacionados, como es el caso del ejemplo anterior pero no nos debemos confundir. Por ejemplo, el método sqrt(), aunque se llama igual, calcula de forma totalmente diferente la raíz cuadrada de un número entero que la de uno de punto flotante. Aquí, aunque aplicáramos sobrecarga al método, realmente no estaríamos respetando el propósito para el que se creó el polimorfismo.

Hemos expuesto que al igual que C++, Java permite métodos sobrecargados

(overloaded), es decir, métodos distintos que tienen el mismo nombre, pero que se diferencian por el número y/o tipo de los argumentos.

A la hora de llamar a un método sobrecargado, Java sigue las siguientes reglas

para determinar el método concreto que debe llamar: 1. Si existe el método cuyos argumentos se ajustan exactamente al tipo de los

argumentos de la llamada (argumentos actuales), se llama ese método.


55

2. Si no existe un método que se ajuste exactamente, se intenta promover los argumentos actuales al tipo inmediatamente superior (por ejemplo char a int, int a long, float a double, etc.) y se llama el método correspondiente.

3. Si sólo existen métodos con argumentos de un tipo más restringido (por

ejemplo, int en vez de long), el programador debe hacer un cast explícito en la llamada.

4. El valor de retorno no influye en la elección del método sobrecargado. En

realidad es imposible saber desde el propio método lo que se va a hacer con él. No es posible crear dos métodos sobrecargados, es decir con el mismo nombre, que sólo difieran en el valor de retorno.

8. Redefinición

Una clase puede redefinir (override) un método heredado de una superclase. Redefinir un método es dar una nueva definición. En este caso el método debe tener exactamente los mismos argumentos en tipo y número que el método redefinido. Una sugerencia importante es que la redefinición debe ser algo excepcional en POO.

Sobrecarga de Constructores

Es aquí donde realmente se aprecian los beneficios del polimorfismo. Como sabemos, el constructor de una clase es el que inicializa los valores que el programador crea conveniente cuando ésta (la clase) se instancia. Pues bien, sobrecargando el constructor conseguimos dotar a la clase de flexibilidad. Por ejemplo, como mínimo se debería tener en cuenta que podría no pasársele parámetros al constructor, cuando éste lo espera, debido a un fallo en alguna otra parte de la aplicación (me refiero a cualquier otra clase que llame a ésta). Es por ello que siempre es recomendable definir al menos dos constructores: el específico de la aplicación que estemos diseñando y el "estándar".

Veamos un ejemplo: class Caja {

double ancho; double alto; double profundidad;

// El siguiente es el constructor específico

Caja(double w, double h, double d) {

ancho = w; alto = h; profundidad = d; }

// pero podría ser que no le llegarán parámetros // por fallar la otra clase (método) que lo // invoque


56

Caja () { ancho = alto = profundidad = -1

//-1 indica volumen no existente }

// e incluso podemos pensar que se quiere construir // un cubo, entonces, por qué introducir 3 valores?

Caja (double valor) { ancho = alto = profundidad = valor;

}

double volume() { return ancho * alto * profundidad;

}}

Objetos como parámetros

Además de usar los tipos primitivos como parámetros, en Java es perfectamente posible pasar a un método, un objeto como parámetro.

class Comparar {

int a, b;

Comparar (int i, int j) { a = i; b = j;

}

boolean equals (Comparar c) { if (c.a == a && c.b == b) return true;

else return false; }

}

Como se puede apreciar, el método equals() de Comparar comprueba si dos objetos son idénticos.

Paso de argumentos. Existen dos formas de pasar un argumento a una rutina:

� Por valor: El método copia el valor de un argumento en el parámetro formal de la rutina.

� Por referencia: El método copia el objeto en el parámetro formal de la rutina.


57

En el primer caso, al ser solo una copia, cualquier modificación dentro de la rutina de ese valor no tendrá efecto una vez fuera de éste, mientras que si es por referencia, sí persistirá la modificación hecha, aún cuando salgamos de la rutina.

Cuando en Java se pasan argumentos de tipo simple, estos siempre se hacen por valor. Si se desea pasar un parámetro por referencia se debe pasar un objeto. Esto ocurre porque cuando se crea una variable de un tipo de clase, el programador solo crea una referencia al objeto. Así, cuando se pasa esta referencia a un método, el parámetro que recibe éste, se refiere al mismo objeto que el referido por el argumento. Por lo tanto, los cambios que se hagan en la referencia de la rutina afectarán también al objeto pasado como argumento.

El operador static

Hay veces que se desea definir una clase miembro para ser usada independientemente de cualquier objeto de esa clase. Normalmente a una clase miembro se accede sólo si hemos instanciado un objeto de dicha clase. No obstante, es posible crear un miembro que pueda ser usado por sí mismo, sin necesidad de referenciar a una instancia específica. Para crear tales tipos de miembros se emplea el operador static.

Cuando un miembro se declara con esta palabra reservada, se puede acceder a él antes de que cualquier objeto de su clase sea creado, y sin referenciar a ningún objeto. Se puede declarar tanto los métodos como las variables como static. El ejemplo más claro de un miembro static es el main(). Se declara de esta manera porque se debe llamar antes de que cualquier objeto sea declarado.

Las variables static

Las variables de instancia declaradas como static (también llamadas "de clase") son, esencialmente, variables globales. Cuando creamos objetos específicos de esa clase no se hace ninguna copia de las variables static. Lo que ocurre es que todas las instancias de esa clase comparten la misma variable static. Estas variables mayormente tienen sentido cuando varias instancias de la misma clase necesitan llevar el control o estado del valor de un dato.

Para llamar a este tipo de variables se suele utilizar el nombre de la clase (no es

imprescindible, pues se puede utilizar también el nombre de cualquier objeto), porque de esta forma queda más claro, seguida de un "." y la variable Estatica.b

Las variables miembro static se crean en el momento en que pueden ser necesarias:

� cuando se va a crear el primer objeto de la clase � cuando se llama a un método static � cuando se utiliza una variable static de dicha clase. Lo importante es que las variables miembro static se inicializan siempre antes

que cualquier objeto de la clase.


58

Los métodos static.

También llamados "de clase", pueden recibir objetos de su clase como argumentos explícitos, pero no tienen argumento implícito ni pueden utilizar la referencia this. Para llamar a estos métodos se suele emplear el nombre de la clase, en vez del nombre de un objeto de la clase.

Los métodos y variables de clase son lo más parecido que Java tiene a las

funciones y variables globales de C/C++. Las restricciones que tiene un método static son:

� Solo pueden llamar otro método static � Solo deben acceder a datos static � No se pueden referir a this o super de ninguna manera � Si se necesita hacer algún tipo de computación para inicializar las variables

static, se puede declarar también un bloque static el cual se ejecutará solo una vez, cuando se carga.

class Estatica {

static int a = 3; static int b; static void show(int x) {

System.out.println("x = " + x); System.out.println("a = " + a); System.out.println("b = " + b);

}static {

System.out.println("Bloque estático inicializado");

b = a * 4;// vemos que, aunque declarada como static // b se inicializa en tiempo de ejecución

}public static void main(String args[ ]) {

show(15); }

}

Tan pronto como la clase “Estatica” se carga, todas las sentencias se ejecutan. Primero, “a” se inicializa a 3, luego se ejecuta el bloque estático y, por último, “b” se inicializa al valor asignado.

En resumen podemos decir para los miembros de tipo static:

� Miembros (métodos o atributos) implementados al nivel de clase � Desde métodos static la referencia this no tiene sentido � No se puede acceder a miembros no estáticos desde métodos estáticos � static: Semántica de "ámbito global" � Permite desarrollo de código sin usar POO


59

El operador final

Al declarar una variable como final, se previene que su contenido sea modificado. No obstante, Java permite separar la definición de la inicialización. Esta última se puede hacer más tarde, en tiempo de ejecución, llamando a métodos o en función de otros datos.

La variable final así definida, es constante pero no tiene porqué tener el mismo

valor en todas las ejecuciones del programa, pues depende de cómo haya sido inicializada. Esto es lo más parecido a las constantes de otros lenguajes de programación.

final float PI = 3.1416; //Según la convención de

// código las variables "constantes" se ponen en // mayúsculas.

Aunque básicamente este operador se emplea para crear constantes en Java,

también podemos definir una clase o un método como final.

Una clase final no puede tener clases derivadas. Esto se hace por motivos de seguridad y de eficiencia, porque cuando el compilador detecta que los métodos no van a ser redefinidos puede hacer optimizaciones adicionales.

Un método final no puede ser redefinido por una clase que derive de su propia

clase.

9. Interfases. Una interfase es un conjunto de declaraciones de métodos (sin definición).

También puede definir constantes, que son implícitamente public, static yfinal, y deben siempre inicializarse en la declaración.

Todas las clases que implementan una determinada interfase están obligadas a

proporcionar una definición de los métodos de la interfase, y en ese sentido adquieren una conducta o modo de funcionamiento.

Una clase puede implementar una o varias interfases. Para indicar que una clase

implementa una o más interfases se ponen los nombres de las interfases, separados por comas, detrás de la palabra implements, que a su vez va siempre a la derecha del nombre de la clase o del nombre de la super-clase en el caso de herencia.

public class Clase extends ClasePadre implements

Interfase, Interfase2 { ...

... }

¿Qué diferencia hay entre una interfase y una clase abstract? Ambas tienen en común que pueden contener varias declaraciones de métodos (la

clase abstract puede además definirlos). A pesar de esta semejanza, que hace que en


60

algunas ocasiones se pueda sustituir una por otra, existen también algunas diferencias importantes:

� Una clase no puede heredar de dos clases abstract, pero sí puede heredar de

una clase abstract e implementar una interfase, o bien implementar dos o más interfases.

� Una clase no puede heredar métodos -definidos- de una interfase, aunque sí

constantes.

� Las interfases permiten mucha más flexibilidad para conseguir que dos clases tengan el mismo comportamiento, independientemente de su situación en la jerarquía de clases de Java.

� Las interfases permiten “publicar” el comportamiento de una clase develando

un mínimo de información.

� Las interfases tienen una jerarquía propia, independiente y más flexible que la de las clases, ya que tienen permitida la herencia múltiple.

� De cara al polimorfismo las referencias de un tipo interfase se pueden utilizar

de modo similar a las clases abstract.

Definición de interfases. Una interfase se define de un modo muy similar a las clases:

public interface NombreInterface { public void metodo(param, param2); public void metodo2(param);

}

Cada interfase public debe ser definida en un fichero *.java con el mismo nombre de la interfase. Los nombres de las interfases suelen comenzar también con mayúscula. Las interfases no admiten más que los modificadores de acceso public y package. Si la interfase no es public no será accesible desde fuera del package.

Los métodos declarados en una interfase son siempre package y abstract, de modo implícito.

Utilización de interfases Las constantes definidas en una interfase se pueden utilizar en cualquier clase

(aunque no implemente la interfase) precediéndolas del nombre de la interfase area = 2.0*NombreInterface.var*r;


61

Sin embargo, en las clases que implementan la interfase las constantes se pueden utilizar directamente, como si fueran constantes de la clase.

A veces se crean interfases para agrupar constantes simbólicas relacionadas. Desde el punto de vista del polimorfismo, el nombre de una interfase se puede

utilizar como un nuevo tipo de referencia. En este sentido, el nombre de una interfase puede ser utilizado en lugar del nombre de cualquier clase que la implemente, aunque su uso estará restringido a los métodos de la interfase. Un objeto de ese tipo puede también ser utilizado como valor de retorno o como argumento de un método.

Conceptos Útiles Es importante distinguir entre la referencia a un objeto y el objeto mismo. Los

objetos son los elementos declarados de una clase. Una referencia es una variable que indica dónde está guardado un objeto en la memoria del ordenador

La llamada a super.

� Referencia a la superclase de la que desciende la clase actual � Reutilización de código por medio de herencia

o Super invoca al comportamiento anterior. o Se puede añadir comportamiento adicional

� Implícita en constructores como primera instrucción � En métodos: super.nombre_metodo()

10. Permisos de acceso en java. Una de las características de la POO es la encapsulación, que consiste

básicamente en ocultar la información que no es pertinente o necesaria para realizar una determinada tarea. Los permisos de acceso de Java son una de las herramientas para conseguir esta finalidad.

Accesibilidad de los Packages (paquetes). El primer tipo de accesibilidad hace referencia a la conexión física de las

computadoras y a los permisos de acceso entre ellas y en sus directorios y ficheros. En este sentido, un paquete (package) es accesible si sus directorios y ficheros

son accesibles (si están en un ordenador accesible y se tiene permiso de lectura). Además de la propia conexión física, serán accesibles aquellos paquetes que se

encuentren en la variable CLASSPATH del sistema.

Accesibilidad de Clases o Interfases. En principio, cualquier clase o interfase de un paquete es accesible para todas las

demás clases del paquete, tanto si es public como si no lo es.


62

Una clase public es accesible para cualquier otra clase (siempre que su paquete sea accesible). Recuérdese que las clases e interfases sólo pueden ser public o paquete (la opción por defecto cuando no se pone ningún modificador).

Accesibilidad de las Variables y Métodos Miembros de una Clase. Desde dentro de la propia clase:

Todos los miembros de una clase son directamente accesibles (sin calificar con

ningún nombre o calificando con la referencia this) desde dentro de la propia clase. Los métodos no necesitan que las variables miembro sean pasadas como argumento.

Los miembros private de una clase sólo son accesibles para la propia clase. Si

el constructor de una clase es private, sólo un método static de la propia clase puede crear objetos.

Desde una sub-clase.

Las sub-clases heredan los miembros private de su super-clase, pero sólo

pueden acceder a ellos a través de métodos public, protected o package de la super-clase. Desde otras clases del paquete (package).

Desde una clase de un package se tiene acceso a todos los miembros que no

sean private de las demás clases del package.

Desde otras clases fuera del paquete (package).

Los métodos y variables son accesibles si la clase es public y el miembro es public. También son accesibles si la clase que accede es una sub-clase y el miembro es protected.

Resumen de los permisos de acceso de Java.

Visibilidad public protected private packageDesde la propia clase Si Si Si Si Desde otra clase en el propio package

Si Si No Si

Desde otra clase fuera del package

Sí No No No

Desde una sub-clase en el propio package

Sí Sí No Si

Desde una sub-clase fuera del propio package

Si Si No No


63

11. Transformaciones de tipo: casting. En muchas ocasiones hay que transformar una variable de un tipo a otro, por

ejemplo de int a double, o de float a long. En otras ocasiones la conversión debe hacerse entre objetos de clases diferentes, aunque relacionadas mediante la herencia. Explicaremos ahora estas transformaciones de tipo.

Conversión de tipos primitivos. Casting Implícito: La conversión entre tipos primitivos es más sencilla. En Java se

realizan de modo automático conversiones implícitas de un tipo a otro de más precisión, por ejemplo de int a long, de float a double, etc. Estas conversiones se hacen al mezclar variables de distintos tipos en expresiones matemáticas o al ejecutar sentencias de asignación en las que el miembro izquierdo tiene un tipo distinto (más amplio) que el resultado de evaluar el miembro derecho.

Casting Explícito (Operador Cast): Las conversiones de un tipo de mayor a otro

de menor precisión requieren una orden explícita del programador, pues son conversiones inseguras que pueden dar lugar a errores (por ejemplo, para pasar a short un número almacenado como int, hay que estar seguro de que puede ser representado con el número de cifras binarias de short). A estas conversiones explícitas de tipo se les llama cast.

El cast se hace poniendo el tipo al que se desea transformar entre paréntesis, como por ejemplo,

long result; result = (long) (a/(b+c));

12. Sincronización de threads (hilos).

La sincronización nace de la necesidad de evitar que dos o más threads (hilos) traten de acceder a los mismos recursos al mismo tiempo. Por ejemplo, si un thread tratara de escribir en un fichero, y otro thread tuviera al mismo tiempo tratando de borrar dicho fichero, se produciría una situación no deseada.

Otra situación en la que hay que sincronizar threads se produce cuando un

thread debe esperar a que estén preparados los datos que le debe suministrar el otro thread.

Capítulo 5 – Implementación de los conceptos de OO con JAVA

65

Capítulo 5.

IMPLEMENTACIÓN DE LOS CONCEPTOS DE OO CON JAVA

En este capítulo se propone fijar los conceptos aprendidos, pero a través de programas de aplicación que utilicen cada uno de ellos.

Implementado el concepto Jerarquía Los temas a implementar son:

� La Jerarquía de Clases � La jerarquía de clases que describen las figuras planas

Consideremos las figuras planas cerradas como el rectángulo y el círculo. Tales

figuras comparten características comunes, tales como, la posición de la figura, de su centro y el área de la figura, aunque el procedimiento para calcular el área sea completamente distinto. Podemos entonces, diseñar una jerarquía de clases, tal que la clase base denominada Figura, tenga las características comunes y cada clase derivada las específicas. La relación jerárquica se muestra en la figura siguiente:

La clase Figura es la que contiene las características comunes a dichas figuras concretas por lo tanto, no tiene forma ni tiene área. Esto lo expresamos declarando Figura como una clase abstracta, declarando la función miembro area abstract.

Las clases abstractas solamente se pueden usar como clases base para otras clases. No se pueden crear objetos pertenecientes a una clase abstracta. Sin embargo, se pueden declarar variables de dichas clases.

En el juego del ajedrez podemos definir una clase base denominada Pieza, con las

características comunes a todas las piezas, como es su posición en el tablero, y derivar de ella las características específicas de cada pieza particular. Así pues, la clase Pieza será una clase abstracta con una función abstract denominada mover, y cada tipo de pieza definirá dicha función de acuerdo a las reglas de su movimiento sobre el tablero.

Figura

CirculoRectángulo


66

La clase Figura

La definición de la clase abstracta Figura, contiene la posición x e y de la figura particular, de su centro, y la función area, que se va a definir en las clases derivadas para calcular el área de cada figura en particular.

public abstract class Figura {

protected int x; protected int y; public Figura(int x, int y) {

this.x=x; this.y=y;

}public abstract double area();

}

La clase Rectángulo Las clases derivadas heredan los miembros dato x e y de la clase base, y definen

la función area, declarada abstract en la clase base Figura, ya que cada figura particular tiene una fórmula distinta para calcular su área. Por ejemplo, la clase derivada Rectangulo, tiene como datos, aparte de su posición (x, y) en el plano, sus dimensiones, es decir, su ancho y alto.

class Rectangulo extends Figura { protected double ancho, alto; public Rectangulo(int x, int y, double ancho,

double alto){ super(x,y); this.ancho=ancho; this.alto=alto;

}public double area(){

return ancho*alto; }

}

La primera sentencia en el constructor de la clase derivada es una llamada al constructor de la clase base, para ello se emplea la palabra reservada super. El constructor de la clase derivada llama al constructor de la clase base y le pasa las coordenadas del punto x e y. Después inicializa sus miembros dato ancho y alto.

En la definición de la función area, se calcula el área del rectángulo como producto

de la anchura por la altura, y se devuelve el resultado


67

La clase Círculo

class Circulo extends Figura { protected double radio; public Circulo(int x, int y, double radio){

super(x,y); this.radio=radio;


return Math.PI*radio*radio; }

}

Como vemos, la primera sentencia en el constructor de la clase derivada es una llamada al constructor de la clase base empleando la palabra reservada super.Posteriormente, se inicializa el miembro dato radio, de la clase derivada Círculo.

En la definición de la función area, se calcula el área del círculo mediante la conocida fórmula p*r2, o bien p*r*r. La constante Math.PI es una aproximación decimal del número irracional pi.

Uso de la jerarquía de clases. Creamos un objeto c de la clase Círculo situado en el punto (0, 0) y de 5.5

unidades de radio. Calculamos y mostramos el valor de su área.

Circulo c=new Circulo(0, 0, 5.5); System.out.println("Area del círculo "+c.area());

Creamos un objeto r de la clase Rectangulo situado en el punto (0, 0) y de dimensiones 5.5 de anchura y 2 unidades de largo. Calculamos y mostramos el valor de su área.

Rectangulo r=new Rectangulo(0, 0, 5.5, 2.0); System.out.println("Area del rectángulo "+r.area());

Veamos ahora, una forma alternativa, guardamos el valor devuelto por new al crear objetos de las clases derivadas en una variable f del tipo Figura (clase base).


68

Figura f=new Circulo(0, 0, 5.5); System.out.println("Area del círculo "+f.area()); f=new Rectangulo(0, 0, 5.5, 2.0); System.out.println("Area del rectángulo

"+f.area());

Enlace dinámico o binding. En el lenguaje C, los identificadores de la función están asociados siempre a

direcciones físicas antes de la ejecución del programa, esto se conoce como enlace temprano o estático. Ahora bien, los lenguajes C++ y Java permiten decidir a que función llamar en tiempo de ejecución, esto se conoce como enlace tardío o dinámico.

Podemos crear un array de la clase base Figura y guardar en sus elementos

los valores devueltos por new al crear objetos de las clases derivadas.

Figura[] fig=new Figura[4]; fig[0]=new Rectangulo(0,0, 5.0, 7.0); fig[1]=new Circulo(0,0, 5.0); fig[2]=new Circulo(0, 0, 7.0); fig[3]=new Rectangulo(0,0, 4.0, 6.0);

¿A qué función area llamará la sentencia: ?

fig[i].area(); La respuesta será, según sea el índice i.

Si i es cero, el primer elemento del array guarda una referencia a un objeto de la clase Rectangulo, luego llamará a la función miembro area de Rectangulo.

Si i es uno, el segundo elemento del array guarda una referencia un objeto de la clase Circulo, luego llamará también a la función area de Circulo, y así sucesivamente.

Podemos introducir el valor del índice i, a través del teclado, o seleccionando un

control en un applet, en el momento en que se ejecuta el programa. Luego, la decisión sobre qué función area se va a llamar se retrasa hasta el tiempo de ejecución.

Ejemplo de polimorfismo. Supongamos que deseamos saber la figura que tiene mayor área

independientemente de su forma. Primero, programamos una función que halle el mayor de varios números reales positivos.


69

double valorMayor(double[] x){ double mayor=0.0; for (int i=0; i<x.length; i++)

if(x[i]>mayor){ mayor=x[i];

}return mayor;

}

Ahora, la llamada a la función valorMayor

double numeros[]={3.2, 3.0, 5.4, 1.2}; System.out.println("El valor mayor es " +

valorMayor(numeros));

La función figuraMayor que compara el área de figuras planas es semejante a la función valorMayor anteriormente definida, se le pasa el array de objetos de la clase base Figura. La función devuelve una referencia al objeto cuya área es la mayor.

static Figura figuraMayor(Figura[] figuras){

Figura mFigura=null; double areaMayor=0.0; for(int i=0; i<figuras.length; i++){

if(figuras[i].area()>areaMayor){ areaMayor=figuras[i].area(); mFigura=figuras[i];

}}return mFigura;

}

La clave de la definición de la función está en las líneas

if(figuras[i].area()>areaMayor){ areaMayor=figuras[i].area(); mFigura=figuras[i];

}

En la primera línea, se llama a la versión correcta de la función area dependiendo de la referencia al tipo de objeto que guarda el elemento figuras[i] del array. En areaMayor se guarda el valor mayor de las áreas calculadas, y en mFigura, la figura cuya área es la mayor.

La principal ventaja de la definición de esta función estriba en que la función

figuraMayor está definida en términos de la variable figuras de la clase base


70

Figura, por tanto, trabaja no solamente para una colección de círculos y rectángulos, sino también para cualquier otra figura derivada de la clase base Figura. Así si se deriva Triangulo de Figura, y se añade a la jerarquía de clases, la función figuraMayor podrá manejar objetos de dicha clase, sin modificar para nada el código de la misma.

Veamos ahora la llamada a la función figuraMayor

Figura[] fig=new Figura[4]; fig[0]=new Rectangulo(0,0, 5.0, 7.0); fig[1]=new Circulo(0,0, 5.0); fig[2]=new Circulo(0, 0, 7.0); fig[3]=new Rectangulo(0,0, 4.0, 6.0); Figura fMayor=figuraMayor(fig); System.out.println(“El área mayor es “+fMayor.area());

Pasamos el array fig a la función figuraMayor, el valor que retorna lo guardamos en fMayor. Para conocer el valor del área, desde fMayor se llamará a la función miembro area. Se llamará a la versión correcta dependiendo de la referencia al tipo de objeto que guarde por fMayor. Si fMayor guarda una referencia a un objeto de la clase Circulo, llamará a la función area definida en dicha clase. Si fMayor guarda una referencia a un objeto de la clase Rectangulo,llamará a la función area definida en dicha clase, y así sucesivamente.

La combinación de herencia y enlace dinámico se denomina polimorfismo. El

polimorfismo es, por lo tanto, la técnica que permite pasar un objeto de una clase derivada a funciones que conocen el objeto solamente por su clase base.

Ampliación de la jerarquía de clases. Ampliamos el árbol jerárquico de las clases que describen las figuras planas

regulares:

Figura

Cuadrado

RectánguloTriángulo Círculo


71

La clase Cuadrado es una clase especializada de Rectangulo, ya que un cuadrado tiene los lados iguales. El constructor solamente precisa de tres argumentos los cuales corresponden a la posición de la figura y a la longitud del lado.

class Cuadrado extends Rectangulo{ public Cuadrado(int x, int y, double dimension){

super(x, y, dimension, dimension); }

}

El constructor de la clase derivada llama al constructor de la clase base y le pasa la posición x e y de la figura, el ancho y alto que tienen el mismo valor. No es necesario redefinir una nueva función area. La clase Cuadrado hereda la función area definida en la clase Rectangulo.

La clase Triangulo.

Esta clase tiene como datos, aparte de su posición (x, y) en el plano, la base y la altura del triángulo.

class Triangulo extends Figura{ protected double base, altura; public Triangulo(int x, int y, double base,

double altura){ super(x, y); this.base=base; this.altura=altura; }

public double area(){ return base*altura/2; }}

El constructor de la clase Triangulo llama al constructor de la clase Figura, le pasa las coordenadas x e y de su centro, y luego inicializa los miembros dato base y altura.

En la definición de la función area, se calcula el área del triángulo como producto de la base por la altura y dividido por dos.


72

El operador instanceof. El operador instanceof tiene dos operandos:

� un objeto en el lado izquierdo, y, � una clase en el lado derecho.

Esta expresión devuelve true o false dependiendo de que el objeto situado a

la izquierda sea o no una instancia de la clase situada a la derecha o de alguna de sus clases derivadas.

Rectangulo rect=new Rectangulo(0, 0, 5.0, 2.0); rect instanceof String //false rect instanceof Rectangulo //true

El objeto rect de la clase Rectangulo no es un objeto de la clase String. El objeto rect si es un objeto de la clase Rectangulo.

Veamos la relación entre rect y las clases de la jerarquía

rect instanceof Figura //true rect instanceof Cuadrado //false

rect es un objeto de la clase base Figura pero no es un objeto de la clase derivada Cuadrado

En resumen: La herencia es la propiedad que permite la creación de nuevas clases a partir de

clases ya existentes. La clase derivada hereda los datos y las funciones miembro de la clase base, y

puede redefinir algunas de las funciones miembro o definir otras nuevas, para ampliar la funcionalidad que ha recibido de la clase base. Para crear un objeto de la clase derivada se llama primero al constructor de la clase base mediante la palabra reservada super. Luego, se inicializan los miembros dato de dicha clase derivada.

El polimorfismo se implementa por medio de las funciones abstractas, en las

clases derivadas se declara y se define una función que tiene el mismo nombre, el mismo número de parámetros y del mismo tipo que en la clase base, pero que da lugar a un comportamiento distinto, específico de los objetos de la clase derivada. (redefinición de métodos)


73

Enlace dinámico significa que la decisión sobre la función a llamar se demora hasta el tiempo de ejecución del programa.

No se pueden crear objetos de una clase abstracta pero sí se pueden declarar

referencias en las que guardamos el valor devuelto por new al crear objetos de las clases derivadas. Esta peculiaridad nos permite pasar un objeto de una clase derivada a una función que conoce el objeto solamente por su clase base. De este modo podemos ampliar la jerarquía de clases sin modificar el código de las funciones que manipulan los objetos de las clases de la jerarquía.

Clases y Métodos Finales Clases Finales.

Se puede declarar una clase como final, cuando no nos interesa crear clases derivadas de dicha clase. La clase Cuadrado se puede declarar como final, ya que no se espera que ningún programador necesite crear clases derivadas de Cuadrado.

final class Cuadrado extends Rectangulo{ public Cuadrado(int x, int y, double dimension){ super(x, y, dimension, dimension);

}}

Uno de los mecanismos que tienen los hackers (piratas) para dañar o para obtener información privada en los sistemas es la de crear una clase derivada y sustituir dicha clase por la original. La clase derivada actúa exactamente igual que la original pero también puede hacer otras cosas, normalmente, dañinas. Para prevenir los posibles daños, se declara la clase como final, impidiendo a cualquier programador la creación de clases derivadas de ésta.

Por ejemplo, la clase String que es una de las más importantes en la programación en lenguaje Java, está declarada como final. El lenguaje Java garantiza que siempre que se utilice un string, es un objeto de la clase String que se encuentra en el paquete java.lang.String, y no cualquier otro string.

Métodos finales. Como sabemos, una de las formas de aprovechar el código existente, es la de

crear una clase derivada y redefinir algunos de los métodos de la clase base.


74

class Base{ //...

final public void funcionFinal(){ //... }

public void dibujar(Graphics g){ }}

class Derivada{ //...

public void dibujar(Graphics g){ // dibujar algunas figuras }}

La clase Base define una función miembro pública “dibujar”, que no dibuja nada en el contexto gráfico g. La clase Derivada redefine la función miembro dibujar, para dibujar algunas figuras en el contexto grafico g. La función que se redefine tiene que tener la misma declaración en la clase Base y en la clase Derivada.

Para evitar que las clases derivadas redefinan una función miembro de una clase base, se le antepone la palabra clave final. La función miembro funcionFinal de la clase Base no se puede redefinir en la clase Derivada, pero si se puede redefinir la función miembro dibujar.

Interfases.

Una interfase es una colección de declaraciones de métodos (sin definirlos) y también puede incluir constantes.

Runnable es un ejemplo de interfase en el cual se declara, pero no se

implementa, una función miembro run.

public interface Runnable { public abstract void run(); }

Las clases que implementen (implements) el interfase Runnable han de definir obligatoriamente la función run.


75

class Animacion implements Runnable{ //..

public void run(){ // define la función run }}

El papel de la interfase es el de describir algunas de las características de una clase. Por ejemplo, el hecho de que una persona sea un futbolista no define su personalidad completa, pero hace que tenga ciertas características que las distinguen de otras.

Clases que no están relacionadas pueden implementar la interfase Runnable,

por ejemplo, una clase que describa una animación, y una clase que realice un cálculo intensivo.

Diferencias entre una Interfase y una Clase Abstracta. Una interfase es:

� una lista de métodos no implementados, � puede incluir la declaración de constantes.

Una clase abstracta puede incluir:

� métodos implementados y no implementados o abstractos, � miembros dato constantes y otros no constantes.

Ahora bien, la diferencia es mucho más profunda. Imaginemos que Runnable

fuese una clase abstracta. Un applet definido por la clase MiApplet que moviese una figura por su área de trabajo, derivaría a la vez de la clase base Applet (que describe la funcionalidad mínima de un applet que se ejecuta en un navegador) y de la clase Runnable.

En el lenguaje Java la clase MiApplet deriva de la clase base Applet e implementa el interfase Runnable

class MiApplet extends Applet implements Runnable{ //...

// define la función run de la interfase public void run(){

//... }// redefine paint de la clase base Applet public void paint(Graphics g){

//... }// define otras funciones miembro

}


76

Una clase solamente puede derivar extends de una clase base, pero puede implementar varias interfases. Los nombres de las interfases se colocan separados por una coma después de la palabra reservada implements.

El lenguaje Java no fuerza una relación jerárquica, simplemente permite que clases no relacionadas puedan tener algunas características de su comportamiento similares.

Las interfases y el Polimorfismo.

En el lenguaje C++, es posible la herencia múltiple, pero este tipo de herencia

presenta dificultades. Por ejemplo, cuando dos clases B y C derivan de una clase base A, y a su vez una clase D deriva de B y C. Este problema es conocido con el nombre de diamante.

En el lenguaje Java solamente existe la herencia simple, pero las clases pueden implementar interfases. Vamos a que la importancia de las interfases no consiste en resolver los problemas inherentes a la herencia múltiple sin forzar relaciones jerárquicas, sino es el de incrementar el polimorfismo del lenguaje más allá del que proporciona la herencia simple.

Para explicar este aspecto importante y novedoso del lenguaje Java adaptaremos

los ejemplos que aparecen en el artículo del Bill Venners "Designing with interfaces" publicado en Java World (http://www.javaworld.com/) en Diciembre de 1998.

Comparemos la herencia simple mediante un ejemplo similar al de la jerarquía de

las figuras planas, con las interfases.

Herencia simple. Ver los programas completos: Animal.java, PoliApp.java

Creamos una clase abstracta denominada Animal de la cual deriva las clases Gato y Perro. Ambas clases redefinen la función habla declarada abstracta en la clase base Animal.

A

CB C

D


77

public abstract class Animal { public abstract void habla();

}

class Perro extends Animal{ public void habla(){

System.out.println("¡Guau!"); }

}

class Gato extends Animal{ public void habla(){

System.out.println("¡Miau!"); }

}

El polimorfismo nos permite pasar la referencia a un objeto de la clase Gato a una función onomatopeya que conoce al objeto por su clase base Animal

public class PoliApp { public static void main(String[] args) {

Gato gato=new Gato(); onomatopeya(gato);

}static void onomatopeya(Animal sujeto){

sujeto.habla(); }

}

El compilador no sabe exactamente que objeto se le pasará a la función onomatopeya en el momento de la ejecución del programa. Si se pasa un objeto de la clase Gato se imprimirá ¡Miau!, si se pasa un objeto de la clase Perro se imprimirá ¡Guau!.

El compilador solamente sabe que se le pasará un objeto de alguna clase derivada de Animal. Por tanto, el compilador no sabe que función habla será llamada en el momento de la ejecución del programa.

El polimorfismo nos ayuda a hacer el programa más flexible, porque en el futuro

podemos añadir nuevas clases derivadas de Animal, sin que cambie para nada el método onomatopeya.

Ver programas completos donde se trata el tema interfases: Parlanchin.java, Animal.java, Reloj.java, PoliApp.java


78

Vamos a crear una interfase denominada Parlanchin que contenga la declaración de una función denominada habla.

public interface Parlanchin { public abstract void habla();

}

Hacemos que la jerarquía de clases que deriva de Animal implemente la interfase Parlanchin

public abstract class Animal implements Parlanchin{ public abstract void habla();

}

class Perro extends Animal{ public void habla(){

System.out.println("¡Guau!"); }

}

class Gato extends Animal{ public void habla(){

System.out.println("¡Miau!"); }

}

Ahora veamos otra jerarquía de clases completamente distinta, la que deriva de la clase base Reloj. Una de las clases de dicha jerarquía Cucu implementa la interfase Parlanchin y por lo tanto, debe de definir obligatoriamente la función habla declarada en dicha interfase.

public abstract class Reloj { }

class Cucu extends Reloj implements Parlanchin{ public void habla(){ System.out.println("¡Cucu, cucu, ..!"); }}

Definamos la función onomatopeya de modo que conozca al objeto que se le pasa, no por una clase base, sino por la interfase Parlanchin. A dicha función le podemos pasar cualquier objeto que implemente la interfase Parlanchin, esté o no en la misma jerarquía de clases.


79

public class PoliApp { public static void main(String[] args) {

Gato gato=new Gato(); onomatopeya(gato); Cucu cucu=new Cucu(); onomatopeya(cucu);

}static void onomatopeya(Parlanchin sujeto){

sujeto.habla(); }

}

Al ejecutar el programa, veremos que se imprime en la consola ¡Miau!, porque a la función onomatopeya se le pasa un objeto de la clase Gato, y después ¡Cucu, cucu, ..!, porque a la función onomatopeya se le pasa un objeto de la clase Cucu.

Si solamente hubiese herencia simple, Cucu tendría que derivar de la clase Animal (lo que no es lógico) o bien no se podría pasar a la función onomatopeya.

Con interfases, cualquier clase en cualquier familia puede implementar la interfase Parlanchin, y se podrá pasar un objeto de dicha clase a la función onomatopeya. Esta es la razón por la cual las interfases proporcionan más polimorfismo que el que se puede obtener de una simple jerarquía de clases.

Composición. Hay dos formas de reutilizar el código:

� mediante la herencia, � mediante la composición: se utiliza una clase ya creada incluyendo

instancias de la misma en nuevas clases representa una relación "tiene un".

Es decir, si tenemos una clase Rueda y una clase Coche, es de esperar que la clase Coche tenga cuatro instancias de Rueda:

class Coche { Rueda rueda1, rueda2, rueda3, rueda 4;

... }

La composición significa utilizar objetos dentro de otros objetos. Por ejemplo, un applet es un objeto que contiene en su interior otros objetos como botones, etiquetas, etc. Cada uno de los controles está descrito por una clase.


80

Vamos a estudiar una clase Rectangulo definiendo el origen, no como un par de coordenadas x e y (números enteros) sino como objetos de una clase denominada Punto.

Ver Programas completos: Punto.java, Rectángulo.java, RectanguloApp.java

La clase punto La clase Punto tiene dos miembros dato, la abscisa x y la ordenada y de un

punto del plano. Definimos dos constructores uno por defecto que sitúa el punto en el origen, y otro constructor explícito que proporciona las coordenadas x e y de un punto concreto.

public class Punto {

int x; int y; // funciones miembro

}

El constructor explícito de la clase Punto podemos escribirlo de dos formas

public Punto(int x1, int y1) { x = x1; y = y1;

}

Cuando el nombre de los parámetros es el mismo que el nombre de los miembros datos escribimos

public Punto(int x, int y) {

this.x = x; this.y = y;

}

this.x que está a la izquierda y que recibe el dato x que se le pasa al constructor se refiere al miembro dato, mientras que x que está a la derecha es el parámetro.

Recordemos que this es una palabra reservada que guarda una referencia al

objeto propio, u objeto actual. La función miembro desplazar simplemente cambia la posición del punto desde

(x, y) a (x+dx, y+dy). Cuando es llamada, recibe en sus dos parámetros dx y dy el desplazamiento del punto y actualiza las coordenadas x e y del punto. La función no retorna ningún valor.


81

public void desplazar(int dx, int dy){ x += dx; y += dy;

}

Para crear un objeto de la clase Punto cuyas coordenadas x e y valgan respectivamente 10 y 23 escribimos

Punto p = new Punto(10, 23);

Para desplazar el punto p 10 unidades hacia la izquierda y 40 hacia abajo, llamamos desde el objeto p a la función desplazar y le pasamos el desplazamiento horizontal y vertical.

p.desplazar(-10, 40);

La clase Rectangulo La clase Rectangulo tiene como miembros dato, el origen, que es un objeto de

la clase Punto y las dimensiones ancho y alto.

public class Rectangulo { Punto origen; int ancho; int alto ; // funciones miembro

}

El constructor por defecto, crea un rectángulo situado en el punto 0,0 y con dimensiones nulas

public Rectangulo() { origen = new Punto(0, 0); ancho=0; alto=0;

}

El constructor explícito crea un rectángulo situado en un determinado punto p ycon unas dimensiones que se le pasan en el constructor


82

public Rectangulo(Punto p, int w, int h) { origen = p; ancho = w; alto = h;

}

Podemos definir otros constructores en términos del constructor explícito usando la palabra reservada this.

public Rectangulo(Punto p) { this(p, 0, 0);

}

public Rectangulo(int w, int h) { this(new Punto(0, 0), w, h);

}

El primero crea un rectángulo de dimensiones nulas situado en el punto p. El segundo, crea un rectángulo de unas determinadas dimensiones, w y h, situándolo en el punto 0, 0.

Dentro del cuerpo de cada constructor, se llama al constructor explícito mediante

this pasándole en sus parámetros los valores apropiados. Para desplazar un rectángulo, trasladamos su origen (esquina superior izquierda) a

otra posición, sin cambiar su anchura o altura. Desde el objeto origen, llamamos a la función desplazar miembro de la clase Punto

void desplazar(int dx, int dy) { origen.desplazar(dx, dy);

}

Objetos de la clase Rectángulo. Para crear un rectángulo rect1 situado en el punto (0, 0) y cuyas dimensiones

son 100 y 200 escribimos

Rectangulo rect1=new Rectangulo(100, 200);

Para crear un rectángulo rect2, situado en el punto de coordenadas 44, 70 y de dimensiones nulas escribimos:

Punto p=new Punto(44, 70); Rectangulo rect2=new Rectangulo(p);


83

O bien, en una sóla línea

Rectangulo rect2=new Rectangulo(new Punto(44, 70)); Para desplazar el rectángulo rect1 desde el punto (100, 200) a otro punto

situado 40 unidades hacia la derecha y 20 hacia abajo, sin modificar sus dimensiones, escribimos:

rect1.desplazar(40, 20);

Para hallar y mostrar el área del rectángulo rect1 podemos escribir

System.out.println("el área es " + rect1.calcularArea());

Para hallar el área de un rectángulo de 100 unidades de largo y 50 de alto y

guardar el resultado en la variable entera areaRect, escribimos en una sola línea:

int areaRect=new Rectangulo(100, 50).calcularArea();

Definiendo Clases. Definición de Clases.

Cuando trabajamos con el flujo de entrada y salida, quizás vimos que hay pasos

muy tediosos. Quizás no se comportan los objetos de estas clases tal y como nosotros queremos. ¿Tenemos que aceptar un comportamiento de un objeto inadecuado para nuestros propósitos solo porque otro programador los diseñó así? No, nosotros podemos definir nuestras propias clases que provean el comportamiento que nosotros requerimos. Definición de Clase Simple:

class Saludos { public Saludos(){ }public void saludo(){

System.out.println("Hola mundo!"); }}

Esto define una clase Saludos con un constructor y un solo método saludo que despliega el mensaje "Hola mundo!". Usando esta definición podemos crear un objeto de la siguiente forma:

Saludos x; x = new Saludos();


84

Podemos mandarle un mensaje de la siguiente forma:

x.saludo();

En general todos los métodos llevan la palabra reservada public al principio. Un método simple tiene la estructura:

public valor-retorno nombre-metodo (){ // cuerpo del método }

La palabra reservada void es usada con aquellos métodos que no devolverán nada.

Definición de Métodos con Parámetros.

Supongamos que queremos diseñar un método saludo mas genérico, en donde

al mandar el mensaje podamos escoger a quien saludar. Esta información adicional, la tendría que incluir el que llama al método como argumento de la siguiente forma:

x.saludo("alumnos")

Para desplegar "Hola alumnos!". Para poder implementar esto necesitamos incluir parámetros en el encabezado del

método, para que este tenga acceso a esta información. La nueva clase quedaría entonces así:

class Saludos { public Saludos(){ }public void saludo(){

System.out.println("Hola mundo!"); }public void saludo(String alguien){

System.out.println("Hola".concat(alguien).concat("!")); }}

Al incluir dos métodos con el mismo nombre, pero diferente firma,

public void saludo() public void saludo(String alguien)

estamos sobrecargando el método saludo. Por lo tanto cuando el usuario quiere saludar a todo el mundo, hace la llamada:


85

x.saludo(); pero cuando quiere saludar a alguien en especial, hace la llamada

x.saludo("Colegio");

Como podemos saludar a todo el mundo sin especificarlo explícitamente, se dice que el saludo al mundo es el saludo default.

Uso de Atributos.

Supongamos que queramos darle la opción al creador del objeto Saludos que escoja el saludo default, para que no necesariamente sea al "mundo". Esta información debería de ser proveída en el constructor del objeto. Así, con las siguientes instrucciones: desplegarían un saludo a la universidad:

Saludos x; x = new Saludos("Universidad"); x.saludos();

Para poder implementar esto, debemos incluir un constructor que reciba una

cadena de argumento. Es decir, que se debe incluir un constructor con un parámetro String. Para que tenga el método saludo acceso a la cadena recibida en el constructor, necesitamos almacenarla en un atributo. Esto lo hacemos porque un método no puede acceder a las variables o parámetros de los otros métodos.

Los atributos pueden ser accedidos por todos los métodos de dentro de la clase.

La declaración de estos es la misma que las variables, con la diferencia que comienzan con la palabra reservada private. La nueva clase quedaría así:

class Saludos { private String quien; public Saludos(){ quien = "mundo"; }

public Saludos(String s){ quien = s; }

public void saludo(){ System.out.println("Hola ".concat(quien).concat("!")); }public void saludo(String alguien){

System.out.println("Hola ".concat(alguien).concat("!")); }}


86

El orden de declaración entre los atributos y los métodos es irrelevante. Cualquier orden es legal. Como norma, conviene para la clase, que declararemos todos los atributos antes de los métodos.

Los miembros (atributos y métodos de la clase) pueden ser públicos, privados o

amigables (default). Los miembros públicos (public) pueden ser accedidos por todos. Los miembros amigables (friendly) pueden ser accedidos por miembros del

mismo paquete (conjunto de clases). Los miembros privados (private) solo pueden ser accedidos por miembros de

la misma clase.

Uso de la Definición de Clase.

El primer paso que tenemos que hacer es escribir nuestra clase Saludos en un archivo que tiene que llamarse Saludos.java. Como esta clase utiliza el PrintStream, asegúrese de incluir la línea:

import java.io.*;

Después compilamos este archivo para producir Saludos.class. Una vez que ya hicimos esto, podemos utilizar nuestra clase en un programa. Por ejemplo, podríamos tener:

import java.io.*; class SaludandoUnPoco { public static void main(String args[]) { System.out.println("Saludando un poco a todos!"); Saludos s1, s2;

s1 = new Saludos(); s2 = new Saludos("FISICC");

s1.saludo(); s2.saludo(); s1.saludo("Suger Montano"); }}

Ya el programa SaludandoUnPoco se compila y se corre de la manera usual.

Diseño e Implementación de Clases.

La definición de la clase trabajada anteriormente fue extremadamente casual. Empezamos con una clase muy simple y le fuimos agregando funcionalidad mientras


87

lo íbamos necesitando. Dicho enfoque fue útil para explicar la definición de las clases, pero es poco funcional para escribir clases de alguna significación. Es como construir una casa, cuarto por cuarto. Necesitamos un enfoque más sistemático. Podemos seguir los siguientes pasos:

Diseño de la clase:

� Decida el comportamiento que la clase deberá proveer. Como el comportamiento de un objeto es proveído a través de sus métodos, determine claramente que métodos debe proveer la clase.

� Determine la interfase de la clase que se usará. La interfase de la clase es

la forma en que podemos usar un objeto de esta clase. En este paso ya es necesario determinar los prototipos de los métodos.

� Escriba un programa de prueba que utilice la clase. Esta es una forma de

revisar si lo que tenemos hasta ahora tiene sentido.

� Escriba un esqueleto de la clase. Este, el esqueleto, es la declaración de la clase con los prototipos de todos los métodos, pero con el cuerpo de los métodos vacío.


88

Implementación de la clase:

Consiste en escribir los cuerpos de los métodos y declarar los atributos mientras se vayan necesitando. Tenga en mente lo siguiente:

� Puede empezar a trabajar en cualquiera de los métodos. � Puede dejar de trabajar en cualquiera de los métodos antes de completarlo

e ir a trabajar en otro método.

� Mejora de la Implementación

� Por lo general cualquier código escrito, a pesar de que funcione puede ser mejorado. La interfase se debe mantener intacta.

Primer Ejemplo Completo: Clase para Entrada/Salida Interactiva (InteractiveIO)

Para ilustrar este enfoque de diseño e implementación de clases, vamos a comenzar resolviendo el problema de entrada y salida interactiva. Queremos diseñar una clase que provea una manera sencilla de leer y desplegar información.

Diseño de la Clase.

Comportamiento que la clase deberá proveer. Si tuviéramos una clase InteractiveIO quisiéramos que esta me ofreciera el

siguiente comportamiento:

� Escribir a la pantalla, asegurándome que se vaya a desplegar inmediatamente.

� Preguntar al usuario por información, desplegándole un mensaje y leyendo

una cadena del teclado, asegurándome que el mensaje se despliegue antes de que la computadora espere la entrada.

Interfase y Prototipos de los métodos.

A partir del comportamiento deseado de InteractiveIO, quisiéramos tener la

capacidad de hacer lo siguiente: Declarar una referencia a la clase InteractiveIO de la siguiente forma: InteractiveIO interIO; Esto me dice simplemente que la clase se debe llamar InteractiveIO.

Crear objetos que sean instancias de InteractiveIO, sin hacer referencia a System.in o System.out de la siguiente forma:

interIO = new InteractiveIO();


89

De esto podemos deducir que necesitaremos un constructor sin parámetros. Mandar un mensaje al objeto para escribir a pantalla de la siguiente forma: interIO.write("Por favor conteste cada pregunta.");

Debemos proveer un método write que reciba una cadena como parámetro, sin devolver nada.

Mandar un mensaje al objeto para preguntar una cadena, desplegando una frase

descriptiva de lo que queremos leer, de la siguiente forma: String s; s = interIO.promptAndRead("Cual es su nombre?"); Debemos proveer un método promptAndRead que reciba una cadena como

parámetro, y que devuelva una cadena. Aquí ya tenemos una idea clara del prototipo de los métodos que incluirá la clase

InteractiveIO. Estos son: public InteractiveIO() public void write(String s) public String promptAndRead(String s)

Programa de prueba que utilice la clase.

Para usar la clase, el programa de prueba más simple que podemos escribir es uno que lee una palabra y a continuación la despliega. Si nuestra clase InteractiveIO funcionara como nosotros quisiéramos este quedaría así:

import java.io.*; class ProbandoInteractiveIO { public static void main(String args[]) { InteractiveIO interIO; String line; interIO = new InteractiveIO(); line = interIO.promptAndRead("Ingrese una palabra: "); interIO.write(line); }}

Concluimos que una clase InteractiveIO diseñada tal y como la tenemos, lleva a cabo bien la tarea. Provee de una entrada y salida interactiva simple, despreocupándonos de System.in, System.out y flush. Esta clase haría todo esto por nosotros.


90

Esqueleto de la clase.

class InteractiveIO { // aqui irían los atributos, si necesitáramos public InteractiveIO() {

// enunciados }

/** despliega s*/ public void write(String s) { // enunciados }

/** despliega s, lee una cadena del teclado y devuelve una referencia a esta */

public String promptAndRead(String s) { // enunciados }}

Implementación de la clase Completamos los métodos de la clase.

class InteractiveIO { // aparentemente no necesitamos atributos public InteractiveIO() {

// parece que necesitamos nada! }

/** despliega s*/ public void write(String s) { System.out.print(s); System.out.flush(); }


public String promptAndRead(String s) throws Exception {

System.out.print(s); System.out.flush(); BufferedReader br = new BufferedRead(

new InputSteamReader(System.in)); String line; line = br.readLine(); return line; }}


91

La palabra reservada return se utiliza para dos operaciones en Java:

� Para retornar un valor. Su sintaxis es: return expresion;� Para forzar la salida de un método. No se ejecutara ninguna instrucción

después del return. Incluso si tengo un método que no retorna ningún valor, pero deseo salirme del método lo puedo hacer mediante el enunciado: return;

Mejora de la implementación.

Observemos que podemos optimizar el programa en los siguientes aspectos: No tiene sentido crear en cada llamada al método write una instancia del

BufferedReader. En vez de esto podemos crearlo una sola vez en el constructor y almacenar una referencia a este como atributo (para que sea accesible desde el método write).

Las primeras instrucciones del método promptAndRead son iguales a las del

método write. Podemos ahorrar esta repetición de código llamando al método write desde el método promptAndRead.

No necesitamos almacenar la referencia al objeto String en el método promptAndRead. Podemos obviar este paso devolviendo la referencia leída en composición.

La nueva implementación de la clase InteractiveIO entonces me queda así:

class InteractiveIO { private BufferedReader br; public InteractiveIO() throws Exception { br = new BufferedReader(

new InputStreamReader(System.in)); }

/** despliega s*/ public void write(String s) { System.out.print(s); System.out.flush(); }


public String promptAndRead(String s) { this.write(s); return keyb.readLine(); }

}


92

Aquí trabajamos con tres tipos de variables:

� Parámetros: son creadas cuando el método al cual pertenecen es invocado. Su valor inicial corresponde a la información enviada como argumento. Son destruidas cuando termina el método. Solo pueden ser accedidas por el método al cual pertenecen.

� Variables Locales: al igual que los parámetros, éstas son creadas cuando el método se invoca y destruidas cuando termina el método y sólo pueden ser accedidas por el método al cual pertenecen. A diferencia de los parámetros éstas deben ser inicializadas dentro del método.

� Atributos: tienen el mismo tiempo de vida que el objeto al cual pertenecen. Son creadas cuando el objeto es creado y destruidas cuando el objeto es destruido. Pueden ser accedidas por todos los métodos de la misma clase. Se acostumbra a declararlas private, ya que no deberían ser accedidas por métodos de otras clases.

Recordemos que cuando mandamos mensajes (al llamar a los métodos) necesitamos un receptor de dicho mensaje. En el método promptAndRead cuando invocamos al mensaje write el receptor de este mensaje debe ser el mismo objeto al cual promptAndRead pertenece. Usamos la palabra reservada this para hacer referencia al objeto al cual le pertenece el método. Podemos utilizar también la palabra reservada this para diferenciar entre variables locales y atributos que tengan el mismo nombre.

Ejercicios propuestos para el alumno:

� Agregue un método writeln a la clase InteractiveIO que reciba una cadena de caracteres, que la despliegue y que garantice que el siguiente carácter a desplegarse aparecerá en una nueva línea.

� Agregue un segundo método writeln (sobrecargado) en la clase

InteractiveIO que no reciba argumentos, pero garantice que el siguiente carácter a desplegarse aparecerá en una nueva línea.

Segundo Ejemplo Completo: Clase Nombre.

Diseñamos la clase InteractiveIO motivados por el deseo de un uso más conveniente del PrintStream y del BufferedReader. Por lo general nuestro punto de partida no son las clases existentes de Java sino problemas de la vida real que deseamos resolver modelándolos de alguna forma.

Las clases predefinidas que Java nos provee ni siquiera se acercan a modelar el

comportamiento de los elementos de nuestro mundo. El ejemplo que vamos a trabajar ahora es modelar el nombre de una persona. Podemos estar tentados a utilizar la clase String, pero esta no nos provee el comportamiento que nosotros quisiéramos de una clase Nombre


93

Diseño de la Clase.

Comportamiento que la clase deberá proveer. Si tuviera una clase Nombre quisiera que esta me ofreciera el comportamiento

para:

� Obtener las iniciales como una cadena. � Obtener el nombre como una cadena; en el orden apellido, primer nombre � Obtener el nombre como una cadena; en el orden primer nombre, apellido � Agregar o reemplazar un titulo.

Interfase y Prototipos de los métodos.

A partir del comportamiento deseado de la clase Nombre, quisiéramos estar en la

capacidad de hacer lo siguiente: Declarar una referencia a la clase Nombre de la siguiente forma: Nombre alumno; Esto me dice simplemente que la clase se debe llamar Nombre.

Crear objetos que sean instancias de Nombre, basados en el primer nombre y el apellido de la siguiente forma:

alumno = new Nombre("Juan", "Perez");

De esto podemos deducir que necesitaremos un constructor con dos parámetros

String.

Mandar un mensaje al objeto para obtener las iniciales como una cadena, de la siguiente forma:

String s; s = alumno.getInitials();

Debemos proveer un método getInitials que devuelva una cadena. Mandar un mensaje al objeto para obtener el nombre completo, en la forma

apellido, primer nombre; como una cadena, de la siguiente forma:

String s; s = alumno.getLastFirst();

Debemos proveer un método getLastFirst que devuelva una cadena. Mandar un mensaje al objeto para obtener el nombre completo, en la forma primer

nombre apellido precedido de un título opcional, como una cadena, de la siguiente forma:


94

String s; s = alumno.getFirstLast();

Debemos proveer un método getFirstLast que devuelva una cadena. Mandar un mensaje al objeto para agregar o reemplazar el título de la siguiente forma:

alumno.setTitle("Ingeniero");

Debemos proveer un método setTitle que reciba como parámetro una cadena. Aquí ya tenemos una idea clara del prototipo de los métodos que incluirá la clase

Nombre. Estos son:

public Nombre(String pnom, String ap) public String getInitials() public String getLastFirst() public String getFirstLast() public void setTitle(String newTitle)

Observe que el constructor no incluye al titulo. Esta fue nuestra opción (como diseñadores de la clase). Nuestro razonamiento fue que: no todos tienen titulo.

En contraste con el nombre y apellido, el titulo no es permanente, por lo que

permitimos que se pudiera agregar un titulo o modificarlo.

Programa de prueba que utilice la clase.

Para usar la clase, el programa de prueba más simple que podemos escribir es uno que lea el primer nombre y apellido y el título. Después el programa deberá desplegar:

� las iniciales � el nombre completo en la forma apellido, primer nombre � el nombre completo en la forma primer nombre apellido.

Una vez que tenemos funcionando nuestra clase InteractiveIO la utilizaremos

en el programa de prueba. Si nuestra clase Nombre funcionara como nosotros quisiéramos este quedaría así:


95

import java.io.*; class ProbandoNombre { public static void main(String args[]) { Nombre n; String primer, apellido, titulo; InteractiveIO io;

io = new InteractiveIO(); primer = io.promptAndRead("Ingrese primer nombre: "); apellido = io.promptAndRead("Ingrese apellido: "); titulo = io.promptAndRead("Ingrese apellido:");

n = new Nombre(primer, apellido); n.setTitle(titulo); io.writeln(n.getInitials()); io.writeln(n.getFirstLast()); io.writeln(n.getLastFirst()); }}

Concluimos que la clase Nombre diseñada tal y como la tenemos, lleva a cabo bien la tarea. Provee una forma simple de manipular los nombres.

Esqueleto de la clase.

class Nombre { // aquí van los atributos si las necesitáramos public Nombre(String pnom, String ap) {

// enunciados }public String getInitials() {

// enunciados }public String getLastFirst() {

// enunciados }public String getFirstLast() {

// enunciados }public void setTitle(String newTitle) {

// enunciados }}

Implementación de la clase

Completamos los métodos de la clase. Razonamos que: Los métodos getFirstLast y getLastFirst necesitan ambos acceso al primer

nombre y al apellido. De la misma forma getFirstLast y setTitle necesitan


96

ambos acceso al título. Por lo tanto, necesitamos hacer del primer nombre, apellido y titulo, atributos.

Asumiremos que mientras no se especifique un titulo la persona no lo tiene. class Nombre { private String primerNombre, apellido, titulo; public Nombre(String pnom, String ap) {

primerNombre = pnom; apellido = ap; titulo = ""; }public String getInitials() {

String inicNom, inicAp; inicNom = primerNombre.substring(0,1); inicAp = apellido.substring(0,1); return inicNom.concat(".").concat(apellido).concat("."); }public String getLastFirst() {

return apellido.concat(", ").concat(primerNombre); }public String getFirstLast() {

return titulo.concat(" ").concat(primerNombre).concat( " ").concat(apellido);

}public void setTitle(String newTitle) {

titulo = newTitle; }}

El objetivo del constructor es garantizar que el objeto comience con valores válidos en sus atributos.

Queda la mejora de la clase a discreción del alumno. Para la clase InteractiveIO, es poco probable que se declare más de un objeto

de esta clase. Sin embargo, para el caso de la clase Nombre, es muy probable que se declaren muchas instancias de esta clase.

Cada una de estas compartirá los mismos métodos pero tendrán su propio juego

de atributos: primerNombre, apellido y titulo. Esto tiene sentido ya que cada objeto instancia de Nombre tendrá su propio primer nombre, apellido y titulo.

A pesar de que todas las instancias de la clase Nombre vayan a tener el mismo

comportamiento (proveído por sus métodos), las llamadas devolverán resultados distintos. Esto es porque los atributos tendrán distintos valores.

Los valores de sus atributos constituyen su estado. Puedo mandarle un mensaje

getLastFirst a dos objetos distintos, y se comportaran igual y pero pueden devolver distinto resultado ya que sus estados son distintos.


97

Ejercicios propuestos para el alumno:

� Escriba un programa que lea tres pares de primer nombre, apellido y a continuación despliegue sus iniciales. El programa deberá usar la clase Nombre.

� Agregue un método IlustrateName a la clase Nombre que despliegue el nombre a pantalla.

� Diseñe e implemente una clase NombreLargo, que tome en consideración

(además del primer nombre y apellido como lo hizo la clase Nombre) el segundo nombre.

� Diseñe e implemente una clase Direccion.

Diseñando la Salida para los Objetos En el diseño original de la clase Nombre, la clase no leía ni desplegaba objetos

Nombre. La entrada y salida era la responsabilidad del usuario de la clase. Algunas veces es deseable que la clase se haga responsable de la entrada y la salida. Para ilustrar como se podría implementar esto, le agregaremos este comportamiento a la clase Nombre, comenzando con la salida.

Podemos diseñar un método print para la clase Nombre que provea el

comportamiento de producir como salida el nombre completo. Hay que considerar dos aspectos en este punto:

� ¿En que forma se debe producir el nombre completo? � La salida, ¿hacia donde debería ir?

La primera cuestión es algo de diseño, arbitrariamente podemos escoger producir

el nombre completo en el orden titulo primer-nombre apellido. Podemos de una forma arbitraria escoger hacia donde debería ir la salida, ya sea al monitor o a algún archivo en especial. Sin embargo, si nos vamos a tomar la molestia de agregar un método extra a la clase, podríamos diseñarlo para que sea lo más general posible sin limitarlo a ninguna salida específica. Podríamos hacer responsabilidad del que invoca el método, hacia donde debería producirse la salida.

Hasta ahora, hemos manejado la salida a través del print y println ha

instancias del PrintStream. Como diseñadores de la clase Nombre, podríamos insistir que la salida se maneje a través del PrintStream. Podríamos pedirle al invocador del método print que incluya como argumento el objeto PrintStream, a donde desea que se mande la salida.

El método quedaría así: void print (PrintStream destino)

De esta manera, si el que llama al método print desea desplegar el nombre en la pantalla, en la llamada, incluiría como argumento System.out. Por otro lado si


98

desease mandar el nombre a un archivo incluiría como argumento alguna instancia del FileOutputStream. Un ejemplo de uso podría ser:

Nombre n; PrintStream p; n = new Nombre("Jodie","Foster"); n.setTitle("Licenciada"); p = new PrintStream (new FileOutputStream ("actrices.txt")); n.print(System.out); // despliega Licenciada Jodie Foster en la pantalla n.print(p); // escribe Licenciada Jodie Foster en el archivo

La implementación quedaría así: void print (PrintStream destino){ destino.print(this.getLastFirst()); }

Ejercicio propuesto para el alumno:

� Implemente una clase llamada SalidaConBitacora. El constructor recibe un solo argumento: una cadena que representa el nombre de un archivo. La clase debe proveer dos métodos: print y println, ambos, de los cuales deben recibir una cadena de argumento. Estos métodos deben mandar la cadena a desplegar a pantalla y a escribirla al archivo.

Diseñando la Entrada para los Objetos

Desearíamos tener la capacidad de mandarle un mensaje pidiendo que se cree un objeto Nombre desde cierta entrada. Nos topamos con un problema: los mensajes los mandamos a objetos y no tenemos un objeto a quien mandarle el mensaje. De hecho, el envío del mensaje debería de crear el objeto.

En realidad no deseamos mandarle el mensaje a un objeto instancia de la clase

Nombre, sino a la clase Nombre. Esto en Java se lleva a cabo a través de un tipo de método conocido como método estático. Estos métodos son definidos de la misma forma que los otros métodos, excepto que estos llevan la palabra reservada static antes del tipo de retorno. Los métodos estáticos no están asociados a ningún objeto. Tienen las siguientes características:

� Deben de ser invocados independientemente de cualquier instancia de la

clase. Se utiliza el nombre de la clase como receptor del mensaje. � No pueden accesar ningún atributo.

� Al igual que con el método print nos debemos preguntar dos cosas:

o ¿En que forma se debe leer el nombre? o La entrada, ¿de donde debería provenir?


99

Requeriremos como diseñadores de la clase, que el primer nombre aparezca en una línea de por sí solo y el apellido en la siguiente línea. De nuevo, esta decisión es arbitraria. Además diseñaremos el método de tal forma que la fuente de entrada sea responsabilidad del que invoque el método. Requeriremos que como argumento se pase una referencia a un BufferedReader, de donde será leído el nombre.

El prototipo sería así: public static Nombre read(BufferedReader fuente)

Podemos utilizar la clase Nombre para leer un nombre desde el teclado y desde un archivo de la siguiente forma:

Nombre n; FileInputStream f; BufferedReader brFile, brKeyb; InputStreamReader isrFile, isrKeyb; isrKeyb = new InputStreamReader(System.in) brKeyb = new BufferedReader(isrKeyb); f = new FileInputStream(new File("nombres.txt")); isrFile = new InputStreamReader(f); brFile = new BufferedReader(isrFile); n = Nombre.read(brKeyb); n.print(System.out); n = Nombre.read(brFile); n.print(System.out);

La implementación quedaría así:

public static Nombre read(BufferedReader fuente){ String primer, apellido; primer = fuente.readLine(); apellido = fuente.readLine(); return new Nombre(primer, apellido); }

Anteriormente vimos que, cuando se esta ingresando la información desde el teclado, es aconsejable desplegar un mensaje para decirle al usuario que información es la que se desea que ingrese. Podemos incluir otro método de entrada readi que utilice la clase InteractiveIO que ya hemos diseñado para llevar a cabo esto. La implementación quedaría así:

public static Nombre readi(Interactive io){ String primer, apellido; primer = io.promptAndRead("Ingrese primer nombre:"); apellido = io.promptAndRead("Ingrese apellido:"); return new Nombre(primer, apellido); }


100

Ejercicio propuesto para el alumno:

� Agregue los métodos read, readi y print a las clases que usted desarrolló anteriormente en ejercicios: NombreLargo y Direccion.

Programa Hello world ! Revisado Con lo que hemos conocido hasta ahora, podemos explicar un poco más el primer

programa que escribimos:

import java.io.*; class HelloApp { public static void main (String args[]) {

System.out.println ("Hello world !"); }}

Vemos que el programa HelloApp es una clase. Toda clase que existe como programa necesita un método main. El método main es static, es decir no esta asociado a ningún objeto HelloApp.

La razón de esto, es que la ejecución de nuestro programa debe de comenzar en algún lado. El intérprete de Java en algún sentido, invoca el método main. Pero esto lo hace antes de que cualquier objeto de nuestro código haya sido creado.

Además vemos que esta declarado como public. La razón de esto es que

necesita ser llamado desde afuera de la clase (desde el interprete de Java).

Capitulo 6 – Software de Calidad.

101

Capítulo 6.

CONTROL DE CALIDAD EN LOS SISTEMAS

Introducción

El desarrollo de sistemas hoy en día ha tomado gran importancia en el mundo, siendo ésta cada vez más creciente.

Me parece muy acertado sugerir, en este punto, y luego de haber analizado en

profundidad un lenguaje de programación, que si una empresa de software pretende competir a nivel internacional, es necesario que contemple seriamente la necesidad de realizar una CERTIFICACION DE CALIDAD DEL SOFTWARE Y DEL SISTEMA.

En el entorno actual de la realidad económica de nuestro país, y considerando

que se están gestando polos de DESARROLLO DE SOFTWARE, como el que se acaba de anunciar en la vecina ciudad de Resistencia, Provincia del Chaco, el que pretende generar fuentes de trabajo mas allá de las fronteras de la nación, el que ha tomado como modelo a la Republica de la India, debemos, no solo entonces elegir un buen lenguaje de programación, sino que también, el mismo debe estar acorde a las pautas mundiales de CALIDAD.

A nivel país, el Gobierno de la Ciudad de Buenos Aires, esta impulsando de

manera coherente desde el año 2003, el programa “PRO ISO 9000”. Este desafío impulsado por el Gobierno porteño, ya ha generado sus primeros frutos en el área informática, siendo la empresa MSA Magic Software Argentina SA, la primera en el rubro en Certificar sus procesos de desarrollo de software, el 21 de abril del 2004.

Es claro que si un sistema presenta errores al momento de ser utilizado, ese

producto pierde confiabilidad a los ojos del usuario hasta el nivel que podría ser desechado como un producto defectuoso.

Muchos proyectos de sistemas presentan fallas que impiden que el sistema

funcione como era de esperarse o que sea utilizado en su totalidad. Por ello, es necesario definir e impulsar líneas de acción tendientes a mejorar el sistema producido.

Dentro de estas líneas de acción, está la relacionada con el proceso mismo del

desarrollo del sistema, y como necesidad primordial, la de realizar una investigación que permita conocer de primera mano el estado en que se encuentra su proceso de desarrollo.

Diferenciaremos dos conceptos importantes como son: Calidad en los Sistemas

y Calidad en el Software. El control de calidad de sistemas está orientado a garantizar el

funcionamiento de los sistemas en explotación.


102

El control de calidad de software está orientado a garantizar las características de los programas que se están desarrollando.

La Ingeniería de Software concierne a teorías, métodos y herramientas para el

desarrollo profesional de productos. Un Sistema concierne a un conjunto de componentes interrelacionados

trabajando conjuntamente para un fin común. El sistema puede incluir software, dispositivos mecánicos y eléctricos, hardware, y ser operado por gente.

Existen varias organizaciones de estandarización internacional que realizan

estándares y modelos de ingeniería de software, esto con el fin de mejorar la Calidad del Software.

La Calidad

La ISO (International Standard Organization), define La Calidad como la ausencia de deficiencias:

"Es la totalidad de aspectos y características de un producto o servicio que se refieren a su capacidad para satisfacer necesidades dadas en la adecuación de sus objetivos'”.

El Instituto de Ingeniería de Software (SEI) en su modelo CMM (Capability

Maturity Model) define la calidad como: • El grado en el cual un sistema, componente o proceso cumple con los

requisitos especificados. • El grado en el cual el sistema, componente o proceso cumple con las

expectativas del cliente o usuario.

La calidad consiste en todos aquellos aspectos del producto que satisfacen las necesidades del cliente y de ese modo proporcionan la satisfacción del producto.

La calidad es sinónimo de eficiencia, flexibilidad, corrección, confiabilidad,

mantenibilidad, portabilidad, usabilidad, seguridad e integridad.

Calidad del Software Definición

La Calidad del Software es el conjunto de cualidades que lo caracterizan y que determinan su utilidad y existencia.

La Calidad del Software es mensurable y varía de un sistema a otro o de un

programa a otro. Por ejemplo: un software elaborado para el control de naves espaciales debe ser confiable al nivel de "cero fallas"; un software hecho para ejecutarse una sola vez no requiere el mismo nivel de calidad; mientras que un producto de software para ser explotado durante un largo período (10 años o más) necesita ser confiable, mantenible y flexible para disminuir los costos de mantenimiento y perfeccionamiento durante el tiempo de explotación.


103

Aspectos de la Calidad

La Calidad del Software puede medirse después de elaborado el producto. Pero esto puede resultar muy costoso si se detectan problemas derivados de imperfecciones en el diseño, por lo que es imprescindible tener en cuenta tanto la obtención de la calidad como su control durante todas las etapas del ciclo de vida del software.

Objetivo de la Calidad en los Sistemas

El Objetivo que persigue la Calidad en los Sistemas está orientada a:

• Incrementar la productividad y satisfacción al trabajo de los profesionales afines al campo de la computación.

• Mejorar la calidad del producto del software. • Proveer técnicas aplicadas para automatizar el manejo de datos. • Realizar una planeación eficaz de los sistemas. • Documentar. • Validar y controlar formalmente la calidad del trabajo realizado. • Cumplir con los objetivos de la organización en cuanto a productividad de sus

sistemas de cómputo. Obtención de un Software de Calidad

La Obtención de un Software con Calidad implica la utilización de metodologías o procedimientos estándares para el análisis, diseño, programación y prueba del software, que permitan uniformar la filosofía de trabajo, en aras de lograr una mayor confiabilidad, mantenibilidad y facilidad de prueba, a la vez que eleven la productividad, tanto para la labor de desarrollo como para el control de la Calidad del Software.

El principio tecnológico define las técnicas a utilizar en el proceso de

desarrollo del software.

El principio administrativo contempla las funciones de planificación y control del desarrollo del software, así como la organización del ambiente o centro de ingeniería de software.

El principio ergonómico define la interfaz entre el usuario y el ambiente

automatizado. Para el aseguramiento de la calidad es necesario su control o evaluación.

Control de la Calidad

El Control de la Calidad es realizar una observación constante acerca del cumplimiento de las tareas que pueden ofrecer una calidad objetiva a la forma en como se está desarrollando un proyecto de Ingeniería de Software. Es decir, una vigilancia permanente a todo el proceso de desarrollo y ciclo de vida del software. Esta meta puede alcanzarse mediante frecuentes inspecciones a las metodologías de


104

trabajo y uso de herramientas, revisiones de prototipos y evaluación exhaustiva de los productos finales.

El Control de la Calidad permite realizar las rectificaciones pertinentes al

desarrollo en cuanto éste empieza a desviarse de sus objetivos, por lo tanto, de la calidad del trabajo. Estas rectificaciones son posibles gracias a una retroalimentación de las etapas superiores, creado así un aprendizaje al observar las salidas de cada etapa, hasta el producto final, y mejorar los procesos que dan origen al sistema.

En el Control de Calidad deben tenerse presentes los costos que esta

involucra. Si se piensa en las tareas que deben realizarse en este control, puede observase que es necesario llevar a cabo tareas de búsqueda de problemas, evaluación, realimentación, rectificación, elaboración, modificación y estudio de la documentación; entre otras actividades.

Pero debe existir un compromiso, ya que un excesivo costo en el control de la

calidad puede hacer que este proceso se torne ineficiente. Pero, por otra parte, el mejoramiento de la calidad implica reducir los costos ya que se tendría un cierto nivel de calidad ya asegurado.

Finalmente, y como consecuencia de la naturaleza del proceso de desarrollo de

productos software, el asegurar la calidad en las primeras etapas de este involucra que los costos del control en las etapas posteriores tenderá a disminuir al tener menos aspectos que controlar pues, nuevamente, la calidad estaría asegurada en sus bases.

Control de Calidad del Software

Para controlar la Calidad del Software es necesario, definir los parámetros, indicadores o criterios de medición.

El software posee determinados índices mensurables que son las bases para la

calidad, el control y el perfeccionamiento de la productividad. Una vez seleccionados los índices de calidad, debe establecerse el proceso de

control, que requiere los siguientes pasos:

1. Definir el software que va a ser controlado: clasificación por tipo, esfera de aplicación, complejidad, etc., de acuerdo con los estándares establecidos para el desarrollo del software.

2. Seleccionar una medida que pueda ser aplicada al objeto de control. Para cada clase de software es necesario definir los indicadores y sus magnitudes.

3. Crear o determinar los métodos de valoración de los indicadores:métodos manuales, como cuestionarios o encuestas estándares para la medición de criterios periciales y herramientas automatizadas para medir los criterios de cálculo.

4. Definir las regulaciones organizativas para realizar el control:quiénes participan en el control de la calidad, cuándo se realiza, qué documentos deben ser revisados y elaborados, etc.


105

Indicadores para diferenciar los productos de calidad de los que carecen de ella:

• El acercamiento a cero defectos. • El cumplimiento de los requisitos intrínsecos y expresos. • La satisfacción del cliente

Sobre todo la satisfacción del cliente.

La Calidad del Software debe ser una disciplina más dentro de la Ingeniería del

software. El principal instrumento para garantizar la calidad de las aplicaciones sigue siendo el Plan de Calidad. El plan se basa en unas normas o estándares genéricos y en unos procedimientos particulares.

Las normas, directivas, modelos y estándares son básicamente las siguientes:

• Familia de normas ISO 9000 y en especial, la ISO 9001 y la ISO 9000-3.2: 1996 Quality Management and Quality Assurance Standards

• ISO 8402: 1994

• IEEE 730/1984, Standard for Software Quality Assurance Plans

• IEEE Std 1028: 1989, IEEE Standard for Software Reviews and Audits

• CMM. Capability Maturity Model

• ISO/IEC JTC1 15504. SPICE. Software Process Improvement and Capability Determination.

• Modelo de EFQM. Modelo de la Fundación Europea de Gestión de Calidad

Los procedimientos pueden variar en cada organización, pero lo importante es que estén escritos, personalizados, adaptados a los procesos de la organización y, lo que es más importante, que se cumplan.

La Calidad del Software debe implementarse a lo largo de todo el ciclo de vida,

debe correr paralela desde la planificación del producto hasta la fase de producción del mismo. Capacidades del Software

Las capacidades importantes para un producto de software desde el punto de vista del usuario, así como los factores que determinan la calidad de cada una de las capacidades son:

• Capacidad de operación con los factores de corrección, facilidad, eficiencia,

integridad y facilidad de uso. • Capacidad para ser modificado o de revisión con los factores de flexibilidad,

facilidad de prueba y facilidad de mantenimiento. • Capacidad de transición o de adaptación a otros entornos con los factores de

transportabilidad, capacidad de reutilización y de interoperación.


106

Calidad Total en el Proceso de Desarrollo del Sistema

Para alcanzar la "Calidad Total", es necesaria la satisfacción por parte de los elementos que intervienen en el proceso:

• La satisfacción de la alta dirección • La satisfacción del personal involucrado en el desarrollo del sistema • La satisfacción del usuario final

La aplicación del control de calidad de sistemas no es solamente al sistema en sí,

ésta conforma la última parte de la evaluación.

Elementos para el Proceso de Sistemas

Son tres los elementos que integran el proceso de sistemas, los cuales por su importancia deben de considerarse para el mejor control de calidad y realización de los sistemas, estos son:

1. Gente 2. Herramientas (Software y Hardware) 3. Tiempo disponible

Debe contarse con la gente adecuada, que tenga la suficiente capacidad para realizar el trabajo, las herramientas de trabajo deben ser confiables, no limitadas y debe tomarse en cuenta cuanto tiempo se dispone para la elaboración del sistema.

Componentes para la Calidad Total

• Claridad • Involucración • Planeamiento • Estándares • Entrenamiento • Experiencia • Controles • Documentación • Soporte • Finalización

Claridad

La definición de lo que se tiene que hacer o lo que el usuario necesita, debe ser clara para todos los responsables del proyecto, esto con el fin de establecer reglas a seguir.

Involucración

Es necesario revisar cada etapa del proyecto. Para cada una de ellas es importante dejar en claro si vale la pena continuar o no, si hay limitaciones o restricciones que afecten o impidan el buen funcionamiento del proyecto y si se está


107

dando el cubrimiento adecuado a todos los requerimientos y funciones, divisiones o departamentos que están involucrados en la realización del proyecto. Planeamiento

En la planificación intervienen tanto los usuarios como el personal que desarrolle el proyecto. Debe planearse el grado de integración que se requiere en las diferentes áreas de la organización, para interpretar necesidades o requerimientos satisfactorios con el objeto de llegar a acuerdos en caso de imprevistos en asuntos tan simples como el método mediante el cual vamos a poner a trabajar alguna etapa o actividad en el proyecto. Estándares

Tiene que tomarse en cuenta la forma mediante la cual vamos a trabajar desde el punto de vista tecnológico, ya que es necesario tener presente la definición de diversos factores que afectarían la realización del proyecto, como son:

• Lenguaje de programación • Manejo de librerías • Código • Instrucciones • Comentarios • Administración de backups • Administración de archivos • Periodicidad de revisiones • Documentación

Debe quedar clara su definición, los elementos que los deben integrar, así como su

estandarización. Sin una estandarización el proyecto se vendría abajo. Entrenamiento

El entrenamiento es un factor determinante para la realización de un proyecto, ya

que mediante él se obtienen los conocimientos y habilidades que se aplicarán en el proyecto. Experiencia

El contar con mucha o poca experiencia, determina el tiempo de desarrollo del sistema así como la calidad del trabajo que realice (oportunidad - calidad).

Controles

Los controles que se establezcan deben realizarse con alguna periodicidad.

Primeramente debe verse el avance del proyecto; el cumplimiento de los requerimientos del cliente; el seguimiento y las normas de seguridad y de auditoria; la involucración de las personas clave para el proyecto; el funcionamiento de la aplicación; del desarrollo con el usuario y un punto importante es la mutua satisfacción entre de la gente que realiza el proyecto con el usuario.


108

En este caso puede contarse con un Calendario de Entrega donde contenga los puntos anteriormente mencionados, así como contar con Bitácoras que respalden las reuniones que se tengan con los usuarios y los acuerdos a los que hayan llegado ambas partes. Documentación

Es importante que la documentación que se genere debe ser clara y útil en cuanto al sistema, ya sean los programas, las tareas del usuario y sus procedimientos, el manejo de la aplicación y producción y los cuidados con respecto a back-ups, ayudas y soporte requerido, la bitácora de historia respecto a fallas, mejoras, arreglos, etc., contribuyen a una mejor utilización del sistema, es decir, a una mayor calidad en su operación. Manuales de usuario, técnico y de operación.

Soporte

Es indispensable tener claro quién nos puede apoyar en las áreas técnica, de

análisis, en el área usuaria, ya sea en la instalación, en el área ejecutiva o en algún otro aspecto, ya que las aplicaciones en los proyectos de sistemas enfrentan siempre necesidades críticas de soporte.

Finalización

La finalización del proyecto de un sistema es una de las labores más importantes en el desarrollo del mismo, de igual manera que en cada etapa. En la finalización del proyecto es necesario considerar cinco puntos vitales:

• La revisión de todos los pasos realizados y de las etapas incluidas en el

proceso total; • Elaboración del proceso en forma integral; • Calidad hecha en cada uno de los pasos o etapas del proyecto; • La atención a los requerimientos del usuario en términos de hacer todo

lo que él quiera, o más; • Y, por supuesto, la satisfacción de nuestro usuario o cliente que, en

últimas, es el reconocimiento a la labor bien realizada y de alta calidad. Cuando se desarrolle un sistema o aplicación y se instale, debe asegurarse de

hacerlo de tal manera que lo que se entregue esté completo, sea oportuno, no tenga errores, sea confiable, útil y estable.

Administración de la Calidad

Calidad en el Nivel de Organización

La Administración de la Calidad cuenta con dos niveles de trabajo: El nivel de entidad u organización

Donde se trata de crear y gestionar una infraestructura que fomente la calidad de los productos software mediante la adecuación y mejora de las actividades y


109

procesos involucrados en su producción e, incluso, en su comercialización y en la interacción con los clientes.

El nivel del proyecto

Donde las guías que la infraestructura organizativa prevé para las distintas actividades y mantenimiento del software deben ser adaptadas a las características concretas del proyecto y de su entorno para ser aplicadas a la práctica.

Dentro del primer nivel de acción, la gestión de la calidad en organizaciones de

software ha seguido dos líneas que pueden ser complementarias entre sí: Por una parte, se ha seguido la línea marcada por las entidades internacionales

de estandarización para todas las organizaciones de producción o servicios. Principalmente se han impuesto en la práctica las directrices marcadas por ISO

(Organization for International Standardization) a través de unas normas ISO 9000 para la gestión de calidad. En el caso del software es principalmente aplicable la norma ISO 9001.

El sector de software difiere por la naturaleza del producto tanto del resto de

sectores productivos que ha sido necesario crear una guía específica para su aplicación a este sector: ISO 9000-3.

El mundo del software ha creado sus propias líneas de trabajo en la gestión de

la calidad, trabaja sobre los procesos de producción como medio para asegurar la calidad del producto software. Por ejemplo, el SEI (Software Engineering Institute), proponiendo un modelo de clasificación y mejora de los procesos empleados por las organizaciones de software denominado CMM (Ver anexo).

Calidad en el Nivel de Proyecto

La Calidad del Software se diseña conjuntamente con el sistema, nunca al final.

A mayor calidad, mayores son los costos, pero mayores también los beneficios obtenidos en la fase del mantenimiento del software. Este costo hay que considerarlo dentro de todo el ciclo de vida del proyecto.

El aseguramiento de la Calidad de Software engloba un enfoque de gestión de

calidad, tecnología de ingeniería de software efectiva (métricas y herramientas), revisiones técnicas formales que se aplican durante el proceso del software, una estrategia de prueba multiescalada, el control de la documentación del software y de los cambios realizados, un procedimiento que asegure un ajuste a los estándares de desarrollo del software (cuando sea posible) y mecanismos de medición y de generación de informes.

La idea de la necesidad de realizar pruebas en fases tempranas, conduce a realizar un mecanismo básico que permite las Revisiones Técnicas Formales.

Una Revisión Técnica Formal (RTF) es una actividad que garantiza la Calidad

del Software y que es llevada a cabo por los profesionales de la ingeniería de software. Los objetivos de la RTF son:

1. Descubrir errores en la función, la lógica o la implementación de cualquier representación del software;


110

2. Verificar que el software bajo revisión alcance sus requisitos; 3. Garantizar que el software haya sido representado de acuerdo con ciertos

estándares predefinidos; 4. Conseguir un software desarrollado de forma uniforme, y 5. Hacer que los proyectos sean más manejables.

La Prueba del Software

Se pueden realizar inspecciones para cada módulo o pequeño grupo de módulos que conformen un sistema. Al limitar el centro de atención de la RTF la probabilidad de descubrir errores es mayor.

En la figura se puede apreciar lo que sería el flujo de información necesario para

realizar correcta y completamente una prueba de software, la cual puede ser aplicada tanto a los módulos individuales como al software en su totalidad.

Calidad por Etapas Calidad en el Diseño

Aquí se plantean características definidas para la realización del producto software que deberán cumplirse posteriormente. La calidad se basa en definir un listado de especificaciones a seguir. Involucra descripción de los procesos, tareas y responsabilidades de los equipos de desarrollo.


111

En esta etapa la calidad aumenta en la medida en que se realiza una alta especificación de los procesos y se propone una estrecha tolerancia a la modificación, estableciendo los métodos correctivos a las desviaciones ocurridas.

Esta es la medida de la calidad apreciada por los usuarios finales del

entendimiento del producto software. Estas apreciaciones de calidad hacia un determinado producto elevarán el nivel

de confianza para la organización desarrolladora, lo que puede elevar su posición en el mercado. Métricas del Software

Las métricas son escalas de unidades sobre las cuales puede medirse un atributo cuantificable. Cuando se habla de software nos referimos a la disciplina de recoger y analizar datos basándonos en mediciones reales de software, así como a las escalas de medición.

Clasificación de Métricas Las métricas de software se pueden clasificar como: Métricas orientadas a la función y Métricas orientadas al tamaño. También se pueden clasificar según la información que entregan:

1. Métricas de productividad, las que se centran en el rendimiento del proceso de ingeniería de software.

2. Métricas de calidad, proporcionan una indicación de cómo se ajusta el software a los requisitos explícitos e implícitos del cliente.

3. Métricas técnicas, que se centran más en el software que en el proceso a través del cuál se ha desarrollado (por ejemplo grado de modularidad o grado de complejidad lógica).

Estándares y Modelos de Calidad en la Ingeniería de Software Introducción

La estandarización es toda actividad documentada que norma el

comportamiento de un grupo de personas. Los estándares nos dan los medios para que todos los procesos se realicen siempre de la misma forma, mientras nos surjan ideas para mejorarlos. Son nuestra guía para la productividad y la calidad.

Expectativas de los estándares:

• Mejora de procesos de software acorde a los objetivos estratégicos • Mejora de los productos • Protección del cliente o usuario • Protección de la organización (cultura de la organización y mejora continua)


112

Existen varias organizaciones de estandarización internacional, algunas son regionales mientras que otras son globales. Las últimas están relacionadas con la ONU o son independientes, como por ejemplo la International Telecommunication Union (ITU).

La International Electrotechnical Commission (IEC) que fue fundada en el año 1906

para definir estándares en eléctrica y electrónica, mientras que la International Organization for Standardization (ISO) fue creada en 1947 para abarcar otros temas. Ambas tienen por objetivo facilitar el intercambio de bienes y servicios a nivel internacional, entre otras.

En 1987, ISO e IEC decidieron formar el Joint Technical Commit (JTC), cuyo

objetivo es elaborar estándares para la tecnología de información Information Technology (IT).

Organizaciones como la ISO, BOOTSTRAP, entre otras se han dedicado a crear

modelos para mejorar la Calidad del Software, entre ellos tenemos: • ISO 9000-3 • Tick IT (Inglaterra) • CMM (Estados Unidos) • Bootstrap (Europa) • Trillium (Canadá) • ISO/SPICE (Australia)

La Norma ISO 9000

La Organización Internacional para la Estandarización (ISO) fue fundada el 23 de febrero de 1947 con el objetivo de crear una norma internacional de calidad. El Comité Técnico ISO/TC 176 para Aseguramiento de la Calidad fue el encargado de crear el estándar ISO 9000.

El objetivo del estándar es desarrollar un código mínimo que contenga prácticas de

administración para garantizar el Aseguramiento y Administración de la Calidad, es decir, qué hacer para responder a los requerimientos de un mercado cada vez más competitivo y cómo deben responder los proveedores y compradores respecto a la calidad de los bienes o servicios intercambiados. Para ello establece una serie de guías para la selección y uso del estándar deseado, así como aclara conceptos en cuanto a la calidad y las interrelaciones que se establecen.

Estructura General

De forma general la norma se divide en 4 guías o modelos fundamentales: • ISO 9001 Sistemas de Calidad. Modelo de Aseguramiento de la Calidad en el

diseño, desarrollo, producción, instalación y servicio. • ISO 9002 Sistemas de Calidad. Modelo de Aseguramiento de la Calidad para la

producción, instalación y servicio. • ISO 9003 Sistemas de Calidad. Modelo de Aseguramiento de la Calidad para la

inspección final y pruebas.


113

• ISO 9004 Elementos para la Administración y el Sistema de Calidad. Guía para el Sistema de Aseguramiento de la Calidad.

Además, existen otras normas y entre ellas las más relevantes son:

• ISO 9000-1 Guía para la selección de la norma a usar. • ISO 8402 Recopilación de definiciones. Vocabulario. • ISO 9000-3 Estándares de Administración y Aseguramiento de la Calidad. Guía

para la aplicación de ISO 9001 al desarrollo, suministro y mantenimiento del software.

De forma general los requerimientos fundamentales de ISO 9000 son:

• Escribir un manual de calidad, describiendo el Sistema de Calidad en alto nivel. • Escribir documentos en forma de procedimientos que describan cómo debe

hacerse el trabajo en la organización. • Crear un sistema para controlar la distribución y reedición de documentos. • Diseño e implantación de un sistema de acciones preventivas y correctivas

para prevenir la ocurrencia de problemas. • Identificar las necesidades en cuanto a entrenamiento en la organización. • Determinar las medidas y equipos para realizar las pruebas. • Capacitar al personal de la organización en la operación del Sistema de

Calidad. • Planificar y llevar a cabo auditorias de calidad internas. • Tener en cuenta los requerimientos del estándar con los que no cumple la

organización. Los factores que determinan el modelo a elegir son:

1. La complejidad del proceso de diseño. Se refiere a la dificultad para diseñar el producto o servicio cuando éste no ha sido diseñado.

2. La madurez del diseño. Se proyecta hacia el conocimiento y aprobación del diseño total, ya sea por las pruebas de desempeño o por la experiencia en el campo.

3. La complejidad del proceso de producción. Está relacionado con la capacidad del proceso de producción, las necesidades de desarrollo del nuevo proceso, las variaciones que se requieren y el impacto en el desempeño del producto o servicio.

4. Las características del producto o servicio. Depende de la complejidad del producto o servicio, del número de características interrelacionadas y de su influencia en el desempeño.

1. La seguridad del producto o servicio. Relacionado con el riesgo de ocurrencia de fallas y el impacto de éstas.

2. Económico. Se refiere al incremento de los costos, para el suministrador o comprador, que puede provocar desacuerdos en cuanto al producto o servicio.


114

El Modelo Tick IT

El Departamento de Comercio e Industria del Reino Unido (DTI: Department of Trade and Industry) creó el esquema Tick IT.

Los objetivos primordiales de éste fueron, además de desarrollar un sistema de

certificación aceptable en el mercado, estimular a los desarrolladores de software a implementar sistemas de calidad, dando la dirección y guías necesarias para tal efecto.

Aunque el proyecto original estuvo a cargo del DTI1, la responsabilidad actual

por el esquema Tick IT se pasó a DISC, que es una oficina dependiente de British Standards Institution (BSI) Standards Division, siendo esta última la única autoridad en el Reino Unido para publicar estándares. Ciclo de Vida del Software

Un sistema de calidad típico Tick IT deberá contener los elementos que se enlistan a continuación:

• Elaboración de propuestas y revisión de contratos asegurando que todos los

requerimientos estén bien especificados y de que la organización tiene la capacidad para cumplirlos.

• Análisis y especificación de los requerimientos del sistema asegurando que sean revisados y acordados con el cliente.

• Planeación, control y monitoreo del avance del desarrollo respecto al plan comunicando a todas las partes afectadas y que avise oportunamente de problemas potenciales.

• Planeación de la calidad del proyecto, especificando las inspecciones, revisiones y pruebas requeridas durante el desarrollo.

• Inspecciones de los productos contra estándares y requerimientos aplicables y las acciones correctivas correspondientes.

• Diseño de primer nivel identificando los componentes principales y los requerimientos que satisfacen.

• Diseño detallado de todos los componentes e interfaces, construcción, y prueba de los mismos verificando que satisfagan la especificación.

• Integración, pruebas e inspecciones del sistema, demostrando que el sistema integrado funciona correctamente y satisface su especificación.

• Identificar, segregar, investigar y corregir productos no conformes. • Auditorias, pruebas e inspecciones de aceptación del sistema demostrando al

cliente que el sistema satisface los requerimientos. • Almacenamiento, replicación, envío e instalación, asegurando la integridad y

seguridad de los productos, así como el cumplimiento de los compromisos adquiridos con el cliente.

• Puesta en marcha y liberación del producto para disponibilidad del cliente. • Entrenamiento a usuarios en el uso del sistema de tal manera que pueda

operarlo y beneficiarse completamente del mismo con la mínima intervención del proveedor.

• Mantenimiento o sustitución del sistema, asegurando que se continúa operando en conformidad con los requerimientos del cliente o usuario.

• Soporte a clientes de acuerdo a lo especificado en el contrato.


115

Soporte y Aseguramiento de Calidad

• Establecer políticas y objetivos de calidad generales de la organización que sirvan para alinearla en todas sus actividades, procedimientos y políticas específicas.

• Implantar y mantener un sistema de aseguramiento de calidad. • Auditorias, revisiones y acciones correctivas al sistema de calidad que

aseguren que el sistema cumple con los requerimientos, es utilizado y que es efectivo en el logro de resultados.

• Definir, recolectar y analizar datos de calidad para evaluar la efectividad del sistema de calidad e identificar mejoras potenciales.

• Administración de la organización y los proyectos de tal forma que facilite los resultados de calidad.

• Administración de la configuración que identifique y controle, de manera continua, las partes constituyentes y sus versiones, de cada instancia de un sistema o subsistema.

• Respaldos, seguridad y almacenamiento que protejan contra cualquier pérdida o corrupción.

• Sistema de control de registros y documentación para todas las actividades de aseguramiento de calidad, de los proyectos y de soporte, incluyendo procedimientos y registros.

• Especificación y control del proceso de desarrollo incluyendo técnicas, prácticas, convenciones, estándares, mediciones y estadísticas.

• Proceso de compras, incluyendo identificación, selección, adquisición y aceptación que asegure que los bienes y servicios adquiridos sean como se requiere y de calidad aceptable.

• Control de productos incluidos, equipo y herramientas utilizadas: Hardware o Software, adquiridos o suministrados por el cliente, incluyendo utilización, configuración, seguridad.

• Entrenamiento, reclutamiento y desarrollo de personal que asegure su competencia y motivación, y disminuya su rotación.

El Modelo CMM

A principios de los años 80’s el Departamento de Defensa de los Estados Unidos enfocó sus tareas a la revisión de los problemas del software y a su mejoramiento.

Para contribuir a este programa se creó el Instituto de Ingeniería de Software (SEI)

a finales de 1984. Como parte de su trabajo, el Instituto se dio a la tarea de desarrollar el Modelo de Madurez del Proceso de Software y para 1986 se comenzó el Proyecto de Evaluación de la Capacidad del Software. Después de varios años de realizar cuestionarios, evaluaciones, consulta e investigación, junto a otras organizaciones, en 1991 SEI produce el Modelo de Capacidad y Madurez del Software.

El Modelo de Madurez y Capacidad del Proceso de Software (CMM) ayuda a que

las organizaciones para producir de manera consistente y predecible productos de calidad superior. La capacidad del proceso es la habilidad inherente para producir los resultados planeados. El principal objetivo de un proceso de software maduro es el de producir productos de calidad que cumplan los requerimientos del usuario.


116

Cuando se habla de madurez se entiende como el crecimiento alcanzado en la capacidad del proceso de software y que se considera como una actividad a largo plazo.

En una organización de software inmadura, el proceso de software es

generalmente improvisado, no existen planes rigurosos, se enfocan en resolver las crisis que se le presentan, carecen de bases objetivas para enjuiciar la calidad de los productos o para resolver los problemas.

Por lo contrario cuando la organización alcanza cierto grado de madurez posee

una gran habilidad para administrar el proceso de desarrollo y mantenimiento del software, se hacen pruebas y análisis de costo-beneficio para mejorar el proceso, el administrador monitorea la calidad del producto y la satisfacción del cliente, se llevan registros y todos los integrantes están involucrados.

La madurez del proceso de software esta dada cuando un proceso en específico

es explícitamente definido, administrado, medido, controlado y es efectivo.

El ciclo Shewhart propone las bases para el trabajo de mejoramiento del proceso. Este consta de 4 pasos que se repiten en forma de ciclo hasta que la implantación produce los resultados esperados y los cambios pasan a ser permanentes.

Los pasos son:

1. Planear a. Definir el problema b. Establecer los objetivos a mejorar

2. Ejecutar a. Identificar las posibles causas de problemas b. Establecer las bases c. Probar los cambios

3. Revisar a. Recolectar los datos b. Evaluar los datos

4. Actuar a. Implementar los cambios b. Determinar la efectividad

CMM es un modelo descriptivo en el sentido que describe los atributos

esenciales que se espera caractericen una organización dentro de un nivel de madurez en particular. Es un modelo normativo ya que las prácticas detalladas caracterizan el tipo normal de comportamiento que se espera de una organización que realiza proyectos a gran escala.

No es prescriptivo ya que no dice a la organización como mejorar.

Estructura del modelo. CMM: Marco de Trabajo Capability Maturity Model – SEI


117

El modelo consta de 5 niveles, diseñados de forma que los inferiores proveen unos fuertes cimientos incrementados de manera progresiva sobre los que se construyen los niveles superiores.

Estas 5 etapas de desarrollo son referidas como niveles de madurez y en cada

una la organización alcanza una capacidad en el proceso superior.

Los 5 niveles del modelo son:

1. Inicial: el proceso de software es un proceso improvisado y caótico. Pocos procesos están definidos y el éxito que se pueda obtener depende de las habilidades, conocimientos y motivaciones del personal. No existen calendarios ni estimados de costos y las funcionalidades y calidad del producto son impredecibles. No existe un ambiente estable para el desarrollo y mantenimiento del software. El proceso del software es impredecible por el continuo cambio o modificación a medida que avanza el trabajo.

2. Repetible: se establecen procedimientos de administración del proceso básico

para determinar costos, calendarios y funcionalidades. Se establecen las políticas para la administración del proceso y los procedimientos de implantación. El proceso se basa en repetir éxitos anteriores en proyectos de similares características, por lo que los mayores riesgos se presentan cuando se enfrentan a nuevos proyectos. Se exhiben problemas de calidad y carecen de una adecuada estructura para mejorarla.

3. Definido: el proceso de software para las actividades administrativas y

técnicas está documentado, homogeneizado e integrado en un proceso de software estándar dentro de la organización, que ayudará a obtener un desempeño más efectivo. El grupo que trabaja en el proceso enfoca y guía sus esfuerzos al mejoramiento de su desarrollo, facilita la introducción de técnicas y métodos e informa a la administración del estado del proceso. La capacidad del proceso está basada en una amplia comprensión común dentro de la organización de las actividades, roles y responsabilidades definidas en el desarrollo de software.

4. Administrativo: se recolectan medidas detalladas del proceso de software y

de la calidad del producto. Ambos son cuantitativamente entendidos y controlados. El ciclo de Shewhart es constantemente utilizado para planear, implementar y registrar las mejoras al proceso. Este nivel de capacidad permite a la organización predecir las tendencias en la calidad del producto dentro de los límites establecidos y tomar las acciones necesarias en caso que sean excedidos. Los productos de dicha categoría son predeciblemente de alta calidad.

5. Optimización: el mejoramiento continuo del proceso es garantizado por la

retroalimentación cuantitativa y desde las pruebas de técnicas y herramientas innovadoras. La organización tiene los medios para identificar los puntos débiles y conocer como fortalecerlos. Su actividad clave es el análisis de las causas de defectos y su prevención.


118

El Modelo BOOTSTRAP

El Instituto Bootstrap es una organización no lucrativa dedicada a la mejora continua del modelo de calidad de software llamado BOOTSTRAP, también tiene como propósito ayudar a la industria europea del software para mejorar su competitividad.

Bootstrap es un método para analizar, rediseñar y mejorar los procesos de negocio

del desarrollo de software. Este se compone de: un modelo, un proceso de evaluación, una base de datos de

soporte, un proceso de mejora y los instrumentos de evaluación.

Su enfoque es evaluar el proceso, no el producto. Para eso se definen un conjunto de características para los procesos, provee un análisis cuantitativo, produce vistas analíticas, hace evidente fortalezas y debilidades, identifica áreas de mejora, provee recomendaciones y sugiere un plan de implementación.

El modelo define el paradigma Organización-Metodología- Tecnología que se usa en Bootstrap para los niveles de evaluación y agrupación de resultados.

El modelo Bootstrap se basa en evaluar las unidades de producción de

software de la organización, a través de sus proyectos para hacer un cambio a toda la organización. Dentro de este proceso, hay cuatro etapas principales: preparación, ejecución de la evaluación, determinación del nivel de madurez y capacidades, y la presentación de resultados de la evaluación.

En la etapa de preparación se realizan las siguientes tareas:

1. un entrenamiento inicial para tener claros los objetivos 2. se seleccionan los proyectos a ser evaluados para obtener la mejor

cobertura de la UPS 3. se define el personal de evaluación para minimizar la subjetividad 4. se define el personal a ser evaluado para obtener la mejor cobertura de

los roles involucrados en los proyectos seleccionados y 5. se hace el acuerdo de confidencialidad.

En la etapa de ejecución, las tareas son:

1. una breve reunión de apertura, para obtener un enfoque colaborativo con el personal a ser entrevistado;

2. el llenado de los cuestionarios con características generales de la UPS; 3. el llenado de los cuestionarios del proyecto elegido, incluyendo la

evaluación de cómo el proceso de producción es aplicado; 4. revisión preliminar de la evaluación, y 5. reunión final, con el enfoque de presentar los resultados de la

evaluación y obtener el consenso para poder pasar a la fase de mejoras.


119

En la etapa de determinar el nivel de madurez y capacidades, es donde se califica cada pregunta con uno de 5 valores posibles: nulo, débil, regular, extenso o no aplica. Para cada atributo clave se obtiene un nivel de madurez, aplicando un algoritmo numérico, dando como resultado uno de estos niveles: 1-inicial, 2-repetible, 3-definido, 4-administrado o 5-optimizado. Estos niveles de madurez están subdivididos en cuatro, de forma que se obtenga una calificación más exacta. Los procesos de organización y metodología se califican de 1 a 5, mientras que el de tecnología se califica sólo con dos niveles A o B. Como resultado de la evaluación, la organización recibe 2 reportes, uno con los resultados de la evaluación de la UPS y otro con los resultados del proyecto evaluado. El correspondiente a la UPS contiene información como: un resumen ejecutivo, los objetivos de la UPS, los puntos débiles y fuertes, un plan de acción recomendado, etc. El reporte del proyecto contiene: comentarios del proyecto actual detallando lo referente a la organización, metodología y tecnología, los niveles de madurez para el proyecto, el plan de acción recomendado, etc. Uso de las Bases de Datos de Soporte

Una de las características principales de Bootstrap es la base de datos con que cuenta para hacer análisis. Con esto se fundamenta el plan de mejoras, se pueden medir las adaptaciones a la metodología, se puede comparar contra la industria y se pueden establecer objetivos basándose en la competencia.

Proceso de Mejora

Otra parte importante de la metodología de Bootstrap, es el plan de mejora que

sugiere. El proceso para obtener el plan de mejora es, Primero evaluar las necesidades de la organización tomando en cuenta las

mejoras deseadas e indicadores sobre calidad del producto y servicio, tiempo de desarrollo, costos y riesgos del producto y del proyecto.

Enseguida hacer una revisión y análisis de resultados de la evaluación,

tomando en cuenta las fortalezas y debilidades detectadas. Después definir las capacidades a mejorar, considerando un período entre 18 y

24 meses. Enseguida, definir las prioridades de acuerdo a un análisis de impactos. Finalmente sobre la base de las actividades definidas, modificar la

organización y responsabilidades para iniciar el cambio, estableciendo un marco de tiempos para su desarrollo y evaluación.


120

El Modelo ISO/SPICE Software Process Improvement and Capability Determination

La Organización Internacional para la Estandarización (ISO) creó el grupo de trabajo WG 10 y le encomendó el desarrollo del estándar internacional de Valuación de Procesos de Software.

El grupo de trabajo (Working Group) WG 10, empezó a trabajar en enero de

1993 bajo la dirección de Alec Dorling y Peter Simms, y decidieron crear el proyecto SPICE Software Process Improvement and Capability Determination; la E de SPICE correspondía, originalmente, a "evaluation" y fue cambiado porque en algunos idiomas se traducía equivocadamente.

Una de las características sobresalientes de este proyecto de estandarización

es que incluyó un periodo de pruebas del estándar de 2 años. Es decir, antes de ser publicado como estándar se había estado ajustando por la práctica.

Arquitectura del Modelo

El modelo es tridimensional: la primera dimensión es funcional (procesos), la segunda de capacidades (niveles), y la tercera de adecuación o efectividad (calificaciones). La dimensión PROCESO:

Está organizada jerárquicamente de la siguiente manera: CATEGORÍA DE PROCESOS, que agrupan procesos comunes; PROCESOS, que logran propósitos técnicos; PRÁCTICAS BÁSICAS, operaciones que conforman un proceso.

Las categorías definidas son: Cliente-Proveedor, Ingeniería, Proyecto,

Organización y Soporte. La dimensión CAPACIDAD:

Está organizada ordinalmente en niveles de capacidad y se han definido cinco niveles. En la versión 1.0 estos niveles son: Desempeño informal, Planeación y seguimiento bien definido, Cuantitativamente controlado, Mejora continua. Está en etapa de instrumentación una versión 2.0.

La tercera dimensión es la CALIFICACIÓN:

El juicio mismo: ¿qué calificación le doy a este proceso en este atributo de capacidad?. Las escalas que se manejan son discretas de tipo: 0 = No adecuado, 1 = Parcialmente adecuado, 2 = Muy Adecuado, 3 = Totalmente Adecuado.

Los Elementos de Evaluación Marco de Valor

El Modelo ISO/SPICE tiene un marco de valor explícito.


121

En la dimensión funcional o de proceso: las "mejores prácticas". En la dimensión de capacidad: los atributos de proceso o prácticas genéricas

que incrementarán la capacidad del proceso. Este es uno de los componentes más valiosos del estándar internacional.

Evidencia

La evidencia para la evaluación serán los productos producidos por las prácticas base. Éste es un enfoque de efectividad… "por sus frutos los conoceréis…". Cada producto tipo ha sido catalogado y sus características de calidad definidas.

Este es otro elemento filosófico fundamental de ISO/SPICE: no es un modelo

nominalista.

Recurrencia

Por último el elemento recurrencia, para fundamentar un juicio o evaluación vendrá dada por la selección de instancias de proyectos o productos representativas, a juicio del Evaluador, de las capacidades reales del proceso de software.

Conceptualmente el modelo ISO/SPICE es un modelo inductivo en su parte

funcional: de característica a producto, de producto a práctica, y de práctica a proceso. En su parte de capacidades es un modelo evolutivo. Es, en general, un modelo

realista: va a ver los productos, es decir, la efectividad de los procesos no lo que está escrito en algún manual de calidad o de procesos.

Estándares y modelos de evaluación y mejora de los procesos software.


122


123

CONCLUSIONES

Es casi imposible resumir y condensar en pocas páginas la gran cantidad de información disponible sobre el tema. A modo de ejemplo de esos volúmenes, sobre el tema “Programación Orientada a Objetos” en Internet quiero destacar:

Buscador Sitios encontrados

En castellano En cualquier idiomaGoogle 110.000 8.560.000Yahoo 93.700 5.640.000Altavista 94.200 ---

Proveedor de libros volúmenes encontrados En cualquier idioma

Amazon.com 3.484Sun Microsystems 32

Como puede verse existe mucha información sobre el tema. La misma simbología ya es una gran nebulosa de la Tecnología de Objetos (OT), pero al menos se expondrán algunas consideraciones prácticas extraídas de la aplicación con los alumnos en la cátedra Programación IV, desde el año 2000 de lenguajes, técnicas y métodos orientados-a-objetos.

La elección del Lenguaje de Programación

Es opinión antigua, firme y consensuada que no existe la solución ideal al elegir un lenguaje de programación, pero también se acepta de forma unánime que la Orientación a Objetos proporciona ventajas evidentes en el desarrollo genérico de software.

Naturalmente lo más fácil es pensar que los "nuevos" métodos que la OO

propugna van a facilitar el trabajo diario "real" en empresas y departamentos de desarrollo de software. Los atractivos de los "objetos" aparecen innegables y, las siguientes etapas personales se cubren de forma inexorable:

• Novicio (1-3 meses): se mezcla el código eminentemente funcional

modificándolo y añadiéndole porciones de objetos. • Aprendiz (3-6 meses): aquí se produce el "despertar" del que hablan los

textos de Zen, se ve el verdadero significado de la orientación-a-objetos y se empiezan a bosquejar diseños pertinentes.

• Postulante (6-18 meses): los conceptos ya se aplican con soltura en el desarrollo, pero todavía se dan algunos problemas con la modelización.

• Experto (gurú): todo son objetos, y el sujeto se pregunta: ¿cómo pude pensar antes de otra manera? Este estadio no siempre se alcanza, naturalmente (afortunadamente, según algunos). Y para fundamentar, aun más la gran profusión de métodos con bases teóricas,

veamos algunos de los actuales métodos de OOA/OOD (Análisis Orientado a Objetos/Diseño Orientado a Objetos):


124

METODOS AUTORES Object Oriented Design OOD Grady Booch Object Behaviour Analysis OBA Rubin & Goldberg Methodology for Object Oriented Software Engineering of Systems

MOSES Henderson-Sellers & Edwards

General Object Oriented Design GOOD Seidewitz & Stark Object Oriented Software Engineering

OOSE Ivar Jacobson

Visual Modeling Technique IBM IBM Texel Texel Object Modeling Technique OMT Rumbaugh y otros Better Object Notation BOM Nerson Object Oriented System Analysis OOSA Shlaer & Mellor Object Oriented Structured Design OOSD Wasserman et al. Systems Engineering OO SEOO LBMS Syntropy Cook y otros Object Oriented Jackson Structured Design

OOJSD Jackson

Hierarchical Object Oriented Design HOOD ESA Object Oriented Analysis OOA Coad & Yourdon Object Oriented Design OOD Coad & Yourdon Object Oriented System Analysis OSA Embley y otros Colbert E. Colbert Frame Object Analysis FOA Andleigh/Gretzingr Semantic Object Modelling Approach

SOMA Ian Graham

Berard Berard ADM3 Donald Firesmith Ptech OOA&D Martin & Odell Object Oriented Rôle Analysis, Synthesis and Structuring

OORASS Reenskaug et al.

Fusion Coleman y otros Desfray Softeam Responsability Driven Design CRC Wirfs-Brock et al.

La realidad es que, es muy difícil diferenciar si uno es mejor que el otro. Cada autor tiene sus flaquezas y fortalezas.

La experiencia y la revisión real de la gestión de proyectos orientados-a-objetos en distintas empresas muestra que el éxito siempre ha ido acompañado de una visión particularizada de OOA/OOD acorde con la política de la empresa, las peculiaridades del equipo de desarrollo, la experiencia en determinados lenguajes de programación y la naturaleza concreta de cada proyecto, dentro de unos márgenes más o menos estables de actuación.

En el ámbito académico, quiero destacar, luego de 4 años de dictar en la

cátedra Programación IV el Paradigma de Objetos, las siguientes conclusiones: Los alumnos se entusiasman con el concepto, pero tienen un pequeño grado

de dificultad al iniciar el diseño de los objetos, definitivamente, les cuesta un poco pensar de manera abstracta. Creo que como todo en su nivel inicial, luego su práctica


125

profesional los pulirá con un mejor diseño. Por ahora en la cátedra pregonamos el “enseñar la técnica”.

Conclusiones y Perspectivas a Futuro

En la etapa de investigación bibliográfica, en la que he utilizado intensamente la fuente inagotable de Internet, he podido comprobar que hay muchísimas páginas que explican muy someramente cada concepto de POO y luego muestran un ejemplo. En este trabajo he tratado de revertir ese problema, brindando abundante material teórico, como así también ejemplos pertinentes en cada caso.

Los ejemplos dados, en general, son similares a los que pueden encontrarse en la

literatura específica, esto es así porque son los más sencillos para la comprensión de los conceptos.

Este material permitirá que los alumnos interesados en profundizar la temática de

Programación Orientada a Objeto, tengan una fuente alternativa completa, clara y precisa sobre los principales tópicos de la POO.

Así también, el código provisto les permitirá visualizar rápida y fácilmente la

implementación de esos conceptos.

Perspectivas a futuro

Cómo actividades complementarias y, en cierta manera, como una continuación de este trabajo, se propone la instrumentación del concepto “SOFTWARE DE CALIDAD” ya sea en esta cátedra o como una cátedra optativa, para afianzar contundentemente la necesidad de desarrollar software competitivo para su venta a nivel internacional.

A nivel de asignatura, se esta desarrollando un sitio Web en el que se pondrá disposición de los alumnos, lo siguiente:

� El material de apoyo utilizado para el presente trabajo. � Direcciones de sitios de descarga de manuales y tutoriales sobre la temática

específica. � Un foro de discusión sobre el tema POO, destinado a alumnos y docentes. � El material de los trabajos prácticos, con test, resultados de los trabajos

prácticos, pizarra de novedades, � Otros trabajos relacionados con el tema.

Con esto se pretende darle mayor difusión a la temática, promover la participación de los alumnos y los docentes del área y generar la sinergia necesaria para lograr una mejor formación de nuestros recursos humanos, que garanticen una exitosa inserción laboral, como así también, la seguridad y conocimientos necesarios para que nuestros futuros egresados se atrevan a sus propios emprendimientos, en este incipiente, exigente y apasionante mundo del desarrollo del software.

Formosa, 14/05/2005

Glosario.

127

GLOSARIO � Abstracción por especificación: Disciplina de programación que busca que el

programador defina qué es lo que hace cada uno de los módulos que componen un programa o sistema, aún antes de realizar la implementación.

� Abstracción por parametrización: Uso de argumentos en procedimientos y rutinas.

� Abstracción: Proceso por medio del que se elimina información para lograr tratar cosas diferentes como si fueran iguales. De esta forma se separan las características de un ente en dos grupos, el de las características que importa y el de las que sobran, para tomar en cuenta únicamente aquellas relevantes a la solución de un problema.

� Abstracción (2): ignorar aquellos aspectos que no sean relevantes al propósito actual para concentrarse más profundamente en aquellos que lo son.

� Asociación y mensajes: los objetos de un sistema se relacionan y se comunican entre sí.

� Asociación: Relación de uso en general. � Atributos: Datos que caracterizan las instancias de una clase. � Calificación: Limita la multiplicidad de las asociaciones. � Clases: Abstracción de objetos con propiedades comunes. � Composición: Relaciones todo/parte. � Concatenación: Unir elementos. � Constructores y Destructores: Facilidad de un lenguaje de programación que le

permite al programador definir uno o varios procedimientos especiales que se encargan de inicializar y destruir las variables de un tipo, y que además son invocadas automáticamente por el compilador. En general, la misión principal de los destructores es devolver la memoria dinámica asociada a un objeto.

� Encapsulación: la interfase de cada componente del programa se define de forma que revele tan poco como sea posible de sus particularidades interiores.

� Encapsulamiento: Facilidad de un lenguaje de programación que permite definir un tipo de datos junto a sus operaciones, con el fin de obtener un tipo abstracto de datos.

� Enlace dinámico: es la propiedad que poseen los objetos para enviar mensajes a otros objetos sin necesidad de conocer (quizá por imposibilidad de hacerlo) la clase a la que pertenecen, se resolverá en tiempo de ejecución.

� Enlaces: Instancias de una relación. Relaciona instancias � Especificación: Proceso por medio del que se definen las características de un

ente. � Generalización. Relaciones padre/hijo. � Herencia (Extensión de tipos): Facilidad del lenguaje de programación que

permite extender un tipo de datos, agregando al final nuevos campos. El efecto de la herencia puede simularse en la mayoría de los lenguajes tradicionales, pero el resultado es un programa menos elegante y en muchos casos mucho más difícil de programar.

� Herencia: expresa la similitud entre clases de objetos, mostrando la especialización de los estados y los comportamientos de las clases de objetos de nuestro sistema en forma jerárquica.

� Instancias: Cada uno de los objetos individuales. � Iteradores: Abstracción que permite obtener todos los elementos contenidos en un

tipo abstracto de datos contenedor. Los contenedores más usuales son los arreglos, las listas, los conjuntos, los árboles y en menor grado los grafos.

Glosario.

128

� Mensaje: Nombre del método con que se invoca a una operación sobre un objeto. Los términos método y operación son sinónimos, pero uno se usa en el contexto de Programación por Objetos y el otro en el de Abstracción de Datos.

� Método: Operación que es definida junto a un tipo de datos en aquellos lenguajes que soportan encapsulamiento.

� Módulos: Partes que componen un sistema, que generalmente se construyen de forma que sean independientes unas de otra. En general se busca que al hacer cambios en un módulo no sea necesario hacerlo en otros. En estos casos, se dice que los módulos tienen una cohesión baja.

� Multiplicidad: Número de instancias que intervienen en la relación. � Ocultación de Datos: Facilidad de un lenguaje de programación que permite

evitar que un programador que usa un tipo abstracto de datos pueda manipular la estructura interna de una instancia. De esta manera se evita que el programador usuario del tipo abstracto de datos introduzca inconsistencias en la estructura de datos.

� Operaciones: Funciones que pueden realizar las instancias. � Polimorfismo (Funciones Virtuales): Un lenguaje de programación que soporta

polimorfismo permite diferir la definición de la operación que debe aplicarse un objeto al momento en que esa operación es necesaria. De esta manera, el programador no necesita conocer el objeto sobre el que opera. Cuando se usa herencia para extender de muchas formas un tipo de datos, resulta luego conveniente que el procedimiento que se use para operar sobre un dato dependa del dato en sí, aunque el programador no haya especificado exactamente cuál es ese procedimiento.

� Polimorfismo: es la propiedad de dos o más clases para responder al mismo mensaje, cada una de ellas según su especificación.

� Procedimiento o rutina: Facilidad sintáctica de los lenguajes de programación que le permiten al programador aislar la solución de un problema particular en un módulo. Mediante el uso de procedimientos es posible aplicar la abstracción por parametrización y por especificación.

� Programación Estructurada: Conjunto de prácticas y disciplinas de programación que se basan en el uso de Abstracción por parametrización y por especificación para construir sistemas. Además, un lenguaje de programación soporta la Programación Estructurada si cuenta con las construcciones sintácticas IF-THEN-ELSE, WHILE-REPEAT, CASE, procedimientos y argumentos. Un programa estructurado nunca hace uso del GO TO, y generalmente se descompone modularmente como una jerarquía de procedimientos, usando la descomposición de Arriba hacia Abajo [Top-Down].

� Programación Orientada a los Objetos [OOP] ó [POO]: Uso de unas técnicas de Abstracción de Datos en un lenguaje que también soporta Encapsulamiento, Herencia y Polimorfismo.

� Redefinición: Modificación de las propiedades heredadas. � Relaciones: Se establecen entre clases. � Roles: Indican los papeles de las clases en las relaciones. � Sobrecarga de identificadores: Facilidad de un lenguaje de programación que

permite usar el mismo identificador para procedimientos diferentes. Los procedimientos se diferencian por sus argumentos y no por su nombre.

� Sobrecarga de Operadores: Facilidad de un lenguaje de programación que le permite al programador definir un nuevo tipo de datos que puede usarse en expresiones. En general, la sobrecarga de operadores implica el uso de los operadores aritméticos [+ - * / ^] en expresiones.

Glosario.

129

� Tipos Abstractos de Datos: Es un el uso de una técnica de abstracción que busca juntar en un sólo módulo toda la programación relevante a una estructura de datos en particular. Esto se logra definiendo las operaciones de un tipo de datos. Lo usual es que un DAT provea Ocultamiento de Datos y alguna forma de Encapsulamiento de datos, aunque ésta última no sea completa.

Bibliografía.

131

BIBLIOGRAFÍA

• Patterson J., Stephenson C., Introduction to Programming in Java, University of Toronto Press, 2000

• Castillo, E., Cobo A., Gómez P., Solares C. Java Un lenguaje de programación multiplataforma para Internet. Paraninfo, 1997.

• Newman, Alexander. Using Java. Macmillan Computer Publishing, 1996. • Froufe, Agustín. Java 2 - Manual de Usuario y Tutorial. Alfaomega, 2000. • Campione, Mary. The Java Tutorial. Addison-Wesley, 2000. • Eckel, Bruce. Thinking in Java. Prentice Hall, 2000. • Griffith, Steven W. 1001 tips para programar con Java. McGraw-Hill, 1997. • Dpto Ampliación de Informática. Java y la POO. Universidad de Zaragoza España. • Parra Fuente, Javier. Curso Java Avanzado. Departamento de Lenguajes y Sistemas

Informáticos, Univ. Pontificia de Salamanca en Madrid • Venners, Hill. Designing with interfaces. Java World (http://www.javaworld.com/),

12/1998. • Grady Booch, Análisis y Diseño orientado a objetos. Ed. Addison Wesley

Iberoamericana. • Sitio Web Oficial de Sun Microsystem – www.java.sun.com• Página de descargas de la Universidad de Castilla La Mancha

http://scalab.uc3m.es/~docweb/pr-inf/index.html• Revista electrónica sobre java – www.javaworld.com• Tutorial Java Avanzado – www.geocities.com• TUTOR JAVA – www.programacion.net• Guía de Páginas OO. www.well.com/user/ritchie/oo.html#index por Ricardo Devis • Guía de Páginas y Lenguajes OO. Universidad Alicante, España

www.dlsi.ua.es/asignaturas/poo/Enlaces• Jakarta Tomcat, http://jakarta.apache.org/tomcat/• Stevens, Jon S. “You Make the Decisión”,

http://jakarta.apache.org/velocity/ymtd/ymtd.html.• Hunter, J “The Problems with JSP”,http://www.servlets.com/soapbox/problems-jsp.htmp• Notas específicas sobre el tema “Sobrecargas” y “Herencias”

http://manowar.lsi.us.es/pipermail/csharp-dist/2001-March/000500.html http://www.sc.ehu.es/sbweb/fisica/cursoJava/fundamentos/herencia/intro_herencia.htm

• http://www.map.es/csi/silice/Auditr12.html• http://www.sld.cu/revistas/aci/vol5_s_97/sup04197.htm• http://www.openresources.com/es/magazine/softwareengineering/quality-control/• http://agamenon.uniandes.edu.co:80/sistemas/6707.htm• http://gente.pue.udlap.mx/~sol/docencia/ti/sesion4.html• http://www.sc.ehu.es/jiwdocoj/remis/docs/aseguracal.htm• http://www.fciencias.unam.mx/~ho/SPICE/pres1.html• http://www.pcworld.com.pa/1998/diciembre/novedades.html• http://www.ati.es/novatica/1997/125/nv125pres.html• http://www.robelle.com/smugbook/quality.html• http://www.abo.fi/~atorn/SQuality/SQ11.html• http://www.utexas.edu/coe/sqi/newsletter/• http://www.isaca.org/standard/sp.htm• http://www.csuohio.edu/accounts/Audit4/• http://www.ati.es/gt/calidad-software/presentacion.htm

Programas ejemplo. Clases abstractas.

133

PROGRAMAS EJEMPLO DE LOS TEMAS TRATADOS.

Redefinición de métodos /*Programa 1 - Versión 1*/ /* REDEFINICIÓN:(OVERRIDEN) Una clase puede redefinir (volver a * definir) cualquiera de los métodos heredados de su super-clase * que no sean final. * El nuevo método sustituye al heredado para todos los efectos * en la clase que lo ha redefinido. * Con Funciones Redefinidas en Java se utiliza siempre * Vinculación tardía */ //CLASE PADRE class Oceania {

// se definen 3 constantes de tipo cadena (variables // finales)

final String e1="Australia",e2="Fidji",e3="Nueva Zelanda"; public void descripción() {

System.out.println("Principales Estados"); System.out.println(e1);System.out.println(e2); System.out.println(e3);

}}

//CLASE HIJA (derivada) class Australia extends Oceania {

final String capital="Canberra"; // se define una // constante(variable final) llamada // capital y se le asigna el valor Canberra public void descripción() {

System.out.println("La capital de Australia es: "+ capital);

}}

public class Geografia1 { public static void main(String[] args) {

Australia ciudad = new Australia(); // crea un objeto "ciudad" de la clase // hija "Australia" ciudad.descripción(); // ejecuta el método "descripción" de la clase // hija

}}

/*el método descripción que estaba definido en la clase * padre(Oceanía), se redefine en la clase hija Australia/


134

/*Programa 1 - Versión 2*/ //CLASE PADRE class Oceania {

//variante // se declara un vector de la clase String(cadena) y se lo // inicializa con 3 posiciones String estado[]=new String[3];

public void descripción() { estado[0]="Australia"; estado[1]="Fidji"; estado[2]="Nueva Zelanda";

System.out.println("Principales Estados de Oceanía"); for(int i=0;i<3;i++){

System.out.println(estado[i]); }

}}


final String capital="Canberra";// se define una constante //(variable final) llamada “capital” y se le asigna el valor // Canberra public void descripción() {

System.out.println("\n"+"La capital de Australia es: "+ capital);

}}

public class Geografia2 { public static void main(String[] args) {

Oceania estado = new Oceania(); //(variante) Crea un objeto "estado" de la clase padre // "Oceanía"

Australia ciudad = new Australia(); // Crea un objeto "ciudad" de la clase Hija // "Australia" estado.descripción(); // (variante) ejecuta el método "descripción" de la // clase padre ciudad.descripción(); //ejecuta el método "descripción" de la clase hija

}}


135

/*Programa 1 - Versión 3*/ //CLASE PADRE class Oceania {

String estado[]=new String[3]; public void descripción() {

estado[0]="Australia"; estado[1]="Fidji"; estado[2]="Nueva Zelanda";

System.out.println("Principales Estados"); for(int i=0;i<3;i++){

System.out.println(estado[i]); }

}}


final String capital="Canberra"; // se define una constante(variable final) y se le asigna // el valor Canberra

public void descripción() { System.out.println("\n"+"La capital de Australia es:

"+ capital); }

}//CLASE HIJA (derivada) class Fidji extends Oceania { final String capital="Suva";

// se define una constante(variable final) y se le asigna // el valor Suva

public void descripción() { System.out.println("\n"+"La capital de Fidji es: "+

capital); }

}public class Geografia3 {

public static void main(String[] args) { /* (variante) */

Oceania ciudad; //declara una referencia a un objeto de la clase padre // "Oceania" . Se inicializa a null ciudad= new Australia(); // La referencia "apunta" al nuevo objeto creado de la // clase hija "Australia" ciudad.descripción(); // ejecuta el método "descripción" de la clase hija // "Australia" ciudad =new Fidji(); // La misma referencia "apunta" al nuevo objeto creado de // la clase hija "Fidji" ciudad.descripción(); // ejecuta el método "descripción" de la clase hija "Fidji"


136

}}

Modelos de Ejecución

Versión 1: La capital de Australia es: Canberra Versión 2: Principales Estados de Oceanía

Australia Fidji Nueva Zelanda

La capital de Australia es: Canberra

Versión 3: Principales Estados de Oceanía

Australia Fidji Nueva Zelanda

La capital de Australia es: Canberra La capital de Fidji es: Suva


137

/* Programa 2 */ /* Cuando una clase deriva de otra hereda la funcionalidad de la * clase padre, pero además una clase hija, puede * sobreescribirla.Podemos escribir un método en la clase hija * que tenga el mismo nombre y los mismos parámetros que un * método de la clase padre */ class Mamifero { public void descripción() {

System.out.println("El mamífero es un Vertebrado"); }

}

class Perro extends Mamifero { public void descripción() {

System.out.println("Mamifero carnivoro "); }

}

public class Animales { public static void main(String[] args) {

Perro Toby = new Perro(); Toby.descripción();

}}

// Al ejecutar el programa veremos que se escribe el mensaje de // la clase hija, no el del padre.


Mamifero carnivoro


138

Sobrecarga de métodos /*Programa 1 - Versión 1*/ /* El concepto de polimorfismo, en cuanto a cambio de forma, se * puede extender a los métodos. * Java permite que varios métodos dentro de una clase se llamen * igual, siempre y cuando su lista de parámetros sea distinta *(en cuanto a número o tipo de argumentos). * / /** Diversos modos de sumar (versión estática)*/ public class Sumar {

public static float suma(float a, float b) { System.out.println("suma de reales"); return a+b;

}public static int suma(int a, int b) {

System.out.println("suma de enteros"); return a+b;

}public static void main(String[] args) {

float x=1,y=2; int v = 3,w = 5; System.out.println(suma(x,y)); System.out.println(suma(v,w));

}}


versión 1 suma de reales 3.0 suma de enteros 8


139

/*Programa 1 - Versión 2*/ /** Diversos modos de sumar(versión flexible) */ public class Sumar {

// método principal public static void main(String[] args) { try { // controla que el usuario ingrese correctamente los // valores

float valor1=Float.parseFloat(args[0]); float valor2=Float.parseFloat(args[1]); int tipo = Integer.parseInt(args[2]); switch (tipo){

case 1: int x=(int)valor1;

int y=(int)valor2; System.out.println(suma(x,y)); break; case 2:

System.out.println(suma(valor1,valor2)); break;

default: System.out.println("El 3er valor debe ser:");

System.out.println("1:si desea sumar enteros");

System.out.println("2:si desea sumar reales");

}}catch(ArrayIndexOutOfBoundsException e){

System.out.println("Por Favor ingrese 3 valores"); System.out.println("1er valor --> 1er sumando"); System.out.println("2do valor --> 2do sumando"); System.out.println("3er valor --> 1 para sumar

enteros"); System.out.println(" --> 2 para sumar reales");

}}// método de clase(Static) que arroja valores REALES public static float suma(float a, float b) {

System.out.println("suma de reales"); return a+b;

}

// método de clase(Static) que arroja valores ENTEROS public static int suma(int a, int b) {

System.out.println("Estoy sumando enteros"); return a+b; }

}


140


versión 2 C:\ JAVA Sumar Por Favor ingrese 3 valores 1er valor --> 1er sumando 2do valor --> 2do sumando 3er valor --> 1 para sumar enteros --> 2 para sumar reales C:\JAVA Sumar 7 7 7 El 3er valor debe ser: 1: si desea sumar enteros 2: si desea sumar reales C:\JAVA Sumar 7 7 1 Suma de enteros 14 C:\Sumar 7 7 2 Suma de reales 14.0


141

/** Programa 2 */ /** Calcula el área de un rectángulo */

public class Rectangulo {

private int largo,ancho; // variables privadas: únicamente se podrán utilizar en // esta clase // metodo principal donde comienza la ejecución del // programa public static void main(String[] args) { // Bloque TRY/CATCH controla que el usuario ingrese los // valores correctamente try{

int n1=Integer.parseInt(args[0]); // n1 toma el 1er valor ingresado por el usuario

int n2=Integer.parseInt(args[1]); // n2 toma el 2do valor ingresado por el usuario // crea un objeto de la clase Rectángulo - se pasa // como argumento los valores n1 y n2 Rectángulo rec1 = new Rectángulo(n1,n2); // crea un objeto de la clase Rectángulo sin // argumentos

Rectángulo rec2 = new Rectángulo(); System.out.println("Área Rectángulo Usuario");

// Llama implícitamente al método calcularArea(con // argumentos) System.out.println(rec1.calcularArea()); System.out.println("Área Rectángulo Computadora"); // Llama implícitamente al método calcularArea(sin // argumentos) System.out.println(rec2.calcularArea());

} catch(ArrayIndexOutOfBoundsException e){

System.out.println("Por Favor Ingrese los valores del largo y ancho del rectangulo");

}}// rec1 utiliza este Método Constructor pues se pasó 2 // argumentos durante su creación public Rectangulo(int lar, int anch) { largo = lar;

// largo y ancho tendrán los valores ingresado por el // usuario ancho = anch;

}


142

// rec2 utiliza este Método Constructor pues no se pasó // argumento alguno durante su creación public Rectangulo() { // largo y ancho tendrán valores aleatorios ingresados por la // función random de la clase Math

largo = (int)(Math.random()*10); ancho = (int)(Math.random()*10);

}

// método al que se llama con los objetos rec1 y rec2 en el // método main(principal)

public float calcularArea() {

int area=(int)Math.abs(largo*ancho); return area;

//e es el valor que se devuelve al programa llamador }

}


C:\java Rectangulo Por Favor Ingrese los valores del largo y ancho del rectangulo C:\java Rectangulo 5 5 Area Rectangulo Usuario 25.0 Area Rectangulo Computadora 32.0


143

/*Programa 3 */

/** Aproximación al Número E */ /** Este ejemplo utiliza los métodos de la clase PrintStream que * proporciona utilidades para dar formato a la salida. Dichos * métodos son print y println que están SOBRECARGADOS para los * tipos primitivos, cadenas y arrays de caracteres. * La diferencia entre ambos métodos está en que println añade un * carácter de nueva línea. Además el método println puede * llamarse sin argumentos, produciendo una nueva línea. */ class NumE { //clase PACKAGE (por defecto) public static void main (String args[]){ try{

// n contiene el nº ingresado por teclado con el cual // nos aproximaremos al nº E

int n=Integer.parseInt(args[0]); double vector[]=new double [(n+1)]; int i=0, j=0, k=0; double numE=0; // Se controla que el usuario no ingrese valores

// negativos o nulo if (n<=0)

System.out.println("La formula solo permite aproximarse al nº e con valores

positivos"); else { vector[0]=1;//0!=1 vector[1]=1;//1!=1 for(i=2; i<=n; i++){ j=i;k=i; while (j>1){ j--; k*=j;

} //n! = n*(n-1)! -variable k //contendrá el valor k!

vector[i]=k; }

}// Forma el número aproximado a "e"

for (i=0; i<=n; i++) { numE+=(1/(vector[i]));

}// Salida por pantalla

System.out.println(); System.out.println("Valor Aproximado: "+numE); System.out.println("Numero e: "+Math.E); System.out.println("Margen de error: "+(Math.E-

numE));

} catch(ArrayIndexOutOfBoundsException e){ System.out.println("Por favor ingrese el valor


144

con el cual desea aproximarse al num E "); }}

}

Explicación del Algoritmo

Existe una forma de aproximarse al número e = 2.71828182.... mediante la siguiente fórmula: 1/0! + 1/1! + ............+1/N! , la cual tiende al número e cuando N tiende a infinito.

Por lo tanto en este programa se define la clase NumE, el método constructor y las variables necesarias. Utilizamos un vector de n+1 elementos, recorriéndolo mediante un bucle For y lo cargamos con el factorial correspondiente a cada posición (pos 0 --> 0!, .pos N --> N! ). Posteriormente se calcula y se da salida al número aproximado obtenido, determinando además el margen de error existente (e - valor aproximado)


C:\java NumE Por favor ingrese el valor con el cual desea aproximarse al num E

C:\java NumE 23 Valor Aproximado: 2.7182818330591023 Numero e: 2.718281828459045 Margen de error: -4.600057224024567E-9 C:\java NumE 30 Valor Aproximado: 2.718281831563322 Numero e: 2.718281828459045 Margen de error: -3.104276835586006E-9 C:\java NumE 50 Valor Aproximado: Infinity Numero e: 2.718281828459045 Margen de error: -Infinity


145

/*Programa 4 */ /** Este ejemplo compara un número ingresado por el usuario con * un valor aleatorio arrojado por la máquina determinando cual * es el mayor en términos de Enteros y Decimales ** Métodos Sobrecargados: * El Método "max" de la clase Math,se utiliza 2 veces con * argumentos de distintos tipos. * El Metodo "println" de la clase PrintStream, se utiliza varias * veces con distintos tipos y/o número de argumentos. */ public class Mayor{ public static void main(String arg[]){ try { // se controla que el usuario ingrese

// correctamente los valores //"va" alberga el valor ingresado por el usuario

double va=Double.parseDouble(arg[0]); // "vc" alberga un valor determinado // aleatoriamente por la función random de la // clase Math

double vc=(Math.random()*100 int vb=(int)va; // se transfiere a la variable entera "vb" el // valor real de precisión doble de la var."va" int vd=(int)vc; //salida por pantalla System.out.println(); System.out.println("Numeros Reales"); System.out.println("Usted ha ingresado el

numero:" + va); System.out.println("La computadora ingreso el

numero:"+ vc); System.out.println("El Mayor es:"+

Math.max(va,vc)); System.out.println(); System.out.println("Numeros Enteros"); System.out.println("Usted ha ingresado el

numero:" + vb); System.out.println("La computadora ingreso el

numero:"+ vd); System.out.println("El Mayor es:"+

Math.max(vb,vd)); }catch(IndexOutOfBoundsException e){

System.out.println("Por Favor Ingrese un Numero");}

} }


146


C:\java Mayor Por Favor Ingrese un Numero C:\java Mayor 55 Numeros Reales Usted ha ingresado el numero:55.0 La computadora ingreso el numero:60.24044742541519 El Mayor es:60.24044742541519 Numeros Enteros Usted ha ingresado el numero:55 La computadora ingreso el numero:60 El Mayor es:60 C:\java Mayor 23 Numeros Reales Usted ha ingresado el numero:23.0 La computadora ingreso el numero:11.226574387976019 El Mayor es:23.0 Numeros Enteros Usted ha ingresado el numero:23 La computadora ingreso el numero:11 El Mayor es:23


147

Clases abstractas /** Programa 1 */ /** Una Clase Abstracta (abstract) es una clase de la que no se * pueden crear objetos. Su utilidad es permitir que otras clases * deriven de ella, proporcionándoles un modelo a seguir y * algunos métodos de utilidad general. */ abstract class LenguajesDeProgramacion { String[] nom=new String[4]; public abstract void detalle();

// método abstract(no se da su definición) }

class Declarativos extends LenguajesDeProgramacion { final String tipo="Funcionales"; public void detalle() { nom[0] = "lisp"; nom[1] = "Hope"; nom[2] = "Miranda"; nom[3] = "Haskell";

System.out.println("Lenguajes Declarativos"); System.out.println("\n"+tipo); for (int i=0;i<4;i++) System.out.println(nom[i]);

}}

public class Abstractos { public static void main(String[] args) { Declarativos nombre = new Declarativos(); nombre.detalle();

} }


C:\ java Abstractos Lenguajes Declarativos Funcionales lisp Hope Miranda Haskell


148

/**Programa 2 – versión 1*/ abstract class Vitamina { String alimento[]=new String[3];

public abstract void detalle(); }

class A extends Vitamina{ public void detalle() {

alimento[0]="vegetales";alimento[1]="Yema de Huevo"; alimento[2]="leche"; System.out.println("La vitamina A se encuentra en:"); for (int i=0;i<3;i++){

System.out.println(alimento[i]); }

}}

public class Medicina { public static void main(String[] args) {

A vita = new A(); vita.detalle();

} }


C:\ java Medicina La vitamina A se encuentra en: vegetales Yema de Huevo Leche


149

/**Programa 2 – versión 2*/

abstract class Vitamina { String alimento[]=new String[3];

public abstract void detalle(); }

class A extends Vitamina{ public void detalle() {

alimento[0]="vegetales";alimento[1]="Yema de Huevo"; alimento[2]="leche";

System.out.println("La vitamina A se encuentra en:"); for (int i=0;i<3;i++){ System.out.println(alimento[i]); }

}}

class E extends Vitamina{ public void detalle() { alimento[0]="germen de trigo";

alimento[1]="aceite de soja"; alimento[2]="maiz";

System.out.println("\n"+"La vitamina E se encuentra en:"); for (int i=0;i<3;i++){ System.out.println(alimento[i]); }

}}

public class Medicina1 { public static void main(String[] args) { A vita = new A();vita.detalle(); E vita1 = new E();vita1.detalle(); }}


C:\java Medicina1 La vitamina A se encuentra en: vegetales Yema de Huevo Leche La vitamina E se encuentra en: germen de trigo aceite de soja maiz

Programas ejemplo. Polimorfismo.

151

Polimorfismo /*Programa 1 – versión1 */ /** En muchas ocasiones, cuando utilizamos herencia podemos * terminar teniendo una familia de clases que comparten un * interfaz común. */ //clase PADRE abstract class Lenguajes {

String nom[]=new String[3]; // se declara un vector "nom[]" de la clase String y se lo // inicializa con 3 posiciones

public abstract void detallar();

}

//clase HIJA (hereda la variable y método de la clase PADRE) class Objetos extends Lenguajes { public void detallar() { // se redefine como public el método detallar

// (definido como abstract) nom[0]="C++";

nom[1]="Java"; nom[2]="Eiffell"; System.out.println("Lenguajes de Prog.Orientados a

Objetos"); for(int i=0;i<3;i++){ System.out.println(nom[i]);

}}

}

//clase HIJA class Declarativos extends Lenguajes { public void detallar() { // se redefine como public el método detallar

// (definido como abstract) nom[0]="Lisp"; nom[1]="Prolog"; nom[2]="Haskell"; System.out.println("\n"); System.out.println("Lenguajes de Prog.Declarativos"); for(int i=0;i<3;i++){

System.out.println(nom[i]); }

}}

public class Informatica1 { public static void detalle(Lenguajes m) {


152

// el método detalle utiliza un objeto "m" de la // clase Lenguajes

m.detallar();

// se llama al método detallar con un argumento // Implícito objeto.método

}

// método PRINCIPAL

public static void main(String[] args) { Objetos leng1 = new Objetos(); // crea un objeto "leng1" de la clase Objetos

Declarativos leng2= new Declarativos(); // crea un objeto "leng2" de la clase Declarativos

detalle(leng1); // llama al método detalle pasando el objeto "leng1" // como argumento explícito

detalle(leng2); // llama al método detalle pasando el objeto "leng2" // como argumento explícito

}}

/*el método detalle llama al método detallar ejecutándose las * sentencias que componen este último método para el objeto * especifico que lo llama.- *(primero llama a un leng. Orientado a Objetos y luego a un * leng. Declarativo) */


Lenguajes de Prog.Orientados a Objetos C++ Java Eiffell Lenguajes de Prog.Declarativos Lisp Prolog Haskell


153

/*Programa 2 – versión 1 */

/** CALCULA AREAS DE DISTINTAS FIGURAS (versión estática)*/ abstract class Figura{ //clase abstracta

abstract public double area(); }

class Circulo extends Figura{ //clase derivada de Figura private double radio;

// var private solo podrá ser utilizada por la clase // Círculo final double pi=3.1416; // var final: (constante) no puede cambiar su valor durante // la ejecución del prog.

// método constructor de la clase Circulo utiliza un // argumento pasado por referencia desde el método main // (principal)

Circulo(double r){ radio=r; } // redefinición del método area(), public double area(){

return pi*radio*radio; // valor que retorna al programa llamador

}}

class Cuadrado extends Figura{ private double lado;

Cuadrado(double l){ lado=l; }

public double area(){ return lado*lado; } }

class Triangulo extends Figura{ private double base; private double altura; Triangulo(double b, double a){ base=b; altura=a; }

public double area(){ return 0.5*base*altura;

}}

class polimorfismo{ // constructor principal (donde comienza la ejecución del // programa)


154

public static void main(String args[]){ // control de Excepciones producidas por el usuario try{ double n1=Double.parseDouble(args[0]); double n2=Double.parseDouble(args[1]); double ñ=Double.parseDouble(args[2]); double m=Double.parseDouble(args[3]);

Triangulo tri=new Triangulo(n1,n2); // se crea un objeto de la clase "Triangulo"

Circulo cir=new Circulo(m); Cuadrado cua=new Cuadrado(ñ);

// salida por pantalla a la información obtenida // en la ejecución del programa System.out.println(); System.out.println("TRIANGULO"); System.out.println("base: "+n1 + " altura: "+

n2); System.out.println("Area "+tri.area());

System.out.println(); System.out.println("CUADRADO"); System.out.println("lado: "+ñ); System.out.println("Area: "+cua.area());

System.out.println();

System.out.println("CIRCULO"); System.out.println("radio: "+m); System.out.println("Area "+cir.area()); System.out.println();

}catch(ArrayIndexOutOfBoundsException e){

System.out.println("Por Favor,ingrese 4 valores"); System.out.println("\n"+ "1er valor: Base

Triangulo"); System.out.println("\n"+ "2do valor: Altura

Triangulo"); System.out.println("\n"+ "3er valor: Lado

Cuadrado"); System.out.println("\n"+ "4to valor: Radio

Circulo"); }

}}


155


C:\java polimorfismo Por Favor, ingrese 4 valores 1er valor: Base Triangulo 2do valor: Altura Triangulo 3er valor: Lado Cuadrado 4to valor: Radio Circulo C:\java polimorfismo 7 5 8 2 TRIANGULO base: 7.0 altura: 5.0 Area 17.5 CUADRADO lado: 8.0 Area: 64.0 CIRCULO radio: 2.0 Area 12.5664


156

/**Programa 2 – versión 2 */ /**CALCULAR AREA DE DISTINTAS FIGURAS (versión flexible)*/ abstract class Figura{ // clase abstracta abstract public double area(); } class Circulo extends Figura{

private double radio; final double pi=3.1416;

// método constructor de la clase Circulo // utiliza un argumento pasado por referencia desde el

// método main(principal) Circulo(double r){

radio=r; }

// redefinición del método area(), se declara como publico // para que pueda ser accedido por todas las clases del // paquete

public double area(){

return pi*radio*radio; //valor que retorna al programa llamador

}}

class Cuadrado extends Figura{ private double lado; Cuadrado(double l){ lado=l; } public double area(){ return lado*lado; } }

class Triangulo extends Figura{ private double base; private double altura; Triangulo(double b, double a){ base=b; altura=a; }

public double area(){ return 0.5*base*altura;

}}


157

class Polimorfismo{

// constructor principal (donde comienza la ejecución del // programa)

public static void main(String args[]){

// control de Excepciones producidas por el usuario try{ double n1=Double.parseDouble(args[1]);

// n1= 2º valor ingresado por el usuario

int picture=Integer.parseInt(args[0]); //picture = 1º valor ingresado por el usuario

switch(picture){

case 1: Circulo cir=new Circulo(n1); System.out.println("\n"+"CIRCULO");

System.out.println("radio: "+n1); System.out.println("Area "+cir.area()); System.out.println("\n"+"Desea calcular el

area de otra figura?"); System.out.println("\n"+"Para calcular area

de un: "); System.out.println("CIRCULO: ingrese 1 y el

valor que desea darle al Radio"); System.out.println("CUADRADO: ingrese 2

y el valor que desea darle al Lado"); System.out.println("TRIANGULO: ingrese 3 y

los valores que desea darle a la Base y a la Altura");

break;

case 2: Cuadrado cua=new Cuadrado(n1); System.out.println("CUADRADO "); System.out.println("lado: "+n1); System.out.println("Area: "+cua.area()); System.out.println("\n"+"Desea calcular el



valor que desea darle al Radio"); System.out.println("CUADRADO: ingrese 2

y el valor que desea darle al Lado"); System.out.println("TRIANGULO: ingrese 3 y


break;


158

case 3: double n2=Double.parseDouble(args[2]); Triangulo tri=new Triangulo(n1,n2); System.out.println("TRIANGULO"); System.out.println("base: "+n1 + " altura: "+

n2); System.out.println("Area "+tri.area()); System.out.println("\n"+"Desea calcular el



valor que desea darle al Radio"); System.out.println("CUADRADO: ingrese 2 y el

valor que desea darle al Lado"); System.out.println("TRIANGULO: ingrese 3 y


break; }

}catch(ArrayIndexOutOfBoundsException e){ System.out.println("\n"+"Ingrese 2 valores, si

desea calcular el area de:"); System.out.println("\n"+"un CIRCULO"); System.out.println("1er valor: 1 " + "\t" +

"2do valor: RADIO CIRCULO"); System.out.println("\n"+"un CUADRADO"); System.out.println("1er valor: 2 " + "\t" +

"2do valor: LADO CUADRADO"); System.out.println();

System.out.println("\n"+"Ingrese 3 valores, si

desea calcular el area de:"); System.out.println("\n"+"un TRIANGULO"); System.out.println("1er valor: 3 " + "\t" +

"2do valor: BASE TRIANGULO; 3er valor: ALTURA TRIANGULO");

}}

}

/** Este programa interactúa con el usuario brindádole la * posibilidad de elegir de que figura desea calcular el área */


159


C:\java Polimorfismo Ingrese 2 valores, si desea calcular el area de: un CIRCULO

1er valor: 1 2do valor: RADIO CIRCULO un CUADRADO

1er valor: 2 2do valor: LADO CUADRADO Ingrese 3 valores, si desea calcular el area de: un TRIANGULO

1er valor: 3 2do valor: BASE TRIANGULO; 3er valor: ALTURA TRIANGULO

C:\java Polimorfismo 1 10 CIRCULO radio: 10.0 Area 314.16 Desea calcular el area de otra figura? Para calcular area de un: CIRCULO: ingrese 1 y el valor que desea darle al Radio CUADRADO: ingrese 2 y el valor que desea darle al Lado TRIANGULO: ingrese 3 y los valores que desea darle a la Base y a la Altura C:\java Polimorfismo 2 10 CUADRADO lado: 10.0 Area: 100.0 Desea calcular el area de otra figura? Para calcular area de un: CIRCULO: ingrese 1 y el valor que desea darle al Radio CUADRADO: ingrese 2 y el valor que desea darle al Lado TRIANGULO: ingrese 3 y los valores que desea darle a la Base y a la Altura


160

/**Programa 3 */ /**subprograma 1*/ package polimorfismo; public class Polimorfis {

public static void main(String[] args) { Espinacas espi=new Espinacas(); que_aporta(espi); Tomate tomate=new Tomate(); que_aporta(tomate);

try {

//espera la pulsación de una tecla y luego RETORNO

System.in.read(); }catch (Exception e) { }

}

static void que_aporta(Vitaminas alimento){ alimento.aporte();

}}

/** subprograma 2*/ package polimorfismo; public abstract class Frutas { }

class Citricos extends Frutas implements Vitaminas{ public void aporte(){

System.out.println("Los cítricos aportan vitamina C");

}}

/** subprograma 3*/ package polimorfismo; // clase Base implementa la interfaz Vitaminas public abstract class Verduras implements Vitaminas{ public abstract void aporte();

//define un método abstracto }// clase derivada de Verduras class Espinacas extends Verduras{

public void aporte(){ System.out.println("Las Espinacas aportan vitamina

B9"); }

}


161

// clase derivada de Verduras class Tomate extends Verduras{

public void aporte(){ System.out.println("El tomate aporta vitamina k");

}}

/** subprograma 4*/ package polimorfismo; public interface Vitaminas {

public abstract void aporte(); }

/* En el lenguaje Java solamente existe la herencia simple, pero * las clases pueden implementar interfases, las cuales * incrementan el polimorfismo del lenguaje más allá del que * proporciona la herencia simple. * Si solamente hubiese herencia simple, Citricos tendría que * derivar de la clase Verduras (lo que no es lógico) o bien no * se podría pasar a la función que_aporta. * Con interfases, cualquier clase en cualquier familia puede * implementar la interfase Vitaminas, y se podrá pasar un objeto * de dicha clase a la función "que_aporta". * Esta es la razón por la cual las interfases proporcionan más * polimorfismo que el que se puede obtener de una simple * jerarquía de clases. */


Las Espinacas aportan vitamina B9 El tomate aporta vitamina k

Programas ejemplo. Ligaduras Dinámicas.

163

Ligaduras dinámicas /** Programa 1 */ /** Subprograma 1*/ package Figura; public abstract class Figura {

public abstract double area(); }

class Circulo extends Figura{ protected double radio; public Circulo(double radio){

this.radio = radio; // variable miembro radio alberga el valor del // argumento radio


//redefine el método abstracto de la clase Base return Math.PI*radio*radio; //retorna el valor del área del círculo

}}

class Cuadrado extends Figura{ protected double lado; public Cuadrado(double lado){

this.lado=lado; }public double area(){

return lado*lado; }

}

/* variables PROTECTED: sólo la clase en la que se define, las * clases que deriven de ella y las clases del propio package * tienen permiso para utilizarlas. * JAVA permite declarar una variable dentro de un bloque con el * mismo nombre que una variable miembro. * La variable declarada dentro del bloque oculta a la variable * miembro en ese bloque. * Para acceder a la variable miembro oculta será preciso * utilizar el operador this, en la forma this.varname. * De esta forma, this.radio se refiere a la variable miembro, * mientras que radio es el argumento del constructor. */

Programas ejemplo. Ligaduras Dinámicas.

164

/**Subprograma 2*/ package Figura; public class FiguraApp { public static void main(String[] args) {

// enlace temprano: tiempo de compilación Circulo c=new Circulo(5.5); System.out.println("Area del circulo "+ c.area()); Cuadrado r=new Cuadrado(5.5); System.out.println("Area del cuadrado "+r.area());

// enlace tardío 1: tiempo de ejecución // valores predefinidos Figura f=new Circulo(2); System.out.println("Area del circulo "+f.area()); f=new Cuadrado(3); System.out.println("Area del cuadrado "+f.area());

// enlace tardío 2 // valores ingresados por teclado try {

Figura fig[]=new Figura[2]; int variable=System.in.read(); // toma el entero correspondiente a alt+variable System.out.println("las areas se calcularan con el

valor: "+variable); fig[0]=new Cuadrado(variable); fig[1]=new Circulo(variable); for(int p=0;p<2;p++)

System.out.println(fig[p].area()); }catch (Exception e) {}

}}


C:\ java FiguraApp Area del circulo 95.03317777109123 Area del cuadrado 30.25 Area del circulo 12.566370614359172 Area del cuadrado 9.0

programacion orientada a objetos(tesis)

Documents