Tema 3 - Sentencias de Control de Java

ITSON Manuel Domitsu Kono
Tema 3
Sentencias de Control de Java

Sentencias

Las sentencias son las instrucciones de las que est formado un programa. Las
sentencias en un programa en J ava se encuentran en el cuerpo de los mtodos,
incluyendo los constructores de las clases.

Las sentencias en J ava se clasifican de la siguiente manera:

Sentencia de expresin o simple
Sentencia compuesta o bloque
Sentencias de seleccin o condicionales
Sentencias de iteracin o repetitivas
Sentencias de salto
Sentencia de Expresin o Simple

La mayora de las sentencias de un programa en J ava son sentencias de expresin. Una
sentencia de expresin tiene la siguiente sintaxis:

[ expresin] ;

Esto es, una expresin seguida de un punto y coma (;). La mayora de las sentencias de
expresin son asignaciones o invocaciones a mtodos. Si expresin se omite, la
construccin se llama sentencia nula.

El punto y coma (;) es un terminador de sentencia.

Algunos ejemplos de sentencias expresin son:

y = x + 3;
n++;
t hi s. t i t ul o = t t ul o;
Syst em. out . pr i nt l n( "\ nHol a") ;
; / / sent enci a nul a
66 Sentencias de Control de Java

Sentencia compuesta o bloque

Una sentencia compuesta o bloque son construcciones que contienen otras sentencias
las cuales se debern ejecutar en secuencia. La sintaxis de una sentencia compuesta es:

{
[ Declaracin local] . . .

sentencia . . .
}

Una sentencia compuesta est formada de declaraciones locales y sentencias. Los
objetos declarados localmente son slo conocidos dentro de la sentencia compuesta en
que fueron declarados. Las sentencias dentro de una sentencia compuesta pueden se de
cualquier tipo: sentencias de expresin, sentencias compuesta, sentencias de seleccin,
sentencias repetitivas, sentencias de salto. Note que dentro de una sentencia compuesta
podemos tener anidadas sentencias compuestas.

Una sentencia compuesta va encerrada entre llaves {y }.

Una sentencia compuesta es sintcticamente equivalente a una sentencia simple, esto es,
donde puede ir una sentencia simple podemos poner una sentencia compuesta y
viceversa.

Un ejemplo de una sentencia compuesta es el cuerpo de un mtodo.
Ejemplo sobre la sentencia Compuesta

Como un ejemplo de una sentencia compuesta, considere el constructor de la clase
Cancin, del problema sobre el amante de la msica y el cine, que recibe como
parmetros los valores para inicializar los atributos de la clase:

publ i c Canci on( St r i ng cl ave, St r i ng t i t ul o, Gener o gener o,
St r i ng i nt er pr et e, St r i ng aut or , St r i ng al bum, i nt dur aci on,
Fecha f echa) {
t hi s. t i t ul o = t i t ul o;
t hi s. gener o = gener o;
t hi s. i nt er pr et e = i nt er pr et e;
t hi s. aut or = aut or ;
t hi s. al bum= al bum;
t hi s. dur aci on = dur aci on;
t hi s. f echa = f echa;
}

Cada una de las lneas de cdigo del cuerpo del constructor es una sentencia simple y
todas juntas constituyen una sentencia compuesta.
Tema 3 Sentencias de Control de Java 67
Sentencias de Seleccin o
Condicionales

Hay ocasiones en las que deseamos que, dependiendo del valor de una expresin, la
computadora ejecute una de dos o ms sentencias compuestas. Las sentencias que nos
permiten realizar tal tarea se conocen como sentencias de seleccin o condicionales.
En J ava existen dos sentencias condicionales: La sentencia if y la sentencia switch.
Sentencia if

La sentencia if nos permite seleccionar entre ejecutar una de dos sentencias compuestas,
dependiendo del resultado de una expresin. La sintaxis de la sentencia if es la siguiente:

if(expresin) sentencia1 [ else sentencia2]

expresin debe ser de tipo booleano. sentencia1 y sentencia2 son sentencias
compuestas.

