Manual Java Basico

Manual del Curso Java Bsico

Programa de Tecnologa en Cmputo

UNIVERSIDAD NACIONAL AUTNOMA DE MXICO FACULTAD DE INGENIERADIVISIN DE INGENIERA ELCTRICA

PROGRAMA DE TECNOLOGA EN CMPUTO

MANUAL DEL CURSO: JAVA BSICO

AUTORES: CAMACHO PREZ HUGO CASTAEDA MUOZ RICARDO VARGAS MEJA ISAAC

1



TABLA DE CONTENIDO1:Programacin Orientada a Objetos.......................................................................................3 Introduccin: .......................................................................................................................3 La Crisis del Software .........................................................................................................3 La metodologa orientada a objetos ....................................................................................4 Clases y objetos...................................................................................................................4 Mensajes y mtodos ............................................................................................................5 Encapsulamiento. ................................................................................................................5 Herencia ..............................................................................................................................5 Polimorfismo.......................................................................................................................6 Abstraccin..........................................................................................................................7 2:La Tecnologa Java...............................................................................................................8 La Plataforma Java. .............................................................................................................8 Tipos de programas en java...............................................................................................10 Compilacin y Ejecucin de Programas ...........................................................................10 Tipos de datos primitivos. .................................................................................................12 El recolector de basura ......................................................................................................13 3: Clases y objetos .................................................................................................................14 Atributos y mtodos ..........................................................................................................16 Constructores, la palabra reservada this ............................................................................18 Variables y mtodos de clase ............................................................................................25 Clases envolventes o wrappers..........................................................................................27 Arreglos.............................................................................................................................28 Arrays de dos dimensiones ...........................................................................................30 Java archivos (JAR) ..........................................................................................................30 Limpieza: Finalizacin y recoleccin de basura. ..............................................................31 La condicin de Muerto ................................................................................................34 Comentarios y documentacin ..........................................................................................35 Sintaxis..........................................................................................................................35 HTML empotrado .........................................................................................................36 4:La Clase String ...................................................................................................................38 Comparacin de Strings ....................................................................................................39 5: Herencia ............................................................................................................................42 La palabra reservada super................................................................................................43 Sobrecarga y sobreescritura de mtodos ...........................................................................45 Sobrescritura de Mtodos..................................................................................................46 Conversin hacia arriba (upcasting)..................................................................................47 La palabra clave final ........................................................................................................48 Para Datos .....................................................................................................................48 Constantes Blancas. ......................................................................................................50 Mtodos Constantes ......................................................................................................51 Clases Constantes..........................................................................................................51 6: Polimorfismo .....................................................................................................................53 Clases y mtodos abstractos..............................................................................................57 Interfaces y clases internas................................................................................................59 Extender una interfaz con herencia. ..............................................................................61 Clases Internas: .................................................................................................................61 7:Paquetes..............................................................................................................................64 Apndice A: Breve historia de Java ......................................................................................69

2



1:Programacin Orientada a Objetos.Introduccin:Los lenguajes de programacin son tcnicas que permiten expresar instrucciones que deben ser ejecutadas por la computadora. Este lenguaje de programacin sirve de nexo entre la parte humana y la computadora. Una de estas tcnicas es la programacin estructurada, en la cual se considera a un dato como pasivo y existe para ser manipulado dentro del programa durante el desarrollo del mismo. La variedad de sistemas hoy en da (y desde hace 20 aos) ha demostrado que esta idea de estructuras de datos simples no es adecuada para soportar grandes cambios o cambios graduales. Tales cambios surgieron cuando aumentaron las expectativas de lo que se poda hacer con un sistema informtico, ocurri entonces lo que se conoce como crisis del software, en la que no fue suficiente la mano de obra para mantener los sistemas actuales.

La Crisis del SoftwareLa crisis del software es el hecho de que el software que se construye no solamente no satisface los requerimientos ni las necesidades pedidos por el cliente, sino que adems excede los presupuestos y los horarios de tiempos. Como alternativas de esta crisis se plantearon varias propuestas: La parametrizacin: Se trato de ubicar en datos externos al programa el conjunto de alternativas posibles para que durante la ejecucin del proceso se determine que poltica utilizar para resolver un problema. Esta tcnica no alcanz a cubrir siquiera las necesidades inmediatas. La Modularizacin: Se comenz por la dcada de los 60s, con Pascal, al definirse una nueva alternativa a la parametrizacin que estaba basada en encapsular comportamiento en mdulos. El advenimiento de lenguajes como Modula II y Ada, en los 70s, fueron muy promisorios para la construccin de sistemas de software grande. El gran esfuerzo en la escritura de cdigo como consecuencia del poco anlisis y diseo del sistema origin una nueva tcnica llamada Metodologa Orientada a Objetos. En el paradigma de objetos, no es necesario el concepto de programa, pues cada objeto tiene una razn de ser para el ambiente que lo contiene y su comportamiento viene dado por su naturaleza.

3



La metodologa orientada a objetosA medida que se acercaban los aos 80, la metodologa orientada a objetos comenzaba a madurar como un enfoque de desarrollo de software. Empezamos a crear diseos de aplicaciones de todo tipo utilizando la forma de pensar orientada a los objetos e implementamos (codificamos) programas utilizando lenguajes y tcnicas orientadas a los objetos. La metodologa orientada a objetos presenta caractersticas que lo hacen idneo para el anlisis, diseo y programacin de sistemas; sin embargo, el anlisis de requisitos, que es la relacin entre la asignacin de software al nivel del sistema y el diseo del software, se qued atrs por lo que empezaron a surgir diferentes mtodos de anlisis y diseo orientado a objetos, entre los que destacan los mtodos Booch, OOSE (Object Oriented Software Engineering) y OMT (Object Modeling Technique). Para poner fin a la "guerra de mtodos" que se present en ese momento, se cre el Lenguaje Unificado de Modelado (UML). La programacin orientada a objetos, intenta simular el mundo real a traves del significado de objetos que contiene caracteristicas y funciones. Los lenguajes orientados a objetos se clasifican como lenguajes de quinta generacion. Como su mismo nombre indica, la programacin orientada a objetos se basa en la idea de un objeto, que es una combinacion de variables locales y procedimientos llamados metodos que juntos conforman una entidad de programacin.

Clases y objetosEn la metodologa orientada a objetos la esencia es el objeto. Un objeto en el mundo real viene a representar cualquier cosa: un plumn, una caja, una silla, un automvil, etc. Por esta razn y en base a nuestra experiencia de la vida diaria podemos identificar grupos o clases de objetos, por ejemplo piense en 5 plumones como los que se muestran a continuacin: De estos 5 plumones podemos decir que pertenecen a la misma clase de objetos pero cada uno de ellos tiene las caractersticas necesarias que lo identifican como un objeto de la clase plumones y no con otros objetos como podra ser los objetos de tipo automvil. A partir de aqu podemos decir que un objeto tiene caractersticas propias que llamaremos atributos y comportamientos o acciones propios de esa clase de objetos que llamaremos mtodos.

4



Mensajes y mtodosComo ya hemos dicho un mtodo es una accin que puede realizar un objeto. Cuando un objeto necesita interactuar con otro lo hace a travs de un mtodo.

Figura 1.1 Cuando un objeto A necesita que un objeto B ejecute alguno de sus mtodos lo hace a travs de sus mtodos. Un mtodo se implementa dentro la clase que defina al objeto. Un buen diseo de clases hace que los atributos solo sean modificados mediante el acceso a un mtodo.

Encapsulamiento.Un objeto lo hemos representado de la siguiente manera: En donde se puede ver que loas datos (variables) y las acciones (mtodos) se renen de tal forma que se oculte al mundo exterior parte de su informacin. De esta manera si queremos acceder a un atributo lo tenemos que hacer a travs de alguno de sus mtodos, a su vez los mtodos tambin pueden ser restringidos de cierta forma.

Figura 1.2 El encapsulamiento provee una idea poderosa: la modularidad, es decir el cdigo fuente puede ser escrito y darle mantenimiento de forma independiente al resto del programa y de los objetos que interactan con l.

HerenciaLa herencia es propiedad que permite a los objetos construirse a partir de otros objetos. El concepto de herencia est presente en nuestras vidas diarias donde las clases se dividen en subclases. Hay diferentes tipos de herencia: los ms importantes son simples y mltiples. La Herencia simple consiste en que una clase slo puede heredar de otra clase llamada clase padre o superclase, en la herencia mltiple una clase puede heredar de una o mas clases.

5



Figura 1.3 La figura 1.3 muestra un ejemplo de herencia simple, la clase B y la clase C son subclases de la clase A, que a su vez es la superclase de B y C, en esta figura la Clase C y la Clase B heredan de la Clase A. Con la Herencia se obtienen mltiples beneficios, al heredar una clase de otra la se obtienen todos sus atributos y mtodos que compone la clase padre. Con la herencia y con un buen diseo Orientado a Objetos podemos llevar a la prctica la reutilizacin de cdigo, ya que si una clase es muy parecida a una anterior, podemos programar nicamente la diferencia entre estas y aplicar la herencia. La figura 1.4 muestra un ejemplo del uso de la herencia.

Figura 1.4

PolimorfismoEl polimorfismo es otra caracterstica esencial de los lenguajes de POO. Un objeto solo tiene una forma, la que se le asigna cuando es creado, pero la

6



referencia a ese objeto es polimorfita ya que puede referirse a objetos de diferentes clases. Para que esta referencia sea polimorfica debe haber necesariamente una relacin de herencia entre las clases. Por ejemplo, en nuestro diagrama de clases anterior: Una referencia a objeto de la clase Empleado tambin puede ser una referencia a objeto de la clase Trabajador. Una referencia a objeto de la clase Consultor tambin puede ser una referencia a objeto de la clase Trabajador.

AbstraccinComo mencionamos anteriormente en la POO para poder utilizar o crear un objeto es necesaria la clase del objeto, a esa clase de objeto la podemos definir como aquello que se desea abstraer, de esta forma el diseo de clases lo podemos considerar como una abstraccin de datos, por ejemplo nuestro diagrama de clases de la figura 1.4 presenta una abstraccin de datos en la parte superior y esta abstraccin desminuye conforme se desciende del rbol, es decir, hablar de un trabajador resulta mas abstracto que hablar de un empleado o bien un consultor, conforme descendemos en el rbol las clases se convierten en algo mas concreto. Disear una clase de una manera muy general para varias clases que hereden de ella nos proveer de un mejor diseo como se ver mas adelante en este curso en el apartado de clases abstractas.

