MODULO

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA CONTENIDO MODULO DEL CUSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD

PROGRAMACION ORIENTA A OBJETOS

ING. CESAR ORLANDO JIMENEZ ANGARITA 2010

i


PROGRAMACIÒN ORIENTADA A OBJETOS

CESAR ORLANDO JIMENEZ ANGARITA

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD ESCUELA CIENCIAS BASICAS, TECNOLOGIA E INGENIERIA PROGRAMA DE INGENIERIA DE SISTEMAS 2010 CONTENIDO UNIDAD 1. INTRODUCCION A LA PROGRAMACION ORIENTADA A OBJETOS

ii


Lección 1 CAPÍTULO 1. CONCEPTOS BASICOS ORIENTADOS A OBJETOS 1.1. (TOMADO DEL LIBRO PROGRAMACIÓN DE COMPUTADORES DE JOSÉ CÁRCAMO SEPÚLVEDA, EDICIONES UIS). 1.2. ¿Que es un objeto? ............................................................................................. 1 Lección 2 1.3. Cada objeto tiene un conjunto de características o atributos que lo hacen diferente a los demás. ................................................................................................ 2 1.4. Inicialmente podríamos decir que un objeto es algo que tiene atributos y comportamientos propios. .......................................................................................... 2 Lección 3 1.5. ¿Podríamos hacer la representación de un objeto del mundo real? ................. 3 1.6. Tipo abstracto de datos........................................................................................ 3 Lección 4 1.7. Características de datos: Por ejemplo hora, minutos y segundos...................... 4 1.8. Para representar el objeto anterior debemos considerar tres aspectos ............. 5 Lección 5 1.9. ¿ Que es un mensaje? ........................................................................................ 5 1.10. Beneficios de la POO (tomado de monografías.com) ...................................... 6 1.11. Problemas derivados de la utilización de OOP en la actualidad (tomado de monografías.com) ....................................................................................................... 6 1.11.1. Curvas de aprendizaje largas. ....................................................................... 6 1.11.2. Dependencia del lenguaje ............................................................................. 7 1.11.3. Determinación de las clases .......................................................................... 7 1.11.4. Performance. .................................................................................................. 7 CAPITULO 2. INTRODUCCIÓN Y ELEMENTOS BÁSICOS DE PROGRAMACIÓN ORIENTADA A OBJETOS (POO) Lección 6 2.1 Introducción .......................................................................................................... 8 2.2 ¿Porqué POO? ..................................................................................................... 9 2.3 ¿Que es la POO? ............................................................................................... 10 Lección 7 2.4 Ventajas de POO ............................................................................................... 11 Lección 8 2.5. Desventajas de la tecnología orientada a objetos ........................................... 12 Lección 9 2.6 Evolución de la programación ............................................................................ 13 2.6.1. Programación lineal. ...................................................................................... 13 2.6.2. Programación Modular ................................................................................... 13 2.6.3. Programación Estructurada ........................................................................... 14 Lección 10 2.7. Comparación entre la Programación orientada a Objetos y la programación estructurada. ............................................................................................................. 14 2.7.1. Paradigma Estructurado ................................................................................ 14 2.7.2 Paradigma Orientado a Objetos ..................................................................... 16 2.7.2.1.Ventajas del Modelo orientado a objetos con respecto al modelo estructurado .............................................................................................................. 17 2.8 ACTIVIDADES COMPLEMENTARIAS ............................................................. 18

iii


CAPITULO 3. PROPIEDADES BÁSICAS DE LA PROGRAMACIÓN ORIENTADA A OBJETOS Lección 11 3.1 Abstracción ......................................................................................................... 19 Lección 12 3.2 Encapulación ...................................................................................................... 20 Lección 13 3.3 Moduaridad ......................................................................................................... 22 Lección 14 3.4 Jerarquia ............................................................................................................. 23 Lección 15 3.5 Polimrfismo ......................................................................................................... 24 3.6 Herencia ............................................................................................................. 25 3.6.1 Tipos de herencia ............................................................................................ 26 3.7 ACTIVIDADES COMPLEMENTARIAS ............................................................. 26 UNIDAD 2. ESTRUCTURA DE UN OBJETO - INTRODUCCION A JAVA CAPITULO 4. ANALISIS DE LA ESTRUCTURA Y COMPORTAMIENTO DE UN OBJETO Lección 16 4.1 Análisis de la Estructura de Objetos. .................................................................. 28 4.1.1 Objetos y Tipos de Objetos .............................................................................. 28 Lección 17 4.1.2 Asociaciones de Objetos.................................................................................. 28 Lección 18 4.1.3 Jerarquías de Generalización .......................................................................... 28 4.1.4 Jerarquías Compuestas. .................................................................................. 29 4.1.5 Diagramas de relación entre los objetos ......................................................... 29 4.1.6 Esquemas de Objetos. ..................................................................................... 30 4.2 Análisis del comportamiento de objetos ............................................................. 30 4.2.1 Estados de un Objeto....................................................................................... 30 4.2.2 Eventos ............................................................................................................. 31 4.2.3 Tipos de Eventos.............................................................................................. 31 4.2.4 El Ciclo Vital de un Objeto Objeto. .................................................................. 33 4.2.5 Interacciones entre tipos de objetos Objeto. ................................................... 33 4.2.6 Operaciones Objeto. ........................................................................................ 34 4.2.7 Fuentes externas de eventos Objeto............................................................... 35 4.2.8 Reglas deactivación Objeto. ............................................................................ 35 4.2.9 Condiciones de Control Objeto. ....................................................................... 35 4.2.10 Subtipos y Supertipos de Eventos Objeto. .................................................... 36 4.3 Diseño de la Estructura y Comportamiento de un Objeto Objeto. ..................... 37 4.3.1 Objeto Objeto. .................................................................................................. 37 4.3.2. Estructura de un Objeto. ................................................................................. 38 4.3.2.1.Componentes Objeto. ................................................................................... 39 Lección 19 4.3.3 Diferencia entre operación y método Objeto. .................................................. 40 4.3.4 Herencia de Clase. Objeto. .............................................................................. 41

iv


4.3.5 Herencia Múltiple. Objeto. ................................................................................ 41 Lección 20 4.3.6 Selección del Método Objeto. .......................................................................... 41 4.3.7 Polimorfismo Objeto. ........................................................................................ 42 4.3.8 Notación. Objeto............................................................................................... 42 4.4 ACTIVIDADES COMPLEMENTARIAS Objeto................................................... 44 CAPITULO 5. FUNDAMENTOS DE JAVA Lección 21 5.1 Introducción ........................................................................................................ 46 5.2 Características de Java ...................................................................................... 47 5.2.1 Diferencias Con C++ ....................................................................................... 50 5.3 Estructura de un programa en Java .................................................................. 51 5.3.1 Creación de un primer programa .................................................................... 53 5.3.1.1 Métodos de definición .................................................................................. 53 5.3.1.2 Palabras clave .............................................................................................. 54 Lección 22 5.3.2 Tipos de datos y declaraciones ...................................................................... 55 5.3.2.1 Tipos de datos simples ................................................................................ 55 5.3.3 Operadores y expresiones .............................................................................. 59 Lección 23 5.3.4 E/S caracteres: ................................................................................................ 62 Lección 24 5.3.5 Estructuras De Control .................................................................................... 64 5.3.5.1 Las sentencias condicionales: if y switch .................................................... 65 5.3.5.1.1 La sentencia if – else ................................................................................ 65 5.3.5.1.2. La sentencia switch .................................................................................. 66 5.3.5.2. Sentencias de iteración o bucles: for, do, while ......................................... 68 5.3.5.2.1 Bucle while ................................................................................................ 68 5.3.5.2.2 Bucle do-while ........................................................................................... 69 5.3.5.2.3 Bucle for .................................................................................................... 69 Lección 25 5.3.5.3 Sentencias de salto: break, continue y return ............................................. 71 5.3.5.3.1 Sentencia break ........................................................................................ 71 5.3.5.3.2 Sentencia continue .................................................................................... 72 5.3.5.3.3 Sentencia return ........................................................................................ 73 5.4 ACTIVIDADES COMPLEMENTARIAS ............................................................. 74 CAPITULO 6. GUIA DE LABORATORIO Lección 26 6.1. Caja de dialogo................................................................................................... 76 6.2. Programacion de arregos................................................................................... 78 6.3. Lectura de un vector por teclado .............................................................................. 79 6.4. Asignacion de un vector con numeros Aleatorios ............................................. 79 6.5. Ordenamiento de un Vector Método Lineal ....................................................... 80 6.6. Ordenamiento de un Vector Método Burbuja .................................................... 80 6.7. Busqueda de un elemento en un vector ordenado. Método Secuencial .......... 81 6.8. Busqueda de un elemento en un vector ordenado. Metodo Binaria ................ 82 6.9. Implementacion de clases que administran Arreglos........................................ 83

v


6.9.1. Prog 1. Creación de una clase Arreglo........................................................... 83 6.9.2. Prog2. Uso de un Objeto StringBuffer para la presentación de un vector ... 86 6.9.3. Programa 3. Invertir un Arreglo ...................................................................... 88 Lección 27 6.10. Proramacion avanzada. uso de matrices ........................................................ 90 6.10.2. Programa lectura y escritura de matrices .................................................... 91 6.10.3. Programa Suma de Diagonales y Transversales......................................... 92 6.10.4. Programa de Diagonal .................................................................................. 93 6.10.5. Programa de Copas ...................................................................................... 93 Lección 28 6.10.6. Programa Simulación de un Inventario ........................................................ 96 6.10.7. Programa Simulación de un Parqueadero .................................................. 97 Lección 29 6.11. Ejemplo Cola 1 ................................................................................................. 99 6.12. Ejemplo Cola 2 ............................................................................................... 101 6.13. Ejemplo Cola 4 ............................................................................................... 104 6.14. Ejemplo Cola 4 Archivo .................................................................................. 107 6.15. Ejemplo Lista .................................................................................................. 111 Lección 30 6.16. Ejemplo Lista Circular .................................................................................... 113 6.17. Ejemplo Lista y Cola....................................................................................... 115 6.18. Ejemplo Lista y Pila ........................................................................................ 117 6.19. Ejemplo Multilista ........................................................................................... 120 6.20. Ejemplo Pila .................................................................................................... 121 6.21. Ejemplo Arbol Binario ..................................................................................... 125 6.22. Ejemplo Arbol Binario ..................................................................................... 127 UNIDAD 3. CLASES Y HERENCIA EN LA PROGRAMACION ORIENTADA A OBJETOS CAPITULO 7. CLASES BASICAS EN LA POO Lección 31 7.1 Conceptos Básicos ........................................................................................... 133 7.1.1 Concepto de Clase ........................................................................................ 133 7.1.2 Características Importantes De Las Clases: ................................................ 134 7.1.3 Concepto de Interface ................................................................................... 134 7.2. Ejemplo De Definición De Una Clase ............................................................. 135 7.3. Variables miembro .......................................................................................... 136 7.3.1 Variables miembro de objeto ........................................................................ 137 7.3.2 Variables Finales ........................................................................................... 138 7.4 Abstracción ....................................................................................................... 139 7.5 Encapsulado ..................................................................................................... 140 7.6 Arreglos y cadenas ........................................................................................... 140 7.7 Flujo de E/S en java ......................................................................................... 141 Lección 32 7.8. Gestión De Excepciones Y Errores ................................................................ 142 7.8.1 Tipos de excepciones ................................................................................... 142 7.8.1.1 Herencia de excepciones Java .................................................................. 143 7.8.2 Funcionamiento ............................................................................................. 143

vi


7.8.2.1 Manejo de excepciones: try - catch – finally .............................................. 144 7.8.2.2. Lanzamiento de excepciones: throw – throws ......................................... 145 7.8.2.3 Ejemplo de gestión de excepciones .......................................................... 145 7.8.3 Los métodos .................................................................................................. 148 Lección 33 7.8.4 La instanciación de las clases: Los objetos ................................................. 149 7.8.4.1 Referencias a Objeto e Instancias ............................................................. 149 7.8.4.2 Constructores ............................................................................................. 150 7.8.4.3 El operador new ......................................................................................... 151 Lección 34 7.8.5. Acceso al objeto ........................................................................................... 152 7.8.5.1 El operador punto (.) .................................................................................. 152 7.8.5.2 La referencia this ........................................................................................ 153 Lección 35 7.8.6. La destrucción del objeto ............................................................................. 154 7.8.6.1 La destrucción de los objetos .................................................................... 154 7.8.6.2 La destrucción por defecto: Recogida de basura ...................................... 154 7.8.6.3 La destrucción personalizada: finalize ....................................................... 155 7.8.7 Herramientas De Java .................................................................................. 155 7.8.7.1 Paquetes de utilidades ............................................................................... 156 7.8.7.2 Paquetes para el desarrollo gráfico ........................................................... 156 7.8.7.3 Paquetes para el desarrollo en red ........................................................... 156 7.8. ACTIVIDADES COMPLEMENTARIAS .......................................................... 156 Lección 36 APITULO 8. HERENCIA 8.1 La Herencia ...................................................................................................... 158 8.2 Jerarquía ........................................................................................................... 158 8.3 Herencia múltiple .............................................................................................. 159 8.4 Declaración ....................................................................................................... 159 Lección 37 8.5 Limitaciones en la herencia ............................................................................. 160 8.6. La clase Object ................................................................................................ 161 Lección 38 8.7 Extensión De Clases ........................................................................................ 162 8.7.1 Composición De Objetos Extendido ............................................................. 162 8.7.1.1subclase ...................................................................................................... 162 8.7.2 Relación de tipo de herencia ........................................................................ 163 Lección 39 8.7.2.1 Métodos ...................................................................................................... 163 Lección 40 8.7.2.2 Sobrecarga De Método .............................................................................. 165 CAPITULO 9. EXTENSIÓN DE CLASES Lección 41 9.1. Applest Y Web ................................................................................................. 167 9.1.1 Applets ........................................................................................................... 167 9.1.2 HTML para Java ............................................................................................ 167 9.1.3 Protocolos Para Trabajo En La Red ............................................................. 167 Lección 42

vii


9.1.4 Que Es Un Applet .......................................................................................... 168 9.1.4.1 Consideraciones sobre la seguridad en las applets ................................. 169 Lección 43 9.1.5 La Clase Applet ............................................................................................. 170 9.1.5 .1 Situación de la clase Applet en la API de Java ........................................ 170 9.1.5.2 Métodos del ciclo de vida ........................................................................... 170 Lección 44 9.1.6 La Clase Url ................................................................................................... 172 9.1.7 Inclusión de la applet en una página Web ................................................... 172 9.1.7.1 Obtención de los parámetros de la applet ................................................. 173 9.1.7.2 Obtención de información sobre una applet ............................................. 174 9.1.7.3 Manipulación del entorno de una applet ................................................... 174 Lección 45 9.1.8 Ejemplo De Construcción De Una Applet ..................................................... 175 9.1.8.1 Código ........................................................................................................ 175 9.1.8.2 Ejecución .................................................................................................... 176 9.2 ACTIVIDADES COMPLEMETARIAS .............................................................. 176 CAPITULO 10. BIBLIOGRAFIA 10.1. Bibliografia .................................................................................................... 178 10.2. Bibliografia Sitios Web ................................................................................. 179

viii


UNIDAD 1. INTRODUCCION A LA PROGRAMACION ORIENTADA A OBJETOS Leección CAPÍTULO 1. CONCEPTOS BASICOS ORIENTADOS A OBJETOS 1.1. (Tomado del libro Programación de Computadores de José Cárcamo Sepúlveda, Ediciones UIS) Hoy por hoy es evidente que la orientación a objetos es el término más corriente en diversos entornos con actividades comerciales, industriales, de servicios y académicos. A través de esta técnica se logra la optimización en tareas concernientes a las fases de desarrollo de software como en el diseño, desarrollo y mantenimiento del software. Esto ha permitido ofrecer soluciones con larga opción de usabilidad atacando problemas concernientes a la denominada crisis del software. Lo anterior pensado teniendo en cuenta la existencia de procesos imprescindibles hoy en día como lo son la reutilización de código y su portabilidad. La Programación Orientada a Objetos se basa en la idea natural de la existencia de un mundo lleno de objetos y que la resolución del problema se realiza en términos de objetos, un lenguaje se dice que está basado en objetos si soporta objetos como una característica fundamental del mismo. Quizá al hablar de objetos se nos venga a la cabeza el cuento de los objetos voladores no identificados, aquí hablaremos de objetos pero no serán solo voladores, y seguro serán siempre plenamente identificados. La Programación Orientada a Objetos modela el mundo en términos de objetos, eventos y responsabilidades. Existen objetos que contienen datos y métodos y eventos que activa procedimientos , que pueden modificar el estado de los objetos. En los lenguajes orientados a objetos un programa, es un apropiado encadenamiento de mensajes entre distintos objetos, previamente instanciados de las clases a las que pertenecen. 1.2. Que es un objeto? Según el diccionario, un objeto es cualquier cosa que se ofrece a la vista y afecta los sentidos. Es así como podemos ver que el mundo real que nos rodea es un conjunto de objetos.

1


Si miramos a nuestro alrededor podemos observar plantas, animales, personas, cosas, etc. Estos son objetos tangibles. Existen otros que no son tangibles, pero somos conscientes de que existen, por ejemplo “un mes del ano”, “una hora de una cita”, un sentimiento, una profesión etc. Lección 2 1.3. Cada objeto tiene un conjunto de características o atributos que lo hacen diferente a los demás. Por ejemplo una planta difiere notablemente de un animal y de un edificio. Cada uno de ellos presentan características y comportamientos muy diferentes, mas aun aunque dos objetos sean exactamente iguales, son distintos entre si, por ejemplo dos carros recién salidos de la fabrica, que tienen la misma marca, el mismo modelo, la misma línea, las mismas características, son dos objetos distintos pues cada uno tiene una identificación diferente, aunque pertenecen a la misma clase. 1.4. Inicialmente podríamos decir que un objeto es algo que tiene atributos y comportamientos propios. Una planta es un ser viviente, vegetal que a primera vista esta construido por hojas, tallos, frutos, raíz, etc. Además respira por sus hojas, se alimenta por su raíz, elabora clorofila etc. Son algunas de las características y comportamiento que podemos percibir superficialmente de una planta. Un diccionario es un libro especial que contiene un conjunto de palabras y definiciones, también podemos encontrar en el graficas, tablas, ilustraciones, etc. Y su utilidad la percibimos cuando necesitamos consultar alguna palabra, leer su significado, verificar su ortografía, o de pronto investigar sobre algún tema especifico. Lección 3 1.5. ¿Podríamos hacer la representación de un objeto del mundo real?

2


¿Por ejemplo el amor? ¿La alegría?. Quizá nos sea difícil en los objetos abstractos, pero de una u otra forma lograríamos hacerlo. Desde el punto de vista computacional es posible representar lógicamente cualquier objeto del mundo real. Para una solución software un objeto es un elemento especial de información que se construye a partir de una estructura de datos y una estructura funcional.

ESTRUCTURA DE DATOS ESTRUCTURA FUNCIONAL

La estructura funcional opera directamente sobre la estructura de datos y esta a su vez solo puede ser manipulada por la estructura funcional del mismo objeto. En la programación estructurada la estructura de datos es totalmente independiente de la parte funcional o procedimental; es mas podríamos afirmar que lo único estructurado en la “programación estructurada” son los procedimientos pero los datos están muy aislados. La programación orientada a objetos se acerca mas al mundo real estructurando en un mismo elemento de información datos y procedimientos. 1.6. Tipo abstracto de datos En la terminología de organización de la información muchas veces se manejan los términos “estructura de datos” y “tipo abstracto de datos” como una misma cosa . Sin embargo, para muchos autores, existe una diferencia entre los dos términos. Aparece entonces un nuevo elemento de información que se denomina “tipo abstracto de datos”. Un tipo abstracto de datos contienen una estructura de datos propia y un conjunto de operaciones o métodos autorizados para manipular la estructura de datos. Para representar a un objeto recurrimos a un tipo abstracto de datos. Por ejemplo tomemos un objeto del mundo real cotidiano que nos rodea. Imaginemos un objeto RELOJ, encontramos en el unas características a nivel de datos (estructuras de datos) y unas características de comportamiento (características funcionales). Lección 4 1.7. Características de datos: Por ejemplo hora, minutos y segundos Características funcionales: Por ejemplo mostrar la hora, actualizar la hora y siendo mas ambiciosos mostrar la hora en segundos, mostrar la hora en minutos o sumar y restar horas.

3


Representemos este objeto del mundo real Quedaría de la siguiente forma: ESTRUCTURA DE DATOS  Hora 

Minutos



Segundos

como un tipo abstracto de datos.

ESTRUCTURA FUNCIONAL  Leer hora 

Mostrar hora



Mostrar hora en segundos



Mostrar hora en minutos



Sumar hora



Restar hora

1.8. Para representar el objeto anterior debemos considerar tres aspectos 1. ¿Cómo representar la estructura de datos? Identificar las características del objeto a nivel de datos. Horas. Minutos. Segundos 2. ¿Cómo representar su comportamiento? Identificar las operaciones o procesos a efectuar sobre los datos Leer hora Mostrar hora Mostrar hora en segundos, etc.

4


3. ¿Cómo comunicarnos con el objeto? Para comunicarnos con el objeto debemos enviarle un mensaje. Lección 5 1.9. Que es un mensaje? Según el diccionario, un mensaje es un encargo de decir o llevar una cosa. Más puntualmente, podemos definir un mensaje como el llamado que se hace a un objeto para que ejecute una de sus operaciones. Para que el objeto funcione se le debe enviar un mensaje adecuado, que sea identificado por el mismo objeto. En el ejemplo del reloj podemos enviarle un mensaje para que nos muestre la hora: MENSAJE: “Mostrar hora”, es un mensaje identificable por el objeto por que puede invocar una operación propia del mismo. MENSAJE: “Mostrar fecha”, resulta desconocido para el objeto por que no existe ninguna operación asociada a el. Los objeto ofrecen al mundo que lo rodea una puerta de entrada que es la que permite determinar si el mensaje es adecuado o no. A esta puerta de entrada se le denomina “interfaz de objeto” El mensaje llega a la interfaz de objeto solicitando una operación y si este se ajusta a una forma de llamado conocida, el objeto actúa.

1.10. Beneficios de la POO (tomado de monografías.com) Día a día los costos del Hardware decrecen. Así surgen nuevas áreas de aplicación cotidianamente: procesamiento de imágenes y sonido, bases de datos multimediales, automatización de oficinas, ambientes de ingeniería de software, etc. Aún en las aplicaciones tradicionales encontramos que definir interfaces hombre-máquina "a-laWindows" suele ser bastante conveniente. Lamentablemente, los costos de producción de software siguen aumentando; el mantenimiento y la modificación de sistemas complejos suele ser una tarea trabajosa; cada aplicación, (aunque tenga aspectos similares a otra) suele encararse como un proyecto nuevo, etc. Todos estos problemas aún no han sido solucionados en forma completa. Pero como los objetos son portables (teóricamente) mientras que la herencia permite la reusabilidad del código orientado a objetos, es más sencillo modificar código existente porque los objetos no interaccionan excepto a través de mensajes; en consecuencia un cambio en la codificación de un objeto no afectará la operación con otro objeto siempre que los métodos respectivos permanezcan intactos. La introducción de tecnología de objetos como una herramienta conceptual para analizar, diseñar e implementar aplicaciones permite obtener aplicaciones más modificables, fácilmente extensibles y a partir de componentes reusables. Esta reusabilidad del código

5


disminuye el tiempo que se utiliza en el desarrollo y hace que el desarrollo del software sea mas intuitivo porque la gente piensa naturalmente en términos de objetos más que en términos de algoritmos de software. 1.11. Problemas derivados de la utilización de OOP en la actualidad (tomado de monografías.com) Un sistema orientado a objetos, por lo visto, puede parecer un paraíso virtual. El problema sin embargo surge en la implementación de tal sistema. Muchas compañías oyen acerca de los beneficios de un sistema orientado a objetos e invierten gran cantidad de recursos luego comienzan a darse cuenta que han impuesto una nueva cultura que es ajena a los programadores actuales. Específicamente los siguientes temas suelen aparecer repetidamente: 1.11.1. Curvas de aprendizaje largas. Un sistema orientado a objetos ve al mundo en una forma única. Involucra la conceptualización de todos los elementos de un programa, desde subsistemas a los datos, en la forma de objetos. Toda la comunicación entre los objetos debe realizarse en la forma de mensajes. Esta no es la forma en que están escritos los programas orientados a objetos actualmente; al hacer la transición a un sistema orientado a objetos la mayoría de los programadores deben capacitarse nuevamente antes de poder usarlo. 1.11.2. Dependencia del lenguaje. A pesar de la portabilidad conceptual de los objetos en un sistema orientado a objetos, en la práctica existen muchas dependencias. Muchos lenguajes orientados a objetos están compitiendo actualmente para dominar el mercado. Cambiar el lenguaje de implementación de un sistema orientado a objetos no es una tarea sencilla; por ejemplo C++ soporta el concepto de herencia múltiple mientras que SmallTalk no lo soporta; en consecuencia la elección de un lenguaje tiene ramificaciones de diseño muy importantes. 1.11.3. Determinación de las clases. Una clase es un molde que se utiliza para crear nuevos objetos. En consecuencia es importante crear el conjunto de clases adecuado para un proyecto. Desafortunadamente la definición de las clases es más un arte que una ciencia. Si bien hay muchas jerarquías de clase predefinidas usualmente se deben crear clases específicas para la aplicación que se este desarrollando. Luego, en 6 meses ó 1 año se da cuenta que las clases que se establecieron no son posibles; en ese caso será necesario reestructurar la jerarquía de clases devastando totalmente la planificación original. 1.11.4. Performance.

6


En un sistema donde todo es un objeto y toda interacción es a través de mensajes, el tráfico de mensajes afecta la performance. A medida que la tecnología avanza y la velocidad de micro procesamiento, potencia y tamaño de la memoria aumentan, la situación mejorará; pero en la situación actual, un diseño de una aplicación orientada a objetos que no tiene en cuenta la performance no será viable comercialmente. Idealmente, habría una forma de atacar estos problemas eficientemente al mismo tiempo que se obtienen los beneficios del desarrollo de una estrategia orientada a objetos. Debería existir una metodología fácil de aprender e independiente del lenguaje, y fácil de reestructurar que no drene la performance del sistema.

7


CAPITULO 2. INTRODUCCIÓN Y ELEMENTOS BÁSICOS DE PROGRAMACIÓN ORIENTADA A OBJETOS (POO) Lección 6 2.1. Introducción Actualmente una de las áreas más importantes en la industria y el ámbito académico es la orientación a objetos. La orientación a objetos promete mejoras de amplio alcance en la forma de diseño, desarrollo y mantenimiento del software ofreciendo una solución a largo plazo a los problemas y preocupaciones que han existido desde el comienzo en el desarrollo del software: la falta de portabilidad del código y reusabilidad, código que es difícil de modificar, ciclos de desarrollo largos y técnicas de codificación no intuitivas. Un lenguaje orientado a objetos ataca estos problemas. Tiene tres características básicas: debe estar basado en objetos, basado en clases y capaz de tener herencia de clases. Muchos de los lenguajes pueden cumplir uno o dos de estos puntos, pero es muy difícil que se cumplan los tres, el inconveniente mas complicado de diseñar es la herencia. El concepto de programación orientada a objetos (POO) no es nuevo, lenguajes clásicos como SmallTalk se basan en ella. Dado que la POO, se basa en la idea natural de la existencia de un mundo lleno de objetos y que la resolución del problema se realiza en términos de objetos. Un lenguaje se dice que está basado en objetos si soporta como una característica fundamental del mismo. El elemento fundamental de la POO es, como su nombre lo indica, el objeto. Podemos definir un objeto como un conjunto complejo de datos y programas que poseen una estructura y forman parte de una organización. Esta definición especifica varias propiedades importantes de los objetos. En primer lugar, un objeto no es un dato simple, sino que contiene en su interior cierto número de componentes bien estructurados. En segundo lugar, cada objeto no es un ente aislado, sino que forma parte de una organización jerárquica o de otro tipo. Básicamente la POO permite a los programadores escribir software, de forma que esté organizado en la misma manera que el problema que trata de modelar. Los lenguajes de programación convencionales son poco más que una lista de acciones a realizar sobre un conjunto de datos en una determinada secuencia. Si en algún punto del programa modificamos la estructura de los datos o la acción realizada sobre ellos, el programa cambia. 2.2 ¿Porqué POO? Es una manera de pensar, otra manera de resolver un problema; lo más reciente en metodologías de desarrollo de software. Es un proceso mental humano aterrizado en una computadora.

8


Antes se adecuaba el usuario al entendimiento de la computadora. Actualmente, se le enseña a la computadora a entender el problema. La Orientación a Objetos es un paradigma, es decir, es un modelo para aclarar algo o para explicarlo. La Orientación a Objetos es el paradigma que mejora el diseño, desarrollo y mantenimiento del software ofreciendo una solución a largo plazo a los problemas y preocupaciones que han existido desde el comienzo del desarrollo del software: La falta de portabilidad del código, su reusabilidad, la modificación (que antes era difícil de lograr), ciclos de desarrollo largo, técnicas de programación no intuitivas.