Primero se evala expresin, si su valor es verdadero, se ejecuta sentencia1 y
despus el programa contina con la sentencia que sigue a la sentencia if; si el valor de
expresin es falso se ejecuta sentencia2 y luego contina con la sentencia despus
de la sentencia if.

Si else sentencia2 no aparece y expresin es verdadera se ejecuta sentencia1 y el
programa contina con la sentencia despus de la sentencia if. De otro modo no se
ejecuta sentencia1 y el programa salta a ejecutar la sentencia despus de la sentencia
if.

Una sentencia if puede estar anidada dentro de otra sentencia if, por ejemplo:

if(expresin1)
if(expresin2) sentencia1
else sentencia2
else
else sentencia4;

escalonados como en el siguiente ejemplo:

else if(expresin2) sentencia2
else sentencia4;


Esta ltima construccin se acostumbra escribir de la siguiente manera para que los
sangrados no crezcan demasiado:

else sentencia4

En los casos donde tenemos sentencias if anidadas podra surgir la pregunta de a qu if
le corresponde cul else. La regla en estos casos es que un else se asocia con el if
anterior ms cercano si es que no est ya asociado con un else.
Ejemplo sobre la sentencia if

El costo de un telegrama ordinario es de $25.00 si el nmero de palabras es hasta 10, por
cada palabra adicional se cobra $2.50. Si el telegrama es urgente los costos son de
$40,00 y $4.00 respectivamente. Escribir una clase permita crear telegramas y determine
su costo.

El cdigo de la clase Telegrama es la siguiente:

/ *
* Tel egr ama. j ava
*
* Cr eada el 10 de oct ubr e de 2005, 12: 36 PM
*/

package t el egr ama;

/ **
* Est a cl ase per mi t e cal cul ar el cost o de un t el egr ama
* I l ust r a el uso de l a sent enci a i f
*
* @aut hor mdomi t su
*/
publ i c cl ass Tel egr ama {
pr i vat e f i nal doubl e COSTO_ORDI NARI O = 25. 0;
pr i vat e f i nal doubl e COSTO_URGENTE = 40. 0;
pr i vat e f i nal doubl e COSTO_ADI CI ONAL_ORDI NARI O = 2. 5;
pr i vat e f i nal doubl e COSTO_ADI CI ONAL_URGENTE = 4. 0;
pr i vat e St r i ng t i poTel egr ama;
pr i vat e i nt numPal abr as;
pr i vat e doubl e cost o;

publ i c Tel egr ama( St r i ng t i poTel egr ama, i nt numPal abr as) {
t hi s. t i poTel egr ama = t i poTel egr ama;
t hi s. numPal abr as = numPal abr as;
cost o = cal cul aCost o( ) ;
}

publ i c doubl e cal cul aCost o( ) {
i f ( t i poTel egr ama. char At ( 0) == ' O' | | t i poTel egr ama. char At ( 0) == ' o' )
i f ( numPal abr as <= 10) r et ur n COSTO_ORDI NARI O;
el se r et ur n COSTO_ORDI NARI O +
COSTO_ADI CI ONAL_ORDI NARI O * ( numPal abr as - 10) ;
el se i f ( t i poTel egr ama. char At ( 0) == ' U' | | t i poTel egr ama. char At ( 0) == ' u' )
i f ( numPal abr as <= 10) r et ur n COSTO_URGENTE;
el se r et ur n COSTO_URGENTE + COSTO_ADI CI ONAL_URGENTE * ( numPal abr as - 10) ;
el se r et ur n 0;
}

publ i c St r i ng t oSt r i ng( ) {
r et ur n t i poTel egr ama + ", " + numPal abr as + ", " + cost o;
}
}
Sentencia switch

Un caso especial de una construccin con varios if escalonados y que aparece con
bastante frecuencia en los programas, tiene la siguiente forma:

if(expresin == cte1) sentencia1
else if(expresin == cte2) sentencia2
else if(expresin == cte3) sentencia3
. . .
else sentencia

