Javabasico PDF

Manual del Curso Java Bsico Programa de Tecnologa en Cmputo
UNIVERSIDAD NACIONAL AUTNOMA DE MXICO
FACULTAD DE INGENIERA
DIVISIN 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 CONTENIDO
1: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 Software
La 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 objetos
A 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 objetos
En 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 mtodos
Como 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.
Herencia
La 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
Polimorfismo
El 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.
Abstraccin
Como 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 Programas
La 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 Tamao Mnimo Mximo Envoltura

bolean - - - Boolean
char 16 bits Unicode 0 Unicote 216-1 Character
byte 8 bits -128 +127 Byte
short 16 bits -215 +215-1 Short
int 32 bits -231 +231-1 Integer
long 64 bits -263 +263-1 Long
float 32 bits IEEE754 IEEE754 Float
double 64 bits IEEE754 IEEE754 Double
void - - - 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 basura
Los 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 objetos
Como 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;
int edad;
String carrera;
int semestre;

{
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.edad=20;
alumno1.semestre=4;
alumno2.nombre="Pedro";//inicializamos sus atributos.

alumno2.apellidoMaterno="Rodriguez";
alumno2.apellidoPaterno="Rodriguez";
alumno2.carrera="Ing. Electrica";
alumno2.edad=18;
alumno2.semestre=1;
System.out.println("Datos del alumno1:");

15

System.out.println("\nDatos del alumno2:");
}
}
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:

Edad: 20
Carrea: Computacion
Semestre: 4
Datos del alumno2:

Nombre: Pedro Rodriguez Rodriguez
Edad: 18
Carrea: Ing. Electrica
Semestre: 1
Atributos y mtodos
En 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 {

String nombre;
int edad;
String carrera;
int semestre;
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);
}

{
Alumno2 alumno1=new Alumno2();// creamos un nuevo objeto de tipo alumno
Alumno2 alumno2= new Alumno2();// creamos otro nuevo objeto
alumno1.edad=20;
alumno1.semestre=4;

alumno2.edad=18;
alumno2.semestre=1;
alumno1.imprimirDatos();
}
}
Hemos agregado el mtodo imprimirDatos, este mtodo es llamado por los dos
objetos creados en las instrucciones:
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 this
En nuestra clase Alumno2 revisemos las siguientes lneas:

alumno1.edad=20;
alumno1.semestre=4;

alumno2.edad=18;
alumno2.semestre=1;
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

String nombre;
int edad;
String carrera;
int semestre;
public Alumno3()
{
System.out.println("Creando un nuevo Alumno...");
}

{
}

{
alumno1.edad=20;
alumno1.semestre=4;

alumno2.edad=18;
alumno2.semestre=1;
}
}
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...

19

Edad: 20
Carrea: Computacion
Semestre: 4
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:
String nombre;
int edad;
String carrera;
int semestre;
public Alumno4(String nom, String apePat, String apeMat, int anios, String car, int sem, String
cuenta)
{
nombre=nom;
apellidoPaterno=apePat;
apellidoMaterno=apeMat;
edad=anios;
carrera=car;
semestre=sem;
numeroDeCuenta=cuenta;
}

{
}
20

{
//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");
}
}
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)
{
nombre=nombre;
apellidoPaterno=apellidoPaterno;
apellidoMaterno=apellidoMaterno;
edad=edad;
carrera=carrera;
semestre=semestre;
numeroDeCuenta=numeroDeCuenta;
}
El resultado de realizar estos cambios se muestra a continuacin:

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:

String nombre;
int edad;
String carrera;
int semestre;
{
this.nombre=nombre;
this.apellidoPaterno=apellidoPaterno;
this.apellidoMaterno=apellidoMaterno;
this.edad=edad;
this.carrera=carrera;
this.semestre=semestre;
this.numeroDeCuenta=numeroDeCuenta;
}

{
}

{
Alumno6 alumno1=new
Electrica",1,"040012548");
}
}
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);
}

{
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
String nombre;
int edad;
String carrera;
int semestre;
{
this.nombre=nombre;
this.edad=edad;
}

{
}
24
//Escuela.java
public class Escuela {

{
Alumno7 alumno1=new
Electrica",1,"040012548");
}
}
Se comprobar que la salida no cambia en relacin a programas anteriores.
Variables y mtodos de clase
Generalmente, 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
String nombre; // variable de instancia, cada que creas un objeto se crea un copia para cada
objeto
int edad;
String carrera;
int semestre;
static int numeroDeAlumnos=0;// variable de clase, no se crean copias para cada objeto, es
fija.
{
this.nombre=nombre;
this.edad=edad;
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;
}

{
}
}
Hemos agregado un mtodo y una variable esttica, ahora modifiquemos el

archivo Escuela para mandar llamar las variables estticas.
//Escuela2.java
public class Escuela2 {
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());
Alumno8 alumno1=new
Electrica",1,"040012548");
//Despues de crear dos objetos, la variable estatica se ha modificado
//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++;
}
}
La salida de este programa deber ser la siguiente:

Numero total de Alumnos: 0
Mensaje del metodo de clase: Metodo de clase
Desde alumno1, Numero de Alumnos: 2
Clases envolventes o wrappers
Los 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.
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 {

{
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]);
}
}
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 dimensiones
Java 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 Crea un archivo nuevo vaco.

