Unidad 2 Metodos y Estructuras de Control

Programacin orientada a objetos I
Unidad 2. Mtodos y estructuras de control
Ingeniera en Desarrollo de Software

3er semestre
Programa de la asignatura:
Unidad 2
Mtodos y estructuras de control
Clave:
Ingeniera: TSU:
15142316 / 16142316
Universidad Abierta y a Distancia de Mxico
Ciencias Exactas, Ingenieras y Tecnologa | Desarrollo de Software 1

ndice
Unidad 2. Mtodos y estructuras de control ....................................................................... 3
Presentacin de la unidad ................................................................................................. 3
Propsito ........................................................................................................................... 3
Competencia especfica..................................................................................................... 3
Consideraciones especficas de la unidad: actividades, requerimientos de asignatura,
otras .................................................................................................................................. 4
2.1. Generalidades de los mtodos.................................................................................... 4
2.1.1. Declaracin y mbito de variables............................................................................ 5
2.1.2. Declaracin de constantes ..................................................................................... 10
2.2. Mtodos que no devuelven valores ........................................................................... 12
2.2.1. Caractersticas ....................................................................................................... 12
2.2.2. Llamada de mtodos.............................................................................................. 12
2.3. Mtodos que devuelven valores ................................................................................ 13
2.3.1. Recepcin de parmetros ...................................................................................... 14
2.3.2. Retorno de parmetros .......................................................................................... 15
2.3.3. Paso de parmetros ............................................................................................... 15
2.3.4. Llamada de mtodos.............................................................................................. 16
2.4. Estructuras de control selectivas ............................................................................... 17
2.4.1. If-else ..................................................................................................................... 17
2.4.2. If anidado ............................................................................................................... 19
2.4.3. Switch-case ........................................................................................................... 20
2.5. Estructuras de control cclicas................................................................................... 23
2.5.1. While...................................................................................................................... 23
2.5.2. Do-while ................................................................................................................. 24
2.5.3. For ......................................................................................................................... 25
Cierre de la unidad .......................................................................................................... 29
Para saber ms ............................................................................................................... 30
Fuentes de consulta ........................................................................................................ 30

Presentacin de la unidad
En la unidad anterior se vieron temas introductorios para la programacin OO, cuyos

temas fungieron como iniciacin para comprender el uso y aplicacin de la programacin.
En esta unidad de POO I, aprenders el concepto de los mtodos y su utilizacin para
crear programas modulares, as como el manejo de las estructuras de control selectivas y
cclicas. Todo esto se utilizar para que realices programas ms completos y complejos
en la siguiente unidad, sobre la aplicacin de las caractersticas de POO y las
excepciones.
Propsito
Al trmino de esta unidad logrars:
Describir las generalidades de los mtodos.

Distinguir los mtodos que devuelven
valores contra los que no devuelven.
Manejar las estructuras de control selectivas
y cclicas.
Competencias especficas

Desarrollar programas modulares para

solucionar problemas diversos, mediante la
aplicacin de los diferentes tipos de variables,
mtodos, y estructuras de control en lenguaje
Java.
Consideraciones especficas de la unidad: actividades, requerimientos

de asignatura, otras
Es muy importante que captures todos los programas de ejemplo, para que analices su
sintaxis y puedas comprender mejor los temas vistos.
2.1. Generalidades de los mtodos
Cuando se est trabajando en el lenguaje de

programacin Java, la clase es el elemento bsico
que lo conforma, pero a su vez est conformada por
varios subbloques de cdigo que la conforman, los
cuales se llaman mtodos y agrupan de manera ms
o menos ordenada a los algoritmos que conforman el
cuerpo de nuestro programa o aplicacin.
Todos los mtodos tienen cierta estructura que los distinguen de los dems elementos del
lenguaje Java, la estructura clsica de un mtodo es la siguiente:
tipo_devuelto nombre_mtodo([parmetros]){
sentencia1;
sentencia2;
sentenciaN;
}

Ntese que el elemento [parmetros] est delimitado por corchetes, lo que quiere decir
que es un elemento opcional. Cuando los parmetros se manejan como lista de ellos, o
sea ms de uno, se separa esta lista con una coma entre cada uno.
Adems de lo anterior, podremos entender a los mtodos como:

Un bloque de cdigo que tiene un nombre.
Capaces de recibir parmetros o argumentos (opcionalmente, como ya se dijo).
Contienen sentencias que le permiten realizar la tarea para la cual fue creado.
Devuelven un valor de algn tipo (recordar el tema de tipo de datos) conocido.
2.1.1. Declaracin y mbito de variables
Haciendo referencia al apartado de tipos de datos, se hablar ahora del concepto de

