1
Download Programacion en Java
Document related concepts
no text concepts found
Transcript
Desarrollo de software Se tratan diferentes aspectos de Java, desde las aplicaciones hasta los applets a través de numerosos ejemplos. Como herramientas de desarrollo se utilizan Microsoft Visual J++ 6 y JBuilder. La versión tratada del lenguaje es la estándar de Sun Microsystems. Se pretende adiestrar sobre: • • • • • • • Programación Orientada a Objetos. Construcción de aplicaciones Java. Creación de applets Java. Tratamiento de eventos y construcción de interfaces de usuario. Utilización de Visual J++ 6. Programación multihilo. Acceso a ficheros y conexiones a través de Internet. El único requisito es conocer algún lenguaje de programación PROGRAMACIÓN EN JAVA ÁNGEL ESTEBAN ADVERTENCIA LEGAL Todos los derechos de esta obra están reservados a Grupo EIDOS Consultoría y Documentación Informática, S.L. El editor prohíbe cualquier tipo de fijación, reproducción, transformación, distribución, ya sea mediante venta y/o alquiler y/o préstamo y/o cualquier otra forma de cesión de uso, y/o comunicación pública de la misma, total o parcialmente, por cualquier sistema o en cualquier soporte, ya sea por fotocopia, medio mecánico o electrónico, incluido el tratamiento informático de la misma, en cualquier lugar del universo. El almacenamiento o archivo de esta obra en un ordenador diferente al inicial está expresamente prohibido, así como cualquier otra forma de descarga (downloading), transmisión o puesta a disposición (aún en sistema streaming). La vulneración de cualesquiera de estos derechos podrá ser considerada como una actividad penal tipificada en los artículos 270 y siguientes del Código Penal. La protección de esta obra se extiende al universo, de acuerdo con las leyes y convenios internacionales. Esta obra está destinada exclusivamente para el uso particular del usuario, quedando expresamente prohibido su uso profesional en empresas, centros docentes o cualquier otro, incluyendo a sus empleados de cualquier tipo, colaboradores y/o alumnos. Si Vd. desea autorización para el uso profesional, puede obtenerla enviando un e-mail [email protected] o al fax (34)-91-5017824. Si piensa o tiene alguna duda sobre la legalidad de la autorización de la obra, o que la misma ha llegado hasta Vd. vulnerando lo anterior, le agradeceremos que nos lo comunique al e-mail [email protected] o al fax (34)-91-5017824). Esta comunicación será absolutamente confidencial. Colabore contra el fraude. Si usted piensa que esta obra le ha sido de utilidad, pero no se han abonado los derechos correspondientes, no podremos hacer más obras como ésta. © Ángel Esteban, 2000 © Grupo EIDOS Consultaría y Documentación Informática, S.L., 2000 ISBN 84-88457-18-9 Programación en Java Ángel Esteban Responsable editorial Paco Marín ([email protected]) Autoedición Magdalena Marín ([email protected]) Ángel Esteban ([email protected]) Grupo EIDOS C/ Téllez 30 Oficina 2 28007-Madrid (España) Tel: 91 5013234 Fax: 91 (34) 5017824 www.grupoeidos.com/www.eidos.es www.LaLibreriaDigital.com Coordinación de la edición Antonio Quirós ([email protected]) Índice ÍNDICE................................................................................................................................................... 5 INTRODUCCIÓN A LA POO ........................................................................................................... 11 ¿QUÉ ES LA POO?.............................................................................................................................. 11 OBJETOS ............................................................................................................................................. 12 MENSAJES .......................................................................................................................................... 13 CLASES............................................................................................................................................... 14 HERENCIA .......................................................................................................................................... 14 MÉTODOS ........................................................................................................................................... 15 POLIMORFISMO .................................................................................................................................. 16 SOBRECARGA ..................................................................................................................................... 16 LA LEY DE DEMETER ......................................................................................................................... 16 MODELO DE OBJETOS ......................................................................................................................... 17 RELACIONES ENTRE CLASES .............................................................................................................. 17 VENTAJAS E INCONVENIENTES DE LA POO ....................................................................................... 18 UN EJEMPLO SENCILLO ...................................................................................................................... 19 INTRODUCCIÓN AL LENGUAJE JAVA ...................................................................................... 21 INTRODUCCIÓN .................................................................................................................................. 21 BREVE HISTORIA DEL LENGUAJE ....................................................................................................... 22 DESCRIPCIÓN DEL LENGUAJE ............................................................................................................. 22 PROGRAMAS EN JAVA: APPLETS Y APLICACIONES ............................................................................ 25 SIMILITUDES Y DIFERENCIAS ENTRE JAVA Y C++ ............................................................................. 26 VERSIONES DEL LENGUAJE ................................................................................................................ 26 ENTORNOS DE DESARROLLO .............................................................................................................. 27 CARACTERÍSTICAS DE LA PLATAFORMA JAVA 2 ............................................................................... 29 SINTAXIS DEL LENGUAJE JAVA................................................................................................. 33 INTRODUCCIÓN .................................................................................................................................. 33 IDENTIFICADORES .............................................................................................................................. 33 PALABRAS CLAVE .............................................................................................................................. 35 LITERALES ......................................................................................................................................... 36 Enteros........................................................................................................................................... 36 Coma flotante................................................................................................................................. 37 Booleanos ...................................................................................................................................... 37 Caracteres...................................................................................................................................... 37 Cadenas ......................................................................................................................................... 38 El literal null.................................................................................................................................. 38 OPERADORES ..................................................................................................................................... 38 SEPARADORES.................................................................................................................................... 39 COMENTARIOS ................................................................................................................................... 39 TIPOS DE DATOS EN JAVA .................................................................................................................. 40 Enteros........................................................................................................................................... 40 Coma flotante................................................................................................................................. 41 Booleanos ...................................................................................................................................... 41 Carácter......................................................................................................................................... 41 Cadenas ......................................................................................................................................... 41 Arrays ............................................................................................................................................ 42 EMPAQUETAR TIPOS PRIMITIVOS ....................................................................................................... 43 CONVERSIÓN DE TIPOS DE DATOS ...................................................................................................... 44 BLOQUES Y ÁMBITOS ......................................................................................................................... 45 Bloques .......................................................................................................................................... 45 Ámbitos .......................................................................................................................................... 46 EXPRESIONES ..................................................................................................................................... 46 CLASIFICACIÓN DE OPERADORES ...................................................................................................... 48 Aritméticos..................................................................................................................................... 48 Operadores sobre enteros........................................................................................................... 48 Operadores sobre reales............................................................................................................. 50 Booleanos ...................................................................................................................................... 50 Relacionales................................................................................................................................... 51 Cadena........................................................................................................................................... 51 Asignación ..................................................................................................................................... 52 PRECEDENCIA DE LOS OPERADORES .................................................................................................. 52 CONTROL DE FLUJO............................................................................................................................ 53 If-else ............................................................................................................................................. 53 Switch............................................................................................................................................. 54 For ................................................................................................................................................. 55 While.............................................................................................................................................. 56 Do-while: ....................................................................................................................................... 57 Break, continue y etiquetas............................................................................................................ 57 Return ............................................................................................................................................ 59 Try, catch, finally y throws: ........................................................................................................... 59 POO EN JAVA: OBJETOS................................................................................................................ 61 INTRODUCCIÓN .................................................................................................................................. 61 OBJETOS ............................................................................................................................................. 61 CREACIÓN DE OBJETOS ...................................................................................................................... 62 Declaración ................................................................................................................................... 62 Instanciación.................................................................................................................................. 63 Inicialización ................................................................................................................................. 64 UTILIZACIÓN DE OBJETOS .................................................................................................................. 64 DESTRUCCIÓN DE OBJETOS ................................................................................................................ 66 POO EN JAVA: CLASES................................................................................................................... 69 CLASES............................................................................................................................................... 69 DECLARACIÓN DE LA CLASE .............................................................................................................. 70 Superclase de la clase.................................................................................................................... 70 Interfaces de la clase ..................................................................................................................... 70 Modificadores de la clase.............................................................................................................. 71 CUERPO DE LA CLASE. DECLARACIÓN DE ATRIBUTOS ...................................................................... 72 Modificadores................................................................................................................................ 72 Tipo................................................................................................................................................ 74 Nombre variable ............................................................................................................................ 75 CUERPO DE LA CLASE. IMPLEMENTACIÓN DE MÉTODOS ................................................................... 75 Declaración del método................................................................................................................. 75 Declaración de variables............................................................................................................... 80 Implementación del método........................................................................................................... 80 HERENCIA .......................................................................................................................................... 82 Sustituir la implementación de un método..................................................................................... 84 Ampliar la implementación de un método ..................................................................................... 85 Métodos que una clase heredada no puede redefinir .................................................................... 85 Métodos que una clase heredada tiene que redefinir .................................................................... 86 CLASES ABSTRACTAS......................................................................................................................... 86 POO EN JAVA: OTROS CONCEPTOS .......................................................................................... 89 INTRODUCCIÓN .................................................................................................................................. 89 INTERFACES ....................................................................................................................................... 89 Declaración del interfaz ................................................................................................................ 90 Cuerpo del interfaz ........................................................................................................................ 90 EXCEPCIONES..................................................................................................................................... 91 PAQUETES .......................................................................................................................................... 94 PRINCIPALES PAQUETES DEL LENGUAJE JAVA................................................................................... 98 LA CLASE OBJECT ............................................................................................................................ 100 POO EN JAVA: UN EJEMPLO. RESUMEN DE CONCEPTOS................................................ 103 INTRODUCCIÓN ................................................................................................................................ 103 DESCRIPCIÓN DEL PROBLEMA.......................................................................................................... 103 UTILIZANDO EL JDK 1.3.................................................................................................................. 104 CREANDO LAS CLASES ..................................................................................................................... 105 APLICACIONES JAVA ................................................................................................................... 111 INTRODUCCIÓN ................................................................................................................................ 111 INTRODUCCIÓN A VISUAL J++ 6...................................................................................................... 112 INTRODUCCIÓN A JBUILDER 3.5 ...................................................................................................... 117 EL MÉTODO MAIN().......................................................................................................................... 122 LA CLASE SYSTEM ........................................................................................................................... 125 LA CLASE RUNTIME ......................................................................................................................... 128 ALGUNAS CONSIDERACIONES SOBRE VISUAL J++ 6 ....................................................................... 130 CONSIDERACIONES SOBRE JBUILDER .............................................................................................. 135 INTERFACES DE USUARIO EN JAVA: COMPONENTES AWT ........................................... 145 INTRODUCCIÓN ................................................................................................................................ 145 EL AWT (ABSTRACT WINDOW TOOLKIT) ...................................................................................... 145 UTILIZANDO LOS COMPONENTES DEL AWT.................................................................................... 148 Frame........................................................................................................................................... 148 Cursor.......................................................................................................................................... 149 7 MenuBar ...................................................................................................................................... 150 Menu ............................................................................................................................................ 150 MenuItem ..................................................................................................................................... 150 CheckboxMenuItem ..................................................................................................................... 150 Dialog .......................................................................................................................................... 152 FileDialog.................................................................................................................................... 153 Container ..................................................................................................................................... 153 Button........................................................................................................................................... 154 Label ............................................................................................................................................ 156 List, Choice.................................................................................................................................. 157 TextField, TextArea ..................................................................................................................... 158 Checkbox, CheckboxGroup ......................................................................................................... 160 ScrollPane.................................................................................................................................... 162 INTERFACES DE USUARIO EN JAVA: GESTORES DE DISEÑO Y EVENTOS................. 165 INTRODUCCIÓN ................................................................................................................................ 165 GESTORES DE DISEÑO ...................................................................................................................... 165 FlowLayout .................................................................................................................................. 167 BorderLayout............................................................................................................................... 167 CardLayout .................................................................................................................................. 168 GridLayout................................................................................................................................... 170 GridBagLayout ............................................................................................................................ 171 TRATAMIENTO DE EVENTOS EN JAVA .............................................................................................. 173 INTERFACES DE USUARIO EN JAVA: COMPONENTES SWING / CONTENEDORES... 189 INTRODUCCIÓN ................................................................................................................................ 189 JFC Y SWING ................................................................................................................................... 190 COMPONENTES SWING FRENTE A COMPONENTES AWT.................................................................. 191 CONTENEDORES DE ALTO NIVEL...................................................................................................... 192 JFrame......................................................................................................................................... 197 JDialog, JOptionPane ................................................................................................................. 199 JApplet ......................................................................................................................................... 208 CONTENEDORES INTERMEDIOS ........................................................................................................ 208 JPanel .......................................................................................................................................... 209 JTabbedPane ............................................................................................................................... 212 JToolBar ...................................................................................................................................... 216 JLayeredPane .............................................................................................................................. 217 INTERFACES DE USUARIO EN JAVA: COMPONENTES ATÓMICOS DE SWING ......... 223 INTRODUCCIÓN ................................................................................................................................ 223 COMPONENTES ATÓMICOS ............................................................................................................... 223 COMPONENTES PARA OBTENER INFORMACIÓN ............................................................................... 225 JButton......................................................................................................................................... 225 JCheckbox.................................................................................................................................... 227 JRadioButton ............................................................................................................................... 229 JComboBox.................................................................................................................................. 231 JMenu .......................................................................................................................................... 233 JSlider.......................................................................................................................................... 238 COMPONENTES PARA MOSTRAR INFORMACIÓN ............................................................................... 242 JLabel .......................................................................................................................................... 242 JToolTip....................................................................................................................................... 245 JProgressBar ............................................................................................................................... 245 COMPONENTES QUE MUESTRAN INFORMACIÓN ESTRUCTURADA.................................................... 247 JColorChooser............................................................................................................................. 247 JFileChooser................................................................................................................................ 252 INTERFACES DE USUARIO EN JAVA: OTRAS CARACTERÍSTICAS DE SWING........... 257 INTRODUCCIÓN ................................................................................................................................ 257 EL GESTOR DE DISEÑO BOXLAYOUT ............................................................................................... 257 ESTABLECIENDO EL LOOK & FEEL .................................................................................................. 262 APPLETS DE JAVA: INTRODUCCIÓN A LOS APPLETS....................................................... 269 CONCEPTOS PREVIOS ....................................................................................................................... 269 Internet......................................................................................................................................... 269 URLs y direcciones IP ................................................................................................................. 270 Clientes y Servidores Web ........................................................................................................... 271 HTML........................................................................................................................................... 272 HTTP ........................................................................................................................................... 272 INTRODUCCIÓN A LOS APPLETS DE JAVA ......................................................................................... 272 EL CICLO DE VIDA DE LOS APPLETS ................................................................................................. 282 SEGURIDAD EN LOS APPLETS ........................................................................................................... 285 TRUSTED/UNTRUSTED APPLETS ...................................................................................................... 289 DIFERENCIAS ENTRE APPLETS Y APLICACIONES .............................................................................. 289 LA ETIQUETA APPLET ....................................................................................................................... 290 Codebase ..................................................................................................................................... 291 Code............................................................................................................................................. 291 Alt................................................................................................................................................. 291 Name............................................................................................................................................ 291 Width, Height............................................................................................................................... 291 Align............................................................................................................................................. 291 Vspace, Hspace............................................................................................................................ 292 <PARAM>................................................................................................................................... 292 Etiquetas HTML alternativas ...................................................................................................... 292 APPLETS DE JAVA: UTILIZANDO LOS APPLETS ................................................................. 293 INTERACCIÓN DE LOS APPLETS CON EL NAVEGADOR WEB .............................................................. 293 EVENTOS, GRÁFICOS Y FUENTES EN LOS APPLETS ........................................................................... 303 COMPRESIÓN DE APPLETS ................................................................................................................ 322 COMPONENTES SWING Y APPLETS ................................................................................................... 325 LA CLASE JAPPLET .......................................................................................................................... 327 ASPECTOS AVANZADOS DE JAVA: PROCESOS.................................................................... 331 INTRODUCCIÓN ................................................................................................................................ 331 PROCESOS Y MULTIPROCESO ........................................................................................................... 331 HOLA MUNDO CON HILOS ................................................................................................................ 332 PARALELISMO .................................................................................................................................. 333 UTILIZANDO PROCESOS. EL INTERFAZ RUNNABLE .......................................................................... 337 COORDINANDO LOS PROCESOS ........................................................................................................ 344 Sin derecho preferente................................................................................................................. 344 Con derecho preferente ............................................................................................................... 344 ASPECTOS AVANZADOS DE JAVA: CANALES Y SOCKETS............................................... 345 INTRODUCCIÓN A LOS CANALES ...................................................................................................... 345 CANALES ESTÁNDAR DE ENTRADA/SALIDA ..................................................................................... 346 CANALES DE JAVA.IO ....................................................................................................................... 348 CANALES DE TRANSMISIÓN (DATA SINK STREAMS) .......................................................................... 350 CANALES DE PROCESO (PROCESSING STREAMS)............................................................................... 352 Canales de Filtrado ..................................................................................................................... 353 Canales de buffer......................................................................................................................... 353 Canal de Concatenación.............................................................................................................. 354 Canales de conversión de tipos ................................................................................................... 354 9 Serialización de Objetos .............................................................................................................. 356 Canal Contador de Líneas........................................................................................................... 357 Canales de impresión .................................................................................................................. 358 Canales de vuelta atrás ............................................................................................................... 359 APLICACIONES CLIENTE/SERVIDOR EN JAVA ................................................................................... 359 Introducción a la POO ¿Qué es la POO? Las siglas POO se corresponden con Programación Orientada a Objetos, aunque muchas veces las podemos encontrar escritas en inglés OOP (Object Oriented Programming). En este primer capítulo de este curso vamos a tratar de explicar de forma sencilla los principales conceptos y términos que se utilizan dentro de este tipo de programación, es decir, dentro de la Programación Orientada a Objetos. No vamos a entrar en sesudas divagaciones filosóficas respecto a la POO, sino que vamos a definir lo más claramente posible cada uno de los elementos clave que aparecen en la POO para después poder aplicarlos al lenguaje que nos ocupa, es decir, al lenguaje Java. Este tema es muy necesario debido a que el lenguaje Java, como veremos en el siguiente capítulo, es un lenguaje que se basa en la Programación Orientada a Objetos, por lo tanto para conocer el lenguaje Java, es necesario conocer la Programación Orientada a Objetos. La Programación Orientada a Objetos trata de utilizar una visión real del mundo dentro de nuestros programas. La visión que se tiene del mundo dentro de la POO es que se encuentra formado por objetos. Para comprender bien la POO debemos olvidar un poco la Programación Estructurada, que si nos fijamos bien es algo artificial, la POO es una forma de abordar los problemas más natural. Aquí natural significa más en contacto con el mundo real que nos rodea, de esta forma si queremos resolver un problema determinado, debemos identificar cada una de las partes del problema con objetos presentes en el mundo real. Programación en Java © Grupo EIDOS En esta definición de POO ya estamos haciendo referencia al elemento clave de la misma: el objeto. El objeto va a ser la modelización de los objetos que nos encontramos en el mundo real, estos objetos los vamos a utilizar en nuestros programas para dar la solución al problema que nos ocupe en cada caso. Objetos Como ya hemos adelantado un objeto es la pieza básica de la POO, es una representación o modelización de un objeto real perteneciente a nuestro mundo, por ejemplo, podemos tener un objeto perro que represente a un perro dentro de nuestra realidad, o bien un objeto factura, cliente o pedido. Los objetos en la vida real tienen todos, dos características: estado y comportamiento. El estado de un objeto viene definido por una serie de parámetros que lo definen y que lo diferencian de objetos del mismo tipo. En el caso de tener un objeto perro, su estado estaría definido por su raza, color de pelo, tamaño, etc. Y el comportamiento viene definido por las acciones que pueden realizar los objetos, por ejemplo, en el caso del perro su comportamiento sería: saltar, correr, ladrar, etc. El comportamiento permite distinguir a objetos de distinto tipo, así por ejemplo el objeto perro tendrá un comportamiento distinto a un objeto gato. Si tomamos un ejemplo que tiene que ver más con el mundo de la informática se pueden ver más claros estos dos conceptos. Si tenemos un objeto pantalla que representa la pantalla de nuestro ordenador, el estado de la misma estaría definido por los siguientes parámetros: encendida o apagada, tamaño, resolución, número de colores, etc.; y su comportamiento podría ser: imprimir, encender, apagar, etc. Los parámetros o variables que definen el estado de un objeto se denominan atributos o variables miembro y las acciones que pueden realizar los objetos se denominan métodos o funciones miembro, y para indicar variables miembro y funciones miembro se utiliza el término general miembro. Si lo comparamos con la programación estructurada podríamos hacer la siguiente aproximación: los atributos o variables miembro serían variables y los métodos o funciones miembro procedimientos y funciones. A partir de ahora y a lo largo de todo el presente curso vamos a utilizar únicamente la nomenclatura de atributos y métodos. Los atributos de un objeto deben encontrarse ocultos al resto de los objetos, es decir, no se va a poder acceder directamente a los atributos de un objeto para modificar su estado o consultarlo. Para acceder a los atributos de un objeto se deben utilizar métodos. Es decir, los métodos exponen toda la funcionalidad del objeto, mientras que los detalles del estado interno del objeto permanecen ocultos. Incluso algunos métodos también pueden permanecer ocultos. El hecho de ocultar la implementación interna de un objeto, es decir, como está construido y de que se compone se denomina encapsulación. La encapsulación es uno de los beneficios y particularidades del paradigma de la Programación Orientada a Objetos. Normalmente un objeto ofrece una parte pública que será utilizada por otros objetos para interactuar entre sí, pero también permanece una parte oculta para encapsular los detalles de la implementación del objeto. Ya se ha dicho que un objeto está compuesto de atributos y métodos. Como la caja negra de un avión, el objeto recubre la información que almacena y solamente podemos obtener la información e indicarle que realiza acciones por medio de lo que comúnmente se denomina interfaz del objeto, que estará constituido por los métodos públicos. 12 © Grupo EIDOS 1. Introducción a la POO Los datos y la implementación queda oculta a los demás objetos que interaccionan en el programa, lo que favorece enormemente la protección de los datos y las estructuras internas contra las modificaciones externas al objeto. De este modo es mucho más sencillo localizar errores en los programas puesto que cada objeto está altamente especializado, y sólo se encarga de su tarea. Como se puede observar, esto consigue una mayor modularidad, que facilita además el diseño en equipo de programas y la reutilización de clases (componentes) creados por otros desarrolladores. Hemos indicado que la encapsulación es un beneficio que nos aporta la POO, es un beneficio porque permite abstraernos de la utilización de los objetos, es decir, a mí me interesa realizar una determinada tarea con un objeto (por ejemplo imprimir una pantalla o rellenar una factura), pero a mí no me interesa como realiza este proceso internamente el objeto que estoy utilizando. En este momento entra en juego otro concepto importante de la POO y que es la abstracción. La abstracción indica la capacidad de ignorar determinados aspectos de la realidad con el fin de facilitar la realización de una tarea. Nos permite ignorar aquellos aspectos de la realidad que no intervienen en el problema que deseamos abordar, y también nos permite ignorar los aspectos de implementación de los objetos en los pasos iniciales, con lo cual sólo necesitamos conocer qué es lo que hace un objeto, y no cómo lo hace, para definir un objeto y establecer las relaciones de éste con otros objetos. Un objeto lo podríamos representar como dos circunferencias, una interna que permanece oculta al mundo exterior y que contendría todos los detalles de la implementación del objeto, y otra circunferencia concéntrica externa, que representa lo que el objeto muestra al mundo exterior y le permite utilizar para interactuar con él. En la Figura 1 se puede ver dicha representación. La encapsulación ofrecida a través de objetos tienen varios beneficios, entre los que destacan la modularidad y la ocultación de la información. Mediante la modularidad podemos escribir código de manera independiente de cómo se encuentren construidos los diferentes objetos que vamos a utilizar. Y ocultando la información se permite realizar cambios en el código interno de los objetos sin que afecte a otros objetos que los utilicen o dependan de ellos. No es necesario entender la implementación interna de un objeto para poder utilizarlo. Figura 1 Mensajes Los mensajes son la forma que tienen de comunicarse distintos objetos entre sí. Un objeto por sí sólo no es demasiado útil, sino que se suele utilizar dentro de una aplicación o programa que utiliza otros objetos. El comportamiento de un objeto está reflejado en los mensajes a los que dicho objeto puede responder. Representan las acciones que un determinado objeto puede realizar. 13 Programación en Java © Grupo EIDOS Un mensaje enviado a un objeto representa la invocación de un determinado método sobre dicho objeto, es decir, la ejecución de una operación sobre el objeto. Es la manera en la que un objeto utiliza a otro, el modo en el que dos objetos se comunican, ya que la ejecución de ese método retornará el estado del objeto invocado o lo modificará. Los mensajes se utilizan para que distintos objetos puedan interactuar entre sí y den lugar a una funcionalidad más compleja que la que ofrecen por separado. Un objeto lanzará o enviará un mensaje a otro objeto si necesita utilizar un método del segundo objeto. De esta forma si el objeto A quiere utilizar un método del objeto B, le enviará un mensaje al objeto A. Para enviar un mensaje se necesitan tres elementos: el objeto al que se le va a enviar el mensaje, el nombre del método que se debe ejecutar y los parámetros necesarios para el método en cuestión. Clases Una clase es un molde o prototipo que define un tipo de objeto determinado. Una clase define los atributos y métodos que va a poseer un objeto. Mediante las clases podremos crear o instanciar objetos de un mismo tipo, estos objetos se distinguirán unos de otros a través de su estado, es decir, el valor de sus atributos. La clase la vamos a utilizar para definir la estructura de un objeto, es decir, estado (atributos) y comportamiento (métodos). La clase es un concepto abstracto que generalmente no se va a utilizar directamente en nuestros programas o aplicaciones. Lo que vamos a utilizar van a ser objetos concretos que son instancias de una clase determinada. La clase es algo genérico y abstracto, es similar a una idea. Cuando decimos piensa en un coche todos tenemos en mente la idea general de un coche, con puertas, ruedas, un volante, etc., sin embargo cuando decimos "ese coche que está aparcado ahí fuera", ya se trata de un coche determinado, con una matrícula, de un color, con un determinado número de puertas, y que podemos tocar y utilizar si es necesario. Sin embargo como ya hemos dicho la clase es la idea que define al objeto concreto. Un ejemplo que se suele utilizar para diferenciar y relacionar clases y objetos es el ejemplo del molde de galletas. El molde para hacer galletas sería una clase, y las galletas que hacemos a partir de ese molde ya son objetos concretos creados a partir de las características definidas por el molde. Una vez implementada una clase podremos realizar instancias de la misma para crear objetos que pertenezcan a esa clase. Las clases ofrecen el beneficio de la reutilización, utilizaremos la misma clase para crear distintos objetos. Y luego veremos que una vez que tenemos una clase podremos aprovecharla heredando de ella para complicarla o especializarla para una labor concreta. Si comparamos las clases y objetos de la POO con la programación estructurada tradicional, se puede decir que las clases son los tipos de datos y los objetos las variables de esos tipos de datos. De esta forma si tenemos el tipo entero, en la POO diríamos que es la clase entero, y si tenemos una variable de tipo entero, en la POO diríamos que tenemos un objeto de la clase entero. Herencia La herencia es un mecanismo mediante el cual podemos reutilizar clases ya definidas. Es decir, si tenemos una clase botón que define un tipo de objeto que se corresponde con un botón que tiene un 14 © Grupo EIDOS 1. Introducción a la POO texto, que se puede pulsar, etc., si queremos definir una nueva clase llamada botón de color, no tenemos que rescribir todo el código y crear una clase completamente nueva, sino lo que haremos será heredar de la clase botón, utilizar lo que nos ofrezca esta clase y añadirle lo que sea necesario para la nueva funcionalidad deseada. La herencia dentro de la POO es un mecanismo fundamental que se puede definir también como una transmisión de las características de padres a hijos. Entendiendo aquí características como métodos y atributos de una clase. La clase hija puede añadir atributos, métodos y redefinir los métodos de la clase padre. Podemos ver la herencia como una sucesiva especialización de las clases. La clase de la que se hereda se suele denominar clase padre o superclase, y la clase que hereda se denomina clase hija o subclase. El mecanismo de herencia es muy potente, puesto que nos permite agregar funcionalidades nuevas a una clase ya existente, reutilizando todo el código que ya se tenga disponible de la clase padre, es decir, se heredarán sus atributos y métodos, como ya habíamos indicado con anterioridad. En las clases hijas podemos redefinir el comportamiento de la clase padre. Para verificar que la herencia entre dos clases es correcta y coherente, debemos hacernos la pregunta de "¿es un?" o "¿es un tipo de?". Por ejemplo, en el caso que comentábamos del botón, tenemos una clase BotonColor que hereda de la clase Boton. Esta herencia contesta perfectamente a la pregunta definida antes: ¿un botón de color es un botón?, evidentemente sí. Mediante el mecanismo de herencia podemos definir superclases denominadas clases abstractas que definen comportamientos genéricos. De esta clase pueden heredar otras clases que ya implementan de forma más concreta estos comportamientos. De esta forma podremos crear jerarquías de clases. Así por ejemplo podemos tener una clase bicicleta, que será más o menos genérica. De esta clase pueden heredar la clase bicicleta de montaña, bicicleta de carreras y tandem, que ya ofrecen una clase más especializada que la clase padre. Los métodos que se heredan de la clase padre no tienen porqué utilizarse sin realizar ningún cambio, se puede llevar a cabo lo que se denomina la sobrescritura de métodos. Podemos heredar un método de la clase padre, pero en la clase hija le podemos dar una implementación diferente para que se adecue a la nueva clase. La herencia puede ser simple si la clase hija hereda de una única clase padre o múltiple si hereda de varias clases padre, más adelante veremos que el tipo de herencia que soporta Java es una herencia simple. Algunas veces la herencia múltiple puede llegar a ser confusa. Métodos Como ya hemos dicho anteriormente los métodos son las acciones que se pueden realizar con los objetos. También se podría definir un método como la implementación de un mensaje, al fin y al cabo, un mensaje es la llamada o invocación de un método de un objeto. Existen dos métodos especiales dentro de la POO que se denominan constructor y destructor. El método constructor se ejecuta automáticamente cada vez que se crea un objeto de la clase en cuestión, sobre el objeto que acaba de crearse, inmediatamente después de haberse asignado memoria a dicho objeto. Algunos lenguajes proporcionan un constructor por defecto, pero generalmente lo correcto es que lo defina el diseñador de la clase y que en él se lleven a cabo las inicializaciones y todas aquellas operaciones que se necesiten para poder usar el objeto. 15 Programación en Java © Grupo EIDOS El método destructor se invoca automáticamente inmediatamente antes de liberar la memoria del objeto en cuestión, o lo que es lo mismo, antes de que se salga del ámbito de la declaración del objeto, por lo que se ha de emplear para que la destrucción del objeto se efectúe correctamente y contendrá operaciones tales como liberación de memoria asignada dinámicamente dependiente del objeto, grabación de todos o parte de los atributos del objeto en un fichero o base de datos y operaciones similares. Polimorfismo El término polimorfismo expresa la posibilidad de que el mismo mensaje, enviado a objetos distintos, ejecute métodos distintos. Esto significa que podemos definir dentro de dos clases distintas dos operaciones con el mismo nombre y aspecto externo, pero con distintas implementaciones para cada clase. En el momento de emplear estas operaciones, el lenguaje es capaz de ejecutar el código correspondiente dependiendo de la clase del objeto sobre el que se ejecuta la operación. Esto permite definir un interfaz común, un aspecto externo idéntico, para una serie de clases. De esta forma podemos definir un método suma() para la clase Enteros y otro método suma() para la clase Matrices. El mensaje será el mismo, pero la implementación de los métodos será distinta ya que no es lo mismo sumar enteros que matrices. Sobrecarga La sobrecarga de métodos se produce cuando una clase tiene métodos con el mismo nombre pero que difieren o bien en el número o en el tipo de los parámetros que reciben dichos métodos. Un ejemplo de sobrecarga los podemos tener en el método imprimir(), mediante este método vamos a imprimir en pantalla y realizar un salto de línea. Este método acepta como parámetro una variable de tipo entero o una variable de tipo cadena de caracteres, incluso si no indicamos ningún parámetro realizaría un salto de línea. La ley de Demeter En lo que respecta a la implementación de métodos de una clase, existe una ley que nos da una serie de pautas para realizar una Programación Orientada a Objetos correcta, esta ley es la Ley de Demeter. La Ley de Demeter, enunciada por Karl Lieberherr, determina el acceso o visibilidad de los objetos en la implantación de un método, y se rige por el siguiente principio: en la implantación de un método se puede tener acceso a los siguientes objetos: • Atributos de su clase. • Los parámetros que se pasan al método. • Objetos temporales creados dentro del método. Existen dos formas de la Ley de Demeter, la flexible y la estricta, la flexible permite acceder a los atributos de la clase padre o superclase y la estricta indica que este acceso se debe lograr mediante la utilización de métodos de acceso de la clase padre. 16 © Grupo EIDOS 1. Introducción a la POO Modelo de objetos El modelo de objetos es un conjunto de principios que se deben dar para que se puedan modelar objetos computacionales (objetos dentro de nuestro código y programas) a partir de objetos de la realidad de manera que éstos reflejen los posibles comportamientos presentes en la realidad y compongan un modelo computacional válido. Es decir, definido e identificado un problema se trata de realizar una representación lógica de los objetos que forman parte del problema en el mundo real, de esta forma podremos utilizar en nuestro programa estos objetos para dar la solución a través de nuestro código. El modelo de objetos que definen un problema de la realidad se basa en los siguientes principios: abstracción, encapsulación, herencia y polimorfismo. Todos estos conceptos básicos de la POO ya han sido discutidos en este tema en mayor o menor medida. Por lo tanto antes de empezar a construir un programa para una tarea específica, es necesario construir y diseñar su modelo de objetos. Existen diversas técnicas de modelización, pero el objetivo de este curso no es el de explicarlas, así que no entraremos en más detalles. Relaciones entre clases Una clase por sí sola no ofrece una funcionalidad demasiado interesante, como ya veremos a lo largo del curso, el lenguaje Java se encuentra formado por un gran número de clases que forman parte de una compleja y completa jerarquía. Cada una de las clases está especializada en una función o tarea específica, es decir, se da una gran modularidad, cada clase tiene su cometido. Por lo tanto para ofrecer una mayor funcionalidad y realizar tareas más complejas es necesario que exista una relación entre distintas clases. Un ejemplo podría ser las piezas del motor de un coche. Las piezas por si solas no realizan ninguna tarea de importancia, cuando realmente se saca provecho de ellas es cuando se relacionan entre sí y se construye con ellas un motor. A su vez este motor puede ser incorporado dentro de un coche, que estará compuesto a su vez de más objetos o piezas. Como vemos la correspondencia entre los objetos del mundo real y los objetos del mundo computacional es bastante obvia en algunos casos. Básicamente una clase se puede relacionar con otra de tres formas diferentes. Las relaciones que podemos distinguir son: • Relación de composición: una clase puede estar compuesta de otras clases. Esto se consigue implementando los atributos de la clase como objetos de otra clase. Una clase hace uso de otra a través de sus atributos, una clase se encuentra formada por varias clases. Por ejemplo la clase Coche tiene atributos que son de la clase Puerta, Rueda, Motor, etc. • Relación de uso: una clase se relaciona con otra a través de los mensajes que le envía. Esto se consigue pasándose una instancia de la clase como uno de los parámetros del método invocado por el mensaje. Es decir, si tenemos la clase Pantalla con el método dibujar() y queremos dibujar un objeto de la clase Rectangulo, deberíamos realizar lo siguiente objPantalla.dibujar(Rectangulo), es decir, el parámetro que se le pasa al método dibujar() de la clase Pantalla es un objeto de la clase Rectangulo. • Relación de herencia: este tipo de relación entre clases ya la conocemos y consiste en que una clase hija hereda de una clase padre o superclase pudiendo utilizar así toda la funcionalidad ofrecida por la clase padre y añadir nuevas funcionalidades. En esta forma de relación se 17 Programación en Java © Grupo EIDOS consigue la reutilización del código y una progresiva especialización a través de una jerarquía de clases. Ventajas e inconvenientes de la POO En este apartado vamos a comentar que ventajas nos ofrece el paradigma de la POO, también mostraremos algunas de sus desventajas. Como ventajas o aportaciones podemos destacar las siguientes: • Facilita la reutilización del software. A través de la herencia se nos permite utilizar en un objeto las operaciones implementadas para otros sin esfuerzo adicional. Por otro lado la encapsulación nos facilita el uso de objetos que no hemos definido ni implementado. Se pude considerar que la encapsulación y el polimorfismo son las herramientas más potentes del paradigma de la POO. • Facilita la construcción de programas portables. Es posible diseñar una capa de objetos que se comunique con la máquina o el sistema operativo, y sobre ésta los objetos que dan funcionalidad a la aplicación. Una migración a otra arquitectura sólo requerirá cambios en dicha capa, y la encapsulación nos garantiza que los cambios se van a limitar a esos objetos. Java refuerza más esta característica de la portabilidad, ya que, como veremos en el próximo capítulo, el lenguaje Java es independiente de la plataforma en la que se ejecuta. • Facilita el mantenimiento. El encapsulamiento nos garantiza que las modificaciones realizadas en un objeto tendrán un efecto limitado. Si un elemento de datos se accede directamente y en un momento dado cambia de tipo o formato, habrá que localizar todos los puntos en los que se accede a dicho elemento y modificarlos en consecuencia. Si este elemento de datos está encapsulado en un objeto y siempre es accedido mediante las operaciones disponibles, un cambio como el indicado se limitará al objeto, del que sólo habrá que cambiar el elemento de datos y las operaciones del objeto que lo utilizan. Lo recomendable es desconocer la implementación interna del objeto, nosotros necesitaremos utilizar un objeto que ofrece una serie de funcionalidades, pero no nos interesa de que forma nos ofrece las mismas. • Provoca que las tareas de análisis, diseño e implementación sean más intuitivas, ya que se manejan objetos, concepto con el que todos estamos familiarizados, y estructuradas, ya que podemos asignar las tareas de diseño e implementación en el ámbito de objetos. Se debe recordar que los objetos en nuestros diseños van a representar objetos presentes en el mundo real. No todos son beneficios, la POO ofrece también una serie de desventajas, aunque más que desventajas o inconvenientes podemos decir que presenta una serie de dificultades, las cuales se comentan a continuación: 18 • Curvas de aprendizaje largas, debido principalmente a que implica un cambio mentalidad, y no sólo el aprender un nuevo lenguaje. • Dificultad en determinar las características de un objeto. Debido a que un objeto no se define aisladamente, sino que depende de las relaciones con otros objetos, el establecimiento de nuevas relaciones puede implicar un cambio en la definición del objeto y viceversa. Por todo ello es conveniente iterar, esto es, repetir el proceso de definición de objetos y de identificación de relaciones, tantas veces como sean necesarias para alcanzar un modelo estable. En muchos casos resulta complicado llegar a un modelo de objetos definitivo con el que se pueda abordar el problema planteado de forma completa. © Grupo EIDOS • 1. Introducción a la POO Jerarquías de herencia complejas: en muchos casos se tiende a utilizar de forma desmedida el mecanismo de herencia, ofreciendo en algunos casos unas jerarquías de herencia difíciles de seguir y abordar. Un ejemplo sencillo No hace falta decir que el tema que nos ocupa es un tema eminentemente teórico, pero aun así vamos a incluir un breve y sencillo ejemplo con el que se pretende mostrar de forma sencilla como se puede construir un modelo de objetos, identificando los objetos que intervienen en el problema a resolver, definiendo los atributos de la clase, los métodos, relaciones entre las diferentes clases, etc. En este caso vamos a abandonar los típicos ejemplos de la clase Coche y similares y vamos a mostrar un ejemplo más lúdico. En nuestro ejemplo vamos a tener la clase VideoJuego, es decir, vamos a crear el juego de matamarcianos conocido por todos. No vamos a profundizar demasiado en todos los atributos y métodos de las clases, sino que vamos a mostrar únicamente los más relevantes. En el primer paso vamos a identificar las clases necesarias para abordar nuestro problema, en este caso, la creación de un juego de matamarcianos. Primero tengamos en cuenta las especificaciones: • En el juego tenemos dos tipos de enemigos: marcianos y venusianos. • El protagonista del juego es un terrícola. • El terrícola dispone de un arma para defenderse de los enemigos, un lanza cohetes. Como se puede observar no vamos a tener demasiadas complicaciones a la hora definir el modelo de objetos de nuestro programa. Se pueden distinguir seis clases: VideoJuego, Enemigo, Marciano, Venusiano, Terricola y LanzaCohetes. La clase VideoJuego sería la clase principal y contendría al resto de las clases. Por lo tanto entre la clase VideoJuego y el resto de las clases existe una relación de composición. Esta clase tendría como atributos posibles: Enemigos, Heroes y Armas; y como métodos: comenzarPartida(), interrumpirPartida(), reanudarPartida() y finalizarPartida(), la finalidad de cada uno de ellos está bastante clara. La clase Enemigo en realidad va a ser una clase abstracta, ya que no vamos a instanciar objetos de esta clase. La clase Enemigo va a ser la clase padre de la clase Marciano y Venusiano, y lo que se consigue con esta clase es agrupar todo el comportamiento que es común a los enemigos que aparecen en el juego. Esta clase tiene los siguientes atributos: Color, NumeroOjos y NumeroPiernas. Estos atributos serán comunes a las clases Marciano y Venusiano. Existe una relación de herencia entre la clase Enemigo y las clases Marciano y Venusiano. La clase Enemigo podría tener los siguientes métodos: mover(), atacar() y disparar(). Estos métodos también serán heredados por la clase hijas mencionadas. Las clases hijas tienen dos opciones, si la implementación de los métodos anteriores que realiza la clase padre es la adecuada, los heredarán y utilizarán sin más, pero si las clases hijas quieren realizar modificaciones o ampliaciones sobre los métodos heredados deberán implementarlos y por lo tanto sobrescribirlos aportando un comportamiento diferente. 19 Programación en Java © Grupo EIDOS Las clases Marciano y Venusiano pueden además de sobrescribir los métodos heredados de la clase Enemigo, aportar nuevos métodos y nuevos atributos. La clase Marciano añade el atributo Visible, es decir, nuestro amigo tiene la capacidad de hacerse invisible, y la clase Venusiano añade el atributo NumeroCabezas. La clase Terricola representa al héroe de nuestro juego y tiene los atributos: NumeroVidas y Municion, ambos requieren poca explicación. Esta clase implementa el método disparar(), que recibe como parámetro un objeto de la clase LanzaCohetes, la relación entre ambas clases es una relación de uso. La clase LanzaCohetes que representa el arma que va a utilizar la clase Terricola y tienen el atributo NumeroCohetes, y posee el método lanzarCohete(). Podríamos entrar en más detalles e ir afinando más en la identificación de objetos, podríamos definir también la clase Cohete, que representaría a los cohetes lanzados por una instancia de la clase LanzaCohetes. Pero no vamos a entrar en más detalles y vamos a dejar de definir más clases, quedándonos con las vistas hasta ahora. En la Figura 2 se trata de mostrar un esquema de todas las clases que implementan el problema propuesto y la relación existente entre cada una de ellas. Cada clase se representa por una circunferencia y las relaciones existentes mediante flechas. Figura 2 20 Introducción al lenguaje Java Introducción En este capítulo vamos a comentar las características principales del lenguaje Java, también comentaremos algunos conceptos interesantes que aporta el lenguaje. Como su nombre indica este capítulo es introductorio, por lo tanto algunos de los conceptos los explicaremos de forma breve y en los sucesivos capítulos profundizaremos en los temas más interesantes. Por lo tanto en este capítulo todavía no vamos a ver ni una sola línea de código en Java, antes debemos tener claro una serie de puntos acerca del lenguaje. También comentaremos tres herramientas de desarrollo que podemos utilizar para realizar nuestros desarrollos en Java, se trata de las siguientes: • JDK (Java Development Kit): herramienta ofrecida por Sun MicroSystems, implementa la versión última y oficial de Java. • Microsoft Visual J++ 6.0: incluida dentro de Visual Studio 6, ofrece la versión 1.1 de Java. • Borland JBuilder 3.5: potente entorno de desarrollo que implementa la versión de Java perteneciente a Java 2. Que el lector no tema por las distintas versiones de Java, en el apartado correspondiente se aclaran las distintas versiones existentes. Programación en Java © Grupo EIDOS Breve historia del lenguaje Los orígenes de Java se remontan al año 1990, cuando un equipo de la compañía Sun Microsystems investigaba, bajo la dirección del ingeniero James Gosling, en el diseño y elaboración de software para pequeños dispositivos electrónicos de consumo. En un primer momento se pensó en la utilización de lenguajes de programación como C o C++, pero para poder compilar un programa en estos lenguajes es preciso adaptarlo a las características de la plataforma en la que debe funcionar, esta situación constituía un gran inconveniente para las compañías dedicadas a la construcción de dispositivos electrónicos, pues cada pocas semanas aparecen en el mercado versiones más potentes y baratas de los chips utilizados, y por lo tanto, el software que se había diseñado para un chip determinado debía modificarse y adaptarse para explotar las características de los chips de reciente aparición. Se hace patente la necesidad de introducir un nuevo lenguaje de programación, que permita desarrollar programas independientes del tipo de plataforma. Los dispositivos que se pretenden fabricar son calculadoras, relojes, equipos de música, cafeteras, etc.…, que no tienen una gran capacidad computacional, por lo que el nuevo lenguaje debe ser capaz de generar programas pequeños y rápidos, además de ser fiables y robustos. La primera versión de este nuevo lenguaje se denominó Oak (roble), pero más tarde Sun descubrió que este nombre estaba ya registrado, y lo tuvieron que cambiar, el nuevo nombre fue Java (una de las versiones sobre el significado del nombre es que Java es un término popularmente empleado en California para designar café de buena calidad). A comienzos de 1993 aparecieron nuevas herramientas gráficas para facilitar la comunicación y navegación por Internet, se concibió la idea de aplicar técnicas de documentos con enlaces de tipo hipertextual para facilitar la navegación por Internet, y se desarrolló el primer browser (navegador Web o visualizador) de lo que se comenzó a denominar World Wide Web. Esta herramienta era denominada Mosaic. El equipo de James Gosling se planteó como objetivo la utilización de Java como lenguaje en el que escribir aplicaciones que pudiesen funcionar a través de Internet. Como resultado de su trabajo se desarrolló un nuevo navegador completamente escrito en Java, llamado HotJava. Este navegador permitía la integración de pequeñas aplicaciones en el interior de las páginas Web. El desarrollo de HotJava hizo patente que las características de Java se adaptan perfectamente a las peculiaridades de Internet. A partir de su primera y sencilla versión Java ha ido creciendo progresiva y espectacularmente para pasar a ofrecer un potente y complejo lenguaje con el que se pueden abarcar una gran cantidad de campos. Descripción del lenguaje En este apartado vamos a resaltar las características principales del lenguaje Java y comentaremos una serie de términos y conceptos que se hacen indispensables para comprender lo que nos ofrece el lenguaje de programación que nos ocupa. Java es un lenguaje de programación orientado a objetos de propósito general, de ahí la necesidad de estudiar el capítulo anterior dedicado íntegramente a la Programación Orientada a Objetos. Según indican desde Sun Microsystems, Java es un lenguaje creado para realizar una programación en Internet rápida y fácil, rápida y fácil si ya poseemos conocimientos previos de C++ y de programación 22 © Grupo EIDOS 2. Introducción al lenguaje Java orientada a objetos. Por lo tanto si el lector ya ha programado en C++ la curva de aprendizaje del lenguaje Java se suavizará considerablemente. Aunque no se debe considerar a Java como una herramienta exclusiva y únicamente para la programación en Internet, ya que su uso, lejos de restringirse a este campo, puede y debe extenderse a problemas y situaciones de todo tipo, por lo tanto para evitar confusiones el lenguaje Java se podría definir mejor de la siguiente forma: Java es un lenguaje de programación orientado a objetos, de propósito general que presenta características especiales que lo hacen idóneo para su uso en Internet. Una de estas características son los applets. Un applet es un programa dinámico e interactivo que se puede ejecutar dentro de una página Web que se carga en un navegador Web, y otra característica para la utilización de Java en Internet son los servlets. Un servlets es una aplicación Java que se ejecuta sobre un servidor y que atiende una serie de peticiones realizadas desde un cliente que será un navegador Web. A diferencia de los applets los servlets no presentan interfaz gráfico. Java toma prestadas características y sintaxis de diferentes lenguajes de programación. La sintaxis básica de Java está sacada del lenguaje C/C++ aunque al contrario de estos lenguajes Java es un lenguaje fuertemente tipado. De Smalltalk Java toma conceptos como el recolector de basura (garbage collector, concepto que se explicará más adelante) y un sólido modelo de orientación a objetos, como iremos comprobando a lo largo del presente curso. De Objective-C, Java toma el concepto de interfaz, en el capítulo correspondiente veremos como define e implementa Java los interfaces. El mecanismo de herencia que posee Java, se denomina herencia simple, esto quiere decir que cada clase Java sólo puede tener una superclase o clase padre. En otros lenguajes de programación como C++, las clases pueden heredar de diferentes superclases, esto se denomina herencia múltiple, la cual no emplea Java. Pero Java posee un mecanismo que le permite simular la herencia múltiple, este mecanismo se consigue a través de los interfaces. Como ya adelantábamos, el concepto de interfaz lo toma Java del lenguaje Objective-C. Un interfaz es una colección de nombres de métodos sin definiciones reales que indican que una clase tiene un conjunto de comportamientos, además de los que la clase hereda de sus superclases. Por lo tanto un interfaz es una lista de métodos sin ninguna implementación, la palabra reservada implements es utilizada en la declaración de una clase para indicar que implementa los métodos de un interfaz determinado. Más tarde, en el curso, retomaremos el concepto de interfaz. Al ser un lenguaje de Programación Orientada a Objetos, la unidad básica dentro de la programación en Java va a ser la clase y el objeto. Java está compuesto por un gran número de clases que se agrupan y clasifican en paquetes, en el capítulo dedicado a la POO con Java veremos como se estructura la jerarquía de clases que presenta el lenguaje. Pero a pesar de estar compuesto de clases, en Java nos encontramos también con una serie de tipos de datos predefinidos similares a C o C++, estos tipos, denominados tipos primitivos son: int, byte, short, char, long, boolean, float y double. Por lo tanto en Java podremos definir variables de estos tipos de datos, en este caso se empleará la denominación variable en lugar de objeto, ya que los tipos primitivos no son clases. En el próximo capítulo volveremos a retomar los tipos primitivos. Java presenta una completa y compleja jerarquía de clases, esto le hace un lenguaje muy potente, ya que para cada tarea a realizar existe una clase determinada que se encuentra especializada para realizar una función específica. Se puede considerar que por un lado tenemos el lenguaje Java, que es con el que escribimos nuestras clases y compilamos, y por otro se encuentra la Máquina Virtual de Java, JVM (Java Virtual 23 Programación en Java © Grupo EIDOS Machine). Para garantizar que los programas son independientes de la plataforma (capacidad del programa de trasladarse con facilidad de un sistema computacional a otro) hay una sola arquitectura a la que todos los programas Java son compilados, es decir, cuando se compila un programa Java en una plataforma Windows/Intel, se obtiene la misma salida compilada que en un sistema Macintosh o Unix. El compilador compila no a una plataforma determinada, sino a una plataforma abstracta llamada Máquina Virtual de Java. La especificación de la Máquina Virtual de Java define la JVM como: una máquina imaginaria que se implementa emulando por software una máquina real. El código para la Máquina Virtual de Java se almacena en ficheros .class, cada uno de los cuales contiene al menos el código de una clase pública, en el capítulo dedicado a la POO con Java comentaremos en detalle la visibilidad de las clases (públicas o privadas). Por lo tanto, cuando se escribe una aplicación Java o un applet Java (después veremos estos dos tipos de programas que se pueden construir en Java), se está escribiendo un programa diseñado para ejecutarse en la Máquina Virtual de Java. La Máquina Virtual de Java requiere un código binario especial para ejecutar los programas Java, este código no debe tener instrucciones relacionadas específicamente con la plataforma. Los archivos binarios Java, que se obtienen al compilar el código fuente, son independientes de la plataforma y pueden ejecutarse en múltiples plataformas sin necesidad de volver a compilar el fuente. Los archivos binarios Java se encuentran en una forma especial llamada bytecode, que son un conjunto de instrucciones muy parecidas al código máquina, pero que no son específicas para ningún procesador. El compilador Java toma el programa Java y en lugar de generar código máquina específico para los archivos fuente, genera un bytecode. Para ejecutar un programa Java, se debe ejecutar un programa llamado intérprete de bytecode, el cual a su vez ejecuta el programa Java deseado. En el caso de los applets el intérprete se encuentra integrado en el navegador Web con capacidad para Java y es ejecutado automáticamente. El concepto de independencia de la plataforma es ilustrado en la Figura 3. Figura 3 24 © Grupo EIDOS 2. Introducción al lenguaje Java La desventaja de utilizar los bytecodes es la velocidad, estos programas tienen una menor velocidad de ejecución, ya que previamente a ejecutarse sobre el sistema, deben ser procesados por el intérprete. Aunque según van apareciendo nuevas versiones del lenguaje Java la velocidad de ejecución se va mejorando, se alcanzará la máxima velocidad y eficacia cuando aparezcan los chips Java. Se trata de una versión hardware del intérprete Java presente en los programas navegadores con capacidad para este lenguaje, es decir, es una implementación hardware de la Máquina Virtual de Java. Estos chips serán los encargados de traducir el código Java sobre la marcha, por lo tanto no será necesaria la etapa intermedia de interpretación de los bytecodes, como se veía en la figura, con lo que se aumentará de forma considerable la velocidad de ejecución. En un principio Sun MicroSystems tiene pensado comercializar estos chips en una especie de tarjeta, que se insertará en un slot del ordenador. Una polémica entorno a Java se produjo cuando Microsoft lanzó su versión del lenguaje, a través de su herramienta de desarrollo Visual J++. Desde esta herramienta corremos el peligro de generar código Java que sí sea dependiente de la plataforma, en este caso de la plataforma Windows, y si estamos utilizando el lenguaje Java es porque nos interesa su característica de independencia de la plataforma, por lo tanto hay que ser cuidadosos en este aspecto. Java incluye características de seguridad para reforzar su empleo en Internet. Un problema de seguridad potencial tiene que ver con los applets de Java, que son código ejecutable que opera en la máquina local del usuario que se conecta a la página Web en la que se encuentran los applets. Java emplea verificación de código y acceso limitado al sistema de archivos para garantizar que el código no dañe nada en la máquina local. En el tema y apartados correspondientes comentaremos las restricciones de seguridad que presentan los applets. Debido a que en Java no existen punteros, la asignación y liberación de recursos tiene algunas particularidades. El recolector de basura (garbage collector) es otro de los aciertos del lenguaje Java, se trata de un hilo de ejecución (thread) que se encarga de rastrear en tiempo de ejecución cada objeto que se ha creado, advierte cuándo desaparece la última referencia a él y libera el objeto por el programador. Es decir, en Java la asignación de memoria es dinámica y automática, cuando se crea un nuevo objeto se destina la cantidad de memoria necesaria, y una vez que se ha dejado de utilizar ese objeto el recolector de basura lo localiza y se apropia de la memoria que empleaba el objeto. Por lo tanto no es necesario realizar ninguna liberación explícita de memoria. Programas en Java: applets y aplicaciones Los programas Java comprenden dos grupos principales: applets y aplicaciones. Un applet (denominado por algunos autores miniaplicación) es un programa dinámico e interactivo que se ejecuta dentro de una página Web, desplegada por un navegador Web con capacidad para Java como puede ser Navigator de Netscape o el Internet Explorer de Microsoft, por lo tanto los applets para ejecutarse dependen de un navegador Web habilitado para Java. Los applets es uno de los principales motivos que han hecho al lenguaje Java tan popular, sin embargo no son tan potentes como las aplicaciones. Las aplicaciones Java son programas más generales que los applets. No requieren un navegador para ejecutarse sólo necesitan de un intérprete de Java para la plataforma en la que se ejecutarán, y pueden emplearse para realizar todo tipo de aplicaciones posibles. Una de las primeras aplicaciones Java que se realizaron fue el navegador Web HotJava. Una aplicación Java consiste en una o más clases, lo único que se necesita para ejecutar una aplicación es tener una clase que funcione como punto de arranque para el resto del programa. 25 Programación en Java © Grupo EIDOS Para ejecutar una aplicación Java en un sistema es necesario ejecutar primero la Máquina Virtual, es decir, el intérprete de Java, que permitirá la ejecución de la aplicación, ya que traduce los bytecodes en código nativo. Este paso intermedio a la ejecución de la aplicación Java puede ser molesto, por ello algunos constructores de software han anunciado que pronto incorporarán la Máquina Virtual de Java a sus sistemas operativos, de esta forma las aplicaciones Java se ejecutarán de una manera muy similar a las aplicaciones de otros lenguajes (C, C++, Pascal, etc.…), todas las llamadas a la Máquina Virtual serán transparentes al usuario y serán manejadas por el sistema operativo. Esto es similar a lo que ocurre cuando un navegador carga un applet y lo ejecuta en la Máquina Virtual de forma automática. Similitudes y diferencias entre Java y C++ Se debe indicar que existen pocas diferencias entre Java y C++, al menos en cuanto al aspecto del código fuente al menos. Las diferencias, gratas en algunos puntos e ingratas en otros, comenzamos a avistarlas cuando profundizamos en el lenguaje. Podremos rentabilizar la inversión de tiempo y esfuerzo invertidos en aprender C++ y controlar la programación orientada a objetos. Todos estos conocimientos serán aprovechables por el programador en Java, sin embargo no es cierto que para conocer Java se debe estudiar previamente C/C++, Java es un lenguaje por sí mismo. Las cadenas de Java no son punteros a cadenas de caracteres como en C/C++, ya que Java no soporta punteros. Este modo de concebir las cadenas libera al programador de la engorrosa manipulación de cadenas de C/C++. Para manejar cadenas en una aplicación Java disponemos del tipo de dato String, que no es más que una clase definida en el sistema. Los archivos .class funcionan en cualquier máquina, ya que el intérprete encargado de ejecutarlos está codificado de forma nativa en el sistema receptor de la aplicación. Para lograr lo anteriormente expuesto Java es interpretado, por lo que la velocidad de los ejecutables (que realmente no lo son) es menor que la que lograríamos con el mismo código en C++ (de 10 a 20 veces mayor). Esto no debe preocuparnos, ya que diferentes tecnologías consiguen disminuir esta diferencia llegado, en algunos casos, a igualar la velocidad de C++. De entre estas tecnologías destaca la compilación Just-in-time, que permite la conversión en tiempo de ejecución a instrucciones nativas de la máquina en la que se estén ejecutando los bytecodes. Dispondremos de una inmensa jerarquía de clases diseñadas para la creación de aplicaciones en la Web. Jerarquía probada y en constante crecimiento. Sun Microsystems facilita gratuitamente una copia del JDK del producto (acorde al sistema operativo bajo el que funcionará), con todos los elementos necesarios para crear aplicaciones con Java. La distribución del intérprete no es necesaria si estamos distribuyendo una miniaplicación (applet) enlazada a una página Web, ya que el navegador correspondiente sería capaz de realizar una compilación Just-in-Time del applet. En caso de no ser así y sí necesitar el intérprete, éste sería de libre distribución. Otra diferencia notable es que Java no soporta la herencia múltiple, es decir, no puede heredar de varias clases, sin embargo C++ si soporta heredar de varias clases padre. Se puede decir que Java ofrece una Programación Orientada a Objetos simplificada en este aspecto. Versiones del lenguaje La última versión del lenguaje Java es lo que se denomina Plataforma Java 2 (Java 2 Platform) que se corresponde con las dos últimas versiones de la herramienta de desarrollo de Sun Microsystems, es decir, con el JDK (Java Development Kit) 1.2 y el JDK 1.3, este último de muy reciente aparición. Anteriormente había una correspondencia entre la versión del lenguaje Java y la versión de la herramienta JDK, así la versión 1.1 de Java se correspondía con la versión 1.1 del JDK. 26 © Grupo EIDOS 2. Introducción al lenguaje Java Ahora vamos a comentar las correspondencias entre las versiones de Java y las distintas herramientas de desarrollo de las que vamos a tratar en este curso. Aunque desde este momento se debe aclarar que este curso no está enfocado a la utilización de ninguna herramienta de desarrollo de terceros como Borland JBuilder o Microsoft Visual J++, sino que se trata la versión estándar del lenguaje, es decir, la que ofrece Sun con su JDK, y en este caso se trata del JDK 1.3, aunque todo lo que vamos a ver es aplicable también al JDK 1.2. La herramienta de desarrollo de Java de la compañía Microsoft, Visual J++ 6.0, soporta la versión 1.1 del lenguaje. Esta herramienta puede interesarnos si lo que vamos a utilizar es la versión 1.1 de Java, esto no es ninguna contradicción, ya que la propia Sun sigue ofreciendo una versión del JDK para la versión 1.1 de Java, se trata del JDK 1.1.8. La versión 1.1 de Java sigue estando vigente debido a la rápida evolución que está sufriendo el lenguaje. Algunos de los ejemplos ofrecidos en el curso no funcionarán dentro de Visual J++ ya que se corresponderán con nuevas características de Java, de todas formas esta situación se le indicará al lector cuando se produzca. La herramienta de desarrollo Borland JBuilder 3.5, de la compañía Inprise, implementa la Plataforma Java 2, equiparándose a la herramienta de Sun JDK 1.2. Si el lector quiere utilizar la última versión de Java es recomendable que utilice JBuilder 3.5. Además en diversos estudios comparativos entra distintas herramientas de desarrollo del lenguaje Java, Borland JBulider ha sido casi siempre la mejor considerada. El lenguaje Java todavía no ha tenido una versión definitiva ni estable, cosa que supone un grave inconveniente para los sufridos desarrolladores, que tenemos que estar actualizándonos continuamente. Según se ha comunicado desde Sun Microsystems, la versión Java 2 Platform es la versión definitiva del lenguaje, esperemos que esto sea cierto, ya que desde mediados/finales del año 1996 se han sucedido un gran número de versiones, y el seguimiento y aprendizaje del lenguaje resulta verdaderamente agotador y desconcertante. Entornos de desarrollo Como ya hemos dicho a lo largo de este capítulo vamos a comentar en el curso tres herramientas de desarrollo distintas para utilizar en la realización de nuestros programas en Java, aunque siempre utilizando el estándar del lenguaje Java. La herramienta de desarrollo oficial de Java es el JDK (Java Development Kit). La herramienta JDK la podemos obtener de forma gratuita desde el sitio Web que posee Sun Microsystems dedicado por completo al lenguaje Java, http://java.sun.com. Las versiones actuales de este producto son la 1.1.8, la 1.2 y la 1.3, correspondiéndose la primera con la versión 1.1 de Java y las dos últimas con la última versión denominada Java 2 Platform. Debido a que muchos fabricantes todavía no soportan la versión nueva de Java y también debido a que la nueva versión es bastante reciente, coexisten las dos versiones del lenguaje. Sun Microsystems no nos lo pone fácil con las nomenclaturas de versiones y de productos, y si acudimos a su sitio Web para descargar el JDK, vemos que no aparece la versión 1.2 ni la 1.3. Esto es debido a que el JDK se encuentra incluido en lo que se denomina Java 2 SDK (Software Development Kit). De esta forma si deseamos la versión 1.2 del JDK veremos descargar el producto Java 2 SDK Standard Edition v 1.2, y si lo que deseamos es tener el JDK 1.3 debemos conseguir el Java 2 SDK Standard Edition v 1.3. A los efectos del presente curso las dos versiones del Java 2 SDK son válidas. 27 Programación en Java © Grupo EIDOS El código que generemos en los ejemplos y las características del lenguaje que vamos a utilizar a lo largo de todo el curso se corresponden todas con el JDK de Sun Microsystems, es decir, vamos a utilizar Java estándar. Por lo tanto el único software completamente necesario para seguir el curso satisfactoriamente es el Java 2 SDK Standard Edition. El entorno de desarrollo ofrecido por Sun es bastante pobre, ya que se basa en modo comando, es decir, no ofrece un entorno gráfico, el código lo escribiremos con un editor de texto y luego lo podremos compilar, ejecutar, depurar, etc., con una serie de programas incluidos en el JDK, pero siempre desde la línea de comandos. Pero para mostrar el panorama actual de herramientas de desarrollo de Java se ha decido incluir dos entornos de desarrollo más. Además estos entornos son más amables de utilizar que el ofrecido por Sun, ofreciendo cada uno de ellos un interfaz gráfico que permite que el desarrollo de aplicaciones Java sea más sencillo y rápido. Una de estas herramientas de desarrollo que vamos a comentar en este curso es, como ya hemos adelantado, Microsoft Visual J++ 6.0. Esta herramienta forma parte de la suite de herramientas de Microsoft Visual Studio 6.0. Microsoft Visual J++ 6.0 ofrece un entorno de desarrollo amigable. Sin embargo, como ya habíamos comentado anteriormente, el JDK ofrece un entorno de desarrollo bastante árido, el editor que se propone es el Edit de MS-DOS o cualquier otro editor de texto que no genere un formato para el texto. El entorno de compilación y depuración es bastante pobre y además se basa completamente en la línea de comandos de MS-DOS. El mayor inconveniente que presenta Visual J++ 6.0 es que en algunos casos puede generar código Java que no pertenece al estándar del lenguaje. Pero en este curso se va a tratar el lenguaje Java estándar no la implementación particular de Microsoft. Se podría decir que vamos a ver el lenguaje Java 100% de Sun. Aunque no utilicemos la implementación que realiza Microsoft del lenguaje, nos podemos beneficiar del entorno de desarrollo que ofrece Microsoft, que como ya hemos dicho es mucho más fácil de utilizar y más amigable que el ofrecido por Sun. A lo largo del curso comentaremos en detalle Visual J++ 6.0 y cómo debemos utilizarlo para generar código Java completamente estándar. Pero el mayor inconveniente que presenta Visual J++ 6.0 es que recoge únicamente hasta l versión 1.1 del lenguaje Java, esto en algunos casos puede ser suficiente, pero veremos que en otros no, sobre todo si queremos utilizar las nuevas características de Java 2, como pueden ser la utilización de componentes avanzados (Swing) para construir interfaces de usuario o el acceso a datos mejorado que ofrece a través de JDBC 2.0. Otro punto en contra de Visual J++ es que ofrece un entorno gráfico, pero no es todo lo gráfico que se podría desear, es decir, no permite construir interfaces de usuario al modo de otras herramientas como pueden ser Visual Basic o Delphi, dónde podemos arrastran controles o elementos del interfaz de usuario y situarlos en el lugar deseado, sino que todo lo debemos hacer a través de programación sin que Visual J++ genera una única línea de código fuente. Podemos decir que el segundo entorno de desarrollo utilizado en este curso Borland JBuilder 3.5 soluciona las dos deficiencias que plantea Visual J++. Por un lado ofrece la versión del lenguaje correspondiente a la Java 2 Platform(Plataforma Java 2) y un entorno de desarrollo que permite la creación visual de interfaces de usuario con generación de código Java incluida. 28 © Grupo EIDOS 2. Introducción al lenguaje Java De todas formas en los sucesivos capítulos veremos con más detenimiento cada uno de estos entornos de desarrollo. Características de la plataforma Java 2 Este apartado muestra de forma general las características que incluye el lenguaje Java en su última versión y que han ido evolucionando desde la versión 1.0. El contenido de este apartado es a modo informativo, el lector no tiene porque comprender los términos que se van a utilizar en este apartado. Este apartado puede ser útil a lectores que ya conozcan algunas de las versiones anteriores del lenguaje y también nos sirve para observar las nuevas características que ha ido implementando el lenguaje. • Internacionalización: permite el desarrollo de applets localizables, es decir, un mecanismo de localización sensible a la hora y fecha locales. Se incluye también la utilización de caracteres Unicode. Unicode tiene la capacidad de representar unos 65.000 caracteres, un número bastante amplio para incluir los caracteres de la mayoría de los lenguajes hablados hoy en día. • Seguridad y firma de applets: el API (aquí entendemos como API un conjunto de clases más o menos complejo que cumplen una funcionalidad común) de