t Lista la tabla de contenidos.
x Extrae todos los archivos.
x file Extraer el archivo nombrado.
f Nombre del archivo.
m Indica que el primer parmetro ser el archivo de declaracin.
v Genera una salida que describe que va haciendo jar.
O Simplemente almacena los archivos; no los comprime (usarlo para crear un
archivo JAR que se puede poner en el CLASSPATH)
M 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
sillas");
f=true;
}
finalizadas++;
if(finalizadas>=creadas)
System.out.println("Las "+finalizadas+" han sido finalizadas");
}
32
//Basura.java
public class Basura {
{
//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 Muerto
En 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 documentacin
Hay 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.
Sintaxis
Todos 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 empotrado
Javadoc 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:
/**
* <pre>
* System.out.println(new Date());
* </pre>
*/
Tambin puede usarse HTML como se hara en cualquier otro documento web
para dar formato al propio texto de las descripciones:
/**
* Uno puede <em>incluso</em> insertar una lista:
* <ol>
* <li> Elemento uno
* <li> Elemento dos
* <li> Elemento tres
* </ol>
*/
@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<br>
* <h1>Se pueden usar etiquetas de HTML</h1>,
* para darle formato al texto.<br>
* 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 String

Dentro 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, alternativamente
String str="El primer programa";
Para crear un String nulo se puede hacer de estas dos formas
String 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.

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:

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:

boolean resultado=str.endsWith("programa");
Si se quiere obtener la posicin de la primera ocurrencia de la letra p, se usa la

funcin indexOf:

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

la misma funcin
pos=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:

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 Strings
La 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 {

{
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: Herencia
La 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");
}

{
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 super
Como 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;
}
}
public Gato2(String nombre,String raza) {
super(nombre, raza);
}

{
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 animal duerme
Sobrecarga y sobreescritura de mtodos
La 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;
}
}
public Gato3(String nombre,String raza) {
super(nombre, raza);
}
public void dormir()

{
System.out.println("El gato esta durmiendo, no molestar");
}

{
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 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{
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 final
La 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 Datos
Una 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);
}

{
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();
}
}
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
49
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=x;//Inicializa la constante blanca
p=new Elemento();
}
{
ConstanteBlanca bf= new ConstanteBlanca();
}
}
50
Mtodos Constantes
Hay dos razones que justifican los mtodos constantes. La primera es poner un
bloqueo en el mtodo para evitar que cualquier clase heredada vare su
significado. Esto se hace por razones de diseo cuando uno se quiere asegurar
de que se mantenga el comportamiento del mtodo durante la herencia,
evitando que sea sobrescrito.
La segunda razn para los mtodos constantes es la eficiencia. Si se puede

hacer un mtodo constante se sta permitiendo al compilador convertir
cualquier llamada a ese mtodo en llamadas rpidas.
Para que un mtodo sea constante, basta con anteponer la palabra final en su
firma, ejemplo:
public final void nombreMetodo()

{
.
.
.
}
Clases Constantes
Cuando se dice que una clase entera es constante (precediendo su definicin

de la palabra clave final), se establece que no se desea heredar de esta clase
o permitir a nadie ms que lo haga. En otras palabras, por alguna razn el
diseo de la clase es tal que nunca hay necesidad de hacer cambios, o por
razones de seguridad no se desea la generacin de subclases. De esta manera
alternativa, se pueden estar tratando aspectos de eficiencia, y hay que
asegurarse de que cualquier actividad involucrada con objetos de esta clase
sea lo ms eficiente posible.
//Cerebro.java
public class CerebroPequenio {
//Dinosaorio.java
public final class Dinosaurio {
int i=7;
int j=1;
CerebroPequenio x= new CerebroPequenio();
public void f()
{}
}
//Jurasico.java
public class Jurasico {
{
Dinosaurio n= new Dinosaurio();
51
n.f();
n.i=40;
n.j++;
}
}
//public class SerEvolucionado extends Dinosaurio{

//} //Error: no se puede heredar de la clase constante.
52
6: Polimorfismo
El polimorfismo es la tercera caracterstica esencial de un lenguaje orientado a
objetos. Es una herramienta que provee otra dimensin de interfaz, capaz de
separar el qu del cmo.
En el captulo pasado aprendimos que con la herencia podemos tratar un

objeto como tipo de su clase padre. Esta habilidad es esencial porque permite
que objetos de varios tipos puedan ser tratados como objetos de un solo tipo,
todo en el mismo cdigo para trabajar con todos los distintos tipos de manera
similar. El polimorfismo nos permite que distinguir entre los tipos de objetos que
son similares. Dicha diferencia se expresa a travs del comportamiento de los
mtodos que se heredan de la clase padre.
Veamos un ejemplo para recordar la conversin (Cast) hacia arriba:
//Nota.java
//Herencia y upcasting.
public class Nota{
private int valor;
private Nota(int val){ valor=val;}
public static final Nota DO_MAYOR=new Nota(0);
public static final Nota DO_SOSTENIDO=new Nota(1);
public static final Nota SI_BEMOL =new Nota(2);
}
//Instrumento2.java
public class Instrumento2{
public void play(Nota n){
System.out.println("Instrumento.play()");
}
}
//Viento2.java
//Los instrumentos de viento son tambin tipo Instrumento!
//porque tienen el mismo comportamiento.
public class Viento2 extends Instrumento2{
//Redefiniendo un mtodo
System.out.println("Viento.play()");
}
}
//Musica2.java
public class Musica2{
public static void tonada(Instrumento2 i){
i.play(Nota.DO_SOSTENIDO);
}
Viento2 flauta=new Viento2();
tonada(flauta); //Upcasting
}
}
53
El mtodo Musica.tonada() acepta un objeto Instrumento como referencia,

