lopezatienza.com

TEMA5. Datos, operadores, variables en Java

En esta Unidad Didáctica se pretende introducir los primeros principios de programación básicos en Java: tipos de datos, operadores, identificadores, variables...

1. Palabras clave
2. Tipos de datos
3. Operadores
4. Identificadores
5. Variables y constantes literales
6. Cadenas
7. Paquetes
8. El tipo void
9. Arrays
10. El método main
11. Entrada y Salida
12. Clases envoltorio

1. Palabras clave

Veamos una lista de las palabras claves existentes en Java:

abstract	boolean	break	byte	byvalue	case	cast	catch
char	class	const	continue	default	do	double	else
extends	final	finally	float	for	future	generic	goto
if	implements	import	inner	instanceof	int	interface	long
native	new	operator	outer	package	private	protected	public
rest	return	short	static	super	switch	synchronized	this
throw	throws	transient	try	var	void	volatile	while

La tabla anterior contiene algunas palabras que se ignorarían o generarían errores de compilación. Estas palabras son: byvalue, cast, const, future, generic, goto, inner, operator, outer, rest y var. Por el momento, no tienen utilidad y están reservadas para proporcionar una mejor detección de errores durante la compilación.

2. Tipos de datos

Java es un lenguaje sencillo y con pocos tipos de datos, lo cual no implica que no sea potente, de hecho, es un lenguaje moderno con el que podemos crear prácticamente cualquier tipo de aplicación que se necesite.

Los tipos de datos se pueden clasificar en dos categorías: los tipos primitivos y los tipos de referencia.

Los tipos primitivos son, al igual que en otros lenguajes, los tipos básicos y no constituyen objetos propiamente dichos. Entre ellos están los tipos byte, short, int, long, char, float, double y boolean. A su vez pueden clasificarse en tipos enteros (byte, short, int, long y char), tipos de coma flotante (float y double) y tipos lógicos (boolean).

Los tipos de referencia se usan para hacer referencia a los objetos. Existen tres tipos: las referencias de objeto, las referencias de interfaz y las matrices.

Tipos primitivos enteros

Se usan para almacenar números enteros. Todos los tipos enteros tienen signo y se representan en complemento a dos, excepto el tipo char, que es un entero sin signo de 16 bits y se usa para representar caracteres Unicode.

Tipo	Tamaño (bits)	Rango	Clase asociada
byte	8	-128 a 127	java.lang.Byte
short	16	-32.768 a 32.767	java.lang.Short
int	32	-2.147.483.648 a 2.147.483.647	java.lang.Integer
long	64	-9.223.372.036.854.775.808 a 9.223.372.036.854.775.808	java.lang.Long
char	16	0 a 65.536	Java.lang.Character

Tipos primitivos de coma flotante

Existen sólo dos tipos: float y double, y la diferencia está en los rangos de valores que pueden almacenar.

Tipo	Tamaño (bits)	Clase asociada
float	32	java.lang.Float
double	64	java.lang.Double

El tipo primitivo boolean

Sólo existe un tipo y puede tomar los valores “true” (verdadero) y “false” (falso). Al contrario que en otros lenguajes, por ejemplo en C, no podemos usar los valores enteros en expresiones que requieran valores booleanos.

Tipos de referencias

Los tipos de referencia se emplean para hacer referencia a objetos, interfaces implementadas y matrices.

Una referencia es esencialmente un puntero a un objeto, pero, a diferencia de los punteros que conocemos en los lenguajes tradicionales, no podemos obtener el valor al que apunta el puntero, sino que es el propio Java el que se encarga de obtener el objeto.

Cuando definimos una variable de un tipo referencia, lo que estamos haciendo es permitir que dicha variable apunte a instancias de dicha clase, es decir, objetos de dicho tipo. Cuando declaramos una variable de ese tipo y no la inicializamos, tomará el valor constante null.

3. Operadores

Son símbolos que se utilizan en algunas expresiones para modificar el valor de expresiones más simples, o bien, para crear expresiones nuevas a partir de otras. Como ejemplo podemos citar el operador de concatenación de cadenas, que se representa por un signo más (+) y que se usa para concatenar dos cadenas de texto en una nueva.

