"Ao de la Diversificacin Productiva y del Fortalecimiento

de la Educacin"
UNIVERSIDD PRIVADA SAN JUAN
BAUTISTA FILIAL - ICA
ESTRUCTURA EN JAVA

CURSO: ALGORITMO Y ESTRUCTURA

DE DATOS
TEMA: ESTRUCTURA EN JAVA
CARRERA: COMPUTACION Y SISTEMAS
PROFESOR(A): HUAMANTOMA CARDENAS ANGEL
ALUMNO: SALCEDO LPEZ OSCAR

TURNO: MAANA

ICA PER
2015

ESTRUCTURA EN
JAVA

DECLARACION DE VARIABLES EN JAVA

Las variables son una de las caractersticas fundamentales de los
lenguajes de programacin, permiten acceder a la memoria para almacenar y
recuperar los datos con los que nuestros programas van a trabajar. Son por
tanto el mecanismo que los lenguajes de programacin ponen a nuestra
disposicin para acceder a la memoria.
Se trata de un mecanismo de lo ms sencillo, slo tenemos que dar un
nombre a nuestras variables, a partir de ese momento el compilador traducir
de forma automtica ese nombre en un acceso a memoria. Por ejemplo:

//Almacenamos un dato en memoria referenciado por el nombre edad

edad = 5;
//Recuperamos el dato almacenado y lo modificamos
edad = edad + 1;

Java es un lenguaje tipado y nos obliga a declarar nuestras variables

antes de poder hacer uso de ellas, con esta declaracin le indicamos al
compilador el espacio en memoria que debe de reservar para almacenar la
informacin. Por ejemplo:

String cliente;

Aqu estamos reservando memoria para una variable de tipo String y la

identificamos con el nombre cliente. De ahora en adelante si en el programa
hablamos de cliente, estamos haciendo referencia a esa porcin de memoria y
al valor que contiene.
Podemos asignarle algn valor en el momento de declarar una variable.
Por ejemplo:

String cliente = "Isaac Newton";

Aqu reservamos memoria para una cadena de caracteres y le

asignamos el valor "Isaac Newton". Tambin podemos declararla y en otro
lugar del programa fijarle un valor:

String cliente; // declaracin

... // El programa sigue
cliente = "Isaac Newton"; // le damos un valor

La sentencia para declarar una variable se resume como:

Tipo_Dato Nombre_Variable [= Valor];

Definimos el tipo de dato, el nombre y opcionalmente su valor.

Para ver como se utilizan las variables, podemos modificar el primer
programa. Agregaremos una variable que contenga el texto que se mostrar en
pantalla:

{{Java/!|public}} {{Java/!|class}} HolaMundo {

{{Java/!|public}} {{Java/!|static}} {{Java/!|void}}
main(String[] args){
String saludo = "Hola Mundo!";
System.out.println( saludo );
}
}

Definimos una variable de tipo String con el nombre "saludo". En la

declaracin de la variable tambin la inicializamos con el valor "Hola mundo!".
Luego llamamos al mtodo que imprimir el texto en la pantalla haciendo
referencia a la variable. En el programa original, explcitamente introducamos
el texto que se mostrara, ahora solo escribimos el nombre de la variable.
Cuando el intrprete se encuentre con el nombre de esta variable, tendr que
buscar el valor que almacene en la memoria para mostrarlo por pantalla.
Un variable puede cambiar su valor en el transcurso del programa.

{{Java/!|public}} {{Java/!|class}} UsoVariables{

{{Java/!|public}} {{Java/!|static}} {{Java/!|void}}
main(String args[]){
String saludo;
saludo = "Hola Mundo!";
System.out.println( saludo );
saludo = ("Estoy utilizando variables");
System.out.println( saludo );
}
}

Siempre debemos inicializar una variable. Al compilar el programa, el

compilador de Java leer el contenido de la variable y siempre verificar que
tenga un valor. De lo contrario el programa no compilar y mostrar un error.
Un ejemplo de este caso:

if (x > 0) {
saludo = "Hola Mundo!!!";
}
System.out.println( saludo );

En este caso el compilador mostrar un mensaje de error indicando que

la variable x no se ha inicializado con ningn valor. Como se puede observar
esta variable solo se inicia cuando se cumple una condicin, sin embargo se
indica que va a ser utilizada siempre. El compilador detecta este posible error.
Un ejemplo de solucin posible sera:
int x = 1;
if (x > 0) {
saludo = "Hola Mundo!";
}
System.out.println( saludo );

Agregando estas lneas al final del cdigo de la clase UsoVariables nos

mostrara lo siguiente a la salida:
Hola Mundo!
Estoy utilizando variables
Hola Mundo!!!

Nombre de la variable
El nombre debe ser nico en el contexto del programa. Adems debe seguir
las siguientes reglas:

No puede ser una palabra reservada del lenguaje o un literal booleano

(true ofalse)
Puede contener cualquier carcter Unicode, pero no puede comenzar

con un nmero
No debe contener los smbolos que se utilicen como operadores ( + ,
- , ?, etc )

Por convencin, los nombres de variables comienzan con una letra en

minscula. Si un nombre consiste en ms de una palabra, se escribir sin
espacios entre ellas y cada palabra (salvo la primera) comenzar con una letra
mayscula (por ejemplo: estaBienEsteNombre).

Tipo de variable
Cada variable debe tener un tipo de dato predefinido. Esto determina el
rango de valores que puede almacenar y qu operaciones se pueden realizar
as como el resultado que te dar. Por ejemplo, una variable de tipo entero
puede almacenar nmeros sin decimales y puede realizar operaciones
aritmticas, pero no puede contener palabras.
Existen dos categoras de variables: las de tipo primitivo y las
referenciadas. Una variable de tipo primitivo accede al valor asignado
directamente. Las referenciadas acceden a travs de un puntero, es decir, no
almacenan un valor sino una direccin de memoria. Estas ltimas son
utilizadas por las matrices, las clases y las interfaces.
Tipos de datos primitivos
Tipo

Tamao y formato

Rango

enteros
byte

8 bits - complemento a 2

short

16 bits - complemento a 2

int

32 bits - complemento a 2

long

64 bits - complemento a 2
nmeros reales

float

32 bits - IEEE 754

double

64 bits - IEEE 754

otros

char

16 bits - caracteres UNICODE

'\u0000' al '\uffff'

boolean

1 bit

true o false

En otros lenguajes de programacin, el formato o el tamao de los tipos

primitivos dependen del microprocesador o del sistema operativo en el que se
estn ejecutando. En cambio, Java pretende ser independiente de la
plataforma y mantiene los formatos sin cambios. Para los caracteres
alfanumricos utiliza la codificacin UNICODE de 16 bits, para permitir la
inclusin de varios alfabetos.

OPERADORES MATEMATICOS EN JAVA

Realizan las operaciones aritmticas bsicas: suma (+), resta (-),

multiplicacin (*), divisin (/) y mdulo (%) para datos de tipo numrico, tanto
enteros como reales. Estas son operaciones binarias porque admiten dos
operandos.
Ejemplo de utilizacin de estos operadores:

public class Aritmetica{

public static void main(String[] args){
int i
= 12;
int j
= 10;
int suma
= i + j;
int resta = i - j;
int mult
= i * j;
int div
= i / j;
int modulo = i % j;
System.out.print("Suma :");
System.out.println(suma );
System.out.print("Resta :");
System.out.println(resta);
System.out.print("Multiplicacion :");

System.out.println(mult);
System.out.print("Division :");
System.out.println(div);
System.out.print("Modulo :");
System.out.println(modulo);
}
}

El resultado de estas operaciones no puede quedar almacenado en una

variable de tipo short o byte, por ms pequeo que sea. Si tramos de compilar
esto:

short i = 1;
short j = 1;
short x = i + j;

Tendremos un "possible lost of precision" como respuesta, por ms que

el pequeito 2 entre holgadamente en una variable short. El compilador evita
que al utilizar estos tipos de datos no nos pasemos de largo. Pero de todas
formas me voy a vengar. Analicemos el siguiente cdigo:

public class IntGrande{

public static void main(String[] args){
int j = 2147483647;
int i = j + 1;
System.out.println("El valor obtenido es " + i);
}
}

El valor 2147483647 (es decir 2^31 - 1 ) es el ms grande que puede

tolerar un int. Pero veamos que pasa al sumarle uno ms. El compilador se

queda mudo y cae en nuestra trampa. Ejecutamos el programa y obtenemos:

El valor obtenido es -2147483648

Desastroso, Verdad? Veamos lo que pas: Tenamos el valor mximo

para los int:

01111111111111111111111111111111 : 2147483647 en nmeros binarios.

00000000000000000000000000000001 : le sumamos 1
10000000000000000000000000000000 : Resultado: -2147483648
complemento a 2

Esta anomala se la conoce como overflow (desbordamiento). El

procesador puede identificar un resultado con este problema comparando los
signos. Es de esperar que si sumamos dos nmeros positivos, no nos d como
resultado un nmero negativo. Pero el intrprete de Java no nos avisa, por lo
tanto tenemos que cuidarnos al trabajar cerca de los extremos.
Sigamos metindonos en embrollos. Veamos ahora que ocurre si
tratamos de dividir cualquier nmero por cero. Para la verificacin escribimos
este programa:

public class DivCero{

public static void main(String[] args){
int x = 5;
int y = 0;
int z = x/y;
System.out.println(z);
}
}