variable que se entender como una locacin de memoria reservada para alojar un dato
que cambiar con respecto al tiempo/espacio donde se ejecute la aplicacin. Tienen
asociado un identificador y un tipo de dato que le da nombre (identificador) e indica qu
guardaremos en ella (tipo de dato); lo que es aplicable a Java y cualquier otro lenguaje de
programacin.
En Java, cuando se va a hacer uso de una variable primero se debe declarar, es decir,
indicarle al compilador que hemos reservado esa locacin de memoria para poder alojar
un dato de inters para nuestra aplicacin. De no ser as, y aunque pongamos un
identificador a la variable, Java nos indicar que no est definida.
En funcin a los datos que almacenan las variables se clasifican en:
Variables primitivas: sirven para almacenar datos numricos, valores lgicos o

caracteres.
Variables referenciadas: asociadas a un objeto, o son la instancia de una clase.

Para profundizar un poco ms en el concepto, se dir que una variable no es nada ms

que un contenedor de bits que representan un valor. Se entender de la siguiente
manera:
Cuando se habla de variables primitivas, los bits que la forman slo representan
un nmero que coincide con el valor asignado a la misma y. como se indic, puede
quedarse conteniendo ese valor o puede cambiar a lo largo de la ejecucin del
programa. Por ejemplo, relacionando lo expuesto ahora con el tema de tipos de
dato, se tiene que hay variables de tipo byte (con una longitud de 8 bits en
memoria) y puede almacenar nmeros enteros con signo entre -128 y 127 (cuando
no se utiliza el signo el valor puede ser hasta 255), de tipo int (con una longitud de
32 bits en memoria), para almacenar nmeros enteros con signo entre -
2,147,483,648 al 2,147,483,647, de tipo float con sus respectivos lmites hasta
abarcar todos los tipos de dato.
Visto de manera grfica pudiera quedar como sigue:
byte z = 5; // declaracin de variable de tipo byte vlida en Java
00000101 contenedor
de bits
byte z Los bits representan el
valor 5. Este valor es el
dato que se almacena en
memoria y se trabajar
con l durante la
ejecucin del programa.
Siguiendo lo antes
expuesto, x ser el
nombre del contenedor y
byte indicar la forma del
contenedor.

Cuando se habla de variables referenciadas o asociadas a un objeto, los bits representan

un identificador que permite acceder al valor de la variable; es decir, nos da una
referencia al objeto, pero no es el objeto a la variable en s.
Visto de manera grfica, pudiera quedar como sigue:
Integer z=new Integer(100); //declaracin de una variable de tipo objeto Integer, vlido en
Java.
Se muestra a continuacin algunos ejemplos de declaraciones de variables referentes a

Java, para los tipos de variables primitivas, referenciadas o asociadas a un objeto:
int a; // declaracin de una variable 'a' de tipo entero

//su valor inicial (por definicin) es 0.
int b = 10;
// declaracin de una variable 'b' de tipo entero
// con valor inicial establecido a 10.
Nombre_Clase referencia;
// declaracin de una variable con identificador 'referencia'

// donde su tipo de dato ser 'Nombre_Clase' o dicho de otra

manera
// aqu es donde se crea el contenedor.
Nombre_Clase referencia2;
// mismo caso que la variable anterior,
// pero el identificador ahora es 'referencia2'.
referencia = new Nombre_Clase;
// En este tipo de variables la declaracin no es suficiente se
deber crear
// un nuevo objeto de la clase 'Nombre_Clase', y es asignado a la
variable
// 'referencia'. En el paso anterior se dijo que se crea el
contenedor,
// en este paso se le asigna un valor (referencia al objeto) al
contenedor.
referencia2 = referencia;
// Ahora tambin 'referencia2' tiene el mismo
// objeto a su cargo que 'referencia'
Ahora que se ha aclarado un poco la idea de qu es una variable, sus componentes

principales y el modo en que se hace una declaracin de la misma, debemos considerar
las distintas partes del programa donde la utilizaremos. Es lo que se conoce como mbito
de la variable.
Este concepto es uno de los ms importantes que debemos conocer cuando estamos
trabajando y manipulando variables. Se llama mbito de una variable al lugar donde sta
est disponible. Por lo general, cuando declaramos una variable, slo estar disponible en
el bloque de cdigo (encerrado entre llaves) donde se ha declarado, que puede ser desde
el mbito de la clase completa, el mbito slo de un mtodo, o incluso dentro del mbito
de los elementos que lo conforman, por ejemplo las sentencias if, while, for y entre todos
los tipos disponibles que tenga Java.

Por ejemplo:
public class AmbitoVariables{

public static void main(String[] args){
if (true) {
int a=10; //Decalaracin de la variable dentro del bloque que
corresponde
// a la sentencia if (dentro del mbito del if).
}
System.out.println(a); // Acceso a la variable fuera del mbito
donde
//fue declarada (fuera del bloque if, delimitado
//por llaves).
}
}
Al compilar esta pequea clase de ejemplo, se notar que el compilador de Java lanza un
mensaje de error que indicar que la variable a la que se hace referencia (variable con
identificador a) no ha sido encontrada; en otras palabras, su declaracin no est dentro
del mbito en donde se pretende usar. El mensaje de error del compilador de Java tendr
un aspecto como se muestra en las siguientes imgenes.
Figura 1 Figura 2