Los operadores no son genéricos, sino que se podrán usar dependiendo de las expresiones sobre las que se quiere operar. Como ejemplo podemos volver a citar el operador de concatenación de cadenas y el operador de suma de enteros. Aunque ambos se representen con el mismo símbolo (el más de la suma) no es el mismo operador.

Operadores enteros

1.    Operadores numéricos de enteros

Se usan con los números enteros. Atendiendo a su funcionalidad, se clasifican en distintos tipos.

Los operadores de cambio de signo son dos y se representan por los signos + y -. Son operadores unarios. El operador – se aplica para cambiar el signo del operando, mientras que el operador + no tiene ningún efecto. A continuación veremos un ejemplo de ambos operadores:

a=-4;    // Asigna el valor -4 a la variable a
b=+7;   // Asigna el valor 7 a la variable b

Los operadores aritméticos son operadores binarios. Se utiliza el símbolo + para la suma, el – para la resta, el * para la multiplicación, el / para la división y el % para la división entera. Veamos los ejemplos que siguen:

a=2+3; a=a-1; a=a*4....

Estas operaciones aritméticas pueden realizarse sobre dos enteros de distinto tipo. La máquina virtual se encarga de convertir el tipo más pequeño al tipo mayor o al tipo “int”, el que sea menor. El tipo de resultado de la operación será el mismo que el tipo al que se ha convertido el tipo menor. A este proceso de conversión se le denomina moldeo o casting. En el siguiente ejemplo veremos detalladamente el proceso de conversión automática:

byte b=4;
short s=2;
int i=b*s;

La tercera sentencia consiste en la multiplicación de un tipo byte por un tipo short y la asignación del resultado a una variable de tipo int. En ella tienen lugar las dos conversiones automáticas que se explican seguidamente:

-    Primera conversión: El operando “b” es de tipo byte y hay que multiplicarlo por un operando de tipo short. Entre ambos tipos, el mayor es del tipo short, pero hemos mencionado que el menor tipo para una conversión automática es el tipo int, por tanto el operando “b” se convierte a tipo int.
-    Segunda conversión: El operando “s” es de tipo short y hay que multiplicarlo por un operando de tipo int (obtenido en el paso anterior). Entre ambos tipos el mayor es de tipo int y, por tanto, el operando “s” se convierte a tipo int.
-    Por último, se multiplican ambos operandos de tipo int y el resultado de la operación se almacena en la variable “i” de tipo int.

Operadores de incremento y decremento. Son de uso frecuente en estructuras iterativas para las variables de control (contadores). Se representan con los símbolos ++ y – para aumentar y disminuir respectivamente, en una unidad al operando sobre el que actúan.

int a=24;
int b=++a;  //Primero se incrementa y luego se asigna
int c=a++;  //Primero se asigna y luego se incrementa

¿Cuánto valdrían a, b y c, después de la ejecución del código?

Operadores de desplazamiento de bits, operador de complemento de bits y operadores de comparación de bits. Son otro tipo de operadores que existen, y si fuese necesario los veríamos en su momento.

2. Operadores de comparación de enteros

Se utilizan para comparar dos números enteros y da como resultado un valor booleano. Son los seis siguientes:

>: Mayor que
<: Menor que
= =: Igual a
>=: Mayor o Igual que
<=:Menor o Igual que
!=: Distinto de

3. Operador condicional de enteros

Es un operador ternario. Construye expresiones que requieren tres operandos y en las cuales el primer y segundo operando se separan usando el símbolo ? y el segundo y tercer operando se separan usando el símbolo :. El primer operando debe ser un valor booleano mientras que el segundo y el tercero han de ser valores enteros. Si el valor booleano es true, la expresión toma como valor el del segundo operando, mientras que en caso contrario toma como valor el del tercer operando.

Es un operando muy usado puesto que permite la toma de decisiones con expresiones muy compactas  y elegantes. Veamos un ejemplo en el cual la última sentencia de asignación es equivalente al bloque “if” previo. Se trata de saber el mayor de dos números.

if(a>b){
c=a;
}else{
c=b;
}

c=a>b ? a : b;

4. Operadores de conversión de tipos enteros

Antes hablamos de las conversiones que realiza Java automáticamente. En contraste con éstas, tenemos las conversiones explícitas de tipos, es decir, aquellas que podemos forzar en el propio código mediante algún tipo de mecanismo.