La Orientación a Objetos está basada en los tres métodos de organización que utilizamos desde la infancia; entre un objeto y sus atributos (automóvil > marca, color, número de llantas, etc.); Entre un objeto y sus componentes donde incluso otros objetos pueden formar parte de otros objetos (agregación) (camión > motor, parabrisas, llantas); entre un objeto y su relación con otros objetos (camión > vehículos automotores; una bicicleta no entraría en esta relación). La metodología del software orientado a objetos consiste en:  Saber el espacio del problema Realizar una abstracción Crear los objetos (espacio de la solución) Instanciarlos (esto es, traerlos a la vida) Dejarlos vivir (ellos ya saben lo que tienen

que hacer)

Las herramientas de programación orientadas a objetos ayudan a manejar la complejidad. Desarrollar software que sea fácil de utilizar hace que sea muy compleja su construcción. El diseño del nuevo software se enfoca a complejas interfaces de usuarios, sistemas de manejo de ventanas, y programas multitarea están haciendo que el software sea cada vez mas complejo. Las herramientas enfocadas a objetos facilitan la comprensión de esta complejidad, la estructuración orientada a objetos reduce el número de conexiones entre los componentes del sistema, obligar a que los objetos se comuniquen a través de una interfaz pública estrecha hace más fácil aislar los errores ocultos y determinar cuales son los métodos responsables de los errores ocultos que ocurran. Los objetos mismos protegen los datos privados de modificaciones no deseadas. La definición explicita de un protocolo de comunicación permite a compiladores e intérpretes advertir a los usuarios acerca de los accesos ilegales e incluso impedir la modificación no deseada de los componentes del sistema. Una de las mayores ventajas de una estructura orientada a objetos es el mapeo directo de los objetos en el dominio del problema a los objetos en el programa.

9


Este mapeo directo es una consecuencia de tener una estructura basada en objetos. Si la programación se considera una simulación, resulta mucho más fácil seleccionar objetos de un mundo simulado que desarrollar una solución de programación basada completamente en procedimientos y acciones. La orientación a objetos surgió de la necesidad de simular sistemas de forma sencilla, no solo de información, si no de cualquier otro tipo, sin importar el modo de implantación. 2.3 ¿Que es la POO? La Programación Orientada a Objetos (POO ú OOP según siglas en inglés) es una metodología de diseño de software y un paradigma de programación que define los programas en términos de "clases de objetos", objetos que son entidades que combinan estado (es decir, datos) y comportamiento (esto es, procedimientos o métodos). La programación orientada a objetos expresa un programa como un conjunto de estos objetos, que se comunican entre ellos para realizar tareas. Esto difiere de los lenguajes procedimentales tradicionales, en los que los datos y los procedimientos están separados y sin relación. Estos métodos están pensados para hacer los programas y módulos más fáciles de escribir, mantener y reutilizar. Otra manera en que esto es expresado a menudo, es que la programación orientada a objetos anima al programador a pensar en los programas principalmente en términos de tipos de datos, y en segundo lugar en las operaciones ("métodos") específicas a esos tipos de datos. Los lenguajes procedimentales animan al programador a pensar sobre todo en términos de procedimientos, y en segundo lugar en los datos que esos procedimientos manejan. Los programadores que emplean lenguajes procedimentales, escriben funciones y después les pasan datos. Los programadores que emplean lenguajes orientados a objetos definen objetos con datos y métodos y después envían mensajes a los objetos diciendo que realicen esos métodos en sí mismos. Algunas personas también diferencian la POO sin clases, la cual es llamada a veces programación basada en objetos. Hay un cierto desacuerdo sobre exactamente que características de un método de programación o lenguaje le califican como "orientado a objetos", Término de Programación Orientada a Objetos indica más una forma de diseño y una metodología de desarrollo de software que un lenguaje de programación, ya que en realidad se puede aplicar el Diseño Orientado a Objetos (En inglés abreviado OOD, Object Oriented Design), a cualquier tipo de lenguaje de programación. El desarrollo de la POO empieza a destacar durante la década de lo 80 tomando en cuenta la programación estructurada, a la que engloba y dotando al programador de nuevos elementos para el análisis y desarrollo de software. Se puede definir POO como una técnica o estilo de programación que utiliza objetos como bloque esencial de construcción.

10


Los objetos son en realidad como los tipos abstractos de datos. Un TAD es un tipo definido por el programador junto con un conjunto de operaciones que se pueden realizar sobre ellos. Se denominan abstractos para diferenciarlos de los tipos de datos fundamentales o básicos. Lección 7 2.4 Ventajas de POO La OOP proporciona las siguientes ventajas sobre otros lenguajes de programación Uniformidad. Ya que la representación de los objetos lleva implica tanto el análisis como el diseño y la codificación de los mismos. Comprensión. Tanto los datos que componen los objetos, como los procedimientos que los manipulan, están agrupados en clases, que se corresponden con las estructuras de información que el programa trata. Flexibilidad. Al tener relacionados los procedimientos que manipulan los datos con los datos a tratar, cualquier cambio que se realice sobre ellos quedará reflejado automáticamente en cualquier lugar donde estos datos aparezcan. Estabilidad. Dado que permite un tratamiento diferenciado de aquellos objetos que permanecen constantes en el tiempo sobre aquellos que cambian con frecuencia permite aislar las partes del programa que permanecen inalterables en el tiempo. Reusabilidad. La noción de objeto permite que programas que traten las mismas estructuras de información reutilicen las definiciones de objetos empleadas en otros programas e incluso los procedimientos que los manipulan. De esta forma, el desarrollo de un programa puede llegar a ser una simple combinación de objetos ya definidos donde estos están relacionados de una manera particular. Reutilización. Las clases se construyen a partir de otras clases. Sistemas más fiables. Proceso de desarrollo apropiado. Desarrollo más flexible. Modelos que reflejan mejor la realidad. Mejor independencia e interoperatividad de la tecnología. Mejor informática distribuida en cliente – servidor. Bibliotecas de clases comerciales disponibles. Mejores relaciones con los clientes. Mejor calidad del producto de software terminado. Lección 8 2.5. Desventajas de la tecnología orientada a objetos. A pesar de que las ventajas de la programación orientada a objetos superan a las limitaciones de la misma, podemos encontrar algunas características no deseables en ésta.

11


Limitaciones para el programador. No obstante que la tecnología orientada a objetos no es nueva, un gran porcentaje de programadores no están familiarizados con los conceptos de dicha tecnología. En otras palabras, la lógica de la programación estructurada sigue siendo predominante en la mayoría de los desarrolladores de software, después de haber revisado de forma breve los principios de la programación orientada a objetos, nos es claro que en ésta se requiere una lógica de pensamiento totalmente diferente a la lógica comúnmente utilizada para la programación estructurada. Tamaño excesivo en las aplicaciones resultantes. La gran mayoría de los equipos de cómputo cuentan con capacidades tanto de almacenamiento como de memoria lo suficientemente buena como para ejecutar la mayoría de las aplicaciones que puedan desarrollarse con la tecnología orientada a objetos, sin embargo existen casos en los que lo anterior no se cumple. Una de las desventajas de la programación orientada a objetos es que cuando se heredan clases a partir de clases existentes se heredan de forma implícita todos los miembros de dicha clase aun cuando no todos se necesiten, lo que produce aplicaciones muy grandes que no siempre encajan en los sistemas con los que se disponga. Velocidad de ejecución. Esto tiene que ver, en cierto modo, con el punto anterior, una aplicación innecesariamente pesada en muchas ocasiones es más lenta de ejecutar que una aplicación conformada únicamente por los módulos necesarios. Lección 9 2.6 Evolución de la programación POO (Programación Orientada a Objetos)es un importante conjunto de técnicas que se pueden utilizar para hacer el desarrollo de programas más eficientes mientras se mejora la facilidad de los programas resultantes. En esencia, POO es un nuevo medio de enfocar el trabajo de programación. Sin embargo, a fin de comprender lo que es la POO, es necesario comprender sus raíces. Así pues, comenzaremos por examinar la historia del proceso de programación analizada cómo evolución POO y deduciendo, en consecuencia, por qué es tan importante este concepto. 2.6.1. Programación lineal. Los lenguajes de programación lineal (BASIC, COBOL Y FORTRAN) no tenían facilidad para reutilizar el código existente de programas. De hecho se duplicaban segmentos de software cada vez más en muchos programas. Los programas se ejecutaban en secuencias lógicas, haciendo la lógica difícil de comprender. El control de programas era difícil y se producían continuos saltos a lo largo del referido programa. Aún más, los lenguajes lineales no tenían capacidad de controlar la visibilidad de los elementos llamados datos. 2.6.2. Programación Modular

12


El soporte más elemental de la programación Modular llegó con la aparición de la subrutina. Una subrutina ha creado una secuencia de instrucciones a las que se les da un nombre independiente; una vez que se ha definido, la subrutina se puede ejecutar simplemente incluyendo el nombre del programa siempre que se requiera. Las subrutinas proporcionan una división natural de las tareas; diferentes programas utilizan. Aunque las subrutinas proporcionan el mecanismo básico de la programación Modular, se necesita mucha disciplina para crear software bien estructurado. Sin esta disciplina, es fácil escribir programas compilados y tortuosos difíciles de modificar y comprender, así como imposible de mantener. Esta ha sido la panorámica durante muchos años en el desarrollo del software. 2.6.3. Programación Estructurada. Un concepto importante en campo de la programación Estructurada: Abstracción, ya que la Abstracción se puede definir como la capacidad de examinar algo sin preocuparse de los detalles internos. En un programa estructurado, es suficiente conocer que un procedimiento sea fiable, para que se pueda utilizar sin tener que conocer cómo funciona su interior. Esto se conoce como una Abstracción funcional y es el núcleo de la programación estructurada. Hoy casi todos los lenguajes de programación tienen construcciones que facilitan la programación estructurada. Lección 10 2.7. Comparación entre la Programación orientada a Objetos y la programación estructurada. 2.7.1. Paradigma Estructurado La Programación estructurada fija su atención en el conjunto de acciones que manipulan el flujo de datos, mientras que la POO se fija en la interrelación que existe entre los datos y las acciones a realizar con ellos. Descomposición funcional: el sistema es considerado una unidad funcional que se disgrega en procesos El resultado del proceso de abstracción para la solución de un problema macro lo constituyen pequeños subprogramas Un problema macro se subdivide en unidades más pequeñas llamadas procesos, estos se pueden distribuir entre diferentes personas que se vean involucradas en la solución de un problema y así efectuar los desarrollos de software de una manera más rápida y eficiente. Figura 1.1 Programación Estructurada Los procesos son la parte central de este modelo pues a partir de estos se manejan las variantes (datos) que solucionarán el problema. Generalmente se manejan muchos procesos lo cual hace largos códigos. El mantenimiento de los desarrollos deben efectuarse minuciosamente.

13


Los procedimientos empleados en una aplicación pueden reutilizarse teniendo cuidado en el manejo de los datos. Las operaciones se ajustan a las características propias de los lenguajes procedimentales. Los procesos que se modelan en el desarrollo de un problema plasman las operaciones necesarias para resolverlo

Los procesos son la parte central de este modelo pues a partir de estos se manejan las variantes (datos) que solucionarán el problema. Generalmente se manejan muchos procesos lo cual hace largos códigos. El mantenimiento de los desarrollos deben efectuarse minuciosamente. Los procedimientos empleados en una aplicación pueden reutilizarse teniendo cuidado en el manejo de los datos. Las operaciones se ajustan a las características propias de los lenguajes procedimentales. Los procesos que se modelan en el desarrollo de un problema plasman las operaciones necesarias para resolverlo

14


2.7.2 Paradigma Orientado a Objetos Descomposición en objetos. El sistema es considerado un objeto o conjunto de objetos. Los cuales son el resultado del proceso de abstracción para la solución del problema macro. Dado que un problema macro puede ser dividido en objetos, estos pueden ser tratados por diferentes personas que luego lo integraran para dar la solución final.

Los datos (estados) son la parte central del modelo y los métodos que los modifican muestran el comportamiento del objeto.

15


El mantenimiento de programas y aplicaciones generalmente son fáciles de realizar . Los objetos que se modelan en el desarrollo de un sistema se ajustan a la realidad que representa el problema, este puede representare como un objeto o conjunto de objetos abstractos. El modelo orientado a objetos no es una técnica de programación sino un medio de plasmar el mundo real.

Adición: Producto Punto: Producto Cruz:

R = A + B, R =(a1 + b1, a2 + b2, a3 + b3) R = A . B, R =(a1 .b1 + a2 .b2 + a3 .b3) R = A x B, R =(a2*f3-a3*b2, a3*b1-a1*b3, a1*b2- a2*b1)

Producto por escalar: Normal:

R = k A, R = ( ka1, ka2, ka3 ) R = /R/I, R = Raíz cuadrada de (A * A) Figura 1.4 Objeto

2.7.2.1.Ventajas del Modelo orientado a objetos con respecto al modelo estructurado Un modelo de objetos es más cercano a la realidad que un modelo funcional. Un desarrollo realizado con el modelo orientado a objetos es más fácil de mantener y de reutilizar. El modelo orientado a objetos evita la redundancia en los procesos luego los códigos son más entendibles y resumidos. La integridad que dan los objetos a los datos evita ambigüedades en su uso, dando mayor seguridad en los resultados. El modelo orientado a objetos facilita la integridad de módulos que hallan sido realizados por separado sin correr riesgos en el manejo de los datos.

16


Autoevaluación 2.8 ACTIVIDADES COMPLEMENTARIAS Pate Uno: 1. Investigue la diferencia entre la POO y la Programación estructurada? 2. Que es la POO? Y cuales son sus ventajas? 3. Que es una clase y Que es un objeto? 4. Explique cual es la estructura de un objeto? 5. Realice un ejemplo de manera grafica en donde se identifiquen los elementos de una clase y un objeto. 6. Ver Capitulo 9 Guia de Laboratorios para desarrollar en los laboratorios del CEAD o CERES respectivos Parte Dos: Realizar los ejercicos complementarios de Laboratorios de la Guia de Laboratotios y Consultar Bibliografia de Libros Virtual de la Unad y otros Autores 1. Autor: Deitel y Deitel Introducción DOO con UML y los Patrones de Diseño JDBC tm, SERVLETS, JSP tm Editorial Pearson Prentice Hall Quinta Edición, 2. David Arnow Gerald Weiss Introducción a la Programación con Java tm Actualización a la Versión 2 de Java Editorial Addison Wesley 3. Fcd Javier Ceballos Java 2 Curso de Programación 2 Edición Editorial Alfaomega Ra-Ma 4. Agustin Froute Java 2 Manual Usuario tutorial 3 Edición Editorial Alfaomega Ra-Ma 5. Herbert shildt Fundamentos de Programación Java 2 Editorial Mc Graw Hill . para conocer el lenguaje de programación JAVA ya que están resueltos solo los puede digitar compilar y ejecutar en la casa o laboratorio de su correspondiente CEAD o CERES.

17


Lección 11 CAPITULO 3. PROPIEDADES BÁSICAS DE LA PROGRAMACIÓN ORIENTADA A OBJETOS La programación orientada a objetos, ha tomado las mejores ideas de la programación estructurada y los ha combinado con varios conceptos nuevos y potentes que incitan a contemplar las tareas de programación desde un nuevo punto de vista. La programación orientada a objetos, permite descomponer más fácilmente un problema en subgrupos de partes relacionadas del problema. Entonces, utilizando el lenguaje se pueden traducir estos subgrupos a unidades auto contenidas llamadas objetos. El término Programación Orientada a Objetos (POO), hoy en día ampliamente utilizado, es difícil de definir, ya que no es un concepto nuevo, sino que ha sido el desarrollo de técnicas de programación desde principios de la década de los setenta, aunque sea en la década de los noventa cuando ha aumentado su difusión, uso y popularidad. No obstante, se puede definir POO como una técnica o estilo de programación que utiliza objetos como bloque esencial de construcción. Un objeto es una unidad que contiene datos y las funciones que operan sobre esos datos. A los elementos de un objeto se les conoce como miembros; las funciones que operan sobre los objetos se denominan métodos y los datos se denominan miembros datos. Lección 12 3.1 Abstracción Cada objeto en el sistema sirve como modelo de un "agente" abstracto que puede realizar trabajo, informar y cambiar su estado, y "comunicarse" con otros objetos en el sistema sin revelar cómo se implementan estas características. Los procesos, las funciones o los métodos pueden también ser abstraídos y cuando los están, una variedad de técnicas son requeridas para ampliar una abstracción. La abstracción es una especificación del sistema que enfatiza sobre algunos de los detalles o propiedades del mismo mientras suprime a otros. Una buena abstracción es aquella que enfatiza sobre detalles significativos al lector y al usuario y suprime detalles que son al menos por el momento irrelevantes o que causan distracción. Existen cuatro tipos de abstracciones: La primera es la abstracción de entidades; este tipo de abstracción representa una entidad ya sea del dominio del problema o del dominio de la solución. El segundo tipo de abstracción es la abstracción de acciones, es la abstracción de comportamiento, esta abstracción proporciona un conjunto especializado de operaciones y todas ellas desempeñan funciones del mismo tipo.

18


El tercer tipo de abstracción es el de maquinas virtuales, este tipo de abstracción agrupa operaciones virtuales utilizadas por un nivel superior de control u operaciones que utilicen un conjunto de operaciones de nivel inferior. Por ejemplo, una abstracción que utilice el código "x" cuando la aplicación se ejecute en Latinoamérica, o utilice el código "y" cuando se ejecute el Norteamérica. El último tipo de abstracción es el de coincidencia, que almacena un conjunto de operaciones que no tienen relación entre sí, esto es, toma actividades que aparentemente no tienen una relación como las clases hombre (con métodos como come(), camina(), etc.), las clases transporte aéreo (volar()) y ave (volar()) y creamos una subclase de hombre llamada superhombre que come(), camina() y vuela(); esto se logra tomando comportamientos que no tienen que ver entre sí y no se atribuyen a la herencia sino a la interfaz. Padre Interfaz \/ Hijo Por definición una interfaz es abstracta, por lo tanto no tiene un comportamiento, sólo la declaración de este. Lección 13 3.2 Encapsulación También llamada "ocultación de la información", esto asegura que los objetos no pueden cambiar el estado interno de otros objetos de maneras inesperadas; solamente los propios métodos internos del objeto pueden acceder a su estado.

Cada tipo de objeto expone una interfaz a otros objetos que especifica cómo otros objetos pueden interactuar con él. Algunos lenguajes resaltan esto, permitiendo un acceso directo a los datos internos del objeto de una manera controlada y limitando el grado de abstracción. La encapsulación protege los atributos que conforman al objeto, y permite o niega información al público. Con el encapsulamiento, se consigue ocultar información y

19


ocultar todos los secretos de un objeto que no contribuyen a sus características esenciales, típicamente la estructura de un objeto se encuentra oculta y la implantación de sus métodos es visible. Para el caso del termómetro tal vez sólo se requieren 3 métodos: activarlo, desactivarlo y pedirle la temperatura. Un objeto es la abstracción de algo que forma parte del dominio del problema reflejando las posibilidades de un sistema para mantener la información sobre él. Representa una entidad real o abstracta con un papel bien definido dentro de nuestro mundo y con dos características que son sus atributos y su comportamiento. Ejemplos de objetos pueden ser un celular, lentes, pluma, computadora, pizarrón, perro, etc. Los objetos se componen de atributos o variables que aclaran el estado del objeto. Los atributos de un objeto, bicicleta, podrían ser el número de llantas que tiene (estado 2) el numero de marchas (estado 4 si es de velocidades), numero de asientos (estado uno), velocidad instantánea. Para alterar el estado de un objeto se necesita invocar un método. Este método es algo que el objeto sabe y por lo tanto define su comportamiento. Bicicleta.dameTuvelocidadactual() -entrega 0 Bicicleta.avanza(10) -modifico su velocidad Bicicleta.dameTuvelocidadactual()-entrega valor distinto de cero. La encapsulacion es una técnica que permite localizar y ocultar los detalles de un objeto. La encapsulación previene que un objeto sea manipulado por operaciones distintas de las definidas. La encapsulación es como una caja negra que esconde los datos y solamente permite acceder a ellos de forma controlada. Las principales razones técnicas para la utilización de la encapsulación son: 1) Mantener a salvo los detalles de representación, si solamente nos interesa el comportamiento del objeto. 2) Modificar y ajustar la representación a mejores soluciones algorítmicas o a nuevas tecnologías de software. Lección 14 3.3 Modularidad Proceso de crear partes de un todo que se integran perfectamente entre sí para que funcionen por un objetivo general, y a las cuales se les pueden agregar más componentes que se acoplen perfectamente al todo, o extraerle componentes sin afectar su funcionamiento. En el caso que se requiera actualizar un módulo, no hay necesidad de hacer cambios en otras partes del todo. Un ejemplo clásico es un conjunto de módulos que, al integrarlos conforman un armario, el cual puede agregarle más funcionalidad si se le agregan más módulos, o al contrario.

20


También se puede cambiar su finalidad si se acomodan esos módulos para darle otro objetivo: volverlo una mesa. Esto ayuda a la descomposición de problemas en subproblemas, es decir, a la solución de problemas por composición de soluciones a subproblemas Modularidad es el atributo del software que permite a un programa ser manejable intelectualmente. G. Myers La arquitectura del software implica la división de éste en componentes identificables y tratables por separado, denominados módulos, que están integrados para satisfacer los requisitos del programa. Un software monolítico no puede ser entendido fácilmente por un solo usuario. El número de caminos de control, ámbito de referencia, número de variables y la complejidad global harían su comprensión casi imposible. Para ver la importancia de la modularidad, considérense los siguientes argumentos basados en observaciones llevadas a cabo: Sea C(x) una función que define la complejidad percibida de un problema x, y E(x) una función que defina el esfuerzo (en tiempo) requerido para solucionar el problema x. Para dos problemas P1 y P2, si C(P1) > C(P2) se sigue que E(P1) > E(P2) Otra interesante característica se ha descubierto durante la experimentación en la resolución de problemas, y es: C(P1 + P2) > C(P1) + C(P2) se sigue que E(P1 + P2) > E(P1) + E(P2) Es más fácil resolver un problema complejo cuando se rompe en piezas manejables. Lección 14 3.4 Jerarquía La mayoría de las personas ve de manera natural nuestro mundo como objetos que se relacionan entre sí de una manera jerárquica. Por ejemplo, un perro es un mamífero, y los mamíferos son animales, y los animales seres vivos... Del mismo modo, las distintas clases de un programa se organizan mediante la jerarquía. La representación de dicha organización da lugar a los denominados árboles de herencia:

21


Mediante la herencia una clase hija puede tomar determinadas propiedades de una clase padre. Así se simplifican los diseños y se evita la duplicación de código al no tener que volver a codificar métodos ya implementados. Al acto de tomar propiedades de una clase padre se denomina heredar. Lección 5 3.5 Polimorfismo Las referencias y las colecciones de objetos pueden contener objetos de diferentes tipos, y la invocación de un comportamiento en una referencia producirá el comportamiento correcto para el tipo real del referente. Cuando esto ocurre en "tiempo de ejecución", esta última característica se llama asignación tardía o asignación dinámica. Algunos lenguajes proporcionan medios más estáticos (en "tiempo de compilación") de polimorfismo, tales como las plantillas y la sobrecarga de operadores de C++. En programación orientada a objetos se denomina polimorfismo a la capacidad del código de un programa para ser utilizado con diferentes tipos de datos u objetos. También se puede aplicar a la propiedad que poseen algunas operaciones de tener un comportamiento diferente dependiendo del objeto (o tipo de dato) sobre el que se aplican. El concepto de polimorfismo se puede aplicar tanto a funciones como a tipos de datos. Así nacen los conceptos de funciones polimórficas y tipos polimórficos. Las primeras son aquellas funciones que pueden evaluarse y/o ser aplicadas a diferentes tipos de datos de forma indistinta; los tipos polimórficos, por su parte, son aquellos tipos de datos que contienen al menos un elemento cuyo tipo no está especificado. Se puede clasificar el polimorfismo en dos grandes clases: Polimorfismo dinámico (o polimorfismo ad hoc) es aquél en el que el código no incluye ningún tipo de especificación sobre el tipo de datos sobre el que se trabaja. Así, puede ser utilizado a todo tipo de datos compatible.

22


Polimorfismo estático (o polimorfismo paramétrico) es aquél en el que los tipos a los que se aplica el polimorfismo deben ser explicitados y declarados uno por uno antes de poder ser utilizados. El polimorfismo dinámico unido a la herencia es lo que en ocasiones se conoce como programación genérica. 3.6 Herencia Organiza y facilita el polimorfismo y la encapsulación permitiendo a los objetos ser definidos y creados como tipos especializados de objetos preexistentes. Estos pueden compartir (y extender) su comportamiento sin tener que reimplementar su comportamiento. Esto suele hacerse habitualmente agrupando los objetos en clases y las clases en árboles o enrejados que reflejan un comportamiento común. La herencia es uno de los mecanismos de la programación orientada a objetos, por medio de la cual una clase se deriva de otra de manera que extiende su funcionalidad. Una de sus funciones más importantes es la de proveer polimorfismo . La herencia en la POO permite a una clase heredar las propiedades de una clase de objetos, donde la clase padre sirve como patrón a la clase derivada. si un objeto hereda sus atributos de un único padre, esto recibe el nombre de herencia simple, y si hereda atributos de múltiples padres es herencia múltiple, la ventaja de la herencia es permitir la reutilización de código. Para realizar herencia se debe tener en cuenta dos aspectos importantes: la clase base y la clase derivada donde la clase base define todas las cualidades que serán heredadas por cualquier clase y la clase derivada hereda las características generales y añade a esta de su propia clase. Utilizando la herencia, un objeto sólo necesita definir aquellas cualidades que lo hacen único dentro de una clase. Este objeto puede heredar sus atributos generales de su padre. Por lo tanto la herencia es el mecanismo que le permite a un objeto ser una instancia específica de un caso más general analicemos el proceso de un animal. Por ejemplo al hacer una descripción de los animales de forma abstracta, se puede decir que estos tiene atributos tales como: tamaño, inteligencia, y el tipo de esqueleto. Los animales tienen diferentes clase de comportamiento esta puede ser una definición de la clase de los animales. La herencia interactúa con el encapsulado. Si una clase dada encapsula algunos atributos, entonces la cualquier clase tendrá los mismos atributos.

23


3.6.1 Tipos de herencia Herencia sencilla: Un objeto puede extender las características de otro objeto y de ningún otro, es decir, solo puede tener un padre. Herencia múltiple: Un objeto puede extender las características de uno o más objetos, es decir, puede tener varios padres. En este aspecto hay discrepancias entre los diseñadores de lenguajes. Algunos de ellos han preferido no admitir la herencia múltiple por las posibles coincidencias en nombres de métodos o datos miembros. Por ejemplo C++ admite herencia múltiple, Java y Ada sólo herencia simple. Si una clase cualquiera tiene más de un ancestro directo en la jerarquía de clases, se considera que existe herencia múltiple. En términos concretos, una instancia de objeto de la clase hija, poseerá todos los atributos y métodos de sus clases ancestro. Autoevaluación 3.7 ACTIVIDADES COMPLEMENTARIAS Parte Uno: 1. De acuerdo con el concepto de abstracción mire su casa o apartamento y diga cual es la función de cada una de las partes. 2. Cual es la función de los descriptores private, public y protected. 3. Realiza un mapa conceptual con 15 términos del tema de modularidad. 4. Cual es la función principal de la jerarquía en la POO. 5. ¿Cual es la relación que existe entre jerarquía y polimorfismo? 6. Mediante un ejemplo explique el concepto de herencia

24


7. Realiza un árbol teniendo en cuanta las clases y subclases y lo que heredan de cada uno de las clases padres. Parte Dos: Realizar los ejercicos complementarios de Laboratorios de la Guia de Laboratotios y Consultar Bibliografia de Libros Virtual de la Unad y otros Autores 1. Autor: Deitel y Deitel Introducción DOO con UML y los Patrones de Diseño JDBC tm, SERVLETS, JSP tm Editorial Pearson Prentice Hall Quinta Edición, 2. David Arnow Gerald Weiss Introducción a la Programación con Java tm Actualización a la Versión 2 de Java Editorial Addison Wesley 3. Fcd Javier Ceballos Java 2 Curso de Programación 2 Edición Editorial Alfaomega Ra-Ma 4. Agustin Froute Java 2 Manual Usuario tutorial 3 Edición Editorial Alfaomega Ra-Ma 5. Herbert shildt Fundamentos de Programación Java 2 Editorial Mc Graw Hill . para conocer el lenguaje de programación JAVA ya que están resueltos solo los puede digitar compilar y ejecutar en la casa o laboratorio de su correspondiente CEAD o CERES.

25


UNIDAD 2. ESTRUCTURA DE UN OBJETO - INTRODUCCION A JAVA Lección 16 Capitulo 4. Análisis De La Estructura Y Comportamiento De Un Objeto 4.1 Análisis de la Estructura de Objetos. 1 El análisis de la estructura de objetos (AEO) define las categorías de los objetos que percibimos y las formas en que los asociamos. 4.1.1 Objetos y Tipos de Objetos. En el análisis se trata de identificar los tipos de objeto más que los objetos individuales en un sistema. Los tipos de objetos se definen en base a la comprensión del analista de nuestro mundo. Un objeto puede categorizarse de variadas formas.

