Manual Completo Java

Manual de Java - Manual completo 26/2/15 11:20
Manual de Java
Manual por: DesarrolloWeb.com Versión on-line:
"Tu mejor ayuda para aprender a hacer webs" http://www.desarrolloweb.com/manuales/57
Introducción a Java
1. Un Toque de Historia.
2. ¿Que es JAVA 2?
1. Un Toque de Historia:
Java nace y da sus primeros pasos en 1991 formando parte de un proyecto de desarrollo de soporte
software para electrónica de consumo ( frigoríficos, lavadoras... ), llevado a cabo por un equipo de
SUN llamado Green Team. Este primer enfoque le da a Java una de sus más interesantes
características: La portabilidad, dado que Java tenia que funcionar en numerosos tipos de CPUs, y por
tanto se pensó para ser independiente de la plataforma sobre la que funcione. Esta característica es
muy posiblemente la que ha permitido a Java convertirse actualmente en el lenguaje por excelencia
para la creación de aplicaciones en Internet.
Este salto de Java para convertirse en un lenguaje de programación para computadores se da

definitivamente en 1995 cuando en la versión 2 del navegador web netscape se incluye un interprete
para este lenguaje, produciendo de este modo una auténtica revolución en Internet.
Con este nuevo enfoque Java sigue creciendo y saca su versión 1.1 en 1997 con muchas mejoras y
adaptaciones, fruto de una revisión sustancial del lenguaje. Java 1.2 aparece a finales de 1998 y más
tarde se rebautizará como Java 2.
Referencia: Tenemos un artículo que también comenta lo que es Java y ofrece algún otro dato de interés.
2. ¿Que es JAVA 2?
Sun describe a Java como "simple, orientado a objetos, distribuido, interpretado, robusto, seguro, de
arquitectura neutra, portable, de altas prestaciones, multitarea y dinámico".
Aparte de ser estas características la lógica lista de piropos que un padre siempre daría a uno de sus
hijos mas aplicados, efectivamente describen bastante bien a Java.
Java 2 es la tercera versión importante del lenguaje de programación Java. Parte de la versión 1.1 sin
introducirle cambios sustanciales, simplemente ampliándolo.
Java presenta muchas características que lo diferencian de lenguajes similares como C++, empezando
por las posibilidades de ejecución.
Básicamente un programa en Java puede ejecutarse como:
Stand Alone: Aplicación independiente.

Applet: Una aplicación especial que se ejecuta en el navegador del cliente.
Servlet: Una aplicación especial sin Interfaz que se ejecuta en servidor.
Por otro lado un desarrollo en Java nunca empieza desde cero. Java implementa consigo un gran
número de clases, incluidas gratuitamente en su entorno de desarrollo, para realizar muy variadas
tareas que permiten al desarrollador centrarse en las características más inherentes a su proyecto.
http://www.desarrolloweb.com/manuales/57/imprimir.php Página 1 de 21
Sun distribuye gratuitamente desde su página web, el entorno de desarrollo Java llamado
indistintamente con estas siglas: JDK, SDK o J2SE. Este paquete incluye como hemos dicho las clases
incluidas ya en java, es decir el API de Java. También incluye el compilador de Java y lo que permite a
Java funcionar en nuestro ordenador: el JRE (Java Runtime Enviroment).
El JRE incluye los elementos necesarios para hacer funcionar programas java en nuestro ordenador.
Principalmente nos instala la Maquina Virtual de Java y los plugins necesarios para el/los navegador/es
instalados en nuestro sistema. El JRE también se puede descargar independientemente del entorno de
desarrollo, pues se distribuye en un paquete llamado J2RE.
¿Y que es la Máquina Virtual de Java? Pues bien, como hemos comentado antes, Java está pensado
para ser independiente de la arquitectura sobre la que funcione y la manera que tiene Java para
conseguirlo es a través de la emulación de una máquina software sobre la que funcionan los
programas compilados con Java.
Es decir, un programa compilado con Java no tiene código comprensible por ningún procesador, ese
código solo lo entiende la Máquina virtual de Java y lo traduce a código que si pueda ser comprensible
por el procesador sobre el que funciona y además lo puede hacer funcionar sobre el sistema operativo
sobre el que está instalada. Por tanto lo único dependiente del Hardware es la máquina virtual, pues
tiene que conocer lo que tiene por debajo para llevar a cabo la traducción, pero los programas en java
siempre pueden funcionar sobre una maquina virtual esté donde esté instalada.
Instalar el entorno de desarrollo Java y primer programa

Ya podemos ir abandonando toda esta teoría y vamos entrando poco a poco en la práctica que es lo
que más nos atañe.
Para empezar vamos a instalar el entorno de desarrollo en nuestro mas que habitual Windows.
Podemos descargar el software gratuitamente de la página oficial de Sun. Actualmente los paquetes de
desarrollo que ofrece Sun vienen con una herramienta IDE ( Integrated Development Enviroment)
llamada Netbeans. Esta herramienta es muy potente, a lo mejor demasiado para empezar con Java,
nosotros nos centraremos en otra llamada Eclipse también gratuita.
Una vez descargado tenemos en nuestro ordenador un archivo llamado: "j2sdk-(versión)-nb-3_6-bin-

windows.exe". Para instalar solo tenemos que ejecutar el archivo, seguir las instrucciones y darle una
ruta de instalación en el momento en que nos lo requiera.
Cuando lo hemos instalado comprobaremos que nos ha creado en nuestro Autoexec.bat las siguientes
sentencias:
set JAVAPATH=<directorio donde hayas instalado java>