Estos mecanismos son los operadores de conversión de tipos, que permiten convertir cualquier expresión numérica a otro tipo distinto. Para cada uno de los tipos numéricos existe un operador de conversión. Consiste en colocar delante de la expresión a convertir el nombre del tipo al cual se quiere convertir encerrado entre paréntesis.

Hemos de tener en cuenta que cuando pasamos de un tipo a otro de inferior rango podemos encontrarnos con resultados inesperados debido a un valor que excede del rango del tipo al cual se convierte.

Ejemplos de conversiones:

int a=24;
byte b= (byte) a;
short c= (short) a;
long d=(long) a;

5. Operador entero de concatenación de cadenas

Cuando una cadena de texto y una expresión que no sea de tipo cadena se combinan usando el operador de concatenación de cadenas (+), el resultado es una nueva cadena. Dependiendo de la expresión y de su contenido, podremos obtener los siguientes resultados:

-    Si la expresión es un tipo de referencia con valor null, se obtendrá una nueva cadena igual a la cadena original más la cadena “nul”.
-    Si la expresión es un tipo de referencia con valor distinto de null, se obtendrá una cadena igual a la original más el valor devuelto por el método toString( ) del tipo de referencia.
-    Si la expresión es un tipo primitivo, se obtendrá una cadena igual a la original más el valor del tipo primitivo representado como cadena.

Ejemplos:

String inicial=”ABC”;
String nulo=null;
String nonulo=”def”;
byte numero=23;
String caso1=inicial+ nulo; //”ABCnull”
String caso2=inicial+nonulo; //”ABCdef”
String caso3=inicial+numero; //”ABC23”

Operadores de coma flotante

Se pueden clasificar, al igual que los enteros, en las mismas cinco categorías según la funcionalidad que ofrecen. De hecho, la mayoría de los operadores de coma flotante funcionan igual que sus homólogos enteros, exceptuando los operadores numéricos y los de comparación.

1.    Operadores numéricos de coma flotante

Son los mismos que los operadores numéricos de enteros exceptuando los que operaban con los bits, es decir, los de desplazamiento, complemento y comparación de bits.

Cada uno de ellos funciona de forma similar a los correspondientes de los enteros y no vamos a entrar en detalles. La principal diferencia está en que el resultado de las operaciones son del tipo de coma flotante.

2.    Operadores de comparación de coma flotante

Existen los seis mismos tipos que citábamos en el apartado de los enteros. >,<, >=, <=, = =, !=.

3.    Operador condicional de coma flotante.
4.    Operadores de conversión de tipos de coma flotante.
5.    Operador de coma flotante de concatenación de cadenas.

Estos tres funcional exactamente igual que los correspondientes vistos en el apartado de enteros.

Operadores booleanos

Las condiciones son fundamentales en el control de flujo de ejecución de los programas. Esencialmente, son expresiones que al ser evaluadas devuelven un valor lógico true o false, también conocido como booleano.

Operadores lógicos de comparación

Hay dos operadores de comparación: igual a (= =) y distinto de (¡=). Ambos requieren dos operandos de tipo booleano. El operador = = da como resultado true si ambos operandos son iguales. Por el contrario, el operador != da como resultado true si ambos operandos son distintos.

Ejemplos: true = = true, true = = false, true ! = false, false ! = false

Operador de complemento lógico

Es un operador unario y se representa por el símbolo !. Da como resultado un valor lógico opuesto al valor lógico del operando sobre el que se aplica.

Ejemplos: !true,!false

Operadores lógicos

Existen tres operadores binarios que son:

-    OR: Se representa con el símbolo |. Da como resultado un valor true si al menos uno de los dos operandos es true.
-    AND: Se representa con el símbolo &. Da como resultado un valor true si ambos operandos son true.
-    XOR: Se representa con el símbolo ^. Da como resultado un valor true si uno y sólo uno de los operadores es true.

Operadores lógicos condicionales

Son dos: OR (||) y AND (&&). Funcionan de forma similar a los anteriores excepto en que no se garantiza la evaluación del segundo operando si el resultado de la expresión puede determinarse directamente a partir del primero. Esto se conoce como lógica booleana cortocircuitada.

