Módulo: Programación

Tema 2. Introducción a Java

Ciclo Formativo Grado Superior:

Desarrollo de Aplicaciones Web

Curso 2024-2025

1
Contenidos

• Tipos de datos primitivos de Java.

• Identificadores y palabras reservadas.
• Variables y constantes.
• Expresiones y asignación.
• Tipos de operadores y reglas de
asociatividad y precedencia.

2
 Tipos y lenguajes de programación

A la hora de seleccionar (juzgar) un lenguaje de programación es

necesario considerar:

• El conjunto de tipos primitivos que proporciona.

• Si permite combinar los tipos de datos primitivos para crear otros

tipos de datos más complejos (arrays, estructuras,…).

• Si permite definir nuevos tipos de datos y la manera en que serán

tratados por el lenguaje (¿serán tipos de datos de primera clase?

• Si pueden realizarse conversiones de tipos de forma segura.

3
 Tipos de datos primitivos de Java
Tipos de datos primitivos  Provistos como parte de la definición del lenguaje.
Los tipos de datos primitivos de Java son transportables a todas las ppllaattaaffoorrm
maass Java.
Java es un lenguaje de tipos estrictos, es decir, requiere que todas las variables tengan
un tipo para poder usarse en el programa.

Ti p o Tamaño (bits) Valores (rango) Formato

boolean 8 true, false

c ha r 16 ´A´<´B´<...´a´<...´z´<´0´<..<´9´<... ISO UNICODE

by te 8 -128 .. 127
s h o rt 16 -32.768 .. 32.767
int 32 -2.147.483.648 .. -2.147.483.647
lon g 64 -9,223,372,036,854,775,808 .. 99,,222233,,337722,,003366,,885544,,777755,,880077

fl o a t 32 -3.40292347E+38 ..+3.40292347E+38 IEEE 754

64 -1.79769313486231570E+308 .. 1.79769313486231570E+308 IEEE 754
double
4
 Identificadores
Secuencia de caracteres que puede ser usada como un nombre en un
programa

En Java:
Un identificador válido en Java es una serie de caracteres que ccoonnssiissttee en lleettrraass,, números,
subrayados ( _ ) y signos de dólar ($) que NO empieza con un número.

Identificadores válidos: Identificadores no válidos:

Vari ableNumero 1 Variab le1.2
_Var iableNumer o2 7_vari able
$var iable_nume ro_3

• Se permiten identificadores de cualquier longitud:

Pero_Que$_variablemaslarga_es_la_NUMERO4
• y se distingue entre mayúsculas y minúsculas (case-sensitive):
Mivariable  mi_variable

5
 Palabras reservadas de Java
abstract boolean break byte case

catch char class continue default

do double else extends false
final finally float for if
implements import instanceof int interface
long native new null package
private protected public return short
static super switch synchronized this
throw throws transient true try
void volatile while
Palabras reservadas, pero NO usadas por Java:
byvalue cast const future generic ggoottoo
inner operator outer rest var
Las palabras reservadas NO pueden usarse como identificadores
6
 Variables
Variables: Identificadores a los cuales se les puede asignar un valor que
puede modificarse durante la ejecución del programa.

Las variables se corresponden con celdas de memoria de la computadora.

• Toda variable tiene un nombre, un tipo y un valor.

• El tipo determina además su tamaño (bits que ocupa en la memoria) y su formato.

Declaración y creación de variables

• Para crear una variable es necesario declararla.
• Para declarar una variable se escribe su tipo seguido del nombre que vamos a
asignarle y opcionalmente su valor:
tipoDeLaVariable nombreDeLaVariable;
int number;
int num = 7;
7
 Variables
• Se puede declarar más de una variable del mismo tipo en la misma línea, separando
con comas los identificadores:
int nroAprobados, nroSuspensos, nroEstudiantes;
int nAprobados = 2, nSuspensos = 0, nEstudiantes = 2;

Inicialización de variables Valores por defecto de variables de instancia

El valor de la variable puede
Tipos de datos primitivos
asignarse cuando se declara o
boolea n false
diferirse a la ejecución del programa. \u0000
char
Si se declara una variable sin 0
Tipos numéricos enteros
especificar su valor: byte, short, int , long

Toma un valor por defecto si es Tipos numéricos reales 0.0

float, double
una variable de instancia
Queda indeterminada si es una
Referencias → null
variable local de un método.

8
 Constantes
Constantes: Identificadores a los cuales se les debe asignar un valor que NO
puede modificarse durante la ejecución del programa.

Declaración de constantes
• La forma que tiene Java de definir una constante es anteponiendo la palabra
reservada final en la declaración de una variable.
Las constantes deben inicializarse asignándolas un valor cuando se declaran:
fi nal float PI = 3.1415 92; // d eclaración válida co nstante
fi nal float F ACTORDECOR RECION; // d eclaración NO válida
// ES TO ES UN C OMENTARIO

• Se insertan comentarios para documentar llooss pprrooggrraam

maass y hhaacceerrllooss más comprensibles.
• El ccoom
mppiillaaddoorr hace caso omiso ddee llooss ccoom
meennttaarriiooss y nnoo ggeenneerraa código de bytes a partir
de ellos.
9
 Expresiones y Asignación
Expresiones: Secuencia de operandos y operadores que unidos según ciertas
reglas producen un resultado.

Sentencia de asignación: Sentencia mediante la cual se asigna un valor a una

variable.

va riable = valor // As ignació n en Ja va

Expresiones y asignación en Java.

c = a * (b+c) // Expresión aritmética
a = a + 1
a >= 7 // Expresión lógica. El resultado es true o false

10
 Expresiones y Asignación en Java (I)
// Consideremos la declaración de tres variables
int operando1;
int operando2;
Recuérdese: Java es un lenguaje
fuertemente tipado.
float operando3;
• No se ppeerrm
miitteenn aassiiggnnaacciioonneess iinnccoonnssiisstteenntteess
// Asignaciones válidas respecto de los tipos.
operando1 = 7; • El valor del lado derecho de la asignación
operando2 = 9; debe ser del mismo tipo que la variable del
lado izquierdo.
operando3 = 4.7;

// Asignaciones no válidas
sum a = operan do1 + oper ando2; // variable s uma no dec larada
ope rando1 = 7 .83; // 7.83 no e s de tipo entero
ope rando1 = o perando3; // operando3 no es de t ipo entero

11
 Expresiones y Asignación en Java (II)
// Asignación curiosamente válida. • operando3 es float

operando3 = operando1 + operando2; • Operando1 + operando2 es

int, pero se promociona de
forma automática a float
// Otra asignación válida y curiosa.
operando1 = operando1 + operando2;

La misma variable (operando1) en ambos lados. Pero

Ejemplo con valores:
no hay ninguna contradicción:
Antes de asignación:
• Primero se ejecuta la expresión de la parte
operando1 → 9
derecha de la asignación tomando los valores
almacenados en ese momento en las variables. operando2 → 7
• Después se efectúa la asignación.
Después de asignación:
En nuestro ejemplo: operando1 → 16
• Primero de ejecuta operando1 + operando2 operando2 → 7
• Después la suma se almacena en operando1
12
 Conversiones (casting)
Las operaciones determinan el tipo a devolver a partir de los operandos
4 / 3 -> 1 (int, int) -> int
Pero a veces, no es el resultado deseado.

Conversión de tipos:
• Implícita (definida en el lenguaje).
• Explícita (casting o promoción), forzada por el programador.

Conversión explícita (casting)

(nombre de tipo) expresión
Convierten el valor de la expresión a un valor del tipo entre paréntesis:
(char)98 → devuelve ´b´
(int)10.0 → devuelve el entero 10
(double)10 → devuelve el double 10.0
13
Conversiones (casting)

NOTA:
Cada tipo primitivo tienen(excepto boolean y char)
una clase declarada en el paquete java.lang
Constantes declaradas:
* MIN_VALUE y MAX_VALUE --> todos los datos primitivos
Las siguientes solo Float y Double
* NEGATIVE_INFINITY y POSITIVE_INFINITY
* NaN (Not a Number) --> indica que el resultado de una
operación fue incorreccto (Ej. 0/0)
14
Conversiones (casting)

15
 Conversiones implícitas
Sólo se aplica a tipos de datos primitivos.
De tipos “pequeños” a “grandes”:
→ byte a shor t, int, long , float, o do uble
→ short a int , long, floa t o doub le
→ char a int, long, float, o double (¡OJO!)
→ int a lon g, float o d ouble
→ long a floa t o double
→ float a dou ble

¡Se puede perder información! LOS DÍGITOS MENOS SIGNIFICATIVOS PUEDEN PERDERSE
• En el paso de long a float o double
• En el paso de int a float
La promoción explícita tiene prioridad sobre la implícita.

16
 Conversiones primitivas a S tring

int a = 123;
String A = Integer.toString(a);
1 double b = 123.456;
String B = Double.toString(b);
;
Otra forma de hacerlo seria invocando al
método valueOf de la clase String para convertir
los datos primitivos : int,long,float,double

int a = 123;
2 String A = String.valueOf (a);
double b = 123.456;
String B = String.valueOf (b);
17
 Conversiones S tring a primitivas
Los wrappers (envoltorios) no son más que clases que modelan los tipos
de datos primitivos tales como enteros o flotantes, precisamente
estos tipos primitivos son los únicos elementos en java que no
son clases
Los wrappers tambien proporcionan métodos para realizar otras tareas
con los primitivos, tales como conversión con cadenas de caracteres en
sentido y en otro.Existe una clase Wrappers para cada uno de los tipos
;
primitivos numericos, eso es, existen las clases Byte,Short,Integer
Long,Float,Double
Ej: Integer.toString, Integer.parseInt

String A = “123”;
int a = Integer.parseInt(A);

String B = “123.456”;
double b = Double.parseDouble(B);
18
 Operadores Aritméticos
Son operadores binarios  Operan sobre dos operandos

Operación Operador Expresión

Suma + f + 7

Resta - p - c

Multiplicación * b * m

División / x / y

Módulo % r % s

• La división entera produce un cociente entero. Cualquier parte fraccionaria se desecha, no hay
redondeo: 17 / 5 produce 3
• El operador módulo produce el residuo de la división entera. Sólo puede usarse con tipos enteros. El
signo es el del numerador : 17 % 5 produce 2
• Se usan paréntesis en las expresiones igual que en álgebra: a * (b + c)
Java aplica los operadores de las expresiones aritméticas en el mismo orden que en álgebra.

19
 Reglas de precedencia de operadores aritméticos
1. Las expresiones contenidas entre paréntesis se evalúan primero, aplicando
primero los operadores del par de paréntesis más interno.

2. A continuación se aplican las operaciones de multiplicación, división y residuo de

izquierda a derecha.

3. A continuación se aplican las operaciones de suma y resta de izquierda a derecha.

Ejemplos de evaluación:
z = p * r % q + w / x – y
orden de evaluación: 1 2 4 3 5

y = a * x * x + b * x + c
orden de evaluación: 1 2 4 3 5

equivalente a: y = (a * x * x) + (b * x) + c
20
 Operadores de igualdad y relacionales
Operador Ejemplo Significado
== x == y x es igual a y
!= x != y x distinto de y
> x > y x mayor que y
< X < y x menor que y
>= x >= y x mayor o igual que y
<= x <= y x menor o igual que y

Precedencia y asociatividad:
Ope radores Asocia tividad Tipo
( ) izquie rda a dere cha paréntesis
* / % izquie rda a dere cha multiplica tivos
+ - izquie rda a dere cha aditivos
< <= > >= izquie rda a dere cha relacional es
==  = izquie rda a dere cha igualdades
= derech a a izquie rda asignación

Se pueden usar los paréntesis para forzar la evaluación en el orden que se desee
21
Operadores de asignación aritmética

Operador Expresión Expresión

Equivalente
+= c += 7 c = c + 7

-= d -= 4 d = d - 4

*= e *= 5 e = e * 5

/= f /= 3 f = f / 3

%= g %= 9 g = g % 9

22
 Operadores de incremento y decremento
Operador Nombre Ejemplo Significado

++ Preincremento ++a Incrementa a en 1 y luego usa el valor de a

en la expresión donde a reside

++ Posincremento a++ Usa el valor de a en la expresión en la que

reside y luego lo incrementa en 1

-- Predecremento --a Decrementa a en 1 y luego usa el valor de a

en la expresión donde a reside

-- Posdecremento a-- Usa el valor de a en la expresión en la que

reside y luego lo decrementa en 1

23
 Operadores Lógicos
Operación lógica Operador Significado
Ejemplo
AN D lógico && true si ambas condiciones son verdaderas
c ond_A && c ond_B false si una de las condiciones es falsa
AN D lógico b ooleano & true si ambas condiciones son verdaderas
cond_A & c ond_B false si una de las condiciones es falsa
OR lógico || false si ambas condiciones son falsas
c ond_A || c ond_B true si una de las condiciones son verdaderas
OR inclusivo lógico | false si ambas condiciones son falsas
bo oleano cond_A | c ond_B true si una de las condiciones son verdaderas
OR exclusivo lógico ^ false si ambas condiciones tienen el mismo valor
bo oleano cond_A ^ c ond_B true (verdadero) si cada una de las expresiones
tiene un valor diferente
NO T lógico  true si condición es falsa
(n egación ló gica)  condici ón false si condición es verdadera
24
Tablas de Verdad
F: fals e (falso)
T: true (verdader o)
AND lóg ico (&&) OR ló gico (||)
F && F : F F || F : F
F && T : F F || T : T
T && F : F T || F : T
T && T : T T || T : T
AND lóg ico boolea no (&) OR in clusivo ló gico boole ano
F & F : F F | F : F
F & T : F F | T : T
T & F : F T | F : T
T & T : T T | T : T
OR excl usivo lógi co boolean o (^) NOT l ógico ( )
F ^ F : F  F : T
F ^ T : T  T : F
T ^ F : T
T ^ T : F
25
 Operadores Lógicos: Evaluación en cortocircuito (I)
Evaluación en cortocircuito: Forma de evaluar las condiciones tal que en
cuanto se conoce el valor final de la expresión no se evalúan el resto de
condiciones.

• && (AND lógico) y || (OR lógico) se evalúan en cortocircuito.

• El resto de los operadores lógicos no se evalúan en cortocircuito.

Ejemplos:
sexo == mujer && edad >= 65
Si sexo no es igual a mujer no se evalúa el segundo operando edad >= 65.

notaLab == noApto || notaTeo ría < 5

Si notaLab es noApto no se evalúa el segundo operando.

En: sexo == mujer & edad >= 65 y en notaLab = noApto | notaTeoría < 5
Se evalúan ambos operandos.
26
 Operadores Lógicos: Evaluación en cortocircuito (II)
• Utilizar & y | en lugar de && y || si el operando derecho de la expresión tiene un
efecto secundario necesario.
sexo == varon | ++edad >65

• En expresiones que usan && y || es posible que sólo tenga sentido evaluar una
condición (condición dependiente) si se cumple la otra. La condición ddeeppeennddiieenntteeddeebbee
incluirse al final, si no se podría incurrir en error.
int counter;
int media;
if (counter != 0 && media/counter > 5) { ... }

• En expresiones con && si las condiciones son independientes colocar primero la que
tenga mayores probabilidades de ser falsa.
• En expresiones con || si las condiciones son iinnddeeppeennddiieenntteess ccoollooccaarr pprriim
meerroo la que
tenga mayores probabilidades de ser verdadera.
27
 Operadores Lógicos: Negación lógica

• El operador ! (negación lógica) sirve para invertir el significado de una

condición.

• El operador ! se coloca delante de una condición para escoger una

trayectoria de ejecución cuando dicha condición es false.
if (!(calificación >= 5))
System.out.println (“Suspendido”);

• Casi siempre puede evitarse expresando la condición de otra manera:

if (calificación < 5)
System.out.println (“Suspendido”);

28
 El operador ?
Condici ón  Ex presion 1 : Exp resion2

Tres operandos:
• Condición: Expresión booleana (verdadero o falso)
• Expresión 1: Resultado si Condición es verdadera
• Expresión 2: Resultado si Condición es falsa

Ejemplo:
boolean haceCalor;
if (temperatura >= 30)
haceCalor=true;
else
haceCalor=false;

Es equivalente a:
boolean haceCalor;
haceCalor=(temperatura>=30 ? true : false); 29
Resumen de operadores asociatividad y precedencia
Operadores Asociatividad Ti p o
( ) Izda a dcha Paréntesis
+ + --  Dcha a izda Unarios
* / % Izda a dcha Multiplicativos
+ - Izda a dcha Aditivos
< <= > >= Izda a dcha Relacionales
== = Izda a dcha De igualdad
& Izda a dcha AND lógico booleano

^ Izda a dcha OR exclusivo lógico booleano

| Izda a dcha OR inclusivo lógico booleano

&& Izda a dcha AND lógico

|| Izda a dcha OR lógico
: Dcha a izda Condicional
= += -= *= /= %= Dcha a izda Asignación 30
 Estructuras de control

Contenidos
• Estructuras de selección: if, else, switch
• Estructuras de repetición: while, do/while, for
• Enunciados break y continue.
• Principios de la Programación Estructurada.

31
 Estructuras de control de Java
Java tiene 7 estructuras de control:
Estructura de secuencia: Las instrucciones se ejecutan una a continuación de otra.
Estructuras de selección: Se salta de una parte a otra del código según el
cumplimiento de una condición.

if if/e lse switch

Estructuras de repetición: Se repite la ejecución de una instrucción o conjunto de
instrucciones si se cumple una cierta condición.

w hile do/w hile for

• Todas estas estructuras cumplen los principios de la programación
estructurada.
• Los algoritmos de los programas Java se construyen a partir de estas
estructuras de control combinadas de dos modos: Apilamiento y Anidamiento
32
 Estructura de selección if
Sentencia de selección única: Si se cumple la condición se
if (condicion) sentencia_1; ejecuta la sentencia_1,
si no,
se salta hasta la siguiente instrucción.

condicion es una expresión lógica

(booleana) cuyo resultado es
true Sentencia_1 verdadero (true) o falso (false)
CONDICIÓN

Ejemplo:
i f (calific ación >= 5 )
false
System.out .println(“ Aprobado”) ;

33
 Estructura de selección if/else
Sentencia de selección doble:
Si se cumple la condición se ejecuta la
if (condicion)
sentencia_1,
sentencia_1;
else si no,
sentencia_2; ejecuta la sentencia_2.

Ejemplo:
if ( calificaci ón >= 5)
false true
S_2 condición S_1 S ystem.out. println(“A probado”);
else
S ystem.out. println(“S uspendido” );

34
 Estructura de selección if/else
Si se quiere indicar que se ejecuta más de una sentencia, hay que
ponerlas entre llaves:
if (con dicion) {
sent encia_1 ; • ¡ No olvidar los paréntesis en la
sent encia-2 ; condición !
} • ¡ No olvidar las llaves si hay más de
una sentencia !
else {
sen t e nc ia _3 ; • ¡ Sangrar las sentencias para hacer el
programa más legible !
sen t e nc ia _4 ;
sen t e nc ia _5 ;
}

35
 if/else en cascada (I)
if (calificac ión >= 9) Para hacer el programa más
System.ou t.println( “Sobresali ente”); legible se suele escribir:
els e
if (calif icacion >= 7)
Syste m.out.prin tln(“Notab le”);
else
if (c alificacio n >= 5)
System.out .println(“ Aprobado”) ;
else
System.out .println(“ Suspendido ”);

if (ca lificación >= 9)

Sy stem.out.p rintln(“So bresalient e”);
else i f (calific acion >= 7 )
System.out.println(“Notable”);
else i f (calific acion >= 5 )
System.out.println(“Aprobado”)
else
Sy stem.out.p rintln(“Su spendido”) ;

36
 if/else en cascada (II)
¡¡ else siempre se refiere al if anterior !!

if (x>5)
if (y>5)
System.out.println(“x e y son mayores que 5”);
else
System.out.println(“x es menor o igual que 5”);

Pero lo que realmente pretendemos es esto:

if (x>5){
if (y>5)
System.out.println(“x e y son mayores que 5”);
}
else
System.out.println(“x es menor o igual que 5”);

37
 if/else en cascada (III)
Errores típicos: Punto y coma mal colocado

• Puede producir un error de lógica:

if (nota >= 5); // No haría nada después de evaluar condición

System.out.println(“Aprobado”); //Siempre se ejecuta

• Puede producir un error de sintaxis:

if (calificación>= 5); // if/else acaba aquí

System.out.println(“Aprobado”); // Siempre se ejecuta
else
System.out.println(“Suspendido”); // ¿A qué if se refiere?

38
 Estructura de selección switch
Sentencia de selección múltiple:
sí
swi tch (expre sión) { Acción a break
Caso a
cas e valor_1: sentencia _1; no
break;
sí
cas e valor_2: sentencia _2; Acción b break
Caso b
break;
no
...
cas e valor_i: sentencia _i;
break;
sí
def ault: sentencia_por_defecto; Acción i break
Caso i
break;
no
}
La expresión después de cada case debe ser una expresión entera
constante, es decir, una combinación de constantes de carácter y constantes
enteras que al evaluarse produzca un valor entero constante.
Una constante de carácter se representa como el carácter en cuestión
encerrado entre apóstrofos: ´A´
39
 Estructura de selección switch (II)
Particularidades de la estructura switch
• ¿Qué ocurre si falta la palabra break?
Si falta break se siguen ejecutando todas las sentencias en las que haya
coincidencia hasta encontrar el siguiente break. Si no hay break se ejecutaría
el default aunque haya habido coincidencia con otras antes.

• La inclusión de un caso por defecto es opcional, pero es aconsejable ponerlo.

• Después de cada caso (case) no se incluyen llaves { }aauunnqquuee hhaayyaa más de una
sentencia.

case v alor_i: se ntencia_a;

se ntencia_b;
br eak;

40
 Estructura de repetición while
Permite al programador especificar que una Ejemplo: Encontrar la primera potencia
acción se repita en tanto se cumpla una de 2 mayor que 1000.
condición.
while (condicion) sentencia; int producto = 2;
while (producto <= 1000)
while (condicion){
producto = 2 * producto;
sentencia_1;
………
sentencia_n;
}
true Sentencia
CONDICIÓN

false

41
 Estructura de repetición do/while
Permite al programador especificar que una acción se
repita en tanto se cumpla una condición.
do
sen tencia;
while (condicion );
T

do{
se ntencia_1; F
……
se ntencia_n; OBSERVACIONES:
} whil e (condici on)
• Ojo con los bucles infinitos: hay que
asegurarse de que la condición deja de
Ejemplo: Encontrar la primera
cumplirse.
potencia de 2 mayor que 1000.
• Diferencia con sentencia while: La
int producto = 2;
sentencia o sentencias se eejjeeccuuttaann al menos
do
una vez. La condición se comprueba después
producto = 2 * producto;
de haber realizado la primera iteración.
while (producto <= 1000)

42
 Estructura de repetición for (I)
Repetición controlada por contador:
for (inicialización del contador;
condición; Inicialización
expresión incremento del contador) Incremento
sentencia;
true
Condición Sentencia
for (inic. cont.; cond.; inc. cont.){
sentencia_1; false
……
sentencia_n;
}
Semántica (pasos):
Ejemplos: (1) Se inicializa contador (sólo la primera vez).
Variable de control de 7 a 77 en incrementos de 7. (2) Se evalúa condición.
for ( int i = 7; i <= 77; i += 7){…} ; • Si true → ejecutar sentencias.
• Si false → a paso 5 (salir del bucle).
Variable de control de 99 a 0 en incrementos de -11
(3) Se incrementa contador según expresión de
for ( int i = 99 ; i >= 0; i = i - 11 ) incremento.
{…};
(4) Volver al paso 2.
(5) Salir del bucle. 43
Estructura de repetición for (II)
Las tres expresiones de la estructura for son opcionales:
• Se puede omitir la inicialización del contador si se ha inicializado antes.
int i = 1;
for( ; i < 10; i++ ) { ... }

• Si se omite la comprobación de la condición, Java supone que la condición para

continuar el ciclo se cumple, creándose un bucle infinito.
for( ; ; i++) { .. . } // Bu cle infini to. Posibl e desborda miento de i.
for( ; ; ) { ... } // Bu cle infini to.

• La propia variable de control se puede utilizar dentro del cuerpo del for.
for( ; i < 10; i++ ) {
if ( i%2 == 0) { ... } / / Se hace algo cuand o i es par .
}

• El incremento del contador puede omitirse si se hace dentro del ccuueerrppoo ddeell for.
for( ; i < 10; ) { ... i++ ... } // Nada acons ejable.

44
Estructura de repetición for (III)
Las expresiones de un for pueden contener expresiones aritméticas.
Por ejemplo,

int x = 2;
int y = 10;

for ( int j = 2; j <= 80; j += 5 )

System.out.println(j);

for ( int j = x; j <= 4 * x * y; j += y / x )

System.out.println(j);

Pero cuidado con las expresiones:

Ambos bucles for son equivalentes si x e y no se modifican en el cuerpo del ciclo,
pero el primero es claro y el segundo difícilmente comprensible.

45
Estructura de repetición for (IV)
La sentencia
for (int contador = 1; contador <= 10; ccoonnttaaddoorr ++)
sentencia;
es equivalente a:
int contador = 1; Inicialización
while (contador <= 10) { Incremento
sentencia;
contador++; true
Condición Sentencia
}
false
Elección de una estructura de repetición:
• Si número fijo de veces, elegir for
• Si 1 o más veces, elegir do { } while { }
• Si 0 o más veces, elegir while ( ) { }

¡ Se trata de elegir la que mejor se ajuste al concepto para mejorar la legibilidad !

46
Break y continue en estructuras de repetición (I)
La palabra reservada break en el cuerpo Continue: Causa el salto a la
de un ciclo causa la terminación siguiente iteración del ciclo, pero sin
inmediata de dicho ciclo. salirse del ciclo .
in t i = 0; for (int i = 0 ; i < 100; i++) {
in t s = 0;
if (i % 2 == 1) continue;
wh ile (i <= 5) {
s = s + 1; // Sólo se pasa aquí si i es p ar
if ( s == 7) break; // sale // otras s entencias ...
// otras sentencias …
}
i++;
}
// Se pasa a quí si i > 5 o s == 7

• En las estructuras while y do/while la condición para continuar el ciclo se

evalúa inmediatamente después de ejecutarse continue.
• En la estructura for se incrementa el contador y luego se evalúa la condición.

47
Break y continue en estructuras de repetición (II)
Las siguientes porciones de código son equivalentes:
fo r (int i = 1; i <= 1 0; i++ ) { int i = 1;
// senten cia 1 while ( i <= 10 ) {
// senten cia n // sentencia 1
} // sentencia n
i+ +;
}