Se puede notar claramente que, en la primer imagen (Figura 1), el IDE nos est indicando
algn tipo de error en la lnea 21, sealando la variable con identificador a como la posible
causa. En la segunda imagen (Figura 2) nos da los detalles completos de la causa del
error, el programador deber entender que no se puede encontrar el smbolo (variable)
especificado.
Hay ms normas de mbito respecto a las variables miembro de una clase, donde
intervienen los modificadores de acceso public o private. Cuando una variable es
declarada con el modificador public, se accede directamente a ellas a travs de
nombre_clase.nombre_variable. En el caso de que una variable sea declarada con el
modificador private, slo se podr acceder a ella mediante los mtodos de la clase que lo
permitan.
2.1.2. Declaracin de constantes
Desde la concepcin de la definicin del lenguaje Java, no fueron consideradas las

constantes en su trmino ms estricto, entendidas como un valor que no puede ser
alterado durante la ejecucin de un programa, y corresponde a una longitud fija en la
memoria de la computadora donde se ejecuta el programa.
Sin embargo, para hacer frente a esta pequea inconveniencia del lenguaje, una
declaracin de variable como static final, se puede considerar una constante muy efectiva.
El modificador static permite el acceso a una variable miembro de una determinada clase,
sin haber cargado una instancia de sta donde ser utilizada. El modificador final provoca
que la variable (su contenido) no pueda ser cambiada.
La siguiente declaracin define la constante llamada PI cuyo valor est definido por el
nmero (3.1415927).
static final float PI = 3.1415927; //Constante que representa el nmero PI.

Como ya se dijo, si se intenta modificar el valor contenido en la variable identificada como

PI, se dar un error de compilacin.

2.2. Mtodos que no devuelven valores
Una vez que se estudiaron las generalidades sobre los mtodos, se deber conocer que
existen dos tipos cuando se habla de ellos:
Mtodos que retornan valores.
Mtodos que no retornan valores.
En este apartado se analizarn los mtodos que no regresan valores.
2.2.1. Caractersticas
El hecho de que un mtodo regrese valores o no es opcional. Cuando un mtodo no

retorna valores, se deber modificar la definicin de sus parmetros y quedar como
sigue:
void nombre_mtodo([parmetros]){
sentencia1;
sentencia2;
sentenciaN;
}
En donde se deber utilizar la palabra reservada void que le indica al compilador y al

mtodo que su valor de retorno ser vaco. Dentro del cuerpo de sus sentencias se
omite return, por no regresar valor alguno a donde fue llamado. Los parmetros de igual
manera son opcionales, aunque los parntesis van por obligacin.
2.2.2. Llamada de mtodos
Cuando decimos que llamamos un mtodo, estamos haciendo uso de las sentencias que
lo conforman. De igual manera, se dice que se invoca al mtodo.

Los mtodos se invocan (llaman) por el nombre definido en su declaracin, y se deber

pasar la lista de argumentos entre parntesis. Por ejemplo, se definir un mtodo que
imprima a pantalla un mensaje para el usuario.
public void saludo_usuario(){

String cadena_Saludo = Hola usuario, feliz viaje en Java;
System.out.println(cadena_Saludo);
System.out.println(Mensaje impreso desde un mtodo);
}
Cuando ya se ha definido el mtodo y sus sentencias son las necesarias y adecuadas, se
hace una invocacin a l o, mejor dicho, se invocan las sentencias que conforman el
cuerpo del mtodo. Se realiza de la siguiente manera:

saludo_usuario();
}
La salida ser la siguiente:
Hola usuario, feliz viaje en Java

Mensaje impreso desde un mtodo
2.3. Mtodos que devuelven valores
Por definicin del lenguaje Java, todos los mtodos deberan regresar valores, excepto en
los casos explicados en el apartado anterior. Cuando los mtodos declarados en Java
regresan valores, quiere decir que se espera recibir alguna respuesta o resultado de
alguna operacin realizada por las sentencias que conforman su cuerpo. Para que un
mtodo pueda regresar valores, deben estar involucrados varios factores que le ayuden o
alimenten, para poder realizar dichas operaciones. Estos elementos bsicos son:

Parmetros de entrada, que son las entradas propias del mtodo que le ayudarn
a saber sobre qu se realizarn las operaciones indicadas en las sentencias que lo
conforman, aunque este apartado se puede considerar opcional.
Parmetros de retorno, que es la respuesta que nos regresar una vez que haya
ejecutado el cuerpo de sus sentencias.
En los apartados siguientes se explicar, con ms detalle, los elementos mencionados y

