II Curso Online JAVA-J2EE

TEMA 1

Introduccin a Java

Autor: PCYTA / Centro de Excelencia de Software Libre de Castilla-La Mancha Versin: 1.0 Fecha: Revisado 07-02-2008 11:46 Licencia: CC-by-sa 2.5

0 Licencia
Usted es libre de: Copiar, distribuir y comunicar pblicamente la obra
Hacer obras derivadas

Bajo las condiciones siguientes:

Reconocimiento. Debe reconocer los crditos de la obra de la manera especificada por el autor o el licenciador (pero no de una manera que sugiera que tiene su apoyo o apoyan el uso que hace de su obra). Compartir bajo la misma licencia. Si altera o transforma esta obra, o genera una obra derivada, slo puede distribuir la obra generada bajo una licencia idntica a sta.

Al reutilizar o distribuir la obra, tiene que dejar bien claro los trminos de la licencia de esta obra. Alguna de estas condiciones puede no aplicarse si se obtiene el permiso del titular de los derechos de autor Nada en esta licencia menoscaba o restringe los derechos morales del autor.

Para ver la licencia visite: http://creativecommons.org/licenses/by-sa/2.5/es/legalcode.es

6 de febrero de 2008

Tema 1

UNIDAD I. INTRODUCCIN A JAVA

0 Usted es libre de:............................................................................................................................2 Bajo las condiciones siguientes:.................................................................................................. 2 1 Introduccin a Java....................................................................................................................... 5 1.1 POO. Clases y Objetos..............................................................................................................5 1.2 POO. Herencia.......................................................................................................................... 5 1.3 Polimorfismo............................................................................................................................ 6 1.4 Ventajas de la POO................................................................................................................... 6 1.5 Java: caractersticas generales...................................................................................................7 1.6 Visin de la plataforma Java..................................................................................................... 7 2 Conceptos bsicos de programacin con Java............................................................................ 9 2.1 Diseccionando el programa HolaMundo.................................................................................. 9 2.2 Tipos de datos, variables y Arrays.......................................................................................... 11 2.2.1 Tipos de Datos..................................................................................................................11 2.2.2 Variables.......................................................................................................................... 12 2.2.3 Arrays.............................................................................................................................. 12 2.3 Operadores, expresiones y control de flujo............................................................................ 13 2.3.1 Operadores....................................................................................................................... 13 2.3.2 Expresiones......................................................................................................................13 2.3.3 Control de flujo................................................................................................................13 2.4 Objetos y clases...................................................................................................................... 15 2.5 Herencia.................................................................................................................................. 19 2.6 Interfaces................................................................................................................................ 20 3 Clases y Paquetes en Java........................................................................................................... 23 3.1 Concepto de paquete. Paquetes bsicos.................................................................................. 23 3.1.1 Concepto de paquete........................................................................................................ 23 3.1.2 Paquetes bsicos...............................................................................................................24 3.2 Gestin de Excepciones.......................................................................................................... 24 3.3 I/O (Entrada/Salida)...............................................................................................................26 3.4 GUI Interfaces Grficos.......................................................................................................27 3.5 Gestin de Hilos..................................................................................................................... 28 4 Java Avanzado..............................................................................................................................31 4.1 Libreras: Generacin y Utilizacin........................................................................................ 31 4.2 Internacionalizacin (I18n).....................................................................................................32 4.3 Instrospection y Reflection.....................................................................................................35 4.4 Seguridad................................................................................................................................36 4.5 Rendimiento............................................................................................................................39 6 de febrero de 2008 Tema 1 3

4.6 Testing (JUnit)........................................................................................................................ 40 4.7 Caractersticas de la versin J2SE 5.0................................................................................... 42 4.8 Patrones de diseo Java.......................................................................................................... 46 5 IDEs (Integrated Development Environment).......................................................................... 48

6 de febrero de 2008

Tema 1

1IntroduccinaJava
1.1POO.ClasesyObjetos
Objetos: o Elementos que comparten dos caractersticas: el estado y el comportamiento. o Objeto como una pieza de programacin que mantiene un estado mediante los atributos y que expone su comportamiento mediante los mtodos. Encapsulacin: Permite ocultar el estado interno del objeto y ofrece maneras de interactuar con el mediante los mtodos. Clase: Es un conjunto de objetos con propiedades (atributos y/o mtodos) comunes. Por lo tanto, una clase muestra el comportamiento general de un grupo de objetos. Clase y objeto son dos conceptos interdependientes .Un objeto pertenece a una clase y una clase contiene objetos. La pertenencia de un objeto a una clase se dice que es una instanciacin de dicha clase en ese objeto. Todos los objetos instanciados en una clase son similares, y difieren en los valores que toman sus atributos. La definicin de una clase permite que los atributos y los mtodos compartidos se definan una sola vez, en la clase, y no en cada uno de los objetos.

1.2POO.Herencia
La herencia es la propiedad por la cual las subclases asumen como propios los atributos y mtodos definidos en las superclases. O dicho de otra forma, herencia es la capacidad de un objeto (clase) para utilizar las estructuras y los mtodos existentes en antepasados o ascendientes. Utilidad:

conseguir una mayor reutilizacin de cdigo (no ser necesario volver a programar los mtodos que se definieron en las clases superiores) y tener un mejor control de los errores pues si lo heredado ya est probado los nuevos errores deben encontrarse en el nuevo cdigo de las subclases que heredan.

Tipos de herencia

Herencia simple: un tipo derivado se crea a partir de una nica clase base.

6 de febrero de 2008

Tema 1

Herencia mltiple: una clase tiene ms de un ascendiente inmediato.

La herencia mltiple presenta problemas de colisin cuando las superclases tienen las mismos atributos y/o mtodos definidos Java nicamente permite la herencia simple

1.3Polimorfismo
Se define polimorfismo como la capacidad de que una variable cambie su comportamiento dependiendo del objeto al que haga referencia. Esta propiedad permite que varios objetos de diferentes subclases sean tratados como objetos de una nica superclase, y que automticamente se seleccione el mtodo adecuado a ejecutar dependiendo de la subclase a la que pertenezca. (Se implementa cuando en la superclase definimos un mtodo abstracto que heredan las subclases, las cuales lo implementan de distinta manera (mismo nombre))

1.4VentajasdelaPOO
1. Enfoque ms natural: el concepto de objeto es natural e intuitivo, pues el mundo est compuesto de objetos. Tanto para el programador como para el propio usuario final es ms fcil pensar en trminos de objetos, y la comunicacin entre ambos es ms fluida. 2. Encapsulacin: la interaccin con los objetos nicamente se puede realizar mediante los 6 de febrero de 2008 Tema 1 6

3.

4.

5.

6. 7.

mtodos lo que permite mantener la implementacin interna oculta. Abstraccin: la orientacin a objetos consiste en aplicar diferentes capas de abstraccin en la modelizacin de una realidad, identificando sucesivamente los conceptos de objeto, clase y superclase en sus diferentes grados de iteracin. Reutilizacin: debido a ese proceso de abstraccin, las clases se disean para que se puedan reutilizar en muchos sistemas. En este sentido es fundamental el concepto de libreras o bibliotecas de clases. Menor acoplamiento: las aplicaciones orientadas a objetos tienen un bajo nivel de acoplamiento debido a la propiedad de encapsulacin que tienen los objetos. Ello hace que las modificaciones de un objeto no afecten a los dems. Mayor cohesin: Los objetos presentan una alta cohesin, justamente porque integran una coleccin de datos muy relacionados y los procesos susceptibles de acometerse entre ellos. Mayor capacidad funcional: el bajo acoplamiento y la alta cohesin de los objetos hacen factible que un sistema inicialmente complejo pueda ser descompuesto ms fcilmente en diferentes capas de clases y subclases, cada una con un grado de complejidad menor. Es posible desarrollar aplicaciones muy avanzadas conceptualmente pero tcnicamente sencillas.

1.5Java:caractersticasgenerales
Java es un lenguaje sencillo, orientado a objetos, distribuido, interpretado, robusto, seguro, de arquitectura neutral, portable, alto rendimiento, multihebra y dinamico.

1.6VisindelaplataformaJava
1. Como lenguaje de programacin.

