Lazzarini

Tesis Hctor Csar Lazzarini
UNIVERSIDAD NACIONAL DE MISIONES

FACULTAD DE CIENCIAS ECONOMICAS MAESTRIA EN INFORMTICA Y COMPUTACIN CONVENIO CON LA UNIVERSIDAD DE CANTABRIA TESIS PROGRAMACION ORIENTADA A OBJETOS
Diirectora: Magiister Glladys Noem Dapozo D rectora: Mag ster G adys Noem Dapozo Maestrando: Hctor Csar Lazzariinii Maestrando: Hctor Csar Lazzar n
Direccin Postal: Moreno 155 P3600KAC Formosa Formosa Argentina
Direccin electrnica: lazzariniylazzarini@arnet.com.ar
TABLA DE CONTENIDOS
TABLA DE CONTENIDOS........................................................................................................ 1 Agradecimientos:........................................................................................................................... 7 Prlogo .......................................................................................................................................... 9 Capitulo 1 .................................................................................................................................... 11 INTRODUCCIN A LA PROGRAMACIN ORIENTADA A OBJETOS (POO) ..................... 11 Un poco de historia de la POO........................................................................................... 11 Ideas bsicas de la POO .................................................................................................... 14 Ventajas e inconvenientes de la orientacin a objetos ...................................................... 15 El modelo OO ..................................................................................................................... 15 Definiciones bsicas ........................................................................................................... 16 Diferencia entre el modelado por descomposicin funcional y el OO................................ 17 Descomposicin OO........................................................................................................... 18 Capitulo 2. ................................................................................................................................... 19 PROGRAMACIN ORIENTADA A OBJETOS FIJANDO CONCEPTOS ........................... 19 Introduccin. ....................................................................................................................... 19 Informacin ......................................................................................................................... 19 Sistemas de informacin. ................................................................................................... 20 Profundizando el concepto de Objeto. ............................................................................... 20 Demonios............................................................................................................................ 23 Abstraccin. ........................................................................................................................ 24 Modularidad. ....................................................................................................................... 24 Encapsulacin de objetos................................................................................................... 24 Reutilizacin. ...................................................................................................................... 25 Clase................................................................................................................................... 25 Herencia.............................................................................................................................. 26 Polimorfismo. ...................................................................................................................... 27 Jerarquas. .......................................................................................................................... 27 Mensajes............................................................................................................................. 28 Capitulo 3. ................................................................................................................................... 29 JAVA Y LA PROGRAMACIN ORIENTADA A OBJETOS.................................................... 29 Introduccin. Porqu Java?.............................................................................................. 29 Origen de Java. .................................................................................................................. 29 Caractersticas de Java ...................................................................................................... 31 Capitulo 4. ................................................................................................................................... 37 PROFUNDIZANDO CONCEPTOS DE POO ejemplos con JAVA ...................................... 37 1. Herencia.......................................................................................................................... 38 2. Sobrescritura de mtodos............................................................................................... 38 3. La clase base y la clase derivada................................................................................... 38 En Java disponemos de los paquetes bsicos: ............................................................. 39 La clase base object. ...................................................................................................... 45 Mtodos que pueden ser redefinidos por el programador. ............................................ 45 Concretando: .................................................................................................................. 48 4. Redefinicin de mtodos heredados .............................................................................. 48 Modificador final:............................................................................................................. 49 5. Clases y mtodos abstractos ......................................................................................... 49 6. Polimorfismo ................................................................................................................... 49 Mtodos (funciones miembro). ....................................................................................... 52 Mtodos sobrecargados (overloaded)............................................................................ 54 7. Vinculacin, Ligadura o Binding ..................................................................................... 49 8. Redefinicin .................................................................................................................... 55 Sobrecarga de Constructores......................................................................................... 55 Objetos como parmetros .............................................................................................. 56 Paso de argumentos. ..................................................................................................... 56 El operador static............................................................................................................ 57 Las variables static ......................................................................................................... 57 Los mtodos static.......................................................................................................... 58
El operador final.............................................................................................................. 59 9. Interfases. ....................................................................................................................... 59 Qu diferencia hay entre una interfase y una clase abstract?..................................... 59 Definicin de interfases. ................................................................................................. 60 Utilizacin 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 Mtodos Miembros de una Clase. .............................. 62 Resumen de los permisos de acceso de Java............................................................... 62 11. Transformaciones de tipo: casting................................................................................ 63 Conversin de tipos primitivos........................................................................................ 63 12. Sincronizacin de threads (hilos). ................................................................................ 63 Captulo 5. ................................................................................................................................... 65 Implementacin de los conceptos de oo con JAVA................................................................ 65 Implementado el concepto Jerarqua ................................................................................. 65 La clase Figura ............................................................................................................... 66 La clase Rectngulo ....................................................................................................... 66 La clase Crculo .............................................................................................................. 67 Uso de la jerarqua de clases. ............................................................................................ 67 Enlace dinmico o binding.................................................................................................. 68 Ejemplo de polimorfismo. ............................................................................................... 68 Ampliacin de la jerarqua de clases.................................................................................. 70 La clase Triangulo. ......................................................................................................... 71 El operador instanceof........................................................................................................ 72 En resumen:........................................................................................................................ 72 Clases y Mtodos Finales................................................................................................... 73 Interfases. ........................................................................................................................... 74 Diferencias entre una Interfase y una Clase Abstracta. ..................................................... 75 Las interfases y el Polimorfismo......................................................................................... 76 Herencia simple. ................................................................................................................. 76 Composicin. ...................................................................................................................... 79 La clase punto ................................................................................................................ 80 La clase Rectangulo ....................................................................................................... 81 Definiendo Clases............................................................................................................... 83 Uso de Atributos. ................................................................................................................ 85 Uso de la Definicin de Clase............................................................................................. 86 Diseo e Implementacin de Clases. ................................................................................. 86 Diseo de la clase: ............................................................................................................. 87 Implementacin 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 Captulo 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 Administracin de la Calidad ............................................................................................ 108 Calidad por Etapas ........................................................................................................... 110 Estndares y Modelos de Calidad en la Ingeniera 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
La eleccin del Lenguaje de Programacin ..................................................................... 123 Perspectivas a futuro ............................................................................................... 125 Bibliografa ............................................................................................................................ 131 PROGRAMAS EJEMPLO DE LOS TEMAS TRATADOS. ................................................... 133 Redefinicin de mtodos .................................................................................................. 133 /*Programa 1 - Versin 1*/ ........................................................................................ 133 /*Programa 1 - Versin 2*/ ........................................................................................ 134 /*Programa 1 - Versin 3*/ ........................................................................................ 135 /* Programa 2 */ .......................................................................................................... 137 Sobrecarga de mtodos ................................................................................................... 138 /*Programa 1 - Versin 1*/ ........................................................................................ 138 /*Programa 1 - Versin 2*/ ........................................................................................ 139 /** Programa 2 */........................................................................................................... 141 /*Programa 3 */ ............................................................................................................. 143 Explicacin del Algoritmo.................................................................................................. 144 /*Programa 4 */ ............................................................................................................. 145 Clases abstractas ............................................................................................................. 147 /** Programa 1 */........................................................................................................... 147 /**Programa 2 versin 1*/.......................................................................................... 148 /**Programa 2 versin 2*/.......................................................................................... 149 Polimorfismo ..................................................................................................................... 151 /*Programa 1 versin1 */ ........................................................................................... 151 /*Programa 2 versin 1 */ .......................................................................................... 153 /**Programa 2 versin 2 */......................................................................................... 156 /**Programa 3 */ /**subprograma 1*/............................................................................ 160 /** subprograma 2*/ ...................................................................................................... 160 /** subprograma 3*/ ...................................................................................................... 160 Ligaduras dinmicas......................................................................................................... 163 /** Programa 1 */ /** Subprograma 1*/ ......................................................................... 163 /**Subprograma 2*/ ...................................................................................................... 164
Agradecimientos:
A toda la gente me alent para que termine este trabajo. A todos los profesores de Espaa, realmente es imposible dejar de recordarlos, por su calidez humana y profesional. A todos: un GRACIAS sincero.
Formosa, 14 de mayo de 2005
Introduccin
Prlogo
Los objetivos de este trabajo son establecer las pautas bsicas para introducir a los alumnos en el mundo de la Programacin Orientada a Objetos (POO), en el marco de la materia PROGRAMACIN IV de la carrera Licenciatura en Sistemas de Informacin. En este libro se ensearan los conceptos de la Programacin Orientada a Objetos con abundantes ejemplos basados en el lenguaje JAVA. Muchos de estos ejemplos van incorporando progresivamente cada nuevo concepto que se ensea, para, de esta manera, facilitar la incorporacin 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 ensear por su popularidad comercial y su aplicacin actual en Internet. Este trabajo de Tesis se ha estructurado de la siguiente manera: Introduccin histrica. Explicacin conceptual de los temas planteados. No se incluyen ejemplos de ningn tipo. Explicacin de los conceptos con ejemplos bsicos. Se revisan los conceptos brevemente y se aplica a un ejemplo preciso. Presentacin de programas en Java que aplican puntualmente los conceptos impartidos. Se trata de programas que funcionan autnomamente. Presentacin de diversos programas ms genricos que combinan varios conceptos combinados. Conclusiones y perspectivas a futuro. Bibliografa utilizada. Glosario Listado de cdigos de programas desarrollados donde se analiza cada concepto en particular.
Captulo 1 Introduccin a la Programacin Orientada a Objetos.
Capitulo 1 INTRODUCCIN A LA PROGRAMACIN ORIENTADA A OBJETOS (POO)

Un poco de historia de la POO. La programacin 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 an est en sus orgenes y que el futuro traer todava grandes adelantos tcnicos y tericos que mejorarn sus resultados. En su corta historia, la programacin ha sufrido importantes cambios, diramos casi revoluciones. Los primeros avances metodolgicamente ordenados, fueron protagonizados principalmente por Wirth, Dijstra y de forma menos terica pero quizs con ms impacto por Kernighan y Ritchie. Es lo que se denomin la programacin estructurada. Los primeros lenguajes de programacin eran simplemente instrucciones que se le podan dar a un autmata como una computadora, para que realizara ciertas operaciones. As un programa no era sino una lista de instrucciones encaminadas a realizar algn clculo. A medida que las computadoras fueron hacindose ms sofisticadas, sus lenguajes propios o lenguajes de mquina iban cambiando y surgi la necesidad de crear unos lenguajes intermedios que cualquier usuario pudiera aprender y que no dependieran de la mquina concreta en la que se iban a ejecutar los programas. As surgieron varios lenguajes que se hicieron famosos y tambin surgieron los primeros compiladores. Un compilador es un programa que traduce las instrucciones de un lenguaje ms o menos humano, a las de una mquina. La aparicin de estos lenguajes intermedios y sus compiladores marca el comienzo de la programacin como una nueva ciencia. El tremendo xito que las computadoras tuvieron a lo largo de los aos 60 fue llevando a la creacin de programas cada vez ms complejos que llegaban a tener miles de lneas de cdigo. 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 mquinas estriles, surgi un grupo de cientficos de la computacin, de los cuales Dijstra y Wirth son dos de los ms destacados. Estos propusieron una serie de ideas que llevaron a la creacin de ese nuevo concepto indicado al inicio: la programacin estructurada. Otros cientficos experimentaron ideas similares creando diversos lenguajes de programacin orientada a objetos como Smalltalk. En ellos se experiment con otras ideas tiles como la definicin 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. Tambin surgi una idea que ayudara a evitar los difciles problemas que surgan en el manejo de la memoria dinmica: los constructores y destructores de objetos.
11
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 prcticamente toda la sintaxis y posibilidades del lenguaje que en ese momento era ms popular entre los programadores, el lenguaje C. Este truco ayud a popularizar la programacin orientada a objetos y prepar el camino para la aparicin del Java. Los creadores de Java aprendieron bien la leccin de Bjarne Stroustrup. Un nuevo lenguaje para tener xito deba ser muy parecido al que en el momento de su lanzamiento fuese el ms popular. As, Java se cre con un gran parecido al C++. Pero Java es un lenguaje ms puro de programacin orientada a objetos, conserva un poco del C original, pero se parece ms al C++. Puede verse al C++ como un paso intermedio en la transicin de la programacin estructurada del C a la programacin orientada a objetos ms pura del Java. Microsoft est tratando de impulsar un nuevo lenguaje llamado C# (C sharp) que promete ser an ms puro como lenguaje orientado a objetos, adopta prcticamente 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 computacin nunca se gana algo sin perder otra cosa, lo importante es que en promedio las cosas vayan mejorando). Hacia los 80s el paradigma orientado a objetos comenzaba a madurar como un enfoque concreto de desarrollo de software. En los ltimos aos esta metodologa 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 Tecnologa Orientada a Objetos (TOO) no solo se aplica a los lenguajes de programacin, sino que tambin se ha propagado a los mtodos de anlisis y diseo 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 detrs de ella y sus antecedentes histricos. Uno de los defectos de la programacin 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 razn es que los mdulos que acceden a estas variables no se pueden comprender completamente, de forma independiente, de todos aquellos otros mdulos que tambin 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 informacin como solucin. Su idea era encapsular cada una de las variables globales del programa en un mdulo junto con sus operaciones asociadas, slo mediante las cuales se poda tener acceso a estas variables. El resto de los mdulos podran acceder a las variables slo de forma indirecta mediante las operaciones diseadas a tal efecto. En la actualidad denominamos objetos a este tipo de mdulos. El primer lenguaje que introdujo los conceptos de orientacin 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.
12
En estos tiempos no existan lenguajes de programacin 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 inclusin (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 programacin estructurada propone dos ideas bsicas: no repetir cdigo y proteger las variables que una parte del programa usa, de que sean modificadas accidentalmente por otras partes del programa. Una sola repeticin de cdigo es fuente probable de errores y dificulta el mantenimiento de un programa. Para no repetir cdigo hay que escribir funciones o procedimientos que se encarguen de realizar siempre lo que las diferentes repeticiones realizaran. Para proteger las variables hay que desarrollar lenguajes que permitan definir variables locales, es decir, que slo pueden ser utilizadas dentro de una funcin o procedimiento. De esta manera ninguna otra funcin del programa puede cambiarla. Como consecuencia de estas ideas disminuye considerablemente el tamao de los programas y stos se hacen ms confiables y ms fciles de corregir o mejorar. Para facilitar la programacin estructurada, aparecen nuevos lenguajes, notoriamente el Pascal y el C, son los dos lenguajes de programacin estructurada ms conocidos. Wirth, creador del Pascal, nunca qued satisfecho con este lenguaje. En su constante anlisis de los hbitos de programacin encontraba que todava haba muchas cosas que mejorar. Una dcada despus del Pascal public otro lenguaje llamado Modula2 en el que presentaban algunas de sus ideas ms recientes. Los mdulos de Modula2 pretendan representar objetos o clases. Dentro de un mdulo se definan variables que representaban el estado del objeto y se definan procedimientos que describan su comportamiento. Las variables y los procedimientos de un mdulo podan ser de uso pblico o privado, exclusivos de la clase, segn lo decidiera el creador del mdulo. Con todo esto se mejoraba notoriamente lo instituido por el Pascal donde el concepto de procedimientos o funciones privadas no exista y se daba un paso importante hacia la programacin de clases o programacin orientada a objetos. Alrededor de los aos 70s fue desarrollado el lenguaje de programacin 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 trmino de Orientacin a Objetos (Object Oriented OO) y que cobrara importancia entre los diseadores de lenguajes de programacin. Los puntos importantes de este lenguaje fueron, por un lado, adoptar el concepto de objeto y clase como ncleo del lenguaje y la programacin 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 programacin 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 mltiple, y se introduce pensando en dar mayor
13
flexibilidad a los desarrolladores. Sin embargo, actualmente la herencia mltiple se ha evitado por agregar complejidad en las estructuras de clases. Ambos lenguajes tuvieron importancia entre 1985 y hasta la primera mitad de los 90s. En 1995 apareci JAVA, el ms reciente lenguaje OO, desarrollado por la empresa SUN Microsystems, que hereda conceptos de C++, pero los simplifica y evita la herencia mltiple. En su lugar se introduce el trmino de interfaz, y la herencia mltiple de interfases. Obtiene una rpida aceptacin gracias a los applets, que son programas en JAVA insertados en pginas WEB dentro del cdigo HTML. Estos programas pueden viajar a travs de la Internet y brindarle al usuario mayor interactividad con las pginas WEB. JAVA introduce tambin, la programacin 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 prximos aos logre la madurez adecuada para convertirse en un lenguaje de desarrollo de mayor importancia. Ideas bsicas de la POO La programacin orientada a objetos es una metodologa 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 representacin de este mundo mediante la identificacin de los objetos que constituyen el vocabulario del dominio del problema, su organizacin y la representacin de sus responsabilidades. El paradigma orientado a objetos se basa en los tres mtodos de organizacin 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 formacin y distincin 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 ms 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 ms a sus equivalentes en el mundo real. La elevacin del nivel de abstraccin es sin duda un objetivo deseable. Las tcnicas orientadas a objetos usan un mismo modelo conceptual para el anlisis, el diseo y la programacin. La transicin desde el anlisis al diseo es tan natural que es difcil especificar donde comienza uno y donde acaba el otro.
14
Ventajas e inconvenientes de la orientacin a objetos Entre las ventajas ms importantes podemos destacar: Favorece la comunicacin entre analistas, diseadores, programadores y usuarios finales al utilizar todos los mismos modelos conceptuales. Esto se traduce en un aumento de la productividad, ya que la comunicacin es uno de los puntos crticos en las primeras fases del proyecto. Se facilita la representacin 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 semntica de estas tcnicas es ms rica (al ser ms natural); al usuario final le es ms fcil 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 tcnicas son ms resistentes al cambio que las tradicionales tcnicas de anlisis orientadas a flujos de datos. Algunas de sus desventajas: Hay que ser muy cuidadosos en la creacin de los objetos, ya que de ello depender el xito de nuestro proyecto. Un error en estas primeras definiciones podra resultar catastrfico. Precisamente el secreto de esta tcnica est en la correcta definicin inicial de los objetos. Los estndares en este tipo de tcnicas estn en continua evolucin, lo que exige una actualizacin permanente. Los analistas, diseadores y desarrolladores del proyecto deben conocer las reglas del juego y poseer suficiente experiencia en programacin. El modelo OO Podemos indicar que se apoya en cuatro conceptos bsicos: objeto clase herencia envo de mensajes Los primeros tres conceptos se refieren a la parte estructural o esttica del modelo y el cuarto, que corresponde a mensajes, se refiere a la parte del comportamiento dinmico.
15
Definiciones bsicas Definicin de Objeto: En trminos ms generales, un objeto es una abstraccin conceptual del mundo real que se puede traducir a un lenguaje computacional o de programacin OO. La abstraccin de objeto se caracteriza por tener una identidad nica que lo distingue de otros objetos. Tambin tiene un estado, que permite informar lo que ste representa y su comportamiento, es decir lo que l sabe hacer. Hablando en trminos 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 mtodos, procedimientos, funciones u operaciones que un objeto puede ejecutar a solicitud de otros objetos. Los objetos tambin se conocen como instancias. Definicin de Clase: Es una coleccin de objetos similares. Estos objetos deben tener los mismos atributos con valores posiblemente diferentes asignados a estos, y el mismo conjunto de mtodos que definen su comportamiento. Por otro lado tambin se puede ver una clase como un molde, esquema o un patrn que define la forma de sus objetos. O bien, como la estructura esttica que define: a) el esquema de estados, y b) el comportamiento que van a tener los objetos A partir de ese esquema, dinmicamente durante la ejecucin de un programa, se van a ir creando objetos que pertenezcan a esa clase. Definicin de Herencia: Una clase puede heredar sus atributos y mtodos a varias subclases (la clase que hereda es llamada superclase). Esto significa que una subclase, aparte de los atributos y mtodos propios, tiene incorporados los atributos y mtodos heredados de la superclase. Una subclase puede a su vez comportarse como una superclase y heredar a otras clases, creando de esta manera la jerarqua de herencia. Cuando una clase hereda de ms de una superclase se conoce como herencia mltiple. Definicin de Envo de Mensajes: Qu sucede cuando los objetos desean comunicarse entre s?. Un objeto recibe un estmulo externo de solicitud de un servicio que se traduce en la invocacin de un mtodo de ste objeto. Al ejecutarse el mtodo, el objeto puede solicitar servicios de otros objetos, envindoles mensajes que implican a su vez la invocacin de sus mtodos, y dentro de estos, nuevamente invocar servicios de otros objetos y as sucesivamente. Este envo de mensajes en cascada representa el comportamiento dinmico del modelo de objetos.
16
Haciendo un parntesis, 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 descomposicin funcional y el OO. Veamos la diferencia con un ejemplo Problema: Hacer bife criollo Resolucin segn la Descomposicin funcional: Se declara una lista de datos, los cuales se encuentran en un espacio comn. El algoritmo divide al problema en sub-problemas o funciones, partiendo de las ms complejas hasta llegar a las acciones ms sencillas de realizar, llamadas tambin atmicas. En todo momento la descomposicin del problema se har identificando las acciones (verbos) que se deben realizar. Hacer bife criollo acompaado de papa se divide en dos subproblemas: frer bifes con cebollas aadir acompaamiento Frer bifes con cebollas presenta tres subdivisiones: frer bifes preparar salsa con cebolla, perejil y pimientos verdes juntar bifes con la salsa Frer bifes y juntar bifes con la salsa son actividades que ya se saben realizar (atmicas). Sin embargo, el caso de preparar salsa con pimientos verdes an podemos aclararlo ms: Rehogar cebolla, el pimiento verde y el perejil Agregar 1 ajo picado chico frer la salsa que ya son actividades atmicas. Para el caso de aadir acompaamiento se particiona en dos actividades atmicas aadir papa cocida
17
aadir perejil Si se deseara ahora preparar bife criollo con salsa de pimiento rojo, se tendra que buscar cuales actividades hay que modificar. En este caso sera 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. Descomposicin OO La modelacin de esta solucin se realiza a travs de los sustantivos que definen al problema. En este caso los sustantivos (nombres) ms importantes son: Bife_Criollo, Salsa_Verde, Ingredientes, Licuadora, Sartn y Acompaamiento. Todos estos van a ser nuestros objetos que internamente van a integrar datos y operaciones, que podemos asociarlos de manera lgica a cada uno de sus conceptos. Cuando se pide haz_bife_criollo al objeto Bife_Criollo, este debe tener un mtodo que sabe hacer bife criollo apoyndose en el objeto Frer_Bifes_Con_Cebolla, que tiene bifes como dato y saber frer bifes cmo mtodo. Para el caso de Salsa de pimiento verde, Bife_Criollo le enva un mensaje dicindole preprate y entonces se preparar enviando mensajes a Ingredientes que los Rehoga, Licuadora que los pica y finalmente llama a Sartn para que los fra. Finalmente Bife_Criollo le va a enviar un mensaje a Acompaamiento, para que se aada la papa y el perejil, y quede finalmente preparado nuestro plato Bife Criollo. Es importante notar que los datos se encuentran implcitos formando parte de los objetos. Si en este modelo se desea hacer el Bife Criollo con Salsa de Pimientos Rojos, solo bastara sustituir el objeto Salsa de Pimientos Verdes por el objeto Salsa de Pimientos Rojos, que se preparar, enviando mensajes a Ingredientes, Licuadora y Sartn, sin modificar nada ms.
18
Captulo 2 Programacin Orientada a Objetos Fijando Conceptos.
Capitulo 2. PROGRAMACIN ORIENTADA A OBJETOS FIJANDO CONCEPTOS