Pero las dos siguientes NO son equivalentes:

fo r (int i = 1; i <= 1 0; i++ ) { int i = 1;

// senten cia 1 while ( i <= 10 ) {
continue; // sentencia 1
// senten cia n co ntinue;
} // sentencia n
i+ +;
}
// Increment o antes d e continue . // In cremento después d el continu e

48
break etiquetado
• El enunciado break sólo causa la salida de la estructura while, do/while o for
que lo encierra directamente.
• Para salirnos de una serie de estructuras anidadas se usa el enunciado break
etiquetado:
• La ejecución del programa continúa con el primer enunciado después del enunciado
compuesto etiquetado, el cual consiste en una serie de enunciados encerrados en
llaves y precedidos por una etiqueta.

// Enunciado compuesto rotulado o etiquetado

stop:
for (i nt fila = 1; fila <= 10; fila++ ) {
for (int columna = 1; columna <= 5; col umna++) {
if ( fila == 5)
break stop;
Syst em.out.pri ntln(“Fila es menor que 5”);
}
}
System.out .println(“ La fila es 5”);

49
continue etiquetado
• El enunciado continue continúa con la siguiente iteración de la estructura while,
do/while o for que lo encierra directamente.

• El enunciado continue etiquetado se salta el resto de los enunciados del cuerpo de

