Programación

Cuando se programa en Java, se coloca todo el código en métodos, de la misma forma

que se escriben funciones en lenguajes como C.

Comentarios
En Java hay tres tipos de comentarios:

// comentarios para una sola línea

/* comentarios de una o
más líneas
*/

/** comentario de documentación, de una o más líneas

*/

Los dos primeros tipos de comentarios son los que todo programador conoce y se
utilizan del mismo modo. Los comentarios de documentación, colocados
inmediatamente antes de una declaración (de variable o función), indican que ese
comentario ha de ser colocado en la documentación que se genera automáticamente
cuando se utiliza la herramienta de Java, javadoc. Dichos comentarios sirven como
descripción del elemento declarado permitiendo generar una documentación de nuestras
clases escrita al mismo tiempo que se genera el código.

En este tipo de comentario para documentación, se permite la introducción de algunos

tokens o palabras clave, que harán que la información que les sigue aparezca de forma
diferente al resto en la documentación.

Identificadores
Los identificadores nombran variables, funciones, clases y objetos; cualquier cosa que el
programador necesite identificar o usar.

En Java, un identificador comienza con una letra, un subrayado (_) o un símbolo de

dólar ($). Los siguientes caracteres pueden ser letras o dígitos. Se distinguen las
mayúsculas de las minúsculas y no hay longitud máxima.

Serían identificadores válidos:

identificador
nombre_usuario
Nombre_Usuario
_variable_del_sistema
$transaccion

y su uso sería, por ejemplo:

int contador_principal;
char _lista_de_ficheros;
float $cantidad_en_Ptas;
Palabras clave
Las siguientes son las palabras clave que están definidas en Java y que no se pueden
utilizar como indentificadores:

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

Palabras Reservadas
Además, el lenguaje se reserva unas cuantas palabras más, pero que hasta ahora no
tienen un cometido específico. Son:

cast future generic inner

operator outer rest var

Literales
Un valor constante en Java se crea utilizando una representación literal de él. Java utiliza
cinco tipos de elementos: enteros, reales en coma flotante, booleanos, caracteres y
cadenas, que se pueden poner en cualquier lugar del código fuente de Java. Cada uno de
estos literales tiene un tipo correspondiente asociado con él.

Enteros:

byte 8 bits complemento a dos

short 16 bits complemento a dos
int 32 bits complemento a dos
long 64 bits complemento a dos
Por ejemplo: 21 077 0xDC00

Reales en coma flotante:

float 32 bits IEEE 754

double 64 bits IEEE 754
Por ejemplo: 3.14 2e12 3.1E12

Booleanos:

true
false

Caracteres:

Por ejemplo: a t u????

[????] es un número unicode
Cadenas:

Por ejemplo: "Esto es una cadena literal"

Arrays
Se pueden declarar en Java arrays de cualquier tipo:

char s[];
int iArray[];

Incluso se pueden construir arrays de arrays:

int tabla[][] = new int[4][5];

Los límites de los arrays se comprueban en tiempo de ejecución para evitar

desbordamientos y la corrupción de memoria.

En Java un array es realmente un objeto, porque tiene redefinido el operador []. Tiene
una función miembro: length. Se puede utilizar este método para conocer la longitud de
cualquier array.

int a[][] = new int[10][3];

a.length; /* 10 */
a[0].length; /* 3 */

Para crear un array en Java hay dos métodos básicos. Crear un array vacío:

int lista[] = new int[50];

o se puede crear ya el array con sus valores iniciales:

String nombres[] = {
"Juan","Pepe","Pedro","Maria"
};

Esto que es equivalente a:

String nombres[];
nombres = new String[4];
nombres[0] = new String( "Juan" );
nombres[1] = new String( "Pepe" );
nombres[2] = new String( "Pedro" );
nombres[3] = new String( "Maria" );

No se pueden crear arrays estáticos en tiempo de compilación:

int lista[50]; // generará un error en tiempo de compilación

Tampoco se puede rellenar un array sin declarar el tamaño con el operador new:

int lista[];
for( int i=0; i < 9; i++ )
lista[i] = i;

Es decir, todos los arrays en Java son estáticos. Para convertir un array en el equivalente
a un array dinámico en C/C++, se usa la clase vector, que permite operaciones de
inserción, borrado, etc. en el array.

Operadores
Los operadores de Java son muy parecidos en estilo y funcionamiento a los de C. En la
siguiente tabla aparecen los operadores que se utilizan en Java, por orden de
precedencia:

. [] ()
++ --
! ~ instanceof
* / %
+ -
<< >> >>>
< > <= >= == !=
& ^ |
&& ||
? :
= op= (*= /= %= += -= etc.) ,

Los operadores numéricos se comportan como esperamos:

int + int = int

Los operadores relacionales devuelven un valor booleano.

Para las cadenas, se pueden utilizar los operadores relacionales para comparaciones
además de + y += para la concatenación:

String nombre = "nombre" + "Apellido";

El operador = siempre hace copias de objetos, marcando los antiguos para borrarlos, y ya
se encargará el garbage collector de devolver al sistema la memoria ocupada por el
objeto eliminado.

Separadores
Sólo hay un par de secuencias con otros caracteres que pueden aparecer en el código
Java; son los separadores simples, que van a definir la forma y función del código. Los
separadores admitidos en Java son:

() - paréntesis. Para contener listas de parámetros en la definición y llamada a métodos.

También se utiliza para definir precedencia en expresiones, contener expresiones para
control de flujo y rodear las conversiones de tipo.

{} - llaves. Para contener los valores de matrices inicializadas automáticamente.

También se utiliza para definir un bloque de código, para clases, métodos y ámbitos
locales.

[] - corchetes. Para declarar tipos matriz. También se utiliza cuando se referencian

valores de matriz.

; - punto y coma. Separa sentencias.

, - coma. Separa identificadores consecutivos en una declaración de variables. También

se utiliza para encadenar sentencias dentro de una sentencia for.

. - punto. Para separar nombres de paquete de subpaquetes y clases. También se utiliza

para separar una variable o método de una variable de referencia.

Control de
Flujo
Muchas de las sentencias de control del flujo del programa se han tomado del C:

Sentencias de Salto

if/else

if( Boolean ) {
sentencias;
}
else {
sentencias;
}

switch

switch( expr1 ) {
case expr2:
sentencias;
break;
case expr3:
sentencias;
break;
default:
sentencias;
break;
}

Sentencias de Bucle

Bucles for

for( expr1 inicio; expr2 test; expr3 incremento ) {

sentencias;
}
El siguiente trocito de código Java que dibuja varias líneas en pantalla alternando sus
colores entre rojo, azul y verde. Este fragmento sería parte de una función Java
(método):

int contador;
for( contador=1; contador <= 12; contador++ ) {
switch( contador % 3 ) {
case 0:
setColor( Color.red );
break;
case 1:
setColor( Color.blue );
break;
case 2:
setColor( Color.green );
break;
}
g.drawLine( 10,contador*10,80,contador*10 );
}

También se soporta el operador coma (,) en los bucles for

for( a=0,b=0; a < 7; a++,b+=2 )

Bucles while

while( Boolean ) {
sentencias;
}

Bucles do/while

do {
sentencias;
}while( Boolean );

Excepciones

try-catch-throw

try {
sentencias;
} catch( Exception ) {
sentencias;
}

Java implementa excepciones para facilitar la construcción de código robusto. Cuando

ocurre un error en un programa, el código que encuentra el error lanza una excepción,
que se puede capturar y recuperarse de ella. Java proporciona muchas excepciones
predefinidas.

Control General del Flujo

 break [etiqueta]
continue [etiqueta]
return expr;
etiqueta: sentencia;

En caso de que nos encontremos con bucles anidados, se permite el uso de etiquetas para
poder salirse de ellos, por ejemplo:

uno: for( )
{
dos: for( )
{
continue; // seguiría en el bucle interno
continue uno; // seguiría en el bucle principal
break uno; // se saldría del bucle principal
}
}

En el código de una función siempre hay que ser consecuentes con la declaración que se
haya hecho de ella. Por ejemplo, si se declara una función para que devuelva un entero,
es imprescindible que se coloque un return final para salir de esa función,
independientemente de que haya otros en medio del código que también provoquen la
salida de la función. En caso de no hacerlo se generará un Warning, y el código Java no
se puede compilar con Warnings.

int func()
{
if( a == 0 )
return 1;
return 0; // es imprescindible porque se retorna un entero
}

Clases
Las clases son lo más simple de Java. Todo en Java forma parte de una clase, es una
clase o describe como funciona una clase. El conocimiento de las clases es fundamental
para poder entender los programas Java.

Todas las acciones de los programas Java se colocan dentro del bloque de una clase o un
objeto. Todos los métodos se definen dentro del bloque de la clase, Java no soporta
funciones o variables globales. Esto puede despistar a los programadores de C++, que
pueden definir métodos fuera del bloque de la clase, pero esta posibilidad es más un
intento de no separarse mucho y ser compatible con C, que un buen diseño orientado a
objetos. Así pues, el esqueleto de cualquier aplicación Java se basa en la definición de
una clase.