4.1.2 Asociaciones de Objetos. Es importante modelar la forma como los objetos se asocian entre sí. Además es necesario identificar el significado de la asociación y la cantidad de objetos con los que un objeto dado puede y debe asociarse (cardinalidad).

Representación para la Asociación entre dos Tipos de Objetos. Un objeto del tipo persona posee cero o muchos objetos del tipo vehículo. Un objeto del tipo vehículo es de un y sólo un objeto del tipo persona. 4.1.3 Jerarquías de Generalización. Una de las vías de sentido común por las que el hombre organiza su volumen de conocimiento es el de las jerarquías, de lo más general a lo más específico.

26


Representación de una Jerarquía de generalización, para el tipo de objeto Persona. En las jerarquías se habla de subtipo o especialización de un supertipo o generalización. En el caso anterior, persona es el supertipo para Empleado y Estudiante, que son sus subtipos. Por otra parte, Empleado es el supertipo para los subtipos Ejecutivo y Vendedor. Los subtipos (niveles inferiores de la jerarquía) heredan las características de sus supertipos, además, cada instancia de un tipo de objeto lo es también de sus supertipos. 4.1.4 Jerarquías Compuestas. Un objeto se denomina complejo si está formado por otros. Las jerarquías Compuestas permiten realizar agregaciones de objetos.

Un objeto del tipo edificio se compone de a lo menos un objeto del tipo piso. A su vez un objeto del tipo piso se compone de a lo menos un objeto del tipo pasillo, podría tener varios (o ninguno) objetos del tipo baño y oficina. 4.1.5 Diagramas de relación entre los objetos. Los tipos de objetos están relacionados con otros tipos de objeto. Por ejemplo, un empleado trabaja en una sucursal, o un cliente realiza un pedido de varios productos.

27


Un objeto del tipo cliente puede ordenar muchos objetos del tipo pedidos, y un objeto del tipo pedido es ordenado por un y sólo un objeto del tipo cliente. Un objeto del tipo producto está en muchos o ningún objeto del tipo pedido, mientras que un objeto del tipo pedido tiene al menos un objeto del tipo producto. 4.1.6 Esquemas de Objetos. La comprensión de un modelo suele ser más sencilla si los tipos de objetos y relaciones se presentan mediante un diagrama de relación entre objetos; los supertipos y subtipos se presentan en un diagrama de jerarquías de generalización y las estructuras compuestas en un diagrama compuesto. Sin embargo, para los usuarios más sofisticados puede ser útil presentarlo todo en un mismo diagrama, el que se denomina esquema de objetos. Lección 17 4.2 Análisis del comportamiento de objetos 2 En el análisis del comportamiento de objetos (ACO) realizamos esquemas de eventos que muestran eventos, la secuencia en que ocurren y cómo los eventos cambian el estado de los objetos. 4.2.1 Estados de un Objeto. Un objeto puede existir en varios estados. Por ejemplo, un objeto reservación aérea puede ser una instancia de alguno de los siguientes tipos de objeto:  Reservación Reservación Reservación Reservación Reservación Reservación

solicitada, en lista de espera, confirmada, cancelada, satisfecha, archivada.

Tales tipos de objetos suelen percibirse como estados posibles del ciclo vital de un objeto. Sin embargo, un objeto puede tener una gran variedad de perspectivas de ciclos vitales. Por ejemplo, el mismo objeto reservación aérea también puede tener los siguientes estados relacionados con el pago: Reservación Reservación Reservación

no liquidada, con un pago de depósito, totalmente pagada,

28

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA CONTENIDO MODULO DEL CUSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS Reservación

reembolsada. Así, el estado de un objeto es la colección de asociaciones que tiene un objeto. 4.2.2 Eventos. El mundo está lleno de eventos: una coneja tiene conejitos, llega el pesado del vecino en forma inesperada, un cliente solicita un préstamo, el servidor se cae, se termina la tarea, etc. En el análisis orientado a objetos el mundo se describe en términos de los objetos y sus estados, así como los eventos que modifican esos estados. Un evento produce un cambio en el estado de un objeto. Los eventos sirven como indicadores de los instantes en que ocurren los cambios de estado. Para saber de los cambios y reaccionar adecuadamente ante ellos, debemos entender y modelar los eventos. 4.2.3 Tipos de Eventos El analista no necesita conocer cada evento que ocurra en una organización: sólo los tipos de eventos. Por ejemplo, el tipo de evento reservación en lista de espera confirmada es la colección de eventos donde un objeto cambia de una reservación en lista de espera a una reservación confirmada. Los tipos de eventos indican los cambios sencillos en el estado de un objeto; por ejemplo, cuando se deposita dinero en una cuenta bancaria o se actualiza el sueldo de un trabajador. Básicamente, los tipos de eventos describen las siguientes formas de cambios de estado: Un Un Un Un Un Un

objeto se crea. objeto se termina. objeto se clasifica como una instancia de un tipo de objeto. objeto se desclasifica como una instancia de un tipo de objeto. objeto cambia de clasificación. atributo de un objeto se cambia.

Los objetos pueden asociar un objeto con otro. Por ejemplo, en la mayoría de las organizaciones, cuando un objeto se clasifica como empleado, debe estar asociado con un departamento. Un evento clasificará al objeto como empleado. Otro evento creará una asociación entre el objeto empleado y un objeto Departamento (las asociaciones son objetos como los demás).

29


Algunos eventos requieren que antes ocurran otros. Por ejemplo, antes de cerrar un departamento, todos los empleados deben ser asignados a otra parte, las oficinas que ocupaban deben tener otro uso, etc. Algunas veces, un evento puede provocar la reacción encadena de otros eventos. Por ejemplo, el cambio de circuito a las conexiones de un avión, puede exigir cambios a varios otros objetos. Una operación hace que los eventos ocurran. Dibujamos la operación como un cuadro con esquinas redondeadas, puesto que los eventos indican los puntos en el tiempo en que se da el cambio de estado de un objeto. Los tipos de eventos se representan como triángulos negros llenos, generalmente unidos a la caja de operación.

Según el área que se modele, puede ocurrir más de un evento al terminar una operación, y cada uno de estos puede activar operaciones independientes.

4.2.4 El Ciclo Vital de un Objeto La mayoría de los objetos tienen un ciclo vital en el que una sucesión de eventos pueden ocurrirle y cada uno de éstos modifica su estado. En este análisis, se dibuja un diagrama que muestre el ciclo vital de un objeto, incluyendo los estados posibles de los objetos, además de los cambios de estado permisibles. Este se denomina diagrama de reja.

30


Diagrama de reja que muestra los estados posibles de un objeto reservación aérea. Las líneas horizontales representan estados y las verticales muestran las transiciones entre estados. 4.2.5 Interacciones entre tipos de objetos La mayoría de los procesos requieren la interacción de varios objetos.

En esta otra figura, se desarrolla el diagrama anterior para mostrar las operaciones necesarias.

31


4.2.6 Operaciones. En el análisis OO, una operación se refiere a una unidad de procesamiento que puede ser solicitada. El procedimiento se implanta mediante un método. El método es la especificación de cómo llevar a cabo la operación. A nivel de programa, el método es el código que implanta la operación. Las operaciones se invocan. Una operación invocada es una instancia de una operación. Una operación puede o no cambiar el estado de un objeto, si lo cambiara ocurriría un evento.

4.2.7 Fuentes externas de eventos Los eventos son cambios de estado que un sistema debe conocer y reaccionar ante ellos de algún modo. Muchas de las operaciones que producen estos eventos son externas al sistema. 4.2.8 Reglas de activación Cuando ocurre un evento, lo normal es que el cambio de estado active el llamado a una o más operaciones. Por ejemplo, si se retiran bienes de un almacén y la cantidad baja de cierto nivel, ello puede activar una operación para volver a realizar un pedido. Las reglas de activación definen la relación entre la causa y el efecto. Siempre que ocurra un evento de cierto tipo, la regla de activación invoca a una operación ya definida. Un tipo de evento puede tener varias reglas de activación, cada una de las cuales invoca a su operación en paralelo. Las operaciones paralelas pueden producir diferentes cambios de estado en forma simultánea. 4.2.9 Condiciones de Control Una operación puede ser invocada por una o varias reglas de activación. Sin embargo, antes de invocar de hecho a la operación se puede verificar una condición de control. Si el resultado de evaluación de la condición es verdadera se invoca su operación, en otro caso no.

32


Las condiciones de control también pueden actuar como puntos de sincronización para el procesamiento en paralelo, pues garantizan que un conjunto de eventos esté completo antes de proceder con una operación. 4.2.10 Subtipos y Supertipos de Eventos.

Los eventos pueden dividirse en subtipos mediante diagramas independientes; o bien, es posible expresar la misma información en un diagrama ampliado.

La operación revisar tarea produce dos eventos: tarea aceptada o tarea rechazada. Sólo se puede dar uno de estos tipos de evento al revisar una tarea.

33


Aquí tarea revisada es un supertipo de tarea aceptada y tarea rechazada, que son los subtipos. Siempre se entiende que existe una relación de exclusividad entre los subtipos. Lección 18 4.3 Diseño de la Estructura y Comportamiento de un Objeto En el diseño de la estructura y comportamiento de objetos se identifican los componentes siguientes:  Clases

que se implantarán. Los tipos de objetos en el AEO serán la guía en esta decisión. Estructuras de Datos que utilizará cada clase. Se puede hacer un diagrama para representar la estructura de datos. Operaciones que ofrecerá cada clase y cuáles serán sus métodos. Se enumeran las operaciones y se especifican los métodos. Forma de Implantación de la herencia de clases y efecto sobre las especificaciones de los datos y operaciones. Identificación de variantes de clases ("igual que, excepto..."). 4.3.1 Objeto

4.3.2. Estructura de un Objeto: Un objeto puede considerarse como una especie de cápsula dividida en tres partes, donde cado uno de ellas desempeñan un papel independiente que son:  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 tienen valores que dependen de la propiedad

34