7



2:La Tecnologa Java.El lenguaje de programacin Java consiste en un lenguaje de programacin y una plataforma. La mayora de los lenguajes se caracterizan por ser interpretados (por ejemplo: Basic) o bien por ser compilados (por ejemplo C) esto determina la manera en que sern ejecutados por la computadora. Java tiene la caracterstica de ser al mismo tiempo compilado e interpretado. El compilador es el encargado de convertir el cdigo fuente de un programa en un cdigo intermedio llamado bytecode que es independiente de la plataforma en que se trabaje y que es ejecutado por el intrprete de Java que forma parte de la Mquina Virtual de Java.

. Figura 2.1

La Plataforma Java.Una plataforma es el ambiente de hardware o software en el cual se ejecutan los programas. En general, la mayora de las plataformas pueden ser descritas como una combinacin de hardware y sistema operativo. Algunas de las plataformas ms populares son Windows, Solaris, Linux y MacOS. La plataforma Java difiere de las anteriores en que sta es una plataforma basada nicamente en software que corre por encima de las plataformas basadas en hardware. La plataforma Java consta de dos componentes:

La Mquina Virtual de Java (JVM) La Interfaz de Programacin de Aplicaciones de Java (API Java)

A continuacin se muestra una representacin de los elementos que forman parte de la plataforma Java.

8



Figura 2.2 La figura anterior muestra un aspecto importante: 1.- Como puede verse la mquina virtual esta por encima de la plataforma del Hardware, esto quiere decir que la maquina virtual es la nica que cambia de una plataforma a otra y es la encargada de interpretar y ejecutar los archivos Bytecode de nuestro programa. La Interfaz de Programacin de Aplicaciones (API) es el conjunto de paquetes y herramientas que nos ayudan a realizar la implementacin de nuestro programa. Los programas de carcter general usan un API denominado J2SE (Java 2 Estndar Edicin) y ser el API que se use a lo largo de este manual. La eleccin del API a utilizar depende del tipo de programa que queremos realizar, a continuacin se muestran varios API (todos ellos bajo la tecnologa Java) y una breve descripcin de cada uno. J2SE: Java Standard Edition. Se utiliza en la elaboracin de programas standalone comnmente utilizados para ser ejecutados de manera local en una PC. J2EE: Java Enterprise Edition. Son programas para ser ejecutados en una arquitectura cliente servidor. J2ME: Java Micro Edition. Este API provee de las clases necesarias para la programacin de dispositivos mviles tales como: Celulares, PDAs, PALM, etc. JavaCard: Con este API podemos incrustarnos en el mundo de la programacin de las llamadas smartCards (como las tarjetas de telefono) a travs del lenguaje java. JNDI: Java Naming and Directory Interface. Nos permite enlazar programas Java con directorios de informacin como un directorio de informacin LDAP.

Existen numerosos APIs, los cuales podemos mezclar en su mayora para lograr aplicaciones robustas y facilitar su implementacin y mantenimiento. Para obtener el J2SE que utilizaremos a lo largo del curso basta con entrar a la pagina de java: http://java.sun.com y descargarlo. Para detalles de la instalacin revisar el apndice C.

9



Tipos de programas en java.Los programas en Java suelen estar en una de las siguientes categoras: Applets : Los applets son pequeos programas que se incorporan en una pgina Web y que por lo tanto, necesitan de un Navegador Web compatible con Java para poder ejecutarse. A menudo los applets se descargan junto con una pgina HTML desde un Servidor Web y se ejecutan en la mquina cliente. Aplicaciones: Las aplicaciones son programas standalone de propsito general que normalmente se ejecutan desde la lnea de comandos del sistema operativo. Con Java se puede realizar cualquier programa que normalmente se creara con algn otro lenguaje de programacin. Servlets: Los servlets al contrario de los applets son programas que estn pensados para trabajar en el lado del servidor y desarrollar aplicaciones Web que interacten con los clientes. Los servlets son una alternativa de la programacin CGI tradicional.

Compilacin y Ejecucin de ProgramasLa figura 2.3 muestra un esquema del proceso de construccin de una aplicacin, para entender su funcionamiento pasaremos a ejecutar un ejemplo directamente.

Figura 2.3 Nuestro primer programa consiste en el tradicional hola mundo, escribirlo en un editor de texto plano como puede ser el block de notas de windows o bien el editor vi de unix.

10



public class HolaMundo { public static void main(String arg[]) { System.out.println("Mi primer programa en java"); } }

Para ejecutar nuestro programa tenemos que seguir algunas reglas: El nombre del archivo debe tener el nombre de la clase publica, en este caso el nombre del archivo corresponde a HolaMundo.java, Java es un lenguaje sensitivo lo cual quiere decir que hace una distincin entre maysculas y minsculas, adems la extensin siempre debe ser *.java. Java sigue ciertas convenciones en la asignacin de nombres a clases, mtodos y variables, dicha convencin se muestra a continuacin y ser la que adoptemos a lo largo de este manual: Para nombrar clases se usa la letra en mayscula al inicio de cada palabra, ejemplos: o NombreDeClase o HolaMundo Para nombrar variables o atributos se usa la primer palabra en minsculas y en mayscula la primer letra de las siguientes palabras que compongan el nombre, ejemplos: o miVariable o nombreDeVariable. Para nombrar mtodos se usa la misma convencin que para nombrar variables, la diferencia es que los mtodos van seguidos por parntesis, ejemplos: o nombreDeMetodo() o realizarSuma()

De esta forma, podemos identificar clases, variables y mtodos en el programa anterior: HolaMundo: es clase String: es clase main(): mtodo main de la clase. System: clase out: atributo de la clase System. println(): mtodo del atributo out. Hasta este momento tenemos listo el cdigo fuente de nuestro programa en un archivo llamado HolaMundo.java este archivo esta listo para ser enviado al compilador de java: javac (de Java Compiler) Para invocar al compilador abrir una ventana de comandos (inicio, ejecutar y escribir cmd en sistemas Windows 2000 y XP) e invocar al compilador de la siguiente manera:

11



C:\> javac HolaMundo.java

Si la compilacin tuvo xito el compilador nos devolver el prompt del sistema operativo y nos generar un nuevo archivo en el directorio actual con el nombre: HolaMundo.class, que ser el archivo byteCode. Como siguiente paso hay que invocar a la maquina virtual de java (JVM) para que se encargue de interpretarlo, esto se hace mediante la siguiente instruccin:C:\> java HolaMundo

Ntese la ausencia de la extensin del archivo en este comando, esto es por que Java busca la clase (el archivo ByteCode o .class) en las rutas especificadas por la variable de entorno CLASSPATH, de no existir la clase o no encontrarla java nos regresar un mensaje con el error encontrado. La figura 2.4 muestra la ejecucin del programa.

Figura 2.4

Tipos de datos primitivos.En el lenguaje de programacin Java, a pesar de ser un lenguaje orientado a objetos, no todo es un objeto. Hay un grupo de tipos que tiene un tratamiento especial: se trata de los tipos primitivos, que se usaran frecuentemente en los programas. La razn para el tratamiento especial es que crear un objeto, para variables pequeas y simples no es eficiente, para estos tipos Java vuelve al enfoque de C y C++. Es decir, en vez de crear un objeto, se crea una variable automtica que no es una referencia. La variable guarda el valor, y se coloca en la pila para que sea ms eficiente. Java determina el tamao de cada tipo primitivo. Estos tamaos no varan de una plataforma a otra como ocurre en la mayora de los lenguajes.

12



Tipo primitivo bolean char byte short int long float double void

Tamao 16 bits 8 bits 16 bits 32 bits 64 bits 32 bits 64 bits -

Mnimo Unicode 0 -128 -215 -231 -263 IEEE754 IEEE754 -

Mximo Unicote 216-1 +127 +215-1 +231-1 +263-1 IEEE754 IEEE754 -

Envoltura Boolean Character Byte Short Integer Long Float Double Void

El estndar IEEE754 especifica bsicamente lo siguiente: Precisin sencilla: bit de signo + 8 bits de exponente + 23 bits de mantisa. Precisin doble: bit de signo +11 bits de exponente + 52 bits de mantisa. Todos los tipos primitivos tienen asociada una envoltura o wrapper que se muestra en la ltima columna de la tabla anterior, esta envoltura ser vista a detalle en el capitulo 3: clases envolventes.

El recolector de basuraLos programadores conocen la importancia de la inicializacin, pero a menudo se les olvida la importancia de la limpieza. Java tiene un recolector de basura para recuperar la memoria de los objetos que ya no se usan, es decir de los cuales se ha perdido su referencia. El recolector de basura se ejecuta en un proceso en segundo plano cada determinado tiempo, verifica que objetos han dejado de usarse y libera esa porcin de memoria al sistema operativo para su nueva reasignacin. Sin embargo puede existir la necesidad de realizar alguna accin cuando un objeto es destruido, por ejemplo hacer uso de un destructor similar al de C++, Java soluciona este problema por medio del mtodo finalize() que ser visto en el siguiente capitulo.

13



3: Clases y objetosComo hemos mencionado Java asume que se desea llevar a cabo exclusivamente programacin orientada a objetos. Para poder crear un objeto es necesario que exista previamente la clase de ese objeto. La definicin de una clase especifica cmo sern los objetos de dicha clase, esto es, de que variables y de que mtodos constarn. La siguiente es la definicin ms simple de una clase:class NombreClase { /* Declaracin de la clase */

/* Aqu va la definicin de variables y mtodos */ }