pero tambin objetos derivado de ste. Por eso es que cualquier objeto Viento
es aceptable para dicho mtodo, ya que Viento hereda de Instrumento. Este
programa parecera ms directo s el mtodo tonada tuviera como argumento
un objeto de tipo Viento. Esto presenta un punto esencial: si se hiciera esto se
necesitar escribir un nuevo mtodo tonada para cada tipo de Instrumento del
sistema. Supngase que se sigue este razonamiento y se aaden los
instrumentos de Cuerda y Metal. Agregaremos las siguientes clases a nuestro
directorio, renombremos y modifiquemos la clase Musica2 por Musica3 como
se muestra a continuacin:
//Metal.java
public class Metal extends Instrumento2{
System.out.println("Metal.play()");
}
}
//Cuerda.java
public class Cuerda extends Instrumento2{
System.out.println("Cuerda.play()");
}
}
//Musica3.java
public static void tonada(Viento2 v){
v.play(Nota.DO_SOSTENIDO);
}
public static void tonada(Cuerda c){
c.play(Nota.DO_SOSTENIDO);
}
public static void tonada(Metal m){
m.play(Nota.DO_SOSTENIDO);
}
Viento2 f=new Viento2();
Cuerda c=new Cuerda();
Metal p=new Metal();
tonada(f);
tonada( c );
tonada( p );
}
}
Como podemos observar, en este ejemplo creamos un mtodo para cada tipo
de objeto distinto. Nuestra primera impresin es que dicho cdigo resulta
bastante largo debido a que repetimos una y otra vez la misma funcin.
Adems resulta muy esttico, dado que una vez que creemos un nuevo objeto
que herede de la clase Instrumento, tendremos que agregar una nueva
54
funcin. No sera ms sencillo escribir un solo mtodo que tome como

argumento a la clase base sin especificar el tipo de objeto en particular ?.
Regresemos al ejemplo de Musica.java. Es claro que la salida del programa es

Viento.play(), ya que el mtodo tonada() recibe como argumento un objeto
Instrumento. Pero, cmo puede saber el compilador que el objeto que recibe
es Viento y no de otro tipo? La respuesta es la manera en que trabaja Java:
binding (ligadura). Expliquemos a grandes rasgos de en qu consiste este
concepto. Ligar la llamada de un mtodo con el cuerpo de un mtodo se llama
ligar (bind). Cuando el compilador realiza dicha accin antes de ejecutar un
cdigo, se le conoce como early binding (ligadura temprana). Java utiliza una
alternativa llamada late binding (ligadura tardia), que significa que dicha
atadura ocurre en tiempo de compilacin. A esta alternativa de binding se le
conoce tambin como dynamic binding (ligadura dinmica).
Todos los mtodos en Java utilizan dicha tcnica a menos que sean declarados
final. Dicho de otra forma, Java es capaz de reconocer el tipo de objeto que
ser utilizado en un mtodo gracias al dynamic binding.
Veamos un ejemplo clsico de la OOP. Consideremos la clase Figura y sus

clases hijas Crculo, Cuadrado y Tringulo. Este ejemplo es bastante
explcito ya que es bastante lgico decir: un cuadrado es una figura.
La frase anterior puede ser codificada correctamente de la siguiente manera:
Figura f = new Cuadrado();
En este ejemplo, un objeto Cuadrado es creado y el resultado es una

referencia asignada a Figura, lo cual parece incorrecto, sin embargo, y desde
la perspectiva anterior, un Cuadrado es una figura, por lo que en realidad la
sentencia es correcta. Ahora, supongamos que llamamos un mtodo de la
clase padre:
f.Dibujar();
Podra suponerse que el mtodo Dibujar() de Figura es llamado, sin embargo,

es el mtodo de Cuadrado el que es llamado gracias al polimorfismo. Ahora
veamos el ejemplo en cdigo Java:
//Figura.java
//Polimorfismo en Java
public class Figura{
void dibujar()
{
System.out.println("Dibujando una Figura");
}
void borrar()
{
System.out.println("Borrando una Figura");
}
}
55
//Circulo.java
public class Circulo extends Figura{
void dibujar(){
System.out.println("Circulo.dibujar()");
}
void borrar(){
System.out.println("Circulo.borrar()");
}
}
//Triangulo.java
public class Triangulo extends Figura{
void dibujar(){
System.out.println("Triangulo.dibujar()");
}
void borrar(){
System.out.println("Triangulo.borrar()");
}
}
//Cuadrado.java
public class Cuadrado extends Figura{
void dibujar(){
System.out.println("Cuadrado.dibujar()");
}
void borrar(){
System.out.println("Cuadrado.borrar()");
}
}
public class Figuras{

public static Figura figuraAleatoria(){
switch((int)(Math.random()*3)){
default:
case 0:
return new Circulo();
case 1:
return new Cuadrado();
case 2:
return new Triangulo();
}
}
Figura[] s=new Figura[9];
//llenamos el arreglo de figures!
for(int i=0;i<s.length;i++)
s[i]=figuraAleatoria();
//Llamadas polimorficas
for(int i=0;i<s.length;i++)
s[i].dibujar();
}
}
La clase padre establece el comportamiento de las clases que la heredan. Es