algunos otros que son necesarios para los mtodos que regresan valores.
2.3.1. Recepcin de parmetros
Los parmetros de un mtodo se pueden entender como los valores que ste recibe
desde la parte del cdigo donde es invocado. Los parmetros pueden ser de tipos
primitivos (int, double, float, entre otros) u objetos.
Como ya se ha visto, en la declaracin del mtodo se escribe qu parmetros recibir

dentro de los parntesis, separando cada uno de ellos por una coma, mencionando el tipo
de cada uno de ellos y el identificador, se entender tambin que no hay lmites en el
nmero de parmetros que se envan al mtodo. Se presenta un ejemplo:
public int obtener_potencia(int base, int potencia){

}
Este mtodo recibe dos parmetros de tipo entero, cuyos identificadores son base y
potencia.

2.3.2. Retorno de parmetros
Cuando el mtodo de nuestro inters ya ha recibido (o consigue) los elementos

necesarios para poder realizar sus funciones, retornar el resultado de aplicarlas sobre
los parmetros recibidos. Se deber indicar en la declaracin del mtodo qu tipo de dato
retornar, y sealar en el cuerpo de sus sentencias la palabra reservada return (con esto
se precisa que regresar). Se ilustra un ejemplo a continuacin:
public int obtener_potencia(int base, int potencia){

int resultado = Math.pow(base, potencia);
return resultado;
}
Las partes del cdigo que estn resaltadas indican el retorno de parmetros del resultado
de obtener la potencia de los parmetros recibidos (base y potencia). El lector deber
notar que el tipo de dato declarado en la definicin del mtodo es el mismo que el
utilizado en la variable de retorno (resultado), si fuera de otra manera, el compilador
lanzar un error de tipos incompatibles.
2.3.3. Paso de parmetros
Cuando se invoque (llame) el parmetro que se quiera utilizar, deberemos pasar los
indicados (necesarios) en su declaracin. Los parmetros se escriben a continuacin del
nombre del mtodo que se quisiera utilizar, de igual manera entre parntesis, pero al
hacer la invocacin no se indica el tipo de dato de los mismos, aunque las variables que
enviemos forzosamente debern coincidir con el tipo que pretendemos utilizar.
Por ejemplo, se completar el llamado del mtodo presentado en el punto anterior.

int b = 3; //representando a la base

int p = 2; //representando a la potencia

obtener_potencia(b,p);

}
Como informacin al lector, se debe aclarar que se omiten muchas partes de los mtodos,
slo son ejemplos ilustrativos de cada uno de los puntos.
Tambin como punto importantsimo, recordando los tipos de variables, se dir que en
Java los parmetros de tipo primitivo (int, long, double, ) siempre se pasan por
valor. Las variables de tipo objeto y arrays se pasan por referencia (a su direccin de
memoria de alojamiento).
2.3.4. Llamada de mtodos
Para complementar todos los elementos de los mtodos que regresan valores, se indicar
cul es la forma correcta de llamar a los mtodos, pasando los parmetros correctos y
recibiendo de manera adecuada los valores de retorno.
Como ya se mencion, al invocar un mtodo simplemente se deber escribir el nombre

del que interesa utilizar, seguido de los parmetros que necesita (fueron indicados en su
declaracin). Como ejemplo, se terminar de desarrollar el cdigo del mtodo de la
obtencin de potencias.

int b = 3; //representando a la base
int p = 2; //representando a la potencia
int r_potencia // variable que recibir el resultado desde el
mtodo
r_potencia = obtener_potencia(b,p);
System.out.println(El resultado es: +r_potencia);
}

Donde:
r_potencia ser el valor de recepcin del parmetro devuelto por el mtodo. De
igual manera deber coincidir el tipo de dato de la variable de recepcin, con el
tipo de dato indicado en el mismo. En este caso indica que regresar un int,
entonces el tipo de la variable deber ser tambin int.
La llamada al mtodo obtener_potencia ser la conjuncin de todos los puntos
explicados, necesitar un lugar donde depositar su valor de retorno (explicado en
el punto anterior), y pasar los parmetros necesarios despus del nombre del
mtodo, sin olvidar que todos los tipos de las variables deben coincidir (las
variables que se pasan como parmetros, la que se retorna desde el mtodo, y
aquella donde se recibe este valor de retorno). Se representa en esta lnea:
r_potencia = obtener_potencia(b,p);
2.4. Estructuras de control selectivas
Las estructuras alternativas son construcciones que permiten

alterar el flujo secuencial de un programa, de forma que en
funcin de una condicin o el valor de una expresin, el mismo
pueda ser desviado en una u otra alternativa de cdigo (Garca,
Rodrguez, Mingo, Imaz, Brazlez, Larzabal et l., 2000).
2.4.1. If - else
La estructura de seleccin simple o if es aquella secuencia de un programa que se ve