Veamos un ejemplo, crearemos una clase llamada Alumno de esa clase vamos a crear un objeto. Ahora codificando esa clase, tenemos el siguiente cdigo:public class Alumno { //Atributos de la clase String nombre; String apellidoPaterno; String apellidoMaterno; int edad; String carrera; int semestre; String numeroDeCuenta; public static void main(String args[]) { Alumno alumno1=new Alumno(); // creamos un nuevo objeto de tipo alumno. alumno1.nombre="Juan"; alumno1.apellidoMaterno="Lopz"; alumno1.apellidoPaterno="Hernandez"; alumno1.carrera="Computacion"; alumno1.edad=20; alumno1.semestre=4; alumno1.numeroDeCuenta="03021458"; System.out.println("Numero de cuenta: "+alumno1.numeroDeCuenta); System.out.println("Nombre: "+alumno1.nombre+" "+alumno1.apellidoPaterno+" "+alumno1.apellidoMaterno); System.out.println("Edad: "+alumno1.edad); System.out.println("Carrea: "+alumno1.carrera); System.out.println("Semestre: "+alumno1.semestre); } }

14



Veremos que es lo que esta pasando en este programa. En el mtodo main de la clase creamos un nuevo objeto de tipo Alumno en la sentencia:Alumno alumno1=new Alumno();

Esta sentencia crea un nuevo objeto, con la palabra reservada new, y lo asigna a la referencia alumno1. Una vez creado el objeto, este contiene una copia de todos los atributos declarados en la clase siempre y cuando no estn declarados como static. Cuando ya esta creado el objeto podemos acceder a un atributo mediante el operador punto (.). En el ejemplo tambin es interesante resaltar el uso de operador + para concatenar cadenas. Al compilar y ejecutar este programa se obtendr la siguiente salida:Numero de cuenta: 03021458 Nombre: Juan Hernandez Lopz Edad: 20 Carrea: Computacion Semestre: 4

Ahora vamos a crear otro objeto de la clase Alumno, este nuevo alumno tendr como referencia: alumno2.public class Alumno { // atributos de la clase String nombre; String apellidoPaterno; String apellidoMaterno; int edad; String carrera; int semestre; String numeroDeCuenta; public static void main(String args[]) { Alumno alumno1=new Alumno();// creamos un nuevo objeto de tipo alumno Alumno alumno2= new Alumno();// creamos otro nuevo objeto alumno1.nombre="Juan";//inicializamos sus atributos. alumno1.apellidoMaterno="Lopz"; alumno1.apellidoPaterno="Hernandez"; alumno1.carrera="Computacion"; alumno1.edad=20; alumno1.semestre=4; alumno1.numeroDeCuenta="03021458"; alumno2.nombre="Pedro";//inicializamos sus atributos. alumno2.apellidoMaterno="Rodriguez"; alumno2.apellidoPaterno="Rodriguez"; alumno2.carrera="Ing. Electrica"; alumno2.edad=18; alumno2.semestre=1; alumno2.numeroDeCuenta="040012548"; System.out.println("Datos del alumno1:"); System.out.println("Numero de cuenta: "+alumno1.numeroDeCuenta);

15



System.out.println("Nombre: "+alumno1.nombre+" "+alumno1.apellidoPaterno+" "+alumno1.apellidoMaterno); System.out.println("Edad: "+alumno1.edad); System.out.println("Carrea: "+alumno1.carrera); System.out.println("Semestre: "+alumno1.semestre); System.out.println("\nDatos del alumno2:"); System.out.println("Numero de cuenta: "+alumno2.numeroDeCuenta); System.out.println("Nombre: "+alumno2.nombre+" "+alumno2.apellidoPaterno+" "+alumno2.apellidoMaterno); System.out.println("Edad: "+alumno2.edad); System.out.println("Carrea: "+alumno2.carrera); System.out.println("Semestre: "+alumno2.semestre); } }

En este ejemplo hemos creado el nuevo objeto el cual tiene la referencia alumno2. de esta forma podemos darnos cuenta de que cada objeto, tanto alumno1 como alumno2, contiene una copia de los atributos de la clase los cuales almacenan valores de forma independiente. La salida de este programa es la siguiente:Datos del alumno1: Numero de cuenta: 03021458 Nombre: Juan Hernandez Lopz Edad: 20 Carrea: Computacion Semestre: 4 Datos del alumno2: Numero de cuenta: 040012548 Nombre: Pedro Rodriguez Rodriguez Edad: 18 Carrea: Ing. Electrica Semestre: 1

Atributos y mtodosEn la versin 2 de nuestra clase Alumno hemos creado 2 objetos de esta clase, sin embargo el cdigo propuesto hasta el momento resulta un tanto ineficiente ya que si quisiramos crear 40 alumnos de un saln de clase e imprimir sus datos repetiramos bastante el cdigo que hasta ahorita tenemos y esto va en contra de la POO en donde la reutilizacin de cdigo es algo primordial. Si observamos las lneas de cdigo en donde se imprimen los datos de cada alumno encontraremos que son prcticamente las mismas, entonces Podemos unir esas lneas en una sola que permitan imprimir los datos de cualquier objeto tipo Alumno creado?. La respuesta es s y esto se har a travs de un mtodo. Como ya se dijo en el capitulo 1, un mtodo es una accin que puede ejecutar un objeto, en este caso la accin ha realizar ser imprimir el valor de sus

16