decir, todas las subclases pueden borrar y dibujar. Cada subclase establece su
comportamiento particular para dichos mtodos. En el ejemplo, se crean
objetos de manera aleatoria y se almacenan en un arreglo de objetos Figura.
56
Clases y mtodos abstractos
En lo ejemplos de la clase Instrumento, los mtodos declarados eran falsos,

su nica intencin era la de crear una interfaz comn para todas las clases que
se deriven de Instrumento. Otra manera es llamar a la clase Instrumento, una
clase abstracta. Se crea una clase abstracta cuando se desea manipular un
conjunto de clases a travs de una interfaz comn.
Si se tiene una clase abstracta como instrumento, los objetos de esa clase casi
nunca tienen significado. Es decir, Instrumento simplemente tiene que
expresar la interfaz, y no una implementacin particular, de forma que no tiene
sentido crear objetos de tipo Instrumento.
Java proporciona un mecanismo para hacer esto, denominado mtodo

abstracto. Se trata de un mtodo incompleto; tiene slo declaracin faltndole
los mtodos. La sintaxis para una declaracin de mtodo abstracto es:
abstract void f ( );
Toda clase que contenga uno o ms mtodos abstractos, se califica de

abstracto. Con las clases abstractas tenemos las siguientes caractersticas:
No se puede crear un objeto de una clase abstracta.

Si una clase hereda de una clase abstracta, sta debe implementar
todos los mtodos abstractos o bien, seguir siendo abstracta.
Una clase abstracta puede tener mtodos no-abstractos y abstractos.
Con un solo mtodo abstracto, la clase debe ser declarada como
abstracta.
La clase instrumento puede convertirse fcilmente en una clase abstracta. Slo

sern abstractos alguno de sus mtodos.
//Instrumento4.java
//Clases abstractas y mtodos.
abstract class Instrumento4{
int i;
public abstract void play();
public String quienSoy(){
return "Instrumento";
}
public abstract void adjust();
}
//Viento4.java
public class Viento4 extends Instrumento4{
public void play(){
}
57
return "Viento";
}
public void adjust(){}//Se implementa el body
}
//Cuerda.java
public class Cuerda4 extends Instrumento4{
public void play(){
System.out.println("Cuerda.play()");
}
return "Cuerda";
}
public void adjust(){}
}
//Percusion.java
public class Percusion4 extends Instrumento4{
public void play(){
System.out.println("Percusion.play()");
}
return "Percusion";
}
}
//Flauta.java
public class Flauta4 extends Viento4{
public void play(){
System.out.println("Flauta.play()");
}
return "Flauta";
}
public void adjust(){ System.out.println("Flauta.adjust()");}
}
//Saxofon.java
public class Saxofon4 extends Viento4{
public void play(){
System.out.println("Saxofon.play()");
}
return "Saxofon";
}
}
//Musica4.java
static void tune(Instrumento4 i){
i.play();
}
static void tuneAll(Instrumento4[] e){
for(int i=0;i<e.length;i++)
tune(e[i]);
}
58
Instrumento4[] orquesta=new Instrumento4[5];

orquesta[0]=new Viento4();
orquesta[1]=new Percusion4();
orquesta[2]=new Cuerda4();
orquesta[3]=new Flauta4();
orquesta[4]=new Saxofon4();
tuneAll(orquesta);
}
}
Interfaces y clases internas
Interfaces.
La palabra clave interfaz lleva el concepto de abstraccin un paso ms all. Se