Introduccin. La Orientacin a Objetos (OO) promete mejoras de amplio alcance en la forma de diseo, desarrollo y mantenimiento del software proponiendo una solucin a largo plazo a los problemas y preocupaciones que han existido desde el comienzo en el desarrollo de software: la falta de portabilidad del cdigo y reusabilidad, cdigo que es difcil de modificar, ciclos de desarrollo largos, y tcnicas de codificacin no intuitivas. Un lenguaje orientado a objetos que ataca estos problemas, tiene 3 caractersticas bsicas: 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 ms difcil de sortear es usualmente la herencia. Dado que la Programacin Orientada a Objetos (POO) se basa en la idea natural de la existencia de un mundo lleno de objetos y que la resolucin del problema se realiza en trminos de objetos, un lenguaje se dice que est basado en objetos si soporta objetos como una caracterstica 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 organizacin. Esta definicin especifica varias propiedades importantes de los objetos. En primer lugar, un objeto no es un dato simple, sino que contiene en su interior cierto nmero de componentes bien estructurados. En segundo lugar, cada objeto no es un ente aislado, sino que forma parte de una organizacin jerrquica o de otro tipo. Informacin La Informacin es una coleccin de datos que entra, fluye, se procesa y sale de un Sistema. El dato es una representacin de la informacin con la estructura ms adecuada para su tratamiento o proceso.
19
Sistemas de informacin. 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 funcin o finalidad determinada. Un Sistema de Informacin se caracteriza porque sus procesos son la adquisicin, manipulacin, uso, produccin, almacenamiento y distribucin de informacin. 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 podra ser real o abstracto, por ejemplo una organizacin, una factura, una figura en un graficador, una pantalla de usuario, un avin, un vuelo de avin, etc. En el anlisis y diseo orientados a objetos (OO), interesa el comportamiento del objeto. Si se construye software, los mdulos 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 mtodos. Entonces, dentro del software orientado a objeto, un objeto es cualquier cosa, real o abstracta, acerca de la cual almacenamos datos y los mtodos que controlan dichos datos. Un objeto puede estar compuesto por otros objetos. Estos ltimos a su vez tambin 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 organizacin. Algunas instancias de empleado podran ser Juan Prez, Jos Martnez, etc. En el anlisis orientado a objetos, estos conceptos se llaman tipos de objetos; las instancias se llaman objetos. As, un tipo de objeto es una categora 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 Prez o Jos Martnez para el tipo de entidad empleado). Del mismo modo, en OO se define tipos de objetos e instancias de tipo de objeto.
20
Sin embargo, el trmino objeto tiene diferencias fundamentales con el trmino entidad, ya que la entidad slo se refiere a los datos, mientras que objeto se refiere a los datos y a los mtodos mediante los cuales se controlan a los propios datos. En OO, la estructura de datos y los mtodos de cada tipo de objeto se manejan juntos. No se puede tener acceso o control de la estructura de datos excepto mediante los mtodos que forman parte del tipo de objeto. Estructura de un objeto. Un objeto puede considerarse como una especie de cpsula dividida en tres partes: Relaciones Propiedades Mtodos Cada uno de estos componentes desempea roles totalmente independientes: Las relaciones permiten que el objeto se inserte en la organizacin y estn formadas esencialmente por punteros a otros objetos. Las propiedades distinguen un objeto determinado de los restantes que forman parte de la misma organizacin 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 organizacin. Los mtodos son las operaciones que pueden realizarse sobre el objeto, que normalmente estarn incorporados en forma de programas (cdigo) que el objeto es capaz de ejecutar y que tambin pone a disposicin de sus descendientes a travs 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 organizacin. Las hay de dos tipos fundamentales: Relaciones jerrquicas. Son esenciales para la existencia misma de la aplicacin 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 organizacin en la que ambos forman parte; asimismo, si un objeto es padre de otro, el segundo es hijo del primero. Una organizacin jerrquica simple puede definirse como aquella en la que un objeto puede tener un solo padre, mientras que en una organizacin jerrquica compleja un hijo puede tener varios padres. Relaciones semnticas. Se refieren a las relaciones que no tienen nada que ver con la organizacin de la que forman parte los objetos que las establecen. Sus propiedades y consecuencias solo dependen de los
21
objetos en s mismos (de su significado) y no de su posicin en la organizacin. Vemoslo con un ejemplo: supongamos que vamos a construir un diccionario informatizado que permita al usuario obtener la definicin de una palabra cualquiera. Supongamos que, en dicho diccionario, las palabras son objetos y que la organizacin jerrquica es la que proviene de forma natural de la estructura de nuestros conocimientos sobre el mundo. La raz del diccionario podra llamarse TEMAS. De ste trmino genrico, descendern 3 grandes ramas de objetos llamadas VIDA, MUNDO y HOMBRE. El primero (VIDA) comprender las ciencias biolgicas: Biologa y Medicina. El segundo (MUNDO), las ciencias de la naturaleza inerte: las Matemticas, la Fsica, la Qumica y la Geologa. El tercero (HOMBRE) comprender las ciencias humanas: la Geografa, la Historia, etc. Aplicamos el ejemplo: establecemos la relacin trabajo entre los objetos NEWTON y PTICA y la interpretaremos diciendo que significa que Newton trabaj en ptica. La relacin es, evidentemente, semntica, pues no establece ninguna connotacin jerrquica entre NEWTON y PTICA y su interpretacin depende exclusivamente del significado de ambos objetos. La existencia de esta relacin nos permitir responder a preguntas como: Quin trabaj en ptica?, En qu trabaj Newton?, Quin trabaj en Fsica? Las dos primeras se deducen inmediatamente de la existencia de la relacin trabajo. Para la tercera observamos que si Newton trabaj en ptica automticamente sabemos que trabaj en Fsica, por ser ptica una rama de la Fsica (en nuestro diccionario, el objeto PTICA es hijo del objeto FSICA). Entonces gracias a la POO podemos responder a la tercera pregunta sin necesidad de establecer una relacin entre NEWTON y FSICA, apoyndonos slo en la relacin definida entre NEWTON y PTICA y en que PTICA es hijo de FSICA. De este modo se elimina toda redundancia innecesaria y la cantidad de informacin que tendremos que definir para todo el diccionario ser mnima. 2) Propiedades. Todo objeto puede tener cierto nmero de propiedades, cada una de las cuales tendr, a su vez, uno o varios valores. En POO, las propiedades corresponden a las clsicas variables de la programacin estructurada. Son, por lo tanto, datos encapsulados dentro del objeto, junto con los mtodos (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 ms o menos estructurados (matrices, vectores, listas, etc.). Adems, los valores pueden ser de cualquier tipo (numrico, alfabtico, etc.) si el sistema de programacin 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:
22
Propiedades propias. Estn formadas dentro de la cpsula del objeto. Propiedades heredadas. Estn 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) Mtodos. Los mtodos especifican la forma en que se controlan los datos de un objeto. Los mtodos, en un tipo de objeto slo 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 estn representadas por tipos de datos y su comportamiento por mtodos. El mtodo es una operacin que realiza el acceso a los datos. Podemos definir mtodo como un programa procedimental o procedural escrito en cualquier lenguaje, que est asociado a un objeto determinado y cuya ejecucin slo puede desencadenarse a travs de un mensaje recibido por ste o por sus descendientes. Sinnimos de mtodo, son todos aquellos trminos que se han aplicado tradicionalmente a los programas, como procedimiento, funcin, rutina, etc. Sin embargo, es conveniente utilizar el trmino mtodo 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 travs de un mensaje) y a su campo de accin, limitado a un objeto y a sus descendientes, aunque posiblemente no a todos. Los mtodos son programas, por lo tanto, tienen argumentos o parmetros. Como los mtodos pueden heredarse de unos objetos a otros, un objeto puede disponer de un mtodo de dos maneras diferentes: Mtodos propios. Estn incluidos dentro de la cpsula del objeto. Mtodos heredados. Estn definidos en un objeto diferente, antepasado de ste (padre, abuelo, etc.). A veces estos mtodos se llaman mtodos miembro porque el objeto los posee por el mero hecho de ser miembro de una clase. Demonios. Es un tipo especial de mtodos, relativamente poco frecuente en los sistemas de POO, que se activa automticamente cuando sucede algo especial. Es decir, es un programa, como los mtodos ordinarios, pero se diferencia de estos porque su ejecucin no se activa con un mensaje, sino que se desencadena automticamente cuando ocurre un suceso determinado: la asignacin de un valor a una propiedad de un objeto, la lectura de un valor determinado, etc.
23
Los demonios, cuando existen, se diferencian de otros mtodos por que no son heredables y porque a veces estn ligados a una de las propiedades de un objeto, ms que al objeto entero. Abstraccin. La Abstraccin es una descripcin especial simplificada de un sistema que hace nfasis en ciertos rasgos y suprime otros. La buena abstraccin es aquella que logra hacer nfasis en los detalles significativos o relevantes de la solucin y discrimina cualquier otra caracterstica. 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 mdico veterinario. La abuela har una abstraccin fijndose en rasgos afectivos y de cuidado mientras que el veterinario lo ver como un objeto anatmicofisiolgico de estudio. Modularidad. La Modularidad es una particin funcional de todo el sistema. Cada mdulo o parte del sistema debe contar tanto con una funcionalidad clara y relativamente sencilla como con una facilidad de combinarse con otros mdulos. Condicionantes tales como limitacin de memoria, o las caractersticas de los compiladores o lenguajes particulares, inducen a la modularidad, pero el principio en la Tecnologa Orientada a Objetos, es dividir funcionalmente buscando la interrelacin ms rica entre mdulos. Una divisin temtica de los mdulos es una manera muy conveniente de equilibrar la modularizacin. De esta manera, un mdulo puede ser el de los clculos numricos mientras que otro, el de las operaciones con cadenas, o bien, un mdulo puede ser el de las variables generales y de arranque y configuracin de un sistema, Un segundo mdulo alojar las clases primitivas, de las cuales se derivarn siempre para su uso otras clases y un tercer mdulo tendr las clases que usan a las primitivas. En el caso de nuestro gato, lo veramos descompuesto en unidades funcionales. Su corazn funciona muy bien, al igual su cuello y cola, cada parte debe ensamblar perfectamente con las de su entorno para formar un gato completo. Encapsulacin 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 Mtodos y Datos. La Interfaz representa la frontera y el lugar de paso en la comunicacin del objeto con el mundo exterior.
24
El empaque conjunto de datos y mtodos se llama encapsulado. El objeto esconde sus datos de los dems objetos y permite el acceso a los datos mediante sus propios mtodos. Esto recibe el nombre de ocultamiento de informacin. El encapsulamiento evita la corrupcin 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 podran corromper o utilizar de mala manera. El encapsulado protege los datos del uso arbitrario o accidental. El encapsulado oculta los detalles de su implantacin 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 cmo se lleva a cabo la operacin. Todos los detalles especficos de los datos del objeto y la codificacin de sus operaciones estn fuera del alcance del usuario. As, encapsulado es el resultado (o acto) de ocultar los detalles de implantacin de un objeto respecto de su usuario. El encapsulado, al separar el comportamiento del objeto de su implantacin, permite la modificacin 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 podra hacer gran cosa con l. Lo que sucede es que las peticiones de informacin a un objeto deben realizarse a travs de mensajes dirigidos a l, con la orden de realizar la operacin pertinente. La respuesta a estas rdenes ser la informacin requerida, siempre que el objeto considere que quien enva el mensaje est autorizado para obtenerla. Reutilizacin. El hecho de que cada objeto sea una cpsula, facilita enormemente que un objeto determinado pueda ser transportado a otro punto de la organizacin, o incluso a otra organizacin totalmente diferente que precise de l. Si el objeto ha sido bien construido, sus mtodos seguirn funcionando en el nuevo entorno sin problemas. Esta cualidad hace que la POO sea muy apta para la reutilizacin de programas. Clase. La clase es una coleccin de objetos con caractersticas comunes. Las clases son entidades conceptuales que sirven para abstraer y modelizar un sistema. Toda clase posee 2 tipos o clases de componentes: Una esttica: los datos. Caracterizan los posibles estados que pueden adoptar los Objetos de la Clase en un instante determinado. Otra dinmica: los mtodos. Caracterizan los posibles comportamientos de los Objetos de la Clase a lo largo de su existencia.
25
Los criterios de clasificacin de una Clase son: Atributos: Variables que tomarn ciertos valores (Datos) en un estado del Objeto. Definen la estructura o componente esttica de los Objetos. Eventos: Estmulos ante los que reaccionan los Objetos cambiando de Estado. Funciones: Ante un evento, actan sobre los datos haciendo que el Objeto cambie de estado. Determinan la componente dinmica de los Objetos. As, una clase es una creacin de un tipo de objeto. Especifica una estructura de datos y los mtodos operativos permisibles que se aplican a cada uno de sus objetos. Herencia. Es una relacin transitiva entre clases, que permite a un objeto de una clase utilizar como propios los datos y mtodos definidos en otra clase. Por ejemplo: La clase cliente hereda de la clase persona sus mtodos y datos. La clase padre se suele denominar superclase. La clase hija se suele especializacin o heredada. denominar subclase, descendiente, derivada,
La Subclase consta de dos tipos de caractersticas: Estructura o comportamiento heredado de la superclase. Estructura o comportamiento propios. La subclase se especializa de las siguientes formas: Enriquecimiento: Estructura o comportamiento aadidos como propios. Ocultacin: Estructura o comportamiento heredado y anulado Sustitucin: 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 acadmico y administrativo. Existe de este modo una jerarqua 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.
26
Una subclase puede heredar la estructura de datos y los mtodos de su superclase. Tambin tiene sus propios mtodos e incluso sus propios tipos de datos. Tipos de herencia. Simple: Se hereda de una sola clase. Mltiple: Se hereda de dos o ms clases. Polimorfismo. Una de las caractersticas fundamentales de la POO es el polimorfismo, que no es otra cosa que la posibilidad de construir varios mtodos con el mismo nombre, pero con relacin 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 recibiran el mismo mensaje global pero responderan a l de formas diferentes; por ejemplo, un mensaje "+" a un objeto ENTERO significara suma, mientras que para un objeto STRING significara concatenacin. Jerarquas. Organizacin de los objetos En principio, los objetos forman siempre una organizacin jerrquica, en el sentido de que ciertos objetos son superiores a otros de cierto modo. Existen varios tipos de jerarquas: sern simples cuando su estructura pueda ser representada por medio de un "rbol". En otros casos puede ser ms compleja. En cualquier caso, sea la estructura simple o compleja, podrn distinguirse en ella 3 niveles de objetos: La raz de la jerarqua: Se trata de un objeto nico y especial. Este se caracteriza por estar en el nivel ms alto de la estructura y suele recibir un nombre muy genrico, que indica su categora especial, como por ejemplo objeto madre, raz o entidad. Los objetos intermedios: Son aquellos que descienden directamente de la raz y que a su vez tienen descendientes. Representan conjuntos o clases de objetos, que pueden ser muy generales o muy especializados, segn la aplicacin. Normalmente reciben nombres genricos 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 jerarqua es el orden por niveles de todas las abstracciones.
27
Las dos partes ms importantes de la jerarqua 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 dinmica de mensajes. La organizacin 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 categora. As al hablar de manzanas, podremos hablar de las amarillas, las rojas, o las verdes, pero en otra categora hablaremos de sus componentes, pulpa, piel, semilla, y posiblemente en una categora ms inferior de sus tejidos. Ni los tejidos sabrn a qu componente pertenecen ni los componentes a qu manzana pertenecen. La abstraccin superior no sabe de sus constituyentes nfimos y viceversa. Cada abstraccin debe connotar un nivel. Mensajes Para que un objeto haga algo, le enviamos una solicitud. Esta hace que se produzca una operacin. La operacin ejecuta el mtodo apropiado y, de manera opcional, produce una respuesta. El mensaje que constituye la solicitud contiene el nombre del objeto, el nombre de una operacin y, a veces, un grupo de parmetros. La programacin orientada a objetos es una forma de diseo modular en la que con frecuencia el mundo se piensa en trminos de objetos, operaciones, mtodos y mensajes que se transfieren entre tales objetos. Un mensaje es una solicitud para que se lleve a cabo la operacin indicada y se produzca el resultado. Los objetos pueden ser muy complejos, puesto que pueden contener muchos subobjetos, 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.
28
Capitulo 3. JAVA Y LA PROGRAMACIN ORIENTADA A OBJETOS