atributos. La implementacin del mtodo, para imprimir el valor de los atributos, se muestra en la siguiente versin de la clase Alumno que renombraremos como Alumno2 para notar de mejor manera la evolucin de nuestra clase.public class Alumno2 { // atributos de la clase String nombre; String apellidoPaterno; String apellidoMaterno; int edad; String carrera; int semestre; String numeroDeCuenta; public void imprimirDatos() { System.out.println("Numero de cuenta: "+numeroDeCuenta); System.out.println("Nombre: "+nombre+" "+apellidoPaterno+" "+apellidoMaterno); System.out.println("Edad: "+edad); System.out.println("Carrea: "+carrera); System.out.println("Semestre: "+semestre); } public static void main(String args[]) { Alumno2 alumno1=new Alumno2();// creamos un nuevo objeto de tipo alumno Alumno2 alumno2= new Alumno2();// creamos otro nuevo objeto alumno1.nombre="Juan";//inicializamos sus atributos. alumno1.apellidoMaterno="Lopz"; alumno1.apellidoPaterno="Hernandez"; alumno1.carrera="Computacion"; alumno1.edad=20; alumno1.semestre=4; alumno1.numeroDeCuenta="03021458"; alumno2.nombre="Pedro";//inicializamos sus atributos. alumno2.apellidoMaterno="Rodriguez"; alumno2.apellidoPaterno="Rodriguez"; alumno2.carrera="Ing. Electrica"; alumno2.edad=18; alumno2.semestre=1; alumno2.numeroDeCuenta="040012548"; alumno1.imprimirDatos(); alumno2.imprimirDatos(); } }

Hemos agregado el mtodo imprimirDatos, este mtodo es llamado por los dos objetos creados en las instrucciones:alumno1.imprimirDatos(); alumno2.imprimirDatos();

Cada objeto ejecuta este mtodo el cual, al ser ejecutado por alumno1, imprime el valor de los atributos de este objeto, es decir de alumno1, cuando es llamado

17



por alumno2 el mtodo imprimirDatos busca el valor de los atributos de ese objeto, es decir del que lo mando llamar.

Constructores, la palabra reservada thisEn nuestra clase Alumno2 revisemos las siguientes lneas:Alumno2 alumno1=new Alumno2();// creamos un nuevo objeto de tipo alumno Alumno2 alumno2= new Alumno2();// creamos otro nuevo objeto alumno1.nombre="Juan";//inicializamos sus atributos. alumno1.apellidoMaterno="Lopz"; alumno1.apellidoPaterno="Hernandez"; alumno1.carrera="Computacion"; alumno1.edad=20; alumno1.semestre=4; alumno1.numeroDeCuenta="03021458"; alumno2.nombre="Pedro";//inicializamos sus atributos. alumno2.apellidoMaterno="Rodriguez"; alumno2.apellidoPaterno="Rodriguez"; alumno2.carrera="Ing. Electrica"; alumno2.edad=18; alumno2.semestre=1; alumno2.numeroDeCuenta="040012548";

Podemos notar que la inicializacin de los atributos de cada objeto vuelve a ser prcticamente la misma, Podemos unir estas lneas en un mtodo como se hizo con el mtodo de imprimirDatos?. La respuesta de nueva cuenta es s. Cuando se crea un objeto se manda llamar un mtodo que recibe el nombre de constructor. Los constructores son mtodos especiales que se ejecutan cuando un objeto es creado, su principal funcin es inicializar los atributos de un objeto y cuentan con las siguientes caractersticas: Son llamados una sola vez cuando es creado el objeto. Tiene el mismo nombre de la clase. No regresa ningn valor de retorno.

Hasta este momento no hemos definido ningn constructor para nuestra clase Alumno, pero sin embargo hemos estado haciendo uso del constructor por default. El constructor por default es agregado automticamente por Java siempre y cuando la clase no contenga ningn constructor. Otra caracterstica del constructor por default es que es un constructor que no tiene argumentos. En la siguiente lnea estamos utilizando el constructor por default.Alumno2 alumno1=new Alumno2(); Alumno2 alumno2= new Alumno2();

La sentencia new Alumno2() constituye la llamada al constructor por default. Ahora agregaremos un constructor a nuestra clase Alumno2 que ahora la renombraremos por Alumno3.

18



public class Alumno3 { // atributos de la clase String nombre; String apellidoPaterno; String apellidoMaterno; int edad; String carrera; int semestre; String numeroDeCuenta; public Alumno3() { System.out.println("Creando un nuevo Alumno..."); } public void imprimirDatos() { System.out.println("Numero de cuenta: "+numeroDeCuenta); System.out.println("Nombre: "+nombre+" "+apellidoPaterno+" "+apellidoMaterno); System.out.println("Edad: "+edad); System.out.println("Carrea: "+carrera); System.out.println("Semestre: "+semestre); } public static void main(String args[]) { Alumno3 alumno1=new Alumno3();// creamos un nuevo objeto de tipo alumno Alumno3 alumno2= new Alumno3();// creamos otro nuevo objeto alumno1.nombre="Juan";//inicializamos sus atributos. alumno1.apellidoMaterno="Lopz"; alumno1.apellidoPaterno="Hernandez"; alumno1.carrera="Computacion"; alumno1.edad=20; alumno1.semestre=4; alumno1.numeroDeCuenta="03021458"; alumno2.nombre="Pedro";//inicializamos sus atributos. alumno2.apellidoMaterno="Rodriguez"; alumno2.apellidoPaterno="Rodriguez"; alumno2.carrera="Ing. Electrica"; alumno2.edad=18; alumno2.semestre=1; alumno2.numeroDeCuenta="040012548"; alumno1.imprimirDatos(); alumno2.imprimirDatos(); } }

En este ejemplo hemos sobrescrito el constructor por default, esta nueva implementacin solo imprime un mensaje cuando el constructor es invocado, la salida del programa quedar de la siguiente forma:Creando un nuevo Alumno... Creando un nuevo Alumno... Numero de cuenta: 03021458

19



Nombre: Juan Hernandez Lopz Edad: 20 Carrea: Computacion Semestre: 4 Numero de cuenta: 040012548 Nombre: Pedro Rodriguez Rodriguez Edad: 18 Carrea: Ing. Electrica Semestre: 1

Lo que demuestra que el constructor es invocado cada vez que se crea un nuevo objeto de la clase. Ahora adecuaremos la firma del constructor para que pueda recibir argumentos e inicialice los atributos del objeto, para esta cambiaremos a firma del constructor de la siguiente manera:public Alumno3(String nom, String apePat, String apeMat, int anios, String car, int sem, String cuenta) { }

Observa que hemos cambiado intencionalmente el nombre de las variables para que no concidan con el nombre de los atributos, es seguida explicaremos la razn. Con esta modificacin al constructor nuestro programa quedar de la siguiente manera:public class Alumno4 { // atributos de la clase String nombre; String apellidoPaterno; String apellidoMaterno; int edad; String carrera; int semestre; String numeroDeCuenta; public Alumno4(String nom, String apePat, String apeMat, int anios, String car, int sem, String cuenta) { System.out.println("Creando un nuevo Alumno..."); nombre=nom; apellidoPaterno=apePat; apellidoMaterno=apeMat; edad=anios; carrera=car; semestre=sem; numeroDeCuenta=cuenta; } public void imprimirDatos() { System.out.println("Numero de cuenta: "+numeroDeCuenta); System.out.println("Nombre: "+nombre+" "+apellidoPaterno+" "+apellidoMaterno); System.out.println("Edad: "+edad); System.out.println("Carrea: "+carrera); System.out.println("Semestre: "+semestre); }

20



public static void main(String args[]) { //creamos un nuevo objeto de tipo alumno Alumno4 alumno1=new Alumno4("Juan","Lopez","Hernadez",20,"computacion",4,"03021458"); //creamos otro nuevo objeto Alumno4 alumno2= new Alumno4("Pedro","Rodriguez","Rodriguez",18,"Ing. Electrica",1,"040012548"); alumno1.imprimirDatos(); alumno2.imprimirDatos();

} }

Al correr este cdigo veremos que se obtiene el mismo resultado. Ahora revisemos de nueva cuenta el constructor, cambiemos en nombre de las variables de los argumentos del constructor por el mismo nombre que tienen los atributos, el resultado podra ser inesperado, el cdigo se encuentra en el archivo Alumno5.java en el cual se hizo el siguiente cambio en el constructor.public Alumno4(String nombre, String apellidoPaterno, String apellidoMaterno, int edad, String carrera, int semestre, String numeroDeCuenta) { System.out.println("Creando un nuevo Alumno..."); nombre=nombre; apellidoPaterno=apellidoPaterno; apellidoMaterno=apellidoMaterno; edad=edad; carrera=carrera; semestre=semestre; numeroDeCuenta=numeroDeCuenta; }

El resultado de realizar estos cambios se muestra a continuacin:Creando un nuevo Alumno... Creando un nuevo Alumno... Numero de cuenta: null Nombre: null null null Edad: 0 Carrea: null Semestre: 0 Numero de cuenta: null Nombre: null null null Edad: 0 Carrea: null Semestre: 0

Como puede verse los atributos de cada objeto no fueron inicializados, esto ocurre debido a que la asignacin de variables en el constructor es nicamente de forma local, es decir la sentencia:nombre=nombre;

21



La variable nombre del lado derecho hace referencia a la variable nombre declarada en los argumentos del constructor siendo la misma variable la del lado derecho, es decir es una asignacin entre la misma variable, nunca se afecta al atributo del objeto. Para poder hacer una distincin de una variable local y un atributo del objeto con el mismo nombre se usa la palabra reservada this. Con el uso de la palabra reservada this, podemos mejorar nuestro cdigo de la siguiente manera:public class Alumno6 { // atributos de la clase String nombre; String apellidoPaterno; String apellidoMaterno; int edad; String carrera; int semestre; String numeroDeCuenta; public Alumno6(String nombre, String apellidoPaterno, String apellidoMaterno, int edad, String carrera, int semestre, String numeroDeCuenta) { System.out.println("Creando un nuevo Alumno..."); this.nombre=nombre; this.apellidoPaterno=apellidoPaterno; this.apellidoMaterno=apellidoMaterno; this.edad=edad; this.carrera=carrera; this.semestre=semestre; this.numeroDeCuenta=numeroDeCuenta; } public void imprimirDatos() { System.out.println("Numero de cuenta: "+numeroDeCuenta); System.out.println("Nombre: "+nombre+" "+apellidoPaterno+" "+apellidoMaterno); System.out.println("Edad: "+edad); System.out.println("Carrea: "+carrera); System.out.println("Semestre: "+semestre); } public static void main(String args[]) { //creamos un nuevo objeto de tipo alumno Alumno6 alumno1=new Alumno6("Juan","Lopez","Hernadez",20,"computacion",4,"03021458"); //creamos otro nuevo objeto Alumno6 alumno2= new Alumno6("Pedro","Rodriguez","Rodriguez",18,"Ing. Electrica",1,"040012548"); alumno1.imprimirDatos(); alumno2.imprimirDatos();

} }

22



En este ejemplo, que produce la misma salida de las versiones anteriores de Alumno, podemos decir que la palabra reservada this hace referencia al objeto que mando llamar el mtodo, en esta caso el constructor. Invocando a Constructores desde Constructores. Cuando se escriben varios constructores para una clase, hay veces en las que uno quisiera invocar a un constructor desde otro para evitar la duplicacin de cdigo. Esto se puede lograr utilizando la palabra reservada this. La palabra clave this toma un significado diferente cuando se le da una lista de parmetros: hace una llamada explcita al constructor que coincida con la lista de parmetros. Por consiguiente, hay una manera directa de llamar otros constructores. Ejemplo:public class Flor { int numeroPetalos=0; String texto=null; public Flor(int petalos) { numeroPetalos=petalos; System.out.println("Constructor: Parametro entero solo, petalos= "+petalos); } public Flor(String ss) { System.out.println("Constructor: Parametro cadena solo, texto= "+ss); texto=ss; } public Flor(String ss, int petalos) { this(petalos); //! this(ss); //No se pueden invocar dos this.texto=ss; System.out.println("Constructor: Parametro cadena y entero"); } public Flor() { this("Hola",20); System.out.println("Constructor por defecto (Sin parametros)"); } public void print() { //this(11); // No se puede invocar this dentro de un no-constructor System.out.println("Numero de petalos: "+numeroPetalos+" texto= "+texto); } public static void main(String args[]) { Flor x= new Flor(); x.print(); Flor y= new Flor("Rosa",18); y.print(); }

23



}

En el ejemplo anterior podemos observar el uso de varios constructores para crear objetos. Adems el uso de this con parmetros, es decir como llamada al constructor, debe ser la primer cosa que se haga o se obtendr un mensaje de error del compilador. La salida del programa anterior es la siguiente:Constructor: Parametro entero solo, petalos= 20 Constructor: Parametro cadena y entero Constructor por defecto (Sin parametros) Numero de petalos: 20 texto= Hola Constructor: Parametro entero solo, petalos= 18 Constructor: Parametro cadena y entero Numero de petalos: 18 texto= Rosa

Para terminar con este apartado mostraremos un ejemplo final de la clase Alumno hasta ahora modificada pero esta vez en archivos distintos, es decir por un lado en un archivo la clase Alumno que renombraremos por Alumno7 y por el otro una clase llamada escuela en un archivo distinto. Estos dos archivos debern encontrarse en el mismo directorio por el momento.//Alumno7.java public class Alumno7 { // atributos de la clase String nombre; String apellidoPaterno; String apellidoMaterno; int edad; String carrera; int semestre; String numeroDeCuenta; public Alumno7(String nombre, String apellidoPaterno, String apellidoMaterno, int edad, String carrera, int semestre, String numeroDeCuenta) { System.out.println("Creando un nuevo Alumno..."); this.nombre=nombre; this.apellidoPaterno=apellidoPaterno; this.apellidoMaterno=apellidoMaterno; this.edad=edad; this.carrera=carrera; this.semestre=semestre; this.numeroDeCuenta=numeroDeCuenta; } public void imprimirDatos() { System.out.println("Numero de cuenta: "+numeroDeCuenta); System.out.println("Nombre: "+nombre+" "+apellidoPaterno+" "+apellidoMaterno); System.out.println("Edad: "+edad); System.out.println("Carrea: "+carrera); System.out.println("Semestre: "+semestre); } }

24



//Escuela.java public class Escuela { public static void main(String args[]) { //creamos un nuevo objeto de tipo alumno Alumno7 alumno1=new Alumno7("Juan","Lopez","Hernadez",20,"computacion",4,"03021458"); //creamos otro nuevo objeto Alumno7 alumno2= new Alumno7("Pedro","Rodriguez","Rodriguez",18,"Ing. Electrica",1,"040012548"); alumno1.imprimirDatos(); alumno2.imprimirDatos();

}

}

Se comprobar que la salida no cambia en relacin a programas anteriores.