la estructura de iteración que lo contiene y cualquier cantidad de estructuras de
iteración que la encierren y continúa con la siguiente iteración de la estructura de
repetición etiquetada.

// Enunciado compuesto rotulado o etiquetado

stop:
for (i nt fila = 1; fila <= 10; fila++ ) {
for (int columna = 1; columna <= 5; col umna++) {
if ( fila == 5)
continue stop;
Syst em.out.pri ntln(“Fila es distin ta que 5”) ;
}
}
System.out .println(“ La fila es 10”);

50
Advertencias sobre break y continue
break y continue suponen una violación de las reglas de la
programación estructurada, si bien de alcance limitado.

• El uso de break está justificado en pocas ocasiones. Puede evitarse con

una escritura más cuidadosa de las condiciones de terminación del ciclo

int i; in t i;
char s; ch ar s;
while (i <= 5 || s != ´a´) { while (i <= 5 && s != ´a´){
if (s == ´a´) break; // Senten cias
// Sent encias i++;
i++; }
}

Si hay más de una salida del ciclo del programa se hace más difícil de leer y
analizar y se va en contra de los principios de la programación estructurada.

51
 Advertencias sobre break y continue
• El uso de continue puede evitarse con una escritura más cuidadosa del
cuerpo del ciclo y de la expresión de incremento de la variable de control.
fo r (int i = 0; i < 10 0; i ++) { fo r (int i = 0; i < 10 0; i += 2) {
if (i%2 == 1) conti nue; // Procesa miento seg ún valor d e i
// Proces amiento se gún valor de i
}
}
• continue ayuda a reducir los niveles de anidado en el cuerpo de la estructura de
iteración,
• pero es peligroso si no se hacen explícitas las condiciones para eejjeeccuuttaarr el resto del ciclo.

// int a, b (declaradas antes) // int a, b (declaradas antes)

// posible bucle  si b es cero al entrar while (a < 5) {
while (a < 5){ if (b == 0){
if (b == 0) continue; a++;
continue;
// otras sentencias;
}
a++;
// otras sentencias;
}
a++;
}

52