Tema 1
Upcoming SlideShare
Loading in...5
×
 

Like this? Share it with your network

Share

Tema 1

on

  • 547 views

 

Statistics

Views

Total Views
547
Views on SlideShare
547
Embed Views
0

Actions

Likes
0
Downloads
6
Comments
0

0 Embeds 0

No embeds

Accessibility

Categories

Upload Details

Uploaded via as Adobe PDF

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

Tema 1 Document Transcript

  • 1. II Curso Online JAVA-J2EE TEMA 1 Introducción a Java
  • 2. Autor: PCYTA / Centro de Excelencia de Software Libre de Castilla-La ManchaVersión: 1.0Fecha: Revisado 07-02-2008 11:46Licencia: CC-by-sa 2.5 0  LicenciaUsted es libre de: Copiar, distribuir y comunicar públicamente la obra Hacer obras derivadasBajo las condiciones siguientes: Reconocimiento. Debe reconocer los créditos 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, sólo puede distribuir la obra generada bajo una licencia idéntica a ésta. • Al reutilizar o distribuir la obra, tiene que dejar bien claro los términos 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.es6 de febrero de 2008 Tema 1 2
  • 3. UNIDAD I. INTRODUCCIÓN A JAVA0 Usted es libre de:............................................................................................................................2 Bajo las condiciones siguientes:.................................................................................................. 21 Introducción 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: características generales...................................................................................................7 1.6 Visión de la plataforma Java..................................................................................................... 72 Conceptos básicos de programación 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................................................................................................................................ 203 Clases y Paquetes en Java........................................................................................................... 23 3.1 Concepto de paquete. Paquetes básicos.................................................................................. 23 3.1.1 Concepto de paquete........................................................................................................ 23 3.1.2 Paquetes básicos...............................................................................................................24 3.2 Gestión de Excepciones.......................................................................................................... 24 3.3 I/O (Entrada/Salida)...............................................................................................................26 3.4 GUI Interfaces Gráficos.......................................................................................................27 3.5 Gestión de Hilos..................................................................................................................... 284 Java Avanzado..............................................................................................................................31 4.1 Librerías: Generación y Utilización........................................................................................ 31 4.2 Internacionalización (I18n).....................................................................................................32 4.3 Instrospection y Reflection.....................................................................................................35 4.4 Seguridad................................................................................................................................36 4.5 Rendimiento............................................................................................................................396 de febrero de 2008 Tema 1 3
  • 4. 4.6 Testing (JUnit)........................................................................................................................ 40 4.7 Características de la versión J2SE 5.0................................................................................... 42 4.8 Patrones de diseño Java.......................................................................................................... 465 IDEs (Integrated Development Environment).......................................................................... 486 de febrero de 2008 Tema 1 4
  • 5.  1 Introducción a Java  1.1 POO. Clases y Objetos • Objetos: o Elementos que comparten dos características: el estado y el comportamiento. o Objeto como una pieza de programación que mantiene un estado mediante los atributos y que expone su comportamiento mediante los métodos. • Encapsulación: Permite ocultar el estado interno del objeto y ofrece maneras de interactuar con el mediante los métodos. • Clase: Es un conjunto de objetos con propiedades (atributos y/o métodos) 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 instanciación 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 definición de una clase permite que los atributos y los métodos compartidos se definan una sola vez, en la clase, y no en cada uno de los objetos.  1.2 POO. Herencia La herencia es la propiedad por la cual las subclases asumen como propios los atributos ymétodos definidos en las superclases. O dicho de otra forma, herencia es la capacidad de un objeto(clase) para utilizar las estructuras y los métodos existentes en antepasados o ascendientes. Utilidad: • conseguir una mayor reutilización de código (no será necesario volver a programar los métodos 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 código 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 5
  • 6. Herencia múltiple: una clase tiene más de un ascendiente inmediato.La herencia múltiple presenta problemas de colisión cuando las superclases tienen las mismosatributos y/o métodos definidosJava únicamente permite la herencia simple  1.3 PolimorfismoSe define polimorfismo como la capacidad de que una variable cambie su comportamientodependiendo del objeto al que haga referencia. Esta propiedad permite que varios objetos dediferentes subclases sean tratados como objetos de una única superclase, y que automáticamente seseleccione el método adecuado a ejecutar dependiendo de la subclase a la que pertenezca.(Se implementa cuando en la superclase definimos un método abstracto que heredan las subclases,las cuales lo implementan de distinta manera (mismo nombre))  1.4 Ventajas de la POO 1. Enfoque más 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 más fácil pensar en términos de objetos, y la comunicación entre ambos es más fluida. 2. Encapsulación: la interacción con los objetos únicamente se puede realizar mediante los6 de febrero de 2008 Tema 1 6
  • 7. métodos lo que permite mantener la implementación interna oculta. 3. Abstracción: la orientación a objetos consiste en aplicar diferentes capas de abstracción en la modelización de una realidad, identificando sucesivamente los conceptos de objeto, clase y superclase en sus diferentes grados de iteración. 4. Reutilización: debido a ese proceso de abstracción, las clases se diseñan para que se puedan reutilizar en muchos sistemas. En este sentido es fundamental el concepto de librerías o bibliotecas de clases. 5. Menor acoplamiento: las aplicaciones orientadas a objetos tienen un bajo nivel de acoplamiento debido a la propiedad de encapsulación que tienen los objetos. Ello hace que las modificaciones de un objeto no afecten a los demás. 6. Mayor cohesión: Los objetos presentan una alta cohesión, justamente porque integran una colección de datos muy relacionados y los procesos susceptibles de acometerse entre ellos. 7. Mayor capacidad funcional: el bajo acoplamiento y la alta cohesión de los objetos hacen factible que un sistema inicialmente complejo pueda ser descompuesto más fácilmente en diferentes capas de clases y subclases, cada una con un grado de complejidad menor. Es posible desarrollar aplicaciones muy avanzadas conceptualmente pero técnicamente sencillas.  1.5 Java: características generales Java es un lenguaje sencillo, orientado a objetos, distribuido, interpretado, robusto, seguro,de arquitectura neutral, portable, alto rendimiento, multihebra y dinamico.  1.6 Visión de la plataforma Java1. Como lenguaje de programación.Como lenguaje de programación, Java se considera un lenguaje de alto nivel con las característicasenumeradas 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 concualquier otro tipo de lenguaje de programación.2. Como entorno de desarrollo.Como entorno de desarrollo, Java proporciona una variada cantidad de herramientas:6 de febrero de 2008 Tema 1 7
  • 8. • compilador (javac) • interprete (java) • generador automático de documentación (javadoc) • empaquetador de librerías (jar) • visor de applets (appletviewer) • etc...3. Como entorno de despliegue y ejecución de aplicaciones.Todas las aplicaciones Java requieren para poder ejecutarse que se encuentre instalado en lamáquina destino el JRE o entorno de ejecución 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 librerías de clases (clases básicas, para I/O, GUI, etc.). • El otro entorno de despliegue y ejecución más conocido es el navegador web. La mayoría de los navegadores (IE, Mozilla, Opera, etc) proporcionan un intérprete y el entorno de ejecución.4. Como plataforma comercial.A lo largo del tiempo Java ha ido evolucionando y SUN ha ido redefiniendo los productos queofrecía. Actualmente, podemos distinguir tres tipos de plataformas ofrecidas por SUN quepretenden cubrir los distintos sistemas sobre los que pueden ejecutarse aplicaciones:6 de febrero de 2008 Tema 1 8
  • 9. • J2ME (Micro Edition): pretende cubrir el segmento de mercado de las pequeños dispositivos como PDAs y teléfonos móviles que se caracterizan por las restricciones tanto de memoria como de capacidad de procesamiento. • J2SE (Standard Edition): la versión estándar es la que todos conocemos, desarrollo de aplicaciones genéricas para ordenadores y servidores. • J2EE (Enterprise Edition): la versión 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 versión es una ampliación de la versión estándar. 2 Conceptos básicos de programación con Java  2.1 Diseccionando el programa HolaMundoEste es el código de la aplicación: public class HolaMundo6 de febrero de 2008 Tema 1 9
  • 10. { /** * Primera aplicación 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 aplicación:1. public class HolaMundo { - Indica el nombre de la clase HolaMundo . - En Java, todo el código debe encontrarse dentro de la declaración 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 símbolo } (utilizados en las líneas 8 y 9). - Se pueden anidar bloques de forma indefinida.2. /**3. * Primera aplicación Java4. */ - Estas tres líneas indican un comentario en Java. - En Java se distinguen tres tipos de comentarios: 1. Comentarios Javadoc (el de estas líneas, se utilizan para generar documentación6 de febrero de 2008 Tema 1 10
  • 11. HTML de forma automática con la herramienta javadoc). 2. Comentarios de estilo C++ (el que vemos en la línea 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 método main es el punto de inicio de un programa Java, desde este método se llamaran a los demás métodos que se indiquen en el mismo. - Todos los programas (excepto los Applets) se inician en el método main. - Los parametros que se pasan cuando se realiza la llamada a la clase desde la línea de comandos se encuentran en el array args.7. System.out.println( Hola Mundo ); - Esta instrucción muestra en línea de comandos el texto Hola Mundo . - El ; (punto y coma) sirve para separar instrucciones.Los ficheros en Java tienen que finalizar siempre con la extensión .java. El nombre del fichero debecoincidir con el nombre de la clase pública que contenga. Así, si la clase se llama HolaMundo elfichero donde se guarda la clase tiene que llamarse HolaMundo.java.  2.2 Tipos de datos, variables y Arrays  2.2.1 Tipos de DatosExisten dos tipos: los tipos primitivos y los tipos de referencia. Los tipos primitivos son valorespropios que se mantienen en las variables, mientras que los tipos de referencia contienen valores queapuntan o identifican arrays u objetos. Tipos primitivos. 1. Enteros: almacenan números enteros, sin 2. Reales: almacenan números reales, es decir, parte decimal. Java proporciona cuatro tipos números con parte fraccionaria. Hay dos tipos. de enteros.6 de febrero de 2008 Tema 1 11
  • 12. Tipo Tamaño Rango Tipo Tamaño Rango byte 8 bits -27 a 27-1 float 32 bits -231 a 231-1 short 16 bits -215 a 215-1 double 64 bits -263 a 263-1 int 32 bits -231 a 231-1 long 64 bits -263 a 263-1 3. Caracteres: en Java hay un único tipo de carácter: char. Cada carácter 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.2 VariablesJava requiere que se declaren los tipos de todas las variables empleadas, además, necesitan serinicializadas antes de usarlas. La siguiente instrucción declara e inicializa una variable de tipoentero: int i = 0;El alcance de una variable en Java viene definido por el bloque de código en el que se definió.Como sabemos los bloques empiezan con { y terminan en } , por lo que la variable dejará deexistir cuando se cierre el corchete que esté justo antes que ella en el código.  2.2.3 ArraysEn Java los arrays son objetos. Como tales se crean mediante el comando new. La sintaxis en ladefinición de un array es la siguiente: Tipo_dato[] nombre_array = new tipo_dato[tamaño_array];donde, tipo_dato es el tipo de los datos que se almacenarán en el array (int, char, & o cualquierobjeto) y tamaño_array es el tamaño que se quiere dar al array. Por ejemplo, la siguiente instruccióncrea 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
  • 13.  2.3 Operadores, expresiones y control de flujo  2.3.1 OperadoresLos Operadores son símbolos especiales que realizan operaciones específicas entre uno, dos otres operandos y devuelven un resultadoTipos de operadores que existen en Java en orden de precedencia: Tipo de operador Símbolo operador Unitarios ++ -- ~ ! Aritméticos */%+- Desplazamiento << >> >>> <<< Relacionales < > <= >= instanceof Igualdad == != Lógicos (nivel bit) &|^ Lógicos && || Ternario ?: Asignación = += -= *= /= %= &= ^= |= <<= >>= >>>=  2.3.2 ExpresionesUna expresión es una construcción formada por variables, operadores e invocaciones amétodos que cumple con las restricciones sintácticas del lenguaje y que devuelve un únicoresultado. A continuación se muestran ejemplos de expresiones: int resultado = 1 + 2; if (valor1 == valor2) System.out.println("hola");  2.3.3 Control de flujoSentencias condicionales.6 de febrero de 2008 Tema 1 13
  • 14. Ejecutan un código u otro en función de que se cumpla o no una determinada condición. Veamosque 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 repetición.Estas instrucciones estarán repitiendo un bloque de instrucciones definido hasta que la condición seevalúe 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
  • 15. for (inicialización; condición; siguientepaso) { bloque_de_instrucciones; }Sentencias de ruptura.Dentro del cuerpo de una sentencia de iteración se puede controlar el flujo del bucle mediante lasinstrucciones break y continue. Break finaliza el bucle y continue pasa a la siguiente iteración.La instrucción return tiene dos propósitos: especifica el valor que va a devolver un método (en elcaso de que tenga que hacerlo) y provoca la devolución de ese valor de forma inmediata.  2.4 Objetos y clasesUna clase es un conjunto de objetos con propiedades (atributos y/o métodos) 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] { Declaración de atributos; Declaración de constructores; Declaración de métodos; }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 verán a continuación. 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 más de una.6 de febrero de 2008 Tema 1 15
  • 16. Modificadores de acceso.Define el control de acceso a la clase declarada desde otras clases. Tiene 4 valores posibles: • Public: clase pública 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.Declaración de atributos.La estructura para declarar variables es: [modificador] [static] [final] <tipo_dato> nombreVariable [=<valor por defecto>];Según 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 común 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 permitencontrolar el acceso a los atributos desde otras clases. Toman los mismos valores y significado quelos explicados arriba para la definición de clases.Declaración de métodos.La estructura para declarar métodos es:6 de febrero de 2008 Tema 1 16
  • 17. [modificador] [static] [abstract] <tipo_dato_devuelto> nombreMetodo ([parámetros]) {}Existen varios tipos de métodos: • Constructores: métodos que se invocan cuando se genera un nuevo objeto con la instrucción new . • Métodos de clase: pertenecen a la clase y se pueden invocar llamando directamente a la clase. Se utiliza la etiqueta static. • Métodos de instancia: los métodos de los objetos y que se necesita tener un objeto para poder llamarlos. • Métodos abstractos: métodos que no tienen ninguna implementación. Se utiliza la etiqueta abstract.Aquí, igual que las clases y los atributos, los modificadores de acceso permiten controlar el acceso alos métodos desde otras clases.En Java se pueden sobrecargar los métodos, es decir, se pueden definir dentro de una misma clasemás de un método que tenga el mismo nombre pero distinto tipo y/o número de parámetros. Acontinuación 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
  • 18. } ... }La variable this es una variable de sólo lectura que proporciona Java y que contiene una referenciaal objeto en el que se usa dicha variable.Los objetos son instancias de las clases. Para poder programar con los objetos en lenguaje Java esnecesario realizar los tres pasos siguientes: 1. Declaración del objeto. 2. Instanciación: la palabra clave new es la instrucción Java que crea el objeto. 3. Inicialización: new está seguido obligatoriamente por la llamada un método constructor que inicializa el objeto.Estos tres pasos se pueden realizar mediantedos instrucciones: Object nuevoObjeto; nuevoObjeto = new Object();o bien, en una sola instrucción: Object nuevoObjeto = new Object();Una vez realizado estos pasos podremos invocar tanto los atributos como los métodos del objeto dela siguiente forma: objeto.nombreVariable; objeto.nombreMetodo(); Recomendaciones a la hora de nombrar las clases, los atributos y los métodos:6 de febrero de 2008 Tema 1 18
  • 19. • Elige nombre que tengan algún significado. Se deben evitar utilizar nombres del estilo XYZ. • Las clases deben empezar con mayúsculas (Persona, Circulo, Coche, ClienteOro, etc). • Los atributos son identificadores que deben empezar en minúsculas (edad, modelo, color, direccionesFacturacion, etc). • Los métodos deberían ser verbos que identifiquen un comportamiento y también deberían empezar con minúsculas (pintar, arrancarCoche, frenar, obtenerFactura, etc). • Comentar los métodos para explicar que función realizan (se debería utilizar el estilo Javadoc).  2.5 HerenciaLa herencia es el medio mediante el cual una clase hija (subclase) hereda las variables y losmétodos definidos en la clase padre (superclase) de forma automática.En Java, para indicar que una clase hereda de otra se utiliza la etiqueta extends . Veamos unejemplo: public class Persona { public class Alumno extends Persona { String nombre; int edad; //método constructor // método constructor public Alumno(){} public Persona() { nombre = ; } edad = 0; .... } }Todas las clases tienen un padre único y directo (herencia simple). En ausencia de declaraciónexplicita de ninguna superclase la clase padre será Object que es la clase de que heredan todos lasclases definidas en Java.Al igual que vimos la variable this que era creada automáticamente por Java para referenciar al6 de febrero de 2008 Tema 1 19
  • 20. propio objeto, Java también proporciona la variable super que apunta a la superclase de la cualderiva nuestra clase.  2.6 InterfacesUn método abstracto es un método que no se ha implementado, es decir, que el cuerpo de dichométodo está vacío. Para definir un método abstracto se utilizar la etiqueta abstract . El siguientemétodo es un ejemplo de método abstracto: public abstract void metodoAbstracto();Una clase es abstracta si contiene uno o más métodos abstractos. Una clase abstracta no puedeser instanciada (se produciría un error de compilación) y serán las subclases las encargadas deimplementar dichos métodos abstractos.Vamos a ver un ejemplo de clase abstracta y las subclases que implementan los métodos 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 método abstracto. public class Hombre extends SerVivo { public void moverse () { System.out.println("caminar..."); } }6 de febrero de 2008 Tema 1 20
  • 21. 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 contieneconstantes y métodos abstractos, es decir, métodos que no se encuentran implementados.Estas interfaces no se pueden instanciar y sólo pueden ser implementadas por clases o por otrasinterfaces.Según esta definición, ¿para que sirve tener una entidad parecida a una clase si no puede serinstanciada? A continuación vamos a enumerar la motivación de las interfaces.Primero, mediante las interfaces ofrecemos la funcionalidad de un objeto sin revelar suimplementación. Este cumple el concepto básico de encapsulación, permite modificar laimplementación sin afectar a las clases invocadoras y las clases que llaman no tienen que conocer laimplementación en tiempo de compilación.Segundo, permite que clases que no se encuentren relacionadas por herencia tengancomportamientos similares.Y tercero, mediante las interfaces podemos modelizar la herencia múltiple que no está permitida enJava. Una clase pueden implementar varias interfaces pero sólo puede heredar de una superclase.La forma general para definir una interface es similar a la de las clases: [modificador] interface nombreInterface [extends (interfacePadre)+] { Declaración de constantes; Declaración de métodos abstractos; } Interfaces o clases abstractas.6 de febrero de 2008 Tema 1 21
  • 22. - Todos los métodos de un Interface son abstractos mientras que las clases abstractas pueden tener métodos abstractos o no. - Una interface sólo puede tener constantes mientras que una clase abstracta puede tener atributos. - Las interfaces no tienen relación con ninguna clase en particular, se definen de forma independiente. Por el contrario, las clases abstractas proporcionan una implementación parcial de la clase, dejando a las subclases completar la implementación.6 de febrero de 2008 Tema 1 22
  • 23.  3 Clases y Paquetes en Java  3.1 Concepto de paquete. Paquetes básicos  3.1.1 Concepto de paqueteUn paquete es una agrupación de clases e interfaces que proporciona protección de acceso ygestión del espacio de nombres. A continuación resumimos las ventajas de agrupar las clases enpaquetes: • Los programadores pueden agrupar en paquetes clases e interfaces que se encuentren relacionados, por ejemplo, agrupar las clases e interfaces que proporcionen la funcionalidad gráfica. • La creación de un paquete genera un nuevo espacio de nombre (namespace) con lo que se evitarán conflicto entre nombres idénticos de clases e interfaces en distintos paquetes. • Mediante la utilización de los paquetes y los modificadores de acceso de las clases se pueden gestionar el acceso público o restringido entre clases de diferentes paquetes.Para crear un paquete se utiliza la etiqueta package al inicio de los ficheros que definan clases ointerfaces indicando el nombre del paquete al que se quiere que pertenezcan dichas clases einterfaces. Por ejemplo, la clase Circulo pertenecería al paquete figuras: package figuras; public class Circulo { // Definición de variables y métodos de la clase Circulo } Si no se incluye la etiqueta package la clase no pertenecerá a ningún paquete. Se recomienda que todos los ficheros (clases e interfaces) pertenezcan a algún paquete.Los paquetes pueden estar anidados formando una jerarquía de paquetes. En este caso, el intérpretede Java espera que la estructura de directorios coincida con la jerarquía de paquetes. Por ejemplo, laclase Circulo de arriba debería encontrarse dentro de un directorio con el nombre figuras.6 de febrero de 2008 Tema 1 23
  • 24.  3.1.2 Paquetes básicosEn Java, las clases e interfaces se agrupan en paquetes y el conjunto de todos los paquetes quevienen con la distribución se conoce como el API (Interface de Programación de Aplicaciones)de Java. En la siguiente imagen extraída de la documentación de la JDK 1.5 podemos ver lospaquetes que vienen con la distribución:Para poder tener un mayor detalle de cada uno de los paquetes que componen el API se remite alalumno a la documentación mencionada que se puede descargar y consultar desde la página de Sun(http://java.sun.com/j2se/1.5.0/docs/index.html).  3.2 Gestión de ExcepcionesJava utiliza las excepciones para permitir gestionar los errores y otras situaciones anormales deuna aplicación.Estas excepciones (que, evidentemente, son objetos) generadas por Java son errores que se producenen tiempo de ejecución y que provocan que el flujo normal del programa se interrumpa. Estos6 de febrero de 2008 Tema 1 24
  • 25. errores pueden variar desde errores por división entre cero o que se sobrepasen los límites de unarray hasta la falta de memoria o problemas de acceso al disco.Cuando un método crea o lanza (throw) una excepción se busca un gestor (handler) para que seatratada. Si se encuentra un gestor adecuado la ejecución del programa pasa a ese punto,conociéndose este proceso como captura de la excepción (catch). Si no se encuentra ningún gestoradecuado para dicha excepción entonces el programa finaliza.La gestión de errores mediante excepciones presenta las siguientes ventajas: • Mantener separado el código que gestiona los errores del código de negocio. • Se propagan los errores a través de la pila de llamadas a los métodos. Aquel método que realmente esté interesado en el error será el encargado de implementar el gestor adecuado (handler). • Permiten agrupar por tipologías de error.Para realizar la gestión de excepciones, Java proporciona la estructura try-catch-finally quepresenta el siguiente formato: try { <código monitorizado por los gestores de excepción> } catch (<ExceptionTipo1> <ObjName1>) { <gestor si ocurre la ExceptionTipo1 > } ... catch (<ExceptionTipoN> <ObjNameN>) { <gestor si ocurre la ExceptionTypeN > } finally { <código que siempre es ejecutado> }Si un método puede causar una excepción está obligado a capturarla o a lanzarla mediante la palabraclave throws en la declaración del método con la siguiente sintaxis:6 de febrero de 2008 Tema 1 25
  • 26. <tipo_dato_devuelto> nombreMetodo ([parámetros]) throws [exceptionList] {}  3.3  I/O (Entrada/Salida)En este apartado vamos a revisar la forma y las clases que proporciona Java para poder llevar a caboel proceso de entrada y salida de datos. Debemos tener en cuenta que estos procesos son hartocomplejos no sólo por la diversidad de fuentes de entrada y salida (ficheros, consola, conexiones dered) sino también por la variedad de formas de comunicarse con estas fuentes (secuencial, aleatoria,binaria, caracteres, líneas, etc.).Los diseñadores de Java crearon clases para tratar estos procesos y las agruparon en el paquetejava.io. La verdad, es que crearon demasiadas clases por lo que tratar con este paquete y saber queclase debo utilizar para mi aplicación a veces es difícil.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 delfichero. El fichero físico puede o no existir.Mediante esta clase podemos realizar operaciones con los ficheros del tipo de borrado, renombradoo cambio de permisos. Además, esta clase también permite referenciar a un directorio y realizaroperaciones con directorios (crear, borrar, etc).InputStream y OutputStream.Las clases que heredan de estas permiten leer y escribir datos binarios. Las entradas y salidas dedatos pueden ser muy diversas lo que provoca que existan multitud de subclases. La mayoría de lassubclases se utilizan de la misma forma y únicamente se diferencian en la forma de su creación.Reader y Writer.6 de febrero de 2008 Tema 1 26
  • 27. Las clases que heredan de estas permiten leer y escribir caracteres Unicode. Ocurre la mismaproblemática con la multitud de formas de entrada y salida y se generan igualmente gran cantidadde 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.4 GUI – Interfaces GráficosLa parte de Java SDK que se dedica a agrupar las clases que se utilizan para simplificar eldesarrollo del entorno gráfico (GUI) se denomina JFC (Java Foundation Classes).Consiste, básicamente, en el conjunto de cinco APIs: • AWT (Abstract Window Toolkit): aporta los componentes necesarios para crear entornos gráficos (ventanas, botones, menús, etc.). • Swing: al igual que AWT aporta componentes para crear las interfaces gráficas. A continuación veremos en que se diferencian estos dos APIs. • Java2D: permite al programador incluir fácilmente gráficos, textos e imágenes 2D.6 de febrero de 2008 Tema 1 27
  • 28. • 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 lasinterfaces gráficas son AWT y Swing. La siguiente tabla muestra las diferencias entre los dos APIs. AWT SWING • Algunos componentes AWT • Los componentes están escritos en utilizan código nativo. Java • Es dependiente de la plataforma. • Es independiente de la plataforma. • Presentan el mismo look&feel de • Aseguran que el look&feel de los la plataforma sobre la que se componentes sea igual ejecutan. independientemente de la plataforma.La siguiente tabla presenta los componentes más utilizados y el nombre de las clases que losimplementan en AWT y SWING. Componente AWT SWING Ventana con titulo, menú, Frame JFrame bordes y reescalable Etiqueta Label JLabel Campo de texto TextField JTextField Botón Button JButton Lista de opciones CheckBox JCheckBox Lista desplegable List JList  3.5 Gestión de HilosLa plataforma Java está diseñada desde su origen para ser capaz de soportar la programación6 de febrero de 2008 Tema 1 28
  • 29. concurrente. Este apartado introduce la forma que plantea Java para permitir la concurrencia yresume 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 ejecución completo que tiene su propio conjunto de recursos, en particular, su propio espacio de memoria. • Un proceso suele ser sinónimo de un programa. • Los threads se conocen como procesos ligeros. Tanto los procesos como los threads proporcionan un entorno de ejecución, pero crear un nuevo thread implica menos recursos que crear un nuevo proceso. • Un thread pertenece siempre a algún 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 comunicación más eficiente pero potencialmente insegura.Todas las aplicaciones de Java se inician con un thread que se denomina main thread . Este threadtiene la capacidad de crear otros threads adicionales que permitirían tener varios hilos en ejecuciónde forma concurrente.Cada uno de los threads que se ejecutan está asociado con una instancia de la clasejava.lang.Thread. Existen dos estrategias básicas para utilizar los Threads y crear aplicacionesconcurrentes: • Crear una clase que extienda de la clase Thread y sobreescribir su método run. En este método va el "cuerpo del thread", es decir, el código que se va a comportar como thread. El resto de métodos de la clase serán normales. • Implementando el interface Runnable, interface que posee un único método run que debemos sobrescribir.Para ejecutar un thread nunca debemos llamar directamente al método run, hemos de llamar almétodo start y ya se encargará éste de llamar a run. Si llamamos directamente a run, éste seejecutará como un método normal y no en un nuevo thread.6 de febrero de 2008 Tema 1 29
  • 30. 6 de febrero de 2008 Tema 1 30
  • 31.  4 Java Avanzado  4.1 Librerías: Generación y UtilizaciónEn Java se ha definido el formato JAR (Java ARchive) que permite unir varios archivos en unosolo. Cada archivo JAR va a contener una serie de clases e interfaces relacionados. Estos ficherosJAR también se les conoce con el nombre de librerías.A continuación vamos a resumir que beneficios se obtienen utilizando dicho formato: • Compresión: los archivos JAR comprimen los ficheros para un almacenaje más eficiente. • Reducción de la descarga: por ser un fichero comprimido la descarga de un archivo JAR será más rápida que tener que descargarnos cada uno de los ficheros que lo componen. • Versionado: los ficheros JAR mantienen un fichero denominado manifest que mantienen información relativa al proveedor y la versión. • 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 losprogramas 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 línea de comandos y dependiendo de los parámetrosrealizará una u otras acciones. La siguiente tabla resume las acciones más comunes: Comando Acción jar cf <fichero.jar> <ficheros_entrada> Crear un fichero JAR. jar tf <fichero.jar> Ver el contenido de un fichero JAR. jar xf <fichero.jar> Extraer el contenido de un fichero JAR. jar xf <fichero.jar> Extraer unos ficheros específicos de un <ficheros_para_extraer> fichero JAR. java -jar aplicacion.jar Ejecutar una aplicación que se encuentra empaquetada en un fichero JAR (es necesario que el fichero de manifiesto6 de febrero de 2008 Tema 1 31
  • 32. tenga especificado el Main-class)El fichero de manifiesto MANIFEST.MFCuando se crea un fichero JAR, automáticamente se añade un fichero de manifiesto. Cada ficheroJAR sólo puede contener un fichero de manifiesto y tiene la siguiente ruta: META-INF/MANIFEST.MFAl 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 seespecifica la versión del manifiesto y la versión de la JDK.Además de estos valores, en el fichero de manifiesto podemos guardar información relacionada conla librería, referenciar a otras librerías que se utilicen, especificar el punto de entrada de unaaplicación, firmar digitalmente, etc. Veamos un ejemplo más 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.2 Internacionalización (I18n)La internacionalización es el proceso de diseñar una aplicación para que sea fácilmenteadaptable a otros lenguajes, también se suele utilizar el término de aplicación multiidioma. EnJava, el término internacionalización se abrevia con i18n porque hay 18 letras entre la primera i y la6 de febrero de 2008 Tema 1 32
  • 33. última n.¿Qué características tiene que cumplir una aplicación para que sea internacionalizable? • El mismo código tiene que utilizarse para los distintos idiomas, únicamente se indicará el idioma mediante algún parámetro. • Si se añade un nuevo idioma no debe ser necesario recompilar el código. • Los textos que aparezcan en la aplicación (formularios de entrada de datos, listados con resultados de consultas, etc) no deben estar escritos en el código. Se utilizarán otros ficheros de textos donde se guarden dichos textos. • Además de los textos, se han de tener en cuenta los datos dependientes de cada país, por ejemplo, las fechas y las monedas.A continuación, vamos a ver un sencillo ejemplo que permitirá comprender los pasos necesariospara diseñar aplicaciones internacionalizadas con Java.Nuestro ejemplo va a mostrar el texto Hola Mundo pero tiene que hacerlo en tres idiomas(español, inglés y francés) dependiendo de parámetros de entrada de la línea de comandos. Unaversión no internacionalizada sería: 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 más evidente de esta forma de implementación es que si queremos incluir otro idiomavamos a necesitar modificar la clase y recompilar el código.Mediante los siguientes pasos vamos a ver como internacionalizar dicho código y evitar este6 de febrero de 2008 Tema 1 33
  • 34. problema.1. Crear los ficheros de properties.Se tiene que crear un fichero de properties para cada uno de los idiomas. El fichero propertiescontendrá líneas de pares "clave = valor" donde la clave se utilizará en el código y el valor será eltexto en el idioma del fichero. Para nuestro ejemplo tendríamos:Nombre Mensajes_es_ES.properties Mensajes_en_GB.properties Mensajes_fr_FR.propertiesdel ficheroContenido saludo=Hola Mundo saludo=Hello World saludo=Bonjour Monde2. Definir el Locale.El objeto Locale identifica un idioma y un pais. Las siguientes instrucciones definen un Locale parael 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 idiomaque identifique el Locale.4. Recuperamos del ResourceBundle el texto.Utilizando los métodos proporcionados por la clase ResourceBundle (getString()) obtenemos eltexto correspondiente.A continuación vemos el código completo de nuestra aplicación internazionalizada donde seidentifican cada uno de los pasos que implican la internacionalización. import java.util.*; public class SaludoI18N { static public void main(String[] args) { String idioma;6 de febrero de 2008 Tema 1 34
  • 35. String pais; Locale locale; ResourceBundle mensajes; // Definimos el Locale según 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 aplicación va más 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. - Números. - Monedas. - Imágenes. - Sonidos. - Etc.  4.3 Instrospection y ReflectionSimplemente vamos a indicar que son estas dos APIs de Java por la gran aplicación que tienendentro del desarrollo de frameworks (Struts, Spring, ...) e IDEs, pero no se entrará en profundidadpor ser funcionalidades complejas que requieren un alto dominio del lenguaje Java por parte deldesarrollador por lo que no deben ser usadas de forma trivial.Instrospection y reflection son utilidades que ofrece Java para permitir a un objeto obtener6 de febrero de 2008 Tema 1 35
  • 36. información sobre si mismo u otros objetos en tiempo de ejecución.Se define reflection como el hecho de mostrar una imagen de . En Java, mediante ésta técnica sepermite: • Construir nuevas instancias de clase y nuevos arrays. • Acceder y modificar los atributos de objetos y clases. • Invocar los métodos de objetos y clases. • Acceder y modificar los elementos de los arrays.Estas acciones se pueden realizar mediante la programación orientada a objetos sin necesidadde utilizar reflection, entonces ¿cuál es la diferencia? Que mediante el uso de la reflection un objetopuede hacer las acciones anteriores sobre otros objetos o sobre si mismo sin conocer sobre queobjetos o clases lo va a realizar en tiempo de compilación sino que será en tiempo de ejecucióncuando 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, lainstrospection se utiliza para permitir a un Bean descubrir propiedades, métodos y eventos de otrosBeans en tiempo de ejecución.Reflection e instrospection están íntimamente relacionadas. Reflection es una facilidad de bajo nivelque permite implementar código para examinar el interior de cualquier clase y objeto en tiempo deejecución. Instrospection se basa en esta facilidad y proporciona un medio más adecuado paraexaminar internamente los Beans.  4.4 SeguridadDesde su creación el entorno Java ha tenido presentes los problemas de seguridad y ha definido unmodelo para controlar y limitar el acceso a los recursos desde los programas y aplicaciones. Elmodelo de seguridad ha ido evolucionando con las distintas versiones, pasando de un modelo muysencillo y restrictivo, el del JDK 1.0, a uno más complejo y flexible desde la aparición del JDK 1.2.Java fue diseñado para ofrecer las siguientes medidas de seguridad básicas:6 de febrero de 2008 Tema 1 36
  • 37. • Uso de un lenguaje de programación seguro. Mediante características como la eliminación de la aritmética con punteros, la comprobación de rangos en el acceso a vectores o la liberación de memoria de forma dinámica. • Integración 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. • Encriptación y uso de certificados. Se definen mecanismos para que los programadores puedan firmar el código, de manera que los usuarios puedan verificar quien es el propietario del código y que este no ha sido modificado después de ser firmado.La seguridad se basa en tres componentes fundamentales del entorno de ejecución: 1. El cargador de clases (Class Loader), que determina como y cuando pueden cargar código 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 código 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 parámetros de tipos correctos. 3. El gestor de seguridad (Security Manager), que controla el acceso a los recursos en tiempo de ejecución. Los recursos sobre los que tiene control son múltiples: E/S de red y ficheros, creación de cargadores de clases, manipulación de hilos de ejecución, ejecución de programas externos (del SO), detener la JVM, cargar código nativo en la máquina virtual, realizar determinadas operaciones en el entorno de ventanas o cargar ciertos tipos de clases.Vamos a resumir a continuación como ha ido evolucionando la seguridad en las distintas versiones.Seguridad en el JDK 1.0El modelo de seguridad original de la plataforma Java es el conocido como el modelo del cajón dearena (sandbox model), que proporcionaba un entorno muy restringido en el que ejecutar código nofiable obtenido de la red.En este modelo trabajamos con dos niveles de acceso a los recursos: total, para programas locales, omuy restringido, para programas remotos. La seguridad se consigue gracias al empleo del cargadorde clases, el verificador de clases y el gestor de seguridad.6 de febrero de 2008 Tema 1 37
  • 38. La pega fundamental de este modelo es que es demasiado restrictivo, ya que no permite que losprogramas remotos hagan nada útil, por estar restringidos al modelo del cajón de arena.Seguridad en el JDK 1.1Como el modelo del JDK 1.0 era demasido restrictivo se introdujo el concepto de código remotofirmado, que sigue garantizando la seguridad de los clientes, pero permite que código obtenidoremotamente salga del cajón y tenga acceso a todos los recursos, siempre y cuando esté firmado poruna entidad en la el cliente confía.Además del código firmado, el JDK 1.1 introdujo otras mejoras de seguridad, un par deherramientas de seguridad (jar y javakey) y un API para programación segura que introdujopaquetes de clases que proporcionan funciones criptográficas a los programadores.Seguridad en Java 2En el JDK 1.2 (Java 2) se han introducido nuevas características que mejoran el soporte y el controlde 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 sólo contempla dos niveles de permisos: acceso total o cajón de arena. Para solventar el problema el JDK 1.2 introduce un sistema de control de permisos de grano fino que permite dar permisos específicos a trozos de código específicos para acceder a recursos específicos en el cliente, dependiendo de la firma del código y/o el URL del que este se obtuvo. • Control de acceso aplicado a todo el código. El concepto de código firmado es ahora aplicable a todo el código, independientemente de su procedencia (local o remoto). • Facilidad de configuración de políticas de seguridad. La nueva arquitectura de seguridad permite el ajuste sencillo de los permisos de acceso usando un fichero de políticas (policy file) en el que se definen los permisos para acceder a los recursos del sistema para todo el código (local o remoto, firmado o sin firmar). Gracias a ello, el usuario puede bajar aplicaciones de la red, instalarlas y ejecutarlas asignándoles sólo 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 añadir un nuevo método6 de febrero de 2008 Tema 1 38
  • 39. check a la clase del gestor de seguridad. Esta versión permite definir permisos tipo que representan un acceso a recursos del sistema y el control automático de todos los permisos de un tipo correcto, lo que repercute en que, en la mayoría de casos, se hace innecesario añadir métodos al gestor de seguridad.En el Java 2 han aparecido o se han mejorado las herramientas y el API de seguridad.  4.5 RendimientoEn este apartado se pretenden dar una serie de recomendaciones a los alumnos para que cuandodesarrollen aplicaciones con Java tengan en cuenta el rendimiento de las mismas.Utilizar datos primitivos u objetos.Cuando tengamos opción 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 seutilicen operaciones internas intermedias que repercuten en pérdida de tiempo. En aquellasaplicaciones donde se realicen concatenaciones con Strings se recomienda utilizar objetosStringBuffer.Java Collections.En Java los objetos Vector y Hashtable tienen sus métodos sincronizados por lo que al utilizarlospagamos el coste de este control cuando sólo es necesario si tenemos varios threads accediendoconcurrentemente. El objeto Vector puede sustituirse por ArrayList o LinkedList y el objetoHashtable por HashSet o HashMap que son objetos no sincronizados y más eficientes.Bloques try-catch.6 de febrero de 2008 Tema 1 39
  • 40. La gestión de excepciones con bloques try-catch no es gratuita por lo que se recomienda no utilizardicha estructura sin tener un planteamiento claro de que se quiere controlar. Es preferible no abusarde estos bloques cuando se puede tener el código controlado con la lógica normal del programa.Controlar la escritura en consola.Se recomienda no abusar de la escritura en consola (System.out.println()) sino que es preferiblecontrolar mediante gestores de logs todas las trazas que necesite generar nuestra aplicación.Evitar tener código que no se utilice.La creación de objetos o las llamadas a ciertos métodos pueden costar su tiempo en ejecutarse ymuchas veces no son necesarios y aparecen únicamente por arrastrar código obsoleto.Reutilizar los objetos creados en vez de estar creando nuevos objetos.  4.6 Testing (JUnit)La realización de tests o pruebas sobre nuestras aplicaciones van a proporcionar las siguientesventajas: • 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 código y conforme se evoluciona el mismo permite que tanto quien lo ha desarrollado como otros programadores prueben que código sigue cumpliendo las pruebas.La necesidad de probar el código para obtener aplicaciones de calidad es algo tan latente que hagenerado una nueva filosofía en el desarrollo del software denominado TDD (Test-DrivenDevelopment). Esta técnica implica que primer se escriban los casos de prueba y después seimplemente únicamente el código 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
  • 41. • Un API para facilitar la creación de casos de prueba en Java. • Entorno de ejecución para lanzar baterías de pruebas. • Generación de informes.Los pasos necesarios para escribir un caso de prueba basado en JUnit son: 1. Incluir la librería JUnit.jar en el classpath. 2. Definir una subclase que herede de TestCase. 3. Definir uno o más metodos públicos testXXX() en la subclase. 4. Dentro de los métodos testXXX() escribir sentencias assert. 5. Opcionalmente, definir el método main para ejecutar el caso de prueba de forma independiente.Los métodos testXXX siguen el patrón de nombrado donde XXX refleja el nombre de la prueba.Estos métodos no tienen parámetros y no devuelven nada (void).Las sentencias assert sirven para determinar el éxito o fallo de una prueba, es decir, una sentenciaassert es una sencilla comparación 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 método assert para comprobar que 2 por 2 son 4."); assertTrue(4 == (2 * 2)); } // Este main es opcional si utilizamos el entorno de ejecución de pruebas6 de febrero de 2008 Tema 1 41
  • 42. 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 formaautomática. Primera, mediante línea de comandos obteniendo los resultados de forma textual, obien, mediante un entorno gráfico diseñado que muestra mediante una barra verde los tests pasadoscorrectamente y otra barra roja los tests que han fallado. La forma de invocar a dichos entornos es:1. Consola: java -classpath ".;c:junit3.8.1junit.jar" junit.textui.TestRunner junit.samples.AllTests2. Entorno gráfico: java -classpath ".;c:junit3.8.1junit.jar" junit.swingui.TestRunnerjunit.samples.AllTests  4.7  Características de la versión J2SE 5.0A pesar de encontrarse actualmente el desarrollo de la J2SE en la versión 6 es poco probable que losalumnos del curso trabajen con dicha versión en el mercado actual, como siempre ocurre con todoslos 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 versión 5.0 pues esla versión que mayores cambios ha tenido desde las últimas versiones (véase como se considera decambiada la versión que la anterior no es la 4.0 sino que es la 1.4).Genéricos.Mediante los genéricos se permite controlar el tipo de los objetos con los que trabajan susinstancias cuando en su definición no se quiere concretar el tipo de objeto que contendrá, parahacerlo, más genérico . El siguiente ejemplo nos aportará un poco más de claridad.Sin utilizar genéricos, cuando trabajamos con una lista lo hacemos del siguiente modo:6 de febrero de 2008 Tema 1 42
  • 43. List lista = new LinkedList(); Lista.add( Hola ); String elemento = (String) lista.get(0);Mediante los genéricos 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 utilización de genéricos el compilador podrá controlar el tipo de los elementos yfacilitar el trabajo con ellos (casting automático).Tipos enumerados.Los tipos enumerados son un nuevo tipo que se añade a las clases y los interfaces dentro dellenguaje Java y que se caracteriza por tener un número finito y normalmente bajo de posiblesvalores.Implementan el concepto de constante que hasta ahora se definía mediante variables static final .Este nuevo tipo tiene la siguiente sintaxis: <modificador> enum NombreTipoEnumerado {valor1, valor2, & }Un ejemplo sencillo sería: public enum DiaSemana { LUNES, MARTES, MIERCOLES, JUEVES, VIERNES, SABADO, DOMINGO}6 de febrero de 2008 Tema 1 43
  • 44. Anotaciones.Las anotaciones permiten asociar información, en forma de pares atributo-valor, a los elementos deprogramación (tipos, métodos, atributos, paquetes). Las anotaciones son meta-información, esdecir, información sobre el código.Las anotaciones no modifican la ejecución de un programa, por lo que sólo tienen sentido paraprogramas o herramientas que las extraigan e interpreten. Por ejemplo, el compilador procesa variostipos de anotaciones predefinidas.La sintaxis de las anotaciones tiene la forma general: @TipoAnotacion (nombre1=valor1, nombre2=valor2, & )Por ejemplo, la anotación @deprecated sirve para informar al compilador que el método marcadocon dicha anotación va a ser invalidado u obsoleto en futuras versiones de la JDK.Autoboxing.En esta versión, la conversión de un valor primitivo a una instancia de su clase (boxing) y alcontrario (unboxing) se realiza de forma automática. Esta nueva facilidad se denominaautoboxing. 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; //autoboxingVarargs.En la nueva versión de Java, se permite declarar métodos que admitan varios parámetros de unmismo tipo sin determinar la cantidad exacta.6 de febrero de 2008 Tema 1 44
  • 45. La sintaxis es: <Tipo>& nombreParametroPor ejemplo, en el siguiente método se define el parámetro emails que es de longitud variable ypodemos pasar el número 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 loselementos de un array o cualquier estructura que implemente el interfaz Iterable (aunque se siguemanteniendo disponible la sentencia for tradicional). La nueva sentencia tiene la siguienteestructura: for (TipoElementos elementoAuxiliar : estructuraElementos) { ... }A continuación mostramos la versión clásica (izquierda) y mejorada de bucle (derecha): int[] numeros = {1,2,3,4,5,6,7,8,9,10}; int[] numeros = {1,2,3,4,5,6,7,8,9,10}; for (int i=0; i<numeros.length; i++) { for (int unNumero : numeros) { int unNumero = numeros[i]; System.out.println("Número: " + System.out.println("Número: " + unNumero); unNumero); } }Static import.Ahora está permitido importar miembros estáticos de un tipo, esta nueva funcionalidad sedenomina static imports. Con un par de ejemplos veremos más claramente que se consigue con estanovedad. Antes de la 5.0 En la 5.0 System.out.println( Hola Mundo ); Import static java.lang.System.out; out.println( Hola Mundo );6 de febrero de 2008 Tema 1 45
  • 46. 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.8 Patrones de diseño JavaLos patrones de diseño son una disciplina de la ingeniería del software para resolver problemas quesurge de la comunidad de orientación a objetos. Un patrón de diseño define una guía para resolverun problema que se presenta en un contexto determinado. A la definición del problema juntocon la mejor solución posible se le denominó con el nombre de Patrón de Diseño en el libro DesignPatterns Elements of Reusable Software de Gamma, Helm, Jonson y Vlissides (GoF, Gang ofTour) cogiendo dicho concepto del campo de la arquitectura.En un patrón de diseño se distinguen 4 partes: 1. Nombre del patrón 2. Descripción del problema 3. Solución 4. ConsecuenciasExisten diferentes agrupaciones de los patrones de diseño. Por ejemplo, el libro anteriormentemencionado agrupa los patrones en patrones de diseño, de creación, de partición, de estructura, decomportamiento y de concurrencia.En este apartado vamos a ver como ejemplo el patrón de diseño Singleton y se deja como ejercicioal alumno que se documente sobre los patrones Factoria, MVC (Model-View-Controller) y Facadepor la importancia que estos presentan dentro del mundo J2EE.PATRÓN SINGLETON- Problema:Se necesita limitar el número de instancias de un objeto a uno sólo. Los clientes que quieran usardicho objeto compartirán la única instancia existente. Como ejemplo, esta situación puede ser6 de febrero de 2008 Tema 1 46
  • 47. necesaria cuando se quiere controlar el acceso a un recurso que por su naturaleza no admite elacceso concurrente (impresora, socket, fichero).- Solución:Se hace privado el único constructor del Singleton para evitar que el cliente lo instancie. El clienteobtiene la instancia a través de un método estático (getInstance()) que devuelve siempre la mismainstancia. Una implementación posible sería: public class Singleton { private static Singleton singleton = new Singleton(); /** El constructor es privado para no permitir a otras clases instanciar este objeto. */ private Singleton() { } /** Método estático que devuelve la única instancia creable de este objeto */ public static Singleton getInstance() { return singleton; } // Otros métodos que se necesiten... }- Consecuencias: • No se pueden crear subclases de un Singleton. • Se puede modificar un Singleton para permitir que existan un pequeño número de instancias creadas y no sólo una.6 de febrero de 2008 Tema 1 47
  • 48.  5 IDEs (Integrated Development Environment)En el mercado existe una multitud de IDEs (Integrated Development Environment) o entornos dedesarrollo para trabajar con Java. A continuación se enumeran una serie de ellos aunque la eleccióndel IDE adecuado depende del conocimiento del programador Java, de la capacidad de la máquinaque 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 recomendación sería probar diferentes entornos para conocer los puntos fuertes de cada entornoy así ser capaz de elegir el entorno adecuado dependiendo de las necesidades del proyecto que sefuese a desarrollar.BLUEJEs un IDE diseñado específicamente para la enseñanza a un nivel introductorio de la programaciónorientada a objetos. Posee las funcionalidades básicas de editar, compilar y depurar. Visualiza elcódigo de nuestro proyecto en UML, mostrando las clases con las relaciones de herencia ydependencia entre ellas.Esta diseñado por la Universidad de Kent en Canterbury y se puede descargar gratuitamente de ladirección http://www.bluej.org.JCREATOREs un IDE que consume muy pocos recursos con lo que puede ejecutarse en máquinas pocopotentes, esto se consigue eliminando capacidades de otros IDEs como por ejemplo no tenerinterfaz visual para el desarrollo de aplicaciones gráficas. No obstante, a diferencia de BlueJ esteproducto 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 desdela dirección http://www.jcreator.com.NETBEANS6 de febrero de 2008 Tema 1 48
  • 49. Tanto éste como los siguientes tres IDEs ya son productos completos que requieren máquinas medianamente potentes. Netbeans y Eclipse son productos gratuitos mientras que JDeveloper yIntelliJ IDEA son de pago.Este IDE permite el diseño de aplicaciones de modo visual a través de su herramienta Matisse,siendo a partir de la versión 5.5 uno de los mejores editores para el diseño gráfico con Java según locomentado en Internet.Es una herramienta Open Source y está respaldada por Sun Microsystems. Se puede descargar de ladirección http://www.netbeans.org.ECLIPSEEste es el IDE por excelencia dentro del mundo de desarrollo de Java (en la actualidad). Su granpopularidad se debe a que cuando nació no había buenos entornos gratuitos de Java que le hiciesencompetencia, pero a día de hoy Netbeans le está empezando a hacer sombra.Esta herramienta en sí no es sólo un editor Java sino que es un IDE extensible a base de plugins.Existen plugins que permiten configurar este entorno para prácticamente cualquier posibilidaddesde hacer que Eclipse sea un editor como Vi, una herramienta de acceso a BD (como TOAD) oincluso un visor de mapas (como Google Maps).Esta capacidad de adaptar el entorno con plugins es para el desarrollador Java novel una desventaja,pues además de tener que aprender Java necesita aprender qué plugins necesita y dóndeconseguirlos.Este IDE es un producto de la Eclipse Foundation y puede ser descargado de la direcciónhttp://www.eclipse.org. Los plugins se pueden encontrar en la direccionhttp://www.eclipseplugincentral.com.JDEVELOPER e INTELLIJ IDEAEstos dos son IDEs de pago, el primero es de Oracle y el segundo de JetBrains. En mi experiencia6 de febrero de 2008 Tema 1 49
  • 50. como desarrollador no he probado ninguno de los dos por dicho motivo (hay que pagar laslicencias) pero se oyen buenos comentarios del IntelliJ IDEA.JDeveloper puede ser descargado de la direcciónhttp://www.oracle.com/technology/products/jdev/index.html e IntelliJ IDEA dehttp://www.jetbrains.com/idea.6 de febrero de 2008 Tema 1 50