Como lenguaje de programacin, Java se considera un lenguaje de alto nivel con las caractersticas enumeradas en el apartado anterior. Mediante Java se pueden crear todos los tipos de aplicaciones (aplicaciones ligeras, pesadas, para escritorio, para Internet, etc.) que se puedan realizar con cualquier otro tipo de lenguaje de programacin.

2. Como entorno de desarrollo.

Como entorno de desarrollo, Java proporciona una variada cantidad de herramientas:

6 de febrero de 2008

Tema 1

compilador (javac) interprete (java) generador automtico de documentacin (javadoc) empaquetador de libreras (jar) visor de applets (appletviewer) etc...

3. Como entorno de despliegue y ejecucin de aplicaciones.

Todas las aplicaciones Java requieren para poder ejecutarse que se encuentre instalado en la mquina destino el JRE o entorno de ejecucin Java.

Existen dos entornos de despliegue principales:

La JRE que se proporciona con la SDK (Software Development Kit) y que incluye un conjunto completo de libreras de clases (clases bsicas, para I/O, GUI, etc.). El otro entorno de despliegue y ejecucin ms conocido es el navegador web. La mayora de los navegadores (IE, Mozilla, Opera, etc) proporcionan un intrprete y el entorno de ejecucin.

4. Como plataforma comercial.

A lo largo del tiempo Java ha ido evolucionando y SUN ha ido redefiniendo los productos que ofreca. Actualmente, podemos distinguir tres tipos de plataformas ofrecidas por SUN que pretenden cubrir los distintos sistemas sobre los que pueden ejecutarse aplicaciones:

6 de febrero de 2008

Tema 1

J2ME (Micro Edition): pretende cubrir el segmento de mercado de las pequeos dispositivos como PDAs y telfonos mviles que se caracterizan por las restricciones tanto de memoria como de capacidad de procesamiento. J2SE (Standard Edition): la versin estndar es la que todos conocemos, desarrollo de aplicaciones genricas para ordenadores y servidores. J2EE (Enterprise Edition): la versin para empresas hace referencia a aplicaciones empresariales de gran calidad con procesos transaccionales, totalmente seguras y de gran rendimiento, con diferentes formas de acceso (online, offline, web, escritorio, batch, etc) e integradas con otros productos (bases de datos, entornos host, LDAP, etc). Esta versin es una ampliacin de la versin estndar.

2ConceptosbsicosdeprogramacinconJava
2.1DiseccionandoelprogramaHolaMundo
Este es el cdigo de la aplicacin:

public class HolaMundo 6 de febrero de 2008 Tema 1 9

