ALGORITMICA Y PROGRAMACION POR OBJETOS I

Nivel  3

Manejando grupos de atributos

Marcela Hernández Hoyos – Olga Mariño

Qué  vamos  a  aprender  en  este  nivel:
• Utilizar  estructuras  contenedoras de  
tamaño  fijo para  almacenar  una  secuencia  
de  valores  (simples  u  objetos)
• Utilizar  estructuras  contenedoras de  
tamaño  variable para  almacenar  una  
secuencia  de  objetos
• Utilizar  instrucciones  iterativas para  
manipular  estructuras  contenedoras
• Crear  una  clase  completa  en  java  
utilizando  eclipse
Caso  de  estudio  No.  1:  Las  
notas  de  un  curso
 Las  notas  de  un  curso
– En  el  curso  hay  12  estudiantes
– De  cada  estudiante  se  tiene  la  nota  
definitiva  (un  valor  entre  0.0  y  5.0)
– Se  quiere  construir  un  programa  que  
permita:
1. Cambiar  la  nota  de  un  estudiante
2. Calcular  el  promedio  del  curso
3. Establecer  el  número  de  estudiantes  que  
están  por  encima  de  dicho  promedio
Interfaz  usuario
 Requerimientos  Funcionales
R1  – Cambiar  una  nota
Nombre

Permite  cambiar  la  nota  definitiva  de  un  estudiante  del  

Resumen
curso

Entradas

1. El  estudiante  a  quien  se  quiere  cambiar  la  nota

2. La  nueva  nota  del  estudiante

Resultado

Se  ha  asignado  al  estudiante  la  nueva  nota.

 Requerimientos  Funcionales
R2  – Calcular  el  promedio
Nombre

Permite  calcular  la  nota  promedio  de  los  estudiantes  

Resumen
del  curso

Entradas

Ninguna

Resultado

El  promedio  de  las  notas  de  los  doce  estudiantes  del  curso
 Requerimientos  Funcionales
R3  – Calcular  el  número  de  estudiantes  por  encima  del  
Nombre
promedio
Permite  saber  cuántos  estudiantes  tienen  una  nota  
Resumen
superior  a  la  nota  promedio  del  curso

Entradas

Ninguna

Resultado

Número  de  estudiantes  con  nota  mayor  al  promedio  del  curso
 Modelo  de  la  Clase

Curso
double  nota1;;
double  nota2;;
double  nota3;;
double  nota4;;
double  nota5;;
double  nota6;;
double  nota7;;
double  nota8;;
double  nota9;;
double  nota10;;
double  nota11;;
double  nota12;;
 Modelo  de  la  Clase

Curso Curso Curso

double  nota1;; double  nota1;; double  nota1;;
double  nota2;; double  nota2;; double  nota2;;
double  nota3;; double  nota3;; double  nota3;;
double  nota4;; double  nota4;; double  nota4;;
double  nota5;; double  nota5;; double  nota5;;
double  nota6;; double  nota6;; double  nota6;;
double  nota7;; double  nota7;; double  nota7;;
double  nota8;; double  nota8;; double  nota8;;
double  nota9;; double  nota9;; double  nota9;;
double  nota10;; double  nota10;; .
double  nota11;; double  nota11;; .
double  nota12;; double  nota12;; .
double  nota13;; double  nota100;;
double  nota14;;
double  nota15;;
 Solución:  Contenedora

Curso Curso
double  nota1;; double  notas =  
0
double  nota2;;
1
double  nota3;;
double  nota4;; 2
double  nota5;; 3
double  nota6;; 4
double  nota7;;
UN  SOLO   5
double  nota8;; ATRIBUTO   6
double  nota9;; LLAMADO   7
double  nota10;; 8
double  nota11;;
notas 9
double  nota12;; 10
11
Arreglo  =  contenedora  de  tamaño  fijo
0 1 2 3 4 5 6 7 8 9 10 11

notas  = 3.5 5.0 4.5 2.5 4.5 2.5 3.5 4.0 2.0 1.5 3.5 5.0

notas[0] notas[4] notas[7] notas[11]

• Cada  posición  del  arreglo  (casilla)  se  utiliza  como  una  variable

notas[5]  =  3.0;;
i  =  2;;
if  (  notas[  i  ]  >  4.0)
notas[10]  =  notas[3];;
if  (notas[11]  ==  notas[0])
notas[0]  =  2.0;;
else
notas[0]  =  notas[11];;
 Declaración  de  un  arreglo
public  class  Curso
{
//Constantes
public  final  static  int  TOTAL_EST  =  12;;

//Atributos
private  double[  ]  notas;;

}
 Declaración  de  un  arreglo
public  class  Curso
{
//Constantes
Se  declara  una  
final  public  static  int  TOTAL_EST  =  12;; constante  para  fijar  el  
tamaño  del  arreglo
//Atributos
private  double[  ]  notas;;

}
TODOS  los  
elementos  del  arreglo  
son  del  MISMO  TIPO
 Inicialización  de  un  arreglo
public  Curso
{
notas  =  new  double  [TOTAL_EST];;
}

• El  espacio  en  memoria  (una  cajita  por  posición  del  arreglo)  queda  
reservada.
• El  valor  de  los  elementos  del  arreglo  es  indefinido  al  comienzo.
• Para  consultar  el  número  de  elementos  del  arreglo:  length
notas.length
• Si  se  trata  de  acceder  a  una  casilla  con  índice  menor  que  0  o  mayor  
que  el  número  máximo  de  casillas  (en  este  caso  12)
java.lang.ArrayIndexOutOfBoundsException
 Para  dar  valores  a  los  elementos  
del  arreglo
public  void  ponerNotasEnCero  (  )
{
notas[0]  =  0;;
notas[1]  =  0;;
notas[2]  =  0;;
notas[3]  =  0;;
notas[4]  =  0;;
notas[5]  =  0;;
notas[6]  =  0;;
notas[7]  =  0;;
notas[8]  =  0;;
notas[9]  =  0;;
notas[10]  =  0;;
notas[11]  =  0;;
}
 Para  calcular  el  promedio  de  las  
notas  del  curso
public  double  promedio  (  )
{
double  suma;;

suma  =  notas[0]  +                                                                                                                                                                          ;;

return  suma;;
}
 Para  calcular  el  promedio  de  las  
notas  del  curso
public  double  promedio  (  )
{
double  suma;;

suma  =  notas[0]  +  notas[1]  +  notas[2]  +  notas[3]  +  notas[4]  +

notas[5]  +  notas[7]  +  notas[8]  +  notas[9]  +  notas[10]  +  notas[11];;

suma  =  suma  /  TOTAL_EST;;

return  suma;;
}
 Para  calcular  el  promedio  de  las  
notas  del  curso
public  double  promedio  (  )
{
double  suma  =  0.0;;
int  indice  =  0;;

suma  +=  notas[  indice  ];;

indice++;;

suma  +=  notas[  indice  ];;

indice++;;

suma  +=  notas[  indice  ];;

indice++;;

… (9  veces  más)

suma  =  suma  /  TOTAL_EST;;

return  suma;;
}
 Para  calcular  el  promedio  de  las  
notas  del  curso
public  double  promedio  (  )
{
double  suma  =  0.0;;
int  indice  =  0;;

suma  +=  notas[  indice  ];;

indice++;; Paso  que  se  repite
suma  +=  notas[  indice  ];;
indice++;;

suma  +=  notas[  indice  ];;

indice++;;

… (9  veces  más)

suma  =  suma  /  TOTAL_EST;;

return  suma;;
}
Instrucciones  repetitivas:  Para  dar  
valores  a  los  elementos  del  arreglo  
• Repita  12  veces  poner  en  cero  la  nota  …cual?

• Para  un  índice  i  que  va  de  0  a  11  ,

asignarle  0  a  nota[  i  ]  

• Inicialice  un  índice  i  en  0

Mientras  que  no  se  haya  acabado  de  recorrer  el  arreglo
asígnele  0  a  nota[i]
incremente  i  en  1
 Para  calcular  el  promedio  de  las  
notas  del  curso
public  double  promedio  (  )
{
double  suma  =  0.0;;
int  indice  =  0;; public  double  promedio  (  )
{
suma  +=  notas[  indice  ];; double  suma  =  0.0;;
indice++;; int  indice  =  0;;

suma  +=  notas[  indice  ];; while  (  indice  <  TOTAL_EST  )

indice++;; {
suma  +=  notas[  indice  ];;
suma  +=  notas[  indice  ];;
indice++;;
indice++;;
}
… (9  veces  más)
suma  =  suma  /  TOTAL_EST;;
suma  =  suma  /  TOTAL_EST;;
return  suma;;
return  suma;; }
}
 Para  calcular  el  promedio  de  las  
notas  del  curso
public  double  promedio  (  )
{
double  suma  =  0.0;;
int  indice  =  0;; public  double  promedio  (  )
{
suma  +=  notas[  indice  ];; double  suma  =  0.0;;
indice++;; int  indice  =  0;;

suma  +=  notas[  indice  ];; while  (  indice  <  TOTAL_EST  )

indice++;; {
suma  +=  notas[  indice  ];;
suma  +=  notas[  indice  ];;
indice++;;
indice++;;
}
… (9  veces  más)
suma  =  suma  /  TOTAL_EST;;
suma  =  suma  /  TOTAL_EST;;
return  suma;;
return  suma;; }
}
Instrucciones  repetitivas
Ejecución  de  una  instrucción  repetitiva
inicio Preparación  
del  ciclo

