Universidad Nacional Autónoma de Nicaragua, León

Facultad de Ciencias y Tecnología

Departamento de Computación

Componente: Programación Orientada a Objetos

Unidad II:
TEMA: Sentencias de control y Arreglos

Elaborado por:
➢ Luis Ernesto Díaz Beteta

“A la libertad por la Universidad”

 Programación Orientada a Objetos

TABLA DE CONTENIDOS

Contenido
1. Sentencias de selección .................................................................................................................. 3
1.1. Generalidades ......................................................................................................................... 3
1.2. Sentencia if (selección simple y doble) .................................................................................... 3
1.3. Anidación de sentencias if ...................................................................................................... 4
1.4. Estructura else if...................................................................................................................... 6
1.5. Estructura switch (selección multiple)..................................................................................... 8
2. Sentencias repetitivas o bucles ..................................................................................................... 10
2.1. Sentencia while ..................................................................................................................... 10
2.2. Sentencia do while ................................................................................................................ 11
2.3. Sentencia for ......................................................................................................................... 12
2.4. Sentencia foreach ................................................................................................................. 14
2.5. Ciclos anidados...................................................................................................................... 14
3. Arreglos ......................................................................................................................................... 16
3.1. Arreglos unidimensionales (Vectores) .................................................................................. 17
3.2. Arreglos bidimensionales (Matrices) .................................................................................... 18
3.3. Arreglos de cadenas .............................................................................................................. 19
3.4. Matriz de tipo ArrayList......................................................................................................... 19
4. Bibliografía .................................................................................................................................... 22

2
 Programación Orientada a Objetos

1. Sentencias de selección
1.1. Generalidades
Las soluciones a los problemas planteados no siempre serán de forma lineal o consecutiva, en ciertas
ocasiones necesitaremos ejecutar sentencias en función del valor que tomen una o más expresiones
(aritméticas o lógicas) en un instante determinado durante la ejecución del programa.
El término de control de flujo se refiere al orden en que se ejecutan las sentencias de un programa.
En más de una ocasión habrá que ejecutar un conjunto de sentencias un número determinado de
veces, o bien hasta que se cumpla una determinada condición.

1.2. Sentencia if (selección simple y doble)

Esta sentencia permite tomar una decisión para ejecutar una acción u otra, basándose en el
resultado de una expresión booleana. La sintaxis para utilizar esta sentencia es la siguiente:

La sentencia if se ejecuta de la forma siguiente:

1. Se evalúa la condición (se obtiene un resultado verdadero o falso).
2. Si el resultado es verdadero (true) se ejecutará lo indicado por la sentencia1.
3. Si el resultado es falso (false) la sentencia1 es ignorada y se ejecutará lo indicado por la
sentencia2, si la cláusula else se ha especificado.
4. En cualquier caso, la ejecución continúa en la siguiente sentencia ejecutable que haya a
continuación de la sentencia if.

A continuación se exponen algunos ejemplos para que vea de una forma sencilla cómo se utiliza la
sentencia if.

En este ejemplo, la condición está dada por la expresión x != 0. Entonces b=a/x, se ejecutará si la
expresión es verdadera (si el valor de x distinto de 0) pero si el resultado de la expresión es falso la
expresión no será ejecutada. En cualquier caso, se continúa la ejecución en la línea siguiente, b=b+1.
En el siguiente diagrama se muestra el flujo de ejecución del código descrito.

3
 Programación Orientada a Objetos

En el ejemplo siguiente, si se cumple que a==b*5, se ejecutan las sentencias x = 4 y a = a+x. de otro
modo, se ejecuta la sentencia b = 0. En ambos casos, la ejecución continúa en la siguiente línea del
programa.

En el siguiente diagrama se muestra el flujo de ejecución del código descrito

1.3. Anidación de sentencias if

Las sentencias de control pueden concatenarse entre sí de tal forma que una sentencia forme parte
del bloque de código de otra sentencia. A esta combinación de sentencias se le conoce como
anidación de sentencias. Ejemplo:

Al evaluarse las condiciones, pueden presentarse los casos que se indican en la tabla siguiente:
Se ejecuta
condicion1 condicion2 sentencia1 sentencia2
F F No Si
F V No Si
V F No No
V V Si No

4
 Programación Orientada a Objetos

En el ejemplo anterior las llaves definen perfectamente que la cláusula else está emparejada
con el primer if. ¿Qué sucede si quitamos las llaves?

Resultado:

Se ejecuta
condicion1 condicion2 sentencia1 sentencia2
F F No No
F V No No
V F No Si
V V Si No

Este resultado se debe a que “cada else se corresponde con el if más próximo que no haya sido
emparejado”. Según esto la cláusula else está emparejada con el segundo if.
Consideremos el siguiente ejemplo:

¿Qué pasa cuando la variable número es igual a cero? ¿Qué sucede cuando el número es menor a
cero o cuando es mayor que cero?
En cualquiera de los casos, se ejecutarán las tres condicionales aunque la primera de ellas haya
resultado ser verdadera. El siguiente código presenta una mejor forma de solucionar el problema
utilizando anidamiento.

5
 Programación Orientada a Objetos

Si la primera condición (numero==0) se cumple las demás no son evaluadas, obteniendo así una
mejor solución al problema.

Como ejercicio sobre la teoría expuesta, vamos a realizar una aplicación que dé como resultado el
menor de tres números.

1.4. Estructura else if

Este tipo de estructura aparece con bastante frecuencia y es por lo que se le da un tratamiento por
separado. Esta estructura es consecuencia de las sentencias if anidadas. Su formato general es:

6
 Programación Orientada a Objetos

La evaluación de esta estructura sucede de la siguiente manera:

Si se cumple la condicion1, se ejecuta la sentencia1. Si no se cumple la condicion1 , se examinan
secuencialmente las condiciones siguientes hasta el último else, ejecutándose la sentencia
correspondiente al primer else if, cuya condición sea cierta.
Ejemplo:

Ejercicio; al efectuar una compra en un cierto almacén, si adquirimos más de 100 unidades de un
mismo artículo, nos hacen un descuento de un 40%; entre 25 y 100 un 20%; entre 10 y 24 un 10%; y
no hay descuento para una adquisición de menos de 10 unidades. Se pide calcular el importe a pagar
basado en la cantidad comprada y el precio del producto.

7
 Programación Orientada a Objetos

1.5. Estructura switch (selección multiple)

switch permite ejecutar una de varias acciones, en función del valor de una expresión. Es una
sentencia especial para decisiones múltiples. La sintaxis es:
Donde expresión es una expresión aritmética de tipo entero,
y expresión_constante es una constante del mismo tipo que
expresión o de un tipo que se pueda convertir implícitamente
al tipo de expresión,
La sentencia switch evalúa la expresión y compara su valor
con las constantes de cada case. La ejecución de las
sentencias del bloque de la sentencia switch comienza en el
case cuya constante coincida con el valor de la expresión, y
continúa hasta una sentencia que transfiera el control dentro
o fuera del bloque de switch; esta sentencia debe estar presente por cada case así como para
default. Generalmente se utiliza break para transferir el control fuera del bloque de la sentencia
switch.
Si no existe una constante igual al valor de la expresión, entonces se ejecutan las sentencias que
están a continuación de default. Ejemplo:

8
 Programación Orientada a Objetos

Para ilustrar la sentencia switch, vamos a realizar un programa que lea una fecha representada por
dos enteros, mes y año, y dé como resultado los días correspondientes al mes. Se debe tener en
cuenta que febrero puede tener 28 días, o bien 29 si el año es bisiesto. Un año es bisiesto cuando es
múltiplo de 4 y no de 100 o cuando es múltiplo de 400.
La solución de este problema puede ser de la siguiente forma:

9
 Programación Orientada a Objetos

El que las cláusulas case estén una a continuación de otra o una debajo de otra no es más que una
cuestión de estilo, ya que C# interpreta cada carácter nueva línea como un espacio en blanco; esto
es, el código al que llega el compilador es el mismo en cualquier caso.

