Programación de juegos para móviles con J2ME Parte II

Breve introducción al lenguaje Java

En este capítulo quiero presentarte, de forma general, J2ME y encuadrarla dentro de la tecnología Java. También vamos a hacer una breve introducción al lenguaje Java, al menos en sus aspectos básicos para poder adentrarte sin problemas en la programación con J2ME.

J2EE

Cuando Sun decidió lanzar su nuevo standard Java, llamado Java2, creó tres diferentes entornos para desarrollo y ejecución de aplicaciones. Estos fueron J2SE, J2EE y J2ME.

J2SE (Java 2 Standard Edition) es, por decirlo de alguna manera, la base de la tecnología Java. Permite el desarrollo de applets (aplicaciones que se ejecutan en un navegador web) y aplicaciones independientes (standalone). J2SE es el heredero directo del Java inicial (antes de Java 2). J2EE (Java 2 Enterprise Edition) está basado en J2SE, pero añade una serie de características necesarias en entornos empresariales, relativos a redes, acceso a datos y entrada/salida que requieren mayor capacidad de proceso, almacenamiento y memoria. La decisión de separarlos es debida a que no todas estas características son necesarias para el desarrollo de aplicaciones standard.

Al igual que J2EE cubre unas necesidades más amplias que J2SE, se hace patente la necesidad de un subconjunto de J2SE para entornos más limitados. La respuesta de Sun es J2ME (Java 2 Micro Edition).

J2ME se basa en los conceptos de configuración y perfil. Una configuración describe las características mínimas en cuanto a la configuración hardware y software. La configuración que usa J2ME es la CLDC (Connected Limited Device Configuration). Concretamente CLDC define:

• Cuáles son las características del lenguaje Java incluidas.
• Qué funcionalidad será incluida en la máquina virtual Java.
• Las APIs necesarias para el desarrollo de aplicaciones en móviles.
• Los requerimientos Hardware de los dispositivos.

Debido a las limitaciones del hardware en el que correrá la máquina virtual, algunas de las características del lenguaje Java han sido recortadas. En concreto, se ha omitido el soporte de operaciones matemáticas en punto flotante, y por lo tanto, los tipos de datos que manejan esta de información. La otra gran diferencia es que la máquina virtual tampoco dará soporte al método finalize() encargado de eliminar los objetos de la memoria. También se limita el número de excepciones disponibles para el control de errores.