La  condición  
es   no Termina  el  ciclo
verdadera?

si

Ejecuta  las  
instrucciones  
del  cuerpo  
del  ciclo
Ejecución  de  una  instrucción  repetitiva
public  double  promedio  (  )
{
double  suma  =  0.0;;
int  indice  =  0;;

while  (  indice  <  TOTAL_EST  )

{
suma  +=  notas[  indice  ];;
indice++;;
}

suma  =  suma  /  TOTAL_EST;;

return  suma;;
}
 while  y  for
<inicio>
while  ( <condición  de  entrada> )
{
<cuerpo>
<avance>
}

for  (<inicio>;; <condición  de  entrada>;; <avance>)

{
<cuerpo>
}
 Para  calcular  el  promedio  de  las  
notas  del  curso
public  double  promedio  (  )
{
Inicio  de  las  variables  de  trabajo:
double  suma  =  0.0;; • Indice  para  movernos  en  el  arreglo
int  indice  =  0;; • Acumulado  de  la  suma  de  las  notas

while  (  indice  <  TOTAL_EST  )

{
suma  +=  notas[  indice  ];;
indice++;;
}

suma  =  suma  /  TOTAL_EST;;

return  suma;;
}
 Para  calcular  el  promedio  de  las  
notas  del  curso
public  double  promedio  (  )
{
double  suma  =  0.0;;
int  indice  =  0;;

while  (  indice  <  TOTAL_EST ) Condición  para  continuar:

• Cualquier  expresión  lógica  
{
suma  +=  notas[  indice  ];;
indice++;;
}

suma  =  suma  /  TOTAL_EST;;

return  suma;;
}
 Para  calcular  el  promedio  de  las  
notas  del  curso
public  double  promedio  (  )
{
double  suma  =  0.0;;
int  indice  =  0;;

while  (  indice  <  TOTAL_EST  )

{
suma  +=  notas[  indice  ];; Cuerpo  del  ciclo:
indice++;; • Instrucciones  que  se  van  a  repetir  en  
cada  iteración  
}

suma  =  suma  /  TOTAL_EST;;

return  suma;;
}
 Para  calcular  el  promedio  de  las  
notas  del  curso
public  double  promedio  (  )
{
double  suma  =  0.0;;
int  indice  =  0;;

while  (  indice  <  TOTAL_EST  )

{
suma  +=  notas[  indice  ];;
indice++;; Avance  del  ciclo:
} • Incremento  del  índice  que  indica  la  
posición  del  arreglo  en  la  que  estamos  en  
un  momento  dado  
suma  =  suma  /  TOTAL_EST;;

return  suma;;
}
 Para  calcular  el  promedio  de  las  
notas  del  curso
public  double  promedio  (  ) Inicio  de  las  variables  de  trabajo:
{ • Indice  para  movernos  en  el  arreglo
double  suma  =  0.0;; • Acumulado  de  la  suma  de  las  notas

for  ( int  indice  =  0;;  indice  <  TOTAL_EST;;  indice  ++  )

{
suma  +=  notas[  indice  ];;
}

suma  =  suma  /  TOTAL_EST;;

return  suma;;
}
 Para  calcular  el  promedio  de  las  
notas  del  curso
public  double  promedio  (  )
{ Condición  para  continuar:
double  suma  =  0.0;; • Cualquier  expresión  lógica  

for  (  int  indice  =  0;;  indice  <  TOTAL_EST;;  indice  ++  )

{
suma  +=  notas[  indice  ];;
}

suma  =  suma  /  TOTAL_EST;;

return  suma;;
}
 Para  calcular  el  promedio  de  las  
notas  del  curso
public  double  promedio  (  )
{
double  suma  =  0.0;;

for  (  int  indice  =  0;;  indice  <  TOTAL_EST;;  indice  ++  )

{
suma  +=  notas[  indice  ];;
} Cuerpo  del  ciclo:
• Instrucciones  que  se  van  a  repetir  en  
cada  iteración  
suma  =  suma  /  TOTAL_EST;;

return  suma;;
}
 Para  calcular  el  promedio  de  las  
notas  del  curso
public  double  promedio  (  )
{
double  suma  =  0.0;;

for  (  int  indice  =  0;;  indice  <  TOTAL_EST;;  indice  ++ )

{
suma  +=  notas[  indice  ];; Avance  del  ciclo:
} • Incremento  del  índice  que  indica  la  
posición  del  arreglo  en  la  que  estamos  en  
un  momento  dado  
suma  =  suma  /  1  TOTAL_EST;;

return  suma;;
}
Tarea  No.  2  -­ Calcular  el  número  de  estudiantes  que  
sacaron  una  nota  entre  3.0  y  5.0
public  int  cuantosPasaron  (  )
{

}
Otra  forma  – instrucción  for  each
Calcular  el  número  de  estudiantes  que  sacaron  una  nota  
entre  3.0  y  5.0
public int darCantidadAprobados(  )
{  
int vanAprobando  =  0;  
for(  Double  nota: notas )  
{  
if(  nota  >=  3.0 )  
{  vanAprobando++;  
}  
}  
return vanAprobando;  
}

Nombre  de  la  contenedora

Nombre  de  la  variable  local  
Que  va  a  contener  en  cada  iteración
El  siguiente  elemento  de  la  contenedora
Tarea  No.  2  -­ Calcular  la  mayor  nota  del  curso

public  int  mayorNota  (  )

{

}
Tarea  No.  2  -­ Contar  el  número  de  estudiantes  que  sacaron  una  nota  inferior  a  
la  del  estudiante  que  está  en  la  posición  del  arreglo  que  llega  como  parámetro.  
Suponga  que  el  parámetro  posEst  tiene  un  valor  entre  0  y  TOTAL_EST-­1
public  int  cuantosPeoresQue  (  int  posEst  )
{

}
Tarea  No.  2  -­ Aumentar  en  un  5%  todas  las  notas  del  
curso,  sin  que  ninguna  de  ellas  sobrepase  el  valor  de  5.0
public  void  hacerCurva  (  )
{

}
Patrones  de  recorrido  de  
arreglos
 Patrón  de  recorrido  total
• Se  usa  cuando  se  necesita  recorrer  TODO
el  arreglo
• Ejemplos:
– Calcular  la  suma  de  TODAS  las  notas  del  
curso
–…
–…
–…
 Patrón  de  recorrido  total
Indice  para  movernos  
en  el  arreglo  empieza  
en  CERO

for  (  int  indice  =  0;;  indice  <  arreglo.length;;  indice++)

{
<cuerpo  del  ciclo>
}
 Patrón  de  recorrido  total
Condición  para  
continuar:  índice  menor  
que  la  longitud  del  
arreglo

for  (  int  indice  =  0;;  indice  <  arreglo.length;;  indice++)

{
<cuerpo  del  ciclo>
}
 Patrón  de  recorrido  total
Avance:  incremento  en  
1  del  índice

for  (  int  indice  =  0;;  indice  <  arreglo.length;;  indice++)

{
<cuerpo  del  ciclo>
}
 Indice  empieza  en   Mientras  índice  menor  
CERO que  la  longitud  del  
arreglo

public  int  contarmayoresque  (double  unaNota)

{      int  nrmayores  =  0;;
for  (  int  i  =  0;;  i  <  notas.length;;  i++) Incremento  en  1  del  
índice
{
if  (notas[  i  ]  >  unaNota)
{          
nrmayores++  ;;
}
}
return  nrmayores;;
}
 Guarda  en  cada  paso   Recorre  todo  el  arreglo
el  siguiente  elemento  
en  la  var  indicada
public  int  contarmayoresque  (double  unaNota)
{      int  nrmayores  =  0;;

for  (Double  nota:  notas) No  se  maneja  un  

{ índice.  La  instrucción  
if  (notas  >  unaNota) for  each  recorre  uno  a  
uno  los  elementos
{          
nrmayores++  ;;
}
}
return  nrmayores;;
}
 Indice  empieza  en   Mientras  índice  menor  
CERO que  la  longitud  del  
arreglo
public  int  contarmayoresque  (double  unaNota)
{      int  nrmayores  =  0;;
int  i  =  0;;  
while  (i  <  notas.length)
{
if  (notas[  i  ]  >  unaNota)
{          
nrmayores++  ;;
}
i++;;
}
return  nrmayores;;
} Incremento  en  1  del  
índice,  como  última  
instrucción  del  while
 Proceso
• ¿Es  recorrido  total  o  no?
• Si  es  recorrido  total,  el  ciclo  va  a  ser  de  la  forma
-­>    inicialización
for (int i  =  0;;  i  <  arreglo.length;;  i++)
cuerpo  
terminación  
• Inicialización
– ¿Qué  variables  voy  a  usar  además  del  índice  y  qué  contienen  EN  CADA  MOMENTO…al  
terminar  una  iteración  del  ciclo  y  antes  de  empezar  el  ciclo?  INVARIANTE
– ¿Con  qué  valor  se  inicializan  esas  variables?
• Cuerpo  =  conservar  el  invariante  y  avanzar  hacia  la  solución  
– OJO:  En  el  cuerpo  debe  aparcer alguna  expresión  con  arreglo[  i  ]
– OJO:  En  el  cuerpo  deben  usarse  (en  general)  las  variables  
• Terminación  
– El  método  debe  hacer  algún  cálculo  o  validación  final  o  retornar  algo?
 Proceso-­ promedio  de  notas