2. Sentencias repetitivas o bucles

2.1. Sentencia while
La sentencia while ejecuta una sentencia, simple o compuesta, cero o más veces, dependiendo del
valor de una expresión booleana. Su sintaxis es:
Donde condición es cualquier expresión booleana y sentencias es una
sentencia simple o compuesta (bloque de código).

La ejecución de la sentencia while sucede así:

1. Si el resultado es falso (false), la sentencia no se ejecuta y se pasa el control a la siguiente
sentencia en el programa.
2. Si el resultado de la evaluación es verdadero (true), se ejecuta la sentencia y el proceso
descrito se repite desde el punto 1.
Por ejemplo, Tenemos un programa que solicita un número e indica se este es par o impar. La
ejecución se termina hasta que se ingresa el valor cero.

10
 Programación Orientada a Objetos

Observe que antes de ejecutarse la sentencia while se visualiza el mensaje pide al usuario que
ingrese un número y luego se verifica la condición del bucle. La sentencia while se interpreta de la
forma siguiente: mientras el valor de la variable numero sea distinto de cero se presentara en
pantalla un mensaje indicando si esté es par o impar.

Por ejemplo, el siguiente programa visualiza el código Unicode de cada uno de los caracteres del
texto introducido por el teclado.

El bucle while se está ejecutando sin pausa mientras se lean caracteres en el flujo de entrada.
Cuando dicho flujo queda vacío y se ejecuta el método Read de nuevo, la ejecución se detiene a la
espera de nuevos datos. Lógicamente, habrá comprendido que aunque se lea carácter a carácter se
puede escribir, hasta pulsar Entrar, un texto cualquiera.

2.2. Sentencia do while

La sentencia do ... while ejecuta una sentencia, simple o compuesta, una o más veces dependiendo
del valor de una expresión. Su sintaxis es la siguiente:

Donde condición es cualquier expresión booleana y sentencias es una sentencia simple o

compuesta. La ejecución de una sentencia do ... while sucede de la siguiente forma:
Se ejecuta el bloque (sentencia simple o compuesta) de do.
Se evalúa la expresión correspondiente a la condición de finalización del bucle y se obtiene un
resultado verdadero o falso.
Si el resultado es falso (false), se pasa el control a la siguiente sentencia en el programa.
Si el resultado es verdadero (true), el proceso descrito se repite desde el punto 1.

11
 Programación Orientada a Objetos

Por ejemplo, el siguiente código obliga al usuario a introducir un valor positivo:

Cuando se utiliza una sentencia do...while el bloque de sentencias se ejecuta al menos una vez,
porque la condición de terminación se evalúa al final. En cambio, cuando se ejecuta una sentencia
while puede suceder que el bloque de sentencias no se ejecute, lo que ocurrirá siempre que la
condición de terminación sea inicialmente falsa.

El siguiente ejemplo presenta la suma acumulativa de una serie de números ingresados por el
usuario, terminando la entrada de números al ingresar el valor cero.

2.3. Sentencia for

La sentencia for permite ejecutar una sentencia simple o compuesta, repetidamente un número de
veces conocido. Su sintaxis es la siguiente:

Donde var1, var2,..., representan variables de control que serán iniciadas con los valores de las
expresiones v1, v2; condición es una expresión booleana que si se omite, se supone verdadera.
Progresión es una o más expresiones separadas por comas cuyos valores evolucionan en el sentido
de que se cumpla la condición para finalizar la ejecución de la sentencia for.

La ejecución de la sentencia for sucede de la siguiente forma:

12
 Programación Orientada a Objetos

1. Se inician las variables con sus respectivos valores

2. Se evalúa la condición de finalización del bucle obteniéndose un resultado verdadero o falso:
a) Si el resultado es verdadero (true), se ejecuta el bloque de sentencias, se evalúa la expresión
que da lugar a la progresión de la condición y se vuelve al punto 2.
b) Si el resultado es falso (false), la ejecución de la sentencia for se da por finalizada y se pasa el
control a la siguiente sentencia en el programa.