Ejemplo:

int a=1;
int b=1;
if(3>1 | ++a>0){
//...
}

if(3>1 || ++b>0){
//...
}

Tras la ejecución de este código, la variable “a” termina con valor 2 mientras que la variable “b” termina con valor 1. ¿Veis la diferencia y sabeis a que se debe?

Operador condicional booleano

Funciona exactamente igual que el operador condicional de enteros y de coma flotante.

Operador booleano de concatenación de cadenas

Funciona exactamente igual que el operador booleano de enteros y de coma flotante. La única diferencia está en que el resultado de convertir un valor booleano a cadena de texto sería la cadena “true” o la cadena “false”, según fuera el valor.

Ejemplo: “TRUE se convierte en “ + true // da como resultado “TRUE se convierte en true”

Operadores de referencias

Se trata de operadores que operan sobre valores de tipo referencia, esto es, sobre referencias a objetos, interfaces, arrays.

Operadores de referencias para acceso a campos

El acceso a los campos se realiza mediante el operador punto (.), por ello esta notación recibe el nombre de notación de punto. En este tipo de expresiones, el elemento que está a la izquierda del punto identifica a la clase, objeto o interfaz a la que pertenece el elemento que está a la derecha del punto.

Operadores de referencias para invocación de métodos

La invocación de métodos, al igual que para el acceso a campos, se realiza mediante el operador punto.

Operadores de conversión de tipos de referencia

Se utilizan para convertir una referencia de objeto a un cierto tipo. Pero existen ciertos requisitos para permitir la conversión. El tipo de un objeto sólo puede convertirse al de su propia clase, al de una de sus superclases, al de una de sus superclases, al de una interfaz que sea implementada por su propia clase o al de una interfaz que sea implementada por alguna de sus superclases.

Los tipos de referencia se convierten usando como operador el nombre entre paréntesis de la clase a la cual se quiere convertir y anteponiéndolo a la expresión a convertir.

Ejemplo:

FiguraGeometrica figura= new Rectangulo( );
Rectangulo rectangulo= (Rectangulo) figura

Operador de tipo de referencia

En Java es sumamente importante la clase a la que pertenece un tipo de referencia. Puesto que se permite la conversión entre tipos, se hace necesario que podamos comprobar desde el código si una determinada conversión puede realizarse.

Para determinar si un objeto es una instancia de una clase concreta, disponemos del operador instanceof que devuelve un valor booleano o genera una excepción. El primer operando debe ser un tipo de referencia y el segundo debe ser un nombre de clase.

-    Si el primer operando es null, el resultado es false.
-    Si el primer operando no es null, y es posible convertirlo a la clase que especifica el segundo, el resultado es true.
-    Si el primer operando no es null y no es un descendiente del tipo especificado por el segundo operando, la instrucción es ilegal y causa error de ejecución.

Ejemplos:

String s1=”texto”;
String s2=null;
boolean b1=s1 instanceof String //”b1” toma el valor true
boolean b2=s2 instanceof String; //”b2” toma el valor false

Operadores de comparación de referencias

A diferencia de lo que ocurre con los operadores de comparación de tipos primitivos, que consiste en comparar los valores de los operandos, el caso de la comparación de tipos de referencia se basa en comparar que los operandos apunten al mismo objeto. En otras palabras, no es suficiente que los objetos sean idénticos, si no que han de ser referenciadas a la misma instancia del objeto.

Ejemplo:

String s1=”texto”;
String s2=s1;
String s3=new String(s1);
boolean b1=s1= =s2  //”b1” toma el valor true
boolean b2= s1= =s3; //”b2” toma el valor false

Operador condicional

Funciona exactamente igual que el operador condicional de los tipos primitivos. En este caso, el primer operando debe ser una expresión booleana mientras que el segundo y tercer operandos deben ser de tipos de referencia.

Operadores de asignación

La asignación es una operación mediante la cual podemos asignar el valor de una expresión a una variable. La variable a la que se asigna el valor se pone a la izquierda del operador de asignación, mientras que a la derecha del mismo se pone la expresión. Si la expresión usada requiere una evaluación, se realiza previa a la asignación.

Operador de asignación simple

