Manual+Java+UML+Básico

INSTITUTO DE TECNOLOGÍA Y COMPUTACIÓN

MANUAL de JAVA y UML Básico

2006

CESAR ROJAS MORAGA RELATOR

Índice Introducción .............................................................................................................................3 CAPITULO 1: INTRODUCCION ..............................................................................................4 Introducción...........................................................................................................................5 Aspectos Históricos ...............................................................................................................6 ¿Qué es Java?.........................................................................................................................8 Evolución de las Versiones de Java .......................................................................................9 CAPITULO 2: PROGRAMACION ORIENTADA A OBJETOS...............................................10 Principios de la Orientación a Objetos ................................................................................11 CAPITULO 3: ELEMENTOS DEL LENGUAJE JAVA .............................................................13 Errores de Programación .....................................................................................................14 Edición, Compilación y Ejecución de Programas ...............................................................16 Elementos Básicos ...............................................................................................................21 Control de Flujo ...................................................................................................................28 Control de Excepciones .......................................................................................................29 Try – Throw – Throws - Catch - Finally ............................................................................32 CAPITULO 4: PROGRAMACION ORIENTADA A OBJETOS CON JAVA............................34 Abstracción (Aplicado)........................................................................................................35 Encapsulamiento (Aplicado) ...............................................................................................36 Herencia (Aplicado).............................................................................................................37 Polimorfismo (Aplicado) .....................................................................................................40 CAPITULO 5: INTRODUCCIÓN A UML ...............................................................................43 CAPITULO 6: PAQUETES DE JAVA......................................................................................44 Introducción.........................................................................................................................45 Paquetes y Directorios .........................................................................................................46 CAPITULO 7: MANEJO DE ARCHIVO EN JAVA..................................................................53 Introducción.........................................................................................................................54 Flujos ...................................................................................................................................55 Jerarquía de Clases ..............................................................................................................56 FileInputStream y FileOutputStream...................................................................................57 Ejemplo Introductorio FileInputStream...............................................................................58 Ejemplo Introductorio FileOutputStream............................................................................60 Ejemplo Introductorio FileReader .......................................................................................61 Ejemplo Introductorio FileWriter ........................................................................................62 CAPITULO 8: APPLETS.........................................................................................................64 Introducción a los Applets de Java ......................................................................................65 Applets .................................................................................................................................66 CAPITULO 9: INTERFASES GRÁFICAS DE USUARIO EN JAVA.......................................74 Eventos ..............................................................................................................................110 La Clase Event ...................................................................................................................111

2

Introducción Java se ha convertido hoy en día en uno de los lenguajes de programación más importantes, sobre el cual se están desarrollando aplicaciones de variadas índoles, como por ejemplo, aplicaciones Web, aplicaciones para dispositivos electrónicos, incluso para proyectos de robótica avanzada. El enfoque que tiene el curso es dar una capacitación en el lenguaje en sí, demostrando que la programación orientación a objeto es fácil de entender mientras se programe y se trabaje directamente en el código.

3

MANUAL DE JAVA CAPITULO 1: INTRODUCCION

4

Introducción El lenguaje de programación que utiliza Java es netamente orientado a objeto, el nivel sintáctico es muy similar a C y C++. Contiene clases que pueden manipular los tipos de variables de manera fácil, además posee un control del flujo de fácil manejo. A continuación presentaremos la Historia y comenzaremos a entrar en profundidad en el lenguaje Java.

5

