Introduccin a Java

En cuanto sali Java fue acogido con gran entusiasmo por la comunidad mundial de los
diseadores de programas y de los proveedores de servicios internet. Esto porque Java
permita a los usuarios de Internet utilizar aplicaciones seguras e independientes de la
plataforma, y que se pueden encontrar en cualquier punto de la red.
Java naci pues como lenguaje para la red, para sostener el Hyper Text Markup Language
(HTML), que no es un lenguaje de programacin propiamente dicho, y para darle la seguridad
que el HTML no tiene. Desde que apareci Java en la red se ha empezado a hablar de
nmeros de tarjetas de crdito y de informaciones seguras, lo cual ha entusiasmado a las
mayores sociedades mundiales que han transformado la vieja Internet, prerrogativa de las
universidades y centros de investigacin, en el medio actual de comunicacin abierto a todos.
El lenguaje de programacin Java se cre a mediados de los noventa, es el ms reciente entre
sus semejantes, y por eso se encuentra en fase de evolucin, hasta el punto que todos los
aos sale una nueva versin.
Creado como lenguaje exclusivamente para la red se ha convertido en un autntico lenguaje de
programacin paragonable, desde el punto de vista de la funcionalidad, al famoso C++.
Java y la mayor parte de los otros lenguajes pueden compararse slo desde el punto de vista
funcional; y esto porque son fundamentalmente diferentes, ya que Java recopila las fuentes de
sus programas en un cdigo llamado Bytecode distinto del aparato en el que se ha compilado,
mientras que lenguajes como C++ recopilan las fuentes de los programas en un cdigo que es
a su vez cdigo del aparato (como aparato se entiende ordenador + sistema operativo) en el
que se ha realizado. Por lo tanto, para poner en marcha un programa Java es necesario contar
con un instrumento llamado Java Virtual Machine que interpreta el bytcode generado por el
recopilador Java y lo ejecuta en el aparato en el que se ha instalado. Gracias al Java Virtual,
Java es independiente de la plataforma, es decir, que el programa recopilado Java est unido a
la JVM y no al sistema operativo, por eso ser posible poner en marcha el mismo programa
Java, recopilado una sola vez en un aparato cualquiera con un recopilador Java versin X, en
una plataforma Windows y en una plataforma Linux, sin embargo para hacer eso se necesita
que Windows y Linux instalen un aparato Java Virtual que apoye la versin X de Java. Las dos
JVM, instaladas en las dos plataformas distintas, son el mismo programa recopilado una vez
por Windows y otra vez por Linux, como ocurra con los programas escritos en lenguajes como
el C/C++.
Un aparato Java Virtual est instalado tambin en los distintos Browser (como Netscape y
Explorer) para poder poner en marcha los programas Java que se encuentran en la red, los
apliques.
Pero esto, debido a que Java sigue evolucionando, provoca obvios problemas de
compatibilidad, siempre ocurre que el Browser ms moderno contiene una versin precedente
de Java con respecto a la ltima versin de la Sun Microsystem. Adems, hay que tener en
cuenta que no todos los usuarios de Internet navegan usando la ltima versin de Netscape o
de Explorer. Por eso, cuando queremos crear un aplique e insertarlo en un documento HTML,
hay que tener en cuenta estos problemas e intentar disear un programa que sea compatible
con la mayor parte de los JVM implementados en los distintos browser.
Otro problema al que hay que enfrentarse es el de la eleccin del recopilador Java a utilizar, ya
que existen varios ambientes integrados para editar, recopilar, depurar y ejecutar programas
Java, como los de la Broland, de la Microsoft, de la Symantec. Todos estos ambientes ofrecen
unas herramientas de desarrollo excelentes, como editores grficos de ventanas, depuradores
muy interesantes, pero presentan dos problemas, el primero que valen mucho dinero, el
segundo es el de la compatibilidad, ya que muy a menudo se encuentran tras la relase de la
Sun y, adems, aaden unas clases que los JVM en los browser no tienen.
Mi consejo es usar los JDK ( Java Development Kit ) de la Sun, que comprenden tanto el
compilador como el aparato Java Virtual Machine, para poner en marcha los programas que
recopilamos, adems son freeware (no cuestan nada) y se pueden bajar de la red y los browser
se ajustan a esta versin de Java.
Si queris escribir apliques para los viejos browser tenis que bajar la versin 1.1 de Java, pero
esta versin no os sirve mucho porque existe otra ms cotizada, es decir la 1.2.2 ( se llama, por
alguna razn que desconozco Java 2, se puede bajar en la direccin
http://java.sun.com/products/jdk/1.2/index.html ), a la que mencionar yo tambin en este curso
y por la que Netscape version 4.0x y Explorer 5 implementaron el Java Virtual Machine (casi
todo, yo tuve problemas con las Swing, que son libreras estndar de Java 2).
Si queris bajar Java 2 os aconsejo que lo hagis entre las nueve y las once de la maana
porque el sitio est muy a menudo colapsado, adems el documento que hay que bajar es de
unos veinte megas. Si queris podis bajar tambin la documentacin pues es muy til, sin
embargo, sta tambin pesa otros veinte megas.
Yo acabo de bajar e instalar la prxima versin, la Relase Candidate del Java 2 Software
Development Kit versin 1.3 Relase Candidate 1, y os aseguro que si la 1.2.2 era extraordinaria
sta es increble. He descubierto tambin que ha salido la Relase Candidate 2 del JDK 1.3 y
que a finales de Abril saldr por fin la relase (yo la espero, no tengo ganas de pasarme otra
noche en blanco para bajarme algo que ser sustituido por la relase dentro de menos de un
mes).
Para bajaros el producto tendris que registraros, hacedlo, la registracin es gratuita.
Un ltimo problema que tiene Java es la lentitud, ya que, como ya hemos sealado, el Java
tiene que ser interpretado, as las instrucciones Java antes de ser ejecutadas por el aparato
tienen que ser interpretadas por la JVM; es decir, que para ejecutar cada instruccin el
ordenador realizar un nmero de instrucciones que es el doble de las instrucciones que
realizara si la misma instruccin estuviera escrita en C. Por lo tanto, necesitaris ordenadores
rpidos para ejecutar cmodamente los programas Java, y de esto os habris percatado
seguramente navegando por la red. Tambin la memoria es importante, se compila y se ejecuta
tambin slo con 32MB de RAM, pero para hacer las cosas con rapidez son necesarios al
menos 64, tened en cuenta que el ltimo ambiente integrado de la Borland, el Jbuilder 3, tiene
como requisito mnimo de RAM 96 Megabyte.
Para acabar vuelvo al Java Development Kit de la Sun Microsystem, con ste es posible
producir todo el software que se quiera sin tener que pagar los derechos de uso del producto,
como sucede con el Borland Jbuilder, el Symantec Cafe, y el Microsoft Visual Java. Os
aconsejo que leais la licencia de uso que encontraris al bajar el JDK antes de empezar a
producir el software.
Llegados a este punto podemos empezar.
La programacin Java
La principal diferencia entre Java y los dems lenguajes de programacin por objetos es que
con estos ltimos es posible programar por objetos, mientras que con Java se tiene
absolutamente que programar por objetos. Por eso es necesario explicar qu quiere decir
programar por objetos. En concreto la programacin se desarrolla de la misma forma que los
lenguajes "normales", pero tanto los datos como las funciones que los trabajan se organizan en
estructuras llamadas clases.
Las clases son prototipos de objetos, es decir, son estructuras abstractas (no demasiado, como
veremos) que se pueden instalar y, por eso, crear un objeto (pero tambin ms de uno).
La clase define todas las propiedades de los objetos que pertenecen a aquella clase, llamadas
atributos, y las funciones que se usarn para actuar sobre ellos, llamados mtodos. Por
ejemplo es posible definir una clase de las personas como sigue:

Inicio clase personas
Atributo aodenacimiento
Mtodo calculaedad (aocorriente)
Fin clase personas

La clase de las personas establecida de esta forma tiene un atributo que es aodenacimiento,
que es seguramente un nmero entero, y un mtodo que, basndose en el ao corriente que le
pongamos, calcula la edad de la persona. Usando el formalismo de Java, para definir la clase
personas tendremos que escribir:

clase personas
{
public ent aodenacimiento;
public ent calcula edad ( ent aocorriente )
{
enva ( aocorriente - aodenacimiento );
}
}

Como acabamos de ver explicamos tanto el mtodo cuanto el atributo como public. Veremos
ahora lo que significa y veremos tambin la clase empieza por { y acaba por }, lo mismo pasa
con los mtodos. Esto nos recuerda mucho al C, y hay que decir que la sintaxis de Java es muy
similar, casi igual, a la de C, mientras que para los que no conocen el C, los corchetes
representan el empezar y el terminar del lenguaje pascal. La clase tendr un llamado
constructor (uno o ms) que es un mtodo peculiar que normalmente se utiliza para inicializar
los atributos cuando se establece la clase de un objeto. Es una funcin que no tiene ningn tipo
de return y tiene el mismo nombre que la clase. Decimos que puede haber ms de un
constructor, sin embargo, el nombre del constructor tiene que ser el mismo que el de la clase. A
los que estn acostumbrados a programar con lenguajes no orientados a los objetos, todo esto
les puede resultar algo raro, sin embargo es posible porque Java realiza el llamado overloading
de funciones, es decir funciones con el mismo nombre que tienen parmetros diferentes (en el
lenguaje informtico se llaman parmetros formales) son distintas, y a la hora de establecerlas
se elige la funcin basndose en el parmetro (llamado parmetro actual).
Esto vale para todos los mtodos, no slo para los constructores.

clase personas
{
public ent aodenacimiento;
public String Apellidos=new String();
// Constructores
public personas(ent aodenacimiento)
{
this("No s");
this.aodenacimiento=aodenacimiento;
}

public personas(String Apellidos)
{
this(0);
this.Apellidos=Apellidos;
}

public personas(ent aodenacimiento , String Apellidos)
{
aodenacimiento=aodenacimiento;
this.Apellidos=Apellidos;
}

// Funcin que calcula la edad del sujeto;
public int calculaedad ( ent aocorriente )
{
return ( aocorriente - aodenacimiento );
}
}


Las lneas que empiezan por // son comentarios, el ordenador los ignora, pero hay otros dos
tipos de comentarios, los que se ponen entre /* y / que permiten definir comentarios sobre ms
de una lnea. Se llaman comentarios de documentacin y se tienen que encontrar antes de la
declaracin de las clases, de los miembros de las clases (atributos o mtodos) o de los
constructores, y hay que inclurlos en la posible documentacin del cdigo que se genera
automticamente.

En el ejemplo vemos que hay tres constructores, distintos por parmetros formales, que tienen
el mismo nombre. Adems vemos un nuevo atributo que son los Apellidos, sa es una cadena,
que se define como public String Apellidos=new String(); la parte que est delante del signo
igual resulta clara, la parte que se encuentra a la derecha del mismo signo un poco menos, ese
new String() crea un nuevo objeto de la clase String y llama a su vez al constructor que no tiene
parmetros. Esto es el procedimiento tipo que usa Java para crear los objetos de una clase. No
hay que sorprenderse de que el tipo de dato cadena sea una clase, porque con Java es posible
usar objetos que representen todos los tipos de datos del lenguaje, insertadoos para completar
el lenguaje, y llamados confecciones que a veces resultan muy tiles. Si embargo, es posible
usar tambin los valores.
As, por ejemplo, trabajaremos tanto con enteros como con objetos que representan enteros.
Por ltimo, resulta bastante evidente en el ejemplo que los constructores tienen
voluntariamente unos parmetros que tienen a su vez el mismo nombre de los atributos. Esto
tambin es posible en Java y quiere decir que cuando hay un valor a la izquierda del signo
igual tiene que encontrase el atributo, y a la derecha el parmetro. De todos modos si no
queremos confundirnos podemos usar la referencia this; escribiendo, por ejemplo,
this.aodenacimiento, esto quiere decir atributo. This se refiere al objeto, y en el ejemplo
anterior lo encontramos tambin como llamada a la funcin this(0), en este caso se refiere a un
constructor del objeto y se llamar constructor personas (ent aodenacimiento), con el valor 0.
Es por tanto posible en un constructor llamar a un constructor distinto de la misma clase, con tal
que la llamada sea la primera instruccin del constructor y que el constructor sea diferente del
actual.
Llegados a este punto, estamos listos para crear objetos que pertenezcan a la clase que
acabamos de definir. Tenemos tres formas de hacerlo porque hemos creado tres constructores
que son:

personas Pietro=nuevas personas(1974);

o

personas Pietro=nuevas personas("Castellucci");

o

personas Pietro=nuevas personas(1974,"Castellucci");

ahora queremos crear otro objeto de la clase personas

personas Lina=nuevas personas(1975);

o

personas Lina=nuevas personas("Marucci");

o

personas Lina=nuevas personas(1975,"Marucci");

a este punto he creado dos objetos de la clase personas que tienen que ver con la llamada
clase inst_of, los objetos se llaman uno Pietro y el otro Lina. Tambin es posible copiar las
referencias de los objetos, por ejemplo es posible escribir:

personas Pietro2=Pietro;

Construidos los objetos puedo crear los mtodos, indicando Objeto.Mtodo. Por ejemplo es
posible crear los mtodos:

Pietro.calculaedad(2000);
Pietro2.calculaedad(2000);
Lina.calculaedad(2000);

Ahora introduzcamos unos atributos y unos mtodos particulares, los llamados miembros
estticos. Por como hemos definido los miembros de la clase, no nos resulta posible hacer una
referencia directa de la clase atributos y mtodos ( personas.aodenacimiento es un error), y
esto porque estos trabajan sobre una instancia de la clase, es decir sobre un objeto, pero a
veces puede ser til escribir mtodos y atributos que se puedan crear sin tener que llamar al
objeto, y que puedan ser llamados directamente desde la clase. Para hacer esto necesitamos
declararlos estticos, por ejemplo:

clase TtulosEmpresaEquis
{
public static int TipodeInters=3;
public String Propietario=new String();
public static float InteresesDevengados (int Perodo)
{
return((Perodo * TipodeInters )/100)
}
TtulosEmpresaExis(String nombre)
{
Propietario=nombre;
}
}

Entonces podremos decidir, por ejemplo, llamar a un objeto de la clase TtulosEmpresaExis
slo si nos conviene, por ejemplo haciendo:

if (TtulosEmpresaEquis.InteresesDevengados(12)>1000)
CompraAcciones(10000);

Donde CompraAcciones (int X) es una funcin que llama X TtulosEmpresaEquis.

Introduzcamos ahora la relacin is_a entre clases. Establecida una clase, es posible crear una
nueva clase partiendo de sta haciendo, como se dice en nuestra jerga, una especializacin de
la primera clase. La nueva clase que creamos est relacionada is_a con la primera. Creada una
clase estudiante de la clase (llamada superclase) personas, la nueva clase hereda de la
primera todos los mtodos y los atributos, con la posibilidad de definir unos atributos y unos
mtodos nuevos o de volver a definir otros. En Java, la estensin de una clase se manifiesta
con la palabra clave extends.

clase estudiante extends personas
{
ent inscripcin;
// Constructores
public estudiante(ent aodenacimiento)
{
super(aodenacimiento,"No Conocido");
}

public estudiante (String Apellidos)
{
super(0,Apellidos);
}

public estudiante(int aodenacimiento , String Apellidos)
{
super(aodenacimiento,Apellidos);
}

}

Como vemos en el ejemplo, la clase estudiante hereda todos los mtodos y los atributos de la
clase personas, define un nuevo atributo inscripcin, y en sus constructores llama a los
constructores de la clase personas con el nombre de super.().
Super() puede ser, como this(), una llamada de otro constructor (entre parntesis van los
parmetros posibles) o una referencia a la clase (a la superclase en este caso). Entonces,
super.aodenacimiento representa el atributo aodenacimiento de la superclase personas. Las
relaciones is_a y inst_of son las dos relaciones ms importantes de los modelos por objetos.
Ahora, en conclusin, ponemos un ejemplo que comentaremos a continuacin para explicar el
significado del public que introducimos anteriormente, y del private y protected (los atributos y
los mtodos pueden llamarse public, private y protected).

clase A
{
public int a;
private int b;
protected int c;
// Sus mtodos, atributos y constructores
}

clase B extends A
{
public float a;
private float b;
protected float c;
// Sus mtodos, atributos y constructores
}

clase C
{
// Sus mtodos, atributos y constructores
}

Hemos definido tres clases, A,B y C, B se define partiendo de A volviendo a definir los tres
atributos, de enteros a reales.
En A, en sus constructores y en sus mtodos, tenemos aceso a los mismos atributos de tipo
entero, sin limitaciones, es decir, podemos escribirlos y leerlos a nuestro antojo.
En B y C pasa lo mismo con los propios atributos, pero vamos a ver lo que sucede para los de
las dems clases.
Por ejemplo, en B (en uno de sus mtodos) si escribimos expresiones con a,b y c, escribiremos
unas expresiones pera unos float (en Java es muy importante el tipo de las expresiones). Sin
embargo, para referirnos a los atributos homnimos de A de la que se ha heredado, tenemos
que escribir, como sabemos, super.a, super.b y super.c (que son unos enteros).
Nuestro compilador Java no dar problemas para las primeras dos, pero nos dar error para el
tercero. Esto porque el c de A est protegido (protected) que quiere decir que es posible leer y
escribir aquel atributo slo internamente a la calse a la que pertenece, pero no es posible leerlo
y escribirlo de clases ajenas o de subclases.
Llegados a este punto metmonos en un mtodo de C, establezcamos un objeto de la clase B
(lo llamamos b) y escribamos las expresiones b.a, b.b y b.c. Nuestro simptico compilador nos
dar slo la primera porque la tercera est protegida y, por eso, slo es visible en la clase a la
que pertenece. La segunda es privada (private) y esto significa que es visible slo para la clase
a la que pertenece y para sus subclases, y C no es una subclase de B.
Anteriormente hicimos una trampa, es decir, hablamos de atributos de clases y de objetos
como si fueran la misma cosa, pero realmente lo son. Slo hay una pequea diferencia. Si
entramos en un atributo de una clase ( NOBRECLASE.NOMBREATRIBUTO ) este ser
seguramente esttico, y podemos entrar slo para leer, es prcticamente una constante.
Cuando estabezcamos la clase en un objeto (NOMBRECLASE NOMBREOBJETO= new
NOMBRECLASE (parmetros); ), entrando en el mismo atributo del objeto (
NOMBREOBJETO.NOMBREATRIBUTO ) entramos en el mismo valor de antes y no podemos
modificarlo (es static). En cambio, si intentamos entrar en un atributo no esttico de una clase,
tendremos un error. Realmente este atributo se crear en el mismo momento de la creacin del
objeto de la clase, y la mayora de las veces ser inicializado por el constructor del objeto.
Espero haber tratado el argumento con claridad, pero hay que decir que los modelos por
objetos son bastantes complicados y es imposible explicarlos en detalle en un solo prrafo, se
necesitara un entero curso. Obviamente lo que acabamos de decir no es todo sobre los
modelos por objetos. Simplemente introducimos unos conceptos que nos valdrn para hacer
nuestros programas en Java. Los puntos importantes que hemos olvidado tratar en este
apartado, sern introducidos ms adelante cuando se presente la ocasin.
Al lector que quiera profundizar el argumento no le puedo aconsejar ningn libro en concreto
porque hay varios sobre este tema y todos son buenos. Sin embargo, si os conformis con una
introduccin al tema, podis mirar los captulos iniciales de cada buen manual de programacin
para principiantes de Lenguajes por objetos (C++ o Java), como, por ejemplo, Java: Didctica y
Programacin de K.Arnold e J.Gosling (Ed. Addison-Wesley) Captulos 2,3 y 4.
Os pido sobre todo que sea un manual para principiantes porque en los libros de programacin
avanzada el tema se da por descontado.
Qu son los paquetes informticos de
Java
Los paquetes informticos son colecciones de clases, contenidas en una coleccin que las une.
Prcticamente son bibliotecas a las que el usuario puede acceder y que ofrecen varias
funciones.
Los usuarios pueden tambin crear paquetes informticos, por ejemplo, haciendo que
contengan todas las clases que ha definido para poner en marcha algunas funciones que luego
usar en varios programas. Sin embargo, esto no nos interesa porque lo que queremos es ver
los paquetes informticos ms interesantes en Java.
Esta es la autntica potencia de Java, el nmero de clases ya establecidas que realizan las
ms variadas tareas, y es tambin la parte que sigue creciendo ms y ms, y que sigue
poniendose al da con las nuevas versiones de Java (JDK 1.3 bien contiene 18Mb). Los
paquetes informticos de Java son tantos que slo describir algunos por encima en un
captulo entero (el captulo 3) del curso. Veremos de forma detallada ms o menos dos, es
decir, los que nos sirven para definir interfaces grficas y apliques. Obviamente todos los
paquetes informticos del lenguaje estn descritos en la mastodntica gua en lnea del JDK
que se puede bajar junto al paquete del compilador (La JDK Documentation 1.3 beta es de 105
Megabyte, comprimida es de unos treinta Megas). sta tambien es gratuita y, si os apetece
pasar un par de horas bajndola, os aconsejo que la cojis junto al compilador. De todas
formas est a vuestra disposicin en lnea (tenis el enlace en la pgina www.javasoft.com o
www.java.sun.com , es prcticamente igual, son primos hermanos).
El ncleo del lenguaje Java contiene slo las palabras claves para la construccin de las
clases, los comentarios, las construcciones normales en if, switch, while, do-while, for,
etiquetas, break, continue e return (falta el goto), que veremos en detalle en el prximo
captulo. Todo lo dems est contenidos en los paquetes informticos del lenguaje, incluidas
las normales primitivas de Entrada y de Salida. En este prrafo veremos la lista de los paquetes
informticos de Java y veremos uno en particular, el que nos interesa para escribir nuestra
primera aplicacin Java an antes de haber visto las construcciones, es decir, en las que
podemos encontrar las instrucciones de entrada y salida.

La lista completa de los paquetes informticos de Java 1.2.1 en orden alfabtico es el
siguiente:

com.sun.image.codec.jpeg, com.sun.java.swing.plaf.windows,com.sun.java.swing.plaf.motif,
java.applet, java.awt, java.awt.color, java.awt.datatransfer, java.awt.dnd, java.awt.event,
java.awt.font, java.awt.geom, java.awt.im, java.awt.image, java.awt.image.renderable,
java.awt.print, java.beans, java.beans.beancontext, java.io, java.lang, java.lang.ref,
java.lang.reflect, java.math, java.net, java.rmi, java.rmi.activation, java.rmi.dgc, java.rmi.registry,
java.rmi.server, java.security, java.security.acl, java.security.cert, java.security.interfaces,
java.security.spec, java.sql, java.text, java.util, java.util.jar, java.util.zip, javax.accessibility,
javax.swing, javax.swing.border, javax.swing.colorchooser, javax.swing.event,
javax.swing.filechooser, javax.swing.plaf, javax.swing.plaf.basic, javax.swing.plaf.metal,
javax.swing.plaf.multi, javax.swing.table, javax.swing.text, javax.swing.text.html,
javax.swing.text.html.parser, javax.swing.text.rtf, javax.swing.tree, javax.swing.undo,
org.omg.CORBA, org.omg.CORBA.DynAnyPackage, org.omg.CORBA.ORBPackage,
org.omg.CORBA.portable, org.omg.CORBA.TypeCodePackage, org.omg.CosNaming,
org.omg.CosNaming.NamingContextPackage, sun.tools.ttydebug, sunw.io, sunw.util.

Realmente parecen pocos, parece que haya dicho una tontera cuando me refera a la potencia
de Java, sin embargo si pensis que slo el paquete informtico Java.io comprende 50 clases y
10 interfaces, comprenderis que los de antes son una coleccin de clases consistente.
Llegados a este punto nos gustara hacer la entrada y la salida de consolle y para hacerlo
debemos usar el paquete informtico java.lang .
para usar un paquete informtico en una de nuestras clases, antes de definir la clase, tenemos
que introducir la instruccin import. Por ejemplo, si queremos usar el paquete informtico
java.awt tenemos que introducir al comienzo de nuestro archivo:

import java.awt.*;

El * indica que queremos usar todas las clases, en cambio si queremos usar slo una clase lo
podemos especificar, por ejemplo, import java.awt.Frame; podremos usar la clase Frame del
awt. En nuestro caso, en el que queremos hacer una operacin de entrada, tendremos que
declarar al empezar import java.lang.*;
o, sabiendo que la clase del paquete informtico java.lang que contiene los mtodos para
hacerlo es System, podremos escribir

import java.lang.System;

La clase System, a su vez, contendr en su interior una import java.io (que es el paquete
informtico para la entrada y la salida) para acceder a las clases de la entrada y de la salida, y
las usar para mandar lo que queramos en la pantalla.
Vimos un ejemplo de paquete informtico que en su interior llama a otro paquete informtico
para que lleve a cabo unas tareas. En estas bibliotecas Java ocurre eso a menudo y es
precisamente este fenmeno que hace de Java un lenguaje incomprensible para la mayora.
Sin embargo, superado este inconveniente que se refiere a este aspecto del lenguaje, la
programacin se hace fcil e inmediata.
He introducido el paquete informtico java.lang. Ahora os digo tambin que este es el ms
importante de Java, en ste estn contenidos las clases fundamentales del lenguaje, hasta el
punto de que no hace falta declarara el import, porque Java lo introduce automticamente.
Adems me gustara detenerme en un aspecto fundamental de la introduccin de los paquetes
informticos. Si importo en mi archivo el paquete informtico java.lang, ste importar a su vez
el paquete informtico java.io, y yo desde mi archivo no podr usar las clases de java.io; para
hacerlo tengo que importarlo explcitamente. Esto sucede aunque programe una aplicacin en
ms de un archivo (con ms clases), en cada archivo tengo que importar los paquetes
informticos que necesito para la clase que estoy estableciendo, no basta con importarlos en
una sola. Veamos pues las clases que contiene este paquete informtico java.lang tan
importante para el lenguaje:

Boolean
hemos dicho que los tipos de datos se pueden representar tambin con objetos dichos;

contenedores
es una clase que genera los contenedores para los tipos de datos boolean (verdadero, falso).

Byte
es la clase que genera los contenedores para los tipos de datos enteros cortos (de un byte).

Character
es una clase que genera los contenedores para los tipos de datos caracteres.

Character.Subset
es la clase que genera los contenedores para los tipos de datos caracteres con codificacin
unicode.

Character.UnicodeBlock
es la clase que genera los contenedores para los tipos de caracteres con codificacin unicode
2.0.

Class
representa las clases y las interfaces a runtime (en ejecucin), en Java es posible, en tiempo
de ejecucin, crear, ejecutar y compilar clases. El compilador y el ejecutor se mezclan de una
forma rara, sin embargo a nosostros no nos sirven estas clases "especiales" porque
escribiremos unas aplicaciones fciles.

ClassLoader
cargador de clases a tiempo de ejecucin.

Compiler
compilador de clases a tiempo de ejecucin.

Double
es la clase que genera los contenedores para los tipos de datos reales en coma mvil de 64 bit.

Float
es la clase que genera los contenedores para los tipos de datos reales de 32 bit en coma mvil.

Integer
es la clase que genera los contenedores para los tipos de datos enteros.

Long
es la clase que genera los contenedores para los tipos de datos enteros dobles.

Math
contiene mtodos que simulan funciones matemticas.

Number
clase de objetos contenedores de nmeros genricos.

Object
es la clase de la que derivan todas las clases del lenguaje Java, es decir, cada clase es
subclase (no necesariamente directa) de sta.

Package
contiene mtodos para extrapolar informaciones en los paquetes informticos de Java.

Process
Java es un lenguaje que permite gestionar Thread, es decir pequeos programas que corren
en paralelo. Esta clase se ocupa de ellos, como las dems clases de java.lang: Runtime,
RuntimePermission, Thread, ThreadGroup, ThreadLocal, Throwable

SecurityManager
para la seguridad

Short
es la clase que genera los contenedores para los tipos de datos enteros cortos.

String
es la clase que genera los contenedores para los tipos de datos cadenas de caracteres.

StringBuffer
es la clase que genera los contenedores para los tipos de datos cadenas de caracteres
modificables.

System
es la clase que interacta con el sistema y contiene muchos mtodos tiles, y unas referencias
a otras clases (llamadas class field), es la que usaremos, por ejemplo, para crear una salida
sobre la pantalla a caracteres.

Void
es la clase que genera los contenedores para los tipos de datos void, es decir, sin tipo. ste
parece un tipo de dato intil, sin embargo veremos que no lo es en absoluto, adems es
utilsimo. En realidad, es til cuando queremos definir un mtodo-procedimiento (un mtodo
que no tiene valor de vuelta), en Java existen slo dos funciones que obligan a devolver un
valor del tipo que declaran. Declarando un mtodo como void, se simula el procedimiento, es
decir, no se necesita la vuelta.
Escritura de apliques "a consola"
Me doy cuenta de que toda la parte descriptiva hasta ahora pudo resultar un poco aburrida y
estoy de acuerdo con vosotros pero, estoy seguro de que me vis a disculpar porque los
conceptos introducidos son FUNDAMENTALES para el apartado menos aburrido que est a
punto de empezar, es decir, la programacin.
Sin embargo, antes de empezar tengo que decir una ltima cosa: con los actuales lenguajes de
programacin es posible hacer dos tipos de programas, excluidas las bibliotecas dinmicas
(.DLL) o estticas (.LIB) y varias, es decir, las aplicaciones a consola y las aplicaciones a
ventanas. Las primeras son las ms simples de construir porque no tienen grfica y no tienen
interfaz de caracteres: son las que se parecen a las viejas aplicaciones DOS, o javac.exe
mismo ( el compilador Java ). Las segundas son las Windows o X-Windows, con todos los
botones, mens, etc., ms complicadas de hacer, pero extremadamente ms agradabledes de
ver. Con Java es posible hacer, adems de stas dos, una tercera aplicacin, la que trabaja en
Red, es decir el aplique. Al principio Java naci slo como un lenguaje para la Red, pero
sucesivamente se vi que era un lenguaje completo con el que era fcil escribir tambin
aplicaciones a consola y a ventanas. Yo tambin estoy preparando mi tesis de licenciatura en
informtica usando Java y es una aplicacin a ventanas. Las primeras aplicaciones que vamos
a ver son, por cierto, las ms simples, aunque las menos sorprendentes, es decir, las
aplicaciones a consola.
Una aplicacin puede estar compuesta por una o ms clases, todas incluidas en homnimos
archivos, simplemente por una cuestin de simplicidad de bsqueda, aunque es posible definir
ms de una en un archivo y llamar los archivos con nombres distintos de las clases que se
encuentran en ellos. Pero, si escribimos una aplicacin a consola o una a ventanas, hay una
clase especial que un archivo del mismo nombre tiene que contener. Esta clase que llamar,
por ejemplo, hola tendr un mtodo, que se llama main, que representa el punto de entrada
del programa, es decir, es el punto desde el que se iniciar la ejecucin del programa.
Cuando un programa en Java se redacta, dar uno o ms archivos .class, entre ellos, en
nuestro caso, estar tambin nuestro hola.class. Para poner en marcha el programa tendremos
que teclear:

java hola [ENVO]

Hay que notar que los viables Java no son .EXE, sino .class, esto porque para que se pongan
en marcha necesitan la ya citada Java Virtual Machine que es, precisamente, el programa
java.exe. Pongamos un ejemplo:

class hola
{
public static void main(String[] args)
{
// Comentario, este programa no hace nada.
}
}

Vemos que main se declara static void, static porque se acude a l al principio de la JVM, antes
de que hola se ponga automticamente en un objeto, void porque no devuelve nada. Esta
clase la escribir en un archivo que llamamos hola.java y la redactar escribiendo javac
ciao.java NB: Es absolutamente obligatorio llamar a los archivos fuentes de Java con la
extensin .java, sino el compilador no los reconoce. Adems si cre hola.java TENGO que
teclear javac hola.java y no javac hola para compilarlo.
Como parmetro el mtodo main tiene una cadena que se llama args que representa los
parmetros con los que se pone en marcha el programa, por ejemplo, si escribo, despus de
redactarlo, hola en hola.class

java hola Pietro Castellucci
args[0] ser igual a Pietro
args[1] ser igual a Castellucci

Esto cuando se pone en marcha. Hay que notar tambin que la JVM java.exe pone en marcha
hola.class especificando simplemente java ciao. A diferencia del compilador javac.exe, si
tecleamos java hola.class nos da error, si queris podis intentarlo.
Nuestro primer programa en Java
Lo que estamos a punto de hacer, no es realmente nuestro primer programa en Java: algunos
los hicimos precedentemente y ste es el primer programa que Java puede trabajar.
Vamos a usar lo que vimos en el precedente prrafo para crear una aplicacin a consola y las
del prrafo anterior para escribir algo en la pantalla.
Empezamos por editar un archivo que llamaremos HolaMundo.java: cuidado con las
maysculas y las minsculas porque en Java son muy importantes, no slo para el programa,
sino tambin para los archivos. Adems espero que tengis un editor que apoye Java porque,
si editis con el edit de DOS, no tendris ninguna ayuda a la hora de escribir los programas. En
cambio, con el editor especializado tendris las indentificaciones hechas ad hoc, distintos
colores para las palabras claves, para los comentarios, etc.
Podis bajar gratuittamente unos editores creados precisamente para Java o adaptados a Java
en red. Podis buscar en el sitio http://omega.di.unipi.it de la facultad de Informtica de Pisa, en
Resources - ftp, o en los varios sitios de la tucows ( www.tucows.com ), en el que encontraris
el bluette (una versin demo) que tiene un buen editor. Simplemente os recomiendo que
tengis cuidado porque en ste caso el bluette es un compilador Java, pero no s si es
totalmente compatible con el Java de la SDK que estoy tratando yo. En nuestro archivo
HolaMundo.java escribiremos:

class HolaMundo
{

public static void main(String[] args)
{

System.out.print ("Hola mundo, soy el primer programa en Java");

System.out.println ("di "+args[0]+" "+args[1]);

}

}

Redactamos el programa escribiendo, como siempre, java HolaMundo.java y ahora podemos
ponerlo en marcha. Escribiremos:

java HolaMundo TUNOMBRE TUSAPELLIDOS

y veremos una salida parecida a sta:

Hola mundo, soy el primer programa en Java de TUNOMBRE TUS APELLIDOS

Si no ponemos el nombre y los apellidos, el programa dar una excepcin, que es parecido a
un error a runtime, debido a que en el main se citan arg[0] y arg[1] que no aparecen. estas
excepciones s son errores a runtime, pero se pueden prever y gestionar precisamente porque
Java es un lenguaje "seguro" y, ms que interrumpirse y dar el normal RUNTIME ERROR que
dan los dems lenguajes, da una excepcin que, si prevista por el programador, no interrumpe
el programa. En el siguiente captulo veremos como gestionar posibles excepciones y, tambin,
como utilizarlas para nuestros fines. Pensemos, por ejemplo, en un programa que lee de los
archivos y que no encuentra este archivo: Java dar su excepcin, nosotros la leemos y
haremos que lea otro archivo. La versin sin riesgos de excepciones y ms espectacular es la
siguiente:

class HolaMundo2
{

public static void main(String[] args)

{

System.out.println ("*************************************************");
System.out.println ("** Hola mundo, soy el primer programa en Java **");
System.out.println ("*************************************************");
System.out.println (" |||||");
System.out.println ("0/ x x \\0");
System.out.println (" | o |");
System.out.println (" |\\___/|");
System.out.println (" |_____|");

}
}

Llegados a este punto, slo me queda felicitaros: acabis de escribir vuestro primer programa
en Java. Si os parece poco, no os procupis: a partir del capttulo sucesivo veremos las
construcciones y entonces nos desahogaremos escribiendo todos los programas que
queramos.
Tipos primitivos de Java y valores
Llamamos tipos primitivos de un lenguaje cuando hablamos de tipos de datos ya definidos en el
lenguaje y de los que se puede partir para la construccin de expresiones o tipos de
compuestos.
Los tipos son muy importantes en todos estos lenguajes de programacin y son fundamentales
en Java que es un lenguaje que se basa mucho en los tipos. El concepto de tipo es muy
natural: si veo un nmero, por ejemplo, 15.4 puedo decir en seguida el conjunto de nmeros al
que pertenece, en este caso al conjunto de los nmeros reales.
Si veo una operacin 4 / 5 puedo decir:

4 es de entero entero 5 es de tipo entero y / es una funcin de dos enteros y que me devuelve
un nmero real. Se escribe as:

/ : ent x ent float

Entonces, puedo decir que toda la expresin 4/5 es de tipo entero.

Lo que acabamos de hacer es, ms o menos, una inferencia de tipos que es una prctica muy
utilizada en informtica. Para explicarla toda se necesitara, como con los modelos por objetos,
un curso entero.
Los problemas no surgen con estas expresiones, que se llaman cerradas, que no tienen
variables, sino con las que tienen variables. Cada lenguaje emplea una tcnica suya: algunas
usan los tipos para las expresiones, otras establecen el tipo partiendo del contexto de la
expresin y da un tipo en secuencia incluso por cada una de las expresiones, y los que, como
Java, obligan a declarar todos los tipos de todas las variables desde el principio. Los tipos
primitivos de Java son los mismos de los dems lenguajes de programacin, slo que difieren
un poco en los valores y son.

boolean
es decir, valores que pueden ser verdaderos o falsos

char los caracteres son de 16 bit y estn codificados en Unicode 1.1.5; en los dems lenguajes
son ASCII solamente de 8 bit.

byte
enteros de 8 bit con signo, es decir, nmero entre menos (dos a la sptima) y dos a la octava.

short
enteros de 16 bit con signo.

int
enteros de 32 bit con signo.

long
enteros de 64 bit con signo.

float
reales de 32 bit con coma mvil (IEEE 754-1985).

double
reales de 32 bit con coma mvil (IEEE 754-1985).

Obviamente, a partir de stos es posible definir nuevos tipos de datos que se llaman
compuestos. Por ejemplo, una cadena es un vector de caracteres y es un tipo compuesto.
Como vimos el la leccin precedente, en el paquete java.lang estn los contenedores para
estos tipos de base, es decir, que si escribo ent, me refiero a un nmero entero, mientras que si
escribo Enteger me refiero a las clases enteros.

Si uso las clases, tendr tambin una serie de atributos y mtodos tiles para trabajar con ellos.
Por ejemplo, en alguans se definen las constantes MIN_VALUE y MAX_VALUE (Mnimo y
mximo valor), en las clases Float y Double encontraremos las constantes
NEGATIVE_INFINITY y POSITIVE_INFINITY, NaN para indicar un valor que no es vlido y el
mtodo isNan() para controlar si un valor es vlido. Por ejemplo, se puede utilizar despus de
una divisin para controlar que no se haya hecho una divisin por cero que resultara
catastrfica. Todo esto no existe en los dems lenguajes de programacin.
Ahora vamos a ver los literales de cada tipo de Java, es decir los valores constantes que cada
tipo puede tener.

El nico literal para referirnos a los objetos es null, se puede utilizar cada vez que nos
esperamos una referencia a un objeto, null es un objeto que no se ha creado y no es vlido: no
es de ningn tipo.

Los literales booleani son verdaderos y falsos e indican, respectivamente, el valor cero y el
valor falso.

Los literales enteros son cadenas de cifras octales, decimales o exadecimales. El inicio de la
constante sirve para escribir la base del nmero: un cero inicial indica base ocho, 0x o 0X
indica base 16 y nada indica los decimales. Por ejemplo, el nmero 15 en base diez puede
representarse como:

15 como decimal
017 como octal
0xf o 0XF como esadecimal.

Las constantes enteras que terminan por l o L se consideran long. Es mejor que terminen por L
porque l se confunde fcilmente con la unidad (no se equivoca el compilador, pero s nosostros
que leemos los programas) y si no acaban por una letra se consideran como ent. Si un leteral
ent se escribe como un short o como un byte, ste se porta como si lo fuera.

Los literales con coma mvil se escriben como nmeros decimales, con un punto opcional
seguido, posiblemente, por un exponente que empieza por e, segn la prctica corriente para
indicar mantisa-exponente. El nmero puede llevar detrs una f (F) o una d (D) para indicar que
es, con precisin, simple o doble, para default es doble.

35, 35. , 3.5y1, .35y2 representan el mismo nmero.

El cero puede ser positivo o negativo, si los comparamos obtenemos la equivalencia. Sin
embargo, es til en los clculos, pensemos en 1d/0d y 1d/-0d.
No es posible conceder una constante doble a una float aunque est en la serie. Si queremos
hacer esta operacin, hay que hacer un cambio que se llama casting que analizaremos a
continuacin.

Los caracteres se ponen entre comilla como, por ejemplo, '2', y los caracteres especiales estn
representados por unas secuencias, llamadas secuencias de escape. Son:

\n newline, a parte

\t tab

\b backspace, borra a la izquierda

\r return, representa el carcter especial ENVIO

\f form feed

\\ es el carcter backslash

\' comilla

\" comillas

\ddd es un char que emplea el valor octal (d son cifras octales, por ejemplo \329, tienen que ser
de tres o menos cifras y menores de \377), se puede dar tambin la representacin exadecimal,
siempre de cuatro cifras. Aqu ponemos en orden los caracteres citados antes con su nmero
exadecimal: \u000A, \u0009, \u0008, \u000D, \u000C, \u005C, \u0027 y \u0022.

Las cadenas se escriben entre comillas, como por ejemplo "Pietro" y todas las secuencias de
escape vlidas se pueden introducir en una larga cadena, creando cosas interesantes como,
por ejemplo:

System.out.println("\tNombre:\tPietro\n\tApellido:\tCastellucci" );

dar este resultado:

Nombre: Pietro
Apellido: Castellucci







Variables
Las variables son valores modificables, es decir, son nombres que representan un valor de
cierto tipo y el valor asociado al nombre se puede variar. Por ejemplo, si digo que X es una
variable de tipo entero y despus digo que tiene valor 10, escribiendo la expresin 5 + X es
como si escribiera la expresin 5 + 10. De todas formas creo que todos vosotros tenis
familiaridad con las variables porque son lo principal de cada lenguaje de programacin. Dicho
esto, vamos a ver como Java trata las variables.
En primer lugar, antes de utilizarla, una variable se tiene que escribir. En Java la escritura de
una variable est compuesta por tres partes: modificadores, tipo e indentificadores.

Los modificadores son una opcin y son los que establecen el acceso a las variables, es decir,
a los public particulares y protegidos que vimos en el captulo anterior. stos se llaman
modificadores de acceso y los hay estticos, sincronizados y finales. No es importante ponerlos
en rden, aunque s es importante utilizar siempre el mismo rden para que sea legible el
cdigo. Esttic tambin lo vimos: nos permite escribir atributos y mtodos constantes que se
pueden invocar incluso antes de que un objeto se escriba. Final, en cambio, quiere decir que,
cuando se utiliza un valor, ste se puede unir slo una vez a un campo porque es tambin una
constante. El modificador sincronizado lo dejaremos de lado: basta con indicar que sirve para
decir que a un mtodo, en el caso de una multiprogramacin (con los thread), se puede
acceder a travs de una exclusin mltiple, es decir, un thread a la vez.

Los identificadores pueden ser uno o ms, estn separados por una coma y son nombres que
tienen variables. Por ejemplo, la escritura de X en el ejemplo anterior se convertir en:

ent X;

pero, tambin puedo escribir ms de uno. Por ejemplo, la siguiente escritura se considera
vlida:

ent X,Y,Z;
doble W=3.12;

Como son atributos de las clases tienen que escribirse dentro de los mismos; escribirlos fuera
de ellos se considera un error.
Como se puede ver en el ejemplo, tambin es posible inicializar una variable en el momento en
el que la creamos: smplemente hay que aadir, despus del nombre, el signo igual y el valor
que toma.
Despus de la escritura de la variable y su inicializacin, el identificador de la variable, en
cualquier lugar que se haya escrito, se entiende como su valor actual, excepto si le damos un
nuevo valor. Por ejemplo, si escribo X = 10 me refiero a la variable X y no a su valor, y con el
signo igual 10 me refiero a que el nuevo valor de la variable es 10.
Si despus escribo:

X = X+1;

con la X a la izquierda del signo igual me refiero a que la variable se llama X, mientras que con
la X a la derecha me refiero al valor actual de la variable X. La expresin X+1, entonces, en
este caso ser

10 + 1 y entonces 11, es decir por X = X + 1, he dicho X = 11;

Provad este pequeo programa que hace unos calculos:

class p
{
ent X,Y,Z;

double W = 3.12;

public double A = 15;

static int B = 101;

private final int C = 2;

protected static boolean D = true;

public p()

{

X= 10 ;

Y= X ;

Z= X + Y ;

System.out.println ("Al\'principio tengo: X="+X+", Y="+Y+", Z="+Z);

X= X + 1 ;

Y= Z - X;

System.out.println ("Hago las operaciones: \nX= X + 1 ;\nY= Z - X;\ned resultado:");

System.out.println ("X="+X+", Y="+Y+", Z="+Z);

}

}

class decl

{

public static void main(String[] a)

{
p Prueba=new p();

}
}

Como sabis, visto que decl es la clase que incluye el main, tendris que editar el programa en
un archivo que se llama decl.java; despus, ponedlo en marcha y a ver lo que ocurre. Hay
tambin otros atributos para mostrar el uso de los modificadores.
En el ejemplo vemos que yo cre una clase p y le puse el objeto Prueba, llamando al
constructor. Hice esto porque las variables son atributos y, por eso, si no son estticos, son
atributos de un objeto. Tuve que crear un objeto para poder trabajar con sus variables. Hay que
acostumbrarse a programar desde esta perspectiva porque los programas Java son todos as.
Como el main del programa TIENE que declararse static (y tiene que tener una cadena como
parmetro), ste se pone en marcha en ausencia del objeto y, por eso, algunas variables no
son estticas. Si hubiera querido crear solo una clase, hubiese tenido que escribir algo
parecido a:

class decl2
{
int X,Y,Z;

// Main
public static void main(String [] a)
{

decl2 Prueba=new decl2();

}

// Constructor

public decl2()
{

X= 10 ;

Y= X ;

Z= X + Y ;

System.out.println ("Al\'inicio tengo: X="+X+", Y="+Y+", Z="+Z);

X= X + 1 ;

Y= Z - X;

System.out.println ("Hago las operaciones: \nX= X + 1 ;\nY= Z - X;\ned resultado:");

System.out.println ("X="+X+", Y="+Y+", Z="+Z);

}

}

En este segundo ejemplo, editado y redactado en decl2.java, no se entiende bien cundo
vemos decl2 como clase y cundo como objeto. Realmente el main est en la clase y en l se
crea el objeto. Por tanto se invoca el constructor y dentro de l razonamos en trminos de
objeto creado. De todas formas, es posible y veris que el programa funciona tambin en este
caso. Algn da, cuando tengis ms familiaridad con el lenguaje, podris hacerlo vosostros
tambin. De momento no os lo aconsejo porque es fundamental, llegados a este punto,
distinguir bien entre clases y objeto, y esto se consigue fcilmente con mucha experiencia.

Los identificadores Java tienen que empezar por una letra (o con _ o $) seguida por una
secuencia larga de caracteres y cifras elegidas a vuestro antojo. Las cifras, codificadas en
Unicode, son mucho ms numerosas que las letras y que las cifras ASCII utilizadas por otros
lenguajes. Lo siento, pero no tengo un mapa completo de los caracteres unicode que dejaros,
pero puedo deciros que estn incluidos los caracteres griegos, cirlicos, rabes, etc.

Ahora vamos a ver cmo escribir e inicializar un array. La escritura se hace ponindo un par de
corchetes despus del tipo:

ent [] vectorDeEnteros;

Los array en Java son casi objetos, slo que no pueden extenderse para aadirles nuevos
mtodos. Lo que acabamos de citar es una referencia a un array que, sin embargo, rl lenguaje
no ha asignado. Si quiero inicializar el array elemento por elemento, como se hace con los
dems lenguajes, tengo que escribir las dimensiones:

ent [] vectorDeEnteros = nuevo ent[100];

A partir de ahora puedo empezar a poner los elementos en el vector, en las posiciones de 0 a
99. Si salgo de estos nmeros, el aparato nos dar unmensaje de excepcin del tipo out of
range.
Cuando creo, puedo adems inicializar un array, basta con escribir:

ent [] vectorDeEnteros = { 1,2,3,10,100,555,0, .otros valores};

Adems puedo crear unos vectores cuyos elementos son ellos mismos vectores, etc. Esto se
consigue de esta forma:

double[] [] matrizIdentidadDerden3 = { { 1.0 , 0.0 , 0.0 } ,
{ 0.0 , 1.0 , 0.0 } ,
{ 0.0 , 0.0 , 1.0 } };

El siguiente programa utiliza los array y lo editaremos en un archivo que se llama vect.java:

clase vect
{

static ent NOMBRE = 0;

static ent APELLIDOS = 1;

static ent PATODNALD=0;

static ent GILBERTO=1;

static ent JORGITO=2;

static ent JAIMITO=3;

static ent JUANITO=4;

static ent GUS=5;

static ent COMISARIO=6;

static ent RATN=7;

static ent SUPER PATO=8;

static ent PLUTO=9;

static ent ABUELA=10;

static ent GILITO=11;

static Cadena personajes[][] = {
{"Paolino","Pato Donald"},
{"Pietro","Gilberto"},
{"Jorgito","No especificado"},
{"Jaimito","No especificado"},
{"Juanito","No especificado"},
{"Ciccio","De Abuela Donald"},
{"No especificado","Comisario"},
{"No especificado","Ratn Micky"},
{"Tribiln","No especificado"},
{"Pluto","No especificado"},
{"No especificado","Daisy"},
{"No especificado","Gilito"},
};

public static void main(String [] a)
{

ent PersonajeTmp;

ent Nmero=1;

System.out.println ("Unos personajes de Walt Disney");

PersonajeTmp=PATODNALD;

System.out.println("Nmero:"+Nmero+"\tNombre:"+personajes[PersonajeTmp][NOMBRE]+"
Apellidos:"+personajes[PersonajeTmp][APELLIDOS]);

Nmero=Nmero+1;

PersonajeTmp=GILBERTO;

System.out.println("Nmero:"+Nmero+"\tNombre:"+personajes[PersonajeTmp][NOMBRE]+"
Apellidos:"+personajes[PersonajeTmp][APELLIDOS]);

Nmero=Nmero+1;

PersonajeTmp=JORGITO;

System.out.println("Nmero:"+Nmero+"\tNombre:"+personajes[PersonajeTmp][NOMBRE]+"
Apellidos:"+personajes[PersonajeTmp][APELLIDOS]);

Nmero=Nmero+1;

PersonajeTmp=JAIMITO;

System.out.println("Nmero:"+Nmero+"\tNombre:"+personajes[PersonajeTmp][NOMBRE]+"
Apellidos:"+personajes[PersonajeTmp][APELLIDOS]);

Nmero=Nmero+1;

PersonajeTmp=JUANITO;

System.out.println("Nmero:"+Nmero+"\tNombre:"+personajes[PersonajeTmp][NOMBRE]+"
Apellidos:"+personajes[PersonajeTmp][APELLIDOS]);

Nmero=Nmero+1;

PersonajeTmp=GUS;

System.out.println("Nmero:"+Nmero+"\tNombre:"+personajes[PersonajeTmp][NOMBRE]+"
Apellidos:"+personajes[PersonajeTmp][APELLIDOS]);

Nmero=Nmero+1;

PersonajeTmp=COMISARIO;

System.out.println("Nmero:"+Nmero+"\tNombre:"+personajes[PersonajeTmp][NOMBRE]+"
Apellidos:"+personajes[PersonajeTmp][APELLIDOS]);

Nmero=Nmero+1;

PersonajeTmp=PLUTO;

System.out.println("Nmero:"+Nmero+"\tNombre:"+personajes[PersonajeTmp][NOMBRE]+"
Apellidos:"+personajes[PersonajeTmp][APELLIDOS]);

Nmero=Nmero+1;

PersonajeTmp=TRIBILN;

System.out.println("Nmero:"+Nmero+"\tNombre:"+personajes[PersonajeTmp][NOMBRE]+"
Apellidos:"+personajes[PersonajeTmp][APELLIDOS]);

Nmero=Nmero+1;

PersonajeTmp=GILITO;

System.out.println("Nmero:"+Nmero+"\tNombre:"+personajes[PersonajeTmp][NOMBRE]+"
Apellidos:"+personajes[PersonajeTmp][APELLIDOS]);

Nmero=Nmero+1;

PersonajeTmp=RATN;

System.out.println("Nmero:"+Nmero+"\tNombre:"+personajes[PersonajeTmp][NOMBRE]+"
Apellidos:"+personajes[PersonajeTmp][APELLIDOS]);

System.out.println("HiCe los clculos "+Nmero+" personajes, y eran muchos ms");

// ste s es un programa realmente intil. El autor.

}
}

Un pequeo comentario sobre el programa. Os habis dado cuanta de que en el main se
establecen unas variables (es posible hacerlo): normalmente se usan sin redactarlas como
static porque las variables del main, o de una funcin, por lo general, no son atributos y, por
eso, no estn relacionados con el objeto o con la clase, sino slamente con la funcin en la que
se escriben. En estas definiciones no estn incluidos los modificadores porque estos se
asocian a las clases.

Llegados a este punto nos queda por ver los tipos compuestos que se pueden fcilmente
identificar ahora con las clases. Por ejemplo, si queris definir el tipo compuesto Complejos,
escribiremos:

clase Complejos
{
private double ParteReal;

private double ParteImaginaria;

Complejos (double Re, double Im)
{

ParteReal=Re;

ParteImaginaria=Im;

}

// ahora estableceremos todos nuestros obvios mtodos en el nuevo tipo
double dmeParteReal()
{
return ParteReal;
};
double dmeParteImaginaria()
{
return ParteImaginaria;
};
double calculaMdulo()
{
return (java.lang.Math.sqrt((ParteImaginaria*ParteImaginaria)+ (ParteReal*ParteReal)));
};

}

Para probar, podis escribir los siguiente(pruebaComplejos.java):

clase pruebaComplejos
{

public static void main (Cadena[] arg)
{
Complejos N=nuevo Complejos(3.0,1.1);

double Re=N.dmeParteReal();

double Im=N.dmeParteImaginaria();

double mod=N.calculaMdulo();

System.out.println("Nmero complejo:"+Re+"+i"+Im+" tiene "+mod);

}

}
Operadores
Los operadores del enguaje Java son los mismos que los de los dems lenguajes, adems
cada nuevo tipo tendr su proprio mtodo que incluyen nuevos operadores, como vimos en el
ejemplo de la clse Complejos.
Analizamos los operadores de acceso a las clases y a los objetos, es decir, simplemente el
punto. Si queremos entrar en el campo X del objeto x, simplemente tendremos que escribir x.X,
aunque x tenga un mtodo Y(ent valor), nosostros entramos o, mejor en este caso, lo
solicitamos escribiendo x.Y(39); Tenemos los operadores aritmticos de siempre: +,-,*,/ y %.
Hay que tener en cuenta tambin las operaciones son tipadas, es decir, si sumo dos enteros el
resultado es un valor entero y as para todas las operaciones, de forma que si tenemos una
expresin siempre es posible establecer el tipo de resultado.
Java ejerce un fuerte control sobre los tipos. De hecho, no es posible asignar un carcter e un
entero, lo que es posible en el lenguaje C, y adems es imposible asignar un double a un float
sin un casting explcito. El casting obliga a un valor de un tipo a tener un tipo distinto. Si escribo
5, me refiero a un entero, mientras que si hago un cast a float me refiero a la versin de 5 real y
para hacerlo tendr que escribir(float) 5.
De esta forma puedo asignar los enteros a reales y de reales double a relaes float. Pensemos,
por ejemplo en:

double v1=10.0;
float v2;
ent v3=5;

y pensemos en las siguientes asignaciones equivocadas:

v2=v1;
v1=v3;

Si hacemos unos cast, se convierten en exactas tambin para Java:

v2=(float) v1;
v1=(double) v3;

Hay que notar la divisin de los enteros que en otros lenguajes da un entero. Por lo tanto, si
queremos el nmero real que resulta de la divisin de los dos nmeros enteros x e y, antes hay
que transformarlos en nmeros reales:

float resultado= (float ) x / (float) y;

Para las cadenas hay un operador de encadenamiento:

cadena a="Pietro " ;
Cadena b= a + "Castellu";
Cadena b+="cci"

El resultado ser Pietro Castellucci. El operador es el signo +. En un momento dado, utilizamos
una asignacin particular, es decir, += que es una abreviacin. Si tengo que escribir a=a+1;
puedo abreviar y escribir a+=1, que es lo mismo. Lo mismo vale para cada operador binario. El
operador + cuelga de una cadena tambin caracteres y nmeros, pensemos en las salidas de
los ejemplos anteriores en los que escribamos, por ejemplo:

System.out.println("Nmero complejo:"+Re+"+i"+Im+" tiene mdulo "+mod);

esto os puede parecer raro, sobre todo si consideramos que dijimos que las expresiones Java
estn bien caracterizadas por los tipos, a diferencia del C. Esto ocurre, sin embargo, porque el
sistema hace unas conversiones implcitas de tipos primitivos y objetos en cadenas. Por
ejemplo, si establecemos cualquier objeto y lo hacemos con un mtodo toString(), el sistema
tendr que trabajar con cadenas y con este objeto solicitar automticamente el mtodo
toString().

Adems Java ofrece otros cuatro operadores que son unas abreviaciones: dos son de
incremento de variables y dos de incremento. Si X es una variable puedo escribir:

X++
++X
X--
--X

Esto quiere decir: primero evalua X y luego incrementa X, primero incrementa X y luego evalua
X, primero evalua X y luego disminuye X y , por ltimo, primero disminuye X y luego evala X.
Esto quiere decir que la expresin X++ es un mando de asignacin, pero tambin una
expresin que devuelve un resultado que, en este caso, es X antes de que se incremente.

Por ejemplo:

X=10;
Y=X++;

dar como resultado X=11 e Y=10. Intendad editar y poner en marcha lo siguiente clase incdec

{

public static void main(Cadena [] a)
{

ent X,Y,Z,W,V;

X=10;

System.out.println("X="+X);

Y=X++;

System.out.println("Y=X++: tengo X="+X+",Y="+Y);

Z=++Y;

System.out.println("Z=++Y: tengo Z="+Z+",Y="+Y);

W=Z--;

System.out.println("W=Z--: tengo W="+W+",Z="+Z);

V=--W;

System.out.println("V=--W: tengo V="+V+",W="+W);

}
}

Otros operadores son los de comparacin, es decir:

> mayor de, x>y nos da verdadero si x es mayor que y, en caso contrario, nos da falso

>= mayor o igual a, x>=y nos da verdadero si x es mayor o igual a y, en caso contrario nos da
falso

< menor de, x<y nos da verdadero si x es menor de y, en caso contrario, nos da falso

<= menor o igual a, x<=y nos da verdadero si x es menor o igual a y, en caso contrario, nos da
falso

== igual a, x==y nos da verdadero si x es igual a y, en caso contrario, nos da falso

!= diferente, x!=y nos da verdadero si x es diferente de y, en caso contrario, nos da falso

Tenemos tambin los operadores lgicos &&, || y !, que representan la conjuncin y, la
disjuntiva o y el no: Establecidos los valores booleanos x e y , x && y ser verdadera si x e y lo
son tambin; ser falsa si no lo son (si las dos son falsas o si una es verdadera y la otra falsa).
x || y sar vedadera si x o y o los dos son verdaderas (ser falsa slo si los dos son falsos). !x
ser verdadera si x es falsa, mientras ser falsa si x es verdadera.
Tenemos los operadores binarios orientados hacia los bit:

&, AND bit a bit
| , OR bit a bit
^, OR EXCLUSIVO, bit a bit
y los shift, >>, <<, >>>.

Estas operaciones binarias son muy tiles para construir las matrices.

El ltimo operador es el condicional que nos permite definir expresiones con dos diferentes
resultados segn un valor booleano.
Pongamos el siguiente ejemplo:

ent ValorAbsoluto = ( a<0 ? -a : a );

ValorAbsoluto tendr el valor -a si a es negativo o si a es positivo o nulo.
Llegados a este punto, podemos escribir todas las expresiones que queramos en lenguaje
Java.
Instrucciones
Estamos preparados para ver los constructores principales del lenguaje Java. Ya vimos los
comentarios, que no se pueden ocultar, es decir, que el siguiente comentario no es posible: /*
+ste es seguramente un comentario /* ste tambin lo es */ */ Sin embargo, se pueden
introducir comentarios de una lnea en los comentarios de ms de una lnea porque son
distintos. Por ejemplo, es posible escribir lo siguiente: /* ste es seguramente un comentario //
ste tambin lo es */ aunque realmente resulte bastante intil. Las primeras instrucciones de
Java que vamos a ver son las instrucciones de declaracin, que son las declaraciones de
variables locales. Se utilizan para declarar variables y darles un posible valor inicial. Estas
instrucciones ya las vimos y se parecen a las declaraciones de los atributos, excepto por la falta
de los modificadores. Las variables locales, antes de ser utilizadas, se tienen que inicializar.
Las variables locales se pueden declarar en un punto cualquiera de un bloque y no
necesariamente al inicio, adems existen slo en los bloques en los que se declaran. Un
bloque es como una instruccin, lo nico es que empieza por { y acaba por }, y en l puede
tener muchas instrucciones, incluso posiblemente de otros bloques.

{
instruccin 1;
instruccin 2;
.
instruccin j-1;
{
subinstruccin1;
subinstruccin2;
..
subinstruccin;
}; // es la instruccin j
instruccin j+1;
.
instruccin n;
}// Este bloque puede ser el cuerpo de un mtodo o un bloque
Pensad en el mtodo:
void tribiln()
{
ent j=0;
{
ent k=0;
k++; // instruccin A
};
j++; // instruccin B
k++; // instruccin C
}

La instruccin A no da problemas porque usa una variable local que est inicialidada, declarada
en su mismo bloque.
Con la instruccin B ocurre lo mismo, mientras la instruccin C est equivocada porque la
variable que utiliza se ha declarado en un bloque entero y no se puede ver externamente. Si en
el bloque interno hubiera escrito j++; no tendra ningn problema porque la variable j se habra
declarado en un bloque externo. (Dentro se ve lo que hay fuera, pero fuera no se puede ver lo
que hay dentro, lo cual ocurre en todos los lenguajes de programacin por bloques).
Acabamos de ver en el ejemplo que tambin j++ es tanto una instruccin como una expresin,
como su otra forma e ++j, y es su imagen especular de disminucin. Hay otras operaciones que
se pueden tener en cuenta a la hora de analizar las instrucciones. Se trata tanto de la
implementacin de los mtodos que pueden devolver o no un valor, como de las instrucciones
de creacin de objetos, las que llevan new. Por ejemplo, new Object(), es una instruccin
correcta.
Otra instruccin muy parecida a una expresin es la instruccin de asignacin, la del tipo:

NombreVariable = expresin;

Por lo tanto, hasta ahora hemos visto las seis instrucciones:
Declaracin de una variable local;
Bloque;
Formas de incremento y disminucin de las variables, prefijas y postfijas;
Creacin de los objetos;
Solicitud de los mtodos;
Asignacin de las variables;

Todas las instrucciones terminan por ;

Las dems instrucciones se llaman constructos y son muy parecidas a las de los dems
lenguajes de programacin. Las vamos a ver detalladamente.

Instruccin condicional
if (EXPBOOL) IST
Esta instruccin pone en marcha la instruccin llamada IST que puede ser una cualquier
instruccin del lenguaje slo si la expresin booleana EXPBOOL es verdadera, de lo contrario
se salta. Una variedad es la en que pone en marcha otra instruccin si EXPBOOL es falsa, es:

if (EXPBOOL) IST
else
IST2

Fijaos que IST y IST2 son instrucciones generales, por lo tanto tambin los bloques o las
dems instrucciones condicionales. En este ltimo caso hablamos de if ocultos.

Instruccin switch

Switch (EXP)
{
case CST11: . :case CST1n: IST1
case CST21: . : case CST2n: IST2
.
case CSTm1: . : case CSTmn: ISTm
default ISTm+1;
};

Si EXP es una expresin, CSTij son unas constantes del mismo tipo que la expresin. EXP y
ISTi son unas instrucciones.
La instruccin evala EXP, y compara el resultado con las constantes de los case; si encuentra
otro igual, pone en marcha la instruccin correspondiente. Si, en cambio, no encuentra ninguna
constante igual, pone en marcha la instruccin despus del default, lo que es una opcin. En el
caso de que est ausente y ningn case tenga la constante igual al valor de EXP, se salta el
switch.
Analizamos, por ejemplo, el siguente mando:

switch (5+1)
{
case 6 : System.out.println ("Muy bien");
default : System.out.println ("Burrp, es seis");
};

Instruccin for for (exp de inicializacin; exb booleana; exp de incremento) ISTR
pone en marcha la instruccin ISTR que es un nmero de veces igual a los valores contenidos
en un intervalo. Normalmente la instruccin de inicializacin pone en marcha una variable en un
valor; la variable se incrementa (o disminuye) a partir de la instruccin de incremento y en la
expresin booleana se controla que la variable tenga los valores que queremos. En efecto, si la
expresin booleana es falsa, enseguida se sale del ciclo for.
Voy a poner un ejemplo: quiero inicializar los valores de un vector de 100 enteros todos a cero.
En lugar de escribir 100 asignaciones, escribir:

ent v = new ent[100];
for (ent e = 0 ; e<100; e++) v[e] = 0 ;

Como acabamos de ver la variable tambin se puede declarar en la instruccin de
inicializacin. De esta forma, slo se puede ver en el for.

Instruccin while
while (EXPBOOL) IST
Pone en marcha IST simulando que EXPBOOL es verdadera, por ejemplo, la inicializacin del
ejemplo anterior se puede llevar a cabo con el while de la siguiente forma:

ent v = nuevo ent[100];
ent e=0;
while (e<100) {
v[e]=0;
e+=1;
};

o de forma comprimida, aprovechando el incremento de forma comprimida:

ent v = nuevo ent[100];
ent e=0;
while (e<100) v[e++]=0;

Instruccin do-while do IST while (EXPBOOL);
ES como el while, slo que antes ejecuta la instruccin y luego controla el EXPBOOL, de nuevo
la inicializacin precedente se convierte en:

ent v = nuevo ent[100];
ent e=0;
do {
v[e]=0;
e+=1;
} while (e<100);

o tambin de forma todava ms comprimida:

ent v = nuevo ent[100];
ent e=0;
do v[e++] = 0 while (e<100);

Etiquetas
Es posible poner etiquetas a las instrucciones, como ocurre con el cdigo assembler. Esto
resulta muy til en combinacin con las instrucciones de break y de continue:

etiqueta: instruccin;

instruccin de break
La instruccin de break se utiliza para salir de un bloque o de un switch; cuando se encuentra
un break se sale del bloque ms interno, mientras que si se pone una etiqueta, se sale hasta
donde la etiqueta se ha declarado.

Ejemplo:

{
while ( COND )
{
while (COND2)
{
if (ALGO) break;
}
}
}
En este caso se sale del while interior, mientras:
{
tribiln: while ( COND )
{
while (COND2)
{
if (ALGO) break tribiln;
}
}
}

se sale de los dos while.

Instruccin de continue
En un ciclo se salta todas las instrucciones que le siguen y evala directamente la expresin
booleana, por ejemplo:

while (Condicin)
{
instrucciones;
if (GolpeDeEfecto) continue;
otras instrucciones;
};

Se entra en el ciclo, se ponen en marcha las instrucciones. Si GolpeDeEfecto es verdadero,
salta otras instrucciones y llega a evaluar Condicin. Si sta tambin es verdadera, contina el
ciclo poniendo en marcha las instrucciones, etc..

Instruccin de return
Produce la conclusin de la ejecucin del mtodo en el que se encuentra y el retorno a la
llamada. Si el mtodo es void basta con escribir return, si no tiene que contener una expresin
del mismo tipo del mtodo, por ejemplo

ent tribiln()
{
return 10;
}

con la instruccin return es posible tambin bloquear la puesta en marcha de un constructor o
de un mtodo static.

Con esto acabamos nuestro examen de las instrucciones. Ahora estamos preparados para
construir cualquier aplicacin a consola.
Pongamos un par de ejemplos: empecemos escribiendo un pequeo programa que imprima los
primeros nmeros, los menores de 500 de la famosa serie de Fibonacci. Para los que no la
conozcan, la serie de Fibonacci es una secuencia infinita de nmeros cuyos dos primeros
elementos son: 1, 1, y los dems elementos se calculan como la suma del e-1 simo nmero y
del e-2 simo, formalmente, reconociendo Fibo come una funcin:

Fibo ( e ) = Fibo ( e - 1 ) + Fibo ( e - 2 );

El programa que hay que escribir en Fibo.java es el siguiente:

class Fibo
{

public static void main (Cadena[] args)

{

ent bajo=1, alto=1;

// ent alto=1;

System.out.println (bajo);

while (alto<500)
{

System.out.println(alto);

alto+=bajo;

bajo = alto - bajo;

};

}

}

Para que os entrengis, podis intentar hacer un programa que calcula 10 ! , sabiendo que 1! =
1 y que establecido n entero, n! = n * ((n-1)!). La solucin se encuentra en el archivo Fatt.java.
Ahora, intentamos escribir nuetra criba de Eratstenes hecho en casa, es decir, una forma para
calcular todos los nmeros primos hasta un nmero establecido, digamos 100;
El algoritmo procede as,

1 es un nmero primo.
2 es un nmero primo, le quito sus mltiplos
3 es un nmero primo, le quito sus mltiplos

etctera hasta encontrar mi mximo.

clase Eratstenes
{
static ent MX=1000;

ent [] nmeros = nuevo ent[MX];

boolean [] primos = nuevo boolean[MX];

public Eratstenes()
{

ent e;

for (e=0;i<MAX;e++)
{
nmeros[e]=e+1;

primos[e]=verdaderos;

};
}

void elMul(ent a)
{

for (ent j=2;j*a<=MX;j++)
primos[(j*a)-1]=falso;

}

ent siguiente(ent n)
{
ent tmp=n;

while (!primos[tmp]) {
tmp++;
if (tmp>=MX) break;
}

return tmp+1;

}

void calculaPrimos()
{
ent nm=2;

while (nm<=MX)
{
elMl(nm);
nm=siguiente(nm);
};

}

void escribaPrimos()

{

System.out.println("Los nmeros primos hasta "+MX+" son:");

for (ent e=0; e < MX ; e++)
if (primos[e]) System.out.print(nmeros[e]+" ");

}

public static void main(Cadena[] args)
{

Eratstenes e = nuevo Eratstenes();

e.calculaPrimos();

e.escribaPrimos();

}

}
Indicaciones sobre las excepciones y
sobre los thread
Las excepciones son una forma clara para controlar los errores sin confundir el cdigo con
muchas instrucciones de control del error. Cuando se verifica un error se pone en marcha una
excepcin que, si se recibe enseguida, nos permite gestionar un error. De lo contrario, el
soporte lleva a cabo como ejecucin de Java, un ter de default.
En Java hay una clase que se llama Exception, y las excepciones son objetos que pertenecen
a esta clase. Por eso, se pueden trabajar como verdaderos componentes del lenguaje.
Vamos a ver cmo es posible crear una excepcin.
Hay que crear una clase que ampla Throwable, o mejor Exception , que es una extensin de
Throwable. Supongamos que queremos crear una excepcin para decir que utilizamos una
cadena vaca: tendremos que escribir:

public clase ErrorCadenaVaca ampla Exception
{
ErrorCadenaVaca()
{
super("Cuidado, ests utilizando una cadena que no ha sido inicializada");
}
}

Esta clase tiene que estar en un archivo que se llama como la clase, es decir,
ErrorCadenaVaca.java Despus de haberla creado, necesitaremos una forma para hacerla
trabajar, es decir, para evidenciar la situacin de error que, ya que estamos, espero que alguien
recoja. Las excepciones trabajan con la instruccin throw que tiene que estar en un mtodo
que, a su vez, se tiene que declarar con un clusola throws. Por ejemplo, en nuestro caso, si
quiero crear un mtodo para imprimir la cadena que controla incluso el error, escribir en mi
clase:

public void Imprimir (Cadena a)
throws ErrorCadenaVaca /* Esto quiere decir que esta funcin puede poner en marcha una
excepcin del tipo ErrorCadenaVaca*/
{
if (a==null) throw nuevo ErrorCadenaVaca();
else System.out.println(a);
}

Entonces, llegados a este punto, el mtodo Imprimir enviar a la pantalla la cadena
transformada en parmetro y dar un excepcin de tipo ErrorCadenaVaca si el puntero era
nulo.
La excepcin que damos nosotros se llama excepcin controlada y tiene que ser
obligatoriamente gestionada, mientras las que da Java no necesariamente tienen que ser
recogidas y gestionadas.
Ahora vamos a ver como recoger las excepciones, por ejemplo, nuestra
ExcepcinCadenaVaca.
Las excepcines se recogen cuando se solicitan los mtodos que se declaran con la clusula
throws. Para recogerlas hay que implementar el mtodo en bloques try que tienen la siguiente
sintaxis:

try
BLOQUE // ste es un bloque peligros porque puede poner en marcha unas excepciones.
catch (Tipo de Excepcin que hay que coger)
BLOQUE // ste es un bloque de restablecimiento. catch (Tipo de Excepcin que hay que
coger)
BLOQUE // ste es un bloque de restablecimiento.
.
finally
BLOQUE