Símbolo =. Su función es la de evaluar la expresión de la parte derecha de la expresión de asignación y asignar el resultado a la variable que figura en la parte de la izquierda.

Ejemplos:

int numero=24;
string texto;
texto=”ejemplo”;

Operadores de asignación complejos

La diferencia fundamental de este tipo de operador con respecto al operador simple es que en la asignación compleja la variable a la que se asigna el valor también participa en la expresión que debe asignársele. En consecuencia, ello implica que una asignación compleja sólo puede usarse con posterioridad a la declaración de la variable puesto que necesita utilizarla.

Los operadores de asignación complejos son +=, -=, *=, /=, %=, <<=, >>=, >>>=, |=, &= y ^=.

Ejemplos:

int a=10;
int b=3;
a+=b;
a*=b;

No son imprescindibles, se suelen usar para crear sentencias más legibles.

Orden de evaluación

A igualdad de condiciones, Java evalúa las expresiones siguiendo un orden estricto de izquierda a derecha. Ciertos operadores tienen precendencia sobre otros.

Cuando una expresión contiene operadores que tienen la misma precedencia, se mantiene el orden de izquierda a derecha. Ahora bien, cuando alguno de ellos tiene mayor precedencia que el otro, se realiza primero la operación de mayor precedencia aunque el operador de menor precedencia esté a la izquierda.

Tabla de precedencias

( )

++,--,+(unario),-(unario),~,!, (conversión de tipo)

*,/,%

+,-

<<,>>,>>>

<,>,<=,>=

= =,!=

&

^

|

&&

||

?:

=,+=,-=,*=,/=,%=,<<=,>>=,>>>=,|=,&= y ^=

4. Identificadores

Sirven para nombrar variables, propiedades, métodos, clases, objetos, interfaces y cualquier otra entidad que sea necesario identificar para poder usar.

Un nombre de identificador debe empezar con una letra, un símbolo de subrayado (_) o un símbolo dólar ($). El resto de los caracteres pueden ser letras o números. No existe una longitud máxima y se distinguen las mayúsculas de las minúsculas.

5. Variables y constantes literales

Variables

Tienen la misma funcionalidad que en el resto de los lenguajes de programación. Representan direcciones de memoria en las que alojar temporalmente la información que necesitemos, y por otro, nos ofrecen la facilidad de referirnos a ellas mediante un nombre. Es un nombre que contiene un valor que puede cambiar a lo largo del programa.

Una declaración de variable se compone de dos partes: su tipo y su nombre. Adicionalmente puede indicarse un valor para su inicialización. El tipo de la variable determina los valores que puede contener y las operaciones que se podrán realizar con ella. Pueden ser de tipos primitivos o variables de referencia.

Desde el punto de vista del papel que desempeñan, las variables pueden ser:

-    Variables miembro de una clase: Se definen dentro de la clase y fuera de cualquier método.
-    Variables locales: Se definen dentro de un método o dentro de cualquier bloque entre llaves. Se crean dentro del bloque y se destruyen al finalizar dicho objeto.

Se denomina visibilidad, ámbito o alcance de una variable, a la parte de una aplicación en la que dicha variable es accesible. En otras palabras, la parte en la cual puede usarse dicha variable. Como norma general, podemos decir que las variables declaradas dentro de un bloque (entre llaves) son visibles y existen dentro de ese bloque. Por ejemplo, las variables declaradas al principio de una función existen mientras se ejecuten las función, las declaradas dentro de un bloque “if” sólo serán accesibles y válidas dentro de dicho bloque y las variables miembro de una clase son válidas miembro de una clase son válidas mientras existe el objeto.

Las variables miembro de una clase declarada como pública (public), serán accesibles mediante una referencia a un objeto de dicha clase usando el operador punto. Por su parte, las declaradas como privadas (private) no son accesibles desde otras clases. Las funciones miembro de una clase tienen acceso directo a todas las variables miembro de la clase sin necesidad de anteponer el nombre de un objeto de la clase. Sin embargo, las funciones miembro de una clase “B” derivada de otra “A”, tienen acceso a todas las variables miembro de “A” declaradas como públicas o protegidas (protected), pero no a las declaradas como privadas. Una clase hija solo puede acceder directamente a las variables y funciones miembro de su clase padre declaradas como públicas o protegidas. Otra característica del lenguaje Java consiste en que es posible declarar una variable dentro de un bloque con el mismo nombre que una variable miembro, pero no con el nombre de otra variable local que ya existiera. La variable declarada dentro del bloque oculta a la variable miembro en ese bloque. Para acceder a la variable miembro oculta sería necesario que usáramos el operador this.

