Tesis Héctor César Lazzarini

UNIVERSIDAD NACIONAL DE MISIONES
FACULTAD DE CIENCIAS ECONOMICAS MAESTRIA EN INFORMÁTICA Y COMPUTACIÓN 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: Héctor César Lazzariinii Maestrando: Héctor César Lazzar n
Dirección Postal: Moreno 155 – P3600KAC Formosa – Formosa – Argentina

Dirección electrónica: lazzariniylazzarini@arnet.com.ar

1

Tesis Héctor César Lazzarini

TABLA DE CONTENIDOS
TABLA DE CONTENIDOS........................................................................................................ 1 Agradecimientos:........................................................................................................................... 7 Prólogo .......................................................................................................................................... 9 Capitulo 1 .................................................................................................................................... 11 INTRODUCCIÓN A LA PROGRAMACIÓN ORIENTADA A OBJETOS (POO) ..................... 11 Un poco de historia de la POO........................................................................................... 11 Ideas básicas de la POO .................................................................................................... 14 Ventajas e inconvenientes de la orientación a objetos ...................................................... 15 El modelo OO ..................................................................................................................... 15 Definiciones básicas ........................................................................................................... 16 Diferencia entre el modelado por descomposición funcional y el OO................................ 17 Descomposición OO........................................................................................................... 18 Capitulo 2. ................................................................................................................................... 19 PROGRAMACIÓN ORIENTADA A OBJETOS – FIJANDO CONCEPTOS ........................... 19 Introducción. ....................................................................................................................... 19 Información ......................................................................................................................... 19 Sistemas de información. ................................................................................................... 20 Profundizando el concepto de Objeto. ............................................................................... 20 Demonios............................................................................................................................ 23 Abstracción. ........................................................................................................................ 24 Modularidad. ....................................................................................................................... 24 Encapsulación de objetos................................................................................................... 24 Reutilización. ...................................................................................................................... 25 Clase................................................................................................................................... 25 Herencia.............................................................................................................................. 26 Polimorfismo. ...................................................................................................................... 27 Jerarquías. .......................................................................................................................... 27 Mensajes............................................................................................................................. 28 Capitulo 3. ................................................................................................................................... 29 JAVA Y LA PROGRAMACIÓN ORIENTADA A OBJETOS.................................................... 29 Introducción. ¿Porqué Java?.............................................................................................. 29 Origen de Java. .................................................................................................................. 29 Características de Java ...................................................................................................... 31 Capitulo 4. ................................................................................................................................... 37 PROFUNDIZANDO CONCEPTOS DE POO – ejemplos con JAVA ...................................... 37 1. Herencia.......................................................................................................................... 38 2. Sobrescritura de métodos............................................................................................... 38 3. La clase base y la clase derivada................................................................................... 38 En Java disponemos de los paquetes básicos: ............................................................. 39 La clase base object. ...................................................................................................... 45 Métodos que pueden ser redefinidos por el programador. ............................................ 45 Concretando: .................................................................................................................. 48 4. Redefinición de métodos heredados .............................................................................. 48 Modificador final:............................................................................................................. 49 5. Clases y métodos abstractos ......................................................................................... 49 6. Polimorfismo ................................................................................................................... 49 Métodos (funciones miembro). ....................................................................................... 52 Métodos sobrecargados (overloaded)............................................................................ 54 7. Vinculación, Ligadura o Binding ..................................................................................... 49 8. Redefinición .................................................................................................................... 55 Sobrecarga de Constructores......................................................................................... 55 Objetos como parámetros .............................................................................................. 56 Paso de argumentos. ..................................................................................................... 56 El operador static............................................................................................................ 57 Las variables static ......................................................................................................... 57 Los métodos static.......................................................................................................... 58

3

Tesis Héctor César Lazzarini

El operador final.............................................................................................................. 59 9. Interfases. ....................................................................................................................... 59 ¿Qué diferencia hay entre una interfase y una clase abstract?..................................... 59 Definición de interfases. ................................................................................................. 60 Utilización de interfases.................................................................................................. 60 Conceptos Útiles............................................................................................................. 61 La llamada a super. ........................................................................................................ 61 10. Permisos de acceso en java......................................................................................... 61 Accesibilidad de los Packages (paquetes)..................................................................... 61 Accesibilidad de las Variables y Métodos Miembros de una Clase. .............................. 62 Resumen de los permisos de acceso de Java............................................................... 62 11. Transformaciones de tipo: casting................................................................................ 63 Conversión de tipos primitivos........................................................................................ 63 12. Sincronización de threads (hilos). ................................................................................ 63 Capítulo 5. ................................................................................................................................... 65 Implementación de los conceptos de oo con JAVA................................................................ 65 Implementado el concepto Jerarquía ................................................................................. 65 La clase Figura ............................................................................................................... 66 La clase Rectángulo ....................................................................................................... 66 La clase Círculo .............................................................................................................. 67 Uso de la jerarquía de clases. ............................................................................................ 67 Enlace dinámico o binding.................................................................................................. 68 Ejemplo de polimorfismo. ............................................................................................... 68 Ampliación de la jerarquía de clases.................................................................................. 70 La clase Triangulo. ......................................................................................................... 71 El operador instanceof........................................................................................................ 72 En resumen:........................................................................................................................ 72 Clases y Métodos Finales................................................................................................... 73 Interfases. ........................................................................................................................... 74 Diferencias entre una Interfase y una Clase Abstracta. ..................................................... 75 Las interfases y el Polimorfismo......................................................................................... 76 Herencia simple. ................................................................................................................. 76 Composición. ...................................................................................................................... 79 La clase punto ................................................................................................................ 80 La clase Rectangulo ....................................................................................................... 81 Definiendo Clases............................................................................................................... 83 Uso de Atributos. ................................................................................................................ 85 Uso de la Definición de Clase............................................................................................. 86 Diseño e Implementación de Clases. ................................................................................. 86 Diseño de la clase: ............................................................................................................. 87 Implementación de la clase: ............................................................................................... 88 Primer Ejemplo Completo: Clase para Entrada/Salida Interactiva (InteractiveIO)......... 88 Segundo Ejemplo Completo: Clase Nombre.................................................................. 92 Programa Hello world ! Revisado ................................................................................. 100 Capítulo 6. ................................................................................................................................. 101 Calidad del Software......................................................................................................... 102 Objetivo de la Calidad en los Sistemas ............................................................................ 103 Control de la Calidad ........................................................................................................ 103 Control de Calidad del Software ....................................................................................... 104 Administración de la Calidad ............................................................................................ 108 Calidad por Etapas ........................................................................................................... 110 Estándares y Modelos de Calidad en la Ingeniería de Software...................................... 111 La Norma ISO 9000.......................................................................................................... 112 El Modelo Tick IT .............................................................................................................. 114 El Modelo CMM ................................................................................................................ 115 El Modelo BOOTSTRAP................................................................................................... 118 El Modelo ISO/SPICE....................................................................................................... 120 Conclusiones......................................................................................................................... 123

4

......................................................................... 148 /**Programa 2 – versión 2*/.......................................................... 149 Polimorfismo ............... 131 PROGRAMAS EJEMPLO DE LOS TEMAS TRATADOS......................................... .......................................................................................................................................................................................................................................................................................................................................................................................................................................... 163 /** Programa 1 */ /** Subprograma 1*/ .......................................................................................................................................... 160 Ligaduras dinámicas.............................................................. 138 /*Programa 1 ....................................................................................................................................................... 134 /*Programa 1 ... 164 5 ......................................................................................................................................... 133 /*Programa 1 .................................................................................... 123 Perspectivas a futuro ................ 151 /*Programa 2 – versión 1 */ ........................................................... 153 /**Programa 2 – versión 2 */..................... 160 /** subprograma 3*/ ....................................... 135 /* Programa 2 */ ................. 147 /** Programa 1 */......................................................................................................................................... 144 /*Programa 4 */ ................................. 156 /**Programa 3 */ /**subprograma 1*/................................................................ 137 Sobrecarga de métodos ................................................................................Versión 2*/ .................. 141 /*Programa 3 */ ................................................................................................. 160 /** subprograma 2*/ .............................................................................................................................................................Versión 3*/ ..........................................Tesis Héctor César Lazzarini La elección del Lenguaje de Programación ...................................................................................... 145 Clases abstractas .......................................................... 125 Bibliografía ................................................................. 147 /**Programa 2 – versión 1*/............................Versión 2*/ ........................................................................ 139 /** Programa 2 */..... 163 /**Subprograma 2*/ .............. 138 /*Programa 1 .................................... 133 /*Programa 1 ............................ 151 /*Programa 1 – versión1 */ ........................................ 143 Explicación del Algoritmo.........................................................................Versión 1*/ ................................................................................................. 133 Redefinición de métodos ......................................................................................................................................................................................................................Versión 1*/ .......................................................................

Tesis Héctor César Lazzarini 6 .

14 de mayo de 2005 7 . realmente es imposible dejar de recordarlos. A todos los profesores de España.Tesis Héctor César Lazzarini Agradecimientos: A toda la gente me alentó para que termine este trabajo. A todos: un “GRACIAS” sincero. Formosa. por su calidez humana y profesional.

.

Debo indicar que he escogido el lenguaje JAVA como soporte para explicar los conceptos a enseñar por su popularidad comercial y su aplicación actual en Internet. He tratado. 9 . Explicación de los conceptos con ejemplos básicos. y tal lo afirmado en el Proyecto original de esta Tesis. en este trabajo. por lo que deben aplicar inmediatamente estos conceptos. facilitar la incorporación de un nuevo concepto con un ejemplo ya visto. para. Este trabajo de Tesis se ha estructurado de la siguiente manera: Introducción histórica. en el marco de la materia PROGRAMACIÓN IV de la carrera Licenciatura en Sistemas de Información. Muchos de estos ejemplos van incorporando progresivamente cada nuevo concepto que se enseña. Puntualmente. En este libro se enseñaran los conceptos de la Programación Orientada a Objetos con abundantes ejemplos basados en el lenguaje JAVA. Glosario Listado de códigos de programas desarrollados donde se analiza cada concepto en particular. porque no debemos perder de vista que es una materia con la cual estos se reciben de Programadores Universitarios.Introducción Prólogo Los objetivos de este trabajo son establecer las pautas básicas para introducir a los alumnos en el mundo de la Programación Orientada a Objetos (POO). de esta manera. Conclusiones y perspectivas a futuro. Presentación de programas en Java que aplican puntualmente los conceptos impartidos. necesito formar a los alumnos con un concepto “entendible” de la POO. Se revisan los conceptos brevemente y se aplica a un ejemplo preciso. Explicación conceptual de los temas planteados. Se trata de programas que funcionan autónomamente. de compatibilizar ambas cosas. Bibliografía utilizada. No se incluyen ejemplos de ningún tipo. Presentación de diversos programas más genéricos que combinan varios conceptos combinados.

.

Capitulo 1 INTRODUCCIÓN A LA PROGRAMACIÓN ORIENTADA A OBJETOS (POO) Un poco de historia de la POO. En su corta historia. Así surgieron varios lenguajes que se hicieron famosos y también surgieron los primeros compiladores. surgió un grupo de científicos de la computación. A medida que las computadoras fueron haciéndose más sofisticadas. Los primeros avances metodológicamente ordenados. Hacer correcciones a este tipo de programas y agregarles mejoras se fue convirtiendo en una labor muy ardua. Es lo que se denominó la programación estructurada. Estos propusieron una serie de ideas que llevaron a la creación de ese nuevo concepto indicado al inicio: la programación estructurada. Por lo tanto podemos suponer que aún está en sus orígenes y que el futuro traerá todavía grandes adelantos técnicos y teóricos que mejorarán sus resultados. También surgió una idea que ayudaría a evitar los difíciles problemas que surgían en el manejo de la memoria dinámica: los constructores y destructores de objetos. sus lenguajes propios o lenguajes de máquina iban cambiando y surgió la necesidad de crear unos lenguajes intermedios que cualquier usuario pudiera aprender y que no dependieran de la máquina concreta en la que se iban a ejecutar los programas. para que realizara ciertas operaciones. En ellos se experimentó con otras ideas útiles como la definición de subclases que heredan las propiedades de su superclase o sea de la clase de la que se derivan.Capítulo 1 – Introducción a la Programación Orientada a Objetos. Otros científicos experimentaron ideas similares creando diversos lenguajes de programación orientada a objetos como Smalltalk. 11 . El tremendo éxito que las computadoras tuvieron a lo largo de los años 60 fue llevando a la creación de programas cada vez más complejos que llegaban a tener miles de líneas de código. Dijstra y de forma menos teórica pero quizás con más impacto por Kernighan y Ritchie. Los primeros lenguajes de programación eran simplemente instrucciones que se le podían dar a un autómata como una computadora. La aparición de estos lenguajes intermedios y sus compiladores marca el comienzo de la programación como una nueva ciencia. pero agregando variables y funciones nuevas. La programación de computadoras es una actividad humana que se ha desarrollado casi enteramente durante la segunda mitad del siglo XX. la programación ha sufrido importantes cambios. Ante este problema que amenazaba con convertir las computadoras en máquinas estériles. fueron protagonizados principalmente por Wirth. Un compilador es un programa que traduce las instrucciones de un lenguaje más o menos humano. diríamos “casi revoluciones”. de los cuales Dijstra y Wirth son dos de los más destacados. Así un programa no era sino una lista de instrucciones encaminadas a realizar algún cálculo. a las de una máquina.

Por lo tanto. Este truco ayudó a popularizar la programación orientada a objetos y preparó el camino para la aparición del Java.Capítulo 1 – Introducción a la Programación Orientada a Objetos. Nygaard. hay que entender bien todos los conceptos del modelo de objetos que está detrás de ella y sus antecedentes históricos. La razón es que los módulos que acceden a estas variables no se pueden comprender completamente. Parnas. Hacia los 80’s el paradigma orientado a objetos comenzaba a madurar como un enfoque concreto de desarrollo de software. Java se creó con un gran parecido al C++. el lenguaje C. Así. para hacer desarrollo de sistemas de software basados en la TOO. sólo mediante las cuales se podía tener acceso a estas variables. es decir. Se trata del C++ creado por Bjarne Stroustrup. 12 . tales como las bases de datos y/o las comunicaciones. Los programas que carecen de disciplina para acceder a variables globales tienden a ser inmanejables. por un grupo de investigadores dirigido por O. Este problema fue detectado alrededor de 1970 por David L. El resto de los módulos podrían acceder a las variables sólo de forma indirecta mediante las operaciones diseñadas a tal efecto. Microsoft está tratando de impulsar un nuevo lenguaje llamado C# (C sharp) que promete ser aún más puro como lenguaje orientado a objetos. tanto en el desarrollo de programas como en la forma de presentar las aplicaciones del sistema al usuario. adopta prácticamente todas las mejoras de Java y agrega algunas nuevas. sino que también se ha propagado a los métodos de análisis y diseño y a otras áreas. El primer lenguaje que introdujo los conceptos de orientación a objetos fue SIMULA 67 creado en Noruega. Los creadores de Java aprendieron bien la lección de Bjarne Stroustrup. pero se parece más al C++. Su idea era encapsular cada una de las variables globales del programa en un módulo junto con sus operaciones asociadas. conserva un poco del C original. Habrá que estar pendientes una vez lanzado a los programadores de sus posibles ventajas y probables desventajas (en computación nunca se gana algo sin perder otra cosa. Actualmente la Tecnología Orientada a Objetos (TOO) no solo se aplica a los lenguajes de programación. con el fin de realizar simulaciones discretas de sistemas reales. Pero Java es un lenguaje más puro de programación orientada a objetos. todo está relacionado con todo. A principios de los 90 se popularizó un nuevo lenguaje orientado a objetos. quien propuso la norma de ocultar información como solución. Puede verse al C++ como un paso intermedio en la transición de la programación estructurada del C a la programación orientada a objetos más pura del Java. En los últimos años esta metodología ha experimentado un gran progreso. lo importante es que en promedio las cosas vayan mejorando). En la actualidad denominamos objetos a este tipo de módulos. desde cualquier punto del programa. de forma independiente. Dahl y K. La idea de Bjarne Stroustrup fue crear un lenguaje orientado a objetos que heredara prácticamente toda la sintaxis y posibilidades del lenguaje que en ese momento era más popular entre los programadores. Un nuevo lenguaje para tener éxito debía ser muy parecido al que en el momento de su lanzamiento fuese el más popular. de todos aquellos otros módulos que también acceden a las mismas variables globales. Uno de los defectos de la programación imperativa es que las variables globales pueden ser utilizadas y modificar sus contenidos. J.

sin embargo los conceptos que se definieron en él. nunca quedó satisfecho con este lenguaje. Una década después del Pascal publicó otro lenguaje llamado Modula2 en el que presentaban algunas de sus ideas más recientes. Para proteger las variables hay que desarrollar lenguajes que permitan definir variables locales. La programación estructurada propone dos ideas básicas: no repetir código y proteger las variables que una parte del programa usa. de que sean modificadas accidentalmente por otras partes del programa. 1986. Éste lenguaje adoptó los conceptos nombrados anteriormente como su fundamento. La herencia es múltiple. Para no repetir código hay que escribir funciones o procedimientos que se encarguen de realizar siempre lo que las diferentes repeticiones realizarían. clases. notoriamente el Pascal y el C. El lenguaje fue utilizado sobre todo en Europa y no tuvo mucho impacto comercial. Ambos manejan conceptos de objetos y herencia de clases. Las variables y los procedimientos de un módulo podían ser de uso público o privado. se creó desde sus bases el lenguaje EIFFEL por B. El hecho de ser creado en EE. Dentro de un módulo se definían variables que representaban el estado del objeto y se definían procedimientos que describían su comportamiento. se volvieron sumamente importantes para el futuro del desarrollo de software. Como consecuencia de estas ideas disminuye considerablemente el tamaño de los programas y éstos se hacen más confiables y más fáciles de corregir o mejorar. es decir.UU. creador del Pascal. Los puntos importantes de este lenguaje fueron. Alrededor de los años 70’s fue desarrollado el lenguaje de programación OO llamado SMALLTALK en los laboratorios Xerox en Palo Alto. exclusivos de la clase. Bjarne Stroustrup extendió el lenguaje de programación C a C++. que sólo pueden ser utilizadas dentro de una función o procedimiento. cerca de esta fecha. EE.Capítulo 1 – Introducción a la Programación Orientada a Objetos. Es decir que se tuviese un lenguaje interpretado y no compilado.. Con todo esto se mejoraba notoriamente lo instituido por el Pascal donde el concepto de procedimientos o funciones privadas no existía y se daba un paso importante hacia la programación de clases o programación orientada a objetos. En su constante análisis de los hábitos de programación encontraba que todavía había muchas cosas que mejorar.UU. adoptar el concepto de objeto y clase como núcleo del lenguaje y la programación interactiva. aparecen nuevos lenguajes. ayudó a que se introdujera a escala mundial el término de Orientación a Objetos (Object Oriented OO) y que cobrara importancia entre los diseñadores de lenguajes de programación. por un lado. incorporando las ideas ya conocidas de lenguajes funcionales. es decir C con conceptos de clases y objetos. En estos tiempos no existían lenguajes de programación que se ajustaran a sus necesidades. y se introduce pensando en dar mayor 13 . son los dos lenguajes de programación estructurada más conocidos. De esta manera ninguna otra función del programa puede cambiarla. Los módulos de Modula2 pretendían representar objetos o clases. Meyer. Wirth. Una sola repetición de código es fuente probable de errores y dificulta el mantenimiento de un programa. el polimorfismo por inclusión (que se obtiene introduciendo la herencia de clases) y procedimientos virtuales. Para facilitar la programación estructurada. herencia. según lo decidiera el creador del módulo. así que se basaron en el lenguaje ALGOL 60 y lo extendieron con conceptos de objetos. En 1985.

manzanas verdes. La elevación del nivel de abstracción es sin duda un objetivo deseable. El paradigma orientado a objetos se basa en los tres métodos de organización que utilizamos desde nuestra infancia y en los que basamos todo nuestro pensamiento: a) la diferencia entre un objeto y sus atributos (por ejemplo.) La idea de manejar objetos reales como contenedores de estados y comportamientos. b) la diferencia entre un objeto y sus componentes (por ejemplo. El lenguaje es mitad compilado y mitad interpretado dando como resultado la portabilidad a distintas plataformas. desarrollado por la empresa SUN Microsystems. flexibilidad a los desarrolladores. es mucho más atractiva desde el punto de vista del usuario.Capítulo 1 – Introducción a la Programación Orientada a Objetos. al intentar construir un modelo del mundo real que envuelve nuestro sistema. Ambos lenguajes tuvieron importancia entre 1985 y hasta la primera mitad de los 90’s. Es decir. entre una manzana y su piel o semillas) y c) la formación y distinción entre clases de objetos (por ejemplo. entre una manzana y su sabor o peso). la representación de este mundo mediante la identificación de los objetos que constituyen el vocabulario del dominio del problema. Las técnicas orientadas a objetos usan un mismo modelo conceptual para el análisis. Ideas básicas de la POO La programación orientada a objetos es una metodología que descansa en el concepto de objeto para imponer la estructura modular de los programas. el más reciente lenguaje OO. Estos programas pueden viajar a través de la Internet y brindarle al usuario mayor interactividad con las páginas WEB. actualmente la herencia múltiple se ha evitado por agregar complejidad en las estructuras de clases. Obtiene una rápida aceptación gracias a los applets. la programación concurrente y distribuida. que hereda conceptos de C++. el diseño y la programación. JAVA aun sigue evolucionando y se espera que en los próximos años logre la madurez adecuada para convertirse en un lenguaje de desarrollo de mayor importancia. que son programas en JAVA insertados en páginas WEB dentro del código HTML. 14 . De esta manera no tendrá que batallar con construcciones orientadas al computador. Permite comprender el dominio del problema a resolver. entre manzanas rojas. En su lugar se introduce el término de interfaz. Sin embargo. JAVA introduce también. La transición desde el análisis al diseño es tan natural que es difícil especificar donde comienza uno y donde acaba el otro. sino que podrá manejar objetos (y operaciones) que se asemejen más a sus equivalentes en el mundo real. pero los simplifica y evita la herencia múltiple. y la herencia múltiple de interfases. etc. su organización y la representación de sus responsabilidades. En 1995 apareció JAVA.

Se facilita la representación de estructuras complejas sin necesidad de adaptarnos a normas y modelos. ya que de ello dependerá el éxito de nuestro proyecto. la reusabilidad y el mantenimiento del software. diseñadores y desarrolladores del proyecto deben conocer las reglas del juego y poseer suficiente experiencia en programación. Esto se traduce en un aumento de la productividad. Un error en estas primeras definiciones podría resultar catastrófico. 15 . Algunas de sus desventajas: Hay que ser muy cuidadosos en la creación de los objetos. La semántica de estas técnicas es más rica (al ser más natural). ya que lo que manejamos son objetos del mundo real. que corresponde a mensajes. lo que facilita la tarea del analista. El modelo OO Podemos indicar que se apoya en cuatro conceptos básicos: objeto clase herencia envío de mensajes Los primeros tres conceptos se refieren a la parte estructural o estática del modelo y el cuarto. Estas técnicas son más resistentes al cambio que las tradicionales técnicas de análisis orientadas a flujos de datos. Los estándares en este tipo de técnicas están en continua evolución. Ventajas e inconvenientes de la orientación a objetos Entre las ventajas más importantes podemos destacar: Favorece la comunicación entre analistas. al usuario final le es más fácil comprender lo que el analista representa en sus modelos (ya que representa los objetos que lo rodean habitualmente) Favorece la modularidad.Capítulo 1 – Introducción a la Programación Orientada a Objetos. ya que la comunicación es uno de los puntos críticos en las primeras fases del proyecto. programadores y usuarios finales al utilizar todos los mismos modelos conceptuales. diseñadores. Los analistas. Precisamente el secreto de esta técnica está en la correcta definición inicial de los objetos. lo que exige una actualización permanente. se refiere a la parte del comportamiento dinámico.

la identidad del objeto se puede interpretar como la referencia. Una subclase puede a su vez comportarse como una superclase y heredar a otras clases. funciones u operaciones que un objeto puede ejecutar a solicitud de otros objetos. y b) el comportamiento que van a tener los objetos A partir de ese esquema.Capítulo 1 – Introducción a la Programación Orientada a Objetos. y dentro de estos. Los objetos también se conocen como instancias. tiene incorporados los atributos y métodos heredados de la superclase. aparte de los atributos y métodos propios. El comportamiento es una lista de métodos. un objeto es una abstracción conceptual del mundo real que se puede traducir a un lenguaje computacional o de programación OO. es decir lo que él sabe hacer. creando de esta manera la jerarquía de herencia. La abstracción de objeto se caracteriza por tener una identidad única que lo distingue de otros objetos. procedimientos. cuyos valores representan el estado que caracteriza al objeto. Definición de Clase: Es una colección de objetos similares. Este envío de mensajes en cascada representa el comportamiento dinámico del modelo de objetos. que permite informar lo que éste representa y su comportamiento. Cuando una clase hereda de más de una superclase se conoce como herencia múltiple. Definiciones básicas Definición de Objeto: En términos más generales. se van a ir creando objetos que pertenezcan a esa clase. Definición de Herencia: Una clase puede heredar sus atributos y métodos a varias subclases (la clase que hereda es llamada superclase). el objeto puede solicitar servicios de otros objetos. enviándoles mensajes que implican a su vez la invocación de sus métodos. 16 . Un objeto recibe un estímulo externo de solicitud de un servicio que se traduce en la invocación de un método de éste objeto. O bien. y el mismo conjunto de métodos que definen su comportamiento. nuevamente invocar servicios de otros objetos y así sucesivamente. Estos objetos deben tener los mismos atributos con valores posiblemente diferentes asignados a estos. Esto significa que una subclase. Definición de Envío de Mensajes: ¿Qué sucede cuando los objetos desean comunicarse entre sí?. Al ejecutarse el método. Hablando en términos computacionales. dinámicamente durante la ejecución de un programa. como la estructura estática que define: a) el esquema de estados. El estado de objeto es una lista de variables conocidas como sus atributos. También tiene un estado. esquema o un patrón que define la forma de sus objetos. Por otro lado también se puede ver una clase como un molde.

Capítulo 1 – Introducción a la Programación Orientada a Objetos. llamadas también atómicas. el caso de preparar salsa con pimientos verdes aún podemos aclararlo más: Rehogar cebolla. partiendo de las más complejas hasta llegar a las acciones más sencillas de realizar. clases y herencia de clases. Hacer bife criollo acompañado de papa se divide en dos subproblemas: freír bifes con cebollas añadir acompañamiento Freír bifes con cebollas presenta tres subdivisiones: freír bifes preparar salsa con cebolla. Tenemos lenguajes: Base-objetos: Lenguajes que no tienen herencia. Haciendo un paréntesis. los cuales se encuentran en un espacio común. es importante diferenciar entre lenguajes OO y lenguajes que no lo son. Diferencia entre el modelado por descomposición funcional y el OO. En todo momento la descomposición del problema se hará identificando las acciones (verbos) que se deben realizar. Orientado a objetos: Presentan el concepto de objetos. Sin embargo. Presentan un concepto parecido a clase y alguna forma de crear objetos a partir de ésta. Para el caso de añadir acompañamiento se particiona en dos actividades atómicas añadir papa cocida 17 . el pimiento verde y el perejil Agregar 1 ajo picado chico freír la salsa que ya son actividades atómicas. El algoritmo divide al problema en sub-problemas o funciones. perejil y pimientos verdes juntar bifes con la salsa Freír bifes y juntar bifes con la salsa son actividades que ya se saben realizar (atómicas). Veamos la diferencia con un ejemplo Problema: Hacer bife criollo Resolución según la Descomposición funcional: Se declara una lista de datos.

Licuadora y Sartén. Salsa_Verde. enviando mensajes a Ingredientes. este debe tener un método que sabe hacer bife criollo apoyándose en el objeto Freír_Bifes_Con_Cebolla. Es importante notar que los datos se encuentran implícitos formando parte de los objetos. añadir perejil Si se deseara ahora preparar bife criollo con salsa de pimiento rojo. que se preparará. Cuando se pide haz_bife_criollo al objeto Bife_Criollo. se tendría que buscar cuales actividades hay que modificar. que tiene bifes como dato y saber freír bifes cómo método. Ingredientes. sin modificar nada más. 18 . Bife_Criollo le envía un mensaje diciéndole prepárate y entonces se preparará enviando mensajes a Ingredientes que los Rehoga. lo complicado no termina en modificarlos. Licuadora que los pica y finalmente llama a Sartén para que los fría. Finalmente Bife_Criollo le va a enviar un mensaje a Acompañamiento. en el caso de nuestro ejemplo.Capítulo 1 – Introducción a la Programación Orientada a Objetos. Sartén y Acompañamiento. Licuadora. Si en este modelo se desea hacer el Bife Criollo con Salsa de Pimientos Rojos. Para el caso de Salsa de pimiento verde. que podemos asociarlos de manera lógica a cada uno de sus conceptos. Sin embargo. En este caso sería la parte de los datos y preparar salsa verde. ya que no se sabe si en alguna otra parte del sistema se puedan referenciar y entonces esto traiga problemas. Todos estos van a ser nuestros objetos que internamente van a integrar datos y operaciones. solo bastaría sustituir el objeto Salsa de Pimientos Verdes por el objeto Salsa de Pimientos Rojos. En este caso los sustantivos (nombres) más importantes son: Bife_Criollo. para que se añada la papa y el perejil. y quede finalmente preparado nuestro plato Bife Criollo. Descomposición OO La modelación de esta solución se realiza a través de los sustantivos que definen al problema. rehogar cebolla pimiento verde y perejil.

El dato es una representación de la información con la estructura más adecuada para su tratamiento o proceso. y ser capaz de tener herencia de clases. como su nombre lo indica. ciclos de desarrollo largos. sino que forma parte de una organización jerárquica o de otro tipo. debe estar basado en clases. En segundo lugar. Podemos definir un objeto como un conjunto de datos y programas que poseen estructura y forma parte de una organización. un lenguaje se dice que está basado en objetos si soporta objetos como una característica fundamental del mismo. PROGRAMACIÓN ORIENTADA A OBJETOS – FIJANDO CONCEPTOS Introducción. se procesa y sale de un Sistema. Un lenguaje orientado a objetos que ataca estos problemas. El elemento fundamental de la POO es. sino que contiene en su interior cierto número de componentes bien estructurados. y técnicas de codificación no intuitivas. 19 . un objeto no es un dato simple. Capitulo 2. tiene 3 características básicas: debe estar basado en objetos. desarrollo y mantenimiento del software proponiendo una solución a largo plazo a los problemas y preocupaciones que han existido desde el comienzo en el desarrollo de software: la falta de portabilidad del código y reusabilidad. muchos menos cumplen los tres.Capítulo 2 – Programación Orientada a Objetos – Fijando Conceptos. En primer lugar. cada objeto no es un ente aislado. Información La Información es una colección de datos que entra. La Orientación a Objetos (OO) promete mejoras de amplio alcance en la forma de diseño. Muchos lenguajes cumplen uno o dos de estos puntos. Esta definición especifica varias propiedades importantes de los objetos. fluye. La barrera más difícil de sortear es usualmente la herencia. código que es difícil de modificar. Dado que la Programación Orientada a Objetos (POO) se basa en la idea natural de la existencia de un mundo lleno de objetos y que la resolución del problema se realiza en términos de objetos. el objeto.