podra pensar que es una clase abstracta pura permite al creador establecer la
forma de una clase: nombres de mtodos, listas de parmetros y tipos de
retorno, pero no cuerpos de mtodo.
Una interfaz dice: sta es la apariencia que tendrn todas las clases que
implementen esta interfaz. Por consiguiente, cualquier cdigo que use una
interfaz particular sabe qu mtodos deberan ser invocados por esa interfaz, y
eso es todo.
Para crear una interfaz, se usa la palabra clave interface en vez de la palabra
clave class. Para hacer una clase que se ajuste a una interfaz particular (o a
un grupo de interfaces), se usa la palabra clave implements. Se esta diciendo
La interfaz contiene la apariencia, pero ahora voy a decir cmo funciona. Por
lo dems, es como la herencia. El ejemplo de los instrumentos utilizando
interfaces se muestra a continuacin.
//Insterface.java
//Interfaces
interface Instrumento5{
int i=5;
//Los mtodos no deben estar definidos.
void play();
String quienSoy();
void adjust();
}
//Viento5.java
public class Viento5 implements Instrumento5{
public void play(){
}
public String quienSoy()
{return "Viento";}
}
public class Cuerda5 implements Instrumento5{

public void play(){
59
}
public String quienSoy(){return "Viento";}
}
//Percusion5.java
public class Percusion5 implements Instrumento5{
public void play(){
System.out.println("Percusion.play()");
}
public String quienSoy(){return "Percusion";}
}
//Flauta.java
public class Flauta5 extends Viento5{
public void play(){
System.out.println("Flauta.play()");
}
return "Flauta";
}
public void adjust(){ System.out.println("Flauta.adjust()");}
}
//Saxofon.java
public class Saxofon5 extends Viento5{
public void play(){
System.out.println("Saxofon.play()");
}
return "Saxofon";
}
}
//Musica5.java
static void tune(Instrumento5 i){
i.play();
}
static void tuneAll(Instrumento5[] e){
for(int i=0;i<e.length;i++)
tune(e[i]);
}
Instrumento5[] orquesta=new Instrumento5[5];
int i=0;
orquesta[i++]=new Viento5();
orquesta[i++]=new Percusion5();
orquesta[i++]=new Cuerda5();
orquesta[i++]=new Flauta5();
orquesta[i++]=new Saxofon5();
tuneAll(orquesta);
}
}
60
Extender una interfaz con herencia.
Podemos fcilmente aadir un nuevo mtodo a una interfaz usando herencia, y

tambin podemos combinar muchas interfaces con una nueva interfaz con
ayuda de la herencia:
//Monstruo.java
//Extendiendo una interfaz con herencia
public interface Monstruo{
void amenaza();
}
//MosntruoPeligroso.java
public interface MonstruoPeligroso extends Monstruo{
void destruye();
}
//Letal.java
public interface Letal{
void mata();
}
//Vampiro.java
interface Vampiro extends MonstruoPeligroso,Letal{
void ChupaSangre();
}
//Dragon.java
public class Dragon implements MonstruoPeligroso{
public void amenaza(){}
public void destruye(){}
}
//ShowDeHorror.java
public class ShowDeHorror {
static void u(Monstruo b){ b.amenaza();}
static void v(MonstruoPeligroso d){
d.amenaza();
d.destruye();
}
Dragon barney=new Dragon();
u(barney);
v(barney);
}
}
Clases Internas:
Es posible colocar una definicin de clase dentro de otra definicin de clase. A

la primera se le denomina clase interna. Este tipo de clases son una
61
caracterstica importante. Este tipo de clases son una caracterstica valiosa,

pues permite agrupar clases que lgicamente estn relacionadas una de otra.
Se crea una clase interna como uno esperara, ubicando su definicin dentro
del envolvente.
//Paquete1.java
//Creando clases internas
public class Paquete1{
class Contenidos{
private int i=11;
public int valor(){ return i;}
}
class Destino{
private String etiqueta;
Destino(String adonde){
etiqueta=adonde;
}
String leerEtiqueta(){ return etiqueta;}
}
public void enviar(String dest){
Contenidos c=new Contenidos();
Destino d=new Destino(dest);
System.out.println(d.leerEtiqueta());
}
Paquete1 p=new Paquete1 ();
p.enviar("Tanzania");
}
}
Las clases internas, cuando se usan dentro de enviar tiene la misma apariencia
que muchas otras clases. Aqu, la nica diferencia prctica es que los nombres
se anidan dentro de Paquete1. Generalmente, la clase externa tendr un
mtodo que devuelva una referencia a una clase interna, como esta:
//Paquete2.java
//Creando clases internas
public class Paquete2{
class Contenidos{
private int i=11;
public int valor(){ return i;}
}
class Destino{
private String etiqueta;
Destino(String aDonde){
etiqueta=aDonde;
}
String leerEtiqueta(){ return etiqueta;}
}
public Destino para(String s)
{
return new Destino(s);
}
public Contenidos cont()
62
{
return new Contenidos();
}
public void enviar(String dest){
Contenidos c= cont();
Destino d=para(dest);
System.out.println(d.leerEtiqueta());
}
Paquete2 p=new Paquete2 ();
p.enviar("Tanzania");
Paquete2 q=new Paquete2();
//Definir referencias a clases internas
Paquete2.Contenidos c= q.cont();
Paquete2.Destino d= q.para("Borneo");
}
}
63
7:Paquetes.
Para hacer que una clase sea ms fcil de localizar y utilizar as como evitar
conflictos de nombres y controlar el acceso a los miembros de una clase, las
clases se agrupan en paquetes.
Paquete
Un paquete es un conjunto de clases e interfaces relacionadas.
La forma general de la declaracin package es la siguiente:
package nombrePaquete;
Donde nombrePaquete puede constar de una sola palabra o de una lista de nombres de
paquetes separados por puntos.
Ejemplo
package miPaquete;
class MiClase
{
...
}
Ejemplo
package nombre1.nombre2.miPaquete;
class TuClase
{
...
}
Los nombres de los paquetes se corresponden con nombre de directorios en el sistema