Aspectos Históricos Hace ya muchos años, por allá por fines de los 60, Martin Richards desarrollo un lenguaje de programación denominado “BCPL”, el cual estaba orientado principalmente para la programación de Sistemas Operativos y compiladores. En 1970, Kem Thomson presentaba su lenguaje, denominado “B”, en el cual se escribieron las primeras líneas del sistema operativo UNIX, este lenguaje fue desarrollado en los laboratorios AT&T DELL Laboratorios en un computador DEC PDP-7. En los mismos laboratorios, en 1972, pero en un computador DEC PDP-11, Dennos Ritchie desarrolla “C”, lenguaje que incorpora a los lenguajes BCPL y C, obteniendo lo mejor de ambos, es así como “C” comienza a ser pilar fundamental en la programación del código fuente de UNIX. Para 1978, la editora Prentice Hall, publica el libro “The C Programming Languaje”, libro que ha sido el más vendido en la historia de los libros informáticos, con ésta fama, C se convierte en el lenguaje preferido para desarrollar aplicaciones y diferentes tipos de sistemas y programas, el problema surge porque C es de “open source”, por lo tanto existieron tantas versiones como aplicaciones, que prontamente se hicieron incompatibles entre ellas, es por esto que en 1983, se realiza una congregación, denominada la X3J11, bajo la supervisión de la ANSI, en donde se comienzan a desarrollar las referencias del lenguaje, para que los desarrolladores tengan a que atenerse para no perder el estándar. Es así como para el año 1989 es aprobado el estándar de C, bajo el nombre de ANSI/ISO 9899:1990. Por el año 1980, Bjarne Stroustrup, comienza a incluir dentro de la programación estructurada de C, una nueva e interesante capacidad, la orientación a objeto, dando como resultado la versión avanzada de C, conocida como C++, ésta versión es un Híbrido, pues permite desarrollar de manera estructurada como en C y también de manera orientada a objeto, es decir con clases. Dentro de las grandes empresas desarrolladoras de tecnología, se encontraba Sun Microsystem, la cual tenía a su haber el sistema operativo Solaris y también la Arquitectura SPARC. Ésta empresa financia a comienzos de los 90 un proyecto denominado GREEN, bajo el mando de James Gosling, el proyecto tenía como meta desarrollar tecnología para el manejo de los dispositivos electrónicos nuevos que aparecerían en el mercado, pues Sun esperaba obtener grandes proyectos, y con ellos, obtener ventaja de la gran expansión tecnológica que vendría con los dispositivos electrónicos.

6

James Goblin y su equipo, desarrollaron un lenguaje de programación que denominaron “OAK” que significa Roble en Inglés, pues se cuenta que desde su ventana en las oficinas de Sun Microsystem, él puede ver un roble que esta en el patio. El problema surge por que ya existía una empresa con un lenguaje denominado “OAK”, con lo cual el equipo de James Goblin debió cambiar el nombre de su lenguaje de programación. La historia cuenta que le denominaron JAVA por el café que tomaban a la hora de descanso durante el desarrollo del lenguaje, otra teoría cuenta que es por el café que le servían a Goblin y su equipo en una cafetería cercana a las oficinas de Sun Microsystem. El tema principal es que la gran explosión de dispositivos electrónicos que esperaba la Sun nunca existió, además que parte de los proyectos que esperaban fueron otorgados a otras empresas, por lo cual se vio gravemente afectado el proyecto GREEN, a tal punto de ser casi clausurado. Pero Goblin no se vería disminuido por lo sucedido, así que, con astucia, volcaron JAVA al desarrollo de aplicaciones Web, debido a que a comienzos de los 90, la WWW alcanzó niveles de desarrollo insospechados, es así como en 1995, Sun Microsystem, presenta al mundo su primera versión de JAVA, la versión 1.0, maravillando al mundo con el dinamismo que le otorgaba a las estáticas páginas Web predominantes en esos años. Nace así, una de las tecnologías más admiradas y venerada de los últimos años, además que la explosión de los dispositivos electrónicos llegó con el tiempo, JAVA ha comenzado a ocupar espacios que ningún otro lenguaje lo había logrado. Permaneciendo así en Celulares, Pocket PC, Palms, Robots, Servidores Web, etc.

7