etc. Un Sistema es un conjunto de objetos ordenadamente relacionados entre sí. 20 . Esta intrincada estructura es la que permite construir objetos muy complejos. almacenamiento y distribución de información. las instancias se llaman objetos. Sistemas de información. 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. los módulos de software OO se basan en los tipos de objetos. producción. En el análisis orientado a objetos.Capítulo 2 – Programación Orientada a Objetos – Fijando Conceptos. “empleado” se aplica a los objetos que son personas empleadas por alguna organización. El software que implanta el objeto contiene estructuras de datos y operaciones que expresan dicho comportamiento. etc. En el mundo de las bases de datos existen los tipos de entidad. Si se construye software. manipulación. Algunas instancias de empleado podrían ser Juan Pérez. Tipo de objeto. Entonces. una factura. un avión. Un objeto puede estar compuesto por otros objetos. Por ejemplo. por ejemplo una organización. Profundizando el concepto de Objeto. real o abstracta. una pantalla de usuario. Un objeto podría ser real o abstracto. estos conceptos se llaman tipos de objetos. interesa el comportamiento del objeto. mientras que un objeto es una instancia de un tipo de objeto. en OO se define tipos de objetos e instancias de tipo de objeto. dentro del software orientado a objeto. como cliente o empleado. un tipo de objeto es una categoría de objeto. Estos últimos a su vez también pueden estar compuestos por otros objetos. Del mismo modo. con arreglo a unas reglas que cooperan para aportar los procesos necesarios para el cumplimento de una función o finalidad determinada. José Martínez. acerca de la cual almacenamos datos y los métodos que controlan dichos datos. Las operaciones se codifican como métodos. uso. Así. un vuelo de avión. Los conceptos que poseemos se aplican a tipos determinados de objetos. Un Sistema de Información se caracteriza porque sus procesos son la adquisición. Existen muchas instancias de cada tipo de entidad (como Juan Pérez o José Martínez para el tipo de entidad empleado). un objeto es cualquier cosa. En el análisis y diseño orientados a objetos (OO). una figura en un graficador.

los enlaces que permiten a un objeto relacionarse con aquellos que forman parte de la misma organización. el segundo es hijo del primero. Las propiedades de un objeto pueden ser heredadas a sus descendientes en la organización. Son bidireccionales. En OO. mientras que en una organización jerárquica compleja un hijo puede tener varios padres. es decir. Relaciones semánticas. la estructura de datos y los métodos de cada tipo de objeto se manejan juntos. el término objeto tiene diferencias fundamentales con el término entidad. Una organización jerárquica simple puede definirse como aquella en la que un objeto puede tener un solo padre. un objeto es padre de otro cuando el primer objeto se encuentra situado inmediatamente encima del segundo en la organización en la que ambos forman parte. mientras que objeto se refiere a los datos y a los métodos mediante los cuales se controlan a los propios datos. si un objeto es padre de otro. Veamos en detalle estos 3 conceptos: 1) Las relaciones entre objetos son. que normalmente estarán incorporados en forma de programas (código) que el objeto es capaz de ejecutar y que también pone a disposición de sus descendientes a través de la herencia. Estructura de un objeto.Capítulo 2 – Programación Orientada a Objetos – Fijando Conceptos. Son esenciales para la existencia misma de la aplicación porque la construyen. Sin embargo. No se puede tener acceso o control de la estructura de datos excepto mediante los métodos que forman parte del tipo de objeto. precisamente. Los métodos son las operaciones que pueden realizarse sobre el objeto. Se refieren a las relaciones que no tienen nada que ver con la organización de la que forman parte los objetos que las establecen. Las hay de dos tipos fundamentales: Relaciones jerárquicas. Un objeto puede considerarse como una especie de cápsula dividida en tres partes: Relaciones Propiedades Métodos Cada uno de estos componentes desempeña roles totalmente independientes: Las relaciones permiten que el objeto se inserte en la organización y están formadas esencialmente por punteros a otros objetos. Las propiedades distinguen un objeto determinado de los restantes que forman parte de la misma organización y tiene valores que dependen de la propiedad de que se trate. ya que la entidad sólo se refiere a los datos. Sus propiedades y consecuencias solo dependen de los 21 . asimismo.

apoyándonos sólo en la relación definida entre NEWTON y ÓPTICA y en que ÓPTICA es hijo de FÍSICA. Las propiedades de un objeto pueden tener un valor único o pueden contener un conjunto de valores más o menos estructurados (matrices. los valores pueden ser de cualquier tipo (numérico. el objeto ÓPTICA es hijo del objeto FÍSICA). En consecuencia. De éste término genérico. por lo tanto. la Historia. 2) Propiedades. objetos en sí mismos (de su significado) y no de su posición en la organización. De este modo se elimina toda redundancia innecesaria y la cantidad de información que tendremos que definir para todo el diccionario será mínima. datos encapsulados dentro del objeto. Además. etc. cada una de las cuales tendrá. descenderán 3 grandes ramas de objetos llamadas VIDA. La raíz del diccionario podría llamarse TEMAS. listas. a su vez. Aplicamos el ejemplo: establecemos la relación trabajo entre los objetos NEWTON y ÓPTICA y la interpretaremos diciendo que significa que Newton trabajó en Óptica.) si el sistema de programación lo permite. ¿En qué trabajó Newton?.Capítulo 2 – Programación Orientada a Objetos – Fijando Conceptos. semántica. uno o varios valores. MUNDO y HOMBRE. El tercero (HOMBRE) comprenderá las ciencias humanas: la Geografía. las ciencias de la naturaleza inerte: las Matemáticas. evidentemente.). Todo objeto puede tener cierto número de propiedades. La relación es. El segundo (MUNDO). un objeto puede tener una propiedad de maneras diferentes: 22 . etc. etc. junto con los métodos (programas) y las relaciones (punteros a otros objetos). Pero existe una diferencia con las "variables". La existencia de esta relación nos permitirá responder a preguntas como: ¿Quién trabajó en óptica?. Para la tercera observamos que si Newton trabajó en Óptica automáticamente sabemos que trabajó en Física. por ser óptica una rama de la Física (en nuestro diccionario. alfabético. la Física. Veámoslo con un ejemplo: supongamos que vamos a construir un diccionario informatizado que permita al usuario obtener la definición de una palabra cualquiera. pues no establece ninguna connotación jerárquica entre NEWTON y ÓPTICA y su interpretación depende exclusivamente del significado de ambos objetos. las palabras son objetos y que la organización jerárquica es la que proviene de forma natural de la estructura de nuestros conocimientos sobre el mundo. El primero (VIDA) comprenderá las ciencias biológicas: Biología y Medicina. Entonces gracias a la POO podemos responder a la tercera pregunta sin necesidad de establecer una relación entre NEWTON y FÍSICA. la Química y la Geología. ¿Quién trabajó en Física? Las dos primeras se deducen inmediatamente de la existencia de la relación trabajo. Son. las propiedades corresponden a las clásicas “variables” de la programación estructurada. en dicho diccionario. vectores. Supongamos que. y es que las propiedades se pueden heredar de unos objetos a otros. En POO.

Un objeto entonces es “una cosa” cuyas propiedades están representadas por tipos de datos y su comportamiento por métodos. 23 . Están definidos en un objeto diferente. Los métodos son programas. 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. función. Los métodos especifican la forma en que se controlan los datos de un objeto. antepasado de éste (padre. sino que se desencadena automáticamente cuando ocurre un suceso determinado: la asignación de un valor a una propiedad de un objeto. en un tipo de objeto sólo hacen referencia a la estructura de datos de ese tipo de objeto. como los métodos ordinarios. aunque posiblemente no a todos. Es un tipo especial de métodos. etc. limitado a un objeto y a sus descendientes. la lectura de un valor determinado. 3) Métodos.). es conveniente utilizar el término “método” para que se distingan claramente las propiedades especiales que adquiere un programa en el entorno POO. Demonios. abuelo. Métodos heredados. rutina. Sin embargo. que afectan fundamentalmente a la forma de invocarlo (únicamente a través de un mensaje) y a su campo de acción. Propiedades heredadas. Están formadas dentro de la cápsula del objeto. El método es una operación que realiza el acceso a los datos. un objeto puede disponer de un método de dos maneras diferentes: Métodos propios. por lo tanto. Podemos definir método como un programa procedimental o procedural escrito en cualquier lenguaje. tienen argumentos o parámetros. etc. Como los métodos pueden heredarse de unos objetos a otros. No deben tener acceso directo a las estructuras de datos de otros objetos. es un programa. Para utilizar la estructura de datos de otro objeto.). que se activa automáticamente cuando sucede algo especial. deben enviar un mensaje a éste. pero se diferencia de estos porque su ejecución no se activa con un mensaje. son todos aquellos términos que se han aplicado tradicionalmente a los programas. etc. Están incluidos dentro de la cápsula del objeto. Están definidas en un objeto diferente. Los métodos. Propiedades propias. Sinónimos de “método”. Es decir.Capítulo 2 – Programación Orientada a Objetos – Fijando Conceptos. etc. como procedimiento. antepasado de éste (padre. A veces estos métodos se llaman métodos miembro porque el objeto los posee por el mero hecho de ser miembro de una clase. que está asociado a un objeto determinado y cuya ejecución sólo puede desencadenarse a través de un mensaje recibido por éste o por sus descendientes. abuelo. relativamente poco frecuente en los sistemas de POO.

de las cuales se derivarán siempre para su uso otras clases y un tercer módulo tendrá las clases que usan a las primitivas. al igual su cuello y cola. o bien. un módulo puede ser el de los cálculos numéricos mientras que otro. En forma sucinta y concreta. el de las operaciones con cadenas. Por ejemplo. En el caso de nuestro gato. lo veríamos descompuesto en unidades funcionales. la perspectiva de ver a un gato es muy distinta entre una abuela amorosa y un médico veterinario. podemos decir que es el “principio por el cual se deben modelar al mismo tiempo y de forma inseparable Métodos y Datos”. Su corazón funciona muy bien. inducen a la modularidad. se diferencian de otros métodos por que no son heredables y porque a veces están ligados a una de las propiedades de un objeto. La Interfaz representa la frontera y el lugar de paso en la comunicación del objeto con el mundo exterior. Una división temática de los módulos es una manera muy conveniente de equilibrar la modularización. Cada módulo o parte del sistema debe contar tanto con una funcionalidad clara y relativamente sencilla como con una facilidad de combinarse con otros módulos. La Abstracción es una descripción especial simplificada de un sistema que hace énfasis en ciertos rasgos y suprime otros. 24 . cada parte debe ensamblar perfectamente con las de su entorno para formar un gato completo. pero el principio en la Tecnología Orientada a Objetos. La buena abstracción es aquella que logra hacer énfasis en los detalles significativos o relevantes de la solución y discrimina cualquier otra característica. Abstracción. Modularidad. Los demonios. o las características de los compiladores o lenguajes particulares. es dividir funcionalmente buscando la interrelación más rica entre módulos. Con esto se consigue un mapeo de los objetos del mundo real a los objetos del sistema. De esta manera. Encapsulación de objetos. La Modularidad es una partición funcional de todo el sistema. Condicionantes tales como limitación de memoria. cuando existen. Un segundo módulo alojará las clases primitivas. La abuela hará una abstracción fijándose en rasgos afectivos y de cuidado mientras que el veterinario lo verá como un objeto anatómicofisiológico de estudio.Capítulo 2 – Programación Orientada a Objetos – Fijando Conceptos. más que al objeto entero. un módulo puede ser el de las variables generales y de arranque y configuración de un sistema.

no se podría hacer gran cosa con él. La clase es una colección de objetos con características comunes. Si todos los programas pudieran tener acceso a los datos de cualquier forma que quisieran los usuarios. siempre que el objeto considere que quien envía el mensaje está autorizado para obtenerla. o incluso a otra organización totalmente diferente que precise de él. encapsulado es el resultado (o acto) de ocultar los detalles de implantación de un objeto respecto de su usuario. permite la modificación de ésta sin que se tengan que modificar las aplicaciones que lo utilizan. Toda clase posee 2 tipos o clases de componentes: Una estática: los datos. Todos los detalles específicos de los datos del objeto y la codificación de sus operaciones están fuera del alcance del usuario. Caracterizan los posibles comportamientos de los Objetos de la Clase a lo largo de su existencia. que sea imposible conocer lo necesario respecto a un objeto y a lo que él contiene. El encapsulado protege los datos del uso arbitrario o accidental. 25 . Esto no quiere decir. El hecho de que cada objeto sea una cápsula. Las clases son entidades conceptuales que sirven para abstraer y modelizar un sistema. El encapsulado oculta los detalles de su implantación interna a los usuarios de un objeto. Lo que sucede es que las peticiones de información a un objeto deben realizarse a través de mensajes dirigidos a él. los datos se podrían corromper o utilizar de mala manera. Reutilización. Así. La respuesta a estas órdenes será la información requerida. pero desconocen los detalles de cómo se lleva a cabo la operación. El objeto esconde sus datos de los demás objetos y permite el acceso a los datos mediante sus propios métodos. Caracterizan los posibles estados que pueden adoptar los Objetos de la Clase en un instante determinado. Los usuarios se dan cuenta de las operaciones que puede solicitar del objeto. facilita enormemente que un objeto determinado pueda ser transportado a otro punto de la organización. con la orden de realizar la operación pertinente. El encapsulamiento evita la corrupción de los datos de un objeto. Si así fuera. El empaque conjunto de datos y métodos se llama encapsulado. Clase. Esta cualidad hace que la POO sea muy apta para la reutilización de programas. al separar el comportamiento del objeto de su implantación. Esto recibe el nombre de “ocultamiento de información”. Otra dinámica: los métodos. sus métodos seguirán funcionando en el nuevo entorno sin problemas. Si el objeto ha sido bien construido.Capítulo 2 – Programación Orientada a Objetos – Fijando Conceptos. sin embargo. El encapsulado.

Existe de este modo una jerarquía de tipos. mientras que empleado puede tener como subtipo a académico y administrativo. subtipos. Una subclase hereda propiedades de su clase padre. Determinan la componente dinámica de los Objetos. Eventos: Estímulos ante los que reaccionan los Objetos cambiando de Estado. 26 . Los criterios de clasificación de una Clase son: Atributos: Variables que tomarán ciertos valores (Datos) en un estado del Objeto. Por ejemplo. etc. el tipo de objeto estudiante puede tener como subtipo estudiante de pre-grado y estudiante de post-grado. Dijimos que un tipo de objeto de alto nivel puede especializarse en tipos de objetos de bajo nivel. Herencia. Especifica una estructura de datos y los métodos operativos permisibles que se aplican a cada uno de sus objetos. La Subclase consta de dos tipos de características: Estructura o comportamiento heredado de la superclase.Capítulo 2 – Programación Orientada a Objetos – Fijando Conceptos. Funciones: Ante un evento. el tipo de objeto persona. La clase padre se suele denominar superclase. una clase es una creación de un tipo de objeto. Estructura o comportamiento propios. derivada. Entonces. etc. denominar subclase. Así. una sub-subclase hereda propiedades de las subclases. puede tener subtipos estudiante y empleado. Definen la estructura o componente estática de los Objetos. La clase hija se suele especialización o heredada. sub-subtipos. descendiente. La subclase se especializa de las siguientes formas: Enriquecimiento: Estructura o comportamiento añadidos como propios. que permite a un objeto de una clase utilizar como propios los datos y métodos definidos en otra clase. una clase implanta el tipo de objeto. Ocultación: Estructura o comportamiento heredado y anulado Sustitución: Estructura o comportamiento heredado y redefinido Ejemplos de herencia. Es una relación transitiva entre clases. actúan sobre los datos haciendo que el Objeto cambie de estado. A su vez. Por ejemplo: La clase cliente hereda de la clase persona sus métodos y datos.

con comportamientos diferentes. Este se caracteriza por estar en el nivel más alto de la estructura y suele recibir un nombre muy genérico. por la clase o subclase a la que pertenecen. Simple: Se hereda de una sola clase. Suelen llamarse casos particulares. por ejemplo. Tipos de herencia. Una de las características fundamentales de la POO es el polimorfismo. mientras que para un objeto STRING significaría concatenación. Una subclase puede heredar la estructura de datos y los métodos de su superclase. Representan conjuntos o clases de objetos. raíz o entidad. por ejemplo. En cualquier caso. Los objetos terminales: Son todos aquellos que descienden de una clase o subclase y no tienen descendientes. pero con relación a la clase a la que pertenece cada uno. También tiene sus propios métodos e incluso sus propios tipos de datos. En otros casos puede ser más compleja. Polimorfismo. según la aplicación. podrán distinguirse en ella 3 niveles de objetos: La raíz de la jerarquía: Se trata de un objeto único y especial. CUENTA. Los objetos intermedios: Son aquellos que descienden directamente de la raíz y que a su vez tienen descendientes. que pueden ser muy generales o muy especializados. Estos objetos recibirían el mismo mensaje global pero responderían a él de formas diferentes. 27 .Capítulo 2 – Programación Orientada a Objetos – Fijando Conceptos. como por ejemplo objeto madre. Existen varios tipos de jerarquías: serán simples cuando su estructura pueda ser representada por medio de un "árbol". Organización de los objetos En principio. Esto conlleva la habilidad de enviar un mismo mensaje a objetos de clases diferentes. porque simbolizan los elementos del conjunto representado. Jerarquías. Múltiple: Se hereda de dos o más clases. un mensaje "+" a un objeto ENTERO significaría suma. en el sentido de que ciertos objetos son superiores a otros de cierto modo. los objetos forman siempre una organización jerárquica. VENTANA. instancias o ítem. sea la estructura simple o compleja. Normalmente reciben nombres genéricos que denotan al conjunto de objetos que representan. que no es otra cosa que la posibilidad de construir varios métodos con el mismo nombre. que indica su categoría especial. La jerarquía es el orden por niveles de todas las abstracciones. FICHERO.

la segunda. etc. métodos y mensajes que se transfieren entre tales objetos. le enviamos una solicitud. Así al hablar de manzanas. La persona que utilice el objeto no tiene que conocer su complejidad interna. La operación ejecuta el método apropiado y. 28 . a veces. Cada abstracción debe connotar un nivel. éstos a su vez pueden contener otros. puesto que pueden contener muchos subobjetos. pero en otra categoría hablaremos de sus componentes. la dinámica de mensajes. un grupo de parámetros. Un mensaje es una solicitud para que se lleve a cabo la operación indicada y se produzca el resultado. La abstracción superior no sabe de sus constituyentes ínfimos y viceversa. el nombre de una operación y. Ni los tejidos sabrán a qué componente pertenecen ni los componentes a qué manzana pertenecen. pulpa. Los objetos pueden ser muy complejos. La organización de todas las abstracciones logradas en un sistema está en un orden riguroso que categoriza objetos de un mismo o semejante tipo dentro de una misma categoría. de manera opcional. produce una respuesta. Mensajes Para que un objeto haga algo. sino la forma de comunicarse con él y la forma en que le responde. podremos hablar de las amarillas.Capítulo 2 – Programación Orientada a Objetos – Fijando Conceptos. La primera establece todas las relaciones de herencia en sus modalidades permitidas. Las dos partes más importantes de la jerarquía son la estructura de clases y la estructura de objetos. semilla. Esta hace que se produzca una operación. operaciones. piel. y posiblemente en una categoría más inferior de sus tejidos. las rojas. o las verdes. La programación orientada a objetos es una forma de diseño modular en la que con frecuencia el mundo se piensa en términos de objetos. El mensaje que constituye la solicitud contiene el nombre del objeto.

tanto entre las diferentes máquinas como entre los diversos sistemas operativos y sistemas de ventanas que funcionaban sobre una misma máquina. Esto se debe en gran parte a la naturaleza misma del lenguaje. respecto del origen del lenguaje Java. que ha permitido a los creadores de Java añadir al lenguaje bibliotecas de clases que pueden ser fácilmente adaptadas a las necesidades del desarrollador de software. Chris Warth. entre otros. 29 . de Sun Microsystems.. Mike Sheridan. Jonathan Payne. por citar algunos de ellos. desde su aparición hasta nuestros días. Origen de Java. ¿Porqué Java? Java es un lenguaje puro Orientado a Objetos. se reúnen y toman la idea de que el futuro de la Informática pasa porque todos los electrodomésticos y productos de consumo estén controlados por un ordenador. es decir cumple perfectamente el paradigma de OO. Entre las “leyendas” más difundidas. el crecimiento de su uso ha sido vertiginoso. Tras unos comienzos dudosos. para dar margen de maniobra al equipo responsable del proyecto. Frank Yellin y Tim Lindholm. se encuentra aquella que dice que: En enero de 1991. Polimorfismo o Sobrecarga Redefinición Es un lenguaje de programación relativamente joven. Ed Frank y Patrick Naughton. añadiendo la dificultad de crear aplicaciones distribuidas en una red como Internet. Sun Microsystems. denominada FirstPerson Inc. JAVA Y LA PROGRAMACIÓN ORIENTADA A OBJETOS Introducción. es la empresa que ha desarrollado el lenguaje Java. Arthur van Hoff.Capitulo 3. James Gosling. a pesar de ello. en un intento de resolver simultáneamente todos los problemas que se le plantean a los desarrolladores de software por la proliferación de arquitecturas incompatibles. Muchos han colaborado en el diseño y evolución del lenguaje: Bill Joy. Se ha elegido este lenguaje para ejemplificar los siguientes conceptos de PPO: Objetos Clase Modularidad Herencia Jerarquías Abstracción Encapsulación Ligaduras Dinámicas o Binding Mensajes. Sun decidió crear una filial.

por pequeña que sea la diferencia en precio ya que. requería interfases mucho más cómodos e intuitivos que los sistemas de ventanas que proliferaban en el momento. aparece en 1993 el navegador NCSA Mosaic. intentaba remediar las deficiencias que iba observando. En 1993. James Gosling había estado trabajando en su tiempo libre en un lenguaje de programación que él había llamado Oak. Por tanto. En paralelo. que facilitará el acceso interactivo a la Internet. James Gosling escribe un compilador de Java. Gosling decidió mejorar las características de Oak y utilizarlo. Sun y Silicon Graphics compiten para hacerse con el proyecto. Los miembros del equipo. Time Warner. Ninguno de estos proyectos se convirtió nunca en un sistema comercial. Lo consigue Sun. sólo como una demo. dada la falta de pericia de los usuarios para el manejo de estos dispositivos. que se convertirá más adelante en HotJava en septiembre de dicho año. aún partiendo de la sintaxis de C++. el cual. 30 . Para ello se construyó un ordenador experimental denominado *7 (Star Seven). Posteriormente se aplicó a otro proyecto denominado VOD (Video On Demand) en el que se lo empleaba como interfaz para la televisión interactiva. supone un ahorro considerable. James Gosling. Este mercado. El mercado. decidió que las ventajas aportadas por la eficiencia de C++ no compensaban el gran coste de pruebas y depuración. estamos hablando del año 1992. Los lenguajes como C o C++. urgieron a FirstPerson a desarrollar con rapidez nuevas estrategias que produjeran beneficios. conduce inmediatamente a los fabricantes a incluirlo en las nuevas series de sus cadenas de producción. otra filial de Sun creada en 1994. Otros requisitos importantes a tener en cuenta eran la fiabilidad del código y la facilidad de desarrollo. la compañía de TV. en principio. La aparición de un chip más barato y.Capítulo 3 – Java y la Programación Orientada a Objetos. Hoffman escribe otro en Java. todo el software debe compilarse de nuevo. El número de usuarios de la Internet crece exponencialmente. pero fueron desarrollados enteramente en un Java primitivo y fueron como su bautismo de fuego. El sistema presentaba una interfaz basada en la representación de la casa de forma animada y el control se llevaba a cabo mediante una pantalla sensible al tacto. deben ser compilados para un chip. Esto encarece mucho los desarrollos y el problema es especialmente sentido en el campo de la electrónica de consumo. pasan a Sun Interactive. generalmente. la actual mascota de Java (esa especie de pingüinito de cabeza negra. Una vez que en Sun se dieron cuenta de que a corto plazo la televisión interactiva no iba a ser un gran éxito. fundamentalmente. Bill Joy decide escribir un navegador (WebRunner. tostadoras y. El primer proyecto en que se aplicó este lenguaje recibió el nombre de Proyecto Verde (Green Project) y consistía en un sistema de control completo de los aparatos electrónicos y el entorno de un hogar. tipo Mosaic) en código Oak. al que pertenece James Gosling. En 1994. y si se cambia el chip. eran los equipos domésticos: microondas. inicialmente previsto para los programas de FirstPerson. multiplicada por la tirada masiva de los aparatos. cuerpo blanco y nariz roja). En el sistema aparecía Duke. televisión interactiva. el miembro del equipo con más experiencia en lenguajes de programación. más eficiente. pretende introducirse en el mercado de la televisión interactiva. No lo consiguieron y FirstPerson cerró en la primavera de 1994.

..vt. se aprende a hacer Applets y aplicaciones fácilmente. Estas características seguramente son opinables según el punto de vista que se las analice.0a” sale al mundo exterior y el código fuente de Java se distribuye en Internet. Y bueno . interpretación. los programas de compilación. Applets ejemplo... Simple: Porque. porque la cuestión es si. Java ofrece toda la funcionalidad de un lenguaje 31 . depuración. la versión “1. En marzo de 1995. etc. a partir de allí el uso intensivo de Java no ha parado de crecer. Recomiendo leer en Internet.html Características de Java Es importante ver las características del lenguaje Java. aplicaciones.. ocupa aproximadamente 10 Mb en disco. para decidir si lo utilizamos o no. independientemente de su origen y entorno comercial.edu/~wwwbtb/book/chap1/java_hist. Java ofrece soluciones a nuestras expectativas. prácticamente sin saber mucho de programación. Algunas de ellas son: Tamaño reducido Simplicidad Portabilidad Interpretado Distribuido Robusto Seguro Programación concurrente y distribuida Dinámico Liberación de memoria no utilizada Manejo de Arreglos Manejo de excepciones Analicemos estas características individualmente: Reducido: Todo el paquete de desarrollo que incluye la librería de clases. Lo mejor será hacer caso omiso de las historias que pretenden dar carta de naturaleza a la clarividencia industrial de sus protagonistas. una muy completa historia de Java en la siguiente dirección: http://ei.Capítulo 3 – Java y la Programación Orientada a Objetos. pudiéndose obtener resultados en poco tiempo.cs. según el tipo de trabajo que debemos encarar. Porque tampoco vamos a desechar la penicilina aunque haya sido su origen fruto de la casualidad.

Java elimina muchas de las características de otros lenguajes como C++. El inconveniente del uso de bytecodes. Interpretado: este era el principal objetivo que Sun buscaba. Seguro: permite la transferencia y el manejo de datos sin errores aparentes. existen otros programas maliciosos contra los que hay que protegerse: estos programas pueden recoger información privada del usuario como números de tarjetas de crédito. necesidad de liberar memoria (free) Portable. definición de tipos (typedef) e. Podemos escribir código Java en una plataforma y marcharnos a otra con la garantía de que ésta también entenderá el código fuente sin necesidad de tener que rescribirlo. Por otro lado.exe) y 2) la interpretación de estos desde cada plataforma con el intérprete Java (usando java. pues permite interpretar los programas Java desde cualquier plataforma de programación. por ello. tanto. Y es un lenguaje de plataforma independiente. como al nivel binario. Esto es así porque para ejecutar los programas en Java se hacen dos operaciones: 1) la compilación obteniendo los bytecodes (usando el compilador javac. no existen referencias c. etc. cuentas bancarias y palabras 32 . Los bytecodes equivalen a código máquina pero sin ser específicos de ningún procesador. Java se diseñó para ser parecido a C++ y así facilitar un rápido y fácil aprendizaje. los archivos binarios Java resultado de la ejecución. se corre el riesgo de recibir un virus. conocidos por bytecodes. macros (#define) f. aritmética de punteros b.Capítulo 3 – Java y la Programación Orientada a Objetos. podrán ejecutarse desde cualquier plataforma sin necesidad de ninguna recompilación. para mantener reducidas las especificaciones del lenguaje y añadir características muy útiles como el reciclador de memoria dinámica (ver explicación detallada más abajo).exe). caballos de Troya. Robusto. registros (struct) d. como tenemos ocasión de ver cuando cargamos un Applet desde una página web. C++ es un lenguaje que adolece de falta de seguridad. siempre será posible la caída de la red o de nuestra maquina. Además. al nivel de código fuente. potente. es la pérdida de velocidad de ejecución. pero es muy difundido. pero sin las características menos usadas y más confusas de éstos. entre las que destacan: a. Cada vez que se transfiere al ordenador de un usuario un programa. Java reduce en un 50% los errores más comunes de programación con lenguajes como C y C++ al eliminar muchas de las características de éstos.

como en rendimiento. aún supera a los entornos de flujo único de programa (single-threaded). interactuando. etc. Con Java. Dinámico: por su capacidad de interactuar con el usuario. son básicamente pequeños procesos o piezas independientes de un gran proceso. Existen librerías de rutinas para acceder e interactuar con protocolos como http y ftp. 33 . procesos ligeros o hilos). Java también tiene la posibilidad de que los objetos puedan ejecutar procedimientos remotos. en cuanto a seguridad se refiere. Las librerías nuevas o actualizadas no paralizarán las aplicaciones actuales (siempre que mantengan el API (Application Programming Interface)). Distribuido: Java se ha construido con extensas capacidades de interconexión TCP/IP (Transmission Control Protocol/Internet Protocol). Concurrente: permite ejecutar varios programas Java (applets) a la vez en el navegador. Como ejemplo de todo esto. Esto le aporta más características del modelo cliente/servidor. Java no intenta conectar todos los módulos que comprenden una aplicación hasta el tiempo de ejecución. El beneficio de ser multithreaded consiste en un mejor rendimiento interactivo y mejor comportamiento en tiempo real. Como ejemplo. Java establece un cortafuegos (firewall) entre una aplicación de red y la computadora local: cuando se carga desde el navegador de un usuario una página web que contiene un applet Java. tanto en facilidad de desarrollo. que no tiene acceso a los recursos locales de la máquina cliente. Aunque el comportamiento en tiempo real está limitado a las capacidades del sistema operativo subyacente (Unix. supongamos la visualización de una imagen desde Internet.Capítulo 3 – Java y la Programación Orientada a Objetos. Los threads (a veces llamados. esta facilidad se llama RMI (Remote Method Invocation). no hay ningún peligro de ser infectados por un virus o a recibir intentos de accesos malintencionados. esta imagen se puede ir trayendo en un thread independiente. de acceso que pueden ser obtenidas analizando el contenido del sistema de ficheros local de la computadora cliente.). Ésta es una de las grandes ventajas de Java. Java consigue esto creando un entorno de ejecución aislado para ese applet. permitiendo que el usuario pueda acceder a la información en la página sin tener que esperar por el navegador. es decir. Java en sí no es distribuído. Esto permite a los programadores acceder a la información a través de la red con tanta facilidad como a los ficheros locales. que se ejecuten en varias máquinas. son más fáciles de usar y más robustos que sus homólogos en C o C++. La siguiente figura muestra las diferencias entre un navegador convencional y uno con Java. Windows. Al estar los threads construidos en el lenguaje. Java se beneficia todo lo posible de la tecnología orientada a objetos. sino que proporciona las librerías y herramientas para que los programas puedan ser distribuidos. Java al ser multitareas (multithreaded). permite muchas actividades simultáneas en un programa.

Administrador de Arreglos: Posee un eficiente sistema de administración de arreglos (array). desde el servidor remoto. permite liberar bloques de memoria muy grandes. cuando entra en acción. Si nuestro ejecuta una aplicación Java sobre la red y encuentra una pieza de la aplicación que no sabe manejar. es capaz de traer automáticamente cualquiera de esas piezas que el sistema necesita para funcionar. para mantener reducidas las especificaciones del lenguaje y añadir características muy útiles como el garbage collector (reciclador de memoria dinámica). Java. No es necesario preocuparse de liberar memoria. para evitar tener que ir descargando módulos de byte-codes. Administrador de Memoria: Es una tarea de la cual el programador no debe preocuparse. Java también simplifica el uso de protocolos nuevos o actualizados. lo que reduce la fragmentación de la memoria.Capítulo 3 – Java y la Programación Orientada a Objetos. que permite almacenar gran cantidad de datos en 34 . objetos o nuevas clases. Java elimina muchas de las características de otros lenguajes como C++. para que no se eliminen cuando se limpie la caché de la máquina. implementa las opciones de persistencia. el reciclador se encarga de ello y como es un thread de baja prioridad.

y lleva el problema de la gestión del error en tiempo de ejecución al mundo orientado a objetos. Java posee gestión de excepciones. Sin embargo. Una excepción es una condición anormal que surge en una secuencia de código durante la ejecución de un programa. para evitar la posibilidad de sobreescribir o corromper memoria resultado de punteros que señalan a zonas equivocadas. Implementa los arrays auténticos. hay que controlar los posibles errores de ejecución del programa manualmente. Pero en algún punto. Las excepciones generadas por Java están relacionadas con errores que violan las reglas del lenguaje Java o las restricciones del entorno de ejecución de Java. En Java. Las excepciones pueden ser generadas por el intérprete de Java o pueden ser generadas por el propio código. usando códigos de error. Las excepciones generadas manualmente se suelen utilizar para informar de algún error al método llamante. la excepción es capturada y procesada. memoria. En los lenguajes de programación que no tienen gestión de excepciones. 35 . se crea un objeto que representa la excepción y se envía al método que provocó esta excepción. los que evitan. Este método puede elegir gestionar la excepción él mismo o pasarla. en vez de listas enlazadas de punteros. es un "error de ejecución". con comprobación de límites. cuando surge una condición excepcional. que el programa cancele su ejecución. Excepciones: Se dispone de una buena batería de métodos que controlan los posibles errores que pudiesen ocurrir durante la ejecución del programa. Es decir. estando bien utilizados.Capítulo 3 – Java y la Programación Orientada a Objetos. con un acceso directo a ellos.

.

se podría definir otra clase para describir a los mamíferos. Redefinición de Métodos Heredados 5. Transformaciones de tipos ó Casting 12. PROFUNDIZANDO CONCEPTOS DE POO – EJEMPLOS CON JAVA En este capítulo se analizarán los siguientes conceptos de la POO. la herencia es el mecanismo que permite a un objeto ser una instancia específica de un caso más general. la clase "mamíferos" es subclase de "animales". cada objeto debería definir todas sus características explícitamente. Redefinición 9. Una subclase hereda todos los atributos de cada uno de sus antecesores en la jerarquía de clases. Sobrescritura de métodos 3. se denomina subclase. La clase base y la clase derivada 4. como el tipo de dientes. concepto ya creado por Dahl y Nygaar en 1965. De esta forma se consigue la clasificación jerárquica. La herencia. Si no se hiciera una clasificación jerárquica de los objetos. Sobrecarga/Polimorfismos 7. La clase "mamíferos" heredaría todos los atributos de la clase "animales". Herencia. Sincronización 1. y aquella clase de la que se hereda. o las glándulas mamarias. es una propiedad esencial de la Programación Orientada a Objetos que consiste en la creación de nuevas clases a partir de otras ya existentes Es el mecanismo mediante el cual un objeto adquiere (o hereda) las propiedades de otro. Permisos de Accesos 11. y esto no sería viable. Por tanto. pero aplicados a ejemplos básicos utilizando el lenguaje de programación JAVA. Ligaduras Dinámicas ó Binding 8. pero además definiría una serie de atributos específicos de los mamíferos. Por ejemplo. y la clase "animales" es superclase de "mamíferos". Clases y Métodos Abstractos 6. Interfases 10. Capitulo 4. En este caso. y definir explícitamente sólo aquellas cualidades que lo hacen único dentro de su clase. supongamos que se define una clase para describir a los animales. Esta característica permite a los programas orientados a objetos crecer en complejidad de manera lineal en vez de geométrica. Sin embargo.Capítulo 4 – Conceptos de Orientación a Objetos. 37 . Una clase que hereda de otra. utilizando la herencia. Herencia 2. 1. un objeto puede heredar sus atributos generales de otro objeto (su padre). se denomina superclase.

Herencia en Java. para heredar una clase. Eiffel o Java. Una vez que una clase ha sido depurada y probada. como el C++. se utiliza la palabra reservada extends. cuando un método de una subclase tiene el mismo nombre y tipo que un método de su superclase. 38 . La herencia ofrece una ventaja importante. La herencia permite las clasificaciones jerárquicas. En Java. Por ejemplo. una superclase puede definir la forma general de los métodos que serán utilizados por todas sus subclases. el código fuente de dicha clase no necesita modificarse. Sobrescritura de métodos. Así. Y cuando se llama a un método sobrescrito dentro de una subclase. Por otra parte. y además define sus propias variables de instancia y métodos. permite la reutilización del código. combinando la herencia con la sobrescritura de métodos. 2. Pero hay una excepción: una subclase no puede acceder a aquellos miembros de la superclase que han sido declarados como private. si la clase B hereda la clase A (B es subclase de A.Capítulo 4 – Conceptos de Orientación a Objetos. etc. BASIC. La clase base y la clase derivada. La herencia es la característica fundamental que distingue un lenguaje orientado a objetos. A es superclase de B). 3. de otro convencional como C. Y la llamada a una función sobrescrita se resuelve en tiempo de ejecución. entonces se dice que el método de la subclase sobrescribe al método de la superclase. este polimorfismo dinámico es uno de los mecanismos más poderosos que ofrece el diseño orientado a objetos para soportar la reutilización del código y la robustez. En una jerarquía de clases. la clase B hereda todas las variables de instancia y métodos de la clase A. esto se denomina selección de método dinámica. Su funcionalidad se puede cambiar derivando una nueva clase que herede la funcionalidad de la clase base y le añada otros comportamientos. la declaración de la clase B sería así: class B extends A { // variables de instancia // métodos } Así. siempre se refiere a la versión del método definida en la subclase. La selección de método dinámica es la forma que tiene Java de implementar el polimorfismo durante la ejecución. en lugar de durante la compilación. La versión del método definida por la superclase está oculta. Smalltalk.

En Java disponemos de los paquetes básicos: java. con el lenguaje C++.io: Clases para la E/S y para el manejo de ficheros. clase Object. son piezas del juego. por ejemplo: En la fase de análisis. nos damos cuenta que diversos tipos de datos tienen algo en común. una clase base pieza y derivamos cada pieza individual a partir de dicha clase base. alfiles. Creamos. por ejemplo en el juego del ajedrez: peones. por lo tanto. que no dibuja nada en el área de trabajo de la misma.awt: Clases para la interfase gráfica. incluyendo la clase Applet y la interfase AudioClip. podemos redefinir en ella la función Paint para que dibuje una figura. clases Socket y clase URL. etc.Capítulo 4 – Conceptos de Orientación a Objetos. reina. En el lenguaje Java. Una de estas clases denominada TWindow describe el aspecto y la conducta de una ventana. Button.util: Clases para las utilidades. clase System y clases para los tipos asociados a las primitivas. java. caballos y torres. en entornos de ventanas. todas las clases derivan implícitamente de la clase base Object. java. La base de la POO fue este tipo de programación. una elipse. CheckBox. de hecho SmallTalk se hizo para eso. tiene una función miembro denominada Paint. clase Date. Definiendo una clase derivada de TWindow.net: Clases para el soporte de redes. La programación en los entornos gráficos. La clase base. etc. Los compiladores como los de Borland y Microsoft proporcionan bibliotecas de clases cuyas clases describen el aspecto y la conducta de las ventanas. Font. en particular Windows. incluyendo las clases Window.applet: Clases que implementan las Applets de Java. 39 . clase String. tendremos que añadir en la clase derivada el código necesario para dibujar un rectángulo. es un ejemplo ilustrativo. Solamente. rey.lang: Clases propias del lenguaje. por lo que heredan las funciones miembro definidas en dicha clase. clase Vector y clase Hashtable. menús. Algunas de las típicas ocasiones en las que nos vemos obligados a crear clases bases son. controles. Menu. java. java. Aprovechamos de este modo la ingente cantidad y complejidad del código necesario para crear una ventana en un entorno gráfico. java.

//constructor de la Clase Base public Ventana(int x. Las funciones miembro.y=y. No tiene valor de retorno. de su esquina superior izquierda. VentanaTitulos.println("posición : x =" + x + ". Supongamos que tenemos una clase que describe la conducta de una ventana muy simple. protected int ancho. y 40 . this.java y VentanaApp.x=x. sin tener que modificar el código existente. } } Constructor (Ventana) Nombre del constructor = nombre de la clase Se encarga de todas las operaciones de inicialización necesarias. int alto) { this.1 o Windows 95. por lo tanto no puede desplazarse. public class Ventana { protected int x. protected int alto.ancho=ancho. protected int y.out. además del constructor serán las siguientes: la función mostrar que simula una ventana en un entorno gráfico. La clase Ventana tendrá las siguientes variables miembros: la posición x e y de la ventana. Vamos a poner un ejemplo del segundo tipo. En otra ocasión. int ancho. this. int y. y las dimensiones de la ventana: ancho y alto. Ejemplos de aplicación del presente concepto los vemos en los programas: Ventana.java. aquella que no dispone de título en la parte superior. pero si cambiar de tamaño actuando con el ratón en los bordes derecho e inferior. precisamos ampliar la funcionalidad de un programa. (ampliar la funcionalidad de un programa) que simule la utilización de librerías de clases para crear una interfase gráfica de usuario como Windows 3.alto=alto.java. this. aquí solamente nos muestra la posición y las dimensiones de la ventana.Capítulo 4 – Conceptos de Orientación a Objetos. public void mostrar(){ System.

el título de la ventana. 20. =" + y). ancho. el constructor de la clase base inicializa los cuatro miembros dato. } La función cambiarDimensiones (de forma relativa) que simula el cambio en la anchura y altura de la ventana.cambiarDimensiones(10. y tendrá una variable miembro más.out. int dalto){ ancho += dancho. System.mostrar(). de la clase Ventana. La instanciación (new) reserva el lugar de almacenamiento e invoca al constructor Ventana ventana=new Ventana (0. public class VentanaTitulo extends Ventana{ protected String titulo.println("dimensiones: ancho =" + ancho + ". 30). alto). 41 . Los objetos de dicha clase tendrán todas las características de los objetos de la clase base. y. int alto. ventana. int y. Como vemos en el código. o es una subclase. public VentanaTitulo(int x. La clase derivada Podemos incrementar la funcionalidad de la clase Ventana definiendo una clase derivada denominada VentanaTitulo. Llamamos al constructor creando un objeto de la clase Ventana (Java invoca al constructor al crear el objeto). 0. } Objetos de la clase base. pero además tendrán un título. String nombre) { super(x. int ancho. titulo = nombre. 10). } } extends es la palabra reservada que indica que la clase VentanaTitulo deriva. Desde el objeto ventana podemos llamar a las funciones miembro públicas ventana. y se podrán desplazar (se simula el desplazamiento de una ventana con el ratón). alto += dalto. La clase derivada heredará las variables miembros de la clase base y las funciones miembro.Capítulo 4 – Conceptos de Orientación a Objetos. alto =" + alto). public void cambiarDimensiones(int dancho.