Por ejemplo, el siguiente bucle for imprime los números del 1 al 100.

En el siguiente ejemplo se puede observar la utilización de la coma como se• parador de las variables
de control y de las expresiones que hacen que evolucionen los valores que intervienen en la
condición de finalización.

El siguiente ejercicio, permite el ingrese de las calificaciones de diez estudiantes y luego presenta el
promedio de las calificaciones ingresadas.

13
 Programación Orientada a Objetos

2.4. Sentencia foreach

foreach es utilizada para recorrer colecciones de datos (por ejemplo vectores), si bien podemos
utilizar de forma tradicional las otras estructuras repetitivas el empleo del foreach hace más natural
el acceso a los elementos. Ejemplo

.
El siguiente ejemplo muestra, solicita el ingrese de “n” valores enteros almacenándolos en un
arreglo, y luego presenta el número menor.

2.5. Ciclos anidados

El anidamiento de bucles se refiera a cuando se incluye una sentencia repetitiva (while, for,
do…while) dentro de otra sentencia repetitiva. Por ejemplo:

14
 Programación Orientada a Objetos

Al ejecutar este método se obtiene el siguiente resultado:

Este resultado demuestra que el bucle exterior se ejecuta tres veces y, por cada una de éstas, el
bucle interior se ejecuta, a su vez, cuatro veces. Es así como se ejecutan los bucles anidados: por
cada iteración del bucle externo, el interno se ejecuta hasta finalizar todas sus iteraciones.

Como aplicación de lo expuesto, realizaremos un programa que muestre un tablero de ajedrez, este
tablero mostrara B en posición de las casillas blancas y N en las posiciones en las que se encuentren
las casillas negras.

Para colocar el carácter B para las casillas blancas o N para las casillas negras, debemos sumar los
valores de las filas y columnas, tal como se muestra en la siguiente imagen.

Observe que la casilla donde la suma de la fila y columna da como

resultado un valor par se muestran marcadas en rojo. Son estas
posiciones las que corresponden a las casillas blancas y las impares a las
casillas negras.

15
 Programación Orientada a Objetos

3. Arreglos
Frecuentemente tenemos la necesidad de almacenar una colección de datos del mismo tipo. Por
ejemplo, cuando se leen las calificaciones de los estudiantes de un curso en particular. En este caso
son necesarios los arreglos.

Un arreglo se define en forma abstracta como una colección finita de elementos homogéneos
ubicados de forma consecutiva en memoria. Entiéndase por “finito” que todo arreglo tiene una
cantidad específica de elementos y por “homogéneos” que todos los elementos pertenecientes al
arreglo son del mismo tipo.

En C# un arreglo es un tipo de dato referenciado derivado de la clase abstracta System.Array, donde

los elementos pueden ser de tipo primitivo o bien una referencia a un objeto.

Para poder crear y utilizar un arreglo se deben de realizar tres operaciones las que son:
• Declarar el array
• Crear el array (Asignación de recursos)
• Iniciar el array

La declaración se realiza de la siguiente forma:

tipo[] identificador;

Donde tipo indica el tipo de datos del arreglo, identificador es el nombre de la variable y los
corchetes le indica al compilador para que este interprete que se está declarando un Arreglo.

16
 Programación Orientada a Objetos

Al crear un Arreglo se reserva memoria para que contenga se puedan almacenar los elementos del
arreglo, para ello se utiliza la palabra clave new ya que C# implementa los arreglos como objetos y
por lo tanto serán tratados como tal.

La sintaxis para crear el arreglo es:

identificador = new tipo[tamaño];

identificador es el nombre de la variable declarada anteriormente, tipo indica el tipo de datos del
arreglo y tamaño es una expresión entera positiva menor o igual que la precisión de un ulong.
Además el tamaño del arreglo puede ser tomado en tiempo de ejecución por medio de una variable.

