Lección 4
From: "Angel Huamani Mejia" Organization: Univ.
Peruana de Ciencias Aplicadas To: java@rcp.net.pe
Date: Fri, 26 Jul 1996 13:40:17 -0500
MIME-Version: 1.0
Subject: java: Leccion #4
Priority: urgent
Sender: java-owner@rcp.net.pe
RCP-Comentario: Lista java
Saludos Amigos,
Aqui la leccion No. 4, proximamente estas lecciones estaran disponibles en el
servidor de la Universidad Peruana de Ciencias Aplicadas en la URL:
http://www.upc.edu.pe/java/java.html por ahora eso es todo, nos vamos a un
almuerzo a celebrar las fiestas patrias aqui en el Peru.
!por cierto , felices fiestas patrias a todos los peruanos, donde quiera que se
encuentren!.
Viva el Peru.
==================== Leccion #4 =================
MAS SOBRE IMPORT
Para utilizar los objetos contenidos en un paquete, bien sea creado por ustedes
o incluido con el entorno de programacion de java, es necesario importar dichos
paquetes.
Por ejemplo para importar un objeto similar a "Applet" del paquete de clases
"java.applet" se debera utilizar la siguiente instruccion:
import java.applet.Applet;
Y para importar todos los objetos del paquete entonces se escribe:
import java.applet.*;
Al importar todos los objetos o solamente uno del paquete de clases, estamos
creando la definicion e implementacion disponible para el paquete actual,
supongamos:
class NuestorApplet extends Applet {
. . .
}
OBS: Recuerde lo de las subclases.
Ahora si ustedes intentan compilar este applet sin importar la clase:
java.applet.Applet
Entonces, el compilador se "molestara" y enviara un mensaje de error con algo
similar a:
"Super class Applet of class NuestroApplet not found"
INSTRUCCIONES DE BLOQUE
-----------------------------------------
Un bloque es un conjunto de sentencias encerradas por ({}) por ejemplo:
void bloque() {
int a = 20;
{ // Aqui empieza el bloque, Ah esto es un comentario.
int b = 30;
System.out.println("Aqui estamos dentro del bloque:"); System.out.println("a:" +
a);
System.out.println("b:" + b);
} // Fin del bloque.
}
CONDICIONALES: IF
----------------------------
La sentencia condicional (if) permite ejecutar codigo java de manera muy similar
a la sentencia (if) en el lenguaje C, (if) es la palabra reservada de esta
condicional seguido por una expresion_booleana y una sentencia o bloque de
sentencias, las cuales seran ejecutadas si la expresion_booleana es verdadera.
if (edad < 18)
system.out.println("No se admiten menores de edad.");
ademas existe la palabra reservada (else), que permite ejecutar una sentencia o
un bloque de sentencias si la expresion_booleana es falsa.
if (edad < 18)
system.out.println("No se admiten menores de edad."); else
system.out.println("Bienvenido, pase adelante.");
operador condicional
-------------------- -----------------
otro modo de utilizar la condicional (if)..(else) es usar el operador concional
(?) el cual tiene la siguiente sintaxis:
expresion_booleana ? valor_true : valor_false
en una sentencia de este tipo el operador condicional solo permite retornar un
valor si al evaluar la expresion_booleana es verdadera, entonces el operador
condicional retorna el valor_true, de lo contrario retorna valor_false este
operador es usado para condicionales pequeñas.
ejemplo, el mayor de 2 numeros a y b:
int mayor = a > b ? a : b;
CONDICIONALES SWITCH
------------------------------------
Para evitar el uso repetido de la sentencia (if), al evaluar el valor de algunas
variables por ejemplo:
if (evento == MouseClick)
Sentencia o bloque;
else if (evento == Drop)
Sentencias o bloque;
else if (evento == Fail)
Sentencias o bloque;
else if (evento == Complete)
Sentencias o bloque;
Este tipo de sentencias (if), es conocida como los (if) anidados.
En java existe un forma mas abreviada de de manejar los (if) anidados esto es
usando la sentencia (switch), cuya sintaxis:
switch (Evaluar) {
case valor1:
Sentencia o bloque;
break;
case valor2:
Sentencia o bloque;
break;
case valor3:
Sentencia o bloque;
break;
...
default: Sentencia o bloque por defecto; }
En la sentencia (switch), el testeo es comparado con cada uno de los valores
(case) si se encuentra una coincidencia la sentencia o sentencias despues del
case es ejecutada.
Si no se encuentran coincidencias, la sentencia (default) es ejecutada, la
sentencia (default) es opcional.
Como varia el ejemplo del (if) anidado con la sentencia (switch):
switch (evento) {
case MouseClick:
Sentencia o bloque;
break;
case Drop:
Sentencia o bloque;
break;
case Fail:
Sentencia o bloque;
break;
case Complete:
Sentencia o bloque;
break;
default: Sentencia o bloque por defecto; }
Por ejemplo en el siguiente ejemplo:
(Num, es un numero par) sera impreso si Num, tiene como valor: 2,4,6 o 8
cualquier otro valor de Num, imprimira (Num, es un numero impar)
switch (Num) {
case 2:
case 4:
case 6:
case 8:
System.out.println("Num, es un numero par"); break;
default: System.out.println("Num, es un numero impar"); }
BUCLES FOR
-----------------
El bucle (for) en java, funciona de manera similar que en C, repite una
sentencia o bloque de sentencias un numero de veces hasta que alguna condicion
se cumpla.
for (Valor_de_inicio; Expresion_booleana; Incremento) {
sentencias o bloque;
}
Explicando las secciones:
Valor_de_inicio:
Aqui debera indicar cual es el valor con el que comenzara el bucle por ejemplo:
int cont = 0
Las variables que se declaren en esta seccion del bucle seran locales para el
bucle estas dejan de existir cuando el bucle a terminado.
Expresion_booleana:
Aqui se chequea la expresion_booleana despues de cada paso por el bucle por
ejemplo: cont < 50 ,si el resultado es verdadero entonces se ejcuta el bucle. si
es falso para la ejecucion.
incremento:
el incremento permite cambiar el valor del indice del bucle.
revise, que es lo que hace este codigo e intente explicarlo?
string strarray[] = new string[15];
int num; // indice del bucle
for (num = 0; num < strarray.length; num++)
strarray[num] = "";
bucle do while:
-------------------------
do {
cuerpo
} while (condicion)
el bucle do {cuerpo} while (condicion) es similar a un bucle while (condicion)
{cuerpo} puesto que ejecutan una sentencia o bloque de sentencias (cuerpo) hasta
que la condicion sea falsa. la principal diferencia es que while (condicion)
{cuerpo} testea la condicion antes de ejecutar el bloque sentencias (cuerpo),
mientras que do {cuerpo} while (condicion) lo hace al final del bloque de
sentencias. de esta manera siempre se ejecutaran al menos una vez las sentencias
en un bucle do {cuerpo} while (condicion) aunque la condicion sea falsa; puesto
que primero se ejecuta el bloque de sentencias y luego se evalua la condicion.
ejemplo :
int a = 1;
do {
system.out.println("Iteraccion : " + a); a++;
} while (a <= 10);
este codigo de programa se ejecuta en los siguientes pasos :
1.- primero se crea e inicializa la variable a con el valor 1. 2.- se ejecuta la
instruccion system.out.println("Iteraccion : " + a); que hace que se imprima en
la salida estandar (pantalla por defecto) iteraccion : (valor de a).
3.- se incrementa la variable a en 1.
4.- se evalua la condicion (a <= 10) que produce un valor verdadero o
falso. si esta condicion es verdadera se ejecuta nuevamente el paso 2; de lo
contrario continua con la siguiente instruccion debajo del do..while.
la salida que produciria seria :
iteraccion : 1
iteraccion : 2
iteraccion : 3
iteraccion : 4
iteraccion : 5
iteraccion : 6
iteraccion : 7
iteraccion : 8
iteraccion : 9
iteraccion : 10
breaking out of loops (ruptura del bucle)
----------------------------------------- en todos los bucles (for, while y do),
el bucle finaliza cuando la condicion no se cumple. algunas veces puede ocurrir
que se quiera salir del bucle antes de evaluarse la condicion, es decir romper
el bucle. para esto se usan las sentencias break y continue.
si se esta usando break como parte de una sentencia switch; este para la
ejecucion del switch y el programa continua. cuando se usa la sentencia break en
un loop, para la ejecucion del loop actual y ejecuta la siguiente sentencia
luego del loop. cuando se usa en bucles anidados el programa salta a la
siguiente instruccion al final del bucle y ejecuta las instrucciones del bucle
anterior.
por ejemplo :
int contador = 0;
while (contador < array1.length) {
if (array1[contador] == 0) {
break;
}
array2[contador] = (float) array1[contador++]; }
en este ejemplo se copian elementos del array1 (array de enteros) al array2
(array de floats) hasta que todos los elemenos del array1 sean copiados o que el
valor al que se hace referencia para copiar del array1 sea 0. el primer valor
del array1 que coincida con 0 no es copiado al array2 y la sentencia break hace
que la ejecucion del programa se traslade a la siguiente instruccion luego del
bucle.
continue es similar a break excepto que en vez de romper la ejecucion del bucle
hace que la ejecucion del programa se traslade a la evaluacion de la condicion
del bucle y comience una nueva iteraccion, dejando sin efecto la ejecucion de
las instrucciones que estan debajo de la instruccion continue.
ejemplo :
int contador1 = 0;
int contador2 = 0;
while (countador1 < array1.length) {
if (array1[contador1] == 0) {
contador1++;
continue;
}
array2[contador2++] = (float)array1[contador1++]; }
en este ejemplo se copian solo los elementos del array1 (array de enteros)
que no sean 0 al array2, la sentencia continue en este caso nos sirve para
que la ejecucion del programa se traslade nuevamente a la evaluacion de la
condicion y el elemento del array1 no se copie al array2
labeled loops (bucles etiquetados)
----------------------------------
break y continue pueden opcionalmente contener etiquetas, estas le dicen a java
donde debe saltar la ejecucion del programa.
para usar un bucle etiquetado, adicionar la etiqueta seguida de dos puntos (:)
antes del comienzo del bucle. luego cuando uses break o continue con el nombre
de esta etiqueta, la ejecucion se trasladara a la instruccion que esta luego de
la etiqueta.
por ejemplo :
fuera:
for (int i = 0; i < 10; i++) {
while (x < 50) {
if (i * x == 400)
break fuera;
...
}
...
}
cuando este fragmento de codigo se ejecute y se cumpla que la multiplicacion de
i * x sea igual a 400 la ejecucion del programa se trasladara a la instruccion
que le sigua a la etiqueta fuera: que viene a ser el bucle for.
aqui otro ejemplo :
fuera:
for (int i = 1; i <= 5; i++)
for (int j = 1; j <= 3; j++) {
system.out.println("i es " + i + ", j es " + j); if ((i + j) > 4)
break fuera;
}
System.out.println("Final de bucles");
Aqui la salida que produciria el programa :
i es 1, j es 1
i es 1, j es 2
i es 1, j es 3
i es 2, j es 1
i es 2, j es 2
i es 2, j es 3
Final de bucles
Hasta la proxima leccion,
Angel Huamani Mejia/ ahuamani@beta.upc.edu.pe Victor Anorga Zavala /
vanorga@beta.upc.edu.pe
[ Home Page | Lugares Internesantes | Indice de las lecciones ]
© 1996 Descarado Software Limited Co..
Si quieres comentarme algo, hazlo
en Jose Arcos
ó en mi dirección de FidoNet 2:346/207.68