donde expresin es una expresin de tipo entero, cte1, cte2, cte3, ... son constantes
de tipo entero y sentencia1, sentencia2, ... , sentencia son sentencias
compuestas. La construccin anterior puede simplificarse utilizando la sentencia switch.
La sintaxis de una sentencia switch es la siguiente:

switch(expresin) {
case cte1: [ sentencia1]
[ break;]
[ case cte2: [ sentencia2]
[ break;] ] . . .

[ default: [ sentencia]
[ break;] ]
}

expresin es una expresin de tipo char, byte, short, o int, y se conoce como el
selector del switch.

cte1, cte2, ... son constantes de tipo char, byte, short, o int. En una sentencia switch
no puede haber dos constantes iguales.

Primero se evala expresin y luego se ejecuta la sentencia compuesta que est
asociada a la constante que es igual al valor de expresin. Despus de ejecutar esa
sentencia, se ejecutan en secuencia todas las sentencias que le siguen hasta encontrar

una sentencia break. Al encontrarse con una sentencia break, el programa contina con
la sentencia despus de la sentencia switch.

Si ninguna constante coincide con el valor de expresin entonces se ejecuta la sentencia
asociado con la etiqueta default. Si sta no existe, el programa contina con la sentencia
despus del switch.

La sentencia asociada a la etiqueta default no tiene que ser la ltima sentencia dentro de
una sentencia switch. Puede ir en cualquier lugar, por ejemplo:

switch(expression {
case cte1: sentencia1
break;
break;
default: sentencia
break;
break;
}

switch(expresin) {
default: sentencia]
break;
break;
break;
break;
}
Ejemplo sobre la sentencia switch

El siguiente cdigo es una modificacin de la clase telegrama para que el mtodo
calculaCosto() emplee una sentencia switch en lugar de ifs anidados.

/ *
* Tel egr ama2. j ava
*
*/

package t el egr ama;

/ **
* Est a cl ase per mi t e cal cul ar el cost o de un t el egr ama.
* I l ust r a el uso de l a sent enci a swi t ch
*
*/
publ i c cl ass Tel egr ama2 {
pr i vat e f i nal doubl e COSTO_ORDI NARI O = 25. 0;
pr i vat e f i nal doubl e COSTO_URGENTE = 40. 0;
pr i vat e f i nal doubl e COSTO_ADI CI ONAL_ORDI NARI O = 2. 5;
pr i vat e f i nal doubl e COSTO_ADI CI ONAL_URGENTE = 4. 0;
pr i vat e St r i ng t i poTel egr ama;
pr i vat e i nt numPal abr as;
pr i vat e doubl e cost o;

publ i c Tel egr ama2( St r i ng t i poTel egr ama, i nt numPal abr as) {
t hi s. t i poTel egr ama = t i poTel egr ama;
t hi s. numPal abr as = numPal abr as;
cost o = cal cul aCost o( ) ;
}

swi t ch( t i poTel egr ama. char At ( 0) ) {
case ' O' :
case ' o' :
i f ( numPal abr as <= 10)
r et ur n COSTO_ORDI NARI O;
el se
r et ur n COSTO_ORDI NARI O + COSTO_ADI CI ONAL_ORDI NARI O *
( numPal abr as - 10) ;
case ' U' :
case ' u' :
r et ur n COSTO_URGENTE;
el se
r et ur n COSTO_URGENTE + COSTO_ADI CI ONAL_URGENTE * ( numPal abr as - 10) ;
def aul t :
r et ur n 0;
}
}

publ i c St r i ng t oSt r i ng( ) {
r et ur n t i poTel egr ama + ", " + numPal abr as + ", " + cost o;
}
}
Sentencias de Iteracin o Repetitivas