{ /** * Primera aplicacin Java */ public static void main (String[] args) { // Muestra en la consola el texto Hola Mundo System.out.println( Hola Mundo ); } }

Revisemos las instrucciones que componen dicha aplicacin:

1. public class HolaMundo {

- Indica el nombre de la clase HolaMundo . - En Java, todo el cdigo debe encontrarse dentro de la declaracin de una clase. - La clase HolaMundo utiliza el modificador de clase public que indica que nuestra clase es accesible por cualquier otra clase incluso de diferente paquete. Estudiaremos los paquetes y los modificadores de clase en un apartado posterior del tema.

2. {

- El '{' indica el inicio de un bloque. - El bloque se finaliza con el smbolo '}' (utilizados en las lneas 8 y 9). - Se pueden anidar bloques de forma indefinida.

2. /** 3. * Primera aplicacin Java 4. */

- Estas tres lneas indican un comentario en Java. - En Java se distinguen tres tipos de comentarios:

1. Comentarios Javadoc (el de estas lneas, se utilizan para generar documentacin 6 de febrero de 2008 Tema 1 10

HTML de forma automtica con la herramienta javadoc). 2. Comentarios de estilo C++ (el que vemos en la lnea 7). 3. Comentarios de estilo C (empiezan con /* y terminan con */).

5. public static void main (String[] args) {

- Indica el nombre de un metodo en la clase HolaMundo con el nombre de main. - El mtodo main es el punto de inicio de un programa Java, desde este mtodo se llamaran a los dems mtodos que se indiquen en el mismo. - Todos los programas (excepto los Applets) se inician en el mtodo main. - Los parametros que se pasan cuando se realiza la llamada a la clase desde la lnea de comandos se encuentran en el array args.

7. System.out.println( Hola Mundo );

- Esta instruccin muestra en lnea de comandos el texto Hola Mundo . - El ';' (punto y coma) sirve para separar instrucciones.

Los ficheros en Java tienen que finalizar siempre con la extensin .java. El nombre del fichero debe coincidir con el nombre de la clase pblica que contenga. As, si la clase se llama HolaMundo el fichero donde se guarda la clase tiene que llamarse HolaMundo.java.

2.2Tiposdedatos,variablesyArrays
2.2.1TiposdeDatos
Existen dos tipos: los tipos primitivos y los tipos de referencia. Los tipos primitivos son valores propios que se mantienen en las variables, mientras que los tipos de referencia contienen valores que apuntan o identifican arrays u objetos. Tipos primitivos. 1. Enteros: almacenan nmeros enteros, sin 2. Reales: almacenan nmeros reales, es decir, parte decimal. Java proporciona cuatro tipos nmeros con parte fraccionaria. Hay dos tipos. de enteros. 6 de febrero de 2008 Tema 1 11

Tipo byte short int long

Tamao 8 bits 16 bits 32 bits 64 bits

Rango -27 a 27-1 -215 a 215-1 -231 a 231-1 -263 a 263-1

Tipo float double

Tamao 32 bits 64 bits

Rango -231 a 231-1 -263 a 263-1

3. Caracteres: en Java hay un nico tipo de carcter: char. Cada carcter en Java est codificado en formato Unicote que ocupa dos bytes. 4. Booleanos: se trata de un tipo de dato que solo puede tomar dos valores true y false .

2.2.2Variables
Java requiere que se declaren los tipos de todas las variables empleadas, adems, necesitan ser inicializadas antes de usarlas. La siguiente instruccin declara e inicializa una variable de tipo entero: int i = 0;

El alcance de una variable en Java viene definido por el bloque de cdigo en el que se defini. Como sabemos los bloques empiezan con { y terminan en } , por lo que la variable dejar de existir cuando se cierre el corchete que est justo antes que ella en el cdigo.

2.2.3Arrays
En Java los arrays son objetos. Como tales se crean mediante el comando new. La sintaxis en la definicin de un array es la siguiente:

Tipo_dato[] nombre_array = new tipo_dato[tamao_array];

donde, tipo_dato es el tipo de los datos que se almacenarn en el array (int, char, & o cualquier objeto) y tamao_array es el tamao que se quiere dar al array. Por ejemplo, la siguiente instruccin crea un array de nombre ejemplo que almacena 10 datos de tipo entero:

int [] ejemplo = new int[10]

6 de febrero de 2008

Tema 1

12

2.3Operadores,expresionesycontroldeflujo
2.3.1Operadores
Los Operadores son smbolos especiales que realizan operaciones especficas entre uno, dos o tres operandos y devuelven un resultado

Tipos de operadores que existen en Java en orden de precedencia: Tipo de operador Unitarios Aritmticos Desplazamiento Relacionales Igualdad Lgicos (nivel bit) Lgicos Ternario Asignacin ++ -- ~ ! */%+<< >> >>> <<< < > <= >= instanceof == != &|^ && || ?: = += -= *= /= %= &= ^= |= <<= >>= >>>= Smbolo operador

2.3.2Expresiones
Una expresin es una construccin formada por variables, operadores e invocaciones a mtodos que cumple con las restricciones sintcticas del lenguaje y que devuelve un nico resultado. A continuacin se muestran ejemplos de expresiones:

int resultado = 1 + 2; if (valor1 == valor2) System.out.println("hola");

2.3.3Controldeflujo
Sentencias condicionales.

6 de febrero de 2008

Tema 1

13

Ejecutan un cdigo u otro en funcin de que se cumpla o no una determinada condicin. Veamos que tipos existen:

if (condicion) { bloque_de_instrucciones; }

if (condicion) { bloque_de_instrucciones; } else { bloque_de_instrucciones; }

switch (condicion) { case valor1: bloque_de_instrucciones; break; case valor2: bloque_de_instrucciones; break; .... default: bloque_de_instrucciones; }

Sentencias de repeticin.

Estas instrucciones estarn repitiendo un bloque de instrucciones definido hasta que la condicin se evale a false. Tienen la siguiente estructura:

while (condicion) { bloque_de_instrucciones; }

do { bloque_de_instrucciones; } while (condicion)

6 de febrero de 2008

Tema 1

14

for (inicializacin; condicin; siguientepaso) { bloque_de_instrucciones; }

Sentencias de ruptura.

Dentro del cuerpo de una sentencia de iteracin se puede controlar el flujo del bucle mediante las instrucciones break y continue. Break finaliza el bucle y continue pasa a la siguiente iteracin.

La instruccin return tiene dos propsitos: especifica el valor que va a devolver un mtodo (en el caso de que tenga que hacerlo) y provoca la devolucin de ese valor de forma inmediata.

2.4Objetosyclases
Una clase es un conjunto de objetos con propiedades (atributos y/o mtodos) comunes, es decir, una plantilla o prototipo de objetos.

En Java, la forma general para definir una clase es:

[modificador] class nombreClase [extends clasePadre] [implements interface] { Declaracin de atributos; Declaracin de constructores; Declaracin de mtodos; }

Donde los elementos contenidos entre [] son optativos y se definen con el siguiente orden:

1. [modificador]: modificadores que pueden tener el valor public, private, etc y que se vern a continuacin. 2. [extends clasePadre]: el nombre de la clase padre de la que hereda. Solo puede tener un padre. 3. [implements interface]: las interfaces implementadas por la clase y puede implementar ms de una. 6 de febrero de 2008 Tema 1 15

Modificadores de acceso.

Define el control de acceso a la clase declarada desde otras clases. Tiene 4 valores posibles:

Public: clase pblica y accesible por todo el mundo. Protected: se tiene acceso por las clases del mismo paquete, y por las subclases incluso de otros paquetes. Ninguno: se tiene acceso nicamente por las clases del mismo paquete. Private: no se puede acceder desde fuera de la propia clase.

Declaracin de atributos.

La estructura para declarar variables es:

[modificador] [static] [final] <tipo_dato> nombreVariable [=<valor por defecto>];

Segn los modificadores utilizados existen los siguientes tipos de variables:

Variables de instancia: pertenecen al objeto (public int variable1;) Variables de clase: pertenecen a la clase y, por lo tanto, es comn a todos los objetos de esa clase (public static int variable2;) Constantes: sirven para definir variables con valores inmodificables (static final double PI = 3.141592554;)

Para todos los tipos de variables se pueden utilizar los modificadores de acceso que permiten controlar el acceso a los atributos desde otras clases. Toman los mismos valores y significado que los explicados arriba para la definicin de clases.

Declaracin de mtodos.

La estructura para declarar mtodos es:

6 de febrero de 2008

Tema 1

16

[modificador] [static] [abstract] <tipo_dato_devuelto> nombreMetodo ([parmetros]) {}

Existen varios tipos de mtodos:

Constructores: mtodos que se invocan cuando se genera un nuevo objeto con la instruccin new . Mtodos de clase: pertenecen a la clase y se pueden invocar llamando directamente a la clase. Se utiliza la etiqueta static. Mtodos de instancia: los mtodos de los objetos y que se necesita tener un objeto para poder llamarlos. Mtodos abstractos: mtodos que no tienen ninguna implementacin. Se utiliza la etiqueta abstract.

Aqu, igual que las clases y los atributos, los modificadores de acceso permiten controlar el acceso a los mtodos desde otras clases. En Java se pueden sobrecargar los mtodos, es decir, se pueden definir dentro de una misma clase ms de un mtodo que tenga el mismo nombre pero distinto tipo y/o nmero de parmetros. A continuacin ponemos un ejemplo donde el constructor est sobrecargado: public class Circulo { private int radio = 0; private Point centro; public Circulo() { centro = new Point(0, 0); } public Circulo(Point p) { centro = p; } public Circulo(int r) { this(new Point(0, 0), r); } public Circulo(Point p, int r) { centro = p; radio = r; 6 de febrero de 2008 Tema 1 17

} ... } La variable this es una variable de slo lectura que proporciona Java y que contiene una referencia al objeto en el que se usa dicha variable. Los objetos son instancias de las clases. Para poder programar con los objetos en lenguaje Java es necesario realizar los tres pasos siguientes:

1. Declaracin del objeto. 2. Instanciacin: la palabra clave new es la instruccin Java que crea el objeto. 3. Inicializacin: new est seguido obligatoriamente por la llamada un mtodo constructor que inicializa el objeto.

Estos tres pasos se pueden realizar mediantedos instrucciones:

Object nuevoObjeto; nuevoObjeto = new Object();

o bien, en una sola instruccin:

Object nuevoObjeto = new Object();

Una vez realizado estos pasos podremos invocar tanto los atributos como los mtodos del objeto de la siguiente forma:

objeto.nombreVariable; objeto.nombreMetodo(); Recomendaciones a la hora de nombrar las clases, los atributos y los mtodos:

6 de febrero de 2008

Tema 1

18

Elige nombre que tengan algn significado. Se deben evitar utilizar nombres del estilo XYZ. Las clases deben empezar con maysculas (Persona, Circulo, Coche, ClienteOro, etc). Los atributos son identificadores que deben empezar en minsculas (edad, modelo, color, direccionesFacturacion, etc). Los mtodos deberan ser verbos que identifiquen un comportamiento y tambin deberan empezar con minsculas (pintar, arrancarCoche, frenar, obtenerFactura, etc). Comentar los mtodos para explicar que funcin realizan (se debera utilizar el estilo Javadoc).

2.5Herencia
La herencia es el medio mediante el cual una clase hija (subclase) hereda las variables y los mtodos definidos en la clase padre (superclase) de forma automtica. En Java, para indicar que una clase hereda de otra se utiliza la etiqueta extends . Veamos un ejemplo: public class Persona { public class Alumno extends Persona { String nombre; int edad; //mtodo constructor // mtodo constructor public Alumno(){} public Persona() { nombre = ; } edad = 0; .... } }

Todas las clases tienen un padre nico y directo (herencia simple). En ausencia de declaracin explicita de ninguna superclase la clase padre ser Object que es la clase de que heredan todos las clases definidas en Java.

Al igual que vimos la variable this que era creada automticamente por Java para referenciar al 6 de febrero de 2008 Tema 1 19

propio objeto, Java tambin proporciona la variable super que apunta a la superclase de la cual deriva nuestra clase.

2.6Interfaces
Un mtodo abstracto es un mtodo que no se ha implementado, es decir, que el cuerpo de dicho mtodo est vaco. Para definir un mtodo abstracto se utilizar la etiqueta abstract . El siguiente mtodo es un ejemplo de mtodo abstracto:

public abstract void metodoAbstracto(); Una clase es abstracta si contiene uno o ms mtodos abstractos. Una clase abstracta no puede ser instanciada (se producira un error de compilacin) y sern las subclases las encargadas de implementar dichos mtodos abstractos.

Vamos a ver un ejemplo de clase abstracta y las subclases que implementan los mtodos abstractos.

//Clase abstracta SerVivo. public abstract class SerVivo { public void respirar () { System.out.println ( respirar .... ); } public void comer () { System.out.println( comer.... ); } //Metodo caminar abstracto, se implementar en las subclases public abstract void moverse() ; }

//Clases concretas Hombre y Ave que heredan del SerVivo e implementan el mtodo abstracto. public class Hombre extends SerVivo { public void moverse () { System.out.println("caminar..."); } } 6 de febrero de 2008 Tema 1 20

public class Ave extends SerVivo { public void moverse () { System.out.println("volar..."); } }

Una interface en Java es un tipo de entidad parecido a una clase pero que nicamente contiene constantes y mtodos abstractos, es decir, mtodos que no se encuentran implementados. Estas interfaces no se pueden instanciar y slo pueden ser implementadas por clases o por otras interfaces.

Segn esta definicin, para que sirve tener una entidad parecida a una clase si no puede ser instanciada? A continuacin vamos a enumerar la motivacin de las interfaces.

Primero, mediante las interfaces ofrecemos la funcionalidad de un objeto sin revelar su implementacin. Este cumple el concepto bsico de encapsulacin, permite modificar la implementacin sin afectar a las clases invocadoras y las clases que llaman no tienen que conocer la implementacin en tiempo de compilacin.

Segundo, permite que clases que no se encuentren relacionadas por herencia tengan comportamientos similares.

Y tercero, mediante las interfaces podemos modelizar la herencia mltiple que no est permitida en Java. Una clase pueden implementar varias interfaces pero slo puede heredar de una superclase.

La forma general para definir una interface es similar a la de las clases:

[modificador] interface nombreInterface [extends (interfacePadre)+] { Declaracin de constantes; Declaracin de mtodos abstractos; } Interfaces o clases abstractas.

6 de febrero de 2008

Tema 1

21

- Todos los mtodos de un Interface son abstractos mientras que las clases abstractas pueden tener mtodos abstractos o no. - Una interface slo puede tener constantes mientras que una clase abstracta puede tener atributos. - Las interfaces no tienen relacin con ninguna clase en particular, se definen de forma independiente. Por el contrario, las clases abstractas proporcionan una implementacin parcial de la clase, dejando a las subclases completar la implementacin.

6 de febrero de 2008

Tema 1

22

3ClasesyPaquetesenJava
3.1Conceptodepaquete.Paquetesbsicos
3.1.1Conceptodepaquete
Un paquete es una agrupacin de clases e interfaces que proporciona proteccin de acceso y gestin del espacio de nombres. A continuacin resumimos las ventajas de agrupar las clases en paquetes:

Los programadores pueden agrupar en paquetes clases e interfaces que se encuentren relacionados, por ejemplo, agrupar las clases e interfaces que proporcionen la funcionalidad grfica. La creacin de un paquete genera un nuevo espacio de nombre (namespace) con lo que se evitarn conflicto entre nombres idnticos de clases e interfaces en distintos paquetes. Mediante la utilizacin de los paquetes y los modificadores de acceso de las clases se pueden gestionar el acceso pblico o restringido entre clases de diferentes paquetes.

Para crear un paquete se utiliza la etiqueta 'package' al inicio de los ficheros que definan clases o interfaces indicando el nombre del paquete al que se quiere que pertenezcan dichas clases e interfaces. Por ejemplo, la clase Circulo pertenecera al paquete figuras:

package figuras; public class Circulo { // Definicin de variables y mtodos de la clase Circulo } Si no se incluye la etiqueta 'package' la clase no pertenecer a ningn paquete. Se recomienda que todos los ficheros (clases e interfaces) pertenezcan a algn paquete. Los paquetes pueden estar anidados formando una jerarqua de paquetes. En este caso, el intrprete de Java espera que la estructura de directorios coincida con la jerarqua de paquetes. Por ejemplo, la clase Circulo de arriba debera encontrarse dentro de un directorio con el nombre 'figuras'.

6 de febrero de 2008

Tema 1

23

3.1.2Paquetesbsicos
En Java, las clases e interfaces se agrupan en paquetes y el conjunto de todos los paquetes que vienen con la distribucin se conoce como el API (Interface de Programacin de Aplicaciones) de Java. En la siguiente imagen extrada de la documentacin de la JDK 1.5 podemos ver los paquetes que vienen con la distribucin:

Para poder tener un mayor detalle de cada uno de los paquetes que componen el API se remite al alumno a la documentacin mencionada que se puede descargar y consultar desde la pgina de Sun (http://java.sun.com/j2se/1.5.0/docs/index.html).

3.2GestindeExcepciones
Java utiliza las excepciones para permitir gestionar los errores y otras situaciones anormales de una aplicacin.

Estas excepciones (que, evidentemente, son objetos) generadas por Java son errores que se producen en tiempo de ejecucin y que provocan que el flujo normal del programa se interrumpa. Estos

6 de febrero de 2008

Tema 1

24

errores pueden variar desde errores por divisin entre cero o que se sobrepasen los lmites de un array hasta la falta de memoria o problemas de acceso al disco.

Cuando un mtodo crea o lanza (throw) una excepcin se busca un gestor (handler) para que sea tratada. Si se encuentra un gestor adecuado la ejecucin del programa pasa a ese punto, conocindose este proceso como captura de la excepcin (catch). Si no se encuentra ningn gestor adecuado para dicha excepcin entonces el programa finaliza.

La gestin de errores mediante excepciones presenta las siguientes ventajas:

Mantener separado el cdigo que gestiona los errores del cdigo de negocio. Se propagan los errores a travs de la pila de llamadas a los mtodos. Aquel mtodo que realmente est interesado en el error ser el encargado de implementar el gestor adecuado (handler). Permiten agrupar por tipologas de error.

Para realizar la gestin de excepciones, Java proporciona la estructura try-catch-finally que presenta el siguiente formato:

try { <cdigo monitorizado por los gestores de excepcin> } catch (<ExceptionTipo1> <ObjName1>) { <gestor si ocurre la ExceptionTipo1 > } ... catch (<ExceptionTipoN> <ObjNameN>) { <gestor si ocurre la ExceptionTypeN > } finally { <cdigo que siempre es ejecutado> }

Si un mtodo puede causar una excepcin est obligado a capturarla o a lanzarla mediante la palabra clave throws en la declaracin del mtodo con la siguiente sintaxis:

6 de febrero de 2008

Tema 1

25

<tipo_dato_devuelto> nombreMetodo ([parmetros]) throws [exceptionList] {}

3.3I/O(Entrada/Salida)
En este apartado vamos a revisar la forma y las clases que proporciona Java para poder llevar a cabo el proceso de entrada y salida de datos. Debemos tener en cuenta que estos procesos son harto complejos no slo por la diversidad de fuentes de entrada y salida (ficheros, consola, conexiones de red) sino tambin por la variedad de formas de comunicarse con estas fuentes (secuencial, aleatoria, binaria, caracteres, lneas, etc.).

Los diseadores de Java crearon clases para tratar estos procesos y las agruparon en el paquete java.io. La verdad, es que crearon demasiadas clases por lo que tratar con este paquete y saber que clase debo utilizar para mi aplicacin a veces es difcil.

Vamos a resumir las cinco clases padre (File, InputStream, OutputStream, Reader y Writer)

File.

Esta clase, a pesar de su nombre, no hace referencia a un fichero sino que referencia al nombre del fichero. El fichero fsico puede o no existir.

Mediante esta clase podemos realizar operaciones con los ficheros del tipo de borrado, renombrado o cambio de permisos. Adems, esta clase tambin permite referenciar a un directorio y realizar operaciones con directorios (crear, borrar, etc).

InputStream y OutputStream.

Las clases que heredan de estas permiten leer y escribir datos binarios. Las entradas y salidas de datos pueden ser muy diversas lo que provoca que existan multitud de subclases. La mayora de las subclases se utilizan de la misma forma y nicamente se diferencian en la forma de su creacin.

Reader y Writer. 6 de febrero de 2008 Tema 1 26

Las clases que heredan de estas permiten leer y escribir caracteres Unicode. Ocurre la misma problemtica con la multitud de formas de entrada y salida y se generan igualmente gran cantidad de subclases.

Veamos un ejemplo:

public class Copia { public static void main(String[] args) throws IOException { FileInputStream in = null; FileOutputStream out = null; try { in = new FileInputStream("entrada.txt"); out = new FileOutputStream("salida.txt"); int c; while ((c = in.read()) != -1) { out.write(c); } } finally { if (in != null) { in.close();} if (out != null) { out.close();} } } }

3.4GUIInterfacesGrficos
La parte de Java SDK que se dedica a agrupar las clases que se utilizan para simplificar el desarrollo del entorno grfico (GUI) se denomina JFC (Java Foundation Classes).

Consiste, bsicamente, en el conjunto de cinco APIs:

AWT (Abstract Window Toolkit): aporta los componentes necesarios para crear entornos grficos (ventanas, botones, mens, etc.). Swing: al igual que AWT aporta componentes para crear las interfaces grficas. A continuacin veremos en que se diferencian estos dos APIs. Java2D: permite al programador incluir fcilmente grficos, textos e imgenes 2D. Tema 1 27

6 de febrero de 2008

Accessibility: con este API se pueden desarrollar aplicaciones que sean accesible por personas con discapacidad. Drag and Drop: permite la transferencia de datos entre el lenguaje Java y las aplicaciones nativas.

De los cinco APIs mencionados, los que verdaderamente aportan las clases que permiten crear las interfaces grficas son AWT y Swing. La siguiente tabla muestra las diferencias entre los dos APIs. AWT

SWING

Algunos componentes AWT utilizan cdigo nativo. Es dependiente de la plataforma.

Los componentes estn escritos en Java Es independiente de la plataforma.

Presentan el mismo look&feel de la plataforma sobre la que se ejecutan.

Aseguran que el look&feel de los componentes sea igual independientemente de la plataforma.

La siguiente tabla presenta los componentes ms utilizados y el nombre de las clases que los implementan en AWT y SWING. Componente Ventana con titulo, men, bordes y reescalable Etiqueta Campo de texto Botn Lista de opciones Lista desplegable Frame Label TextField Button CheckBox List AWT JFrame JLabel JTextField JButton JCheckBox JList SWING

3.5GestindeHilos
La plataforma Java est diseada desde su origen para ser capaz de soportar la programacin

6 de febrero de 2008

Tema 1

28

concurrente. Este apartado introduce la forma que plantea Java para permitir la concurrencia y resume de forma general como utilizar el API.

Antes de ver como trata Java la concurrencia, vamos a distinguir entre proceso y thread:

Un proceso es un entorno de ejecucin completo que tiene su propio conjunto de recursos, en particular, su propio espacio de memoria. Un proceso suele ser sinnimo de un programa. Los threads se conocen como procesos ligeros. Tanto los procesos como los threads proporcionan un entorno de ejecucin, pero crear un nuevo thread implica menos recursos que crear un nuevo proceso. Un thread pertenece siempre a algn proceso, no pueden existir independientemente. Los distintos threads de un proceso comparten los recursos (incluidos la memoria y los ficheros abiertos) lo que implica una comunicacin ms eficiente pero potencialmente insegura.

Todas las aplicaciones de Java se inician con un thread que se denomina main thread . Este thread tiene la capacidad de crear otros threads adicionales que permitiran tener varios hilos en ejecucin de forma concurrente.

Cada uno de los threads que se ejecutan est asociado con una instancia de la clase java.lang.Thread. Existen dos estrategias bsicas para utilizar los Threads y crear aplicaciones concurrentes:

Crear una clase que extienda de la clase Thread y sobreescribir su mtodo run. En este mtodo va el "cuerpo del thread", es decir, el cdigo que se va a comportar como thread. El resto de mtodos de la clase sern normales. Implementando el interface Runnable, interface que posee un nico mtodo 'run' que debemos sobrescribir.

Para ejecutar un thread nunca debemos llamar directamente al mtodo run, hemos de llamar al mtodo start y ya se encargar ste de llamar a run. Si llamamos directamente a run, ste se ejecutar como un mtodo normal y no en un nuevo thread.

6 de febrero de 2008

Tema 1

29

6 de febrero de 2008

Tema 1

30

4JavaAvanzado
4.1Libreras:GeneracinyUtilizacin
En Java se ha definido el formato JAR (Java ARchive) que permite unir varios archivos en uno solo. Cada archivo JAR va a contener una serie de clases e interfaces relacionados. Estos ficheros JAR tambin se les conoce con el nombre de libreras.

A continuacin vamos a resumir que beneficios se obtienen utilizando dicho formato:

Compresin: los archivos JAR comprimen los ficheros para un almacenaje ms eficiente. Reduccin de la descarga: por ser un fichero comprimido la descarga de un archivo JAR ser ms rpida que tener que descargarnos cada uno de los ficheros que lo componen. Versionado: los ficheros JAR mantienen un fichero denominado manifest que mantienen informacin relativa al proveedor y la versin. Seguridad: el contenido de un fichero JAR puede ser firmado digitalmente.

Los archivos JAR se comprimen utilizando el formato ZIP, de sta forma, es posible utilizar los programas compresores (Winzip o Winrar) para poder ver el contenido de los archivos JAR.

Para crear un archivo JAR utilizaremos la herramienta Java Archive Tool (jar) que viene con la JDK. Esta herramienta se puede invocar desde la lnea de comandos y dependiendo de los parmetros realizar una u otras acciones. La siguiente tabla resume las acciones ms comunes: Comando jar cf <fichero.jar> <ficheros_entrada> jar tf <fichero.jar> jar xf <fichero.jar> jar xf <fichero.jar> <ficheros_para_extraer> java -jar aplicacion.jar Accin Crear un fichero JAR. Ver el contenido de un fichero JAR. Extraer el contenido de un fichero JAR. Extraer unos ficheros especficos de un fichero JAR. Ejecutar una aplicacin que se encuentra empaquetada en un fichero JAR (es necesario que el fichero de manifiesto Tema 1 31

6 de febrero de 2008

tenga especificado el Main-class) El fichero de manifiesto MANIFEST.MF

Cuando se crea un fichero JAR, automticamente se aade un fichero de manifiesto. Cada fichero JAR slo puede contener un fichero de manifiesto y tiene la siguiente ruta:

META-INF/MANIFEST.MF

Al crear el archivo JAR, el fichero de manifiesto contiene:

Manifest-Version: 1.0 Created-By: 1.5.0 (Sun Microsystems Inc.)

Podemos ver que el fichero de manifiesto mantiene pares "clave: valor". En este caso vemos que se especifica la versin del manifiesto y la versin de la JDK.

Adems de estos valores, en el fichero de manifiesto podemos guardar informacin relacionada con la librera, referenciar a otras libreras que se utilicen, especificar el punto de entrada de una aplicacin, firmar digitalmente, etc. Veamos un ejemplo ms completo.

Manifest-Version: 1.0 Class-Path: utilidades.jar Main-Class: ClasePrincipal Signature-Version: 1.0 SHA1-Digest-Manifest: h1yS+K9T7DyHtZrtI+LxvgqaMYM= Created-By: 1.5.0 (Sun Microsystems Inc.)

4.2Internacionalizacin(I18n)
La internacionalizacin es el proceso de disear una aplicacin para que sea fcilmente adaptable a otros lenguajes, tambin se suele utilizar el trmino de aplicacin multiidioma. En Java, el trmino internacionalizacin se abrevia con i18n porque hay 18 letras entre la primera i y la

6 de febrero de 2008

Tema 1

32

ltima n.

Qu caractersticas tiene que cumplir una aplicacin para que sea internacionalizable?

El mismo cdigo tiene que utilizarse para los distintos idiomas, nicamente se indicar el idioma mediante algn parmetro. Si se aade un nuevo idioma no debe ser necesario recompilar el cdigo. Los textos que aparezcan en la aplicacin (formularios de entrada de datos, listados con resultados de consultas, etc) no deben estar escritos en el cdigo. Se utilizarn otros ficheros de textos donde se guarden dichos textos. Adems de los textos, se han de tener en cuenta los datos dependientes de cada pas, por ejemplo, las fechas y las monedas.

A continuacin, vamos a ver un sencillo ejemplo que permitir comprender los pasos necesarios para disear aplicaciones internacionalizadas con Java.

Nuestro ejemplo va a mostrar el texto Hola Mundo pero tiene que hacerlo en tres idiomas (espaol, ingls y francs) dependiendo de parmetros de entrada de la lnea de comandos. Una versin no internacionalizada sera:

public class SaludoNoI18N { public static void main (String[] args) { if (args[0].equals( ES )) System.out.println( Hola Mundo ); else if (args[0].equals ( EN")) System.out.println( Hello World ); else if (args[0].equals ( FR")) System.out.println( Bonjour Monde ); } }

El problema ms evidente de esta forma de implementacin es que si queremos incluir otro idioma vamos a necesitar modificar la clase y recompilar el cdigo.

Mediante los siguientes pasos vamos a ver como internacionalizar dicho cdigo y evitar este 6 de febrero de 2008 Tema 1 33

problema.

1. Crear los ficheros de properties. Se tiene que crear un fichero de properties para cada uno de los idiomas. El fichero properties contendr lneas de pares "clave = valor" donde la clave se utilizar en el cdigo y el valor ser el texto en el idioma del fichero. Para nuestro ejemplo tendramos: Nombre Mensajes_es_ES.properties Mensajes_en_GB.properties Mensajes_fr_FR.properties del fichero Contenido saludo=Hola Mundo saludo=Hello World saludo=Bonjour Monde

2. Definir el Locale. El objeto Locale identifica un idioma y un pais. Las siguientes instrucciones definen un Locale para el idioma ingles y el primero para el EEUU y el segundo para Inglaterra: localeAmericano = new Locale ("en","US); localeIngles = new Locale("en","GB");

3. Crear un ResourceBundle. El objeto ResouceBundle se utiliza para cargarlo con el fichero de properties adecuado al idioma que identifique el Locale.

4. Recuperamos del ResourceBundle el texto. Utilizando los mtodos proporcionados por la clase ResourceBundle (getString()) obtenemos el texto correspondiente.

A continuacin vemos el cdigo completo de nuestra aplicacin internazionalizada donde se identifican cada uno de los pasos que implican la internacionalizacin.

import java.util.*; public class SaludoI18N { static public void main(String[] args) { String idioma; 6 de febrero de 2008 Tema 1 34

String pais; Locale locale; ResourceBundle mensajes; // Definimos el Locale segn los parametros idioma = new String(args[0]); pais = new String(args[1]); locale = new Locale(idioma, pais); // Creamos un ResourceBundle messages = ResourceBundle.getBundle("MessagesBundle", currentLocale); // Recuperamos del ResourceBundle el texto System.out.println(messages.getString("saludo")); } } El alcance de internacionalizar una aplicacin va ms all de nicamente coger todos los textos y meterlos en ficheros de Resources. La siguiente es una lista datos susceptibles de ser dependientes del idioma: - Mensajes. - Fechas. - Nmeros. - Monedas. - Imgenes. - Sonidos. - Etc.

4.3InstrospectionyReflection
Simplemente vamos a indicar que son estas dos APIs de Java por la gran aplicacin que tienen dentro del desarrollo de frameworks (Struts, Spring, ...) e IDEs, pero no se entrar en profundidad por ser funcionalidades complejas que requieren un alto dominio del lenguaje Java por parte del desarrollador por lo que no deben ser usadas de forma trivial.

Instrospection y reflection son utilidades que ofrece Java para permitir a un objeto obtener

6 de febrero de 2008

Tema 1

35

informacin sobre si mismo u otros objetos en tiempo de ejecucin.

Se define reflection como el hecho de mostrar una imagen de . En Java, mediante sta tcnica se permite:

Construir nuevas instancias de clase y nuevos arrays. Acceder y modificar los atributos de objetos y clases. Invocar los mtodos de objetos y clases. Acceder y modificar los elementos de los arrays.

Estas acciones se pueden realizar mediante la programacin orientada a objetos sin necesidad de utilizar reflection, entonces cul es la diferencia? Que mediante el uso de la reflection un objeto puede hacer las acciones anteriores sobre otros objetos o sobre si mismo sin conocer sobre que objetos o clases lo va a realizar en tiempo de compilacin sino que ser en tiempo de ejecucin cuando se determine el estado y el comportamiento de los objetos y clases.

Se define instrospection como la capacidad de examinar u observar el estado de algo . En Java, la instrospection se utiliza para permitir a un Bean descubrir propiedades, mtodos y eventos de otros Beans en tiempo de ejecucin.

Reflection e instrospection estn ntimamente relacionadas. Reflection es una facilidad de bajo nivel que permite implementar cdigo para examinar el interior de cualquier clase y objeto en tiempo de ejecucin. Instrospection se basa en esta facilidad y proporciona un medio ms adecuado para examinar internamente los Beans.

4.4Seguridad
Desde su creacin el entorno Java ha tenido presentes los problemas de seguridad y ha definido un modelo para controlar y limitar el acceso a los recursos desde los programas y aplicaciones. El modelo de seguridad ha ido evolucionando con las distintas versiones, pasando de un modelo muy sencillo y restrictivo, el del JDK 1.0, a uno ms complejo y flexible desde la aparicin del JDK 1.2.

Java fue diseado para ofrecer las siguientes medidas de seguridad bsicas:

6 de febrero de 2008

Tema 1

36

Uso de un lenguaje de programacin seguro. Mediante caractersticas como la eliminacin de la aritmtica con punteros, la comprobacin de rangos en el acceso a vectores o la liberacin de memoria de forma dinmica. Integracin de un sistema de control de permisos para los programas. Java define un mecanismo (denominado sandbox model) que permite controlar que se le permite hacer a un programa y controlar como accede a los recursos. Encriptacin y uso de certificados. Se definen mecanismos para que los programadores puedan firmar el cdigo, de manera que los usuarios puedan verificar quien es el propietario del cdigo y que este no ha sido modificado despus de ser firmado.

La seguridad se basa en tres componentes fundamentales del entorno de ejecucin:

1. El cargador de clases (Class Loader), que determina como y cuando pueden cargar cdigo los programas y garantiza que los componentes del sistema no han sido reemplazados. 2. El verificador de archivos de clases (Class file verifier), que garantiza que el cdigo tiene el formato correcto, que el bytecode no viola las restricciones de seguridad de tipos de la JVM, que las pilas internas no puedan desbordarse ni por arriba ni por abajo y que las instrucciones en bytecode tengan parmetros de tipos correctos. 3. El gestor de seguridad (Security Manager), que controla el acceso a los recursos en tiempo de ejecucin. Los recursos sobre los que tiene control son mltiples: E/S de red y ficheros, creacin de cargadores de clases, manipulacin de hilos de ejecucin, ejecucin de programas externos (del SO), detener la JVM, cargar cdigo nativo en la mquina virtual, realizar determinadas operaciones en el entorno de ventanas o cargar ciertos tipos de clases.

Vamos a resumir a continuacin como ha ido evolucionando la seguridad en las distintas versiones.

Seguridad en el JDK 1.0

El modelo de seguridad original de la plataforma Java es el conocido como el modelo del cajn de arena (sandbox model), que proporcionaba un entorno muy restringido en el que ejecutar cdigo no fiable obtenido de la red.

En este modelo trabajamos con dos niveles de acceso a los recursos: total, para programas locales, o muy restringido, para programas remotos. La seguridad se consigue gracias al empleo del cargador de clases, el verificador de clases y el gestor de seguridad.

6 de febrero de 2008

Tema 1

37

La pega fundamental de este modelo es que es demasiado restrictivo, ya que no permite que los programas remotos hagan nada til, por estar restringidos al modelo del cajn de arena.

Seguridad en el JDK 1.1

Como el modelo del JDK 1.0 era demasido restrictivo se introdujo el concepto de cdigo remoto firmado, que sigue garantizando la seguridad de los clientes, pero permite que cdigo obtenido remotamente salga del cajn y tenga acceso a todos los recursos, siempre y cuando est firmado por una entidad en la el cliente confa.

Adems del cdigo firmado, el JDK 1.1 introdujo otras mejoras de seguridad, un par de herramientas de seguridad (jar y javakey) y un API para programacin segura que introdujo paquetes de clases que proporcionan funciones criptogrficas a los programadores.

Seguridad en Java 2

En el JDK 1.2 (Java 2) se han introducido nuevas caractersticas que mejoran el soporte y el control de la seguridad:

Control de acceso de grano fino. Uno de los problemas fundamentales de la seguridad en el JDK 1.1 es que el modelo slo contempla dos niveles de permisos: acceso total o cajn de arena. Para solventar el problema el JDK 1.2 introduce un sistema de control de permisos de grano fino que permite dar permisos especficos a trozos de cdigo especficos para acceder a recursos especficos en el cliente, dependiendo de la firma del cdigo y/o el URL del que este se obtuvo. Control de acceso aplicado a todo el cdigo. El concepto de cdigo firmado es ahora aplicable a todo el cdigo, independientemente de su procedencia (local o remoto). Facilidad de configuracin de polticas de seguridad. La nueva arquitectura de seguridad permite el ajuste sencillo de los permisos de acceso usando un fichero de polticas (policy file) en el que se definen los permisos para acceder a los recursos del sistema para todo el cdigo (local o remoto, firmado o sin firmar). Gracias a ello, el usuario puede bajar aplicaciones de la red, instalarlas y ejecutarlas asignndoles slo los permisos que necesiten. Estructura de control de acceso extensible. En versiones anteriores del JDK cuando se deseaba crear un nuevo tipo de permiso de acceso era necesario aadir un nuevo mtodo

6 de febrero de 2008

Tema 1

38

check a la clase del gestor de seguridad. Esta versin permite definir permisos tipo que representan un acceso a recursos del sistema y el control automtico de todos los permisos de un tipo correcto, lo que repercute en que, en la mayora de casos, se hace innecesario aadir mtodos al gestor de seguridad.

En el Java 2 han aparecido o se han mejorado las herramientas y el API de seguridad.

4.5Rendimiento
En este apartado se pretenden dar una serie de recomendaciones a los alumnos para que cuando desarrollen aplicaciones con Java tengan en cuenta el rendimiento de las mismas.

Utilizar datos primitivos u objetos.

Cuando tengamos opcin de elegir entre utilizar los datos primitivos (int, double, ..) o los objetos (Integer, Double,...) se recomienda utilizar los primeros.

String contra StringBuffer.

Los objetos String son objeto inmutables, lo que implica que cuando realizamos concatenaciones se utilicen operaciones internas intermedias que repercuten en prdida de tiempo. En aquellas aplicaciones donde se realicen concatenaciones con Strings se recomienda utilizar objetos StringBuffer.

Java Collections.

En Java los objetos Vector y Hashtable tienen sus mtodos sincronizados por lo que al utilizarlos pagamos el coste de este control cuando slo es necesario si tenemos varios threads accediendo concurrentemente. El objeto Vector puede sustituirse por ArrayList o LinkedList y el objeto Hashtable por HashSet o HashMap que son objetos no sincronizados y ms eficientes.

Bloques try-catch.

6 de febrero de 2008

Tema 1

39

La gestin de excepciones con bloques try-catch no es gratuita por lo que se recomienda no utilizar dicha estructura sin tener un planteamiento claro de que se quiere controlar. Es preferible no abusar de estos bloques cuando se puede tener el cdigo controlado con la lgica normal del programa.

Controlar la escritura en consola.

Se recomienda no abusar de la escritura en consola (System.out.println()) sino que es preferible controlar mediante gestores de logs todas las trazas que necesite generar nuestra aplicacin.

Evitar tener cdigo que no se utilice.

La creacin de objetos o las llamadas a ciertos mtodos pueden costar su tiempo en ejecutarse y muchas veces no son necesarios y aparecen nicamente por arrastrar cdigo obsoleto.

Reutilizar los objetos creados en vez de estar creando nuevos objetos.

4.6Testing(JUnit)
La realizacin de tests o pruebas sobre nuestras aplicaciones van a proporcionar las siguientes ventajas:

Es un medio de asegurar la calidad del software. Es posible automatizar las pruebas mediante ciertas herramientas. Las pruebas se pueden guardar junto con el cdigo y conforme se evoluciona el mismo permite que tanto quien lo ha desarrollado como otros programadores prueben que cdigo sigue cumpliendo las pruebas.

La necesidad de probar el cdigo para obtener aplicaciones de calidad es algo tan latente que ha generado una nueva filosofa en el desarrollo del software denominado TDD (Test-Driven Development). Esta tcnica implica que primer se escriban los casos de prueba y despus se implemente nicamente el cdigo necesario para pasar la prueba.

En este apartado vamos a presentar la herramienta JUnit. Esta herramienta proporciona:

6 de febrero de 2008

Tema 1

40

Un API para facilitar la creacin de casos de prueba en Java. Entorno de ejecucin para lanzar bateras de pruebas. Generacin de informes.

Los pasos necesarios para escribir un caso de prueba basado en JUnit son:

1. 2. 3. 4. 5.

Incluir la librera JUnit.jar en el classpath. Definir una subclase que herede de TestCase. Definir uno o ms metodos pblicos testXXX() en la subclase. Dentro de los mtodos testXXX() escribir sentencias assert. Opcionalmente, definir el mtodo main para ejecutar el caso de prueba de forma independiente.

Los mtodos testXXX siguen el patrn de nombrado donde XXX refleja el nombre de la prueba. Estos mtodos no tienen parmetros y no devuelven nada (void).

Las sentencias assert sirven para determinar el xito o fallo de una prueba, es decir, una sentencia assert es una sencilla comparacin entre el valor que se espera y el valor obtenido realmente.

Veamos un ejemplo de caso de prueba.

import junit.framework.TestCase; public class Prueba1 extends TestCase { public Prueba1(String nombre) { super(nombre); } // Codigo de prueba public void testEjemplo() { System.out.println("Llamando al mtodo assert para comprobar que 2 por 2 son 4."); assertTrue(4 == (2 * 2)); } // Este main es opcional si utilizamos el entorno de ejecucin de pruebas

6 de febrero de 2008

Tema 1

41

public static void main(String[] args) { junit.textui.TestRunner.run(SimpleTest.class); } }

Una vez creados los casos de prueba existen dos posibilidades para lanzar dichas pruebas de forma automtica. Primera, mediante lnea de comandos obteniendo los resultados de forma textual, o bien, mediante un entorno grfico diseado que muestra mediante una barra verde los tests pasados correctamente y otra barra roja los tests que han fallado. La forma de invocar a dichos entornos es:

1. Consola: java -classpath ".;c:\junit3.8.1\junit.jar" junit.textui.TestRunner junit.samples.AllTests

2. Entorno grfico: java -classpath ".;c:\junit3.8.1\junit.jar" junit.swingui.TestRunner junit.samples.AllTests

4.7CaractersticasdelaversinJ2SE5.0
A pesar de encontrarse actualmente el desarrollo de la J2SE en la versin 6 es poco probable que los alumnos del curso trabajen con dicha versin en el mercado actual, como siempre ocurre con todos los productos suele existir un desfase entre lo que se desarrolla y lo que realmente se utiliza.

Por eso presentaremos en este apartado las principales cambios que ofrece la versin 5.0 pues es la versin que mayores cambios ha tenido desde las ltimas versiones (vase como se considera de cambiada la versin que la anterior no es la 4.0 sino que es la 1.4).

Genricos.

Mediante los genricos se permite controlar el tipo de los objetos con los que trabajan sus instancias cuando en su definicin no se quiere concretar el tipo de objeto que contendr, para hacerlo, ms genrico . El siguiente ejemplo nos aportar un poco ms de claridad.

Sin utilizar genricos, cuando trabajamos con una lista lo hacemos del siguiente modo:

6 de febrero de 2008

Tema 1

42

List lista = new LinkedList(); Lista.add( Hola ); String elemento = (String) lista.get(0);

Mediante los genricos actualmente se define la clase LinkedList del siguiente modo:

public class LinkedList<E> extends AbstractSequentialList<E>;

Y se utiliza del siguiente modo:

List<String> listaDeStrings = new LinkedList<String>(); listaDeStrings.add( Hola ); String elemento = listaDeStrings.get(0);

Mediante la utilizacin de genricos el compilador podr controlar el tipo de los elementos y facilitar el trabajo con ellos (casting automtico).

Tipos enumerados.

Los tipos enumerados son un nuevo tipo que se aade a las clases y los interfaces dentro del lenguaje Java y que se caracteriza por tener un nmero finito y normalmente bajo de posibles valores.

Implementan el concepto de constante que hasta ahora se defina mediante variables static final . Este nuevo tipo tiene la siguiente sintaxis:

<modificador> enum NombreTipoEnumerado {valor1, valor2, & }

Un ejemplo sencillo sera:

public enum DiaSemana { LUNES, MARTES, MIERCOLES, JUEVES, VIERNES, SABADO, DOMINGO} 6 de febrero de 2008 Tema 1 43

Anotaciones.

Las anotaciones permiten asociar informacin, en forma de pares atributo-valor, a los elementos de programacin (tipos, mtodos, atributos, paquetes). Las anotaciones son meta-informacin, es decir, informacin sobre el cdigo.

Las anotaciones no modifican la ejecucin de un programa, por lo que slo tienen sentido para programas o herramientas que las extraigan e interpreten. Por ejemplo, el compilador procesa varios tipos de anotaciones predefinidas.

La sintaxis de las anotaciones tiene la forma general:

@TipoAnotacion (nombre1=valor1, nombre2=valor2, & )

Por ejemplo, la anotacin @deprecated sirve para informar al compilador que el mtodo marcado con dicha anotacin va a ser invalidado u obsoleto en futuras versiones de la JDK.

Autoboxing.

En esta versin, la conversin de un valor primitivo a una instancia de su clase (boxing) y al contrario (unboxing) se realiza de forma automtica. Esta nueva facilidad se denomina autoboxing. Antes de la 5.0 En la 5.0

Integer iObjeto = new Integer(1); //boxing Integer iObjeto = 1; //autoboxing int i = iObjeto.intValue(); //unboxing int i = iObjeto; //autoboxing Varargs.

En la nueva versin de Java, se permite declarar mtodos que admitan varios parmetros de un mismo tipo sin determinar la cantidad exacta.

6 de febrero de 2008

Tema 1

44

La sintaxis es: <Tipo>& nombreParametro

Por ejemplo, en el siguiente mtodo se define el parmetro emails que es de longitud variable y podemos pasar el nmero de argumentos de tipo String que se quiera:

public void enviarEmail (String asunto, String& emails) {}

Bucle mejorado (foreach).

Se ha mejorado la sentencia de bucle proporcionando una sintaxis muy sencilla para recorrer los elementos de un array o cualquier estructura que implemente el interfaz Iterable (aunque se sigue manteniendo disponible la sentencia for tradicional). La nueva sentencia tiene la siguiente estructura:

for (TipoElementos elementoAuxiliar : estructuraElementos) { ... }

A continuacin mostramos la versin clsica (izquierda) y mejorada de bucle (derecha): int[] numeros = {1,2,3,4,5,6,7,8,9,10}; for (int i=0; i<numeros.length; i++) { int unNumero = numeros[i]; System.out.println("Nmero: " + unNumero); } Static import. int[] numeros = {1,2,3,4,5,6,7,8,9,10}; for (int unNumero : numeros) { System.out.println("Nmero: " + unNumero); }

Ahora est permitido importar miembros estticos de un tipo, esta nueva funcionalidad se denomina static imports. Con un par de ejemplos veremos ms claramente que se consigue con esta novedad. Antes de la 5.0 System.out.println( Hola Mundo ); En la 5.0 Import static java.lang.System.out; out.println( Hola Mundo ); Tema 1 45

6 de febrero de 2008

Import java.lang.Math; Import static java.lang.Math.*; double d = Math.sqrt(Math.cos(Math.abs(23.45))); double d = sqrt(cos(abs(23.45)));

4.8PatronesdediseoJava
Los patrones de diseo son una disciplina de la ingeniera del software para resolver problemas que surge de la comunidad de orientacin a objetos. Un patrn de diseo define una gua para resolver un problema que se presenta en un contexto determinado. A la definicin del problema junto con la mejor solucin posible se le denomin con el nombre de Patrn de Diseo en el libro Design Patterns Elements of Reusable Software de Gamma, Helm, Jonson y Vlissides (GoF, Gang of Tour) cogiendo dicho concepto del campo de la arquitectura.

En un patrn de diseo se distinguen 4 partes:

1. 2. 3. 4.

Nombre del patrn Descripcin del problema Solucin Consecuencias

Existen diferentes agrupaciones de los patrones de diseo. Por ejemplo, el libro anteriormente mencionado agrupa los patrones en patrones de diseo, de creacin, de particin, de estructura, de comportamiento y de concurrencia.

En este apartado vamos a ver como ejemplo el patrn de diseo Singleton y se deja como ejercicio al alumno que se documente sobre los patrones Factoria, MVC (Model-View-Controller) y Facade por la importancia que estos presentan dentro del mundo J2EE.

PATRN SINGLETON

- Problema: Se necesita limitar el nmero de instancias de un objeto a uno slo. Los clientes que quieran usar dicho objeto compartirn la nica instancia existente. Como ejemplo, esta situacin puede ser 6 de febrero de 2008 Tema 1 46

necesaria cuando se quiere controlar el acceso a un recurso que por su naturaleza no admite el acceso concurrente (impresora, socket, fichero).

- Solucin: Se hace privado el nico constructor del Singleton para evitar que el cliente lo instancie. El cliente obtiene la instancia a travs de un mtodo esttico (getInstance()) que devuelve siempre la misma instancia. Una implementacin posible sera:

public class Singleton { private static Singleton singleton = new Singleton(); /** El constructor es privado para no permitir a otras clases instanciar este objeto. */ private Singleton() { } /** Mtodo esttico que devuelve la nica instancia creable de este objeto */ public static Singleton getInstance() { return singleton; } // Otros mtodos que se necesiten... }

- Consecuencias:

No se pueden crear subclases de un Singleton. Se puede modificar un Singleton para permitir que existan un pequeo nmero de instancias creadas y no slo una.

6 de febrero de 2008

Tema 1

47

5IDEs(IntegratedDevelopmentEnvironment)
En el mercado existe una multitud de IDEs (Integrated Development Environment) o entornos de desarrollo para trabajar con Java. A continuacin se enumeran una serie de ellos aunque la eleccin del IDE adecuado depende del conocimiento del programador Java, de la capacidad de la mquina que tenga, de la tendencia del mercado, del coste del producto, de la empresa en la que se trabaje, etc..., es decir, depende de muchos factores.

La recomendacin sera probar diferentes entornos para conocer los puntos fuertes de cada entorno y as ser capaz de elegir el entorno adecuado dependiendo de las necesidades del proyecto que se fuese a desarrollar.

BLUEJ

Es un IDE diseado especficamente para la enseanza a un nivel introductorio de la programacin orientada a objetos. Posee las funcionalidades bsicas de editar, compilar y depurar. Visualiza el cdigo de nuestro proyecto en UML, mostrando las clases con las relaciones de herencia y dependencia entre ellas.

Esta diseado por la Universidad de Kent en Canterbury y se puede descargar gratuitamente de la direccin http://www.bluej.org.

JCREATOR

Es un IDE que consume muy pocos recursos con lo que puede ejecutarse en mquinas poco potentes, esto se consigue eliminando capacidades de otros IDEs como por ejemplo no tener interfaz visual para el desarrollo de aplicaciones grficas. No obstante, a diferencia de BlueJ este producto si es un IDE que puede ser empleado por un programador profesional.

Existen dos versiones: JCreator LE (gratuito) y JCreator Pro (de pago). Se pueden descargar desde la direccin http://www.jcreator.com.

NETBEANS 6 de febrero de 2008 Tema 1 48

Tanto ste como los siguientes tres IDEs ya son productos completos que requieren mquinas medianamente potentes. Netbeans y Eclipse son productos gratuitos mientras que JDeveloper y IntelliJ IDEA son de pago.

Este IDE permite el diseo de aplicaciones de modo visual a travs de su herramienta Matisse, siendo a partir de la versin 5.5 uno de los mejores editores para el diseo grfico con Java segn lo comentado en Internet.

Es una herramienta Open Source y est respaldada por Sun Microsystems. Se puede descargar de la direccin http://www.netbeans.org.

ECLIPSE

Este es el IDE por excelencia dentro del mundo de desarrollo de Java (en la actualidad). Su gran popularidad se debe a que cuando naci no haba buenos entornos gratuitos de Java que le hiciesen competencia, pero a da de hoy Netbeans le est empezando a hacer sombra.

Esta herramienta en s no es slo un editor Java sino que es un IDE extensible a base de plugins. Existen plugins que permiten configurar este entorno para prcticamente cualquier posibilidad desde hacer que Eclipse sea un editor como Vi, una herramienta de acceso a BD (como TOAD) o incluso un visor de mapas (como Google Maps).

Esta capacidad de adaptar el entorno con plugins es para el desarrollador Java novel una desventaja, pues adems de tener que aprender Java necesita aprender qu plugins necesita y dnde conseguirlos.

Este IDE es un producto de la Eclipse Foundation y puede ser descargado de la direccin http://www.eclipse.org. Los plugins se pueden encontrar en la direccion http://www.eclipseplugincentral.com.

JDEVELOPER e INTELLIJ IDEA

Estos dos son IDEs de pago, el primero es de Oracle y el segundo de JetBrains. En mi experiencia

6 de febrero de 2008

Tema 1

49

como desarrollador no he probado ninguno de los dos por dicho motivo (hay que pagar las licencias) pero se oyen buenos comentarios del IntelliJ IDEA.

JDeveloper puede ser descargado de la direccin http://www.oracle.com/technology/products/jdev/index.html e IntelliJ IDEA de http://www.jetbrains.com/idea.

6 de febrero de 2008

Tema 1

50