de que se trate. Las propiedades de u objeto pueden ser heredadas a sus descendientes en la organización. LOS METODOS: Son las operaciones que pueden realizarse sobre el objeto, que normalmente estarán incorporados en formas de programas (en 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.

Una clase es la evolución natural de una estructura, la existencia de clases es la característica más significativa que convierte a muchos lenguajes de programación en un lenguaje orientado a objetos. Las clases son estructuras que contienen no sólo declaraciones de datos, sino también declaraciones de funciones. Las funciones se conocen como funciones miembro, e indican qué tipos de cosas puede hacer una clase. La palabra reservada class introduce una declaración de clase. “Clase es la implantación de un tipo de objeto. Especifica la estructura de datos y los métodos operativos permitidos que se aplican a cada uno de sus objetos. La clase específica la estructura de datos de cada uno de sus objetos y las operaciones que se utilizan para tener acceso a los objetos. La especificación de cómo se llevan a cabo las funciones de una clase se llama método. Los objetos se pueden utilizar exclusivamente con métodos específicos. Una instancia de una clase, almacena sus datos dentro de él. Se tiene acceso a los datos y se les modifica sólo mediante operaciones que son permitidas. Esta restricción al acceso se debe al encapsulado. El encapsulado protege los datos del

35


uso arbitrario o no permitido. El acceso o la actualización directa de los datos de un objeto por parte del usuario violaría el encapsulado. “ Los usuarios observan el "comportamiento" del objeto en términos de las operaciones que se pueden aplicar a los objetos, así como los resultados de tales operaciones. Estas operaciones forman la interfaz del objeto con sus usuarios. Las clases son declaraciones o abstracciones de objetos, lo que significa, que una clase es la definición de un objeto. Cuando se programa un objeto y se definen sus características y funcionalidades, realmente se programa una clase. 4.3.2.1 Componentes Una clase es un contenedor de uno o más datos (variables o propiedades miembro) junto a las operaciones de manipulación de dichos datos (funciones/métodos). Las clases pueden definirse como estructuras (struct), uniones (unión) o clases (class) pudiendo existir diferencias entre cada una de las definiciones según el lenguaje. Variables miembro Las propiedades o atributos que son características de los objetos. Cuando definimos una propiedad normalmente especificamos su nombre y su tipo. Nos podemos hacer a la idea de que las variables son algo así como el almacén de los datos de estado relacionados con los objetos. Habitualmente, las variables miembro son privadas al objeto (siguiendo las directrices de diseño del Principio de ocultación) y su acceso se realiza mediante propiedades o métodos que realizan comprobaciones adicionales. Suelen denominarse con nombres. Métodos en las clases Implementan la funcionalidad asociada al objeto. Los métodos son el equivalente a las funciones en los lenguajes estructurados. Se diferencian de ellos en que es posible acceder a las variables de la clase de forma implícita. Cuando se desea realizar una acción sobre un objeto, se dice que se le manda un mensaje invocando a un método que realizará la acción. Habitualmente, los métodos suelen ser verbos. Propiedades Las propiedades son un tipo especial de métodos. Debido a que suele ser común que las variables miembro sean privadas para controlar el acceso y mantener la coherencia, surge la necesidad de permitir consultar o modificar su valor mediante pares de métodos: GetVariable y SetVariable.

36


Los lenguajes orientados a objetos más modernos (Java, C#, añaden la construcción de propiedad que es una sintaxis simplificada para dichos métodos: tipo Propiedad { get { } set { } } De esta forma es posible realizar operaciones sobre las propiedades como si fuesen variables normales, el compilador se encarga de crear el código apropiado que llame a la cláusula get o set según se necesite. Las propiedades se denominan con nombres como las variables. Lección 19 4.3.3 Diferencia entre operación y método.5 Las operaciones son procesos que se pueden solicitar como unidades. Losmétodos son especificaciones del procedimiento de una operación dentro de una clase. Es decir, la operación es el tipo de servicio solicitado y el método es su código de programación. Por ejemplo una operación asociada con la clase pedido podría ser aquella que calcule el total del pedido. El método especificaría la forma de calcular el total. Para esto, el método podría obtener el precio de cada artículo del pedido al enviar una solicitud a los objetos artículo asociados. A su vez, cada objeto artículo regresaría su precio al método pedido mediante un método de la clase artículo. Los métodos de una clase controlan solamente a los objetos de esa clase. No pueden tener acceso directo a las estructuras de datos de un objeto en una clase distinta. Para utilizar las estructuras de datos en una clase diferente, deben enviar una solicitud a ese objeto. 4.3.4 Herencia de Clase. La generalización es una noción conceptual. La herencia de clase (que sólo se conoce como herencia) es una implantación de la generalización. La generalización establece que las propiedades de un tipo se aplican a sus subtipos. La herencia de clase hace que la estructura de datos y operaciones sean disponibles para su reutilización por parte de sus subclases. La herencia de las operaciones de una superclase permite que las clases compartan código. La herencia de la estructura de datos permite la reutilización de la estructura.

37


4.3.5 Herencia Múltiple. En la herencia múltiple, una clase puede heredar estructuras de datos y operaciones de más de una superclase. Por ejemplo supóngase que existe un tipo de objeto cuenta, que tiene como subtipos a los tipos de objetos cuenta de cliente y cuenta vencida. A su vez, cuenta de cliente tiene como a subtipo a cuenta de cliente vencida y cuenta vencida también tiene como subtipo a cuenta de cliente vencida. Lección 20 4.3.6 Selección del Método. Cuando se envía una solicitud a un objeto, el software selecciona los métodos por utilizar. El método no se almacena en el objeto, pues esto causaría una réplica múltiple y pérdida de espacio. En vez de esto, el método se asocia con la clase. El método puede no estar en la clase de la que el objeto es una instancia, sino en una superclase. En ese caso, el mecanismo de selección buscará la operación en su superclase y en todas las superclases de la jerarquía hasta que lo encuentre, nivel por nivel. Si la encuentra, selecciona la operación. Si la operación no se encuentra en ningún nivel de la superclase, se considera inválida la fuente de la solicitud. De esta forma, los usuarios sólo deben especificar lo que se debe hacer, dejando que sea el mecanismo de selección el que determine la forma de localizar la operación y la ejecute. El mecanismo de selección deja en manos de la aplicación OO el problema de localizar la operación y la ejecute. 4.3.7 Polimorfismo Uno de los objetivos principales de las técnicas OO es utilizar otra vez el código. Sin embargo, algunas de las operaciones requieren adaptación para resolver necesidades particulares. Esta necesidad, se da generalmente entre superclases y subclases, donde una subclase es una especialización de su superclase, y puede requerir alcanzar los mismos objetivos, pero con distintos mecanismos. Por ejemplo, una superclase rectángulo podría tener una operación área cuyo objetivo es calcular el área del rectángulo, definida como la multiplicación de los largos de dos lados contiguos. A su vez, la clase cuadrado es una subclase de rectángulo que también tiene una operación área cuyo objetivo es calcular el área del cuadrado, pero que está definida especialmente para los objetos del tipo cuadrado como la multiplicación del largo de uno de sus lados por si mismo.

38


El fenómeno recién descrito se conoce como polimorfismo, y se aplica a una operación que adopta varias formas de implantación segun el tipo de objeto, pero cumple siempre el mismo objetivo. Una de las ventajas del polimorfismo es que se puede hacer una solicitud de una operación sin conocer el método que debe ser llamado. Estos detalles de la implantación quedan ocultos para el usuario; la responsabilidad descansa en el mecanismo de selección de la implantación OO. 4.3.8 Notación. Para representar una clase, sus atributos y sus métodos:

Para representar una instancia de una clase:

Objeto es una instancia de la Clase. La media luna representa una jerarquía de generalización (se lee Objeto 'es un' Clase). La forma general de la declaración de una clase es: class Nombre_de_la_clase { datos y funciones privados public: datos y funciones publicas } lista de objetos; La sintaxis típica de una clase es: class Nombre { // Variables miembro (habitualmente privadas)

39


miembro_1; //lista de miembros miembro_2; miembro_3; // Funciones o métodos (habitualmente públicas) funcion_miembro_1( ); // funciones miembro conocidas funcion_miembro_2 ( ); // funciones como métodos // Propiedades (habitualmente públicas) propiedad_1; propiedad_2; propiedad_3; propiedad_4; } Autoevaluación 4.4 ACTIVIDADES COMPLEMENTARIAS Parte Uno: 1. Crear el siguiente objeto de la figura:

Donde demuestre la creación de los 6 métodos que consta la clase operación. 2. ¿cual es la diferencia de la programación orientada objetos con otros lenguajes. 3. ¿Cuáles son las desventajas de la programación orientada a objetos? 4. Realiza una estructura por ejemplo del computador de su casa donde indique cuales son los datos y cuales son los métodos. 5. Investiga como es el comportamiento de los objetos en una clase. Parte Dos: Realizar los ejercicos complementarios de Laboratorios de la Guia de Laboratotios y Consultar Bibliografia de Libros Virtual de la Unad y otros Autores 1. Autor: Deitel y Deitel Introducción DOO con UML y los Patrones de Diseño JDBC tm, SERVLETS, JSP tm Editorial Pearson Prentice Hall Quinta Edición, 2. David Arnow Gerald Weiss Introducción a la Programación con Java tm Actualización a la Versión 2 de Java Editorial Addison Wesley 3. Fcd Javier Ceballos Java 2 Curso de Programación 2 Edición Editorial Alfaomega Ra-Ma 4. Agustin Froute Java 2 Manual Usuario tutorial 3

40


Edición Editorial Alfaomega Ra-Ma 5. Herbert shildt Fundamentos de Programación Java 2 Editorial Mc Graw Hill . para conocer el lenguaje de programación JAVA ya que están resueltos solo los puede digitar compilar y ejecutar en la casa o laboratorio de su correspondiente CEAD o CERES.

41


Lección 21 CAPITULO 5. FUNDAMENTOS DE JAVA 5.1 Introducción Plataforma de software desarrollada por Sun Microsystems. Esta plataforma ha sido desarrollada de tal manera que los programas desarrollados para ella puedan ejecutarse de la misma forma en diferentes tipos de arquitecturas y dispositivos computacionales. La plataforma Java se divide en 3 partes:  Lenguaje de programación. Máquina Virtual Java API Java

Es un lenguaje de programación orientada a objetos puro diseñado para su uso en Internet. Se parece mucho a C++, pero adopta algunas ideas de Smalltalk. Los programas se ejecutan por medio de un intérprete que ha sido incorporado a los navegadores de Internet más usuales. A finales del siglo XX, Java llegó a ser el lenguaje de mayor acogida para programas de servidor. Utilizando una tecnología llamada JSP (basada en ASP de Microsoft), se hizó muy fácil escribir páginas dinámicas para sitios de Internet. Sumado a esto, la tecnología de JavaBeans, al incorporarse con JSP, permitía utilizar el patrón MVC (Modelo-Vista-Controlador) que ya tanto se había aplicado a interfaces gráficas. Java llegó a ser extremadamente popular cuando Sun Microsystems introdujo el J2EE (Java 2 Enterprise Edition) en la que incluía la tecnología de Enterprise Java Beans (EJB) que es una tecnología de objetos distribuídos, logrando por fin el sueño de muchas empresas como Microsoft e IBM de crear una plataforma de objetos distribuídos con un monitor de transacciones. Con este nuevo estándar, empresas como BEA, IBM, Sun Microsystems, Oracle y otros crearon nuevos "servidores de aplicaciones" que tuvieron gran acogida en el mercado. Además de programas del servidor, Java permite escribir programas de interfaz gráfica o textual. Además se pueden correr programas de manera incorporada a los navegadores de Internet, aunque esto nunca llegó a popularizarse como se esperaba. Programas en Java generalmente son compilados y luego interpretados por una máquina virtual. Esta última sirve como una plataforma de abstracción entre la máquina y el lenguaje permitiendo que se pueda "escribir el programa una vez, y correrlo en cualquier lado". También existen compiladores nativos de Java, tanto comercial como libre. El compilador GCC de GNU compila Java con algunas limitaciones (año 2002). 5.2 Características de Java

42


Microsystems, líder en servidores para Internet, uno de cuyos lemas desde hace mucho tiempo es "the network is the computer" (lo que quiere dar a entender que el verdadero ordenador es la red en su conjunto y no cada máquina individual). Es quien ha desarrollado el lenguaje Java, en un intento de resolver simultáneamente todos los problemas que se le plantean a los desarrolladores de software por la proliferación de arquitecturas incompatibles, tanto entre las diferentes máquinas como entre los diversos sistemas operativos y sistemas de ventanas que funcionaban sobre una misma máquina, añadiendo la dificultad de crear aplicaciones distribuidas en una red como Internet. Hace algunos años, Sun Microsystems decidió intentar introducirse en el mercado de la electrónica de consumo y desarrollar programas para pequeños dispositivos electrónicos. Tras unos comienzos dudosos, Se decidió crear una filial, denominada FirstPerson Inc, para dar una margen de maniobra al equipo responsable del proyecto. El mercado inicialmente previsto para los programas de FirstPerson eran los equipos domésticos: microondas, tostadoras y, fundamentalmente, televisión interactiva. Este mercado, dada la falta de pericia de los usuarios para el manejo de estos dispositivos, requería unas interfaces mucho más cómodos e intuitivos que los sistemas de ventanas que proliferaban en el momento. Otros requisitos importantes a tener en cuenta eran la fiabilidad del código y la facilidad de desarrollo. James Gosling, el miembro del equipo con más experiencia en lenguajes de programación, decidió que las ventajas aportadas por la eficiencia de C++ no compensaban el gran coste de pruebas y depuración. Gosling había estado trabajando en su tiempo libre en un lenguaje de programación que él había llamado Oak, el cual, aún partiendo de la sintaxis de C++, intentaba remediar las deficiencias que iba observando. Los lenguajes al uso, como C o C++, deben ser compilados para un chip, y si se cambia el chip, todo el software debe compilarse de nuevo. Esto encarece mucho los desarrollos y el problema es especialmente acusado en el campo de la electrónica de consumo. La aparición de un chip más barato y, generalmente, más eficiente, conduce inmediatamente a los fabricantes a incluirlo en las nuevas series de sus cadenas de producción, por pequeña que sea la diferencia en precio ya que, multiplicada por la tirada masiva de los aparatos, supone un ahorro considerable. Por tanto, Gosling decidió mejorar las características de Oak y utilizarlo. El primer proyecto en que se aplicó este lenguaje recibió el nombre de proyecto Green y consistía en un sistema de control completo de los aparatos electrónicos y el entorno de un hogar. Para ello se construyó un ordenador experimental denominado *7 (Star Seven). El sistema presentaba una interfaz basada en la representación de la casa de forma animada y el control se llevaba a cabo mediante una pantalla sensible al tacto. En el sistema aparecía Duke, la actual mascota de Java. Posteriormente se aplicó a otro proyecto denominado VOD (Video On Demand) en el que se empleaba como interfaz para la televisión interactiva. Ninguno de estos

43


proyectos se convirtió nunca en un sistema comercial, pero fueron desarrollados enteramente en un Java primitivo y fueron como su bautismo de fuego. Una vez que en Sun se dieron cuenta de que a corto plazo la televisión interactiva no iba a ser un gran éxito, urgieron a FirstPerson a desarrollar con rapidez nuevas estrategias que produjeran beneficios. No lo consiguieron y FirstPerson cerró en la primavera de 1994. Lo mejor será hacer caso omiso de las historias que pretenden dar carta de naturaleza a la clarividencia industrial de sus protagonistas; porque la cuestión es si independientemente de su origen y entorno comercial, Java ofrece soluciones a nuestras expectativas. Porque tampoco vamos a desechar la penicilina aunque haya sido su origen fruto de la casualidad. Se puede decir que Java es: Simple: Basado en el lenguaje C++ pero donde se eliminan muchas de las características POO que se utilizan esporádicamente y que creaban frecuentes problemas a los programadores. Esta eliminación de causas de error y problemas de mantenimiento facilita y reduce el costo del desarrollo de software. Java no da soporte a struct, union y pointer Java no ofrece typedef ni #define No permite la sobrecarga de operadores. No ofrece herencia múltiple. Maneja los comandos en línea de diferente manera que C++ Java tienen una clase String, que permite un mejor manejo que los arrays de terminación nula del C y C++. Java tiene un sistema automático de asignación y liberación de memoria (recolector de basura) que mejora mucho los sistemas del C++. Orientado al objeto: Java da buen soporte a las técnicas de desarrollo POO y en resumen a la reutilización de componentes de software. Distribuido: Java se ha diseñado para trabajar en ambiente de redes y contienen una gran biblioteca de clases para la utilización del protocolo TCP/IP, incluyendo HTTP y FTP. El código Java se puede manipular a través de recursos URL con la misma facilidad que C y C++ utilizan recursos locales (archivos). Interpretado: El compilador Java traduce cada fichero fuente de clases a código de bytes (Bytecode), que puede ser interpretado por todas las máquinas que den soporte a un visualizador de que funcione con Java. Este Bytecode no es especifico de una máquina determinada, por lo que no se compila y enlaza como en el ciclo clásico, sino que se interpreta. Sólido: El código Java no se quiebra fácilmente ante errores de programación. Así el relaje que existe en la declaración y manejo de tipos en C y C++ se torna en restricciones en Java, donde no es posible la conversión forzada (cast) de enteros en

44


punteros y no ofrece soporte a los punteros que permitan saltarse reglas de manejo de tipos. Así en Java no es posible escribir en áreas arbitrarias de memoria ni realizar operaciones que corrompan el código. En resumen se eliminan muchas de las posibilidades de "trucos" que ofrecía el C y C++. Seguro: Como Java suele funcionar en ambiente de redes el tema de seguridad debe interesar en sobremanera. Las mismas características antes descritas que evitan la corrupción de código evitan su manipulación. Actualmente se esta trabajando en encriptar el código. Arquitectura Neutral: El compilador crea códigos de byte (Bytecode) que se envía al visualizador solicitado y se interpreta en la máquina que posee un interprete de Java o dispone de un visualizador que funciona con Java. Portable: Al ser de arquitectura neutral es altamente portable, pero esta característica puede verse de otra manera: Los tipos estándares (int., float...) están igualmente implementados en todas las máquinas por lo que las operaciones aritméticas funcionaran igual en todas las máquinas. Alto desempeño: Al ser código interpretado, la ejecución no es tan rápida como el código compilado para una plataforma particular. El compilador Java suele ofrecer la posibilidad de compilar Bytecode en código máquina de determinadas plataformas, y según Sun este código resultar de una eficacia similar a compilaciones de C y C++. Multihilos: Java puede aplicarse a la realización de aplicaciones en las que ocurra más de una cosa a la vez. Java, apoyándose en un sistema de gestión de eventos basado en el paradigma de condición y monitores C.A.R. permite apoyar la conducta en tiempo real e interactivo en programas. Dinámico: Al contrario que C++ que exige se compile de nuevo la aplicación al cambiar una clase madre Java utiliza un sistema de interfaces que permite aligerar esta dependencia. Como resultado, los programas Java pueden permitir nuevos métodos y variables en un objeto de biblioteca sin afectar a los objetos dependientes. 5.2.1 Diferencias Con C++ En Java no es posible crear variables globales. Solo las variables estáticas y publicas de algunas clases pueden considerarse como tales, pero esto generalmente, y como en el caso de las variables globales en C++ son síntoma de un mal diseño. Java no dispone de sentencia goto lo cual permite crear un código más robusto y seguro así como más optimizado. Para cubrir esta falta Java proporciona un tratamiento muy optimizado de excepciones, poderoso y bien definido. Los punteros son una característica poderosa y peligrosa del C++, en si evitan que ninguna variable sea privada de verdad, ya que es fácil acceder a la mis a través de punteros, los cuales son fuente inacabable de problemas y malfuncionamiento. Java no dispone de tratamiento de punteros. Los vectores o arrays lo son de modo cierto, lo cual evita sobrepasar el mismo o salirse de sus limites.

45


El manejo de memoria en C se realiza de forma peligrosa a través de punteros obtenidos con la función malloc (), y que se libera explícitamente con free(), esto puede causar errores si el programador no controla perfectamente los pasos en que estas operaciones se realizan. Otro error es el olvido frecuente de liberar memoria, lo cual termina consumiendo los recursos del sistema. Java no dispone de punteros y todos lo objetos se crean con el operador new, el cual asigna espacio en el montículo de memoria a cada objeto. Lo que se obtiene con new es un descriptor del objeto (no una dirección) la dirección real es manejada por el sistema el cual la puede mover o recolocar según necesidad, pero el programador no ha de preocuparse por ello. Lo importante es que el objeto tiene memoria asignada mientras le interese al programa, quedando esta memoria disponible en cuanto este interés cese. No se hará falta llamar a free o delete ya que el recolector de basura realizara esta labor. Este recolector o reciclador de basura se ejecutara cuando el sistema este libre o una asignación no encuentren lugar disponible. C y C++ disponen de tipos de datos frágiles cuyos límites y características dependen de la implementación y maquina del compilador. Java implementa límites y tamaños sensatos y validos para todo tipo de máquinas y entornos (independientes del Hardware) por lo que es totalmente reproducible en cualquier plataforma. En C es posible la realización de casting o conversión de tipos en tiempo de ejecución. En C++ esta operación es peligrosa ya que los objetos son referencias a zonas de memoria y no es posible tener información sobre sí la conversión en posible. En Java los descriptores de los objetos contienen información completa acerca de la clase a la que pertenece el objeto, por lo que pueden realizarse comprobaciones en tiempo de ejecución sobre la compatibilidad de tipos y emitir la excepción correspondiente si no es aplicable la conversión. En Java no se dispone de archivos de cabecera con los prototipos de las clases. Esto, en principio es una desventaja, hasta que se comprueba que esta habilidad del C++ ha llevado a entornos de compilación prácticamente inmanejables, ya que cada compilación puede tratar estos archivos de formas un tanto complejas. Java no dispone de esta habilidad de archivos de cabecera, el tipo y la visibilidad de la clase se compila en el propio archivo de la clase, siendo tarea del intérprete de Java realizar el acceso. Java no tiene struct ni unión, ambos sistemas de encasulamiento y polimorfismo un tanto crípticos e inseguros del C++, unificando todo en un solo concepto de class. La programación de entornos reales de C y C++ implica un buen conocimiento del manejo del procesador y sus trucos, lo cual no es una manera limpia de controlar lo que se compila. Java no dispone de este sistema, pero tienen medios (como la declaración final para constantes) que permiten igual potencia. 5.3 Estructura de un programa en Java

46


/**mi primera aplicación Java @autor jmrr @version 1.1.0.*/ Class AplicacionEsencial { Public static void main (String args[]) { System.out.println("Hola Mundo"); } } Lo anterior representa el código de un programa Java que se compilara y ejecutara de la siguiente forma: El código anterior se guarda en un fichero texto cuya extensión es .java (Aplicación Escencial. java).  Este se compila llamando a javac. El resultado de esta compilación es un fichero con el nombre de la clase contenida y la extensión .class (AplicacionEsencial.class). El nombre del fichero fuente (.java podrá ser cualquiera pero dado que el resultado de la compilación adquiere el nombre de la clase contenida en el mismo, es buena practica el llamar al fichero fuente con el mismo nombre.  El fichero obtenido puede ser llamado como argumento del interprete para su ejecución: $ javac AplicacionEsencial.java $ java AplicacionEsencial.class Hola Mundo $ Las partes del programa anterior son: _ Comentarios: desde "/*" hasta que aparece "*/", son ignorados por el compilador. _ La palabra clave class que seguida del nombre de la clase a definir y de la llave de apertura "{" da comienzo a la definición de la misma. _ Cuerpo de la clase que contendrá métodos, operaciones y datos de la clase. En nuestro caso solo contienen un método, el que todas las aplicaciones han de tener: main. _ La línea: "Public static void main (String args[]) {" da comienzo al método main, las palabras clave que anteceden al nombre indican formas especificas para este y su explicación se hará a posteriori. _ Después de main se declara los parámetros de este método (String args[]) que en este caso consta de un array de cadenas de caracteres cuyo nombre es args. Esta

47


aplicación no hace uso de estos parámetros, pero todos los métodos main han de declarar tal lista, ya que representa la teórica línea de comandos que podría acompañar a la llamada a la clase: _ $java Aplicación esencial alpha beta _ Entre las llaves de apertura y cierre se encuentra en cuerpo del método o lista de sentencias que le implementan, en nuestro caso una única llamada al método println. 5.3.1 Creación de un primer programa /* Este es un primer programa de prueba. Este archivo de llama “ejemplo.java” /* class ejemplo { // El programa comienza con una llamada a main (). Public static void main (String args[ ]) { System.out.println(“Este es un programa sencillo en java.”); } } Para compilar el programa ejemplo, ejecutamos el compilador javac, dando el nombre del archivo fuente en línea de órdenes de la siguiente forma C:\>javac ejemplo.java 5.3.1.1 Métodos de definición Los métodos en java le dan mucho poder y flexibilidad debido a su gran utilidad. Los métodos son conjuntos de instrucciones agrupadas bajo un mismo nombre y existen 5 tipos de parámetros que son: METODO El incluyen parámetros por valor

DESCRIPCIÓN Este método recibe en la variable x un valor entero lo mismo que la variable b y retorna un dato de tipo entero que corresponde a la suma de los valores recibidos ejemplo: int f(int x, int b){ Return x+b }

El que incluye parámetros por Referencia

Se caracteriza porque sus parámetros son matrices, arreglos u objetos

Los que devuelven un dato

Veamos el siguiente ejemplo donde recibe un entero y devuelve un # de dígitos que componen dicho entero, ,entonces: Int p (int a){ If (a<0) a = -a; int f = 0;

48


While (a>0){ F = f+1; a = a/10; } Return f; } Los que no devuelven ningún Estas rutinas se utilizan para cambiar algún valor dato fuera de la función Los que no reciben parámetros

Esta rutina no recibe parámetros pero pueden generar un valor o cambiar un dato de un variable global.

La forma general de un método es la siguiente: tipo nombre _ de_ método(lista de parámetros) { // cuerpo del método } 5.3.1.2 Palabras clave Las palabras claves son aquellos identificadores reservados por Java para un objetivo determinado y se usan sólo de la forma limitada y específica. Java tiene un conjunto de palabras clave más rico que C o que C++, por lo que sí está aprendiendo Java con conocimientos de C o C++, asegúrese de que presta atención a las palabras clave de Java. Las siguientes palabras son palabras reservadas de Java: Abstact Case Const Else Float If Int Null Protected Static Throw Var

boolean cast continue extends for implements interface operator public super throws void

break catch default false future mport long outer rest switch transient volatile

byte char do final generic inner native package return syncroniced true while

byvalue class double finally goto instanceof new private short this try

Tabla 2: Palabras reservadas Java Lección 22 5.3.2 Tipos de datos y declaraciones A toda variable que se use en un programa, se le debe asociar (generalmente al principio del programa) un tipo de dato específico.

49


Un tipo de dato define todo el posible rango de valores que una variable puede tomar al momento de ejecución del programa y a lo largo de toda la vida útil del propio programa. 5.3.2.1 Tipos de datos simples Es uno de los conceptos fundamentales de cualquier lenguaje de programación. Estos definen los métodos de almacenamiento disponibles para representar información, junto con la manera en que dicha información ha de ser interpretada. Para crear una variable (de un tipo simple) en memoria debe declararse indicando su tipo de variable y su identificador que la identificará de forma única. La sintaxis de declaración de variables es la siguiente: TipoSimple Identificador1, Identificador2; Esta sentencia indica al compilador que reserve memoria para dos variables del tipo simple TipoSimple con nombres Identificador1 e Identificador2. Los tipos de datos en Java pueden dividirse en dos categorías: simples y compuestos. Los simples son tipos nucleares que no se derivan de otros tipos, como los enteros, de coma flotante, booleanos y de carácter. Los tipos compuestos se basan en los tipos simples, e incluyen las cadenas, las matrices y tanto las clases como las interfaces, en general. Cada tipo de datos simple soporta un conjunto de literales que le pueden ser asignados, para darles valor. En este apartado se explican los tipos de datos simples (o primitivos) que presenta Java, así como los literales que soporta (sintaxis de los valores que se les puede asignar). Tipos de datos enteros Se usan para representar números enteros con signo. Hay cuatro tipos: byte, short, int y long. Tipo

Tamaño

Byte Short Int Long

1Byte (8 bits) 2 Bytes (16 bits) 4 Bytes (32 bits) 8 Bytes (64 bits)

Tabla 5: Tipos de datos enteros Literales enteros Son básicos en la programación en Java y presentan tres formatos:  Decimal:

Los literales decimales aparecen como números ordinarios sin ninguna notación especial.

50

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA CONTENIDO MODULO DEL CUSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS Hexadecimal:

Los hexadecimales (base 16) aparecen con un 0x ó 0X inicial, notación similar a la utilizada en C y C++. Octal: Los octales aparecen con un 0 inicial delante de los dígitos. Por ejemplo, un literal entero para el número decimal 12 se representa en Java como 12 en decimal, como 0xC en hexadecimal, y como 014 en octal. Los literales enteros se almacenan por defecto en el tipo int, (4 bytes con signo), o si se trabaja con números muy grandes, con el tipo long, (8 bytes con signo), añadiendo una L ó l al final del número. La declaración de variables enteras es muy sencilla. Un ejemplo de ello sería: long numeroLargo = 0xC; // Por defecto vale 12 Tipos de datos en coma flotante Se usan para representar números con partes fraccionarias. Hay dos tipos de coma flotante: float y double. El primero reserva almacenamiento para un númerode precisión simple de 4 bytes y el segundo lo hace para un numero de precisión doble de 8 bytes. Tipo Float Doublé

Tamaño 4 Byte (32 bits) 8 Bytes (64 bits)

Tabla 6: Tipos de datos numéricos en coma flotante Literales en coma flotante Representan números decimales con partes fraccionarias. Pueden representarse con notación estándar (563,84) o científica (5.6384e2). De forma predeterminada son del tipo double (8 bytes). Existe la opción de usar un tipo más corto (el tipo float de 4 bytes), especificándolo con una F ó f al final del número. La declaración de variables de coma flotante es muy similar a la de las variables enteras. Por ejemplo: double miPi = 314.16e-2 ; // Aproximadamente float temperatura = (float)36.6; // Paciente sin fiebre Se realiza un moldeado a temperatura, porque todos los literales con decimales por defecto se consideran double. Tipo de datos boolean

51


Se usa para almacenar variables que presenten dos estados, que serán representados por los valores true y false. Representan valores bi-estado, provenientes del denominado álgebra de Boole. Literales Booleanos Java utiliza dos palabras clave para los estados: true (para verdadero) y false (para falso). Este tipo de literales es nuevo respecto a C/C++, lenguajes en los que el valor de falso se representaba por un 0 numérico, y verdadero cualquier número que no fuese el 0. Para declarar un dato del tipo booleano se utiliza la palabra reservada boolean: boolean reciboPagado = false; // ¡¿Aun no nos han pagado?! Tipo de datos carácter Se usa para almacenar caracteres Unicode simples. Debido a que el conjunto de caracteres Unicode se compone de valores de 16 bits, el tipo de datos char se almacena en un entero sin signo de 16 bits. Java a diferencia de C/C++ distingue entre matrices de caracteres y cadenas. Literales carácter Representan un único carácter (de la tabla de caracteres Unicode 1.1) y aparecen dentro de un par de comillas simples. De forma similar que en C/C++. Los caracteres especiales (de control y no imprimibles) se representan con una barra invertida ('\') seguida del código carácter. Descripción

Representación

Valor Unicode

Caracter Unicode Numero octal Barra invertida Continuación Retroceso Retorno de carro Alimentación de Formularios Tabulación horizontal Línea nueva Comillas simples Comillas dobles Números arábigos ASCII Alfabeto ASCII en Mayúsculas Alfabeto ASCII en Minúsculas

\udddd \ddd \\ \ \b \r \f

\u005C \ \u0008 \u000D \u000C

\t \n \’ \" 0-9 A.-Z

\u0009 \u000A \u0027 \u0022 \u0030 a \u0039 \u0041 a \u005A

a.-z

\u0061 a \u007A

Tabla 7: Caracteres especiales Java Las variables de tipo char se declaran de la siguiente forma:

52


char letraMayuscula = 'A'; // Observe la necesidad de las ' ' char letraV = '\u0056'; // Letra 'V' Conversión de tipos de datos En Java es posible transformar el tipo de una variable u objeto en otro diferente al original con el que fue declarado. Este proceso se denomina "conversión", "moldeado" o "tipado". La conversión se lleva a cabo colocando el tipo destino entre paréntesis, a la izquierda del valor que queremos convertir de la forma siguiente: char c = (char)System.in.read(); La función read devuelve un valor int, que se convierte en un char debido a la conversión (char), y el valor resultante se almacena en la variable de tipo carácter c. El tamaño de los tipos que queremos convertir es muy importante. No todos los tipos se convertirán de forma segura. Por ejemplo, al convertir un long en un int, el compilador corta los 32 bits superiores del long (de 64 bits), de forma que encajen en los 32 bits del int, con lo que si contienen información útil, esta se perderá. Por ello se establece la norma de que "en las conversiones el tipo destino siempre debe ser igual o mayor que el tipo fuente":

Tipo Origen

Tipo Destino

Byte Short Char Int Long Float

double, float, long, int, char, short double, float, long, int double, float, long, int double, float, long double, float double

Tabla 8: Conversiones sin pérdidas de información 5.3.3 Operadores y expresiones Un operador es un símbolo especial que indica al compilador que debe efectuar una operación matemática o lógica, java reconoce los siguientes operadores. OPERADOR

OPERACIÓN

+ * /

SUMA RESTA MULTIPLICACIÓN DIVISIÓN

53


%

RESIDUO O MODULO

Es importante tener en cuenta lo siguiente: En problemas de división entre números enteros, java trunca la parte residual, ejemplo: Dividir--_13/5---_el resultado es 2  Para resolver los problemas de potencias y raíces, se usan ciertas instrucciones especiales que proporcionan el lenguaje, llamadas funciones matemáticas, en java existe toda una librería de instrucciones o funciones matemáticas. Recordar que todas las funciones reciben uno o más datos o valores y regresan siempre un resultado, una de estas funciones matemáticas es: import java,lang.math : piblic stagic double pow(double a, double b) ; Esta función ocupa dos valores o datos (base y exp) ambos de tipo double, y regresa un resultado también de tipo double, ejemplo; Resolver el problema de calcular 53 import java,io.*; import java,lang.math : public class ejemplo1 { public static void man(String args[ ]) { double base=5; double exponente=3; double potencia = 0 ; potencia = Math.pow(base, exponente); System.out.println(“potencia=”+potencia); } // cerrar main } // cerrar clase Para resolver el problema de raíces, se aprovecha una de las más elementales y conocida de las leyes de exponentes que dice:

Es decir una raíz cualquiera se puede transformar a una potencia con un exponente fraccionario ejemplo:

54


Problema y = 3Ö x esto es equivalente a y-3*x1/2 entonces //hay que usar la función pow() para trabajar correctamente y=3*Math.pow(x,0.5);// En este ejemplo no funcional se esta dando por supuesto que no interesa el tipo de dato que requiere la función pow () para trabajar correctamente. Para realizar operaciones con objetos numéricos, es importante tener en cuenta que no se pueden hacer directamente operaciones con ellos ni tampoco pueden recibir resultados en ellos, lo que se debe hacer es usar una variable temporal de tipo apropiado, hacer operaciones con dicha variable y al final si se quiere convertir esta variable al objeto numérico apropiado ejemplo: integer alfa = new Integer(20); Double zeta = new Double(5); Double alfa1= 0, zeta1=0; Alfa1=alfa.doubleValue(); Zeta1=zeta.doubleValue(); Alfa1=alfa1 + zeta1; Desplegar alfa1; Como se observa se crearon dos objetos numéricos, luego dos variables numéricas normales, luego estas dos últimas variables se cargan con los objetos numéricos que emplean métodos propios para convertirlos a datos normales. La librería matemática completa incluye: Class Math Public final class java.lang.math extends java.Objet { // fields public final static double E public final static double PI; // Metodos public static double abs(double a); public static float abs(float a); public static int abs(int a); public static long abs(long a); public static double acos(double a); public static double asin(double a); public static double atan(double a); public static double atan2(double a, double b); public static double ceil(double a); public static double cos(double a); public static double exp(double a); public static double floor(double a);

55


public static double IEEEremainder(double f1, double f2); public static double log(double a); public static double max(double a, double b); public static float max(float a, float b); public static int max(int a, int b); public static long max(long a, long b); public static double min(double a, double b); public static float min(float a, float b); public static int min(int a, int b); public static long min(long a, long b); public static double pow(double a, double b); public static double random(); public static double rint(double a); public static long round(double a); public static int round(float a); public static double sin(double a); public static double sqrt(double a); public static double tan(double a); }

Lección 23 5.3.4 E/S caracteres: Los programas en java realizan la E/S a través de flujos(stream). Un flujo es una abstracción que produce o consume información. Un flujo esta relacionado con un dispositivo físico a través del sistema de E/S de java. Todos los flujos se comportan de la misma forma, incluso aunque estén relacionados con distintos dispositivos físicos. Esto significa que un flujo de entrada puede abstraer distintos tipos de entrada, desde un archivo de disco o una conexión de red. Clases de flujos: java implementa los flujos dentro de una jerarquía de clases definida en el paquete java.io. En la parte superior hay dos clases abstractas que son:  InputStream OutputStream Estas clases definen los métodos read( ) y write( ) que respectivamente leen y escriben bytes de datos, hay que tener en encuenta que estos métodos están declarados como abstracto dentro de inputStream y OutputStream y son sobrescritos en las clases derivadas. Flujos predefinidos: java importa automáticamente el paquete java.lang. Este paquete define una clase llamada system que encapsula algunos aspectos del entorno de ejecución. System.out: salida estándar. Por defecto, es la consola

56


System.in: hace referencia a la entrada estándar que es por defecto el teclado System. Err: hace referencia al flujo de error estándar que por defecto es la consola. Java no tiene un método de entrada por consola generalizado que sea similar a la función scanf() de c o a lo operadores de entrada de C++. Ejemplo: // ejemplo del método read(). Import java.io.*; Class Usuread { public static void main (string args[]) throws IOExceptoon { char c; system.out.println(“ introduzca caracteres, ‘q’ para salir.”); // lee caracteres do { c = (char) System. In.read(); } while(c = != ‘q’); } } Cuando ejecute el programa el resultado debe ser el siguiente: Introduzca caracteres, ‘q’ para salir 123abcq 1 2 3 a b c q Lección 24 5.3.5 Estructuras De Control Durante un programa existen acciones que se han de repetir un número determinado de veces. Por ejemplo, leer 3 caracteres de un flujo de entrada in se codificaría: in.read(); in.read(); in.read(); Este código además de poco elegante sería inviable para una repetición de 3000 lecturas. Por eso aparecen las estructuras de control, que facilitan que determinadas acciones se realicen varias veces, mientras que una condición se cumpla, y en definitiva, tomar decisiones de qué hacer en función de las condiciones que se den en el programa en un momento dado de su ejecución. Así, nuestro ejemplo se podría indicar como: i

57


nt i=0; for ( i=0 ; i <= 3 ; i++ ) in.read(); Donde bastaría cambiar el 3 por cualquier otro número para que la lectura se repitiese ese número de veces. El lenguaje Java soporta las estructuras de control: Sentencia Toma de decisión Bucle Misceláneo

Clave if-else, switch-case for, while, do-while break, continue, label:, return, goto

Tabla 18: Estructuras de control Aunque goto es una palabra reservada, actualmente el lenguaje Java no soporta la sentencia goto. Se puede utilizar las sentencias de bifurcación en su lugar. 5.3.5.1 Las sentencias condicionales: if y switch 5.3.5.1.1 La sentencia if – else La sentencia if-else de Java dota a los programas de la habilidad de ejecutar distintos conjuntos de sentencias según algún criterio. La sintaxis de la sentencia if-else es: If ( condición ) Bloque de código a ejecutar si la condición es cierta else Bloque de código a ejecutar si la condición es falsa La parte del else es opcional, y un bloque de código puede ser simplemente la sentencia vacía; para representar que en ese caso no se ha de ejecutar nada. Supongamos que un programa debe realizar diferentes acciones dependiendo de si el usuario oprime el botón aceptar o el botón cancelar en una ventana de dialogo. Nuestro programa puede realizar esto usando la sentencia if - else: // La respuesta es Aceptar o Cancelar If (respuesta == Aceptar) { // código para realizar la acción Aceptar System.out.println( "Su peticion esta siendo atendida" ); } else { // código para realizar la acción Cancelar System.out.println( "Cancelando accion" );

58


} Se pueden anidar expresiones if-else, para poder implementar aquellos casos con múltiples acciones. Esto es lo que se suele denominar como sentencias else if. Por ejemplo, supongamos que se desea escribir un programa que clasifique según el contenido de una variable valor, asigne una letra a una variable clasificacion: A para un valor del 100-91, B de 90-81, C para 80-71 y F si no es ninguno de los anteriores: int valor; char clasificacion; if (valor > 90) { clasificacion='A'; } else if (valor > 80) { clasificacion='B'; } else if (valor > 70) { clasificacion='C'; } else { clasificacion='F'; } Se pueden escribir los if en las mismas líneas que los else, pero se recomienda utilizar la tabulación (como se ha podido ver en el ejemplo), pues es más clara para el lector. 5.3.5.1.2. La sentencia switch Mediante la sentencia switch se puede seleccionar entre varias sentencias según el valor de cierta expresión. Es una instrucción de decisión múltiple donde el compilador prueba o busca casos, o se usa una condición compuesta muy grande. La forma general de switch es la siguiente: switch ( expresionMultivalor ) { case valor1 : conjuntoDeSentencias; break; case valor2 : conjuntoDeSentencias; break; case valor3: conjuntoDeSentencias; break; default: conjuntoDeSentencias; break;

59


} La sentencia switch evalúa la expresiónMultivalor y ejecuta el conjuntoDeSentencias que aparece junto a la cláusula case cuyo valor corresponda con el de la expresiónMultivalor. Cada sentencia case debe ser única y el valor que evalúa debe ser del mismo tipo que el devuelto por la expresiónMultivalor de la sentencia switch. Las sentencias break que aparecen tras cada conjuntoDeSentencias provocan que el control salga del switch y continúe con la siguiente instrucción al switch. Las sentencias break son necesarias porque sin ellas se ejecutarían secuencialmente las sentencias case siguientes. Existen ciertas situaciones en las que se desea ejecutar secuencialmente algunas o todas las sentencias case, para lo que habrá que eliminar algunos break. Finalmente, se puede usar la sentencia default para manejar los valores que no son explícitamente contemplados por alguna de las sentencias case. Su uso es altamente recomendado. Por ejemplo, supongamos un programa con una variable entera meses cuyo valor indica el mes actual, y se desea imprimir el nombre del mes en que estemos. Se puede utilizar la sentencia switch para realizar esta operación: int meses; switch ( meses ) { case 1: System.out.println( "Enero" ); break; case 2: System.out.println( "Febrero" ); break; case 3: System.out.println( "Marzo" ); break; //Demas meses // . . . case 12: System.out.println( "Diciembre" ); break; default: System.out.println( "Mes no valido" ); break; } Por supuesto, se puede implementar esta estructura como una sentencia if else if: int meses; if ( meses == 1 ) { System.out.println( "Enero" ); } else if ( meses == 2 ) { System.out.println( "Febrero" ); } // Y así para los demás meses

60


El decidir si usar la sentencia if o switch depende del criterio de cada caso. Se puede decidir cuál usar basándonos en la legibilidad, aunque se recomienda utilizar switch para sentencias con más de tres o cuatro posibilidades. 5.3.5.2. Sentencias de iteración o bucles: for, do, while 5.3.5.2.1 Bucle while El bucle while es el bucle básico de iteración. Sirve para realizar una acción sucesivamente mientras se cumpla una determinada condición. La forma general del bucle while es la siguiente: while ( expresiónBooleana ) { sentencias; }; Las sentencias se ejecutan mientras la expresiónBooleana tenga un valor de verdadero. Se utiliza, por ejemplo para estar en un bucle del que no hay que salir hasta que no se cumpla una determinada condición. Por ejemplo, multiplicar un número por 2 hasta que sea mayor que 100: int i = 1; while ( i <= 100 ) { i = i * 2; } Con él se podrían eliminar los bucles do-while y for por ser extensiones de éste, pero que se incluyen en el lenguaje para facilitar la programación. 5.3.5.2.2 Bucle do-while El bucle do-while es similar al bucle while, pero en el bucle while la expresión se evalúa al principio del bucle y en el bucle do-while la evaluación se realiza al final. La forma general del bucle do-while es la siguiente: Do { sentencias; } while ( expresiónBooleana ); La sentencia do-while es el constructor de bucles menos utilizado en la programación, pero tiene sus usos, cuando el bucle deba ser ejecutado por lo menos una vez.

61


Por ejemplo, cuando se lee información de un archivo, se sabe que siempre se debe leer por lo menos un carácter: Int c; do { c = System.in.read( ); // Sentencias para tratar el carácter c } while ( c != -1 ); // No se puede leer más (Fin fichero) 5.3.5.2.3 Bucle for Mediante la sentencia for se resume un bucle do-while con una iniciación previa. Es muy común que en los bucles while y do-while se inicien las variables de control de número de pasadas por el bucle, inmediatamente antes de comenzar los bucles. Por eso el bucle for está tan extendido. Se utiliza para repetir una instrucción o un grupo de instrucciones un determinado número de veces. Su formato general es: For (inicialización; condición; incremento) { Instrucción(es); }; En su forma simple la inicialización es una instrucción de asignación que carga una variable de control de ciclo con un valor inicial. La condición es una expresión relacional que evalúa la variable de control de ciclo contra un valor final o de parada que determina cuando debe acabar el ciclo. El incremento define la manera en que la variable de control de ciclo debe cambiar cada vez que el computador repite el ciclo. Se deben separar esos tres argumentos con punto y coma. Ejemplo: Import java.io.* ; Import javax.servlet.* ; Import javax.servlet.http* ; Public class prog7 extends Http.*; { public void doGet(HttpServetRequest request,HttpSerletResponse response) throws ServletException,IOException {

62


printWriter pagina=respionse.getWriter(); response.setContentType(“text/html”); pagina.println(“”); int x; for(x=1;x<=10;x++) {pagina.printl(“x=”+x+”
”); pagina.println(“”); pagina.close(); pagina.flusch(); }; public void destroy(){sper.destroy();}; } Lección 25 5.3.5.3 Sentencias de salto: break, continue y return 5.3.5.3.1 Sentencia break La sentencia break provoca que el flujo de control salte a la sentencia inmediatamente posterior al bloque en curso. Ya se ha visto anteriormente la sentencia break dentro de la sentencia switch. El uso de la sentencia break con sentencias etiquetadas es una alternativa al uso de la sentencia goto, que no es soportada por el lenguaje Java. Se puede etiquetar una sentencia poniendo un identificador Java válido seguido por dos puntos antes de la sentencia: nombreSentencia: sentenciaEtiquetada La sentencia break se utiliza para salir de una sentencia etiquetada, llevando el flujo del programa al final de la sentencia de programa que indique: break nombreSentencia2; Un ejemplo de esto sería el programa: void gotoBreak() { System.out.println("Ejemplo de break como 'goto' "); a: for( int i=1; i<10; i++ ) { System.out.print(" i="+i); for( int j=1; j<10; j++ ) { if ( j==5 ) break a; //Sale de los dos bucles!!! System.out.print(" j="+j); } System.out.print("No llega aquí"); } }

63


Al interpretar break a, no solo se rompe la ejecución del bucle interior (el de j), sino que se salta al final del bucle i, obteniéndose: i=1 j=1 j=2 j=3 Nota: Se desaconseja esta forma de programación, basada en goto, y con saltos de flujo no controlados. 5.3.5.3.2 Sentencia continue Del mismo modo que en un bucle se puede desear romper la iteración, también se puede desear continuar con el bucle, pero dejando pasar una determinada iteración. Se puede usar la sentencia continue dentro de los bucles para saltar a otra sentencia, aunque no puede ser llamada fuera de un bucle. Tras la invocación a una sentencia continue se transfiere el control a la condición de terminación del bucle, que vuelve a ser evaluada en ese momento, y el bucle continúa o no dependiendo del resultado de la evaluación. En los bucles for además en ese momento se ejecuta la cláusula de incremento (antes de la evaluación). Por ejemplo el siguiente fragmento de código imprime los números del 0 al 9 no divisibles por 3: for ( int i = 0 ; i < 10 ; i++ ) { if ( ( i % 3 ) == 0 ) continue; System.out.print( " " + i ); } Del mismo modo que break, en las sentencias continue se puede indicar una etiqueta de bloque al que hace referencia. Con ello podemos referirnos a un bloque superior, si estamos en bucles anidados. Si dicha etiqueta no es indicada, se presupone que nos referimos al bucle en el que la sentencia continue aparece. Por ejemplo, el siguiente fragmento de código: void gotoContinue( ) { f for ( int i=1; i <5; i++ ) { for ( int j=1; j<5; j++ ) { if ( j>i ) { System.out.println(" "); continue f; } System.out.print( " " + (i*j) );

64


} } } En este código la sentencia continue termina el bucle de j y continua el flujo en la siguiente iteración de i. Ese método imprimiría: 1 24 369 4 8 12 16 Nota: Se desaconseja esta forma de programación, basada en goto, y con saltos de flujo no controlados. 5.3.5.3.3 Sentencia return La última de las sentencias de salto es la sentencia return, que puede usar para salir del método en curso y retornar a la sentencia dentro de la cual se realizó la llamada. Para devolver un valor, simplemente se debe poner el valor (o una expresión que calcule el valor) a continuación de la palabra return. El valor devuelto por return debe coincidir con el tipo declarado como valor de retorno del método. Cuando un método se declara como void se debe usar la forma de return sin indicarle ningún valor. Esto se hace para no ejecutar todo el código del programa: int contador; boolean condicion; int devuelveContadorIncrementado() { return ++contador; } void metodoReturn() { //Sentencias if ( condicion == true ) return; //Más sentencias a ejecutar si condición no vale true } 5.4 ACTIVIDADES COMPLEMENTARIAS Parte Uno: 1. Explique cual es la diferencia de la estructura de un programa en C y Java. 2. ¿qué instrucciones debemos tener en cuenta para crear un programa sencillo? 3. Investigue sobre los métodos de definición para complementar el tema 4. Realice un mapa conceptual sobe el tema anterior.

65


5. Exponga 10 ventajas de para utilizar instrucciones repetitivas 6. Realice un mapa conceptual con 20 términos sobre tipo de datos y declaraciones. 7. Diseñar un programa que despliegue los números del 20 al 30. 8. Diseñar un programa de los múltiplos de 5, entre 10 y 50, acompañados de su factorial y logaritmo respectivo. 9. Diseñar un programa donde se despliegue las tablas de multiplicar que usuario indique. 10. Diseñar un programa que muestre los múltiplos de 4 entre 60 y 20 acompañados de su logaritmo de base 10 y base e respectivos. 11. Construir la tabla de dividir que el usuario indique. 12. Diseñar un programa que capture un deporte cualquiera y despliegue dos implementos deportivos apropiados. 13. construir un programa que capture un número cualesquiera y diga si es o no es mayor de 50 y múltiplo de tres. 14. construir un programa que indique si un número es par positivo. 15. construir un programa que capture los datos de un empleado, desplegar en una página su cheque semanal si gana más de $500.000 y si esta en el departamento de producción, en caso contrario desplegar en otra página un bono del 25% de su sueldo semanal. Parte Dos: Realizar los ejercicos complementarios de Laboratorios de la Guia de Laboratotios y Consultar Bibliografia de Libros Virtual de la Unad y otros Autores 1. Autor: Deitel y Deitel Introducción DOO con UML y los Patrones de Diseño JDBC tm, SERVLETS, JSP tm Editorial Pearson Prentice Hall Quinta Edición, 2. David Arnow Gerald Weiss Introducción a la Programación con Java tm Actualización a la Versión 2 de Java Editorial Addison Wesley 3. Fcd Javier Ceballos Java 2 Curso de Programación 2 Edición Editorial Alfaomega Ra-Ma 4. Agustin Froute Java 2 Manual Usuario tutorial 3 Edición Editorial Alfaomega Ra-Ma 5. Herbert shildt Fundamentos de Programación Java 2 Editorial Mc Graw Hill . para conocer el lenguaje de programación JAVA ya que están resueltos solo los puede digitar compilar y ejecutar en la casa o laboratorio de su correspondiente CEAD o CERES.

66


Lección 26 Capitulo 6 Guia de Laboratorio 6.1. CAJAS DE DIALOGO El método showMessageDialog Este método nos permite mostrar diálogos que muestran un mensaje y contienen un botón de aceptación. Los parámetro mínimos necesarios dependen del carácter del mensaje aunque general mente son la ventana padre, el mensaje a mostrar, el título del diálogo y el tipo de mensaje que se mostrará. En las siguientes figuras podremos ver algunos ejemplos junto al código que lo genera. JOptionPane.showMessageDialog( null, “Diálogo de información”);

JOptionPane.showMessageDialog( null, JOptionPane.WARNING_MESSAGE);

JOptionPane.showMessageDialog( JOptionPane.ERROR_MESSAGE);

null,

“Diálogo

“Diálogo

de

advertencia”,

de

error”,

“Título

“Título

del

del

Mensaje”,

Mensaje”,

El método showInputDialog Este método nos permite mostrar diálogos estandarizados que nos piden que introduzcamos algún dato. Al igual que en los métodos anteriores los argumentos que utilizan principalmente son el mensaje a mostrar, el título, etc. A continuación vemos un ejemplo de uso de este método. String n = JOptionPane.showInputDialog(null, "Introduce el dato");

67


Como podemos observar en el código anterior este método nos devuelve una cadena que contiene los datos que hemos introducido en el diálogo. DESARROLLO DEL TALLER 1. Abra el Aplicativo JCREATOR LE (Inicio>Todos Los Programas>JCREATOR LE>JCREATOR LE) 2. Es Necesario crear el archivo java: Menú File>New>File a. En la casilla de texto Name: coloque el nombre del programa con extensión java), en este caso Interfaz b. En la Casilla de Texto Location: C:\ o utilice el botón … y seleccione C: (Carpeta Raíz) c. Pulse el Botón Finish 3. En la Ventana de Código escriba: import javax.swing.*; public class Interfaz { public static void main(String args[]) { JOptionPane.showMessageDialog( null, "Diálogo de información"); JOptionPane.showMessageDialog( null, "Diálogo de advertencia", "Título del Mensaje", JOptionPane.WARNING_MESSAGE); JOptionPane.showMessageDialog( null, "Diálogo de error", "Título del Mensaje", JOptionPane.ERROR_MESSAGE); String n = JOptionPane.showInputDialog(null, "Introduce el dato"); } } donde las cajas de Dialogo están en el paquete de clases javax.swing, por eso, en la cláusula import javax.swing.*; 4. Compile y Ejecute el Programa Menú Build > Compile File Menú Build > Execute File

6.2. Definiciones de Arreglos

68

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA CONTENIDO MODULO DEL CUSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS 1. Declaración de un arreglo: int A[]; // A es un arreglo de enteros int A[10]; // error, el tamaño no va aquí int[] A; // A es un arreglo de enteros int A,B[]; // A es un entero, B un arreglo int[] A,B; // A y B son arreglos String S[]; // S es un arreglo de strings S[1]="" // error, el arreglo no ha sido // creado 2. Creación de un arreglo int A[]= new int[10]; // 10 enteros Subindicación de un arreglo: A[0], A[1], ..., A[9] // correcto A[10] // error, índice fuera // de rango 3. Modificación de un arreglo: A[3]= 8; 4. Tamaño de un arreglo: A.length // correcto A.length() // error, sin paréntesis 5. Inicialización de un arreglo: for (int i=0; i
69

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA CONTENIDO MODULO DEL CUSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS { public static void main(String[] args) { int n,i,j,aux; int A[]; n=Integer.parseInt(JOptionPane.showInputDialog(null,"Digite la dimension: ")); A=new int[n]; for(i=0;i
6.5. ORDENAMIENTO DE UN VECTOR. METODO LINEAL import javax.swing.*; public class OrdenarLineal { public static void main(String[] args)

70

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA CONTENIDO MODULO DEL CUSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS { int n,i,j,aux; int A[]; n=Integer.parseInt(JOptionPane.showInputDialog(null,"Digite la dimension: ")); A=new int[n]; for(i=0;iA[j]) { aux=A[i]; A[i]=A[j]; A[j]=aux; } System.out.println("Vector Ordenado"); for(i=0;i
71

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA CONTENIDO MODULO DEL CUSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS if(A[j]>A[j+1]) { aux=A[j]; A[j]=A[j+1]; A[j+1]=aux; } System.out.println("Vector Ordenado"); for(i=0;iA[j]) { aux=A[i]; A[i]=A[j]; A[j]=aux; } System.out.println("Vector Ordenado"); for(i=0;i
72

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA CONTENIDO MODULO DEL CUSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS System.out.println("Existe: "+j+" en la Posicion: "+i); else System.out.println("No Existe "); System.exit(0); } } 6.8. BUSQUEDA DE UN ELEMENTO EN UN VECTOR ORDENADO. METODO BINARIA import javax.swing.*; public class BuscarBinaria { public static void main(String[] args) { int n,i,j,aux,mitad,menor,mayor; int A[]; n=Integer.parseInt(JOptionPane.showInputDialog(null,"Digite la dimension: ")); A=new int[n]; for(i=0;iA[j]) { aux=A[i]; A[i]=A[j]; A[j]=aux; } System.out.println("Vector Ordenado"); for(i=0;ij) mayor=mitad-1; if(A[mitad]=menor); if(A[mitad]==j)

73

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA CONTENIDO MODULO DEL CUSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS System.out.println("Existe: "+j+" en la Posicion: "+mitad); else System.out.println("No Existe "); System.exit(0); } }

6.9. IMPLEMENTACION DE CLASES QUE ADMINISTRAN ARREGLOS 6.9.1. Programa 1. Creación de una clase Arreglo import javax.swing.*; import java.util.*; class Arreglo { int A[]=new int[100]; int aux; int i,j,n; public Arreglo(int B[]) //Constructor { if(B.length<=100) n=B.length; else n=100; for(i=0;i=A[i+1];i++); if(i
74

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA CONTENIDO MODULO DEL CUSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS boolean buscardesc(int x) // Busqueda Descendente { for(i=0;ix;i++); if(iA[j]) { aux=A[i]; A[i]=A[j]; A[j]=aux; } } void ordenardesc()// Ordenar Descendente { for(i=0;i
75

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA CONTENIDO MODULO DEL CUSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS aux=A[i]; A[i]=A[j]; A[j]=aux; } } } public class Arreglos { public static void main(String args[]) { int i,opcion,x; int B[]=new int[10]; Random R=new Random(); for(i=0;i6); if(opcion!=6) { switch(opcion) { case 1:Z.lectura(); break; case 2:Z.ordenarasc(); break; case 3:Z.ordenardesc(); break; case 4: x=Integer.parseInt(JOptionPane.showInputDialog(null," Numero a Buscar ")); if(!Z.buscarasc(x) && !Z.buscardesc(x) && !Z.busqueda(x)) JOptionPane.showMessageDialog(null,x+" No existe"); else JOptionPane.showMessageDialog(null,x+" Existe"); break; case 5: Z.consulta(); } } }while(opcion!=6);

76

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA CONTENIDO MODULO DEL CUSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS System.exit(0); } } 6.9.2 Programa 2. Uso de un Objeto StringBuffer para la presentación de un vector. import java.util.*; import javax.swing.*; class CasoVector1 { StringBuffer P=new StringBuffer(); int i,j,aux; int A[]=new int[10]; Random R=new Random(); public CasoVector1() { P.append("Vector de Entrada: "); for(i=0;iA[j]) { aux=A[i]; A[i]=A[j]; A[j]=aux; } } String impresion() { return P.toString(); } void adicionOrdenado() { P.append(" Vector Ordenado: "); for(i=0;i
77

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA CONTENIDO MODULO DEL CUSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS int i,j,aux; int A[]=new int[10]; Random R=new Random(); public CasoVector2() { for(i=0;iA[j]) { aux=A[i]; A[i]=A[j]; A[j]=aux; } } String impresion() { return P.toString(); } } public class VectorCasos { public static void main(String[] args) { CasoVector1 X=new CasoVector1(); CasoVector2 Y=new CasoVector2(); JOptionPane.showMessageDialog(null," Caso Vector 1: \n"+X.impresion().toString()); JOptionPane.showMessageDialog(null," Caso Vector 2: \n"+Y.impresion().toString()); System.exit(0); } } 6.9.3. Programa 3. Invertir un Arreglo import javax.swing.*;

78

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA CONTENIDO MODULO DEL CUSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS class Inverso { int i,j,k; void pasar(char C[],String S) { j=-1; for(i=S.length()-1;i>=0;i--) { j++; C[j]=S.charAt(i); } } String pasar(String S) { char C[]=new char[S.length()]; j=-1; for(i=S.length()-1;i>=0;i--) { j++; C[j]=S.charAt(i); } return new String().valueOf(C).toString(); } /* String pasar(String S) { StringBuffer B=new StringBuffer(); for(i=S.length()-1;i>=0;i--) B.append(S.charAt(i)); return B.toString(); }*/ void pasar(int C[],int n) { j=-1; while(n>0) { j++; C[j]=n%10; n/=10; } } int pasar(int n) { int m=n; k=0; while(m>0) { if(k==0) k=1; else k*=10; m/=10; } m=0; while(n>0) { m=m+((n%10)*k);

79

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA CONTENIDO MODULO DEL CUSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS n/=10; k/=10; } return m; } } public class PasoInverso { public static void main(String[] args) { Inverso I=new Inverso(); String S; int n; do { n=0; S=JOptionPane.showInputDialog(null," Digite Valor a Invertir: "); try { n=Integer.parseInt(S); } catch(NumberFormatException e){n=0;} } while(n==0); char C[]=new char[S.length()]; int A[]=new int[S.length()]; StringBuffer B=new StringBuffer(); int i; I.pasar(C,S); I.pasar(A,n); JOptionPane.showMessageDialog(null," Valor Inverso de String a char[]: "+new String().valueOf(C).toString()); for(i=0;i
Lección 27 6.10. PROGRAMACION AVANZADA. USO DE MATRICES 6.10.1. Programa Lectura y Escritura de Matrices import java.util.*; import javax.swing.*; class LecturaEscrituraMatriz { public static void main(String[] args) { int filas=Integer.parseInt(JOptionPane.showInputDialog(null,"Digite las Filas: ")); int columnas=Integer.parseInt(JOptionPane.showInputDialog(null,"Digite las columnas: ")); int i,j; Random R=new Random(); int A[][]=new int[filas][columnas];

80

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA CONTENIDO MODULO DEL CUSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS //Lectura() for(i=0;i=10) System.out.print(A[i][j]+" "); else System.out.print(A[i][j]+" "); } } System.out.println(); System.exit(0); } } import java.util.*; import javax.swing.*; class SumaDiagTran { public static void main(String[] args) { int filas=Integer.parseInt(JOptionPane.showInputDialog(null,"Digite las Filas: ")); int columnas=Integer.parseInt(JOptionPane.showInputDialog(null,"Digite las columnas: ")); int i,j,k; int d=0,t=columnas-1; int sumad=0,sumat=0; Random R=new Random(); int A[][]=new int[filas][columnas]; //Lectura() for(i=0;i=10) System.out.print(A[i][j]+" "); else System.out.print(A[i][j]+" ");

81

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA CONTENIDO MODULO DEL CUSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS } } System.out.println(); System.out.println("Suma de Diagonal: "+sumad+" Suma Transversal: "+sumat); System.exit(0); } } 6.10.2. Programa Suma de Diagonales y Transversales import java.util.*; import javax.swing.*; class SumaDiagTran { public static void main(String[] args) { int n=Integer.parseInt(JOptionPane.showInputDialog(null,"Digite Dimension: ")); int i,j,k; int d=0,t=n-1; int sumad=0,sumat=0; Random R=new Random(); int A[][]=new int[n][n]; //Lectura() for(i=0;i=10) System.out.print(A[i][j]+" "); else System.out.print(A[i][j]+" "); } } System.out.println(); System.out.println("Suma de Diagonal: "+sumad+" Suma Transversal: "+sumat); System.exit(0); } } 6.10.3. Programa de Diagonal import java.util.*; import javax.swing.*;

82

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA CONTENIDO MODULO DEL CUSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS class Diagonal { public static void main(String[] args) { int n=Integer.parseInt(JOptionPane.showInputDialog(null,"Digite Dimension: ")); int i,j,k; int d=0,t=n-1; int A[][]=new int[n][n]; //Lectura() for(i=0;i
83

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA CONTENIDO MODULO DEL CUSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS { System.out.println(); for(j=0;j
84

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA CONTENIDO MODULO DEL CUSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS { if(A[pos][1]>=cant) { A[pos][1]=A[pos][1]-cant; A[pos][3]=A[pos][3]+cant; } else JOptionPane.showMessageDialog(null,"No se puede realizar la venta...no hay existencia"); } void compra(int cant,int pos) { A[pos][1]=A[pos][1]+cant; A[pos][2]=A[pos][2]+cant; } String impresion() { StringBuffer P=new StringBuffer(); P.append(" CODIGO SALDO ENTRADA SALIDA"); for(i=0;i
85

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA CONTENIDO MODULO DEL CUSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS X.compra(Integer.parseInt(JOptionPane.showInputDialog(null," Digite Cantidad a Comprar ")),pos); break; case 2: pos=X.existe(Integer.parseInt(JOptionPane.showInputDialog(null," Digite Codigo "))); if(pos==-1) JOptionPane.showMessageDialog(null,"No existe Codigo"); else X.venta(Integer.parseInt(JOptionPane.showInputDialog(null," Digite Cantidad a Venta ")),pos); break; case 3: JOptionPane.showMessageDialog(null," Inventario \n"+X.impresion().toString()); } }while(opc!=4); System.exit(0); } }

Lección 28 6.10.6. Programa Simulación de un Parqueadero import javax.swing.*; import java.util.*; class Parqueo { int n=10,i,j,k; int h,m,ha,hf; int Militar[][]=new int[10][10]; // Hora Militar de Entrada de Vehiculo int Entrada[][]=new int[10][10]; // Hora de Entrada Vehiculo AM/PM int Placa[][]=new int[10][10]; // Placa del Vehiculo int hora=5,minuto=59; Random R=new Random(); boolean lleno() { k=0; for(i=0;i
86

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA CONTENIDO MODULO DEL CUSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS while(hhora+2); m=Math.abs(R.nextInt()%59+0); hf=(h*60)+m; } while(hf<=ha); hora=h; minuto=m; } boolean noatiende() { if(hora>=20) return true; else return false; } void asignar(int placa) { do { i=m=Math.abs(R.nextInt()%(n-1)+0); j=m=Math.abs(R.nextInt()%(n-1)+0); } while(Entrada[i][j]!=0); reloj(); Militar[i][j]=(hora*100)+minuto; Entrada[i][j]=(hora*60)+minuto; Placa[i][j]=placa; } boolean existe(int placa) { boolean esta=false; i=0; while(i
87

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA CONTENIDO MODULO DEL CUSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS int salida(int placa) { if(existe(placa)) { reloj(); hf=(hora*60)+minuto; ha= (hora*100)+minuto; k=(hf-Entrada[i][j])*10; JOptionPane.showMessageDialog(null,"Placa: "+placa+"\n Hora de Entrada: "+leerReloj(Militar[i][j]).toString()+" \n Hora de Salida: "+leerReloj(ha).toString()+" \n Pago:"+k); Entrada[i][j]=0; Placa[i][j]=0; Militar[i][j]=0; } else { JOptionPane.showMessageDialog(null,"No existe la placa:"+placa); k=0; } return k; } String impresion() { StringBuffer P=new StringBuffer(); P.append(" PLACA ENTRADA"); for(i=0;i
88

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA CONTENIDO MODULO DEL CUSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS placa=Integer.parseInt(JOptionPane.showInputDialog(null,"Digite Placa: "," Parqueadero Doris",JOptionPane.QUESTION_MESSAGE)); if(P.existe(placa)) JOptionPane.showMessageDialog(null,"Placa: "+placa+" Ya Esta en el Parqueadero"); else P.asignar(placa); } break; case 2: if(!P.noatiende()) { placa=Integer.parseInt(JOptionPane.showInputDialog(null,"Digite Placa: "," Parqueadero Doris",JOptionPane.QUESTION_MESSAGE)); P.salida(placa); } break; case 3: JOptionPane.showMessageDialog(null," Parqueadero Doris \n"+P.impresion().toString()); } } while(opc!=4); System.exit(0); } }

Lección 29 6.11. Ejemplo Cola1: import javax.swing.*; import java.io.*; import java.lang.Math.*; import java.util.*; public class Cola1 { static double SALDO=0; public static void main(String[]args) { int i,opc,nit; Cola A=new Cola(10); Cola B=new Cola(20); Cliente C=new Cliente(); Object [] valores = {"1. Adicion","2. Borrar","3. Consulta Por Atender","4. Consulta Atendidos","5.Salir"}; do { String resp=(String) JOptionPane.showInputDialog(null,"Elija la Opcion", "Entrada de datos",JOptionPane.QUESTION_MESSAGE, null, valores,valores[0]); opc=Character.digit(resp.charAt(0),10); switch(opc) { case 1: C.nit=Integer.parseInt(JOptionPane.showInputDialog(null,"Escriba el número de Nit")); if(A.existe(C.nit) || B.existe(C.nit)) JOptionPane.showMessageDialog(null,"Existe Nit"); else

89

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA CONTENIDO MODULO DEL CUSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS if(A.llena()) JOptionPane.showMessageDialog(null,"No se Puede Atender Mas"); else { C.nomCliente=JOptionPane.showInputDialog(null,"Digite Nombre"); C.telefono=Integer.parseInt(JOptionPane.showInputDialog(null,"Digite Telefono")); A.adicion(C); } break; case 2: if(A.vacia()) JOptionPane.showMessageDialog(null,"Cola de Atencion Vacia"); else { A.borra(C); if(!B.llena()) B.adicion(C); } break; case 3: if(A.vacia()) JOptionPane.showMessageDialog(null,"Cola de Atencion Vacia"); else JOptionPane.showMessageDialog(null,A.imprime(" Atencion ")); break; case 4: if(B.vacia()) JOptionPane.showMessageDialog(null,"Cola de Atendidos Vacia"); else JOptionPane.showMessageDialog(null,B.imprime(" Atencion ")); } } while(opc!=5); } } class Cliente { int nit; String nomCliente; int telefono; } class Cola { int min,max,n; Cliente A[]; int i; public Cola(int n) { min=-1; max=-1; this.n=n; A=new Cliente[n]; } boolean vacia() {

90

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA CONTENIDO MODULO DEL CUSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS if(min==-1) return true; else return false; } boolean llena() { if(max==n-1) return true; else return false; } void adicion(Cliente C) { if(min==-1) min++; max++; A[max]=new Cliente(); A[max].nit=C.nit; A[max].telefono=C.telefono; A[max].nomCliente=C.nomCliente; } void borra(Cliente C) { C.nit=A[min].nit; C.telefono=A[min].telefono; C.nomCliente=A[min].nomCliente; if(min==max) min=max=-1; else min++; } boolean existe(int nit) { boolean esta=false; if(!vacia()) for(i=min;i<=max && ! esta;i++) if(A[i].nit==nit) esta=true; return esta; } String imprime(String Aviso) { String S=" Elemenos de la Cola de: "+Aviso.toString()+"\n"; for(i=min;i<=max;i++) { S=S+" "+new String().valueOf(A[i].nit).toString(); S=S+" "+A[i].nomCliente; S=S+" "+new String().valueOf(A[i].telefono).toString()+"\n"; } return S.toString(); } 6.12. Ejemplo Cola2:

91

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA CONTENIDO MODULO DEL CUSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS import javax.swing.*; import java.io.*; import java.lang.Math.*; import java.util.*; public class Cola2 { public static void main(String[]args) { int i,opc,nit; BiCola A=new BiCola(10); Info C=new Info(); Object [] valores = {"1. Adicion Mas Reciente","2. Adicion Menos Reciente","3. Borrar Menos Reciente","4. Borrar Mas Recientes","5. Consulta","6.Salir"}; do { String resp=(String) JOptionPane.showInputDialog(null,"Elija la Opcion", "Entrada de datos",JOptionPane.QUESTION_MESSAGE, null, valores,valores[0]); opc=Character.digit(resp.charAt(0),10); switch(opc) { case 1: if(A.llena()) JOptionPane.showMessageDialog(null,"No se Puede Atender Mas"); else { C.nit=Integer.parseInt(JOptionPane.showInputDialog(null,"Escriba el número de Nit")); C.nomCliente=JOptionPane.showInputDialog(null,"Digite Nombre"); C.telefono=Integer.parseInt(JOptionPane.showInputDialog(null,"Digite Telefono")); A.adicion_max(C); } break; case 2: if(A.llena()) JOptionPane.showMessageDialog(null,"No se Puede Atender Mas"); else if(!A.tope() && !A.minimo()) { C.nit=Integer.parseInt(JOptionPane.showInputDialog(null,"Escriba el número de Nit")); C.nomCliente=JOptionPane.showInputDialog(null,"Digite Nombre"); C.telefono=Integer.parseInt(JOptionPane.showInputDialog(null,"Digite Telefono")); A.adicion_min(C); } break; case 3: if(A.vacia()) JOptionPane.showMessageDialog(null,"Cola de Atencion Vacia"); else { A.borra_min(); } break; case 4: if(A.vacia()) JOptionPane.showMessageDialog(null,"Cola de Atencion Vacia");

92

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA CONTENIDO MODULO DEL CUSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS else { A.borra_max(); } break; case 5: if(A.vacia()) JOptionPane.showMessageDialog(null,"BiCola Vacia"); else JOptionPane.showMessageDialog(null,A.imprime()); } } while(opc!=6); } } class Info { int nit; String nomCliente; int telefono; } class BiCola { int min,max,n; Info A[]; int i; public BiCola(int n) { min=-1; max=-1; this.n=n; A=new Info[n]; for(i=0;i
93

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA CONTENIDO MODULO DEL CUSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS boolean minimo() { if(min==0) return true; else return false; } void adicion_max(Info C) { if(min==-1) min=0; max++; A[max].nit=C.nit; A[max].telefono=C.telefono; A[max].nomCliente=C.nomCliente; } void adicion_min(Info C) { min--; A[min].nit=C.nit; A[min].telefono=C.telefono; A[min].nomCliente=C.nomCliente;; } void borra_min() { if(min==max) min=max=-1; else min++; } void borra_max() { if(min==max) min=max=-1; else max--; } String imprime() { String S=" Elemenos de la Cola \n"; for(i=min;i<=max;i++) { S=S+" "+new String().valueOf(A[i].nit).toString(); S=S+" "+A[i].nomCliente; S=S+" "+new String().valueOf(A[i].telefono).toString()+"\n"; } return S.toString(); } } 6.13. Ejemplo Cola3: import javax.swing.*; import java.io.*; import java.lang.Math.*;

94

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA CONTENIDO MODULO DEL CUSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS import java.util.*; public class Cola3 { public static void main(String[]args) { int i,opc,nit; ColaCir A=new ColaCir(3); Info C=new Info(); Object [] valores = {"1. Adicion","2.Eliminar","3. Consulta","4.Salir"}; do { String resp=(String) JOptionPane.showInputDialog(null,"Elija la Opcion", "Entrada de datos",JOptionPane.QUESTION_MESSAGE, null, valores,valores[0]); opc=Character.digit(resp.charAt(0),10); switch(opc) { case 1: if(A.llena()) JOptionPane.showMessageDialog(null,"No se Puede Atender Mas"); else { C.nit=Integer.parseInt(JOptionPane.showInputDialog(null,"Escriba el número de Nit")); C.nomCliente=JOptionPane.showInputDialog(null,"Digite Nombre"); C.telefono=Integer.parseInt(JOptionPane.showInputDialog(null,"Digite Telefono")); A.adicion(C); } break; case 2: if(A.vacia()) JOptionPane.showMessageDialog(null,"Cola de Atencion Vacia"); else { A.borrar(); } break; case 3: if(A.vacia()) JOptionPane.showMessageDialog(null,"Cola Vacia"); else JOptionPane.showMessageDialog(null,A.imprime()); } } while(opc!=4); } } class Info { int nit; String nomCliente; int telefono; } class ColaCir { int min,max,n; Info A[];

95

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA CONTENIDO MODULO DEL CUSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS int i; String S=" "; public ColaCir(int n) { min=-1; max=-1; this.n=n; A=new Info[n]; for(i=0;i
96

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA CONTENIDO MODULO DEL CUSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS consulta(min,max); return S.toString(); } void consulta(int inf,int sup) { for(i=inf;i<=sup;i++) { S=S+" "+new String().valueOf(A[i].nit).toString(); S=S+" "+A[i].nomCliente; S=S+" "+new String().valueOf(A[i].telefono).toString()+"\n"; } } }

Lección 29 6.14. Ejemplo Cola 3 Archivos import javax.swing.*; import java.io.*; import java.lang.Math.*; import java.util.*; public class ColaArch { static double SALDO=0; public static void main(String[]args) { int i,opc,nit; Cola A=new Cola(10); if(A.salir()) System.exit(1); A.cargar(); Object [] valores = {"1. Adicion","2. Borrar","3. Consulta","4.Salir"}; do { String resp=(String) JOptionPane.showInputDialog(null,"Elija la Opcion", "Entrada de datos",JOptionPane.QUESTION_MESSAGE, null, valores,valores[0]); opc=Character.digit(resp.charAt(0),10); switch(opc) { case 1: if(A.llena() || !A.hayMas()) JOptionPane.showMessageDialog(null,"No se Puede Atender Mas"); else A.adicion(); break; case 2: if(A.vacia()) JOptionPane.showMessageDialog(null,"Cola de Atencion Vacia"); else A.borrar(); break; case 3: if(A.vacia()) JOptionPane.showMessageDialog(null,"Cola de Atencion Vacia");

97

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA CONTENIDO MODULO DEL CUSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS else JOptionPane.showMessageDialog(null,A.imprime()); break; } } while(opc!=4); A.cerrar(); System.exit(1); } } class Cola { ArchivoBase P=new ArchivoBase(); int min,max,n,d,numreg=-1; int A[]; int i; public Cola(int n) { min=-1; max=-1; this.n=n; A=new int[n]; } void cargar() { P.tabla(); } boolean salir() { if(!P.lectura("cliente.txt")) return true; cargar(); if(P.tope()==0) return true; return false; } boolean vacia() { if(min==-1) return true; else return false; } boolean llena() { if(max==n) return true; else return false; } boolean hayMas() { if(numreg
98

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA CONTENIDO MODULO DEL CUSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS } void adicion() { if(min==-1) min++; max++; numreg++; A[max]=numreg; } void borrar() { if(min==max) min=max=-1; else min++; } String imprime() { String S=" Elemenos de la Cola de: \n"; for(i=min;i<=max;i++) { S=S+P.consulta(A[i])+"\n"; } return S.toString(); } String Consulta() { return P.Consultabla(); } void cerrar() { P.cerrar(); } } class ArchivoBase { long longreg=34; StringBuffer linea=new StringBuffer(); RandomAccessFile arch; long pos=-1; //Numero de Registro long k; int numreg=-1; Hashtable H=new Hashtable(); boolean lectura(String Nom) { try { arch=new RandomAccessFile(Nom.toString(),"r"); } catch(FileNotFoundException e) { System.out.println("No Existe Archivo"); return false; } return true; }

99

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA CONTENIDO MODULO DEL CUSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS void tabla() { pos=0; numreg=-1; try { do { numreg++; H.put(new String().valueOf(numreg),new String().valueOf(pos)); pos=pos+(longreg*2); } while(pos
100

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA CONTENIDO MODULO DEL CUSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS String Consultabla() { Enumeration codigo=H.keys(); String S=null; linea=new StringBuffer(); linea.append(" Codigo Nombre Telefono \n"); while(codigo.hasMoreElements()) { S=(String) codigo.nextElement(); pos=Long.parseLong((String) H.get(S))*longreg; bajar(); linea.append("\n"); } return linea.toString(); } void cerrar() { try { arch.close(); } catch(IOException e){} } }

Lección 20 6.15. Ejemplo de Lista import javax.swing.*; class Nodo { int info; Nodo(int info) { this.info = info; } Nodo sig; } class Listas { Nodo p,q,r; Nodo cab=null; boolean busca_ant(int x) { p=q=cab; while(p!=null && p.info!=x) { q=p; p=p.sig; } if(p!=null) return true; else return false; } void recorre_ant() {

101

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA CONTENIDO MODULO DEL CUSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS p=q=cab; while(p!=null) { q=p; p=p.sig; } } void adicion(int x) { if(!busca_ant(x)) { r=new Nodo(x); if(cab==null) cab=r; else q.sig=r; r.sig=null; } } void borrar(int x) { if(busca_ant(x)) { if(p==cab) cab=cab.sig; else q.sig=p.sig; } } String consulta() { String S="C O N S U L T A \n" ; p=cab; while(p!=null) { S+=p.info+"\n"; p=p.sig; } return S.toString(); } } public class Lista { public static void main(String[]args) { int i,opc,info; Listas L=new Listas(); Object [] valores = {"1. Adicion","2. Borrar","3. Consulta","4.Salir"}; do { String resp=(String) JOptionPane.showInputDialog(null,"Elija la Opcion", "Entrada de datos",JOptionPane.QUESTION_MESSAGE, null, valores,valores[0]); opc=Character.digit(resp.charAt(0),10); switch(opc) {

102

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA CONTENIDO MODULO DEL CUSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS case 1: info=Integer.parseInt(JOptionPane.showInputDialog(null," Digite Info a Adicionar:")); L.adicion(info); break; case 2: info=Integer.parseInt(JOptionPane.showInputDialog(null," Digite Info a Borrar:")); L.borrar(info); break; case 3: JOptionPane.showMessageDialog(null,L.consulta()); break; } } while(opc!=4); System.exit(1); } } 6.16. Ejemplo de Lista Circular import javax.swing.*; class Nodo { int info; Nodo(int info) { this.info = info; } Nodo sig; } class Listas { Nodo p,q,r; Nodo cab=null; Nodo ult=null; boolean vacia() { if(cab==null) return true; else return false; } void adicion(int x) { r=new Nodo(x); if(cab==null) cab=r; else ult.sig=r; ult=r; r.sig=cab; } void borrar() { if(cab==ult)

103

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA CONTENIDO MODULO DEL CUSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS cab=ult=null; else { cab=cab.sig; ult.sig=cab; } } String consulta() { String S="C O N S U L T A \n" ; p=cab; do { S+=p.info+"\n"; p=p.sig; } while(p!=cab); return S.toString(); } } public class ListaCircular { public static void main(String[]args) { int i,opc,info; Listas L=new Listas(); Object [] valores = {"1. Adicion","2. Borrar","3. Consulta","4.Salir"}; do { String resp=(String) JOptionPane.showInputDialog(null,"Elija la Opcion", "Entrada de datos",JOptionPane.QUESTION_MESSAGE, null, valores,valores[0]); opc=Character.digit(resp.charAt(0),10); switch(opc) { case 1: info=Integer.parseInt(JOptionPane.showInputDialog(null," Digite Info a Adicionar:")); L.adicion(info); break; case 2: if(!L.vacia()) L.borrar(); break; case 3: if(!L.vacia()) JOptionPane.showMessageDialog(null,L.consulta()); break; } } while(opc!=4); System.exit(1); } } 6.17. Ejemplo de Lista y Cola

104

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA CONTENIDO MODULO DEL CUSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS import javax.swing.*; class Alumno { int Cod; String Nombre; Alumno(int Cod,String Nombre) { this.Cod = Cod; this.Nombre = Nombre; } Alumno sig; } class Programa { int Id; String Nombre; Programa sig; Alumno p,q,r; Alumno cab=null; Alumno ult=null; Programa(int Id,String Nombre) { this.Id = Id; this.Nombre = Nombre; } boolean vacia() { if(cab==null) return true; else return false; } void adicion(int x,String y) { r=new Alumno(x,y); if(cab==null) cab=r; else ult.sig=r; ult=r; r.sig=null; } void borrar() { if(cab==ult) cab=ult=null; else cab=cab.sig; } String consulta() { String S="C O N S U L T A \n" ; p=cab; while(p!=null) { S+=p.info+"\n"; p=p.sig;

105

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA CONTENIDO MODULO DEL CUSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS } return S.toString(); } } public class ListaCola { public static void main(String[]args) { int i,opc,info; Listas L=new Listas(); Object [] valores = {"1. Adicion","2. Borrar","3. Consulta","4.Salir"}; do { String resp=(String) JOptionPane.showInputDialog(null,"Elija la Opcion", "Entrada de datos",JOptionPane.QUESTION_MESSAGE, null, valores,valores[0]); opc=Character.digit(resp.charAt(0),10); switch(opc) { case 1: info=Integer.parseInt(JOptionPane.showInputDialog(null," Digite Info a Adicionar:")); L.adicion(info); break; case 2: if(!L.vacia()) L.borrar(); break; case 3: JOptionPane.showMessageDialog(null,L.consulta()); break; } } while(opc!=4); System.exit(1); } }

6.18. Ejemplo Lista Encadenada import javax.swing.*; class Nodo { int info; Nodo(int info) { this.info = info; } Nodo sig; Nodo ant; } class Listas { Nodo p,q,r; Nodo cab=null; Nodo ult=null; boolean vacia()

106

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA CONTENIDO MODULO DEL CUSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS { if(cab==null) return true; else return false; } boolean esta(int x) { p=q=cab; while(p!=null && p.infoult.info)

107

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA CONTENIDO MODULO DEL CUSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS mayor(x); else if(x
108

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA CONTENIDO MODULO DEL CUSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS p=p.ant; } return S.toString(); } } public class ListaEncadenada { public static void main(String[]args) { int i,opc,info; Listas L=new Listas(); Object [] valores = {"1. Adicion","2. Borrar","3. Consulta Ascendente","4. Consulta Descendente","5.Salir"}; do { String resp=(String) JOptionPane.showInputDialog(null,"Elija la Opcion", "Entrada de datos",JOptionPane.QUESTION_MESSAGE, null, valores,valores[0]); opc=Character.digit(resp.charAt(0),10); switch(opc) { case 1: info=Integer.parseInt(JOptionPane.showInputDialog(null," Digite Info a Adicionar:")); L.adicion(info); break; case 2: info=Integer.parseInt(JOptionPane.showInputDialog(null," Digite Info a Borrar:")); L.borrar(info); break; case 3: JOptionPane.showMessageDialog(null,L.consulta_asc()); break; case 4: JOptionPane.showMessageDialog(null,L.consulta_desc()); break; } } while(opc!=5); System.exit(1); } } 6.19. Ejemplo de Lista y Pila import javax.swing.*; class Nodo { int info; Nodo(int info) { this.info = info; } Nodo sig; } class Listas {

109

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA CONTENIDO MODULO DEL CUSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS Nodo p,r; Nodo cab=null; boolean vacia() { if(cab==null) return true; else return false; } void adicion(int x) { r=new Nodo(x); r.sig=cab; cab=r; } void borrar() { cab=cab.sig; } String consulta() { String S="C O N S U L T A \n" ; p=cab; while(p!=null) { S+=p.info+"\n"; p=p.sig; } return S.toString(); } } public class ListaPila { public static void main(String[]args) { int i,opc,info; Listas L=new Listas(); Object [] valores = {"1. Adicion","2. Borrar","3. Consulta","4.Salir"}; do { String resp=(String) JOptionPane.showInputDialog(null,"Elija la Opcion", "Entrada de datos",JOptionPane.QUESTION_MESSAGE, null, valores,valores[0]); opc=Character.digit(resp.charAt(0),10); switch(opc) { case 1: info=Integer.parseInt(JOptionPane.showInputDialog(null," Digite Info a Adicionar:")); L.adicion(info); break; case 2: if(!L.vacia()) L.borrar(); break; case 3:

110

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA CONTENIDO MODULO DEL CUSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS JOptionPane.showMessageDialog(null,L.consulta()); break; } } while(opc!=4); System.exit(1); } } 6.20. Ejemplo de Multilista import javax.swing.*; class Alumno { int Cod; String Nombre; Alumno(int Cod,String Nombre) { this.Cod = Cod; this.Nombre = Nombre; } Alumno sig; } class Programa { int Id; String Nombre; Programa sig; Alumno p,q,r; Alumno cab=null; Alumno ult=null; Programa(int Id,String Nombre) { this.Id = Id; this.Nombre = Nombre; } boolean vacia() { if(cab==null) return true; else return false; } void adicion(int x,String y) { r=new Alumno(x,y); if(cab==null) cab=r; else ult.sig=r; ult=r; r.sig=null; } void borrar() { if(cab==ult) cab=ult=null; else

111

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA CONTENIDO MODULO DEL CUSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS cab=cab.sig; } String consulta() { String S="C O N S U L T A D E A L U M N O S \n" ; p=cab; while(p!=null) { S+=p.Cod+" "+p.Nombre+"\n"; p=p.sig; } return S.toString(); } } class Facultad { Programa p,q,r; Programa cab=null; Programa ult=null; boolean vacia() { if(cab==null) return true; else return false; } void adicion(int x,String y) { r=new Programa(x,y); if(cab==null) cab=r; else ult.sig=r; ult=r; r.sig=null; } void borrar() { if(cab==ult) cab=ult=null; else cab=cab.sig; } boolean existe(int id) { p=cab; while(p!=null && p.Id!=id) p=p.sig; if(p==null) return false; else return true; } void borrarAlumno() {

112

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA CONTENIDO MODULO DEL CUSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS if(!p.vacia()) p.borrar(); } void adicionAlumno(int x,String y) { p.adicion(x,y); } String consulta() { String S="C O N S U L T A D E P R O G R A M A S \n" ; p=cab; while(p!=null) { S+=p.Id+" "+p.Nombre+"\n"; p=p.sig; } return S.toString(); } String consultaTodo() { String S="C O N S U L T A D E P R O G R A M A S \n" ; S+=p.Id+" "+p.Nombre+"\n"; S+=p.consulta(); return S.toString(); } } public class MultiLista { public static void main(String[]args) { int i,opc,cod,id; String Nombre; Facultad L=new Facultad(); Object [] valores = {"1. Adicion Programa","2. Borrar Programa","3. Consulta Programa","4.Adicion Alumno","5.Borrar Alumno","6. Consulta","7.Salir"}; do { String resp=(String) JOptionPane.showInputDialog(null,"Elija la Opcion", "Entrada de datos",JOptionPane.QUESTION_MESSAGE, null, valores,valores[0]); opc=Character.digit(resp.charAt(0),10); switch(opc) { case 1: cod=Integer.parseInt(JOptionPane.showInputDialog(null," Digite Programa a Adicionar:")); Nombre=JOptionPane.showInputDialog(null," Digite Nombre A Adicionar:"); L.adicion(cod,Nombre); break; case 2: if(!L.vacia()) L.borrar(); break; case 3: JOptionPane.showMessageDialog(null,L.consulta()); break;

113

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA CONTENIDO MODULO DEL CUSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS case 4: case 5: case 6: cod=Integer.parseInt(JOptionPane.showInputDialog(null," Digite Programa:")); if(L.existe(cod)) switch(opc) { case 4: cod=Integer.parseInt(JOptionPane.showInputDialog(null," Digite Alumno a Adicionar:")); Nombre=JOptionPane.showInputDialog(null," Digite Nombre A Adicionar:"); L.adicionAlumno(cod,Nombre); break; case 5: L.borrarAlumno(); break; case 6: JOptionPane.showMessageDialog(null,L.consultaTodo()); } } } while(opc!=7); System.exit(1); } } 6.21. Ejemplo de Pila import javax.swing.*; import java.io.*; import java.lang.Math.*; import java.util.*; public class Pila1 { static double SALDO=0; public static void main(String[]args) { int i,opc,nit; Pila A=new Pila(10); Info C=new Info(); Object [] valores = {"1. Apilar","2. Desempila","3. Consulta","4.Salir"}; do { String resp=(String) JOptionPane.showInputDialog(null,"Elija la Opcion", "Entrada de datos",JOptionPane.QUESTION_MESSAGE, null, valores,valores[0]); opc=Character.digit(resp.charAt(0),10); switch(opc) { case 1: if(A.llena()) JOptionPane.showMessageDialog(null,"No se Puede Atender Mas"); else {

114

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA CONTENIDO MODULO DEL CUSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS C.nit=Integer.parseInt(JOptionPane.showInputDialog(null,"Escriba el número de Nit")); C.nomCliente=JOptionPane.showInputDialog(null,"Digite Nombre"); C.telefono=Integer.parseInt(JOptionPane.showInputDialog(null,"Digite Telefono")); A.apila(C); } break; case 2: if(A.vacia()) JOptionPane.showMessageDialog(null,"Pila de Atencion Vacia"); else { A.desempila(); } break; case 3: if(A.vacia()) JOptionPane.showMessageDialog(null,"Pila Vacia"); else JOptionPane.showMessageDialog(null,A.imprime()); } } while(opc!=4); } } class Info { int nit; String nomCliente; int telefono; } class Pila { int cab,n; Info A[]; int i,k; public Pila(int n) { cab=-1; this.n=n; A=new Info[n]; for(i=0;i
115

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA CONTENIDO MODULO DEL CUSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS else return false; } void apila(Info C) { cab++; A[cab].nit=C.nit; A[cab].telefono=C.telefono; A[cab].nomCliente=C.nomCliente; } void desempila() { cab--; } String imprime() { String S=" Elemenos de la Pila\n"; for(i=cab;i>=0;i--) { S=S+" "+new String().valueOf(A[i].nit).toString(); S=S+" "+A[i].nomCliente; S=S+" "+new String().valueOf(A[i].telefono).toString()+"\n"; } return S.toString(); } } 6.22. Ejemplo de Arbol Binario import javax.swing.*; import java.util.*; class ArbolBin { NodoArbol raiz=null; NodoArbol p,q,r; Stack Pila=new Stack(); int fila=0; boolean existe(int x) { q=p=raiz; while(p!=null && x!=p.info) { q=p; if(x
116

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA CONTENIDO MODULO DEL CUSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS return true; } boolean adicion(int x) { if(existe(x)) return false; // System.out.println("adicion de: "+x+"raiz: "+raiz+" q:"+q+" p: "+p); r=new NodoArbol(x); r.izq=r.der=null; if(raiz==null) { raiz=r; } else { if(x
117

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA CONTENIDO MODULO DEL CUSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS Pila=null; while(s!=null) { Pila.push((Object) s); s=s.izq; } if(Pila.empty()) return false; s=(NodoArbol) Pila.pop(); if(p==raiz) raiz=s; else { if(q.izq==p) q.izq=s; else q.der=s; } if(Pila.empty()) return true; r=(NodoArbol) Pila.pop(); r.izq=s.der; s.izq=p.izq; s.der=p.der; return true; } void caso1Borrado()// P. Es Nodo Terminal { if(p==raiz) raiz=null; else { if(q.izq==p) q.izq=null; if(q.der==p) q.der=null; } } void caso2Borrado()//Hijo Unico. P.der es Null ó P.izq es Null { if(p==raiz) { if(p.izq==null) raiz=p.der; else raiz=p.izq; } else { if(p.izq==null) { if(q.izq==p) q.izq=p.der; else q.der=p.der; }

118

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA CONTENIDO MODULO DEL CUSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS else //p.der==null { if(q.izq==p) q.izq=p.izq; else q.der=p.izq; } } } void caso3Borrado()// Dos Hijos. P.der y P.izq no es null { if(!masderecha(p.izq)) if(!masizquierda(p.der)) System.out.println(" No se pudo Borrar"); } boolean borrar(int x) { if(!existe(x)) return false; if(p.izq!=null && p.der!=null) caso3Borrado(); else if(p.izq==null && p.der==null) caso1Borrado(); else caso2Borrado(); return true; } void preorden(NodoArbol p) { if(p!=null) { System.out.println(p.info); preorden(p.izq); preorden(p.der); } } void inorden(NodoArbol p) { if(p!=null) { inorden(p.izq); System.out.println(p.info); inorden(p.der); } } void posorden(NodoArbol p) { if(p!=null) { posorden(p.izq); posorden(p.der); System.out.println(p.info); } } void conteoNodo(NodoArbol p,int A[])

119

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA CONTENIDO MODULO DEL CUSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS { if(p!=null) { A[0]++; conteoNodo(p.izq,A); conteoNodo(p.der,A); } } void contarNodos() { int A[]=new int[2]; p=raiz; conteoNodo(p,A); System.out.print("El numero de nodos: "+A[0]); } void imprimirInorden() { System.out.println("Impresion de Arbol en InOrden"); p=raiz; inorden(p); } void imprimirPreorden() { System.out.println("Impresion de Arbol en PreOrden"); p=raiz; preorden(p); } void imprimirPosorden() { System.out.println("Impresion de Arbol en PosOrden"); p=raiz; posorden(p); } } class NodoArbol { int info; NodoArbol(int x) { info=x; } NodoArbol izq,der; } public class Arbol { static double SALDO=0; public static void main(String[]args) { int info,opc; ArbolBin A=new ArbolBin(); Object [] valores = {"1. Adicion","2. Borrar","3. Consulta En PreOrden","4. Consulta en InOrden","5. Consulta en PosOrden","6. Conteo de Nodos","7.Salir"}; do

120

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA CONTENIDO MODULO DEL CUSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS { String resp=(String) JOptionPane.showInputDialog(null,"Elija la Opcion", "Entrada de datos",JOptionPane.QUESTION_MESSAGE, null, valores,valores[0]); opc=Character.digit(resp.charAt(0),10); switch(opc) { case 1: info=Integer.parseInt(JOptionPane.showInputDialog(null,"Escriba info a Borrar: ")); if(!A.adicion(info)) JOptionPane.showMessageDialog(null,"Existe Info"); break; case 2: info=Integer.parseInt(JOptionPane.showInputDialog(null,"Escriba info a Adicionar: ")); if(!A.borrar(info)) JOptionPane.showMessageDialog(null,"No Existe Info"); break; case 3: A.imprimirPreorden(); break; case 4: A.imprimirInorden(); break; case 5: A.imprimirPosorden(); break; case 6: A.contarNodos(); break; } } while(opc!=7); System.exit(0); } }

121


UNIDAD 3. CLASES Y HERENCIA EN LA PROGRAMACION ORIENTADA A OBJETOS Lección 31 CAPITULO 7. Clases En La Poo Una clase es el núcleo en java para la construcción lógica en la programación de este lenguaje. La clase construye la base de programación orientada a objetos en java. La clase define un nuevo tipo de dato. Las clases son el centro de la Programación Orientada a Objetos (OOP – Object Oriented Programming). Algunos de los conceptos más importantes de la POO son los siguientes: Encapsulación. Las clases pueden ser declaradas como públicas (public) y como package (accesibles sólo para otras clases del paquete). Las variables miembro y los métodos pueden ser public, private, protected y package. De esta forma se puede controlar el acceso y evitar un uso inadecuado. Herencia. Una clase puede derivar de otra (extends), y en ese caso hereda todas sus variables y métodos. Una clase derivada puede añadir nuevas variables y métodos y/o redefinir las variables y métodos heredados. Polimorfismo. Los objetos de distintas clases pertenecientes a una misma jerarquía o que implementan una misma interface pueden tratarse de una forma general e individualizada, al mismo tiempo. 7.1 Conceptos Básicos 7.1.1 Concepto de Clase Una clase es una agrupación de datos (variables o campos) y de funciones (métodos) que operan sobre esos datos. La definición de una clase se realiza en la siguiente forma: [public] class Class name { // definición de variables y métodos ... } Donde la palabra public es opcional: si no se pone, la clase tiene la visibilidad por defecto, esto es, sólo es visible para las demás clases del paquete. Todos los métodos y variables deben ser definidos dentro del bloque {...} de la clase. Un objeto (en inglés, instance) es un ejemplar concreto de una clase. Las clases son como tipos de variables, mientras que los objetos son como variables concretas de un tipo determinado. Classname unObjeto; ClassnameotroObjeto;

122


7.1.2 Características Importantes De Las Clases: Todas las variables y funciones de Java deben pertenecer a una clase. No hay variables y funciones globales. Si una clase deriva de otra (extends), hereda todas sus variables y métodos. Java tiene una jerarquía de clases estándar de la que pueden derivar las clases que crean los usuarios. Una clase sólo puede heredar de una única clase (en Java no hay herencia múltiple). Si al definir una clase no se especifica de qué clase deriva, por defecto la clase deriva de Object. La clase Object es la base de toda la jerarquía de clases de Java. En un archivo se pueden definir varias clases, pero en un archivo no puede haber más que una clase public. Este archivo se debe llamar como la clase public que contiene con extensión *.java. Con algunas excepciones, lo habitual es escribir una sola clase por archivo. Si una clase contenida en un archivo no es public, no es necesario que el archivo se llame como la clase. Los métodos de una clase pueden referirse de modo global al objeto de esa clase al que se aplican por medio de la referencia this. Las clases se pueden agrupar en paquetes, introduciendo una línea al comienzo del archivo (paquete Nombrepaquete;). Esta agrupación en paquetes está relacionada con la jerarquía de directorios y archivos en la que se guardan las clases. 7.1.3 Concepto de Interface Una interface es un conjunto de declaraciones de funciones. Si una clase implementa (implements) una interface, debe definir todas las funciones especificadas por la interface. Las interfaces pueden definir también variables finales (constantes). Una clase puede implementar más de una interface, representando una alternativa a la herencia múltiple. En algunos aspectos los nombres de las interfaces pueden utilizarse en lugar de las clases. Por ejemplo, las interfaces sirven para definir referencias a cualquier objeto de cualquiera de las clases que implementan esa interface. Con ese nombre o referencia, sin embargo, sólo se pueden utilizar los métodos de la interface. Éste es un aspecto importante del polimorfismo. Una interface puede derivar de otra o incluso de varias interfaces, en cuyo caso incorpora las declaraciones de todos los métodos de las interfaces de las que deriva (a diferencia de las clases, las interfaces de Java sí tienen herencia múltiple). 7.2. Ejemplo De Definición De Una Clase

123


A continuación se reproduce como ejemplo la clase Círculo. // archivo Circulo.java public class Circulo extends Geometria { static int numCirculos = 0; public static final double PI=3.14159265358979323846; public double x, y, r; public Circulo(double x, double y, double r) { this.x=x; this.y=y; this.r=r; numCirculos++; } public Circulo(double r) { this(0.0, 0.0, r); } public Circulo(Circulo c) { this(c.x, c.y, c.r); } public Circulo() { this(0.0, 0.0, 1.0); } public double perimetro() { return 2.0 * PI * r; } public double area() { return PI * r * r; } // método de objeto para comparar círculos public Circulo elMayor(Circulo c) { if (this.r>=c.r) return this; else return c; } // método de clase para comparar círculos public static Circulo elMayor(Circulo c, Circulo d) { if (c.r>=d.r) return c; else

124


return d; } } // fin de la clase Circulo. En este ejemplo se ve cómo se definen las variables miembro y los métodos (cuyos nombres se han resaltado en negrita) dentro de la clase. Dichas variables y métodos pueden ser de objeto o de clase (static). Se puede ver también cómo el nombre del archivo coincide con el de la clase public con la extensión *.java. 7.3. Variables miembro A diferencia de la programación algorítmica clásica, que estaba centrada en las funciones, la programación orientada a objetos está centrada en los datos. Una clase está constituida por unos datos y unos métodos que operan sobre esos datos. 7.3.1 Variables miembro de objeto Cada objeto, es decir cada ejemplar concreto de la clase, tiene su propia copia de las variables miembro. Las variables miembro de una clase (también llamadas campos) pueden ser de tipos primitivos (boolean, int, long, double, ?) o referencias a objetos de otra clase (composición). Un aspecto muy importante del correcto funcionamiento de los programas es que no haya datos sin inicializar. Por eso las variables miembro de tipos primitivos se inicializan siempre de modo automático, incluso antes de llamar al constructor (false para boolean, el carácter nulo para char y cero para los tipos numéricos). De todas formas, lo más adecuado es inicializarlas también en el constructor. Las variables miembro pueden también inicializarse explícitamente en la declaración, como las variables locales, por medio de constantes o llamadas a métodos (esta inicialización no está permitida en C++). Por ejemplo, long nDatos = 100; Las variables miembro se inicializan en el mismo orden en que aparecen en el código de la clase. Esto es importante porque unas variables pueden apoyarse en otras previamente definidas. Cada objeto que se crea de una clase tiene su propia copia de las variables miembro. Por ejemplo, cada objeto de la clase Circulo tiene sus propias coordenadas del centro x e y, y su propio valor del radio r. Los métodos de objeto se aplican a un objeto concreto poniendo el nombre del objeto y luego el nombre del método, separados por un punto. A este objeto se le llama argumento implícito. Por ejemplo, para calcular el área de un objeto de la clase Circulo llamado c1 se escribirá: c1.area();. Las variables miembro del argumento

125


implícito se acceden directamente o precedidas por la palabra this y el operador punto. Las variables miembro pueden ir precedidas en su declaración por uno de los modificadores de acceso: public, private, protected y package (que es el valor por defecto y puede omitirse). Junto con los modificadores de acceso de la clase (public y package), determinan qué clases y métodos van a tener permiso para utilizar la clase y sus métodos y variables miembro. Existen otros dos modificadores (no de acceso) para las variables miembro: Transient: indica que esta variable miembro no forma parte de la persistencia (capacidad de los objetos de mantener su valor cuando termina la ejecución de un programa) de un objeto y por tanto no debe ser serializada (convertida en flujo de caracteres para poder ser almacenada en disco o en una base de datos) con el resto del objeto. Volatile: indica que esta variable puede ser utilizada por distintas threads sincronizadas que el compilador no debe realizar optimizaciones con esta variable. Al nivel de estos apuntes, los modificadores transient y volatile no serán utilizados. Variables miembro de clase (static) Una clase puede tener variables propias de la clase y no de cada objeto. A estas variables se les llama variables de clase o variables static. Las variables static se suelen utilizar para definir constantes comunes para todos los objetos de la clase (por ejemplo PI en la clase Circulo) o variables que sólo tienen sentido para toda la clase (por ejemplo, un contador de objetos creados como numCirculos en la clase Circulo). Las variables de clase son lo más parecido que Java tiene a las variables globales de C/C++. Las variables de clase se crean anteponiendo la palabra static a su declaración. Para llamarlas 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 su sentido queda más claro. Por ejemplo, Circulo.numCirculos es una variable de clase que cuenta el número de círculos creados. Si no se les da valor en la declaración, las variables miembro static se inicializan con los valores por defecto para los tipos primitivos (false para boolean, el carácter nulo para char y cero para los tipos numéricos), y con null si es una referencia. 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, en cuanto se llama a un método static o en cuanto 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. 7.3.2 Variables Finales

126


Una variable de un tipo primitivo declarada como final no puede cambiar su valor a lo largo de la ejecución del programa. Puede ser considerada como una constante, y equivale a la palabra const de C/C++. Java permite separar la definición de la inicialización de una variable final. La inicialización puede hacerse más tarde, en tiempo de ejecución, llamando a métodos o en función de otros datos. La variable final así definida es constante (no puede cambiar), pero no tiene por qué tener el mismo valor en todas las ejecuciones del programa, pues depende de cómo haya sido inicializada. Además de las variables miembro, también las variables locales y los propios argumentos de un método pueden ser declarados final. Declarar como final un objeto miembro de una clase hace constante la referencia, pero no el propio objeto, que puede ser modificado a través de otra referencia. En Java no es posible hacer que un objeto sea constante. 7.4 Abstracción El elemento esencial de la programación orientada a objetos en java es la abstracción. Nosotros normalmente miramos la complejidad a través de la abstracción. Por ejemplo como se puede observar en la figura vemos un conjunto de miles de partes individuales. Donde es un objeto bien definido con un comportamiento propio único. Una forma poderosa de gestionar la abstracción es utilizando clasificaciones jerárquicas; esto nos permite dividir en niveles la semántica de los sistemas complejos, obteniendo sistemas más manejables. Por ejemplo el paisaje desde el exterior es un sistema sencillo a simple vista pero una vez dentro, podemos ver que este sistema esta compuesto por varios subsistemas: el clima, la vegetación, los animales, el medio ambiente ect.. Como podemos ver la importancia de la abstracción es que se puede controlar la complejidad de un sistema utilizando abstracciones jerárquicas. En la programación se puede utilizar en los programas de algorítmicos tradicionales se pueden transformar mediante la abstracción en objetos. Realizando una secuencia de pasos don de un proceso se puede convertir en un conjunto de mensajes entre otros objetos donde cada uno de ellos tiene su propio comportamiento. Esta es la esencia de la programación orientada a objetos. Los conceptos orientada a objetos forma el corazón de java, estos conceptos se aplican en la programación cuando por ejemplo se nos presenta un problema de la vida real se realiza una clasificación jerárquica para poderlo resolver satisfactoriamente. Ejemplo:

127


Desde el exterior el cuadro es un objeto sencillo, una vez dentro podemos ver esta compuesto por varios subsistemas: las nubes, los árboles, etc. 7.5 Encapsulado Es el proceso de compartimentalización de los elementos de una abstracción que constituyen su estructura y comportamiento. La Encapsulación sirve para separar la interface de una abstracción y su implementación.  Es La

un concepto complementario al de abstracción. Encapsulación esconde la implementación del objeto que no contribuye a sus características esenciales. La Encapsulación da lugar a que las clases se dividan en dos partes: a. Interfase: captura la visión externa de una clase, abarcando la abstracción del comportamiento común a los ejemplos de esa clase. b. Implementación: comprende la representación de la abstracción, así como los mecanismos que conducen al comportamiento deseado. Se conoce también como ocultamiento o privacidad de la información. 7.6 Arreglos y cadenas Uno de los problemas más comunes en los diversos sistemas de información es el tratamiento o procesamiento de un gran volumen de datos o de información. Las variables usadas hasta ahora reciben propiamente el nombre de variable escalares, porque solo permiten almacenar o procesar un dato a la vez. Por ejemplo si quiere almacenar nombre y edad de 15 personas con el método tradicional se ocuparan de 30 variables y sólo es nombre y edad de 15 personas, agreguen más datos y más personas y ya es tiempo de empezar otro tipo de variables. Es decir, en problemas que exigen manejar mucha información o datos a la vez, variables escalares no son suficientes ya que su principal problema es que sólo

128


permiten almacenar y procesar un dato a la vez; se ocupan entonces variables que sean capaces de almacenar y , manipular conjuntos de datos a al vez Variables de tipo arreglo si permiten almacenar conjuntos de datos del mismo tipo a la vez. Cada dato dentro del arreglo se le conoce como elemento del arreglo y se simboliza y procesa (captura, operación despliegue) usando el nombre del arreglo respectivo y un subíndice indicando la posición relativa del elemento con respecto a los demás elementos del arreglo, sólo recordar que en vcpp la primera posición elemento o renglón es el 0(cero). Ejemplo: NOMBRES Juan----- nombres(0) Pedro---- nombres(1) Rosa ----nombres(2) Camilo--nombres(3) Sin embargo sus problemas son similares a los de variables normales es decir hay que declararlos, capturarlos, hacer operaciones con ellos, compilarlos, etc., 7.7 Flujo de E/S en java Java proporciona una E/s completa y flexible para archivos y redes. El sistema de E/S de java es coherente y consistente a la vez que se entienden sus fundamentos, el resto del sistema de E/s es bastante sencillo. Flujos: los programas de java realizan las E/S a través de flujos (streams) donde un flujo es una abstracción que produce o consume información y está relacionado con dispositivos físicos a través del sistema de java, los flujos se comportan de la misma forma aunque estén relacionados con diferentes dispositivos físicos. Por esta razón se pueden aplicar las mismas clases y métodos de E/S al cualquier tipo de dispositivo, donde el flujo de entrada puede abstraer distintos tipos de entrada desde un archivo de disco a un teclado de conexión de red. Del mismo modo el destino de salida puede ser una consola, un archivo de disco. Los flujos son una forma de limpia de tratar con la E/S sin necesitar que todo el código comprenda la diferencia entre un teclado y una red. La E/S por consola de java es bastante limitada y no es fácil de usar, incluso en programas sencillos. La E/S basada en texto no es importante en la programación en java. Java implementa los flujos dentro de una jerarquía de clases definida en el paquete java.io. En la parte superior de la jerarquía hay dos clases abstracta. 1. Estas clases definen algunos métodos que las otras clases 2. Implementan. Dos de los métodos más importantes son: 3. InputStream read( ) y write ( ), respectivamente lee y escribe byte de 4. OutputStream datos. Ambos métodos están declarados como abstractos

129


5. Dentro de InputStream y OutputStram Lección 32 7.8 Gestión De Excepciones Y Errores El control de flujo en un programa Java puede hacerse mediante las ya conocidas sentencias estructuradas (if, while, return). Pero Java va mucho más allá, mediante una técnica de programación denominada gestión de excepciones. Mediante las excepciones se podrá evitar repetir continuamente código, en busca de un posible error, y avisar a otros objetos de una condición anormal de ejecución durante un programa. Durante este capítulo estudiaremos la gestión de excepciones y errores, sin pretender profundizar demasiado, pero sí fijando la base conceptual de lo que este modo de programación supone. Mediante la gestión de excepciones se prescindirá de sentencias de control de errores del tipo: if ( error == true ) return ERROR; 7.8.1 Tipos de excepciones Existen varios tipos fundamentales de excepciones:  Error:

Excepciones que indican problemas muy graves, que suelen ser no recuperables y no deben casi nunca ser capturadas. Exception: Excepciones no definitivas, pero que se detectan fuera del tiempo de ejecución. RuntimeException: Excepciones que se dan durante la ejecución del programa.

130


7.8.1.1 Herencia de excepciones Java Todas las excepciones tienen como clase base la clase Throwable, que está incluida en el paquete java.lang, y sus métodos son: Trowable( String mensaje ); Constructor. La cadena es opcional Throwable fillInStackTrace(); Llena la pila de traza de ejecución. String getLocalizedMessage(); Crea una descripción local de este objeto. String getMessage(); Devuelve la cadena de error del objeto. void printStackTrace( PrintStream_o_PrintWriter s ); Imprime este objeto

y su traza

en el flujo del parámetro s, o en la salida estándar (por defecto). String toString; Devuelve una breve descripción del objeto. 7.8.2 Funcionamiento Para que el sistema de gestión de excepciones funcione, se ha de trabajar en dos partes de los programas: Definir qué partes de los programas crean una excepción y bajo qué condiciones. Para ello se utilizan las palabras reservadas throw y throws. Comprobar en ciertas partes de los programas si una excepción se ha producido, y actuar en consecuencia. Para ello se utilizan las palabras reservadas try, catch y finally. 7.8.2.1 Manejo de excepciones: try - catch - finally Cuando el programador va a ejecutar un trozo de código que pueda provocar una excepción (por ejemplo, una lectura en un fichero), debe incluir este fragmento de código dentro de un bloque try: try { // Código posiblemente problemático } Pero lo importante es cómo controlar qué hacer con la posible excepción que se cree. Para ello se utilizan las clausulas catch, en las que se especifica que acción realizar: try { // Código posiblemente problemático } catch( tipo_de_excepcion e) { // Código para solucionar la excepción e } catch( tipo_de_excepcion_mas_general e) { // Código para solucionar la excepción e }

131


En el ejemplo se observa que se pueden anidar sentencias catch, pero conviene hacerlo indicando en último lugar las excepciones más generales (es decir, que se encuentren más arriba en el árbol de herencia de excepciones), porque el intérprete Java ejecutará aquel bloque de código catch cuyo parámetro sea del tipo de una excepción lanzada. Si por ejemplo se intentase capturar primero una excepción Throwable, nunca llegaríamos a gestionar una excepción Runtime, puesto que cualquier clase hija de Runtime es también hija de Throwable, por herencia. Si no se ha lanzado ninguna excepción el código continúa sin ejecutar ninguna sentencia catch. Pero, ¿y si quiero realizar una acción común a todas las opciones?. Para insertar fragmentos de código que se ejecuten tras la gestión de las excepciones. Este código se ejecutará tanto si se ha tratado una excepción (catch) como sino. Este tipo de código se inserta en una sentencia finally, que será ejecutada tras el bloque try o catch: try { } catch( Exception e ) { } finally { // Se ejecutara tras try o match } 7.8.2.2 Lanzamiento de excepciones: throw - throws Muchas veces el programador dentro de un determinado método deberá comprobar si alguna condición de excepción se cumple, y si es así lanzarla. Para ello se utilizan las palabras reservadas throw y throws. Por una parte la excepción se lanza mediante la sentencia throw: if ( condicion_de_excepcion == true ) throw new miExcepcion(); Se puede observar que hemos creado un objeto de la clase miExcepcion, puesto que las excepciones son objetos y por tanto deberán ser instanciadas antes de ser lanzadas. Aquellos métodos que pueden lanzar excepciones, deben cuáles son esas excepciones en su declaración. Para ello se utiliza la sentencia throws: tipo_devuelto miMetodoLanzador() throws miExcep1, miExcep2 { // Codigo capaz de lanzar excepciones miExcep1 y miExcep2 } Se puede observar que cuando se pueden lanzar en el método más de una excepción se deben indicar en su declaración separadas por comas. 7.8.2.3 Ejemplo de gestión de excepciones

132


Ahora que ya sabemos cómo funciona este sistema, conviene ver al menos un pequeño ejemplo, que ilustre al lector en el uso de las excepciones: // Creación de una excepción personalizada class MiExcepcion extends Exception { MiExcepcion() { super(); // constructor por defecto de Exception } MiExcepcion( String cadena ) { super( cadena ); // constructor param. de Exception } } // Esta clase lanzará la excepción class Lanzadora { void lanzaSiNegativo( int param ) throws MiExcepcion { if ( param < 0 ) throw new MiExcepcion( "Numero negativo" ); } } class Excepciones { public static void main( String[] args ) { // Para leer un fichero Lanzadora lanza = new Lanzadora(); FileInputStream entrada = null; int leo; try { entrada = new FileInputStream( "fich.txt" ); while ( ( leo = entrada.read() ) != -1 ) lanza.lanzaSiNegativo( leo ); entrada.close(); System.out.println( "Todo fue bien" ); } catch ( MiExcepcion e ){ // Personalizada System.out.println( "Excepcion: " + e.getMessage() ); } catch ( IOException e ){ // Estándar System.out.println( "Excepcion: " + e.getMessage() ); }finally { if ( entrada != null ) try

133


{ entrada.close(); // Siempre queda cerrado } catch ( Exception e ) { System.out.println( "Excepcion: " + e.getMessage() ); } System.out.println( "Fichero cerrado." ); } } } class Excepciones { public static void main( String[] args ) { // Para leer un Archivo FileInputStream entrada = null; Lanzadora lanza = new Lanzadora(); int leo; try { entrada = new FileInputStream("fich.txt"); while ( ( leo = entrada.read() ) != -1 ) 80 lanza.lanzaSiNegativo( leo ); System.out.println( "Todo fue bien" ); } catch ( MiExcepcion e ){ // Personalizada System.out.println( "Excepcion: " + e.getMessage() ); } catch ( IOException e ){ // Estándar System.out.println( "Excepcion: " + e.getMessage() ); } finally { entrada.close(); // Así el fichero siempre queda cerrado System.out.println( "Fichero cerrado" ); } } } Este programa lee un Archivo (fichero.txt), y lee su contenido en forma de números. Si alguno de los números leídos es negativo, lanza una excepción MiExcepcion, Además gestiona la excepción IOException, que es una excepción de las que Java incluye y que se lanza si hay algún problema en una operación de entrada/salida. Ambas excepciones son gestionadas, imprimiendo su contenido (cadena de error) por pantalla. La salida de este programa, suponiendo un número negativo sería: Excepción: Numero negativo

134


Archivo cerrado En el caso de que no hubiera ningún número negativo sería: Todo fue bien Archivo cerrado En el caso de que se produjese un error de E/S, al leer el primer número, sería: Excepción: java.io.IOException Archivo cerrado 7.8.3 Los métodos Los métodos son subrutinas que definen la interfaz de una clase, sus capacidades y comportamiento. Un método ha de tener por nombre cualquier identificador legal distinto de los ya utilizados por los nombres de la clase en que está definido. Los métodos se declaran al mismo nivel que las variables de instancia dentro de una definición de clase. En la declaración de los métodos se define el tipo de valor que devuelven y a una lista formal de parámetros de entrada, de sintaxis tipo identificador separadas por comas. La forma general de una declaración de método es: tipo_devuelto nombre_de_método( lista-formal-de-parámetros ) { cuerpo_del_método; } Por ejemplo el siguiente método devuelve la suma de dos enteros: int metodoSuma( int paramX, int paramY ) { return ( paramX + paramY ); } En el caso de que no se desee devolver ningún valor se deberá indicar como tipo la palabra reservada void. Así mismo, si no se desean parámetros, la declaración del método debería incluir un par de paréntesis vacíos (sin void):serf void metodoVacio( ) { }; Los métodos son llamados indicando una instancia individual de la clase, que tendrá su propio conjunto único de variables de instancia, por lo que los métodos se pueden referir directamente a ellas. El método inicia() para establecer valores a las dos variables de instancia sería el siguiente: void inicia( int paramX, int paramY ) { x = paramX; y = paramY;

135


} Lección 33 7.8.4 La instanciación de las clases: Los objetos 7.8.4.1 Referencias a Objeto e Instancias Los tipos simples de Java describían el tamaño y los valores de las variables. Cada vez que se crea una clase se añade otro tipo de dato que se puede utilizar igual que uno de los tipos simples. Por ello al declarar una nueva variable, se puede utilizar un nombre de clase como tipo. A estas variables se las conoce como referencias a objeto. Todas las referencias a objeto son compatibles también con las instancias de subclases de su tipo. Del mismo modo que es correcto asignar un byte a una variable declarada como int, se puede declarar que una variable es del tipo MiClase y guardar una referencia a una instancia de este tipo de clase: MiPunto p; Esta es una declaración de una variable p que es una referencia a un objeto de la clase MiPunto, de momento con un valor por defecto de null. La referencia null es una referencia a un objeto de la clase Object, y se podrá convertir a una referencia a cualquier otro objeto porque todos los objetos son hijos de la clase Object. 7.8.4.2 Constructores Las clases pueden implementar un método especial llamado constructor. Un constructor es un método que inicia un objeto inmediatamente después de su creación. De esta forma nos evitamos el tener que iniciar las variables explícitamente para su iniciación. El constructor tiene exactamente el mismo nombre de la clase que lo implementa; no puede haber ningún otro método que comparta su nombre con el de su clase. Una vez definido, se llamará automáticamente al constructor al crear un objeto de esa clase (al utilizar el operador new). El constructor no devuelve ningún tipo, ni siquiera void. Su misión es iniciar todo estado interno de un objeto (sus atributos), haciendo que el objeto sea utilizable inmediatamente; reservando memoria para sus atributos, iniciando sus valores... Por ejemplo: MiPunto( ) { inicia( -1, -1 ); }

136


Este constructor denominado constructor por defecto, por no tener parámetros, establece el valor -1 a las variables de instancia x e y de los objetos que construya. El compilador, por defecto ,llamará al constructor de la superclase Object() si no se especifican parámetros en el constructor. Este otro constructor, sin embargo, recibe dos parámetros: MiPunto( int paraX, int paraY ) { inicia( paramX, paramY ); } La lista de parámetros especificada después del nombre de una clase en una sentencia new se utiliza para pasar parámetros al constructor. Se llama al método constructor justo después de crear la instancia y antes de que new devuelva el control al punto de la llamada. Así, cuando ejecutamos el siguiente programa: MiPunto p1 = new MiPunto(10, 20); System.out.println( "p1.- x = " + p1.x + " y = " + p1.y ); Se muestra en la pantalla: p1.- x = 10 y = 20 Para crear un programa Java que contenga ese código, se debe de crear una clase que contenga un método main(). El intérprete java se ejecutará el método main de la clase que se le indique como parámetro. 7.8.4.3 El operador new El operador new crea una instancia de una clase (objetos) y devuelve una referencia a ese objeto. Por ejemplo: MiPunto p2 = new MiPunto(2,3); Este es un ejemplo de la creación de una instancia de MiPunto, que es controlador por la referencia a objeto p2. Hay una distinción crítica entre la forma de manipular los tipos simples y las clases en Java: Las referencias a objetos realmente no contienen a los objetos a los que referencian. De esta forma se pueden crear múltiples referencias al mismo objeto, como por ejemplo: MiPunto p3 =p2;

137


Aunque tan sólo se creó un objeto MiPunto, hay dos variables (p2 y p3) que lo referencian. Cualquier cambio realizado en el objeto referenciado por p2 afectará al objeto referenciado por p3. La asignación de p2 a p3 no reserva memoria ni modifica el objeto. De hecho, las asignaciones posteriores de p2 simplemente desengancharán p2 del objeto, sin afectarlo: p2 = null; // p3 todavía apunta al objeto creado con new Aunque se haya asignado null a p2, p3 todavía apunta al objeto creado por el operador new. Cuando ya no haya ninguna variable que haga referencia a un objeto, Java reclama automáticamente la memoria utilizada por ese objeto, a lo que se denomina recogida de basura. Cuando se realiza una instancia de una clase (mediante new) se reserva en la memoria un espacio para un conjunto de datos como el que definen los atributos de la clase que se indica en la instanciación. A este conjunto de variables se le denomina variables de instancia. La potencia de las variables de instancia es que se obtiene un conjunto distinto de ellas cada vez que se crea un objeto nuevo. Es importante el comprender que cada objeto tiene su propia copia de las variables de instancia de su clase, por lo que los cambios sobre las variables de instancia de un objeto no tienen efecto sobre las variables de instancia de otro. El siguiente programa crea dos objetos MiPunto y establece los valores de x e y de cada uno de ellos de manera independiente para mostrar que están realmente separados. MiPunto p4 = new MiPunto( 10, 20 ); MiPunto p5 = new MiPunto( 42, 99 ); System.out.println("p4.- x = " + p4.x + " y = " + p4.y); System.out.println("p5.- x = " + p5.x + " y = " + p5.y); Este es el aspecto de salida cuando lo ejecutamos. p4.- x = 10 y = 20 p5.- x = 42 y = 99 Lección 34 7.8.5. Acceso al objeto 7.8.5.1 El operador punto (.)

138


El operador punto (.) se utiliza para acceder a las variables de instancia y los métodos contenidos en un objeto, mediante su referencia a objeto: referencia_a_objeto.nombre_de_variable_de_instancia referencia_a_objeto.nombre_de_método( lista-de-parámetros ); Hemos creado un ejemplo completo que combina los operadores new y punto para crear un objeto MiPunto, almacenar algunos valores en él e imprimir sus valores finales: MiPunto p6 = new MiPunto( 10, 20 ); System.out.println ("p6.- 1. X=" + p6.x + " , Y=" + p6.y); p6.inicia( 30, 40 ); System.out.println ("p6.- 2. X=" + p6.x + " , Y=" + p6.y); Cuando se ejecuta este programa, se observa la siguiente salida: p6.- 1. X=10 , Y=20 p6.- 2. X=30 , Y=40 Durante las impresiones (método println()) se accede al valor de las variables mediante p6.x y p6.y, y entre una impresión y otra se llama al método inicia(), cambiando los valores de las variables de instancia. Este es uno de los aspectos más importantes de la diferencia entre la programación orientada a objetos y la programación estructurada. Cuando se llama al método p6.inicia(), lo primero que se hace en el método es sustituir los nombres de los atributos de la clase por las correspondientes variables de instancia del objeto con que se ha llamado. Así por ejemplo x se convertirá en p6.x. Si otros objetos llaman a inicia(), incluso si lo hacen de una manera concurrente, no se producen efectos laterales, ya que las variables de instancia sobre las que trabajan son distintas. 7.8.5.2 La referencia this Java incluye un valor de referencia especial llamado this, que se utiliza dentro de cualquier método para referirse al objeto actual. El valor this se refiere al objeto sobre el que ha sido llamado el método actual. Se puede utilizar this siempre que se requiera una referencia a un objeto del tipo de una clase actual. Si hay dos objetos que utilicen el mismo código, seleccionados a través de otras instancias, cada uno tiene su propio valor único de this. Un refinamiento habitual es que un constructor llame a otro para construir la instancia correctamente. El siguiente constructor llama al constructor parametrizado MiPunto(x,y) para terminar de iniciar la instancia: MiPunto() {

139


this( -1, -1 ); // Llama al constructor parametrizado } En Java se permite declarar variables locales, incluyendo parámetros formales de métodos, que se solapen con los nombres de las variables de instancia. No se utilizan x e y como nombres de parámetro para el método inicia, porque ocultarían las variables de instancia x e y reales del ámbito del método. Si lo hubiésemos hecho, entonces x se hubiera referido al parámetro formal, ocultando la variable de instancia x: void inicia2( int x, int y ) { x = x; // Ojo, no modificamos la variable de instancia!!! this.y = y; // Modificamos la variable de instancia!!! } Lección 35 7.8.6. La destrucción del objeto 7.8.6.1 La destrucción de los objetos Cuando un objeto no va a ser utilizado, el espacio de memoria de dinámica que utiliza ha de ser liberado, así como los recursos que poseía, permitiendo al programa disponer de todos los recursos posibles. A esta acción se la da el nombre de destrucción del objeto. En Java la destrucción se puede realizar de forma automática o de forma personalizada, en función de las características del objeto. 7.8.6.2 La destrucción por defecto: Recogida de basura El intérprete de Java posee un sistema de recogida de basura, que por lo general permite que no nos preocupemos de liberar la memoria asignada explícitamente. El recolector de basura será el encargado de liberar una zona de memoria dinámica que había sido reservada mediante el operador new, cuando el objeto ya no va a ser utilizado más durante el programa (por ejemplo, sale del ámbito de utilización, o no es referenciado nuevamente). El sistema de recogida de basura se ejecuta periódicamente, buscando objetos que ya no estén referenciados. 7.8.6.3 La destrucción personalizada: finalize A veces una clase mantiene un recurso que no es de Java como un descriptor de archivo o un tipo de letra del sistema de ventanas. En este caso sería acertado el utilizar la finalización explícita, para asegurar que dicho recurso se libera. Esto se

140


hace mediante la destrucción personalizada, un sistema similar a los destructores de C++. Para especificar una destrucción personalizada se añade un método a la clase con el nombre finalize: class ClaseFinalizada { ClaseFinalizada() { // Constructor // Reserva del recurso no Java o recurso compartido } protected void finalize() { // Liberación del recurso no Java o recurso compartido } } El intérprete de Java llama al método finalize(), si existe cuando vaya a reclamar el espacio de ese objeto, mediante la recogida de basura. Debe observarse que el método finalize() es de tipo protected void y por lo tanto deberá de sobreescribirse con este mismo tipo. 7.8.7 Herramientas De Java Con cada una de las versiones que Sun lanza del JDK, se acompaña de una serie de bibliotecas con clases estándar que valen como referencia para todos los programadores en Java. Estas clases se pueden incluir en los programas Java, sin temor a fallos de portabilidad. Además, están bien documentadas (mediante páginas Web), y organizadas en paquetes y en un gran árbol de herencia. A este conjunto de paquetes (o bibliotecas) se le conoce como la API de Java (Application Programming Interface). A continuación se explicara los paquetes basicos de la API de JAVA, aunque algunos de ellos tienen subpaquetes. 7.8.7.1 Paquetes de utilidades  java.lang: Fundamental para el lenguaje. Incluye clases como String o StringBuffer. java.io: Para la entrada y salida a través de flujos de datos, y ficheros del sistema. java.util: Contiene colecciones de datos y clases, el modelo de eventos, facilidades

horarias, generación aleatoria de números, y otras clases de utilidad. java.math: Clases para realizar aritmética con la precisión que se desee. java.text: Clases e interfaces para manejo de texto, fechas, números y mensajes

de

una manera independiente a los lenguajes naturales. java.security: Clases e interfaces para seguridad en Java: Encriptación RSA..

141


7.8.7.2 Paquetes para el desarrollo gráfico  java.applet:

Para crear applets y clases que las applets utilizan para comunicarse con su contexto. java.awt: Para crear interfaces con el usuario, y para dibujar imágenes y gráficos. javax.swing: Conjunto de componentes gráficos que funcionan igual en todas las plataformas que Java soporta. javax.accesibility: Da soporte a clases de accesibilidad para personas discapacitadas. java.beans: Para el desarrollo de JavaBeans. 7.8.7.3 Paquetes para el desarrollo en red  java.sql:

Paquete que contiene el JDBC, para conexión de programas Java con Bases de datos. java.rmi: Paquete RMI, para localizar objetos remotos, comunicarse con ellos e incluso enviar objetos como parámetros de un objeto a otro. org.omg.CORBA: Facilita la posibilidad de utilizar OMG CORBA, para la conexión entre objetos distribuidos, aunque esté codificados en distintos lenguajes. 7.9 ACTIVIDADES COMPLEMENTARIAS Parte Uno: 1. Investiga cuales son las herramientas utilizas en java y diga cual es su función. 2. Construye un arreglo donde incluya un método. 3. Realice un mapa conceptual con el siguiente tema E/s. 4. Realice una abstracción jerárquica de su carro donde enuncie el sistema principal y los subsistemas. 5. Escriba los enunciados que ejecuten cada uno de los siguientes: Introduzca el valor en el elemento 4 de un arreglo de punto flotante de un solo subíndice b. 6. Determine e imprima los valores más pequeños y más contenidos en un arreglo de punto flotante w de 99 elementos. Parte Dos:

Realizar los ejercicos complementarios de Laboratorios de la Guia de Laboratotios y Consultar Bibliografia de Libros Virtual de la Unad y otros Autores 1. Autor: Deitel y Deitel Introducción DOO con UML y los Patrones de Diseño JDBC tm, SERVLETS, JSP tm Editorial Pearson Prentice Hall Quinta Edición, 2. David Arnow Gerald Weiss Introducción a la Programación con Java tm Actualización a la Versión 2 de Java Editorial Addison Wesley 3. Fcd Javier Ceballos Java 2 Curso de Programación 2 Edición Editorial Alfaomega Ra-Ma 4. Agustin Froute Java 2 Manual Usuario tutorial 3 Edición Editorial Alfaomega Ra-Ma 5. Herbert shildt Fundamentos de Programación Java 2 Editorial Mc Graw Hill . para conocer el lenguaje de programación JAVA ya que están resueltos solo los puede digitar compilar y ejecutar en la casa o laboratorio de su correspondiente CEAD o CERES.

142


143


Lección 36 CAPITULO 8. Herencia 8.1 La Herencia La verdadera potencia de la programación orientada a objetos radica en su capacidad para reflejar la abstracción que el cerebro humano realiza automáticamente durante el proceso de aprendizaje y el proceso de análisis de información. Las personas percibimos la realidad como un conjunto de objetos interrelacionados. Dichas interrelaciones, pueden verse como un conjunto de abstracciones y generalizaciones que se han ido asimilando desde la niñez. Así, los defensores de la programación orientada a objetos afirman que esta técnica se adecua mejor al funcionamiento del cerebro humano, al permitir descomponer un problema de cierta magnitud en un conjunto de problemas menores subordinados del primero. La capacidad de descomponer un problema o concepto en un conjunto de objetos relacionados entre sí, y cuyo comportamiento es fácilmente identificable, puede ser muy útil para el desarrollo de programas informáticos. 8.2 Jerarquía La herencia es el mecanismo fundamental de relación entre clases en la orientación a objetos. Relaciona las clases de manera jerárquica; una clase padre o superclase sobre otras clases hijas o subclases.

Los descendientes de una clase heredan todas las variables y métodos que sus ascendientes hayan especificado como heredables, además de crear los suyos propios. La característica de herencia, nos permite definir nuevas clases derivadas de otra ya existente, que la especializan de alguna manera. Así logramos definir una jerarquía de clases, que se puede mostrar mediante un árbol de herencia. En todo lenguaje orientado a objetos existe una jerarquía, mediante la que las clases se relacionan en términos de herencia. En Java, el punto más alto de la jerarquía es la clase Object de la cual derivan todas las demás clases. 8.3 Herencia múltiple

144


En la orientación a objetos, se consideran dos tipos de herencia, simple y múltiple. En el caso de la primera, una clase sólo puede derivar de una única superclase. Para el segundo tipo, una clase puede descender de varias superclases. En Java sólo se dispone de herencia simple, para una mayor sencillez del lenguaje, si bien se compensa de cierta manera la inexistencia de herencia múltiple con un concepto denominado interface, que estudiaremos más adelante. 8.4 Declaración Para indicar que una clase deriva de otra, heredando sus propiedades (métodos y atributos), se usa el término extends, como en el siguiente ejemplo: public class SubClase extends SuperClase { // Contenido de la clase } Por ejemplo, creamos una clase MiPunto3D, hija de la clase ya mostrada MiPunto: class MiPunto3D extends MiPunto { int z; MiPunto3D( ) { x = 0; // Heredado de MiPunto y = 0; // Heredado de MiPunto z = 0; // Nuevo atributo } } La palabra clave extends se utiliza para decir que deseamos crear una subclase de la clase que es nombrada a continuación, en nuestro caso MiPunto3D es hija de MiPunto.

Lección 37 8.5 Limitaciones en la herencia Todos los campos y métodos de una clase son siempre accesibles para el código de la misma clase. Para controlar el acceso desde otras clases, y para controlar la herencia por las subclase, los miembros (atributos y métodos) de las clases tienen tres modificadores posibles de control de acceso: public:

Los miembros declarados public son accesibles en cualquier lugar en que sea accesible la clase, y son heredados por las subclases. private: Los miembros declarados private son accesibles sólo en la propia clase.

145

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA CONTENIDO MODULO DEL CUSO: 301403 – PROGRAMACION ORIENTADA A OBJETOS protected: Los miembros declarados protected son accesibles sólo para sus subclases

Por ejemplo: class Padre { // Hereda de Object // Atributos private int numeroFavorito, nacidoHace, dineroDisponible; // Métodos public int getApuesta() { return numeroFavorito; } protected int getEdad() { return nacidoHace; } private int getSaldo() { return dineroDisponible; } } class Hija extends Padre { // Definición } class Visita { // Definición } En este ejemplo, un objeto de la clase Hija, hereda los tres atributos (numeroFavorito, nacidoHace y dineroDisponible) y los tres métodos (getApuesta(), getEdad() y getSaldo() ) de la clase Padre, y podrá invocarlos. Cuando se llame al método getEdad() de un objeto de la clase Hija, se devolverá el valor de la variable de instancia nacidoHace de ese objeto, y no de uno de la clase Padre. Sin embargo, un objeto de la clase Hija, no podrá invocar al método getSaldo() de un objeto de la clase Padre, con lo que se evita que el Hijo conozca el estado de la cuenta corriente de un Padre. La clase Visita, solo podrá acceder al método getApuesta(), para averiguar el número favorito de un Padre, pero de ninguna manera podrá conocer ni su saldo, ni su edad (sería una indiscreción, ¿no?).

146


8.6. La clase Object La clase Object es la superclase de todas las clases da Java. Todas las clases derivan, directa o indirectamente de ella. Si al definir una nueva clase, no aparece la cláusula extends, Java considera que dicha clase desciende directamente de Object. La clase Object aporta una serie de funciones básicas comunes a todas las clases: public

boolean equals( Object obj ): Se utiliza para comparar, en valor, dos objetos. Devuelve true si el objeto que recibe por parámetro es igual, en valor, que el objeto desde el que se llama al método. Si se desean comparar dos referencias a objeto se pueden utilizar los operadores de comparación == y !=. public int hashCode(): Devuelve un código hash para ese objeto, para poder almacenarlo en una Hashtable. protected Object clone() throws CloneNotSupportedException: Devuelve una copia de ese objeto. public final Class getClass(): Devuelve el objeto concreto, de tipo Class, que representa la clase de ese objeto. protected void finalize() throws Trowable: Realiza acciones durante la recogida de basura. E/S caracteres Organización del código Utilización de Sentencias en Java Sentencias de selección Sentencias de repetición Principios de los applets Lección 38 8.7 Extensión De Clases 8.7.1 Composición De Objetos Extendido 8.7.1.1. Subclase Es una versión especializada de una superclase, que hereda todas las variables de instancia y los métodos definidos por a superclase y que añade sus propios elementos. Ejemplo: Este ejemplo crea una superclase llamada A y una subclase B entonces tenemos: // ejemplo de herencia // crea una superclase. class A { int i, j; void showij(); system.out.println (“i y j:”+i+” “+j); }

147


} // crea una subclase extendiendo la clase A class B extendí a { int k; void show ();{ system.out.println(“k: “+k); } void sum(); { System.out.println (“i+ j+k: “ +(i+j+k)); } } class SimpleInheritance { public static void main (string args[ ]){ A superOb = new A (); B superOb = new b (); //La superclase se puede usarse así misma. SuperOb.i = 10; SuperOb.j = 20; System.out.println (“Contenido de SuperOb: ”); SuperOb.showij(); System.out.println(); /* la subclase tiene acceso a todos los miembros públicos de la superclase.*/ SuperOb.i = 7; SuperOb.j = 8; SuperOb.k = 9; System.out.println (“Contenido de SubOb: ”); SuperOb.showij ( ); SuperOb.showk ( ); System.out.println ( ); System.out.println ( “ suma de i, j y k en subOb: “); subOb.sum ( ); } } La salida de este programa debe ser la siguiente; Contenido de la superOb: I y j: 10 ,20 Contenido de la subOb: I y j: 7,8 K: 9 Suma de i, j y k en subOb: I+j+k: 24 8.7.2 Relación de tipo de herencia

148


Existen 2 tipos de herencia simple, cuando depende de un solo padre y múltiple cuando hereda de varios padres. Lección 39 8.7.2.1 Métodos Forma general de un método: Tipo nombre_de_método(lista_de_parámetros) { //cuerpo_del_método } Aquí, tipo especifica el tipo de dato devuelto por el método. Puede ser cualquier tipo válido, incluidos los tipos de clase. Si el método no devuelve ningún valor, el tipo devuelto debe ser void. El nombre del método puede ser cualquier identificador válido distinto de los ya utilizados por otros elementos del ámbito actual. La lista de parámetros son variables que reciben el valor de los argumentos que se pasan al método. Si el método no tiene parámetros, entonces la lista de parámetros estará vacía.. Los métodos que devuelven un tipo distinto de void, devuelve un valor a la rutina llamante utilizando la siguiente forma de la sentencia return. Return valor. Java proporciona un mecanismo para la llamada a funciones C y C++ desde nuestro código fuente java. Para definir como funciones C o C++ se utiliza la palabra clave native. Ejemplo Public class fecha { Int ahora; Public fecha() { Ahora =time(); } private native int time(); static{ system.loadLibrary(“time”); } } una vez escrito el código Java, se necesitan ejecutar los pasos para poder integrar el código C oC++: Utilizar javah para crear un fichero de cabecera (.h) Utilizar javah para crear un fichero de stubs, es decir, contiene la declaración de las funciones.

149


Escribir el código del método nativo en C o C++, es decir, rellenar el código de la función, completando el trabajo de javah al crear el fichero de stubus Compilar el fichero de stubs y el fichero .c en una librería de carga dinámica(DLL en Windows ’95 o lobXX.so en UniX) Ejecutar la aplicación con el appletviwer Lección 40 8.7.2.2 Sobrecarga De Método Java utiliza la sobrecarga de métodos para implementar polimorfismos, al invocar un método sobrecargado, java utiliza el número de argumentos para determinar la versión del método sobrecargado el cual debe llamar. Ejemplo: // Ejemplo de sobrecarga de métodos class overloadDemo void test() { System.out.println (“ Sin parámetros”); } //Sobrecarga del método test con un parámetro enteros. System.out.println (“a: “+a); } // Sobrecarga el método test con un parámetro con dos parámetros //enteros. Void test (int a, int b) { System.out.println (“a y b: “ +a+” ” + b); } // sobrecarga del método test con un parámetro double double test(double a) { System.out.println (“a double: “ +a); Return a*a; } } class overload { public static void main (string args[ ]) { overloadDemo ob=new overloadDemo( ); double result; // llama a todas las versiones de test ( ) ob.test ( ); ob.test (10 ); ob.test ( 10,20); result = ob.test (123 .2 );

150


system. Out. Println (“Resultado de ob.test(123 .2): “ + result); } } EL PROGRAMA GENERA LA SIGUIENTE SALIDA Sin parámetros a : 10 a y b: 10 20 a double: 123 .2 Resultado de ob.test(123.2): 15178.2 Clase object y códigos genéricos: La clase object es definida por java, esta clase es la superclase de las demás clases, donde esta clase puede referenciar a un objeto de otra clase; teniendo en cuenta que las matrices se implementan como las clases una variable de tipo object puede referenciar a una matriz. La clase object define los siguientes métodos: Object clone ( ): crea un nuevo objeto igual al que está siendo duplicado Bolean equeal(object objeto): determina si un objeto es igual a otro. Void finalize ( ): llamada que se realiza antes de que un objeto se reciclado Class get (): obtiene en tiempo de ejecución la clase de un tiempo Int hashCode: Devuelve el código hash asociado al objeto llamante.

151


CAPITULO 9. Extensión de Clases Lección 41 9.1. Applest Y Web 9.1.1 Applets Programas elementales incluidos en páginas HTML a través de la etiqueta app y que se despliega en el visualizador tras cargarse la página. Cuando un usuario solicita un applet construido con java ocurre: El usuario solicita un documento HTML al servidor de información. El servidor envía el documento al visualizador del cliente, este documento tienen una etiqueta app que identifica la referencia a un applet El bytecode (obtenido por compilación de código java) del applet se transfiere al cliente. El visualizador del cliente, que funciona con Java (tiene una VM) interpreta el Bytecode y despliega el applet . Como código del applet contiene toda la información necesaria, el usuario tiene una interacción total con el applet sin relacionarse de nuevo con el servidor. 9.1.2 HTML para Java HTML es una forma de definir la organización lógica de la información que a través de enlaces, llamados enlaces de hipertexto e hiperenlaces, permite acceder a otra información relacionada, el enlace hipertexto es un enlace a otro documento con hipertexto que puede estar en la máquina local de cualquier otra parte de la red. El elemento que define un documento con hipertexto es que se puede leer de una forma no lineal, donde el usuario puede elegir distintos caminos a través de los enlaces, pudiendo acceder a otros documentos relacionados. La única conexión que tiene HTML con java es que proporcional la etiqueta applet que permite ejecutar applest. Por lo tanto, es imposible introducir instrucciones de java en un documento HTML para hacer que se ejecute una applet. 9.1.3 Protocolos Para Trabajo En La Red Un protocolo es un lenguaje que se usa para ejecutar tareas muy específicas. Por ejemplo el protocolo para conectar un cliente con un servidor a través de Internet. Este protocolo se denomina TPC/IP. Internet es un conexión de varias redes a través de las cuales podemos comunicarnos para obtener información, escuchar música o ver videos, enviar y recibir datos, leer noticias, hacer reservaciones en hoteles, negocios, establecer comunicaciones con otras personas, hacer publicidad, etc., Intranet es una red al interior de una empresa

152


para establecer una comunicación entre todos los departamentos u oficinas dentro de una empresa. Script ejecutable: es un archivo ejecutable que se crea para poder ejecutar una applet en Internet. Lección 42 9.1.4 Que Es Un Applet Los applets (miniaplicación) son programas escritos en Java que sirven para "dar vida" a las páginas Web (interacción en tiempo real, inclusión de animaciones, sonidos...), de ahí su potencia. Los applets son programas que se incluyen en las páginas Web y son ejecutados en la máquina cliente, con lo que no existen ralentizaciones por la saturación del módem o del ancho de banda. Permiten cargar a través de la red una aplicación portable que se ejecuta en el navegador. Para que esto ocurra tan sólo hace falta que el navegador sea capaz de interpretar Java. A las páginas que contienen applets se las denomina páginas Java-Powered. Los applets pueden ser visualizadas con la herramienta appletviewer, incluido en el JDK de Java. Los applets no son exactamente aplicaciones Java, ya que presentan las siguientes diferencias respecto a las aplicaciones normales Java: Se cargan mediante un navegador, no siendo lanzados por el intérprete Java. Son cargados a través de la red por medio de páginas HTML y no residen en el disco duro de la máquina que los ejecuta. Poseen un ciclo de vida diferente; mientras que una aplicación se lanza una vez, un applet se arranca (inicia) cada vez que el usuario recarga la página en la que se encuentra la applet. Tienen menos derechos que una aplicación clásica, por razones de seguridad. De modo predeterminado en el puesto que los ejecuta no pueden ni leer ni escribir ficheros, ni lanzar programas, ni cargar DLLs. Sólo pueden comunicarse con el servidor Web en que se encuentra la página Web que las contiene. 9.1.4.1 Consideraciones sobre la seguridad en las applets Los applets tienen una serie de restricciones de programación que los hacen "seguros". Estas restricciones de seguridad son especialmente importantes, ya que evitarán que se cargue por error un applet que destruya datos de la máquina, que obtenga información restringida, o que produzca otros daños inesperados. Los applets no dejan de ser "ejecutables" que funcionan dentro de una aplicación, como puede ser un visualizador de páginas Web (browser). Este ejecutable puede

153


obtenerse de una red, lo que significa que hay código posiblemente no fiable que se ejecuta dentro de la aplicación. Java tiene muchas salvaguardas de seguridad que minimizan el riesgo de la ejecución de applets, pero estas salvaguardas también limitan a los programadores de applets en su capacidad de programación. El modelo de seguridad para las applets en Java trata una applet como código no fiable ejecutándose dentro de un entorno fiable. Por ejemplo, cuando un usuario instala una copia de un navegador Web en una máquina se está fiando de que su código será funcional en el entorno. Normalmente los usuarios tienen cuidado de qué instalan cuando proviene de una red. Una applet, por el contrario, se carga desde la red sin ninguna comprobación de su fiabilidad. El lenguaje Java y los applets son escritos para que eviten los applets no fiables. Estas salvaguardas son implementadas para verificar que los códigos de byte de las clases de los applets, no rompen las reglas básicas del lenguaje ni las restricciones de acceso en tiempo de ejecución. Sólo cuando estas restricciones son satisfechas se le permite al applet ejecutar su código. Cuando se ejecuta, se le marca para señalar que se encuentra dentro del intérprete. Esta marca permite a las clases de tiempo de ejecución determinar cuándo a una fracción del código se le permite invocar a cierto método. Por ejemplo, una applet está restringida en los hosts en los que se puede abrir una conexión de red o en un conjunto de URLs a las que puede acceder. En su conjunto estas restricciones constituyen una política de seguridad. En el futuro, Java tendrá políticas más ricas, incluyendo algunas que usen encriptación y autentificación para permitir a las applets una mayor capacidad. La actual política de seguridad afecta a los recursos que una applet puede usar, cuyos principales puntos son: Los accesos que pueden realizar los applets a los ficheros son restringidos. En particular escribir en ficheros y/o leerles no será una capacidad estándar que se pueda realizar en los navegadores que soporten applets de Java. Las conexiones de red serán restringidas a conectar solo con el host del que proviene el applet. Un applet no es capaz de usar ningún método que pueda resultar en una ejecución arbitraria, código no revisado o ambos. Esto incluye métodos que ejecuten programas arbitrarios (métodos nativos) así como la carga de bibliotecas dinámicas. Se anticipa en cualquier caso que en el futuro los modelos de seguridad permitirán a los applets autentificadas superar estas restricciones. 9.1.5 La Clase Applet 9.1.5.1 Situación de la clase Applet en la API de Java

154


La clase Applet Java, de la cual han de heredar todos los programas Java que vayan a actuar como applets, es la única clase que contiene el paquete java.applet de la API de Java. Esta clase hereda de Object (como todas las clases Java), pero además hereda de Component y Container, que son dos clases del paquete gráfico AWT. Esto ya perfila las posibilidades gráficas de este tipo de aplicaciones Java. 9.1.5.2 Métodos del ciclo de vida Como ya se ha indicado una applet no tiene un ciclo de vida tan "sencillo" como el de una aplicación, que simplemente se ejecuta hasta que finaliza su método main(). La siguiente figura modela el ciclo de vida de una applet:

Cada círculo representa una fase en el ciclo de vida de la applet. Las flechas representan transiciones y el texto representa la acción que causa la transición. Cada fase está marcada con una invocación a un método de la applet: void init(); Es invocado cuando se carga la applet. Aquí se suelen introducir las iniciaciones que la applet necesite. void start();Es invocado cuando la applet, después de haber sido cargada, ha sido parada (cambio de página Web, minimización del navegador,...), y de nuevo activada (vuelta a la página, restauración del navegador,...). Se informa a la applet de que tiene que empezar su funcionamiento. void stop(); Es invocado para informar al applet de que debe de parar su ejecución. Así una applet que utilice threads, debería detenerlos en el código de este método. void destroy();Es invocado para informar a la applet de que su espacio está siendo solicitado por el sistema, es decir el usuario abandona el navegador. El applet debe de aprovechar este momento para liberar o destruir los recursos que está utilizando.

155


void paint(); Es invocado cada vez que hay que el navegador redibuja el applet. Al crear una applet no es necesario implementar todos estos métodos. De hecho habrá applets que no los necesiten. Cuando un navegador carga una página Web que contiene una applet, suele mostrar en su parte inferior un mensaje como: initializing... starting... Esto indica que la applet, se está cargando: 1. Una instancia de la clase applet es creada. 2. El applet es iniciado, mediante su método init(). 3. El applet empieza a ejecutarse, mediante su método start(). Cuando el usuario se encuentra con una página Web, que contiene una applet y salta a otra página, entonces el applet se detiene invocando a su método stop(). Si el usuario retorna a la página donde reside el applet, ésta vuelve a ejecutarse nuevamente invocando a su método start(). Cuando el usuario sale del navegador el applet tiene un tiempo para finalizar su ejecución y hacer una limpieza final, mediante el método destroy(). 9.1.6 La Clase Url Un URL (Uniform Resource Locator) es una dirección de Internet. Cada recurso (fichero, página Web, imagen...) tiene uno propio. En Java existe una clase denominada URL que modeliza esta clase de objetos. La clase URL pertenece al paquete java.net, y tiene una cierta importancia en el desarrollo de los applets, puesto que muchos de los métodos de la clase Applet la utilizan para acceder a determinado recurso de Internet o para identificarse. Podemos especificar un URL de manera absoluta: URL URLabsoluto = new URL("http://www.host.com/dir/fich.htm"); O bien podemos especificar un URL de manera relativa: URL URLhost = new URL("http://www.Javasoft.com/"); URL URLrelativo = new URL( URLhost, "dir/fich.htm"); Ambos ejemplos corresponderían al URL "http://www.host.com/dir/fich.htm". 9.1.7 Inclusión de la applet en una página Web Para incluir una applet en una página Web, una vez compilada la applet, debe incluirse entre el código HTML de la página Web una etiqueta , que como mínimo ha de presentar los siguientes tres parámetros: code: Especifica el URL del fichero de clase Java (*.class) que contiene la applet. width: Especifica la anchura inicial de la applet (en pixels). heigth: Especifica la altura inicial de la applet (en pixels).

156


Además, de la etiqueta inicial, una applet puede tener parámetros que se especificarán mediante etiquetas , que como mínimo han de presentar dos parámetros: name: Indica el nombre del parámetro de la applet al que esta etiqueta hace referencia. value: Establece este valor al parámetro indicado en name de la misma etiqueta. Así un ejemplo de esto sería: En este ejemplo la applet puede entender los parámetros Parametro1 y Parametro2, mediante los métodos que se describen en el siguiente apartado, y obtendría Valor1 y Valor2 respectivamente. Se observa que además de la etiqueta en el código HTML también aparece una etiqueta . Esto sucede porque HTML es un lenguaje pareado, en el que casi todas las etiquetas de inicio de elemento () tienen una etiqueta de fin (). 9.1.7.1 Obtención de los parámetros de la applet Cuando se incluye una applet en una página Web ha de hacerse mediante la etiqueta HTML . Las etiquetas HTML permiten utilizar parámetros, y la etiqueta hace lo propio, permitiendo a la applet recibir parámetros de ejecución, tal y como una aplicación los recibe en el parámetro (un vector de cadenas) de su método main(Strings). Los siguientes métodos se utilizan para extraer información de los parámetros que recibió el applet cuando fue llamado desde el código HTML: URL getDocumentBase(); Devuelve el URL del documento que contiene la apple´,K VKVKKLBKK KV KKLVLV.URL getCodeBase(); Devuelve el URL de la applet. String getParameter(String name); Devuelve el valor de un parámetro (etiquetas ) que aparezca en el documento HTML. Si por ejemplo se llamase a una applet, con el código HTML: Una llamada en esta applet al método getParameter("Color") devolverá "red".

157


9.1.7.2 Obtención de información sobre una applet Algunos métodos de los applet se utilizan para comunicar información o mostrar mensajes en la pantalla referentes al applet: boolean isActive(); Comprueba si la applet está activa. void showStatus(String status); Muestra una cadena del estado en la pantalla. String getAppletInfo(); Devuelve información relativa a la applet como el autor, Copyright o versión. String[ ][ ] getParameterInfo(); Devuelve un vector que describe algún parámetro específico de la applet. Cada elemento en el vector es un vector de tres cadenas que tienen la forma: {nombre, tipo, comentario}. Un ejemplo de como definir este método para una applet que permita un solo parámetro, color, sería: public String[][] getParameterInfo() { String info[][] = { {"Color","String","foreground color"} }; return info; } 9.1.7.3 Manipulación del entorno de una applet Algunas applets pueden afectar al entorno en que están ejecutándose. Para ello se utilizan los métodos: AppletContext getAppletContext(); Devuelve un AppletContext, que permite a la applet afectar a su entorno de ejecución. void resize( int ancho, int largo); Solicita que se modifique el tamaño de la applet. También permite recibir un único parámetro Dimension. Locale getLocale(); Devuelve el Locale de la applet si fue establecido. void setStub( AppletStub s ); Establece el stub de esta applet. 9.1.8 Ejemplo De Construcción De Una Applet 9.1.8.1 Código Para crear un applet normalmente será necesario importar al menos las bibliotecas java.awt.* y la java.applet.*. La clase que represente a la applet se ha de declarar como una subclase de la clase Applet, para poder sobreescribir los métodos de la clase Applet. Siempre conviene sobreescribir al menos el método paint() que será llamado por los navegadores que soporten applets para mostrarles por pantalla.

158


Vamos a construir un applet denominada AppletDiagonal que simplemente dibuje una línea diagonal. Un posible código para este applet sería: import java.awt.*; import java.applet.*; public class AppletDiagonal extends Applet { public void paint(Graphics g) { g.setColor( Color.red ); g.drawLine(0, 0, getWidth(), getHeight() ); } } Como funciona este código: El método paint() recibe un objeto de la clase Graphics. La clase Graphics, incluida en el AWT, contiene métodos para mostrar varios tipos de gráficos. Mediante el método setColor() de la clase Graphics se establece el color de primer plano a rojo, que es uno de los colores predefinidos de la clase Color. Por último, mediante drawLine() se dibuja una línea dadas las coordenadas de su esquina superior izquierda y de la inferior derecha. En este caso se indican la esquina superior izquierda de la applet mediante las coordenadas (0,0), y la esquina inferior derecha se obtiene mediante dos métodos de la clase Dimension (getWidth(), getHeight() ) . 9.1.8.2 Ejecución Para ejecutar el applet, una vez compilado el archivo, se introduce el llamado al applet en una página Web (por ejemplo AppletDiagonal.htm), introduciendo entre su código HTML lo siguiente: Cuando se cargue esta página Web en un navegador compatible con Java o mediante el visualizador de applets que viene con el JDK (appletviewer) se verá algo como:

159


Se podría dibujar un rectángulo con cambiar la línea de código de drawLine() por otra que llamase al método drawRect(): g.drawRect(10, 10, r.width –20, r.height –20); 9.2 ACTIVIDADES COMPLEMETARIAS Parte Uno: 1. Realiza un mapa conceptual sobre las clases que se manejan en java 2. Investigar más sobre anidado de clases y reflexiona sobre cual es la función importante en java. 3. ¿Que es una subclase y cual es su función? 4. ¿cual es la función principal de los métodos en la programación java? 5. ¿Cuál es la importancia de los códigos genéricos en java? 6. ¿Cual es la función principal de los protocolos para el trabajo en red? 7. Cuales son las ventajas para utilizar redes a nivel de comunicaciones 8. Haga una lista con los protocolos más importantes a nivel de comunicaciones. 9. ¿Cual es la estructura de una applet? 10. ¿Como se controlan las applets? 11. ¿Dónde se inicia la ejecución de una applet? Explique su respuesta con un ejemplo. 12. Diseñe un applet donde actualice los colores del primer plano y del fondo y que escriba un texto de 5 renglones. Parte Uno: Realizar los ejercicos complementarios de Laboratorios de la Guia de Laboratotios y Consultar Bibliografia de Libros Virtual de la Unad y otros Autores 1. Autor: Deitel y Deitel Introducción DOO con UML y los Patrones de Diseño JDBC tm, SERVLETS, JSP tm Editorial Pearson Prentice Hall Quinta Edición, 2. David Arnow Gerald Weiss Introducción a la Programación con Java tm Actualización a la Versión 2 de Java Editorial Addison Wesley 3. Fcd Javier Ceballos Java 2 Curso de Programación 2 Edición Editorial Alfaomega Ra-Ma 4. Agustin Froute Java 2 Manual Usuario tutorial 3

160


Edición Editorial Alfaomega Ra-Ma 5. Herbert shildt Fundamentos de Programación Java 2 Editorial Mc Graw Hill . para conocer el lenguaje de programación JAVA ya que están resueltos solo los puede digitar compilar y ejecutar en la casa o laboratorio de su correspondiente CEAD o CERES.

161


CAPITULO 10. BIBLIOGRAFIA 10.1. BIBLIOGRAFIA 

Autor: Deitel y Deitel Introducción DOO con UML y los Patrones de Diseño JDBC tm, SERVLETS, JSP tm Editorial Pearson Prentice Hall Quinta Edición.



David Arnow Gerald Weiss Introducción a la Programación con Java tm Actualización a la Versión 2 de Java Editorial Addison Wesley



Fcd Javier Ceballos Java 2 Curso de Programación 2 Edición Editorial Alfaomega Ra-Ma



Agustin Froute Java 2 Manual Usuario tutorial 3 Edición Editorial Alfaomega RaMa 5.



Herbert shildt Fundamentos de Programación Java 2 Editorial Mc Graw Hill . para conocer el lenguaje de programación JAVA 

         

        

Arnow, D., Weiss, G., Introducción a la programación con JAVA, Addison wesley, 2000. Larman, C., UML y patrones, Prentice Hall, 1998. Meyer, B., Construcción de software orientado a objetos, Prentice Hall, segunda edición, 1997. Wu, T., Introducción a la programación orientada a objetos con Java, Mc Graw Hill, 2000. Joyanes, L., Programación orientada a objetos, Segunda edición, Mc Graw Hill, 1998. Grez Voss, Introducción Orientada a Objetos, Editorial Mc Graw Hill, 1994 Joyanes, L., C++ a su alcance un enfoque orientada a objetos, Editorial, Mc Graw Hill, 1994. Cesar Becerra Santamaría, C++ Una Herramienta para la Programación Orientada a Objetos, Editorial Mc Graw Hill, 1.993 Fco Javier Ceballos, Programación Orientada a Objetos con C++,Editorial Alfaomega, 1.998 Nathan Meyers, Programación JAVA en Linux, Editorial Prentice Hall, 2.000.

10.2. SITIOS WEB

162


www.lawebdelprogramador.com www.programacion.com http://www.cimat.mx/~jlabreu/CursoJava/ http://www.mindview.net/Books/TIJ http://java.sun.com/docs/books/tutorial/ http://programacion.com/java/tutoriales/ http://www.inf.udec.cl/~mvaras/estprog/cap44.html

163

Report "MODULO"

Your name

Email

Reason

Description

Copyright © 2024 IDOC.TIPS. All rights reserved.
About Us | Privacy Policy | Terms of Service | Copyright | Contact Us | Cookie Policy

Sign In

Email

Password

Remember me Forgot password?

Our partners will collect data and use cookies for ad personalization and measurement. Learn how we and our ad partner Google, collect and use data. Agree & close

MODULO

Recommend Documents