J2ME está formado por la configuración CLDC y por el perfil MID (conocido por MIDP o MID Profile). CLDC es una especificación general para un amplio abanico de dispositivos, que van desde PDAs a teléfonos móviles y otros. Un perfil define las características del dispositivo de forma más especifica. MIDP (Mobile Information Device Profile) define las APIs y características hardware y software necesarias para el caso concreto de los teléfono móviles. Las características concretas de la versión 1.0 y 2.0 de MIDP pueden ser consultadas en la página web de Sun (http://java.sun.com/j2me/).

El lenguaje Java

El lenguaje Java es un lenguaje completamente orientado a objetos. Todo en Java es un objeto. Durante el resto del capítulo vamos a ver las características generales del lenguaje Java (sólo las necesarias en J2ME), lo que nos permitirá entrar en el siguiente capítulo con la base necesaria para empezar a programar MIDlets. Un MIDlet es un programa capaz de correr en un dispositivo móvil. El nombre guarda cierta similitud (no casual) con los programas capaces de correr en un navegador (applets). Si quieres ampliar conocimientos sobre el lenguaje Java, puedes consultar la bibliografía en los apéndices de este libro.

Variables y Tipos de Datos

Las variables nos permiten almacenar información y tal como indica su propio nombre, pueden variar a lo largo de la ejecución del programa. Una variable se define a partir de un nombre y un tipo.

El nombre de una variable puede ser cualquiera, aunque conviene utilizar nombres claros y relacionados con el cometido de la variable. Sólo hemos de tener en cuenta algunas reglas en los nombres de variables:

• No pueden contener espacios en blanco.
• Dos variables no pueden tener el mismo nombre.
• No podemos utilizar palabras reservadas de Java.

Los programadores en Java suelen seguir una serie de convenciones a la hora de nombrar las variables. Esto facilita la lectura de código de terceros.

• Las variables comienzan con una letra minúscula.
• Si la variable está compuesta por dos o más palabras, la segunda (y las siguientes también) comienzan por letra mayúscula. Por ejemplo numeroDeVidas.
• Los nombres de las clases comienzan por letra mayúscula.

Las variables tienen asociado un tipo. El tipo de la variable define qué dato es capaz de almacenar. Los tipos de datos válidos en Java son los siguientes:

• byte. Ocho bits.
• short. Número entero de 16 bits.
• int. Número entero de 32 bits.
• long. Número entero de 64 bits.
• float. Número en punto flotante de 32 bits.
• double. Número en punto flotante de 64 bits.
• char. Carácter ASCII.
• boolean. Valor verdadero o falso.

Hay que aclarar que los tipos float y double, aún formando parte del standard Java, no están disponibles en J2ME.

Antes de poder utilizar una variable, hay que declararla, es decir, darle un nombre y un tipo. La siguiente línea declara una variable llamada vidas de tipo entero de 32 bits.

int vidas;

Una variable por sí misma no es muy útil, a no ser que podamos realizar operaciones con ellas. Estas operaciones se realizan por medio de operadores. Hay cinco tipos de operadores.

• De asignación
• Aritméticos
• Relaciónales
• Lógicos
• A nivel de bit

Cuando declaramos una variable ésta no contiene ningún valor (realmente si, tiene el valor null). Para darle un valor a la variable utilizamos el operador de asignación = (signo de igualdad). Así, para asignar el valor 3 a la variable vidas, procedemos de la siguiente forma.

vidas = 3;

Observa el punto y coma (;) al final de la línea. En Java cada instrucción acaba con un punto y coma.

Tenemos disponibles otros operadores de asignación:

Operador	Significado
a += b	a = a + b
a -= b	a = a – b
a *= b	a = a * b
a /= b	a = a / b
a %= b	a = a % b
a &= b	a = a & b
a |= b	a = a | b

Los siguientes operadores que vamos a ver son los operadores aritméticos. Hay dos tipos, los operadores unarios y los binarios. Los operadores aritméticos unarios son ++ y --. Pueden ir delante o detrás de una variable, y su misión es incrementar (o decrementar) en una unidad el valor de la variable. Si se sitúan tras la variable hablamos de postincremento (o postdecremento), es decir, la variable es incrementada (o decrementada) después de haberse hecho uso de ella. Si por el contrario va delante hablamos de preincremento (o predecremento), es decir, primero se modifica su valor y después se hace uso de la variable. Veamos un ejemplo:

nuevasVidas = ++vidas;

En este ejemplo, primero incrementamos el valor de la variable vidas, y después se lo asignamos a la variable nuevasVidas.

enemigoActual = enemigos--;

Aquí, primero asignamos a la variable enemigoActual el valor de la variable enemigos, y después decrementamos el valor de esta última variable.

El otro tipo de operadores aritméticos son los binarios.

Operador	Significado
a + b	Suma de a y b
a - b	Diferencia de a y b
a * b	Producto de a por b
a / b	Diferencia entre a y b
a % b	Resto de la división entre a y b

Los operadores relacionales nos permiten comparar dos variables o valores. Un operador relacional devuelve un valor de tipo boolean, es decir, verdadero (true) o falso (false).

Operador	Significado
a > b	true si a es mayor que b
a < b	true si a es menor que b
a >= b	true si a es mayor o igual que b
a <= b	true si a es menor o igual que b
a == b	true si a es igual que b
a != b	true si a es distinto a b

Los operadores lógicos nos permiten realizar comprobaciones lógicas del tipo Y, O y NO. Al igual que los operadores relaciones devuelven true o false.

Operador	Significado
a && b	true si a y b son verdaderos
a || b	true si a o b son verdaderos
!a	true si a es false, y false si a es true

Cuando veamos la estructura de control if() nos quedará más clara la utilidad de los operadores lógicos.

Los operadores de bits trabajan, como su propio nombre indica, a nivel de bits, es decir, permite manipularlos directamente.

Operador	Significado
a >> b	Desplaza los bits de a hacia la derecha b veces
a << b	Desplaza los bits de a hacia la izquierda b veces
a <<< b	Igual que el anterior pero sin signo
a & b	Suma lógica entre a y b
a | b	O lógico entre a y b
a ^ b	O exclusivo (xor) entre a y b
~ a	Negación lógica de a (not)

Cuando una expresión está compuesta por más de un operador, estos se aplican en un orden concreto. Este orden se llama orden de precedencia de operadores. En la siguiente tabla se muestra el orden en el que son aplicados los operadores.

Orden	Operadores
1	operadores sufijo	[] . (params) expr++ expr--
2	operadores unarios	++expr --expr +expr -expr ~ !
3	creación o tipo	new (type)expr
4	multiplicadores	* / %
5	suma/resta	+ -
6	desplazamiento	<< >> >>>
7	relacionales	< > <= >= instanceof
8>	igualdad	== !=
9	bitwise AND	&
10	bitwise exclusive OR	^
11	bitwise inclusive OR	|
12	AND lógico	&&
13	OR lógico	||
14	condicional	? :
15	asignación	= += -= *= /= %= ^= &= |= <<= >>= >>>=

Clases y Objetos

¿Qué es un objeto? Trataré de explicarlo de la forma más intuitiva posible sin entrar en demasiados formalismos. Si te pido que pienses en un objeto, seguramente pensarás en un lápiz, una mesa, unas gafas de sol, un coche o cualquier otra cosa que caiga dentro de tu radio de visión. Ésta es la idea intuitiva de objeto: algo físico y material. En POO, el concepto de objeto no es muy diferente. Una de las diferencias básicas evidentes es que un objeto en Java puede hacer referencia a algo abstracto.

Como en el ejemplo del coche, un objeto puede estar compuesto por otra clase de objeto, como rueda, carrocería, etc... Este concepto de clase de objeto es importante. Un objeto siempre pertenece a una clase de objeto. Por ejemplo, todas las ruedas, con independencia de su tamaño, pertenecen a la clase rueda. Hay muchos objetos “rueda” diferentes que pertenecen a la clase rueda y cada uno de ellos forman una instancia de la clase rueda. Tenemos, pues, instancias de la clase rueda que son ruedas de camión, ruedas de coches o ruedas de motocicleta.

Volvamos al ejemplo del coche. Vamos a definir otra clase de objeto, la clase coche. Esta clase define a “algo” que está compuesto por objetos (instancias) de la clase rueda, la clase carrocería, la clase volante, etc... Ahora vamos a crear un objeto de la clase coche, al que llamaremos coche_rojo. En este caso hemos instanciado un objeto de la clase coche y hemos definido uno de sus atributos, el color, al que hemos dado el valor de rojo. Vemos pues, que un objeto puede poseer atributos. Sobre el objeto coche podemos definir también acciones u operaciones posibles. Por ejemplo, el objeto coche, entre otras cosas, puede realizar las operaciones de acelerar, frenar, girar a la izquierda, etc... Estas operaciones que pueden ser ejecutadas sobre un objeto se llaman métodos del objeto.

Podríamos hacer ya una primera definición de lo que es un objeto. Es la instancia de una clase de objeto concreta, que está compuesta por atributos y métodos. Esta definición nos muestra una de las tres principales características que definen a la POO. Me refiero al encapsulamiento, que no es, ni más ni menos, que la capacidad que tiene un objeto de contener datos (atributos) y código (métodos).

Clases y Objetos en Java

Antes de poder crear un objeto hay que definirlo. Un objeto, tal como decíamos antes, pertenece a una clase, así que antes de crear nuestro objeto, hay que definir una clase (o utilizar una clase ya definida en las APIs de Java). La forma básica para declarar una clase en Java es.

class nombre_clase {
// variables de la clase (atributos)
...
// métodos de la clase
}

En Java, utilizamos las dos barras inclinadas (//) para indicar que lo que sigue es un comentario. Una vez definida la clase, podemos ya crear un objeto de la clase que hemos declarado. Lo hacemos así.

clase_objeto nombre_objeto;

Las variables de la clase o atributos son variables como las que vimos en la sección anterior.

Los métodos, son similares a las funciones de otros lenguajes. La declaración de un método tiene la siguiente forma.

tipo NombreMetodo(tipo arg1, tipo arg2, ...) {
// cuerpo del método (código)

}

El método tiene un tipo de retorno (tipo que devuelve al ser llamado). También tiene una lista de argumentos o parámetros.

Vamos a clarificar lo visto hasta ahora con un ejemplo.

class Coche {
 // variables de clase
 int velocidad;

 // métodos de la clase
 void acelerar(int nuevaVelocidad) {
  velocidad = nuevaVelocidad;
 }

 void frenar() {
  velocidad = 0;
 }
}

Hemos declarado la clase coche, que tiene un sólo atributo, la velocidad, y dos métodos, uno para acelerar y otro para frenar. En el método acelerar, simplemente recibimos como parámetro una nueva velocidad, y actualizamos este atributo con el nuevo valor. En el caso del método frenar, ponemos la velocidad a 0. Veamos ahora cómo declaramos un objeto de tipo coche y cómo utilizar sus métodos.

// declaración del objeto
Coche miCoche = new Coche();

// acelerar hasta 100 km/h 
miCoche.acelerar(100);

// frenar
miCoche.frenar();

En primer lugar, hemos creado el objeto miCoche que pertenece a la clase Coche mediante el operador new. Después, podemos acceder tanto a los métodos como a las variables miembro usando su nombre precedido de un punto y el nombre del objeto. También podríamos haber accedido a la variable miembro: miCoche.velocidad = 100; Ésta no es una práctica aconsejable. Lo óptimo es que la clase ofrezca los métodos necesarios para acceder a las variables miembro para tener así control sobre el acceso a los atributos. No queremos que nadie haga algo como miCoche.velocidad = 1200; sin que podamos controlarlo.

Si nuestro método tiene algún tipo de retorno, quiere decir que ha de devolver un valor de dicho tipo. Esto se hace mediante la palabra reservada return.

return vidas;

Esta línea al final del método devuelve el valor de la variable vidas.

Hay un tipo especial de método que se llama constructor. Un constructor es un método que se llama exactamente igual que la clase a la que pertenece. Cuando creamos un objeto con new, el método constructor es ejecutado de forma automática.

Hay cuatro tipos de modificadores que permiten especificar qué tipo de clase estamos declarando. Los tipos de modificadores son los siguientes.

• abstract. Una clase abstract tiene al menos un método abstracto. Una clase abstracta sólo puede ser heredada para implementar los métodos abstractos que contiene. En ningún caso podemos instanciar un objeto de este tipo.
• final. Una clase final no puede ser heredada por ninguna otra.
• public. Una clase public puede ser accedida por otras clases pertenecientes al mismo paquete, o por cualquier otra siempre que sea importada o heredada.
• synchronizable. Significa que esta clase sólo puede ser accedida por un sólo thread a la vez. Se utiliza en aplicaciones multihebra para asegurar que no hay problemas de sincronización entre hilos.

Al igual que tenemos modificadores para las clases, también tenemos modificadores de acceso a las variables miembro y a los métodos.

• public. Se puede acceder desde fuera de la clase a la que pertenece.
• protected. Sólo las subclases pueden acceder a este miembro de la clase.
• private. Sólo se puede acceder a la variable o al método desde el interior de la clase.
• friendly. Es la opción por defecto si no se especifica nada. Permite sólo el acceso desde las clases pertenecientes al mismo paquete.

Un paquete nos permite agrupar clases bajo un nombre común, por ejemplo, si hiciéramos una librería capaz de manejar gráficos, tendríamos un montón de clases encargadas de manejar el color, píxeles, imágenes, etc... Tiene lógica agrupar todas estas clases dentro de un paquete. Cuando creamos un paquete, las clases que están incluidas se almacenan en un mismo directorio con el nombre del paquete. Indicamos que una clase pertenece a un paquete concreto mediante la palabra reservada package al principio del archivo fuente.

package nombre_paquete;

Si quisiéramos utilizar este paquete que acabamos de crear, hay que importarlo. Para ello utilizamos la palabra reservada import.

import nombre_paquete; 

J2ME dispone de multitud de paquetes, por ejemplo, si queremos utilizar el interfaz de usuario propio de J2ME, debemos importar el paquete lcdui.

import javax.microedition.lcdui.*; 

El punto se utiliza para indicar la jerarquía de paquetes, es decir, la jerarquía de directorios donde están almacenadas las clases. El asterisco indica que deben importarse todas las clases pertenecientes al paquete.

Herencia

No sé de color tienes los ojos, pero puedo asegurar que del mismo color que alguno de tus ascendientes. Este mecanismo biológico fue descrito por Mendel (armado con una buena dosis de paciencia y una gran cantidad de guisantes) y se llama herencia. La herencia se transmite de padres a hijos, nunca al revés. En Java la herencia funciona igual, es decir, en un sólo sentido. Mediante la herencia, una clase hija (llamada subclase) hereda los atributos y los métodos de su clase padre.

Imaginemos -volviendo al ejemplo del coche- que queremos crear una clase llamada CochePolicia, que además de acelerar y frenar pueda activar y desactivar una sirena. Podríamos crear una clase nueva llamada CochePolicia con los atributos y clases necesarios tanto para frenar y acelerar como para activar y desactivar la sirena. En lugar de eso, vamos a aprovechar que ya tenemos una clase llamada Coche y que ya contiene algunas de las funcionalidades que queremos incluir en CochePolicia. Veámoslo sobre un ejemplo.

Class CochePolicia extends Coche {

 // variables
 int sirena;

 // métodos
 void sirenaOn() { 
   sirena=1; 
 }
 void sirenaOff() { 
   sirena=0; 
 }
}

Lo primero que nos llama la atención de la declaración de la clase es su primera línea. Tras el nombre de la clase hemos añadido la palabra extends seguido de la clase padre, es decir, de la cual heredamos los métodos y atributos. La clase CochePolicia posee dos atributos, velocidad, que ha sido heredado y sirena, que ha sido declarada dentro de la clase CochePolicia. Con los métodos sucede exactamente igual. La clase hija ha heredado acelerar() y frenar(), además le hemos añadido los métodos sirenaOn() y sirenaOff(). Un objeto instancia de CochePolicia puede utilizar sin ningún problema los métodos acelerar() y frenar() tal y como hacíamos con los objetos instanciados de la clase Coche.

No es posible heredar de dos o más clases a la vez (al contrario que en C++). Esto se llama herencia múltiple, y suele conllevar más problemas que ventajas, así que los diseñadores de Java prefirieron no incluir esta característica.

Polimorfismo

El polimorfismo es otra de las grandes característica de la POO. La palabra polimorfismo deriva de poli (múltiples) y del término griego morfos (forma). Es decir, múltiples formas.

Supongamos que queremos dotar al método frenar de más funcionalidad. Queremos que nos permita reducir hasta la velocidad que queramos. Para ello le pasaremos como parámetro la velocidad, pero también sería útil que frenara completamente si no le pasamos ningún parámetro. El siguiente código cumple estos requisitos.

// Declaración de la clase coche
class Coche {
 // Atributos de la clase coche
int velocidad;

 // Métodos de la clase coche
 void acelerar(int velocidad);
 void frenar() {
 // Ponemos a 0 el valor del atributo velocidad
 velocidad = 0;
}
 void frenar(int velocidad) {
 // Reducimos la velocidad
  if (velocidad < this.velocidad)
this.velocidad = velocidad;

 }
}

Como ves tenemos dos métodos frenar. Cuando llamemos al método frenar(), Java sabrá cual tiene que ejecutar dependiendo de si lo llamamos con un parámetro de tipo entero o sin parámetros. Esto que hemos hecho se llama sobrecarga de métodos. Podemos crear tantas versiones diferentes del método siempre y cuando sean diferentes. El constructor de una clase también puede ser sobrecargado. En el ejemplo, encontramos la palabra reservada this. Ésta se utiliza para indicar que a la variable que nos referimos es la de la clase, y no la que se ha pasado como parámetro. Hay que hacer esta distinción, ya que tienen el mismo nombre.

Estructuras de control

Las estructuras de control de Java son similares a las de C. Tenemos las estructuras de control condicionales y repetitivas clásicas de la programación estructurada.

La estructura de control más básica es if/else, que tiene la siguiente forma:

if (condición) {
 sentencias;
} else {
 sentencias;
}

Mediante esta estructura condicional, podemos ejecutar un código u otro dependiendo de si se cumple una condición concreta. La segunda parte de la estructura (else) es opcional. Las siguientes líneas muestran un ejemplo de uso de la estructura if/else.

if (vidas == 0) {
 terminar = true;
} else {
 vidas--;
}

En este ejemplo, si la variable vidas vale 0, la variable terminar tomará el valor true. En otro caso, se decrementa el valor de la variable vidas.

La otra estructura condicional es switch, que permite un control condicional múltiple. Tiene el formato siguiente.

switch (expresión) {
 case val1:
  sentencias;
  break;
 case val2:
  sentencias;
  break;
 case valN:
  sentencias;
  break;
 default:
  sentencias;
  break;
}

Dependiendo del valor que tome la expresión, se ejecutará un código determinado por la palabra reservada case. Observa como al final de las sentencias se incluye la palabra reservada break, que hace que no se siga ejecutando el código perteneciente al siguiente bloque. Si el valor de la expresión no coincide con ninguno de los bloques, se ejecuta el bloque default. Lo veremos mejor con un ejemplo.

switch (posicion) {
 case 1:
  medalla = “oro”;
  break;
 case 2:
  medalla = “plata”;
  break;
 case 3:
  medalla = “bronce”;
  break;
 default:
  medalla = “sin medalla”;
  break;
}

Las estructuras que hemos visto hasta ahora nos permiten tomar decisiones. Las siguientes que vamos a ver nos van a permitir realizar acciones repetitivas. Son los llamados bucles. El bucle más sencillo es el bucle for.

for (inicialización_contador ; control ; incremento) {
 sentencias;
}

Este bucle ejecuta el bloque de sentencias un número determinado de veces.

[
for (i=1 ; i<=10 ; i++) {
 suma+=i;
}

Este ejemplo de código suma los 10 primero números. La variable i lleva la cuenta, es decir, es el contador del bucle. En la primera sección nos encargamos de inicializar la variable con el valor 1. La segunda sección es la condición que ha de darse para que se continúe la ejecución del bucle, en este caso, mientras i sea menor o igual a 10, se estará ejecutando el bucle. La tercera sección es la encargada de incrementar la variable en cada vuelta.

El siguiente bucle que te voy a presentar es el bucle while y tiene la siguiente estructura.

while (condición) {
 sentencias;
}

El bloque de sentencias se ejecutará mientras se cumpla la condición del bucle.

vueltas = 10;
while (vueltas > 0) {
 vueltas--;
}

A la entrada del bucle, la variable vueltas tiene el valor 10. Mientras el valor de esta variable sea mayor que 0, se va a repetir el bloque de código que contiene. En este caso, el bloque de código se encarga de decrementar la variable vuelta, por lo que cuando su valor llegue a 0, no volverá a ejecutarse. Lo que estamos haciendo es simular un bucle for que se ejecuta 10 veces.

El bucle do/while funciona de forma similar al anterior, pero hace la comprobación a la salida del bucle.

do {
 sentencias;
} while (condición);

El siguiente ejemplo, es igual que el anterior. La diferencia entre ambos es que con el bucle do/while, el código se ejecutará siempre al menos una vez, ya que la comprobación se hace al final, mientras que con el bucle while, es posible que nunca se ejecute el código interno si no se cumple la condición.

vueltas = 10;
do {
 vueltas--;
} while(vueltas > 0);

Veamos una última estructura propia de Java (no existe en C) y que nos permite ejecutar un código de forma controlada. Concretamente nos permite tomar acciones específicas en caso de error de ejecución en el código.

try {
 sentencias;
} catch (excepción) {
 sentencias;
}

Si el código incluido en el primer bloque de código produce algún tipo de excepción, se ejecutará el código contenido en el segundo bloque de código. Una excepción es un tipo de error que Java es capaz de controlar por decirlo de una forma sencilla, realmente, una excepción es un objeto de la clase Exception. Si por ejemplo, dentro del primer bloque de código intentamos leer un archivo, y no se encuentra en la carpeta especificada, el método encargado de abrir el archivo lanzará una excepción del tipo IOException.

Estructuras de datos

Ya hemos visto los tipos de datos que soporta Java. Ahora vamos a ver un par de estructuras muy útiles. Concretamente la cadena de caracteres y los arrays.

Una cadena de caracteres es una sucesión de caracteres continuos. Van encerrados siempre entre comillas. Por ejemplo:

“En un lugar de La Mancha...”

Es una cadena de caracteres. Para almacenar una cadena, Java dispone del tipo String.

String texto;

Una vez declarada la variable, para asignarle un valor, lo hacemos de la forma habitual.

texto = “Esto es un texto”;

Podemos concatenar dos cadenas utilizando el operador +. También podemos concatenar una cadena y un tipo de datos distinto. La conversión a cadena se hace de forma automática.

String texto;
int vidas;

texto = “Vidas:” + vidas;

Podemos conocer la longitud de una variable de tipo String (realmente un objeto de tipo String) haciendo uso de su método lenght.

longitud = texto.lenght();

El otro tipo de datos que veremos a continuación es el array. Un array nos permite almacenar varios elementos de un mismo tipo bajo el mismo nombre. Imagina un juego multijugador en el que pueden participar cinco jugadores a la vez. Cada uno llevará su propio contador de vidas. Mediante un array de 5 elementos de tipo entero (int) podemos almacenar estos datos. La declaración de un array se hace así.

public int[] vidas;
vidas = new int[5];

o directamente:

public int[] vidas = new int[5]; 

Hemos declarado un array de cinco elementos llamado vidas formado por cinco números enteros. Si quisiéramos acceder, por ejemplo, al tercer elemento del array, lo haríamos de la siguiente manera.

v = vidas[3];

La variable v tomará el valor del tercer elemento del array. La asignación de un valor es exactamente igual a la de cualquier variable.

vidas[3] -= 1;

El siguiente ejemplo muestra el uso de los arrays.

tmp = 0;
for (i=1 ; i<=puntos.lenght ; i++) {
 if (tmp < puntos[i]) {
  tmp = puntos[i];
 }
}

record = tmp;

En este ejemplo, el bucle for recorre todos los elementos del array puntos que contiene los puntos de cada jugador (el método lenght nos devuelve el número de elementos el array). Al finalizar el bucle, la variable tmp contendrá el valor de la puntuación más alta.