¿Qué es Java? El significado de Java, tal y como se le conoce en al actualidad, es el de un lenguaje de programación y un entorno para ejecución de programas escritos en lenguaje Java. Al contrario de los compiladores normales que convierten el código fuente a instrucciones a nivel de máquina, el compilador traduce el código fuente Java a Bytecode, instrucciones que son interpretadas por una Máquina Virtual de Java, conocida como la JVM (Java Virtual Machine). Java se ha convertido en el lenguaje de programación de Internet por excelencia, debido a que trata de resolver problemas de Internet con contenidos de Internet. • •

En la actualidad, el contenido de la WWW es pasivo y estático. La entrega (Delivery) del contenido WWW es dependiente de la configuración de cada navegador Web de usuario.

Para el mundo Web, Java es una tecnología facilitadota que permite crear paginas Web que se entregaran de manera consistente a todos los usuarios con un navegador habilitado para java y con independencia de a plataforma hardware que se este utilizando. Toda esta maravilla la permite la JVM y se explica en este gráfico a continuación. Computador Servidor (Host)

Computador Local Sistema Operativo Navegador Java Máquina Virtual Java

Código Fuente

Código Nativo Java

En ésta figura, cuando una maquina se conecta a un servidor, éste le transfiere el código nativo de java al computador del usuario para que la maquina virtual lo ejecute en el navegador del mismo, indistintamente el hardware que posea el computador del usuario. Actualmente, para cada Sistema Operativo, existe una Maquina Virtual para descargar, además que Java es un Kit de Desarrollo gratis, el cual se puede descargar desde la página de sus creadores y dueños, www.sun.com/java/.

8

Evolución de las Versiones de Java Existen dos grandes especificaciones actualmente en entorno Java: J2EE Está orientada a al desarrollo de aplicaciones de propósito empresarial o para servidores y son numerosos los grandes fabricantes (IBM, Nokia, Motorola, HewtlettPackard…) que lo soportan con especificaciones comunes. Actualmente J2EE se ha convertido en un autentico estándar, reconocido por la industria. J2ME Es un nuevo estándar para dispositivos inalámbricos (móviles, de bolsillo o de mano (handhelds)) que requieren una integración en dispositivos con poco espacio físico y memoria de trabajo. La versión J2SDK, es un Kit de Desarrollo Estándar, el cual permite comenzar a desarrollar aplicaciones de aprendizaje previo al desarrollo profesional de aplicaciones en J2EE. Versiones La versión original de Java que se comercializó y se expandió rápidamente fue la 1.0, posteriormente aparece la 1.1, que para muchos fue un salto bastante importante dentro del desarrollo de las capacidades del lenguaje, salto que no se representaba con un aumento de un dígito. Posteriormente la versión 2, con sus diferentes kit de desarrollo, ha servido para asentar la eficiencia y calidad de Java. Se puede considerar que Sun ha lanzado al mercado seis versiones importantes del lenguaje Java: Java 1.0

1995, pequeña versión centrada en la Web, disponible uniformemente para todos los navegadores Web populares. Java 1.1 1997, mejora la interfaz de usuario, manipulación de eventos o sucesos, reescrito totalmente, y una tecnología de componentes denominada JavaBeans. Java 2 con SDK 1998, versión ampliada significativamente, incluye una nueva 1.2 interfaz gráfica de usuario, conectividad a bases de datos y muchas otras mejoras. Java 2 con SDK 2000, añade características notables como multimedia 1.3 mejorada, más accesibilidad y compilación más rápida. Java 2 con SDK 2001, introduce la posibilidad de trabajar con XML 1.4 Java 2 con SDK 1.5

9

MANUAL DE JAVA CAPITULO 2: PROGRAMACION ORIENTADA A OBJETOS

10