de archivos.
De esta manera, cuando se requiera hacer uso de estas clases se tendrn que importar de
la siguiente manera.
Ejemplo
import miPaquete.MiClase;
import nombre1.nombre2.miPaquete.TuClase;
class OtraClase
{
/* Aqui se hace uso de la clase 'Miclase' y de la
clase 'TuClase' */
...
}
64
Para importar todas las clases que estn en un paquete, se utiliza el asterisco ( * ).
Ejemplo
import miPaquete.*;
Si no se utiliza la sentencia package para indicar a que paquete pertenece una clase, sta
terminar en el package por default, el cual es un paquete que no tiene nombre.
Ejemplo:
package paquete1;
public class ClaseEnPaquete {

int prueba;
public void algunMetodo()
{
System.out.println("Prueba de paquete");
}
{
ClaseEnPaquete a=new ClaseEnPaquete();
a.algunMetodo();
}
}
Para compilar este clase ejecutar la siguiente sentencia:
javac d . ClaseEnPaquete.java
Donde el punto (.) a indica que se crearan los directorios a partir del directorio actual.
Para ejecutar esta clase podemos escribir:

java paquete1.ClaseEnPaquete
Modificadores de Acceso
Los modificadores ms importantes desde el punto de vista del diseo de clases y
objetos, son los que permiten controlar la visibilidad y acceso a los mtodos y variables
que estn dentro de una clase.
Uno de los beneficios de las clases, es que pueden proteger a sus variables y mtodos
(tanto de instancia como de clase) del acceso desde otras clases.
Java soporta cuatro niveles de acceso a variables y mtodos. En orden, del ms pblico
al menos pblico son: pblico (public), protegido (protected), sin modificador (tambin
conocido como package) y privado (private).
La siguiente tabla muestra el nivel de acceso permitido por cada modificador:
public protected (sin modificador) private
65
Clase SI SI SI SI
Subclase en
SI SI SI NO
el mismo paquete
No-Subclase en
SI SI SI NO
el mismo paquete
Subclase en
SI SI/NO (*) NO NO
diferente paquete
No-Subclase en
diferente paquete SI NO NO NO
(Universo)
(*) Los miembros (variables y metodos) de clase (static) si son visibles. Los miembros
de instancia no son visibles.
Como se observa de la tabla anterior, una clase se ve a ella misma todo tipo de variables
y mtodos (desde los public hasta los private); las demas clases del mismo paquete (ya
sean subclases o no) tienen acceso a los miembros desde los public hasta los sin-
modificador. Las subclases de otros paquetes pueden ver los miembros public y a los
miembros protected, stos ltimos siempre que sean static ya de no ser as no sern
visibles en la subclase (Esto se explica en la siguiente pgina). El resto del universo de
clases (que no sean ni del mismo paquete ni subclases) pueden ver slo los miembros
public.
Ejemplo:
//ClaseInicial.java
package paq01;
public class ClaseInicial
{
public int a = 1;
protected int b = 2;
int c = 3; //es amigable
private int d = 4;
public void metodoPublic()

{
System.out.println("En el metodo public");
}
protected void metodoProtected()
{
System.out.println("En el metodo protected");
}
void metodo()
{
System.out.println("En el metodo sin modificador");
}
private void metodoPrivate()
{
System.out.println("En el metodo private");
}
66

{
ClaseInicial obj = new ClaseInicial();
System.out.println("a = " + obj.a);
obj.metodoPublic();
System.out.println("b = " + obj.b);
obj.metodoProtected();
System.out.println("c = " + obj.c);
obj.metodo();
System.out.println("d = " + obj.d);
obj.metodoPrivate();
}
}
// ClaseHijaEnDiferentePaquete.java
package paq02;
import paq01.*;
public class ClaseHijaEnDiferentePaquete extends ClaseInicial
{
{
obj.metodoPublic();
/*
obj.metodo();
*/
}
}
// ClaseHijaEnMismoPaquete.java
package paq01;
public class ClaseHijaEnMismoPaquete extends ClaseInicial

{
{
obj.metodoPublic();
obj.metodo();
//System.out.println("d = " + obj.d);
//obj.metodoPrivate();
}
}
// ClaseNoHijaEnDiferentePaquete.java
package paq02;
import paq01.ClaseInicial;
public class ClaseNoHijaEnDiferentePaquete
{
67
{
obj.metodoPublic();
/*
obj.metodo();
*/
}
}
// ClaseNoHijaEnMismoPaquete.java
package paq01;
public class ClaseNoHijaEnMismoPaquete
{
{
obj.metodoPublic();
obj.metodo();
//System.out.println("d = " + obj.d);
//obj.metodoPrivate();
}
}
Para ejecutar el ejemplo, compilar y ejecutar cada clase por separado.
68
Apndice A: Breve historia de Java

Para apreciar el significado e importancia de Java, es muy importante conocer
su lugar de origen y cuales fueron sus propsitos: En Diciembre de 1990,
Patrick Naughton, un empleado de la empresa Sun, reclut a sus colegas
James Gosling y Mike Sheridan para trabajar sobre un nuevo tema conocido
como "El proyecto verde". Este a su vez estaba auspiciado por la compaa
"Sun founder Hill Joy" y tena como objetivo principal crear un lenguaje de
programacin accesible, fcil de aprender y de usar, que fuera universal, y que
estuviera basado en un ambiente C++ ya que haba mucha frustracin por la
complejidad y las limitaciones de los lenguajes de programacin existentes.
En abril de 1991, el equipo decidi introducir sistemas de software con