Para acceder a los miembros de arreglo, se utilizan un subíndice encerrados entre corchetes después
del nombre del arreglo. Siendo el primera posición del arreglo la posición 0. Si al intentar acceder a
un elemento del arreglo utilizando un subíndice que no esta dentro del rango del mismo, C# lanza
una excepción del tipo IndexOutOfRangeException indicando de esa manera que el subíndice esta
fuera de limite.

3.1. Arreglos unidimensionales (Vectores)

De acuerdo con la sintaxis de declaración de un arreglo, podemos crear arreglos de la forma:

El arreglo n posee un tamaño de 10 elementos y el arreglo cadenas es capaz de almacenar 20

elementos de tipo string.
Ejemplo:

17
 Programación Orientada a Objetos

3.2. Arreglos bidimensionales (Matrices)

Como su nombre lo indica, un arreglo multidimensional es una matriz de dos o más dimensiones. La
definición es estos tiene la siguiente sintaxis:

Por ejemplo:

De acuerdo con el código anterior, C# creara una matriz de 3 filas por 2 columnas, la cual
gráficamente la podemos representar así:

matriz

[0][0] [0][1]

[1][0] [1][1]

[2][0] [2][1]

Para poder acceder a los elementos de matriz, hemos de utilizar dos subíndices uno para las filas y
otro para las columnas.
También se puede implementar arreglo de arreglos, siendo la sintaxis:

Por ejemplo:

La declaración anterior también se puede realizar de la siguiente manera:

18
 Programación Orientada a Objetos

De acuerdo con los dos ejemplos anteriores C# crea un arreglo llamado matriz el cual contiene tres
elementos, que a la vez cada elemento contiene una referencia a otro arreglo.El tipo de elementos
referenciados por matriz es int[] y los tipos referenciados por matriz[0], matriz[1], matriz[2] son del
tipo int.

3.3. Arreglos de cadenas

Son matrices multidimensionales generalmente de dos dimensiones en las que cada fila corresponde
a una cadena, por ejemplo:

3.4. Matriz de tipo ArrayList

La clase ArrayList definida en el espacio de nombres System.Collections facilita la creación y
manipulación de matrices unidimensionales o listas.
Un objeto ArrayList pertenece a esa clase de objetos conocidos como colecciones. La sintaxis a
utilizar es la siguiente:

19
 Programación Orientada a Objetos

Donde identificador que nombra a la colección de elementos. Los elementos de la lista son de tipo
Object; por lo tanto, la lista de elementos que se pueden agregar a la colección incluye tipos de
datos estándar y matrices, así como estructuras y objetos de cualquier clase. El número de
elementos de la lista será inicialmente cero.

La clase ArrayList proporciona métodos para acceder a los elementos de la lista, insertar nuevos
elementos, eliminar elementos, obtener el número de elementos, buscar elementos, etc.

Añadir un elemento
Añadir un elemento al final de la colección disponemos del método Add(elem). Por ejemplo:

Insertar un elemento
Para insertar un elemento en una determinada posición de la colección. Por ejemplo: inserta el
elemento “x” en la posición “i”.

Modificar un elemento
Para modificar un elemento determinado de la colección reemplazándolo por otro disponemos del
operador []. Por ejemplo:

Tamaño
Para conocer el tamaño de una colección hay que acceder a su propiedad Count

Eliminar elementos
El método Clear permite eliminar todos los elementos de la colección, Remove permite eliminar la
primera aparición de un objeto concreto y RemoveAt elimina el elemento que tiene por índice el
especificado.

20
 Programación Orientada a Objetos

Buscar elementos
El método Contains devuelve true si la lista contiene el elemento especificado, y los métodos
IndexOf y LastlndexOf devuelven, respectivamente, el índice en la lista del primero y del último
elemento especificado, o -1 si dicho elemento no se localiza. Por ejemplo:

Ejemplo

21
 Programación Orientada a Objetos

4. Bibliografía

• Ceballos, F.J. (2011). Microsoft C#, Curso de Programación, 2ª. Edición. Madrid, España.
Editorial RA-MA.

22