TEMA 2:

ESTRUCTURA DEL LENGUAJE

2.1 Estructura básica de un programa

La estructura básica de un programa en Java tiene la forma siguiente

// Importa las clases necesarias del paquete

especificado

import paquete;

class nombre_de_clase
{

// Conjunto de datos miembro con la forma

protección tipo variable;

//Conjunto de métodos miembro con la forma

protección static tipo función(tipo parametro)

{
Conjunto _de _Sentencias
}

//Método principal
public static void main( String[ ] args)
{
Conjunto _de _Sentencias
}

Ejemplo
 class usametodo
{

public static double suma(double a, double b)

{

double z;
z= a + b;
return z;

public static void main(String[] args)

{
double x= 80.;
double y= 4.5;
double z;
z= suma(x,y);

System.out.print(" \t El resultado de " + x + " + " + y +

" es " + z);

}
}

Es necesario escribir los programas en un editor de texto y guardarlo con

extensión java. Es importante mencionar que el programa fuente debe llevar el
mismo nombre que la clase principal.

La palabra import se utiliza para importar las clases necesarias del paquete
indicado, en otras palabras son las librerías.

Con la palabra class se define una clase . En los lenguajes orientados a objetos,
existen terminologías como: clase, objeto, encapsulamiento, herencia,
polimorfismo, etc. (Ver tema 3).

Por otra parte, la función main recibe como parámetro un arreglo de cadenas, (el
manejo de cadenas se tratará más adelante). Para poder ejecutar un programa en
Java es necesaria la existencia de la función main() que es única.

Ejemplo
 import java.io.*;

class asignacion1
{
public static void main (String [] args)
{
int x=12;
System.out.println("El valor de x es " + x);
x+=10;
System.out.println("El valor de x es " + x);
}
}

import java.io.* le indica al compilador que importe las clases necesarias del
paquete java.io proporcionado por java.

2.2 Identificadores

Una variable es un identificador que hace referencia a una ubicación de memoria

que contiene un valor. Un identificador también puede ser un nombre de clase, de
método, de campo, etcétera. Los identificadores de Java comienzan con una letra
de Unicode (incluyendo _ y $) seguida de cualqier número de letras y números.

Unicode permite la codificación de 34,168 caracteres. Esto le permite en sus

programas Java varios alfabetos como el Japonés, el Griego, el Ruso o el Hebreo.
Esto es importante para que los programadores puedan escribir código en su
lengua nativa.

Por convención, en Java, los identificadores empiezan con una letra minúscula. Si
un identificador esta compuesto de más de una palabra, como 'nombreDato' las
palabras se ponen juntas y cada nueva palabra después de la primera empieza
con una letra mayúscula. Los nombres de las clases empiezan con una letra
mayúscula.

2.3 Variables primitivas y tipos de datos

Todas las variables en Java deben tener un tipo de dato. El nombre de variable No
puede ser el mismo que una palabra clave o el nombre de un valor booleano (false
o true). No deben tener el mismo nombre que otros identificadores cuyas
declaraciones aparezcan en el mismo ámbito.
El tipo de dato de la variable determina los valores que puede contener y las
operaciones que se pueden realizar con ella. Existen dos categorías de datos
principales en Java: los tipos primitivos y los tipos referenciados.

Los tipos de datos primitivos también conocidos como tipos de datos

Normalizados, son aquellos que forman parte de la mayoría de las computadoras
y comprenden a los números

• enteros
• reales (números de punto flotante)
• valores lógicos (false, true)
• conjunto de caracteres de escritura.

La tabla siguiente muestra todos los tipos primitivos soportados por Java, su
formato, su tamaño y una breve descripción de cada uno:

Tipo Tamaño Descripción

byte De -128 a 127 Entero de un
byte
short De -32768 a 32767 Entero corto
int De -2,147,483648 a 2147,483647 Entero
long De -2^63 a 2^63 -1 Entero largo
float 6 dígitos significativos (10^-46 , 10^38 ) Flotante de
precisión simple
double 15 dígitos significativos (10-324 , 10308 ) Flotante de
precisión doble
char 16 bits Un sólo
carácter
boolean 1 byte Variable
booleana false y true

Los tipos referenciados se llaman así porque el valor de una variable es una
referencia (un apuntador) hacia el valor real. En Java los arreglos, las clases y las
interfaces son tipos de datos referenciados.

Cualquier variable se declara proporcionando su tipo, su identificador (nombre), y

opcionalmente su valor inicial. Es sensible a las mayúsculas, es decir, es diferente
la variable Edad que la variable llamada edad.

Como ejemplo veamos el programa en java:

1. import java.io.*;
2. public class Asignacion{
3. public static void main(String [] argc)
4. {
5. int x = 12;
 6. x = x+31;
7. System.out.println("El valor de x es " +
x);
8. }
9.}

Observemos que en la línea 5 se define una variable entera llamada x e

inmediatamente después se le asigna el valor de 12. Posteriormente se modifica el
valor de x en la línea 6. Para terminar escribiendo el nuevo valor de x; con un salto
de línea. (Es importante ponerle el mismo nombre que la clase al programa; es
decir, este programa debe llamarse Asignacion.java).

En la línea 7 del programa, la función println recibe como parámetro una cadena
de caracteres. Pero como se observa en la línea, se suman una cadena con un
entero. Esto se le llama concatenación, lo que significa unir dos cadenas. Otro
término que se utiliza aquí es el de parámetro; esto también se verá más adelante.

Como observarán en la línea 6 se le asigna un nuevo valor a x; pero esta línea se

puede cambiar x+=31; y entonces el programa quedaría así:

1. import java.io.*;
2. public class Asignacion{
3. public static void main(String [] argc)
4. {
5. int x = 12;
6. x += 31;
7. System.out.println("El valor de x es " + x);
8. }
9. }

2.4 Expresiones y operadores

Una computadora debe de contener un conjunto de operaciones primitivas

interconstruidas. Un conjunto típico incluirá primitivas para aritmética sobre cada
tipo numérico de datos, por ejemplo, suma, resta, multiplicación, división de reales
y enteros.

Existen operadores binarios y operadores monario. Los binarios son los que tienen
dos operandos y un operador, por ejemplo

a+b
el operador suma (+) es binario ya que tiene el operando a y el operando b. Los
operadores monarios son los que tiene un sólo operando, por ejemplo el operador
menos para indicar los números negativos

-8

el - solo tiene el operando 8.

Los operadores se han clasificado en operadores de asignación, aritméticos,

relacionales y operadores lógicos, en seguida se mostrarán.

2.4.1 Asignación

La sentencia de asignación se logra mediante el operador igual (=), es también

conocida como una operación L-value y su función es asignar un valor numérico o
el resultado de una expresión a una variable. Por ejemplo

x=10;

en donde x es la variable que reciben el valor entero de 10. La variable x

previamente debe ser declarada de tipo entero. Otro ejemplo

area= (base * altura) / 2

en este caso la variable area se le asignará el valor que resulte de evaluar la

expresión. La variable area previamente debe ser declarada de tipo flotante, así
como las variables base y altura, que deben tener ya un valor para poder ejecutar
la operación respectiva.

Es regla que del lado izquierdo del operador =, en una asignación, exista una sola
variable (o identificador), en tanto que del lado derecho puede haber un número o
una expresión. Es un ERROR de asignación en programación el siguiente caso

a + b = 100

2.4.2 Operadores aritméticos

Dentro de los operadores aritméticos podemos mencionar la suma, la resta, la

multiplicación , la división o cociente y el módulo. En Java:

La suma se representa con el símbolo + , y se utiliza para indicar un incremento,

por ejemplo
 x = a + 20

en este caso al valor de a se le incrementará el valor de 20 y el resultado se

asignará a la variable x.

La resta se representa con el símbolo - , y se utiliza para indicar un decremento,

ejemplo

x = a - 50

en este caso al valor de a se le resta el valor 50 y el resultado se asigna a la

variable x.

En cuanto a la multiplicación se representa con el símbolo *, y se utiliza para

multiplicar, ejemplo

x=a*8

en este caso el valor de a es multiplicado por el valor 8 y el resultado es asignado

a la variable x.

Por otra parte la división en algunos lenguajes se representa con el símbolo /, y se

utiliza para dividir, ejemplo

x=a/b

en este caso el valor de a es dividido entre el valor de b y el resultado es asignado

a la variable x.

Otra operación muy utilizada es el módulo y se utiliza el símbolo %, y se utiliza

para obtener el residuo del conciente, ejemplo

x=7%2

en este caso el valor del residuo del cociente de 7 %2 es 1 el cual es asignado a la

variable x.

2.4.3 Operadores relacionales

Los operadores relacionales son operadores binarios y son utilizados para verificar
si una expresión es mayor que otra , o es menor que, o es mayor o igual, o es
menor o igual, o diferente de, o igual que. En el caso de lenguaje Java los
símbolos utilizados son:
El "mayor que" se representa con el símbolo > , por ejemplo a > b y da como
resultado un verdadero si el valor de a es mayor estrictamente que el valor de b,
es falso en caso contrario.

El "menor que" se representa con el símbolo < , por ejemplo a < b y da como
resultado un verdadero si el valor de a es absolutamente menor que el valor de b,
es falso en caso contrario.

Por otra parte el"mayor o igual" se representa con el símbolo >= , por ejemplo a >=
b y da como resultado un verdadero si el valor de a es mayor o igual que el valor
de b, es falso en caso contrario.

En cuanto al "menor o igual" se representa con el símbolo <=, por ejemplo a <= b
y da como resultado un verdadero si el valor de a es menor o igual que el valor de
b, es falso en caso contrario.

Para verificar si dos expresiones son diferentes se utiliza el operador !=, por
ejemplo a != b y da como resultado un verdadero si el valor de a es diferente a el
valor de b, es falso en caso contrario.

De manera similar, para verificar si dos expresiones son iguales se utiliza el

operador ==, por ejemplo en la expresión a == b y da como resultado un
verdadero si el valor de a es igual a el valor de b, en caso contrario es falso.

2.4.4 Operadores lógicos

Estos operadores están conformados por el AND, OR y NOT, y su resultado es

uno de los valores lógicos (Falso o Verdadero). Los resultados de evaluación se
muestran en la siguiente tabla de verdad.

a b a OR a AND NOT NOT

b b a b
00 0 0 1 1

01 1 0 1 0

10 1 0 0 1

11 1 1 0 0

en donde el 0 se interpreta como falso (false) y el 1 como verdadero (true). En el

lenguaje Java, el AND se representa con &&, el OR con || y el NOT con !. Ejemplo
 ((a>0) && (a < 100))

dependiendo del valor de a la expresión puede ser falsa o verdadera, siguiendo la

tabla anterior. Esto es si a=50, entonces la expresión es verdadera, pero si a=200
la expresión es falsa.

Nota: en Java el cero es falso y se considera verdadero todo número diferente de

cero.

2.4.5 Precedencia de operadores y evaluación de expresiones

Por precedencia de operadores se entiende a que operador se ejecuta primero en

una expresión durante la ejecución de un programa. La precedencia para los
operadores aritméticos se muestra en la siguiente tabla

Mas alta - (para números

negativos)

^ (exponente)

* / %

Mas baja + -

Lo que significa que en la siguiente expresión

a+b/c

primero se desarrollará el cociente b / c , en seguida el resultado será

incrementado a la variable a.

En cuanto a la precedencia de los operadores relacionales y lógicos el orden

queda como se muestra a continuación

Mas alta ! (negación)

== != (igual que y diferente

respectivamente)

< > >= <=

&&
 Mas baja ||

Por lo tanto en la expresión siguiente

a==b && b!= 0 || a> 100

La expresión será verdadera si a= 5 y b=5, ya que primero se verifica que a==b ,

luego se verifica que b!=0 es verdadera lo que deduce que la expresión a==b &&
b!= 0 es verdadera y ya no se analiza la siguiente parte de la expresión, porque
como se pudo ver en la tabla de verdad sólo debe de existir un verdadero en el
OR para que toda la expresión sea verdadera.

Pero si a= 105 y b=5, primero se verifica que a==b es falso, sin verificar mas se
deduce que a==b && b!= 0 es falso, en esta ocasión es imperioso verificar que a>
100 es verdadera, por lo tanto (a==b && b!= 0 || a> 100) es verdadera.

En el caso de que a= 8 y b=5, primero se verifica que a==b es falso, sin verificar
mas se deduce que a==b && b!= 0 es falso, en seguida se verifica que a> 100 es
falso, por lo tanto (a==b && b!= 0 || a> 100) es falsa

Observar que en los casos anteriores la evaluación de las expresiones fue en el

orden que marca las reglas de precedencia de los operadores.

2.4.5.1 Uso de paréntesis

El orden de precedencia de los operadores puede ser cambiada con los

paréntesis, veámoslo en el siguiente ejemplo

a-b+c*d

Por la precedencia de operadores, primero se ejecutaría el producto c * d,en

seguida el resultado se sumaráa a b y el valor obtenido se restaría a la variable a.
Es decir, si a=5, b=3, c= 2 y d=4 entonces el resultado de la operación de la
primera expresión sería c*d= 2*4 = 8, en seguida se ejecutaría b+8=3+8=11 y este
resultado será restado a a -11= 5-11= - 6.

Pero si a la misma expresión le agregamos los paréntesis

(a - b + c) * d

independientemente de las reglas de precedencia de operadores, primero se

ejecutará lo que está entre paréntesis (a - b + c) ,en seguida el resultado se
multiplicará con la variable d. Es decir, si a=5, b=3, c= 2 y d=4 entonces el
resultado de la operación (a - b + c) = (5-3+2)= 4 , luego se ejecutará 4*d=4*4=16.
Observar que los paréntesis no sólo altera el orden de precedencia de los
operadores sino también se altera el resultado de las operaciones.

Los operadores compuestos son

x = x+y también se puede ver como x += y

x=x*y también se puede ver como x *= y
x=x-y también se puede ver como x -= y
x=x/y también se puede ver como x /= y
x=x%y también se puede ver como x %= y

2.5 Palabras clave

Las palabras reservadas del lenguaje son las que definen al mismo y no pueden
ser utilizadas para nombrar identificadores dentro de un programa. Son ejemplos
de palabras reservadas
main
print
void
exit
switch
case
break
default
char
int
double
if
else
for
while
do

2.6 Bloques y sentencias

2.6.1 Sentencia condicional (if)

La sentencia if funciona de la misma manera en casi todos los lenguajes. Su

forma más sencilla es

if (condición) sentencia
donde condición es una expresión que se evalúa de falsa o verdadera (en el
lenguaje Java, verdadero es diferente de cero y falso es cero). Ejemplo

if (10 < 11) System.out.print("10 es menor que 11");

En la línea anterior, la condición es verdadera por lo tanto se imprimirá en

pantalla el mensaje dado en la instrucción System.out.print de Java.

Otra forma de manejar a la sentencia if es recurriendo al else que se leé "si

no". Si la condición es evaluada como verdadera se ejecutará el código siguiente
inmediato, pero si no lo es, se ejecutará el código que sigue del else. La estructura
general es

if (condición)
ejecuta sentencia(s) si la condición es verdadera

else
ejecuta sentencia(s) si la condición es falsa

Ejemplo

if (n < 11)
System.out.print ("%d es menor que 11" +n);

else
System.out.print ("%d es mayor o igual que 11" + n);

En el ejemplo dependerá del valor que tome "n" para ejecutar la instrucción
indicada.

Por último, veremos la sentencia if en su forma anidada. En esta sentencia

pueden existir diferentes condiciones que deben ser evaluadas, esto es, si la
condición se cumple se ejecuta el código respectivo, pero si no, se verifica la
segunda condición y, si tampoco se cumple se verifica la siguiente, así
sucesivamente hasta que alguna se cumpla o hasta llegar a un último else, en el
que se ejecuta el código respectivo dado que ninguna condición se verifico. Su
estructura general es

if (condición 1) then
ejecuta sentencia(s) si la condición 1 es verdadera
else if (condición 2) then
ejecuta sentencia(s) si la condición 2 es verdadera
...

else if (condición n) then

ejecuta sentencia(s) si la condición-n es verdadera

else
ejecuta sentencia(s) si las condiciones de la 1 a la n fueron falsas

Ejemplo en lenguaje Java

if ((n>=0)&&(n < 11))

System.out.print ("%d es mayor o igual que 0 pero menor que 11" + n);

else if ((n>=11)&&(n < 20))

System.out.print ("%d es mayor o igual que 11 pero menor que 20" + n);

else if ((n>=21)&&(n < 30))

System.out.print ("%d es mayor o igual que 21 pero menor que 30" + n);

else
System.out.print ("%d es mayor o igual 30" + n);

En el ejemplo dependerá del valor que tome n para ejecutar la instrucción

indicada.

Observe que el símbolo de comparación se escribe con dos signos igual (==),
mientras que el igual de asignación sólo se escribe con uno.

Un ejemplo para ver como se comporta la sentencia if puede ser: saber si el valor
que se proporciona es positivo o negativo.

1. import java.io.*;
2.
3. public class SentenciaIf{
4. public static void main(String [] argc)
5. {
6. BufferedReader entrada = new BufferedReader(
new InputStreamReader(
System.in) );
7. int x;
 8. String unaLinea;
9.
10. System.out.print("Introduce un valor entero ");
11. try
12. {
13. unaLinea = entrada.readLine();
14. x = Integer.parseInt( unaLinea );
15. if (x < 0)
16. System.out.println("El valor negativo
de x es " + x);
17. if (x >= 0)
18. System.out.println("El valor positivo de
x es " + x);
19. }
20. catch (Exception e)
21. {
22. System.out.println(e);
23. }
24. }
25. }

Observe que si el valor que se introduce es un número negativo, se activa la línea

16 y entonces la línea 18 no se ejecuta, debido a que la línea 17 es falso el valor
de la condición. Para este ejemplo, como la línea 17 es el complemento de la línea
15, podemos escribir en la línea 17 un else y no alterará la salida original.

Otro ejemplo, donde no es necesario utilizar else puede ser el siguiente problema:
Un programa que lea dos números y los compare, mostrando todas las
comparaciones que hizo.

1. import java.io.*;
2.
3. public class Compara{
4. public static void main(String []argc)
5. {
6. BufferedReader entrada = new
BufferedReader(
new InputStreamReader(
System.in) );
7. int x,y;
8. String unaLinea;
9.
 10. try
11. {
12. System.out.print("Dame un valor ");
13. unaLinea = entrada.readLine();
14. x = Integer.parseInt( unaLinea );
15. System.out.print("Dame otro valor ");
16. unaLinea = entrada.readLine();
17. y = Integer.parseInt( unaLinea );
18. if(x == y) System.out.println(x + " == " +
y);
19. if(x != y) System.out.println(x + " != " +
y);
20. if(x < y) System.out.println(x + " < " + y);
21. if(x > y) System.out.println(x + " > " + y);
22. if(x < = y) System.out.println(x + " <= " +
y);
23. if(x > = y) System.out.println(x + " >= " +
y);
24. }
25. catch(Exception e)
26. {
27. System.out.println("A ocurrido un error: " +
e);
28. }
29. }
30. }

El siguiente ejemplo lee dos números de punto flotante, los compara e indica el
resultado de la comparación

import java.io.*;

class mayormenor
{

public static void main(String[] args)

{
BufferedReader entrada = new BufferedReader( new InputStreamReader(
System.in) );
double a, b;
String unaLinea;
try
{
System.out.print("\n \nInicio \n\nIntroduce un valor entero: ");
unaLinea = entrada.readLine();
a= Double.parseDouble( unaLinea );
 System.out.print("Introduce otro valor entero: ");
unaLinea = entrada.readLine();
b=Double.parseDouble( unaLinea );

if (a > b)
System.out.println("\n\n" + a + " es mayor que " + b + "\n\n \n Fin\n");
else if(a == b )
System.out.println("\n\n"+ a + " es igual que " + b + "\n\n \n Fin\n");
else
System.out.println("\n\n" +a + " es menor que " + b + "\n \n \n Fin\n");
}
catch (Exception e)
{
System.out.println(e);
}

}
}

2.6.2 Sentencias de ciclo (while, do-while, for)

Las sentencias de ciclo, también denominadas bucles, permiten ejecutar en forma

repetitiva (o iterativa) el conjunto de instrucciones definidas dentro de ellas. Son
ejemplo de estas sentencias el while, do-while y for, que enseguida se describirán.

Uso de while

El bucle while presenta la siguiente estructura en su forma más sencilla es

while (condición) sentencia;

donde sentencia puede ser una sentencia vacía, una sentencia única o un bloque
de sentencias que se repetirán mientras la condición sea verdadera. La condición
es una expresión que se evalúa de falsa o verdadera cada vez que se repite el
bucle. El bucle itera mientras la condición sea verdadera. Cuando llega a ser falsa,
el control del programa pasa a la línea que sigue al bucle. Ejemplo

int con=0;
while(con != -1)
System.out.println("\n Repitiendo . El valor de cont es " + con+ "\nFin");

En la línea anterior, la variable con se estará leyendo indefinidamente hasta que el

usuario introduzca un -1
El while comprueba la condición en lo alto del bucle, lo que significa que el código
del mismo no se ejecuta siempre. Por esta razón es necesario inicializar a con=0
antes del while.

Para ejemplificar el uso de la sentencia, trabajaremos el ejemplo que utilizamos

anteriormente; la sumatoria. El programa debe de quedar así:

1. import java.io.*;
2.
3. public class SentenciaWhile{
4. public static void main(String [] argc)
5. {
6. BufferedReader entrada = new BufferedReader( new InputStreamReader(
System.in) );
7. int n,suma=0,i=1;
8. String unaLinea;
9.
10. System.out.print("Hasta que numero deseas la suma ");
11. try
12. {
13. unaLinea = entrada.readLine();
14. n = Integer.parseInt( unaLinea );
15. while ( i<=n)
16. {
17. suma += i;
18. i++;
19. }
20. System.out.print("la suma desde 1 hasta " + n + " es " + suma);
21. }
22. catch (Exception e)
23. {
24. System.out.println(e);
25. }
26. }
27. }

Observe que aquí el alcance de la sentencia while abarca 2 sentencias, es por ello
que se necesitan las llaves. Es posible reducir las líneas 17 y 18 por la línea

suma += i++;

Uso de do-while

Al contrario del while el bucle do-while examina la condición en la parte baja. Esta
característica provoca que el do-while siempre se ejecute almenos una vez . La
forma general del bucle es
do{

sentencia

} while (condición) ;

La condición es una expresión que se evalúa de falsa o verdadera cada vez que
se repite el bucle. El bucle itera mientras la condición sea verdadera. Cuando llega
a ser falsa, el control del programa pasa a la línea que sigue al bucle. Ejemplo

int con;
do {

System.out.println("\n Repitiendo . El valor de cont es " + con+ "\nFin");

}while(con != -1) ;

En la línea anterior, la variable con se estará leyendo indefinidamente hasta que el

usuario introduzca un -1 . La diferencia con el ejemplo del while es que en este
caso no necesita inicializarse la variable con ya que se ejecuta almenos una vez el
código interno del bucle.

Ahora mostraremos como se haría el mismo programa pero utilizando la sentencia

do_while:

1. import java.io.*;
2.
3. public class SentenciaDoWhile{
4. public static void main(String [] argc)
5. {
6. BufferedReader entrada = new BufferedReader( new InputStreamReader(
System.in) );
7. int n,suma=0,i=1;
8. String unaLinea;
9.
10. System.out.print("Hasta que numero deseas la suma ");
11. try
12. {
13. unaLinea = entrada.readLine();
14. n = Integer.parseInt( unaLinea );
15. do
16. {
17. suma += i;
18. i++;
19. }while ( i<=n);
20. System.out.print("la suma desde 1 hasta " + n + " es " + suma);
21. }
22. catch (Exception e)
23. {
24. System.out.println(e);
 25. }
26. }
27. }

Como se darán cuenta, los problemas se pueden resolver de diferente manera y

obtener los mismos resultados. Este ejemplo que acabamos de mostrar, es uno
muy bueno para probar esta afirmación. Pero surge una pregunta, ¿Funcionan de
la misma manera las tres sentencias vistas anteriormente? La respuesta esta en el
viento. Quizá dependa del problema, cual de ellas utilizar. Por ejemplo, si
corremos el programa, SentenciaWhile y pide que calcule la suma hasta -1, saldrá
como resultado 0, en cambio si ejecutan el programa SentenciaDoWhile y piden
calcular la suma hasta -1 saldrá como resultado 1. ¿Por qué? La respuesta es
sencilla, para el while primero hace la comparación, si es verdadera, realiza lo que
contenga el alcance del while, si es falsa no realiza esa parte del alcance del
while. En cambio, la sentencia do_while primero realiza el alcance de la sentencia
do_while y después hace la comparación, si es verdadera se regresa a la línea del
do, si no se sigue con la siguiente línea.

Uso de for

Por otra parte el bucle for requiere de un variable inicializada con un valor, a partir
de él, la variable se actualiza según el incremento o decremento definido por el
programador, el ciclo for repetirá las sentencias definidas dentro de él, hasta que
el valor de dicha variable alcance el valor impuesto por la condición de paro dada
por el programador. A continuación se presenta la estructura en su forma más
sencilla

for (inicialización, condición de paro, incremento o decremento) sentencia;

donde inicialización asigna un valor inical a la variable de control del bucle. La

condición es una expresión que se evalúa de falsa o verdadera cada vez que se
repite el bucle. El bucle se repite mientras la condición es verdadera. El
incremento o decremento es el valor en el que se incrementará o decrementará la
variable de control. Ejemplo en lenguaje C

int contador;
for(contador =1; contador<=100; contador++)
System.out.println("\n Repitiendo . El valor de cont es " + contador+ "\nFin");

En la línea anterior, el contador se inicializa con 1, cada vez que se repite el

bucle, el programa comprueba la condición contador < =100. Si la condición es
verdadera, el programa ejecuta la sentencia println() e incrementa en uno al
contador. Cuando contador es más grande que 100, la condición el falsa y el bucle
se detiene. Se imprimirán en pantalla los números del 1 al 100.

repetitivas. Una de ellas es la sentencia for, la cual utiliza las siguientes sintaxis:

Tipo 1.
for(inicio;condición;incremento)
sentencia;

Tipo 2.
for(incio;condición;incremento)
{
Cuerpo;
}

Un ejemplo que nos ayudará a comprender como se utiliza la sentencia for es el

problema de la sumatoria. Consiste en esperar un número n tal que hay que
calcular la suma total desde 1+2+3+…+n. La forma que se utilizará para resolver
el problema es: 1+2=3, 3+3=6, 6+4=10, y así sucesivamente hasta alcanzar el
valor n. Los resultados: 3, 6, 10, etc. Se van almacenando en una variable llamada
suma. Y el programa quedaría así:

1. import java.io.*;
2.
3. public class SentenciaFor{
4. public static void main(String [] argc)
5. {
6. BufferedReader entrada = new BufferedReader( new InputStreamReader(
System.in) );
7. int n,suma=0,i;
8. String unaLinea;
9.
10. System.out.print("Hasta que numero deseas la suma ");
11. try
12. {
13. unaLinea = entrada.readLine();
14. n = Integer.parseInt( unaLinea );
15. for ( i=1 ; i<=n; i++)
16. {
17. suma += i;
18.
19. }
20. System.out.print("la suma desde 1 hasta " + n + " es " + suma);
21. }
22. catch (Exception e)
23. {
24. System.out.println(e);
25. }
 26. }
27. }

Es interesante observar que si ejecutan el programa, le pedimos la suma desde 1

hasta 10 el resultado es 55. Desde 1 hasta 100 es 5050. Desde 1 hasta 1000 es
500500. Y así sucesivamente. (Curioso ¿no?).

La corrida funciona de la siguiente manera: toma el valor de i=1 y después hace la

comparación en la condición (i<=n), si es verdadera realiza la sentencia en la línea
17, después se incrementa el valor de i y vuelve a la comparación; si es falsa se
salta a la línea 20.

Observe que aquí se utilizaron las llaves para indicar para una sentencia, dichas
llaves pueden ser eliminadas sin afectar al programa..

La sentencia for( ; ; ) genera un ciclo infinito, el cuál nunca parará de ejecutarse.

2.6.3 Selección múltiple (switch o select-case)

La sentencia de selección múltiple es de gran utilidad en los casos en los que se

desea dar al usuario un conjunto de opciones de las cuales el podrá elegir alguna.
Su funcionamiento es el siguiente: se leé la elección del usuario, en seguida se
verifica si coinside con alguna de las opciones que se presentan, en el caso de
que así sea, se ejecuta el código respectivo de dicha opción. De todas las
opciones únicamente se ejecuta la seleccionada por el usuario. Ejemplo, en
lenguaje C esta opción se maneja a través de la sentencia switch y su formato
general es

switch(x)
{
case 1: codigo respectivo de esta opción
break;

case 2: codigo respectivo de esta opción

break;
...

case n: codigo respectivo de esta opción

default

codigo respectivo
}

La sentencia break rompe el ciclo del programa y se salta hasta donde se

encuentre una llave que cierra ( "}" ). Cuando el programa llega a una sentencia
switch, activa una bandera para dirigirse al posible valor de la variable, no
compara valor por valor (como lo haría el if). Esto le da más velocidad a la
ejecución del programa. Mostraremos un ejemplo con el problema puesto al final
de la sección anterior.

1. import java.io.*;
2.
3. public class SentenciaSwitch{
4. public static void main(String [] argc)
5. {
6. BufferedReader entrada = new BufferedReader( new InputStreamReader(
System.in) );
7. int x;
8. String unaLinea;
9.
10. System.out.print("Introduce el numero de dia (0-6) ");
11. try
12. {
13. unaLinea = entrada.readLine();
14. x = Integer.parseInt( unaLinea );
15. System.out.print("El dia escogido es ");
16. switch(x){
17. case 0: System.out.println("Lunes");
18. break;
19. case 1: System.out.println("Martes");
20. break;
21. case 2: System.out.println("Miercoles");
22. break;
23. case 3: System.out.println("Jueves");
24. break;
25. case 4: System.out.println("Viernes");
26. break;
27. case 5: System.out.println("Sabado");
28. break;
29. case 6: System.out.println("Domingo");
30. break;
31. default: System.out.println("No existe");
32. break;
33. }
34. }
35. catch (Exception e)
36. {
37. System.out.println(e);
38. }
39. }
40. }
Es importante recordar que la función que realiza el break es muy importante. Si el
break no estuviera, el programa se sigue a la siguiente línea.

Otro programa que podemos ver como ejemplo para el switch es uno que
llamaremos calculadora. Este programa va a recibir dos valores enteros y un
operador, ya sea '+' o '*'. Según el operador calculará el resultado.

1. import java.io.*;
2. import java.lang.*;
3.
4. public class Calculadora{
5. public static void main(String [] argc)
6. {
7. int val1,val2;
8. BufferedReader entrada = new BufferedReader( new InputStreamReader(
System.in) );
9. String unaLinea;
10. char operador;
11. try
12. {
13. unaLinea = entrada.readLine();
14. val1 = Integer.parseInt( unaLinea );
15. unaLinea = entrada.readLine();
16. val2 = Integer.parseInt( unaLinea );
17. unaLinea = entrada.readLine();
18. operador = unaLinea.charAt(0);
19. switch(operador)
20. {
21. case '+': System.out.println(val1 + " + " + val2 + " = " + (val1+val2));
22. break;
23. case '*': System.out.println(val1 + " * " + val2 + " = " + (val1*val2));
24. break;
25. default : System.out.println("No existe opcion");
26. break;
27. }
28. }
29. catch(Exception e)
30. {
31. System.out.println("Ocurre un error: " + e);
32. }
33. }
34. }

En la línea 18 dice: unaLinea.charAt(0); La función charAt es una función miembro

de la clase String. Lo que implica que todos los objetos de tipo String pueden
manipularla, y está definida en la librería lang, como se observa en la línea 2. La
función se encarga de extraer algún carácter de la cadena. El carácter que extrae
de la cadena para este caso es el primero.

2.7 Comentarios

En Java para poner comentarios dentro de un progama puede ser de las formas
siguientes

• /* */ :Para encerrar varias líeas, y

Por ejemplo

/* esta forma de comentario puede

encerrar a varias lineas */

• // :Para indicar que apartir de donde se colocaron hasta el final de la línea

es un comentario

Por ejemplo

//Esta línea es un comentario

• /** */ :Tiene una función similar al comentario de varias líneas con la

diferencia que el texto que encierra será usado para un procesamiento
especial que lleva acabo la herramienta javadoc

Por ejemplo

/** esta forma de comentario puede

encerrar a varias lineas que usará javadoc*/

Los comentarios en java no tienen nigún efecto en la compilación ni ejecución (de

hecho son eliminados en la etapa de preprocesador) y se utilizan para documentar
el programa.