Variables y mtodos de claseGeneralmente, al crear una clase se est describiendo qu apariencia tienen sus objetos y cmo se comportan. No se tiene nada hasta crear un objeto de ese clase con new, momento en el que se crea el espacio de almacenamiento y los mtodos pasan a estar disponibles. Pero hay dos situaciones en las que este enfoque no es suficiente. Una es cuando se desea tener solamente un fragmento de espacio de almacenamiento para una parte concreta de datos, independientemente de cuntos objetos se creen, o incluso aunque no se cree ninguno. La otra es si se necesita un mtodo que no est asociado con ningn objeto particular de esa clase. Es decir, se necesita un mtodo al que se puede invocar incluso si no se ha creado ningn objeto. Ambos efectos se pueden lograr con la palabra clave static. Al decir que algo es esttico se est indicando que el dato o mtodo no est atado a ninguna instancia de objeto de esa clase. Con los datos y mtodos ordinarios no estticos, es necesario crear un objeto para poder utilizarlos, estos mtodos y datos que necesitan un objeto para poder ser utilizados reciben el nombre de variables y mtodos de instancia. Para declarar un dato o un mtodo static, basta con colocar la palabra clave static antes de la definicin, por ejemplo:public class PruebaEstatica { static int i=47; }

Ahora, incluso si se construyen dos objetos de tipo PruebaEstatica, slo habr un espacio de almacenamiento, es decir ambos objetos compartirn la misma i. La sintaxis recomendada de llamar a una variable o mtodo de clase es la siguiente:

25



NombreDeClase.nombreDeAtributo; NombreDeClase.nombreDeMtodo();

Modifiquemos nuestro ejemplo de la clase Alumno para ver un ejemplo://Alumno8.java public class Alumno8 { // atributos de la clase String nombre; // variable de instancia, cada que creas un objeto se crea un copia para cada objeto String apellidoPaterno; String apellidoMaterno; int edad; String carrera; int semestre; String numeroDeCuenta; static int numeroDeAlumnos=0;// variable de clase, no se crean copias para cada objeto, es fija. public Alumno8(String nombre, String apellidoPaterno, String apellidoMaterno, int edad, String carrera, int semestre, String numeroDeCuenta) { System.out.println("Creando un nuevo Alumno..."); this.nombre=nombre; this.apellidoPaterno=apellidoPaterno; this.apellidoMaterno=apellidoMaterno; this.edad=edad; this.carrera=carrera; this.semestre=semestre; this.numeroDeCuenta=numeroDeCuenta; numeroDeAlumnos++;// modificamos una variable de clase } public static String metodoDeClase() { String mensaje="Metodo de clase"; //nombre="Paco"; //Un mtodo de clase o puede modificar variables de instancia return mensaje; } public void imprimirDatos() { System.out.println("Numero de cuenta: "+numeroDeCuenta); System.out.println("Nombre: "+nombre+" "+apellidoPaterno+" "+apellidoMaterno); System.out.println("Edad: "+edad); System.out.println("Carrea: "+carrera); System.out.println("Semestre: "+semestre); } }

Hemos agregado un mtodo y una variable esttica, ahora modifiquemos el archivo Escuela para mandar llamar las variables estticas.//Escuela2.java public class Escuela2 { public static void main(String args[])

26



//Las variables y mtodos de clase se pueden usar sin crear un objeto System.out.println("Numero total de Alumnos: "+Alumno8.numeroDeAlumnos); System.out.println("Mensaje del metodo de clase: "+Alumno8.metodoDeClase()); //creamos un nuevo objeto de tipo alumno Alumno8 alumno1=new Alumno8("Juan","Lopez","Hernadez",20,"computacion",4,"03021458"); //creamos otro nuevo objeto Alumno8 alumno2= new Alumno8("Pedro","Rodriguez","Rodriguez",18,"Ing. Electrica",1,"040012548"); //Despues de crear dos objetos, la variable estatica se ha modificado System.out.println("Numero total de Alumnos: "+Alumno8.numeroDeAlumnos); //Los objetos tambien pueden accesar a las variables y metodos estaticos System.out.println("Desde alumno1, Numero de Alumnos: "+alumno1.numeroDeAlumnos); //Los objetos tambien pueden modificar las variables estaticas directamente: alumno2.numeroDeAlumnos++; System.out.println("Numero total de Alumnos: "+Alumno8.numeroDeAlumnos); } }

{

La salida de este programa deber ser la siguiente:Numero total de Alumnos: 0 Mensaje del metodo de clase: Metodo de clase Creando un nuevo Alumno... Creando un nuevo Alumno... Numero total de Alumnos: 2 Desde alumno1, Numero de Alumnos: 2 Numero total de Alumnos: 3

Clases envolventes o wrappersLos tipos de datos primitivos tienen asociado una clase envoltura. Esto quiere decir que si se desea hacer un objeto no primitivo para representar ese tipo primitivo, se hace uso del envoltorio asociado. Por ejemplo:char c= x; Charcter C = new Character(c)

Veamos un ejemplo ms prctico, queremos realizar un programa que reciba desde la lnea de comandos dos nmeros y que los sume, mostrando el resultado en pantalla. Para utilizar los parmetros de la lnea de comandos utilizamos el arreglo de String que viene en la firma del mtodo main.public static void main(String args[])

La referencia args es un arreglo de objetos tipo String, que veremos ms adelante en este capitulo, para acceder al primer parmetro utilizaremos el ndice 0 del arreglo y 1 para el segundo. Pero esto ocasionar un problema: los datos estarn en un objeto String lo que dificultara la operacin de suma que queremos realizar, para solucionar esto utilizaremos la clase envolvente Integer 27



que nos provee de un mtodo para realizar esta conversin de un String a un int. El siguiente ejemplo ilustra lo anterior.public class SumaDeNumeros { public static void main(String args[]) { int a= Integer.parseInt(args[0]); int b= Integer.parseInt(args[1]); int c= a+b; System.out.println("El resultado de la suma es: "+c); }

}

para ejecutar este programa hay que hacerlo de la siguiente manera:C:\ javac SumaDeNumeros.java C:\ java SumaDeNumeros 1 2

Arreglos.Hasta ahora, hemos descrito datos (variables) individuales y aislados. Por ejemplo:int contador, suma; String nombre;

Estos datos trabajan por su cuenta, desempeando funciones tiles en los programas, como contadores, sumas o lo que sea. Podemos pensar en estas variables como posiciones en memoria que tienen asignados nombres individuales. En contraste, en la vida tratamos con datos que no estn aislados, sino agrupados en una coleccin de informacin. Para solucionar este problema contamos con un tipo de almacenamiento que son los arrays. Existen muchas otras formas de guardar objetos, pero como se ver a continuacin el array tiene dos aspectos especiales con respecto a otros tipos de contenedores: la eficiencia y el tipo. El array es la forma ms eficiente que proporciona Java para almacenar y acceder al azar a una secuencia de objetos (verdaderamente, referencias a objetos). El array es una secuencia lineal simple, que hace rpidos los accesos a elementos, pero se paga por esa velocidad: cuando se crea un objeto array su tamao es limitado y no puede variarse. Para declara un array basta escribir:int[] suma;

o bien:

28



int suma[]:

Son exactamente la misma sentencia, que declara que la referencia suma ser un array de objetos. Un ejemplo de un primer array de cadenas es el siguiente:public class PrimerArray{ public static void main(String arg[]){ String nombres[] ={ "Juan", "Maria", "Antonio", "Victoria" }; nombres[2]="Alejandro"; System.out.println("Numero de elementos en el array: "+nombres.length); System.out.println(nombres[0]); System.out.println(nombres[1]); System.out.println(nombres[2]); System.out.println(nombres[3]); } }

Java permite varias formas de inicializar los array, el acceso a cada elemento de un array se realiza mediante el ndice del elemento. He aqu la salida del programa:Numero de elementos en el array: 4 Juan Maria Alejandro Victoria

Tambin podemos realizar array de tipos primitivos, la diferencia es que el objeto array no guarda referencias como array con objetos, si no que guarda directamente el valor de cada elemento. Ejemplo:public class ArrayDeEnteros { public static void main(String[] args) { int[] enteros; // declara un arreglo de enteros enteros = new int[10]; // crea el objeto que alamcenara 10 enteros // inicializa los elementos del arreglo y lo imprime for (int i = 0; i < enteros.length; i++) { enteros[i] = i; System.out.print(enteros[i] + " "); } }

}

Este ejemplo muestra otra forma de inicializar el array, primero se declara el tamao y luego se inicializa el array cabe destacar que para especificar el

29



tamao del array se usa new int[10], ntese el cambio de corchetes por los tradicionales parntesis, la salida del programa se muestra a continuacin:0123456789

Arrays de dos dimensionesJava ofrece una extensin natural de los arreglos unidimensionales a dos dimensiones, para crear un arreglo de dos dimensiones usamos dobles corchetes, por ejemplo:int[][] ventas = new ventas[4][7] ;

Esta instruccin declara una matriz de 4 x 7 elementos.

Java archivos (JAR)El formato ZIP tambin se usa en el formato de archivos JAR (Java ARchive), que es una forma de coleccionar un grupo de archivos en un nico archivo comprimido, exactamente igual que el ZIP. Sin embargo, como todo lo dems en Java, los ficheros JAR son multiplataforma, por lo que no hay que preocuparse por aspectos de plataforma. Tambin se pueden incluir archivos de audio e imagen, o archivos de clases. Un archivo JAR consta de un nico archivo que contiene una coleccin de archivos ZIP junto con una declaracin que los describe. La utilidad jar que viene con el JDK de Sun comprime automticamente los archivos que se seleccionan. Se invoca en la lnea de comandos:jar [opciones] destino [manifiesto] archivo(s)Entrada

Las opciones son simplemente una coleccin de letras, los usuarios de linux notarn una semejanza con las opciones tar. Las opciones son: c t x x file f m v O M Crea un archivo nuevo vaco. Lista la tabla de contenidos. Extrae todos los archivos. Extraer el archivo nombrado. Nombre del archivo. Indica que el primer parmetro ser el archivo de declaracin. Genera una salida que describe que va haciendo jar. Simplemente almacena los archivos; no los comprime (usarlo para crear un archivo JAR que se puede poner en el CLASSPATH) No crear automticamente un archivo de declaracin.

30



He aqu una forma habitual de invocar a Jar:C:\jar cf miArchivoJar.jar *.class

Esto crea un fichero JAR llamado miFichero.jar que contiene todos los archivos de clase del directorio actual, junto con un archive declaracin creado automticamente. El archivo de declaracin que es creado automticamente puede tener varias utilidades como por ejemplo indicar la clase a partir de la cual se podr ejecutar el archivo completo JAR. Por ejemplo vamos a comprimir en un archivo JAR las dos ultimas clases que trabajamos de la versin de nuestra clase Alumno que son: Alumno8 y Escuela2. Primero vamos a crear nuestro archivo Manifiesto que tenga la siguiente informacin, este archivo puede ser escrito en un editor de texto plano como puede ser notepad de Windows o vi de Linux:Manifest-Version: 1.0 Created-By: 1.5.0_02 (Sun Microsystems Inc.) Main-Class: Escuela2

Nota que hemos especificado la clase que contiene el mtodo main a ejecutar, guarda este archivo en el mismo directorio de tus clases con el nombre: MANIFEST.MF Como siguiente paso vamos a comprimir los archivos, en la lnea de comandos escribe:C:\ >jar cmf MANIFEST.MF Escuela.jar Alumno8.class Escuela2.class

Para ejecutar el archivo escribir:C:\>java jar Escuela.jar

Limpieza: Finalizacin y recoleccin de basura.En el capitulo anterior hablamos del recolector de basura como un proceso que se ejecuta en segundo plano y libera la memoria de aquellos objetos que han perdido su referencia. Considere ahora un caso muy inusual. Supngase que los objetos asignan memoria especial sin utilizar new. El recolector de basura slo sabe liberar la memoria asignada por new, por lo que ahora no sabr como liberar esa memoria especial del objeto. Para hacer frente a este caso, Java proporciona un mtodo denominado finalize( ) que se puede definir en cada clase. He aqu como se supone que funciona. Cuando el recolector de basura est preparado para liberar el espacio de almacenamiento utilizado por el objeto, primero invocara a finalize( ), y slo recuperar la memoria del objeto durante la pasada del recolector de basura. Por tanto, si se elige usar finalize(), ste te proporciona la habilidad de llevar acabo alguna limpieza importante a la vez que la recoleccin de basura.

31



Hay que sealar que no es lo mismo que un destructor para C++, que es una funcin que siempre se invoca. Java no cuenta con algo parecido as que si se necesita para un programa en especfico tendr que ser programado por su cuenta. Por ejemplo, considere un objeto que dibuja una figura en pantalla, el recolector de basura puede eliminar el objeto pero no la informacin que dibujo en pantalla. Pero la limpieza y recoleccin de basura esta ligada exclusivamente a la liberacin de memoria. Resulta que la necesidad de finalize( ) se limita a casos especiales, en los que un objeto puede reservar espacio de almacenamiento de forma distinta a la creacin de un objeto. Esto puede ocurrir principalmente a travs de mtodos nativos, que son la forma de invocar a cdigo no-Java desde Java. Una de las cosas para las que puede ser til finalize( ) es para observar el proceso de recoleccin de basura. El ejemplo siguiente resume las descripciones anteriores del recolector de basura://Silla.java //Demostracion de recolector de Basura y //finalizacion public class Silla { static boolean recolector=false; static boolean f= false; static int creadas = 0; static int finalizadas =0; int i; public Silla() { i= ++creadas; if(creadas==47) System.out.println("Creadas 47"); } public void finalize() { if(!recolector) {//la primera vez que se invoca a finalize(): recolector=true; System.out.println("Comenzando a finalizar tras haber creado "+ creadas +"sillas"); } if(i==47) { System.out.println("Finalizando la silla #47, "+ "Poniendo el indicador que evita la creacion de mas f=true; } finalizadas++; if(finalizadas>=creadas) System.out.println("Las "+finalizadas+" han sido finalizadas");

sillas");

}

32



} //Basura.java public class Basura { public static void main(String args[]) { //Mientras no se haya puesto la bandera, //hacer sillas y cadenas de texto while(!Silla.f) { new Silla(); new String("Ocupar Espacio"); } System.out.println("Despues de haber creado todas las sillas: \n"+ "Creadas en total: "+Silla.creadas+", total finalizadas: "+Silla.finalizadas); } }