No tenemos noticias al compilar. Pero al ejecutar el programa, el

intrprete nos manda a pasear con la siguiente nota:

Exception in thread "main" java.lang.ArithmeticException: / by zero

Veremos ms adelante cmo controlar el nimo del intrprete cuando

ocurren estos errores, aqu conocidos como excepciones. La moraleja es que
no se puede dividir un entero por cero.
Sigamos dando pelea, no nos dejemos intimidar. Probemos que ocurre
con los nmeros reales:

public class DivCeroFloat{

public static void main(String[] args){
float x = 5.0f;
float y = 0.0f;
float z = x/y;
System.out.println(z);
}
}

Compilamos y no escuchamos nada. Ejecutamos el programa...

Infinity

Ni error ni cosas raras, el float se aguant los malos tratos. Esto ocurre
porque los nmeros reales en su representacin binaria soportan el valor
infinito.
Operadores aritmticos unarios
Dentro de los operadores aritmticos tenemos los unarios + y que
simplemente operan con el signo de un valor dado. Por ejemplo:

int h = -1;
int m = +h; // es equivalente a m = h * (+1)
int n = -h; // es equivalente a n = h * (-1)

El operador se encarga de cambiar el signo, y el + sencillamente deja

el signo como est. Nuevamente no podemos almacenar el resultado en
enteros cortos, los tipos byte y short los transforma en int. Dentro del catlogo
10

de operadores tenemos algunos unarios ms. Se trata del auto incremental ++

y del auto decremental --. Respectivamente, suma y resta una unidad al valor.
Ambos operadores pueden ser sufijos, es decir se coloca antes del operando o
posfijo que se sita detrs. Veamos algunos ejemplos:

int i = 1;
i++;
++i;
i--;
--i;

En este ejemplo estamos incrementado y decrementando el valor de i. A

priori parece que los operadores funcionan igual, tanto como posfijo como
sufijo, pero su comportamiento es diferente. Observemos lo que ocurre en este
ejemplo:

public class Diferentes{

public static void main(String[] args){
int i = 2;
int j = 2;
System.out.println(i++);
System.out.println(++j);
System.out.print("Estado Final (i) :");
System.out.println(i);
System.out.print("Estado Final (j) :");
System.out.println(j);
}
}

todo es practico. Partiendo del mismo valor, vemos que j se increment,

mientras que la variable i se mostr sin cambios. Si colocamos el operador
como sufijo, primero se evala la variable y luego se realiza la operacin. En el
caso de la variable i, antes de incrementar su valor se mostr por pantalla. Para
la variable j el procedimiento fue inverso. Antes de mostrar su valor se
increment.

11

OPERADORES DE COMPARACIN EN JAVA

Revisando algunas definiciones matemticas, nos enteramos que los
nmeros conforman un conjunto ordenado. Cada uno tiene una posicin
relativa. Sabemos que el 2 "es menor que" el 4 y que el 6 "es ms grande que"
el 1. Al comparar dos nmeros, realizamos una funcin de relacin.
En java disponemos de los operadores relacionales para verificar si se
cumple una relacin. Por ejemplo el operador de equivalencia ( == ) nos
devuelve un valor de verdadero si los operandos son iguales. Estas
operaciones comparan dos valores numricos y devuelven un valor booleano.
Operadores relacionales
Operador

Utilizacin

Resultado

>

A>B

verdadero si A es mayor que B

>=

A >= B

verdadero si A es mayor o igual que B

<

A<B

verdadero si A es menor que B

<=

A <= B

verdadero si A es menor o igual que B

==

A == B

verdadero si A es igual a B

!=

A != B

verdadero si A es distinto de B

Aqu tenemos un programa para ver el funcionamiento de estos operadores:

public class relaciones {

12

public static void main(String args[]){

int
i = -3;
byte
b = 5;
float f = 1e-10f;
double d = 3.14;
boolean b1 = i > i;
boolean b2 = i < b;
boolean b3 = b <= f;
boolean b4 = f >= d;
boolean b5 = d != 0;
boolean b6 = 1 == f;
System.out.println("b1:
System.out.println("b2:
System.out.println("b3:
System.out.println("b4:
System.out.println("b5:
System.out.println("b6:

"
"
"
"
"
"

+
+
+
+
+
+

i
i
b
f
d
1

+
+
+
+
+
+

"
"
"
"
"
"

> " + i + " = " + b1);

< " + b + " = " + b2);
<= " + f + " = " + b3);
>= " + d + " = " + b4);
!= " + 0 + " = " + b5);
== " + f + " = " + b6);

}
}

No nos olvidemos de los char, que tambin participan. Podemos

comparar caracteres, pues internamente estn almacenados como nmeros.

char a = 'A';
char b = 'B';
boolean x = a > b;

Entre los booleanos solo se permiten los operadores de equivalencia, es

igual (==) o es distinto (!= )

boolean x = true;
boolean y = x == x;
boolean z = x != y;

13

OPERADORES LOGICOS EN JAVA

Como deben suponer, trabajan con operandos booleanos. Realizan las
operaciones lgicas de conjuncin (AND), disyuncin (OR), negacin (NOT) y
la disyuncin exclusiva (XOR).
Operadores booleanos
Nombr
e
OperadorUtilizacinResultado
AND

&&

A && B

verdadero cuando A y B son verdaderos.

Evaluacin condicional.

OR

||

A || B

verdadero cuando A o B son verdaderos.

Evaluacin condicional.

NOT

!A

verdadero si A es falso.

AND

&

A&B

verdadero cuando A y B son verdaderos.

Siempre evala ambos operandos.

OR

A|B

verdadero cuando A o B son verdaderos.

Siempre evala ambos operandos.

XOR

A^B

verdadero cuando A y B son diferentes

Cada una de estas operaciones tiene asociada una tabla de verdad.

Esto nos permite ver el resultado de un operador aplicado a las distintas
combinaciones de valores que pueden tener los operandos. A continuacin
mostraremos cmo se comporta el operador AND mediante su tabla de verdad.

public class TablaAnd {

public static void main(String args[]){
boolean x = true;
boolean y = false;
boolean a1 = x && x;
boolean a2 = x && y;

14

boolean a3 = y && x;
boolean a4 = y && y;
System.out.println("Tabla
System.out.println( x + "
System.out.println( x + "
System.out.println( y + "
System.out.println( y + "

de verdad
AND " + x
AND " + y
AND " + x
AND " + y

de la
+ " =
+ " =
+ " =
+ " =

conjuncin");
" + a1 );
" + a2 );
" + a3 );
" + a4 );

}
}

Si probamos a quitar un ampersand ( & ) del operador, vemos que

obtenemos los mismos resultados. Existen dos operadores AND, uno con dos
smbolos & y el otro con uno solo. Tambin tenemos dos operadores OR.

boolean x1 = operando1 && operando2;

boolean x2 = operando1 & operando2;
boolean y1 = operando1 || operando2;
boolean y2 = operando1 | operando2;

Parece extrao, sobre todo porque tienen la misma tabla de verdad.

Pero internamente tienen un comportamiento diferente.
Cuando estamos en presencia de un operador con un solo smbolo,
siempre se evalan ambos operandos. En cambio para el operador con el
smbolo repetido, su evaluacin cambia segn el valor del primer operando. Por
ejemplo tenemos la siguiente operacin.

boolean x = true && false;

El resultado es falso, pero el intrprete tiene que mirar el segundo

operando para saberlo.

15

boolean x = false && true

Aqu ni se molesta en mirar el ltimo operando, porque la operacin AND

es verdadera solamente cuando ambos operandos son verdaderos.
En el caso del operador OR, se evala el segundo operador si el primero
es falso. Cuando es verdadero, no tiene en cuenta el otro operando. El
resultado es verdadero sin importar el valor del segundo.
Veamos un caso extremo para mostrar como funciona la evaluacin
condicional. Tenemos el siguiente programa en donde pretendemos hacer
saltar al intrprete con un error.

public class Condicional {

public static void main(String args[]){
int x = 0;
int y = 2;
boolean b = ( x != 0 ) && ( ( y / x ) != 0 );
System.out.println(b);
}
}

Sin ningn tipo de emocin, aburridamente el intrprete nos avisa que el

resultado es "false". Ahora ver. Quitemos un smbolo & y quedmonos con
uno solo. El resultado es otro:

java.lang.ArithmeticException: / by zero

La primera vez verific que x!=0 era falso, entonces dio por terminada la
operacin con el resultado falso. Cuando cambiamos de operador, evalu los
dos operandos y cay en nuestra trampa. Tuvo que calcular cunto es y / x
dando luego un error de divisin por cero.
Los operadores booleanos son muy amigos de los relacionales. Se
llevan bien porque los ltimos dan resultados booleanos. Entre ambos tipos de
operadores se pueden construir instrucciones ms complejas.
Por ejemplo, queremos saber si un nmero est dentro de un rango. Solo

16

tenemos que compararlo con los extremos:

int
y = 4;
boolean x = ( y > 3 ) && ( y < 6 );

Ahora deseamos saber si una variable tiene el valor "a" no importando si

es mayscula o minscula.

char c = 'b';
boolean x = ( c == 'a' ) || ( c == 'A' );

No olviden que el operador de equivalencia (==) tiene dos smbolos igual

(=), si colocan uno solo les dar un error de asignacin.

17