Principios de la Orientación a Objetos Todos los programas de computadora constan de dos elementos: código y datos. Sin embargo, un programa se puede organizar conceptualmente alrededor de su código o alrededor de sus datos. Existen dos paradigmas que controlan el modo en que se construye un programa. Los programas que se escriben alrededor de “lo que esta sucediendo” (paradigma procedimental u orientado a procesos); este enfoque caracteriza un programa como una serie de etapas lineales, es decir, código. El otro enfoque dice que los programas se pueden escribir alrededor de “quien está siendo afectado” (paradigma orientado a objetos). Este paradigma es la base de Java. La Programación Orientada a Objeto (de ahora en adelante POO), está en el núcleo de Java. De hecho, todos los programas en Java son orientados a objetos. La idea principal de un sistema orientado a objetos es un conjunto de objetos que interactúan entre sí y que están organizados en clases. Todos los lenguajes de POO proporcionan mecanismos que ayudan a implementar el modelo orientado a objetos. Estos principios o propiedades fundamentales son: abstracción, encapsulamiento, herencia y polimorfismo. Abstracción: • Es un elemento fundamental de la POO • Las personas gestionamos la complejidad a través de la abstracción. o Por ejemplo, las personas andamos en un auto sin importar como este trabaja internamente, sabemos conducirlo, pero muchas veces no nos importa como funciona su motor, el aire acondicionado, los freso, la caja de cambio etc., solo nos importa el auto como un todo. • La abstracción es el proceso de capturar los detalles fundamentales de un objeto mientras se suprimen o ignoran los detalles. o Por ejemplo, si tenemos que ir de un sitio A a un sitio B en el vehículo del ejemplo anterior, no nos vamos a concentrar en como funciona el motor o las partes tecnológicas del auto, solo nos vamos a concentrar en acelerar, virar a la derecha o izquierda por el camino, nada más. • La noción de abstracción entraña la descomposición de un sistema complejo o complicado en sus partes más fundamentales y describir estas partes en un lenguaje sencillo y preciso. • La abstracción se puede presentar como un Tipo Abstracto de Dato (TAD), lo que quiere decir que es un modelo matemático de una estructura de dato que especifica el tipo de dato almacenado, las operaciones soportadas pro ellos y tipos de los parámetros de las operaciones. • Un TAD especifica qué hace cada operación, pero no cómo lo hace. • En Java, un TAD se puede expresar como una interfaz que normalmente es una lista de declaraciones de métodos.

11

Encapsulamiento • Es sinónimo de ocultación de información. • Es el proceso de ocultar todos los detalles de un objeto que no contribuyen a sus características esenciales. • El usuario de un objeto nunca necesitará conocer el interior de una clase. • Como ventaja, el encapsulamiento proporciona al programador libertad en la implementación de los detalles de un sistema. La única restricción que tendrá el programador es mantener la interfaz abstracta que ven los usuarios externos. • Encapsulamiento, desde un punto de vista más técnico, es el mecanismo que enlaza juntos código y los datos que los manipulan y los mantienen seguros de interfaces externas y mal uso. • Se puede pensar en encapsulamiento, como el envoltorio que encierra al código y a los datos. • En Java, los fundamentos de la encapsulación están en la clase. Una clase define la estructura y el comportamiento (datos y código) que se compartirá por un conjunto de objetos. • Cuando se crea una clase, se especifica el código y los datos que constituyen esa clase, a estos elementos se les llama miembros de la clase. Estos miembros pueden ser públicos o privados dentro de la misma clase. Así que comúnmente se utilizan métodos públicos para manipular los datos de la clase que son privados. Herencia • Herencia es el proceso mediante el cual un objeto adquiere las propiedades de otro objeto. Por ejemplo, un pastor alemán es parte de la clase perro, y a su vez es parte de la clase mamífero, que a su vez es de la clase animal. • Sin el uso de la herencia, el objeto necesitaría definir todas las características nuevamente. Sin embargo, usando herencia, un objeto solo necesita definir aquellas cualidades que lo hace único dentro de la clase. • Las nuevas clases pueden heredar atributos generales de su clase padre o clase base, también denominada superclase. Animal

Mamífero