El programa anterior crea muchos objetos Silla, y en cierto momento despus de que el recolector de basura comience a ejecutarse el programa deja de crear objetos Silla. Dado que el recolector puede ejecutarse en cualquier momento, uno no sabe exactamente cuando empezar, y hay un indicador denominado recolector para indicar si el recolector a comenzado su ejecucin o no. Un segundo indicador f es la forma de que Silla le comunique al bucle main( ) que deber dejar de hacer objetos. Ambos indicadores se ponen dentro de finalize( ), que se invoca durante la recoleccin de basura. La creacin de un objeto String en cada iteracin es simplemente la asignacin de almacenamiento extra para animar al recolector de basura a actuar, lo que har cuando se empiece a poner nervioso por la cantidad de memoria disponible. Una posible salida del programa anterior se muestra a continuacin:Creadas 47 Comenzando a finalizar tras haber creado 12207sillas Finalizando la silla #47, Poniendo el indicador que evita la creacion de mas sillas Las 33864 han sido finalizadas Despues de haber creado todas las sillas: Creadas en total: 33865, total finalizadas: 33864

Por consiguiente, no se invoca a todos los finalizadotes cuando acaba el programa. Recuerde que ni el recolector de basura ni la finalizacin estn garantizadas. Si la Mquina Virtual Java (JVM) no est a punto de quedarse sin memoria, entonces (sabiamente) no malgastar tiempo en recuperar memoria mediante el recolector de basura. Existe tambin una forma de invocar al recolector de basura explcitamente cuando el programador lo desee y esto se hace mediante el mtodo: System.gc(). Si se llama a System.gc() se finalizan todos los objetos, por consiguiente se destruirn todos los objetos que no estn en uso en ese momento.

33



La condicin de MuertoEn el momento que uno deja de estar interesado en un objeto cuando est listo para ser eliminado el objeto debera estar en cierto estado en el que su memoria puede ser liberada de manera segura. Por ejemplo, si el objeto representa un fichero abierto, ese fichero debera ser cerrado por el programador antes de que el objeto sea eliminado por el recolector de basura. Si no se eliminan correctamente ciertas porciones de objeto, se tendr un fallo en el programa que podra ser difcil de encontrar. El valor de finalize( ) es que puede usarse para descubrir esta condicin, incluso si no se invoca siempre. Si una de las finalizaciones acaba revelando el fallo, se descubre el problema, que es lo que verdaderamente hay que cuidar. He aqu un ejemplo simple de cmo debera usarse://Libro.java //Utilizacion de finalize() para detectar un objeto // que no ha sido correctamente eliminado public class Libro { boolean comprobado=false; public Libro(boolean comprobar) { comprobado=comprobar; } void correcto() { comprobado=false; } public void finalize() { if(comprobado) System.out.println("Error: comprobado"); } } //CondicionDeMuerto.java public class CondicionDeMuerto { public static void main(String[] args) { Libro novela = new Libro(true); //Eliminacion Correcta novela.correcto(); //Cargarse la referencia olvidando la limpieza new Libro(true); //forzar la recoleccion de basura y finalizacion System.gc(); } }

La condicin de muerto consiste en que todos los objetos libros supuestamente sern comprobados antes de ser recogidos por el recolector de basura, pero en el mtodo main( ) un error del programador no comprueba alguno de los libros.

34



Sin finalize( ) para verificar la condicin de muerte, este error sera difcil de encontrar.

Comentarios y documentacinHay dos tipos de comentarios en Java. El primero es el estilo de comentarios tradicional de C, que fue heredado por C++. Estos comentarios empiezan por /* y pueden extenderse a lo largo de varias lneas hasta encontrar */. Una de las partes ms interesantes del lenguaje Java es que los diseadores no slo tuvieron en cuenta que la escritura de cdigo era la nica actividad importante, sino que tambin pensaron en la documentacin del cdigo. Esto se hizo mediante comentarios especiales que se incrustan dentro del cdigo fuente, sin embargo, es necesaria una sintaxis especial y una herramienta para extraer esos comentarios. La herramienta para extraer comentarios se le denomina javadoc. Utiliza parte de la tecnologa del compilador Java para extraer etiquetas de comentarios especiales. La salida de javadoc es un archivo HTML que puede visualizarse a travs del navegador web. Gracias a javadoc se tiene incluso un estndar para la creacin de documentacin, tan sencillo que se puede incluso esperar o solicitar documentacin con todas las bibliotecas Java.

SintaxisTodos los comandos de javadoc se dan nicamente en comentarios /**. Estos comentarios acaban con */. Hay dos formas principales de usar javadoc: empotrar HTML, o utilizar etiquetas doc. Kas etiquetas doc son comandos que comienzan por @ y se sitan al principio de una lnea de comentarios. Hay tres tipos de documentacin en forma de comentarios, que corresponden con el elemento al que precede el comentario: una clase, una variable o un mtodo. Es decir, el comentario relativo a una clase aparece justo antes de la definicin de la misma; el comentario relativo a una variable precede siempre a la definicin de la variable, y un comentario de un mtodo aparece inmediatamente antes de la definicin de un mtodo. Un ejemplo simple:/** Un comentario de clase */ public class PruebaDoc { /** Un comentario de una variable */ public int i; /** Un comentario de un mtodo */ public void f( ){} }

35



HTML empotradoJavadoc pasa comandos HTML al documento HTML generado. Esto permite un uso total de HTML; sin embargo, el motivo principal es permitir dar formato al cdigo, como:/** * * System.out.println(new Date()); * */

Tambin puede usarse HTML como se hara en cualquier otro documento web para dar formato al propio texto de las descripciones:/** * * * * * * */ Uno puede incluso insertar una lista: Elemento uno Elemento dos Elemento tres

@see: Referencias a otras clases. Los tres tipos de comentarios de documentacin (de clase, variable y mtodos) pueden contener etiquetas @see, que permiten hacer referencia a la documentacin de otras clases. Javadoc generar HTML con las etiquetas @see en forma de vnculos a la otra documentacin. La forma es:@see NombreDeClase

@version: Informacin de la versin de la clase. La forma es:@version informacin-de-version.

@author: Suele ser el nombre del creador pero podra ser cualquier cosa como la direccin de correo. La forma de uso es:@author informacin-del-autor

@param: permite especificar una descripcin de un parmetro. Forma de uso:@param nombre-parmetro descripcin

@return: especifica una descripcin para un valor de retorno@return descripcin

@throws: Descripcin para las excepciones, que sern vistas en el curso de java Avanzado.