PATH=.;%JAVAPATH\bin;%PATH%
set CLASSPATH=.\;%JAVAPATH%\lib\classes.zip;%CLASSPATH%
En caso de que no las tengamos, nosotros mismos las escribiremos y guardaremos los cambios.
Una vez reiniciado el ordenador, los ejecutables de java instalados serán disponibles desde todo el
sistema y por tanto también para Eclipse que como hemos dicho instalaremos a continuación. Aparte
de esto también serán disponibles todas las clases para el compilador de java "javac" pues el camino
se define con la variable "CLASSPATH" ya definida.
Pues ahora podemos programar nuestro querido programa "hola mundo". Copia este código en un
editor de texto de tu preferencia y guárdalo como "Ejemplo.java". Mas tarde nos ocuparemos de
entender cual es su significado.
public class Ejemplo {

public static void main ( String argumentos[] )
{
System.out.println ("Hola Mundo\n");
}
}
Ahora vamos a compilar el programa y a proceder a ejecutarlo. Para esto nos vamos a abrir una
ventana de línea de comandos en Windows y nos dirigimos al directorio donde está "Ejemplo.java" y
ejecutamos el compilador de java "javac" con este comando: "javac Ejemplo.java". Podemos ver que
nos ha creado en el mismo directorio un archivo con el mismo nombre pero con extensión ".class".
Este archivo es un ejecutable java y por tanto funciona dentro de la máquina virtual java. Para
probarlo ejecutamos el siguiente comando: "java Ejemplo" dentro del mismo directorio.
Si todo ha ido bien te debería de haber mostrado: "Hola mundo" como habrías podido suponer.
Ya solo nos queda Instalar un Entorno de desarrollo integrado (IDE) para hacernos el trabajo más
sencillo a la hora de tirar líneas de código en java y manejarnos con nuestras clases.
Instalación de un entorno de desarrollo integrado (IDE): Eclipse.

Como hemos dicho, un IDE puede hacernos el trabajo mucho más sencillo, sobretodo si nuestro
desarrollo ya va manejando un buen número de Clases. Además estos entornos nos permiten mucha
más versatilidad para depurar nuestros programas puesto que tienen debbugers mucho más
avanzados, cosa que nos viene de perlas para ir empezando en este mundillo.
Eclipse es un IDE de código abierto. Hay mas herramientas similares de código abierto disponibles
pero he decidido usar esta pues es la que creo que tiene mejor relación calidad-facilidad de las que he
encontrado.
Su instalación es muy sencilla, podemos descargárnoslo de www.eclipse.org en forma de archivo ZIP y

solo tenemos que descomprimirlo en la carpeta donde queramos tenerlo instalado. Para ejecutarlo solo
hay que arrancar el fichero Eclipse.exe . Una vez arrancado lo único que nos pedirá es que le demos la
ruta por defecto donde queramos que eclipse nos vaya guardando los proyectos que creemos:
Después de esto nos aparecerá la ventana principal de Eclipse:
Ahora nos vamos a disponer a hacer el mismo ejercicio que hemos hecho antes pero con la ayuda de
Eclipse. Como es evidente para un ejercicio tan trivial nos va a suponer casi mas un gasto que un
ahorro pero lo importante es conseguir para empezar un manejo básico de Eclipse.
Eclipse puede usar varias perspectivas en su ventana principal dependiendo del tipo de desarrollo que
vayamos a realizar. Ahora abriremos la perspectiva "Java":
Es conveniente que todos los desarrollos que hagamos los hagamos dentro de un proyecto y por
mucho que nuestro ejercicio sea tan simple como útil a estas alturas, vamos a hacerlo como tal. Por lo
tanto vamos a crear un proyecto para nuestro desarrollo:
Para esto le damos a "File àNew à Proyect". Como podemos ver hay muchos tipos de proyectos para
poder crear para nuestro desarrollo. Elegimos "Java proyect" y le damos a siguiente. En la ventana en
la que estamos ahora podemos darle un nombre a nuestro proyecto y nos aparecen dos opciones
relativas a la organización de nuestro proyecto. Las dejamos tal y como está para que simplemente
nos coloque nuestros archivos .java y .class (fuentes y ejecutables java) en la carpeta que hemos
escogido para el entorno de trabajo al arrancar eclipse, y le damos a "Finish".
El siguiente paso es ir añadiendo nuestras clases al proyecto. Si no tienes conocimientos de