afectada por una condicin, si sta es cumplida la secuencia del programa entrar en el
bloque de instrucciones de dicha estructura, de lo contrario la secuencia del programa se
saltar ese bloque de cdigo y entrar al bloque de instrucciones else, dado que la
condicin se cumpli. Esta estructura de control se conforma como sigue:
// Instrucciones previas a la condicin
if( condicin) {
Instrucciones a ejecutarse solo si la condicin se cumpli.
}

else{
Instrucciones a ejecutarse si la condicin NO se cumpli.
}
// Instrucciones a ejecutarse despus de la condicin
Las llaves se utilizan para agrupar las instrucciones que se han de ejecutar, si slo
quieres que se ejecute una instruccin puedes omitirlas. Es importante mencionar que las
instrucciones previas y posteriores al bloque if-else se ejecutan de manera normal, se
cumpla o no la condicin, por lo que slo se altera la secuencia del programa en ese
bloque.
A continuacin se muestra un ejemplo donde dada una calificacin, se decide si es

aprobatoria o no, y esto se indica en un mensaje.
package ejemplos; Define el paquete donde se encuentra
/**
* @author ESAD Indica el nombre del autor
*/ Declara la clase llamada estructuraIF
public class estructuraIF {
Se declara el mtodo main
public static void main(String[] args) {
int calificacion=80; Declaro la variable calificacin
if(calificacion> 70){ Establezco la condicin de If

System.out.print("Aprobado"); Se muestra a pantalla el resultado
} Palabra reservada else
else{ Se enva el mensaje a pantalla.
System.out.print("Reprobado");
} Se manda una impresin que se ejecutar
System.out.print("esto se imprimir se despus de la estructura selectiva if else.
cumpla o no la condicin");
}
}

2.4.2. If anidado
Esta estructura es un agrandamiento de la anterior, ya que se pueden evaluar diferentes

condiciones ligadas.
Por ejemplo, en el tema anterior slo queramos que se mostrara Aprobado o Reprobado,
segn la calificacin, pero ahora se quiere dar mayor reconocimiento a los puntos
obtenidos. Esto se realizara de la siguiente manera:
package ejemplos;
/**
* @author ESAD
*/
public class estructuraIF {

int calificacion=90;
if(calificacion> 90 && calificacion <= 100){

System.out.print("Excelente");
}
else if(calificacion >80 && calificacion <= 90){
System.out.print("Muy Bien");
}
else if(calificacion >70 && calificacion <= 80){
System.out.print("Bien");
}
else if(calificacion < 70){
System.out.print("Muy mal");
}
}
}

En este ejemplo evaluamos que, si su calificacin est entre 90 y 100, se mostrar un

mensaje diciendo Muy bien. Si no tienes una calificacin entre 90 y 100, pero est entre
80 y 90, se mostrar Bien; pero si no cumpli ninguna de las anteriores, y la calificacin
es menor de 70 se mostrar Muy mal.
Como has podido observar, se pueden colocar condiciones mltiples como en este
ejemplo, donde no slo se evalu una calificacin, sino todo un rango, para ello se auxili
de los operadores lgicos y relacionales que se vieron en la unidad anterior.
2.4.3. Switch-case
La estructura selectiva switchcase tambin es conocida como de decisin mltiple. En

sta se puede evaluar una misma expresin con, como su nombre lo indica, mltiples
opciones, pero en este caso no son condiciones, el switch evala si una variable tiene un
valor en especfico. A continuacin se muestra una estructura:
// Instrucciones previas a la condicin

switch(expresion) {
case valor: instrucciones a ejecutarse;
break;
case valor: instrucciones a ejecutarse;
break;
default: instrucciones;
}
// Instrucciones a ejecutarse despus de la condicin
Una sentencia case es una opcin de los diferentes valores que puede tomar la expresin
que se evala. Por cada valor permitido que la expresin pueda tomar, se representar
una sentencia case.
Las caractersticas ms relevantes de switch son las siguientes (Gosling, Holmes y

Arnold, 2001):

1. Cada sentencia case se corresponde con un nico valor. No se pueden establecer

