Modulo Programacion Orienta A Objetos 33

Universidad Nacional Abierta y a Distancia - UNAD Escuela de Ciencias Bsica Tecnologa e Ingeniera Programa de Ingenieria de Sistemas
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA UNAD
PROGRAMACION ORIENTA A OBJETOS
ING. CESAR ORLANDO JIMENEZ ANGARITA 2010
PROGRAMACIN 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
ii
CONTENIDO UNIDAD 1. INTRODUCCION A LA PROGRAMACION ORIENTADA A OBJETOS Leccin 1 CAPTULO 1. CONCEPTOS BASICOS ORIENTADOS A OBJETOS 1.1. (TOMADO DEL LIBRO PROGRAMACIN DE COMPUTADORES DE JOS CRCAMO SEPLVEDA, EDICIONES UIS). 1.2. Que es un objeto? ............................................................................................................................1 Leccin 2 1.3. Cada objeto tiene un conjunto de caractersticas o atributos que lo hacen diferente a los dems. ...................................................................................................................................................2 1.4. Inicialmente podramos decir que un objeto es algo que tiene atributos y comportamientos propios. .....................................................................................................................2 Leccin 3 1.5. Podramos hacer la representacin de un objeto del mundo real? .........................3 1.6. Tipo abstracto de datos ....................................................................................................................3 Leccin 4 1.7. Caractersticas de datos: Por ejemplo hora, minutos y segundos ................................4 1.8. Para representar el objeto anterior debemos considerar tres aspectos ....................5 Leccin 5 1.9. Que es un mensaje? ......................................................................................................................5 1.10. Beneficios de la POO (tomado de monografas.com) .....................................................6 1.11. Problemas derivados de la utilizacin de OOP en la actualidad (tomado de monografas.com) .......................................................................................................................................6 1.11.1. Curvas de aprendizaje largas. .................................................................................................6 1.11.2. Dependencia del lenguaje .........................................................................................................7 1.11.3. Determinacin de las clases .....................................................................................................7 1.11.4. Performance. ...................................................................................................................................7 CAPITULO 2. INTRODUCCIN Y ELEMENTOS BSICOS DE PROGRAMACIN ORIENTADA A OBJETOS (POO) Leccin 6 2.1 Introduccin ...........................................................................................................................................8 2.2 Porqu POO? .......................................................................................................................................9 2.3 Que es la POO? ............................................................................................................................... 10 Leccin 7 2.4 Ventajas de POO ............................................................................................................................... 11 Leccin 8 2.5. Desventajas de la tecnologa orientada a objetos ........................................................... 12 Leccin 9 2.6 Evolucin de la programacin ................................................................................................... 13
iii
2.6.1. Programacin lineal. ................................................................................................................... 13 2.6.2. Programacin Modular ............................................................................................................. 13 2.6.3. Programacin Estructurada .................................................................................................... 14 Leccin 10 2.7. Comparacin entre la Programacin orientada a Objetos y la programacin 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 CAPITULO 3. PROPIEDADES BSICAS DE LA PROGRAMACIN ORIENTADA A OBJETOS Leccin 11 3.1 Abstraccin .......................................................................................................................................... 19 Leccin 12 3.2 Encapulacin ....................................................................................................................................... 20 Leccin 13 3.3 Moduaridad ........................................................................................................................................ 22 Leccin 14 3.4 Jerarquia ............................................................................................................................................... 23 Leccin 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 Leccin 16 4.1 Anlisis de la Estructura de Objetos. ...................................................................................... 28 4.1.1 Objetos y Tipos de Objetos ..................................................................................................... 28 Leccin 17 4.1.2 Asociaciones de Objetos. ......................................................................................................... 28 Leccin 18 4.1.3 Jerarquas de Generalizacin................................................................................................. 28 4.1.4 Jerarquas Compuestas. ........................................................................................................... 29 4.1.5 Diagramas de relacin entre los objetos ........................................................................... 29 4.1.6 Esquemas de Objetos................................................................................................................ 30
iv
4.2 Anlisis 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 deactivacin Objeto..................................................................................................... 35 4.2.9 Condiciones de Control Objeto.............................................................................................. 35 4.2.10 Subtipos y Supertipos de Eventos Objeto. .................................................................... 36 4.3 Diseo 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 Leccin 19 4.3.3 Diferencia entre operacin y mtodo Objeto. ................................................................. 40 4.3.4 Herencia de Clase. Objeto....................................................................................................... 41 4.3.5 Herencia Mltiple. Objeto. ........................................................................................................ 41 Leccin 20 4.3.6 Seleccin del Mtodo Objeto.................................................................................................. 41 4.3.7 Polimorfismo Objeto. ................................................................................................................... 42 4.3.8 Notacin. Objeto. .......................................................................................................................... 42 4.4 ACTIVIDADES COMPLEMENTARIAS Objeto. ................................................................. 44 CAPITULO 5. FUNDAMENTOS DE JAVA Leccin 21 5.1 Introduccin ........................................................................................................................................ 46 5.2 Caractersticas de Java ................................................................................................................... 47 5.2.1 Diferencias Con C++ ................................................................................................................... 50 5.3 Estructura de un programa en Java ......................................................................................... 51 5.3.1 Creacin de un primer programa .......................................................................................... 53 5.3.1.1 Mtodos de definicin ........................................................................................................... 53 5.3.1.2 Palabras clave ............................................................................................................................. 54 Leccin 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 Leccin 23 5.3.4 E/S caracteres: ................................................................................................................................ 62 Leccin 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 iteracin 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 Leccin 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 Leccin 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 Mtodo Lineal ........................................................................ 80 6.6. Ordenamiento de un Vector Mtodo Burbuja .................................................................... 80 6.7. Busqueda de un elemento en un vector ordenado. Mtodo Secuencial ............... 81 6.8. Busqueda de un elemento en un vector ordenado. Metodo Binaria ....................... 82 6.9. Implementacion de clases que administran Arreglos ..................................................... 83 6.9.1. Prog 1. Creacin de una clase Arreglo ................................................................................ 83 6.9.2. Prog2. Uso de un Objeto StringBuffer para la presentacin de un vector ....... 86 6.9.3. Programa 3. Invertir un Arreglo ............................................................................................. 88 Leccin 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 Leccin 28 6.10.6. Programa Simulacin de un Inventario............................................................................ 96 6.10.7. Programa Simulacin de un Parqueadero .................................................................... 97 Leccin 29 6.11. Ejemplo Cola 1 ................................................................................................................................ 99 6.12. Ejemplo Cola 2 ............................................................................................................................. 101
vi
6.13. Ejemplo Cola 4 ............................................................................................................................. 104 6.14. Ejemplo Cola 4 Archivo ............................................................................................................ 107 6.15. Ejemplo Lista ................................................................................................................................. 111 Leccin 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 Leccin 31 7.1 Conceptos Bsicos ........................................................................................................................ 133 7.1.1 Concepto de Clase .................................................................................................................... 133 7.1.2 Caractersticas Importantes De Las Clases: .................................................................... 134 7.1.3 Concepto de Interface ............................................................................................................. 134 7.2. Ejemplo De Definicin 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 Abstraccin ....................................................................................................................................... 139 7.5 Encapsulado ..................................................................................................................................... 140 7.6 Arreglos y cadenas ....................................................................................................................... 140 7.7 Flujo de E/S en java ...................................................................................................................... 141 Leccin 32 7.8. Gestin 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 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 gestin de excepciones .............................................................................. 145 7.8.3 Los mtodos ................................................................................................................................. 148 Leccin 33 7.8.4 La instanciacin de las clases: Los objetos ..................................................................... 149 7.8.4.1 Referencias a Objeto e Instancias ................................................................................... 149
vii
7.8.4.2 Constructores ........................................................................................................................... 150 7.8.4.3 El operador new ...................................................................................................................... 151 Leccin 34 7.8.5. Acceso al objeto ........................................................................................................................ 152 7.8.5.1 El operador punto (.) ............................................................................................................ 152 7.8.5.2 La referencia this .................................................................................................................... 153 Leccin 35 7.8.6. La destruccin del objeto ..................................................................................................... 154 7.8.6.1 La destruccin de los objetos ........................................................................................... 154 7.8.6.2 La destruccin por defecto: Recogida de basura .................................................... 154 7.8.6.3 La destruccin 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 grfico ............................................................................... 156 7.8.7.3 Paquetes para el desarrollo en red ................................................................................ 156 7.8. ACTIVIDADES COMPLEMENTARIAS .................................................................................... 156 Leccin 36 APITULO 8. HERENCIA 8.1 La Herencia ....................................................................................................................................... 158 8.2 Jerarqua ............................................................................................................................................ 158 8.3 Herencia mltiple .......................................................................................................................... 159 8.4 Declaracin ....................................................................................................................................... 159 Leccin 37 8.5 Limitaciones en la herencia ...................................................................................................... 160 8.6. La clase Object ............................................................................................................................... 161 Leccin 38 8.7 Extensin De Clases ...................................................................................................................... 162 8.7.1 Composicin De Objetos Extendido ................................................................................. 162 8.7.1.1subclase ....................................................................................................................................... 162 8.7.2 Relacin de tipo de herencia ................................................................................................ 163 Leccin 39 8.7.2.1 Mtodos ..................................................................................................................................... 163 Leccin 40 8.7.2.2 Sobrecarga De Mtodo ....................................................................................................... 165 CAPITULO 9. EXTENSIN DE CLASES Leccin 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
viii
Leccin 42 9.1.4 Que Es Un Applet ...................................................................................................................... 168 9.1.4.1 Consideraciones sobre la seguridad en las applets ............................................... 169 Leccin 43 9.1.5 La Clase Applet ........................................................................................................................... 170 9.1.5 .1 Situacin de la clase Applet en la API de Java ........................................................ 170 9.1.5.2 Mtodos del ciclo de vida .................................................................................................. 170 Leccin 44 9.1.6 La Clase Url ................................................................................................................................... 172 9.1.7 Inclusin de la applet en una pgina Web .................................................................... 172 9.1.7.1 Obtencin de los parmetros de la applet ................................................................ 173 9.1.7.2 Obtencin de informacin sobre una applet ............................................................ 174 9.1.7.3 Manipulacin del entorno de una applet ................................................................... 174 Leccin 45 9.1.8 Ejemplo De Construccin De Una Applet ...................................................................... 175 9.1.8.1 Cdigo ......................................................................................................................................... 175 9.1.8.2 Ejecucin .................................................................................................................................... 176 9.2 ACTIVIDADES COMPLEMETARIAS ......................................................................................... 176 CAPITULO 10. BIBLIOGRAFIA 10.1. Bibliografia ................................................................................................................................... 178 10.2. Bibliografia Sitios Web ........................................................................................................... 179
ix
UNIDAD 1. INTRODUCCION A LA PROGRAMACION ORIENTADA A OBJETOS Leeccin CAPTULO 1. CONCEPTOS BASICOS ORIENTADOS A OBJETOS 1.1. (Tomado del libro Programacin de Computadores de Jos Crcamo Seplveda, Ediciones UIS) Hoy por hoy es evidente que la orientacin a objetos es el trmino ms corriente en diversos entornos con actividades comerciales, industriales, de servicios y acadmicos. A travs de esta tcnica se logra la optimizacin en tareas concernientes a las fases de desarrollo de software como en el diseo, desarrollo y mantenimiento del software. Esto ha permitido ofrecer soluciones con larga opcin de usabilidad atacando problemas concernientes a la denominada crisis del software. Lo anterior pensado teniendo en cuenta la existencia de procesos imprescindibles hoy en da como lo son la reutilizacin de cdigo y su portabilidad. La Programacin Orientada a Objetos se basa en la idea natural de la existencia de un mundo lleno de objetos y que la resolucin del problema se realiza en trminos de objetos, un lenguaje se dice que est basado en objetos si soporta objetos como una caracterstica fundamental del mismo. 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 sern solo voladores, y seguro sern siempre plenamente identificados. La Programacin Orientada a Objetos modela el mundo en trminos de objetos, eventos y responsabilidades. Existen objetos que contienen datos y mtodos 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? Segn 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.
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 profesin etc. Leccin 2 1.3. Cada objeto tiene un conjunto de caractersticas o atributos que lo hacen diferente a los dems. Por ejemplo una planta difiere notablemente de un animal y de un edificio. Cada uno de ellos presentan caractersticas y comportamientos muy diferentes, mas aun aunque dos objetos sean exactamente iguales, son distintos entre si, por ejemplo dos carros recin salidos de la fabrica, que tienen la misma marca, el mismo modelo, la misma lnea, las mismas caractersticas, son dos objetos distintos pues cada uno tiene una identificacin diferente, aunque pertenecen a la misma clase. 1.4. Inicialmente podramos 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, raz, etc. Adems respira por sus hojas, se alimenta por su raz, elabora clorofila etc. Son algunas de las caractersticas y comportamiento que podemos percibir superficialmente de una planta.
Un diccionario es un libro especial que contiene un conjunto de palabras y definiciones, tambin podemos encontrar en el graficas, tablas, ilustraciones, etc. Y su utilidad la percibimos cuando necesitamos consultar alguna palabra, leer su significado, verificar su ortografa, o de pronto investigar sobre algn tema especifico. Leccin 3 1.5. Podramos hacer la representacin de un objeto del mundo real? Por ejemplo el amor? La alegra?. Quiz nos sea difcil en los objetos abstractos, pero de una u otra forma lograramos hacerlo. Desde el punto de vista computacional es posible representar lgicamente cualquier objeto del mundo real. Para una solucin software un objeto es un elemento especial de informacin 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 programacin estructurada la estructura de datos es totalmente independiente de la parte funcional o procedimental; es mas podramos afirmar que lo nico estructurado en la programacin estructurada son los procedimientos pero los datos estn muy aislados. La programacin orientada a objetos se acerca mas al mundo real estructurando en un mismo elemento de informacin datos y procedimientos. 1.6. Tipo abstracto de datos En la terminologa de organizacin de la informacin muchas veces se manejan los trminos estructura de datos y tipo abstracto de datos como una misma cosa . Sin embargo, para muchos autores, existe una diferencia entre los dos trminos. Aparece entonces un nuevo elemento de informacin que se denomina tipo abstracto de datos.
Un tipo abstracto de datos contienen una estructura de datos propia y un conjunto de operaciones o mtodos 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 caractersticas a nivel de datos (estructuras de datos) y unas caractersticas de comportamiento (caractersticas funcionales). Leccin 4 1.7. Caractersticas de datos: Por ejemplo hora, minutos y segundos Caractersticas 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.
Representemos este objeto del mundo real Quedara 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. Cmo representar la estructura de datos? Identificar las caractersticas del objeto a nivel de datos. Horas. Minutos. Segundos 2. Cmo representar su comportamiento? Identificar las operaciones o procesos a efectuar sobre los datos Leer hora Mostrar hora Mostrar hora en segundos, etc. 3. Cmo comunicarnos con el objeto? Para comunicarnos con el objeto debemos enviarle un mensaje. Leccin 5 1.9. Que es un mensaje? Segn el diccionario, un mensaje es un encargo de decir o llevar una cosa. Ms 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 operacin propia del mismo. MENSAJE: Mostrar fecha, resulta desconocido para el objeto por que no existe ninguna operacin 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 operacin y si este se ajusta a una forma de llamado conocida, el objeto acta.
1.10. Beneficios de la POO (tomado de monografas.com) Da a da los costos del Hardware decrecen. As surgen nuevas reas de aplicacin cotidianamente: procesamiento de imgenes y sonido, bases de datos multimediales, automatizacin de oficinas, ambientes de ingeniera de software, etc. An en las aplicaciones tradicionales encontramos que definir interfaces hombre-mquina "a-laWindows" suele ser bastante conveniente. Lamentablemente, los costos de produccin de software siguen aumentando; el mantenimiento y la modificacin de sistemas complejos suele ser una tarea trabajosa; cada aplicacin, (aunque tenga aspectos similares a otra) suele encararse como un proyecto nuevo, etc. Todos estos problemas an no han sido solucionados en forma completa. Pero como los objetos son portables (tericamente) mientras que la herencia permite la reusabilidad del cdigo orientado a objetos, es ms sencillo modificar cdigo existente porque los objetos no interaccionan excepto a travs de mensajes; en consecuencia un cambio en la codificacin de un objeto no afectar la operacin con otro objeto siempre que los mtodos respectivos permanezcan intactos. La introduccin de tecnologa de objetos como una herramienta conceptual para analizar, disear e implementar aplicaciones permite obtener aplicaciones ms modificables, fcilmente extensibles y a partir de componentes reusables. Esta reusabilidad del cdigo 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 trminos de objetos ms que en trminos de algoritmos de software. 1.11. Problemas derivados de la utilizacin de OOP en la actualidad (tomado de monografas.com) Un sistema orientado a objetos, por lo visto, puede parecer un paraso virtual. El problema sin embargo surge en la implementacin de tal sistema. Muchas compaas 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. Especficamente 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 conceptualizacin de todos los elementos de un programa, desde subsistemas a los datos, en la forma de objetos. Toda la comunicacin entre los objetos debe realizarse en la forma de mensajes. Esta no es la forma en que estn escritos los programas orientados a objetos actualmente; al hacer la transicin a un sistema orientado a
objetos la mayora 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 prctica existen muchas dependencias. Muchos lenguajes orientados a objetos estn compitiendo actualmente para dominar el mercado. Cambiar el lenguaje de implementacin de un sistema orientado a objetos no es una tarea sencilla; por ejemplo C++ soporta el concepto de herencia mltiple mientras que SmallTalk no lo soporta; en consecuencia la eleccin de un lenguaje tiene ramificaciones de diseo muy importantes. 1.11.3. Determinacin 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 definicin de las clases es ms un arte que una ciencia. Si bien hay muchas jerarquas de clase predefinidas usualmente se deben crear clases especficas para la aplicacin que se este desarrollando. Luego, en 6 meses 1 ao se da cuenta que las clases que se establecieron no son posibles; en ese caso ser necesario reestructurar la jerarqua de clases devastando totalmente la planificacin original. 1.11.4. Performance. En un sistema donde todo es un objeto y toda interaccin es a travs de mensajes, el trfico de mensajes afecta la performance. A medida que la tecnologa avanza y la velocidad de micro procesamiento, potencia y tamao de la memoria aumentan, la situacin mejorar; pero en la situacin actual, un diseo de una aplicacin orientada a objetos que no tiene en cuenta la performance no ser viable comercialmente. Idealmente, habra una forma de atacar estos problemas eficientemente al mismo tiempo que se obtienen los beneficios del desarrollo de una estrategia orientada a objetos. Debera existir una metodologa fcil de aprender e independiente del lenguaje, y fcil de reestructurar que no drene la performance del sistema.
CAPITULO 2. INTRODUCCIN Y ELEMENTOS BSICOS DE PROGRAMACIN ORIENTADA A OBJETOS (POO) Leccin 6 2.1. Introduccin Actualmente una de las reas ms importantes en la industria y el mbito acadmico es la orientacin a objetos. La orientacin a objetos promete mejoras de amplio alcance en la forma de diseo, desarrollo y mantenimiento del software ofreciendo una solucin a largo plazo a los problemas y preocupaciones que han existido desde el comienzo en el desarrollo del software: la falta de portabilidad del cdigo y reusabilidad, cdigo que es difcil de modificar, ciclos de desarrollo largos y tcnicas de codificacin no intuitivas. Un lenguaje orientado a objetos ataca estos problemas. Tiene tres caractersticas bsicas: 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 difcil que se cumplan los tres, el inconveniente mas complicado de disear es la herencia. El concepto de programacin orientada a objetos (POO) no es nuevo, lenguajes clsicos 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 resolucin del problema se realiza en trminos de objetos. Un lenguaje se dice que est basado en objetos si soporta como una caracterstica fundamental del mismo. El elemento fundamental de la POO es, como su nombre lo indica, el objeto. Podemos definir un objeto como un conjunto complejo de datos y programas que poseen una estructura y forman parte de una organizacin. Esta definicin especifica varias propiedades importantes de los objetos. En primer lugar, un objeto no es un dato simple, sino que contiene en su interior cierto nmero de componentes bien estructurados. En segundo lugar, cada objeto no es un ente aislado, sino que forma parte de una organizacin jerrquica o de otro tipo. Bsicamente 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 programacin convencionales son poco ms que una lista de acciones a realizar sobre un conjunto de datos en una determinada secuencia. Si en algn punto del
programa modificamos la estructura de los datos o la accin realizada sobre ellos, el programa cambia. 2.2 Porqu POO? Es una manera de pensar, otra manera de resolver un problema; lo ms reciente en metodologas de desarrollo de software. Es un proceso mental humano aterrizado en una computadora. Antes se adecuaba el usuario al entendimiento de la computadora. Actualmente, se le ensea a la computadora a entender el problema. La Orientacin a Objetos es un paradigma, es decir, es un modelo para aclarar algo o para explicarlo. La Orientacin a Objetos es el paradigma que mejora el diseo, desarrollo y mantenimiento del software ofreciendo una solucin a largo plazo a los problemas y preocupaciones que han existido desde el comienzo del desarrollo del software:
La
falta de portabilidad del cdigo, su reusabilidad, la modificacin (que antes era difcil de lograr), ciclos de desarrollo largo, tcnicas de programacin no intuitivas. La Orientacin a Objetos est basada en los tres mtodos de organizacin que utilizamos desde la infancia; entre un objeto y sus atributos (automvil > marca, color, nmero de llantas, etc.); Entre un objeto y sus componentes donde incluso otros objetos pueden formar parte de otros objetos (agregacin) (camin > motor, parabrisas, llantas); entre un objeto y su relacin con otros objetos (camin > vehculos automotores; una bicicleta no entrara en esta relacin). La metodologa del software orientado a objetos consiste en:
Saber
el espacio del problema Realizar una abstraccin Crear los objetos (espacio de la solucin) Instanciarlos (esto es, traerlos a la vida) Dejarlos vivir (ellos ya saben lo que tienen que hacer) Las herramientas de programacin orientadas a objetos ayudan a manejar la complejidad. Desarrollar software que sea fcil de utilizar hace que sea muy compleja su construccin.
El diseo del nuevo software se enfoca a complejas interfaces de usuarios, sistemas de manejo de ventanas, y programas multitarea estn haciendo que el software sea cada vez mas complejo. Las herramientas enfocadas a objetos facilitan la comprensin de esta complejidad, la estructuracin orientada a objetos reduce el nmero de conexiones entre los componentes del sistema, obligar a que los objetos se comuniquen a travs de una interfaz pblica estrecha hace ms fcil aislar los errores ocultos y determinar cuales son los mtodos responsables de los errores ocultos que ocurran. Los objetos mismos protegen los datos privados de modificaciones no deseadas. La definicin explicita de un protocolo de comunicacin permite a compiladores e intrpretes advertir a los usuarios acerca de los accesos ilegales e incluso impedir la modificacin 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. Este mapeo directo es una consecuencia de tener una estructura basada en objetos. Si la programacin se considera una simulacin, resulta mucho ms fcil seleccionar objetos de un mundo simulado que desarrollar una solucin de programacin basada completamente en procedimientos y acciones. La orientacin a objetos surgi de la necesidad de simular sistemas de forma sencilla, no solo de informacin, si no de cualquier otro tipo, sin importar el modo de implantacin. 2.3 Que es la POO? La Programacin Orientada a Objetos (POO OOP segn siglas en ingls) es una metodologa de diseo de software y un paradigma de programacin que define los programas en trminos de "clases de objetos", objetos que son entidades que combinan estado (es decir, datos) y comportamiento (esto es, procedimientos o mtodos). La programacin 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 estn separados y sin relacin. Estos mtodos estn pensados para hacer los programas y mdulos ms fciles de escribir, mantener y reutilizar. Otra manera en que esto es expresado a menudo, es que la programacin orientada a objetos anima al programador a pensar en los programas principalmente en trminos de tipos de datos, y en segundo lugar en las operaciones ("mtodos") especficas a
10
esos tipos de datos. Los lenguajes procedimentales animan al programador a pensar sobre todo en trminos de procedimientos, y en segundo lugar en los datos que esos procedimientos manejan. Los programadores que emplean lenguajes procedimentales, escriben funciones y despus les pasan datos. Los programadores que emplean lenguajes orientados a objetos definen objetos con datos y mtodos y despus envan mensajes a los objetos diciendo que realicen esos mtodos en s mismos. Algunas personas tambin diferencian la POO sin clases, la cual es llamada a veces programacin basada en objetos. Hay un cierto desacuerdo sobre exactamente que caractersticas de un mtodo de programacin o lenguaje le califican como "orientado a objetos", Trmino de Programacin Orientada a Objetos indica ms una forma de diseo y una metodologa de desarrollo de software que un lenguaje de programacin, ya que en realidad se puede aplicar el Diseo Orientado a Objetos (En ingls abreviado OOD, Object Oriented Design), a cualquier tipo de lenguaje de programacin. El desarrollo de la POO empieza a destacar durante la dcada de lo 80 tomando en cuenta la programacin estructurada, a la que engloba y dotando al programador de nuevos elementos para el anlisis y desarrollo de software. Se puede definir POO como una tcnica o estilo de programacin que utiliza objetos como bloque esencial de construccin. 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 bsicos. Leccin 7 2.4 Ventajas de POO La OOP proporciona las siguientes ventajas sobre otros lenguajes de programacin Uniformidad. Ya que la representacin de los objetos lleva implica tanto el anlisis como el diseo y la codificacin de los mismos. Comprensin. Tanto los datos que componen los objetos, como los procedimientos que los manipulan, estn agrupados en clases, que se corresponden con las estructuras de informacin que el programa trata.
11
Flexibilidad. Al tener relacionados los procedimientos que manipulan los datos con los datos a tratar, cualquier cambio que se realice sobre ellos quedar reflejado automticamente 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 nocin de objeto permite que programas que traten las mismas estructuras de informacin 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 combinacin de objetos ya definidos donde estos estn relacionados de una manera particular. Reutilizacin. Las clases se construyen a partir de otras clases. Sistemas ms fiables. Proceso de desarrollo apropiado. Desarrollo ms flexible. Modelos que reflejan mejor la realidad. Mejor independencia e interoperatividad de la tecnologa. Mejor informtica distribuida en cliente servidor. Bibliotecas de clases comerciales disponibles. Mejores relaciones con los clientes. Mejor calidad del producto de software terminado. Leccin 8 2.5. Desventajas de la tecnologa orientada a objetos. A pesar de que las ventajas de la programacin orientada a objetos superan a las limitaciones de la misma, podemos encontrar algunas caractersticas no deseables en sta. Limitaciones para el programador. No obstante que la tecnologa orientada a objetos no es nueva, un gran porcentaje de programadores no estn familiarizados con los conceptos de dicha tecnologa. En otras palabras, la lgica de la programacin estructurada sigue siendo predominante en la mayora de los desarrolladores de software, despus de haber revisado de forma breve los principios de la programacin orientada a objetos, nos es claro que en sta se requiere una lgica de pensamiento totalmente diferente a la lgica comnmente utilizada para la programacin estructurada.
12
Tamao excesivo en las aplicaciones resultantes. La gran mayora de los equipos de cmputo cuentan con capacidades tanto de almacenamiento como de memoria lo suficientemente buena como para ejecutar la mayora de las aplicaciones que puedan desarrollarse con la tecnologa orientada a objetos, sin embargo existen casos en los que lo anterior no se cumple. Una de las desventajas de la programacin orientada a objetos es que cuando se heredan clases a partir de clases existentes se heredan de forma implcita 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 ejecucin. Esto tiene que ver, en cierto modo, con el punto anterior, una aplicacin innecesariamente pesada en muchas ocasiones es ms lenta de ejecutar que una aplicacin conformada nicamente por los mdulos necesarios. Leccin 9 2.6 Evolucin de la programacin POO (Programacin Orientada a Objetos)es un importante conjunto de tcnicas que se pueden utilizar para hacer el desarrollo de programas ms eficientes mientras se mejora la facilidad de los programas resultantes. En esencia, POO es un nuevo medio de enfocar el trabajo de programacin. Sin embargo, a fin de comprender lo que es la POO, es necesario comprender sus races. As pues, comenzaremos por examinar la historia del proceso de programacin analizada cmo evolucin POO y deduciendo, en consecuencia, por qu es tan importante este concepto. 2.6.1. Programacin lineal. Los lenguajes de programacin lineal (BASIC, COBOL Y FORTRAN) no tenan facilidad para reutilizar el cdigo existente de programas. De hecho se duplicaban segmentos de software cada vez ms en muchos programas. Los programas se ejecutaban en secuencias lgicas, haciendo la lgica difcil de comprender. El control de programas era difcil y se producan continuos saltos a lo largo del referido programa. An ms, los lenguajes lineales no tenan capacidad de controlar la visibilidad de los elementos llamados datos. 2.6.2. Programacin Modular El soporte ms elemental de la programacin Modular lleg con la aparicin 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
13
simplemente incluyendo el nombre del programa siempre que se requiera. Las subrutinas proporcionan una divisin natural de las tareas; diferentes programas utilizan. Aunque las subrutinas proporcionan el mecanismo bsico de la programacin Modular, se necesita mucha disciplina para crear software bien estructurado. Sin esta disciplina, es fcil escribir programas compilados y tortuosos difciles de modificar y comprender, as como imposible de mantener. Esta ha sido la panormica durante muchos aos en el desarrollo del software. 2.6.3. Programacin Estructurada. Un concepto importante en campo de la programacin Estructurada: Abstraccin, ya que la Abstraccin 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 cmo funciona su interior. Esto se conoce como una Abstraccin funcional y es el ncleo de la programacin estructurada. Hoy casi todos los lenguajes de programacin tienen construcciones que facilitan la programacin estructurada. Leccin 10 2.7. Comparacin entre la Programacin orientada a Objetos y la programacin estructurada. 2.7.1. Paradigma Estructurado La Programacin estructurada fija su atencin en el conjunto de acciones que manipulan el flujo de datos, mientras que la POO se fija en la interrelacin que existe entre los datos y las acciones a realizar con ellos. Descomposicin funcional: el sistema es considerado una unidad funcional que se disgrega en procesos El resultado del proceso de abstraccin para la solucin de un problema macro lo constituyen pequeos subprogramas Un problema macro se subdivide en unidades ms pequeas llamadas procesos, estos se pueden distribuir entre diferentes personas que se vean involucradas en la solucin de un problema y as efectuar los desarrollos de software de una manera ms rpida y eficiente. Figura 1.1 Programacin Estructurada Los procesos son la parte central de este modelo pues a partir de estos se manejan las variantes (datos) que solucionarn el problema. Generalmente se manejan muchos procesos lo cual hace largos cdigos.
14
El mantenimiento de los desarrollos deben efectuarse minuciosamente. Los procedimientos empleados en una aplicacin pueden reutilizarse teniendo cuidado en el manejo de los datos. Las operaciones se ajustan a las caractersticas 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 solucionarn el problema. Generalmente se manejan muchos procesos lo cual hace largos cdigos. El mantenimiento de los desarrollos deben efectuarse minuciosamente. Los procedimientos empleados en una aplicacin pueden reutilizarse teniendo cuidado en el manejo de los datos. Las operaciones se ajustan a las caractersticas propias de los lenguajes procedimentales. Los procesos que se modelan en el desarrollo de un problema plasman las operaciones necesarias para resolverlo
15
2.7.2 Paradigma Orientado a Objetos Descomposicin en objetos. El sistema es considerado un objeto o conjunto de objetos. Los cuales son el resultado del proceso de abstraccin para la solucin 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 solucin final.
16
Los datos (estados) son la parte central del modelo y los mtodos que los modifican muestran el comportamiento del objeto. El mantenimiento de programas y aplicaciones generalmente son fciles 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 tcnica de programacin sino un medio de plasmar el mundo real.
Adicin: Producto Punto: Producto Cruz: Producto por escalar: Normal:
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) R = k A, R = ( ka1, ka2, ka3 ) R = /R/I, R = Raz 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 ms cercano a la realidad que un modelo funcional. Un desarrollo realizado con el modelo orientado a objetos es ms fcil de mantener y de reutilizar.
17
El modelo orientado a objetos evita la redundancia en los procesos luego los cdigos son ms entendibles y resumidos. La integridad que dan los objetos a los datos evita ambigedades en su uso, dando mayor seguridad en los resultados. El modelo orientado a objetos facilita la integridad de mdulos que hallan sido realizados por separado sin correr riesgos en el manejo de los datos. Autoevaluacin 2.8 ACTIVIDADES COMPLEMENTARIAS Pate Uno: 1. Investigue la diferencia entre la POO y la Programacin 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 Introduccin DOO con UML y los Patrones de Diseo JDBC tm, SERVLETS, JSP tm Editorial Pearson Prentice Hall Quinta Edicin, 2. David Arnow Gerald Weiss Introduccin a la Programacin con Java tm Actualizacin a la Versin 2 de Java Editorial Addison Wesley 3. Fcd Javier Ceballos Java 2 Curso de Programacin 2 Edicin Editorial Alfaomega Ra-Ma 4. Agustin Froute Java 2 Manual Usuario tutorial 3 Edicin Editorial Alfaomega Ra-Ma 5. Herbert shildt Fundamentos de Programacin Java 2 Editorial Mc Graw Hill . para conocer el lenguaje de programacin JAVA ya que estn resueltos solo los puede digitar compilar y ejecutar en la casa o laboratorio de su correspondiente CEAD o CERES.
18
Leccin 11 CAPITULO 3. PROPIEDADES BSICAS DE LA PROGRAMACIN ORIENTADA A OBJETOS La programacin orientada a objetos, ha tomado las mejores ideas de la programacin estructurada y los ha combinado con varios conceptos nuevos y potentes que incitan a contemplar las tareas de programacin desde un nuevo punto de vista. La programacin orientada a objetos, permite descomponer ms fcilmente 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 trmino Programacin Orientada a Objetos (POO), hoy en da ampliamente utilizado, es difcil de definir, ya que no es un concepto nuevo, sino que ha sido el desarrollo de tcnicas de programacin desde principios de la dcada de los setenta, aunque sea en la dcada de los noventa cuando ha aumentado su difusin, uso y popularidad. No obstante, se puede definir POO como una tcnica o estilo de programacin que utiliza objetos como bloque esencial de construccin. 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 mtodos y los datos se denominan miembros datos. Leccin 12 3.1 Abstraccin 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 cmo se implementan estas caractersticas. Los procesos, las funciones o los mtodos pueden tambin ser abstrados y cuando los estn, una variedad de tcnicas son requeridas para ampliar una abstraccin. La abstraccin es una especificacin del sistema que enfatiza sobre algunos de los detalles o propiedades del mismo mientras suprime a otros. Una buena abstraccin 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 distraccin. Existen cuatro tipos de abstracciones:
19
La primera es la abstraccin de entidades; este tipo de abstraccin representa una entidad ya sea del dominio del problema o del dominio de la solucin. El segundo tipo de abstraccin es la abstraccin de acciones, es la abstraccin de comportamiento, esta abstraccin proporciona un conjunto especializado de operaciones y todas ellas desempean funciones del mismo tipo. El tercer tipo de abstraccin es el de maquinas virtuales, este tipo de abstraccin agrupa operaciones virtuales utilizadas por un nivel superior de control u operaciones que utilicen un conjunto de operaciones de nivel inferior. Por ejemplo, una abstraccin que utilice el cdigo "x" cuando la aplicacin se ejecute en Latinoamrica, o utilice el cdigo "y" cuando se ejecute el Norteamrica. El ltimo tipo de abstraccin es el de coincidencia, que almacena un conjunto de operaciones que no tienen relacin entre s, esto es, toma actividades que aparentemente no tienen una relacin como las clases hombre (con mtodos como come(), camina(), etc.), las clases transporte areo (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 definicin una interfaz es abstracta, por lo tanto no tiene un comportamiento, slo la declaracin de este. Leccin 13 3.2 Encapsulacin Tambin llamada "ocultacin de la informacin", esto asegura que los objetos no pueden cambiar el estado interno de otros objetos de maneras inesperadas; solamente los propios mtodos internos del objeto pueden acceder a su estado.
20
Cada tipo de objeto expone una interfaz a otros objetos que especifica cmo 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 abstraccin. La encapsulacin protege los atributos que conforman al objeto, y permite o niega informacin al pblico. Con el encapsulamiento, se consigue ocultar informacin y ocultar todos los secretos de un objeto que no contribuyen a sus caractersticas esenciales, tpicamente la estructura de un objeto se encuentra oculta y la implantacin de sus mtodos es visible. Para el caso del termmetro tal vez slo se requieren 3 mtodos: activarlo, desactivarlo y pedirle la temperatura. Un objeto es la abstraccin de algo que forma parte del dominio del problema reflejando las posibilidades de un sistema para mantener la informacin sobre l. Representa una entidad real o abstracta con un papel bien definido dentro de nuestro mundo y con dos caractersticas que son sus atributos y su comportamiento. Ejemplos de objetos pueden ser un celular, lentes, pluma, computadora, pizarrn, perro, etc. Los objetos se componen de atributos o variables que aclaran el estado del objeto. Los atributos de un objeto, bicicleta, podran ser el nmero de llantas que tiene (estado 2) el numero de marchas (estado 4 si es de velocidades), numero de asientos (estado uno), velocidad instantnea. Para alterar el estado de un objeto se necesita invocar un mtodo. Este mtodo es algo que el objeto sabe y por lo tanto define su comportamiento.
21
Bicicleta.dameTuvelocidadactual() -entrega 0 Bicicleta.avanza(10) -modifico su velocidad Bicicleta.dameTuvelocidadactual()-entrega valor distinto de cero. La encapsulacion es una tcnica que permite localizar y ocultar los detalles de un objeto. La encapsulacin previene que un objeto sea manipulado por operaciones distintas de las definidas. La encapsulacin es como una caja negra que esconde los datos y solamente permite acceder a ellos de forma controlada. Las principales razones tcnicas para la utilizacin de la encapsulacin son: 1) Mantener a salvo los detalles de representacin, si solamente nos interesa el comportamiento del objeto. 2) Modificar y ajustar la representacin a mejores soluciones algortmicas o a nuevas tecnologas de software. Leccin 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 ms componentes que se acoplen perfectamente al todo, o extraerle componentes sin afectar su funcionamiento. En el caso que se requiera actualizar un mdulo, no hay necesidad de hacer cambios en otras partes del todo. Un ejemplo clsico es un conjunto de mdulos que, al integrarlos conforman un armario, el cual puede agregarle ms funcionalidad si se le agregan ms mdulos, o al contrario. Tambin se puede cambiar su finalidad si se acomodan esos mdulos para darle otro objetivo: volverlo una mesa. Esto ayuda a la descomposicin de problemas en subproblemas, es decir, a la solucin de problemas por composicin 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 divisin de ste en componentes identificables y tratables por separado, denominados mdulos, que estn integrados para satisfacer los requisitos del programa.
22
Un software monoltico no puede ser entendido fcilmente por un solo usuario. El nmero de caminos de control, mbito de referencia, nmero de variables y la complejidad global haran su comprensin casi imposible. Para ver la importancia de la modularidad, considrense los siguientes argumentos basados en observaciones llevadas a cabo: Sea C(x) una funcin que define la complejidad percibida de un problema x, y E(x) una funcin 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 caracterstica se ha descubierto durante la experimentacin en la resolucin de problemas, y es: C(P1 + P2) > C(P1) + C(P2) se sigue que E(P1 + P2) > E(P1) + E(P2) Es ms fcil resolver un problema complejo cuando se rompe en piezas manejables. Leccin 14 3.4 Jerarqua La mayora de las personas ve de manera natural nuestro mundo como objetos que se relacionan entre s de una manera jerrquica. Por ejemplo, un perro es un mamfero, y los mamferos son animales, y los animales seres vivos... Del mismo modo, las distintas clases de un programa se organizan mediante la jerarqua. La representacin de dicha organizacin da lugar a los denominados rboles de herencia:
23
Mediante la herencia una clase hija puede tomar determinadas propiedades de una clase padre. As se simplifican los diseos y se evita la duplicacin de cdigo al no tener que volver a codificar mtodos ya implementados. Al acto de tomar propiedades de una clase padre se denomina heredar. Leccin 5 3.5 Polimorfismo Las referencias y las colecciones de objetos pueden contener objetos de diferentes tipos, y la invocacin de un comportamiento en una referencia producir el comportamiento correcto para el tipo real del referente. Cuando esto ocurre en "tiempo de ejecucin", esta ltima caracterstica se llama asignacin tarda o asignacin dinmica. Algunos lenguajes proporcionan medios ms estticos (en "tiempo de compilacin") de polimorfismo, tales como las plantillas y la sobrecarga de operadores de C++. En programacin orientada a objetos se denomina polimorfismo a la capacidad del cdigo de un programa para ser utilizado con diferentes tipos de datos u objetos. Tambin 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 polimrficas y tipos polimrficos. Las primeras son aquellas funciones que pueden evaluarse y/o ser aplicadas a diferentes tipos de datos de forma indistinta; los tipos polimrficos, 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 dinmico (o polimorfismo ad hoc) es aqul en el que el cdigo no incluye ningn tipo de especificacin sobre el tipo de datos sobre el que se trabaja. As, puede ser utilizado a todo tipo de datos compatible. Polimorfismo esttico (o polimorfismo paramtrico) es aqul 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 dinmico unido a la herencia es lo que en ocasiones se conoce como programacin genrica.
24
3.6 Herencia Organiza y facilita el polimorfismo y la encapsulacin 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 comn. La herencia es uno de los mecanismos de la programacin orientada a objetos, por medio de la cual una clase se deriva de otra de manera que extiende su funcionalidad. Una de sus funciones ms 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 patrn 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 mltiples padres es herencia mltiple, la ventaja de la herencia es permitir la reutilizacin de cdigo. 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 sern heredadas por cualquier clase y la clase derivada hereda las caractersticas generales y aade a esta de su propia clase. Utilizando la herencia, un objeto slo 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 especfica de un caso ms general analicemos el proceso de un animal. Por ejemplo al hacer una descripcin de los animales de forma abstracta, se puede decir que estos tiene atributos tales como: tamao, inteligencia, y el tipo de esqueleto. Los animales tienen diferentes clase de comportamiento esta puede ser una definicin de la clase de los animales. La herencia interacta con el encapsulado. Si una clase dada encapsula algunos atributos, entonces la cualquier clase tendr los mismos atributos.
25
3.6.1 Tipos de herencia Herencia sencilla: Un objeto puede extender las caractersticas de otro objeto y de ningn otro, es decir, solo puede tener un padre. Herencia mltiple: Un objeto puede extender las caractersticas de uno o ms objetos, es decir, puede tener varios padres. En este aspecto hay discrepancias entre los diseadores de lenguajes. Algunos de ellos han preferido no admitir la herencia mltiple por las posibles coincidencias en nombres de mtodos o datos miembros. Por ejemplo C++ admite herencia mltiple, Java y Ada slo herencia simple. Si una clase cualquiera tiene ms de un ancestro directo en la jerarqua de clases, se considera que existe herencia mltiple. En trminos concretos, una instancia de objeto de la clase hija, poseer todos los atributos y mtodos de sus clases ancestro. Autoevaluacin 3.7 ACTIVIDADES COMPLEMENTARIAS Parte Uno: 1. De acuerdo con el concepto de abstraccin mire su casa o apartamento y diga cual es la funcin de cada una de las partes. 2. Cual es la funcin de los descriptores private, public y protected.
26
3. Realiza un mapa conceptual con 15 trminos del tema de modularidad. 4. Cual es la funcin principal de la jerarqua en la POO. 5. Cual es la relacin que existe entre jerarqua y polimorfismo? 6. Mediante un ejemplo explique el concepto de herencia 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 Introduccin DOO con UML y los Patrones de Diseo JDBC tm, SERVLETS, JSP tm Editorial Pearson Prentice Hall Quinta Edicin, 2. David Arnow Gerald Weiss Introduccin a la Programacin con Java tm Actualizacin a la Versin 2 de Java Editorial Addison Wesley 3. Fcd Javier Ceballos Java 2 Curso de Programacin 2 Edicin Editorial Alfaomega Ra-Ma 4. Agustin Froute Java 2 Manual Usuario tutorial 3 Edicin Editorial Alfaomega Ra-Ma 5. Herbert shildt Fundamentos de Programacin Java 2 Editorial Mc Graw Hill . para conocer el lenguaje de programacin JAVA ya que estn resueltos solo los puede digitar compilar y ejecutar en la casa o laboratorio de su correspondiente CEAD o CERES.
27
UNIDAD 2. ESTRUCTURA DE UN OBJETO - INTRODUCCION A JAVA Leccin 16 Capitulo 4. Anlisis De La Estructura Y Comportamiento De Un Objeto 4.1 Anlisis de la Estructura de Objetos. 1 El anlisis de la estructura de objetos (AEO) define las categoras de los objetos que percibimos y las formas en que los asociamos. 4.1.1 Objetos y Tipos de Objetos. En el anlisis se trata de identificar los tipos de objeto ms que los objetos individuales en un sistema. Los tipos de objetos se definen en base a la comprensin 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. Adems es necesario identificar el significado de la asociacin y la cantidad de objetos con los que un objeto dado puede y debe asociarse (cardinalidad).
Representacin para la Asociacin entre dos Tipos de Objetos. Un objeto del tipo persona posee cero o muchos objetos del tipo vehculo. Un objeto del tipo vehculo es de un y slo un objeto del tipo persona. 4.1.3 Jerarquas de Generalizacin. Una de las vas de sentido comn por las que el hombre organiza su volumen de conocimiento es el de las jerarquas, de lo ms general a lo ms especfico.
28
Representacin de una Jerarqua de generalizacin, para el tipo de objeto Persona. En las jerarquas se habla de subtipo o especializacin de un supertipo o generalizacin. 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 jerarqua) heredan las caractersticas de sus supertipos, adems, cada instancia de un tipo de objeto lo es tambin de sus supertipos. 4.1.4 Jerarquas Compuestas. Un objeto se denomina complejo si est formado por otros. Las jerarquas 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, podra tener varios (o ninguno) objetos del tipo bao y oficina. 4.1.5 Diagramas de relacin entre los objetos. Los tipos de objetos estn relacionados con otros tipos de objeto. Por ejemplo, un empleado trabaja en una sucursal, o un cliente realiza un pedido de varios productos.
29
Un objeto del tipo cliente puede ordenar muchos objetos del tipo pedidos, y un objeto del tipo pedido es ordenado por un y slo un objeto del tipo cliente. Un objeto del tipo producto est en muchos o ningn 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 comprensin de un modelo suele ser ms sencilla si los tipos de objetos y relaciones se presentan mediante un diagrama de relacin entre objetos; los supertipos y subtipos se presentan en un diagrama de jerarquas de generalizacin y las estructuras compuestas en un diagrama compuesto. Sin embargo, para los usuarios ms sofisticados puede ser til presentarlo todo en un mismo diagrama, el que se denomina esquema de objetos. Leccin 17 4.2 Anlisis del comportamiento de objetos
En el anlisis del comportamiento de objetos (ACO) realizamos esquemas de eventos que muestran eventos, la secuencia en que ocurren y cmo 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 reservacin area puede ser una instancia de alguno de los siguientes tipos de objeto:
Reservacin
solicitada, Reservacin en lista de espera, Reservacin confirmada, Reservacin cancelada, Reservacin satisfecha, Reservacin archivada.
30
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 reservacin area tambin puede tener los siguientes estados relacionados con el pago:
Reservacin
no liquidada, Reservacin con un pago de depsito, Reservacin totalmente pagada, Reservacin reembolsada. As, el estado de un objeto es la coleccin 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 prstamo, el servidor se cae, se termina la tarea, etc. En el anlisis orientado a objetos el mundo se describe en trminos 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 organizacin: slo los tipos de eventos. Por ejemplo, el tipo de evento reservacin en lista de espera confirmada es la coleccin de eventos donde un objeto cambia de una reservacin en lista de espera a una reservacin 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. Bsicamente, los tipos de eventos describen las siguientes formas de cambios de estado:
Un
objeto se crea.
31
Un
objeto se termina. Un objeto se clasifica como una instancia de un tipo de objeto. Un objeto se desclasifica como una instancia de un tipo de objeto. Un objeto cambia de clasificacin. Un atributo de un objeto se cambia. Los objetos pueden asociar un objeto con otro. Por ejemplo, en la mayora 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 asociacin entre el objeto empleado y un objeto Departamento (las asociaciones son objetos como los dems). 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 reaccin encadena de otros eventos. Por ejemplo, el cambio de circuito a las conexiones de un avin, puede exigir cambios a varios otros objetos. Una operacin hace que los eventos ocurran. Dibujamos la operacin 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 tringulos negros llenos, generalmente unidos a la caja de operacin.
Segn el rea que se modele, puede ocurrir ms de un evento al terminar una operacin, y cada uno de estos puede activar operaciones independientes.
32
4.2.4 El Ciclo Vital de un Objeto La mayora de los objetos tienen un ciclo vital en el que una sucesin de eventos pueden ocurrirle y cada uno de stos modifica su estado. En este anlisis, se dibuja un diagrama que muestre el ciclo vital de un objeto, incluyendo los estados posibles de los objetos, adems de los cambios de estado permisibles. Este se denomina diagrama de reja.
Diagrama de reja que muestra los estados posibles de un objeto reservacin area. Las lneas horizontales representan estados y las verticales muestran las transiciones entre estados. 4.2.5 Interacciones entre tipos de objetos La mayora de los procesos requieren la interaccin de varios objetos.
33
En esta otra figura, se desarrolla el diagrama anterior para mostrar las operaciones necesarias.
4.2.6 Operaciones. En el anlisis OO, una operacin se refiere a una unidad de procesamiento que puede ser solicitada. El procedimiento se implanta mediante un mtodo. El mtodo es la especificacin de cmo llevar a cabo la operacin. A nivel de programa, el mtodo es el cdigo que implanta la operacin. Las operaciones se invocan. Una operacin invocada es una instancia de una operacin. Una operacin puede o no cambiar el estado de un objeto, si lo cambiara ocurrira un evento.
34
4.2.7 Fuentes externas de eventos Los eventos son cambios de estado que un sistema debe conocer y reaccionar ante ellos de algn modo. Muchas de las operaciones que producen estos eventos son externas al sistema. 4.2.8 Reglas de activacin Cuando ocurre un evento, lo normal es que el cambio de estado active el llamado a una o ms operaciones. Por ejemplo, si se retiran bienes de un almacn y la cantidad baja de cierto nivel, ello puede activar una operacin para volver a realizar un pedido. Las reglas de activacin definen la relacin entre la causa y el efecto. Siempre que ocurra un evento de cierto tipo, la regla de activacin invoca a una operacin ya definida. Un tipo de evento puede tener varias reglas de activacin, cada una de las cuales invoca a su operacin en paralelo. Las operaciones paralelas pueden producir diferentes cambios de estado en forma simultnea. 4.2.9 Condiciones de Control Una operacin puede ser invocada por una o varias reglas de activacin. Sin embargo, antes de invocar de hecho a la operacin se puede verificar una condicin de control. Si el resultado de evaluacin de la condicin es verdadera se invoca su operacin, en otro caso no.
35
Las condiciones de control tambin pueden actuar como puntos de sincronizacin para el procesamiento en paralelo, pues garantizan que un conjunto de eventos est completo antes de proceder con una operacin. 4.2.10 Subtipos y Supertipos de Eventos.
Los eventos pueden dividirse en subtipos mediante diagramas independientes; o bien, es posible expresar la misma informacin en un diagrama ampliado.
36
La operacin revisar tarea produce dos eventos: tarea aceptada o tarea rechazada. Slo se puede dar uno de estos tipos de evento al revisar una tarea. Aqu tarea revisada es un supertipo de tarea aceptada y tarea rechazada, que son los subtipos. Siempre se entiende que existe una relacin de exclusividad entre los subtipos. Leccin 18 4.3 Diseo de la Estructura y Comportamiento de un Objeto En el diseo de la estructura y comportamiento de objetos se identifican los componentes siguientes:
Clases
que se implantarn. Los tipos de objetos en el AEO sern la gua en esta decisin. Estructuras de Datos que utilizar cada clase. Se puede hacer un diagrama para representar la estructura de datos. Operaciones que ofrecer cada clase y cules sern sus mtodos. Se enumeran las operaciones y se especifican los mtodos. Forma de Implantacin de la herencia de clases y efecto sobre las especificaciones de los datos y operaciones. Identificacin de variantes de clases ("igual que, excepto..."). 4.3.1 Objeto
37
4.3.2. Estructura de un Objeto: Un objeto puede considerarse como una especie de cpsula dividida en tres partes, donde cado uno de ellas desempean un papel independiente que son: LAS RELACIONES: Permiten que el objeto se inserte en la organizacin y estn formadas esencialmente por punteros a otros objetos. LAS PROPIEDADES: Distinguen un objeto determinado de los restantes que forman parte de la misma organizacin y tienen valores que dependen de la propiedad de que se trate. Las propiedades de u objeto pueden ser heredadas a sus descendientes en la organizacin. LOS METODOS: Son las operaciones que pueden realizarse sobre el objeto, que normalmente estarn incorporados en formas de programas (en cdigo) que el objeto es capaz de ejecutar y que tambin pone a disposicin de sus descendientes a travs de la herencia.
Una clase es la evolucin natural de una estructura, la existencia de clases es la caracterstica ms significativa que convierte a muchos lenguajes de programacin en un lenguaje orientado a objetos. Las clases son estructuras que contienen no slo declaraciones de datos, sino tambin 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 declaracin de clase.
38
Clase es la implantacin de un tipo de objeto. Especifica la estructura de datos y los mtodos operativos permitidos que se aplican a cada uno de sus objetos. La clase especfica la estructura de datos de cada uno de sus objetos y las operaciones que se utilizan para tener acceso a los objetos. La especificacin de cmo se llevan a cabo las funciones de una clase se llama mtodo. Los objetos se pueden utilizar exclusivamente con mtodos especficos. Una instancia de una clase, almacena sus datos dentro de l. Se tiene acceso a los datos y se les modifica slo mediante operaciones que son permitidas. Esta restriccin al acceso se debe al encapsulado. El encapsulado protege los datos del uso arbitrario o no permitido. El acceso o la actualizacin directa de los datos de un objeto por parte del usuario violara el encapsulado. Los usuarios observan el "comportamiento" del objeto en trminos 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 definicin de un objeto. Cuando se programa un objeto y se definen sus caractersticas y funcionalidades, realmente se programa una clase. 4.3.2.1 Componentes Una clase es un contenedor de uno o ms datos (variables o propiedades miembro) junto a las operaciones de manipulacin de dichos datos (funciones/mtodos). Las clases pueden definirse como estructuras (struct), uniones (unin) o clases (class) pudiendo existir diferencias entre cada una de las definiciones segn el lenguaje. Variables miembro Las propiedades o atributos que son caractersticas 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 almacn de los datos de estado relacionados con los objetos. Habitualmente, las variables miembro son privadas al objeto (siguiendo las directrices de diseo del Principio de ocultacin) y su acceso se realiza mediante propiedades o mtodos que realizan comprobaciones adicionales. Suelen denominarse con nombres.
39
Mtodos en las clases Implementan la funcionalidad asociada al objeto. Los mtodos 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 implcita. Cuando se desea realizar una accin sobre un objeto, se dice que se le manda un mensaje invocando a un mtodo que realizar la accin. Habitualmente, los mtodos suelen ser verbos. Propiedades Las propiedades son un tipo especial de mtodos. Debido a que suele ser comn 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 mtodos: GetVariable y SetVariable. Los lenguajes orientados a objetos ms modernos (Java, C#, aaden la construccin de propiedad que es una sintaxis simplificada para dichos mtodos: 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 cdigo apropiado que llame a la clusula get o set segn se necesite. Las propiedades se denominan con nombres como las variables. Leccin 19 4.3.3 Diferencia entre operacin y mtodo.5 Las operaciones son procesos que se pueden solicitar como unidades. Losmtodos son especificaciones del procedimiento de una operacin dentro de una clase. Es decir, la operacin es el tipo de servicio solicitado y el mtodo es su cdigo de programacin.
40
Por ejemplo una operacin asociada con la clase pedido podra ser aquella que calcule el total del pedido. El mtodo especificara la forma de calcular el total. Para esto, el mtodo podra obtener el precio de cada artculo del pedido al enviar una solicitud a los objetos artculo asociados. A su vez, cada objeto artculo regresara su precio al mtodo pedido mediante un mtodo de la clase artculo. Los mtodos 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 generalizacin es una nocin conceptual. La herencia de clase (que slo se conoce como herencia) es una implantacin de la generalizacin. La generalizacin 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 reutilizacin por parte de sus subclases. La herencia de las operaciones de una superclase permite que las clases compartan cdigo. La herencia de la estructura de datos permite la reutilizacin de la estructura. 4.3.5 Herencia Mltiple. En la herencia mltiple, una clase puede heredar estructuras de datos y operaciones de ms de una superclase. Por ejemplo supngase 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 tambin tiene como subtipo a cuenta de cliente vencida. Leccin 20 4.3.6 Seleccin del Mtodo. Cuando se enva una solicitud a un objeto, el software selecciona los mtodos por utilizar. El mtodo no se almacena en el objeto, pues esto causara una rplica mltiple y prdida de espacio. En vez de esto, el mtodo se asocia con la clase. El mtodo puede no estar en la clase de la que el objeto es una instancia, sino en una superclase.
41
En ese caso, el mecanismo de seleccin buscar la operacin en su superclase y en todas las superclases de la jerarqua hasta que lo encuentre, nivel por nivel. Si la encuentra, selecciona la operacin. Si la operacin no se encuentra en ningn nivel de la superclase, se considera invlida la fuente de la solicitud. De esta forma, los usuarios slo deben especificar lo que se debe hacer, dejando que sea el mecanismo de seleccin el que determine la forma de localizar la operacin y la ejecute. El mecanismo de seleccin deja en manos de la aplicacin OO el problema de localizar la operacin y la ejecute. 4.3.7 Polimorfismo Uno de los objetivos principales de las tcnicas OO es utilizar otra vez el cdigo. Sin embargo, algunas de las operaciones requieren adaptacin para resolver necesidades particulares. Esta necesidad, se da generalmente entre superclases y subclases, donde una subclase es una especializacin de su superclase, y puede requerir alcanzar los mismos objetivos, pero con distintos mecanismos. Por ejemplo, una superclase rectngulo podra tener una operacin rea cuyo objetivo es calcular el rea del rectngulo, definida como la multiplicacin de los largos de dos lados contiguos. A su vez, la clase cuadrado es una subclase de rectngulo que tambin tiene una operacin rea cuyo objetivo es calcular el rea del cuadrado, pero que est definida especialmente para los objetos del tipo cuadrado como la multiplicacin del largo de uno de sus lados por si mismo. El fenmeno recin descrito se conoce como polimorfismo, y se aplica a una operacin que adopta varias formas de implantacin 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 operacin sin conocer el mtodo que debe ser llamado. Estos detalles de la implantacin quedan ocultos para el usuario; la responsabilidad descansa en el mecanismo de seleccin de la implantacin OO. 4.3.8 Notacin. Para representar una clase, sus atributos y sus mtodos:
42
Para representar una instancia de una clase:
Objeto es una instancia de la Clase. La media luna representa una jerarqua de generalizacin (se lee Objeto 'es un' Clase). La forma general de la declaracin de una clase es: class Nombre_de_la_clase { datos y funciones privados public: datos y funciones publicas } lista de objetos; La sintaxis tpica de una clase es: class Nombre { // Variables miembro (habitualmente privadas) miembro_1; //lista de miembros miembro_2; miembro_3; // Funciones o mtodos (habitualmente pblicas) funcion_miembro_1( ); // funciones miembro conocidas funcion_miembro_2 ( ); // funciones como mtodos // Propiedades (habitualmente pblicas)
43
propiedad_1; propiedad_2; propiedad_3; propiedad_4; } Autoevaluacin 4.4 ACTIVIDADES COMPLEMENTARIAS Parte Uno: 1. Crear el siguiente objeto de la figura:
Donde demuestre la creacin de los 6 mtodos que consta la clase operacin. 2. cual es la diferencia de la programacin orientada objetos con otros lenguajes. 3. Cules son las desventajas de la programacin orientada a objetos? 4. Realiza una estructura por ejemplo del computador de su casa donde indique cuales son los datos y cuales son los mtodos. 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 Introduccin DOO con UML y los Patrones de Diseo JDBC tm, SERVLETS, JSP tm Editorial Pearson Prentice Hall Quinta Edicin, 2. David Arnow Gerald Weiss Introduccin a la Programacin con Java tm Actualizacin a la Versin 2 de Java Editorial Addison Wesley 3. Fcd Javier Ceballos Java 2 Curso de Programacin 2 Edicin Editorial Alfaomega Ra-Ma 4. Agustin Froute Java 2 Manual Usuario tutorial 3 Edicin Editorial Alfaomega Ra-Ma 5. Herbert shildt Fundamentos de Programacin Java 2 Editorial Mc Graw Hill . para conocer el lenguaje de programacin JAVA ya que
44
estn resueltos solo los puede digitar compilar y ejecutar en la casa o laboratorio de su correspondiente CEAD o CERES.
45
Leccin 21 CAPITULO 5. FUNDAMENTOS DE JAVA 5.1 Introduccin 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 programacin. Mquina Virtual Java API Java Es un lenguaje de programacin orientada a objetos puro diseado para su uso en Internet. Se parece mucho a C++, pero adopta algunas ideas de Smalltalk. Los programas se ejecutan por medio de un intrprete que ha sido incorporado a los navegadores de Internet ms usuales. A finales del siglo XX, Java lleg a ser el lenguaje de mayor acogida para programas de servidor. Utilizando una tecnologa llamada JSP (basada en ASP de Microsoft), se hiz muy fcil escribir pginas dinmicas para sitios de Internet. Sumado a esto, la tecnologa de JavaBeans, al incorporarse con JSP, permita utilizar el patrn MVC (Modelo-Vista-Controlador) que ya tanto se haba aplicado a interfaces grficas. Java lleg a ser extremadamente popular cuando Sun Microsystems introdujo el J2EE (Java 2 Enterprise Edition) en la que inclua la tecnologa de Enterprise Java Beans (EJB) que es una tecnologa de objetos distribudos, logrando por fin el sueo de muchas empresas como Microsoft e IBM de crear una plataforma de objetos distribudos con un monitor de transacciones. Con este nuevo estndar, empresas como BEA, IBM, Sun Microsystems, Oracle y otros crearon nuevos "servidores de aplicaciones" que tuvieron gran acogida en el mercado. Adems de programas del servidor, Java permite escribir programas de interfaz grfica o textual. Adems 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 mquina virtual. Esta ltima sirve como una plataforma de abstraccin entre la mquina y el lenguaje permitiendo que se pueda "escribir el programa una vez, y
46
correrlo en cualquier lado". Tambin existen compiladores nativos de Java, tanto comercial como libre. El compilador GCC de GNU compila Java con algunas limitaciones (ao 2002). 5.2 Caractersticas de Java Microsystems, lder 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 mquina individual). Es quien ha desarrollado el lenguaje Java, en un intento de resolver simultneamente todos los problemas que se le plantean a los desarrolladores de software por la proliferacin de arquitecturas incompatibles, tanto entre las diferentes mquinas como entre los diversos sistemas operativos y sistemas de ventanas que funcionaban sobre una misma mquina, aadiendo la dificultad de crear aplicaciones distribuidas en una red como Internet. Hace algunos aos, Sun Microsystems decidi intentar introducirse en el mercado de la electrnica de consumo y desarrollar programas para pequeos dispositivos electrnicos. 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 domsticos: microondas, tostadoras y, fundamentalmente, televisin interactiva. Este mercado, dada la falta de pericia de los usuarios para el manejo de estos dispositivos, requera unas interfaces mucho ms cmodos e intuitivos que los sistemas de ventanas que proliferaban en el momento. Otros requisitos importantes a tener en cuenta eran la fiabilidad del cdigo y la facilidad de desarrollo. James Gosling, el miembro del equipo con ms experiencia en lenguajes de programacin, decidi que las ventajas aportadas por la eficiencia de C++ no compensaban el gran coste de pruebas y depuracin. Gosling haba estado trabajando en su tiempo libre en un lenguaje de programacin que l haba llamado Oak, el cual, an partiendo de la sintaxis de C++, intentaba remediar las deficiencias que iba observando. Los lenguajes 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 electrnica de consumo. La aparicin de un chip ms barato y, generalmente, ms eficiente, conduce inmediatamente a los fabricantes a incluirlo en las nuevas series de sus cadenas de produccin, por pequea que sea la diferencia en precio ya que, multiplicada por la
47
tirada masiva de los aparatos, supone un ahorro considerable. Por tanto, Gosling decidi mejorar las caractersticas de Oak y utilizarlo. El primer proyecto en que se aplic este lenguaje recibi el nombre de proyecto Green y consista en un sistema de control completo de los aparatos electrnicos y el entorno de un hogar. Para ello se construy un ordenador experimental denominado *7 (Star Seven). El sistema presentaba una interfaz basada en la representacin de la casa de forma animada y el control se llevaba a cabo mediante una pantalla sensible al tacto. En el sistema apareca Duke, la actual mascota de Java. Posteriormente se aplic a otro proyecto denominado VOD (Video On Demand) en el que se empleaba como interfaz para la televisin interactiva. Ninguno de estos proyectos se convirti nunca en un sistema comercial, pero fueron desarrollados enteramente en un Java primitivo y fueron como su bautismo de fuego. Una vez que en Sun se dieron cuenta de que a corto plazo la televisin interactiva no iba a ser un gran xito, urgieron a FirstPerson a desarrollar con rapidez nuevas estrategias que produjeran beneficios. No lo consiguieron y FirstPerson cerr en la primavera de 1994. Lo mejor ser hacer caso omiso de las historias que pretenden dar carta de naturaleza a la clarividencia industrial de sus protagonistas; porque la cuestin es si independientemente de su origen y entorno comercial, Java ofrece soluciones a nuestras expectativas. Porque tampoco vamos a desechar la penicilina aunque haya sido su origen fruto de la casualidad. Se puede decir que Java es: Simple: Basado en el lenguaje C++ pero donde se eliminan muchas de las caractersticas POO que se utilizan espordicamente y que creaban frecuentes problemas a los programadores. Esta eliminacin 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 mltiple. Maneja los comandos en lnea de diferente manera que C++ Java tienen una clase String, que permite un mejor manejo que los arrays de terminacin nula del C y C++.
48
Java tiene un sistema automtico de asignacin y liberacin de memoria (recolector de basura) que mejora mucho los sistemas del C++. Orientado al objeto: Java da buen soporte a las tcnicas de desarrollo POO y en resumen a la reutilizacin de componentes de software. Distribuido: Java se ha diseado para trabajar en ambiente de redes y contienen una gran biblioteca de clases para la utilizacin del protocolo TCP/IP, incluyendo HTTP y FTP. El cdigo Java se puede manipular a travs 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 cdigo de bytes (Bytecode), que puede ser interpretado por todas las mquinas que den soporte a un visualizador de que funcione con Java. Este Bytecode no es especifico de una mquina determinada, por lo que no se compila y enlaza como en el ciclo clsico, sino que se interpreta. Slido: El cdigo Java no se quiebra fcilmente ante errores de programacin. As el relaje que existe en la declaracin y manejo de tipos en C y C++ se torna en restricciones en Java, donde no es posible la conversin forzada (cast) de enteros en 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 cdigo. En resumen se eliminan muchas de las posibilidades de "trucos" que ofreca el C y C++. Seguro: Como Java suele funcionar en ambiente de redes el tema de seguridad debe interesar en sobremanera. Las mismas caractersticas antes descritas que evitan la corrupcin de cdigo evitan su manipulacin. Actualmente se esta trabajando en encriptar el cdigo. Arquitectura Neutral: El compilador crea cdigos de byte (Bytecode) que se enva al visualizador solicitado y se interpreta en la mquina 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 caracterstica puede verse de otra manera: Los tipos estndares (int., float...) estn igualmente implementados en todas las mquinas por lo que las operaciones aritmticas funcionaran igual en todas las mquinas. Alto desempeo: Al ser cdigo interpretado, la ejecucin no es tan rpida como el cdigo compilado para una plataforma particular. El compilador Java suele ofrecer la
49
posibilidad de compilar Bytecode en cdigo mquina de determinadas plataformas, y segn Sun este cdigo resultar de una eficacia similar a compilaciones de C y C++. Multihilos: Java puede aplicarse a la realizacin de aplicaciones en las que ocurra ms de una cosa a la vez. Java, apoyndose en un sistema de gestin de eventos basado en el paradigma de condicin y monitores C.A.R. permite apoyar la conducta en tiempo real e interactivo en programas. Dinmico: Al contrario que C++ que exige se compile de nuevo la aplicacin al cambiar una clase madre Java utiliza un sistema de interfaces que permite aligerar esta dependencia. Como resultado, los programas Java pueden permitir nuevos mtodos 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 estticas y publicas de algunas clases pueden considerarse como tales, pero esto generalmente, y como en el caso de las variables globales en C++ son sntoma de un mal diseo. Java no dispone de sentencia goto lo cual permite crear un cdigo ms robusto y seguro as como ms optimizado. Para cubrir esta falta Java proporciona un tratamiento muy optimizado de excepciones, poderoso y bien definido. Los punteros son una caracterstica poderosa y peligrosa del C++, en si evitan que ninguna variable sea privada de verdad, ya que es fcil acceder a la mis a travs 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. El manejo de memoria en C se realiza de forma peligrosa a travs de punteros obtenidos con la funcin malloc (), y que se libera explcitamente 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 montculo de memoria a cada objeto. Lo que se obtiene con new es un descriptor del objeto (no una direccin) la direccin real es manejada por el sistema el cual la puede mover o recolocar segn 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
50
inters 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 asignacin no encuentren lugar disponible. C y C++ disponen de tipos de datos frgiles cuyos lmites y caractersticas dependen de la implementacin y maquina del compilador. Java implementa lmites y tamaos sensatos y validos para todo tipo de mquinas y entornos (independientes del Hardware) por lo que es totalmente reproducible en cualquier plataforma. En C es posible la realizacin de casting o conversin de tipos en tiempo de ejecucin. En C++ esta operacin es peligrosa ya que los objetos son referencias a zonas de memoria y no es posible tener informacin sobre s la conversin en posible. En Java los descriptores de los objetos contienen informacin completa acerca de la clase a la que pertenece el objeto, por lo que pueden realizarse comprobaciones en tiempo de ejecucin sobre la compatibilidad de tipos y emitir la excepcin correspondiente si no es aplicable la conversin. 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 compilacin prcticamente inmanejables, ya que cada compilacin 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 intrprete de Java realizar el acceso. Java no tiene struct ni unin, ambos sistemas de encasulamiento y polimorfismo un tanto crpticos e inseguros del C++, unificando todo en un solo concepto de class. La programacin 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 declaracin final para constantes) que permiten igual potencia. 5.3 Estructura de un programa en Java /**mi primera aplicacin Java @autor jmrr @version 1.1.0.*/ Class AplicacionEsencial {
51
Public static void main (String args[]) { System.out.println("Hola Mundo"); } } Lo anterior representa el cdigo de un programa Java que se compilara y ejecutara de la siguiente forma: El cdigo anterior se guarda en un fichero texto cuya extensin es .java (Aplicacin Escencial. java). Este se compila llamando a javac. El resultado de esta compilacin es un fichero con el nombre de la clase contenida y la extensin .class (AplicacionEsencial.class). El nombre del fichero fuente (.java podr ser cualquiera pero dado que el resultado de la compilacin 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 ejecucin: $ 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 definicin de la misma. _ Cuerpo de la clase que contendr mtodos, operaciones y datos de la clase. En nuestro caso solo contienen un mtodo, el que todas las aplicaciones han de tener: main. _ La lnea: "Public static void main (String args[]) {" da comienzo al mtodo main, las palabras clave que anteceden al nombre indican formas especificas para este y su explicacin se har a posteriori.
52
_ Despus de main se declara los parmetros de este mtodo (String args[]) que en este caso consta de un array de cadenas de caracteres cuyo nombre es args. Esta aplicacin no hace uso de estos parmetros, pero todos los mtodos main han de declarar tal lista, ya que representa la terica lnea de comandos que podra acompaar a la llamada a la clase: _ $java Aplicacin esencial alpha beta _ Entre las llaves de apertura y cierre se encuentra en cuerpo del mtodo o lista de sentencias que le implementan, en nuestro caso una nica llamada al mtodo println. 5.3.1 Creacin 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 lnea de rdenes de la siguiente forma C:\>javac ejemplo.java 5.3.1.1 Mtodos de definicin Los mtodos en java le dan mucho poder y flexibilidad debido a su gran utilidad. Los mtodos son conjuntos de instrucciones agrupadas bajo un mismo nombre y existen 5 tipos de parmetros que son: METODO El incluyen parmetros por valor DESCRIPCIN Este mtodo 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 }
53
El que incluye parmetros por Referencia Los que devuelven un dato
Se caracteriza porque sus parmetros son matrices, arreglos u objetos
Veamos el siguiente ejemplo donde recibe un entero y devuelve un # de dgitos que componen dicho entero, ,entonces: Int p (int a){ If (a<0) a = -a; int f = 0; While (a>0){ F = f+1; a = a/10; } Return f; } Los que no devuelven ningn Estas rutinas se utilizan para cambiar algn valor dato fuera de la funcin Los que no reciben parmetros Esta rutina no recibe parmetros pero pueden generar un valor o cambiar un dato de un variable global.
La forma general de un mtodo es la siguiente: tipo nombre _ de_ mtodo(lista de parmetros) { // cuerpo del mtodo } 5.3.1.2 Palabras clave Las palabras claves son aquellos identificadores reservados por Java para un objetivo determinado y se usan slo de la forma limitada y especfica. Java tiene un conjunto de palabras clave ms rico que C o que C++, por lo que s est aprendiendo Java con conocimientos de C o C++, asegrese de que presta atencin a las palabras clave de Java. Las siguientes palabras son palabras reservadas de Java: Abstact Case Const Else Float boolean cast continue extends for break catch default false future byte char do final generic byvalue class double finally goto
54
If Int Null Protected Static Throw Var implements interface operator public super throws void mport long outer rest switch transient volatile inner native package return syncroniced true while instanceof new private short this try
Tabla 2: Palabras reservadas Java Leccin 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 especfico. Un tipo de dato define todo el posible rango de valores que una variable puede tomar al momento de ejecucin 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 programacin. Estos definen los mtodos de almacenamiento disponibles para representar informacin, junto con la manera en que dicha informacin 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 declaracin 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 categoras: simples y compuestos. Los simples son tipos nucleares que no se derivan de otros tipos, como los enteros, de coma flotante, booleanos y de carcter. Los tipos compuestos se basan en los tipos simples, e incluyen las cadenas, las matrices y tanto las clases como las interfaces, en general.
55
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 nmeros enteros con signo. Hay cuatro tipos: byte, short, int y long. Tipo Byte Short Int Long Tabla 5: Tipos de datos enteros Literales enteros Son bsicos en la programacin en Java y presentan tres formatos:
Decimal:
Tamao 1Byte (8 bits) 2 Bytes (16 bits) 4 Bytes (32 bits) 8 Bytes (64 bits)
Los literales decimales aparecen como nmeros ordinarios sin ninguna notacin especial. Hexadecimal: Los hexadecimales (base 16) aparecen con un 0x 0X inicial, notacin similar a la utilizada en C y C++. Octal: Los octales aparecen con un 0 inicial delante de los dgitos. Por ejemplo, un literal entero para el nmero 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 nmeros muy grandes, con el tipo long, (8 bytes con signo), aadiendo una L l al final del nmero. La declaracin de variables enteras es muy sencilla. Un ejemplo de ello sera: long numeroLargo = 0xC; // Por defecto vale 12 Tipos de datos en coma flotante
56
Se usan para representar nmeros con partes fraccionarias. Hay dos tipos de coma flotante: float y double. El primero reserva almacenamiento para un nmerode precisin simple de 4 bytes y el segundo lo hace para un numero de precisin doble de 8 bytes. Tipo Float Doubl Tamao 4 Byte (32 bits) 8 Bytes (64 bits)
Tabla 6: Tipos de datos numricos en coma flotante Literales en coma flotante Representan nmeros decimales con partes fraccionarias. Pueden representarse con notacin estndar (563,84) o cientfica (5.6384e2). De forma predeterminada son del tipo double (8 bytes). Existe la opcin de usar un tipo ms corto (el tipo float de 4 bytes), especificndolo con una F f al final del nmero. La declaracin 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 Se usa para almacenar variables que presenten dos estados, que sern 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 numrico, y verdadero cualquier nmero que no fuese el 0.
57
Para declarar un dato del tipo booleano se utiliza la palabra reservada boolean: boolean reciboPagado = false; // Aun no nos han pagado?! Tipo de datos carcter 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 carcter Representan un nico carcter (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 cdigo carcter. Descripcin Caracter Unicode Numero octal Barra invertida Continuacin Retroceso Retorno de carro Alimentacin de Formularios Tabulacin horizontal Lnea nueva Comillas simples Comillas dobles Nmeros arbigos ASCII Alfabeto ASCII en Maysculas Alfabeto ASCII en Minsculas Representacin \udddd \ddd \\ \ \b \r \f \t \n \ \" 0-9 A.-Z a.-z Valor Unicode
\u005C \ \u0008 \u000D \u000C \u0009 \u000A \u0027 \u0022 \u0030 a \u0039 \u0041 a \u005A \u0061 a \u007A
Tabla 7: Caracteres especiales Java Las variables de tipo char se declaran de la siguiente forma: char letraMayuscula = 'A'; // Observe la necesidad de las ' '
58
char letraV = '\u0056'; // Letra 'V' Conversin 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 "conversin", "moldeado" o "tipado". La conversin se lleva a cabo colocando el tipo destino entre parntesis, a la izquierda del valor que queremos convertir de la forma siguiente: char c = (char)System.in.read(); La funcin read devuelve un valor int, que se convierte en un char debido a la conversin (char), y el valor resultante se almacena en la variable de tipo carcter c. El tamao de los tipos que queremos convertir es muy importante. No todos los tipos se convertirn 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 informacin 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 Byte Short Char Int Long Float
Tipo Destino double, float, long, int, char, short double, float, long, int double, float, long, int double, float, long double, float double
Tabla 8: Conversiones sin prdidas de informacin 5.3.3 Operadores y expresiones Un operador es un smbolo especial que indica al compilador que debe efectuar una operacin matemtica o lgica, java reconoce los siguientes operadores. OPERADOR + OPERACIN SUMA
59
* / % RESTA MULTIPLICACIN DIVISIN RESIDUO O MODULO
Es importante tener en cuenta lo siguiente: En problemas de divisin entre nmeros enteros, java trunca la parte residual, ejemplo: Dividir--_13/5---_el resultado es 2 Para resolver los problemas de potencias y races, se usan ciertas instrucciones especiales que proporcionan el lenguaje, llamadas funciones matemticas, en java existe toda una librera de instrucciones o funciones matemticas. Recordar que todas las funciones reciben uno o ms datos o valores y regresan siempre un resultado, una de estas funciones matemticas es: import java,lang.math : piblic stagic double pow(double a, double b) ; Esta funcin ocupa dos valores o datos (base y exp) ambos de tipo double, y regresa un resultado tambin 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
60
Para resolver el problema de races, se aprovecha una de las ms elementales y conocida de las leyes de exponentes que dice:
Es decir una raz cualquiera se puede transformar a una potencia con un exponente fraccionario ejemplo: Problema y = 3 x esto es equivalente a y-3*x1/2 entonces //hay que usar la funcin 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 funcin pow () para trabajar correctamente. Para realizar operaciones con objetos numricos, 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 numrico 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 numricos, luego dos variables numricas normales, luego estas dos ltimas variables se cargan con los objetos numricos que emplean mtodos propios para convertirlos a datos normales. La librera matemtica completa incluye: Class Math Public final class java.lang.math
61
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); 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); }
62
Leccin 23 5.3.4 E/S caracteres: Los programas en java realizan la E/S a travs de flujos(stream). Un flujo es una abstraccin que produce o consume informacin. Un flujo esta relacionado con un dispositivo fsico a travs del sistema de E/S de java. Todos los flujos se comportan de la misma forma, incluso aunque estn relacionados con distintos dispositivos fsicos. Esto significa que un flujo de entrada puede abstraer distintos tipos de entrada, desde un archivo de disco o una conexin de red. Clases de flujos: java implementa los flujos dentro de una jerarqua de clases definida en el paquete java.io. En la parte superior hay dos clases abstractas que son: InputStream OutputStream Estas clases definen los mtodos read( ) y write( ) que respectivamente leen y escriben bytes de datos, hay que tener en encuenta que estos mtodos estn declarados como abstracto dentro de inputStream y OutputStream y son sobrescritos en las clases derivadas. Flujos predefinidos: java importa automticamente el paquete java.lang. Este paquete define una clase llamada system que encapsula algunos aspectos del entorno de ejecucin. System.out: salida estndar. Por defecto, es la consola System.in: hace referencia a la entrada estndar que es por defecto el teclado System. Err: hace referencia al flujo de error estndar que por defecto es la consola. Java no tiene un mtodo de entrada por consola generalizado que sea similar a la funcin scanf() de c o a lo operadores de entrada de C++. Ejemplo: // ejemplo del mtodo read(). Import java.io.*; Class Usuread { public static void main (string args[]) throws IOExceptoon { char c;
63
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 Leccin 24 5.3.5 Estructuras De Control Durante un programa existen acciones que se han de repetir un nmero determinado de veces. Por ejemplo, leer 3 caracteres de un flujo de entrada in se codificara: in.read(); in.read(); in.read(); Este cdigo adems de poco elegante sera inviable para una repeticin de 3000 lecturas. Por eso aparecen las estructuras de control, que facilitan que determinadas acciones se realicen varias veces, mientras que una condicin se cumpla, y en definitiva, tomar decisiones de qu hacer en funcin de las condiciones que se den en el programa en un momento dado de su ejecucin. As, nuestro ejemplo se podra indicar como: i nt i=0; for ( i=0 ; i <= 3 ; i++ ) in.read(); Donde bastara cambiar el 3 por cualquier otro nmero para que la lectura se repitiese ese nmero de veces. El lenguaje Java soporta las estructuras de control:
64
Sentencia Toma de decisin Bucle Miscelneo 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 bifurcacin 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 segn algn criterio. La sintaxis de la sentencia if-else es: If ( condicin ) Bloque de cdigo a ejecutar si la condicin es cierta else Bloque de cdigo a ejecutar si la condicin es falsa La parte del else es opcional, y un bloque de cdigo puede ser simplemente la sentencia vaca; 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 botn aceptar o el botn 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) { // cdigo para realizar la accin Aceptar System.out.println( "Su peticion esta siendo atendida" ); } else { // cdigo para realizar la accin Cancelar System.out.println( "Cancelando accion" ); }
65
Se pueden anidar expresiones if-else, para poder implementar aquellos casos con mltiples acciones. Esto es lo que se suele denominar como sentencias else if. Por ejemplo, supongamos que se desea escribir un programa que clasifique segn 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 lneas que los else, pero se recomienda utilizar la tabulacin (como se ha podido ver en el ejemplo), pues es ms clara para el lector. 5.3.5.1.2. La sentencia switch Mediante la sentencia switch se puede seleccionar entre varias sentencias segn el valor de cierta expresin. Es una instruccin de decisin mltiple donde el compilador prueba o busca casos, o se usa una condicin compuesta muy grande. La forma general de switch es la siguiente:
66
switch ( expresionMultivalor ) { case valor1 : conjuntoDeSentencias; break; case valor2 : conjuntoDeSentencias; break; case valor3: conjuntoDeSentencias; break; default: conjuntoDeSentencias; break; } La sentencia switch evala la expresinMultivalor y ejecuta el conjuntoDeSentencias que aparece junto a la clusula case cuyo valor corresponda con el de la expresinMultivalor. Cada sentencia case debe ser nica y el valor que evala debe ser del mismo tipo que el devuelto por la expresinMultivalor de la sentencia switch. Las sentencias break que aparecen tras cada conjuntoDeSentencias provocan que el control salga del switch y contine con la siguiente instruccin al switch. Las sentencias break son necesarias porque sin ellas se ejecutaran 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 explcitamente 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 operacin: 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; }
67
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 dems meses El decidir si usar la sentencia if o switch depende del criterio de cada caso. Se puede decidir cul usar basndonos en la legibilidad, aunque se recomienda utilizar switch para sentencias con ms de tres o cuatro posibilidades. 5.3.5.2. Sentencias de iteracin o bucles: for, do, while 5.3.5.2.1 Bucle while El bucle while es el bucle bsico de iteracin. Sirve para realizar una accin sucesivamente mientras se cumpla una determinada condicin. La forma general del bucle while es la siguiente: while ( expresinBooleana ) { sentencias; }; Las sentencias se ejecutan mientras la expresinBooleana 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 condicin. Por ejemplo, multiplicar un nmero por 2 hasta que sea mayor que 100: int i = 1; while ( i <= 100 )
68
{ i = i * 2; } Con l se podran eliminar los bucles do-while y for por ser extensiones de ste, pero que se incluyen en el lenguaje para facilitar la programacin. 5.3.5.2.2 Bucle do-while El bucle do-while es similar al bucle while, pero en el bucle while la expresin se evala al principio del bucle y en el bucle do-while la evaluacin se realiza al final. La forma general del bucle do-while es la siguiente: Do { sentencias; } while ( expresinBooleana ); La sentencia do-while es el constructor de bucles menos utilizado en la programacin, pero tiene sus usos, cuando el bucle deba ser ejecutado por lo menos una vez. Por ejemplo, cuando se lee informacin de un archivo, se sabe que siempre se debe leer por lo menos un carcter: Int c; do { c = System.in.read( ); // Sentencias para tratar el carcter c } while ( c != -1 ); // No se puede leer ms (Fin fichero) 5.3.5.2.3 Bucle for Mediante la sentencia for se resume un bucle do-while con una iniciacin previa. Es muy comn que en los bucles while y do-while se inicien las variables de control de nmero de pasadas por el bucle, inmediatamente antes de comenzar los bucles. Por eso el bucle for est tan extendido. Se utiliza para repetir una instruccin o un grupo de instrucciones un determinado nmero de veces.
69
Su formato general es: For (inicializacin; condicin; incremento) { Instruccin(es); }; En su forma simple la inicializacin es una instruccin de asignacin que carga una variable de control de ciclo con un valor inicial. La condicin es una expresin relacional que evala 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 { printWriter pagina=respionse.getWriter(); response.setContentType(text/html); pagina.println(<HTML>); int x; for(x=1;x<=10;x++) {pagina.printl(x=+x+<br>); pagina.println(</HTML>); pagina.close(); pagina.flusch(); }; public void destroy(){sper.destroy();}; }
70
Leccin 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 vlido 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 sera 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"); } } Al interpretar break a, no solo se rompe la ejecucin del bucle interior (el de j), sino que se salta al final del bucle i, obtenindose: i=1 j=1 j=2 j=3
71
Nota: Se desaconseja esta forma de programacin, 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 iteracin, tambin se puede desear continuar con el bucle, pero dejando pasar una determinada iteracin. 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 invocacin a una sentencia continue se transfiere el control a la condicin de terminacin del bucle, que vuelve a ser evaluada en ese momento, y el bucle contina o no dependiendo del resultado de la evaluacin. En los bucles for adems en ese momento se ejecuta la clusula de incremento (antes de la evaluacin). Por ejemplo el siguiente fragmento de cdigo imprime los nmeros 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 cdigo: void gotoContinue( ) { f for ( int i=1; i <5; i++ ) { for ( int j=1; j<5; j++ ) { if ( j>i ) {
72
System.out.println(" "); continue f; } System.out.print( " " + (i*j) ); } } } En este cdigo la sentencia continue termina el bucle de j y continua el flujo en la siguiente iteracin de i. Ese mtodo imprimira: 1 24 369 4 8 12 16 Nota: Se desaconseja esta forma de programacin, 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 mtodo 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 expresin que calcule el valor) a continuacin de la palabra return. El valor devuelto por return debe coincidir con el tipo declarado como valor de retorno del mtodo. Cuando un mtodo se declara como void se debe usar la forma de return sin indicarle ningn valor. Esto se hace para no ejecutar todo el cdigo del programa: int contador; boolean condicion; int devuelveContadorIncrementado() { return ++contador; } void metodoReturn() { //Sentencias if ( condicion == true )
73
return; //Ms sentencias a ejecutar si condicin 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 mtodos de definicin para complementar el tema 4. Realice un mapa conceptual sobe el tema anterior. 5. Exponga 10 ventajas de para utilizar instrucciones repetitivas 6. Realice un mapa conceptual con 20 trminos sobre tipo de datos y declaraciones. 7. Disear un programa que despliegue los nmeros del 20 al 30. 8. Disear un programa de los mltiplos de 5, entre 10 y 50, acompaados de su factorial y logaritmo respectivo. 9. Disear un programa donde se despliegue las tablas de multiplicar que usuario indique. 10. Disear un programa que muestre los mltiplos de 4 entre 60 y 20 acompaados de su logaritmo de base 10 y base e respectivos. 11. Construir la tabla de dividir que el usuario indique. 12. Disear un programa que capture un deporte cualquiera y despliegue dos implementos deportivos apropiados. 13. construir un programa que capture un nmero cualesquiera y diga si es o no es mayor de 50 y mltiplo de tres. 14. construir un programa que indique si un nmero es par positivo. 15. construir un programa que capture los datos de un empleado, desplegar en una pgina su cheque semanal si gana ms de $500.000 y si esta en el departamento de produccin, en caso contrario desplegar en otra pgina 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 Introduccin DOO con UML y los Patrones de Diseo JDBC tm, SERVLETS, JSP tm Editorial Pearson Prentice Hall Quinta Edicin, 2. David Arnow Gerald Weiss Introduccin a la Programacin con Java tm Actualizacin a la Versin 2 de Java Editorial Addison Wesley 3. Fcd Javier Ceballos Java 2 Curso de Programacin 2 Edicin Editorial Alfaomega Ra-Ma 4. Agustin Froute Java 2 Manual Usuario tutorial 3 Edicin Editorial Alfaomega Ra-Ma 5. Herbert shildt Fundamentos de Programacin
74
Java 2 Editorial Mc Graw Hill . para conocer el lenguaje de programacin JAVA ya que estn resueltos solo los puede digitar compilar y ejecutar en la casa o laboratorio de su correspondiente CEAD o CERES.
75
Leccin 26 Capitulo 6 Guia de Laboratorio
6.1. CAJAS DE DIALOGO El mtodo showMessageDialog Este mtodo nos permite mostrar dilogos que muestran un mensaje y contienen un botn de aceptacin. Los parmetro mnimos necesarios dependen del carcter del mensaje aunque general mente son la ventana padre, el mensaje a mostrar, el ttulo del dilogo y el tipo de mensaje que se mostrar. En las siguientes figuras podremos ver algunos ejemplos junto al cdigo que lo genera. JOptionPane.showMessageDialog( null, Dilogo de informacin);
JOptionPane.showMessageDialog( null, JOptionPane.WARNING_MESSAGE);
Dilogo
de
advertencia,
Ttulo
del
Mensaje,
JOptionPane.showMessageDialog( JOptionPane.ERROR_MESSAGE);
null,
Dilogo
de
error,
Ttulo
del
Mensaje,
El mtodo showInputDialog Este mtodo nos permite mostrar dilogos estandarizados que nos piden que introduzcamos algn dato. Al igual que en los mtodos anteriores los argumentos que utilizan principalmente son el mensaje a mostrar, el ttulo, etc. A continuacin vemos un ejemplo de uso de este mtodo. String n = JOptionPane.showInputDialog(null, "Introduce el dato");
76
Como podemos observar en el cdigo anterior este mtodo nos devuelve una cadena que contiene los datos que hemos introducido en el dilogo. 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 extensin java), en este caso Interfaz b. En la Casilla de Texto Location: C:\ o utilice el botn y seleccione C: (Carpeta Raz) c. Pulse el Botn Finish 3. En la Ventana de Cdigo escriba: import javax.swing.*; public class Interfaz { public static void main(String args[]) { JOptionPane.showMessageDialog( null, "Dilogo de informacin"); JOptionPane.showMessageDialog( null, "Dilogo de advertencia", "Ttulo del Mensaje", JOptionPane.WARNING_MESSAGE); JOptionPane.showMessageDialog( null, "Dilogo de error", "Ttulo del Mensaje", JOptionPane.ERROR_MESSAGE); String n = JOptionPane.showInputDialog(null, "Introduce el dato"); } } donde las cajas de Dialogo estn en el paquete de clases javax.swing, por eso, en la clusula import javax.swing.*; 4. Compile y Ejecute el Programa Men Build > Compile File Men Build > Execute File
77
6.2. Definiciones de Arreglos
1. Declaracin de un arreglo: int A[]; // A es un arreglo de enteros int A[10]; // error, el tamao 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. Creacin de un arreglo int A[]= new int[10]; // 10 enteros Subindicacin de un arreglo: A[0], A[1], ..., A[9] // correcto A[10] // error, ndice fuera // de rango 3. Modificacin de un arreglo: A[3]= 8; 4. Tamao de un arreglo: A.length // correcto A.length() // error, sin parntesis 5. Inicializacin de un arreglo: for (int i=0; i<A.length; i++) A[i]= i; 6. Asignacin de punteros a arreglos int B[]; B= A; // A y B son el mismo arreglo if (A==B) // Comparacin de punteros // true! ... A[0]= 10; B[0] // tambin 10 7. Copia de un arreglo: B= (int[])A.clone();
78
6.3. LECTURA DE UN VECTOR POR TECLADO import javax.swing.*; public class LecturaVector { 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<A.length;i++) { A[i]=Integer.parseInt(JOptionPane.showInputDialog(null,"Digite A["+i+"]: ")); } System.out.println("Vector Leido"); for(i=0;i<A.length;i++) { System.out.print(A[i]+" "); } System.out.println(); System.exit(0); } } 6.4. ASIGNACION A UN VECTOR DE NUMEROS ALEATORIOS import javax.swing.*; import java.util.*; public class LectorVectorAleatoria { 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]; Random R=new Random(); //Objeto que genera el aleatorio for(i=0;i<A.length;i++) { A[i]=Math.abs(R.nextInt()%100+1); // R,nextInt()%100+1)::Aleatorio Entero desde 1 hasta los siguientes 100 } System.out.println("Vector Leido"); for(i=0;i<A.length;i++) { System.out.print(A[i]+" "); } System.out.println(); System.exit(0); } }
79
6.5. ORDENAMIENTO DE UN VECTOR. METODO LINEAL import javax.swing.*; public class OrdenarLineal { 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<A.length;i++) { A[i]=Integer.parseInt(JOptionPane.showInputDialog(null,"Digite A["+i+"]: ")); } System.out.println("Vector Leido"); for(i=0;i<A.length;i++) { System.out.print(A[i]+" "); } System.out.println(); for(i=0;i<A.length-1;i++) for(j=i+1;j<A.length;j++) if(A[i]>A[j]) { aux=A[i]; A[i]=A[j]; A[j]=aux; } System.out.println("Vector Ordenado"); for(i=0;i<A.length;i++) { System.out.print(A[i]+" "); } System.out.println(); } } 6.6. ORDENAMIENTO DE UN VECTOR. METODO BURBUJA import javax.swing.*; public class OrdenarBurbuja { 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<A.length;i++) { A[i]=Integer.parseInt(JOptionPane.showInputDialog(null,"Digite A["+i+"]: ")); }
80
System.out.println("Vector Leido"); for(i=0;i<A.length;i++) { System.out.print(A[i]+" "); } System.out.println(); for(i=1;i<=A.length-1;i++) for(j=0;j<A.length-i;j++) 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;i<A.length;i++) { System.out.print(A[i]+" "); } System.out.println(); } } 6.7. BUSQUEDA DE UN ELEMENTO EN UN VECTOR ORDENADO. METODO SECUENCIAL import javax.swing.*; public class BuscarLinealOrdenado { 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<A.length;i++) { A[i]=Integer.parseInt(JOptionPane.showInputDialog(null,"Digite A["+i+"]: ")); } System.out.println("Vector Leido"); for(i=0;i<A.length;i++) { System.out.print(A[i]+" "); } System.out.println(); for(i=0;i<A.length-1;i++) for(j=i+1;j<A.length;j++) if(A[i]>A[j]) { aux=A[i]; A[i]=A[j]; A[j]=aux; } System.out.println("Vector Ordenado"); for(i=0;i<A.length;i++)
81
{ System.out.print(A[i]+" "); } System.out.println(); j=Integer.parseInt(JOptionPane.showInputDialog(null,"Digite el Numero a Buscar: ")); i=0; while(i<A.length && A[i]<j) i++; if(i<A.length && A[i]==j) 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;i<A.length;i++) { A[i]=Integer.parseInt(JOptionPane.showInputDialog(null,"Digite A["+i+"]: ")); } System.out.println("Vector Leido"); for(i=0;i<A.length;i++) { System.out.print(A[i]+" "); } System.out.println(); for(i=0;i<A.length-1;i++) for(j=i+1;j<A.length;j++) if(A[i]>A[j]) { aux=A[i]; A[i]=A[j]; A[j]=aux; } System.out.println("Vector Ordenado"); for(i=0;i<A.length;i++) { System.out.print(A[i]+" "); } System.out.println(); j=Integer.parseInt(JOptionPane.showInputDialog(null,"Digite el Numero a Buscar: "));
82
menor=0; mayor=A.length-1; do { mitad=(menor+mayor)/2; if(A[mitad]>j) mayor=mitad-1; if(A[mitad]<j) menor=mitad+1; } while(A[mitad]!=j && mayor>=menor); if(A[mitad]==j) 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. Creacin 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<n;i++) A[i]=B[i]; } boolean verificarasc() // Verifica Ordenamiento ascendente { for(i=0;i<n-1 && A[i]<=A[i+1];i++); if(i<n-1) return false; else return true; } boolean verificardesc() // Verifica Ordenamiento Descendente { for(i=0;i<n-1 && A[i]>=A[i+1];i++); if(i<n-1)
83
return false; else return true; } boolean buscarasc(int x) // Busqueda Ascendente { for(i=0;i<n && A[i]<x;i++); if(i<n && A[i]==x) return true; else return false; } boolean buscardesc(int x) // Busqueda Descendente { for(i=0;i<n && A[i]>x;i++); if(i<n && A[i]==x) return true; else return false; } boolean busqueda(int x) // Busqueda Normal { for(i=0;i<n && A[i]!=x;i++); if(i<n) return true; else return false; } void consulta() // Recorrer el contenido de vector { StringBuffer S=new StringBuffer(); for(i=0;i<n;i++) { S.append(A[i]); S.append('\n'); } JOptionPane.showMessageDialog(null,S.toString()); } void lectura() // Leer el Vector { for(i=0;i<n;i++) { A[i]=Integer.parseInt(JOptionPane.showInputDialog(null," Vector Posicion ["+i+"]")); } } void ordenarasc() // Ordenar Ascendente {
84
for(i=0;i<n-1;i++) for(j=i+1;j<n;j++) if(A[i]>A[j]) { aux=A[i]; A[i]=A[j]; A[j]=aux; } } void ordenardesc()// Ordenar Descendente { for(i=0;i<n-1;i++) for(j=i+1;j<n;j++) if(A[i]<A[j]) { 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;i<B.length;i++) B[i]=Math.abs(R.nextInt()%100+1); String S=new String(); Arreglo Z=new Arreglo(B); String Menu="1. Lectura \n 2. Ordenar Ascendente \n 3. Ordenar Descendente \n 4. Busqueda \n 5. Consulta \n6. Salir \n Seleccion Opcion[1..6]"; do { do { S=JOptionPane.showInputDialog(null,Menu); try { opcion=Integer.parseInt(S); } catch(NumberFormatException e) { opcion=0; // Error de Conversion } }while(opcion<1 || opcion>6); if(opcion!=6) { switch(opcion) {
85
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); System.exit(0); } } 6.9.2 Programa 2. Uso de un Objeto StringBuffer para la presentacin 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;i<A.length;i++) { P.append(" "); A[i]=Math.abs(R.nextInt()%99+1); P.append(A[i]); } ordenar(); adicionOrdenado(); } void ordenar() { for(i=0;i<A.length-1;i++) for(j=i+1;j<A.length;j++) if(A[i]>A[j]) { aux=A[i]; A[i]=A[j]; A[j]=aux; }
86
} String impresion() { return P.toString(); } void adicionOrdenado() { P.append(" Vector Ordenado: "); for(i=0;i<A.length;i++) { P.append(" "); P.append(A[i]); } } } class CasoVector2 { StringBuffer P=new StringBuffer("Vector de Entrada: Vector de Salida: "); StringBuffer Q; int i,j,aux; int A[]=new int[10]; Random R=new Random(); public CasoVector2() { for(i=0;i<A.length;i++) A[i]=Math.abs(R.nextInt()%99+1); j=new String(P.toString()).indexOf(':'); insertar(j); ordenar(); j=new String(P.toString()).lastIndexOf(':'); insertar(j); } void insertar(int k) { Q=new StringBuffer(); for(i=0;i<A.length;i++) { Q.append(" "); Q.append(A[i]); } P.insert(k+1,Q.toString()); } void ordenar() { for(i=0;i<A.length-1;i++) for(j=i+1;j<A.length;j++) if(A[i]>A[j]) { aux=A[i]; A[i]=A[j]; A[j]=aux; } }
87
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.*; 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) {
88
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); 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);
89
JOptionPane.showMessageDialog(null," Valor Inverso de String a char[]: "+new String().valueOf(C).toString()); for(i=0;i<A.length;i++) B.append(A[i]); JOptionPane.showMessageDialog(null," Valor Inverso de un Entero a int[]: "+B.toString()); JOptionPane.showMessageDialog(null," Valor Inverso de String a String "+new String().valueOf(I.pasar(S)).toString()); JOptionPane.showMessageDialog(null," Valor Inverso de String a int "+B.toString()); } }
Leccin 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]; //Lectura() for(i=0;i<filas;i++) for(j=0;j<columnas;j++) A[i][j]=Math.abs(R.nextInt()%99+1); //Escritura System.out.println(" ------ Matriz Leida -------"); for(i=0;i<filas;i++) { System.out.println(); for(j=0;j<columnas;j++) { if(A[i][j]>=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: "));
90
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<filas;i++) for(j=0;j<columnas;j++) A[i][j]=Math.abs(R.nextInt()%10+1); for(i=0;i<filas;i++) { sumad=sumad+A[i][d]; sumat=sumat+A[i][t]; d++; t--; } //Escritura System.out.println(" ------ Matriz Leida -------"); for(i=0;i<filas;i++) { System.out.println(); for(j=0;j<columnas;j++) { if(A[i][j]>=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.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<n;i++) for(j=0;j<n;j++) A[i][j]=Math.abs(R.nextInt()%10+1);
91
for(i=0;i<n;i++) { sumad=sumad+A[i][d]; sumat=sumat+A[i][t]; d++; t--; } //Escritura System.out.println(" ------ Matriz Leida -------"); for(i=0;i<n;i++) { System.out.println(); for(j=0;j<n;j++) { if(A[i][j]>=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.*; 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<n;i++) for(j=0;j<n;j++) if(i==j) A[i][j]=1; else A[i][j]=0; //Escritura System.out.println(" ------ Diagonal -----"); for(i=0;i<n;i++) { System.out.println(); for(j=0;j<n;j++) System.out.print(A[i][j]+" "); } System.out.println();
92
System.exit(0); } } 6.10.4. Programa de Copas import javax.swing.*; class Copas { 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; Random R=new Random(); int A[][]=new int[n][n]; //Lectura() for(i=0;i<n;i++) for(j=0;j<n;j++) A[i][j]=0; for(i=0;i<n;i++) { for(j=d;j<=t;j++) A[i][j]=1; for(j=t;j<=d;j++) A[i][j]=1; d++; t--; } //Escritura System.out.println(" ------ Copas-----"); for(i=0;i<n;i++) { System.out.println(); for(j=0;j<n;j++) { if(A[i][j]==0) System.out.print(" "); else System.out.print("*"); } } System.out.println(); System.exit(0); } } 6.10.5. Programa Simulacin de un Inventario import java.util.*; import javax.swing.*; class Inventario { int i,j,k; final int n=10;
93
int A[][]=new int[n][4]; //Simulador de un Kardex Random R=new Random(); public Inventario() { for(k=0;k<n;k++) { do { j=Math.abs(R.nextInt()%999+1); } while(existe(j)!=-1); A[k][0]=j; // Referencia del Articulo A[k][1]=Math.abs(R.nextInt()%999+1); // Cantidad de Articulos A[k][2]=0; // Entrada de Productos A[k][3]=0; // Salida de Productos } } int existe(int x) { boolean esta=false; i=0; while(i<n && !esta) { if(A[i][0]==x) esta=true; else i++; } if(esta) return i; else return -1; } void venta(int cant,int pos) { 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<n;i++)
94
{ P.append("\n "); for(j=0;j<4;j++) { P.append(A[i][j]); if(A[i][j]<10) P.append(" "); if(A[i][j]<100) P.append(" "); P.append(" "); } } return P.toString(); } } public class Kardex { public static void main(String[] args) { Inventario X=new Inventario(); Object[] Opcion={"1. Compra","2. Venta","3. Consulta","4.Cierre"}; int opc,pos; String S; do { S=(String) JOptionPane.showInputDialog(null,"Opciones: "," Almacen Doris",JOptionPane.QUESTION_MESSAGE,null,Opcion,Opcion[2]); opc=Character.digit(S.charAt(0),10); switch(opc) { case 1: pos=X.existe(Integer.parseInt(JOptionPane.showInputDialog(null," Digite Codigo "))); if(pos==-1) JOptionPane.showMessageDialog(null,"No existe Codigo"); else 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); } }
95
Leccin 28
6.10.6. Programa Simulacin 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<n;i++) for(j=0;j<n;j++) if(Entrada[i][j]!=0) k++; if(k==n*n) return true; else return false; } void reloj() { int hi=hora+2; ha=(hora*60)+minuto; do { do { h=Math.abs(R.nextInt()%21+hora); } while(h<hora || h>hora+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; }
96
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<n && !esta) { j=0; while(j<n && !esta) if(Placa[i][j]==placa) esta=true; else j++; if(!esta) i++; } return esta; } String leerReloj(int hm) { String H=new String(new String().valueOf(hm/100)); String M=new String(new String().valueOf(hm%100)); String P=new String(":"); return new String(H.concat(P.concat(M))).toString(); } 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
97
{ 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<n;i++) for(j=0;j<n;j++) if(Placa[i][j]!=0) { P.append("\n "); P.append(Placa[i][j]); P.append(" "); P.append(Militar[i][j]); } return P.toString(); } } public class Parqueadero { public static void main(String[] args) { Object[] Opcion={"1. Entrada","2. Salida","3. Consulta","4. Cierre"}; int opc,placa; String S; Parqueo P=new Parqueo(); do { S=(String) JOptionPane.showInputDialog(null,"Opciones: "," Parqueadero Doris",JOptionPane.QUESTION_MESSAGE,null,Opcion,Opcion[0]); opc=Character.digit(S.charAt(0),10); switch(opc) { case 1: if(!P.noatiende() && !P.lleno()) { 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);
98
} break; case 3: JOptionPane.showMessageDialog(null," } } while(opc!=4); System.exit(0); } }
Parqueadero Doris \n"+P.impresion().toString());
Leccin 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 nmero de Nit")); if(A.existe(C.nit) || B.existe(C.nit)) JOptionPane.showMessageDialog(null,"Existe Nit"); else 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())
99
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() { if(min==-1) return true; else return false; } boolean llena() { if(max==n-1) return true; else
100
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: import javax.swing.*; import java.io.*; import java.lang.Math.*; import java.util.*; public class Cola2 { public static void main(String[]args) {
101
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 nmero 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 nmero 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"); else { A.borra_max(); } break; case 5:
102
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<n;i++) A[i]=new Info(); } boolean vacia() { if(min==-1) return true; else return false; } boolean llena() { if(min==0 && max==n-1) return true; else return false; } boolean tope() { if(max==n-1) return true; else return false; } boolean minimo() { if(min==0) return true;
103
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.*; import java.util.*; public class Cola3
104
{ 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 nmero 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[];
105
int i; String S=" "; public ColaCir(int n) { min=-1; max=-1; this.n=n; A=new Info[n]; for(i=0;i<n;i++) A[i]=new Info(); } boolean vacia() { if(min==-1) return true; else return false; } boolean llena() { if((min==0 && max==n-1) || (max==min-1)) return true; else return false; } void adicion(Info C) { if(min==-1) min=0; if(max==n-1) max=0; else max++; A[max].nit=C.nit; A[max].telefono=C.telefono; A[max].nomCliente=C.nomCliente;; } void borrar() { if(min==max) min=max=-1; else if(min==n-1) min=0; else min++; } String imprime() { S=" Elemenos de la Cola \n"; if(max<min) { consulta(min,n-1); consulta(0,max);
106
} else 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"; } } }
Leccin 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();
107
break; case 3: if(A.vacia()) JOptionPane.showMessageDialog(null,"Cola de Atencion Vacia"); 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; }
108
boolean hayMas() { if(numreg<P.tope()) return true; else return false; } 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");
109
} catch(FileNotFoundException e) { System.out.println("No Existe Archivo"); return false; } return true; } 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<arch.length()); } catch(IOException e) { } } void bajar() { try { arch.seek(pos); for(k=pos;k<pos+longreg;k++) { if(k==7 || k==27) linea.append(" "); linea.append(arch.readChar()); } } catch(IOException e) { } } String consulta(int n) { String S=new String().valueOf(n); linea=new StringBuffer(); pos=Long.parseLong((String) H.get(S)); bajar(); return linea.toString(); } long longitud() { long k=0; try
110
{ k=arch.length(); } catch(IOException e){} return k; } int tope() { return numreg; } 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){} } }
Leccin 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;
111
while(p!=null && p.info!=x) { q=p; p=p.sig; } if(p!=null) return true; else return false; } void recorre_ant() { 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(); } }
112
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) { 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;
113
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) 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);
114
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 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
115
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; } 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);
116
} }
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() { if(cab==null) return true; else return false; } boolean esta(int x) { p=q=cab; while(p!=null && p.info<x) { q=p; p=p.sig; } if(p!=null && p.info==x) return true; else return false; } void primero(int x) { r=new Nodo(x); cab=ult=r; r.ant=null; r.sig=null; } void insertar(int x) { r=new Nodo(x); q.sig=r; p.ant=r; r.ant=q;
117
r.sig=p; } void menor(int x) { r=new Nodo(x); r.sig=cab; r.ant=null; cab.ant=r; cab=r; } void mayor(int x) { r=new Nodo(x); ult.sig=r; r.ant=ult; r.sig=null; ult=r; } void adicion(int x) { if(vacia()) primero(x); else if(x>ult.info) mayor(x); else if(x<cab.info) menor(x); else if(!esta(x)) insertar(x); } void borrar(int x) { if(esta(x)) { if(p==cab) { if(cab==ult) cab=ult=null; else { cab=cab.sig; cab.ant=null; } } else if(p==ult) { ult=ult.ant; ult.sig=null; } else {
118
r=p.sig; q.sig=r; r.ant=q; } } } String consulta_asc() { 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(); } String consulta_desc() { String S="C O N S U L T A \n" ; p=ult; while(p!=null) { S+=p.info+"\n"; 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:"));
119
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 { 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) {
120
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: 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 {
121
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 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() {
122
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() { 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()
123
{ 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; 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());
124
} } } 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 { C.nit=Integer.parseInt(JOptionPane.showInputDialog(null,"Escriba el nmero 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:
125
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<n;i++) A[i]=new Info(); } boolean vacia() { if(cab==-1) return true; else return false; } boolean llena() { if(cab==n-1) return true; 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()
126
{ 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<p.info) { p=p.izq; } else { p=p.der; } } if(p==null) return false; else 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; }
127
else { if(x<q.info) { q.izq=r; } else { q.der=r; } } return true; } boolean masderecha(NodoArbol s) { Pila=new Stack(); while(s!=null) { Pila.push((Object) s); s=s.der; } 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.der=s.izq; s.izq=p.izq; s.der=p.der; return true; } boolean masizquierda(NodoArbol s) { 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;
128
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; } else //p.der==null { if(q.izq==p) q.izq=p.izq; else q.der=p.izq; } } }
129
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[]) { if(p!=null) { A[0]++; conteoNodo(p.izq,A); conteoNodo(p.der,A); }
130
} 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 { 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)
131
{ 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); } }
132
UNIDAD 3. CLASES Y HERENCIA EN LA PROGRAMACION ORIENTADA A OBJETOS Leccin 31 CAPITULO 7. Clases En La Poo Una clase es el ncleo en java para la construccin lgica en la programacin de este lenguaje. La clase construye la base de programacin orientada a objetos en java. La clase define un nuevo tipo de dato. Las clases son el centro de la Programacin Orientada a Objetos (OOP Object Oriented Programming). Algunos de los conceptos ms importantes de la POO son los siguientes: Encapsulacin. Las clases pueden ser declaradas como pblicas (public) y como package (accesibles slo para otras clases del paquete). Las variables miembro y los mtodos 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 mtodos. Una clase derivada puede aadir nuevas variables y mtodos y/o redefinir las variables y mtodos heredados. Polimorfismo. Los objetos de distintas clases pertenecientes a una misma jerarqua o que implementan una misma interface pueden tratarse de una forma general e individualizada, al mismo tiempo. 7.1 Conceptos Bsicos 7.1.1 Concepto de Clase Una clase es una agrupacin de datos (variables o campos) y de funciones (mtodos) que operan sobre esos datos. La definicin de una clase se realiza en la siguiente forma: [public] class Class name { // definicin de variables y mtodos ... } Donde la palabra public es opcional: si no se pone, la clase tiene la visibilidad por defecto, esto es, slo es visible para las dems clases del paquete. Todos los mtodos y variables deben ser definidos dentro del bloque {...} de la clase.
133
Un objeto (en ingls, 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; 7.1.2 Caractersticas 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 mtodos. Java tiene una jerarqua de clases estndar de la que pueden derivar las clases que crean los usuarios. Una clase slo puede heredar de una nica clase (en Java no hay herencia mltiple). 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 jerarqua de clases de Java. En un archivo se pueden definir varias clases, pero en un archivo no puede haber ms que una clase public. Este archivo se debe llamar como la clase public que contiene con extensin *.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 mtodos 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 lnea al comienzo del archivo (paquete Nombrepaquete;). Esta agrupacin en paquetes est relacionada con la jerarqua 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 tambin variables finales (constantes). Una clase
134
puede implementar ms de una interface, representando una alternativa a la herencia mltiple. 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, slo se pueden utilizar los mtodos 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 mtodos de las interfaces de las que deriva (a diferencia de las clases, las interfaces de Java s tienen herencia mltiple). 7.2. Ejemplo De Definicin De Una Clase A continuacin se reproduce como ejemplo la clase Crculo. // 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); }
135
public double perimetro() { return 2.0 * PI * r; } public double area() { return PI * r * r; } // mtodo de objeto para comparar crculos public Circulo elMayor(Circulo c) { if (this.r>=c.r) return this; else return c; } // mtodo de clase para comparar crculos public static Circulo elMayor(Circulo c, Circulo d) { if (c.r>=d.r) return c; else return d; } } // fin de la clase Circulo. En este ejemplo se ve cmo se definen las variables miembro y los mtodos (cuyos nombres se han resaltado en negrita) dentro de la clase. Dichas variables y mtodos pueden ser de objeto o de clase (static). Se puede ver tambin cmo el nombre del archivo coincide con el de la clase public con la extensin *.java. 7.3. Variables miembro A diferencia de la programacin algortmica clsica, que estaba centrada en las funciones, la programacin orientada a objetos est centrada en los datos. Una clase est constituida por unos datos y unos mtodos que operan sobre esos datos.
136
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 (tambin llamadas campos) pueden ser de tipos primitivos (boolean, int, long, double, ?) o referencias a objetos de otra clase (composicin). 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 automtico, incluso antes de llamar al constructor (false para boolean, el carcter nulo para char y cero para los tipos numricos). De todas formas, lo ms adecuado es inicializarlas tambin en el constructor. Las variables miembro pueden tambin inicializarse explcitamente en la declaracin, como las variables locales, por medio de constantes o llamadas a mtodos (esta inicializacin no est permitida en C++). Por ejemplo, long nDatos = 100; Las variables miembro se inicializan en el mismo orden en que aparecen en el cdigo 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 mtodos de objeto se aplican a un objeto concreto poniendo el nombre del objeto y luego el nombre del mtodo, separados por un punto. A este objeto se le llama argumento implcito. Por ejemplo, para calcular el rea de un objeto de la clase Circulo llamado c1 se escribir: c1.area();. Las variables miembro del argumento implcito se acceden directamente o precedidas por la palabra this y el operador punto. Las variables miembro pueden ir precedidas en su declaracin 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 mtodos van a tener permiso para utilizar la clase y sus mtodos 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 ejecucin de un programa) de un objeto y por tanto no debe ser serializada
137
(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 sern 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 slo 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 ms parecido que Java tiene a las variables globales de C/C++. Las variables de clase se crean anteponiendo la palabra static a su declaracin. Para llamarlas se suele utilizar el nombre de la clase (no es imprescindible, pues se puede utilizar tambin el nombre de cualquier objeto), porque de esta forma su sentido queda ms claro. Por ejemplo, Circulo.numCirculos es una variable de clase que cuenta el nmero de crculos creados. Si no se les da valor en la declaracin, las variables miembro static se inicializan con los valores por defecto para los tipos primitivos (false para boolean, el carcter nulo para char y cero para los tipos numricos), 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 mtodo 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 Una variable de un tipo primitivo declarada como final no puede cambiar su valor a lo largo de la ejecucin del programa. Puede ser considerada como una constante, y equivale a la palabra const de C/C++.
138
Java permite separar la definicin de la inicializacin de una variable final. La inicializacin puede hacerse ms tarde, en tiempo de ejecucin, llamando a mtodos o en funcin 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 cmo haya sido inicializada. Adems de las variables miembro, tambin las variables locales y los propios argumentos de un mtodo 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 travs de otra referencia. En Java no es posible hacer que un objeto sea constante. 7.4 Abstraccin El elemento esencial de la programacin orientada a objetos en java es la abstraccin. Nosotros normalmente miramos la complejidad a travs de la abstraccin. 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 abstraccin es utilizando clasificaciones jerrquicas; esto nos permite dividir en niveles la semntica de los sistemas complejos, obteniendo sistemas ms 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 vegetacin, los animales, el medio ambiente ect.. Como podemos ver la importancia de la abstraccin es que se puede controlar la complejidad de un sistema utilizando abstracciones jerrquicas. En la programacin se puede utilizar en los programas de algortmicos tradicionales se pueden transformar mediante la abstraccin 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 programacin orientada a objetos. Los conceptos orientada a objetos forma el corazn de java, estos conceptos se aplican en la programacin cuando por ejemplo se nos presenta un problema de la vida real se realiza una clasificacin jerrquica para poderlo resolver satisfactoriamente.
139
Ejemplo:
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 compartimentalizacin de los elementos de una abstraccin que constituyen su estructura y comportamiento. La Encapsulacin sirve para separar la interface de una abstraccin y su implementacin.
Es
un concepto complementario al de abstraccin. La Encapsulacin esconde la implementacin del objeto que no contribuye a sus caractersticas esenciales. La Encapsulacin da lugar a que las clases se dividan en dos partes: a. Interfase: captura la visin externa de una clase, abarcando la abstraccin del comportamiento comn a los ejemplos de esa clase. b. Implementacin: comprende la representacin de la abstraccin, as como los mecanismos que conducen al comportamiento deseado. Se conoce tambin como ocultamiento o privacidad de la informacin. 7.6 Arreglos y cadenas Uno de los problemas ms comunes en los diversos sistemas de informacin es el tratamiento o procesamiento de un gran volumen de datos o de informacin. Las variables usadas hasta ahora reciben propiamente el nombre de variable escalares, porque solo permiten almacenar o procesar un dato a la vez.
140
Por ejemplo si quiere almacenar nombre y edad de 15 personas con el mtodo tradicional se ocuparan de 30 variables y slo es nombre y edad de 15 personas, agreguen ms datos y ms personas y ya es tiempo de empezar otro tipo de variables. Es decir, en problemas que exigen manejar mucha informacin o datos a la vez, variables escalares no son suficientes ya que su principal problema es que slo 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, operacin despliegue) usando el nombre del arreglo respectivo y un subndice indicando la posicin relativa del elemento con respecto a los dems elementos del arreglo, slo recordar que en vcpp la primera posicin elemento o rengln 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 travs de flujos (streams) donde un flujo es una abstraccin que produce o consume informacin y est relacionado con dispositivos fsicos a travs del sistema de java, los flujos se comportan de la misma forma aunque estn relacionados con diferentes dispositivos fsicos. Por esta razn se pueden aplicar las mismas clases y mtodos 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 conexin de red. Del mismo modo el destino de salida puede ser una consola, un archivo de disco. Los flujos son una forma
141
de limpia de tratar con la E/S sin necesitar que todo el cdigo comprenda la diferencia entre un teclado y una red. La E/S por consola de java es bastante limitada y no es fcil de usar, incluso en programas sencillos. La E/S basada en texto no es importante en la programacin en java. Java implementa los flujos dentro de una jerarqua de clases definida en el paquete java.io. En la parte superior de la jerarqua hay dos clases abstracta. 1. Estas clases definen algunos mtodos que las otras clases 2. Implementan. Dos de los mtodos ms importantes son: 3. InputStream read( ) y write ( ), respectivamente lee y escribe byte de 4. OutputStream datos. Ambos mtodos estn declarados como abstractos 5. Dentro de InputStream y OutputStram Leccin 32 7.8 Gestin 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 ms all, mediante una tcnica de programacin denominada gestin de excepciones. Mediante las excepciones se podr evitar repetir continuamente cdigo, en busca de un posible error, y avisar a otros objetos de una condicin anormal de ejecucin durante un programa. Durante este captulo estudiaremos la gestin de excepciones y errores, sin pretender profundizar demasiado, pero s fijando la base conceptual de lo que este modo de programacin supone. Mediante la gestin 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:
142
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 ejecucin. RuntimeException: Excepciones que se dan durante la ejecucin del programa.
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 mtodos son:
Trowable(
String mensaje ); Constructor. La cadena es opcional Throwable fillInStackTrace(); Llena la pila de traza de ejecucin. String getLocalizedMessage(); Crea una descripcin 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 parmetro s, o en la salida estndar (por defecto). String toString; Devuelve una breve descripcin del objeto. 7.8.2 Funcionamiento Para que el sistema de gestin de excepciones funcione, se ha de trabajar en dos partes de los programas: Definir qu partes de los programas crean una excepcin y bajo qu condiciones. Para ello se utilizan las palabras reservadas throw y throws. Comprobar en ciertas partes de los programas si una excepcin se ha producido, y actuar en consecuencia. Para ello se utilizan las palabras reservadas try, catch y finally.
143
7.8.2.1 Manejo de excepciones: try - catch - finally Cuando el programador va a ejecutar un trozo de cdigo que pueda provocar una excepcin (por ejemplo, una lectura en un fichero), debe incluir este fragmento de cdigo dentro de un bloque try: try { // Cdigo posiblemente problemtico } Pero lo importante es cmo controlar qu hacer con la posible excepcin que se cree. Para ello se utilizan las clausulas catch, en las que se especifica que accin realizar: try { // Cdigo posiblemente problemtico } catch( tipo_de_excepcion e) { // Cdigo para solucionar la excepcin e } catch( tipo_de_excepcion_mas_general e) { // Cdigo para solucionar la excepcin e } En el ejemplo se observa que se pueden anidar sentencias catch, pero conviene hacerlo indicando en ltimo lugar las excepciones ms generales (es decir, que se encuentren ms arriba en el rbol de herencia de excepciones), porque el intrprete Java ejecutar aquel bloque de cdigo catch cuyo parmetro sea del tipo de una excepcin lanzada. Si por ejemplo se intentase capturar primero una excepcin Throwable, nunca llegaramos a gestionar una excepcin Runtime, puesto que cualquier clase hija de Runtime es tambin hija de Throwable, por herencia. Si no se ha lanzado ninguna excepcin el cdigo contina sin ejecutar ninguna sentencia catch. Pero, y si quiero realizar una accin comn a todas las opciones?. Para insertar fragmentos de cdigo que se ejecuten tras la gestin de las excepciones. Este cdigo
144
se ejecutar tanto si se ha tratado una excepcin (catch) como sino. Este tipo de cdigo 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 mtodo deber comprobar si alguna condicin de excepcin se cumple, y si es as lanzarla. Para ello se utilizan las palabras reservadas throw y throws. Por una parte la excepcin 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 debern ser instanciadas antes de ser lanzadas. Aquellos mtodos que pueden lanzar excepciones, deben cules son esas excepciones en su declaracin. 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 mtodo ms de una excepcin se deben indicar en su declaracin separadas por comas. 7.8.2.3 Ejemplo de gestin de excepciones Ahora que ya sabemos cmo funciona este sistema, conviene ver al menos un pequeo ejemplo, que ilustre al lector en el uso de las excepciones: // Creacin de una excepcin personalizada class MiExcepcion extends Exception { MiExcepcion() {
145
super(); // constructor por defecto de Exception } MiExcepcion( String cadena ) { super( cadena ); // constructor param. de Exception } } // Esta clase lanzar la excepcin 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 ){ // Estndar System.out.println( "Excepcion: " + e.getMessage() ); }finally { if ( entrada != null ) try
146
{ 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 ){ // Estndar 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 nmeros. Si alguno de los nmeros ledos es negativo, lanza una excepcin MiExcepcion,
147
Adems gestiona la excepcin IOException, que es una excepcin de las que Java incluye y que se lanza si hay algn problema en una operacin de entrada/salida. Ambas excepciones son gestionadas, imprimiendo su contenido (cadena de error) por pantalla. La salida de este programa, suponiendo un nmero negativo sera: Excepcin: Numero negativo Archivo cerrado En el caso de que no hubiera ningn nmero negativo sera: Todo fue bien Archivo cerrado En el caso de que se produjese un error de E/S, al leer el primer nmero, sera: Excepcin: java.io.IOException Archivo cerrado 7.8.3 Los mtodos Los mtodos son subrutinas que definen la interfaz de una clase, sus capacidades y comportamiento. Un mtodo ha de tener por nombre cualquier identificador legal distinto de los ya utilizados por los nombres de la clase en que est definido. Los mtodos se declaran al mismo nivel que las variables de instancia dentro de una definicin de clase. En la declaracin de los mtodos se define el tipo de valor que devuelven y a una lista formal de parmetros de entrada, de sintaxis tipo identificador separadas por comas. La forma general de una declaracin de mtodo es: tipo_devuelto nombre_de_mtodo( lista-formal-de-parmetros ) { cuerpo_del_mtodo; } Por ejemplo el siguiente mtodo devuelve la suma de dos enteros: int metodoSuma( int paramX, int paramY ) { return ( paramX + paramY ); }
148
En el caso de que no se desee devolver ningn valor se deber indicar como tipo la palabra reservada void. As mismo, si no se desean parmetros, la declaracin del mtodo debera incluir un par de parntesis vacos (sin void):serf void metodoVacio( ) { }; Los mtodos son llamados indicando una instancia individual de la clase, que tendr su propio conjunto nico de variables de instancia, por lo que los mtodos se pueden referir directamente a ellas. El mtodo inicia() para establecer valores a las dos variables de instancia sera el siguiente: void inicia( int paramX, int paramY ) { x = paramX; y = paramY; } Leccin 33 7.8.4 La instanciacin de las clases: Los objetos 7.8.4.1 Referencias a Objeto e Instancias Los tipos simples de Java describan el tamao y los valores de las variables. Cada vez que se crea una clase se aade 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 tambin 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 declaracin 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
149
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 mtodo especial llamado constructor. Un constructor es un mtodo que inicia un objeto inmediatamente despus de su creacin. De esta forma nos evitamos el tener que iniciar las variables explcitamente para su iniciacin. El constructor tiene exactamente el mismo nombre de la clase que lo implementa; no puede haber ningn otro mtodo que comparta su nombre con el de su clase. Una vez definido, se llamar automticamente al constructor al crear un objeto de esa clase (al utilizar el operador new). El constructor no devuelve ningn tipo, ni siquiera void. Su misin 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 ); } Este constructor denominado constructor por defecto, por no tener parmetros, 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 parmetros en el constructor. Este otro constructor, sin embargo, recibe dos parmetros: MiPunto( int paraX, int paraY ) { inicia( paramX, paramY ); } La lista de parmetros especificada despus del nombre de una clase en una sentencia new se utiliza para pasar parmetros al constructor.
150
Se llama al mtodo constructor justo despus 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 cdigo, se debe de crear una clase que contenga un mtodo main(). El intrprete java se ejecutar el mtodo main de la clase que se le indique como parmetro. 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 creacin de una instancia de MiPunto, que es controlador por la referencia a objeto p2. Hay una distincin crtica 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 mltiples referencias al mismo objeto, como por ejemplo: MiPunto p3 =p2; Aunque tan slo 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 asignacin de p2 a p3 no reserva memoria ni modifica el objeto. De hecho, las asignaciones posteriores de p2 simplemente desengancharn p2 del objeto, sin afectarlo: p2 = null; // p3 todava apunta al objeto creado con new
151
Aunque se haya asignado null a p2, p3 todava apunta al objeto creado por el operador new. Cuando ya no haya ninguna variable que haga referencia a un objeto, Java reclama automticamente 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 instanciacin. 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 estn 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 Leccin 34 7.8.5. Acceso al objeto 7.8.5.1 El operador punto (.) El operador punto (.) se utiliza para acceder a las variables de instancia y los mtodos contenidos en un objeto, mediante su referencia a objeto:
152
referencia_a_objeto.nombre_de_variable_de_instancia referencia_a_objeto.nombre_de_mtodo( lista-de-parmetros ); 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 (mtodo println()) se accede al valor de las variables mediante p6.x y p6.y, y entre una impresin y otra se llama al mtodo inicia(), cambiando los valores de las variables de instancia. Este es uno de los aspectos ms importantes de la diferencia entre la programacin orientada a objetos y la programacin estructurada. Cuando se llama al mtodo p6.inicia(), lo primero que se hace en el mtodo 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 mtodo para referirse al objeto actual. El valor this se refiere al objeto sobre el que ha sido llamado el mtodo 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 cdigo, seleccionados a travs de otras instancias, cada uno tiene su propio valor nico de this.
153
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() { this( -1, -1 ); // Llama al constructor parametrizado } En Java se permite declarar variables locales, incluyendo parmetros formales de mtodos, que se solapen con los nombres de las variables de instancia. No se utilizan x e y como nombres de parmetro para el mtodo inicia, porque ocultaran las variables de instancia x e y reales del mbito del mtodo. Si lo hubisemos hecho, entonces x se hubiera referido al parmetro 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!!! } Leccin 35 7.8.6. La destruccin del objeto 7.8.6.1 La destruccin de los objetos Cuando un objeto no va a ser utilizado, el espacio de memoria de dinmica que utiliza ha de ser liberado, as como los recursos que posea, permitiendo al programa disponer de todos los recursos posibles. A esta accin se la da el nombre de destruccin del objeto. En Java la destruccin se puede realizar de forma automtica o de forma personalizada, en funcin de las caractersticas del objeto. 7.8.6.2 La destruccin por defecto: Recogida de basura El intrprete de Java posee un sistema de recogida de basura, que por lo general permite que no nos preocupemos de liberar la memoria asignada explcitamente.
154
El recolector de basura ser el encargado de liberar una zona de memoria dinmica que haba sido reservada mediante el operador new, cuando el objeto ya no va a ser utilizado ms durante el programa (por ejemplo, sale del mbito de utilizacin, o no es referenciado nuevamente). El sistema de recogida de basura se ejecuta peridicamente, buscando objetos que ya no estn referenciados. 7.8.6.3 La destruccin 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 sera acertado el utilizar la finalizacin explcita, para asegurar que dicho recurso se libera. Esto se hace mediante la destruccin personalizada, un sistema similar a los destructores de C++. Para especificar una destruccin personalizada se aade un mtodo a la clase con el nombre finalize: class ClaseFinalizada { ClaseFinalizada() { // Constructor // Reserva del recurso no Java o recurso compartido } protected void finalize() { // Liberacin del recurso no Java o recurso compartido } } El intrprete de Java llama al mtodo finalize(), si existe cuando vaya a reclamar el espacio de ese objeto, mediante la recogida de basura. Debe observarse que el mtodo 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 acompaa de una serie de bibliotecas con clases estndar que valen como referencia para todos los programadores en Java.
155
Estas clases se pueden incluir en los programas Java, sin temor a fallos de portabilidad. Adems, estn bien documentadas (mediante pginas 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 continuacin 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 travs de flujos de datos, y ficheros del sistema. java.util: Contiene colecciones de datos y clases, el modelo de eventos, facilidades horarias, generacin aleatoria de nmeros, y otras clases de utilidad. java.math: Clases para realizar aritmtica con la precisin que se desee. java.text: Clases e interfaces para manejo de texto, fechas, nmeros y mensajes de una manera independiente a los lenguajes naturales. java.security: Clases e interfaces para seguridad en Java: Encriptacin RSA.. 7.8.7.2 Paquetes para el desarrollo grfico
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 imgenes y grficos. javax.swing: Conjunto de componentes grficos 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 conexin de programas Java con Bases
de datos. java.rmi: Paquete RMI, para localizar objetos remotos, comunicarse con ellos e incluso enviar objetos como parmetros de un objeto a otro. org.omg.CORBA: Facilita la posibilidad de utilizar OMG CORBA, para la conexin entre objetos distribuidos, aunque est codificados en distintos lenguajes. 7.9 ACTIVIDADES COMPLEMENTARIAS
156
Parte Uno: 1. Investiga cuales son las herramientas utilizas en java y diga cual es su funcin. 2. Construye un arreglo donde incluya un mtodo. 3. Realice un mapa conceptual con el siguiente tema E/s. 4. Realice una abstraccin jerrquica 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 subndice b. 6. Determine e imprima los valores ms pequeos y ms 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 Introduccin DOO con UML y los Patrones de Diseo JDBC tm, SERVLETS, JSP tm Editorial Pearson Prentice Hall Quinta Edicin, 2. David Arnow Gerald Weiss Introduccin a la Programacin con Java tm Actualizacin a la Versin 2 de Java Editorial Addison Wesley 3. Fcd Javier Ceballos Java 2 Curso de Programacin 2 Edicin Editorial Alfaomega Ra-Ma 4. Agustin Froute Java 2 Manual Usuario tutorial 3 Edicin Editorial Alfaomega Ra-Ma 5. Herbert shildt Fundamentos de Programacin Java 2 Editorial Mc Graw Hill . para conocer el lenguaje de programacin JAVA ya que estn resueltos solo los puede digitar compilar y ejecutar en la casa o laboratorio de su correspondiente CEAD o CERES.
157
Leccin 36 CAPITULO 8. Herencia 8.1 La Herencia La verdadera potencia de la programacin orientada a objetos radica en su capacidad para reflejar la abstraccin que el cerebro humano realiza automticamente durante el proceso de aprendizaje y el proceso de anlisis de informacin. 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 niez. As, los defensores de la programacin orientada a objetos afirman que esta tcnica 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 fcilmente identificable, puede ser muy til para el desarrollo de programas informticos. 8.2 Jerarqua La herencia es el mecanismo fundamental de relacin entre clases en la orientacin a objetos. Relaciona las clases de manera jerrquica; una clase padre o superclase sobre otras clases hijas o subclases.
Los descendientes de una clase heredan todas las variables y mtodos que sus ascendientes hayan especificado como heredables, adems de crear los suyos propios. La caracterstica de herencia, nos permite definir nuevas clases derivadas de otra ya existente, que la especializan de alguna manera. As logramos definir una jerarqua de clases, que se puede mostrar mediante un rbol de herencia.
158
En todo lenguaje orientado a objetos existe una jerarqua, mediante la que las clases se relacionan en trminos de herencia. En Java, el punto ms alto de la jerarqua es la clase Object de la cual derivan todas las dems clases. 8.3 Herencia mltiple En la orientacin a objetos, se consideran dos tipos de herencia, simple y mltiple. En el caso de la primera, una clase slo puede derivar de una nica superclase. Para el segundo tipo, una clase puede descender de varias superclases. En Java slo se dispone de herencia simple, para una mayor sencillez del lenguaje, si bien se compensa de cierta manera la inexistencia de herencia mltiple con un concepto denominado interface, que estudiaremos ms adelante. 8.4 Declaracin Para indicar que una clase deriva de otra, heredando sus propiedades (mtodos y atributos), se usa el trmino 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 continuacin, en nuestro caso MiPunto3D es hija de MiPunto.
159
Leccin 37 8.5 Limitaciones en la herencia Todos los campos y mtodos de una clase son siempre accesibles para el cdigo de la misma clase. Para controlar el acceso desde otras clases, y para controlar la herencia por las subclase, los miembros (atributos y mtodos) 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 slo en la propia clase. protected: Los miembros declarados protected son accesibles slo para sus subclases Por ejemplo: class Padre { // Hereda de Object // Atributos private int numeroFavorito, nacidoHace, dineroDisponible; // Mtodos public int getApuesta() { return numeroFavorito; } protected int getEdad() { return nacidoHace; } private int getSaldo() { return dineroDisponible; } } class Hija extends Padre { // Definicin } class Visita
160
{ // Definicin } En este ejemplo, un objeto de la clase Hija, hereda los tres atributos (numeroFavorito, nacidoHace y dineroDisponible) y los tres mtodos (getApuesta(), getEdad() y getSaldo() ) de la clase Padre, y podr invocarlos. Cuando se llame al mtodo 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 mtodo 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 mtodo getApuesta(), para averiguar el nmero favorito de un Padre, pero de ninguna manera podr conocer ni su saldo, ni su edad (sera una indiscrecin, no?). 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 clusula extends, Java considera que dicha clase desciende directamente de Object. La clase Object aporta una serie de funciones bsicas 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 parmetro es igual, en valor, que el objeto desde el que se llama al mtodo. Si se desean comparar dos referencias a objeto se pueden utilizar los operadores de comparacin == y !=. public int hashCode(): Devuelve un cdigo 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 Organizacin del cdigo Utilizacin de Sentencias en Java
161
Sentencias de seleccin Sentencias de repeticin Principios de los applets Leccin 38 8.7 Extensin De Clases 8.7.1 Composicin De Objetos Extendido 8.7.1.1. Subclase Es una versin especializada de una superclase, que hereda todas las variables de instancia y los mtodos definidos por a superclase y que aade 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); } } // 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
162
{ 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 pblicos 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 Relacin de tipo de herencia Existen 2 tipos de herencia simple, cuando depende de un solo padre y mltiple cuando hereda de varios padres. Leccin 39 8.7.2.1 Mtodos Forma general de un mtodo:
163
Tipo nombre_de_mtodo(lista_de_parmetros) { //cuerpo_del_mtodo } Aqu, tipo especifica el tipo de dato devuelto por el mtodo. Puede ser cualquier tipo vlido, incluidos los tipos de clase. Si el mtodo no devuelve ningn valor, el tipo devuelto debe ser void. El nombre del mtodo puede ser cualquier identificador vlido distinto de los ya utilizados por otros elementos del mbito actual. La lista de parmetros son variables que reciben el valor de los argumentos que se pasan al mtodo. Si el mtodo no tiene parmetros, entonces la lista de parmetros estar vaca.. Los mtodos 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 cdigo 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 cdigo Java, se necesitan ejecutar los pasos para poder integrar el cdigo C oC++: Utilizar javah para crear un fichero de cabecera (.h) Utilizar javah para crear un fichero de stubs, es decir, contiene la declaracin de las funciones.
164
Escribir el cdigo del mtodo nativo en C o C++, es decir, rellenar el cdigo de la funcin, completando el trabajo de javah al crear el fichero de stubus Compilar el fichero de stubs y el fichero .c en una librera de carga dinmica(DLL en Windows 95 o lobXX.so en UniX) Ejecutar la aplicacin con el appletviwer Leccin 40 8.7.2.2 Sobrecarga De Mtodo Java utiliza la sobrecarga de mtodos para implementar polimorfismos, al invocar un mtodo sobrecargado, java utiliza el nmero de argumentos para determinar la versin del mtodo sobrecargado el cual debe llamar. Ejemplo: // Ejemplo de sobrecarga de mtodos class overloadDemo void test() { System.out.println ( Sin parmetros); } //Sobrecarga del mtodo test con un parmetro enteros. System.out.println (a: +a); } // Sobrecarga el mtodo test con un parmetro con dos parmetros //enteros. Void test (int a, int b) { System.out.println (a y b: +a+ + b); } // sobrecarga del mtodo test con un parmetro double double test(double a) { System.out.println (a double: +a); Return a*a; } } class overload { public static void main (string args[ ]) {
165
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 ); system. Out. Println (Resultado de ob.test(123 .2): + result); } } EL PROGRAMA GENERA LA SIGUIENTE SALIDA Sin parmetros a : 10 a y b: 10 20 a double: 123 .2 Resultado de ob.test(123.2): 15178.2 Clase object y cdigos genricos: La clase object es definida por java, esta clase es la superclase de las dems 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 mtodos: 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 ejecucin la clase de un tiempo Int hashCode: Devuelve el cdigo hash asociado al objeto llamante.
166
CAPITULO 9. Extensin de Clases Leccin 41 9.1. Applest Y Web 9.1.1 Applets Programas elementales incluidos en pginas HTML a travs de la etiqueta app y que se despliega en el visualizador tras cargarse la pgina. Cuando un usuario solicita un applet construido con java ocurre: El usuario solicita un documento HTML al servidor de informacin. El servidor enva el documento al visualizador del cliente, este documento tienen una etiqueta app que identifica la referencia a un applet El bytecode (obtenido por compilacin de cdigo 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 cdigo del applet contiene toda la informacin necesaria, el usuario tiene una interaccin total con el applet sin relacionarse de nuevo con el servidor. 9.1.2 HTML para Java HTML es una forma de definir la organizacin lgica de la informacin que a travs de enlaces, llamados enlaces de hipertexto e hiperenlaces, permite acceder a otra informacin relacionada, el enlace hipertexto es un enlace a otro documento con hipertexto que puede estar en la mquina 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 travs de los enlaces, pudiendo acceder a otros documentos relacionados. La nica conexin 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 especficas. Por ejemplo el protocolo para conectar un cliente con un servidor a travs de Internet.
167
Este protocolo se denomina TPC/IP. Internet es un conexin de varias redes a travs de las cuales podemos comunicarnos para obtener informacin, escuchar msica 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 para establecer una comunicacin 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. Leccin 42 9.1.4 Que Es Un Applet Los applets (miniaplicacin) son programas escritos en Java que sirven para "dar vida" a las pginas Web (interaccin en tiempo real, inclusin de animaciones, sonidos...), de ah su potencia. Los applets son programas que se incluyen en las pginas Web y son ejecutados en la mquina cliente, con lo que no existen ralentizaciones por la saturacin del mdem o del ancho de banda. Permiten cargar a travs de la red una aplicacin portable que se ejecuta en el navegador. Para que esto ocurra tan slo hace falta que el navegador sea capaz de interpretar Java. A las pginas que contienen applets se las denomina pginas 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 intrprete Java. Son cargados a travs de la red por medio de pginas HTML y no residen en el disco duro de la mquina que los ejecuta. Poseen un ciclo de vida diferente; mientras que una aplicacin se lanza una vez, un applet se arranca (inicia) cada vez que el usuario recarga la pgina en la que se encuentra la applet.
168
Tienen menos derechos que una aplicacin clsica, 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. Slo pueden comunicarse con el servidor Web en que se encuentra la pgina Web que las contiene. 9.1.4.1 Consideraciones sobre la seguridad en las applets Los applets tienen una serie de restricciones de programacin que los hacen "seguros". Estas restricciones de seguridad son especialmente importantes, ya que evitarn que se cargue por error un applet que destruya datos de la mquina, que obtenga informacin restringida, o que produzca otros daos inesperados. Los applets no dejan de ser "ejecutables" que funcionan dentro de una aplicacin, como puede ser un visualizador de pginas Web (browser). Este ejecutable puede obtenerse de una red, lo que significa que hay cdigo posiblemente no fiable que se ejecuta dentro de la aplicacin. Java tiene muchas salvaguardas de seguridad que minimizan el riesgo de la ejecucin de applets, pero estas salvaguardas tambin limitan a los programadores de applets en su capacidad de programacin. El modelo de seguridad para las applets en Java trata una applet como cdigo no fiable ejecutndose dentro de un entorno fiable. Por ejemplo, cuando un usuario instala una copia de un navegador Web en una mquina se est fiando de que su cdigo 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 comprobacin 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 cdigos de byte de las clases de los applets, no rompen las reglas bsicas del lenguaje ni las restricciones de acceso en tiempo de ejecucin. Slo cuando estas restricciones son satisfechas se le permite al applet ejecutar su cdigo. Cuando se ejecuta, se le marca para sealar que se encuentra dentro del intrprete. Esta marca permite a las clases de tiempo de ejecucin determinar cundo a una fraccin del cdigo se le permite invocar a cierto mtodo. Por ejemplo, una applet est restringida en los hosts en los que se puede abrir una conexin de red o en un conjunto de URLs a las que puede acceder. En su conjunto estas restricciones constituyen una poltica de seguridad. En el futuro, Java tendr polticas ms ricas, incluyendo algunas que usen encriptacin y autentificacin para permitir a las applets una mayor capacidad.
169
La actual poltica 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 estndar que se pueda realizar en los navegadores que soporten applets de Java. Las conexiones de red sern restringidas a conectar solo con el host del que proviene el applet. Un applet no es capaz de usar ningn mtodo que pueda resultar en una ejecucin arbitraria, cdigo no revisado o ambos. Esto incluye mtodos que ejecuten programas arbitrarios (mtodos nativos) as como la carga de bibliotecas dinmicas. Se anticipa en cualquier caso que en el futuro los modelos de seguridad permitirn a los applets autentificadas superar estas restricciones. 9.1.5 La Clase Applet 9.1.5.1 Situacin de la clase Applet en la API de Java 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 adems hereda de Component y Container, que son dos clases del paquete grfico AWT. Esto ya perfila las posibilidades grficas de este tipo de aplicaciones Java. 9.1.5.2 Mtodos del ciclo de vida Como ya se ha indicado una applet no tiene un ciclo de vida tan "sencillo" como el de una aplicacin, que simplemente se ejecuta hasta que finaliza su mtodo main(). La siguiente figura modela el ciclo de vida de una applet:
170
Cada crculo representa una fase en el ciclo de vida de la applet. Las flechas representan transiciones y el texto representa la accin que causa la transicin. Cada fase est marcada con una invocacin a un mtodo 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, despus de haber sido cargada, ha sido parada (cambio de pgina Web, minimizacin del navegador,...), y de nuevo activada (vuelta a la pgina, restauracin 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 ejecucin. As una applet que utilice threads, debera detenerlos en el cdigo de este mtodo. 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. void paint(); Es invocado cada vez que hay que el navegador redibuja el applet. Al crear una applet no es necesario implementar todos estos mtodos. De hecho habr applets que no los necesiten. Cuando un navegador carga una pgina Web que contiene una applet, suele mostrar en su parte inferior un mensaje como: initializing... starting...
171
Esto indica que la applet, se est cargando: 1. Una instancia de la clase applet es creada. 2. El applet es iniciado, mediante su mtodo init(). 3. El applet empieza a ejecutarse, mediante su mtodo start(). Cuando el usuario se encuentra con una pgina Web, que contiene una applet y salta a otra pgina, entonces el applet se detiene invocando a su mtodo stop(). Si el usuario retorna a la pgina donde reside el applet, sta vuelve a ejecutarse nuevamente invocando a su mtodo start(). Cuando el usuario sale del navegador el applet tiene un tiempo para finalizar su ejecucin y hacer una limpieza final, mediante el mtodo destroy(). 9.1.6 La Clase Url Un URL (Uniform Resource Locator) es una direccin de Internet. Cada recurso (fichero, pgina 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 mtodos 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 corresponderan al URL "http://www.host.com/dir/fich.htm". 9.1.7 Inclusin de la applet en una pgina Web Para incluir una applet en una pgina Web, una vez compilada la applet, debe incluirse entre el cdigo HTML de la pgina Web una etiqueta <APPLET>, que como mnimo ha de presentar los siguientes tres parmetros: 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).
172
Adems, de la etiqueta inicial, una applet puede tener parmetros que se especificarn mediante etiquetas <PARAM>, que como mnimo han de presentar dos parmetros: name: Indica el nombre del parmetro de la applet al que esta etiqueta hace referencia. value: Establece este valor al parmetro indicado en name de la misma etiqueta. As un ejemplo de esto sera: <applet code="AppletDiagonal.class" width=200 height=200> <param name=Parametro1 value=Valor1> <param name=Parametro2 value=Valor2> </applet> En este ejemplo la applet puede entender los parmetros Parametro1 y Parametro2, mediante los mtodos que se describen en el siguiente apartado, y obtendra Valor1 y Valor2 respectivamente. Se observa que adems de la etiqueta <applet> en el cdigo HTML tambin aparece una etiqueta </applet>. Esto sucede porque HTML es un lenguaje pareado, en el que casi todas las etiquetas de inicio de elemento (<etiq>) tienen una etiqueta de fin (</etiq>). 9.1.7.1 Obtencin de los parmetros de la applet Cuando se incluye una applet en una pgina Web ha de hacerse mediante la etiqueta HTML <applet>. Las etiquetas HTML permiten utilizar parmetros, y la etiqueta <applet> hace lo propio, permitiendo a la applet recibir parmetros de ejecucin, tal y como una aplicacin los recibe en el parmetro (un vector de cadenas) de su mtodo main(Strings). Los siguientes mtodos se utilizan para extraer informacin de los parmetros que recibi el applet cuando fue llamado desde el cdigo 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 parmetro (etiquetas <param>) que aparezca en el documento HTML.
173
Si por ejemplo se llamase a una applet, con el cdigo HTML: <applet code="AppletParam.class" width=50 height=50> <param name=Color value="red"> </applet> Una llamada en esta applet al mtodo getParameter("Color") devolver "red". 9.1.7.2 Obtencin de informacin sobre una applet Algunos mtodos de los applet se utilizan para comunicar informacin 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 informacin relativa a la applet como el autor, Copyright o versin. String[ ][ ] getParameterInfo(); Devuelve un vector que describe algn parmetro especfico 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 mtodo para una applet que permita un solo parmetro, color, sera: public String[][] getParameterInfo() { String info[][] = { {"Color","String","foreground color"} }; return info; } 9.1.7.3 Manipulacin del entorno de una applet Algunas applets pueden afectar al entorno en que estn ejecutndose. Para ello se utilizan los mtodos: AppletContext getAppletContext(); Devuelve un AppletContext, que permite a la applet afectar a su entorno de ejecucin. void resize( int ancho, int largo); Solicita que se modifique el tamao de la applet. Tambin permite recibir un nico parmetro Dimension. Locale getLocale(); Devuelve el Locale de la applet si fue establecido.
174
void setStub( AppletStub s ); Establece el stub de esta applet. 9.1.8 Ejemplo De Construccin De Una Applet 9.1.8.1 Cdigo 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 mtodos de la clase Applet. Siempre conviene sobreescribir al menos el mtodo paint() que ser llamado por los navegadores que soporten applets para mostrarles por pantalla. Vamos a construir un applet denominada AppletDiagonal que simplemente dibuje una lnea diagonal. Un posible cdigo para este applet sera: 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 cdigo: El mtodo paint() recibe un objeto de la clase Graphics. La clase Graphics, incluida en el AWT, contiene mtodos para mostrar varios tipos de grficos. Mediante el mtodo 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 lnea 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
175
derecha se obtiene mediante dos mtodos de la clase Dimension (getWidth(), getHeight() ) . 9.1.8.2 Ejecucin Para ejecutar el applet, una vez compilado el archivo, se introduce el llamado al applet en una pgina Web (por ejemplo AppletDiagonal.htm), introduciendo entre su cdigo HTML lo siguiente: <applet code="AppletDiagonal.class" width=200 height=200> </applet> Cuando se cargue esta pgina Web en un navegador compatible con Java o mediante el visualizador de applets que viene con el JDK (appletviewer) se ver algo como:
Se podra dibujar un rectngulo con cambiar la lnea de cdigo de drawLine() por otra que llamase al mtodo 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 ms sobre anidado de clases y reflexiona sobre cual es la funcin importante en java. 3. Que es una subclase y cual es su funcin? 4. cual es la funcin principal de los mtodos en la programacin java? 5. Cul es la importancia de los cdigos genricos en java?
176
6. Cual es la funcin 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 ms importantes a nivel de comunicaciones. 9. Cual es la estructura de una applet? 10. Como se controlan las applets? 11. Dnde se inicia la ejecucin de una applet? Explique su respuesta con un ejemplo. 12. Disee 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 Introduccin DOO con UML y los Patrones de Diseo JDBC tm, SERVLETS, JSP tm Editorial Pearson Prentice Hall Quinta Edicin, 2. David Arnow Gerald Weiss Introduccin a la Programacin con Java tm Actualizacin a la Versin 2 de Java Editorial Addison Wesley 3. Fcd Javier Ceballos Java 2 Curso de Programacin 2 Edicin Editorial Alfaomega Ra-Ma 4. Agustin Froute Java 2 Manual Usuario tutorial 3 Edicin Editorial Alfaomega Ra-Ma 5. Herbert shildt Fundamentos de Programacin Java 2 Editorial Mc Graw Hill . para conocer el lenguaje de programacin JAVA ya que estn resueltos solo los puede digitar compilar y ejecutar en la casa o laboratorio de su correspondiente CEAD o CERES.
177
CAPITULO 10. BIBLIOGRAFIA 10.1. BIBLIOGRAFIA Autor: Deitel y Deitel Introduccin DOO con UML y los Patrones de Diseo JDBC tm, SERVLETS, JSP tm Editorial Pearson Prentice Hall Quinta Edicin. David Arnow Gerald Weiss Introduccin a la Programacin con Java tm Actualizacin a la Versin 2 de Java Editorial Addison Wesley Fcd Javier Ceballos Java 2 Curso de Programacin 2 Edicin Editorial Alfaomega Ra-Ma Agustin Froute Java 2 Manual Usuario tutorial 3 Edicin Editorial Alfaomega RaMa 5. Herbert shildt Fundamentos de Programacin Java 2 Editorial Mc Graw Hill . para conocer el lenguaje de programacin JAVA Arnow, D., Weiss, G., Introduccin a la programacin con JAVA, Addison wesley, 2000. Larman, C., UML y patrones, Prentice Hall, 1998. Meyer, B., Construccin de software orientado a objetos, Prentice Hall, segunda edicin, 1997. Wu, T., Introduccin a la programacin orientada a objetos con Java, Mc Graw Hill, 2000. Joyanes, L., Programacin orientada a objetos, Segunda edicin, Mc Graw Hill, 1998. Grez Voss, Introduccin 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 Santamara, C++ Una Herramienta para la Programacin Orientada a Objetos, Editorial Mc Graw Hill, 1.993 Fco Javier Ceballos, Programacin Orientada a Objetos con C++,Editorial Alfaomega, 1.998
178
Nathan Meyers, Programacin JAVA en Linux, Editorial Prentice Hall, 2.000.
10.2. SITIOS WEB 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
179

Modulo Programacion Orienta A Objetos 33

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Modulo Programacion Orienta A Objetos 33

Încărcat de

Drepturi de autor:

Formate disponibile

Universidad Nacional Abierta y a Distancia - UNAD Escuela de Ciencias Bsica Tecnologa e Ingeniera Programa de Ingenieria de Sistemas

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA UNAD

PROGRAMACION ORIENTA A OBJETOS

ING. CESAR ORLANDO JIMENEZ ANGARITA 2010

PROGRAMACIN ORIENTADA A OBJETOS

CESAR ORLANDO JIMENEZ ANGARITA

ESTRUCTURA DE DATOS ESTRUCTURA FUNCIONAL

como un tipo abstracto de datos.

Adicin: Producto Punto: Producto Cruz: Producto por escalar: Normal:

Para representar una instancia de una clase:

El que incluye parmetros por Referencia Los que devuelven un dato

Se caracteriza porque sus parmetros son matrices, arreglos u objetos

Tipo Origen Byte Short Char Int Long Float

JOptionPane.showMessageDialog( null, JOptionPane.WARNING_MESSAGE);

Parqueadero Doris \n"+P.impresion().toString());

10.2. SITIOS WEB 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/

S-ar putea să vă placă și