Introduccin. 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 Jerarquas Abstraccin Encapsulacin Ligaduras Dinmicas o Binding Mensajes. Polimorfismo o Sobrecarga Redefinicin Es un lenguaje de programacin relativamente joven, a pesar de ello, desde su aparicin hasta nuestros das, 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 aadir al lenguaje bibliotecas de clases que pueden ser fcilmente adaptadas a las necesidades del desarrollador de software. Sun Microsystems, es la empresa que ha desarrollado el lenguaje Java, en un intento de resolver simultneamente todos los problemas que se le plantean a los desarrolladores de software por la proliferacin de arquitecturas incompatibles, tanto entre las diferentes mquinas como entre los diversos sistemas operativos y sistemas de ventanas que funcionaban sobre una misma mquina, aadiendo la dificultad de crear aplicaciones distribuidas en una red como Internet. Origen de Java. Entre las leyendas ms 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 renen y toman la idea de que el futuro de la Informtica pasa porque todos los electrodomsticos y productos de consumo estn controlados por un ordenador. Muchos han colaborado en el diseo y evolucin 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.
29
Captulo 3 Java y la Programacin Orientada a Objetos.
El mercado, inicialmente previsto para los programas de FirstPerson, eran los equipos domsticos: microondas, tostadoras y, fundamentalmente, televisin interactiva. Este mercado, dada la falta de pericia de los usuarios para el manejo de estos dispositivos, requera interfases mucho ms cmodos e intuitivos que los sistemas de ventanas que proliferaban en el momento. Otros requisitos importantes a tener en cuenta eran la fiabilidad del cdigo y la facilidad de desarrollo. James Gosling, el miembro del equipo con ms experiencia en lenguajes de programacin, decidi que las ventajas aportadas por la eficiencia de C++ no compensaban el gran coste de pruebas y depuracin. James Gosling haba estado trabajando en su tiempo libre en un lenguaje de programacin que l haba llamado Oak, el cual, an 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 electrnica de consumo. La aparicin de un chip ms barato y, generalmente, ms eficiente, conduce inmediatamente a los fabricantes a incluirlo en las nuevas series de sus cadenas de produccin, por pequea 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 caractersticas de Oak y utilizarlo. El primer proyecto en que se aplic este lenguaje recibi el nombre de Proyecto Verde (Green Project) y consista en un sistema de control completo de los aparatos electrnicos y el entorno de un hogar. Para ello se construy un ordenador experimental denominado *7 (Star Seven), estamos hablando del ao 1992. El sistema presentaba una interfaz basada en la representacin de la casa de forma animada y el control se llevaba a cabo mediante una pantalla sensible al tacto. En el sistema apareca Duke, la actual mascota de Java (esa especie de pinginito 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 televisin 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 compaa de TV, Time Warner, pretende introducirse en el mercado de la televisin 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 televisin 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 nmero de usuarios de la Internet crece exponencialmente. En 1994, Bill Joy decide escribir un navegador (WebRunner, tipo Mosaic) en cdigo Oak, en principio, slo como una demo, que se convertir ms adelante en HotJava en septiembre de dicho ao. James Gosling escribe un compilador de Java. Hoffman escribe otro en Java.
30
En marzo de 1995, la versin 1.0a sale al mundo exterior y el cdigo 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 cuestin 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 direccin: http://ei.cs.vt.edu/~wwwbtb/book/chap1/java_hist.html Caractersticas de Java Es importante ver las caractersticas del lenguaje Java, para decidir si lo utilizamos o no, segn el tipo de trabajo que debemos encarar. Estas caractersticas seguramente son opinables segn el punto de vista que se las analice. Algunas de ellas son:
Tamao reducido Simplicidad Portabilidad Interpretado Distribuido Robusto Seguro Programacin concurrente y distribuida Dinmico Liberacin de memoria no utilizada Manejo de Arreglos Manejo de excepciones Analicemos estas caractersticas individualmente: Reducido: Todo el paquete de desarrollo que incluye la librera de clases, los programas de compilacin, interpretacin, depuracin, aplicaciones, Applets ejemplo, etc., ocupa aproximadamente 10 Mb en disco. Simple: Porque, prcticamente sin saber mucho de programacin, se aprende a hacer Applets y aplicaciones fcilmente; pudindose obtener resultados en poco tiempo. Java ofrece toda la funcionalidad de un lenguaje
31
potente, pero sin las caractersticas menos usadas y ms 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 rpido y fcil aprendizaje. Java elimina muchas de las caractersticas de otros lenguajes como C++, para mantener reducidas las especificaciones del lenguaje y aadir caractersticas muy tiles como el reciclador de memoria dinmica (ver explicacin detallada ms abajo). Java reduce en un 50% los errores ms comunes de programacin con lenguajes como C y C++ al eliminar muchas de las caractersticas de stos, entre las que destacan: a. aritmtica de punteros b. no existen referencias c. registros (struct) d. definicin 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 programacin. Y es un lenguaje de plataforma independiente, tanto, al nivel de cdigo fuente, como al nivel binario. Podemos escribir cdigo Java en una plataforma y marcharnos a otra con la garanta de que sta tambin entender el cdigo fuente sin necesidad de tener que rescribirlo. Por otro lado, los archivos binarios Java resultado de la ejecucin, conocidos por bytecodes, podrn ejecutarse desde cualquier plataforma sin necesidad de ninguna recompilacin. Los bytecodes equivalen a cdigo mquina pero sin ser especficos de ningn procesador. Esto es as porque para ejecutar los programas en Java se hacen dos operaciones: 1) la compilacin obteniendo los bytecodes (usando el compilador javac.exe) y 2) la interpretacin de estos desde cada plataforma con el intrprete Java (usando java.exe). El inconveniente del uso de bytecodes, como tenemos ocasin de ver cuando cargamos un Applet desde una pgina web, es la prdida de velocidad de ejecucin. Robusto, Seguro: permite la transferencia y el manejo de datos sin errores aparentes; siempre ser posible la cada 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. Adems, existen otros programas maliciosos contra los que hay que protegerse: estos programas pueden recoger informacin privada del usuario como nmeros de tarjetas de crdito, cuentas bancarias y palabras
32
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 aplicacin de red y la computadora local: cuando se carga desde el navegador de un usuario una pgina web que contiene un applet Java, no hay ningn peligro de ser infectados por un virus o a recibir intentos de accesos malintencionados. Java consigue esto creando un entorno de ejecucin aislado para ese applet, que no tiene acceso a los recursos locales de la mquina 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 simultneas en un programa. Los threads (a veces llamados, procesos ligeros o hilos), son bsicamente pequeos procesos o piezas independientes de un gran proceso. Al estar los threads construidos en el lenguaje, son ms fciles de usar y ms robustos que sus homlogos 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.), an 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 visualizacin 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 informacin en la pgina sin tener que esperar por el navegador. Distribuido: Java se ha construido con extensas capacidades de interconexin TCP/IP (Transmission Control Protocol/Internet Protocol). Existen libreras de rutinas para acceder e interactuar con protocolos como http y ftp. Esto permite a los programadores acceder a la informacin a travs de la red con tanta facilidad como a los ficheros locales. Java en s no es distribudo, sino que proporciona las libreras y herramientas para que los programas puedan ser distribuidos, es decir, que se ejecuten en varias mquinas, interactuando. Como ejemplo, Java tambin tiene la posibilidad de que los objetos puedan ejecutar procedimientos remotos; esta facilidad se llama RMI (Remote Method Invocation). Esto le aporta ms caractersticas del modelo cliente/servidor. Dinmico: por su capacidad de interactuar con el usuario, Java se beneficia todo lo posible de la tecnologa orientada a objetos. Java no intenta conectar todos los mdulos que comprenden una aplicacin hasta el tiempo de ejecucin. Las libreras nuevas o actualizadas no paralizarn 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.
33
Java tambin simplifica el uso de protocolos nuevos o actualizados. Si nuestro ejecuta una aplicacin Java sobre la red y encuentra una pieza de la aplicacin que no sabe manejar, es capaz de traer automticamente cualquiera de esas piezas que el sistema necesita para funcionar, desde el servidor remoto.
Java, para evitar tener que ir descargando mdulos de byte-codes, objetos o nuevas clases, implementa las opciones de persistencia, para que no se eliminen cuando se limpie la cach de la mquina. Administrador de Memoria: Es una tarea de la cual el programador no debe preocuparse. Java elimina muchas de las caractersticas de otros lenguajes como C++, para mantener reducidas las especificaciones del lenguaje y aadir caractersticas muy tiles como el garbage collector (reciclador de memoria dinmica). No es necesario preocuparse de liberar memoria, el reciclador se encarga de ello y como es un thread de baja prioridad, cuando entra en accin, permite liberar bloques de memoria muy grandes, lo que reduce la fragmentacin de la memoria. Administrador de Arreglos: Posee un eficiente sistema de administracin de arreglos (array), que permite almacenar gran cantidad de datos en
34
memoria, con un acceso directo a ellos. Implementa los arrays autnticos, en vez de listas enlazadas de punteros, con comprobacin de lmites, para evitar la posibilidad de sobreescribir o corromper memoria resultado de punteros que sealan a zonas equivocadas. Excepciones: Se dispone de una buena batera de mtodos que controlan los posibles errores que pudiesen ocurrir durante la ejecucin del programa, los que evitan, estando bien utilizados, que el programa cancele su ejecucin. Una excepcin es una condicin anormal que surge en una secuencia de cdigo durante la ejecucin de un programa. Es decir, es un "error de ejecucin". En los lenguajes de programacin que no tienen gestin de excepciones, hay que controlar los posibles errores de ejecucin del programa manualmente, usando cdigos de error. Sin embargo, Java posee gestin de excepciones, y lleva el problema de la gestin del error en tiempo de ejecucin al mundo orientado a objetos. En Java, cuando surge una condicin excepcional, se crea un objeto que representa la excepcin y se enva al mtodo que provoc esta excepcin. Este mtodo puede elegir gestionar la excepcin l mismo o pasarla. Pero en algn punto, la excepcin es capturada y procesada. Las excepciones pueden ser generadas por el intrprete de Java o pueden ser generadas por el propio cdigo. Las excepciones generadas por Java estn relacionadas con errores que violan las reglas del lenguaje Java o las restricciones del entorno de ejecucin de Java. Las excepciones generadas manualmente se suelen utilizar para informar de algn error al mtodo llamante.
35
Captulo 4 Conceptos de Orientacin a Objetos.
Capitulo 4. PROFUNDIZANDO CONCEPTOS DE POO EJEMPLOS CON JAVA