El corpus de esta instruccin se ejecuta hasta el final o hasta que aparezca una excepcin. En
caso de excepcin, se analizan las clusulas catch para ver si existe un administrador para esa
excepcin o para una de sus superclases. Si ninguna clusula catch recoge esa excepcin,
sta vuelve a lanzarse en el mtodo que la ha provocado (que la ha ejecutado).
Si en el try hay una clusula finally, su cdigo se pone en marcha despus de que se hayan
completado todas las dems operaciones del try, independientemente de que sta haya
ejcutado una excepcin o no. Por ejemplo, nuestro mtodo Imprimir se puede invocar as:

Si X es la cadena que hay que imprimir:

try {Imprimir(X);}
catch (ErrorCadenaVaca e)
{System.out.println ("Lo siento");}

En este caso, si X es nulo, se pondr en marcha la excepcin y se recoger; despus se
imprimir la cadena Lo siento, si no X. Si escribiera Imprimir(X) fuera de la try, saldra error
porque las excepciones que yo he causado tienen que ser recogidas. Esto obliga al
programador a escribir cdigo "bueno". Las excepciones de Java, en cambio, se pueden coger
o no.
El ejemplo siguiente recoge el HolaMundo del primer captulo que, si invocado sin parmetros,
daba una excepcin de ArrayIndexOutOfBoundsException, que, este vez, se gestiona;

clase HolaMundo
{

public static void main(Cadena[] args)
{

System.out.print ("Hola Mundo, soy el primer programa en Java");

Cadena Nombre;

Cadena Apellidos;

try {Nombre=args[0];}
catch (ArrayIndexOutOfBoundsException e)
{Nombre="No has introducido tu Nombre";}

;
try {Apellidos=args[1];}
catch (ArrayIndexOutOfBoundsException e)
{Apellidos="No has intruducido tus Apellidos";}
;

System.out.println ("de "+Nombre+" "+Apellidos);
}
}

Intenten ponerlo en marcha de las siguientes formas:

java HolaMundo Nombre Apellidos
java HolaMundo Nombre
java HolaMundo

y a ver lo que pasa. Hagan lo mismo con el HolaMundo del primer captulo.