Todos los datos básicos, como los enteros, se deben declarar en las clases antes de hacer
uso de ellos. En C la unidad fundamental son los ficheros con código fuente, en Java son
las clases. De hecho son pocas las sentencias que se pueden colocar fuera del bloque de
una clase. La palabra clave import (equivalente al #include) puede colocarse al principio
de un fichero, fuera del bloque de la clase. Sin embargo, el compilador reemplazará esa
sentencia con el contenido del fichero que se indique, que consistirá, como es de
suponer, en más clases.

Tipos de Clases

Hasta ahora sólo se ha utilizado la palabra clave public para calificar el nombre de las
clases que hemos visto, pero hay tres modificadores más. Los tipos de clases que
podemos definir son:

abstract

Una clase abstract tiene al menos un método abstracto. Una clase abstracta no se
instancia, sino que se utiliza como clase base para la herencia.

final

Una clase final se declara como la clase que termina una cadena de herencia. No se
puede heredar de una clase final. Por ejemplo, la clase Math es una clase final.

public

Las clases public son accesibles desde otras clases, bien sea directamente o por herencia.
Son accesibles dentro del mismo paquete en el que se han declarado. Para acceder desde
otros paquetes, primero tienen que ser importadas.

synchronizable

Este modificador especifica que todos los métodos definidos en la clase son
sincronizados, es decir, que no se puede acceder al mismo tiempo a ellos desde distintos
threads; el sistema se encarga de colocar los flags necesarios para evitarlo. Este
mecanismo hace que desde threads diferentes se puedan modificar las mismas variables
sin que haya problemas de que se sobreescriban.

Variables y Métodos de
Instancia
 

Una clase en Java puede contener variables y métodos. Las variables pueden ser tipos
primitivos como int, char, etc. Los métodos son funciones.

Por ejemplo, en el siguiente trozo de código podemos observarlo:

public MiClase {
int i;
public MiClase() {
i = 10;
}
public void Suma_a_i( int j ) {
i = i + j;
}
}

La clase MiClase contiene una variable (i) y dos métodos, MiClase que es el constructor
de la clase y Suma_a_i( int j ).

Ambito de una variable

Los bloques de sentencias compuestas en Java se delimitan con dos llaves. Las variables
de Java sólo son válidas desde el punto donde están declaradas hasta el final de la
sentencia compuesta que la engloba. Se pueden anidar estas sentencias compuestas, y
cada una puede contener su propio conjunto de declaraciones de variables locales. Sin
embargo, no se puede declarar una variable con el mismo nombre que una de ámbito
exterior.

El siguiente ejemplo intenta declarar dos variables separadas con el mismo nombre. En
C y C++ son distintas, porque están declaradas dentro de ámbitos diferentes. En Java,
esto es ilegal.

Class Ambito {
int i = 1; // ámbito exterior
{ // crea un nuevo ámbito
int i = 2; // error de compilación
}
}

Métodos y Constructores
Los métodos son funciones que pueden ser llamadas dentro de la clase o por otras clases.
El constructor es un tipo específico de método que siempre tiene el mismo nombre que
la clase.

Cuando se declara una clase en Java, se pueden declarar uno o más constructores
opcionales que realizan la inicialización cuando se instancia (se crea una ocurrencia) un
objeto de dicha clase.

Utilizando el código de ejemplo anterior, cuando se crea una nueva instancia de

MiClase, se crean (instancian) todos los métodos y variables, y se llama al constructor de
la clase:

MiClase mc;
mc = new MiClase();

La palabra clave new se usa para crear una instancia de la clase. Antes de ser instanciada
con new no consume memoria, simplemente es una declaración de tipo. Después de ser
instanciado un nuevo objeto mc, el valor de i en el objeto mc será igual a 10. Se puede
referenciar la variable (de instancia) i con el nombre del objeto:

mc.i++; // incrementa la instancia de i de mc

Al tener mc todas las variables y métodos de MiClase, se puede usar la primera sintaxis
para llamar al método Suma_a_i() utilizando el nuevo nombre de clase mc:
 mc.Suma_a_i( 10 );

y ahora la variable mc.i vale 21.

Finalizadores

Java no utiliza destructores (al contrario que C++) ya que tiene una forma de recoger
automáticamente todos los objetos que se salen del alcance. No obstante proporciona un
método que, cuando se especifique en el código de la clase, el reciclador de memoria
(garbage collector) llamará:

// Cierra el canal cuando este objeto es reciclado

protected void finalize() {
close();
}

Alcance de Objetos y Reciclado de

Memoria
 

Los objetos tienen un tiempo de vida y consumen recursos durante el mismo. Cuando un
objeto no se va a utilizar más, debería liberar el espacio que ocupaba en la memoria de
forma que las aplicaciones no la agoten (especialmente las grandes).

En Java, la recolección y liberación de memoria es responsabilidad de un thread llamado

automatic garbage collector (recolector automático de basura). Este thread monitoriza el
alcance de los objetos y marca los objetos que se han salido de alcance. Veamos un
ejemplo:

String s; // no se ha asignado todavia

s = new String( "abc" ); // memoria asignada
s = "def"; // se ha asignado nueva memoria
// (nuevo objeto)

Más adelante veremos en detalle la clase String , pero una breve descripción de lo que
hace esto es; crear un objeto String y rellenarlo con los caracteres "abc" y crear otro
(nuevo) String y colocarle los caracteres "def".

En esencia se crean dos objetos:

Objeto String "abc"

Objeto String "def"

Al final de la tercera sentencia, el primer objeto creado de nombre s que contiene "abc"
se ha salido de alcance. No hay forma de acceder a él. Ahora se tiene un nuevo objeto
llamado s y contiene "def". Es marcado y eliminado en la siguiente iteración del thread
reciclador de memoria.
Herencia
 La Herencia es el mecanismo por el que se crean nuevos objetos definidos en términos
de objetos ya existentes. Por ejemplo, si se tiene la clase Ave, se puede crear la subclase
Pato, que es una especialización de Ave.

class Pato extends Ave {

int numero_de_patas;
}

La palabra clave extends se usa para generar una subclase (especialización) de un objeto.
Una Pato es una subclase de Ave. Cualquier cosa que contenga la definición de Ave será
copiada a la clase Pato, además, en Pato se pueden definir sus propios métodos y
variables de instancia. Se dice que Pato deriva o hereda de Ave.

Además, se pueden sustituir los métodos proporcionados por la clase base. Utilizando
nuestro anterior ejemplo de MiClase, aquí hay un ejemplo de una clase derivada
sustituyendo a la función Suma_a_i() :

import MiClase;
public class MiNuevaClase extends MiClase {
public void Suma_a_i( int j ) {
i = i + ( j/2 );
}
}

Ahora cuando se crea una instancia de MiNuevaClase, el valor de i también se inicializa

a 10, pero la llamada al método Suma_a_i() produce un resultado diferente:

MiNuevaClase mnc;
mnc = new MiNuevaClase();
mnc.Suma_a_i( 10 );
En Java no se puede hacer herencia múltiple. Por ejemplo, de la clase aparato con motor
y de la clase animal no se puede derivar nada, sería como obtener el objeto toro
mecánico a partir de una máquina motorizada (aparato con motor) y un toro (aminal).
En realidad, lo que se pretende es copiar los métodos, es decir, pasar la funcionalidad del
toro de verdad al toro mecánico, con lo cual no sería necesaria la herencia múltiple sino
simplemente la compartición de funcionalidad que se encuentra implementada en Java a
través de interfaces .

Control de
Acceso
Cuando se crea una nueva clase en Java, se puede especificar el nivel de acceso que se
quiere para las variables de instancia y los métodos definidos en la clase:

public
public void CualquieraPuedeAcceder(){}
Cualquier clase desde cualquier lugar puede acceder a las variables y métodos de
instacia públicos.

protected

protected void SoloSubClases(){}

Sólo las subclases de la clase y nadie más puede acceder a las variables y métodos de
instancia protegidos.

private

private String NumeroDelCarnetDeIdentidad;

Las variables y métodos de instancia privados sólo pueden ser accedidos desde dentro de
la clase. No son accesibles desde las subclases.

friendly (sin declaración específica)

void MetodoDeMiPaquete(){}
Por defecto, si no se especifica el control de acceso, las variables y métodos de instancia
se declaran friendly (amigas), lo que significa que son accesibles por todos los objetos
dentro del mismo paquete, pero no por los externos al paquete. Es lo mismo que
protected.

Los métodos protegidos (protected) pueden ser vistos por las clases derivadas, como en
C++, y también, en Java, por los paquetes (packages). Todas las clases de un paquete
pueden ver los métodos protegidos de ese paquete. Para evitarlo, se deben declarar como
private protected , lo que hace que ya funcione como en C++ en donde sólo se puede
acceder a las variables y métodos protegidos de las clases derivadas.