mostrar(). La primera sentencia del constructor de la clase derivada es una llamada al constructor de la clase base mediante la palabra reservada super. inicializa los cuatro miembros dato de la clase base Ventana:( x.out.println("titulo : "+titulo).out. que muestre el título). System. y se realizan las tareas de inicialización que sean necesarias. } Objetos de la clase derivada. La función miembro denominada desplazar cambia la posición de la ventana. alto). tendríamos una función recursiva.función recursiva System. int dy){ x+=dx. ancho. (redefinimos la función mostrar en la clase derivada). 42 . y. mediante super. añadiéndole el desplazamiento. De este modo aprovechamos el código ya escrito. La llamada super(x. La función miembro mostrar de la clase derivada VentanaTitulo hace una llamada a la función mostrar de la clase base Ventana. llamando al constructor por defecto si existe. Si nos olvidamos de poner la palabra reservada super llamando a la función mostrar. ancho.Capítulo 4 – Conceptos de Orientación a Objetos. se inicializan las variables miembros de la clase derivada. y+=dy. Si no se llama explícitamente al constructor de la clase base Java lo realiza por nosotros. y. alto) A continuación.println("titulo } : "+titulo). public void mostrar(){ super. En la clase derivada se define una función que tiene el mismo nombre y los mismos parámetros que la de la clase base.mostrar(). public void desplazar(int dx. y le añadimos el código que describe la nueva funcionalidad de la ventana (por ejemplo. (La función mostrar llamaría a mostrar indefinidamente.) public void mostrar(){ //¡ojo!.mostrar(). } Ahora redefinimos la función miembro mostrar para mostrar una ventana con un título.

.. la función miembro desplazar accede a dichas variables miembros public class VentanaTitulo extends Ventana{ //.desplazar(4. ventana. Creamos un objeto ventana de la clase derivada VentanaTitulo VentanaTitulo ventana=new VentanaTitulo(0. Desde el objeto ventana de la clase derivada llamamos a las funciones miembro definidas en dicha clase ventana. Desde el objeto ventana de la clase derivada podemos llamar a las funciones miembro definidas en la clase base. 20. //. surge un nuevo control de acceso denominado protected. Para mostrar la nueva ventana desplazada y cambiada de tamaño escribimos ventana. Hemos puesto protected delante de las variables miembros x e y de la clase base Ventana public class Ventana { protected int x. } En la clase derivada. 0. public void desplazar(int dx. 30. Mostramos la ventana con su título. llamando a la función mostrar. redefinida en la clase derivada ventana.cambiarDimensiones(10. protected int y. } } 43 . Modificadores de acceso. En la herencia.. y+=dy. 3).mostrar().mostrar(). -5). int dy){ x+=dx. "Principal")..Capítulo 4 – Conceptos de Orientación a Objetos.

Capítulo 4 – Conceptos de Orientación a Objetos. las variables y métodos de instancia privados sólo pueden ser accedidos desde dentro de la clase. friendly. cualquier clase desde cualquier lugar puede acceder a las variables y métodos de instancia públicos 4. private. 2. Es lo mismo que protected. Si cambiamos el modificador de acceso de los miembros x e y de la clase base Ventana de protected a private. por defecto. lo que significa que son accesibles por todos los objetos dentro del mismo paquete. 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 . public. No son accesibles desde las subclases. si no se especifica el control de acceso. sólo las subclases de la clase y nadie más. las variables y métodos de instancia se declaran friendly (amigas). protected. Los miembros ancho y alto se pueden poner con acceso private. puede acceder a las variables y métodos de instancia protegidos 3. Dentro de una jerarquía pondremos un miembro con acceso private. es mejor dejarlos como protected ya que podrían ser utilizados por alguna función miembro de otra clase derivada de VentanaTitulo. sin embargo. si estamos seguros de que dicho miembro solamente va a ser usado por dicha clase. pero no por los externos al paquete. Como vemos hay cuatro modificadores de acceso a los miembros dato y a los métodos: 1. el compilador nos informará que los miembros x e y no son accesibles.

. Esta derivación es implícita. tanto si son referencias al mismo objeto como si son objetos distintos con iguales valores de las variables miembro. ni aquellos miembros (dato o función) cuyo nombre sea el mismo en la clase base y en la clase derivada. demuestra si el objeto dado como parámetro es igual al objeto actual.toHexString(hashCode()). } protected native Object clone() throws CloneNotSupportedException. equals() Indica si dos objetos son o no iguales. public String toString() { return getClass(). Desde el punto de vista práctico.equals(Object). Podemos simplificar la consulta utilizando el operador = = (igualdad). Esta implementación comprueba si ambas referencias son iguales. 45 . boolean objeto.Capítulo 4 – Conceptos de Orientación a Objetos. cabe reseñar que no se heredan los miembros privados. Devuelve true si son iguales. Igualdad de dos Objetos: El método equals de la clase Object compara dos objetos uno que llama a la función y otro es el argumento de dicha función. Entonces. La clase Object es la clase raíz de la cual derivan todas las clases. Las más importantes son las siguientes: public class Object { public boolean equals(Object obj) { return (this == obj). } Métodos que pueden ser redefinidos por el programador. } protected void finalize() throws Throwable { } //otras funciones miembro. La clase Object define una serie de funciones miembro que heredan todas las clases. La clase base object.. Las distintas clases de la librería de Java suelen sobrescribirlo para comprobar si los contenidos de la instancia son los mismos.getName() + "@" + Integer.

} Entonces: String objeto. clone() crea un objeto a partir de otro objeto de la misma clase.toString()devuelve una representación del objeto en formato de cadena de caracteres. es llamado automáticamente por Java cuando necesita convertir el objeto en cadena. por ejemplo para imprimirlo o exportarlo. es decir. que x. public String toString() { return getClass().equals(x) sea cierto. Es decir. La función toString se llama automáticamente siempre que pongamos un objeto como argumento de la función System.toHexString(hashCode()). No debería llamar al operador new ni a los constructores. Esta implementación devuelve una cadena que contiene el nombre de la clase del objeto. Por ejemplo. 46 .println o concatenado con otro string. Si se desea clonar una clase hay que implementar la interfase Cloneable y redefinir el método clone(). Este método debe hacer una copia miembro a miembro del objeto original.getName() + "@" + Integer. Duplicación de objetos: El método clone crea un objeto duplicado (clónico) de otro objeto.clone.Capítulo 4 – Conceptos de Orientación a Objetos. El método toString imprime por defecto el nombre de la clase a la que pertenece el objeto y su código (hash). seguido de una arroba y del código hash del mismo. al sobreescribirlo. Representación en forma de texto de un objeto: El método toString() devuelve un String que contiene una representación del objeto como cadena de caracteres. creemos un objeto nuevo cuyas propiedades tengan el mismo valor que las del objeto a copiar. El método original heredado de Object lanza una CloneNotSupportedException.out. La intención es que. cuando String sobrescribe este método compara si las cadenas contenidas en ambas instancias son iguales. Entonces: Object objeto.clone() copia el objeto. Esta función miembro se redefine en la clase derivada para mostrar la información que nos interese acerca del objeto.

hashCode() devuelve el código Hash del objeto. //código que libera recursos externos } } La primera sentencia que contenga la redefinición de finalize ha de ser una llamada a la función del mismo nombre de la clase base. etc. y a continuación le añadimos cierta funcionalidad. no es necesario redefinir este método en las clases. cerrar un archivo. las interfases implementadas.finalize().finalize()es llamado por el recolector de basura antes de eliminar el objeto.getClass() = = y. Este código se utiliza para las tablas Hash. al cual se le pueden aplicar métodos para determinar el nombre de la clase. protected void finalize() trows Throwable{ super. entonces sería acertado el utilizar la finalización para asegurar que los recursos se liberan. Se puede crear un objeto de la misma clase que otro sin saber de qué clase es. Finalización: El método finalize se llama cuando va a ser liberada la memoria que ocupa el objeto por el recolector de basura (garbage collector). Es similar a los destructores de C++. o cuando se han abierto varios archivos durante la vida de un objeto.getClass() int objeto. Por ejemplo.Capítulo 4 – Conceptos de Orientación a Objetos. etc. Métodos que NO pueden ser Redefinidos: getClass() devuelve un objeto de la clase class. class CualquierClase{ //. que son la manera más eficiente de almacenar objetos. La forma en la que se redefine este método es el siguiente. Para que dichas tablas funcionen necesitan que cada objeto almacenado tenga un código numérico que se mantenga durante toda la ejecución del 47 .getClass() devuelve un objeto de tipo class que identifica el tipo de objeto que tenemos. habitualmente. Por ejemplo podemos comprobar si x e y son del mismo tipo con: x.. Entonces: Class objeto. y se desea que los archivos estén cerrados cuando dicho objeto desaparece. su superclase. Entonces: void objeto. Normalmente. debe ser el programador el que sobreescriba este método en caso de que quiera realizar algo en especial antes de eliminar el objeto de la memoria. la liberación de recursos. solamente en contados casos especiales. Esta implementación no hace nada. 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.

que es la clase raíz de toda la jerarquía de clases de Java.Capítulo 4 – Conceptos de Orientación a Objetos.. Todas las clases de Java creadas por el programador tienen una super-clase. la clase deriva de java. programa y que sea el mismo para dos objetos si dichos objeto son iguales según el método equals(). Como consecuencia. aunque con este sistema sólo se puede subir un nivel en la jerarquía de clases. notifyAll() wait() Concretando: Son métodos relacionados con las threads Se puede construir una clase a partir de otra mediante el mecanismo de la herencia.. Estas funciones y variables miembro pueden ser redefinidas (overridden) en la clase derivada. } Cuando una clase deriva de otra. Se pueden crear tantas clases derivadas de una misma clase como se quiera. Java permite múltiples niveles de herencia.Object. notify(). 48 . devolver la longitud de la misma. El nuevo método sustituye al heredado para todos los efectos en la clase que lo ha redefinido. Los métodos de la super-clase que han sido redefinidos pueden ser todavía accedidos por medio de la palabra super desde los métodos de la clase derivada. Cuando no se indica explícitamente una super-clase con la palabra extends. Para indicar que una clase deriva de otra se utiliza la palabra extends. En cierta forma es como si la sub-clase (la clase derivada) “contuviera” un objeto de la super-clase. 4. hereda todas sus variables y métodos. class ClaseHija extends ClasePadre { . para las cadenas. que puede también definir o añadir nuevas variables y métodos. pero no permite que una clase derive de varias (no es posible la herencia múltiple). Redefinición de métodos heredados Una clase puede redefinir cualquiera de los métodos heredados de su super-clase que no sean final.lang. en realidad lo “amplía” con nuevas variables y métodos. todas las clases tienen algunos métodos que han heredado de Object. Un ejemplo sería.

MIERCOLES=2. Si es la clase la que lleva el modificador (final). Polimorfismo Esta palabra que significa "muchas formas". JUEVES=3. 6. en vez de protected o package). En 49 . un método abstract no puede ser static. DOMINGO=6. Aunque no se puedan crear objetos de esta clase.. pero no modificar. crearemos una constante. Clases y métodos abstractos Una clase abstracta (abstract) es una clase de la que no se pueden crear objetos. Debemos tener en cuenta que como los métodos static no pueden ser redefinidos. por lo que mantendrá su implementación. entonces nos aseguramos que nadie pueda heredar de dicha clase Por último. } 5. indicaremos que no puede ser sobreescrito en clases heredadas. proporcionándoles un marco o modelo que deben seguir y algunos métodos de utilidad general. Modificador final: Si declaramos un método como final. Las clases abstractas se declaran anteponiéndoles la palabra abstract. Su utilidad es permitir que otras clases deriven de ella. VIERNES=4. en cuyo caso no se da definición del método. pero nunca restringirlos. } Una clase abstract puede tener métodos declarados como abstract. Este último caso presenta un uso más habitual de este modificador: class Dias { static final int LUNES=0. Los métodos de clase static no pueden ser redefinidos en las clases derivadas. Una clase abstract puede tener métodos que no son abstract.. es una característica del lenguaje Java que permite a una interfase ser usada por una clase general de acciones. Los métodos redefinidos pueden ampliar los derechos de acceso de la super-clase (por ejemplo ser public. ya que dicha variable se puede inicializar. si declaramos una propiedad como final. Si una clase tiene algún método abstract es obligatorio que la clase sea abstract.Capítulo 4 – Conceptos de Orientación a Objetos. En cualquier sub-clase este método deberá ser redefinido o volver a declararse como abstract (el método y la sub-clase). por ejemplo: public abstract class NombreClase { . SABADO=5. sus sub-clases heredarán el método completamente a punto para ser utilizado. MARTES=1.

Capítulo 4 – Conceptos de Orientación a Objetos. objeto2= new ClaseHija2(parámetros). objeto2. el método) para aplicar en cada situación. funciona así: cuando se llama a un método. Será el compilador el que tendrá que seleccionar la acción concreta (esto es. Análogamente una referencia a un objeto de una determinada Interfase es capaz de servir de referencia o de nombre a objetos de cualquiera de las clases que implementan dicha interfase. Más detalladamente. Es evidente que esta forma de trabajar ayuda a reducir la complejidad del diseño. La dirección de la función llamada no se asigna en tiempo de compilación como ocurre con el enlace estático del C sino que se obtiene la dirección de la función llamada justo en el momento antes de ejecutarse. el código generado por el compilador consulta una tabla oculta de punteros a funciones que dispone cada clase. sepa discernir a qué método llamar en cada caso. ClasePadre objeto1. términos más generales. La idea básica es que una referencia a un objeto de una determinada clase es capaz de servir de referencia o de nombre a objetos de cualquiera de sus clases derivadas. aunque pertenecientes a distintas sub-clases o bien a clases que implementan dicha interfase. el polimorfismo consiste en poder definir métodos con la misma firma (nombre del método más argumentos) en diferentes niveles de la jerarquía de clases. Repasando. nosotros sólo tenemos que conocer la interfaz general. Podemos entender el sobrepaso fácilmente con un modelo simplificado. permite tratar de un modo unificado objetos distintos. 50 . ya que el compilador de Java hubiera generado un error en el tiempo de compilación si la firma del mensaje invocado sobre un objeto no corresponde a ninguna firma dentro de la clase a la que pertenece este o alguna superclase. cuando un mensaje es pasado a un objeto. objeto2. objeto2= new Clase2 (parámetros). y. Esto significa que es posible diseñar una interfaz genérica para un grupo de actividades relacionadas. que durante la ejecución el programa. pues permite usar una misma interfaz para especificar un conjunto de acciones similares. Es decir. Si se encuentra una igualdad el método correspondiente es ejecutado. Interface objeto1. la firma del mensaje es comparada con la firma de los mensajes de la clase a la que pertenece dicho objeto. El proceso se repite hasta que una igualdad se encuentre. Si no la firma del mensaje es comparada con la firma de los mensajes de la superclase. el concepto de polimorfismo a menudo se expresa por la frase "una interfaz. Como programadores. Durante la ejecución. objeto1= new Clase (parámetros). objeto1= new ClaseHija(parámetros). Una igualdad es garantizada. múltiples métodos".

Ligadura o Binding. que convierta su 51 . Un objeto cuya referencia es un tipo interfase sólo puede utilizar los métodos definidos en dicha interfase. con un método declarado en una clase base (o en una interfase) y redefinido en las clases derivadas (o en clases que implementan esa interfase). La vinculación tardía hace posible que. A esta relación se llama vinculación o ligadura (binding). De esta forma las referencias de tipo interfase definen. e interfases. Con funciones normales o sobrecargadas se utiliza generalmente vinculación temprana. Si se desea utilizar todos los métodos y acceder a todas las variables que la clase de un objeto permite.Capítulo 4 – Conceptos de Orientación a Objetos. clase base o interfase) limita los métodos que se pueden utilizar y las variables miembro a las que se pueden acceder. pero hay una importante limitación: el tipo de la referencia (clase abstracta. 7. Por ejemplo. Las interfases permiten ampliar muchísimo las posibilidades del polimorfismo por su mayor flexibilidad y por su independencia de la jerarquía de clases estándar. La vinculación puede ser: temprana (en tiempo de compilación) tardía (en tiempo de ejecución). hay que utilizar un cast (lanzamiento) explícito. El polimorfismo tiene que ver con la relación que se establece entre la llamada a un método y el código que efectivamente se asocia con dicha llamada. Las ventajas del polimorfismo son evidentes. Dicho de otro modo. El polimorfismo permite a los programadores separar las cosas que cambian de las que no cambian. excepto si el método es final. sea el tipo de objeto y no el tipo de la referencia lo que determine qué definición del método se va a utilizar. y de esta manera hacer más fácil la ampliación. superclases normales. El tipo del objeto al que apunta una referencia sólo puede conocerse en tiempo de ejecución. Vinculación. el mantenimiento y la reutilización de los programas. El polimorfismo puede hacerse con referencias de super-clases abstractas. Conversión de objetos El polimorfismo visto previamente está basado en utilizar referencias de un tipo más “amplio” que los objetos a los que apuntan. Con funciones redefinidas se utiliza siempre vinculación tardía. aunque sólo en el caso en que su clase o una de sus super-clases implementen dicha interfase. ese objeto no puede utilizar las variables y los métodos propios de su clase. un objeto puede tener una referencia cuyo tipo sea una interfase. limitan y unifican la forma de utilizarse de objetos pertenecientes a clases muy distintas (que implementan dicha interfase). y por eso el polimorfismo necesita evaluación tardía.

j ).x ((A)this). System. Los métodos pueden además tener otros argumentos explícitos que van entre paréntesis. Si falta información. referencia más general en la del tipo específico del objeto. Sólo se pueden utilizar los métodos definidos en la super-clase. por ejemplo. Para acceder a esta información adicional hay que hacer un cast explícito en la forma (B)a. Los métodos son funciones definidas dentro de una clase. aunque la definición utilizada para dichos métodos sea la de la sub-clase. Dicho objeto es su argumento implícito. Salvo los métodos static o de clase.). ya que el objeto de la subclase siempre tiene toda la información necesaria para ser utilizado en lugar de un objeto de la superclase. Considérese el siguiente ejemplo: La clase C deriva de B y B deriva de A. Para la conversión entre objetos de distintas clases. una nueva variable miembro j declarada en B). De aquí una parte importante del interés del cast entre objetos (más bien entre referencias).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. Java exige que dichas clases estén relacionadas por herencia (una deberá ser subclase de la otra). Por ejemplo. Se realiza una conversión implícita o automática de una subclase a una superclase siempre que se necesite.Capítulo 4 – Conceptos de Orientación a Objetos. a continuación del nombre del método. se aplican siempre a un objeto de la clase por medio del operador punto (. aunque estén redefinidos en la sub-clase. Las tres definen una variable x. //imprime la variable j Un cast de un objeto a la super-clase puede permitir utilizar variables -no métodosde la super-clase.x ((B)this). supóngase que se crea un objeto de una sub-clase B y se referencia con un nombre de una super-clase A.println( ((B)a). 52 .x super. A a = new B(). No se puede acceder a las variables exclusivas de la sub-clase a través de una referencia de la super-clase.out. Sólo se puede x de B x de A Métodos (funciones miembro). En este caso. si desde el código de la sub-clase C se utiliza: x this. La conversión en sentido contrario debe hacerse de modo explícito y puede producir errores por falta de información o de métodos. en este caso el objeto creado dispone de más información de la que la referencia a le permite acceder (podría ser. se obtiene una ClassCastException.

Si no hay argumentos explícitos se dejan los paréntesis vacíos. pueden acceder a ellas sin cualificarlas con un nombre de objeto y el operador punto. Es la forma de poder utilizar conjuntamente funciones realizadas en otros lenguajes desde código escrito en Java. alguna variable local o argumento las oculta.} 53 .). y el código comprendido entre las llaves {…} es el cuerpo (body) del método. C++. es decir. Los métodos pueden definir variables locales. Un método también puede declararse como synchronized public synchronized double metodo(){. pero el compilador no permite utilizarlas sin haberles dado un valor. Su visibilidad llega desde la definición al final del bloque en el que han sido definidas. etc. pero nunca de una superclase. del tipo del valor de retorno (Float en este ejemplo. separados por comas. Se puede devolver también una referencia a un objeto por medio de un nombre de interfase. Estas librerías son ficheros de funciones compiladas normalmente en lenguajes distintos de Java (C.. El valor de retorno (return) puede ser un valor de un tipo primitivo o una referencia. Si en el header del método se incluye la palabra native public native void metodo().. En cualquier caso no puede haber más que un único valor de retorno (que puede ser un objeto o un arreglo). no hay que incluir el código o implementación del método. public Float método() { // header y comienzo del método sentencias // body o cuerpo return valor } // final del método El header consta del cualificador de acceso (public. El objeto devuelto debe pertenecer a una clase que implemente esa interfase. Los métodos tienen visibilidad directa de las variables miembro del objeto que es su argumento implícito. De todas formas. Se puede devolver como valor de retorno un objeto de la misma clase que el método o de una sub-clase. La primera línea de la definición de un método se llama declaración (header). Este código deberá estar en una librería dinámica (Dynamic Link Library o DLL). también se puede acceder a ellas mediante la referencia this (this. Fortran.variable) o sí. A diferencia de las variables miembro. del nombre de la función y de una lista de argumentos explícitos entre paréntesis. en este caso). las variables locales no se inicializan por defecto. No hace falta inicializar las variables locales en el punto en que se definen.Capítulo 4 – Conceptos de Orientación a Objetos. void si no tiene).

} Realmente no sería necesario definir el método suma() para todos los tipos de datos. la idea es aprovechar las ventajas que ofrece esta forma de polimorfismo. el compilador actúa justo sobre la versión cuyo tipo de parámetros coincida con los de la llamada. Por ejemplo. int b) { return a+b. Aquí. } double suma (double a. como es el caso del ejemplo anterior pero no nos debemos confundir. se llama ese método. 54 . double b) { return a+b. Por ejemplo. A la hora de llamar a un método sobrecargado. siempre que la declaración de sus parámetros sea diferente. se podría definir la siguiente clase "SumaGenerica" que aglutinará las sumas de todos los tipos primitivos: class SumaGenerica { int suma (int a. una suma de float. claro está.. es decir. pero que se diferencian por el número y/o tipo de los argumentos. Si existe el método cuyos argumentos se ajustan exactamente al tipo de los argumentos de la llamada (argumentos actuales). Así. No existe una regla exacta para saber si un método se debe sobrecargar o no.. métodos distintos que tienen el mismo nombre. En este caso se dice que el método está sobrecargado y el proceso de definir un método así se conoce como sobrecarga del método. Java sigue las siguientes reglas para determinar el método concreto que debe llamar: 1. Hemos expuesto que al igual que C++. llamaría automáticamente al método que devuelve double siempre y cuando no esté definido el método que devuelve float. el método sqrt(). calcula de forma totalmente diferente la raíz cuadrada de un número entero que la de uno de punto flotante. Cuando se llama a un método sobrecargado. Java permite métodos sobrecargados (overloaded). pues aquí también interviene el casting implícito que hace Java. Estos métodos tienen la particularidad de que sobre un objeto no pueden ejecutarse simultáneamente dos métodos que estén sincronizados. aunque aplicáramos sobrecarga al método.Capítulo 4 – Conceptos de Orientación a Objetos. así que lo normal es sobrecargar aquellos métodos que estén intrínsicamente relacionados. } . aunque se llama igual. Métodos sobrecargados (overloaded) Otra de las ventajas de este lenguaje de programación es que nos permite definir dos o más métodos dentro de la misma clase con el mismo nombre. Realmente. realmente no estaríamos respetando el propósito para el que se creó el polimorfismo. La sobrecarga de métodos es una de las maneras en que Java implementa el polimorfismo.

En realidad es imposible saber desde el propio método lo que se va a hacer con él. debido a un fallo en alguna otra parte de la aplicación (me refiero a cualquier otra clase que llame a ésta). como mínimo se debería tener en cuenta que podría no pasársele parámetros al constructor. es decir con el mismo nombre. el constructor de una clase es el que inicializa los valores que el programador crea conveniente cuando ésta (la clase) se instancia. float a double. double alto. Es por ello que siempre es recomendable definir al menos dos constructores: el específico de la aplicación que estemos diseñando y el "estándar". // El siguiente es el constructor específico Caja(double w. el programador debe hacer un cast explícito en la llamada. Si sólo existen métodos con argumentos de un tipo más restringido (por ejemplo. Redefinición Una clase puede redefinir (override) un método heredado de una superclase.) y se llama el método correspondiente. double h. Pues bien. int en vez de long). Redefinir un método es dar una nueva definición. No es posible crear dos métodos sobrecargados. } // pero podría ser que no le llegarán parámetros // por fallar la otra clase (método) que lo // invoque 55 . Por ejemplo. Una sugerencia importante es que la redefinición debe ser algo excepcional en POO. 4. En este caso el método debe tener exactamente los mismos argumentos en tipo y número que el método redefinido. alto = h. Si no existe un método que se ajuste exactamente. double profundidad. int a long. 8. El valor de retorno no influye en la elección del método sobrecargado. etc. 3. sobrecargando el constructor conseguimos dotar a la clase de flexibilidad. profundidad = d. Sobrecarga de Constructores Es aquí donde realmente se aprecian los beneficios del polimorfismo. 2. que sólo difieran en el valor de retorno.Capítulo 4 – Conceptos de Orientación a Objetos. Como sabemos. se intenta promover los argumentos actuales al tipo inmediatamente superior (por ejemplo char a int. double d) { ancho = w. cuando éste lo espera. Veamos un ejemplo: class Caja { double ancho.

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

Caja () { ancho = alto = profundidad = -1 //-1 indica volumen no existente } // e incluso podemos pensar que se quiere construir // un cubo, entonces, por qué introducir 3 valores? Caja (double valor) { ancho = alto = profundidad = valor; } double volume() { return ancho * alto * profundidad; }

}

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

class Comparar { int a, b; Comparar (int i, int j) { a = i; b = j; } boolean equals (Comparar c) { if (c.a == a && c.b == b) return true; else return false; }

}

Como se puede apreciar, el método equals() de Comparar comprueba si dos objetos son idénticos. Paso de argumentos. Existen dos formas de pasar un argumento a una rutina: Por valor: El método copia el valor de un argumento en el parámetro formal de la rutina. Por referencia: El método copia el objeto en el parámetro formal de la rutina.

56

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

En el primer caso, al ser solo una copia, cualquier modificación dentro de la rutina de ese valor no tendrá efecto una vez fuera de éste, mientras que si es por referencia, sí persistirá la modificación hecha, aún cuando salgamos de la rutina. Cuando en Java se pasan argumentos de tipo simple, estos siempre se hacen por valor. Si se desea pasar un parámetro por referencia se debe pasar un objeto. Esto ocurre porque cuando se crea una variable de un tipo de clase, el programador solo crea una referencia al objeto. Así, cuando se pasa esta referencia a un método, el parámetro que recibe éste, se refiere al mismo objeto que el referido por el argumento. Por lo tanto, los cambios que se hagan en la referencia de la rutina afectarán también al objeto pasado como argumento. El operador static Hay veces que se desea definir una clase miembro para ser usada independientemente de cualquier objeto de esa clase. Normalmente a una clase miembro se accede sólo si hemos instanciado un objeto de dicha clase. No obstante, es posible crear un miembro que pueda ser usado por sí mismo, sin necesidad de referenciar a una instancia específica. Para crear tales tipos de miembros se emplea el operador static. Cuando un miembro se declara con esta palabra reservada, se puede acceder a él antes de que cualquier objeto de su clase sea creado, y sin referenciar a ningún objeto. Se puede declarar tanto los métodos como las variables como static. El ejemplo más claro de un miembro static es el main(). Se declara de esta manera porque se debe llamar antes de que cualquier objeto sea declarado. Las variables static Las variables de instancia declaradas como static (también llamadas "de clase") son, esencialmente, variables globales. Cuando creamos objetos específicos de esa clase no se hace ninguna copia de las variables static. Lo que ocurre es que todas las instancias de esa clase comparten la misma variable static. Estas variables mayormente tienen sentido cuando varias instancias de la misma clase necesitan llevar el control o estado del valor de un dato. Para llamar a este tipo de variables se suele utilizar el nombre de la clase (no es imprescindible, pues se puede utilizar también el nombre de cualquier objeto), porque de esta forma queda más claro, seguida de un "." y la variable Estatica.b Las variables miembro static se crean en el momento en que pueden ser necesarias: cuando se va a crear el primer objeto de la clase cuando se llama a un método static cuando se utiliza una variable static de dicha clase. Lo importante es que las variables miembro static se inicializan siempre antes que cualquier objeto de la clase.

57

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

Los métodos static. También llamados "de clase", pueden recibir objetos de su clase como argumentos explícitos, pero no tienen argumento implícito ni pueden utilizar la referencia this. Para llamar a estos métodos se suele emplear el nombre de la clase, en vez del nombre de un objeto de la clase. Los métodos y variables de clase son lo más parecido que Java tiene a las funciones y variables globales de C/C++. Las restricciones que tiene un método static son: Solo pueden llamar otro método static Solo deben acceder a datos static No se pueden referir a this o super de ninguna manera Si se necesita hacer algún tipo de computación para inicializar las variables static, se puede declarar también un bloque static el cual se ejecutará solo una vez, cuando se carga.

class Estatica { static int a = 3; static int b; static void show(int x) { System.out.println("x = " + x); System.out.println("a = " + a); System.out.println("b = " + b); } static { System.out.println("Bloque estático inicializado"); b = a * 4; // vemos que, aunque declarada como static // b se inicializa en tiempo de ejecución } public static void main(String args[ ]) { show(15); } }
Tan pronto como la clase “Estatica” se carga, todas las sentencias se ejecutan. Primero, “a” se inicializa a 3, luego se ejecuta el bloque estático y, por último, “b” se inicializa al valor asignado. En resumen podemos decir para los miembros de tipo static: Miembros (métodos o atributos) implementados al nivel de clase Desde métodos static la referencia this no tiene sentido No se puede acceder a miembros no estáticos desde métodos estáticos static: Semántica de "ámbito global" Permite desarrollo de código sin usar POO

58

public class Clase extends ClasePadre implements Interfase. Esto es lo más parecido a las constantes de otros lenguajes de programación. es constante pero no tiene porqué tener el mismo valor en todas las ejecuciones del programa. . Aunque básicamente este operador se emplea para crear constantes en Java. La variable final así definida. 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. pues depende de cómo haya sido inicializada. Interfases. y deben siempre inicializarse en la declaración. Interfase2 { . detrás de la palabra implements. separados por comas. A pesar de esta semejanza. Esto se hace por motivos de seguridad y de eficiencia. que hace que en 59 . final float PI = 3. No obstante. llamando a métodos o en función de otros datos. static y final. Un método final no puede ser redefinido por una clase que derive de su propia clase. 9. se previene que su contenido sea modificado. También puede definir constantes. que son implícitamente public. Una interfase es un conjunto de declaraciones de métodos (sin definición). El operador final Al declarar una variable como final..Capítulo 4 – Conceptos de Orientación a Objetos. } ¿Qué diferencia hay entre una interfase y una clase abstract? Ambas tienen en común que pueden contener varias declaraciones de métodos (la clase abstract puede además definirlos). porque cuando el compilador detecta que los métodos no van a ser redefinidos puede hacer optimizaciones adicionales.. Todas las clases que implementan una determinada interfase están obligadas a proporcionar una definición de los métodos de la interfase. Esta última se puede hacer más tarde. //Según la convención de // código las variables "constantes" se ponen en // mayúsculas. Para indicar que una clase implementa una o más interfases se ponen los nombres de las interfases. Una clase puede implementar una o varias interfases.1416... Una clase final no puede tener clases derivadas. y en ese sentido adquieren una conducta o modo de funcionamiento. también podemos definir una clase o un método como final. Java permite separar la definición de la inicialización. en tiempo de ejecución.

Las interfases tienen una jerarquía propia. Las interfases permiten mucha más flexibilidad para conseguir que dos clases tengan el mismo comportamiento. Definición de interfases. Si la interfase no es public no será accesible desde fuera del package. de modo implícito.0*NombreInterface. independientemente de su situación en la jerarquía de clases de Java.java con el mismo nombre de la interfase. ya que tienen permitida la herencia múltiple. Una clase no puede heredar métodos -definidos. existen también algunas diferencias importantes: Una clase no puede heredar de dos clases abstract. public void metodo2(param). Utilización de interfases Las constantes definidas en una interfase se pueden utilizar en cualquier clase (aunque no implemente la interfase) precediéndolas del nombre de la interfase area = 2.Capítulo 4 – Conceptos de Orientación a Objetos.de una interfase. De cara al polimorfismo las referencias de un tipo interfase se pueden utilizar de modo similar a las clases abstract. aunque sí constantes. Las interfases permiten “publicar” el comportamiento de una clase develando un mínimo de información. independiente y más flexible que la de las clases. pero sí puede heredar de una clase abstract e implementar una interfase. Una interfase se define de un modo muy similar a las clases: public interface NombreInterface { public void metodo(param. Los nombres de las interfases suelen comenzar también con mayúscula. algunas ocasiones se pueda sustituir una por otra. Las interfases no admiten más que los modificadores de acceso public y package. Los métodos declarados en una interfase son siempre package y abstract. param2). o bien implementar dos o más interfases.var*r. 60 . } Cada interfase public debe ser definida en un fichero *.

nombre_metodo() 10. 61 . que consiste básicamente en ocultar la información que no es pertinente o necesaria para realizar una determinada tarea. Los permisos de acceso de Java son una de las herramientas para conseguir esta finalidad. o Se puede añadir comportamiento adicional Implícita en constructores como primera instrucción En métodos: super. En este sentido. Accesibilidad de los Packages (paquetes). como si fueran constantes de la clase. cualquier clase o interfase de un paquete es accesible para todas las demás clases del paquete. Una referencia es una variable que indica dónde está guardado un objeto en la memoria del ordenador La llamada a super. el nombre de una interfase se puede utilizar como un nuevo tipo de referencia. tanto si es public como si no lo es. Accesibilidad de Clases o Interfases. Una de las características de la POO es la encapsulación. serán accesibles aquellos paquetes que se encuentren en la variable CLASSPATH del sistema. Conceptos Útiles Es importante distinguir entre la referencia a un objeto y el objeto mismo. Sin embargo. aunque su uso estará restringido a los métodos de la interfase. Permisos de acceso en java. A veces se crean interfases para agrupar constantes simbólicas relacionadas. un paquete (package) es accesible si sus directorios y ficheros son accesibles (si están en un ordenador accesible y se tiene permiso de lectura). En este sentido. Desde el punto de vista del polimorfismo. el nombre de una interfase puede ser utilizado en lugar del nombre de cualquier clase que la implemente.Capítulo 4 – Conceptos de Orientación a Objetos. Referencia a la superclase de la que desciende la clase actual Reutilización de código por medio de herencia o Super invoca al comportamiento anterior. En principio. Los objetos son los elementos declarados de una clase. El primer tipo de accesibilidad hace referencia a la conexión física de las computadoras y a los permisos de acceso entre ellas y en sus directorios y ficheros. Además de la propia conexión física. en las clases que implementan la interfase las constantes se pueden utilizar directamente. Un objeto de ese tipo puede también ser utilizado como valor de retorno o como argumento de un método.

Las sub-clases heredan los miembros private de su super-clase. Desde una sub-clase. protected o package de la super-clase. 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 . sólo un método static de la propia clase puede crear objetos. También son accesibles si la clase que accede es una sub-clase y el miembro es protected. Desde otras clases del paquete (package). Accesibilidad de las Variables y Métodos Miembros de una Clase. Recuérdese que las clases e interfases sólo pueden ser public o paquete (la opción por defecto cuando no se pone ningún modificador).Capítulo 4 – Conceptos de Orientación a Objetos. Si el constructor de una clase es private. Resumen de los permisos de acceso de Java. Los métodos y variables son accesibles si la clase es public y el miembro es public. Desde dentro de la propia clase: Todos los miembros de una clase son directamente accesibles (sin calificar con ningún nombre o calificando con la referencia this) desde dentro de la propia clase. pero sólo pueden acceder a ellos a través de métodos public. Desde otras clases fuera del paquete (package). Una clase public es accesible para cualquier otra clase (siempre que su paquete sea accesible). Los métodos no necesitan que las variables miembro sean pasadas como argumento. Desde una clase de un package se tiene acceso a todos los miembros que no sean private de las demás clases del package. Los miembros private de una clase sólo son accesibles para la propia clase.

Por ejemplo. La sincronización nace de la necesidad de evitar que dos o más threads (hilos) traten de acceder a los mismos recursos al mismo tiempo. por ejemplo de int a double. 11. Otra situación en la que hay que sincronizar threads se produce cuando un thread debe esperar a que estén preparados los datos que le debe suministrar el otro thread. por ejemplo de int a long. result = (long) (a/(b+c)). Sincronización de threads (hilos). Casting Explícito (Operador Cast): Las conversiones de un tipo de mayor a otro de menor precisión requieren una orden explícita del programador. 12. se produciría una situación no deseada. long result. Explicaremos ahora estas transformaciones de tipo. Casting Implícito: La conversión entre tipos primitivos es más sencilla. En Java se realizan de modo automático conversiones implícitas de un tipo a otro de más precisión. si un thread tratara de escribir en un fichero. Transformaciones de tipo: casting. En muchas ocasiones hay que transformar una variable de un tipo a otro. de float a double. El cast se hace poniendo el tipo al que se desea transformar entre paréntesis. pues son conversiones inseguras que pueden dar lugar a errores (por ejemplo. y otro thread tuviera al mismo tiempo tratando de borrar dicho fichero. A estas conversiones explícitas de tipo se les llama cast. aunque relacionadas mediante la herencia. hay que estar seguro de que puede ser representado con el número de cifras binarias de short). o de float a long. 63 . etc. En otras ocasiones la conversión debe hacerse entre objetos de clases diferentes. Conversión de tipos primitivos. Estas conversiones se hacen al mezclar variables de distintos tipos en expresiones matemáticas o al ejecutar sentencias de asignación en las que el miembro izquierdo tiene un tipo distinto (más amplio) que el resultado de evaluar el miembro derecho.Capítulo 4 – Conceptos de Orientación a Objetos. como por ejemplo. para pasar a short un número almacenado como int.

.

La relación jerárquica se muestra en la figura siguiente: Figura Circulo Rectángulo La clase Figura es la que contiene las características comunes a dichas figuras concretas por lo tanto. diseñar una jerarquía de clases. 65 . tenga las características comunes y cada clase derivada las específicas. aunque el procedimiento para calcular el área sea completamente distinto. IMPLEMENTACIÓN DE LOS CONCEPTOS DE OO CON JAVA En este capítulo se propone fijar los conceptos aprendidos. Tales figuras comparten características comunes. Implementado el concepto Jerarquía Los temas a implementar son: La Jerarquía de Clases La jerarquía de clases que describen las figuras planas Consideremos las figuras planas cerradas como el rectángulo y el círculo. Esto lo expresamos declarando Figura como una clase abstracta. y derivar de ella las características específicas de cada pieza particular. pero a través de programas de aplicación que utilicen cada uno de ellos. con las características comunes a todas las piezas. tal que la clase base denominada Figura. la posición de la figura. declarando la función miembro area abstract. tales como. Podemos entonces. Sin embargo. como es su posición en el tablero.Capítulo 5 – Implementación de los conceptos de OO con JAVA Capítulo 5. Así pues. Las clases abstractas solamente se pueden usar como clases base para otras clases. de su centro y el área de la figura. se pueden declarar variables de dichas clases. y cada tipo de pieza definirá dicha función de acuerdo a las reglas de su movimiento sobre el tablero. En el juego del ajedrez podemos definir una clase base denominada Pieza. la clase Pieza será una clase abstracta con una función abstract denominada mover. No se pueden crear objetos pertenecientes a una clase abstracta. no tiene forma ni tiene área.

protected int y. this. ya que cada figura particular tiene una fórmula distinta para calcular su área. El constructor de la clase derivada llama al constructor de la clase base y le pasa las coordenadas del punto x e y. Después inicializa sus miembros dato ancho y alto. int y) { this. class Rectangulo extends Figura { protected double ancho. la clase derivada Rectangulo. declarada abstract en la clase base Figura. int y. Por ejemplo. } public double area(){ return ancho*alto. de su centro. aparte de su posición (x. public abstract class Figura { protected int x. } } La primera sentencia en el constructor de la clase derivada es una llamada al constructor de la clase base. this. contiene la posición x e y de la figura particular.x=x.ancho=ancho.y=y. alto. public Rectangulo(int x. } public abstract double area(). para ello se emplea la palabra reservada super. se calcula el área del rectángulo como producto de la anchura por la altura.Capítulo 5 – Implementación de los conceptos de OO con JAVA La clase Figura La definición de la clase abstracta Figura. double alto){ super(x. this. sus dimensiones. su ancho y alto.alto=alto. En la definición de la función area.y). } La clase Rectángulo Las clases derivadas heredan los miembros dato x e y de la clase base. public Figura(int x. double ancho. y la función area. y) en el plano. tiene como datos. y definen la función area. y se devuelve el resultado 66 . que se va a definir en las clases derivadas para calcular el área de cada figura en particular. es decir.

0) y de 5. public Circulo(int x. Uso de la jerarquía de clases.PI es una aproximación decimal del número irracional pi. 67 .out.5. Creamos un objeto c de la clase Círculo situado en el punto (0. o bien p*r*r. double radio){ super(x. se inicializa el miembro dato radio. En la definición de la función area. int y.println("Area del rectángulo "+r. 0) y de dimensiones 5. } } Como vemos.Capítulo 5 – Implementación de los conceptos de OO con JAVA La clase Círculo class Circulo extends Figura { protected double radio. se calcula el área del círculo mediante la conocida fórmula p*r2. 0.PI*radio*radio.0).5 unidades de radio. La constante Math. Calculamos y mostramos el valor de su área. System.y). 2. 5. } public double area(){ return Math.println("Area del círculo "+c. Rectangulo r=new Rectangulo(0.out. 0.area()). System. 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). Circulo c=new Circulo(0.5). Veamos ahora. this. Calculamos y mostramos el valor de su área. Posteriormente. de la clase derivada Círculo.radio=radio. Creamos un objeto r de la clase Rectangulo situado en el punto (0. 5. la primera sentencia en el constructor de la clase derivada es una llamada al constructor de la clase base empleando la palabra reservada super.area()).5 de anchura y 2 unidades de largo.

7. 5. Ahora bien. fig[0]=new Rectangulo(0. System.0). Supongamos que deseamos saber la figura que tiene mayor área independientemente de su forma.0. o seleccionando un control en un applet. 2. esto se conoce como enlace temprano o estático.out. 4. los lenguajes C++ y Java permiten decidir a que función llamar en tiempo de ejecución. luego llamará a la función miembro area de Rectangulo. esto se conoce como enlace tardío o dinámico. f=new Rectangulo(0. 68 . 6. el segundo elemento del array guarda una referencia un objeto de la clase Circulo. en el momento en que se ejecuta el programa.0.0. Primero.area()).println("Area del rectángulo "+f. 0. 7.0). fig[1]=new Circulo(0. la decisión sobre qué función area se va a llamar se retrasa hasta el tiempo de ejecución. fig[2]=new Circulo(0. En el lenguaje C.0). luego llamará también a la función area de Circulo. fig[3]=new Rectangulo(0. y así sucesivamente.out. La respuesta será. Enlace dinámico o binding. Si i es cero. a través del teclado. ¿A qué función area llamará la sentencia: ? fig[i]. 5.0). 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.area()).0). 5. según sea el índice i. 0. Figura[] fig=new Figura[4].Capítulo 5 – Implementación de los conceptos de OO con JAVA Figura f=new Circulo(0.println("Area del círculo "+f.5). Luego. programamos una función que halle el mayor de varios números reales positivos.0. Ejemplo de polimorfismo. System.0. los identificadores de la función están asociados siempre a direcciones físicas antes de la ejecución del programa.area(). 5. Si i es uno. el primer elemento del array guarda una referencia a un objeto de la clase Rectangulo.5. 0. Podemos introducir el valor del índice i.

i<x. y en mFigura. static Figura figuraMayor(Figura[] figuras){ Figura mFigura=null.length. } La clave de la definición de la función está en las líneas if(figuras[i]. En areaMayor se guarda el valor mayor de las áreas calculadas. La función figuraMayor que compara el área de figuras planas es semejante a la función valorMayor anteriormente definida. } return mayor.println("El valor mayor es " + valorMayor(numeros)).length. for (int i=0. } } return mFigura.area()>areaMayor){ areaMayor=figuras[i].0. } Ahora. i++){ if(figuras[i]. 1. } En la primera línea. double areaMayor=0.area(). System. i++) if(x[i]>mayor){ mayor=x[i]. se le pasa el array de objetos de la clase base Figura. 5.area()>areaMayor){ areaMayor=figuras[i].out. se llama a la versión correcta de la función area dependiendo de la referencia al tipo de objeto que guarda el elemento figuras[i] del array.2}. for(int i=0. la figura cuya área es la mayor. La principal ventaja de la definición de esta función estriba en que la función figuraMayor está definida en términos de la variable figuras de la clase base 69 . la llamada a la función valorMayor double numeros[]={3.Capítulo 5 – Implementación de los conceptos de OO con JAVA double valorMayor(double[] x){ double mayor=0.4.0.0. mFigura=figuras[i]. mFigura=figuras[i]. La función devuelve una referencia al objeto cuya área es la mayor. 3.area(). i<figuras.2.

llamará a la función area definida en dicha clase. 0. Pasamos el array fig a la función figuraMayor. trabaja no solamente para una colección de círculos y rectángulos. 5. y se añade a la jerarquía de clases. Veamos ahora la llamada a la función figuraMayor Figura[] fig=new Figura[4]. Así si se deriva Triangulo de Figura.0). desde fMayor se llamará a la función miembro area.0. llamará a la función area definida en dicha clase.0.0.Capítulo 5 – Implementación de los conceptos de OO con JAVA Figura.println(“El área mayor es “+fMayor. 6. 7. La combinación de herencia y enlace dinámico se denomina polimorfismo. fig[0]=new Rectangulo(0. 4. por tanto.out. System. el valor que retorna lo guardamos en fMayor. la función figuraMayor podrá manejar objetos de dicha clase.0. 5. sin modificar para nada el código de la misma.area()). Se llamará a la versión correcta dependiendo de la referencia al tipo de objeto que guarde por fMayor.0). fig[1]=new Circulo(0. Ampliamos el árbol jerárquico de las clases que describen las figuras planas regulares: Figura Triángulo Rectángulo Círculo Cuadrado 70 .0). y así sucesivamente. El polimorfismo es.0. Para conocer el valor del área.0). fig[3]=new Rectangulo(0. fig[2]=new Circulo(0. Si fMayor guarda una referencia a un objeto de la clase Rectangulo. Figura fMayor=figuraMayor(fig). Si fMayor guarda una referencia a un objeto de la clase Circulo. Ampliación de la jerarquía de clases. por lo tanto. la técnica que permite pasar un objeto de una clase derivada a funciones que conocen el objeto solamente por su clase base. sino también para cualquier otra figura derivada de la clase base Figura. 7.

double dimension){ super(x. } public double area(){ return base*altura/2. int y. } } El constructor de la clase Triangulo llama al constructor de la clase Figura. se calcula el área del triángulo como producto de la base por la altura y dividido por dos. } } El constructor de la clase derivada llama al constructor de la clase base y le pasa la posición x e y de la figura. ya que un cuadrado tiene los lados iguales. En la definición de la función area. double base. el ancho y alto que tienen el mismo valor. aparte de su posición (x. this. dimension).base=base. dimension. 71 . this. class Triangulo extends Figura{ protected double base. La clase Cuadrado hereda la función area definida en la clase Rectangulo. y luego inicializa los miembros dato base y altura.Capítulo 5 – Implementación de los conceptos de OO con JAVA La clase Cuadrado es una clase especializada de Rectangulo. y) en el plano. la base y la altura del triángulo. y. Esta clase tiene como datos. altura. public Triangulo(int x. int y. La clase Triangulo. No es necesario redefinir una nueva función area.altura=altura. class Cuadrado extends Rectangulo{ public Cuadrado(int x. El constructor solamente precisa de tres argumentos los cuales corresponden a la posición de la figura y a la longitud del lado. double altura){ super(x. y). le pasa las coordenadas x e y de su centro.

rect instanceof String //false rect instanceof Rectangulo //true El objeto rect de la clase Rectangulo no es un objeto de la clase String. se inicializan los miembros dato de dicha clase derivada. el mismo número de parámetros y del mismo tipo que en la clase base. una clase en el lado derecho. Esta expresión devuelve true o false dependiendo de que el objeto situado a la izquierda sea o no una instancia de la clase situada a la derecha o de alguna de sus clases derivadas. (redefinición de métodos) 72 . La clase derivada hereda los datos y las funciones miembro de la clase base. El objeto rect si es un objeto de la clase Rectangulo. Veamos la relación entre rect y las clases de la jerarquía rect instanceof Figura 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 creación de nuevas clases a partir de clases ya existentes. en las clases derivadas se declara y se define una función que tiene el mismo nombre. específico de los objetos de la clase derivada. 5.0. y puede redefinir algunas de las funciones miembro o definir otras nuevas. El polimorfismo se implementa por medio de las funciones abstractas. pero que da lugar a un comportamiento distinto. Para crear un objeto de la clase derivada se llama primero al constructor de la clase base mediante la palabra reservada super. Rectangulo rect=new Rectangulo(0. Luego. para ampliar la funcionalidad que ha recibido de la clase base.Capítulo 5 – Implementación de los conceptos de OO con JAVA El operador instanceof. 0. 2. y.0). El operador instanceof tiene dos operandos: un objeto en el lado izquierdo.

ya que no se espera que ningún programador necesite crear clases derivadas de Cuadrado. es la de crear una clase derivada y redefinir algunos de los métodos de la clase base. se declara la clase como final. Clases y Métodos Finales Clases Finales. 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. final class Cuadrado extends Rectangulo{ public Cuadrado(int x. double dimension){ super(x. está declarada como final. Se puede declarar una clase como final. Como sabemos. la clase String que es una de las más importantes en la programación en lenguaje Java. dañinas. La clase Cuadrado se puede declarar como final.Capítulo 5 – Implementación de los conceptos de OO con JAVA Enlace dinámico significa que la decisión sobre la función a llamar se demora hasta el tiempo de ejecución del programa. dimension). y no cualquier otro string.String. De este modo podemos ampliar la jerarquía de clases sin modificar el código de las funciones que manipulan los objetos de las clases de la jerarquía. Por ejemplo.lang. 73 . una de las formas de aprovechar el código existente. es un objeto de la clase String que se encuentra en el paquete java. El lenguaje Java garantiza que siempre que se utilice un string. impidiendo a cualquier programador la creación de clases derivadas de ésta. y. Para prevenir los posibles daños. Esta peculiaridad nos permite pasar un objeto de una clase derivada a una función que conoce el objeto solamente por su clase base. normalmente. } } Uno de los mecanismos que tienen los hackers (piratas) para dañar o para obtener información privada en los sistemas es la de crear una clase derivada y sustituir dicha clase por la original. La clase derivada actúa exactamente igual que la original pero también puede hacer otras cosas. Métodos finales. int y. dimension. cuando no nos interesa crear clases derivadas de dicha clase.

.. La clase Derivada redefine la función miembro dibujar. Interfases. public interface Runnable { public abstract void run(). final public void funcionFinal(){ //. public void dibujar(Graphics g){ // dibujar algunas figuras } } La clase Base define una función miembro pública “dibujar”. La función que se redefine tiene que tener la misma declaración en la clase Base y en la clase Derivada. } public void dibujar(Graphics g){ } } class Derivada{ //. La función miembro funcionFinal de la clase Base no se puede redefinir en la clase Derivada. pero no se implementa.. } Las clases que implementen (implements) el interfase Runnable han de definir obligatoriamente la función run. pero si se puede redefinir la función miembro dibujar. que no dibuja nada en el contexto gráfico g.Capítulo 5 – Implementación de los conceptos de OO con JAVA class Base{ //.. Para evitar que las clases derivadas redefinan una función miembro de una clase base. Una interfase es una colección de declaraciones de métodos (sin definirlos) y también puede incluir constantes. una función miembro run... Runnable es un ejemplo de interfase en el cual se declara. se le antepone la palabra clave final. 74 . para dibujar algunas figuras en el contexto grafico g.

En el lenguaje Java la clase MiApplet deriva de la clase base Applet e implementa el interfase Runnable class MiApplet extends Applet implements Runnable{ //. Una clase abstracta puede incluir: métodos implementados y no implementados o abstractos. } // redefine paint de la clase base Applet public void paint(Graphics g){ //.. y una clase que realice un cálculo intensivo. miembros dato constantes y otros no constantes.. Clases que no están relacionadas pueden implementar la interfase Runnable. por ejemplo. Por ejemplo... } // define otras funciones miembro } 75 . el hecho de que una persona sea un futbolista no define su personalidad completa. derivaría a la vez de la clase base Applet (que describe la funcionalidad mínima de un applet que se ejecuta en un navegador) y de la clase Runnable. Ahora bien.Capítulo 5 – Implementación de los conceptos de OO con JAVA class Animacion implements Runnable{ //. public void run(){ // define la función run } } El papel de la interfase es el de describir algunas de las características de una clase.. la diferencia es mucho más profunda. // define la función run de la interfase public void run(){ //. Un applet definido por la clase MiApplet que moviese una figura por su área de trabajo. pero hace que tenga ciertas características que las distinguen de otras.. una clase que describa una animación. Imaginemos que Runnable fuese una clase abstracta.. Una interfase es: una lista de métodos no implementados. puede incluir la declaración de constantes. Diferencias entre una Interfase y una Clase Abstracta.

con las interfases. 76 . Vamos a que la importancia de las interfases no consiste en resolver los problemas inherentes a la herencia múltiple sin forzar relaciones jerárquicas.java Creamos una clase abstracta denominada Animal de la cual deriva las clases Gato y Perro. A C B C D En el lenguaje Java solamente existe la herencia simple.Capítulo 5 – Implementación de los conceptos de OO con JAVA Una clase solamente puede derivar extends de una clase base.javaworld. cuando dos clases B y C derivan de una clase base A. Las interfases y el Polimorfismo. Comparemos la herencia simple mediante un ejemplo similar al de la jerarquía de las figuras planas. En el lenguaje C++. Por ejemplo. Este problema es conocido con el nombre de diamante. pero las clases pueden implementar interfases. Para explicar este aspecto importante y novedoso del lenguaje Java adaptaremos los ejemplos que aparecen en el artículo del Bill Venners "Designing with interfaces" publicado en Java World (http://www. Herencia simple. y a su vez una clase D deriva de B y C. pero puede implementar varias interfases. El lenguaje Java no fuerza una relación jerárquica. Ambas clases redefinen la función habla declarada abstracta en la clase base Animal. Ver los programas completos: Animal.com/) en Diciembre de 1998. Los nombres de las interfases se colocan separados por una coma después de la palabra reservada implements. pero este tipo de herencia presenta dificultades. PoliApp.java. simplemente permite que clases no relacionadas puedan tener algunas características de su comportamiento similares. sino es el de incrementar el polimorfismo del lenguaje más allá del que proporciona la herencia simple. es posible la herencia múltiple.

onomatopeya(gato). Si se pasa un objeto de la clase Gato se imprimirá ¡Miau!. porque en el futuro podemos añadir nuevas clases derivadas de Animal.java 77 . PoliApp. El polimorfismo nos ayuda a hacer el programa más flexible.println("¡Miau!").java. } } El polimorfismo nos permite pasar la referencia a un objeto de la clase Gato a una función onomatopeya que conoce al objeto por su clase base Animal public class PoliApp { public static void main(String[] args) { Gato gato=new Gato(). } } El compilador no sabe exactamente que objeto se le pasará a la función imprimirá ¡Guau!. Animal. } static void onomatopeya(Animal sujeto){ sujeto.out. sin que cambie para nada el método onomatopeya. 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.out.Capítulo 5 – Implementación de los conceptos de OO con JAVA public abstract class Animal { public abstract void habla().java. Por tanto. Ver programas completos donde se trata el tema interfases: Parlanchin.println("¡Guau!").habla(). Reloj. onomatopeya en el momento de la ejecución del programa.java. el compilador no sabe que función habla será llamada en el momento de la ejecución del programa. } } class Gato extends Animal{ public void habla(){ System. } class Perro extends Animal{ public void habla(){ System.

} } Ahora veamos otra jerarquía de clases completamente distinta.println("¡Cucu. 78 . la que deriva de la clase base Reloj.out. A dicha función le podemos pasar cualquier objeto que implemente la interfase Parlanchin.println("¡Guau!"). } } class Gato extends Animal{ public void habla(){ System.. no por una clase base.Capítulo 5 – Implementación de los conceptos de OO con JAVA Vamos a crear una interfase denominada Parlanchin que contenga la declaración de una función denominada habla. .out. esté o no en la misma jerarquía de clases. } class Perro extends Animal{ public void habla(){ System. public interface Parlanchin { public abstract void habla(). public abstract class Reloj { } class Cucu extends Reloj implements Parlanchin{ public void habla(){ System. sino por la interfase Parlanchin. } } Definamos la función onomatopeya de modo que conozca al objeto que se le pasa. } Hacemos que la jerarquía de clases que deriva de Animal implemente la interfase Parlanchin public abstract class Animal implements Parlanchin{ public abstract void habla(). cucu. Una de las clases de dicha jerarquía Cucu implementa la interfase Parlanchin y por lo tanto. debe de definir obligatoriamente la función habla declarada en dicha interfase.out.println("¡Miau!").!").

} } Al ejecutar el programa. si tenemos una clase Rueda y una clase Coche. Cada uno de los controles está descrito por una clase. onomatopeya(gato).habla(). porque a la función onomatopeya se le pasa un objeto de la clase Gato. Cucu cucu=new Cucu(). Hay dos formas de reutilizar el código: mediante la herencia. rueda3. Cucu tendría que derivar de la clase Animal (lo que no es lógico) o bien no se podría pasar a la función onomatopeya. . un applet es un objeto que contiene en su interior otros objetos como botones. etiquetas. rueda2.. Por ejemplo. Si solamente hubiese herencia simple. Composición. mediante la composición: se utiliza una clase ya creada incluyendo instancias de la misma en nuevas clases representa una relación "tiene un". cucu.!. 79 . porque a la función onomatopeya se le pasa un objeto de la clase Cucu. } La composición significa utilizar objetos dentro de otros objetos. cualquier clase en cualquier familia puede implementar la interfase Parlanchin.Capítulo 5 – Implementación de los conceptos de OO con JAVA public class PoliApp { public static void main(String[] args) { Gato gato=new Gato(). } static void onomatopeya(Parlanchin sujeto){ sujeto.. Con interfases. Esta es la razón por la cual las interfases proporcionan más polimorfismo que el que se puede obtener de una simple jerarquía de clases.. etc. y se podrá pasar un objeto de dicha clase a la función onomatopeya. veremos que se imprime en la consola ¡Miau!. rueda 4. es de esperar que la clase Coche tenga cuatro instancias de Rueda: class Coche { Rueda rueda1. y después ¡Cucu. onomatopeya(cucu). Es decir. .

Ver Programas completos: Punto. parámetro. this.java. La función miembro desplazar simplemente cambia la posición del punto desde (x. La función no retorna ningún valor. Rectángulo. int y) { this. RectanguloApp. } Cuando el nombre de los parámetros es el mismo que el nombre de los miembros datos escribimos public Punto(int x. Cuando es llamada.x = x. public class Punto { int x. la abscisa x y la ordenada y de un punto del plano. Definimos dos constructores uno por defecto que sitúa el punto en el origen. // funciones miembro } El constructor explícito de la clase Punto podemos escribirlo de dos formas public Punto(int x1. y) a (x+dx. } this. mientras que x que está a la derecha es el Recordemos que this es una palabra reservada que guarda una referencia al objeto propio. y+dy). recibe en sus dos parámetros dx y dy el desplazamiento del punto y actualiza las coordenadas x e y del punto.java. int y1) { x = x1. u objeto actual. 80 . int y. y otro constructor explícito que proporciona las coordenadas x e y de un punto concreto.java La clase punto La clase Punto tiene dos miembros dato. y = y1.y = y.x que está a la izquierda y que recibe el dato x que se le pasa al constructor se refiere al miembro dato.Capítulo 5 – Implementación de los conceptos de OO con JAVA Vamos a estudiar una clase Rectangulo definiendo el origen. no como un par de coordenadas x e y (números enteros) sino como objetos de una clase denominada Punto.

ancho=0. int dy){ x += dx. 23). el origen. llamamos desde el objeto p a la función desplazar y le pasamos el desplazamiento horizontal y vertical.desplazar(-10. int ancho. } Para crear un objeto de la clase Punto cuyas coordenadas x e y valgan respectivamente 10 y 23 escribimos Punto p = new Punto(10. // funciones miembro } El constructor por defecto. La clase Rectangulo La clase Rectangulo tiene como miembros dato. p. public class Rectangulo { Punto origen. 40). y += dy. } El constructor explícito crea un rectángulo situado en un determinado punto p y con unas dimensiones que se le pasan en el constructor 81 . alto=0. crea un rectángulo situado en el punto 0. Para desplazar el punto p 10 unidades hacia la izquierda y 40 hacia abajo. int alto . que es un objeto de la clase Punto y las dimensiones ancho y alto.0 y con dimensiones nulas public Rectangulo() { origen = new Punto(0. 0).Capítulo 5 – Implementación de los conceptos de OO con JAVA public void desplazar(int dx.

0) y cuyas dimensiones son 100 y 200 escribimos Rectangulo rect1=new Rectangulo(100. w. int h) { origen = p. ancho = w.desplazar(dx. 0). } El primero crea un rectángulo de dimensiones nulas situado en el punto p. 0. w y h. 200). int w. int h) { this(new Punto(0. crea un rectángulo de unas determinadas dimensiones. Para desplazar un rectángulo. 70 y de dimensiones nulas escribimos: Punto p=new Punto(44. } Podemos definir otros constructores en términos del constructor explícito usando la palabra reservada this. Dentro del cuerpo de cada constructor. } public Rectangulo(int w. situado en el punto de coordenadas 44. sin cambiar su anchura o altura. El segundo. trasladamos su origen (esquina superior izquierda) a otra posición. } Objetos de la clase Rectángulo. public Rectangulo(Punto p) { this(p. Para crear un rectángulo rect1 situado en el punto (0. 0. int dy) { origen. Desde el objeto origen.Capítulo 5 – Implementación de los conceptos de OO con JAVA public Rectangulo(Punto p. Para crear un rectángulo rect2. 70). llamamos a la función desplazar miembro de la clase Punto void desplazar(int dx. situándolo en el punto 0. Rectangulo rect2=new Rectangulo(p). 0). dy). se llama al constructor explícito mediante this pasándole en sus parámetros los valores apropiados. alto = h. 82 . h).

Para hallar y mostrar el área del rectángulo rect1 podemos escribir System. Quizás no se comportan los objetos de estas clases tal y como nosotros queremos. x = new Saludos().Capítulo 5 – Implementación de los conceptos de OO con JAVA O bien.calcularArea()). Para hallar el área de un rectángulo de 100 unidades de largo y 50 de alto y guardar el resultado en la variable entera areaRect.out. 83 . 20). } } Esto define una clase Saludos con un constructor y un solo método saludo que despliega el mensaje "Hola mundo!". Definiendo Clases. escribimos: rect1.desplazar(40. quizás vimos que hay pasos muy tediosos. escribimos en una sola línea: int areaRect=new Rectangulo(100. 200) a otro punto situado 40 unidades hacia la derecha y 20 hacia abajo. Cuando trabajamos con el flujo de entrada y salida.println("el área es " + rect1.out. ¿Tenemos que aceptar un comportamiento de un objeto inadecuado para nuestros propósitos solo porque otro programador los diseñó así? No. nosotros podemos definir nuestras propias clases que provean el comportamiento que nosotros requerimos.println("Hola mundo!"). en una sóla línea Rectangulo rect2=new Rectangulo(new Punto(44. Usando esta definición podemos crear un objeto de la siguiente forma: Saludos x. 70)). 50).calcularArea(). Para desplazar el rectángulo rect1 desde el punto (100. Definición de Clase Simple: class Saludos { public Saludos(){ } public void saludo(){ System. sin modificar sus dimensiones. Definición de Clases.

en donde al mandar el mensaje podamos escoger a quien saludar.concat("!")). En general todos los métodos llevan la palabra reservada public al principio. Para poder implementar esto necesitamos incluir parámetros en el encabezado del método.saludo(). Por lo tanto cuando el usuario quiere saludar a todo el mundo.println("Hola mundo!"). public void saludo() public void saludo(String alguien) estamos sobrecargando el método saludo.println("Hola". La nueva clase quedaría entonces así: class Saludos { public Saludos(){ } public void saludo(){ System. la tendría que incluir el que llama al método como argumento de la siguiente forma: x. Definición de Métodos con Parámetros. pero diferente firma. Supongamos que queremos diseñar un método saludo mas genérico.out. hace la llamada: 84 . Esta información adicional.saludo("alumnos") Para desplegar "Hola alumnos!". } public void saludo(String alguien){ System. Un método simple tiene la estructura: public valor-retorno nombre-metodo (){ // cuerpo del método } La palabra reservada void es usada con aquellos métodos que no devolverán nada. } } Al incluir dos métodos con el mismo nombre.out.Capítulo 5 – Implementación de los conceptos de OO con JAVA Podemos mandarle un mensaje de la siguiente forma: x.concat(alguien). para que este tenga acceso a esta información.

con las siguientes instrucciones: desplegarían un saludo a la universidad: Saludos x.saludos(). Es decir. Así. La nueva clase quedaría así: class Saludos { private String quien. que se debe incluir un constructor con un parámetro String. x = new Saludos("Universidad"). } } 85 . para que no necesariamente sea al "mundo".saludo("Colegio").out. Para que tenga el método saludo acceso a la cadena recibida en el constructor. Esto lo hacemos porque un método no puede acceder a las variables o parámetros de los otros métodos.println("Hola ".concat(alguien). Para poder implementar esto. Los atributos pueden ser accedidos por todos los métodos de dentro de la clase.println("Hola ".saludo(). hace la llamada x. } public void saludo(){ System. public Saludos(){ quien = "mundo". debemos incluir un constructor que reciba una cadena de argumento.concat("!")).concat(quien). } public Saludos(String s){ quien = s. } public void saludo(String alguien){ System. pero cuando quiere saludar a alguien en especial. Uso de Atributos. Como podemos saludar a todo el mundo sin especificarlo explícitamente. necesitamos almacenarla en un atributo. La declaración de estos es la misma que las variables. se dice que el saludo al mundo es el saludo default. con la diferencia que comienzan con la palabra reservada private. Esta información debería de ser proveída en el constructor del objeto. x. Supongamos que queramos darle la opción al creador del objeto Saludos que escoja el saludo default.out.concat("!")).Capítulo 5 – Implementación de los conceptos de OO con JAVA x.

Cualquier orden es legal. Por ejemplo. s2.io.java. Los miembros públicos (public) pueden ser accedidos por todos. podemos utilizar nuestra clase en un programa.println("Saludando un poco a todos!"). Los miembros privados (private) solo pueden ser accedidos por miembros de la misma clase.*. Saludos s1.saludo("Suger Montano"). Una vez que ya hicimos esto. Uso de la Definición de Clase. privados o amigables (default). Los miembros amigables (friendly) pueden ser accedidos por miembros del mismo paquete (conjunto de clases). Empezamos con una clase muy simple y le fuimos agregando funcionalidad mientras 86 . s1 = new Saludos(). El primer paso que tenemos que hacer es escribir nuestra clase Saludos en un archivo que tiene que llamarse Saludos. podríamos tener: import java. asegúrese de incluir la línea: import java. conviene para la clase. Los miembros (atributos y métodos de la clase) pueden ser públicos.saludo(). La definición de la clase trabajada anteriormente fue extremadamente casual. Como esta clase utiliza el PrintStream.saludo(). que declararemos todos los atributos antes de los métodos. Después compilamos este archivo para producir Saludos. s2 = new Saludos("FISICC").out. class SaludandoUnPoco { public static void main(String args[]) { System.Capítulo 5 – Implementación de los conceptos de OO con JAVA El orden de declaración entre los atributos y los métodos es irrelevante. s1.*. } } Ya el programa SaludandoUnPoco se compila y se corre de la manera usual. Diseño e Implementación de Clases. s2.io. Como norma.class. s1.

Necesitamos un enfoque más sistemático. Este. pero es poco funcional para escribir clases de alguna significación. Determine la interfase de la clase que se usará. pero con el cuerpo de los métodos vacío. Dicho enfoque fue útil para explicar la definición de las clases.Capítulo 5 – Implementación de los conceptos de OO con JAVA lo íbamos necesitando. Podemos seguir los siguientes pasos: Diseño de la clase: Decida el comportamiento que la clase deberá proveer. es la declaración de la clase con los prototipos de todos los métodos. determine claramente que métodos debe proveer la clase. Es como construir una casa. La interfase de la clase es la forma en que podemos usar un objeto de esta clase. Escriba un esqueleto de la clase. 87 . En este paso ya es necesario determinar los prototipos de los métodos. Como el comportamiento de un objeto es proveído a través de sus métodos. el esqueleto. cuarto por cuarto. Esta es una forma de revisar si lo que tenemos hasta ahora tiene sentido. Escriba un programa de prueba que utilice la clase.

Tenga en mente lo siguiente: Puede empezar a trabajar en cualquiera de los métodos. a pesar de que funcione puede ser mejorado. Interfase y Prototipos de los métodos. Mejora de la Implementación Por lo general cualquier código escrito. asegurándome que el mensaje se despliegue antes de que la computadora espere la entrada.in o System. Primer Ejemplo Completo: Clase para Entrada/Salida Interactiva (InteractiveIO) Para ilustrar este enfoque de diseño e implementación de clases. sin hacer referencia a System. vamos a comenzar resolviendo el problema de entrada y salida interactiva. Comportamiento que la clase deberá proveer. desplegándole un mensaje y leyendo una cadena del teclado. Esto me dice simplemente que la clase se debe llamar InteractiveIO. Queremos diseñar una clase que provea una manera sencilla de leer y desplegar información.Capítulo 5 – Implementación de los conceptos de OO con JAVA Implementación de la clase: Consiste en escribir los cuerpos de los métodos y declarar los atributos mientras se vayan necesitando. A partir del comportamiento deseado de InteractiveIO. Puede dejar de trabajar en cualquiera de los métodos antes de completarlo e ir a trabajar en otro método. Preguntar al usuario por información.out de la siguiente forma: interIO = new InteractiveIO(). asegurándome que se vaya a desplegar inmediatamente. Diseño de la Clase. Crear objetos que sean instancias de InteractiveIO. La interfase se debe mantener intacta. quisiéramos tener la capacidad de hacer lo siguiente: Declarar una referencia a la clase InteractiveIO de la siguiente forma: InteractiveIO interIO. 88 . Si tuviéramos una clase InteractiveIO quisiéramos que esta me ofreciera el siguiente comportamiento: Escribir a la pantalla.

promptAndRead("Cual es su nombre?"). Si nuestra clase InteractiveIO funcionara como nosotros quisiéramos este quedaría así: import java. Aquí ya tenemos una idea clara del prototipo de los métodos que incluirá la clase InteractiveIO. desplegando una frase descriptiva de lo que queremos leer.io. String line. s = interIO. interIO = new InteractiveIO(). System. Estos son: public InteractiveIO() public void write(String s) public String promptAndRead(String s) Programa de prueba que utilice la clase. Mandar un mensaje al objeto para preguntar una cadena.in. lleva a cabo bien la tarea. Esta clase haría todo esto por nosotros. line = interIO.*.write("Por favor conteste cada pregunta. Mandar un mensaje al objeto para escribir a pantalla de la siguiente forma: interIO. Provee de una entrada y salida interactiva simple.out y flush. interIO. 89 . el programa de prueba más simple que podemos escribir es uno que lee una palabra y a continuación la despliega.Capítulo 5 – Implementación de los conceptos de OO con JAVA De esto podemos deducir que necesitaremos un constructor sin parámetros. de la siguiente forma: String s. y que devuelva una cadena. despreocupándonos de System. Debemos proveer un método promptAndRead que reciba una cadena como parámetro. } } Concluimos que una clase InteractiveIO diseñada tal y como la tenemos. sin devolver nada. class ProbandoInteractiveIO { public static void main(String args[]) { InteractiveIO interIO.promptAndRead("Ingrese una palabra: "). Para usar la clase."). Debemos proveer un método write que reciba una cadena como parámetro.write(line).

si necesitáramos public InteractiveIO() { // enunciados } /** despliega s*/ public void write(String s) { // enunciados } /** despliega s. class InteractiveIO { // aqui irían los atributos.out. String line. line = br. class InteractiveIO { // aparentemente no necesitamos atributos public InteractiveIO() { // parece que necesitamos nada! } /** despliega s*/ public void write(String s) { System.Capítulo 5 – Implementación de los conceptos de OO con JAVA Esqueleto de la clase.print(s).flush(). } } 90 .flush(). System. System.in)).out.out. } /** despliega s.readLine(). BufferedReader br = new BufferedRead( new InputSteamReader(System. lee una cadena del teclado y devuelve una referencia a esta */ public String promptAndRead(String s) throws Exception { System.print(s). lee una cadena del teclado y devuelve una referencia a esta */ public String promptAndRead(String s) { // enunciados } } Implementación de la clase Completamos los métodos de la clase. return line.out.

System. pero deseo salirme del método lo puedo hacer mediante el enunciado: return.out. } /** despliega s*/ public void write(String s) { System. Incluso si tengo un método que no retorna ningún valor. Observemos que podemos optimizar el programa en los siguientes aspectos: No tiene sentido crear en cada llamada al método write una instancia del BufferedReader. No necesitamos almacenar la referencia al objeto String en el método promptAndRead. Para forzar la salida de un método. } /** despliega s.out. Podemos ahorrar esta repetición de código llamando al método write desde el método promptAndRead. Mejora de la implementación. Podemos obviar este paso devolviendo la referencia leída en composición.Capítulo 5 – Implementación de los conceptos de OO con JAVA La palabra reservada return se utiliza para dos operaciones en Java: Para retornar un valor. lee una cadena del teclado y devuelve una referencia a esta */ public String promptAndRead(String s) { this. La nueva implementación de la clase InteractiveIO entonces me queda así: class InteractiveIO { private BufferedReader br.flush(). return keyb. No se ejecutara ninguna instrucción después del return.write(s).readLine(). En vez de esto podemos crearlo una sola vez en el constructor y almacenar una referencia a este como atributo (para que sea accesible desde el método write). Las primeras instrucciones del método promptAndRead son iguales a las del método write. } } 91 .print(s). Su sintaxis es: return expresion. public InteractiveIO() throws Exception { br = new BufferedReader( new InputStreamReader(System.in)).

Se acostumbra a declararlas private. Son creadas cuando el objeto es creado y destruidas cuando el objeto es destruido. En el método promptAndRead cuando invocamos al mensaje write el receptor de este mensaje debe ser el mismo objeto al cual promptAndRead pertenece. ya que no deberían ser accedidas por métodos de otras clases. Pueden ser accedidas por todos los métodos de la misma clase. pero esta no nos provee el comportamiento que nosotros quisiéramos de una clase Nombre 92 . Solo pueden ser accedidas por el método al cual pertenecen. Recordemos que cuando mandamos mensajes (al llamar a los métodos) necesitamos un receptor de dicho mensaje. que la despliegue y que garantice que el siguiente carácter a desplegarse aparecerá en una nueva línea. Diseñamos la clase InteractiveIO motivados por el deseo de un uso más conveniente del PrintStream y del BufferedReader. pero garantice que el siguiente carácter a desplegarse aparecerá en una nueva línea. Son destruidas cuando termina el método.Capítulo 5 – Implementación de los conceptos de OO con JAVA Aquí trabajamos con tres tipos de variables: Parámetros: son creadas cuando el método al cual pertenecen es invocado. Variables Locales: al igual que los parámetros. Su valor inicial corresponde a la información enviada como argumento. Usamos la palabra reservada this para hacer referencia al objeto al cual le pertenece el método. Podemos estar tentados a utilizar la clase String. Agregue un segundo método writeln (sobrecargado) en la clase InteractiveIO que no reciba argumentos. Podemos utilizar también la palabra reservada this para diferenciar entre variables locales y atributos que tengan el mismo nombre. Ejercicios propuestos para el alumno: Agregue un método writeln a la clase InteractiveIO que reciba una cadena de caracteres. Por lo general nuestro punto de partida no son las clases existentes de Java sino problemas de la vida real que deseamos resolver modelándolos de alguna forma. El ejemplo que vamos a trabajar ahora es modelar el nombre de una persona. Atributos: tienen el mismo tiempo de vida que el objeto al cual pertenecen. Segundo Ejemplo Completo: Clase Nombre. A diferencia de los parámetros éstas deben ser inicializadas dentro del método. éstas son creadas cuando el método se invoca y destruidas cuando termina el método y sólo pueden ser accedidas por el método al cual pertenecen. Las clases predefinidas que Java nos provee ni siquiera se acercan a modelar el comportamiento de los elementos de nuestro mundo.

getLastFirst(). como una cadena. Comportamiento que la clase deberá proveer. Mandar un mensaje al objeto para obtener el nombre completo.Capítulo 5 – Implementación de los conceptos de OO con JAVA Diseño de la Clase. Crear objetos que sean instancias de Nombre. s = alumno. en el orden apellido.getInitials(). en la forma primer nombre apellido precedido de un título opcional. Debemos proveer un método getInitials que devuelva una cadena. de la siguiente forma: String s. De esto podemos deducir que necesitaremos un constructor con dos parámetros String. Esto me dice simplemente que la clase se debe llamar Nombre. "Perez"). Interfase y Prototipos de los métodos. A partir del comportamiento deseado de la clase Nombre. en la forma apellido. Si tuviera una clase Nombre quisiera que esta me ofreciera el comportamiento para: Obtener las iniciales como una cadena. primer nombre Obtener el nombre como una cadena. de la siguiente forma: 93 . s = alumno. Mandar un mensaje al objeto para obtener el nombre completo. Mandar un mensaje al objeto para obtener las iniciales como una cadena. primer nombre. Debemos proveer un método getLastFirst que devuelva una cadena. quisiéramos estar en la capacidad de hacer lo siguiente: Declarar una referencia a la clase Nombre de la siguiente forma: Nombre alumno. de la siguiente forma: String s. apellido Agregar o reemplazar un titulo. basados en el primer nombre y el apellido de la siguiente forma: alumno = new Nombre("Juan". como una cadena. Obtener el nombre como una cadena. en el orden primer nombre.

Para usar la clase.Capítulo 5 – Implementación de los conceptos de OO con JAVA String s. Nuestro razonamiento fue que: no todos tienen titulo.setTitle("Ingeniero"). s = alumno. el programa de prueba más simple que podemos escribir es uno que lea el primer nombre y apellido y el título.getFirstLast(). Debemos proveer un método setTitle que reciba como parámetro una cadena. En contraste con el nombre y apellido. Si nuestra clase Nombre funcionara como nosotros quisiéramos este quedaría así: 94 . el titulo no es permanente. Aquí ya tenemos una idea clara del prototipo de los métodos que incluirá la clase Nombre. Después el programa deberá desplegar: las iniciales el nombre completo en la forma apellido. Debemos proveer un método getFirstLast que devuelva una cadena. Programa de prueba que utilice la clase. Esta fue nuestra opción (como diseñadores de la clase). por lo que permitimos que se pudiera agregar un titulo o modificarlo. String ap) String getInitials() String getLastFirst() String getFirstLast() void setTitle(String newTitle) Observe que el constructor no incluye al titulo. primer nombre el nombre completo en la forma primer nombre apellido. Mandar un mensaje al objeto para agregar o reemplazar el título de la siguiente forma: alumno. Una vez que tenemos funcionando nuestra clase InteractiveIO la utilizaremos en el programa de prueba. Estos son: public public public public public Nombre(String pnom.

writeln(n. } } n = new Nombre(primer.getLastFirst()). io. io. De la misma forma getFirstLast y setTitle necesitan 95 . lleva a cabo bien la tarea. Provee una forma simple de manipular los nombres. io. Esqueleto de la clase.getInitials()). Razonamos que: Los métodos getFirstLast y getLastFirst necesitan ambos acceso al primer nombre y al apellido.Capítulo 5 – Implementación de los conceptos de OO con JAVA import java.setTitle(titulo). apellido). String primer. io. n. String ap) // enunciados } public String getInitials() { // enunciados } public String getLastFirst() { // enunciados } public String getFirstLast() { // enunciados } public void setTitle(String newTitle) // enunciados } { { } Implementación de la clase Completamos los métodos de la clase.io. io = new primer = apellido titulo = InteractiveIO(). apellido. Concluimos que la clase Nombre diseñada tal y como la tenemos. titulo.promptAndRead("Ingrese apellido: "). = io.writeln(n.promptAndRead("Ingrese primer nombre: ").*.promptAndRead("Ingrese apellido:"). class Nombre { // aquí van los atributos si las necesitáramos public Nombre(String pnom.writeln(n. class ProbandoNombre { public static void main(String args[]) { Nombre n.getFirstLast()). io. InteractiveIO io.

atributos. } } El objetivo del constructor es garantizar que el objeto comience con valores válidos en sus atributos. es muy probable que se declaren muchas instancias de esta clase. return inicNom. A pesar de que todas las instancias de la clase Nombre vayan a tener el mismo comportamiento (proveído por sus métodos).concat(apellido). necesitamos hacer del primer nombre. Queda la mejora de la clase a discreción del alumno. Por lo tanto.concat(primerNombre). String ap) { primerNombre = pnom. Asumiremos que mientras no se especifique un titulo la persona no lo tiene."). public Nombre(String pnom.1). las llamadas devolverán resultados distintos.concat(primerNombre). } public void setTitle(String newTitle) { titulo = newTitle.concat(". apellido y titulo. titulo. inicAp = apellido. Esto tiene sentido ya que cada objeto instancia de Nombre tendrá su propio primer nombre. } public String getFirstLast() { return titulo. class Nombre { private String primerNombre. Puedo mandarle un mensaje getLastFirst a dos objetos distintos. es poco probable que se declare más de un objeto de esta clase.").substring(0. } public String getLastFirst() { return apellido. titulo = "".concat( " ").1).concat(". apellido y titulo. ").concat(" "). inicNom = primerNombre. } public String getInitials() { String inicNom. y se comportaran igual y pero pueden devolver distinto resultado ya que sus estados son distintos. Cada una de estas compartirá los mismos métodos pero tendrán su propio juego de atributos: primerNombre.Capítulo 5 – Implementación de los conceptos de OO con JAVA ambos acceso al título. Esto es porque los atributos tendrán distintos valores. inicAp.concat(apellido). Los valores de sus atributos constituyen su estado. apellido. Para la clase InteractiveIO. Sin embargo. apellido = ap. para el caso de la clase Nombre. 96 . apellido y titulo.substring(0.concat(".

Hasta ahora. El método quedaría así: void print (PrintStream destino) De esta manera. Algunas veces es deseable que la clase se haga responsable de la entrada y la salida. Como diseñadores de la clase Nombre. a donde desea que se mande la salida. hacia donde debería producirse la salida. Diseñe e implemente una clase NombreLargo.out. Sin embargo. comenzando con la salida. ¿hacia donde debería ir? La primera cuestión es algo de diseño. la clase no leía ni desplegaba objetos Nombre. Agregue un método IlustrateName a la clase Nombre que despliegue el nombre a pantalla. Diseñe e implemente una clase Direccion. hemos manejado la salida a través del print y println ha instancias del PrintStream. Por otro lado si 97 . Podríamos pedirle al invocador del método print que incluya como argumento el objeto PrintStream. Diseñando la Salida para los Objetos En el diseño original de la clase Nombre. si nos vamos a tomar la molestia de agregar un método extra a la clase. Para ilustrar como se podría implementar esto. Hay que considerar dos aspectos en este punto: ¿En que forma se debe producir el nombre completo? La salida. ya sea al monitor o a algún archivo en especial. podríamos insistir que la salida se maneje a través del PrintStream. apellido y a continuación despliegue sus iniciales. Podemos de una forma arbitraria escoger hacia donde debería ir la salida.Capítulo 5 – Implementación de los conceptos de OO con JAVA Ejercicios propuestos para el alumno: Escriba un programa que lea tres pares de primer nombre. le agregaremos este comportamiento a la clase Nombre. arbitrariamente podemos escoger producir el nombre completo en el orden titulo primer-nombre apellido. Podemos diseñar un método print para la clase Nombre que provea el comportamiento de producir como salida el nombre completo. La entrada y salida era la responsabilidad del usuario de la clase. podríamos diseñarlo para que sea lo más general posible sin limitarlo a ninguna salida específica. incluiría como argumento System. si el que llama al método print desea desplegar el nombre en la pantalla. Podríamos hacer responsabilidad del que invoca el método. en la llamada. que tome en consideración (además del primer nombre y apellido como lo hizo la clase Nombre) el segundo nombre. El programa deberá usar la clase Nombre.

print(System. Al igual que con el método print nos debemos preguntar dos cosas: o ¿En que forma se debe leer el nombre? o La entrada. La clase debe proveer dos métodos: print y println. En realidad no deseamos mandarle el mensaje a un objeto instancia de la clase Nombre. } Ejercicio propuesto para el alumno: Implemente una clase llamada SalidaConBitacora. Estos métodos deben mandar la cadena a desplegar a pantalla y a escribirla al archivo. el envío del mensaje debería de crear el objeto. Estos métodos son definidos de la misma forma que los otros métodos. n.txt")). De hecho. Los métodos estáticos no están asociados a ningún objeto. Nos topamos con un problema: los mensajes los mandamos a objetos y no tenemos un objeto a quien mandarle el mensaje. // escribe Licenciada Jodie Foster en el archivo La implementación quedaría así: void print (PrintStream destino){ destino. p = new PrintStream (new FileOutputStream ("actrices."Foster").out). PrintStream p.getLastFirst()). ambos. Diseñando la Entrada para los Objetos Desearíamos tener la capacidad de mandarle un mensaje pidiendo que se cree un objeto Nombre desde cierta entrada. Esto en Java se lleva a cabo a través de un tipo de método conocido como método estático. El constructor recibe un solo argumento: una cadena que representa el nombre de un archivo. // despliega Licenciada Jodie Foster en la pantalla n. Se utiliza el nombre de la clase como receptor del mensaje.print(p). Tienen las siguientes características: Deben de ser invocados independientemente de cualquier instancia de la clase. ¿de donde debería provenir? 98 . excepto que estos llevan la palabra reservada static antes del tipo de retorno.print(this. n. n = new Nombre("Jodie".setTitle("Licenciada"). sino a la clase Nombre.Capítulo 5 – Implementación de los conceptos de OO con JAVA desease mandar el nombre a un archivo incluiría como argumento alguna instancia del FileOutputStream. No pueden accesar ningún atributo. Un ejemplo de uso podría ser: Nombre n. de los cuales deben recibir una cadena de argumento.

es aconsejable desplegar un mensaje para decirle al usuario que información es la que se desea que ingrese.read(brFile). n. apellido). Podemos incluir otro método de entrada readi que utilice la clase InteractiveIO que ya hemos diseñado para llevar a cabo esto. La implementación quedaría así: public static Nombre read(BufferedReader fuente){ String primer. } 99 . brFile = new BufferedReader(isrFile). isrFile = new InputStreamReader(f). return new Nombre(primer. isrKeyb = new InputStreamReader(System. El prototipo sería así: public static Nombre read(BufferedReader fuente) Podemos utilizar la clase Nombre para leer un nombre desde el teclado y desde un archivo de la siguiente forma: Nombre n. apellido. cuando se esta ingresando la información desde el teclado. brKeyb. primer = fuente.promptAndRead("Ingrese apellido:"). return new Nombre(primer.Capítulo 5 – Implementación de los conceptos de OO con JAVA Requeriremos como diseñadores de la clase. esta decisión es arbitraria. apellido.readLine(). Además diseñaremos el método de tal forma que la fuente de entrada sea responsabilidad del que invoque el método. n. InputStreamReader isrFile. primer = io.print(System. apellido).readLine(). De nuevo.promptAndRead("Ingrese primer nombre:").out).print(System. n = Nombre. f = new FileInputStream(new File("nombres. apellido = fuente. que el primer nombre aparezca en una línea de por sí solo y el apellido en la siguiente línea. Requeriremos que como argumento se pase una referencia a un BufferedReader. BufferedReader brFile.out). FileInputStream f. de donde será leído el nombre.in) brKeyb = new BufferedReader(isrKeyb).read(brKeyb).txt")). } Anteriormente vimos que. n = Nombre. isrKeyb. La implementación quedaría así: public static Nombre readi(Interactive io){ String primer. apellido = io.

} } Vemos que el programa HelloApp es una clase. 100 . podemos explicar un poco más el primer programa que escribimos: import java. invoca el método main. Toda clase que existe como programa necesita un método main. El método main es static. Programa Hello world ! Revisado Con lo que hemos conocido hasta ahora. es decir no esta asociado a ningún objeto HelloApp.println ("Hello world !").*.Capítulo 5 – Implementación de los conceptos de OO con JAVA Ejercicio propuesto para el alumno: Agregue los métodos read. readi y print a las clases que usted desarrolló anteriormente en ejercicios: NombreLargo y Direccion.out. Pero esto lo hace antes de que cualquier objeto de nuestro código haya sido creado. es que la ejecución de nuestro programa debe de comenzar en algún lado. class HelloApp { public static void main (String args[]) { System.io. La razón de esto. El intérprete de Java en algún sentido. Además vemos que esta declarado como public. La razón de esto es que necesita ser llamado desde afuera de la clase (desde el interprete de Java).

es necesario definir e impulsar líneas de acción tendientes a mejorar el sistema producido. no solo entonces elegir un buen lenguaje de programación. Es claro que si un sistema presenta errores al momento de ser utilizado. 101 . el que ha tomado como modelo a la Republica de la India. Muchos proyectos de sistemas presentan fallas que impiden que el sistema funcione como era de esperarse o que sea utilizado en su totalidad. Diferenciaremos dos conceptos importantes como son: Calidad en los Sistemas y Calidad en el Software. que si una empresa de software pretende competir a nivel internacional. Por ello. como el que se acaba de anunciar en la vecina ciudad de Resistencia. y luego de haber analizado en profundidad un lenguaje de programación.Capitulo 6 – Software de Calidad. el Gobierno de la Ciudad de Buenos Aires. El control de calidad de sistemas está orientado a garantizar el funcionamiento de los sistemas en explotación. siendo ésta cada vez más creciente. Dentro de estas líneas de acción. el 21 de abril del 2004. la de realizar una investigación que permita conocer de primera mano el estado en que se encuentra su proceso de desarrollo. Capítulo 6. la primera en el rubro en Certificar sus procesos de desarrollo de software. En el entorno actual de la realidad económica de nuestro país. A nivel país. Este desafío impulsado por el Gobierno porteño. el programa “PRO ISO 9000”. esta impulsando de manera coherente desde el año 2003. ya ha generado sus primeros frutos en el área informática. debemos. y como necesidad primordial. el mismo debe estar acorde a las pautas mundiales de CALIDAD. el que pretende generar fuentes de trabajo mas allá de las fronteras de la nación. y considerando que se están gestando polos de DESARROLLO DE SOFTWARE. Me parece muy acertado sugerir. está la relacionada con el proceso mismo del desarrollo del sistema. en este punto. CONTROL DE CALIDAD EN LOS SISTEMAS Introducción El desarrollo de sistemas hoy en día ha tomado gran importancia en el mundo. sino que también. Provincia del Chaco. ese producto pierde confiabilidad a los ojos del usuario hasta el nivel que podría ser desechado como un producto defectuoso. es necesario que contemple seriamente la necesidad de realizar una CERTIFICACION DE CALIDAD DEL SOFTWARE Y DEL SISTEMA. siendo la empresa MSA Magic Software Argentina SA.

Capitulo 6 – Software de Calidad.

El control de calidad de software está orientado a garantizar las características de los programas que se están desarrollando. La Ingeniería de Software concierne a teorías, métodos y herramientas para el desarrollo profesional de productos. Un Sistema concierne a un conjunto de componentes interrelacionados trabajando conjuntamente para un fin común. El sistema puede incluir software, dispositivos mecánicos y eléctricos, hardware, y ser operado por gente. Existen varias organizaciones de estandarización internacional que realizan estándares y modelos de ingeniería de software, esto con el fin de mejorar la Calidad del Software. La Calidad La ISO (International Standard Organization), define La Calidad como la ausencia de deficiencias: "Es la totalidad de aspectos y características de un producto o servicio que se refieren a su capacidad para satisfacer necesidades dadas en la adecuación de sus objetivos'”. El Instituto de Ingeniería de Software (SEI) en su modelo CMM (Capability Maturity Model) define la calidad como: • El grado en el cual un sistema, componente o proceso cumple con los requisitos especificados. • El grado en el cual el sistema, componente o proceso cumple con las expectativas del cliente o usuario. La calidad consiste en todos aquellos aspectos del producto que satisfacen las necesidades del cliente y de ese modo proporcionan la satisfacción del producto. La calidad es sinónimo de eficiencia, flexibilidad, corrección, confiabilidad, mantenibilidad, portabilidad, usabilidad, seguridad e integridad.

Calidad del Software
Definición La Calidad del Software es el conjunto de cualidades que lo caracterizan y que determinan su utilidad y existencia. La Calidad del Software es mensurable y varía de un sistema a otro o de un programa a otro. Por ejemplo: un software elaborado para el control de naves espaciales debe ser confiable al nivel de "cero fallas"; un software hecho para ejecutarse una sola vez no requiere el mismo nivel de calidad; mientras que un producto de software para ser explotado durante un largo período (10 años o más) necesita ser confiable, mantenible y flexible para disminuir los costos de mantenimiento y perfeccionamiento durante el tiempo de explotación.

102

Capitulo 6 – Software de Calidad.

Aspectos de la Calidad La Calidad del Software puede medirse después de elaborado el producto. Pero esto puede resultar muy costoso si se detectan problemas derivados de imperfecciones en el diseño, por lo que es imprescindible tener en cuenta tanto la obtención de la calidad como su control durante todas las etapas del ciclo de vida del software. Objetivo de la Calidad en los Sistemas El Objetivo que persigue la Calidad en los Sistemas está orientada a: • • • • • • • Incrementar la productividad y satisfacción al trabajo de los profesionales afines al campo de la computación. Mejorar la calidad del producto del software. Proveer técnicas aplicadas para automatizar el manejo de datos. Realizar una planeación eficaz de los sistemas. Documentar. Validar y controlar formalmente la calidad del trabajo realizado. Cumplir con los objetivos de la organización en cuanto a productividad de sus sistemas de cómputo.

Obtención de un Software de Calidad La Obtención de un Software con Calidad implica la utilización de metodologías o procedimientos estándares para el análisis, diseño, programación y prueba del software, que permitan uniformar la filosofía de trabajo, en aras de lograr una mayor confiabilidad, mantenibilidad y facilidad de prueba, a la vez que eleven la productividad, tanto para la labor de desarrollo como para el control de la Calidad del Software. El principio tecnológico define las técnicas a utilizar en el proceso de desarrollo del software. El principio administrativo contempla las funciones de planificación y control del desarrollo del software, así como la organización del ambiente o centro de ingeniería de software. El principio ergonómico define la interfaz entre el usuario y el ambiente automatizado. Para el aseguramiento de la calidad es necesario su control o evaluación. Control de la Calidad El Control de la Calidad es realizar una observación constante acerca del cumplimiento de las tareas que pueden ofrecer una calidad objetiva a la forma en como se está desarrollando un proyecto de Ingeniería de Software. Es decir, una vigilancia permanente a todo el proceso de desarrollo y ciclo de vida del software. Esta meta puede alcanzarse mediante frecuentes inspecciones a las metodologías de

103

Capitulo 6 – Software de Calidad.

trabajo y uso de herramientas, revisiones de prototipos y evaluación exhaustiva de los productos finales. El Control de la Calidad permite realizar las rectificaciones pertinentes al desarrollo en cuanto éste empieza a desviarse de sus objetivos, por lo tanto, de la calidad del trabajo. Estas rectificaciones son posibles gracias a una retroalimentación de las etapas superiores, creado así un aprendizaje al observar las salidas de cada etapa, hasta el producto final, y mejorar los procesos que dan origen al sistema. En el Control de Calidad deben tenerse presentes los costos que esta involucra. Si se piensa en las tareas que deben realizarse en este control, puede observase que es necesario llevar a cabo tareas de búsqueda de problemas, evaluación, realimentación, rectificación, elaboración, modificación y estudio de la documentación; entre otras actividades. Pero debe existir un compromiso, ya que un excesivo costo en el control de la calidad puede hacer que este proceso se torne ineficiente. Pero, por otra parte, el mejoramiento de la calidad implica reducir los costos ya que se tendría un cierto nivel de calidad ya asegurado. Finalmente, y como consecuencia de la naturaleza del proceso de desarrollo de productos software, el asegurar la calidad en las primeras etapas de este involucra que los costos del control en las etapas posteriores tenderá a disminuir al tener menos aspectos que controlar pues, nuevamente, la calidad estaría asegurada en sus bases. Control de Calidad del Software Para controlar la Calidad del Software es necesario, definir los parámetros, indicadores o criterios de medición. El software posee determinados índices mensurables que son las bases para la calidad, el control y el perfeccionamiento de la productividad. Una vez seleccionados los índices de calidad, debe establecerse el proceso de control, que requiere los siguientes pasos: 1. Definir el software que va a ser controlado: clasificación por tipo, esfera de aplicación, complejidad, etc., de acuerdo con los estándares establecidos para el desarrollo del software. 2. Seleccionar una medida que pueda ser aplicada al objeto de control. Para cada clase de software es necesario definir los indicadores y sus magnitudes. 3. Crear o determinar los métodos de valoración de los indicadores: métodos manuales, como cuestionarios o encuestas estándares para la medición de criterios periciales y herramientas automatizadas para medir los criterios de cálculo. 4. Definir las regulaciones organizativas para realizar el control: quiénes participan en el control de la calidad, cuándo se realiza, qué documentos deben ser revisados y elaborados, etc.

104

integridad y facilidad de uso. que se cumplan. 105 . pero lo importante es que estén escritos. Modelo de EFQM. así como los factores que determinan la calidad de cada una de las capacidades son: • • • Capacidad de operación con los factores de corrección. El principal instrumento para garantizar la calidad de las aplicaciones sigue siendo el Plan de Calidad. La Calidad del Software debe ser una disciplina más dentro de la Ingeniería del software. personalizados.2: 1996 Quality Management and Quality Assurance Standards ISO 8402: 1994 IEEE 730/1984. Capacidad de transición o de adaptación a otros entornos con los factores de transportabilidad.Capitulo 6 – Software de Calidad. facilidad de prueba y facilidad de mantenimiento. debe correr paralela desde la planificación del producto hasta la fase de producción del mismo. La satisfacción del cliente Sobre todo la satisfacción del cliente. SPICE. la ISO 9001 y la ISO 9000-3. directivas. facilidad. Capability Maturity Model ISO/IEC JTC1 15504. modelos y estándares son básicamente las siguientes: • • • • • • • Familia de normas ISO 9000 y en especial. eficiencia. IEEE Standard for Software Reviews and Audits CMM. Modelo de la Fundación Europea de Gestión de Calidad Los procedimientos pueden variar en cada organización. La Calidad del Software debe implementarse a lo largo de todo el ciclo de vida. El plan se basa en unas normas o estándares genéricos y en unos procedimientos particulares. Capacidad para ser modificado o de revisión con los factores de flexibilidad. Software Process Improvement and Capability Determination. lo que es más importante. Las normas. adaptados a los procesos de la organización y. Capacidades del Software Las capacidades importantes para un producto de software desde el punto de vista del usuario. El cumplimiento de los requisitos intrínsecos y expresos. capacidad de reutilización y de interoperación. Standard for Software Quality Assurance Plans IEEE Std 1028: 1989. Indicadores para diferenciar los productos de calidad de los que carecen de ella: • • • El acercamiento a cero defectos.

es necesaria la satisfacción por parte de los elementos que intervienen en el proceso: • • • La satisfacción de la alta dirección La satisfacción del personal involucrado en el desarrollo del sistema La satisfacción del usuario final La aplicación del control de calidad de sistemas no es solamente al sistema en sí. Elementos para el Proceso de Sistemas Son tres los elementos que integran el proceso de sistemas. no limitadas y debe tomarse en cuenta cuanto tiempo se dispone para la elaboración del sistema. Involucración Es necesario revisar cada etapa del proyecto. Gente 2. Herramientas (Software y Hardware) 3. ésta conforma la última parte de la evaluación. que tenga la suficiente capacidad para realizar el trabajo. estos son: 1.Capitulo 6 – Software de Calidad. si hay limitaciones o restricciones que afecten o impidan el buen funcionamiento del proyecto y si se está 106 . las herramientas de trabajo deben ser confiables. debe ser clara para todos los responsables del proyecto. Tiempo disponible Debe contarse con la gente adecuada. Calidad Total en el Proceso de Desarrollo del Sistema Para alcanzar la "Calidad Total". Para cada una de ellas es importante dejar en claro si vale la pena continuar o no. esto con el fin de establecer reglas a seguir. Componentes para la Calidad Total • • • • • • • • • • Claridad Involucración Planeamiento Estándares Entrenamiento Experiencia Controles Documentación Soporte Finalización Claridad La definición de lo que se tiene que hacer o lo que el usuario necesita. los cuales por su importancia deben de considerarse para el mejor control de calidad y realización de los sistemas.

Experiencia El contar con mucha o poca experiencia. el cumplimiento de los requerimientos del cliente. así como su estandarización. divisiones o departamentos que están involucrados en la realización del proyecto. los elementos que los deben integrar. Planeamiento En la planificación intervienen tanto los usuarios como el personal que desarrolle el proyecto.calidad). ya que mediante él se obtienen los conocimientos y habilidades que se aplicarán en el proyecto. determina el tiempo de desarrollo del sistema así como la calidad del trabajo que realice (oportunidad . el funcionamiento de la aplicación. Debe planearse el grado de integración que se requiere en las diferentes áreas de la organización. del desarrollo con el usuario y un punto importante es la mutua satisfacción entre de la gente que realiza el proyecto con el usuario. ya que es necesario tener presente la definición de diversos factores que afectarían la realización del proyecto. Estándares Tiene que tomarse en cuenta la forma mediante la cual vamos a trabajar desde el punto de vista tecnológico. Primeramente debe verse el avance del proyecto.Capitulo 6 – Software de Calidad. 107 . dando el cubrimiento adecuado a todos los requerimientos y funciones. Entrenamiento El entrenamiento es un factor determinante para la realización de un proyecto. el seguimiento y las normas de seguridad y de auditoria. la involucración de las personas clave para el proyecto. como son: • • • • • • • • • Lenguaje de programación Manejo de librerías Código Instrucciones Comentarios Administración de backups Administración de archivos Periodicidad de revisiones Documentación Debe quedar clara su definición. Controles Los controles que se establezcan deben realizarse con alguna periodicidad. Sin una estandarización el proyecto se vendría abajo. para interpretar necesidades o requerimientos satisfactorios con el objeto de llegar a acuerdos en caso de imprevistos en asuntos tan simples como el método mediante el cual vamos a poner a trabajar alguna etapa o actividad en el proyecto.

no tenga errores. Calidad hecha en cada uno de los pasos o etapas del proyecto. de análisis. sea oportuno. etc. debe asegurarse de hacerlo de tal manera que lo que se entregue esté completo. mejoras. en el área usuaria. es el reconocimiento a la labor bien realizada y de alta calidad. útil y estable. el manejo de la aplicación y producción y los cuidados con respecto a back-ups. ya sea en la instalación. La atención a los requerimientos del usuario en términos de hacer todo lo que él quiera. Manuales de usuario. ya sean los programas. es decir. así como contar con Bitácoras que respalden las reuniones que se tengan con los usuarios y los acuerdos a los que hayan llegado ambas partes. por supuesto. de igual manera que en cada etapa. Cuando se desarrolle un sistema o aplicación y se instale. En la finalización del proyecto es necesario considerar cinco puntos vitales: • • • • • La revisión de todos los pasos realizados y de las etapas incluidas en el proceso total. arreglos. Y. a una mayor calidad en su operación. las tareas del usuario y sus procedimientos. Finalización La finalización del proyecto de un sistema es una de las labores más importantes en el desarrollo del mismo. Administración de la Calidad Calidad en el Nivel de Organización La Administración de la Calidad cuenta con dos niveles de trabajo: El nivel de entidad u organización Donde se trata de crear y gestionar una infraestructura que fomente la calidad de los productos software mediante la adecuación y mejora de las actividades y 108 . ayudas y soporte requerido. contribuyen a una mejor utilización del sistema. En este caso puede contarse con un Calendario de Entrega donde contenga los puntos anteriormente mencionados. sea confiable.. la bitácora de historia respecto a fallas. Soporte Es indispensable tener claro quién nos puede apoyar en las áreas técnica. técnico y de operación. la satisfacción de nuestro usuario o cliente que. en el área ejecutiva o en algún otro aspecto. Elaboración del proceso en forma integral. ya que las aplicaciones en los proyectos de sistemas enfrentan siempre necesidades críticas de soporte.Capitulo 6 – Software de Calidad. Documentación Es importante que la documentación que se genere debe ser clara y útil en cuanto al sistema. o más. en últimas.

Principalmente se han impuesto en la práctica las directrices marcadas por ISO (Organization for International Standardization) a través de unas normas ISO 9000 para la gestión de calidad. 109 . En el caso del software es principalmente aplicable la norma ISO 9001. el SEI (Software Engineering Institute).Capitulo 6 – Software de Calidad. proponiendo un modelo de clasificación y mejora de los procesos empleados por las organizaciones de software denominado CMM (Ver anexo). Este costo hay que considerarlo dentro de todo el ciclo de vida del proyecto. incluso. tecnología de ingeniería de software efectiva (métricas y herramientas). conduce a realizar un mecanismo básico que permite las Revisiones Técnicas Formales. Dentro del primer nivel de acción. pero mayores también los beneficios obtenidos en la fase del mantenimiento del software. Descubrir errores en la función. en su comercialización y en la interacción con los clientes. nunca al final. el control de la documentación del software y de los cambios realizados. mayores son los costos. A mayor calidad. revisiones técnicas formales que se aplican durante el proceso del software. El aseguramiento de la Calidad de Software engloba un enfoque de gestión de calidad. la lógica o la implementación de cualquier representación del software. un procedimiento que asegure un ajuste a los estándares de desarrollo del software (cuando sea posible) y mecanismos de medición y de generación de informes. El sector de software difiere por la naturaleza del producto tanto del resto de sectores productivos que ha sido necesario crear una guía específica para su aplicación a este sector: ISO 9000-3. se ha seguido la línea marcada por las entidades internacionales de estandarización para todas las organizaciones de producción o servicios. una estrategia de prueba multiescalada. trabaja sobre los procesos de producción como medio para asegurar la calidad del producto software. El nivel del proyecto Donde las guías que la infraestructura organizativa prevé para las distintas actividades y mantenimiento del software deben ser adaptadas a las características concretas del proyecto y de su entorno para ser aplicadas a la práctica. Los objetivos de la RTF son: 1. procesos involucrados en su producción e. Por ejemplo. Una Revisión Técnica Formal (RTF) es una actividad que garantiza la Calidad del Software y que es llevada a cabo por los profesionales de la ingeniería de software. El mundo del software ha creado sus propias líneas de trabajo en la gestión de la calidad. La idea de la necesidad de realizar pruebas en fases tempranas. Calidad en el Nivel de Proyecto La Calidad del Software se diseña conjuntamente con el sistema. la gestión de la calidad en organizaciones de software ha seguido dos líneas que pueden ser complementarias entre sí: Por una parte.

Calidad por Etapas Calidad en el Diseño Aquí se plantean características definidas para la realización del producto software que deberán cumplirse posteriormente. Verificar que el software bajo revisión alcance sus requisitos. La Prueba del Software Se pueden realizar inspecciones para cada módulo o pequeño grupo de módulos que conformen un sistema. tareas y responsabilidades de los equipos de desarrollo. En la figura se puede apreciar lo que sería el flujo de información necesario para realizar correcta y completamente una prueba de software. 110 . Involucra descripción de los procesos. 2. La calidad se basa en definir un listado de especificaciones a seguir.Capitulo 6 – Software de Calidad. 4. Hacer que los proyectos sean más manejables. Conseguir un software desarrollado de forma uniforme. Garantizar que el software haya sido representado de acuerdo con ciertos estándares predefinidos. la cual puede ser aplicada tanto a los módulos individuales como al software en su totalidad. Al limitar el centro de atención de la RTF la probabilidad de descubrir errores es mayor. y 5. 3.

Esta es la medida de la calidad apreciada por los usuarios finales del entendimiento del producto software. las que se centran en el rendimiento del proceso de ingeniería de software. Métricas de calidad. mientras nos surjan ideas para mejorarlos. Clasificación de Métricas Las métricas de software se pueden clasificar como: Métricas orientadas a la función y Métricas orientadas al tamaño. que se centran más en el software que en el proceso a través del cuál se ha desarrollado (por ejemplo grado de modularidad o grado de complejidad lógica). 3.Capitulo 6 – Software de Calidad. 2. Estas apreciaciones de calidad hacia un determinado producto elevarán el nivel de confianza para la organización desarrolladora. proporcionan una indicación de cómo se ajusta el software a los requisitos explícitos e implícitos del cliente. Cuando se habla de software nos referimos a la disciplina de recoger y analizar datos basándonos en mediciones reales de software. Expectativas de los estándares: • • • • Mejora de procesos de software acorde a los objetivos estratégicos Mejora de los productos Protección del cliente o usuario Protección de la organización (cultura de la organización y mejora continua) 111 . En esta etapa la calidad aumenta en la medida en que se realiza una alta especificación de los procesos y se propone una estrecha tolerancia a la modificación. Los estándares nos dan los medios para que todos los procesos se realicen siempre de la misma forma. así como a las escalas de medición. lo que puede elevar su posición en el mercado. Métricas técnicas. Métricas de productividad. Estándares y Modelos de Calidad en la Ingeniería de Software Introducción La estandarización es toda actividad documentada que norma el comportamiento de un grupo de personas. estableciendo los métodos correctivos a las desviaciones ocurridas. Métricas del Software Las métricas son escalas de unidades sobre las cuales puede medirse un atributo cuantificable. Son nuestra guía para la productividad y la calidad. También se pueden clasificar según la información que entregan: 1.

ISO e IEC decidieron formar el Joint Technical Commit (JTC). mientras que la International Organization for Standardization (ISO) fue creada en 1947 para abarcar otros temas. 112 . desarrollo. instalación y servicio. Ambas tienen por objetivo facilitar el intercambio de bienes y servicios a nivel internacional. producción. Estructura General De forma general la norma se divide en 4 guías o modelos fundamentales: • • • ISO 9001 Sistemas de Calidad. Modelo de Aseguramiento de la Calidad en el diseño. Las últimas están relacionadas con la ONU o son independientes. Modelo de Aseguramiento de la Calidad para la producción. entre ellos tenemos: • • • • • • ISO 9000-3 Tick IT (Inglaterra) CMM (Estados Unidos) Bootstrap (Europa) Trillium (Canadá) ISO/SPICE (Australia) La Norma ISO 9000 La Organización Internacional para la Estandarización (ISO) fue fundada el 23 de febrero de 1947 con el objetivo de crear una norma internacional de calidad. así como aclara conceptos en cuanto a la calidad y las interrelaciones que se establecen. BOOTSTRAP. instalación y servicio. La International Electrotechnical Commission (IEC) que fue fundada en el año 1906 para definir estándares en eléctrica y electrónica. El objetivo del estándar es desarrollar un código mínimo que contenga prácticas de administración para garantizar el Aseguramiento y Administración de la Calidad. Organizaciones como la ISO. Existen varias organizaciones de estandarización internacional. qué hacer para responder a los requerimientos de un mercado cada vez más competitivo y cómo deben responder los proveedores y compradores respecto a la calidad de los bienes o servicios intercambiados. En 1987.Capitulo 6 – Software de Calidad. El Comité Técnico ISO/TC 176 para Aseguramiento de la Calidad fue el encargado de crear el estándar ISO 9000. entre otras. como por ejemplo la International Telecommunication Union (ITU). cuyo objetivo es elaborar estándares para la tecnología de información Information Technology (IT). es decir. ISO 9002 Sistemas de Calidad. algunas son regionales mientras que otras son globales. ISO 9003 Sistemas de Calidad. Para ello establece una serie de guías para la selección y uso del estándar deseado. entre otras se han dedicado a crear modelos para mejorar la Calidad del Software. Modelo de Aseguramiento de la Calidad para la inspección final y pruebas.

Depende de la complejidad del producto o servicio. las necesidades de desarrollo del nuevo proceso. Escribir documentos en forma de procedimientos que describan cómo debe hacerse el trabajo en la organización. 2. Guía para el Sistema de Aseguramiento de la Calidad. Las características del producto o servicio. que puede provocar desacuerdos en cuanto al producto o servicio. • ISO 9004 Elementos para la Administración y el Sistema de Calidad. La complejidad del proceso de diseño. La madurez del diseño. Capacitar al personal de la organización en la operación del Sistema de Calidad. 4. Planificar y llevar a cabo auditorias de calidad internas. Guía para la aplicación de ISO 9001 al desarrollo. las variaciones que se requieren y el impacto en el desempeño del producto o servicio. describiendo el Sistema de Calidad en alto nivel. Además. 113 . Vocabulario. Diseño e implantación de un sistema de acciones preventivas y correctivas para prevenir la ocurrencia de problemas. Identificar las necesidades en cuanto a entrenamiento en la organización. Se refiere al incremento de los costos. suministro y mantenimiento del software. ya sea por las pruebas de desempeño o por la experiencia en el campo. Se refiere a la dificultad para diseñar el producto o servicio cuando éste no ha sido diseñado. ISO 8402 Recopilación de definiciones. existen otras normas y entre ellas las más relevantes son: • • • ISO 9000-1 Guía para la selección de la norma a usar.Capitulo 6 – Software de Calidad. Los factores que determinan el modelo a elegir son: 1. Crear un sistema para controlar la distribución y reedición de documentos. La complejidad del proceso de producción. para el suministrador o comprador. Determinar las medidas y equipos para realizar las pruebas. De forma general los requerimientos fundamentales de ISO 9000 son: • • • • • • • • • Escribir un manual de calidad. Está relacionado con la capacidad del proceso de producción. ISO 9000-3 Estándares de Administración y Aseguramiento de la Calidad. del número de características interrelacionadas y de su influencia en el desempeño. La seguridad del producto o servicio. 1. Se proyecta hacia el conocimiento y aprobación del diseño total. 3. Relacionado con el riesgo de ocurrencia de fallas y el impacto de éstas. 2. Económico. Tener en cuenta los requerimientos del estándar con los que no cumple la organización.

Los objetivos primordiales de éste fueron. asegurando la integridad y seguridad de los productos. pruebas e inspecciones del sistema. Análisis y especificación de los requerimientos del sistema asegurando que sean revisados y acordados con el cliente.Capitulo 6 – Software de Calidad. demostrando que el sistema integrado funciona correctamente y satisface su especificación. Aunque el proyecto original estuvo a cargo del DTI1. construcción. Soporte a clientes de acuerdo a lo especificado en el contrato. Planeación de la calidad del proyecto. la responsabilidad actual por el esquema Tick IT se pasó a DISC. control y monitoreo del avance del desarrollo respecto al plan comunicando a todas las partes afectadas y que avise oportunamente de problemas potenciales. envío e instalación. asegurando que se continúa operando en conformidad con los requerimientos del cliente o usuario. Integración. replicación. además de desarrollar un sistema de certificación aceptable en el mercado. especificando las inspecciones. investigar y corregir productos no conformes. Diseño de primer nivel identificando los componentes principales y los requerimientos que satisfacen. Identificar. Puesta en marcha y liberación del producto para disponibilidad del cliente. segregar. Inspecciones de los productos contra estándares y requerimientos aplicables y las acciones correctivas correspondientes. dando la dirección y guías necesarias para tal efecto. estimular a los desarrolladores de software a implementar sistemas de calidad. Entrenamiento a usuarios en el uso del sistema de tal manera que pueda operarlo y beneficiarse completamente del mismo con la mínima intervención del proveedor. 114 . que es una oficina dependiente de British Standards Institution (BSI) Standards Division. Ciclo de Vida del Software Un sistema de calidad típico Tick IT deberá contener los elementos que se enlistan a continuación: • • • • • • • • • • • • • • • Elaboración de propuestas y revisión de contratos asegurando que todos los requerimientos estén bien especificados y de que la organización tiene la capacidad para cumplirlos. Planeación. Auditorias. Mantenimiento o sustitución del sistema. Almacenamiento. Diseño detallado de todos los componentes e interfaces. pruebas e inspecciones de aceptación del sistema demostrando al cliente que el sistema satisface los requerimientos. así como el cumplimiento de los compromisos adquiridos con el cliente. siendo esta última la única autoridad en el Reino Unido para publicar estándares. y prueba de los mismos verificando que satisfagan la especificación. El Modelo Tick IT El Departamento de Comercio e Industria del Reino Unido (DTI: Department of Trade and Industry) creó el esquema Tick IT. revisiones y pruebas requeridas durante el desarrollo.

de los proyectos y de soporte. Entrenamiento. Administración de la organización y los proyectos de tal forma que facilite los resultados de calidad. convenciones. adquisición y aceptación que asegure que los bienes y servicios adquiridos sean como se requiere y de calidad aceptable. de manera continua. Especificación y control del proceso de desarrollo incluyendo técnicas. de cada instancia de un sistema o subsistema. 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. seguridad. incluyendo identificación. junto a otras organizaciones. seguridad y almacenamiento que protejan contra cualquier pérdida o corrupción. 115 . incluyendo procedimientos y registros. prácticas. Definir. selección. Para contribuir a este programa se creó el Instituto de Ingeniería de Software (SEI) a finales de 1984. el Instituto se dio a la tarea de desarrollar el Modelo de Madurez del Proceso de Software y para 1986 se comenzó el Proyecto de Evaluación de la Capacidad del Software. y disminuya su rotación. Como parte de su trabajo. reclutamiento y desarrollo de personal que asegure su competencia y motivación. Sistema de control de registros y documentación para todas las actividades de aseguramiento de calidad. Administración de la configuración que identifique y controle. Después de varios años de realizar cuestionarios. Auditorias. Soporte y Aseguramiento de Calidad • • • • • • • • • • • • Establecer políticas y objetivos de calidad generales de la organización que sirvan para alinearla en todas sus actividades. evaluaciones. Respaldos. adquiridos o suministrados por el cliente. revisiones y acciones correctivas al sistema de calidad que aseguren que el sistema cumple con los requerimientos. estándares. Control de productos incluidos. es utilizado y que es efectivo en el logro de resultados. procedimientos y políticas específicas. en 1991 SEI produce el Modelo de Capacidad y Madurez del Software. configuración. equipo y herramientas utilizadas: Hardware o Software. recolectar y analizar datos de calidad para evaluar la efectividad del sistema de calidad e identificar mejoras potenciales. mediciones y estadísticas. consulta e investigación. incluyendo utilización. las partes constituyentes y sus versiones. El principal objetivo de un proceso de software maduro es el de producir productos de calidad que cumplan los requerimientos del usuario. La capacidad del proceso es la habilidad inherente para producir los resultados planeados. Proceso de compras.Capitulo 6 – Software de Calidad. El Modelo CMM A principios de los años 80’s el Departamento de Defensa de los Estados Unidos enfocó sus tareas a la revisión de los problemas del software y a su mejoramiento. Implantar y mantener un sistema de aseguramiento de calidad.

Determinar la efectividad CMM es un modelo descriptivo en el sentido que describe los atributos esenciales que se espera caractericen una organización dentro de un nivel de madurez en particular. Actuar a. Implementar los cambios b. CMM: Marco de Trabajo Capability Maturity Model – SEI 116 . Ejecutar a. no existen planes rigurosos. Establecer los objetivos a mejorar 2. Identificar las posibles causas de problemas b. Es un modelo normativo ya que las prácticas detalladas caracterizan el tipo normal de comportamiento que se espera de una organización que realiza proyectos a gran escala. Este consta de 4 pasos que se repiten en forma de ciclo hasta que la implantación produce los resultados esperados y los cambios pasan a ser permanentes. controlado y es efectivo. el administrador monitorea la calidad del producto y la satisfacción del cliente. Recolectar los datos b. se llevan registros y todos los integrantes están involucrados. carecen de bases objetivas para enjuiciar la calidad de los productos o para resolver los problemas. Planear a. En una organización de software inmadura. Estructura del modelo. Establecer las bases c. se hacen pruebas y análisis de costo-beneficio para mejorar el proceso. Por lo contrario cuando la organización alcanza cierto grado de madurez posee una gran habilidad para administrar el proceso de desarrollo y mantenimiento del software.Capitulo 6 – Software de Calidad. Los pasos son: 1. administrado. Probar los cambios 3. 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. La madurez del proceso de software esta dada cuando un proceso en específico es explícitamente definido. medido. Revisar a. Definir el problema b. Evaluar los datos 4. No es prescriptivo ya que no dice a la organización como mejorar. El ciclo Shewhart propone las bases para el trabajo de mejoramiento del proceso. el proceso de software es generalmente improvisado. se enfocan en resolver las crisis que se le presentan.

El grupo que trabaja en el proceso enfoca y guía sus esfuerzos al mejoramiento de su desarrollo. facilita la introducción de técnicas y métodos e informa a la administración del estado del proceso. Repetible: se establecen procedimientos de administración del proceso básico para determinar costos. Optimización: el mejoramiento continuo retroalimentación cuantitativa y desde las innovadoras. Este nivel de capacidad permite a la organización predecir las tendencias en la calidad del producto dentro de los límites establecidos y tomar las acciones necesarias en caso que sean excedidos. 4. Se exhiben problemas de calidad y carecen de una adecuada estructura para mejorarla. El modelo consta de 5 niveles. El proceso del software es impredecible por el continuo cambio o modificación a medida que avanza el trabajo. por lo que los mayores riesgos se presentan cuando se enfrentan a nuevos proyectos. homogeneizado e integrado en un proceso de software estándar dentro de la organización. 5. No existen calendarios ni estimados de costos y las funcionalidades y calidad del producto son impredecibles.Capitulo 6 – Software de Calidad. El ciclo de Shewhart es constantemente utilizado para planear. Ambos son cuantitativamente entendidos y controlados. del proceso es garantizado por la pruebas de técnicas y herramientas medios para identificar los puntos actividad clave es el análisis de las 117 . roles y responsabilidades definidas en el desarrollo de software. Estas 5 etapas de desarrollo son referidas como niveles de madurez y en cada una la organización alcanza una capacidad en el proceso superior. Definido: el proceso de software para las actividades administrativas y técnicas está documentado. El proceso se basa en repetir éxitos anteriores en proyectos de similares características. La organización tiene los débiles y conocer como fortalecerlos. Su causas de defectos y su prevención. calendarios y funcionalidades. Los 5 niveles del modelo son: 1. Inicial: el proceso de software es un proceso improvisado y caótico. Se establecen las políticas para la administración del proceso y los procedimientos de implantación. Los productos de dicha categoría son predeciblemente de alta calidad. 3. 2. La capacidad del proceso está basada en una amplia comprensión común dentro de la organización de las actividades. No existe un ambiente estable para el desarrollo y mantenimiento del software. que ayudará a obtener un desempeño más efectivo. Administrativo: se recolectan medidas detalladas del proceso de software y de la calidad del producto. Pocos procesos están definidos y el éxito que se pueda obtener depende de las habilidades. diseñados de forma que los inferiores proveen unos fuertes cimientos incrementados de manera progresiva sobre los que se construyen los niveles superiores. implementar y registrar las mejoras al proceso. conocimientos y motivaciones del personal.

el llenado de los cuestionarios del proyecto elegido. una breve reunión de apertura.Capitulo 6 – Software de Calidad. 4. El Modelo BOOTSTRAP El Instituto Bootstrap es una organización no lucrativa dedicada a la mejora continua del modelo de calidad de software llamado BOOTSTRAP. Su enfoque es evaluar el proceso. determinación del nivel de madurez y capacidades. identifica áreas de mejora. Este se compone de: un modelo. hace evidente fortalezas y debilidades. se seleccionan los proyectos a ser evaluados para obtener la mejor cobertura de la UPS 3. una base de datos de soporte. para obtener un enfoque colaborativo con el personal a ser entrevistado. las tareas son: 1. a través de sus proyectos para hacer un cambio a toda la organización. y la presentación de resultados de la evaluación. Para eso se definen un conjunto de características para los procesos. En la etapa de ejecución. En la etapa de preparación se realizan las siguientes tareas: 1. rediseñar y mejorar los procesos de negocio del desarrollo de software. El modelo Bootstrap se basa en evaluar las unidades de producción de software de la organización. reunión final. Bootstrap es un método para analizar. ejecución de la evaluación. un proceso de mejora y los instrumentos de evaluación. también tiene como propósito ayudar a la industria europea del software para mejorar su competitividad.Tecnología que se usa en Bootstrap para los niveles de evaluación y agrupación de resultados. revisión preliminar de la evaluación. 2. 118 . 3. un entrenamiento inicial para tener claros los objetivos 2. hay cuatro etapas principales: preparación. no el producto. El modelo define el paradigma Organización-Metodología. Dentro de este proceso. se define el personal de evaluación para minimizar la subjetividad 4. provee recomendaciones y sugiere un plan de implementación. se hace el acuerdo de confidencialidad. un proceso de evaluación. produce vistas analíticas. el llenado de los cuestionarios con características generales de la UPS. con el enfoque de presentar los resultados de la evaluación y obtener el consenso para poder pasar a la fase de mejoras. provee un análisis cuantitativo. y 5. incluyendo la evaluación de cómo el proceso de producción es aplicado. se define el personal a ser evaluado para obtener la mejor cobertura de los roles involucrados en los proyectos seleccionados y 5.

regular. 2-repetible. Estos niveles de madurez están subdivididos en cuatro. se pueden medir las adaptaciones a la metodología. Enseguida hacer una revisión y análisis de resultados de la evaluación. de forma que se obtenga una calificación más exacta. uno con los resultados de la evaluación de la UPS y otro con los resultados del proyecto evaluado. débil.Capitulo 6 – Software de Calidad. Enseguida. aplicando un algoritmo numérico. tomando en cuenta las fortalezas y debilidades detectadas. Con esto se fundamenta el plan de mejoras. Proceso de Mejora Otra parte importante de la metodología de Bootstrap. El proceso para obtener el plan de mejora es. extenso o no aplica. los objetivos de la UPS. modificar la organización y responsabilidades para iniciar el cambio. el plan de acción recomendado. mientras que el de tecnología se califica sólo con dos niveles A o B. Finalmente sobre la base de las actividades definidas. metodología y tecnología. considerando un período entre 18 y 24 meses. Los procesos de organización y metodología se califican de 1 a 5. es el plan de mejora que sugiere. Uso de las Bases de Datos de Soporte Una de las características principales de Bootstrap es la base de datos con que cuenta para hacer análisis. 3-definido. El reporte del proyecto contiene: comentarios del proyecto actual detallando lo referente a la organización. los niveles de madurez para el proyecto. Como resultado de la evaluación. se puede comparar contra la industria y se pueden establecer objetivos basándose en la competencia. etc. Para cada atributo clave se obtiene un nivel de madurez. es donde se califica cada pregunta con uno de 5 valores posibles: nulo. un plan de acción recomendado. estableciendo un marco de tiempos para su desarrollo y evaluación. En la etapa de determinar el nivel de madurez y capacidades. El correspondiente a la UPS contiene información como: un resumen ejecutivo. la organización recibe 2 reportes. etc. 119 . Después definir las capacidades a mejorar. definir las prioridades de acuerdo a un análisis de impactos. 4-administrado o 5-optimizado. costos y riesgos del producto y del proyecto. dando como resultado uno de estos niveles: 1-inicial. Primero evaluar las necesidades de la organización tomando en cuenta las mejoras deseadas e indicadores sobre calidad del producto y servicio. los puntos débiles y fuertes. tiempo de desarrollo.

PROCESOS. Arquitectura del Modelo El modelo es tridimensional: la primera dimensión es funcional (procesos).0. originalmente. a "evaluation" y fue cambiado porque en algunos idiomas se traducía equivocadamente. empezó a trabajar en enero de 1993 bajo la dirección de Alec Dorling y Peter Simms. La dimensión PROCESO: Está organizada jerárquicamente de la siguiente manera: CATEGORÍA DE PROCESOS. Cuantitativamente controlado. que logran propósitos técnicos. Ingeniería. Las escalas que se manejan son discretas de tipo: 0 = No adecuado. 1 = Parcialmente adecuado. 2 = Muy Adecuado. operaciones que conforman un proceso. 120 . El grupo de trabajo (Working Group) WG 10. PRÁCTICAS BÁSICAS. Organización y Soporte. La tercera dimensión es la CALIFICACIÓN: El juicio mismo: ¿qué calificación le doy a este proceso en este atributo de capacidad?. Una de las características sobresalientes de este proyecto de estandarización es que incluyó un periodo de pruebas del estándar de 2 años. En la versión 1. El Modelo ISO/SPICE Software Process Improvement and Capability Determination La Organización Internacional para la Estandarización (ISO) creó el grupo de trabajo WG 10 y le encomendó el desarrollo del estándar internacional de Valuación de Procesos de Software. Planeación y seguimiento bien definido. antes de ser publicado como estándar se había estado ajustando por la práctica. Los Elementos de Evaluación Marco de Valor El Modelo ISO/SPICE tiene un marco de valor explícito. 3 = Totalmente Adecuado. la segunda de capacidades (niveles).0 estos niveles son: Desempeño informal. y decidieron crear el proyecto SPICE Software Process Improvement and Capability Determination. y la tercera de adecuación o efectividad (calificaciones). Está en etapa de instrumentación una versión 2. Proyecto. la E de SPICE correspondía. Es decir. Mejora continua. que agrupan procesos comunes. Las categorías definidas son: Cliente-Proveedor.Capitulo 6 – Software de Calidad. La dimensión CAPACIDAD: Está organizada ordinalmente en niveles de capacidad y se han definido cinco niveles.

Conceptualmente el modelo ISO/SPICE es un modelo inductivo en su parte funcional: de característica a producto.Capitulo 6 – Software de Calidad. en general. es decir. Este es uno de los componentes más valiosos del estándar internacional. Es. En la dimensión funcional o de proceso: las "mejores prácticas". a juicio del Evaluador. un modelo realista: va a ver los productos. Éste es un enfoque de efectividad… "por sus frutos los conoceréis…". la efectividad de los procesos no lo que está escrito en algún manual de calidad o de procesos. En su parte de capacidades es un modelo evolutivo. 121 . Cada producto tipo ha sido catalogado y sus características de calidad definidas. Este es otro elemento filosófico fundamental de ISO/SPICE: no es un modelo nominalista. de las capacidades reales del proceso de software. Recurrencia Por último el elemento recurrencia. de producto a práctica. Evidencia La evidencia para la evaluación serán los productos producidos por las prácticas base. y de práctica a proceso. para fundamentar un juicio o evaluación vendrá dada por la selección de instancias de proyectos o productos representativas. Estándares y modelos de evaluación y mejora de los procesos software. En la dimensión de capacidad: los atributos de proceso o prácticas genéricas que incrementarán la capacidad del proceso.

Capitulo 6 – Software de Calidad. 122 .

484 32 Como puede verse existe mucha información sobre el tema. A modo de ejemplo de esos volúmenes. Postulante (6-18 meses): los conceptos ya se aplican con soltura en el desarrollo. desde el año 2000 de lenguajes.560.000 8. Experto (gurú): todo son objetos. Y para fundamentar.700 5.000 94. firme y consensuada que no existe la solución ideal al elegir un lenguaje de programación. Los atractivos de los "objetos" aparecen innegables y.000 93. según algunos). y el sujeto se pregunta: ¿cómo pude pensar antes de otra manera? Este estadio no siempre se alcanza. sobre el tema “Programación Orientada a Objetos” en Internet quiero destacar: Buscador Google Yahoo Altavista Proveedor de libros Amazon. Naturalmente lo más fácil es pensar que los "nuevos" métodos que la OO propugna van a facilitar el trabajo diario "real" en empresas y departamentos de desarrollo de software. La elección del Lenguaje de Programación Es opinión antigua. pero también se acepta de forma unánime que la Orientación a Objetos proporciona ventajas evidentes en el desarrollo genérico de software. La misma simbología ya es una gran nebulosa de la Tecnología de Objetos (OT). CONCLUSIONES Es casi imposible resumir y condensar en pocas páginas la gran cantidad de información disponible sobre el tema.com Sun Microsystems Sitios encontrados En castellano En cualquier idioma 110. las siguientes etapas personales se cubren de forma inexorable: • • • • Novicio (1-3 meses): se mezcla el código eminentemente funcional modificándolo y añadiéndole porciones de objetos. Aprendiz (3-6 meses): aquí se produce el "despertar" del que hablan los textos de Zen.640.Capitulo 6 – Software de Calidad. pero todavía se dan algunos problemas con la modelización.200 --volúmenes encontrados En cualquier idioma 3. veamos algunos de los actuales métodos de OOA/OOD (Análisis Orientado a Objetos/Diseño Orientado a Objetos): 123 . naturalmente (afortunadamente. técnicas y métodos orientados-a-objetos. se ve el verdadero significado de la orientación-a-objetos y se empiezan a bosquejar diseños pertinentes. aun más la gran profusión de métodos con bases teóricas. pero al menos se expondrán algunas consideraciones prácticas extraídas de la aplicación con los alumnos en la cátedra Programación IV.

es muy difícil diferenciar si uno es mejor que el otro. las siguientes conclusiones: Los alumnos se entusiasman con el concepto. Colbert Andleigh/Gretzingr Ian Graham Berard Donald Firesmith Martin & Odell Reenskaug et al. las peculiaridades del equipo de desarrollo. En el ámbito académico. Creo que como todo en su nivel inicial. Cada autor tiene sus flaquezas y fortalezas. OOA&D OORASS CRC La realidad es que. 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 Rôle Analysis. les cuesta un poco pensar de manera abstracta. quiero destacar. luego su práctica 124 . la experiencia en determinados lenguajes de programación y la naturaleza concreta de cada proyecto. dentro de unos márgenes más o menos estables de actuación. 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. luego de 4 años de dictar en la cátedra Programación IV el Paradigma de Objetos. Coleman y otros Softeam Wirfs-Brock et al. La experiencia y la revisión real de la gestión de proyectos orientados-a-objetos en distintas empresas muestra que el éxito siempre ha ido acompañado de una visión particularizada de OOA/OOD acorde con la política de la empresa. pero tienen un pequeño grado de dificultad al iniciar el diseño de los objetos. definitivamente.Capitulo 6 – Software de Calidad.

A nivel de asignatura. Conclusiones y Perspectivas a Futuro En la etapa de investigación bibliográfica. Los ejemplos dados. tengan una fuente alternativa completa. destinado a alumnos y docentes. brindando abundante material teórico. Direcciones de sitios de descarga de manuales y tutoriales sobre la temática específica. he podido comprobar que hay muchísimas páginas que explican muy someramente cada concepto de POO y luego muestran un ejemplo. como una continuación de este trabajo. exigente y apasionante mundo del desarrollo del software. profesional los pulirá con un mejor diseño. esto es así porque son los más sencillos para la comprensión de los conceptos. como así también. como así también ejemplos pertinentes en cada caso. Un foro de discusión sobre el tema POO. Con esto se pretende darle mayor difusión a la temática. se propone la instrumentación del concepto “SOFTWARE DE CALIDAD” ya sea en esta cátedra o como una cátedra optativa.Capitulo 6 – Software de Calidad. se esta desarrollando un sitio Web en el que se pondrá disposición de los alumnos. con test. Este material permitirá que los alumnos interesados en profundizar la temática de Programación Orientada a Objeto. son similares a los que pueden encontrarse en la literatura específica. Por ahora en la cátedra pregonamos el “enseñar la técnica”. el código provisto les permitirá visualizar rápida y fácilmente la implementación de esos conceptos. Formosa. clara y precisa sobre los principales tópicos de la POO. 14/05/2005 125 . en la que he utilizado intensamente la fuente inagotable de Internet. en cierta manera. en este incipiente. pizarra de novedades. resultados de los trabajos prácticos. En este trabajo he tratado de revertir ese problema. la seguridad y conocimientos necesarios para que nuestros futuros egresados se atrevan a sus propios emprendimientos. en general. para afianzar contundentemente la necesidad de desarrollar software competitivo para su venta a nivel internacional. que garanticen una exitosa inserción laboral. lo siguiente: El material de apoyo utilizado para el presente trabajo. Perspectivas a futuro Cómo actividades complementarias y. El material de los trabajos prácticos. Otros trabajos relacionados con el tema. promover la participación de los alumnos y los docentes del área y generar la sinergia necesaria para lograr una mejor formación de nuestros recursos humanos. Así también.

.

los conjuntos. Atributos: Datos que caracterizan las instancias de una clase. con el fin de obtener un tipo abstracto de datos. para tomar en cuenta únicamente aquellas relevantes a la solución de un problema. y que además son invocadas automáticamente por el compilador. Composición: Relaciones todo/parte. El efecto de la herencia puede simularse en la mayoría de los lenguajes tradicionales. Abstracción (2): ignorar aquellos aspectos que no sean relevantes al propósito actual para concentrarse más profundamente en aquellos que lo son. De esta forma se separan las características de un ente en dos grupos. mostrando la especialización de los estados y los comportamientos de las clases de objetos de nuestro sistema en forma jerárquica. Encapsulamiento: Facilidad de un lenguaje de programación que permite definir un tipo de datos junto a sus operaciones. Enlaces: Instancias de una relación. Constructores y Destructores: Facilidad de un lenguaje de programación que le permite al programador definir uno o varios procedimientos especiales que se encargan de inicializar y destruir las variables de un tipo. Relaciones padre/hijo. Relaciona instancias Especificación: Proceso por medio del que se definen las características de un ente. Iteradores: Abstracción que permite obtener todos los elementos contenidos en un tipo abstracto de datos contenedor. los árboles y en menor grado los grafos. se resolverá en tiempo de ejecución. Los contenedores más usuales son los arreglos. pero el resultado es un programa menos elegante y en muchos casos mucho más difícil de programar. Enlace dinámico: es la propiedad que poseen los objetos para enviar mensajes a otros objetos sin necesidad de conocer (quizá por imposibilidad de hacerlo) la clase a la que pertenecen. GLOSARIO Abstracción por especificación: Disciplina de programación que busca que el programador defina qué es lo que hace cada uno de los módulos que componen un programa o sistema. Asociación y mensajes: los objetos de un sistema se relacionan y se comunican entre sí. Concatenación: Unir elementos. la misión principal de los destructores es devolver la memoria dinámica asociada a un objeto. el de las características que importa y el de las que sobran. En general. agregando al final nuevos campos. Herencia (Extensión de tipos): Facilidad del lenguaje de programación que permite extender un tipo de datos. aún antes de realizar la implementación. Encapsulación: la interfase de cada componente del programa se define de forma que revele tan poco como sea posible de sus particularidades interiores. Abstracción: Proceso por medio del que se elimina información para lograr tratar cosas diferentes como si fueran iguales. Asociación: Relación de uso en general. Instancias: Cada uno de los objetos individuales. Abstracción por parametrización: Uso de argumentos en procedimientos y rutinas. las listas. Generalización. 127 . Herencia: expresa la similitud entre clases de objetos. Clases: Abstracción de objetos con propiedades comunes.Glosario. Calificación: Limita la multiplicidad de las asociaciones.

resulta luego conveniente que el procedimiento que se use para operar sobre un dato dependa del dato en sí. Método: Operación que es definida junto a un tipo de datos en aquellos lenguajes que soportan encapsulamiento. Ocultación de Datos: Facilidad de un lenguaje de programación que permite evitar que un programador que usa un tipo abstracto de datos pueda manipular la estructura interna de una instancia. En estos casos. Redefinición: Modificación de las propiedades heredadas. En general. que generalmente se construyen de forma que sean independientes unas de otra.* / ^] en expresiones. Programación Estructurada: Conjunto de prácticas y disciplinas de programación que se basan en el uso de Abstracción por parametrización y por especificación para construir sistemas. Módulos: Partes que componen un sistema. Además. procedimientos y argumentos. Mensaje: Nombre del método con que se invoca a una operación sobre un objeto. Sobrecarga de identificadores: Facilidad de un lenguaje de programación que permite usar el mismo identificador para procedimientos diferentes. Multiplicidad: Número de instancias que intervienen en la relación. 128 . Los términos método y operación son sinónimos. Sobrecarga de Operadores: Facilidad de un lenguaje de programación que le permite al programador definir un nuevo tipo de datos que puede usarse en expresiones. Polimorfismo (Funciones Virtuales): Un lenguaje de programación que soporta polimorfismo permite diferir la definición de la operación que debe aplicarse un objeto al momento en que esa operación es necesaria. un lenguaje de programación soporta la Programación Estructurada si cuenta con las construcciones sintácticas IF-THEN-ELSE. En general se busca que al hacer cambios en un módulo no sea necesario hacerlo en otros. Procedimiento o rutina: Facilidad sintáctica de los lenguajes de programación que le permiten al programador aislar la solución de un problema particular en un módulo. De esta manera. Polimorfismo: es la propiedad de dos o más clases para responder al mismo mensaje. Un programa estructurado nunca hace uso del GO TO. y generalmente se descompone modularmente como una jerarquía de procedimientos. Operaciones: Funciones que pueden realizar las instancias. Los procedimientos se diferencian por sus argumentos y no por su nombre. cada una de ellas según su especificación. el programador no necesita conocer el objeto sobre el que opera. Mediante el uso de procedimientos es posible aplicar la abstracción por parametrización y por especificación. Relaciones: Se establecen entre clases. pero uno se usa en el contexto de Programación por Objetos y el otro en el de Abstracción de Datos. Roles: Indican los papeles de las clases en las relaciones. Herencia y Polimorfismo. WHILE-REPEAT. se dice que los módulos tienen una cohesión baja. usando la descomposición de Arriba hacia Abajo [Top-Down]. Programación Orientada a los Objetos [OOP] ó [POO]: Uso de unas técnicas de Abstracción de Datos en un lenguaje que también soporta Encapsulamiento. aunque el programador no haya especificado exactamente cuál es ese procedimiento. Cuando se usa herencia para extender de muchas formas un tipo de datos. la sobrecarga de operadores implica el uso de los operadores aritméticos [+ .Glosario. CASE. De esta manera se evita que el programador usuario del tipo abstracto de datos introduzca inconsistencias en la estructura de datos.

Esto se logra definiendo las operaciones de un tipo de datos. aunque ésta última no sea completa. Lo usual es que un DAT provea Ocultamiento de Datos y alguna forma de Encapsulamiento de datos. 129 . Tipos Abstractos de Datos: Es un el uso de una técnica de abstracción que busca juntar en un sólo módulo toda la programación relevante a una estructura de datos en particular.Glosario.

.

sc. Using Java.html http://www.html http://www.map.csuohio.html http://www. Hunter. Análisis y Diseño orientado a objetos..org/velocity/ymtd/ymtd.ati. 2000.html http://www.co:80/sistemas/6707. http://jakarta. Pontificia de Salamanca en Madrid Venners.es/sbweb/fisica/cursoJava/fundamentos/herencia/intro_herencia. Universidad Alicante. Steven W. Java 2 .cu/revistas/aci/vol5_s_97/sup04197.apache.mx/~sol/docencia/ti/sesion4.com Tutorial Java Avanzado – www. 2000.pa/1998/diciembre/novedades. J “The Problems with JSP”.ehu.well. Addison Wesley Iberoamericana.htm http://www. 2000 Castillo.es/gt/calidad-software/presentacion.sun.ati. Paraninfo.geocities.html. Solares C. The Java Tutorial.html Revista electrónica sobre java – www.com/soapbox/problems-jsp. Jon S.http://www.edu/coe/sqi/newsletter/ http://www.html#index por Ricardo Devis Guía de Páginas y Lenguajes OO. Grady Booch.htm http://www.javaworld. Parra Fuente.mx/~ho/SPICE/pres1.ua. E. Ed.. Campione.udlap..es/asignaturas/poo/Enlaces Jakarta Tomcat.com. University of Toronto Press.Bibliografía.uniandes. Univ. Designing with interfaces.html http://www.programacion..org/tomcat/ Stevens.es/csi/silice/Auditr12. Griffith.net Guía de Páginas OO.com/). Addison-Wesley.com TUTOR JAVA – www. Gómez P. Alexander.servlets. “You Make the Decisión”.fciencias.com Página de descargas de la Universidad de Castilla La Mancha http://scalab.htm http://gente. 2000. Universidad de Zaragoza España. McGraw-Hill.htmp Notas específicas sobre el tema “Sobrecargas” y “Herencias” http://manowar. Mary. España www.unam.com/es/magazine/softwareengineering/quality-control/ http://agamenon. Departamento de Lenguajes y Sistemas Informáticos.dlsi.sc. Introduction to Programming in Java. BIBLIOGRAFÍA • • • • • • • • • • • • • • • • • • • • • • Patterson J.uc3m..htm • • • • • • • • • • • • • • • 131 .htm http://www.sld. 1996. Agustín.fi/~atorn/SQuality/SQ11. 1001 tips para programar con Java.utexas.apache. Cobo A.isaca.java.pcworld.html http://www.html http://www.Manual de Usuario y Tutorial.org/standard/sp. www.htm http://www.es/novatica/1997/125/nv125pres.us. Sitio Web Oficial de Sun Microsystem – www.html http://www. Eckel.es/jiwdocoj/remis/docs/aseguracal.com/smugbook/quality.abo.pue. 1997.openresources. Java Un lenguaje de programación multiplataforma para Internet.com/user/ritchie/oo. Prentice Hall.lsi. 12/1998. Alfaomega.ehu. Javier. Hill.edu.es/pipermail/csharp-dist/2001-March/000500. Dpto Ampliación de Informática.es/~docweb/pr-inf/index. Stephenson C. Java World (http://www. Thinking in Java.edu/accounts/Audit4/ http://www. Macmillan Computer Publishing.robelle. http://jakarta. Java y la POO. Froufe. 1997. Bruce.javaworld. Newman. Curso Java Avanzado.

.

* Con Funciones Redefinidas en Java se utiliza siempre * Vinculación tardía */ //CLASE PADRE class Oceania { // se definen 3 constantes de tipo cadena (variables // finales) final String e1="Australia". } } //CLASE HIJA (derivada) class Australia extends Oceania { final String capital="Canberra".out.System.println("Principales Estados").e2="Fidji". } } "+ public class Geografia1 { public static void main(String[] args) { Australia ciudad = new Australia(). // se define una // constante(variable final) llamada // capital y se le asigna el valor Canberra public void descripción() { System.e3="Nueva Zelanda".println("La capital de Australia es: capital).println(e2). PROGRAMAS EJEMPLO DE LOS TEMAS TRATADOS. Redefinición de métodos /*Programa 1 .out.out. // ejecuta el método "descripción" de la clase // hija } } /*el método descripción que estaba definido en la clase * padre(Oceanía).println(e1).descripción(). // crea un objeto "ciudad" de la clase // hija "Australia" ciudad. System. Clases abstractas. public void descripción() { System. System.println(e3).out.Versión 1*/ /* REDEFINICIÓN:(OVERRIDEN) Una clase puede redefinir (volver a * definir) cualquiera de los métodos heredados de su super-clase * que no sean final.out. * El nuevo método sustituye al heredado para todos los efectos * en la clase que lo ha redefinido. se redefine en la clase hija Australia/ 133 .Programas ejemplo.

estado[1]="Fidji".Programas ejemplo. /*Programa 1 .println("Principales Estados de Oceanía"). // (variante) ejecuta el método "descripción" de la // clase padre ciudad. //ejecuta el método "descripción" de la clase hija } } 134 .println(estado[i]).Versión 2*/ //CLASE PADRE class Oceania { //variante // se declara un vector de la clase String(cadena) y se lo // inicializa con 3 posiciones String estado[]=new String[3]. public void descripción() { estado[0]="Australia".out. // Crea un objeto "ciudad" de la clase Hija // "Australia" estado.out.out.descripción().// se define una constante //(variable final) llamada “capital” y se le asigna el valor // Canberra public void descripción() { System.println("\n"+"La capital de Australia es: "+ capital). System. estado[2]="Nueva Zelanda". Clases abstractas. for(int i=0. } } } //CLASE HIJA (derivada) class Australia extends Oceania { final String capital="Canberra". } } public class Geografia2 { public static void main(String[] args) { Oceania estado = new Oceania().descripción().i<3. //(variante) Crea un objeto "estado" de la clase padre // "Oceanía" Australia ciudad = new Australia().i++){ System.

Programas ejemplo. Clases abstractas.

/*Programa 1

- Versión 3*/

//CLASE PADRE class Oceania { String estado[]=new String[3]; public void descripción() { estado[0]="Australia"; estado[1]="Fidji"; estado[2]="Nueva Zelanda"; System.out.println("Principales Estados"); for(int i=0;i<3;i++){ System.out.println(estado[i]); } } } //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 descripción() { System.out.println("\n"+"La capital de Australia es: "+ capital); } } //CLASE HIJA (derivada) class Fidji extends Oceania { final String capital="Suva"; // se define una constante(variable final) y se le asigna // el valor Suva public void descripción() { System.out.println("\n"+"La capital de Fidji es: "+ capital); } } public class Geografia3 { public static void main(String[] args) { /* (variante) */ Oceania ciudad; //declara una referencia a un objeto de la clase padre // "Oceania" . Se inicializa a null ciudad= new Australia(); // La referencia "apunta" al nuevo objeto creado de la // clase hija "Australia" ciudad.descripción(); // ejecuta el método "descripción" de la clase hija // "Australia" ciudad =new Fidji(); // La misma referencia "apunta" al nuevo objeto creado de // la clase hija "Fidji" ciudad.descripción(); // ejecuta el método "descripción" de la clase hija "Fidji"

135

Programas ejemplo. Clases abstractas.

}

}

Modelos de Ejecución Versión 1: La capital de Australia es: Canberra

Versión 2: Principales Estados de Oceanía Australia Fidji Nueva Zelanda La capital de Australia es: Canberra

Versión 3: Principales Estados de Oceanía Australia Fidji Nueva Zelanda La capital de Australia es: Canberra La capital de Fidji es: Suva

136

Programas ejemplo. Clases abstractas.

/*

Programa 2

*/

/* Cuando una clase deriva de otra hereda la funcionalidad de la * clase padre, pero además una clase hija, puede * sobreescribirla.Podemos escribir un método en la clase hija * que tenga el mismo nombre y los mismos parámetros que un * método de la clase padre */ class Mamifero { public void descripción() { System.out.println("El mamífero es un Vertebrado"); } } class Perro extends Mamifero { public void descripción() { System.out.println("Mamifero carnivoro "); } } public class Animales { public static void main(String[] args) { Perro Toby = new Perro(); Toby.descripción(); } } // Al ejecutar el programa veremos que se escribe el mensaje de // la clase hija, no el del padre. Modelos de Ejecución Mamifero carnivoro

137

out. * / /** Diversos modos de sumar (versión estática)*/ public class Sumar { public static float suma(float a.println(suma(v. System.y=2.println("suma de enteros").y)).Versión 1*/ /* El concepto de polimorfismo. Clases abstractas. } public static void main(String[] args) { float x=1. System.out. int b) { System. siempre y cuando su lista de parámetros sea distinta *(en cuanto a número o tipo de argumentos).0 suma de enteros 8 138 .w)). } } Modelos de Ejecución versión 1 suma de reales 3. Sobrecarga de métodos /*Programa 1 .Programas ejemplo. } public static int suma(int a.w = 5. return a+b.out.println(suma(x.out. * Java permite que varios métodos dentro de una clase se llamen * igual. int v = 3. se * puede extender a los métodos. float b) { System.println("suma de reales"). return a+b. en cuanto a cambio de forma.

println("suma de reales"). int tipo = Integer. System. float b) { System. System.out. } } catch(ArrayIndexOutOfBoundsException e){ System. int y=(int)valor2. System.println(suma(valor1.println("Estoy sumando enteros").out.out.println("3er valor --> 1 para sumar enteros").y)).out.out. case 2: System.println("Por Favor ingrese 3 valores").println(suma(x. System.parseInt(args[2]). switch (tipo){ case 1: int x=(int)valor1.out. int b) { System.out.out.println("El 3er valor debe ser:").valor2)). return a+b. System. Clases abstractas. } // método de clase(Static) que arroja valores ENTEROS public static int suma(int a. System.out. float valor2=Float.println("2do valor --> 2do sumando").parseFloat(args[0]).println("1:si desea sumar enteros"). /*Programa 1 .out.println(" --> 2 para sumar reales"). } } // método de clase(Static) que arroja valores REALES public static float suma(float a.println("2:si desea sumar reales").out. break.Programas ejemplo. System.Versión 2*/ /** Diversos modos de sumar(versión flexible) */ public class Sumar { // método principal public static void main(String[] args) { try { // controla que el usuario ingrese correctamente los // valores float valor1=Float.parseFloat(args[1]).println("1er valor --> 1er sumando"). break.out. return a+b. } } 139 . default: System.

Programas ejemplo. Clases abstractas. Modelos de Ejecución versión 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 .

parseInt(args[0]).out. int anch) { largo = lar. // Llama implícitamente al método calcularArea(sin // argumentos) System. Clases abstractas.println(rec2. // crea un objeto de la clase Rectángulo sin // argumentos Rectángulo rec2 = new Rectángulo().println("Área Rectángulo Usuario").n2). } } // rec1 utiliza este Método Constructor pues se pasó 2 // argumentos durante su creación public Rectangulo(int lar. // Llama implícitamente al método calcularArea(con // argumentos) System.out. // n2 toma el 2do valor ingresado por el usuario // crea un objeto de la clase Rectángulo .println("Área Rectángulo Computadora"). // n1 toma el 1er valor ingresado por el usuario int n2=Integer.Programas ejemplo.calcularArea()). } catch(ArrayIndexOutOfBoundsException e){ System.calcularArea()).out. } 141 . // largo y ancho tendrán los valores ingresado por el // usuario ancho = anch. System.println(rec1.println("Por Favor Ingrese los valores del largo y ancho del rectangulo").parseInt(args[1]).out.out. System.se pasa // como argumento los valores n1 y n2 Rectángulo rec1 = new Rectángulo(n1.ancho. // variables privadas: únicamente se podrán utilizar en // esta clase // metodo principal donde comienza la ejecución del // programa public static void main(String[] args) { // Bloque TRY/CATCH controla que el usuario ingrese los // valores correctamente try{ int n1=Integer. /** Programa 2 */ /** Calcula el área de un rectángulo */ public class Rectangulo { private int largo.

ancho = (int)(Math.random()*10).0 142 . // rec2 utiliza este Método Constructor pues no se pasó // argumento alguno durante su creación public Rectangulo() { // largo y ancho tendrán valores aleatorios ingresados por la // función random de la clase Math largo = (int)(Math.0 Area Rectangulo Computadora 32. } // método al que se llama con los objetos rec1 y rec2 en el // método main(principal) public float calcularArea() { int area=(int)Math. Clases abstractas.random()*10).abs(largo*ancho). return area. //e es el valor que se devuelve al programa llamador } } Modelos de Ejecución C:\java Rectangulo Por Favor Ingrese los valores del largo y ancho del rectangulo C:\java Rectangulo 5 5 Area Rectangulo Usuario 25.Programas ejemplo.

cadenas y arrays de caracteres. } //n! = n*(n-1)! -variable k //contendrá el valor k! vector[i]=k. else { vector[0]=1. i<=n.out.out.out.Programas ejemplo. i<=n.println("Margen de error: "+(Math. } // Salida por pantalla System. j=0.println("La formula solo permite aproximarse al nº e con valores positivos"). } catch(ArrayIndexOutOfBoundsException e){ System.out.EnumE)). double vector[]=new double [(n+1)]. System. System. * La diferencia entre ambos métodos está en que println añade un * carácter de nueva línea.//1!=1 for(i=2. /*Programa 3 */ /** Aproximación al Número E */ /** Este ejemplo utiliza los métodos de la clase PrintStream que * proporciona utilidades para dar formato a la salida. produciendo una nueva línea. System. k*=j.out. */ 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. while (j>1){ j--.out. Además el método println puede * llamarse sin argumentos.//0!=1 vector[1]=1. i++){ j=i. Clases abstractas.println(). } } // Forma el número aproximado a "e" for (i=0.println("Por favor ingrese el valor 143 .parseInt(args[0]). // Se controla que el usuario no ingrese valores // negativos o nulo if (n<=0) System.println("Valor Aproximado: "+numE).E).k=i. i++) { numE+=(1/(vector[i])). Dichos * métodos son print y println que están SOBRECARGADOS para los * tipos primitivos. int i=0.println("Numero e: "+Math. k=0. double numE=0.

determinando además el margen de error existente (e .104276835586006E-9 C:\java NumE 50 Valor Aproximado: Infinity Numero e: 2.. .valor aproximado) Modelos de Ejecución C:\java NumE Por favor ingrese el valor con el cual desea aproximarse al num E C:\java NumE 23 Valor Aproximado: 2. la cual tiende al número e cuando N tiende a infinito.+1/N! . Utilizamos un vector de n+1 elementos.71828182. Clases abstractas..718281828459045 Margen de error: -3. el método constructor y las variables necesarias. Por lo tanto en este programa se define la clase NumE.pos N --> N! ).. mediante la siguiente fórmula: 1/0! + 1/1! + .600057224024567E-9 C:\java NumE 30 Valor Aproximado: 2..Programas ejemplo....718281831563322 Numero e: 2... recorriéndolo mediante un bucle For y lo cargamos con el factorial correspondiente a cada posición (pos 0 --> 0!. } } } con el cual desea aproximarse al num E ").718281828459045 Margen de error: -Infinity 144 ... Posteriormente se calcula y se da salida al número aproximado obtenido...7182818330591023 Numero e: 2. Explicación del Algoritmo Existe una forma de aproximarse al número e = 2.718281828459045 Margen de error: -4..

se utiliza varias * veces con distintos tipos y/o número de argumentos. System.println("Numeros Reales")."va" int vd=(int)vc.println("El Mayor es:"+ Math.out. /*Programa 4 */ /** Este ejemplo compara un número ingresado por el usuario con * un valor aleatorio arrojado por la máquina determinando cual * es el mayor en términos de Enteros y Decimales * * Métodos Sobrecargados: * El Método "max" de la clase Math.Programas ejemplo.out. // "vc" alberga un valor determinado // aleatoriamente por la función random de la // clase Math double vc=(Math.se utiliza 2 veces con * argumentos de distintos tipos. System.out.out. // se transfiere a la variable entera "vb" el // valor real de precisión doble de la var.println("Usted ha ingresado el numero:" + vb). }catch(IndexOutOfBoundsException e){ System. * El Metodo "println" de la clase PrintStream.println("Numeros Enteros").out.println().out.vd)).} } } 145 .max(vb. System.out. System.println("Por Favor Ingrese un Numero"). System.out.vc)). System. System.println().println("La computadora ingreso el numero:"+ vd). //salida por pantalla System.max(va.parseDouble(arg[0]). System.out. System.println("El Mayor es:"+ Math.println("Usted ha ingresado el numero:" + va).out. */ 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.out. Clases abstractas.random()*100 int vb=(int)va.println("La computadora ingreso el numero:"+ vc).

226574387976019 El Mayor es:23.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.24044742541519 El Mayor es:60.Programas ejemplo.0 Numeros Enteros Usted ha ingresado el numero:23 La computadora ingreso el numero:11 El Mayor es:23 146 . Clases abstractas. Modelos de Ejecución 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.

Programas ejemplo. Clases abstractas.

Clases abstractas /** Programa 1 */ /** Una Clase Abstracta (abstract) es una clase de la que no se * pueden crear objetos. Su utilidad es permitir que otras clases * deriven de ella, proporcionándoles un modelo a seguir y * algunos métodos de utilidad general. */ abstract class LenguajesDeProgramacion { String[] nom=new String[4]; public abstract void detalle(); // método abstract(no se da su definición) } class Declarativos extends LenguajesDeProgramacion { final String tipo="Funcionales"; public void detalle() { nom[0] = "lisp"; nom[1] = "Hope"; nom[2] = "Miranda"; nom[3] = "Haskell"; System.out.println("Lenguajes Declarativos"); System.out.println("\n"+tipo); for (int i=0;i<4;i++) System.out.println(nom[i]); } } public class Abstractos { public static void main(String[] args) { Declarativos nombre = new Declarativos(); nombre.detalle(); } } Modelos de Ejecución C:\ java Abstractos Lenguajes Declarativos Funcionales lisp Hope Miranda Haskell

147

Programas ejemplo. Clases abstractas.

/**Programa 2 – versión 1*/ abstract class Vitamina { String alimento[]=new String[3]; public abstract void detalle(); } class A extends Vitamina{ public void detalle() { alimento[0]="vegetales";alimento[1]="Yema de Huevo"; alimento[2]="leche"; System.out.println("La vitamina A se encuentra en:"); for (int i=0;i<3;i++){ System.out.println(alimento[i]); } } } public class Medicina { public static void main(String[] args) { A vita = new A(); vita.detalle(); } }

Modelos de Ejecución C:\ java Medicina La vitamina A se encuentra en: vegetales Yema de Huevo Leche

148

Programas ejemplo. Clases abstractas.

/**Programa 2 – versión 2*/ abstract class Vitamina { String alimento[]=new String[3]; public abstract void detalle(); } class A extends Vitamina{ public void detalle() { alimento[0]="vegetales";alimento[1]="Yema de Huevo"; alimento[2]="leche"; System.out.println("La vitamina A se encuentra en:"); for (int i=0;i<3;i++){ System.out.println(alimento[i]); } } } class E extends Vitamina{ public void detalle() { alimento[0]="germen de trigo"; alimento[1]="aceite de soja"; alimento[2]="maiz"; System.out.println("\n"+"La vitamina E se encuentra en:"); for (int i=0;i<3;i++){ System.out.println(alimento[i]); } } } public class Medicina1 { public static void main(String[] args) { A vita = new A();vita.detalle(); E vita1 = new E();vita1.detalle(); } } Modelos de Ejecución 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

.

// se declara un vector "nom[]" de la clase String y se lo // inicializa con 3 posiciones } public abstract void detallar(). System.out.println(nom[i]). } } } public class Informatica1 { public static void detalle(Lenguajes m) { 151 .println("Lenguajes de Prog. System. for(int i=0. nom[2]="Haskell". System.i<3.Programas ejemplo. //clase HIJA (hereda la variable y método de la clase PADRE) class Objetos extends Lenguajes { public void detallar() { // se redefine como public el método detallar // (definido como abstract) nom[0]="C++".out.out.println("Lenguajes de Prog.out. for(int i=0. nom[1]="Prolog". */ //clase PADRE abstract class Lenguajes { String nom[]=new String[3].i<3. cuando utilizamos herencia podemos * terminar teniendo una familia de clases que comparten un * interfaz común. Polimorfismo /*Programa 1 – versión1 */ /** En muchas ocasiones.i++){ System.out.println(nom[i]).Orientados a Objetos"). nom[2]="Eiffell".Declarativos"). nom[1]="Java".println("\n").i++){ System. Polimorfismo. } } } //clase HIJA class Declarativos extends Lenguajes { public void detallar() { // se redefine como public el método detallar // (definido como abstract) nom[0]="Lisp".

// llama al método detalle pasando el objeto "leng1" // como argumento explícito detalle(leng2). // el método detalle utiliza un objeto "m" de la // clase Lenguajes m. Declarativo) */ Modelos de Ejecución Lenguajes de Prog. Polimorfismo. // crea un objeto "leng2" de la clase Declarativos detalle(leng1).*(primero llama a un leng.detallar(). Orientado a Objetos y luego a un * leng. // llama al método detalle pasando el objeto "leng2" // como argumento explícito } } /*el método detalle llama al método detallar ejecutándose las * sentencias que componen este último método para el objeto * especifico que lo llama.Declarativos Lisp Prolog Haskell 152 . // se llama al método detallar con un argumento // Implícito objeto.método } // método PRINCIPAL public static void main(String[] args) { Objetos leng1 = new Objetos(). // crea un objeto "leng1" de la clase Objetos Declarativos leng2= new Declarativos().Orientados a Objetos C++ Java Eiffell Lenguajes de Prog.Programas ejemplo.

private double altura.1416. } // redefinición del método area().Programas ejemplo. // valor que retorna al programa llamador } } class Cuadrado extends Figura{ private double lado.5*base*altura. } public double area(){ return 0. } } class Triangulo extends Figura{ private double base. double a){ base=b. // método constructor de la clase Circulo utiliza un // argumento pasado por referencia desde el método main // (principal) Circulo(double r){ radio=r. // var final: (constante) no puede cambiar su valor durante // la ejecución del prog. public double area(){ return pi*radio*radio. altura=a. // var private solo podrá ser utilizada por la clase // Círculo final double pi=3. /*Programa 2 – versión 1 */ /** CALCULA AREAS DE DISTINTAS FIGURAS (versión estática)*/ abstract class Figura{ abstract public double area(). Triangulo(double b. } public double area(){ return lado*lado. Cuadrado(double l){ lado=l. Polimorfismo. } } class polimorfismo{ // constructor principal (donde comienza la ejecución del // programa) 153 . } //clase abstracta class Circulo extends Figura{ //clase derivada de Figura private double radio.

println("Por Favor.out. // se crea un objeto de la clase "Triangulo" Circulo cir=new Circulo(m).out.out.println().out.parseDouble(args[2]).parseDouble(args[0]). System.println("Area "+tri.println("base: "+n1 + " altura: "+ System.println("lado: "+ñ).area()). System. System.parseDouble(args[1]). System.out.out.parseDouble(args[3]).out. } n2).println("CIRCULO"). double n2=Double. double ñ=Double. System.println("\n"+ "2do valor: Altura Triangulo"). }catch(ArrayIndexOutOfBoundsException e){ System.out. System.println(). Polimorfismo.out.Programas ejemplo. System. Cuadrado cua=new Cuadrado(ñ).out.println("CUADRADO").out.println("\n"+ "1er valor: Base Triangulo").println("radio: "+m). } } 154 . System.n2). // salida por pantalla a la información obtenida // en la ejecución del programa System. double m=Double.println("\n"+ "3er valor: Lado Cuadrado").println().ingrese 4 valores").out.println("Area "+cir.out.out.println("TRIANGULO"). System. System.area()). public static void main(String args[]){ // control de Excepciones producidas por el usuario try{ double n1=Double.out.out.out.area()).println(). System. System. System.out. System.println("Area: "+cua.println("\n"+ "4to valor: Radio Circulo"). System. Triangulo tri=new Triangulo(n1.

Programas ejemplo.0 Area 17.0 Area 12.0 CIRCULO radio: 2. Polimorfismo.5 CUADRADO lado: 8.5664 altura: 5. Modelos de Ejecución 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 155 .0 Area: 64.

double a){ base=b. } } class Triangulo extends Figura{ private double base. } // redefinición del método area().1416. } class Circulo extends Figura{ private double radio. /**Programa 2 – versión 2 */ /**CALCULAR AREA DE DISTINTAS FIGURAS (versión flexible)*/ abstract class Figura{ abstract public double area(). } } 156 . final double pi=3. Cuadrado(double l){ lado=l. } public double area(){ return 0. private double altura.5*base*altura. } public double area(){ return lado*lado. altura=a. 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. // método constructor de la clase Circulo // utiliza un argumento pasado por referencia desde el // método main(principal) Circulo(double r){ radio=r.Programas ejemplo. Polimorfismo. Triangulo(double b.

println("\n"+"Para calcular area de un: ").out. System.out.area()).out.println("TRIANGULO: ingrese 3 y los valores que desea darle a la Base y a la Altura"). case 2: Cuadrado cua=new Cuadrado(n1).out. System. System. System.out.parseInt(args[0]). System.println("\n"+"Para calcular area de un: ").out. System. // n1= 2º valor ingresado por el usuario int picture=Integer.println("Area "+cir. //picture = 1º valor ingresado por el usuario switch(picture){ case 1: Circulo cir=new Circulo(n1).out. System.out.out.println("\n"+"Desea calcular el area de otra figura?").println("\n"+"CIRCULO"). System.println("CUADRADO: ingrese 2 y el valor que desea darle al Lado"). Polimorfismo.area()). System.println("radio: "+n1). System.out.out. System.println("CIRCULO: ingrese 1 y el valor que desea darle al Radio").out.println("\n"+"Desea calcular el area de otra figura?").Programas ejemplo.println("CUADRADO ").parseDouble(args[1]). System. break.out. class Polimorfismo{ // constructor principal (donde comienza la ejecución del // programa) public static void main(String args[]){ // control de Excepciones producidas por el usuario try{ double n1=Double. System.println("CUADRADO: ingrese 2 y el valor que desea darle al Lado").println("Area: "+cua. System. System.println("lado: "+n1).out.out. System.println("TRIANGULO: ingrese 3 y los valores que desea darle a la Base y a la Altura"). break.println("CIRCULO: ingrese 1 y el valor que desea darle al Radio").out. 157 .

println("TRIANGULO"). break.println("\n"+"un CIRCULO"). } }catch(ArrayIndexOutOfBoundsException e){ System. Polimorfismo. System.println("1er valor: 2 " + "\t" + "2do valor: LADO CUADRADO").out. si desea calcular el area de:"). 3er valor: ALTURA TRIANGULO"). case 3: double n2=Double.println("\n"+"Ingrese 2 valores.area()).println("\n"+"Ingrese 3 valores.out.println("\n"+"un CUADRADO").out.println("CIRCULO: ingrese 1 y el valor que desea darle al Radio"). System. System. Triangulo tri=new Triangulo(n1.out.out.println("\n"+"un TRIANGULO"). System.println("Area "+tri.out.out.out.println("\n"+"Desea calcular el area de otra figura?"). System. System.println("CUADRADO: ingrese 2 y el valor que desea darle al Lado").out. System.out. System.println().println("\n"+"Para calcular area de un: ").out.println("1er valor: 1 " + "\t" + "2do valor: RADIO CIRCULO").parseDouble(args[2]). System. } } } /** Este programa interactúa con el usuario brindádole la * posibilidad de elegir de que figura desea calcular el área */ 158 .println("TRIANGULO: ingrese 3 y los valores que desea darle a la Base y a la Altura"). System. System.println("1er valor: 3 " + "\t" + "2do valor: BASE TRIANGULO.n2). System. System. si desea calcular el area de:").Programas ejemplo. System.out.out. System.out. System.out.out.out.println("base: "+n1 + " altura: "+ n2).

si desea calcular el area de: un TRIANGULO 1er valor: 3 2do valor: BASE TRIANGULO.0 Area 314. Polimorfismo.0 Area: 100. 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.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 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 . 3er valor: ALTURA TRIANGULO C:\java Polimorfismo 1 10 CIRCULO radio: 10.Programas ejemplo. Modelos de Ejecución C:\java Polimorfismo Ingrese 2 valores.

//define un método abstracto } // clase derivada de Verduras class Espinacas extends Verduras{ public void aporte(){ System.in.println("Los cítricos aportan vitamina C"). try { //espera la pulsación de una tecla y luego RETORNO System. /**Programa 3 */ /**subprograma 1*/ package polimorfismo.out.read(). que_aporta(tomate). Tomate tomate=new Tomate().Programas ejemplo. public abstract class Frutas { } class Citricos extends Frutas implements Vitaminas{ public void aporte(){ System. Polimorfismo. }catch (Exception e) { } } } static void que_aporta(Vitaminas alimento){ alimento.out. } /** subprograma 2*/ package polimorfismo. que_aporta(espi). } } 160 .aporte().println("Las Espinacas aportan vitamina B9"). public class Polimorfis { public static void main(String[] args) { Espinacas espi=new Espinacas(). } } /** subprograma 3*/ package polimorfismo. // clase Base implementa la interfaz Vitaminas public abstract class Verduras implements Vitaminas{ public abstract void aporte().

out. * Si solamente hubiese herencia simple. Polimorfismo. // clase derivada de Verduras class Tomate extends Verduras{ public void aporte(){ System. las cuales * incrementan el polimorfismo del lenguaje más allá del que * proporciona la herencia simple.Programas ejemplo. */ Modelos de Ejecución Las Espinacas aportan vitamina B9 El tomate aporta vitamina k 161 . public interface Vitaminas { public abstract void aporte(). pero * las clases pueden implementar interfases. Citricos tendría que * derivar de la clase Verduras (lo que no es lógico) o bien no * se podría pasar a la función que_aporta.println("El tomate aporta vitamina k"). * Esta es la razón por la cual las interfases proporcionan más * polimorfismo que el que se puede obtener de una simple * jerarquía de clases. } /* En el lenguaje Java solamente existe la herencia simple. cualquier clase en cualquier familia puede * implementar la interfase Vitaminas. * Con interfases. } } /** subprograma 4*/ package polimorfismo. y se podrá pasar un objeto * de dicha clase a la función "que_aporta".

.

varname. public Cuadrado(double lado){ this.PI*radio*radio. } } /* variables PROTECTED: sólo la clase en la que se define. * 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. public Circulo(double radio){ this. en la forma this. Ligaduras dinámicas /** Programa 1 */ /** Subprograma 1*/ package Figura. * mientras que radio es el argumento del constructor.lado=lado. public abstract class Figura { public abstract double area(). // variable miembro radio alberga el valor del // argumento radio } public double area(){ //redefine el método abstracto de la clase Base return Math. las * clases que deriven de ella y las clases del propio package * tienen permiso para utilizarlas. * Para acceder a la variable miembro oculta será preciso * utilizar el operador this.radio = radio. */ 163 . this. Ligaduras Dinámicas. //retorna el valor del área del círculo } } class Cuadrado extends Figura{ protected double lado.radio se refiere a la variable miembro.Programas ejemplo. * De esta forma. } public double area(){ return lado*lado. } class Circulo extends Figura{ protected double radio.

0 164 .in.println("las areas se calcularan con el valor: "+variable).566370614359172 cuadrado 9. System. // enlace tardío 1: tiempo de ejecución // valores predefinidos Figura f=new Circulo(2).read().Programas ejemplo. for(int p=0. fig[1]=new Circulo(variable).out.03317777109123 cuadrado 30. fig[0]=new Cuadrado(variable). /**Subprograma 2*/ package Figura.println("Area del circulo "+f.25 circulo 12. }catch (Exception e) {} } } Modelos de Ejecución C:\ java Area del Area del Area del Area del FiguraApp circulo 95. Cuadrado r=new Cuadrado(5.println("Area del cuadrado "+f. f=new Cuadrado(3).println("Area del circulo "+ c.out. int variable=System.area()).5).println("Area del cuadrado "+r. System.out. // toma el entero correspondiente a alt+variable System.out.out.p<2. Ligaduras Dinámicas.println(fig[p].p++) System. System.area()).area()). public class FiguraApp { public static void main(String[] args) { // enlace temprano: tiempo de compilación Circulo c=new Circulo(5.5). // enlace tardío 2 // valores ingresados por teclado try { Figura fig[]=new Figura[2].area()).area()). System.out.