Perro • Muchas personas ven en la naturaleza como un conjunto de objetos están relacionados entre sí de manera jerárquica. • En la POO se pueden derivar o extender nuevas clases de otras clases existentes. Esta propiedad se denomina herencia. 12

• La herencia es un concepto poderos de Java. De hecho cada clase que se define en Java se hereda de una clase existente, bien explicita o implícitamente. Polimorfismo • Proviene del griego polymorphos, que significa “muchas formas” • En la práctica, es la propiedad que permite enviar el mismo mensaje a objetos de diferentes clases (totalmente diferentes). Del mismo modo cada objeto responde a ese mensaje de manera distinta, dependiendo de su implementación. • El polimorfismo como sobrecarga (en Java) ocurre cuando una clase X tiene múltiples métodos con el mismo nombre, cada uno de ellos con una signatura distinta, por ejemplo. o public double getDistancia() o public double getDistancia(double x, double y) En este caso, tenemos dos métodos con el mismo nombre, pero con argumentos distintos. • La signatura de un método es una combinación de nombre y tipo de argumentos de un método. • El polimorfismo se aplica sólo a métodos que tienen la misma signatura pero están definidos en clases diferentes. • Herencia, polimorfismo y sobrecarga de métodos soportan el desarrollo de software reutilizable.

MANUAL DE JAVA CAPITULO 3: ELEMENTOS DEL LENGUAJE JAVA

13

Errores de Programación Los errores de programación son inevitables, incluso para programadores experimentados. El proceso de corregir un error (bug en inglés) se denomina depuración (debugging) del programa. Cuando se detecta un error en Java, se visualiza un mensaje de error que devuelve la posible causa del error. Desgraciadamente los errores no siempre se detectan y los mensajes de error no siempre son fáciles de interpretar. El ciclo de Editar-Compilar-Ejecutar junto con la depuración paso a paso de los errores observados y fijados en los programas se pueden observar en la siguiente figura. Editar y crear un nuevo archivo .java

Compilar

Errores

Editar y corregir errores de compilación

No existen errores Ejecutar Programa

Editar para corregir o ampliar

Los mensajes de error que produce el compilador no siempre ayudan a encontrar los errores. Una mezcla de las advertencias del compilador, manual de instrucciones y sobre todo la experiencia del programador, serán quienes proporcionen el conocimiento suficiente para llegar a depurar programas con éxito. Existen tres tipos de errores: errores de compilación (sintaxis), errores de ejecución y errores lógicos. Errores de Compilación • Este tipo de errores ocurren cuando el código viola un o más reglas gramaticales de Java. • Estos errores los detecta el compilador. • Ejemplo: utilizar una variable que no se ha definido previamente. Errores de Ejecución

14

• • • • •

Este tipo de errores aparecen cuando el sistema termina de forma anormal y que se detectan y visualizan durante la ejecución del programa. Un error de ejecución se produce cuando el usuario instruye a la computadora para que ejecute una operación no válida. Ejemplo: realizar una división por cero. Un error de entrada ocurre cuando el usuario introduce un valor de entrada imprevisto que el programa no puede manejar. Ejemplo: si el programa espera un número y el usuario ingresa una cadena de caracteres.

Errores Lógicos • Los errores lógicos ocurren cuando un programa realiza un algoritmo incorrecto y no ejecuta la operación que estaba prevista. • Son complicados de detectar, pues no se avisan como los errores de compilación, además pueden no producir un término anormal del programa. • Generalmente se detectan cuando se observan los valores de salida del programa.

15