Hay ocasiones que se requiere que una sentencia compuesta se ejecute varias veces,
posiblemente cambiando los valores de las expresiones contenidas en sta. Por ejemplo,
supongamos que deseamos crear una tabla del capital acumulado de una cantidad
invertida a una tasa de inters anual y recapitalizado mensualmente. En este ejemplo,
para cada mes es necesario determinar el capital acumulado e imprimir el resultado. Este
proceso se repetir tantas veces como el nmero de meses que deseemos tabular. Las
sentencias que nos permiten realizar tal tarea se conocen como sentencias de iteracin

o repetitivas. En J ava existen tres tipos de sentencias repetitivas: La sentencia while, la
sentencia for y la sentencia do - while.
Sentencia while

La sentencia while nos permite ejecutar una sentencia compuesta, mientras se cumpla
una condicin. La sintaxis para esta sentencia es la siguiente:

while(expresin) sentencia

expresin debe ser de tipo booleano. sentencia es una sentencia compuesta.

La sentencia while opera de la siguiente manera: Primero se evala expresin. Si su
valor es verdadero, se ejecuta sentencia y expresin es evaluada de nuevo,
repitindose el ciclo hasta que expresin resulta falsa. Cuando esto ltimo ocurre el
ciclo termina y el programa contina con la siguiente instruccin despus del ciclo.

Si expresin es falsa al principio del ciclo, sentencia no se ejecuta ni una vez.
Ejemplo sobre la sentencia while

Se desea una clase llamada Capital para estudiar el comportamiento del capital
acumulado de una inversin, a una tasa de inters anual, con recapitalizacin mensual.
Se requiere un mtodo que tabule el capital acumulado mensualmente. La salida del
programa ser una tabla de la forma:

Mes Capi t al
- - - - - - - - - - - - - - -
1 dddd. dd
2 dddd. dd
. . .

/ *
* Capi t al . j ava
*
*/

package capi t al ;

/ **
* Est a cl ase per mi t e t abul ar el capi t al acumul ado de una i nver si n,
* a una t asa de i nt er s anual , con r ecapi t al i zaci n mensual .
* I l ust r a el uso de l a sent enci a whi l e
*
*/
publ i c cl ass Capi t al {
pr i vat e doubl e capi t al ;
pr i vat e doubl e t asa;
pr i vat e i nt meses;

publ i c Capi t al ( doubl e capi t al , doubl e t asa, i nt meses) {
t hi s. capi t al = capi t al ;
t hi s. t asa = t asa;
t hi s. meses = meses;
}

publ i c voi d t abl a( ) {
i nt mes = 1;
doubl e capi t al = t hi s. capi t al ;

Syst em. out . pr i nt l n( "Mes Capi t al ") ;
whi l e( mes <= meses) {
capi t al *= ( 1 + t asa / 12) ;
Syst em. out . pr i nt l n( mes + ": " + capi t al ) ;
mes++;
}
}
}
Sentencia for

La sentencia for es una sentencia de repeticin cuya sintaxis tiene una forma ms
compacta utilizando la sentencia while. La sintaxis de la sentencia for es la siguiente:

for([ expresin1] ; [ expresin2] ; [ expresin3] ) sentencia

Aqu la expresin expresin2 es una expresin booleana y expresin1 y
expresin3 son, cada una, una expresin simple o varias expresiones simples
separadas por comas.

La sentencia for opera de la siguiente manera:

1. Se evala expresin1. Si expresin1 est formada de varias expresiones
simples, stas se evalan en secuencia.

2. Se evala expresin2. Si el resultado es verdadero entonces se ejecuta la
sentencia compuesta, sentencia y luego se evala expresin3. Si
expresin3 est formada de varias expresiones simples, stas se evalan en
secuencia.

3. Repite el paso 2 hasta que el resultado de la comparacin es falso, en cuyo caso el
programa brinca a la siguiente sentencia despus de la sentencia for.

Si inicialmente el valor de expresin2 es falso, sentencia no se ejecuta ni una sola vez y el
ciclo termina.

En la sentencia for, cualesquiera de las tres expresiones se pueden omitir. En particular si
omitimos expresin2 se considera que es verdadera y tendremos un ciclo infinito. A
continuacin se muestran algunas construcciones usando la sentencia for:

f or ( i = 0; i < N; i ++) {
. . . / * Uso ms comn */
}

f or ( i = 0, j = 1; i < N; i ++, j += 3) {
. . . / * Dobl e i ni ci al i zaci n y dobl e i ncr ement o */
}

f or ( ; ; ) {
. . . / * Un ci cl o i nf i ni t o */
}
Ejemplo sobre la sentencia for

El siguiente cdigo muestra la clase Capital del ejemplo sobre la proposicin while
modificado para que utilice en su lugar una proposicin for.

*
* Capi t al 2. j ava
*
*/

package capi t al ;

/ **
*
* I l ust r a el uso de l a sent enci a f or
*
*/
publ i c cl ass Capi t al 2 {

publ i c Capi t al 2( doubl e capi t al , doubl e t asa, i nt meses) {
}


Syst em. out . pr i nt l n( " Mes Capi t al " ) ;
f or ( i nt mes = 1; mes <= meses; mes++) {
capi t al *= ( 1 + t asa / 12) ;
Syst em. out . pr i nt l n( mes + " : " + capi t al ) ;
}
}
}
Sentencia do - while

La sentencia do - while es otra variante de la sentencia while cuya sintaxis es la
siguiente:

do sentencia while(expresin)

expresin debe ser de tipo booleano. sentencia es una sentencia compuesta.

La sentencia do - while opera de la siguiente manera: Primero se ejecuta sentencia y
luego se evala expresin, si su valor es verdadero, se ejecuta sentencia y
expresin es evaluada de nuevo, repitindose el ciclo hasta que expresin resulta
falsa. Cuando esto ltimo ocurre el ciclo termina y el programa contina con la siguiente
instruccin despus del ciclo.

La diferencia bsica entre las sentencias do - while y while es que la sentencia
compuesta en el ciclo do - while se ejecuta por lo menos una vez, ya que la prueba sobre
expresin se realiza hasta que la sentencia compuesta se ha ejecutado; mientras que
la sentencia compuesta en la sentencia while no se ejecutar si expresin es falsa
desde el principio.
Ejemplo sobre la sentencia do - while

El siguiente cdigo muestra la clase Capital del ejemplo sobre la proposicin while
modificado para que utilice en su lugar una do-while.

/ *
* Capi t al 3. j ava
*
*/

package capi t al ;

/ **
*
* I l ust r a el uso de l a sent enci a do- whi l e
*
*/
publ i c cl ass Capi t al 3 {


publ i c Capi t al 3( doubl e capi t al , doubl e t asa, i nt meses) {
}

i nt mes = 1;

Syst em. out . pr i nt l n( "Mes Capi t al ") ;
do {
capi t al *= ( 1 + t asa / 12) ;
Syst em. out . pr i nt l n( mes + ": " + capi t al ) ;
mes++;
}
whi l e( mes <= meses) ;
}
}
Sentencias de Salto

Hay ocasiones en que es conveniente que el programa salte de una instruccin a otra en
forma incondicional, esto es, no sujeto a una condicin como lo vimos con las sentencias
de seleccin y de iteracin. En J ava existen cinco sentencias de salto: Las sentencias
break, continue, break etiquetada, continue etiquetada y return.
Sentencia break

Cuando estudiamos la sentencia switch vimos que la sentencia break transfiere el
control del programa a la siguiente sentencia despus de la sentencia switch. Esto es,
termina la ejecucin de una sentencia switch. La sentencia break tambin se utiliza para
terminar en forma incondicional la ejecucin de cualquier sentencia de iteracin. La
sintaxis de esta sentencia es:

break;

La ejecucin de una sentencia break se encuentra dentro de una sentencia switch o
iterativa que a su vez est dentro de otra sentencia switch o iterativa, slo termina la
sentencia switch o iterativa ms interna.

Ejemplo sobre la sentencia break

Un nmero es primo slo si es divisible entre 1 y si mismo. Para determinar si un nmero
n es primo podemos probar si es divisible entre i, donde i =2, 3, ... , n-1. Si encontramos
que el nmero es divisible entre uno de los valores de i, el nmero ya no es primo y no es
necesario seguir probando para los valores restantes de i.