rangos o condiciones sino que se deben comparar con valores concretos.
2. Los valores no comprendidos en ninguna sentencia case se pueden gestionar en
default, que es opcional.
3. En la ausencia de break, cuando se ejecuta una sentencia case se ejecutan
tambin todas las case que van a continuacin, hasta que se llega a un break o
termina el switch.
Se muestra un ejemplo a continuacin:
package ejemplos;
import javax.swing.JOptionPane;
/**
* @author ESAD
*/
public class ejemploSwitch {
int mes= Integer.parseInt(JOptionPane.showInputDialog("Cul es el

nmero del mes"));
switch(mes){
case 1: System.out.print("Enero");
break;
case 2: System.out.print("Febrero");
break;
case 3: System.out.print("Marzo");
break;
case 4: System.out.print("Abril");
break;

case 5: System.out.print("Mayo");
break;
case 6: System.out.print("Junio");
break;
case 7: System.out.print("Julio");
break;
case 8: System.out.print("Agosto");
break;
case 9: System.out.print("Septiembre");
break;
case 10: System.out.print("Octubre");
break;
case 11: System.out.print("Noviembre");
break;
case 12: System.out.print("Diciembre");
break;
default:System.out.print("Mes no vlido");
}
}
}
Este ejemplo muestra que, al inicio del programa, se crea una variable llamada mes, la
cual almacena el nmero del mes indicado por el usuario, y muestra en la pantalla el
nombre del mes correspondiente. Para identificarlo utilizamos la sentencia switch, que
para este ejemplo tiene 12 casos que son los meses que existen. Al encontrar el valor
correspondiente mostrar el nombre del mes, y en caso de que el usuario ingrese un
nmero no vlido, como 20, se mostrar el siguiente mensaje: Mes no vlido.
Si requieres usar un programa donde las comparaciones sean muy especficas, puedes
emplear un switch; en el caso de evaluar rangos, utiliza un if.

2.5. Estructuras de control cclicas
Las estructuras de control cclicas son bloques de instrucciones que se repiten un nmero
de veces mientras se cumple, o hasta que se cumpla una condicin (Garca, Rodrguez,
Mingo, Imaz, Brazlez, Larzabal et l., 2000).
Como regla general puede decirse que se utilizar:
Ciclo for, cuando se conozca de antemano el nmero exacto de veces que ha de

repetirse un determinado bloque de instrucciones.
Ciclo do-while, cuando no se conoce exactamente el nmero de veces que se
ejecutar, pero se sabe que por lo menos se ha de ejecutar una.
Ciclo while-do, cuando es posible que no deba ejecutarse ninguna vez.
Estas reglas son generales, y algunos programadores se sienten ms cmodos utilizando
principalmente una de ellas. Con mayor o menor esfuerzo, puede utilizarse cualquiera de
ellas indistintamente.
2.5.1. While
El ciclo while tiene como caracterstica que primero evala la condicin y solo si se
cumple realiza las instrucciones, as es que si la condicin no es cumplida desde un inicio,
el control del programa no entrar en el bloque de instrucciones que se encuentran dentro
del ciclo. Su declaracin es como se muestra a continuacin:
while (condicion){
Bloque de Instrucciones a repetir
}
La condicin que se d, deber ser evaluada verdadera para que el control del programa
ingrese al bloque de instrucciones, y deber llegar en algn punto a que esa misma
condicin se evale falsa y salga del bloque repetitivo. Si planteas mal la condicin y sta
nunca se evala como falsa, el programa se repetir infinitamente, lo que provocar un
problema en la ejecucin.

Observa el siguiente ejemplo.
package ejemplos;
/**
* @author ESAD
*/
public class ejemploWhile {
int n= Integer.parseInt(JOptionPane.showInputDialog("Ingresa el
9"));
while(n != 9){
n= Integer.parseInt(JOptionPane.showInputDialog("Ingresa el 9"));
}
}
}
En este ejemplo se pide al usuario ingresar el nmero 9, y el ciclo seguir mientras no lo
ingresen, en el momento en que la condicin se deja de cumplir (precisamente al ingresar
dicho nmero) el ciclo terminar y el programa tambin.
2.5.2. Do-while
Este ciclo permite la ejecucin del bloque repetitivo al menos una vez, se cumpla o no la
condicin, pues ejecuta primero el bloque do y al finalizarlo evala la condicin, si sta se
cumple regresa a ejecutar nuevamente el bloque do, de lo contrario termina la ejecucin.
do{
Bloque de instrucciones a repetir
}
While(condicion);
Veamos el siguiente ejemplo:

package ejemplos;

/**
* @author ESAD
*/
public class ejemploDoWhile {
int n;
do{
n= Integer.parseInt(JOptionPane.showInputDialog("Ingresa el 9"));
}
while(n != 9);
}
}
Como se puede observar, el ciclo while es muy parecido al do-while, pero recordemos que
el while, si desde un principio no se cumple la condicin no entra al ciclo, y el do-while
primero entra y despus evala.
Compara los dos ejemplos, y observars que en el ciclo do-while la peticin del nmero la
hacemos dentro del bloque que conforma el do, pues se tiene la certeza de que entrar a
ejecutar esta porcin del programa, al menos una vez. Mientras que en el ciclo while la
peticin se hace fuera del bloque de instrucciones que lo conforman, pues la evaluacin
se realiza antes de entrar al ciclo.
2.5.3. For
Este ciclo es especialmente til cuando, de antemano, conoces el nmero de veces que
quieres que se ejecute el mismo bloque de instrucciones, su declaracin es como sigue:
for(inicio ; condicin; incremento){
Bloque de instrucciones repetitivas
}
Inicio: se debe colocar un valor numrico donde comenzar el conteo de ejecuciones.

Condicin: se coloca la condicin a evaluar en cada iteracin del ciclo para que se siga
ejecutando el nmero de veces que se cumpla esta condicin, pues el momento en que
se evale como falsa el ciclo dejar de repetirse.
Incremento: esta instruccin se evala como si fuese la ltima del bloque de

instrucciones, e indica el incremento o decremento de la variable numrica de inicio, para
reevaluar la condicin en cada iteracin.
Se expone a continuacin el ejemplo:

package ejemplos;
/**
* @author ESAD
*/
public class ejemploFor {
int n= Integer.parseInt(JOptionPane.showInputDialog("Cuntos
nmeros quieres ver"));
for(int i=1; i<=n; i=i+1){
System.out.print(i);
}
}
}
Aqu se pide al usuario un nmero, y muestra esa misma cantidad de elementos. Veamos,
el inicio empieza en 1, la condicin para seguir es que la variable i sea menor o igual que
el nmero dado por el usuario, y el incremento ser de uno en uno; de esta manera, la
salida del programa al ingresar un 5 sera como se muestra a continuacin.

Otro punto importante respecto al ciclo for es que se puede anidar. sto se refiere a que
puedo utilizar un ciclo dentro de otro, a manera de explicacin observa el siguiente cdigo
y su salida.
package ejemplos;
/**
* @author ESAD
*/
public class forAnidado {
int n= Integer.parseInt(JOptionPane.showInputDialog("Cuantos
temas son"));
int m= Integer.parseInt(JOptionPane.showInputDialog("Cuantos
subtemas contiene cada tema"));
for(int i=1; i<=n; i=i+1){
for(int j=1; j<=m; j=j+1){
System.out.print(i+","+j);
System.out.print("\n");
}
}
}
}
Como se puede ver, se tiene un ciclo dentro de otro. Su manera de funcionar es que entra
al primero, despus al segundo y, hasta que el segundo termine sus repeticiones, el
primero volver a incrementar su valor y volver a entrar al segundo tomando sus valores
iniciales. Veamos la salida. En este ejemplo se indic que los temas eran tres, mientras
que los subtemas dos, entonces se coloca el primer tema y sus respectivos subtemas 1.1.

y 1.2., ya que termina ese tema se sigue con el 2.1. y 2.2.
Nota: Si se quisieran anidar ms de dos ciclos for es posible realizarlo, tomando en cuenta
que siempre el ciclo que se encuentre ms adentro ser el que se realice primero.
Tambin puede ser que el ciclo, en lugar de ir de manera ascendente, se realice de forma
descendente, para esto se debe tomar en cuenta que el inicio sea el ltimo elemento, la
condicin de paro el 0 y su incremento sea restar 1. Observa el siguiente ejemplo, que es
el mismo que el ejemplo del for, pero ahora con un recorrido inverso.
package ejemplos;
/**
* @author ESAD
*/
public class ejemploFor2 {
int n= Integer.parseInt(JOptionPane.showInputDialog("Cuntos
nmeros quieres ver"));
for(int i=n; i>0; i=i-1){
System.out.print(i);
System.out.print("\n");
}
}
}

Al realizar los cambios comentados, podemos observar que la salida nos muestra los
cinco nmeros, pero de manera descendente.
Cierre de la unidad
Has concluido la unidad 2 del curso. A lo largo de sta has visto lo que es una variable, su
mbito y declaracin, as como las generalidades de los mtodos, sus caractersticas,
llamadas y tipos de parmetros que se manejan. Posteriormente, te involucraste
conociendo las estructuras de control selectivas, como lo son el If-else, If anidado y
switch-case.
Al final de la unidad, tambin se vieron las estructuras de control cclicas while, do-while y
for, cuyo propsito ha sido que obtengas conocimientos sobre estructuras de control, y
logres aplicarlas en la resolucin de problemas y creacin de programas para dichas
soluciones.
Es aconsejable que revises nuevamente la unidad en caso de que los temas que se
acaban de mencionar no te sean familiares o no los recuerdes, de no ser este tu caso, ya
ests preparado(a) para seguir con la unidad 3, en donde continuars con la revisin de
herencia, polimorfismo y excepciones en un programa Java. Todo ello con el fin de
obtener el conocimiento necesario para comenzar a realizar pequeos programas
computacionales al final de la cuarta y ltima unidad del curso de Programacin orientada
a objetos I.

Para saber ms
Consulta la pgina oficial del lenguaje Java: http://www.java.com/es/, donde podrs

encontrar manuales de referencia sobre los mtodos, variables, estructuras de control
selectivas y de repeticin.
Fuentes de consulta
Garca, J., Rodrguez, J., Mingo, I., Imaz, A., Brazlez, A., Larzabal, A. et l.
(2000). Aprenda Java como si estuviera en primero. Recuperado de
http://www.tecnun.es/asignaturas/Informat1/AyudaInf/aprendainf/Java/Java2.pdf
Gosling, J., Holmes, D. y Arnold, K. (2001). El lenguaje de programacin Java TM.
Recuperado de http://icesecurity.org/programacion/JAVA/Libro_Java-SP.pdf

Unidad 2 Metodos y Estructuras de Control

Cargado por

Información del documento

Descripción original:

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Unidad 2 Metodos y Estructuras de Control

Cargado por

Copyright:

Formatos disponibles

Programacin orientada a objetos I

Unidad 2. Mtodos y estructuras de control

Ingeniera en Desarrollo de Software

Universidad Abierta y a Distancia de Mxico

Ciencias Exactas, Ingenieras y Tecnologa | Desarrollo de Software 1

Ciencias Exactas, Ingenieras y Tecnologa | Desarrollo de Software 2

Unidad 2. Mtodos y estructuras de control

En la unidad anterior se vieron temas introductorios para la programacin OO, cuyos

Al trmino de esta unidad logrars:

Describir las generalidades de los mtodos.

Ciencias Exactas, Ingenieras y Tecnologa | Desarrollo de Software 3

Desarrollar programas modulares para

Consideraciones especficas de la unidad: actividades, requerimientos

2.1. Generalidades de los mtodos

Cuando se est trabajando en el lenguaje de

Ciencias Exactas, Ingenieras y Tecnologa | Desarrollo de Software 4

Adems de lo anterior, podremos entender a los mtodos como:

2.1.1. Declaracin y mbito de variables

Haciendo referencia al apartado de tipos de datos, se hablar ahora del concepto de

En funcin a los datos que almacenan las variables se clasifican en:

Variables primitivas: sirven para almacenar datos numricos, valores lgicos o

Ciencias Exactas, Ingenieras y Tecnologa | Desarrollo de Software 5

Para profundizar un poco ms en el concepto, se dir que una variable no es nada ms

Visto de manera grfica pudiera quedar como sigue:

byte z = 5; // declaracin de variable de tipo byte vlida en Java

Ciencias Exactas, Ingenieras y Tecnologa | Desarrollo de Software 6

Cuando se habla de variables referenciadas o asociadas a un objeto, los bits representan

Visto de manera grfica, pudiera quedar como sigue:

Se muestra a continuacin algunos ejemplos de declaraciones de variables referentes a

int a; // declaracin de una variable 'a' de tipo entero

Ciencias Exactas, Ingenieras y Tecnologa | Desarrollo de Software 7

// donde su tipo de dato ser 'Nombre_Clase' o dicho de otra

Ahora que se ha aclarado un poco la idea de qu es una variable, sus componentes

Ciencias Exactas, Ingenieras y Tecnologa | Desarrollo de Software 8

public class AmbitoVariables{

Ciencias Exactas, Ingenieras y Tecnologa | Desarrollo de Software 9

2.1.2. Declaracin de constantes

Desde la concepcin de la definicin del lenguaje Java, no fueron consideradas las

static final float PI = 3.1415927; //Constante que representa el nmero PI.

Ciencias Exactas, Ingenieras y Tecnologa | Desarrollo de Software 10

Como ya se dijo, si se intenta modificar el valor contenido en la variable identificada como

Ciencias Exactas, Ingenieras y Tecnologa | Desarrollo de Software 11

2.2. Mtodos que no devuelven valores

En este apartado se analizarn los mtodos que no regresan valores.

El hecho de que un mtodo regrese valores o no es opcional. Cuando un mtodo no

En donde se deber utilizar la palabra reservada void que le indica al compilador y al

2.2.2. Llamada de mtodos

Ciencias Exactas, Ingenieras y Tecnologa | Desarrollo de Software 12

Los mtodos se invocan (llaman) por el nombre definido en su declaracin, y se deber

public void saludo_usuario(){

public static void main(String[] args){

Hola usuario, feliz viaje en Java

2.3. Mtodos que devuelven valores

Ciencias Exactas, Ingenieras y Tecnologa | Desarrollo de Software 13

En los apartados siguientes se explicar, con ms detalle, los elementos mencionados y

2.3.1. Recepcin de parmetros

Como ya se ha visto, en la declaracin del mtodo se escribe qu parmetros recibir

public int obtener_potencia(int base, int potencia){

Ciencias Exactas, Ingenieras y Tecnologa | Desarrollo de Software 14

2.3.2. Retorno de parmetros

Cuando el mtodo de nuestro inters ya ha recibido (o consigue) los elementos

public int obtener_potencia(int base, int potencia){

2.3.3. Paso de parmetros