Edición, Compilación y Ejecución de Programas Los programas escritos en java, pueden ser editados desde cualquier editor de texto, y ejecutados desde una línea de comandos cualquiera, a continuación presentaré un ejemplo sencillo de nuestro primer programa en Java. Primeramente, editamos el texto en Java y lo guardamos como Holamundo.java. class Holamundo{ static public void main(String [] args){ System.out.println("Hola mundo, este es el primer ejemplo en java"); } } Posteriormente a esta edición, preparamos las variables de entorno para poder compilar nuestro programa y ejecutarlo en cualquier directorio en el que se encuentre; NOTA: al utilizar algún editor, sea este Netbeans, JCreator, Eclipse, Visual age, etc, no es necesario realizar el paso que explicaré a continuación debido a que los editores por lo general encuentran la ruta al JDK de manera automática, por ende, nos permiten a través de botones, realizar la compilación y ejecución de nuestros programas. Para ello, obtenemos las propiedades de Mi PC

16

Chiqueamos en la pestaña de “Opciones avanzadas” y presionamos en el botón de “Variables de Entorno”

17

Esta ventana nos permite editar las variables que permanecerán en el entorno de Windows, permitiéndonos así utilizarlas desde cualquier directorio en nuestro computador. Seleccionamos la variable Path y chiqueamos en “Nueva”

Ingresamos el nombre de la variable como “java” y como valor de la variable, ponemos la dirección de la carpeta “bin” en el JDK de Java.

18

La ventana nos quedaría de la siguiente forma, posteriormente aceptamos

y volvemos a aceptar en la ventana de propiedades de Mi PC, con esto, podremos compilar nuestro archivo Holamundo.java.

Si revisamos el directorio veremos que solo esta nuestro archivo Holamundo.java, ahora procederé a compilar el archivo con el comando “javac”.

19

Si volvemos a revisar nuestro directorio, observaremos que el compilador de java genera un archivo en bytecode, este archivo se crea como Holamundo.class.

Para ejecutar nuestro archivo en bytecode con la Maquina Virtual de Java, lo hacemos con el comando “java”.

Lo que realizamos se explica en este gráfico: Holamundo.java

Javac Holamundo.java

Holamundo.class (en Bytecode)

Java Holamundo (Solaris)

Java Holamundo (Windows)

Java Holamundo (Otra Maquina y S.O.)

Esto nos demuestra que Java es multiplataforma, ya que su JVM ejecuta su Bytecode en cualquier máquina en la cual este instalada.

20

Elementos Básicos Comentarios Los comentarios en Java se pueden anotar de dos maneras: //comentario de una sola línea /* Comentario de un bloque */ Palabras Reservadas Las palabras reservadas son palabras que tiene un determinado significado para el compilador y no pueden ser utilizadas para otros fines. Por ejemplo la palabra “import” le indica al compilador que se necesita realizar una importación. El listado de las palabras reservadas de Java se presenta a continuación:

Modificadores Existen palabras reservadas que Java denomina “Modificadores”, las cuales especifican las propiedades de los datos, métodos y clases. Por ejemplo: public, private, static, final, abstract, protected Public: Modificador que permite visualizar las variables y métodos desde cualquier otro paquete de clases o clase. Private: Modificador que impide visualizar las variables o métodos desde otras clases y paquetes, solo se pueden manipular las variables o métodos con este modificador dentro de la misma clase. Static: Modificador que indica que las variable so métodos declarados, permanecerán estáticos bajo la misma clase, es decir que si tengo una variable declarada de manera estática, y es modificada, se modificará a todos los miembros de la clase. Final: Modificador que declara constantes 21

Abstract: Modificador que declara clases y métodos que se declaran de manera abstracta. Protected: Modificador que permite a miembros de una misma clase o paquete a obtener la variables y métodos declarados como protegidos, pero las clases que se encuentran fuera del paquete, no podrán acceder a las variables y métodos protegidos. Sentencias Una sentencia representa una acción o una secuencia de acciones, cada sentencia termina con un punto y coma (“;”), ejemplos de sentencias: int c=0; System.out.println (“Hola mundo”); Bloques Un bloque es una estructura de programa que agrupa sentencias. Los bloques comienzan con una llave de apertura ({) y cierran con una llave de cierre (}), por ejemplo: if (a