El cdigo siguiente muestra el mtodo esPrimo() que determina si su argumento es primo
o no.

/ *
* Pr i mo. j ava
*
*/

package pr i mo;

i mpor t j ava. ut i l . Vect or ;

/ **
* Est a cl ase per mi t e det er mi nar si un nmer o ent er o es pr i mo.
* Tambi n det er mi na l os nmer os pr i mos que hay en un r ango de nmer os
*
* I l ust r a el uso de l as sent enci as br eak y cont i nue
*
*/
publ i c cl ass Pr i mo {

/ **
* Det er mi na si un nmer o es pr i mo
* @par amn Nmer o a det er mi nar si es pr i mo
* @r et ur n t r ue si el nmer o es pr i mo, f al se en caso cont r ar i o
*/
publ i c st at i c bool ean esPr i mo( i nt n) {
i nt i ;

/ / Pr ueba si sl o es di vi si bl e ent r e 1 y si mi smo
f or ( i = 2; i < n; i ++)
/ / Si el nmer o es di vi si bl e ent r e i no es pr i mo, r ompe el ci cl o.
i f ( n %i == 0) br eak;

/ / Si se r ecor r i t odo el ci cl o si es pr i mo, f al so en caso cont r ar i o
i f ( i == n) r et ur n t r ue;
el se r et ur n f al se;
}

. . .
}

Sentencia continue

La sentencia continue slo se utiliza con las sentencias de iteracin. La sintaxis de esta
sentencia es:

continue;

Al ejecutarse la sentencia continue, genera un salto al final de la ltima sentencia dentro
del cuerpo de una sentencia de iteracin. En las sentencias while y do - while, la
sentencia continue hace que el programa salte a evaluar la expresin de control del ciclo.
En la sentencia for la sentencia continue hace que el programa salte a evaluar la tercera
expresin y luego la expresin de control del ciclo.

La ejecucin de una sentencia continue que se encuentra dentro de una sentencia
iterativa que a su vez est dentro de otra sentencia iterativa, slo termina la sentencia
iterativa ms interna.

Ejemplo sobre la sentencia continue

El siguiente mtodo de la clase Primo determina los nmeros primos entre dos
nmeros.

/ *
* Pr i mo. j ava
*
*/

package pr i mo;

i mpor t j ava. ut i l . Vect or ;

/ **
* Est a cl ase per mi t e det er mi nar si un nmer o ent er o es pr i mo.
* Tambi n det er mi na l os nmer os pr i mos que hay en un r ango de nmer os
*
* I l ust r a el uso de l as sent enci as br eak y cont i nue
*
*/
publ i c cl ass Pr i mo {

. . .

/ **
* Det er mi na l os nmer os pr i mos que hay en un r ango de nmer os
* @par amn1 L mi t e i nf er i or del r ango
* @par amn2 L mi t e super i or del r ango
* @r et ur n Vect or con l os pr i mos encont r ados.
*/
publ i c st at i c Vect or pr i mos( i nt n1, i nt n2) {
i nt i , j ;
Vect or l i st aPr i mos = new Vect or ( ) ;

/ / Pr ueba par a cada nmer o en el r ango, si es pr i mo
f or ( j = n1; j <= n2; j ++) {
/ / Si no es pr i mo, pr ueba el si gui ent e nmer o
i f ( ! esPr i mo( j ) ) cont i nue;

/ / Es pr i mo, agr gal o a l a l i st a de pr i mos
el se l i st aPr i mos. add( new I nt eger ( j ) ) ;
}

r et ur n l i st aPr i mos;
}
}
Sentencia break Etiquetada

Ya se vio que la sentencia break slo termina la sentencia switch o iterativa ms interna
que la contiene. Si deseamos salir de un conjunto de sentencias iterativas anidadas
podemos usar una forma extendida de la sentencia break, la sentencia break
etiquetada, cuya sintaxis es:

break etiqueta;