Constantes literales

Por su parte, las constantes literales son representaciones literales de datos en el código fuente. Estos valores se emplean para inicializar variables o para usarlas en expresiones en las que se requieren valores constantes.

Las constantes literales pueden usarse para referirse explícitamente a uno de los tipos siguientes: int, long, float, double, boolean, char, String y null.

Los objetos no pueden ser representados mediante estas constantes, y por tanto, no existen constantes literales de tipo referencia.

Constantes enteras

int a=1002        // Tipo int
long b=1002L    // Tipo long
int c=053        // Tipo int en octal
int d=053L        // Tipo long en octal
int e=0X002B        // Tipo int en hexadecimal
int f=0X002BL    // Tipo long en hexadecimal

El tipo char es un tipo entero, no obstante se trata de un tipo especial pensado para almacenar caracteres Unicode. Estos últimos son similares a los caracteres ASCII en que están pensados para almacenar símbolos, números y caracteres. Sin embargo, el rango de tipo char es mucho mayor porque permite representar caracteres de casi todos los idiomas del mundo.

Las constantes literales de tipo char pueden representarse de dos formas distintas:

-    Encerrando un único carácter entre comillas simples.
-    Utilizando una secuencia de escape, que es muy útil para representar caracteres que no pueden escribirse mediante el teclado. La secuencia de escape se representa por una barra inclinada inversa (\) seguida de un número octal de tres dígitos, o bien por la barra seguida de la letra “u” y de un número hexadecimal de cuatro dígitos. La secuencia de escape también debe ir encerrada entre comillas simples. También existe una serie de secuencias de escapes especiales que se utilizan para representar algunos de los caracteres ASCII más comunes. En la siguiente tabla se relacionan todos:

Secuencia de escape	Carácter que representa
\\	Barra inclinada
\'	Comilla simple
\"	Comilla doble
\b	Espacio
\f	Salto de página
\n	Salto de línea
\r	Retorno de carro
\t	Tabulador
\uFFFF	Escape Unicode

Constantes de coma flotante

double a=123.4    // Tipo double
float b=123.4F    // Tipo float
double c=4.502e-12    // Tipo double en notación exponencial

Constantes de cadena

Se representan por una secuencia de caracteres encerrados entre comillas dobles. Dentro de ellas se pueden incluir las secuencias de escape que antes mencionamos. Veamos algunos ejemplos:

String a=”Texto simple”;    // Texto simple
String b=”Esta es la letra u0041”    // Usando una secuencia de escape para representar la letra “A”
String c=”El proceso ha terminado.\nPulse una tecla”;    // Texto en dos líneas

Constantes booleanas

Existen dos: true y false. Ninguna de estas constantes puede ser representada mediante un valor entero usando como criterio la igualdad a cero.

Constante “null”

Existe una constante (null) que podemos usarla para representar el valor null.

6. Cadenas

Por cadena se entiende a una secuencia de datos del tipo primitivo carácter (char). En el entorno Java está implementada mediante la clase String, perteneciente al paquete java.lang.

La clase String

Los objetos de la clase String se pueden crear a partir de cadenas constantes o literales, definidas entre dobles comillas. Java crea siempre un objeto String al encontrar una cadena entre comillas. A continuación se describen dos formas de crear objetos de esta clase:

String a= “Hola”;    // Creado automáticamente por Java
String b=new String(“Hola”)        // Creado con un constructor

El primero de los métodos expuestos es el más eficiente, debido a que al encontrar un texto entre comillas se crea automáticamente un objeto String. Por otra parte, usando “new” se llama al constructor dos veces. No debemos confundirlo con los arrays de caracteres

String objcadena=”Cadena”;
char ArraydeCaracteres={‘C’, ‘a’, ‘d’, ‘e’, ‘n’, ‘a’};

Métodos más comunes:

int length( ): Devuelve un tipo int, que es el número de caracteres que contiene la cadena.