• ¿Es  recorrido  total  o  no?
• recorrido  total,  el  ciclo  va  a  ser  de  la  forma
-­>    inicialización
for (int i  =  0;;  i  <  notas.length;;  i++)
cuerpo  
terminación  
• Inicialización
– ¿Qué  variables  voy  a  usar  además  del  índice  y  qué  contienen  EN  CADA  MOMENTO…al  
terminar  una  iteración  del  ciclo  y  antes  de  empezar  el  ciclo?  INVARIANTE
– int suma    /*  suma  de  los  elementos  YA  revisados  
– ¿Con  qué  valor  se  inicializan  esas  variables?
– int suma  =  0;;
• Cuerpo  =  conservar  el  invariante  y  avanzar  hacia  la  solución  
– OJO:  En  el  cuerpo  debe  aparcer alguna  expresión  con  arreglo[  i  ]
– OJO:  En  el  cuerpo  deben  usarse  (en  general)  las  variables  
– Suma  +=  notas  [  i  ]  ;;
• Terminación  
– return suma  /  notas.length;;
Ej.  Lab  1  punto  1  cambiarNotas
Descripción del método:
cambia todas las notas de los estudiantes de la siguiente manera:
* A todos los que obtuvieron menos de 1.5, les asigna la nota 1.5
* A todos los que obtuvieron más de 4.0 les quita 0.5
* A todos los que obtuvieron menos de 3.0 y más de 1.5 les suma 0.5
* Las otras notas las deja iguales

public void cambiarNotas()

 Proceso
• ¿Es  recorrido  total  o  no?
• Si  es  recorrido  total,  el  ciclo  va  a  ser  de  la  forma
-­>    inicialización
for (int i  =  0;;  i  <  arreglo.length;;  i++)
cuerpo  
terminación  
• Inicialización
– ¿Qué  variables  voy  a  usar  además  del  índice  y  qué  contienen  EN  CADA  MOMENTO…al  
terminar  una  iteración  del  ciclo  y  antes  de  empezar  el  ciclo?  INVARIANTE
– ¿Con  qué  valor  se  inicializan  esas  variables?
• Cuerpo  =  conservar  el  invariante  y  avanzar  hacia  la  solución  
– OJO:  En  el  cuerpo  debe  aparcer alguna  expresión  con  arreglo[  i  ]
– OJO:  En  el  cuerpo  deben  usarse  (en  general)  las  variables  
• Terminación  
– El  método  debe  hacer  algún  cálculo  o  validación  final  o  retornar  algo?
 public void cambiarNotas ( )
{
for (int i = 0; i < notas.length; i++)
{

<cuerpo>

}
}

Cuerpo
public void cambiarNotas ( )
{
for (int i = 0; i < notas.length; i++)
{ if (notas[i] < 1.5)
{
notas[i] = 1.5;
}
else if (notas[i] > 4.0)
{
notas [i] = notas [i] -0.5;
}
else if (notas[i] > 1.5 && notas[i] < 3.0)
{
notas [i] = notas [i] + 0.5;
}
}
}
 Patrón  de  recorrido  total  con  
acumulado
• Se  usa  cuando  se  necesita  recorrer  TODO
el  arreglo  y  además  ACUMULAR o  
CALCULAR alguna  propiedad  sobre  
TODOS los  elementos.
• Ejemplos:
– Contar  cuántos  estudiantes  pasaron
– Calcular  el  promedio
–…
–…
 Patrón  de  recorrido  total  con  
acumulado
• Decisiones  a  tomar:
– Cómo  acumular?
– Cómo  inicializar  el  acumulado?
– Condición  para  cambiar  el  acumulado?
– Cómo  cambiar  el  acumulado?
 Proceso
• ¿Es  recorrido  total  o  no?
• Si  es  recorrido  total,  el  ciclo  va  a  ser  de  la  forma
-­>    inicialización
for (int i  =  0;;  i  <  arreglo.length;;  i++)
cuerpo  
terminación  
• ¿Es  con  acumulado?  
– Inicialización:  El  acumulado  se  inicializa  en  0
– int suma  =  0;;
• Cuerpo  =  conservar  el  invariante  y  avanzar  hacia  la  solución  
– El  acumulado  se  incrementa  como  corresponde
 Ejemplo  de  recorrido  total  
public  double  promedio  (  ) public  double  promedio  (  )
{ {
double  suma  =  0.0;;
double  suma  =  0.0;;
for  (  indice  =  0;;  indice  <  notas.length;;   int  indice  =  0;;
indice++)
{
while  (  indice  <  notas.length  )
suma  +=  notas[  indice  ];;
indice++;; {
} suma  +=  notas[  indice  ];;
indice++;;
suma  =  suma  /  TOTAL_EST;; }
return  suma;;
}
suma  =  suma  /  TOTAL_EST;;
return  suma;;
}
 Ejemplo  promedio  de  notas
public  double  promedio  (  )
{
double  suma  =  0.0;;
int  indice  =  0;;

while  (  indice  <  notas.length  )

{
suma  +=  notas[  indice  ];;
indice++;;
}

suma  =  suma  /  TOTAL_EST;;

return  suma;;
}
Ejecución  de  una  instrucción  repetitiva
inicio Preparación  
del  ciclo
Incluye  
indice  =  0

La  condición  es  
verdadera? no
indice  <  arreglo.length Termina  el  ciclo

si

Ejecuta  las  
instrucciones  
del  cuerpo  
del  ciclo
Termina  con  
Indice++
Ejecución  de  una  instrucción  repetitiva
inicio Preparación  del  
ciclo  
Int indice =  0;;  

indice  <   no
arreglo.length Termina  el  ciclo

si
Ejecuta  las  instrucciones  
del  cuerpo  del  ciclo
indice ++;;
Ejecución  de  una  instrucción  repetitiva
inicio Preparación  del  
ciclo  

Int indice =  0;;  

indice  <   no
arreglo.length Termina  el  ciclo

indice ++;;

si
Ejecuta  las  instrucciones  
del  cuerpo  del  ciclo
 Ejemplo

public  int  cuantosPasaron  (  )

{
int  cuantos =  0;;
for  (  int  i  =  0;;  i  <  notas.length;;  i++)
{
if  (  notas[  i  ]  >=  3.0  )
cuantos++;;
}
return  cuantos;;
}
 Patrón  de  recorrido  parcial
• Se  usa  cuando  NO se  necesita  recorrer  TODO
el  arreglo
• Existe  una  condición  que  debemos  verificar  en  
cada  iteración  para  saber  si  debemos  detener  el  
ciclo  o  volver  a  repetirlo
• Si  NO  es  seguro  que  se  salga  por  esa  condición  
debe  también  validarse  que  no  se  termine  el  
arreglo
• Ejemplos:
– Decidir  si  al  menos  un  estudiante  sacó  5.0
– Buscar  el  primer  estudiante  con  nota  igual  a  cero
–…
 Proceso
• ¿Es  recorrido  total  o  parcial?  Si  es  recorrido  parcial…

• Inicialización
– ¿Qué  variables  voy  a  usar  además  del  índice  y  qué  contienen  EN  CADA  MOMENTO…al  
terminar  una  iteración  del  ciclo  y  antes  de  empezar  el  ciclo?  INVARIANTE
– ¿Con  qué  valor  se  inicializan  esas  variables?

• Condición  de  salida:  cuándo  termino  el  ciclo?

– Puede  ser  por  una  causa  o  por  varias
• Encontré  lo  que  buscaba
• Se  recorrió  todo  el  arreglo  y  no  lo  encontré

• Condición  de  entrada:      !terminó_recorrido &&  !encontro

– (i  <  arreglo.length)  &&  (!  encontro)
• Cuerpo  =  conservar  el  invariante  y  avanzar  hacia  la  solución  
– OJO:  En  el  cuerpo  debe  aparcer alguna  expresión  con  arreglo[  i  ]
– OJO:  En  el  cuerpo  deben  usarse  (en  general)  las  variables
– OJO:  en  el  cuerpo  debe  habar  una  condición  que  valide  si  encontró  lo  que  se  buscaba  
Recorrido  con  while  y  con  centinela
public  boolean  alguienConCinco  (  )
{
boolean  encontro  =  false;;
int  i  =  0;;
while  (i  <  notas.length  &&  !encontro)
{
if  (  notas[  i  ]  ==  5.0  )
encontro  =  true;;
i++;;
}
return  encontro;;
0 1 2 3 4 5 6 7 8 9 10 11
}
notas  = 3.5 4.5 3.5 5.0 4.5 2.5 3.5 4.0 2.0 1.5 3.5 5.0
Recorrido  con  while  y  sin  centinela  
public  boolean  alguienConCinco  (  )
{
int  i  =  0;;
while  (  i  <  notas.length  &&  notas[  i  ]  !=  5.0  )
{  
i++;;
}
if  (  i  ==  notas.length)
return  false;;
else
return  true;;
}
0 1 2 3 4 5 6 7 8 9 10 11

notas  = 3.5 4.5 3.5 5.0 4.5 2.5 3.5 4.0 2.0 1.5 3.5 5.0
 Otra  posibilidad:  con  while  y  sin  
centinela  
public  boolean  alguienConCinco  (  )
{
int  i  =  0;;
while  (  i  <  notas.length  &&  notas[  i  ]  !=  5.0  )
{  
i++;;
}
return  (  i  <  notas.length  );;
}

0 1 2 3 4 5 6 7 8 9 10 11

notas  = 3.5 4.5 3.5 5.0 4.5 2.5 3.5 4.0 2.0 1.5 3.5 5.0
 Con  for  y  condición  doble
Indice  para  movernos  
en  el  arreglo  empieza  
en  CERO

for  (  int  indice  =  0;;  indice  <  arreglo.length  &&  !<condicion>;;  indice++)
{
<cuerpo  del  ciclo>
}
 Patrón  de  recorrido  parcial
Condición  para  continuar:  
• índice  menor  que  la  longitud  del  arreglo
Y  (&&)
• no  se  cumple  una  condición

int  indice  =  0  ;;

While  (  indice  <  arreglo.length  &&  !<condicion>)
{
<cuerpo  del  ciclo>
indice++
}
 Patrón  de  recorrido  parcial

for  (  int  indice  =  0;;  indice  <  arreglo.length  &&  !<condicion>;;  indice++)
{
<cuerpo  del  ciclo>
}
 Patrón  de  recorrido  parcial
…  Calcular  la  condición  dentro  del  ciclo  
y  utilizar  una  variable  auxiliar  (centinela)

boolean termino  =  false;;

for  (  int  indice  =  0;;  indice  <  arreglo.length && !termino;;  indice++)
{
<cuerpo  del  ciclo>
if  (  <ya  se  cumplió  el  objetivo>)
termino  =  true;;
}
 Ejemplo
public  boolean  alguienConCinco  (  )
{
boolean  termino  =  false;;
for  (  int  i  =  0;;  i  <  notas.length  &&  !termino;;  i++)
{
if  (  notas[  i  ]  ==  5.0  )
termino  =  true;;
}
return  termino;;
}

0 1 2 3 4 5 6 7 8 9 10 11

notas  = 3.5 4.5 3.5 5.0 4.5 2.5 3.5 4.0 2.0 1.5 3.5 5.0
 Otra  opción:  cortando  el  ciclo  
con  un  return
public boolean alguienConCinco (  )
{
for (  int i  =  0;;  i  <  notas.length;;  i++)
{
public boolean alguienConCinco (  )
if (  notas[  i  ]  ==  5.0  ) {
public boolean alguienConCinco (  )
for (  int i  =  0;;  i  <  notas.length;;  i++)
return true;; { {
for (  int i  =  0;;  i  <  notas.length;;  i++)
} { if (  notas[  i  ]  ==  5.0  )
{  return true;;}
return false  ;; if (  notas[  i  ]  ==  5.0  )
else
{  return true;;}
} return false;; {return false;;}
}
}
} }
 Patrón  de  recorrido  parcial  con  
acumulado
• Se  usa  cuando  NO se  necesita  recorrer  
TODO el  arreglo,  sino  hasta  que  se  
cumpla  una  condición  y  además
• Se  necesita  ACUMULAR o  CALCULAR
alguna  propiedad  sobre  los  elementos.
 Ejemplo  con  acumulado
Encontrar  las  primeras  TRES  notas  de  1.5  y  asignarles  2.5.  
public  void  subirTresNotas(  )
{
Una  variable  para  
int  numNotas  =  0;;
contar  cuántas  notas  de  
boolean  termino  =  false;; 1.5  se  han  subido  a  2.5

for  (  int  i  =  0;;  i  <  notas.length  &&  !termino;;  i++)

{
if  (  notas[  i  ]  ==  1.5  )
{
numNotas++;;
notas[  i  ]  =  2.5;;
}
if  (  numNotas  ==  3  )
termino  =  true;;                
}
}
 Ejemplo  con  acumulado
Encontrar  las  primeras  TRES  notas  de  1.5  y  asignarles  2.5.  
public  void  subirTresNotas(  )
{
Una  variable  centinela  
int  numNotas  =  0;;
para  parar  el  ciclo  
boolean  termino  =  false;; cuando  ya  se  hayan  
subido  3  notas
for  (  int  i  =  0;;  i  <  notas.length  &&  !termino;;  i++)
{
if  (  notas[  i  ]  ==  1.5  )
{
numNotas++;;
notas[  i  ]  =  2.5;;
}
if  (  numNotas  ==  3  )
termino  =  true;;                
}
}
 Ejemplo  con  acumulado
Encontrar  las  primeras  TRES  notas  de  1.5  y  asignarles  2.5.  
public  void  subirTresNotas(  )
{
Ciclo  desde  la  primera  
int  numNotas  =  0;;
posición  del  arreglo,  
boolean  termino  =  false;; mientras  NO  haya  
llegado  al  final  y  NO  se  
for  (  int  i  =  0;;  i  <  notas.length  &&  !termino;;  i++) haya  cumplido  la  
{ condición  del  centinela
if  (  notas[  i  ]  ==  1.5  )
{
numNotas++;;
notas[  i  ]  =  2.5;;
}
if  (  numNotas  ==  3  )
termino  =  true;;                
}
}
 Ejemplo  con  acumulado
Encontrar  las  primeras  TRES  notas  de  1.5  y  asignarles  2.5.  
public  void  subirTresNotas(  )
{
int  numNotas  =  0;;
boolean  termino  =  false;;

for  (  int  i  =  0;;  i  <  notas.length  &&  !termino;;  i++)

Si  la  nota  actual  (de  la  
{ posición  i)  es  1.5,  
if  (  notas[  i  ]  ==  1.5  ) subirla  a  2.5  e  
{ incrementar  el  contador  
numNotas++;; de  notas
notas[  i  ]  =  2.5;;
}
if  (  numNotas  ==  3  )
termino  =  true;;                
}
}
 Ejemplo  con  acumulado
Encontrar  las  primeras  TRES  notas  de  1.5  y  asignarles  2.5.  
public  void  subirTresNotas(  )
{
int  numNotas  =  0;;
boolean  termino  =  false;;

for  (  int  i  =  0;;  i  <  notas.length  &&  !termino;;  i++)

{
if  (  notas[  i  ]  ==  1.5  )
{
numNotas++;;
notas[  i  ]  =  2.5;;
} Si  ya  se  han  subido  
TRES  notas  de  1.5,  
if  (  numNotas  ==  3  )
entonces  poner  el  
termino  =  true;; centinela  en  true  para  
} acabar  el  ciclo
}
 Otra  posibilidad  sin  centinela
Encontrar  las  primeras  TRES  notas  de  1.5  y  asignarles  2.5.  
public  void  subirTresNotas(  )
{
int  numNotas  =  0;;

for  (  int  i  =  0;;  i  <  notas.length  && numNotas  <  3;;  i++)
{
if  (  notas[  i  ]  ==  1.5  )
{
numNotas++;;
notas[  i  ]  =  2.5;;
Se  pone  la  condición  de  
}                
continuación  
} directamente  en  el  ciclo  
}
 Ejemplo  con  acumulado
Método  que  retorna  la  posición  en  el  arreglo  de  la  tercera  nota  con  valor  5.0
public  int  tercerCinco(  )
{
int  cuantosCincos  =  0;; Dos  variables  para  
int  posición  =  0;; acumular  la  información
boolean  termino  =  false;;
for  (  int  i  =  0;;  i  <  notas.length  &&  !termino;;  i++)
{
if  (  notas[  i  ]  ==  5.0  )
cuantosCincos++;;
if  (  cuantosCincos  ==  3  )
{
termino  =  true;;
posicion  =  i;;
}
}
return  posicion;;
}
 Ejemplo  con  acumulado
Método  que  retorna  la  posición  en  el  arreglo  de  la  tercera  nota  con  valor  5.0
public  int  tercerCinco(  )
{
int  cuantosCincos  =  0;;
int  posición  =  0;;
Variable  centinela  del  
boolean  termino  =  false;;
ciclo
for  (  int  i  =  0;;  i  <  notas.length  &&  !termino;;  i++)
{
if  (  notas[  i  ]  ==  5.0  )
cuantosCincos++;;
if  (  cuantosCincos  ==  3  )
{
termino  =  true;;
posicion  =  i;;
}
}
return  posicion;;
}
 Ejemplo  con  acumulado
Método  que  retorna  la  posición  en  el  arreglo  de  la  tercera  nota  con  valor  5.0
public  int  tercerCinco(  )
{
int  cuantosCincos  =  0;;
Condición  con  el  centinela
int  posición  =  0;;
boolean  termino  =  false;;
for  (  int  i  =  0;;  i  <  notas.length  &&  !termino;;  i++)
{
if  (  notas[  i  ]  ==  5.0  )
cuantosCincos++;;
if  (  cuantosCincos  ==  3  )
{
termino  =  true;;
posicion  =  i;;
}
}
return  posicion;;
}
 Ejemplo  con  acumulado
Método  que  retorna  la  posición  en  el  arreglo  de  la  tercera  nota  con  valor  5.0
public  int  tercerCinco(  )
{
int  cuantosCincos  =  0;;
int  posición  =  0;;
boolean  termino  =  false;;
for  (  int  i  =  0;;  i  <  notas.length  &&  !termino;;  i++)
{
if  (  notas[  i  ]  ==  5.0  ) Condición  para  cambiar  el  acumulado
cuantosCincos++;;
if  (  cuantosCincos  ==  3  )
{
termino  =  true;;
posicion  =  i;;
}
}
return  posicion;;
}
 Ejemplo  con  acumulado
Método  que  retorna  la  posición  en  el  arreglo  de  la  tercera  nota  con  valor  5.0
public  int  tercerCinco(  )
{
int  cuantosCincos  =  0;;
int  posición  =  0;;
boolean  termino  =  false;;
for  (  int  i  =  0;;  i  <  notas.length  &&  !termino;;  i++)
{
if  (  notas[  i  ]  ==  5.0  )
cuantosCincos++;;
if  (  cuantosCincos  ==  3  ) Condición  para  cambiar  el  centinela  y  
{ salir  del  ciclo
termino  =  true;;
posicion  =  i;;
}
}
return  posicion;;
0 1 2 3 4 5 6 7 8 9 10 11
}
notas  = 5.0 4.5 3.5 5.0 4.5 5.0 3.5 4.0 2.0 1.5 3.5 5.0
Tarea  No.  4:  Calcular  el  número  mínimo  de  notas  del  curso  necesarias  
para  que  la  suma  supere  el  valor  30,  recorriéndolas  desde  la  posición  0  
en  adelante.  Si  al  sumar  todas  las  notas  no  se  llega  a  ese  valor,  el  
método  debe  retornar  -­1
public  int sumadasDanTreinta  (  )
{
double  sumaNotas  =  0;;
int  cuantasNotas  =  0;;
boolean  termino  =  false;;

for  (  int  i  =  0;;  i  <  notas.length  && !termino;;  i++)

{
sumaNotas  +=  notas[  i  ];;
cuantasNotas++;;
if  (sumaNotas  >=  30)
termino  =  true;;
}
if  (i  ==  notas.lenght)
return  -­1;;
else
return  cuantasNotas;;
}
Caso  de  estudio:  El  Avión
Interfaz  usuario
 Modelo  del  Mundo
Constantes

Arreglo  con   Arreglo  con  

42  sillas 8  sillas

Constantes

Asociación  
opcional
 La  clase  Avion
public  class  Avion
{
//Constantes  
public  final  static  int  SILLAS_EJECUTIVAS  =  8;;
public  final  static  int  SILLAS_ECONOMICAS  =  42;;

//Atributos  
private  Silla[]  sillasEjecutivas;;
private  Silla[]  sillasEconomicas;;
}
 La  clase  Silla
public  class  Silla
{
//  Constantes
public  final  static  int  CLASE_EJECUTIVA  =  1;;
public  final  static  int  CLASE_ECONOMICA  =  2;;
public  final  static  int  VENTANA  =  1;;
public  final  static  int  CENTRAL  =  2;;
public  final  static  int  PASILLO  =  3;;

//  Atributos
private  int  numero;;
private  int  clase;;
private  int  ubicacion;;
private  Pasajero  pasajero;;
}
 La  clase  Pasajero
public  class  Pasajero
{
//  Atributos
private  int  cedula;;
private  String  nombre;;
}
 Un  objeto  de  la  
clase  Avión  podría  
verse  así
Tarea  No.6  – Hacer  la  declaración  de  la  clase  Pasajero
public class Pasajero
{
//-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­
//  Atributos
//-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­

//-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­
//  Constructor
//-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­
public  Pasajero(  int unaCedula,  String  unNombre  )
{

}
Tarea  No.6  – Hacer  la  declaración  de  la  clase  Pasajero
public class Pasajero
{
//-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­
//  Métodos
//-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­
public int darCedula(  )
{

}        

public String  darNombre(  )

{

}
}  
Tarea  No.7  – Completar  la  declaración  de  la  clase  Silla
public class Silla
{
//-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­
//  Constantes
//-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­
public final static int CLASE_EJECUTIVA  =  1;;
public final static int CLASE_ECONOMICA  =  2;;
public final static int VENTANA  =  1;;

//-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­
//  Atributos
//-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­-­
private int numero;;
private int clase;;
private int ubicacion;;
private Pasajero  pasajero;;        
Tarea  No.7  – Completar  la  declaración  de  la  clase  Silla
public class Silla
{
public Silla(  int num,  int clas,  int ubica  )
{
numero  =  num;;
clase  =  clas;;
ubicacion  =  ubica;;
pasajero  =  null;;
}

public void asignarPasajero(  Pasajero  pas  )

{

}  
Tarea  No.7  – Completar  la  declaración  de  la  clase  Silla
public void  desasignarSilla  (  )
{

public boolean sillaAsignada(  )

{

}    

public int darNumero(  )

{

}  
Tarea  No.7  – Completar  la  declaración  de  la  clase  Silla
public int darClase(  )
{

}  

pubic int darUbicacion(  )

{

}  

public Pasajero  darPasajero(  )

{

}  
 La  clase  Avion
public  class  Avion
{
//Constantes  
public  final  static  int  SILLAS_EJECUTIVAS  =  8;;
public  final  static  int  SILLAS_ECONOMICAS  =  42;;

//Atributos  
private  Silla[]  sillasEjecutivas;;
private  Silla[]  sillasEconomicas;;
}
 Método  constructor  de  la  clase  Avion
public  Avion(  )
{
//  Crea  las  sillas  ejecutivas  y  economicas
sillasEjecutivas  =  new  Silla[SILLAS_EJECUTIVAS];;
sillasEconomicas  =  new  Silla[SILLAS_ECONOMICAS];;

sillasEjecutivas[  0  ]  =  new  Silla(  1,  Silla.CLASE_EJECUTIVA,  Silla.VENTANA  );;

sillasEjecutivas[  1  ]  =  new  Silla(  2,  Silla.CLASE_EJECUTIVA,  Silla.PASILLO  );;
sillasEjecutivas[  2  ]  =  new  Silla(  3,  Silla.CLASE_EJECUTIVA,  Silla.PASILLO  );;
sillasEjecutivas[  3  ]  =  new  Silla(  4,  Silla.CLASE_EJECUTIVA,  Silla.VENTANA  );;
sillasEjecutivas[  4  ]  =  new  Silla(  5,  Silla.CLASE_EJECUTIVA,  Silla.VENTANA  );;
sillasEjecutivas[  5  ]  =  new  Silla(  6,  Silla.CLASE_EJECUTIVA,  Silla.PASILLO  );;
sillasEjecutivas[  6  ]  =  new  Silla(  7,  Silla.CLASE_EJECUTIVA,  Silla.PASILLO  );;
sillasEjecutivas[  7  ]  =  new  Silla(  8,  Silla.CLASE_EJECUTIVA,  Silla.VENTANA  );;

sillasEconomicas[  0  ]  =  new  Silla(  9,  Silla.CLASE_ECONOMICA,  Silla.PASILLO  );;

sillasEconomicas[  1  ]  =  new  Silla(  10,  Silla.CLASE_ECONOMICA,  Silla.CENTRAL  );;
…
}
 Un  objeto  de  la  
clase  Avión  podría  
verse  así
Preguntas  frecuentes…
• Cómo  se  hace  el  llamado  a  un  método  
de  un  objeto  que  está  en  el  arreglo?

• Los  objetos  que  están  en  el  arreglo  se  

pueden  guardar  en  una  variable  ?
Preguntas  frecuentes…
• Cómo  se  hace  el  llamado  a  un  método  
de  un  objeto  que  está  en  el  arreglo?

R//  sillasEjecutivas[  3  ].sillaAsignada(  )

• Los  objetos  que  están  en  el  arreglo  se  

pueden  guardar  en  una  variable  ?
R//  SI.
Silla  sillaTemp  =  sillasEjecutivas  [  0  ];;
Volvamos  al  arreglo  de  notas  …
Contar  cuántas  notas  están  por  encima  de  3.0  (o  sea  cuántos  
estudiantes  pasaron)

public  int cuantosPasaron  (  )

{
int  contador  =  0;;
FACIL  !!!
for  (  int  i  =  0;;    i  <  notas.length;;  i++  )
{
if  (  notas  [  i  ] >=  3.0  )
contador++;;
}

return  contador;;
}
Pasemos  al  avión  …
Contar  cuántas  sillas  ejecutivas  están  libres  (o  sea  no  asignadas)

• En  qué  se  parece  al  caso  anterior    (cuantosPasaron)  ?

• En  qué  se  diferencia?

– Cuál  es  el  arreglo  en  este  problema  ?

– Qué  estamos  buscando  ?

 Transformación  …
Caso  de  las  notas  del  curso   Caso  avión  (método  
(método  de  la  clase  Curso) de  la  clase  Avion)  
public  int cuantosPasaron  (  ) public  int cuantasSillasEjecutivasLibres  (  )
{ {

} }
 Transformación  …
Caso  de  las  notas  del  curso   Caso  avión  (método  
(método  de  la  clase  Curso) de  la  clase  Avion)  
public  int cuantosPasaron  (  ) public  int cuantasSillasEjecutivasLibres  (  )
{ {
int  contador  =  0;;

} }
 Transformación  …
Caso  de  las  notas  del  curso   Caso  avión  (método  
(método  de  la  clase  Curso) de  la  clase  Avion)  
public  int cuantosPasaron  (  ) public  int cuantasSillasEjecutivasLibres  (  )
{ {
int  contador  =  0;; int  contador  =  0;;

} }
 Transformación  …
Caso  de  las  notas  del  curso   Caso  avión  (método  
(método  de  la  clase  Curso) de  la  clase  Avion)  
public  int cuantosPasaron  (  ) public  int cuantasSillasEjecutivasLibres  (  )
{ {
int  contador  =  0;; int  contador  =  0;;

for  (  int  i  =  0;;    i  <  notas.length;;  i++  )

} }
 Transformación  …
Caso  de  las  notas  del  curso   Caso  avión  (método  
(método  de  la  clase  Curso) de  la  clase  Avion)  
public  int cuantosPasaron  (  ) public  int cuantasSillasEjecutivasLibres  (  )
{ {
int  contador  =  0;; int  contador  =  0;;

for  (  int  i  =  0;;    i  <  notas.length;;  i++  ) for  (  int  i  =  0;;    i  <  sillasEjecutivas.length;;  i++  )

} }
 Transformación  …
Caso  de  las  notas  del  curso   Caso  avión  (método  
(método  de  la  clase  Curso) de  la  clase  Avion)  
public  int cuantosPasaron  (  ) public  int cuantasSillasEjecutivasLibres  (  )
{ {
int  contador  =  0;; int  contador  =  0;;

for  (  int  i  =  0;;    i  <  notas.length;;  i++  ) for  (  int  i  =  0;;    i  <  sillasEjecutivas.length;;  i++  )
{
if  (  notas  [  i  ] >=  3.0  )
contador++;;
}

} }
 Transformación  …
Caso  de  las  notas  del  curso   Caso  avión  (método  
(método  de  la  clase  Curso) de  la  clase  Avion)  
public  int cuantosPasaron  (  ) public  int cuantasSillasEjecutivasLibres  (  )
{ {
int  contador  =  0;; int  contador  =  0;;

for  (  int  i  =  0;;    i  <  notas.length;;  i++  ) for  (  int  i  =  0;;    i  <  sillasEjecutivas.length;;  i++  )
{ {
if  (  notas  [  i  ] >=  3.0 ) if  (  sillasEjecutivas[  i  ].sillaAsignada(  ) ==  false )
contador++;; contador++;;
} }

} }
 Transformación  …
Caso  de  las  notas  del  curso   Caso  avión  (método  
(método  de  la  clase  Curso) de  la  clase  Avion)  
public  int cuantosPasaron  (  ) public  int cuantasSillasEjecutivasLibres  (  )
{ {
int  contador  =  0;; int  contador  =  0;;

for  (  int  i  =  0;;    i  <  notas.length;;  i++  ) for  (  int  i  =  0;;    i  <  sillasEjecutivas.length;;  i++  )
{ {
if  (  notas  [  i  ] >=  3.0 ) if  (  sillasEjecutivas[  i  ].sillaAsignada(  ) ==  false )
contador++;; contador++;;
} }

return  contador;;

} }
 Transformación  …
Caso  de  las  notas  del  curso   Caso  avión  (método  
(método  de  la  clase  Curso) de  la  clase  Avion)  
public  int cuantosPasaron  (  ) public  int cuantasSillasEjecutivasLibres  (  )
{ {
int  contador  =  0;; int  contador  =  0;;

for  (  int  i  =  0;;    i  <  notas.length;;  i++  ) for  (  int  i  =  0;;    i  <  sillasEjecutivas.length;;  i++  )
{ {
if  (  notas  [  i  ] >=  3.0 ) if  (  sillasEjecutivas[  i  ].sillaAsignada(  ) ==  false )
contador++;; contador++;;
} }

return  contador;; return  contador;;

} }
 Ahora  con  variables  auxiliares  …
Caso  de  las  notas  del  curso   Caso  avión  (método  
(método  de  la  clase  Curso) de  la  clase  Avion)  
public  int cuantosPasaron  (  ) public  int cuantasSillasEjecutivasLibres  (  )
{ {
int  contador  =  0;; int  contador  =  0;;
double  notaAux;; Silla  sillaAux;;

for  (  int  i  =  0;;    i  <  notas.length;;  i++  ) for  (  int  i  =  0;;    i  <  sillasEjecutivas.length;;  i++  )
{ {
notaAux  =  notas[  i  ];; sillaAux  =  sillasEjecutivas[  i  ];;
if  (  notaAux >=  3.0 ) if  (  sillaAux.sillaAsignada(  ) ==  false )
contador++;; contador++;;
} }

return  contador;; return  contador;;

} }
En  la  clase  AVION:

Contar  cuántas  sillas  de  clase  económica  tienen  ubicación  VENTANA  

public  int contarVentanasEconomica  (  )

{

}
En  la  clase  AVION:

Contar  cuántas  sillas  de  clase  económica  tienen  ubicación  VENTANA  

public  int contarVentanasEconomica  (  )

{
int  contador  =  0;;
Silla  sillaAux;;

for  (  int  i  =  0;;    i  <  sillasEconomicas.length;;  i++  )

{
sillaAux  =  sillasEconomicas[  i  ];;
if  (  sillaAux.darUbicacion(  ) ==  Silla.VENTANA)
contador++;;
}

return  contador;;
En  la  clase  AVION:

Contar  cuántas  sillas  de  clase  económica  tienen  una  ubicación  dada  
(que  se  recibe  como  parámetro)
public  int contarSillasEconomicasEnUbicacion  (  int  ubi )
{

}
En  la  clase  AVION:

Contar  cuántas  sillas  de  clase  económica  tienen  una  ubicación  dada  
(que  se  recibe  como  parámetro)
public  int contarSillasEconomicasEnUbicacion  (  int  ubi )
{
int  contador  =  0;;
Silla  sillaAux;;

for  (  int  i  =  0;;    i  <  sillasEconomicas.length;;  i++  )

{
sillaAux  =  sillasEconomicas[  i  ];;
if  (  sillaAux.darUbicacion(  ) ==  ubi )
contador++;;
}

return  contador;;
En  la  clase  AVION:

Informar  (verdadero  o  falso)  si  un  pasajero  dado  se  encuentra  en  la  
clase  ejecutiva  del  avión  (la  cédula  del  pasajero  se  recibe  como  
parámetro)

public  boolean existePasajeroEjecutivo  (  int  ced )

AYUDAS:  
1.  Es  un  patrón  de  recorrido  parcial
2.  Utilice  el  método  darPasajero(  )  de  la  clase  Silla  para  obtener  el
pasajero  de  una  silla
3.  Recuerde  que  una  silla  puede  o  no  estar  asignada  (una  silla  está
asignada  cuando  su  pasajero  existe.  Una  silla  NO  está  asignada
cuando  su  pasajero  no  existe  (es  null))
4.  Utilice  el  método  darCedula(  )  de  la  clase  Pasajero,  para  obtener  el
número  de  cédula  del  pasajero  de  una  silla
En  la  clase  AVION:

Informar  (verdadero  o  falso)  si  un  pasajero  dado  se  encuentra  en  la  
clase  ejecutiva  del  avión  (la  cédula  del  pasajero  se  recibe  como  
parámetro)

public  boolean existePasajeroEjecutivo(  int  ced )

{

}
 Contenedoras  de  tamaño  
variable  o  vectores  (ArrayList)

Caso  de  estudio:  Tienda  de  

Libros
Interfaz  usuario
 Modelo  del  Mundo

Cada  
compra  
Número   hace  
La  tienda   indeterminado   referencia  a  
tiene  un   de  objetos un  libro  del  
carrito  de  
compras catálogo

En  el  carrito  puede  

haber  cero  o  más  
ítems  de  compra
Un  objeto  de  la  clase  
TiendaLibros  podría  
verse  así
 Contenedoras  de  tamaño  
variable  o  vectores  (ArrayList)
 Contenedoras  de  tamaño  variable  
o  vectores
• Se  usan  cuando  NO  conocemos  el  
tamaño  de  la  contenedora  (cantidad  de  
elementos  que  se  van  a  guardar)

• Para  implementarlas  en  Java  es  necesario  

utilizar  una  clase  de  Java  que  se  llama  
ArrayList (se  encuentra  en  el  paquete  
java.util)
Diferencias  entre  arreglos  y  vectores
ARREGLOS VECTORES
• Tamaño  fijo • Tamaño  variable

• Permite  almacenar   • NO permite  almacenar  

elementos  de  tipo  simple   elementos  de  tipo  simple  
(int,  float,  double)  y  objetos (int,  float,  double),  SOLO
objetos
• Para  implementarlos  en   • Para  implementarlos  en  
java,  existe  una  sintaxis   java  debemos  utilizar  una  
especial: clase  especial  de  java  
– [  ]:  para  obtener  un  elemento   (ArrayList).
del  arreglo • Para  manipular  un  vector  
– length:  para  conocer  la   se  utiliza  entonces  la  
longitud misma  sintaxis  que  
utilizamos  para  manejar  
cualquier  otra  clase  
(llamado  a  métodos)
 Declaración  de  un  vector
Se  importa  el  paquete  de  java  
import  java.util.*;; donde  se  encuentra  la  clase  
ArrayList  

public  class  TiendaLibros El  atributo  es  un  vector

Sus  elementos  son  libros
{ Su  nombre  es  catalogo

private  ArrayList <Libro>  catalogo;;

Lo  que  ya  sabíamos  hacer:
private  CarroCompras carrito;; Declara  un  atributo  cuyo  tipo
Es  una  clase  

} Nombre  de  la  clase Nombre  del  atributo

Inicialización  y  tamaño  de  un  vector

public  TiendaLibros(  )
{
catalogo  =  new ArrayList  <Libro>(  );;
carrito  =  new CarroCompras(  );;    
}
• Se  usa  la  misma  sintaxis  que  para  crear  un  objeto  
de  cualquier  clase  (new)  

• No  se  dice  cuántos  elementos  va  a  tener  el  vector.  

El  tamaño  inicial  es  0  (cero).

• No  se  dice  de  que  tipo  son  los  objetos  que  se  van  a  
guardar  en  él
 Algunos  métodos  de  la  clase  
ArrayList
• isEmpty(  )  -­ Es  un  método  que  retorna  verdadero  si  el  vector  no  
tiene  elementos,  y  falso  en  caso  contrario.
• size(  )  – Es  un  método  que  retorna  el  número  de  elementos  que  hay  
en  el  vector
• get  (indice)  – Retorna  el  objeto  en  la  posición  indice.  Las  posiciones  
comienzan  desde  0
• add(  objeto)  – agrega  el  objeto  al  final  del  vector
• add(  indice,  objeto)  – inserta  el  objeto  en  la  posición  indice  y  corre  
los  siguiente  una  posición
• set  (indice,  objeto)  – pone  el  objeto  en  la  posición  índice.  No  corre  
los  otros.  El  que  estaba  en  esa  posición  se  pierde
• remove  (indice)  – elimina  ese  elemento  del  vector.  Los  que  le  siguen  
quedan  enuna  posición  adelantas
 Patrón  de  recorrido  total

En  arreglos   En  vectores  

for  (  int  i  =  0;;  i  <  notas.length;;  i++) for  (  int  i  =  0;;  i  <  catalogo.size(  );;  i++)
{ {
<cuerpo  del  ciclo> <cuerpo  del  ciclo>
} }
Acceso  a  los  elementos  de  un  vector
Nombre  del  
vector

vector.get ( pos  )
Método  get   Parámetro  que  indica  la  
de  la  clase   posición  del  elemento  
ArrayList que  se  quiere  obtener
Ejemplo  en  la  clase  TiendaLibros
public  int inventario(  )
{
int  sumaPrecios  =  0;; Variable  auxiliar  o  
temporal  de  tipo  
Libro  libroAux;; Libro

for  (  int  i  =  0;;  i  <  catalogo.size(  );;  i++)

{
libroAux =  catalogo.get(  i  );;
sumaPrecios  +=  libroAux.darPrecio(  );;
}
return  sumaPrecios;;
}
Ejemplo  en  la  clase  TiendaLibros
public  int inventario(  )
{
int  sumaPrecios  =  0;;
Recorrido  total  
Libro  libroAux;; hasta  el  final  del  
vector  catalogo

for  (  int  i  =  0;;  i  <  catalogo.size(  );;  i++)

{
libroAux =  catalogo.get(  i  );;
sumaPrecios  +=  libroAux.darPrecio(  );;
}
return  sumaPrecios;;
}
Ejemplo  en  la  clase  TiendaLibros
public  int inventario(  )
{
int  sumaPrecios  =  0;;
Libro  libroAux;;

for  (  int  i  =  0;;  i  <  catalogo.size(  );;  i++) Obtención  del  

elemento  de  la  
{ posición  i  del  
libroAux =  catalogo.get(  i  );; vector
sumaPrecios  +=  libroAux.darPrecio(  );;
}
return  sumaPrecios;;
}
Ejemplo  en  la  clase  TiendaLibros
public  int inventario(  )
{
int  sumaPrecios  =  0;;
Libro  libroAux;;

for  (  int  i  =  0;;  i  <  catalogo.size(  );;  i++)

{
libroAux =  catalogo.get(  i  );;
sumaPrecios  +=  libroAux.darPrecio(  );;
}
return  sumaPrecios;;
}
Ejemplo  en  la  clase  TiendaLibros
public  int inventario(  )
{
int  sumaPrecios  =  0;;
Libro  libroAux;;

for  (  int  i  =  0;;  i  <  catalogo.size(  );;  i++)

{
libroAux =  catalogo.get(  i  );;
sumaPrecios  +=  libroAux.darPrecio(  );;
}
Llamado  al  
return  sumaPrecios;; método  darPrecio  
} del  libroAux
Agregar  un  elemento  al  final  de  un  
vector
Nombre  del  
vector

vector.add ( objeto  )
Método  add   Parámetro  que  es  el  
de  la  clase   objeto  que  se  va  a  
ArrayList agregar  al  vector
Insertar  un  elemento  en  una  posición  
dada  dentro  de  un  vector
Nombre  del   Parámetro  que  indica  la  
vector posición  donde  se  va  a  
insertar  el  elemento

vector.add ( indice, objeto  )

Método  add   Parámetro  que  es  el  
de  la  clase   objeto  que  se  va  a  
ArrayList insertar  en  el  vector
Ejemplo  en  la  clase  TiendaLibros
public  void agregarTresLibros(  )
{
Libro libroAux1  =  new  Libro(“Cien  años  de  soledad”,  “98657”,  15000);;
Libro libroAux2 =  new  Libro(“La  inmortalidad”,  “23758”,  23800);;
Libro libroAux3 =  new  Libro(“El  perfume”,  “5759308”,  42100);;

catalogo.add(  libroAux1 );;

catalogo.add(  libroAux2 );;
catalogo.add(  1,  libroAux3 );;
}
Remplazar  un  elemento  en  un  vector

Nombre  del   Parámetro  que  indica  la  

vector posición  donde  se  va  a  
remplazar  el  elemento

vector.set ( indice, objeto  )

Método  set   Parámetro  que  es  el  
de  la  clase   nuevo  objeto  que  va  a  
ArrayList remplazar  el  anterior  en  
el  vector
Ejemplo  en  la  clase  TiendaLibros
public  void intercambiar(  int  pos1,  int  pos2 )
{
Libro libroAux1;;
Libro libroAux2;;

libroAux1 =  catalogo.get(  pos1 );;

libroAux2 =  catalogo.get(  pos2 );;
catalogo.set(  pos1,  libroAux2 );;
catalogo.set(  pos2,  libroAux1 );;
}
Eliminar  un  elemento  de  un  vector

Nombre  del  
vector

vector.remove ( indice )
Método  remove   Parámetro  que  indica  la  
de  la  clase   posición  del  elemento  que  se  
ArrayList desea  eliminar
Tarea  No.  10  -­ En  la  clase  TiendaLibros:

Localizar  un  libro  en  el  catalogo,  dado  su  ISBN  (que  se  recibe  como  
parámetro).  Si  no  lo  encuentra,  el  método  debe  retornar  null  
public  Libro buscarLibro  (  String  isbn)
{

}
Tarea  No.  10  -­ En  la  clase  TiendaLibros:

Adicionar  un  libro  en  el  catálogo,  si  no  existe  ya  un  libro  con  ese  ISBN.  
Utilice  el  método  anterior  para  identificar  el  caso  en  el  cual  ya  hay  un  
libro  con  ese  ISBN.  El  libro  que  se  desea  adicionar  se  recibe  como  
parámetro.
public  void adicionarLibroCatalogo  (  Libro  nuevoLibro)
{

}
Tarea  No.  11  -­ En  la  clase  CarroCompras:

Adicionar  una  cantidad  de  ejemplares  de  un  libro  al  pedido  actual.  El  
método  debe  considerar  el  caso  en  el  que  el  libro  ya  se  encuentre  en  el  
pedido,  caso  en  el  cual  solo  debe  incrementar  el  número  de  
ejemplares.  Si  el  libro  no  se  encuentra,  el  método  debe  crear  un  nuevo  
item  ItemCompra.  El  libro  que  se  desea  adicionar,  así  como  la  cantidad  
se  reciben  como  parámetros.

public  void adicionarCompra  (  Libro  lib,  int  cant)

{

}
Tarea  No.  11  -­ En  la  clase  CarroCompra:

Calcular  el  monto  total  de  la  compra  del  usuario.  Para  esto  debe  tener  
en  cuenta  el  precio  de  cada  libro  y  el  número  de  ejemplares  de  cada  
uno  que  hay  en  el  pedido.
public  int calcularValorTotalCompra  (  )
{

}
Tarea  No.  11  -­ En  la  clase  CarroCompra:

Eliminar  del  pedido  el  libro  que  tiene  el  ISBN  dado  como  parámetro.  Si  
no  hay  ningún  libro  con  ese  ISBN,  el  método  no  hace  nada.

public  void borrarItemCompra(  String  isbn)

{

}
 Patrón  de  doble  recorrido
• Se  usa  cuando  por  CADA  ELEMENTO del  
arreglo  se  debe  hacer  un  recorrido  
COMPLETO
• Ejemplos:
– Encontrar  la  nota  que  aparece  un  mayor  
número  de  veces  en  el  curso
–…
–…
–…
 Patrón  de  doble  recorrido

for  (  int indice1  =  0;;  indice1 <  arreglo.length;;  indice1++)

{
for  (int  indice2  =  0;;  indice2 <  arreglo.length;;  indice2++)
{
<cuerpo  del  ciclo  interno>
}
<cuerpo  del  ciclo  externo>
}
2  ciclos
2  índices
 Patrón  de  doble  recorrido
for  (  int indice1  =  0;;  indice1 <  arreglo.length;;  indice1++)
{
for  (int  indice2  =  0;;  indice2 <  arreglo.length;;  indice2++)
{
<cuerpo  del  ciclo  interno>
}
<cuerpo  del  ciclo  externo>
}
0 1 2 3 4 5 6 7 8 9 10 11
indice1:  avanza  
lentamente
5.0 4.5 3.5 5.0 4.5 5.0 3.5 4.0 2.0 1.5 3.5 5.0
notas  =
Indice2:  avanza  
rápidamente.  Cada  vez  
que  índice1  se  
incrementa  en  una  
unidad,  indice2  recorre  
TODO  el  arreglo
 Ejemplo
Encontrar  la  nota  que  aparece  un  mayor  número  de  veces  en  el  curso

public  double masVecesAparece(  )

{
Qué  hacer  ???
}

0 1 2 3 4 5 6 7 8 9 10 11

notas  = 5.0 4.5 3.5 5.0 4.5 5.0 3.5 4.0 3.5 1.5 3.5 5.0
 Ejemplo
Encontrar  la  nota  que  aparece  un  mayor  número  de  veces  en  el  curso

public  double masVecesAparece(  )

{
double  notasMasVecesAparece =  0.0;;
for  (  int i  =  0;;  i <  notas.length;;  i++)
{
for  (int  j  =  0;;  j <  notas.length;;  j++) El  resultado  lo  vamos  a  
{ dejar  en  una  variable  
<cuerpo  del  ciclo  interno> llamada  
notasMasVecesAparece,  la  
} cual  retornamos  al  final  del  
<cuerpo  del  ciclo  externo> método
}  
return  notaMasVecesAparece;;
}
 Ejemplo
Encontrar  la  nota  que  aparece  un  mayor  número  de  veces  en  el  curso

public  double masVecesAparece(  )

{
double  notasMasVecesAparece =  0.0;;
for  (  int i  =  0;;  i <  notas.length;;  i++)
{
for  (int  j  =  0;;  j <  notas.length;;  j++) Armamos  la  estructura  del  
{ método  a  partir  del  esqueleto  
<cuerpo  del  ciclo  interno> del  patrón.
} Utilizamos  las  variables i y    j
para  llevar  los  índices  de  cada  
<cuerpo  del  ciclo  externo> uno  de  los  ciclos
}  
return  notaMasVecesAparece;;
}
 Ejemplo
Encontrar  la  nota  que  aparece  un  mayor  número  de  veces  en  el  curso

public  double masVecesAparece(  )

{
double  notasMasVecesAparece =  0.0;;
for  (  int i  =  0;;  i <  notas.length;;  i++)
{ Hay  dos  problemas  para  
resolver:
for  (int  j  =  0;;  j <  notas.length;;  j++) 1) Contar  el  número  de  veces  
{ que  aparece  en  el  arreglo  
<cuerpo  del  ciclo  interno> el  valor  que  está  en  la  
} casilla  i
2) Encontrar  el  mayor  valor  
<cuerpo  del  ciclo  externo> entre  los  calculados  por  el  
}   primer  problema
return  notaMasVecesAparece;;
}
 Ejemplo
Encontrar  la  nota  que  aparece  un  mayor  número  de  veces  en  el  curso
public  double  masVecesAparece(  )
{
double  notaMasVecesAparece =  0.0;;
Hay  dos  problemas  para  
resolver:
for  (  int i  =  0;;  i <  notas.length;;  i++) 1) Contar  el  número  de  veces  
{ que  aparece  en  el  arreglo  
for  (int  j  =  0;;  j <  notas.length;;  j++) el  valor  que  está  en  la  
{ casilla i
<contar  cuantas  veces  aparece  } 2) Encontrar  el  mayor  valor  
entre  los  calculados  por  el  
la  nota  buscada  (notas  [  i  ])>
primer  problema
}
<verificar  si  es  la  nota  mas  frecuente>
}
return  notaMasVecesAparece;;
}
 Primer  problema:  contar  el  número  de  veces  que  
aparece  en  el  arreglo  el  valor  que  está  en  la  casilla  i

public  double  masVecesAparece(  )

{
double  notasMasVecesAparece  =  0.0;;
Dejamos  en  la  variable  
for  (  int  i  =  0;;  i  <  notas.length;;  i++) notaBuscada,  la  nota  para  
{ la  cual  queremos  contar  el  
double  notaBuscada  =  notas[  i  ];; número  de  ocurrencias.  La  
int  contador  =  0;; inicializamos  con  la  nota  de  
la  casilla  i.
for  (int  j  =  0;;  j  <  notas.length;;  j++)
{
if  (  notas[  j  ]  ==  notaBuscada  )
contador++;;
}
<verificar  si  es  la  nota  mas  frecuente>
}  
return  notaMasVecesAparece;;
}
 Primer  problema:  contar  el  número  de  veces  que  
aparece  en  el  arreglo  el  valor  que  está  en  la  casilla  i

public  double  masVecesAparece(  )

{
double  notasMasVecesAparece  =  0.0;;
for  (  int  i  =  0;;  i  <  notas.length;;  i++)
{
double  notaBuscada  =  notas[  i  ];; Usamos  una  segunda  
int  contador  =  0;; variable  llamada  contador  
para  acumular  allí  el  número  
for  (int  j  =  0;;  j  <  notas.length;;  j++) de  veces  que  aparece  la  
{ nota  buscada.
if  (  notas[  j  ]  ==  notaBuscada  )
contador++;;
}
<verificar  si  es  la  nota  mas  frecuente>
}  
return  notaMasVecesAparece;;
}
 Primer  problema:  contar  el  número  de  veces  que  
aparece  en  el  arreglo  el  valor  que  está  en  la  casilla  i

public  double  masVecesAparece(  )

{
double  notasMasVecesAparece  =  0.0;;
for  (  int  i  =  0;;  i  <  notas.length;;  i++)
{
double  notaBuscada  =  notas[  i  ];;
int  contador  =  0;;

for  (int  j  =  0;;  j  <  notas.length;;  j++)

{ En  el  ciclo  interno,  vamos  a  
if  (  notas[  j  ]  ==  notaBuscada  ) contar  cuántas  veces  
contador++;; aparece  la  nota  buscada.  
} Se  incrementa  el  contador  
<verificar  si  es  la  nota  mas  frecuente> cada  vez  que  notaBuscada  
}   sea  igual  a  notas[  j  ].
return  notaMasVecesAparece;;
}
 Segundo  problema:  Encontrar  el  mayor  valor  entre  los  
calculados  por  el  primer  problema
public  double  masVecesAparece(  )
{
Usamos  esta  variable  para  
double  notaMasVecesAparece  =  0.0;;
indicar  la  nota  que  hasta  el  
int  numeroVecesAparece  =  0;;
momento  aparece  mas  
for  (  int  i  =  0;;  i  <  notas.length;;  i++) veces
{
double  notaBuscada  =  notas[  i  ];;
int  contador  =  0;;
for  (int  j  =  0;;  j  <  notas.length;;  j++)
{
if  (  notas  [  j  ]  ==  notaBuscada  )
contador++;;                                                    
}
if  (  contador  >  numeroVecesAparece)
{
notasMasVecesAparece  =  notaBuscada;;
numeroVecesAparece  =  contador;;
}
}
return  notaMasVecesAparece;;
}
 Segundo  problema:  Encontrar  el  mayor  valor  entre  los  
calculados  por  el  primer  problema
public  double  masVecesAparece(  )
{
double  notaMasVecesAparece  =  0.0;; Usamos  esta  variable  para  
int  numeroVecesAparece  =  0;; contar  cuántas  veces  
for  (  int  i  =  0;;  i  <  notas.length;;  i++) aparece  la  nota  
{ notaMasVecesAparece  
double  notaBuscada  =  notas[  i  ];;
int  contador  =  0;;
for  (int  j  =  0;;  j  <  notas.length;;  j++)
{
if  (  notas  [  j  ]  ==  notaBuscada  )
contador++;;                                                    
}
if  (  contador  >  numeroVecesAparece)
{
notasMasVecesAparece  =  notaBuscada;;
numeroVecesAparece  =  contador;;
}
}
return  notaMasVecesAparece;;
}
 Segundo  problema:  Encontrar  el  mayor  valor  entre  los  
calculados  por  el  primer  problema
public  double  masVecesAparece(  )
{
double  notaMasVecesAparece  =  0.0;;
int  numeroVecesAparece  =  0;;        
for  (  int  i  =  0;;  i  <  notas.length;;  i++)
{
double  notaBuscada  =  notas[  i  ];;
int  contador  =  0;;
for  (int  j  =  0;;  j  <  notas.length;;  j++)
{
Definimos  el  caso  en  el  cual  
if  (  notas  [  j  ]  ==  notaBuscada  ) debemos  cambiar  el  
contador++;;                                                     acumulado:  si  encontramos  
} un  valor  que  aparezca  mas  
if  (  contador  >  numeroVecesAparece) veces  que  el  que  teníamos  
{ hasta  el  momento  (contador  
notasMasVecesAparece  =  notaBuscada;; >  numeroVecesAparece)  
numeroVecesAparece  =  contador;; debemos  actualizar  los  
} valores  de  las  variables  
}
return  notaMasVecesAparece;;
}
 Conclusión
• Para  resolver  un  problema  que  implique  doble  
recorrido:
– Primero  debemos  identificar  los  dos  problemas  que  
queremos  resolver  (uno  con  cada  ciclo)
– Luego,  debemos  tratar  de  resolverlos  
independientemente,  usando  los  patrones  de  
recorrido  total  o  parcial
• Si  para  resolver  el  problema,  se  necesita  un  
tercer  ciclo  anidado,  debemos  escribir  métodos  
separados  que  ayuden  a  resolver  cada  
problema  individualmente  (nivel  4),  porque  la  
solución  directa  es  muy  compleja  y  propensa  a  
errores.
Tarea  No.  5:  Calcular  una  nota  del  curso  tal  que  la  mitad  de  las  notas  
sean  menores  o  iguales  a  ella.  Si  hay  varias  que  lo  cumplan,  puede  
retornar  cualquiera.
public  double notaMediana  (  )
{

}
 Ahora  con  la  Tienda  de  Libros
Tarea:  Informar  (verdadero  o  falso)  si  en  el  catálogo  de  la  tienda  de  
libros  hay  dos  libros  con  el  mismo  título

public  boolean hayDobleTitulo(  )

{
Qué  hacer  ???
}
 Ahora  con  la  Tienda  de  Libros
Tarea:  Informar  (verdadero  o  falso)  si  en  el  catálogo  de  la  tienda  de  
libros  hay  dos  libros  con  el  mismo  título
public  boolean hayDobleTitulo(  )
{