donde etiqueta es un identificador que identifica un bloque (sentencia compuesta) y debe
contener a la sentencia break etiquetada,. Para identificar el bloque lo precedemos de la
etiqueta y dos puntos:

etiqueta: bloque

Al ejecutarse la sentencia break etiquetada, el control del programa pasa a la siguiente
instruccin despus del bloque etiquetado.

Por ejemplo, en el siguiente cdigo suma los nmeros del 0 al 100. Cuando i + j toma
el valor de 100, el control del programa termina la ejecucin de ambos ciclos:

suma = 0;

bl oque: f or ( j = 0; j < 20; j += 10) {
f or ( i = 0; i < 10; i ++) {
suma += j + i ;
i f ( j + i == 100) br eak bl oque;
}
}
/ / Al ej ecut ar se l a sent enci a br eak bl oque, el cont r ol del pr ogr ama
/ / sal t a a l a i nst r ucci n en l a si gui ent e l nea.
Sentencia continue Etiquetada

Un bloque etiquetado tambin puede contener una sentencia continue etiquetada cuya
sintaxis es:

continue etiqueta;

donde etiqueta es un identificador que identifica al bloque etiquetado. Al ejecutarse la
sentencia continue etiquetada, el control del programa pasa al final de la ltima
sentencia dentro del bloque etiquetado.


Por ejemplo, en el siguiente cdigo suma los nmeros del 0 al 199 menos el 100. Cuando
i + j toma el valor de 100, no se hace la suma:

suma = 0;

bl oque: f or ( j = 0; j <= 20; j += 10) {
f or ( i = 0; i < 10; i ++) {
i f ( j + i == 100) cont i nue bl oque;
suma += j + i ;
/ / Al ej ecut ar se l a sent enci a cont i nue bl oque, el cont r ol
/ / del pr ogr amasal t a aqu si n r eal i zar l a suma.
}
}
Sentencia return

La sentencia return termina la ejecucin de un mtodo regresando el control del
programa al mtodo llamante. La sintaxis de la sentencia return es la siguiente:

return [ expresin] ;

Si el mtodo es de tipo void, puede haber 0, 1 o ms sentencias return y todas
las sentencias aparecen sin expresin.

Si un mtodo es de un tipo diferente a void, debe tener al menos una sentencia
return y todas las sentencias return del mtodo llevan una expresin. Y el tipo
de la expresin debe coincidir con el tipo del mtodo.

Aunque un mtodo tenga varias sentencias return, slo una de ellas se ejecuta.

Si en el cuerpo de un mtodo no hay una sentencia return, la ejecucin del
mtodo termina despus de ejecutar la ltima sentencia del mtodo.

Al ejecutar la sentencia return el control del programa pasa al mtodo llamante.
Si la sentencia return aparece con expresin, antes de regresar el control se
evala expresin y se regresa su valor al mtodo llamante.

Por ejemplo el siguiente mtodo no tiene una sentencia return y por lo tanto termina
despus de ejecutar la ltima sentencia dentro del mtodo:

publ i c voi d set Ti t ul o( St r i ng t i t ul o) {
t hi s. t i t ul o = t i t ul o;
}

El siguiente mtodo tiene cinco sentencias return y cmo el mtodo es del tipo doble
(regresa un valor de tipo doble), cada una de ellas va seguida de una expresin:

swi t ch( t i poTel egr ama. char At ( 0) ) {
case ' O' :
case ' o' :
r et ur n cost oOr di nar i o;
el se
r et ur n cost oOr di nar i o + cost oAdi ci onal Or di nar i o *
case ' U' :
case ' u' :
r et ur n cost oUr gent e;
el se
r et ur n cost oUr gent e + cost oAdi ci onal Ur gent e *
def aul t :
r et ur n 0;
}
}

Tema 3 - Sentencias de Control de Java

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Tema 3 - Sentencias de Control de Java

Încărcat de

Drepturi de autor:

Formate disponibile

ITSON Manuel Domitsu Kono

S-ar putea să vă placă și