aplicaciones para consumidores smart como plataforma de lanzamiento para
su proyecto. James Gosling escribi el compilador original y lo denomin "Oak",
y con la ayuda de los otros miembros del equipo desarrollaron un decodificador
que mas tarde se convertira en lenguaje Java. Para 1992, el equipo ya haba
desarrollado un sistema prototipo conocido como "*7", que era una especie de
cruce entre un asistente digital personalizado y un mecanismo inteligente de
control remoto.
Por su parte el presidente de la compaa Sun, Scott McNealy, se dio cuenta

en forma muy oportuna y estableci el Proyecto Verde como una subsidiaria de
Sun. De 1993 a 1994, el equipo de Naughton se lanz en busca de nuevas
oportunidades en el mercado, mismas que se fueron dando mediante el
sistema operativo base. La incipiente subsidiaria fracas en sus intentos de
ganar una oferta con Time-Warner, sin embargo el equipo concluy que el
mercado para consumidores electrnicos smart y las cajas Set-Up en
particular, no eran del todo eficaces. La subsidiaria Proyecto Verde fue
amortizada por la compaa Sun a mediados del 94.
Afortunadamente, el cese del Proyecto Verde coincidi con el nacimiento del

fenmeno mundial Web. Al examinar las dinmicas de Internet, lo realizado por
el ex equipo verde se adecuaba a este nuevo ambiente ya que cumpla con los
mismos requerimientos de las settop box OS que estaban diseadas con un
cdigo de plataforma independiente pero sin dejar de ser pequeas y
confiables. Patrick Naugthon procedi a la construccin del lenguaje de
programacin Java que se accionaba con un browser prototipo, ms tarde se le
fueron incorporando algunas mejoras y el browser Hot Java fue dado a conocer
al mundo en 1995. Con el paso del tiempo el Hot Java se convirti en un
concepto prctico dentro del leguaje Java y demostr que podra proporcionar
una forma segura multiplataforma para que el cdigo pueda ser bajado y
corrido del Host del World Wide Web y que de otra forma no son seguros.
Una de las caractersticas ms atractivas del Hot Java fue su soporte para los
"applets", que son las partes del cdigo Java que pueden ser cargadas
mediante una red de trabajo para despus ejecutarlo localmente y as lograr o
alcanzar soluciones dinmicas en computacin acordes al rpido crecimiento
del ambiente Web.
69
Para dedicarse al desarrollo de productos basados en la tecnologa Java, Sun

form la empresa Java Soft en enero de 1996, de esta forma de se dio
continuidad al fortalecimiento del programa del lenguaje Java y as trabajar con
terceras partes para crear aplicaciones, herramientas, sistemas de plataforma y
servicios para aumentar las capacidades del lenguaje.
Durante ese mismo mes, Java Soft dio a conocer el Java Developmet Kit (JDK)
1.0, una rudimentaria coleccin de componentes bsicos para ayudar a los
usuarios de software a construir aplicaciones de Java. Dicha coleccin inclua
el compilador Java, un visualizador de applets, un debugger prototipo y una
mquina virtual Java(JVM), necesaria para correr programas basados en Java,
tambin inclua paquetera bsica de grficos, sonido, animacin y trabajo en
red.
Asimismo el Netscape Comunications Inc, mostr las ventajas de Java y

rpidamente se asoci con Java Soft para explotar su nueva tecno loga. No
pas mucho tiempo antes de que Netscape Communications decidiera apoyar
a los Java applets en Netscape Navigator 2.0. Este fue el factor clave que lanz
a Java a ser reconocido y famoso, y que a su vez forz a otros vendedores
para apoyar el soporte de applets en Java. Como parte de su estrategia de
crecimiento mundial y para favorecer la promocin de su nueva tecnologa,
Java Soft otorg permisos a otras compaas para que pudieran tener acceso
al cdigo fuente de Java y al mismo tiempo mejorar sus navegadores, dicha
licencia tambin les permita crear herramientas de desarrollo para
programacin Java y los facultaba para acondicionar Mquinas Virtuales Java
(JVM), a varios sistemas operativos.
Muy pronto las licencias o permisos contemplaban a prestigiadas firmas como

IBM, Microsoft, Symantec, Silicon Graphics, Oracle, Toshiba y por supuesto
Novell. Desde su aparicin, Java se ha ganado una impresionante cantidad de
apoyo. Virtualmente cada vendedor importante de software ha obtenido
autorizacin de Java y ahora ha sido incorporado en los principales sistemas
operativos base de PCs de escritorio hasta estaciones de trabajo UNIX.
Un gran nmero de nuevas empresas ya estn preparadas para recibir a la Ola