36



@throws nombre-de-clase descripcin

Ejemplo de documentacin.import java.util.Vector; /** * Este es un ejemplo de cdigo comentado
* Se pueden usar etiquetas de HTML, * para darle formato al texto.
* En esta parte, se describe sobre las caractersticas, uso, y funcionamiento * de la clase en general. * @author PROTECO * */ public class Comentada extends Vector implements Runnable{ /** * Asi se comentan los atributos */ protected String atributo; /** * Este es una atributo de clase, y no modificable */ static final int VALOR=10; /** * Tambien los mtodos constructores pueden ir comentados * */ public Comentada(){ } /** * Asi se comentan lo mtodos. Se da una descripcin de lo que hacen * y se pueden dar algunos ejemplos. Se utilizan * @param arg1 Comentario del parmetro 1 * @param arg2 Comentario del parmetro 2 * @param num Comentario del parmetro n * @return Comentario del valor de retorno * @throws Exception Comentario sobre alguna excepcin que regrese */ private int Metodo(String arg1,Vector arg2,int num) throws Exception{ return 0; } public void run(){ } /** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub }

}

Para ejecutar el comando javadoc en un ventana de comandos escribir:javadoc Comantada.java

y la herramienta javadoc generar el archivo html en el directorio actual.

37



4:La Clase StringDentro de un objeto de la clases String o StringBuffer, Java crea un array de caracteres de una forma similar a como lo hace el lenguaje C++. A este array se accede a travs de mtodos de la clase. Los String se pueden crear explcitamente o implcitamente. Para crear un String implcitamente basta poner una cadena de caracteres entre comillas dobles. Por ejemplo, cuando se escribe:System.out.println("El primer programa");

Java crea un objeto de la clase String automticamente. Para crear un String explcitamente escribimos:String str=new String("El primer programa");

Tambin se puede escribir, alternativamenteString str="El primer programa";

Para crear un String nulo se puede hacer de estas dos formasString str=""; String str=new String();

Un string nulo es aqul que no contiene caracteres, pero es un objeto de la clase String. Sin embargo,String str;

Est declarando un objeto str de la clase String, pero an no se ha creado ningn objeto de esta clase. Cmo se obtiene informacin acerca del String Una vez creado un objeto de la clase String podemos obtener informacin relevante acerca del objeto a travs de las funciones miembro. Para obtener la longitud, nmero de caracteres que guarda un String se llama al mtodo length.String str="El primer programa"; int longitud=str.length();

Podemos conocer si un string comienza con un determinado prefijo, llamando al mtodo startsWith, que devuelve true o false, segn que el string comience o no por dicho prefijo:String str="El primer programa"; boolean resultado=str.startsWith("El");

En este ejemplo la variable resultado tomar el valor true.

38



De modo similar, podemos saber si un String finaliza con un conjunto dado de caracteres, mediante el mtodo endsWith:String str="El primer programa"; boolean resultado=str.endsWith("programa");

Si se quiere obtener la posicin de la primera ocurrencia de la letra p, se usa la funcin indexOf:String str="El primer programa"; int pos=str.indexOf('p');

Para obtener las sucesivas posiciones de la letra p, se llama a otra versin de la misma funcinpos=str.indexOf('p', pos+1);

El segundo argumento le dice a la funcin indexOf que empiece a buscar la primera ocurrencia de la letra p a partir de la posicin pos+1. Otra versin de indexOf busca la primera ocurrencia de un substring dentro del String:String str="El primer programa"; int pos=str.indexOf("pro");

Vemos que una clase puede definir varios mtodos con el mismo nombre pero que tienen distinto nmero de parmetros o de distinto tipo, esto se conoce como sobrecarga de mtodos y ser visto a detalle en el siguiente capitulo.

Comparacin de StringsLa comparacin de strings nos da la oportunidad de distinguir entre el operador lgico == y la funcin miembro equals de la clase String. En el siguiente cdigo:public class ClaseString { public static void main(String[] args) { String str1="El lenguaje Java"; String str2=new String("El lenguaje Java"); if(str1==str2) { System.out.println("Los mismos objetos"); } else { System.out.println("Distintos objetos"); } if(str1.equals(str2)) { System.out.println("El mismo contenido"); } else { System.out.println("Distinto contenido");

39



} }

}

Esta porcin de cdigo devolver que str1 y str2 son distintos objetos pero con el mismo contenido. str1 y str2 ocupan posiciones distintas en memoria pero guardan los mismos datos. Cambiemos la segunda sentencia y escribamos:String str1="El lenguaje Java"; String str2=str1; System.out.prinln("Son el mimso objeto "+(str1==str2);

Los objetos str1 y str2 guardan la misma referencia al objeto de la clase String creado. La expresin (str1==str2) devolver true. As cuando deseamos comparar el contenido de dos String se debe usar el mtodo equals, ya que de otra forma, con el operador = = compararemos si los Objetos apuntan a la misma direccin de memoria. El mtodo comapareTo devuelve un entero menor que cero si el objeto String es menor (en orden alfabtico) que el String dado, cero si son iguales, y mayor que cero si el objeto String es mayor que el String dado.String str="Toms"; int resultado=str.compareTo("Alberto");

La variable entera resultado tomar un valor mayor que cero, ya que Toms est despus de Alberto en orden alfabtico.String str="Alberto"; int resultado=str.compareTo("Toms");

La variable entera resultado tomar un valor menor que cero, ya que Alberto est antes que Toms en orden alfabtico. Extraer un substring de un String En muchas ocasiones es necesario extraer una porcin o subcadena de un String dado. Para este propsito hay un mtodo de la clase String denominada substring. Para extraer un substring desde una posicin determinada hasta el final del String escribimos:String str="El lenguaje Java"; String subStr=str.substring(12);

Se obtendr el substring "Java". Una segunda versin del mtodo substring, nos permite extraer un substring especificando la posicin de comienzo y la el final.String str="El lenguaje Java"; String subStr=str.substring(3, 11);

40



Se obtendr el substring "lenguaje". Recurdese, que las posiciones se empiezan a contar desde el indice cero. Convertir un nmero a String Para convertir un nmero en String se emplea el mtodo esttico valueOf:int valor=10; String str=String.valueOf(valor);

La clase String proporciona versiones de valueOf para convertir los datos primitivos: int, long, float, double. Cuando introducimos caracteres en un control de edicin a veces es inevitable que aparezcan espacios ya sea al comienzo o al final. Para eliminar estos espacios tenemos el mtodo trim:String str=" 12 "; String str1=str.trim();

41



5: HerenciaLa herencia es una parte integral de Java. Resulta que siempre se esta haciendo herencia cuando se crea una clase, pero a menos que se herede explcitamente de otra clase, se hereda implcitamente de la clase raz estndar de Java Object. Cuando se hereda, se dice: Esta clase nueva es como esa clase vieja. Se dice esto en el cdigo dando el nombre de la clase pero antes de abrir el cuerpo de clase, se pone la palabra reservada extends seguida del nombre de la clase base. Cuando se hace esto, automticamente se tiene todos los atributos y mtodos de la clase base. He aqu un ejemplo.//Animal.java public class Animal { String raza; String nombre; int edad; String tamao; String tipoDePelaje; public Animal(){ System.out.println("El animal es totalmente Rebelde"); } public Animal(String nombre, String nombre){ this.nombre=nombre; this.raza= nombre; } public void comer() { System.out.println("Alimentando al animal"); } public void respirar() { System.out.println("El animal respira"); } public void reproduccion() { System.out.println("El animal puede reproducirse"); } public void dormir() { System.out.println("El animal duerme"); } } //Gato.java public class Gato extends Animal { int numVidas=7; String tipoDeComida; public void maullar() { System.out.println("El gato esta maullando");

42



} public void rasgar() { System.out.println("El gato esta rasgando"); } public Gato(String nombre,String raza) { this.nombre=nombre; this.raza=raza; System.out.println("\nGato creado"); } public static void main(String args[]) { Gato gato1=new Gato("Batman","Angora"); gato1.respirar(); gato1.maullar(); gato1.rasgar(); gato1.dormir(); }

}

En la clase Gato muestra el uso de la herencia en este ejemplo, como puede verse la clase Gato no incorpora explcitamente los atributos nombre y raza, estos son heredados directamente por la clase Animal. Como dijimos en el capitulo uno, tambin los mtodos son heredados, esto se puede ver en las llamadas a los mtodos respirar y dormir. He aqu la salida del programa:El animal es totalmente Rebelde Gato creado El animal respira El gato esta maullando El gato esta rasgando El animal duerme

Hace falta aun notar un punto importante en este programa, al observar la salida del programa anterior nos encontramos en la primera linea: El animal es totalmente Rebelde, Esta lnea muestra que en la herencia se crean los objetos correspondientes que se encuentran el la cima del rbol jerrquico, en este caso antes de haber creado un Gato fue necesario crear primero un objeto de tipo Animal, se invoca al constructor por default de la clase animal, debido a que la clase gato no invoca de manera explicita ningn constructor. Invocar explcitamente a un constructor es posible mediante el uso de la palabra reservada super.

La palabra reservada superComo ya dijimos, una vez creado un objeto de tipo Gato se crear, en primera instancia, un objeto tipo Animal, el programa anterior crea este objeto por medio del constructor por default, pero Por qu no crear el objeto Animal llamando otro constructor? Si usamos el segundo constructor de animal podemos inicializar las variables nombre y raza de manera automtica, para

43



invocar a un constructor en especfico debemos hacer uso de la palabra super. Modificando el programa anterior tenemos://Animal.java public class Animal2 { String raza; String nombre; int edad; String tamao; String tipoDePelaje; public Animal2(){ System.out.println("El animal es totalmente Rebelde"); } public Animal2(String nombre, String raza){ this.nombre=nombre; this.raza= nombre; System.out.println("En el constructor llamado por super"); } public void comer() { System.out.println("Alimentando al animal"); } public void respirar() { System.out.println("El animal respira"); } public void reproduccion() { System.out.println("El animal puede reproducirse"); } public void dormir() { System.out.println("El animal duerme"); }

}

public class Gato2 extends Animal2 { int numVidas=7; String tipoDeComida; public void maullar() { System.out.println("El gato esta maullando"); } public void rasgar() { System.out.println("El gato esta rasgando"); } public Gato2(String nombre,String raza) { super(nombre, raza); System.out.println("\nGato creado"); } public static void main(String args[]) {

44



Gato2 gato1=new Gato2("Batman","Angora"); gato1.respirar(); gato1.maullar(); gato1.rasgar(); gato1.dormir(); } }

Hemos agregado la llamada al constructor por medio de super en mtodo constructor de Gato, cabe sealar que super buscar un constructor que contenga ese tipo de parmetros, de no existir, la compilacin no tendr xito. Cuando se usa super de esta manera debe ser la primera instruccin en aparecen en el constructor. La salida del programa se muestra a continuacin:En el constructor llamado por super Gato creado El animal respira El gato esta maullando El gato esta rasgando El animal duerme

Sobrecarga y sobreescritura de mtodosLa firma de un mtodo es la combinacin del tipo de dato que regresa, su nombre y su lista de argumentos. La sobrecarga de mtodos es la creacin de varios mtodos con el mismo nombre pero con diferentes firmas y definiciones. Java utiliza el nmero y tipo de argumentos para seleccionar cul definicin de mtodo ejecutar. Java diferencia los mtodos sobrecargados con base en el nmero y tipo de argumentos que tiene el mtodo y no por el tipo que devuelve. Tambin existe la sobrecarga de constructores: Cuando en una clase existen constructores mltiples, se dice que hay sobrecarga de constructores. La sobrecarga de constructores ya la hemos manejado en algunos ejemplos de este manual, a continuacin se muestra un ejemplo que ilustra la sobrecarga de constructores.//SobreCarga.java public class SobreCarga{ public SobreCarga(){ System.out.println("Soy un objeto creado por el constructor sin argumentos"); } public SobreCarga(int num){ System.out.println("Soy un objeto creado por el constructor con un argumento int= "+num); } public SobreCarga(String cad){

45



System.out.println("Soy un objeto creado por el constructor con un argumento String= "+cad); } public SobreCarga(char c,int num,String cad){ System.out.println("Soy un objeto creado por el constructor con tres argumentos char= "+c+" ,int= "+num+" ,String= "+cad); } public static void main(String[] args){ new SobreCarga(2); new SobreCarga("Hola enfermera"); new SobreCarga(); new SobreCarga('Z',7,"No hay papel"); new SobreCarga(9); } }

Sobrescritura de Mtodos.Una subclase hereda todos los mtodos de su superclase que son accesibles a dicha subclase a menos que la subclase sobrescriba los mtodos. Una subclase sobrescribe un mtodo de su superclase cuando define un mtodo con las mismas caractersticas (nombre, nmero y tipo de argumentos) que el mtodo de la superclase. Las subclases emplean la sobre-escritura de mtodos la mayora de las veces para agregar o modificar la funcionalidad del mtodo heredado de la clase padre. Como ejemplo, regresemos al ejemplo de la clase Animal y Gato. Esta vez la Clase Gato sobrescribir el mtodo dormir de la clase Animal cuyo cdigo no variara con respecto a la ltima versin, es decir Animal2.//Gato3.java public class Gato3 extends Animal2 { int numVidas=7; String tipoDeComida; public void maullar() { System.out.println("El gato esta maullando"); } public void rasgar() { System.out.println("El gato esta rasgando"); } public Gato3(String nombre,String raza) { super(nombre, raza); System.out.println("\nGato creado"); } public void dormir() { System.out.println("El gato esta durmiendo, no molestar"); } public static void main(String args[]) { Gato3 gato1=new Gato3("Batman","Angora"); gato1.respirar();

46



gato1.maullar(); gato1.rasgar(); gato1.dormir(); } }

He aqu la Salida:En el constructor llamado por super Gato creado El animal respira El gato esta maullando El gato esta rasgando El gato esta durmiendo, no molestar

Observe que la ltima lnea ha cambiado por la sobre-escritura del mtodo dormir. Ahora modifiquemos la clase Gato, esta vez agregaremos la siguiente lnea:super.dormir();

Justo antes de la lnea que imprime: El gato esta durmiendo, no molestar. Es decir:public void dormir() { super.dormir(); System.out.println("El gato esta durmiendo, no molestar"); }

Esta es otra forma de usar super, en la cual se ejecuta un mtodo de la clase Padre o superclase. Al usar super de esta manera, no hay ninguna restriccin del lugar donde se haga la llamada al mtodo.

Conversin hacia arriba (upcasting)Hasta ahora, podemos pensar que el aspecto ms importante acerca de la herencia, es que podemos heredar mtodos a nuestra clase hija. Sin embargo, la herencia es importante por la relacin que se crea entre la clase padre y la clase hija. Veamos un ejemplo, consideremos como clase base Instrumento que representa instrumentos musicales, y una clase derivada Viento. Como sabemos, la herencia implica que todos los mtodos de la clase padre estarn disponibles en la clase hija; entonces; cualquier mensaje que le enviemos a la clase padre podr ser enviado a la clase hija.//Instrumento.java //Herencia y upcasting public class Instrumento{

47



public void play(){} public static void tune(Instrumento i){ // i.play(); } } //Viento.java //Los instrumentos de Viento son instrumentos! //porque tienen la misma interfaz public class Viento extends Instrumento{ public static void main(String[] args){ Viento flauta=new Viento(); Instrumento.tune(flauta); //Upcasting } }

Vemos en el ejemplo lo siguiente: el mtodo tune() tiene como argumento un objeto Instrumento. Sin embargo, en el mtodo Viento.main() el mtodo tune() es llamado con una referencia de tipo Viento. Como podemos comprobar, los objetos de tipo Viento tambin son objetos de tipo Instrumento. Vemos que el upcasting tiene sentido ya que partimos de una clase ms especfica a una ms general, por lo que se cumple la regla. La clase hija podr tener ms mtodos que la clase padre, sin embargo, debe contener por lo menos los mtodos de la clase padre.

La palabra clave finalLa palabra clave final de Java tiene significados ligeramente diferentes dependiendo del contexto, pero en general dice: Esto no puede cambiarse. Se podra querer evitar cambios por dos razones: diseo o eficiencia. Dado que estas dos razones son bastantes diferentes, es posible utilizar errneamente la palabra clave final.

Para DatosUna variable o atributo puede ser una constante que deseamos no cambia nunca en nuestro programa, esto se puede realizar anteponiendo la palabra final a la declaracin de una variable. Utilizar constantes declaradas por final puede eliminar parte de la sobrecarga en tiempo de ejecucin de un programa. Al usar final con referencias a objetos en vez que con datos primitivos, su significado se vuelve algo confuso. Con un dato primitivo, final convierte el valor en constante, pero con una referencia a un objeto, final hace de la referencia una constante. Una vez que la referencia se inicializa a un objeto, sta nunca se puede cambiar para que apunte a otro objeto. Sin embargo se puede modificar el objeto en s; Java no proporciona ninguna manera de convertir un objeto arbitrario en una constante. 48



He aqu un ejemplo que muestra el funcionamiento de los campos final://Valor.java public class Valor { int i = 1; } //DatosConstantes.java public class DatosConstantes { //Pueden ser constantes en tiempo de compilacion final int variable1 = 9; static final int VAL_DOS=99; //Tipica constante publica public static final int VAL_TRES=39; //No pueden ser constantes en tiempo de compilacion final int variable4= (int)(Math.random()*20); static final int variable5=(int)(Math.random()*20); Valor v1= new Valor(); final Valor v2 = new Valor(); static final Valor v3 = new Valor(); //Arrays: final int[] a= {1,2,3,4,5,6}; public void escribir(String id) { System.out.println(id+" : variable4 ="+variable4+ ", variable5 ="+variable5); } public static void main(String[] args) { DatosConstantes fd1= new DatosConstantes(); //! fd1.variable1++; //Error: No se puede cambiar el valor fd1.v2.i++; //El objeto no es constante fd1.v1= new Valor(); //OK, el Objeto no es final for(int i=0;i< fd1.a.length;i++) fd1.a[i]++; //! fd1.v2 = new Valor(); // No se puede //! fd1.v3 = new valor3(); //Cambiar la referencia //! fd1.a= new int[3]; fd1.escribir("fd1"); System.out.println("Creando un nuevo DatosConstantes"); DatosConstantes fd2= new DatosConstantes(); fd1.escribir("fd1"); fd2.escribir("fd2"); } }

Nota que los datos primitivos static final, se escriben en maysculas por convencin. Una posible salida del programa se muestra a continuacin:fd1 : variable4 =12, variable5 =14 Creando un nuevo DatosConstantes fd1 : variable4 =12, variable5 =14

49



fd2 : variable4 =19, variable5 =14

Fjese que los valores de variable4 para fd1 y fd2 son nicos, pero el valor variable5 no ha cambiado al crear el segundo objeto DatosConstantes. Esto es porque es esttico y se inicializa una vez en el momento de la carga y no cada vez que se crea un nuevo objeto. Las variables v2 y v3 demuestran el significado de una referencia final. Como se puede ver en main( ), justo porque v2 sea final, no significa que no pueda cambiar su valor. Sin embargo, no se puede reubicar v2 a un nuevo objeto, precisamente por que es final. Esto es lo que final significa para un referencia.

Constantes Blancas.Java permite la creacin de constantes blancas, que son campos declarados como final pero a los que no se da un valor de inicializacin. En cualquier caso, se debe inicializar una constante blanca antes de utilizarla, y esto lo asegura el propio compilador. Sin embargo, las constantes blancas proporcionan mucha mayor flexibilidad en el uso de la palabra clave final puesto que, por ejemplo, un campo final incluido en una clase puede ahora ser diferente para cada objeto, y sin embargo, sigue reteniendo su cualidad de inmutable. He aqu un ejemplo://ConstanteBlanca.java public class ConstanteBlanca { final int i=0; //Constante inializada final int j; // Constante blanca final Elemento p; //Referencia a constante blanca //Las constantes blancas DEBEN inicializarse en el constructor public ConstanteBlanca(){ j=1; //Inicializa la constante blanca p= new Elemento(); } public ConstanteBlanca(int x){ j=

Manual Java Basico

Documents

Transcript of Manual Java Basico