programación orientada a objetos te recomiendo que leas el articulo sobre tal, que hay en este mismo
sitio, y que te será indispensable para programar con Java. Por ahora continuamos.
Pinchando con el botón derecho en la carpeta del proyecto que se nos ha creado en la parte izquierda
de la ventana principal podemos darle a "New à Class"
Esta ventana tiene varias opciones que iremos entendiendo poco a poco. Por ahora simplemente
pondremos los nombres de la clase, del paquete donde queramos incluirla (podemos dejar el paquete
por defecto dejando este campo en blanco) y marcaremos las opciones que vemos en la ilustración.
Como hemos podido comprobar al escribir los nombres de la clase y del paquete nos avisa de ciertas
reglas para la nomenclatura de estos. Podemos avanzar que los nombres de las clases siempre
empiezan en mayúscula y que los de los paquetes en minúscula, ya comentaremos esto mas adelante
y con mas detenimiento.
Al darle a finalizar nos crea una plantilla que podemos ver en el centro de la pantalla. Esta área es la
que corresponde al editor y aquí es donde escribiremos nuestros programas en Java. La plantilla
creada nos añade las líneas básicas en el tipo de clase Java que hemos creado con todos los pasos
anteriores.
Al igual que en el ejemplo anterior cuando hemos hecho el habitual hola mundo escribimos lo que
queda para que se nos quede tal y como en la figura. Es decir, introducimos System.out.println ("Hola
Mundo\n"); dentro del método "main" de la clase.
Ya solo nos queda ejecutar el programa para ver que funciona. Para hacerlo funcionar podemos utilizar
el menú "run" o directamente mediante los iconos de la barra de herramientas.
Al ejecutar el "run" un asistente nos dará a elegir el tipo de ejecución que queremos para nuestro
código en Java. Simplemente escogemos "Java Application" en el menú con un doble "clic" y nos
creará un "apéndice" de configuración de ejecución para nuestro código en concreto, como podemos
ver:
En principio y sin mas detalles le damos a "Run" y vemos los resultados:
Como podemos comprobar, abajo hay una pestaña que pone "console". Esa pestaña nos muestra una
consola que hace las veces de la línea de comandos desde la que ejecutamos nuestro programa de
Java en el primer ejemplo. Por tanto es en ese espacio en el que podemos ver la salida del programa:
"Hola Mundo".
Esto es todo por ahora. Ya tenemos un entorno completo para hacer nuestros pequeños desarrollos en
Java y ya lo hemos probado. A partir de aquí tienes varias opciones para continuar:
Si desconoces o quieres recordar bases acerca de la Programación Orientada a objetos, consulta

este manual.
Si quieres conocimientos básicos acerca de la sintaxis y comportamiento básico del lenguaje
Java, consulta este manual.
Para pasar directamente a la acción consulta nuestros tutoriales de Java en la sección de
tutoriales de este sitio.
Introducción al lenguaje JAVA

1. Introducción:
Java tiene como todos los lenguajes de programación sus propias características para describir
algoritmos, es decir sus propios fundamentos del lenguaje. Este manual no pretende ser una
descripción exhaustiva de todos los modos en que podemos "expresarnos" en este lenguaje, sino una
base para poder ir creando nuestros pequeños programas. Creo que es mucho mas útil empezar a
programar puesto que se aprenden mejor estas cosas cuando tenemos que resolver algún problema
durante nuestro trabajo.
Para introducir simplemente destacar que Java tiene una sintaxis muy similar a la de C++ por lo que
los programadores que vengan desde este lenguaje se sentirán muy cómodos en él.
2. Comentarios:
Hay tres tipos de comentarios en Java:
// Este es un comentario de una sola línea

/* Este es un comentario de una o más líneas */
/** Este es un comentario de documentación */
3. Identificadores:
Un identificador es un "nombre" que nos permite dirigirnos específicamente a una de las entidades
propias del lenguaje, es decir, son los nombres que podemos ponerles a nuestros/as variables,
métodos, clases, interfaces y objetos.
La única restricción en la formación de identificadores es que tienen que comenzar por letra,
subrayado o por el signo '$', pudiéndoles seguir después letras o números. Hay que tener en cuenta
que en Java como en otros muchos lenguajes de programación se distinguen las mayúsculas y las
minúsculas.
Hay una serie de normas muy recomendables para crear identificadores en Java: En Java es habitual
escribir todos los identificadores en minúscula teniendo en cuenta las siguientes excepciones:
1. Si en un identificador queremos incluir un nombre compuesto se pone el primer nombre entero en

minúscula y el resto con la primera letra en mayúscula y el resto en minúscula. Por ejemplo:
miNuevaVariable = 3;
2. Los identificadores de clases e interfaces siempre empiezan en mayúscula siguiendo la anterior

norma en caso de tratarse de un nombre compuesto. Por ejemplo:
MiNuevaClase();
3. Los nombres de variables finales ( las mas habitualmente llamadas "constantes") se escriben
íntegramente en mayúscula. Por ejemplo: "PI"
Otra restricción muy importante y evidente a la hora de elegir identificador por ejemplo para una
variable es no coincidir con ciertas palabras restringidas que tiene el lenguaje, estas son:
abstract continue for new switch boolean default goto null synchronized
break do if package this byte double implements private threadsafe
byvalue else import protected throw case extends instanceof public transient
catch false int return true char final interface short try
class finally long static void const float native super while
Tipos primitivos y variables en Java

Continuamos nuestra introducción al lenguaje Java comentando los tipos primitivos y las variables.
4. Tipos Primitivos:
Como tipos primitivos entendemos aquellos tipos de información mas usuales y básicos. Son los
habituales de otros lenguajes de programación. Te describo algún dato a tener en cuenta en cada tipo.
Boolean: No es un valor numérico, solo admite los valores true o false.

Char: Usa el código UNICODE y ocupa cada carácter 16 bits.
Enteros: Difieren en las precisiones y pueden ser positivos o negativos.
Byte: 1 byte.
Short: 2 bytes.
Int: 4 bytes.
Long: 8 bytes.
Reales en punto flotante: igual que los enteros también difieren en las precisiones y pueden ser
positivos o negativos.
Float: 4 bytes.
Double: 8 bytes.
5. Variables:
Ahora que tenemos las piezas necesarias ( identificadores y tipos ) podemos definir variables en Java.
Una variable referenciará siempre a un tipo primitivo de Java o a cualquier otro objeto creado en
nuestro programa. Veamos algunas declaraciones:
Int a ; // declaración de una variable 'a'

//inicializada a 0 (valor por defecto).
Int b = 8; // declaración de una variable 'b' inicializada a 8.
NombreClase referencia; // declaración de una variable 'referencia' preparada //para llevar un objeto de la clase
'NombreClase'.
NombreClase referencia2; // lo mismo que en la variable anterior.
Referencia = new NombreClase; // se crea un nuevo objeto de la clase

//'NombreClase',y es asignado a la variable
//'Referencia'
Referencia2 = referencia; // Ahora también 'referencia2' tiene el mismo

// objeto a su cargo que 'referencia'
Una vez tenemos un poco de idea de como declarar variables en Java, tenemos que tener en cuenta
desde que sitios de nuestro programa podemos acceder a ellas, es lo que llamamos ámbito de la
variable.
Básicamente la norma es que la variable tiene validez dentro del bloque encerrado entre llaves donde
ha sido declarada, ya sea dentro de una función o de por ejemplo una sentencia 'if'. Veamos un
ejemplo con un pequeño programita en java.
public class AmbitoVariables {
public static void main(String[] args) {

if (true) {
int y=5;
}
System.out.println(y);
}
}
Si intentamos ejecutar este código el compilador nos dará un error diciéndonos que la variable y no
está definida puesto que la hemos declarado en un bloque distinto de donde la pretendemos utilizar.
Hay mas normas de ámbito respecto a las variables miembro de una clase. Para acceder a ellas
depende si en la clase está declarada como 'public' o como 'private'. Las variables declaradas en una
clase como 'public' se acceden directamente a través de 'NombreClase.nombreVariable'. En caso de
una variable 'private' solo podemos utilizarla mediante los métodos de esa clase.
Por otro lado desde la declaración de cualquier función propia de una clase podemos acceder a las
variables internas de esa clase directamente.
Ya incluiré mas normas de ámbito cuando veamos el concepto de herencia en siguientes capitulos de la
programación en Java. Este tutorial acaba con el siguiente punto en el que vemos los operadores.
Operadores en Java
Los operadores son muy similares a los de C++, ya lo advertimos en su momento.
Operadores Aritméticos: Los habituales
Suma + .
Resta - .
Multiplicación * .
División / .
Resto de la División % .
Operadores de Asignación: El principal es '=' pero hay más operadores de asignación con distintas
funciones que explicamos brevemente ahora.
'+=' : op1 += op2 à op1 = op1 + op2

'-=' : op1 -= op2 à op1 = op1 - op2
'*=' : op1 *= op2 à op1 = op1 * op2
'/=' : op1 /= op2 à op1 = op1 / op2
'%=' : op1 %= op2 à op1 = op1 % op2
Operadores Unarios: El mas (+) y el menos (-). Para cambiar el signo del operando.
Operador Instanceof: Nos permite saber si un objeto pertenece a una clase o no.
NombreObjeto instanceof NombreClase
Operadores Incrementales: Son los operadores que nos permiten incrementar las variables en una
unidad. Se pueden usar delante y detrás de la variable dependiendo de lo que queramos, es decir, si
queremos que incremente o viceversa antes de utilizar o lo contrario.
'++'
'--'
Operadores Relacionales: Permiten comparar variables según relación de igualdad/desigualdad o

relacción mayor/menor. Devuelven siempre un valor boolean.
'>': Mayor que

'<': Menor que
'==': Iguales
'¡=': Distintos
'>=': Mayor o igual que
'<=': Menor o igual que
Operadores Lógicos: Nos permiten construir expresiones lógicas.
'&&' : devuelve true si ambos operandos son true.

'||' : devuelve true si alguno de los operandos son true.
'!' : Niega el operando que se le pasa.
'&' : devuelve true si ambos operandos son true, evaluándolos ambos.
'|' : devuelve true uno de los operandos es true, evaluándolos ambos.
Operador de concatenación con cadena de caracteres '+':
Por Ejemplo: System.out.println("El total es"+ result +"unidades");
Operadores que actúan a nivel de bits: Son mucho menos utilizados por eso los explicamos mas
por encima.
'>>': desplazamiento a la derecha de los bits del operando

'<<': desplazamiento a la izquierda de los bits de operando
'&': operador and a nivel de bit.
'|': operador or a nivel de bit
Estructuras de control de bifurcación en Java
Se tratan de las mismas estructuras que pueden encontrarse en cualquier otro lenguaje, si sabes ya
programar ten en cuenta que lo único que necesitas aprender es la sintaxis y eso se consigue mucho
mejor programando así que puedes pasar por alto este punto.
Bifurcaciones: Permiten ejecutar código en función de una expresión evaluada
Bifurcaciones if:
Tienen las siguientes posibilidades en su sintaxis:
if (ExpresionBooleana){conjuntoDeSentencias}
if (ExpresionBooleana) {conjuntoDeSentencias}
else {conjuntoAlternativo}
if (ExpresionBooleana) {conjuntoDeSentencias}
else if {conjuntoAlternativo}
else if {conjuntoAlternativo2}
Ejemplos:
if (i == 5){ System.out.println(" i vale 5 ");}

else {System.out.println("i no vale 5");}
if (i == 5){ System.out.println(" i vale 5 ");}

else if (i < 5){System.out.println("i es menor que 5");}
else if (i > 5){System.out.println("i es mayor que 5");}
Bifurcaciones switch
Son las que permiten realizar varias acciones distintas dependiendo del estado de una variable.
Switch (Expresion){
Case valor1: conjuntoDeSentencias;
break;
Case valor2: SentenciasAlternativas;
break;
Case valor3: SentenciasAlternativas2;
break;
Case valor4: SentenciasAlternativas3;
break;
}
La sentencia 'break' detrás de cada opción de case sirve para que no evalue el resto de opciones sino
que se salga directamente del 'Switch', asi que dependiendo de lo que quieras hacer la pondrás o no.
Ejemplos:
switch (i) {
case '1': System.out.println( "i contiene un 1");
}
Estructuras de control tipo bucle en Java

Los bucles se utilizan para ejecutar un conjunto de instrucciones varias veces basándose siempre en
una condición que decidirá si se sigue repitiendo o no. Veamos los tipos que hay.
Bucle While
while (expresion) {sentencias}
Las instrucciones dentro de las llaves se ejecutan mientras la expresión sea verdadera.
i=5;
while ( i > 0 ) {i --;}
// las llaves aquí se podían haber omitido, puesto
// que solo hay una sentencia.
System.out.println("Ahora i vale 0");
Bucle For
Es un bucle más "fijo", permite ejecutar el conjunto de sentencias un numero determinado de veces
fijado al principio del bucle y funciona por tanto como un contador. Su expresión general seria como la
que sigue:
for (inicialización, expresionBooleana, incremento) {conjuntoDeSentencias;}
for (int i= 0; i <10; i++){ System.out.println("el valor de i es: " + i); }
Este ejemplo nos mostraría por la pantalla diez líneas diciéndonos el valor creciente de 'i' de cero a
nueve.
Bucle do while
Es igual al bucle while anteriormente visto, solo que ahora se evalúa la expresión al final del bucle, por
lo que ese conjunto de sentencias se ejecuta al menos una vez:
i=5;
do
{i --;} // las llaves aquí se pueden omitir puesto
while ( i > 0 ) // que solo hay una sentencia.
Este ejemplo similar al anterior para el bucle while se diferencia en que ejecuta una vez mas las
sentencias en su cuerpo puesto que comprueba la condición posteriormente.
Sentencias Break, Continue y Return
Antes hemos hablado de la sentencia Break con las bifurcaciones switch. Pues bien, esta sentencia
tiene un valor mas amplio. La sentencia break nos permite salirnos del bloque de sentencias
(encerrado entre llaves) o el bucle que estamos ejecutando, sin ejecutar las sentencias que resten
para el final o las restantes iteraciones del bucle. Por ejemplo:
i=5;
do{
i --;
if (i == 3) break;
} while ( i > 0 )
// En este ejemplo cuando i tenga el valor 3
// se abandonará el bucle.
La sentencia Continue solo es válida para bucles, sirve para no ejecutar las sentencias que restan para
la finalización de una iteración de ese bucle, continuando después con las siguientes iteraciones del
bucle. Por ejemplo:
i=5;
do{
if (i == 3) continue; i --;
}while ( i > 0 ) // En este ejemplo cuando i tenga el valor 3
// se abandonará la iteración y por tanto el
// bucle no tendrá fin puesto que no se
// ejecutaría la sentencia de decremento.
Tanto la sentencia continue como break se pueden utilizar con etiquetas para poder discriminar los
bucles que quieren afectar en caso de que se encuentren en un bucle anidado. Por ejemplo:
Bucle1:
for (int i=0; i<10; i++){
bucle2:
for (int j=0; i<10; j++){
if (j==5) {break bucle2;}
}
} // cuando j llega a 5 el bucle2 deja de
// ejecutarse hasta la siguiente iteracion
// del bloque1
Por último vemos la sentencia return. Esta sentencia nos permite finalizar también un conjunto de
sentencias, con la peculiaridad esta vez de que también finaliza el método o función que en el que se
encuentre. En el caso de que queramos devolver un valor desde esa función o método lo debemos
poner a continuación de return. Por ejemplo:
void funcionEjemplo(){
int i=0;
while (i < 100){ //esta absurda función nos devuelve
i++; //al llamarla el valor 100 como has
} //podido comprobar
return i;
}
Bloque Try Catch Finally
Se trata de unas sentencias de control relacionadas con el tratamiento de excepciones, no tiene nada
que ver con las estructuras de control de bucle, vistas en este artículo, salvo porque es también una
estructura de control. La comentamos a continuación, aunque se verá con ejemplos más adelante.
El tratamiento de excepciones se utiliza para detectar errores cuando se ejecutan nuestros programas
y tratarlos del modo que nosotros queramos. Los errores cazados por un sistema de tratamiento de
excepciones no bloquean el programa y el manejo de excepciones nos permite hacer cosas cuando
esos errores ocurren.
Por ahora solo es bueno que sepas que existen, ya las veremos en otro momento.
Lenguaje Java II
Vamos a intentar entender como funciona un programa en Java para poder empezar a programar
nosotros posteriormente. Intentaré también explicar algo sobre los conceptos básicos de la
Programación orientada a objetos, mientras avanzamos. De todos modos os remito al artículo sobre este
tema que ya tenemos publicado en nuestra página. Seguramente en un futuro ampliaremos los contenidos
sobre programación orientada a objetos dentro de nuestra web por la importancia que esta tiene.
Vamos adelante.
Estructura básica de un programa en Java
En Java, como en cualquier otro lenguaje orientado a objetos, abandonamos el modo de entender un
programa que utilizábamos anteriormente para aproximarnos a un modo más cercano a "la vida
misma".
Los programas ahora estarán divididos en clases. Una clase en si se puede entender como un
programa independiente, tiene sus propios datos y también maneja esos datos "a su modo".
La relación con la vida misma la podemos ver en el siguiente comentario: Imaginemos que dos clases
tal y como las hemos explicado anteriormente son "la clase mecánico" y la "clase panadero". Cada una
de estas clases tiene sus propias herramientas y sus propias tareas, por ejemplo, el panadero tiene
"harina" y una de sus tareas es "amasar", mientras que el mecánico tiene "bujías" y una de sus tareas
es "limpiar bujías". Lo importante de todo esto es que cada uno hace muy bien su tarea pero no tiene
sentido "llevar el coche a la panadería de la esquina" ni "pedir una baguette junto con un cambio de
aceite".
Vamos a estudiar unas pequeñas clases que nos servirán en un futuro para implementar un ejercicio
un poco más complicado. Estas clases son la clase "ficha" y la clase "tablero" que nos servirán para
implementar con el tiempo un juego de las "cuatro en raya".
public class Fichas {

String color;
public Fichas(String c){color=c;}
public String dameColor(){return(color);}
}
Esta va a ser la clase ficha. Veámosla un poco: Esta clase tiene una variable "color" que es un String.
El tipo String no es un tipo primitivo en Java, es una clase que está dentro del API de Java, mas
concretamente dentro del paquete "Java.lang" y que además siempre se incluye por defecto en cada
programa Java que hagamos.
Por tanto, lo que estamos haciendo en la segunda línea de nuestro programa es declarar un objeto sin
valor de la clase String.
La tercera y la cuarta línea son dos métodos de la clase "Fichas" que estamos definiendo.
El primer método es un constructor. Un constructor es un método que se llama con la sentencia "new",
es decir cuando alguien quiera crear un objeto y que nos define bajo que condiciones se crea ese
objeto, ya lo entenderás mejor. En este caso para que alguien quiera crear una ficha tiene que pasar
un objeto "String" como parámetro y obtendrá a cambio un objeto de la clase "Fichas" del color que ha
solicitado.
El segundo método nos devuelve un objeto "String" con el valor del color que tiene el objeto ficha en
ese momento.
public class Tablero {

Fichas estadoTablero[][];
public Tablero(){estadoTablero=new Fichas [6][7];};
public boolean verSiLlena(int indice){
return(estadoTablero[7][indice]==null);};
}
Bueno, esta segunda clase que estudiamos tiene también un objeto interno llamado "estadoTablero"
que en este caso es un "array" cuyas posiciones son de la clase anteriormente declarada "Fichas".
También tenemos un "constructor" para el objeto "estadoTablero" que crea ese "array" con las
dimensiones que queremos.
Y en este caso hay una función que nos dice si la columna por la que nos interesamos con el
parámetro de entrada "índice" está llena.
De estos dos ejemplos de clases aún nos quedan algunos conceptos por aprender, como por ejemplo
eso del "constructor". Lo veremos con detenimiento más adelante.
Clases en Java
En si, y como he comentado anteriormente en el Manual de Java, las clases marcan la estructura básica
de un programa tanto en Java como en la programación orientada a objetos en general.
Una clase es el producto de enfocar la programación a los datos más que a las funciones. Por tanto
una clase es una colección de datos y además para operar con ellos una serie de funciones propias de
la clase. Veamos por ejemplo la clase "Fichas" definida anteriormente, su único dato es "el color" y la
única operación que permite es saber el color de la ficha en cualquier momento. Eso permite un acceso
restrictivo a los datos según la función de los mismos. En este caso la clase es así basándose en la
vida misma: No creo que nadie haya cambiado el color de una ficha jugando a las "cuatro en raya" y
en caso positivo no tendría muy buenas intenciones al hacerlo.
Además de este método básico de protección de los datos, Java permite algunos más que vemos ahora
mismo.
Cuando declaramos una clase lo primero que ponemos es la cabecera:
public class Fichas { (cuerpo de la clase) }
La primera palabra nos proporciona la posibilidad de dar permisos de accesos a nuestra clase, los
permisos son los siguientes:
"Public": Una clase "public" es accesible desde cualquier otra clase, no obstante para que esto
suceda debe ser primero accesible el "package" de esa clase "public". Para que un "package" sea
accesible debe de estar en el directorio que señala la variable "CLASSPATH" que definimos al
instalar nuestro entorno Java y, claro está, tener permiso de lectura en ese directorio.
"Package": Usar este identificador en la cabecera de la clase es opcional, pues es la opción por
defecto en java, es decir, si escribimos:
class Fichas {(Cuerpo de la clase)}
Es lo mismo que si escribimos:
package class Fichas {(Cuerpo de la clase)}
Las clases "package" ( que podemos entender como las que no son "public" ) son accesibles solo
desde su propio package.
Esto es relativo a la accesibilidad de las clases. Más conceptos relativos a la accesibilidad hacen
referencia a las variables internas de una clase que ya comentamos en un capítulo anterior, y a sus
métodos.
En cuanto al nombre de la clase consideraremos varias cosas. Debe de obedecer al convenio de

nombres de Java y coincidir con el nombre del fichero ".java" en el que se guardará la clase.
Lo normal es que cada clase vaya incluida en un único fichero pero claro está, nos puede interesar por
algún motivo meter varias clases en un único fichero. En este caso solo puede haber una clase public
que es la que dará el nombre a dicho fichero. En caso de que no hubiese una clase public el
compilador entenderá que la clase "principal" de ese fichero es la que concuerda con el nombre del
mismo, por lo que evidentemente dos clases con un mismo nombre no son permitidas en un mismo
fichero.
Por último para explicar la estructura de una clase explicaré los elementos habituales en la definición
de su cuerpo.
Primero se suelen declarar, al menos, las variables internas de esa clase y posteriormente se definen
los constructores y los métodos que dispondrá la clase. Lo entenderemos mejor más adelante
En la definición de constructores y métodos tenemos que tener en cuenta un nuevo concepto de la

programación orientada a objetos. La sobrecarga. La sobrecarga consiste en poder tener varios
métodos o constructores con el mismo nombre dentro de una misma clase y que no hagan las mismas
cosas.
Esto se consigue de una manera muy sencilla, se diferencian entre ellos mediante el número y tipo de
parámetros que reciben. Veamos un ejemplo:
/*tenemos dos métodos que pueden por ejemplo obtener el área de una figura geométrica en concreto, podrían ser:*/
float obtenerAreaCirculo(Circulo ci){

/* ... */
}
float obtenerAreaCuadrado(Cuadrado cu){

/* ... */
}
/*en Java esto se puede abreviar teniendo dos métodos sobrecargados, por ejemplo: */
float obtenerArea(Circulo ci){

/* ... */
}
float obtenerArea(Cuadrado cu){

/* ... */
}
/*A la hora de ejecutar el método obtenerArea se utilizará el que corresponda al parámetro que se le pase por
cabecera*/
Organización de las clases y uso de packages

Efectivamente vamos a necesitar organizar nuestras clases en algún momento porque nuestro
desarrollo puede ir creciendo, y tener un cúmulo de clases todas juntas en un directorio, sin ningún
tipo de organización física ni lógica, no nos ayudará demasiado.
Java nos permite con los "Packages" evitar esta situación de un modo bastante elegante y ordenado.
Un "Package" es básicamente una agrupación de clases, vemos por ejemplo que la versión 1.2 de Java
incluye un total de 59 "Packages" para organizar todo su API.
Cualquier grupo de clases se puede organizar dentro de un "package" pero evidentemente lo más
normal es que tus clases las organices por algún motivo. Las clases se suelen organizar según la
relación entre ellas. Por ejemplo si tuviésemos un grupo de clases que permiten hacer una ordenación
de elementos en un array podríamos organizarlas de este modo:
Quicksort.class; // Clase para ordenar arrays con el método quicksort

Burbuja.class; // Clase para ordenar arrays con el método de la burbuja
Seleccion.class; // Clase para ordenar arrays con el método de selección
Insercion.class; // Clase para ordenar arrays con el método de inserción directa
/* Podemos englobar estas clases en un package puesto que todas están relacionadas en su cometido. Crearemos por
tanto el "package ordenaciones" para que podamos acceder a ellas de este modo: */
ordenacion.Quicksort.class; // Ejemplo acceso a quicksort en el package ordenación
/* Igualmente podríamos tener también clases para la búsqueda de un elemento en un array en tal caso repetiríamos el
proceso y por ejemplo tendríamos el "package tratamientoArrays" de este modo: */
tratamientoArrays.ordenacion.Quicksort.class; // Ejemplo acceso a quicksort dentro del // package ordenación que a su

vez está // dentro del package tratamientoArrays.
El uso de "Packages" no solo nos permite organizar nuestras clases, sino que nos permite diferenciar
clases que siendo distintas tengan que tener el mismo nombre, es decir, ayuda a java con la resolución
de nombres.
También como hemos visto por encima anteriormente nos permite ciertas normas para controlar el
acceso a clases.
Veamos ahora como utilizar los "packages" para nuestras clases. Lo primero que tenemos que tener en
cuenta es que todas las clases que van a pertenecer a un mismo "package" tienen que estar en un
mismo directorio que debe coincidir en nombre con el nombre del "package". Vemos que por tanto el
nombre completo de una clase de un "package" equivale a su ruta desde el directorio que tomemos de
base para nuestras clases.
El directorio de base para nuestras clases es el definido por la variable de entorno CLASSPATH que
introducimos en el segundo capitulo de este manual. Veamos el ejemplo:
tratamientoArrays.ordenacion.Quicksort.class
/* Equivale al acceso a la clase que se encuentra en el directorio:
$CLASSPATH/tratamientoArrays/ordenacion/Quicksort.class */
El convenio de nombres de Java establece también que los nombres de los "packages" empiecen por
minúsculas.
En segundo lugar para utilizar los "packages" en nuestras clases tenemos que incluir al principio del
fichero de la clase (antes de cualquier otra sentencia) la linea:
Package nombreDelPackage;
Por último veamos la sentencia "import". "import" permite importar un "package" a nuestra clase Java.
Esto nos permite acceder (en caso de que sean accesibles) sin usar todo el nombre del "package" a
cualquier clase dentro de él. Veámoslo en el siguiente ejemplo:
Import tratamientoArrays.ordenación.*; //Importamos todas las clases

//del "Package" de ordenación de
//arrays que teníamos organizado.
/*tiramos líneas de código en Java hasta que... */
Quicksort arrayQuick= new Quicksort(); //... En cualquier momento de nuestra clase // podemos hacer uso de la clase
Quicksort sin
// utilizar toda la ruta del package.
Hay que tener también en cuenta que importando un "package" no importamos todos sus
"subpackages" sino solo todas las clases de ese "package". También podemos simplemente importar
solo una clase dentro de ese "package" poniendo en vez de un asterisco el nombre de la clase a
importar.
Para acabar con este punto quiero hacer un comentario acerca del API de Java. Ya os he dicho que las
clases del API de Java están organizadas en "packages" según su función. Hay "packages" preparados
para acometer las mas variadas tareas. Es ejercicio del lector informarse de que "packages" le
interesan en su desarrollo y del funcionamiento de las clases incluidas en estos. Nosotros veremos
ciertos "packages" de uso habitual durante el manual.
Como ya os comenté, en java no se empieza desde cero, tenemos un conjunto de clases que podemos
incluir en nuestro programa sin necesidad de importar ningún "package". Esas clases son las que
pertenecen al "package" Java.lang. este "package" incluye las clases básicas de Java como por
ejemplo la clase "Array" que utilizaremos muy habitualmente.
Las Clases en funcionamiento

Como dicta el titulo de este punto un objeto es precisamente eso: "Una clase en movimiento".
Podemos ver la relación entre clase y objeto de este modo.
Supongamos por ejemplo una clase llamada "Mamífero". Como en la "vida misma" tu te puedes
encontrar por la calle con "Personas", "Perros", "Gatos" ... que evidentemente pertenecen a esa clase
"Mamífero", pero no te vas a encontrar con un "Mamífero" a secas.
Más o menos esa es la relación entre clase y objeto. Una clase es una especificación de cómo debe ser
un objeto para pertenecer a esa clase y por consiguiente un objeto es un ejemplar individual de una
clase.
Tomando como ejemplo nuestra clase "Fichas" vemos que todas las fichas tienen que tener un color
como característica que la defina. Es decir, nuestros objetos "ficha" serán fichas blancas, negras, etc.
A la hora de "actuar" por tanto se hará sobre un objeto en concreto. En un objeto se puede acceder a
sus métodos y a las variables miembro que tenga, siempre claro que sean ambos declarados en la
clase como accesibles.
La accesibilidad para métodos y variables depende en primera instancia de la accesibilidad a la clase a

la que pertenecen. Si la clase nos es accesible entonces depende en segunda instancia de estas
normas:
Accesibilidad de variables y métodos: depende de los siguientes modificadores de acceso que se ponen
(o no) delante de la variable en su declaración o del método en su definición.
"public": Da accesibilidad completa a la variable, se puede ver desde la propia clase, dentro y
fuera del mismo "package" y en cualquier "subclase" de la clase en la que se declara, ya esté en
el mismo o en distinto "package".
"protected": Se puede acceder desde la propia clase, desde el mismo "package" y desde
cualquier "subclase", pero no se puede ver desde una clase de otro "package".
"private": Solo se puede acceder desde la propia clase.
"package": Es la opción por defecto (como si no se pone nada). Proporciona accesibilidad desde
el propio "package" y por tanto lógicamente desde la propia clase y además desde cualquier
subclase que esté dentro del mismo "package".
Una vez tenemos claros las normas acerca de la accesibilidad en Java, veamos unos ejemplos de
utilización de los objetos en Java.
Utilización de los objetos en Java

Lo primero que hay que hacer para utilizar un objeto es tenerlo ¿no?. Pues vamos a entender primero
cómo se crean los objetos para después pasar a utilizarlos.
Instanciación de objetos:
Para instanciar un objeto el método que se utiliza es "new". "New" crea un objeto de la clase que le
especifiquemos pero antes de esto se tiene que declarar la variable que contendrá ese nuevo objeto.
Veámoslo en nuestra clase Tablero vista anteriormente.
Fichas estadoTablero[][];
En estas dos líneas se engloba todo el mecanismo de creación de un objeto. En la primera línea se
declara una variable "estadoTablero" de la clase "array". La clase "array" es una clase utilitaria de Java
que esta incluida en "Java.lang" y por lo tanto, como ya comenté una vez y explicaré mejor mas
adelante, se encuentra disponible desde cualquier programa en Java.
En principio esta variable está vacía, no contiene ningún objeto, pero está "preparada" para contener
un objeto de la clase "array".
En la segunda línea de este código hay mas miga que comentar: Se trata de la definición de un
constructor sencillo para la clase "Tablero".
Cuando se ejecuta una sentencia "new" para crear un objeto de una clase, lo que realmente se hace es
llamar al método constructor correspondiente a esa clase. Por ejemplo si ejecutamos esta sentencia:
Tablero miTablero = New Tablero();
Estamos llamando al método anterior:
Por tanto lo que conseguimos es crear la variable interna de "Tablero", que hemos llamado
"estadoTablero" como un objeto "array" de dimensiones 6x7 que son las dimensiones de un tablero de
"cuatro en raya". Como vemos, igual que con nuestra clase tablero y cualquier otra clase, también
usamos "new" para crear el "array".
Por último, y como puedes comprobar, para definir un constructor para nuestra clase simplemente
definimos un método que como peculiaridad tiene el mismo nombre de la clase en la que se define. En
cuanto a su modificador de acceso lo normal es que sea "public", pero puede ser también "private" en
cuyo caso solo será accesible desde un método "static" de la misma clase. Ya explicaremos esto último
mejor, por ahora simplemente nos tiene que sonar.
Paso de mensajes:
Como "paso de mensajes" se entiende en programación orientada a objetos lo que siempre hemos
llamado en programación tradicional: "llamada a una función". En el fondo si nos ponemos a pensar
vemos básicamente que:
En primer lugar: Los programas "sobre el papel" son las clases.

En segundo lugar: Las clases "sobre papel" se relacionan con otras clases. Por ejemplo nuestra
clase Ficha utiliza para definir su parámetro "color" a la clase "String" propia de Java.
En tercer lugar: En la "vida real", es decir, en funcionamiento, las clases se muestran como
"objetos".
Como conclusión: Son los objetos los que colaboran y se relacionan con otros objetos, y lo hacen
mediante el "paso de mensajes".
Para ejecutar un método de una clase se utiliza esta sintaxis:
NombreDeLaClase.nombreDelMetodo(parámetros del método);
Los pasos de mensajes tienen una ventaja con respecto a las llamadas a función de los lenguajes
tradicionales. La ventaja es que siempre llevan un parámetro implícito: El objeto al que pertenece el
propio método. Lo vemos con un ejemplo muy sencillo.
Imaginamos un método y una función que simplifican una fracción pasada como parámetro. La
diferencia seria la siguiente al utilizar tanto el método como la función.
Programación tradicional:
fraccion_simp = simplifica_fraccion(fraccion);
/*fraccion_simp guarda el resultado
de aplicar la función simplifica_fraccion
al parámetro fraccion*/
Programación orientada a objetos:
ObjetoFraccion.simplificaFraccion();
/*este caso lo podríamos entender como que
simplemente le decimos a la fracción que se
simplifique a ella misma "como ella sabe" */
Como vemos en Programación orientada a objetos no se pasa como parámetro la fracción a simplificar
puesto que es el mismo objeto el que es la fracción y el que a su vez posee el método para
simplificarla de acuerdo con sus atributos internos.
Acceso a variables internas de un objeto:
Para acceder a una variable interna de un objeto esta nos tiene que ser accesible según las normas
vistas anteriormente. En caso de que si simplemente podemos acceder a ella con la siguiente sintaxis:
NombreDeLaClase.nombreDeVariableInterna;
Autores del manual:

Hay que agradecer a diversas personas la dedicación prestada para la creación de este manual. Sus
nombres junto con el número de artículos redactados por cada uno son los siguientes:
Victorino Blanco González

Forma parte del equipo DesarrolloWeb.com y MercadoProfesional.com
http://www.mercadoprofesional.com
(13 capítulos)
Todos los derechos de reproducción y difusión reservados a Guiarte Multimedia S.L.
Volver

Manual Completo Java

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Manual Completo Java

Hochgeladen von

Copyright:

Verfügbare Formate

Manual de Java - Manual completo 26/2/15 11:20

Este salto de Java para convertirse en un lenguaje de programación para computadores se da

Básicamente un programa en Java puede ejecutarse como:

Stand Alone: Aplicación independiente.

Instalar el entorno de desarrollo Java y primer programa

Una vez descargado tenemos en nuestro ordenador un archivo llamado: "j2sdk-(versión)-nb-3_6-bin-

set JAVAPATH=<directorio donde hayas instalado java>

public class Ejemplo {

Instalación de un entorno de desarrollo integrado (IDE): Eclipse.

Su instalación es muy sencilla, podemos descargárnoslo de www.eclipse.org en forma de archivo ZIP y

Después de esto nos aparecerá la ventana principal de Eclipse:

El siguiente paso es ir añadiendo nuestras clases al proyecto. Si no tienes conocimientos de

En principio y sin mas detalles le damos a "Run" y vemos los resultados:

Si desconoces o quieres recordar bases acerca de la Programación Orientada a objetos, consulta

Introducción al lenguaje JAVA

Hay tres tipos de comentarios en Java:

// Este es un comentario de una sola línea

1. Si en un identificador queremos incluir un nombre compuesto se pone el primer nombre entero en

2. Los identificadores de clases e interfaces siempre empiezan en mayúscula siguiendo la anterior

Tipos primitivos y variables en Java

Boolean: No es un valor numérico, solo admite los valores true o false.

Int a ; // declaración de una variable 'a'

Int b = 8; // declaración de una variable 'b' inicializada a 8.

NombreClase referencia2; // lo mismo que en la variable anterior.

Referencia = new NombreClase; // se crea un nuevo objeto de la clase

Referencia2 = referencia; // Ahora también 'referencia2' tiene el mismo

public class AmbitoVariables {

public static void main(String[] args) {

Operadores Aritméticos: Los habituales

'+=' : op1 += op2 à op1 = op1 + op2

NombreObjeto instanceof NombreClase

Operadores Relacionales: Permiten comparar variables según relación de igualdad/desigualdad o

'>': Mayor que

Operadores Lógicos: Nos permiten construir expresiones lógicas.

'&&' : devuelve true si ambos operandos son true.

Operador de concatenación con cadena de caracteres '+':

Por Ejemplo: System.out.println("El total es"+ result +"unidades");

'>>': desplazamiento a la derecha de los bits del operando

Estructuras de control de bifurcación en Java

Bifurcaciones: Permiten ejecutar código en función de una expresión evaluada

Tienen las siguientes posibilidades en su sintaxis:

if (i == 5){ System.out.println(" i vale 5 ");}

if (i == 5){ System.out.println(" i vale 5 ");}

Estructuras de control tipo bucle en Java

while (expresion) {sentencias}

for (inicialización, expresionBooleana, incremento) {conjuntoDeSentencias;}

for (int i= 0; i <10; i++){ System.out.println("el valor de i es: " + i); }

Sentencias Break, Continue y Return

Bloque Try ​ Catch ​ Finally

Estructura básica de un programa en Java

public class Fichas {

public class Tablero {

Cuando declaramos una clase lo primero que ponemos es la cabecera:

public class Fichas { (cuerpo de la clase) }

class Fichas {(Cuerpo de la clase)}

Es lo mismo que si escribimos:

package class Fichas {(Cuerpo de la clase)}

En cuanto al nombre de la clase consideraremos varias cosas. Debe de obedecer al convenio de

En la definición de constructores y métodos tenemos que tener en cuenta un nuevo concepto de la

float obtenerAreaCirculo(Circulo ci){

float obtenerAreaCuadrado(Cuadrado cu){

float obtenerArea(Circulo ci){

float obtenerArea(Cuadrado cu){

Bloque Try Catch Finally

/tiramos líneas de código en Java hasta que... /