Java o para ingresar a los Mercados de software basados en Java, en algunos
casos como "Marimbas
Castanet" se han concebido desde un principio con bases de tecnologa Java
para Internet y han sido autorizados bajo licencia de Netscape para poner al
corriente "netcast", un producto informativo para PCs de escritorio. Los nuevos
proyectos de Java son co-patrocinados por cientos de millones de dlares en
capital disponible de recursos tales como la Fundacin Java, un fondo comn
de capital formado el verano pasado por 11 compaas, incluyendo Cisco
Systems, IBM, Netscape y Oracle. Los Colegios y Universidades alrededor del
mundo estn adoptando Java como un lenguaje universal y de enseanza
indispensable, hoy en da existen ms de 150 libros en Java que se estn
imprimiendo en este momento.
70
En un reciente estudio se encontr que el 60% de los empresarios estn

usando Java y el
40% expresaron que Java representa la solucin estratgica que estaban
buscando para sus negocios..
Para darse una idea de la rpida aceptacin que tiene Java en el mundo,
tenemos el ejemplo de las conferencias "Java Soft Java One" en San
Francisco, el primer Java One fue celebrado en abril de 1996 y atrajo a 5000
usuarios, un ao despus, en la segunda conferencia Java One alberg a
10,000 usuarios, asistentes. Java Soft estima que el nmero actual de usuarios
Java llega a 400 mil y sigue creciendo. Java tambin est ganando aceptacin
en el rea empresarial, se ha estimado que actualmente las compaas de hoy
que cuentan con ms de 5000 empleados, una tercera parte estn usando
Java.
71

Javabasico PDF

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Javabasico PDF

Cargado por

Copyright:

Formatos disponibles

Manual del Curso Java Bsico Programa de Tecnologa en Cmputo

UNIVERSIDAD NACIONAL AUTNOMA DE MXICO

DIVISIN DE INGENIERA ELCTRICA

PROGRAMA DE TECNOLOGA EN CMPUTO

MANUAL DEL CURSO: JAVA BSICO

CAMACHO PREZ HUGO

1:Programacin Orientada a Objetos.

Los lenguajes de programacin son tcnicas que permiten expresar

Una de estas tcnicas es la programacin estructurada, en la cual se considera

Tales cambios surgieron cuando aumentaron las expectativas de lo que se

La Crisis del Software

La crisis del software es el hecho de que el software que se construye no

La parametrizacin: Se trato de ubicar en datos externos al programa el

La Modularizacin: Se comenz por la dcada de los 60s, con Pascal, al

El gran esfuerzo en la escritura de cdigo como consecuencia del poco anlisis

En el paradigma de objetos, no es necesario el concepto de programa, pues

La metodologa orientada a objetos

A medida que se acercaban los aos 80, la metodologa orientada a objetos

La metodologa orientada a objetos presenta caractersticas que lo hacen

La programacin orientada a objetos, intenta simular el mundo real a traves del

Como su mismo nombre indica, la programacin orientada a objetos se basa

En la metodologa orientada a objetos la esencia es el objeto. Un objeto en el

De estos 5 plumones podemos decir que pertenecen a la misma

Cuando un objeto A necesita que un objeto B ejecute alguno de sus mtodos lo

Un mtodo se implementa dentro la clase que defina al objeto. Un buen diseo

En donde se puede ver que loas datos (variables) y

La herencia es propiedad que permite a los objetos construirse a partir de otros

Hay diferentes tipos de herencia: los ms importantes son simples y mltiples.

La figura 1.3 muestra un ejemplo de herencia simple, la clase B y la clase C

Con la Herencia se obtienen mltiples beneficios, al heredar una clase de otra

El polimorfismo es otra caracterstica esencial de los lenguajes de POO. Un

referencia a ese objeto es polimorfita ya que puede referirse a objetos de

Por ejemplo, en nuestro diagrama de clases anterior:

Una referencia a objeto de la clase Empleado tambin puede ser una

Como mencionamos anteriormente en la POO para poder utilizar o crear un

2:La Tecnologa Java.

El lenguaje de programacin Java consiste en un lenguaje de programacin y

Java tiene la caracterstica de ser al mismo tiempo compilado e interpretado. El

Una plataforma es el ambiente de hardware o software en el cual se ejecutan

La plataforma Java difiere de las anteriores en que sta es una plataforma

La plataforma Java consta de dos componentes:

La Mquina Virtual de Java (JVM)

A continuacin se muestra una representacin de los elementos que forman

La figura anterior muestra un aspecto importante:

La Interfaz de Programacin de Aplicaciones (API) es el conjunto de paquetes

J2SE: Java Standard Edition. Se utiliza en la elaboracin de programas

Existen numerosos APIs, los cuales podemos mezclar en su mayora para

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

Aplicaciones: Las aplicaciones son programas standalone de propsito

Servlets: Los servlets al contrario de los applets son programas que

Compilacin y Ejecucin de Programas

La figura 2.3 muestra un esquema del proceso de construccin de una

Nuestro primer programa consiste en el tradicional hola mundo, escribirlo en un

public class HolaMundo

Para ejecutar nuestro programa tenemos que seguir algunas reglas:

Java sigue ciertas convenciones en la asignacin de nombres a clases,

Para nombrar clases se usa la letra en mayscula al inicio de cada

De esta forma, podemos identificar clases, variables y mtodos en el programa

Hasta este momento tenemos listo el cdigo fuente de nuestro programa en un

Para invocar al compilador abrir una ventana de comandos (inicio, ejecutar y

C:\> javac HolaMundo.java