En este captulo se analizarn los siguientes conceptos de la POO, pero aplicados a ejemplos bsicos utilizando el lenguaje de programacin JAVA. 1. Herencia 2. Sobrescritura de mtodos 3. La clase base y la clase derivada 4. Redefinicin de Mtodos Heredados 5. Clases y Mtodos Abstractos 6. Sobrecarga/Polimorfismos 7. Ligaduras Dinmicas Binding 8. Redefinicin 9. Interfases 10. Permisos de Accesos 11. Transformaciones de tipos Casting 12. Sincronizacin 1. Herencia. La herencia, concepto ya creado por Dahl y Nygaar en 1965, es una propiedad esencial de la Programacin Orientada a Objetos que consiste en la creacin 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 clasificacin jerrquica. Si no se hiciera una clasificacin jerrquica de los objetos, cada objeto debera definir todas sus caractersticas explcitamente, y esto no sera viable. Sin embargo, utilizando la herencia, un objeto puede heredar sus atributos generales de otro objeto (su padre), y definir explcitamente slo 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 especfica de un caso ms 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 podra definir otra clase para describir a los mamferos. La clase "mamferos" heredara todos los atributos de la clase "animales", pero adems definira una serie de atributos especficos de los mamferos, como el tipo de dientes, o las glndulas mamarias. En este caso, la clase "mamferos" es subclase de "animales", y la clase "animales" es superclase de "mamferos". Una subclase hereda todos los atributos de cada uno de sus antecesores en la jerarqua de clases. Esta caracterstica permite a los programas orientados a objetos crecer en complejidad de manera lineal en vez de geomtrica.
37
La herencia es la caracterstica 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 jerrquicas. 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 declaracin de la clase B sera as:
class B extends A { // variables de instancia // mtodos }

As, la clase B hereda todas las variables de instancia y mtodos de la clase A, y adems define sus propias variables de instancia y mtodos. Pero hay una excepcin: una subclase no puede acceder a aquellos miembros de la superclase que han sido declarados como private. 2. Sobrescritura de mtodos. En una jerarqua de clases, cuando un mtodo de una subclase tiene el mismo nombre y tipo que un mtodo de su superclase, entonces se dice que el mtodo de la subclase sobrescribe al mtodo de la superclase. Y cuando se llama a un mtodo sobrescrito dentro de una subclase, siempre se refiere a la versin del mtodo definida en la subclase. La versin del mtodo definida por la superclase est oculta. Y la llamada a una funcin sobrescrita se resuelve en tiempo de ejecucin, en lugar de durante la compilacin; esto se denomina seleccin de mtodo dinmica. La seleccin de mtodo dinmica es la forma que tiene Java de implementar el polimorfismo durante la ejecucin. As, combinando la herencia con la sobrescritura de mtodos, una superclase puede definir la forma general de los mtodos que sern utilizados por todas sus subclases. Por otra parte, este polimorfismo dinmico es uno de los mecanismos ms poderosos que ofrece el diseo orientado a objetos para soportar la reutilizacin del cdigo y la robustez. 3. La clase base y la clase derivada. La herencia ofrece una ventaja importante, permite la reutilizacin del cdigo. Una vez que una clase ha sido depurada y probada, el cdigo 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 aada otros comportamientos.
38
La programacin en los entornos grficos, 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, mens, etc. Una de estas clases denominada TWindow describe el aspecto y la conducta de una ventana, tiene una funcin 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 funcin Paint para que dibuje una figura. Aprovechamos de este modo la ingente cantidad y complejidad del cdigo necesario para crear una ventana en un entorno grfico. Solamente, tendremos que aadir en la clase derivada el cdigo necesario para dibujar un rectngulo, una elipse, etc. La base de la POO fue este tipo de programacin, en entornos de ventanas, de hecho SmallTalk se hizo para eso. En el lenguaje Java, todas las clases derivan implcitamente de la clase base Object, por lo que heredan las funciones miembro definidas en dicha clase. En Java disponemos de los paquetes bsicos:
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 grfica, 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 tpicas ocasiones en las que nos vemos obligados a crear clases bases son, por ejemplo: En la fase de anlisis, nos damos cuenta que diversos tipos de datos tienen algo en comn, 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.
39
En otra ocasin, precisamos ampliar la funcionalidad de un programa, sin tener que modificar el cdigo existente. Ejemplos de aplicacin 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 utilizacin de libreras de clases para crear una interfase grfica 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 ttulo en la parte superior, por lo tanto no puede desplazarse, pero si cambiar de tamao actuando con el ratn en los bordes derecho e inferior. La clase Ventana tendr las siguientes variables miembros: la posicin 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 inicializacin necesarias. No tiene valor de retorno. Las funciones miembro, adems del constructor sern las siguientes: la funcin mostrar que simula una ventana en un entorno grfico, aqu solamente nos muestra la posicin y las dimensiones de la ventana.
public void mostrar(){ System.out.println("posicin : x
=" + x + ", y
40
=" + y); System.out.println("dimensiones: ancho =" + ancho + ", alto =" + alto); }
La funcin 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 cdigo, 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 instanciacin (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 pblicas
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 tendrn todas las caractersticas de los objetos de la clase base, pero adems tendrn un ttulo, y se podrn desplazar (se simula el desplazamiento de una ventana con el ratn). La clase derivada heredar las variables miembros de la clase base y las funciones miembro, y tendr una variable miembro ms, el ttulo 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.
41
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 continuacin, se inicializan las variables miembros de la clase derivada, y se realizan las tareas de inicializacin que sean necesarias. Si no se llama explcitamente al constructor de la clase base Java lo realiza por nosotros, llamando al constructor por defecto si existe. La funcin miembro denominada desplazar cambia la posicin de la ventana, aadindole el desplazamiento.
public void desplazar(int dx, int dy){ x+=dx; y+=dy; }

Ahora redefinimos la funcin miembro mostrar para mostrar una ventana con un ttulo.
public void mostrar(){ super.mostrar(); System.out.println("titulo }
: "+titulo);
En la clase derivada se define una funcin que tiene el mismo nombre y los mismos parmetros que la de la clase base. (redefinimos la funcin mostrar en la clase derivada). La funcin miembro mostrar de la clase derivada VentanaTitulo hace una llamada a la funcin mostrar de la clase base Ventana, mediante
super.mostrar();
De este modo aprovechamos el cdigo ya escrito, y le aadimos el cdigo que describe la nueva funcionalidad de la ventana (por ejemplo, que muestre el ttulo). Si nos olvidamos de poner la palabra reservada super llamando a la funcin mostrar, tendramos una funcin recursiva. (La funcin mostrar llamara a mostrar indefinidamente.)
public void mostrar(){ //ojo!,funcin recursiva System.out.println("titulo : "+titulo); mostrar(); }

Objetos de la clase derivada.
42
Creamos un objeto ventana de la clase derivada VentanaTitulo
VentanaTitulo ventana=new VentanaTitulo(0, 0, 20, 30, "Principal");

Mostramos la ventana con su ttulo, llamando a la funcin 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 tamao 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 funcin miembro desplazar accede a dichas variables miembros
public class VentanaTitulo extends Ventana{ //... public void desplazar(int dx, int dy){ x+=dx; y+=dy; } }
43
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 podran ser utilizados por alguna funcin miembro de otra clase derivada de VentanaTitulo. Dentro de una jerarqua 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 mtodos: 1. private, las variables y mtodos de instancia privados slo pueden ser accedidos desde dentro de la clase. No son accesibles desde las subclases. 2. protected, slo las subclases de la clase y nadie ms, puede acceder a las variables y mtodos de instancia protegidos 3. public, cualquier clase desde cualquier lugar puede acceder a las variables y mtodos de instancia pblicos 4. friendly, por defecto, si no se especifica el control de acceso, las variables y mtodos 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 Si No Si Si Accesible Si No Si Si
Default Private Protected Public

Clases en distintos paquetes: Modificador de acceso
Heredado No No Si Si
Accesible No No No Si
Default Private Protected Public
44
Desde el punto de vista prctico, cabe resear que no se heredan los miembros privados, ni aquellos miembros (dato o funcin) cuyo nombre sea el mismo en la clase base y en la clase derivada. La clase base object. La clase Object es la clase raz de la cual derivan todas las clases. Esta derivacin es implcita. La clase Object define una serie de funciones miembro que heredan todas las clases. Las ms 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... }
Mtodos que pueden ser redefinidos por el programador. Igualdad de dos Objetos: El mtodo equals de la clase Object compara dos objetos uno que llama a la funcin y otro es el argumento de dicha funcin.
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 parmetro es igual al objeto actual. Esta implementacin comprueba si ambas referencias son iguales. Podemos simplificar la consulta utilizando el operador = = (igualdad). Las distintas clases de la librera de Java suelen sobrescribirlo para comprobar si los contenidos de la instancia son los mismos.
45
Por ejemplo, cuando String sobrescribe este mtodo compara si las cadenas contenidas en ambas instancias son iguales. Representacin en forma de texto de un objeto: El mtodo toString() devuelve un String que contiene una representacin del objeto como cadena de caracteres, por ejemplo para imprimirlo o exportarlo. El mtodo toString imprime por defecto el nombre de la clase a la que pertenece el objeto y su cdigo (hash). Esta funcin miembro se redefine en la clase derivada para mostrar la informacin que nos interese acerca del objeto. La funcin toString se llama automticamente siempre que pongamos un objeto como argumento de la funcin System.out.println o concatenado con otro string.
public String toString() { return getClass().getName() + "@" + Integer.toHexString(hashCode()); }

Entonces: String objeto.toString()devuelve una representacin del objeto en formato de cadena de caracteres, es llamado automticamente por Java cuando necesita convertir el objeto en cadena. Esta implementacin devuelve una cadena que contiene el nombre de la clase del objeto, seguido de una arroba y del cdigo hash del mismo. Duplicacin de objetos: El mtodo clone crea un objeto duplicado (clnico) de otro objeto, es decir, clone() crea un objeto a partir de otro objeto de la misma clase. El mtodo original heredado de Object lanza una
CloneNotSupportedException.
Si se desea clonar una clase hay que implementar la interfase Cloneable y redefinir el mtodo clone(). Este mtodo debe hacer una copia miembro a miembro del objeto original. No debera llamar al operador new ni a los constructores. Entonces: Object objeto.clone() copia el objeto. La intencin 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.
46
Finalizacin: El mtodo 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 mtodo 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 estn cerrados cuando dicho objeto desaparece, entonces sera acertado el utilizar la finalizacin para asegurar que los recursos se liberan. Es similar a los destructores de C++. La forma en la que se redefine este mtodo es el siguiente.
class CualquierClase{ //.. protected void finalize() trows Throwable{ super.finalize(); //cdigo que libera recursos externos } }
La primera sentencia que contenga la redefinicin de finalize ha de ser una llamada a la funcin del mismo nombre de la clase base, y a continuacin le aadimos cierta funcionalidad, habitualmente, la liberacin de recursos, cerrar un archivo, etc. Entonces: void objeto.finalize()es llamado por el recolector de basura antes de eliminar el objeto. Esta implementacin no hace nada, debe ser el programador el que sobreescriba este mtodo en caso de que quiera realizar algo en especial antes de eliminar el objeto de la memoria. Mtodos que NO pueden ser Redefinidos:
getClass() devuelve un objeto de la clase class, al cual se le pueden aplicar mtodos 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 cdigo Hash del objeto. Este cdigo se utiliza para las tablas Hash, que son la manera ms eficiente de almacenar objetos. Para que dichas tablas funcionen necesitan que cada objeto almacenado tenga un cdigo numrico que se mantenga durante toda la ejecucin del
47
programa y que sea el mismo para dos objetos si dichos objeto son iguales segn el mtodo equals(). Un ejemplo sera, para las cadenas, devolver la longitud de la misma.
notify(), notifyAll() wait()

Concretando:
Son mtodos relacionados con las threads
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 mtodos. Estas funciones y variables miembro pueden ser redefinidas (overridden) en la clase derivada, que puede tambin definir o aadir nuevas variables y mtodos. En cierta forma es como si la sub-clase (la clase derivada) contuviera un objeto de la super-clase; en realidad lo ampla con nuevas variables y mtodos. Java permite mltiples niveles de herencia, pero no permite que una clase derive de varias (no es posible la herencia mltiple). 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 explcitamente una super-clase con la palabra extends, la clase deriva de java.lang.Object, que es la clase raz de toda la jerarqua de clases de Java. Como consecuencia, todas las clases tienen algunos mtodos que han heredado de Object. 4. Redefinicin de mtodos heredados Una clase puede redefinir cualquiera de los mtodos heredados de su super-clase que no sean final. El nuevo mtodo sustituye al heredado para todos los efectos en la clase que lo ha redefinido. Los mtodos de la super-clase que han sido redefinidos pueden ser todava accedidos por medio de la palabra super desde los mtodos de la clase derivada, aunque con este sistema slo se puede subir un nivel en la jerarqua de clases.
48
Los mtodos 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 mtodos de clase static no pueden ser redefinidos en las clases derivadas. Modificador final: Si declaramos un mtodo como final, indicaremos que no puede ser sobreescrito en clases heredadas, por lo que mantendr su implementacin. 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 ms 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 mtodos 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, proporcionndoles un marco o modelo que deben seguir y algunos mtodos de utilidad general. Las clases abstractas se declaran anteponindoles la palabra abstract, por ejemplo:
public abstract class NombreClase { ... }

Una clase abstract puede tener mtodos declarados como abstract, en cuyo caso no se da definicin del mtodo. Si una clase tiene algn mtodo abstract es obligatorio que la clase sea abstract. En cualquier sub-clase este mtodo deber ser redefinido o volver a declararse como abstract (el mtodo y la sub-clase). Una clase abstract puede tener mtodos que no son abstract. Aunque no se puedan crear objetos de esta clase, sus sub-clases heredarn el mtodo completamente a punto para ser utilizado. Debemos tener en cuenta que como los mtodos static no pueden ser redefinidos, un mtodo abstract no puede ser static. 6. Polimorfismo Esta palabra que significa "muchas formas", es una caracterstica del lenguaje Java que permite a una interfase ser usada por una clase general de acciones. En
49
trminos ms generales, el concepto de polimorfismo a menudo se expresa por la frase "una interfaz, mltiples mtodos". Esto significa que es posible disear una interfaz genrica para un grupo de actividades relacionadas. Es evidente que esta forma de trabajar ayuda a reducir la complejidad del diseo, pues permite usar una misma interfaz para especificar un conjunto de acciones similares. Ser el compilador el que tendr que seleccionar la accin concreta (esto es, el mtodo) para aplicar en cada situacin. Como programadores, nosotros slo tenemos que conocer la interfaz general. Ms detalladamente, funciona as: cuando se llama a un mtodo, el cdigo generado por el compilador consulta una tabla oculta de punteros a funciones que dispone cada clase. La direccin de la funcin llamada no se asigna en tiempo de compilacin como ocurre con el enlace esttico del C sino que se obtiene la direccin de la funcin llamada justo en el momento antes de ejecutarse. Repasando, el polimorfismo consiste en poder definir mtodos con la misma firma (nombre del mtodo ms argumentos) en diferentes niveles de la jerarqua de clases, y, que durante la ejecucin el programa, sepa discernir a qu mtodo llamar en cada caso. Podemos entender el sobrepaso fcilmente con un modelo simplificado. Durante la ejecucin, 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 mtodo 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 compilacin 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 bsica 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(parmetros); objeto2= new ClaseHija2(parmetros);

Anlogamente 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 (parmetros); objeto2= new Clase2 (parmetros);
Es decir, permite tratar de un modo unificado objetos distintos, aunque pertenecientes a distintas sub-clases o bien a clases que implementan dicha interfase.
50
El polimorfismo tiene que ver con la relacin que se establece entre la llamada a un mtodo y el cdigo que efectivamente se asocia con dicha llamada. A esta relacin se llama vinculacin o ligadura (binding). 7. Vinculacin, Ligadura o Binding. La vinculacin puede ser: temprana (en tiempo de compilacin) tarda (en tiempo de ejecucin). Con funciones normales o sobrecargadas se utiliza generalmente vinculacin temprana. Con funciones redefinidas se utiliza siempre vinculacin tarda, excepto si el mtodo es final. La vinculacin tarda hace posible que, con un mtodo 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 definicin del mtodo se va a utilizar. El tipo del objeto al que apunta una referencia slo puede conocerse en tiempo de ejecucin, y por eso el polimorfismo necesita evaluacin tarda. El polimorfismo permite a los programadores separar las cosas que cambian de las que no cambian, y de esta manera hacer ms fcil la ampliacin, el mantenimiento y la reutilizacin de los programas. El polimorfismo puede hacerse con referencias de super-clases abstractas, superclases normales, e interfases. Las interfases permiten ampliar muchsimo las posibilidades del polimorfismo por su mayor flexibilidad y por su independencia de la jerarqua de clases estndar. Conversin de objetos El polimorfismo visto previamente est basado en utilizar referencias de un tipo ms amplio que los objetos a los que apuntan. Las ventajas del polimorfismo son evidentes, pero hay una importante limitacin: el tipo de la referencia (clase abstracta, clase base o interfase) limita los mtodos 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 slo en el caso en que su clase o una de sus super-clases implementen dicha interfase. Un objeto cuya referencia es un tipo interfase slo puede utilizar los mtodos definidos en dicha interfase. Dicho de otro modo, ese objeto no puede utilizar las variables y los mtodos 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 mtodos y acceder a todas las variables que la clase de un objeto permite, hay que utilizar un cast (lanzamiento) explcito, que convierta su
51
referencia ms general en la del tipo especfico del objeto. De aqu una parte importante del inters del cast entre objetos (ms bien entre referencias). Para la conversin entre objetos de distintas clases, Java exige que dichas clases estn relacionadas por herencia (una deber ser subclase de la otra). Se realiza una conversin implcita o automtica de una subclase a una superclase siempre que se necesite, ya que el objeto de la subclase siempre tiene toda la informacin necesaria para ser utilizado en lugar de un objeto de la superclase. La conversin en sentido contrario debe hacerse de modo explcito y puede producir errores por falta de informacin o de mtodos. Si falta informacin, se obtiene una ClassCastException. No se puede acceder a las variables exclusivas de la sub-clase a travs de una referencia de la super-clase. Slo se pueden utilizar los mtodos definidos en la super-clase, aunque la definicin utilizada para dichos mtodos sea la de la sub-clase. Por ejemplo, supngase 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 ms informacin de la que la referencia a le permite acceder (podra ser, por ejemplo, una nueva variable miembro j declarada en B). Para acceder a esta informacin adicional hay que hacer un cast explcito 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 mtodosde la super-clase, aunque estn redefinidos en la sub-clase. Considrese 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 cdigo de la sub-clase C se utiliza:
x this.x super.x ((B)this).x ((A)this).x
// // // // // //
se accede a la se accede a la se accede a la subir un nivel se accede a la se accede a la
x de C x de C x de B. Slo se puede x de B x de A
Mtodos (funciones miembro). Los mtodos son funciones definidas dentro de una clase. Salvo los mtodos static o de clase, se aplican siempre a un objeto de la clase por medio del operador punto (.). Dicho objeto es su argumento implcito. Los mtodos pueden adems tener otros argumentos explcitos que van entre parntesis, a continuacin del nombre del mtodo.
52
La primera lnea de la definicin de un mtodo se llama declaracin (header), y el cdigo comprendido entre las llaves {} es el cuerpo (body) del mtodo.
public Float mtodo() { // header y comienzo del mtodo sentencias // body o cuerpo return valor } // final del mtodo
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 funcin y de una lista de argumentos explcitos entre parntesis, separados por comas. Si no hay argumentos explcitos se dejan los parntesis vacos. Los mtodos tienen visibilidad directa de las variables miembro del objeto que es su argumento implcito, es decir, pueden acceder a ellas sin cualificarlas con un nombre de objeto y el operador punto. De todas formas, tambin 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 ms que un nico valor de retorno (que puede ser un objeto o un arreglo). Se puede devolver tambin 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 mtodo o de una sub-clase, pero nunca de una superclase. Los mtodos pueden definir variables locales. Su visibilidad llega desde la definicin 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 mtodo se incluye la palabra native
public native void metodo();

no hay que incluir el cdigo o implementacin del mtodo. Este cdigo deber estar en una librera dinmica (Dynamic Link Library o DLL). Estas libreras 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 cdigo escrito en Java. Un mtodo tambin puede declararse como synchronized
public synchronized double metodo(){...}
53
Estos mtodos tienen la particularidad de que sobre un objeto no pueden ejecutarse simultneamente dos mtodos que estn sincronizados. Mtodos sobrecargados (overloaded) Otra de las ventajas de este lenguaje de programacin es que nos permite definir dos o ms mtodos dentro de la misma clase con el mismo nombre, siempre que la declaracin de sus parmetros sea diferente. En este caso se dice que el mtodo est sobrecargado y el proceso de definir un mtodo as se conoce como sobrecarga del mtodo. La sobrecarga de mtodos es una de las maneras en que Java implementa el polimorfismo. Cuando se llama a un mtodo sobrecargado, el compilador acta justo sobre la versin cuyo tipo de parmetros coincida con los de la llamada. As, se podra 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 sera necesario definir el mtodo suma() para todos los tipos de datos, pues aqu tambin interviene el casting implcito que hace Java. Por ejemplo, una suma de float, llamara automticamente al mtodo que devuelve double siempre y cuando no est definido el mtodo que devuelve float, claro est. No existe una regla exacta para saber si un mtodo 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 mtodos que estn intrnsicamente relacionados, como es el caso del ejemplo anterior pero no nos debemos confundir. Por ejemplo, el mtodo sqrt(), aunque se llama igual, calcula de forma totalmente diferente la raz cuadrada de un nmero entero que la de uno de punto flotante. Aqu, aunque aplicramos sobrecarga al mtodo, realmente no estaramos respetando el propsito para el que se cre el polimorfismo. Hemos expuesto que al igual que C++, Java permite mtodos sobrecargados (overloaded), es decir, mtodos distintos que tienen el mismo nombre, pero que se diferencian por el nmero y/o tipo de los argumentos. A la hora de llamar a un mtodo sobrecargado, Java sigue las siguientes reglas para determinar el mtodo concreto que debe llamar: 1. Si existe el mtodo cuyos argumentos se ajustan exactamente al tipo de los argumentos de la llamada (argumentos actuales), se llama ese mtodo.
54
2. Si no existe un mtodo 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 mtodo correspondiente. 3. Si slo existen mtodos con argumentos de un tipo ms restringido (por ejemplo, int en vez de long), el programador debe hacer un cast explcito en la llamada. 4. El valor de retorno no influye en la eleccin del mtodo sobrecargado. En realidad es imposible saber desde el propio mtodo lo que se va a hacer con l. No es posible crear dos mtodos sobrecargados, es decir con el mismo nombre, que slo difieran en el valor de retorno. 8. Redefinicin Una clase puede redefinir (override) un mtodo heredado de una superclase. Redefinir un mtodo es dar una nueva definicin. En este caso el mtodo debe tener exactamente los mismos argumentos en tipo y nmero que el mtodo redefinido. Una sugerencia importante es que la redefinicin 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 mnimo se debera tener en cuenta que podra no pasrsele parmetros al constructor, cuando ste lo espera, debido a un fallo en alguna otra parte de la aplicacin (me refiero a cualquier otra clase que llame a sta). Es por ello que siempre es recomendable definir al menos dos constructores: el especfico de la aplicacin que estemos diseando y el "estndar". Veamos un ejemplo:
class Caja { double ancho; double alto; double profundidad; // El siguiente es el constructor especfico Caja(double w, double h, double d) { ancho = w; alto = h; profundidad = d; } // pero podra ser que no le llegarn parmetros // por fallar la otra clase (mtodo) que lo // invoque
55
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 parmetros Adems de usar los tipos primitivos como parmetros, en Java es perfectamente posible pasar a un mtodo, un objeto como parmetro.
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 mtodo equals() de Comparar comprueba si dos objetos son idnticos. Paso de argumentos. Existen dos formas de pasar un argumento a una rutina: Por valor: El mtodo copia el valor de un argumento en el parmetro formal de la rutina. Por referencia: El mtodo copia el objeto en el parmetro formal de la rutina.
56
En el primer caso, al ser solo una copia, cualquier modificacin dentro de la rutina de ese valor no tendr efecto una vez fuera de ste, mientras que si es por referencia, s persistir la modificacin hecha, an 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 parmetro 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 mtodo, el parmetro 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 afectarn tambin 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 slo 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 especfica. 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 ningn objeto. Se puede declarar tanto los mtodos como las variables como static. El ejemplo ms 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 (tambin llamadas "de clase") son, esencialmente, variables globales. Cuando creamos objetos especficos 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 tambin el nombre de cualquier objeto), porque de esta forma queda ms 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 mtodo 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.
57
Los mtodos static. Tambin llamados "de clase", pueden recibir objetos de su clase como argumentos explcitos, pero no tienen argumento implcito ni pueden utilizar la referencia this. Para llamar a estos mtodos se suele emplear el nombre de la clase, en vez del nombre de un objeto de la clase. Los mtodos y variables de clase son lo ms parecido que Java tiene a las funciones y variables globales de C/C++. Las restricciones que tiene un mtodo static son: Solo pueden llamar otro mtodo static Solo deben acceder a datos static No se pueden referir a this o super de ninguna manera Si se necesita hacer algn tipo de computacin para inicializar las variables static, se puede declarar tambin 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 esttico inicializado"); b = a * 4; // vemos que, aunque declarada como static // b se inicializa en tiempo de ejecucin } 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 esttico y, por ltimo, b se inicializa al valor asignado. En resumen podemos decir para los miembros de tipo static: Miembros (mtodos o atributos) implementados al nivel de clase Desde mtodos static la referencia this no tiene sentido No se puede acceder a miembros no estticos desde mtodos estticos static: Semntica de "mbito global" Permite desarrollo de cdigo sin usar POO
58
El operador final Al declarar una variable como final, se previene que su contenido sea modificado. No obstante, Java permite separar la definicin de la inicializacin. Esta ltima se puede hacer ms tarde, en tiempo de ejecucin, llamando a mtodos o en funcin 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 cmo haya sido inicializada. Esto es lo ms parecido a las constantes de otros lenguajes de programacin.
final float PI = 3.1416; //Segn la convencin de // cdigo las variables "constantes" se ponen en // maysculas.
Aunque bsicamente este operador se emplea para crear constantes en Java, tambin podemos definir una clase o un mtodo 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 mtodos no van a ser redefinidos puede hacer optimizaciones adicionales. Un mtodo final no puede ser redefinido por una clase que derive de su propia clase. 9. Interfases. Una interfase es un conjunto de declaraciones de mtodos (sin definicin). Tambin puede definir constantes, que son implcitamente public, static y final, y deben siempre inicializarse en la declaracin. Todas las clases que implementan una determinada interfase estn obligadas a proporcionar una definicin de los mtodos 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 ms interfases se ponen los nombres de las interfases, separados por comas, detrs 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 comn que pueden contener varias declaraciones de mtodos (la clase abstract puede adems definirlos). A pesar de esta semejanza, que hace que en
59
algunas ocasiones se pueda sustituir una por otra, existen tambin 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 ms interfases. Una clase no puede heredar mtodos -definidos- de una interfase, aunque s constantes. Las interfases permiten mucha ms flexibilidad para conseguir que dos clases tengan el mismo comportamiento, independientemente de su situacin en la jerarqua de clases de Java. Las interfases permiten publicar el comportamiento de una clase develando un mnimo de informacin. Las interfases tienen una jerarqua propia, independiente y ms flexible que la de las clases, ya que tienen permitida la herencia mltiple. De cara al polimorfismo las referencias de un tipo interfase se pueden utilizar de modo similar a las clases abstract. Definicin 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 tambin con mayscula. Las interfases no admiten ms que los modificadores de acceso public y package. Si la interfase no es public no ser accesible desde fuera del
package.
Los mtodos declarados en una interfase son siempre package y abstract, de modo implcito. Utilizacin de interfases Las constantes definidas en una interfase se pueden utilizar en cualquier clase (aunque no implemente la interfase) precedindolas del nombre de la interfase
area = 2.0*NombreInterface.var*r;
60
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 simblicas 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 mtodos de la interfase. Un objeto de ese tipo puede tambin ser utilizado como valor de retorno o como argumento de un mtodo. 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 dnde est guardado un objeto en la memoria del ordenador La llamada a super. Referencia a la superclase de la que desciende la clase actual Reutilizacin de cdigo por medio de herencia o Super invoca al comportamiento anterior. o Se puede aadir comportamiento adicional Implcita en constructores como primera instruccin En mtodos: super.nombre_metodo() 10. Permisos de acceso en java. Una de las caractersticas de la POO es la encapsulacin, que consiste bsicamente en ocultar la informacin 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 conexin fsica 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 estn en un ordenador accesible y se tiene permiso de lectura). Adems de la propia conexin fsica, sern 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 dems clases del paquete, tanto si es public como si no lo es.
61
Una clase public es accesible para cualquier otra clase (siempre que su paquete sea accesible). Recurdese que las clases e interfases slo pueden ser public o paquete (la opcin por defecto cuando no se pone ningn modificador). Accesibilidad de las Variables y Mtodos Miembros de una Clase. Desde dentro de la propia clase: Todos los miembros de una clase son directamente accesibles (sin calificar con ningn nombre o calificando con la referencia this) desde dentro de la propia clase. Los mtodos no necesitan que las variables miembro sean pasadas como argumento. Los miembros private de una clase slo son accesibles para la propia clase. Si el constructor de una clase es private, slo un mtodo static de la propia clase puede crear objetos. Desde una sub-clase. Las sub-clases heredan los miembros private de su super-clase, pero slo pueden acceder a ellos a travs de mtodos 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 dems clases del package. Desde otras clases fuera del paquete (package). Los mtodos y variables son accesibles si la clase es public y el miembro es public. Tambin 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 Desde la propia clase Desde otra clase en el propio package Desde otra clase fuera del package Desde una sub-clase en el propio package Desde una sub-clase fuera del propio package public Si Si S S Si protected Si Si No S Si private Si No No No No package Si Si No Si No
62
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 conversin debe hacerse entre objetos de clases diferentes, aunque relacionadas mediante la herencia. Explicaremos ahora estas transformaciones de tipo. Conversin de tipos primitivos. Casting Implcito: La conversin entre tipos primitivos es ms sencilla. En Java se realizan de modo automtico conversiones implcitas de un tipo a otro de ms precisin, por ejemplo de int a long, de float a double, etc. Estas conversiones se hacen al mezclar variables de distintos tipos en expresiones matemticas o al ejecutar sentencias de asignacin en las que el miembro izquierdo tiene un tipo distinto (ms amplio) que el resultado de evaluar el miembro derecho. Casting Explcito (Operador Cast): Las conversiones de un tipo de mayor a otro de menor precisin requieren una orden explcita del programador, pues son conversiones inseguras que pueden dar lugar a errores (por ejemplo, para pasar a short un nmero almacenado como int, hay que estar seguro de que puede ser representado con el nmero de cifras binarias de short). A estas conversiones explcitas de tipo se les llama cast. El cast se hace poniendo el tipo al que se desea transformar entre parntesis, como por ejemplo,
long result; result = (long) (a/(b+c));

12. Sincronizacin de threads (hilos). La sincronizacin nace de la necesidad de evitar que dos o ms 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 producira una situacin no deseada. Otra situacin en la que hay que sincronizar threads se produce cuando un thread debe esperar a que estn preparados los datos que le debe suministrar el otro thread.
63
Captulo 5 Implementacin de los conceptos de OO con JAVA
Captulo 5. IMPLEMENTACIN DE LOS CONCEPTOS DE OO CON JAVA

En este captulo se propone fijar los conceptos aprendidos, pero a travs de programas de aplicacin que utilicen cada uno de ellos. Implementado el concepto Jerarqua Los temas a implementar son: La Jerarqua de Clases La jerarqua de clases que describen las figuras planas Consideremos las figuras planas cerradas como el rectngulo y el crculo. Tales figuras comparten caractersticas comunes, tales como, la posicin de la figura, de su centro y el rea de la figura, aunque el procedimiento para calcular el rea sea completamente distinto. Podemos entonces, disear una jerarqua de clases, tal que la clase base denominada Figura, tenga las caractersticas comunes y cada clase derivada las especficas. La relacin jerrquica se muestra en la figura siguiente:
Figura
Circulo
Rectngulo
La clase Figura es la que contiene las caractersticas 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 funcin 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 caractersticas comunes a todas las piezas, como es su posicin en el tablero, y derivar de ella las caractersticas especficas de cada pieza particular. As pues, la clase Pieza ser una clase abstracta con una funcin abstract denominada mover, y cada tipo de pieza definir dicha funcin de acuerdo a las reglas de su movimiento sobre el tablero.
65
La clase Figura La definicin de la clase abstracta Figura, contiene la posicin x e y de la figura particular, de su centro, y la funcin 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 Rectngulo Las clases derivadas heredan los miembros dato x e y de la clase base, y definen la funcin area, declarada abstract en la clase base Figura, ya que cada figura particular tiene una frmula distinta para calcular su rea. Por ejemplo, la clase derivada Rectangulo, tiene como datos, aparte de su posicin (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. Despus inicializa sus miembros dato ancho y alto. En la definicin de la funcin area, se calcula el rea del rectngulo como producto de la anchura por la altura, y se devuelve el resultado
66
La clase Crculo
class Circulo extends Figura { protected double radio; public Circulo(int x, int y, double radio){ super(x,y); this.radio=radio; } public double area(){ 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 Crculo. En la definicin de la funcin area, se calcula el rea del crculo mediante la conocida frmula p*r2, o bien p*r*r. La constante Math.PI es una aproximacin decimal del nmero irracional pi. Uso de la jerarqua de clases. Creamos un objeto c de la clase Crculo 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 crculo "+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 rectngulo "+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).
67
Figura f=new Circulo(0, 0, 5.5); System.out.println("Area del crculo "+f.area()); f=new Rectangulo(0, 0, 5.5, 2.0); System.out.println("Area del rectngulo "+f.area());
Enlace dinmico o binding. En el lenguaje C, los identificadores de la funcin estn asociados siempre a direcciones fsicas antes de la ejecucin del programa, esto se conoce como enlace temprano o esttico. Ahora bien, los lenguajes C++ y Java permiten decidir a que funcin llamar en tiempo de ejecucin, esto se conoce como enlace tardo o dinmico. 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 funcin area llamar la sentencia: ?
fig[i].area();
La respuesta ser, segn 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 funcin miembro area de Rectangulo. Si i es uno, el segundo elemento del array guarda una referencia un objeto de la clase Circulo, luego llamar tambin a la funcin area de Circulo, y as sucesivamente. Podemos introducir el valor del ndice i, a travs del teclado, o seleccionando un control en un applet, en el momento en que se ejecuta el programa. Luego, la decisin sobre qu funcin area se va a llamar se retrasa hasta el tiempo de ejecucin. Ejemplo de polimorfismo. Supongamos que deseamos saber la figura que tiene mayor rea independientemente de su forma. Primero, programamos una funcin que halle el mayor de varios nmeros reales positivos.
68
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 funcin valorMayor
double numeros[]={3.2, 3.0, 5.4, 1.2}; System.out.println("El valor mayor es " + valorMayor(numeros));
La funcin figuraMayor que compara el rea de figuras planas es semejante a la funcin valorMayor anteriormente definida, se le pasa el array de objetos de la clase base Figura. La funcin 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 definicin de la funcin est en las lneas
if(figuras[i].area()>areaMayor){ areaMayor=figuras[i].area(); mFigura=figuras[i]; }

En la primera lnea, se llama a la versin correcta de la funcin 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 definicin de esta funcin estriba en que la funcin
figuraMayor est definida en trminos de la variable figuras de la clase base
69
Figura, por tanto, trabaja no solamente para una coleccin de crculos y rectngulos, sino tambin para cualquier otra figura derivada de la clase base Figura. As si se deriva Triangulo de Figura, y se aade a la jerarqua de clases, la funcin figuraMayor podr manejar objetos de dicha clase, sin modificar para nada el
cdigo de la misma. Veamos ahora la llamada a la funcin 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 funcin figuraMayor, el valor que retorna lo guardamos en fMayor. Para conocer el valor del rea, desde fMayor se llamar a la funcin miembro area. Se llamar a la versin 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 funcin area definida en dicha clase. Si fMayor guarda una referencia a un objeto de la clase Rectangulo, llamar a la funcin area definida en dicha clase, y as sucesivamente. La combinacin de herencia y enlace dinmico se denomina polimorfismo. El polimorfismo es, por lo tanto, la tcnica que permite pasar un objeto de una clase derivada a funciones que conocen el objeto solamente por su clase base. Ampliacin de la jerarqua de clases. Ampliamos el rbol jerrquico de las clases que describen las figuras planas regulares:
Figura
Tringulo
Rectngulo
Crculo
Cuadrado
70
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 posicin 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 posicin x e y de la figura, el ancho y alto que tienen el mismo valor. No es necesario redefinir una nueva funcin area. La clase Cuadrado hereda la funcin area definida en la clase Rectangulo. La clase Triangulo. Esta clase tiene como datos, aparte de su posicin (x, y) en el plano, la base y la altura del tringulo.
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 definicin de la funcin area, se calcula el rea del tringulo como producto de la base por la altura y dividido por dos.
71
El operador instanceof. El operador instanceof tiene dos operandos: un objeto en el lado izquierdo, y, una clase en el lado derecho. Esta expresin 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 relacin entre rect y las clases de la jerarqua
rect instanceof Figura rect instanceof Cuadrado
//true //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 creacin 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 funcin que tiene el mismo nombre, el mismo nmero de parmetros y del mismo tipo que en la clase base, pero que da lugar a un comportamiento distinto, especfico de los objetos de la clase derivada. (redefinicin de mtodos)
72
Enlace dinmico significa que la decisin sobre la funcin a llamar se demora hasta el tiempo de ejecucin 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 funcin que conoce el objeto solamente por su clase base. De este modo podemos ampliar la jerarqua de clases sin modificar el cdigo de las funciones que manipulan los objetos de las clases de la jerarqua. Clases y Mtodos 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 ningn 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 daar o para obtener informacin privada en los sistemas es la de crear una clase derivada y sustituir dicha clase por la original. La clase derivada acta exactamente igual que la original pero tambin puede hacer otras cosas, normalmente, dainas. Para prevenir los posibles daos, se declara la clase como final, impidiendo a cualquier programador la creacin de clases derivadas de sta. Por ejemplo, la clase String que es una de las ms importantes en la programacin 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. Mtodos finales. Como sabemos, una de las formas de aprovechar el cdigo existente, es la de crear una clase derivada y redefinir algunos de los mtodos de la clase base.
73
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 funcin miembro pblica dibujar, que no dibuja nada en el contexto grfico g. La clase Derivada redefine la funcin miembro dibujar, para dibujar algunas figuras en el contexto grafico g. La funcin que se redefine tiene que tener la misma declaracin en la clase Base y en la clase Derivada. Para evitar que las clases derivadas redefinan una funcin miembro de una clase base, se le antepone la palabra clave final. La funcin miembro funcionFinal de la clase Base no se puede redefinir en la clase Derivada, pero si se puede redefinir la funcin miembro dibujar. Interfases. Una interfase es una coleccin de declaraciones de mtodos (sin definirlos) y tambin puede incluir constantes.
Runnable es un ejemplo de interfase en el cual se declara, pero no se implementa, una funcin miembro run. public interface Runnable { public abstract void run(); }
Las clases que implementen (implements) el interfase Runnable han de definir obligatoriamente la funcin run.
74
class Animacion implements Runnable{ //.. public void run(){ // define la funcin run } }
El papel de la interfase es el de describir algunas de las caractersticas de una clase. Por ejemplo, el hecho de que una persona sea un futbolista no define su personalidad completa, pero hace que tenga ciertas caractersticas que las distinguen de otras. Clases que no estn relacionadas pueden implementar la interfase Runnable, por ejemplo, una clase que describa una animacin, y una clase que realice un clculo intensivo. Diferencias entre una Interfase y una Clase Abstracta. Una interfase es: una lista de mtodos no implementados, puede incluir la declaracin de constantes. Una clase abstracta puede incluir: mtodos implementados y no implementados o abstractos, miembros dato constantes y otros no constantes. Ahora bien, la diferencia es mucho ms profunda. Imaginemos que Runnable fuese una clase abstracta. Un applet definido por la clase MiApplet que moviese una figura por su rea de trabajo, derivara a la vez de la clase base Applet (que describe la funcionalidad mnima 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 funcin run de la interfase public void run(){ //... } // redefine paint de la clase base Applet public void paint(Graphics g){ //... } // define otras funciones miembro }
75
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 despus de la palabra reservada implements. El lenguaje Java no fuerza una relacin jerrquica, simplemente permite que clases no relacionadas puedan tener algunas caractersticas de su comportamiento similares. Las interfases y el Polimorfismo. En el lenguaje C++, es posible la herencia mltiple, 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.
A
C
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 mltiple sin forzar relaciones jerrquicas, sino es el de incrementar el polimorfismo del lenguaje ms all del que proporciona la herencia simple. Para explicar este aspecto importante y novedoso del lenguaje Java adaptaremos los ejemplos que aparecen en el artculo 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 jerarqua 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 funcin habla declarada abstracta en la clase base Animal.
76
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 funcin 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 funcin
imprimir Guau!.
onomatopeya en el momento de la ejecucin del programa. Si se pasa un objeto de la clase Gato se imprimir Miau!, si se pasa un objeto de la clase Perro se
El compilador solamente sabe que se le pasar un objeto de alguna clase derivada de Animal. Por tanto, el compilador no sabe que funcin habla ser llamada en el momento de la ejecucin del programa. El polimorfismo nos ayuda a hacer el programa ms flexible, porque en el futuro podemos aadir nuevas clases derivadas de Animal, sin que cambie para nada el mtodo onomatopeya. Ver programas completos donde se trata el tema interfases: Parlanchin.java, Animal.java, Reloj.java, PoliApp.java
77
Vamos a crear una interfase denominada Parlanchin que contenga la declaracin de una funcin denominada habla.
public interface Parlanchin { public abstract void habla(); }

Hacemos que la jerarqua 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 jerarqua de clases completamente distinta, la que deriva de la clase base Reloj. Una de las clases de dicha jerarqua Cucu implementa la interfase Parlanchin y por lo tanto, debe de definir obligatoriamente la funcin 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 funcin onomatopeya de modo que conozca al objeto que se le pasa, no por una clase base, sino por la interfase Parlanchin. A dicha funcin le podemos pasar cualquier objeto que implemente la interfase Parlanchin, est o no en la misma jerarqua de clases.
78
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 funcin onomatopeya se le pasa un objeto de la clase Gato, y despus Cucu, cucu, ..!, porque a la funcin onomatopeya se le pasa un objeto de la clase Cucu. Si solamente hubiese herencia simple, Cucu tendra que derivar de la clase Animal (lo que no es lgico) o bien no se podra pasar a la funcin onomatopeya. Con interfases, cualquier clase en cualquier familia puede implementar la interfase Parlanchin, y se podr pasar un objeto de dicha clase a la funcin onomatopeya. Esta es la razn por la cual las interfases proporcionan ms polimorfismo que el que se puede obtener de una simple jerarqua de clases. Composicin. Hay dos formas de reutilizar el cdigo: mediante la herencia, mediante la composicin: se utiliza una clase ya creada incluyendo instancias de la misma en nuevas clases representa una relacin "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 composicin 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.
79
Vamos a estudiar una clase Rectangulo definiendo el origen, no como un par de coordenadas x e y (nmeros enteros) sino como objetos de una clase denominada Punto. Ver Programas completos: Punto.java, Rectngulo.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 sita el punto en el origen, y otro constructor explcito que proporciona las coordenadas x e y de un punto concreto.
public class Punto { int x; int y; // funciones miembro }

El constructor explcito de la clase Punto podemos escribirlo de dos formas
public Punto(int x1, int y1) { x = x1; y = y1; }

Cuando el nombre de los parmetros 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
Recordemos que this es una palabra reservada que guarda una referencia al objeto propio, u objeto actual. La funcin miembro desplazar simplemente cambia la posicin del punto desde (x, y) a (x+dx, y+dy). Cuando es llamada, recibe en sus dos parmetros dx y dy el desplazamiento del punto y actualiza las coordenadas x e y del punto. La funcin no retorna ningn valor.
parmetro.
80
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 funcin 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 rectngulo situado en el punto 0,0 y con dimensiones nulas
public Rectangulo() { origen = new Punto(0, 0); ancho=0; alto=0; }

El constructor explcito crea un rectngulo situado en un determinado punto p y con unas dimensiones que se le pasan en el constructor
81
public Rectangulo(Punto p, int w, int h) { origen = p; ancho = w; alto = h; }

Podemos definir otros constructores en trminos del constructor explcito 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 rectngulo de dimensiones nulas situado en el punto p. El segundo, crea un rectngulo de unas determinadas dimensiones, w y h, situndolo en el punto 0, 0. Dentro del cuerpo de cada constructor, se llama al constructor explcito mediante
this pasndole en sus parmetros los valores apropiados.

Para desplazar un rectngulo, trasladamos su origen (esquina superior izquierda) a otra posicin, sin cambiar su anchura o altura. Desde el objeto origen, llamamos a la funcin desplazar miembro de la clase Punto
void desplazar(int dx, int dy) { origen.desplazar(dx, dy); }
Objetos de la clase Rectngulo. Para crear un rectngulo rect1 situado en el punto (0, 0) y cuyas dimensiones son 100 y 200 escribimos
Rectangulo rect1=new Rectangulo(100, 200);

Para crear un rectngulo 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);
82
O bien, en una sla lnea
Rectangulo rect2=new Rectangulo(new Punto(44, 70));

Para desplazar el rectngulo 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 rectngulo rect1 podemos escribir
System.out.println("el rea es " + rect1.calcularArea());

Para hallar el rea de un rectngulo de 100 unidades de largo y 50 de alto y guardar el resultado en la variable entera areaRect, escribimos en una sola lnea:
int areaRect=new Rectangulo(100, 50).calcularArea();
Definiendo Clases. Definicin de Clases. Cuando trabajamos con el flujo de entrada y salida, quizs vimos que hay pasos muy tediosos. Quizs no se comportan los objetos de estas clases tal y como nosotros queremos. Tenemos que aceptar un comportamiento de un objeto inadecuado para nuestros propsitos solo porque otro programador los dise as? No, nosotros podemos definir nuestras propias clases que provean el comportamiento que nosotros requerimos. Definicin 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 mtodo saludo que despliega el mensaje "Hola mundo!". Usando esta definicin podemos crear un objeto de la siguiente forma: Saludos x; x = new Saludos();
83
Podemos mandarle un mensaje de la siguiente forma: x.saludo(); En general todos los mtodos llevan la palabra reservada public al principio. Un mtodo simple tiene la estructura: public valor-retorno nombre-metodo (){ // cuerpo del mtodo } La palabra reservada void es usada con aquellos mtodos que no devolvern nada. Definicin de Mtodos con Parmetros. Supongamos que queremos disear un mtodo saludo mas genrico, en donde al mandar el mensaje podamos escoger a quien saludar. Esta informacin adicional, la tendra que incluir el que llama al mtodo como argumento de la siguiente forma: x.saludo("alumnos") Para desplegar "Hola alumnos!". Para poder implementar esto necesitamos incluir parmetros en el encabezado del mtodo, para que este tenga acceso a esta informacin. La nueva clase quedara 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 mtodos con el mismo nombre, pero diferente firma, public void saludo() public void saludo(String alguien) estamos sobrecargando el mtodo saludo. Por lo tanto cuando el usuario quiere saludar a todo el mundo, hace la llamada:
84
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 explcitamente, se dice que el saludo al mundo es el saludo default. Uso de Atributos. Supongamos que queramos darle la opcin al creador del objeto Saludos que escoja el saludo default, para que no necesariamente sea al "mundo". Esta informacin debera de ser proveda en el constructor del objeto. As, con las siguientes instrucciones: desplegaran 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 parmetro String. Para que tenga el mtodo saludo acceso a la cadena recibida en el constructor, necesitamos almacenarla en un atributo. Esto lo hacemos porque un mtodo no puede acceder a las variables o parmetros de los otros mtodos. Los atributos pueden ser accedidos por todos los mtodos de dentro de la clase. La declaracin de estos es la misma que las variables, con la diferencia que comienzan con la palabra reservada private. La nueva clase quedara 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("!")); }
85
El orden de declaracin entre los atributos y los mtodos es irrelevante. Cualquier orden es legal. Como norma, conviene para la clase, que declararemos todos los atributos antes de los mtodos. Los miembros (atributos y mtodos de la clase) pueden ser pblicos, privados o amigables (default). Los miembros pblicos (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 Definicin 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, asegrese de incluir la lnea: import java.io.*; Despus compilamos este archivo para producir Saludos.class. Una vez que ya hicimos esto, podemos utilizar nuestra clase en un programa. Por ejemplo, podramos 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. Diseo e Implementacin de Clases. La definicin de la clase trabajada anteriormente fue extremadamente casual. Empezamos con una clase muy simple y le fuimos agregando funcionalidad mientras
86
lo bamos necesitando. Dicho enfoque fue til para explicar la definicin de las clases, pero es poco funcional para escribir clases de alguna significacin. Es como construir una casa, cuarto por cuarto. Necesitamos un enfoque ms sistemtico. Podemos seguir los siguientes pasos: Diseo de la clase: Decida el comportamiento que la clase deber proveer. Como el comportamiento de un objeto es provedo a travs de sus mtodos, determine claramente que mtodos 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 mtodos. 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 declaracin de la clase con los prototipos de todos los mtodos, pero con el cuerpo de los mtodos vaco.
87
Implementacin de la clase: Consiste en escribir los cuerpos de los mtodos y declarar los atributos mientras se vayan necesitando. Tenga en mente lo siguiente: Puede empezar a trabajar en cualquiera de los mtodos. Puede dejar de trabajar en cualquiera de los mtodos antes de completarlo e ir a trabajar en otro mtodo. Mejora de la Implementacin Por lo general cualquier cdigo 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 diseo e implementacin de clases, vamos a comenzar resolviendo el problema de entrada y salida interactiva. Queremos disear una clase que provea una manera sencilla de leer y desplegar informacin. Diseo de la Clase. Comportamiento que la clase deber proveer. Si tuviramos una clase InteractiveIO quisiramos que esta me ofreciera el siguiente comportamiento: Escribir a la pantalla, asegurndome que se vaya a desplegar inmediatamente. Preguntar al usuario por informacin, desplegndole un mensaje y leyendo una cadena del teclado, asegurndome que el mensaje se despliegue antes de que la computadora espere la entrada. Interfase y Prototipos de los mtodos. A partir del comportamiento deseado de InteractiveIO, quisiramos 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();
88
De esto podemos deducir que necesitaremos un constructor sin parmetros. Mandar un mensaje al objeto para escribir a pantalla de la siguiente forma: interIO.write("Por favor conteste cada pregunta."); Debemos proveer un mtodo write que reciba una cadena como parmetro, 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 mtodo promptAndRead que reciba una cadena como parmetro, y que devuelva una cadena. Aqu ya tenemos una idea clara del prototipo de los mtodos 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 ms simple que podemos escribir es uno que lee una palabra y a continuacin la despliega. Si nuestra clase InteractiveIO funcionara como nosotros quisiramos este quedara 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 diseada tal y como la tenemos, lleva a cabo bien la tarea. Provee de una entrada y salida interactiva simple, despreocupndonos de System.in, System.out y flush. Esta clase hara todo esto por nosotros.
89
Esqueleto de la clase. class InteractiveIO { // aqui iran los atributos, si necesitramos 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 }
Implementacin de la clase Completamos los mtodos 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(); } /** despliega s, lee una cadena del teclado y devuelve una referencia a esta */ 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; }
90
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 mtodo. No se ejecutara ninguna instruccin despus del return. Incluso si tengo un mtodo que no retorna ningn valor, pero deseo salirme del mtodo lo puedo hacer mediante el enunciado: return; Mejora de la implementacin. Observemos que podemos optimizar el programa en los siguientes aspectos: No tiene sentido crear en cada llamada al mtodo 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 mtodo write).
Las primeras instrucciones del mtodo promptAndRead son iguales a las del mtodo write. Podemos ahorrar esta repeticin de cdigo llamando al mtodo write desde el mtodo promptAndRead. No necesitamos almacenar la referencia al objeto String en el mtodo promptAndRead. Podemos obviar este paso devolviendo la referencia leda en composicin. La nueva implementacin 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(); } /** despliega s, lee una cadena del teclado y devuelve una referencia a esta */ public String promptAndRead(String s) { this.write(s); return keyb.readLine(); }
91
Aqu trabajamos con tres tipos de variables: Parmetros: son creadas cuando el mtodo al cual pertenecen es invocado. Su valor inicial corresponde a la informacin enviada como argumento. Son destruidas cuando termina el mtodo. Solo pueden ser accedidas por el mtodo al cual pertenecen. Variables Locales: al igual que los parmetros, stas son creadas cuando el mtodo se invoca y destruidas cuando termina el mtodo y slo pueden ser accedidas por el mtodo al cual pertenecen. A diferencia de los parmetros stas deben ser inicializadas dentro del mtodo. 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 mtodos de la misma clase. Se acostumbra a declararlas private, ya que no deberan ser accedidas por mtodos de otras clases. Recordemos que cuando mandamos mensajes (al llamar a los mtodos) necesitamos un receptor de dicho mensaje. En el mtodo 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 mtodo. Podemos utilizar tambin la palabra reservada this para diferenciar entre variables locales y atributos que tengan el mismo nombre. Ejercicios propuestos para el alumno: Agregue un mtodo writeln a la clase InteractiveIO que reciba una cadena de caracteres, que la despliegue y que garantice que el siguiente carcter a desplegarse aparecer en una nueva lnea. Agregue un segundo mtodo writeln (sobrecargado) en la clase InteractiveIO que no reciba argumentos, pero garantice que el siguiente carcter a desplegarse aparecer en una nueva lnea.
Segundo Ejemplo Completo: Clase Nombre. Diseamos la clase InteractiveIO motivados por el deseo de un uso ms 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 modelndolos 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 quisiramos de una clase Nombre
92
Diseo 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 mtodos. A partir del comportamiento deseado de la clase Nombre, quisiramos 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 parmetros 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 mtodo 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 mtodo getLastFirst que devuelva una cadena. Mandar un mensaje al objeto para obtener el nombre completo, en la forma primer nombre apellido precedido de un ttulo opcional, como una cadena, de la siguiente forma:
93
String s; s = alumno.getFirstLast(); Debemos proveer un mtodo getFirstLast que devuelva una cadena. Mandar un mensaje al objeto para agregar o reemplazar el ttulo de la siguiente forma: alumno.setTitle("Ingeniero"); Debemos proveer un mtodo setTitle que reciba como parmetro una cadena. Aqu ya tenemos una idea clara del prototipo de los mtodos que incluir la clase Nombre. Estos son: public public public public public Nombre(String pnom, String ap) String getInitials() String getLastFirst() String getFirstLast() void setTitle(String newTitle)
Observe que el constructor no incluye al titulo. Esta fue nuestra opcin (como diseadores 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 ms simple que podemos escribir es uno que lea el primer nombre y apellido y el ttulo. Despus 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 quisiramos este quedara as:
94
import java.io.*; class ProbandoNombre { public static void main(String args[]) { Nombre n; String primer, apellido, titulo; InteractiveIO io; io = new primer = apellido titulo = InteractiveIO(); io.promptAndRead("Ingrese primer nombre: "); = io.promptAndRead("Ingrese apellido: "); 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 diseada 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 necesitramos 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 } {
Implementacin de la clase Completamos los mtodos de la clase. Razonamos que: Los mtodos getFirstLast y getLastFirst necesitan ambos acceso al primer nombre y al apellido. De la misma forma getFirstLast y setTitle necesitan
95
ambos acceso al ttulo. 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 vlidos en sus atributos. Queda la mejora de la clase a discrecin del alumno. Para la clase InteractiveIO, es poco probable que se declare ms 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 mtodos pero tendrn 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 (provedo por sus mtodos), las llamadas devolvern resultados distintos. Esto es porque los atributos tendrn 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.
96
Ejercicios propuestos para el alumno: Escriba un programa que lea tres pares de primer nombre, apellido y a continuacin despliegue sus iniciales. El programa deber usar la clase Nombre. Agregue un mtodo IlustrateName a la clase Nombre que despliegue el nombre a pantalla. Disee e implemente una clase NombreLargo, que tome en consideracin (adems del primer nombre y apellido como lo hizo la clase Nombre) el segundo nombre. Disee e implemente una clase Direccion. Diseando la Salida para los Objetos En el diseo original de la clase Nombre, la clase no lea 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 podra implementar esto, le agregaremos este comportamiento a la clase Nombre, comenzando con la salida. Podemos disear un mtodo 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 debera ir? La primera cuestin es algo de diseo, arbitrariamente podemos escoger producir el nombre completo en el orden titulo primer-nombre apellido. Podemos de una forma arbitraria escoger hacia donde debera ir la salida, ya sea al monitor o a algn archivo en especial. Sin embargo, si nos vamos a tomar la molestia de agregar un mtodo extra a la clase, podramos disearlo para que sea lo ms general posible sin limitarlo a ninguna salida especfica. Podramos hacer responsabilidad del que invoca el mtodo, hacia donde debera producirse la salida. Hasta ahora, hemos manejado la salida a travs del print y println ha instancias del PrintStream. Como diseadores de la clase Nombre, podramos insistir que la salida se maneje a travs del PrintStream. Podramos pedirle al invocador del mtodo print que incluya como argumento el objeto PrintStream, a donde desea que se mande la salida. El mtodo quedara as: void print (PrintStream destino) De esta manera, si el que llama al mtodo print desea desplegar el nombre en la pantalla, en la llamada, incluira como argumento System.out. Por otro lado si
97
desease mandar el nombre a un archivo incluira como argumento alguna instancia del FileOutputStream. Un ejemplo de uso podra 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 implementacin quedara 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 mtodos: print y println, ambos, de los cuales deben recibir una cadena de argumento. Estos mtodos deben mandar la cadena a desplegar a pantalla y a escribirla al archivo. Diseando la Entrada para los Objetos Desearamos 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 envo del mensaje debera 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 travs de un tipo de mtodo conocido como mtodo esttico. Estos mtodos son definidos de la misma forma que los otros mtodos, excepto que estos llevan la palabra reservada static antes del tipo de retorno. Los mtodos estticos no estn asociados a ningn objeto. Tienen las siguientes caractersticas: 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 ningn atributo. Al igual que con el mtodo print nos debemos preguntar dos cosas: o En que forma se debe leer el nombre? o La entrada, de donde debera provenir?
98
Requeriremos como diseadores de la clase, que el primer nombre aparezca en una lnea de por s solo y el apellido en la siguiente lnea. De nuevo, esta decisin es arbitraria. Adems disearemos el mtodo de tal forma que la fuente de entrada sea responsabilidad del que invoque el mtodo. Requeriremos que como argumento se pase una referencia a un BufferedReader, de donde ser ledo el nombre. El prototipo sera 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 implementacin quedara 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 informacin desde el teclado, es aconsejable desplegar un mensaje para decirle al usuario que informacin es la que se desea que ingrese. Podemos incluir otro mtodo de entrada readi que utilice la clase InteractiveIO que ya hemos diseado para llevar a cabo esto. La implementacin quedara 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); }
99
Ejercicio propuesto para el alumno: Agregue los mtodos 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 ms 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 mtodo main. El mtodo main es static, es decir no esta asociado a ningn objeto HelloApp. La razn de esto, es que la ejecucin de nuestro programa debe de comenzar en algn lado. El intrprete de Java en algn sentido, invoca el mtodo main. Pero esto lo hace antes de que cualquier objeto de nuestro cdigo haya sido creado. Adems vemos que esta declarado como public. La razn de esto es que necesita ser llamado desde afuera de la clase (desde el interprete de Java).
100
Capitulo 6 Software de Calidad.
Captulo 6.
CONTROL DE CALIDAD EN LOS SISTEMAS

Introduccin
El desarrollo de sistemas hoy en da ha tomado gran importancia en el mundo, siendo sta cada vez ms creciente. Me parece muy acertado sugerir, en este punto, y luego de haber analizado en profundidad un lenguaje de programacin, 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 econmica de nuestro pas, y considerando que se estn 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 nacin, el que ha tomado como modelo a la Republica de la India, debemos, no solo entonces elegir un buen lenguaje de programacin, sino que tambin, el mismo debe estar acorde a las pautas mundiales de CALIDAD. A nivel pas, el Gobierno de la Ciudad de Buenos Aires, esta impulsando de manera coherente desde el ao 2003, el programa PRO ISO 9000. Este desafo impulsado por el Gobierno porteo, ya ha generado sus primeros frutos en el rea informtica, 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 podra 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 lneas de accin tendientes a mejorar el sistema producido. Dentro de estas lneas de accin, est la relacionada con el proceso mismo del desarrollo del sistema, y como necesidad primordial, la de realizar una investigacin 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 explotacin.
101
El control de calidad de software est orientado a garantizar las caractersticas de los programas que se estn desarrollando. La Ingeniera de Software concierne a teoras, mtodos y herramientas para el desarrollo profesional de productos. Un Sistema concierne a un conjunto de componentes interrelacionados trabajando conjuntamente para un fin comn. El sistema puede incluir software, dispositivos mecnicos y elctricos, hardware, y ser operado por gente. Existen varias organizaciones de estandarizacin internacional que realizan estndares y modelos de ingeniera 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 caractersticas de un producto o servicio que se refieren a su capacidad para satisfacer necesidades dadas en la adecuacin de sus objetivos'. El Instituto de Ingeniera 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 satisfaccin del producto. La calidad es sinnimo de eficiencia, flexibilidad, correccin, confiabilidad, mantenibilidad, portabilidad, usabilidad, seguridad e integridad.
Calidad del Software

Definicin 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 vara 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 perodo (10 aos o ms) necesita ser confiable, mantenible y flexible para disminuir los costos de mantenimiento y perfeccionamiento durante el tiempo de explotacin.
102
Aspectos de la Calidad La Calidad del Software puede medirse despus de elaborado el producto. Pero esto puede resultar muy costoso si se detectan problemas derivados de imperfecciones en el diseo, por lo que es imprescindible tener en cuenta tanto la obtencin 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 satisfaccin al trabajo de los profesionales afines al campo de la computacin. Mejorar la calidad del producto del software. Proveer tcnicas aplicadas para automatizar el manejo de datos. Realizar una planeacin eficaz de los sistemas. Documentar. Validar y controlar formalmente la calidad del trabajo realizado. Cumplir con los objetivos de la organizacin en cuanto a productividad de sus sistemas de cmputo.
Obtencin de un Software de Calidad La Obtencin de un Software con Calidad implica la utilizacin de metodologas o procedimientos estndares para el anlisis, diseo, programacin y prueba del software, que permitan uniformar la filosofa 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 tecnolgico define las tcnicas a utilizar en el proceso de desarrollo del software. El principio administrativo contempla las funciones de planificacin y control del desarrollo del software, as como la organizacin del ambiente o centro de ingeniera de software. El principio ergonmico define la interfaz entre el usuario y el ambiente automatizado. Para el aseguramiento de la calidad es necesario su control o evaluacin. Control de la Calidad El Control de la Calidad es realizar una observacin constante acerca del cumplimiento de las tareas que pueden ofrecer una calidad objetiva a la forma en como se est desarrollando un proyecto de Ingeniera 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 metodologas de
103
trabajo y uso de herramientas, revisiones de prototipos y evaluacin 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 retroalimentacin 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 bsqueda de problemas, evaluacin, realimentacin, rectificacin, elaboracin, modificacin y estudio de la documentacin; 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 tendra 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 estara asegurada en sus bases. Control de Calidad del Software Para controlar la Calidad del Software es necesario, definir los parmetros, indicadores o criterios de medicin. 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: clasificacin por tipo, esfera de aplicacin, complejidad, etc., de acuerdo con los estndares 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 mtodos de valoracin de los indicadores: mtodos manuales, como cuestionarios o encuestas estndares para la medicin de criterios periciales y herramientas automatizadas para medir los criterios de clculo. 4. Definir las regulaciones organizativas para realizar el control: quines participan en el control de la calidad, cundo se realiza, qu documentos deben ser revisados y elaborados, etc.
104
Indicadores para diferenciar los productos de calidad de los que carecen de ella: El acercamiento a cero defectos. El cumplimiento de los requisitos intrnsecos y expresos. La satisfaccin del cliente
Sobre todo la satisfaccin del cliente. La Calidad del Software debe ser una disciplina ms dentro de la Ingeniera 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 estndares genricos y en unos procedimientos particulares. Las normas, directivas, modelos y estndares son bsicamente 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 Fundacin Europea de Gestin de Calidad
Los procedimientos pueden variar en cada organizacin, pero lo importante es que estn escritos, personalizados, adaptados a los procesos de la organizacin y, lo que es ms importante, que se cumplan. La Calidad del Software debe implementarse a lo largo de todo el ciclo de vida, debe correr paralela desde la planificacin del producto hasta la fase de produccin 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 operacin con los factores de correccin, facilidad, eficiencia, integridad y facilidad de uso. Capacidad para ser modificado o de revisin con los factores de flexibilidad, facilidad de prueba y facilidad de mantenimiento. Capacidad de transicin o de adaptacin a otros entornos con los factores de transportabilidad, capacidad de reutilizacin y de interoperacin.
105
Calidad Total en el Proceso de Desarrollo del Sistema Para alcanzar la "Calidad Total", es necesaria la satisfaccin por parte de los elementos que intervienen en el proceso: La satisfaccin de la alta direccin La satisfaccin del personal involucrado en el desarrollo del sistema La satisfaccin del usuario final
La aplicacin del control de calidad de sistemas no es solamente al sistema en s, sta conforma la ltima parte de la evaluacin. 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 realizacin 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 elaboracin del sistema. Componentes para la Calidad Total Claridad Involucracin Planeamiento Estndares Entrenamiento Experiencia Controles Documentacin Soporte Finalizacin
Claridad La definicin 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. Involucracin 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
106
dando el cubrimiento adecuado a todos los requerimientos y funciones, divisiones o departamentos que estn involucrados en la realizacin del proyecto. Planeamiento En la planificacin intervienen tanto los usuarios como el personal que desarrolle el proyecto. Debe planearse el grado de integracin que se requiere en las diferentes reas de la organizacin, para interpretar necesidades o requerimientos satisfactorios con el objeto de llegar a acuerdos en caso de imprevistos en asuntos tan simples como el mtodo mediante el cual vamos a poner a trabajar alguna etapa o actividad en el proyecto. Estndares Tiene que tomarse en cuenta la forma mediante la cual vamos a trabajar desde el punto de vista tecnolgico, ya que es necesario tener presente la definicin de diversos factores que afectaran la realizacin del proyecto, como son: Lenguaje de programacin Manejo de libreras Cdigo Instrucciones Comentarios Administracin de backups Administracin de archivos Periodicidad de revisiones Documentacin
Debe quedar clara su definicin, los elementos que los deben integrar, as como su estandarizacin. Sin una estandarizacin el proyecto se vendra abajo. Entrenamiento El entrenamiento es un factor determinante para la realizacin de un proyecto, ya que mediante l se obtienen los conocimientos y habilidades que se aplicarn 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 involucracin de las personas clave para el proyecto; el funcionamiento de la aplicacin; del desarrollo con el usuario y un punto importante es la mutua satisfaccin entre de la gente que realiza el proyecto con el usuario.
107
En este caso puede contarse con un Calendario de Entrega donde contenga los puntos anteriormente mencionados, as como contar con Bitcoras que respalden las reuniones que se tengan con los usuarios y los acuerdos a los que hayan llegado ambas partes. Documentacin Es importante que la documentacin 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 aplicacin y produccin y los cuidados con respecto a back-ups, ayudas y soporte requerido, la bitcora de historia respecto a fallas, mejoras, arreglos, etc., contribuyen a una mejor utilizacin del sistema, es decir, a una mayor calidad en su operacin. Manuales de usuario, tcnico y de operacin. Soporte Es indispensable tener claro quin nos puede apoyar en las reas tcnica, de anlisis, en el rea usuaria, ya sea en la instalacin, en el rea ejecutiva o en algn otro aspecto, ya que las aplicaciones en los proyectos de sistemas enfrentan siempre necesidades crticas de soporte. Finalizacin La finalizacin del proyecto de un sistema es una de las labores ms importantes en el desarrollo del mismo, de igual manera que en cada etapa. En la finalizacin del proyecto es necesario considerar cinco puntos vitales: La revisin de todos los pasos realizados y de las etapas incluidas en el proceso total; Elaboracin del proceso en forma integral; Calidad hecha en cada uno de los pasos o etapas del proyecto; La atencin a los requerimientos del usuario en trminos de hacer todo lo que l quiera, o ms; Y, por supuesto, la satisfaccin 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 aplicacin 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. Administracin de la Calidad Calidad en el Nivel de Organizacin La Administracin de la Calidad cuenta con dos niveles de trabajo: El nivel de entidad u organizacin Donde se trata de crear y gestionar una infraestructura que fomente la calidad de los productos software mediante la adecuacin y mejora de las actividades y
108
procesos involucrados en su produccin e, incluso, en su comercializacin y en la interaccin con los clientes. El nivel del proyecto Donde las guas que la infraestructura organizativa prev para las distintas actividades y mantenimiento del software deben ser adaptadas a las caractersticas concretas del proyecto y de su entorno para ser aplicadas a la prctica. Dentro del primer nivel de accin, la gestin de la calidad en organizaciones de software ha seguido dos lneas que pueden ser complementarias entre s: Por una parte, se ha seguido la lnea marcada por las entidades internacionales de estandarizacin para todas las organizaciones de produccin o servicios. Principalmente se han impuesto en la prctica las directrices marcadas por ISO (Organization for International Standardization) a travs de unas normas ISO 9000 para la gestin 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 gua especfica para su aplicacin a este sector: ISO 9000-3. El mundo del software ha creado sus propias lneas de trabajo en la gestin de la calidad, trabaja sobre los procesos de produccin como medio para asegurar la calidad del producto software. Por ejemplo, el SEI (Software Engineering Institute), proponiendo un modelo de clasificacin 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 disea conjuntamente con el sistema, nunca al final. A mayor calidad, mayores son los costos, pero mayores tambin 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 gestin de calidad, tecnologa de ingeniera de software efectiva (mtricas y herramientas), revisiones tcnicas formales que se aplican durante el proceso del software, una estrategia de prueba multiescalada, el control de la documentacin del software y de los cambios realizados, un procedimiento que asegure un ajuste a los estndares de desarrollo del software (cuando sea posible) y mecanismos de medicin y de generacin de informes. La idea de la necesidad de realizar pruebas en fases tempranas, conduce a realizar un mecanismo bsico que permite las Revisiones Tcnicas Formales. Una Revisin Tcnica Formal (RTF) es una actividad que garantiza la Calidad del Software y que es llevada a cabo por los profesionales de la ingeniera de software. Los objetivos de la RTF son: 1. Descubrir errores en la funcin, la lgica o la implementacin de cualquier representacin del software;
109
2. Verificar que el software bajo revisin alcance sus requisitos; 3. Garantizar que el software haya sido representado de acuerdo con ciertos estndares predefinidos; 4. Conseguir un software desarrollado de forma uniforme, y 5. Hacer que los proyectos sean ms manejables. La Prueba del Software Se pueden realizar inspecciones para cada mdulo o pequeo grupo de mdulos que conformen un sistema. Al limitar el centro de atencin de la RTF la probabilidad de descubrir errores es mayor. En la figura se puede apreciar lo que sera el flujo de informacin necesario para realizar correcta y completamente una prueba de software, la cual puede ser aplicada tanto a los mdulos individuales como al software en su totalidad.
Calidad por Etapas Calidad en el Diseo Aqu se plantean caractersticas definidas para la realizacin del producto software que debern cumplirse posteriormente. La calidad se basa en definir un listado de especificaciones a seguir. Involucra descripcin de los procesos, tareas y responsabilidades de los equipos de desarrollo.
110
En esta etapa la calidad aumenta en la medida en que se realiza una alta especificacin de los procesos y se propone una estrecha tolerancia a la modificacin, estableciendo los mtodos 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 elevarn el nivel de confianza para la organizacin desarrolladora, lo que puede elevar su posicin en el mercado. Mtricas del Software Las mtricas 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 basndonos en mediciones reales de software, as como a las escalas de medicin. Clasificacin de Mtricas Las mtricas de software se pueden clasificar como: Mtricas orientadas a la funcin y Mtricas orientadas al tamao. Tambin se pueden clasificar segn la informacin que entregan: 1. Mtricas de productividad, las que se centran en el rendimiento del proceso de ingeniera de software. 2. Mtricas de calidad, proporcionan una indicacin de cmo se ajusta el software a los requisitos explcitos e implcitos del cliente. 3. Mtricas tcnicas, que se centran ms en el software que en el proceso a travs del cul se ha desarrollado (por ejemplo grado de modularidad o grado de complejidad lgica). Estndares y Modelos de Calidad en la Ingeniera de Software Introduccin La estandarizacin es toda actividad documentada que norma el comportamiento de un grupo de personas. Los estndares nos dan los medios para que todos los procesos se realicen siempre de la misma forma, mientras nos surjan ideas para mejorarlos. Son nuestra gua para la productividad y la calidad. Expectativas de los estndares: Mejora de procesos de software acorde a los objetivos estratgicos Mejora de los productos Proteccin del cliente o usuario Proteccin de la organizacin (cultura de la organizacin y mejora continua)
111
Existen varias organizaciones de estandarizacin internacional, algunas son regionales mientras que otras son globales. Las ltimas estn 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 ao 1906 para definir estndares en elctrica y electrnica, 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 estndares para la tecnologa de informacin 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 Organizacin Internacional para la Estandarizacin (ISO) fue fundada el 23 de febrero de 1947 con el objetivo de crear una norma internacional de calidad. El Comit Tcnico ISO/TC 176 para Aseguramiento de la Calidad fue el encargado de crear el estndar ISO 9000. El objetivo del estndar es desarrollar un cdigo mnimo que contenga prcticas de administracin para garantizar el Aseguramiento y Administracin de la Calidad, es decir, qu hacer para responder a los requerimientos de un mercado cada vez ms competitivo y cmo deben responder los proveedores y compradores respecto a la calidad de los bienes o servicios intercambiados. Para ello establece una serie de guas para la seleccin y uso del estndar 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 guas o modelos fundamentales: ISO 9001 Sistemas de Calidad. Modelo de Aseguramiento de la Calidad en el diseo, desarrollo, produccin, instalacin y servicio. ISO 9002 Sistemas de Calidad. Modelo de Aseguramiento de la Calidad para la produccin, instalacin y servicio. ISO 9003 Sistemas de Calidad. Modelo de Aseguramiento de la Calidad para la inspeccin final y pruebas.
112
ISO 9004 Elementos para la Administracin y el Sistema de Calidad. Gua para el Sistema de Aseguramiento de la Calidad.
Adems, existen otras normas y entre ellas las ms relevantes son: ISO 9000-1 Gua para la seleccin de la norma a usar. ISO 8402 Recopilacin de definiciones. Vocabulario. ISO 9000-3 Estndares de Administracin y Aseguramiento de la Calidad. Gua para la aplicacin 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 cmo debe hacerse el trabajo en la organizacin. Crear un sistema para controlar la distribucin y reedicin de documentos. Diseo e implantacin de un sistema de acciones preventivas y correctivas para prevenir la ocurrencia de problemas. Identificar las necesidades en cuanto a entrenamiento en la organizacin. Determinar las medidas y equipos para realizar las pruebas. Capacitar al personal de la organizacin en la operacin del Sistema de Calidad. Planificar y llevar a cabo auditorias de calidad internas. Tener en cuenta los requerimientos del estndar con los que no cumple la organizacin.
Los factores que determinan el modelo a elegir son: 1. La complejidad del proceso de diseo. Se refiere a la dificultad para disear el producto o servicio cuando ste no ha sido diseado. 2. La madurez del diseo. Se proyecta hacia el conocimiento y aprobacin del diseo total, ya sea por las pruebas de desempeo o por la experiencia en el campo. 3. La complejidad del proceso de produccin. Est relacionado con la capacidad del proceso de produccin, las necesidades de desarrollo del nuevo proceso, las variaciones que se requieren y el impacto en el desempeo del producto o servicio. 4. Las caractersticas del producto o servicio. Depende de la complejidad del producto o servicio, del nmero de caractersticas interrelacionadas y de su influencia en el desempeo. 1. La seguridad del producto o servicio. Relacionado con el riesgo de ocurrencia de fallas y el impacto de stas. 2. Econmico. Se refiere al incremento de los costos, para el suministrador o comprador, que puede provocar desacuerdos en cuanto al producto o servicio.
113
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, adems de desarrollar un sistema de certificacin aceptable en el mercado, estimular a los desarrolladores de software a implementar sistemas de calidad, dando la direccin y guas 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 estndares. Ciclo de Vida del Software Un sistema de calidad tpico Tick IT deber contener los elementos que se enlistan a continuacin: Elaboracin de propuestas y revisin de contratos asegurando que todos los requerimientos estn bien especificados y de que la organizacin tiene la capacidad para cumplirlos. Anlisis y especificacin de los requerimientos del sistema asegurando que sean revisados y acordados con el cliente. Planeacin, control y monitoreo del avance del desarrollo respecto al plan comunicando a todas las partes afectadas y que avise oportunamente de problemas potenciales. Planeacin de la calidad del proyecto, especificando las inspecciones, revisiones y pruebas requeridas durante el desarrollo. Inspecciones de los productos contra estndares y requerimientos aplicables y las acciones correctivas correspondientes. Diseo de primer nivel identificando los componentes principales y los requerimientos que satisfacen. Diseo detallado de todos los componentes e interfaces, construccin, y prueba de los mismos verificando que satisfagan la especificacin. Integracin, pruebas e inspecciones del sistema, demostrando que el sistema integrado funciona correctamente y satisface su especificacin. Identificar, segregar, investigar y corregir productos no conformes. Auditorias, pruebas e inspecciones de aceptacin del sistema demostrando al cliente que el sistema satisface los requerimientos. Almacenamiento, replicacin, envo e instalacin, asegurando la integridad y seguridad de los productos, as como el cumplimiento de los compromisos adquiridos con el cliente. Puesta en marcha y liberacin 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 mnima intervencin del proveedor. Mantenimiento o sustitucin del sistema, asegurando que se contina operando en conformidad con los requerimientos del cliente o usuario. Soporte a clientes de acuerdo a lo especificado en el contrato.
114
Soporte y Aseguramiento de Calidad Establecer polticas y objetivos de calidad generales de la organizacin que sirvan para alinearla en todas sus actividades, procedimientos y polticas especficas. 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. Administracin de la organizacin y los proyectos de tal forma que facilite los resultados de calidad. Administracin de la configuracin 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 prdida o corrupcin. Sistema de control de registros y documentacin para todas las actividades de aseguramiento de calidad, de los proyectos y de soporte, incluyendo procedimientos y registros. Especificacin y control del proceso de desarrollo incluyendo tcnicas, prcticas, convenciones, estndares, mediciones y estadsticas. Proceso de compras, incluyendo identificacin, seleccin, adquisicin y aceptacin 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 utilizacin, configuracin, seguridad. Entrenamiento, reclutamiento y desarrollo de personal que asegure su competencia y motivacin, y disminuya su rotacin.
El Modelo CMM A principios de los aos 80s el Departamento de Defensa de los Estados Unidos enfoc sus tareas a la revisin de los problemas del software y a su mejoramiento. Para contribuir a este programa se cre el Instituto de Ingeniera 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 Evaluacin de la Capacidad del Software. Despus de varios aos de realizar cuestionarios, evaluaciones, consulta e investigacin, 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.
115
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 organizacin 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 organizacin alcanza cierto grado de madurez posee una gran habilidad para administrar el proceso de desarrollo y mantenimiento del software, se hacen pruebas y anlisis de costo-beneficio para mejorar el proceso, el administrador monitorea la calidad del producto y la satisfaccin del cliente, se llevan registros y todos los integrantes estn involucrados. La madurez del proceso de software esta dada cuando un proceso en especfico es explcitamente 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 implantacin 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 organizacin dentro de un nivel de madurez en particular. Es un modelo normativo ya que las prcticas detalladas caracterizan el tipo normal de comportamiento que se espera de una organizacin que realiza proyectos a gran escala. No es prescriptivo ya que no dice a la organizacin como mejorar. Estructura del modelo. CMM: Marco de Trabajo Capability Maturity Model SEI
116
El modelo consta de 5 niveles, diseados 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 organizacin alcanza una capacidad en el proceso superior.
Los 5 niveles del modelo son: 1. Inicial: el proceso de software es un proceso improvisado y catico. Pocos procesos estn 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 modificacin a medida que avanza el trabajo. 2. Repetible: se establecen procedimientos de administracin del proceso bsico para determinar costos, calendarios y funcionalidades. Se establecen las polticas para la administracin del proceso y los procedimientos de implantacin. El proceso se basa en repetir xitos anteriores en proyectos de similares caractersticas, 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 tcnicas est documentado, homogeneizado e integrado en un proceso de software estndar dentro de la organizacin, que ayudar a obtener un desempeo ms efectivo. El grupo que trabaja en el proceso enfoca y gua sus esfuerzos al mejoramiento de su desarrollo, facilita la introduccin de tcnicas y mtodos e informa a la administracin del estado del proceso. La capacidad del proceso est basada en una amplia comprensin comn dentro de la organizacin 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 organizacin predecir las tendencias en la calidad del producto dentro de los lmites establecidos y tomar las acciones necesarias en caso que sean excedidos. Los productos de dicha categora son predeciblemente de alta calidad. 5. Optimizacin: el mejoramiento continuo retroalimentacin cuantitativa y desde las innovadoras. La organizacin tiene los dbiles y conocer como fortalecerlos. Su causas de defectos y su prevencin. del proceso es garantizado por la pruebas de tcnicas y herramientas medios para identificar los puntos actividad clave es el anlisis de las
117
El Modelo BOOTSTRAP El Instituto Bootstrap es una organizacin no lucrativa dedicada a la mejora continua del modelo de calidad de software llamado BOOTSTRAP, tambin tiene como propsito ayudar a la industria europea del software para mejorar su competitividad. Bootstrap es un mtodo para analizar, redisear y mejorar los procesos de negocio del desarrollo de software. Este se compone de: un modelo, un proceso de evaluacin, una base de datos de soporte, un proceso de mejora y los instrumentos de evaluacin. Su enfoque es evaluar el proceso, no el producto. Para eso se definen un conjunto de caractersticas para los procesos, provee un anlisis cuantitativo, produce vistas analticas, hace evidente fortalezas y debilidades, identifica reas de mejora, provee recomendaciones y sugiere un plan de implementacin. El modelo define el paradigma Organizacin-Metodologa- Tecnologa que se usa en Bootstrap para los niveles de evaluacin y agrupacin de resultados. El modelo Bootstrap se basa en evaluar las unidades de produccin de software de la organizacin, a travs de sus proyectos para hacer un cambio a toda la organizacin. Dentro de este proceso, hay cuatro etapas principales: preparacin, ejecucin de la evaluacin, determinacin del nivel de madurez y capacidades, y la presentacin de resultados de la evaluacin. En la etapa de preparacin 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 evaluacin 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 ejecucin, las tareas son: 1. una breve reunin de apertura, para obtener un enfoque colaborativo con el personal a ser entrevistado; 2. el llenado de los cuestionarios con caractersticas generales de la UPS; 3. el llenado de los cuestionarios del proyecto elegido, incluyendo la evaluacin de cmo el proceso de produccin es aplicado; 4. revisin preliminar de la evaluacin, y 5. reunin final, con el enfoque de presentar los resultados de la evaluacin y obtener el consenso para poder pasar a la fase de mejoras.
118
En la etapa de determinar el nivel de madurez y capacidades, es donde se califica cada pregunta con uno de 5 valores posibles: nulo, dbil, regular, extenso o no aplica. Para cada atributo clave se obtiene un nivel de madurez, aplicando un algoritmo numrico, dando como resultado uno de estos niveles: 1-inicial, 2-repetible, 3-definido, 4-administrado o 5-optimizado. Estos niveles de madurez estn subdivididos en cuatro, de forma que se obtenga una calificacin ms exacta. Los procesos de organizacin y metodologa se califican de 1 a 5, mientras que el de tecnologa se califica slo con dos niveles A o B. Como resultado de la evaluacin, la organizacin recibe 2 reportes, uno con los resultados de la evaluacin de la UPS y otro con los resultados del proyecto evaluado. El correspondiente a la UPS contiene informacin como: un resumen ejecutivo, los objetivos de la UPS, los puntos dbiles y fuertes, un plan de accin recomendado, etc. El reporte del proyecto contiene: comentarios del proyecto actual detallando lo referente a la organizacin, metodologa y tecnologa, los niveles de madurez para el proyecto, el plan de accin recomendado, etc. Uso de las Bases de Datos de Soporte Una de las caractersticas principales de Bootstrap es la base de datos con que cuenta para hacer anlisis. Con esto se fundamenta el plan de mejoras, se pueden medir las adaptaciones a la metodologa, se puede comparar contra la industria y se pueden establecer objetivos basndose en la competencia. Proceso de Mejora Otra parte importante de la metodologa de Bootstrap, es el plan de mejora que sugiere. El proceso para obtener el plan de mejora es, Primero evaluar las necesidades de la organizacin 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 revisin y anlisis de resultados de la evaluacin, tomando en cuenta las fortalezas y debilidades detectadas. Despus definir las capacidades a mejorar, considerando un perodo entre 18 y 24 meses. Enseguida, definir las prioridades de acuerdo a un anlisis de impactos. Finalmente sobre la base de las actividades definidas, modificar la organizacin y responsabilidades para iniciar el cambio, estableciendo un marco de tiempos para su desarrollo y evaluacin.
119
El Modelo ISO/SPICE Software Process Improvement and Capability Determination La Organizacin Internacional para la Estandarizacin (ISO) cre el grupo de trabajo WG 10 y le encomend el desarrollo del estndar internacional de Valuacin de Procesos de Software. El grupo de trabajo (Working Group) WG 10, empez a trabajar en enero de 1993 bajo la direccin de Alec Dorling y Peter Simms, y decidieron crear el proyecto SPICE Software Process Improvement and Capability Determination; la E de SPICE corresponda, originalmente, a "evaluation" y fue cambiado porque en algunos idiomas se traduca equivocadamente. Una de las caractersticas sobresalientes de este proyecto de estandarizacin es que incluy un periodo de pruebas del estndar de 2 aos. Es decir, antes de ser publicado como estndar se haba estado ajustando por la prctica. Arquitectura del Modelo El modelo es tridimensional: la primera dimensin es funcional (procesos), la segunda de capacidades (niveles), y la tercera de adecuacin o efectividad (calificaciones). La dimensin PROCESO: Est organizada jerrquicamente de la siguiente manera: CATEGORA DE PROCESOS, que agrupan procesos comunes; PROCESOS, que logran propsitos tcnicos; PRCTICAS BSICAS, operaciones que conforman un proceso. Las categoras definidas son: Cliente-Proveedor, Ingeniera, Proyecto, Organizacin y Soporte. La dimensin CAPACIDAD: Est organizada ordinalmente en niveles de capacidad y se han definido cinco niveles. En la versin 1.0 estos niveles son: Desempeo informal, Planeacin y seguimiento bien definido, Cuantitativamente controlado, Mejora continua. Est en etapa de instrumentacin una versin 2.0. La tercera dimensin es la CALIFICACIN: El juicio mismo: qu calificacin 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 Evaluacin
Marco de Valor El Modelo ISO/SPICE tiene un marco de valor explcito.
120
En la dimensin funcional o de proceso: las "mejores prcticas". En la dimensin de capacidad: los atributos de proceso o prcticas genricas que incrementarn la capacidad del proceso. Este es uno de los componentes ms valiosos del estndar internacional. Evidencia La evidencia para la evaluacin sern los productos producidos por las prcticas base. ste es un enfoque de efectividad "por sus frutos los conoceris". Cada producto tipo ha sido catalogado y sus caractersticas de calidad definidas. Este es otro elemento filosfico fundamental de ISO/SPICE: no es un modelo nominalista. Recurrencia Por ltimo el elemento recurrencia, para fundamentar un juicio o evaluacin vendr dada por la seleccin 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 caracterstica a producto, de producto a prctica, y de prctica 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 algn manual de calidad o de procesos. Estndares y modelos de evaluacin y mejora de los procesos software.
121
122
CONCLUSIONES
Es casi imposible resumir y condensar en pocas pginas la gran cantidad de informacin disponible sobre el tema. A modo de ejemplo de esos volmenes, sobre el tema Programacin Orientada a Objetos en Internet quiero destacar: Buscador Google Yahoo Altavista Proveedor de libros Amazon.com Sun Microsystems Sitios encontrados En castellano En cualquier idioma 110.000 8.560.000 93.700 5.640.000 94.200 --volmenes encontrados En cualquier idioma 3.484 32
Como puede verse existe mucha informacin sobre el tema. La misma simbologa ya es una gran nebulosa de la Tecnologa de Objetos (OT), pero al menos se expondrn algunas consideraciones prcticas extradas de la aplicacin con los alumnos en la ctedra Programacin IV, desde el ao 2000 de lenguajes, tcnicas y mtodos orientados-a-objetos. La eleccin del Lenguaje de Programacin Es opinin antigua, firme y consensuada que no existe la solucin ideal al elegir un lenguaje de programacin, pero tambin se acepta de forma unnime que la Orientacin a Objetos proporciona ventajas evidentes en el desarrollo genrico de software. Naturalmente lo ms fcil es pensar que los "nuevos" mtodos 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 cdigo eminentemente funcional modificndolo y aadindole 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 orientacin-a-objetos y se empiezan a bosquejar diseos pertinentes. Postulante (6-18 meses): los conceptos ya se aplican con soltura en el desarrollo, pero todava se dan algunos problemas con la modelizacin. Experto (gur): todo son objetos, y el sujeto se pregunta: cmo pude pensar antes de otra manera? Este estadio no siempre se alcanza, naturalmente (afortunadamente, segn algunos).
Y para fundamentar, aun ms la gran profusin de mtodos con bases tericas, veamos algunos de los actuales mtodos de OOA/OOD (Anlisis Orientado a Objetos/Diseo Orientado a Objetos):
123
METODOS Object Oriented Design Object Behaviour Analysis Methodology for Object Oriented Software Engineering of Systems General Object Oriented Design Object Oriented Software Engineering Visual Modeling Technique Texel Object Modeling Technique Better Object Notation Object Oriented System Analysis Object Oriented Structured Design Systems Engineering OO Syntropy Object Oriented Jackson Structured Design Hierarchical Object Oriented Design Object Oriented Analysis Object Oriented Design Object Oriented System Analysis Colbert Frame Object Analysis Semantic Object Modelling Approach Berard ADM3 Ptech Object Oriented Rle Analysis, Synthesis and Structuring Fusion Desfray Responsability Driven Design
OOD OBA MOSES GOOD OOSE IBM OMT BOM OOSA OOSD SEOO OOJSD HOOD OOA OOD OSA FOA SOMA
AUTORES Grady Booch Rubin & Goldberg Henderson-Sellers & Edwards Seidewitz & Stark Ivar Jacobson IBM Texel Rumbaugh y otros Nerson Shlaer & Mellor Wasserman et al. LBMS Cook y otros Jackson ESA Coad & Yourdon Coad & Yourdon Embley y otros E. Colbert Andleigh/Gretzingr Ian Graham Berard Donald Firesmith Martin & Odell Reenskaug et al. Coleman y otros Softeam Wirfs-Brock et al.
OOA&D OORASS
CRC
La realidad es que, es muy difcil diferenciar si uno es mejor que el otro. Cada autor tiene sus flaquezas y fortalezas. La experiencia y la revisin real de la gestin de proyectos orientados-a-objetos en distintas empresas muestra que el xito siempre ha ido acompaado de una visin particularizada de OOA/OOD acorde con la poltica de la empresa, las peculiaridades del equipo de desarrollo, la experiencia en determinados lenguajes de programacin y la naturaleza concreta de cada proyecto, dentro de unos mrgenes ms o menos estables de actuacin. En el mbito acadmico, quiero destacar, luego de 4 aos de dictar en la ctedra Programacin IV el Paradigma de Objetos, las siguientes conclusiones: Los alumnos se entusiasman con el concepto, pero tienen un pequeo grado de dificultad al iniciar el diseo de los objetos, definitivamente, les cuesta un poco pensar de manera abstracta. Creo que como todo en su nivel inicial, luego su prctica
124
profesional los pulir con un mejor diseo. Por ahora en la ctedra pregonamos el ensear la tcnica.
Conclusiones y Perspectivas a Futuro

En la etapa de investigacin bibliogrfica, en la que he utilizado intensamente la fuente inagotable de Internet, he podido comprobar que hay muchsimas pginas 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 terico, como as tambin ejemplos pertinentes en cada caso. Los ejemplos dados, en general, son similares a los que pueden encontrarse en la literatura especfica, esto es as porque son los ms sencillos para la comprensin de los conceptos. Este material permitir que los alumnos interesados en profundizar la temtica de Programacin Orientada a Objeto, tengan una fuente alternativa completa, clara y precisa sobre los principales tpicos de la POO. As tambin, el cdigo provisto les permitir visualizar rpida y fcilmente la implementacin de esos conceptos.
Perspectivas a futuro
Cmo actividades complementarias y, en cierta manera, como una continuacin de este trabajo, se propone la instrumentacin del concepto SOFTWARE DE CALIDAD ya sea en esta ctedra o como una ctedra 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 disposicin 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 temtica especfica. Un foro de discusin sobre el tema POO, destinado a alumnos y docentes. El material de los trabajos prcticos, con test, resultados de los trabajos prcticos, pizarra de novedades, Otros trabajos relacionados con el tema. Con esto se pretende darle mayor difusin a la temtica, promover la participacin de los alumnos y los docentes del rea y generar la sinergia necesaria para lograr una mejor formacin de nuestros recursos humanos, que garanticen una exitosa insercin laboral, como as tambin, 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
125
Glosario.
GLOSARIO
Abstraccin por especificacin: Disciplina de programacin que busca que el programador defina qu es lo que hace cada uno de los mdulos que componen un programa o sistema, an antes de realizar la implementacin. Abstraccin por parametrizacin: Uso de argumentos en procedimientos y rutinas. Abstraccin: Proceso por medio del que se elimina informacin para lograr tratar cosas diferentes como si fueran iguales. De esta forma se separan las caractersticas de un ente en dos grupos, el de las caractersticas que importa y el de las que sobran, para tomar en cuenta nicamente aquellas relevantes a la solucin de un problema. Abstraccin (2): ignorar aquellos aspectos que no sean relevantes al propsito actual para concentrarse ms profundamente en aquellos que lo son. Asociacin y mensajes: los objetos de un sistema se relacionan y se comunican entre s. Asociacin: Relacin de uso en general. Atributos: Datos que caracterizan las instancias de una clase. Calificacin: Limita la multiplicidad de las asociaciones. Clases: Abstraccin de objetos con propiedades comunes. Composicin: Relaciones todo/parte. Concatenacin: Unir elementos. Constructores y Destructores: Facilidad de un lenguaje de programacin 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 adems son invocadas automticamente por el compilador. En general, la misin principal de los destructores es devolver la memoria dinmica asociada a un objeto. Encapsulacin: 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 programacin que permite definir un tipo de datos junto a sus operaciones, con el fin de obtener un tipo abstracto de datos. Enlace dinmico: 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 ejecucin. Enlaces: Instancias de una relacin. Relaciona instancias Especificacin: Proceso por medio del que se definen las caractersticas de un ente. Generalizacin. Relaciones padre/hijo. Herencia (Extensin de tipos): Facilidad del lenguaje de programacin que permite extender un tipo de datos, agregando al final nuevos campos. El efecto de la herencia puede simularse en la mayora de los lenguajes tradicionales, pero el resultado es un programa menos elegante y en muchos casos mucho ms difcil de programar. Herencia: expresa la similitud entre clases de objetos, mostrando la especializacin de los estados y los comportamientos de las clases de objetos de nuestro sistema en forma jerrquica. Instancias: Cada uno de los objetos individuales. Iteradores: Abstraccin que permite obtener todos los elementos contenidos en un tipo abstracto de datos contenedor. Los contenedores ms usuales son los arreglos, las listas, los conjuntos, los rboles y en menor grado los grafos.
127
Glosario.
Mensaje: Nombre del mtodo con que se invoca a una operacin sobre un objeto. Los trminos mtodo y operacin son sinnimos, pero uno se usa en el contexto de Programacin por Objetos y el otro en el de Abstraccin de Datos. Mtodo: Operacin que es definida junto a un tipo de datos en aquellos lenguajes que soportan encapsulamiento. Mdulos: 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 mdulo no sea necesario hacerlo en otros. En estos casos, se dice que los mdulos tienen una cohesin baja. Multiplicidad: Nmero de instancias que intervienen en la relacin. Ocultacin de Datos: Facilidad de un lenguaje de programacin 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 programacin que soporta polimorfismo permite diferir la definicin de la operacin que debe aplicarse un objeto al momento en que esa operacin 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 cul es ese procedimiento. Polimorfismo: es la propiedad de dos o ms clases para responder al mismo mensaje, cada una de ellas segn su especificacin. Procedimiento o rutina: Facilidad sintctica de los lenguajes de programacin que le permiten al programador aislar la solucin de un problema particular en un mdulo. Mediante el uso de procedimientos es posible aplicar la abstraccin por parametrizacin y por especificacin. Programacin Estructurada: Conjunto de prcticas y disciplinas de programacin que se basan en el uso de Abstraccin por parametrizacin y por especificacin para construir sistemas. Adems, un lenguaje de programacin soporta la Programacin Estructurada si cuenta con las construcciones sintcticas 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 jerarqua de procedimientos, usando la descomposicin de Arriba hacia Abajo [Top-Down]. Programacin Orientada a los Objetos [OOP] [POO]: Uso de unas tcnicas de Abstraccin de Datos en un lenguaje que tambin soporta Encapsulamiento, Herencia y Polimorfismo. Redefinicin: Modificacin 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 programacin 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 programacin 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 aritmticos [+ - * / ^] en expresiones.
128
Glosario.
Tipos Abstractos de Datos: Es un el uso de una tcnica de abstraccin que busca juntar en un slo mdulo toda la programacin 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.
129
Bibliografa.
BIBLIOGRAFA
Patterson J., Stephenson C., Introduction to Programming in Java, University of Toronto Press, 2000 Castillo, E., Cobo A., Gmez P., Solares C. Java Un lenguaje de programacin multiplataforma para Internet. Paraninfo, 1997. Newman, Alexander. Using Java. Macmillan Computer Publishing, 1996. Froufe, Agustn. 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 Ampliacin de Informtica. Java y la POO. Universidad de Zaragoza Espaa. Parra Fuente, Javier. Curso Java Avanzado. Departamento de Lenguajes y Sistemas Informticos, Univ. Pontificia de Salamanca en Madrid Venners, Hill. Designing with interfaces. Java World (http://www.javaworld.com/), 12/1998. Grady Booch, Anlisis y Diseo orientado a objetos. Ed. Addison Wesley Iberoamericana. Sitio Web Oficial de Sun Microsystem www.java.sun.com Pgina de descargas de la Universidad de Castilla La Mancha http://scalab.uc3m.es/~docweb/pr-inf/index.html Revista electrnica sobre java www.javaworld.com Tutorial Java Avanzado www.geocities.com TUTOR JAVA www.programacion.net Gua de Pginas OO. www.well.com/user/ritchie/oo.html#index por Ricardo Devis Gua de Pginas y Lenguajes OO. Universidad Alicante, Espaa www.dlsi.ua.es/asignaturas/poo/Enlaces Jakarta Tomcat, http://jakarta.apache.org/tomcat/ Stevens, Jon S. You Make the Decisin, http://jakarta.apache.org/velocity/ymtd/ymtd.html. Hunter, J The Problems with JSP,http://www.servlets.com/soapbox/problems-jsp.htmp Notas especficas 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
131
Programas ejemplo. Clases abstractas.
PROGRAMAS EJEMPLO DE LOS TEMAS TRATADOS.

Redefinicin de mtodos /*Programa 1 - Versin 1*/
/* REDEFINICIN:(OVERRIDEN) Una clase puede redefinir (volver a * definir) cualquiera de los mtodos heredados de su super-clase * que no sean final. * El nuevo mtodo sustituye al heredado para todos los efectos * en la clase que lo ha redefinido. * Con Funciones Redefinidas en Java se utiliza siempre * Vinculacin tarda */ //CLASE PADRE class Oceania { // se definen 3 constantes de tipo cadena (variables // finales) final String e1="Australia",e2="Fidji",e3="Nueva Zelanda"; public void descripcin() { 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 descripcin() { 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.descripcin(); // ejecuta el mtodo "descripcin" de la clase // hija } } /*el mtodo descripcin que estaba definido en la clase * padre(Oceana), se redefine en la clase hija Australia/
133
/*Programa 1
- Versin 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 descripcin() { estado[0]="Australia"; estado[1]="Fidji"; estado[2]="Nueva Zelanda"; System.out.println("Principales Estados de Oceana"); for(int i=0;i<3;i++){ System.out.println(estado[i]); } }
//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 descripcin() { 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 // "Oceana" Australia ciudad = new Australia(); // Crea un objeto "ciudad" de la clase Hija // "Australia" estado.descripcin(); // (variante) ejecuta el mtodo "descripcin" de la // clase padre ciudad.descripcin(); //ejecuta el mtodo "descripcin" de la clase hija } }
134
/*Programa 1
- Versin 3*/
//CLASE PADRE class Oceania { String estado[]=new String[3]; public void descripcin() { 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]); } } } //CLASE HIJA (derivada) class Australia extends Oceania { final String capital="Canberra"; // se define una constante(variable final) y se le asigna // el valor Canberra public void descripcin() { 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 descripcin() { 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.descripcin(); // ejecuta el mtodo "descripcin" de la clase hija // "Australia" ciudad =new Fidji(); // La misma referencia "apunta" al nuevo objeto creado de // la clase hija "Fidji" ciudad.descripcin(); // ejecuta el mtodo "descripcin" de la clase hija "Fidji"
135
Modelos de Ejecucin Versin 1: La capital de Australia es: Canberra
Versin 2: Principales Estados de Oceana Australia Fidji Nueva Zelanda La capital de Australia es: Canberra
Versin 3: Principales Estados de Oceana Australia Fidji Nueva Zelanda La capital de Australia es: Canberra La capital de Fidji es: Suva
136
/*
Programa 2
*/
/* Cuando una clase deriva de otra hereda la funcionalidad de la * clase padre, pero adems una clase hija, puede * sobreescribirla.Podemos escribir un mtodo en la clase hija * que tenga el mismo nombre y los mismos parmetros que un * mtodo de la clase padre */ class Mamifero { public void descripcin() { System.out.println("El mamfero es un Vertebrado"); } } class Perro extends Mamifero { public void descripcin() { System.out.println("Mamifero carnivoro "); } } public class Animales { public static void main(String[] args) { Perro Toby = new Perro(); Toby.descripcin(); } } // Al ejecutar el programa veremos que se escribe el mensaje de // la clase hija, no el del padre. Modelos de Ejecucin Mamifero carnivoro
137
Sobrecarga de mtodos /*Programa 1 - Versin 1*/
/* El concepto de polimorfismo, en cuanto a cambio de forma, se * puede extender a los mtodos. * Java permite que varios mtodos dentro de una clase se llamen * igual, siempre y cuando su lista de parmetros sea distinta *(en cuanto a nmero o tipo de argumentos). * / /** Diversos modos de sumar (versin esttica)*/ 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)); } } Modelos de Ejecucin versin 1 suma de reales 3.0 suma de enteros 8
138
/*Programa 1
- Versin 2*/
/** Diversos modos de sumar(versin flexible) */ public class Sumar { // mtodo 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"); } } // mtodo de clase(Static) que arroja valores REALES public static float suma(float a, float b) { System.out.println("suma de reales"); return a+b; } // mtodo de clase(Static) que arroja valores ENTEROS public static int suma(int a, int b) { System.out.println("Estoy sumando enteros"); return a+b; } }
139
Modelos de Ejecucin versin 2 C:\ Por 1er 2do 3er JAVA Sumar Favor ingrese 3 valores valor --> 1er sumando valor --> 2do sumando valor --> 1 para sumar enteros --> 2 para sumar reales 7 ser: enteros reales
C:\JAVA Sumar 7 7 El 3er valor debe 1: si desea sumar 2: si desea sumar
C:\JAVA Sumar 7 7 1 Suma de enteros 14 C:\Sumar 7 7 2 Suma de reales 14.0
140
/** Programa 2 */ /** Calcula el rea de un rectngulo */ public class Rectangulo { private int largo,ancho; // variables privadas: nicamente se podrn utilizar en // esta clase // metodo principal donde comienza la ejecucin 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 Rectngulo - se pasa // como argumento los valores n1 y n2 Rectngulo rec1 = new Rectngulo(n1,n2); // crea un objeto de la clase Rectngulo sin // argumentos Rectngulo rec2 = new Rectngulo(); System.out.println("rea Rectngulo Usuario"); // Llama implcitamente al mtodo calcularArea(con // argumentos) System.out.println(rec1.calcularArea()); System.out.println("rea Rectngulo Computadora"); // Llama implcitamente al mtodo 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 Mtodo Constructor pues se pas 2 // argumentos durante su creacin
public Rectangulo(int lar, int anch) { largo = lar; // largo y ancho tendrn los valores ingresado por el // usuario ancho = anch; }
141
// rec2 utiliza este Mtodo Constructor pues no se pas // argumento alguno durante su creacin public Rectangulo() { // largo y ancho tendrn valores aleatorios ingresados por la // funcin random de la clase Math largo = (int)(Math.random()*10); ancho = (int)(Math.random()*10);
// mtodo al que se llama con los objetos rec1 y rec2 en el // mtodo main(principal) public float calcularArea() { int area=(int)Math.abs(largo*ancho); return area; //e es el valor que se devuelve al programa llamador }
Modelos de Ejecucin 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
142
/*Programa 3 */ /** Aproximacin al Nmero E */ /** Este ejemplo utiliza los mtodos de la clase PrintStream que * proporciona utilidades para dar formato a la salida. Dichos * mtodos son print y println que estn SOBRECARGADOS para los * tipos primitivos, cadenas y arrays de caracteres. * La diferencia entre ambos mtodos est en que println aade un * carcter de nueva lnea. Adems el mtodo println puede * llamarse sin argumentos, produciendo una nueva lnea. */ 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 nmero 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.EnumE)); } catch(ArrayIndexOutOfBoundsException e){ System.out.println("Por favor ingrese el valor
143
con el cual desea aproximarse al num E ");
Explicacin del Algoritmo Existe una forma de aproximarse al nmero e = 2.71828182.... mediante la siguiente frmula: 1/0! + 1/1! + ............+1/N! , la cual tiende al nmero e cuando N tiende a infinito. Por lo tanto en este programa se define la clase NumE, el mtodo constructor y las variables necesarias. Utilizamos un vector de n+1 elementos, recorrindolo mediante un bucle For y lo cargamos con el factorial correspondiente a cada posicin (pos 0 --> 0!, .pos N --> N! ). Posteriormente se calcula y se da salida al nmero aproximado obtenido, determinando adems el margen de error existente (e - valor aproximado)
Modelos de Ejecucin 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
144
/*Programa 4 */ /** Este ejemplo compara un nmero ingresado por el usuario con * un valor aleatorio arrojado por la mquina determinando cual * es el mayor en trminos de Enteros y Decimales * * Mtodos Sobrecargados: * El Mtodo "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 nmero 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 funcin 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 precisin 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");}
145
Modelos de Ejecucin 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
146
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, proporcionndoles un modelo a seguir y * algunos mtodos de utilidad general. */ abstract class LenguajesDeProgramacion { String[] nom=new String[4]; public abstract void detalle(); // mtodo abstract(no se da su definicin) } 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(); } } Modelos de Ejecucin C:\ java Abstractos Lenguajes Declarativos Funcionales lisp Hope Miranda Haskell
147
/**Programa 2 versin 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(); } }
Modelos de Ejecucin C:\ java Medicina La vitamina A se encuentra en: vegetales Yema de Huevo Leche
148
/**Programa 2 versin 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(); } } Modelos de Ejecucin 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
149
Programas ejemplo. Polimorfismo.
Polimorfismo /*Programa 1 versin1 */ /** En muchas ocasiones, cuando utilizamos herencia podemos * terminar teniendo una familia de clases que comparten un * interfaz comn. */ //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 mtodo de la clase PADRE) class Objetos extends Lenguajes { public void detallar() { // se redefine como public el mtodo 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 mtodo 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) {
151
// el mtodo detalle utiliza un objeto "m" de la // clase Lenguajes m.detallar(); // se llama al mtodo detallar con un argumento // Implcito objeto.mtodo
// mtodo 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 mtodo detalle pasando el objeto "leng1" // como argumento explcito detalle(leng2); // llama al mtodo detalle pasando el objeto "leng2" // como argumento explcito
/*el mtodo detalle llama al mtodo detallar ejecutndose las * sentencias que componen este ltimo mtodo para el objeto * especifico que lo llama.*(primero llama a un leng. Orientado a Objetos y luego a un * leng. Declarativo) */ Modelos de Ejecucin Lenguajes de Prog.Orientados a Objetos C++ Java Eiffell Lenguajes de Prog.Declarativos Lisp Prolog Haskell
152
/*Programa 2 versin 1 */ /** CALCULA AREAS DE DISTINTAS FIGURAS (versin esttica)*/ abstract class Figura{ abstract public double area(); } //clase abstracta
class Circulo extends Figura{ //clase derivada de Figura private double radio; // var private solo podr ser utilizada por la clase // Crculo final double pi=3.1416; // var final: (constante) no puede cambiar su valor durante // la ejecucin del prog. // mtodo constructor de la clase Circulo utiliza un // argumento pasado por referencia desde el mtodo main // (principal) Circulo(double r){ radio=r; } // redefinicin del mtodo 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 ejecucin del // programa)
153
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 informacin obtenida // en la ejecucin del programa System.out.println(); System.out.println("TRIANGULO"); System.out.println("base: "+n1 + " altura: "+ 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"); }
n2);
154
Modelos de Ejecucin
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 Area 17.5 CUADRADO lado: 8.0 Area: 64.0 CIRCULO radio: 2.0 Area 12.5664 altura: 5.0
155
/**Programa 2 versin 2 */ /**CALCULAR AREA DE DISTINTAS FIGURAS (versin flexible)*/ abstract class Figura{ abstract public double area(); } class Circulo extends Figura{ private double radio; final double pi=3.1416; // mtodo constructor de la clase Circulo // utiliza un argumento pasado por referencia desde el // mtodo main(principal) Circulo(double r){ radio=r; } // redefinicin del mtodo 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 } // clase abstracta
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; } }
156
class Polimorfismo{ // constructor principal (donde comienza la ejecucin 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 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;
157
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 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; } }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 interacta con el usuario brinddole la * posibilidad de elegir de que figura desea calcular el rea */
158
Modelos de Ejecucin
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
159
/**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 pulsacin 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 ctricos 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 mtodo abstracto } // clase derivada de Verduras class Espinacas extends Verduras{ public void aporte(){ System.out.println("Las Espinacas aportan vitamina B9"); } }
160
// 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 ms all del que * proporciona la herencia simple. * Si solamente hubiese herencia simple, Citricos tendra que * derivar de la clase Verduras (lo que no es lgico) o bien no * se podra pasar a la funcin 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 funcin "que_aporta". * Esta es la razn por la cual las interfases proporcionan ms * polimorfismo que el que se puede obtener de una simple * jerarqua de clases. */ Modelos de Ejecucin Las Espinacas aportan vitamina B9 El tomate aporta vitamina k
161
Programas ejemplo. Ligaduras Dinmicas.
Ligaduras dinmicas /** 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 } public double area(){ //redefine el mtodo abstracto de la clase Base return Math.PI*radio*radio; //retorna el valor del rea del crculo } } class Cuadrado extends Figura{ protected double lado; public Cuadrado(double lado){ this.lado=lado; } public double area(){ return lado*lado; } } /* variables PROTECTED: slo 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. */
163
Programas ejemplo. Ligaduras Dinmicas.
/**Subprograma 2*/ package Figura; public class FiguraApp { public static void main(String[] args) { // enlace temprano: tiempo de compilacin 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 tardo 1: tiempo de ejecucin // 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 tardo 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) {}
Modelos de Ejecucin C:\ java Area del Area del Area del Area del FiguraApp circulo 95.03317777109123 cuadrado 30.25 circulo 12.566370614359172 cuadrado 9.0
164

Lazzarini

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Lazzarini

Uploaded by

Copyright:

Available Formats

Tesis Hctor Csar Lazzarini

UNIVERSIDAD NACIONAL DE MISIONES

Direccin electrnica: lazzariniylazzarini@arnet.com.ar

Tesis Hctor Csar Lazzarini

Tesis Hctor Csar Lazzarini

Tesis Hctor Csar Lazzarini

Tesis Hctor Csar Lazzarini

Tesis Hctor Csar Lazzarini

Formosa, 14 de mayo de 2005

Captulo 1 Introduccin a la Programacin Orientada a Objetos.

Capitulo 1 INTRODUCCIN A LA PROGRAMACIN ORIENTADA A OBJETOS (POO)

Captulo 1 Introduccin a la Programacin Orientada a Objetos.

Captulo 1 Introduccin a la Programacin Orientada a Objetos.

Captulo 1 Introduccin a la Programacin Orientada a Objetos.

Captulo 1 Introduccin a la Programacin Orientada a Objetos.

Captulo 1 Introduccin a la Programacin Orientada a Objetos.

Captulo 1 Introduccin a la Programacin Orientada a Objetos.

Captulo 1 Introduccin a la Programacin Orientada a Objetos.

Captulo 2 Programacin Orientada a Objetos Fijando Conceptos.

Capitulo 2. PROGRAMACIN ORIENTADA A OBJETOS FIJANDO CONCEPTOS

Captulo 2 Programacin Orientada a Objetos Fijando Conceptos.

Captulo 2 Programacin Orientada a Objetos Fijando Conceptos.

Captulo 2 Programacin Orientada a Objetos Fijando Conceptos.

Captulo 2 Programacin Orientada a Objetos Fijando Conceptos.

Captulo 2 Programacin Orientada a Objetos Fijando Conceptos.

Captulo 2 Programacin Orientada a Objetos Fijando Conceptos.

Captulo 2 Programacin Orientada a Objetos Fijando Conceptos.

Captulo 2 Programacin Orientada a Objetos Fijando Conceptos.

Captulo 2 Programacin Orientada a Objetos Fijando Conceptos.

Capitulo 3. JAVA Y LA PROGRAMACIN ORIENTADA A OBJETOS

Captulo 3 Java y la Programacin Orientada a Objetos.

Captulo 3 Java y la Programacin Orientada a Objetos.

Captulo 3 Java y la Programacin Orientada a Objetos.

Captulo 3 Java y la Programacin Orientada a Objetos.

Captulo 3 Java y la Programacin Orientada a Objetos.

Captulo 3 Java y la Programacin Orientada a Objetos.

Captulo 4 Conceptos de Orientacin a Objetos.

Capitulo 4. PROFUNDIZANDO CONCEPTOS DE POO EJEMPLOS CON JAVA

Captulo 4 Conceptos de Orientacin a Objetos.

class B extends A { // variables de instancia // mtodos }

Captulo 4 Conceptos de Orientacin a Objetos.

java.applet: Clases que implementan las Applets de Java, incluyendo

Captulo 4 Conceptos de Orientacin a Objetos.

public void mostrar(){ System.out.println("posicin : x

Captulo 4 Conceptos de Orientacin a Objetos.

Ventana ventana=new Ventana (0, 0, 20, 30);

Desde el objeto ventana podemos llamar a las funciones miembro pblicas

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

Captulo 4 Conceptos de Orientacin a Objetos.

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

public void mostrar(){ super.mostrar(); System.out.println("titulo }

public void mostrar(){ //ojo!,funcin recursiva System.out.println("titulo : "+titulo); mostrar(); }

Captulo 4 Conceptos de Orientacin a Objetos.

Creamos un objeto ventana de la clase derivada VentanaTitulo

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

public class Ventana { protected int x; protected int y; //... }

Captulo 4 Conceptos de Orientacin a Objetos.

Default Private Protected Public

Default Private Protected Public

Captulo 4 Conceptos de Orientacin a Objetos.

Captulo 4 Conceptos de Orientacin a Objetos.

public String toString() { return getClass().getName() + "@" + Integer.toHexString(hashCode()); }

Captulo 4 Conceptos de Orientacin a Objetos.

Captulo 4 Conceptos de Orientacin a Objetos.