String cadena= “Esto es una cadena”;
int lon= cadena.length( );    // long será 18

char charAt(int index): Tipo devuelto es char, argumentos es la posición del carácter a devolver empezando por el 0. Devuelve el carácter especificado por el argumento.

String cadena= “Esto es una cadena”;
char primero= cadena.charAt(0);    // carácter e

String substring(int inicio, int fin): Tipo devuelto es un String, los argumentos son la posición inicial de la subcadena y la posición final de la subcadena. Devuelve una subcadena a partir de una cadena mayor. La longitud de la subcadena será la diferencia (fin – inicio).

String cadena= “0123456789”;
String subc=cadena.substring(0,4);    //subc=”0123”

int indexOf(String subcad, int inicio): Tipo devuelto es un int, los argumentos son la subcadena buscada y la posición desde donde se empieza a buscar. Devuelve la posición de la primera ocurrencia de la subcadena buscada o -1 si no la encuentra.

String cadena= “Esto es una cadena”;
nt pos= cadena.indexOf(“na”,0);    //pos=9

boolean equals(Object cadena): Tipo devuelto es un boolean, los argumentos son la cadena con la que hay que comparar. Compara los caracteres de dos cadenas.

String cad1=”cadena”;
String cad2=”cadena”;
String cad3=new  String(“cadena”);
boolean comp12=cad1.equals(cad2);
boolean comp23= (cad2==cad3);

String toUpperCase( ): El tipo devuelto es un String. Genera una nueva cadena pasando a mayúsculas la cadena actual.

String minusc=”cadena”;
String mayusc=minusc.toUpperCase( );

String toLowerCase( ): El tipo devuelto es un String. Genera una nueva cadena pasando a minúsculas la cadena actual.

String mayusc=”CADENA”;
String minusc=mayusc.toLowerCase( );

char[] toCharArray( ): El tipo devuelto es un array de caracteres. Genera un array de caracteres a partir de una cadena.

String cad=”Cadena”;
char[] array= cad.toCharArray( );

Si necesitas más información sobre la clase String, te recomiendo que visites la API, y observer la clase java.lang.String

http://java.sun.com/j2se/1.4.2/docs/api/

7. Paquetes

Se utilizan para agrupar clases Java relacionadas. Algunos de los paquetes más importantes predefinidos y que podemos encontrar en la API de Java son los siguientes:

-    java.lang: Núcleo del lenguaje Java. System, String, Integer, Math, Object, Exception, Error. No hace falta indicarlo, se importa por defecto.
-    java.io: Para Entrada/Salida (Input/Output). BufferedReader, InputStreamReader, File. Sistemas de ficheros y otros sistemas de entrada/salida.
-    java.util: Contiene clases de utilidad como las “Collections”, eventos, fechas, internacionalización, clases de utilidad.
-    java.applet y java.awt: Para trabajar con applets y aplicaciones gráficas basadas en ventanas.

Creación de paquetes

package Biblioteca;

public class Libro{
static double precio = 40.00;
public static void verPrecio ( ){
System.out.println(“Precio = “ + precio);
}
}

Dos formas de usarlo

public class GestionBiblioteca{
public static void mani(String[] _args){
biblioteca.Libro.verPrecio( );
}
}

import biblioteca.Libro;

public class GestionBiblioteca{
public static void main(String[] _args) {
Libro.verPrecio( );
}
}

8. El tipo void

No es un tipo de datos.

void v; // Error

Sólo como retorno de métodos que no devuelven nada:

public static void metodoSinRetorno( ) {...}

9. Arrays

Es una estructura de datos lineal que sirve para almacenar listas de datos primitivos u otros objetos. Se les puede llamar también vectores o matrices.

Los elementos de un array se inicializan al valor por defecto del tipo correspondiente. Cero para valores numéricos, el carácter nulo para el tipo char, el valor false para el tipo boolean y null para los demás.

Hay tres pasos para usar un array: declaración de la variable array, construcción para darle el tamaño apropiado, inicialización para darle valores.

En tres pasos:

int enteros[];   // Declaración
enteros= new int[10]; // Construcción
for(int i=0;i<10;i++)    // Inicialización
enteros[i]=i;

En dos pasos:

int enteros[]=new int[10]; / Declaración y Construcción
for(int i=0;i<10;i++)    // Inicialización
enteros[i]=i;

En un paso:

int enteros[]={0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; // Decl, Cons, Inic

A continuación podemos ver varios ejemplos relacionados con los arrays:

int[] a;        // Array de enteros inicializado a null
MiClase[] miClase= new MiClase[5];    // Array de 5 referencias a objetos, todas inicializadas a null
long[] b=new long[10];  // Array de10 enteros,  elementos inicializado a cero
double[] v={1.3, 3.5, 10.0};   // Array de 3 elementos inicializados
miObjeto.metodo( new String[]={“A”, “B”, “C”, “D”}); //Array anónimo

El último ejemplo podemos comprobar en que consiste un array anónimo, que no es más que la creación de un array como argumento actual en la llamada a un método.

Arrays bidimensionales

En Java, una matriz es un vector de vectores fila, o más concretamente, un vector de referencias a los vectores fila. Con este esquema, cada fila podría tener un número de elementos diferente.

Una matriz podemos crearla directamente de la siguiente forma:
int[] [] array= new int[3][4];

O bien, podemos crearla dinámicamente con los siguientes pasos:
- Creamos la referencia indicando con corchetes dobles que es una referencia a matriz         int[][] array;
- Creamos el vector de referencias a las filas
Array= new int[numero_de_filas][];
- Reservamos memoria para los vectores correspondientes a las filas
for(int index=0;index < numero_de_filas; index++)
array[index]=new int[numero_de_columnas];

Si tenemos una matriz de nombre “array”, la expresión “array.length” indica el número de filas mientras que la expresión “array[0].length” indica el número de columnas de la primera fila.

10. El método main

Es el punto de entrada a las aplicaciones de consola.

Es siempre la misma sintaxis:
public static void main(String[] args)

public: para que pueda ser ejecutado por la JVM (java.exe).

static: no hace falta crear un objeto para ejecutarlo.

void: no devuelve nada

String[ ] args: se le pueden pasar argumentos desde línea de comandos:

C:\> java Suma 1 2

args[0]=1;
args[1]=2;

11. Entrada y Salida

Se accede a la entrada y salida estándar desde la clase java.lang.System a través de dos variables estáticas:

-    System.in: entrada estándar (teclado)
-    System.out: salida estándar (monitor)

Salida (System.out)

print( ): imprime un mensaje
println( ): imprime un mensaje+nueva línea.

Entrada (System.in)

Dos formas de leer desde teclado:

-    Lectura de un carácter

char c=(char) System.in.read( );

-    Lectura de una cadena

A través de una clase que permita leer líneas completas: BufferedReader.

Ejemplo: Solicitar el nombre del usuario por teclado

import java.io.*;

public class DatosUsuario{
public static void main(String[] args) throws IOException{
BufferedReader teclado=new BufferedReader (new InputStreamReader(System.in));
System.out.print(“Escribe tu nombre y pulsa ENTER: “);
String nombre=teclado.readLine( );
System.out.println(“Hola “+nombre);
}
}

12. Clases envoltorio

Se utilizan para trabajar con tipos primitivos en forma de objetos. Se suelen usar para convertir desde cadenas a tipos primitivos.

Pertenecen al paquete java.lang y las más usuales son Integer y Double que equivalen respectivamente.

Clase Integer

Método mas utilizado: static int parseInt(String s)

Por ejemplo: mostrar edad a partir del año de nacimiento.

System.out.print(“Fecha de nacimiento: “);
String añoNacimiento=teclado.readLine( );
int añoActual=2004;
int edad=añoActual – Integer.parseInt(añoNacimiento);
System.out.println(“Tu edad es “+edad);

Clase Double

Método más utilizado: static double parseDouble(String s)

Ejemplo: mostrar la altura en centímetros a partir de la altura en metros.

System.out.print(“Altura en metros: “)
String metros= teclado.readLine( );
double m= Double.parseDouble(metros);
int cm=(int) (m*100);
System.out.println(“Mides “+cm+”centimetros”);

<< Volver al tema anterior  || >> Ir al tema siguiente

 

Referencias:

 

http://www.jmordax.com/

 

Autor: Antonio Lopez Atienza