Guía Programación Orientada A Objetos

PROGRAMACIÓN ORIENTADA A OBJETOS (072-2103)
Unidad I: Introducción
1.1 Historia del Computador
1.2 Lenguajes de Programación
1.3 Compilación de Programas
1.4 Paradigmas de Programación
Unidad II: Paradigma Orientado a Objetos

2.1 Generalidades
2.2 Clases y Objetos
2.3 Programación en Consola
Unidad III: Datos Simples

3.1 Variables
3.2 Tipos de Datos
3.3 Expresiones, Operadores y Asignaciones
Unidad IV: Estructuras de Control

4.1 Estructuras de Control Selectivas
4.2 Estructuras de Control Iterativas
Unidad V: Datos Compuestos

5.1 Arreglos
5.2 Cadenas
Unidad VI: Fundamentos Avanzados de Programación

6.1 Procedimientos y funciones
6.2 Recursividad
6.3 Apuntadores y referencias
6.4 Herencia
Programación Orientada a Objetos
TABLA DE CONTENIDO
Unidad I: Introducción
1.1 Historia de la computación............................................................................................ 4
1.1.1 La computadora ............................................................................................................. 4
1.1.2 Prehistoria de la computación ....................................................................................... 4
1.1.3 Generaciones de la computadora .................................................................................. 5
1.2 Lenguajes de programación .......................................................................................... 8
1.2.1 Tipos de lenguajes ......................................................................................................... 8
1.2.2 Criterios del lenguaje .................................................................................................... 9
1.3 Compilación de programas ......................................................................................... 10
1.3.1 Tipos de compiladores ................................................................................................ 11
1.3.2 Proceso de compilación............................................................................................... 11
1.3.3 Etapas de la compilación ............................................................................................. 12
1.3.4 Otras herramientas de programación .......................................................................... 12
1.4 Paradigmas de programación ...................................................................................... 13
Unidad II: Paradigma orientado a objetos

2.1 Generalidades .............................................................................................................. 15
2.1.1 Conceptos dentro de la POO ....................................................................................... 15
2.1.2 Ventajas ....................................................................................................................... 16
2.2 Clases y objetos ........................................................................................................... 16
2.2.1 Acceso a los miembros de una clase ........................................................................... 18
2.2.2 Constructores y destructores ....................................................................................... 20
2.2.3 Ventajas del uso de clases ........................................................................................... 22
2.3 Programación en consola ............................................................................................ 23
2.3.1 Buffer de pantalla y ventana de la consola.................................................................. 23
2.3.2 La clase console .......................................................................................................... 24
2.3.3 Entrada y salida por consola ....................................................................................... 24
2.3.4 Métodos para personalizar la consola ......................................................................... 27
2.4 Ejercicios propuestos .................................................................................................. 29
2
Unidad III: Datos Simples

3.1 Variables ..................................................................................................................... 30
3.1.1 Reglas para asignar nombres de variables .................................................................. 30
3.1.2 Tipos de identificadores .............................................................................................. 31
3.2 Tipos de datos ............................................................................................................. 31
3.3 Expresiones, operadores y asignaciones ..................................................................... 32
3.3.1 Operadores aritméticos................................................................................................ 33
3.3.2 Expresiones y operadores relacionales........................................................................ 34
3.3.3 Expresiones y operadores lógicos ............................................................................... 34
3.3.4 Operadores incrementales y decrementales ................................................................ 35
3.3.5 Operadores compuestos de asignación........................................................................ 35
3.3.6 Operador condicional .................................................................................................. 36
3.3.7 Precedencia de operadores .......................................................................................... 36
3.4 Ejercicios propuestos .................................................................................................. 38
Unidad IV: Estructuras de control

4.1 Estructuras de control selectivas ................................................................................. 39
4.1.1 La estructura de selección simple: if ........................................................................... 39
4.1.2 La estructura de selección doble: if/else ..................................................................... 40
4.1.3 La estructura de selección múltiple: switch/case ........................................................ 46
4.2 Estructuras de control iterativas .................................................................................. 47
4.2.1 La estructura iterativa for ............................................................................................ 48
4.2.2 La estructura iterativa while ........................................................................................ 50
4.2.3 La estructura iterativa do-while .................................................................................. 52
4.2.4 Sentencias break y continue ........................................................................................ 53
4.3 Ejercicios propuestos: ................................................................................................. 54
Unidad V: Datos compuestos

5.1 Arreglos ....................................................................................................................... 56
3
UNIDAD I: INTRODUCCIÓN
1.1 Historia de la computación
1.1.1 La computadora
Es una colección de circuitos integrados y otros componentes relacionados capaz de efectuar

una secuencia de operaciones mediante un programa, de tal manera que recibe y procesa un
conjunto de datos de entrada para convertirlos en información útil.
1.1.2 Prehistoria de la computación
Uno de los primeros dispositivos mecánicos para contar fue el ábaco, cuya historia se
remonta a las antiguas civilizaciones griega y romana, el cual tenía cuentas ensartadas en
varillas que, a su vez, estaban montadas en un marco rectangular. Al desplazar las cuentas
sobre las varillas, sus posiciones representaban valores determinados. Por supuesto, este
dispositivo no podía considerarse como una computadora, ya que carecía de un elemento
fundamental llamado programa.
Otros dispositivos mecánicos fueron la Pascalina, inventada por el francés Blaise

Pascal (1623 – 1662), y la máquina inventada por el alemán Gottfried Wilhelm Von Leibniz
(1646 – 1716), con las cuales los datos se representaban mediante las posiciones de los
engranajes, y los mismos se introducían manualmente estableciendo las posiciones finales de
la rueda, de forma similar a cómo se cuentan los kilómetros recorridos en el cuentakilómetros
de un automóvil.
En el siglo XIX Charles Babbage trabajaba en el proyecto de la “máquina de

diferencias”, es decir, aquella que realizaba una serie de sumas sucesivas, con la cual buscaba
solucionar el problema que implica la elaboración de tablas matemáticas ya que era una tarea
tediosa y propensa a errores. Sin embargo, en el año 1823 Charles Jaquard había inventado
un telar que podía reproducir patrones de tejidos leyendo la información codificada en
4
patrones de agujeros perforados en papel rígido. Esto sirvió de inspiración a Babbage para
que abandonase la máquina de diferencias y se dedicase a la “máquina analítica”, un
dispositivo que podría ser programado con tarjetas perforadas para efectuar cálculos con una
precisión de hasta 20 dígitos. Desafortunadamente, la tecnología de la época no bastaba para
hacer realidad sus ideas.
Unos 100 años después, concretamente en el año 1944, se construyó en la Universidad

de Harvard la MARK I, diseñada por un equipo encabezado por Howard E. Aiken, cuyo
funcionamiento estaba basado en dispositivos electromecánicos llamados relevadores.
En 1947 se construyó en la Universidad de Pensilvania la ENIAC (Electronic

Numerical Integrator And Calculator) por el equipo de diseño dirigido por John Mauchly y
John Eckert, la cual ocupaba todo un sótano de la universidad, tenía más de 18 mil tubos de
vacío, consumía 200 KW de energía y requería todo un sistema de aire acondicionado, la
cual tenía capacidad para realizar 5 mil operaciones aritméticas por segundo. Esta máquina
marcó el inicio de las generaciones de la computadora.
1.1.3 Generaciones de la computadora
Se definen tomando en cuenta la forma en que fueron construidas, y la manera en que el ser
humano se comunica con ellas, además de las tecnologías empleadas.
1ª Generación: Tubos de Vacío (1947 – 1958)

 Utilizaban tubos de vacío para procesar la información.
 Empleaban tarjetas perforadas para realizar programas.
 La memoria principal consistía en un tambor magnético.
 Eran de un inmenso tamaño y gran peso.
 Costaban alrededor de US$ 10.000
 Surge el lenguaje máquina (código binario)
 Máquinas representativas: ENIAC y UNIVAC.
5
2ª Generación: Transistores (1958 – 1964)

 Uso de transistores para procesar la información.
 Reducción del tamaño y emisión de calor.
 Menor consumo eléctrico.
 Eran comercialmente accesibles.
 Las computadoras de ese período eran muy avanzadas para la época.
 Se define la programación de sistemas.
 Máquinas representativas: PHILCO 212 y UNIVAC M460.
3ª Generación: Circuitos Integrados (1964 – 1971)

 Uso de circuitos integrados (inventados en 1959) para procesar la información.
 Las computadoras son mucho más pequeñas y producen menos calor.
 Son enérgicamente más eficientes.
 Surge la multiprogramación.
 Máquina representativa: IBM 360.
4ª Generación: Microprocesadores (1971 – 1981)

 Uso del microprocesador (inventado en 1971) para procesar información.
 Desarrollo de las microcomputadoras y supercomputadoras.
 Reemplazo de las memorias con núcleos magnéticos por chips de silicio.
 Uso de los Sistemas Operativos.
5ª Generación: Inteligencia Artificial (1981 – 1990)

 Avances en el desarrollo del software y la robótica.
 Se crea la primera súper computadora con capacidad de proceso en paralelo.
 Desarrollo de sistemas expertos e inteligencia artificial.
 Uso del lenguaje natural.
 Almacenamiento en dispositivos magnético-ópticos extraíbles.
6
6ª Generación: Arquitectura Paralelo/Vectorial (1990 – 1999)

 Utilizan cientos de microprocesadores vectoriales trabajando en paralelo.
 Se crearon computadoras capaces de realizar millones de operaciones aritméticas en
punto flotante (teraflops) por segundo.
 Uso de las redes WWW y WAN para comunicar las computadoras entre sí.
 Uso de fibra óptica con gran ancho de banda y satélites para las comunicaciones.
 Desarrollo de tecnologías con inteligencia artificial distribuida, teoría de caos, holografía,
transistores ópticos, etc.
7ª Generación: LCD y Dispositivos Inteligentes (1999 – 2011)

 Aparecen las pantallas planas LCD2 y se hacen a un lado las de rayos catódicos.
 Se crea el Blu-Ray Disc, reemplazando al DVD.
 Almacenamiento de datos de alta densidad.
 Reemplazo de TV’s y equipos de sonido por dispositivos digitales.
 Aparecen las computadoras portátiles (laptops), dispositivos de bolsillo (PDA’s),
computadoras ópticas y cuánticas.
 Uso masivo de mensajería y correo electrónico.
 Tecnología de reconocimiento de voz y escritura, además de la realidad virtual y
dispositivos inalámbricos.
 Súper cómputo (procesadores paralelos masivos).
 Proliferación de los Smartphone y memorias compactas.
8ª Generación: Nuevas Tecnologías (2011 – Presente)

 Se inicia con el lanzamiento del Nintendo 3DS (25 de febrero de 2011), seguido por la
Sony PlayStation Vita (17 de diciembre de 2011).
 Empleo de tecnologías de última generación, como la estereoscopía y detección del
movimiento corporal.
 Mayor capacidad de almacenamiento en los dispositivos móviles.
 A futuro se plantea la desaparición de dispositivos físicos y de almacenamiento
mecánicos (disco duro, tarjeta madre), además del uso de la nanotecnología.
7
1.2 Lenguajes de programación
Un programa es una secuencia de instrucciones mediante las cuales se ejecutan diferentes

acciones de acuerdo con los datos que se estén procesando, el cual está desarrollado para ser
utilizado por la computadora.
Por su parte, la programación es el proceso de diseñar, escribir, probar, depurar y

mantener el código fuente de programas computacionales. El código fuente es escrito en un
lenguaje de programación. El propósito de la programación es crear programas que exhiban
un comportamiento deseado. El proceso de escribir código requiere frecuentemente
conocimientos en varias áreas distintas, además del dominio del lenguaje a utilizar,
algoritmos especializados y lógica formal.
Programar no involucra necesariamente otras tareas tales como el análisis y diseño de

la aplicación (pero si el diseño del código), aunque si suelen estar fusionadas en el desarrollo
de pequeñas aplicaciones.
Obviamente, para llevar a cabo esta tarea se requiere de un lenguaje de programación,

el cual no es más que un sistema de símbolos y reglas que permite la construcción de
programas con los que la computadora puede operar así como resolver problemas de manera
eficaz. Estos contienen un conjunto de instrucciones que permiten realizar operaciones de
entrada / salida, calculo, manipulación de textos, lógica / comparación y almacenamiento /
recuperación.
1.2.1 Tipos de lenguajes
 Lenguaje Máquina: Son aquellos cuyas instrucciones son directamente entendibles por
la computadora y no necesitan traducción posterior para que la CPU pueda comprender
y ejecutar el programa. Las instrucciones en lenguaje maquina se expresan en términos
de la unidad de memoria más pequeña el bit (dígito binario 0 ó 1).
8
 Lenguaje de Bajo Nivel (Ensamblador): En este lenguaje las instrucciones se escriben

en códigos alfabéticos conocidos como mnemotécnicos para las operaciones y
direcciones simbólicas. Los lenguajes de bajo nivel permiten crear programas muy
rápidos, pero que a menudo son difíciles de entender. Más importante es el hecho de que
los programas escritos en bajo nivel son prácticamente específicos para cada procesador.
 Lenguaje de Alto Nivel: Los lenguajes de programación de alto nivel (BASIC, pascal,
cobol, fortran, etc.) son aquellos en los que las instrucciones o sentencias a la
computadora son escritas con palabras similares a los lenguajes humanos (en general en
inglés), lo que facilita la escritura y comprensión del programa. Éstos son normalmente
fáciles de aprender porque están formados por objetos de lenguajes naturales, sin
embargo, para muchas personas esta forma de trabajar es un poco frustrante dado que, en
realidad, las computadoras suelen operar de forma rígida y sistemática.
1.2.2 Criterios del lenguaje
Son características interrelacionadas empleadas para considerar si un lenguaje tiene méritos,

es decir, si es eficiente, confiable y es capaz de proporcionar los mejores resultados.
 Sintaxis: Es la forma del lenguaje, es decir, una colección de instrucciones formadas al

seguir un conjunto de reglas que diferencian los programas válidos de nos no válidos.
 Semántica: Describe de manera precisa lo que significa una construcción particular, ya

que cada lenguaje de programación podría interpretar de manera distinta las instrucciones
escritas exactamente igual.
 Comprobabilidad:
o El programa cumple con la intención del programador.
o El compilador traduce de manera correcta a código de máquina la sintaxis y
semántica del programa en el lenguaje empleado.
o La máquina misma funciona correctamente.
9
 Confiabilidad: El programa se considera confiable si se comporta como es anunciado y

produce los resultados que el usuario espera.
 Traducción Rápida: La traducción del código fuente a un lenguaje que la máquina

pueda reconocer, y luego a un código máquina que la misma pueda ejecutar, debe ser lo
más rápida y óptima posible.
 Corrección: Un programa es correcto si hace lo que debe hacer tal y como se estableció
en las fases previas a su desarrollo.
 Claridad: Es muy importante que el programa sea lo más claro y legible posible, para
facilitar así su desarrollo y posterior mantenimiento. Al elaborar un programa, se debe
intentar que su estructura sea sencilla y coherente, así como cuidar el estilo de la edición.
 Eficiencia: Se trata de que el programa, además de realizar aquello para lo que fue
creado, lo haga gestionando de la mejor forma los recursos que utiliza, para lo cual es
necesario que exista un balance comparativo entre el trabajo que el programador debe
hacer y el trabajo que el compilador puede hacer.
 Ortogonalidad: Las variables aleatorias se consideran ortogonales si son independientes

entre sí. De esta forma los componentes son independientes entre sí y se comportan de la
misma manera bajo cualquier circunstancia.
 Portabilidad: Cuando el programa puede compilarse y ejecutarse en una plataforma

(Hardware o Software) diferente a aquella en la cual se elaboró.
1.3 Compilación de programas
Un compilador es un programa que permite traducir el código fuente (conjunto de

instrucciones que describe el funcionamiento de un programa determinado), realizado en
10
lenguaje de alto nivel, a otro de nivel inferior (típicamente a lenguaje máquina). De esta
manera, un programador puede diseñar un programa en un lenguaje mucho más cercano a
cómo piensa un ser humano, para luego compilarlo a un programa más manejable por una
computadora.
1.3.1 Tipos de compiladores
 Cruzados: Generan código para un sistema distinto del que están funcionando.
 Optimizadores: Realizan cambios en el código para mejorar su eficiencia, manteniendo
la funcionalidad del programa original.
 De una sola pasada: Generan el código máquina a partir de una única lectura del código
fuente.
 De varias pasadas: Necesitan leer el código fuente varias veces antes de poder producir
el código máquina.
 JIT (Just In Time): Forma parte de un intérprete y compilan muestras del código según
sus necesidades.
1.3.2 Proceso de compilación
Normalmente, la creación de un programa ejecutable conlleva dos pasos:
 Compilación: Traduce el código fuente escrito en un lenguaje de alto nivel a bajo nivel,
creando un código objeto que puede ser en lenguaje máquina o bytecode (es más
abstracto que el código máquina) y distribuirse en varios ficheros.
 Enlazado: Se enlaza el código de bajo nivel generado de todos los ficheros y

subprogramas que se han mandado a compilar, y se añade el código de las funciones que
hay en las bibliotecas del compilador, traduciendo así el código objeto a lenguaje
máquina, generando un módulo ejecutable.
11
1.3.3 Etapas de la compilación
 Fase de Análisis:
o Análisis Léxico: Se lee el programa fuente de izquierda a derecha y se agrupa en
componentes léxicos llamados tokens (secuencias de caracteres que tienen un
significado determinado).
o Análisis Sintáctico: Los tokens se agrupan jerárquicamente en frases
gramaticales que el compilador utiliza para sintetizar la salida.
o Análisis Semántico: Se revisa el programa fuente para tratar de encontrar errores
semánticos, reuniendo la información sobre los tipos para la fase posterior de
generación de código.
 Fase de Síntesis: Consiste en generar el código objeto equivalente al programa fuente, y

sólo se realiza esta acción cuando el programa fuente está libre de errores de análisis
(aunque esto no implica que el programa corra bien).
o Generación de código intermedio: Algunos compiladores generan una
representación intermedia explícita del programa fuente, el cual debe ser fácil de
producir y fácil de traducir al programa objeto.
 Fase de Optimización del Código: Mejora el código intermedio, de modo que resulte
un código máquina más rápido de ejecutar.
1.3.4 Otras herramientas de programación
Además del compilador, existen otras herramientas de programación con funciones muy
similares, las cuales son:
 Ensamblador: Traduce un fichero fuente en lenguaje ensamblador (bajo nivel) a código

máquina.
 Enlazador: Toma los objetos generados en los primeros pasos de compilación y la
información de biblioteca, (salvo lo que no necesita), y crea un archivo ejecutable.
12
 Intérprete: Es un programa informático capaz de analizar y ejecutar otros programas. Se

diferencia del compilador en que, mientras éste traduce un programa desde su descripción
en un lenguaje de programación al código máquina, los intérpretes sólo la traducción a
medida que sea necesaria, típicamente, instrucción por instrucción, por lo que
normalmente no guardan los resultados de dicha traducción, lo que los hace mucho más
lentos, pero a su vez menos susceptibles de provocar fallos.
1.4 Paradigmas de programación
Son colecciones de características abstractas que categorizan un grupo de lenguajes que son
aceptados y utilizados por un grupo de profesionales, representando un enfoque particular o
filosofía para diseñar soluciones. Éstos están delimitados en el tiempo en cuanto a aceptación
y uso, ya que nuevos paradigmas aportan nuevas o mejores soluciones que los sustituyen
parcial o totalmente.
Algunos tipos de paradigmas conocidos en la actualidad son:
 Imperativos: Facilitan cálculos por medio de cambios de estados, pues se basan en dar
instrucciones al ordenador de cómo hacer las cosas en forma de algoritmo. El ejemplo
principal de este tipo de paradigmas es el lenguaje de máquina.
 De Procedimientos: Constituidos por bloques de programas (secciones de código con
una o más declaraciones y sentencias), que forman un archivo plano, en donde cada
bloque sigue a su predecesor, constituyéndose así un programa lineal. Ejemplo:
FORTRAN.
 Estructurados en Bloques: Están constituidos por ámbitos anidados, es decir, los
bloques pueden estar dentro de otros bloques e incluso tener sus propias variables.
Ejemplo: Basic, Pascal, C.
 Basados en Objetos: Describen a los lenguajes que soportan objetos en interacción,
además de la abstracción, encapsulación y polimorfismo. Ejemplo: ADA, Modula,
SmallTalk.
13
 Orientados a Objetos: Incluyen a los lenguajes que están basados en objetos y, además,
soportan clases de objetos y herencia de atributos. Ejemplo: C++, C#, Object Pascal
(Delphi) y Java.
 De Procedimiento en Paralelo: Describen los lenguajes que soportan el uso de
procesadores múltiples, la cooperación entre procesos y el potencial para falla parcial
(esto último implica que algún proceso puede fallar sin peligrar la ejecución de los
demás). Ejemplo: Concurrent C, Pascal S, C-Linda.
 De Programación Lógica: Están basados en un subconjunto del cálculo de predicados
o relación de elementos, proporcionando axiomas y reglas de inferencia que permiten
inferir nuevos hechos a partir de hechos conocidos. Ejemplo: Prolog.
 Funcionales: Es cuando el lenguaje opera solamente a través de funciones. Ejemplo:
Scheme y Haskell.
 Declarativos: Se basan en el desarrollo de programas declarando propiedades y reglas
que deben cumplirse, en lugar de instrucciones. Ejemplo: Maude y ML.
 Dirigidos por Eventos: Tanto la estructura como la ejecución de los programas son
determinados por los sucesos que ocurran en el sistema, ya sean definidos por el usuario
o provocados por ellos mismos. Ejemplo: Lexico y Visual Basic.
 Específicos del Dominio: Conocidos como DSL, se denomina así a los lenguajes
desarrollados para resolver un problema en específico. Puede pertenecer a cualquiera de
los paradigmas antes descritos. Ejemplo: SQL (declarativo) y LOGO (imperativo).
 Multiparadigma: Es el uso de dos o más paradigmas dentro de un programa. Ejemplo:
Lisp y Python.
14
UNIDAD II: PARADIGMA ORIENTADO A OBJETOS
2.1 Generalidades
La programación orientada a objetos ha tomado las mejores ideas de la programación

estructurada y los ha combinado con varios conceptos nuevos y potentes que incitan a
contemplar las tareas de programación desde un nuevo punto de vista.
El término Programación Orientada a Objetos (POO), hoy en día ampliamente

utilizado, es difícil de definir debido a que no es un concepto nuevo, sino que ha sido el
desarrollo de técnicas de programación desde principios de la década de los 70’s, cuando ha
aumentado su difusión, uso y popularidad. No obstante, se puede definir como una técnica o
estilo de programación que utiliza objetos como bloque especial de construcción.
2.1.1 Conceptos dentro de la POO
 Objeto: Entidad de programa que consiste en datos, y todos aquellos procedimientos que
pueden manipularlos.
 Clase: Colección de objetos que poseen características comunes, la cual contiene toda la
información necesaria para crear nuevos objetos. En otras palabras, se definen las
características concretas de un determinado tipo de objetos, es decir, de cuáles son los
datos y los métodos de los que van a disponer todas las instancias de ese tipo.
 Encapsulación: Técnica que permite localizar y ocultar los detalles de un objeto,
previniendo que el mismo sea manipulado por operaciones distintas de las definidas. Ésta
se puede comparar con el funcionamiento de una caja negra.
 Abstracción: Representación concisa de una idea u objeto complicado, localizando y
ocultando los detalles de un modelo o diseño para generar y manipular objetos.
 Polimorfismo: Se refiere al hecho de que un nombre se puede utilizar para especificar
una clase genérica de acciones.
 Herencia: Proceso mediante el cual un objeto (hijo) puede adquirir las propiedades de
otro objeto (padre).
15
2.1.2 Ventajas
 Uniformidad: La representación de los objetos implica tanto el análisis como el diseño

y la codificación de los mismos.
 Comprensión: Los datos y los procedimientos que los manipulan se pueden agrupar en
clases.
 Flexibilidad: Cualquier cambio en los datos (o sus respectivas funciones) quedará
reflejado automáticamente en cualquier lugar donde éstos aparezcan.
 Estabilidad: Permite aislar las partes del programa que permanecen inalterables con el
tiempo.
 Reusabilidad: Se pueden reutilizar las definiciones de objetos empleadas en otros
programas, o incluso los procedimientos que los manipulan.
2.2 Clases y objetos
Una clase es un tipo definido por el usuario que determina la estructura de los datos y las
operaciones asociadas a este tipo, es decir, son modelos o plantillas que describen cómo se
construyen ciertos tipos de objetos.
La sintaxis básica para definir una clase es la mostrada a continuación:
class nombre_clase {
miembros;
}
Donde los miembros son datos y funciones pertenecientes a la clase definida, las cuales
están a disposición de todos los objetos o instancias de la misma. Obviamente hay muchos
tipos de miembros distintos, pero por ahora sólo se considerarán los siguientes:
 Campo o Atributo: Es un dato común a todos los objetos de una determinada clase. Su
sintaxis es como sigue: <modificador_de_acceso> tipo_de_campo nombre_campo;
16
o <modificador_de_acceso>: Es una palabra reservada que permite restringir el

acceso a un atributo o método de un objeto en particular, es decir, que con ella se
decide si un miembro perteneciente a una clase puede ser visto o no desde
cualquier punto del programa. Puede ser:
 Private: Implica que sólo permite el acceso a los miembros de la clase
donde está definido. En caso de omitirse el modificador de acceso, el
miembro es private por defecto.
 Protected: Sólo tienen acceso la clase donde está definido y sus
herederas.
 Public: Se puede acceder desde cualquier parte del programa.
o tipo_de_campo: Establece el tipo de formato (o categoría) del dato. Puede ser
definido dentro del sistema (int, float, string, etc.) o por el usuario.
 Método: Es un conjunto de instrucciones a las que se les asocia un nombre, con las cuales
se manipulan los datos asociados a la clase. Su sintaxis es como sigue:
<modificador_de_acceso> <tipo_de_retorno> nombre_método(parámetros) {
sentencias;
}
o tipo_de_retorno: Es el tipo del dato u objeto que se devuelve como resultado de
la ejecución de las sentencias (instrucciones) pertenecientes a dicho método: Si
no se indica nada, el retorno es de tipo void (vacío), y si se devuelve algo, se debe
terminar la ejecución de las sentencias con la instrucción return <objeto>
o parámetros: Son los objetos o atributos que recibe el método al ser invocado,
especificando allí el tipo de dato y el nombre con el que se referencia de manera
interna. Si no se recibe nada, sólo se colocan los paréntesis, asumiendo que los
parámetros son de tipo void.
Ejemplo 2.1: Cree una clase llamada empleado, cuyos atributos son nombre, edad,
departamento y salario. Incluya los métodos necesarios para agregar un empleado y
visualizar sus datos.
17
En este ejemplo, se agregan además de los atributos señalados, un método que reciba
los datos, y otro para visualizarlos, quedando de la siguiente manera:
class empleado {
private string nombre, dpto;
private int edad;
private float salario;
public void agregar_datos() {

//Sentencias para agregar datos
}
public void mostrar_datos() {

//Sentencias para mostrar datos
}
}
Como se pudo observar en el ejemplo, los atributos o campos son private, mientras
ambos métodos son de tipo public, lo que indica que estos últimos podrán ser vistos desde
cualquier parte del programa. Esto es así debido al principio de encapsulación, ya que de
esta manera se puede proteger la información interno, evitando así una errónea manipulación
de los datos en cualquier parte del programa, Por supuesto se pueden usar otros
modificadores, con funciones privadas y atributos públicos, pero esta manera es la más
recomendada (sobre todo para los principiantes).
2.2.1 Acceso a los miembros de una clase
Ejemplo 2.2: Tratar de cargar los datos del empleado, usando el método definido en el
ejemplo anterior.
Aquí hay que llamar al método “cargar_datos”, el cual ha sido definido como public,
lo que indica que puede ser visto por el método Main (éste es el método principal, que se
encarga de ejecutar el programa). Obsérvese el siguiente código:
class Program {
static void Main(string[] args) {
cargar_datos();
}
}
18
En este caso el programa da error, ya que “cargar_datos”, aun siendo visible en

cualquier parte del programa, no está definido dentro del método Main, sino dentro de la
clase empleado, lo que indica que hace falta algo para acceder a dicho método, un enlace
entre ambas clases. Por lo tanto… ¿Cómo se accede a un método de la clase? La respuesta:
Declarar un objeto.
Como se ha dicho, los objetos son instancias de una clase, es decir, cada objeto definido
trabaja con los mismos atributos y posee los mismos métodos de la clase a la que pertenece,
Éste se declara de la siguiente manera:
nombre_clase nombre_objeto = new nombre_clase();
Donde nombre_clase hace referencia a la clase definida por el usuario, es decir, es el

“tipo de dato” del objeto; new es un operador que reserva espacio de memoria para almacenar
un objeto de tipo clase, y nombre_clase( ) es el constructor, es decir, un método especial que
se encarga de inicializar dicho objeto.
Ejemplo 2.3: Cree un objeto de tipo empleado.
class Program {
empleado e = new empleado();
}
}
Con esto se ha creado un objeto llamado “e” el cual tiene todas las características de la
clase a la cual instancia (empleado), es decir, posee la capacidad de almacenar dentro de sí
un nombre de empleado, el departamento al cual pertenece, su edad y su salario, además de
tener la capacidad de invocar métodos para la carga e impresión de dichos datos.
Pero sigue la pregunta… ¿Cómo acceder a los miembros de una clase? Ahora que se
tiene el objeto definido, la manera de acceder a los mismos se realiza utilizando la siguiente
sintaxis:
nombre_objeto.miembro
19
Aquí, el operador “.” (Punto) se utiliza como operador de acceso a los miembros de
una clase, los cuales pueden ser atributos o métodos, siempre y cuando su nivel de acceso lo
permita, es decir, este método no funciona, por ejemplo, para miembros de tipo private
porque se generaría un error, ya que el acceso a los mismos está restringido sólo y
exclusivamente para la clase donde son definidos.
A raíz de lo anteriormente dicho, para resolver el problema planteado en el Ejemplo 2

se procede de la siguiente manera:
class Program {
e.cargar_datos();
}
}
2.2.2 Constructores y destructores
Como se mencionó, el constructor se trata de un método especial, cuya principal

característica es que tiene el mismo nombre de la clase. Se define de forma similar a un
método cualquiera, salvo que a éste se le omite el tipo de retorno (de hecho, muchos autores
ni siquiera emplean la palabra void). En cuanto a su acceso, aunque pueden ser private o
protected, éstos se recomiendan que sean de tipo public (por defecto).
Cuando el usuario no define ningún constructor, se emplea el constructor por defecto,

definido dentro del sistema con las operaciones básicas que éste necesita para la construcción
de cualquier objeto. Sin embargo, si el usuario define al menos un constructor, cada vez que
se crea el objeto su constructor debe coincidir con lo que definió dicho usuario.
Además de los constructores, también se tienen los destructores, los cuales se utilizan
para realizar ciertas operaciones que son necesarias cuando ya no se utiliza un objeto. Su
definición es similar a la de un constructor, sólo que se coloca el carácter “~” (virgulilla)
antes del nombre. Su uso es poco frecuente, y cuando no se define se suele utilizar un
destructor por defecto que se encarga de liberar el espacio en memoria.
20
Ejemplo 2.4: Incluya un constructor y un destructor para la clase empleado.
class empleado {
//Atributos y métodos internos
public empleado() {
//Sentencias para construir el objeto
}
public ~empleado() {
//Sentencias para destruir el objeto
}
}
Ejemplo 2.5: Desarrolle un proyecto que posea una clase llamada empleado, cuyos atributos
son los siguientes: nombre, edad, departamento y salario; y posea los métodos necesarios
para agregar un nuevo empleado y mostrar sus datos.
Compilando todo lo desarrollado en los ejemplos anteriores, el programa queda de la

siguiente manera:
class empleado {
private string nombre, dpto;
private int edad;
private float salario;
public void agregar_datos() {

//Sentencias para agregar datos
}
public void mostrar_datos() {

//Sentencias para mostrar datos
}
public empleado() {
//Sentencias para construir el objeto
}
}
class Program {
e.cargar_datos();
e.mostrar_datos();
}
}
21
2.2.3 Ventajas del uso de clases
El programa del Ejemplo 5 muestra la misma salida que uno donde se trabaje sólo con el
método Main, así:
class Program {
string nombre, dpto;
int edad;
float salario;
// Instrucciones para cargar datos del empleado
// Instrucciones para mostrar datos del empleado

}
}
Ahora, imagínese por un momento que se desean cargar los datos de 3 empleados. Se
podría realizar con un ciclo, pero en este caso los datos no serían reutilizables, ya que los
mismos se reemplazarían en cada iteración (lo que impediría su uso en sentencias
posteriores); y si se hace de manera lineal resulta tedioso, puesto que se estarían declarando
muchas variables, con sus instrucciones de entrada y salida correspondientes, eso sin
mencionar que, al tener que escribir mucho código, se está más propenso a cometer errores.
En cambio, si la clase está adecuadamente definida, sólo harían falta 3 objetos, y pocas líneas
de código para llamar a los métodos correspondientes:
class Program {
empleado a = new empleado();
empleado b = new empleado();
empleado c = new empleado();
// Cargar datos de 3 empleados

a.cargar_datos();
b.cargar_datos();
c.cargar_datos();
// Mostrar datos de 3 empleados

a.mostrar_datos();
b.mostrar_datos();
c.mostrar_datos();
}
}
22
2.3 Programación en consola
La consola es una ventana del Sistema Operativo en la cual los usuarios interactúan con el
S.O., o con una aplicación de consola basada en texto. Este tipo de aplicaciones utilizan como
entrada y salida líneas de comandos, lo que permite probar rápidamente las características
del lenguaje y escribir utilidades en modo carácter.
2.3.1 Buffer de pantalla y ventana de la consola
La consola posee dos características que están estrechamente relacionadas entre sí:
 Buffer de Pantalla: Atributo de la consola que está organizado como una cuadrícula
rectangular de filas y columnas. Cada intersección (llamada celda de carácter) puede
contener un carácter. Cada carácter tiene su propio color de primer plano y cada celda de
carácter tiene su propio color de fondo.
 Ventana de Consola: Es otro atributo de la consola, una ventana del Sistema Operativo
que también está organizada en filas y columnas. Su tamaño es menor o igual al Buffer
de Pantalla, se puede mover para permitir la visibilidad de secciones del buffer de
pantalla, y cuando su tamaño es menor a este último, crea automáticamente barras de
desplazamiento.
Ejemplo de Consola: El área negra es el Buffer de Pantalla, La Ventana de Consola es el marco que la rodea
23
2.3.2 La clase console
La consola posee dos características que están estrechamente relacionadas entre sí:
 Representa las secuencias de entrada, salida y error estándar para las aplicaciones de
consola.
 No se puede heredar.
Su sintaxis se define de la siguiente forma: public static class Console; lo que

indica que esta clase es de dominio público (accesible por todos los objetos) y a su vez es
estática (lo que implica que, una vez definida, no se puede modificar). Nótese que luego de
la instrucción se coloca un “;” (punto y coma), el cual es el operador de fin de sentencia.
Cuando se inicia una aplicación de consola, el Sistema Operativo asocia

automáticamente a la misma tres secuencias de Entrada y Salida: Entrada Estándar, Salida
Estándar y Error Estándar, las cuales se representan a la aplicación como los valores de las
propiedades In (entrada), Out (salida) y Error. Éstas se encuentran contenidas en:
 System.IO.TextReader (entrada)
 System.IO.TextWriter (salida y error)
La clase Console contiene métodos de lectura y escritura de caracteres individuales o

líneas enteras de la consola; métodos de conversión de una instancia de un tipo de valor,
matriz de caracteres o conjunto de objetos en una cadena con o sin formato; métodos y
propiedades para cambiar la posición del cursor, los colores de primer plano y de fondo, para
reproducir un “bip”, entre otros.
2.3.3 Entrada y salida por consola
WriteLine
Es un método estándar para mostrar información a través del monitor de la consola donde se
esté ejecutando el programa en C#. Tiene 3 variantes fundamentales:
24
 Mostrar mensaje: Es una de las formas más comunes de usar el método y consiste en
mostrar por pantalla una cadena de texto (escrita entre comillas dobles “0”). Sintaxis:
Console.WriteLine("Este es un mensaje");
 Mostrar el contenido de un atributo: Otra de las formas más comunes de usar el

método, y consiste en mostrar en pantalla el valor almacenado dentro de una variable.
Sintaxis: Console.WriteLine(atributo);
 Mostrar mensaje y el valor de 1 o más atributos y/u operaciones: La forma más

completa de usar el método, el cual permite mostrar no sólo un mensaje, sino que éste
puede ir acompañado de 1 o más valores. Una sintaxis puede ser como la siguiente:
Console.WriteLine("Texto "+ atributo);
Nótese el uso del operador “+”, el cual en este caso se emplea como concatenación
(unión) de cadenas de texto y atributos. Como ya se mencionó, el texto debe estar entre
comillas dobles “0”, los atributos no. Si por ejemplo se escribe esto:
Console.WriteLine(Texto + atributo);
Se muestra en pantalla el contenido de una variable Texto y de una variable atributo.

Si por el contrario se escribe esto: Console.WriteLine("Texto"+"atributo"); se muestra
en pantalla la palabra Textoatributo.
Otra manera de mostrar este tipo de salidas es la siguiente:

Console.WriteLine("La suma de {0} y {1} es {2}", a, b, a+b);
En este caso se escribe dentro del mensaje un identificador de posición de la variable.

En C#, la posición de una variable o atributo dentro del método WriteLine se cuenta de
izquierda a derecha a partir de la posición 0 (0 – 1 – 2 – 3 …). En el ejemplo, la variable a se
encuentra en la posición 0, por eso se escribe {0}, la variable b está en la posición 1, así que
es {1}, mientras que la operación a+b se encuentra en la posición, 2, entonces se coloca {2}.
Si se escribe algo como esto:
25
Console.WriteLine("La suma de {0} y {0} es {2}", a, b, a+b);

Se mostraría el valor de a de manera duplicada, y el valor de a+b. En este caso, el valor
de b no se mostraría, dado que no está indicado en el método. Esta modalidad también
permite definir la cantidad de espacios previos a la impresión de algún valor, por ejemplo:
Console.WriteLine("Número {0,5}", num);
Imprime el valor de num predecedido por 5 espacios en blanco. Esto es muy útil
cuando se desea tabular la salida. Cabe destacar que si el valor a imprimir excede la cantidad
de caracteres señalada, símplemente se tratará como una impresión normal, y no lo truncará.
Por último, hay que señalar que cualquiera de las dos formas de mostrar la salida (con
cocatenación o indicador de posición) es totalmente válida. Incluso, una combinación de
ambas formas es igualmente aplicable:
Console.WriteLine("La suma de {0} y {1} es "+(a+b), a, b);
Write
Se trata de un método muy similar a WriteLine, con sintaxis casi idéntica y mismas
variantes:
Console.Write("Hola ");
Console.Write(a);
Console.Write("La suma de a+b es "+(a+b));
La única diferencia es que mientras WriteLine imprime una línea de texto y/o variable
y coloca el cursor en la siguiente línea, Write imprime la línea y coloca el cursor al final de
la misma.
ReadLine
Es el método estándar para leer información a través del teclado de la consola donde se esté
ejecutando el programa en C#. Es importante saber que cuando se emplea éste para la entrada
de datos, los mismos se leen en forma de cadena de caracteres, por lo que aunque se
introduzca un valor numérico por teclado NO se podrá operar matemáticamente este valor
26
hasta tanto no se transforme adecuadamente al tipo indicado. Su sintaxis es como sigue:

lector = Console.ReadLine(); donde lector es una cadena de caracteres con capacidad
de almacenar cualquier cosa que el usuario introduzca por el teclado.
Si se desea emplear la información de entrada para realizar cálculos matemáticos, se

puede realizar una conversión de tipo, lo cual no es más que llevar el contenido de una
cadena a un tipo de dato específico. La sintaxis para tal conversión es como sigue:
variable_real = tipo_de_dato_a_convertir.Parse(cadena_a_transformar)
Por ejemplo, si se quiere transformar la entrada de datos a un número entero y

almacenarlo en una variable num, se realiza como sigue:
num = int.Parse(cadena);
Ahora, para transformar una variable de cualqueir tipo a cadena, existe el método
ToString, cuya sintaxis es: cadena = variable.ToString();
Al ejecutar un programa en C#, éste lo hace tán rápidamente que finaliza y se cierra
impidiendo ver los resultados. Para evitar esto, es recomendable escribir al final del código
la siguiente línea: Console.ReadLine(); ya que obliga al programa a esperar la entrada del
usuario, permitiendo ver la ejecución del mismo.
2.3.4 Métodos para personalizar la consola
Como ya se ha dicho, la clase Console no sólo permite la entrada y salida de datos, sino que
también permite la personalización de la pantalla. Dos de los métodos más populares son los
siguientes:
 BackgroundColor: Permite cambiar el color de fondo de las celdas de carácter. Su

sintaxis es como sigue:
Console.BackgroundColor = ConsoleColor.DarkBlue;
27
De acuerdo al ejemplo, se asigna como color de fondo uno de los colores disponibles para
consola (en este caso el azul oscuro).
 ForegroundColor: Permite cambiar el color en primer plano, es decir, cambia el color

de las letras. Su sintaxis es muy parecida a la del método anterior:
Console.ForegroundColor = ConsoleColor.Yellow;
Para activar ambos métodos debe escribirse lo siguiente: Console.Clear(); la cual,

como su nombre lo indica, realiza una limpieza de pantalla. Cabe destacar que es
recomendable escribir estos métodos ANTES de escribir el resto del programa.
Ejemplo 2.6: Escriba un programa que lea 2 números enteros e imprima la suma:
using System;
using System.Collections.Generic;
using System.Text;
namespace Ejemplo2_6
{
class Sumador
{
private int a, b, suma;
private string temp;
public void ejercicio()

{
Console.WriteLine("Ingrese 2 números");
temp = Console.ReadLine(); // Lectura de una cadena de texto
a = int.Parse(temp); // Conversión a entero
// Lectura y conversión directa:
b = int.Parse(Console.ReadLine());
suma = a + b;
// Impresión de texto y variable:
Console.WriteLine("La suma es: " + suma);
}
}
class Program
{
static void Main(string[] args)
{
// Personalización de la Consola:
Console.BackgroundColor = ConsoleColor.DarkBlue;
Console.ForegroundColor = ConsoleColor.Yellow;
Console.Clear();
28
// Aquí inicia el programa como tal:

Sumador sum = new Sumador(); // Declaración del objeto
sum.ejercicio() // Ejecución del método interno
Console.ReadLine();
}
}
}
Nótese las líneas precedidas por la doble barra “//”. Estos son los comentarios de una
línea, los cuales no son más que línea no ejecutables que se emplean para la documentación
del código fuente. Si se quieren usar comentarios de líneas múltiples, se emplea la
combinación de /* y */, así:
/* Este es un comentario de múltiples lineas
Y estará inactivo hasta el cierre del mismo */
La combinación anterior suele ser empleada para la inhabilitación de código ejecutable,

esto con el fin de facilitar la revisión y detección de errores de código, sin necesidad de borrar
el contenido.
2.4 Ejercicios propuestos
1) Escriba un programa que lea tres palabras e imprima una frase completa con ellas. Por
ejemplo, si se reciben las cadenas “Bienvenido”, “a” y “C#” se imprima la línea
“Bienvenido a C#”.
2) Modifique el programa anterior para imprimir texto adicional, el cual debe ir entre las
palabras recibidas desde el teclado. Por ejemplo, al recibir “Bienvenido”, “a” y “C#”, se
imprima algo como “Sean todos Bienvenidos a las clases de C#”.
3) Escriba un programa que lea un número entero e imprima su cuadrado.
4) Construya una clase que sea capaz de realizar las operaciones aritméticas fundamentales
entre dos números (suma, resta, producto y división).
29
UNIDAD III: DATOS SIMPLES
3.1 Variables
La variable es una posición de memoria donde se puede almacenar un valor para uso de un
programa, ya sea entero, número real, carácter, entre otros. Este valor es temporal, pues puede
ser reemplazado por otro a medida que se van ejecutando las instrucciones. La manera de
informar a la computadora que se crea una variable es a través de una sentencia de
declaración, la cual ayuda a definir lo que se puede almacenar en un nombre de variable.
Por su parte están las constantes, cuyo valor es invariable durante la ejecución del
algoritmo. En ambos casos se requiere del uso de un identificador, el cual consiste en una
secuencia de caracteres alfanuméricos que permite asignar un nombre (preferiblemente
significativo) al referido espacio de memoria, ya que de no hacerlo se requeriría conocer la
dirección específica de la variable o constante, lo cual resulta muy complicado.
3.1.1 Reglas para asignar nombres de variables
La sintaxis del lenguaje de programación C# impone algunas reglas en la construcción de los

nombres de variables. Estos se listan a continuación:
 Puede ir formado por una o más letras, o en combinación con números.

 Puede tener cualquier longitud.
 No se permite el uso de caracteres especiales, excepto el underscope “_”.
 Siempre deberá comenzar con una letra o por “_”. Sin embargo, es buena práctica de
programación tener nombres de variables que empiecen con letras minúsculas (a - z).
 Preferiblemente, que sea mnemotécnico.
 Todas las variables deben declararse con un nombre y un tipo de datos. Por ejemplo,
string cad;
 La declaración de una variable se puede realizar en cualquier parte del programa, siempre
y cuando sea antes de su primer uso
30
 No puede ser una palabra reservada del lenguaje (se trata en este caso de un
identificador predefinido que tiene un significado especial).
Algunas palabras reservadas por C#

bool break case char const
continue decimal default do double
else enum extern float for
goto if int long object
return short sizeof static string
struct switch void volatile while
3.1.2 Tipos de identificadores
Los identificadores (variables o constantes) pueden ser:
 Numéricos: Almacenan sólo números.

o Acumulador: Es aquel que se incrementa en forma no definida por la suma o
producto con otro valor a dicho campo. Su valor inicial suele ser 0 (suma) o 1
(producto).
 Alfanuméricos: Almacenan cualquier carácter.
 Lógicos: Almacenan los estados true (verdadero) y false (falso).
 Compuestos: Combinación de varios identificadores de uno o más tipos.
3.2 Tipos de datos
Se define como un conjunto de valores y operaciones definidas para las variables de ese tipo
en particular. Los tipos de datos básicos en C# son: Byte, Int, Single, Double, Decimal,
Boolean, Char, String y Object.
Por ejemplo, int es un tipo de dato y conjunto de valores que una variable de tipo int
puede almacenar, y también el conjunto de operaciones que se pueden usar con los operandos
enteros.
31
Cada uno de los tipos de datos básicos se almacena en forma diferente en la memoria
de la computadora:
Tipo Descripción Bits Rango de Valores Alias

Sbyte Bytes con signo 8 -128 a 127 sbyte
Byte Bytes sin signo 8 0 a 255 byte
Int16 Enteros cortos con signo 16 -32.768 a 32.767 short
UInt16 Enteros cortos sin signo 16 0 a 65.535 ushort
Int32 Enteros normales con signo 32 -2.147.483.648 a 2.145.483.647 int
UInt32 Enteros normales sin signo 32 0 a 4.294.697.295 uint
-9.223.372.036.854.775.808 a
Int64 Enteros largos con signo 64 long
9.223.372.036.854.775.807
UInt64 Enteros largos sin signo 64 0 a 18.446.744.073.709.551.615 ulong
Single Reales con 7 dígitos de precisión 32 1,5x10-45 a 3,4x1018 float
Double Reales con 15-16 dígitos de precisión 64 1,0x10-28 a 7,9x1028 double
Decimal Reales con 28-29 dígitos de precisión 128 5,0x10-324 a 1,7x10308 decimal
Boolean Valores Lógicos 32 True, false bool
Char Caracteres Unicode 16 ‘\u0000’ a ‘\uFFFF’ char
String Cadenas de Caracteres Variable El permitido por la memoria string
Object Cualquier Objeto Variable Cualquier objeto object
Como se puede observar, además de los datos básicos existen los calificadores de
datos signed y unsigned, los cuales modifican las propiedades de los tipos (es decir,
determina si tienen o no tienen signo). También puede apreciarse un “alias” o nombre
alternativo en el que pueden ser declarados los tipos de datos.
Por ejemplo: long a = 123456789;
Int64 b = 987654321;
En ambos casos se declaran variables de tipo entero largo (o de 64 bits). Ambas

declaraciones son totalmente válidas.
3.3 Expresiones, operadores y asignaciones
El operador es el símbolo utilizado en matemáticas o computación para indicar la operación

que se realiza entre los elementos que une o la relación que existe entre ellos.
32
3.3.1 Operadores aritméticos
Los operadores aritméticos de C# se muestran en la siguiente tabla:
Operación Operador Expresión Algebraica Expresión en C#

Suma + Z+7 Z+7
Resta – A–B A–B
Producto * XY X*Y
División / j/k ó j÷k j/k
Módulo % r mod s r%s
Advierta el uso de varios símbolos especiales, no utilizados en álgebra. El asterisco (*)

indica producto, y el signo de porcentaje (%) denota el operador módulo. Los operadores
aritméticos son operadores binarios. La combinación de operandos por medio de cualquiera
de estos operadores se llama expresión algebraica o aritmética.
La división de enteros da como resultado también un entero. Por ejemplo, la expresión

7/4 da como resultado 1, y la expresión 17/5 da como resultado 3. Se debe tener mucho
cuidado de asegurar que al realizar la división, el denominador sea distinto a 0. Si se intenta
dividir entre 0, el programa no funcionará.
C# tiene el operador de módulo %, que proporciona el residuo después de una división

de enteros, por lo tanto, 7%4 da como resultado 3, y 17%5 da como resultado 2. El módulo
es un operador entero, es decir, que sólo puede ser utilizado con operandos de tipo int.
Cuando uno de los operandos es negativo, el resultado de % no está definido.
Las expresiones aritméticas deben ser escritas en una línea continua para facilitar la
escritura de programas en la computadora. Entonces, expresiones tales como “a dividido
𝒂
entre b” deben ser escritas como a/b, y no como 𝒃. Por su parte, los paréntesis se utilizan en
las expresiones de C# de manera muy similar a como se usan en las expresiones algebraicas.
Por ejemplo, para multiplicar a por la cantidad b+c se escribe lo siguiente: a * (b + c).
33
3.3.2 Expresiones y operadores relacionales
Las expresiones relacionales son aquellas que se forman con una combinación de
identificadores, constantes y expresiones aritméticas, todas enlazadas a través de un conjunto
de operadores relaciónales. Los siguientes, por ejemplo, son todas expresiones relacionales
válidas:
 10
 (a-25) <= max
 b<=0
 (b*b -2*a) < (c*e)/2
Operadores relacionales
Algunos de los operadores relacionales son: < (menor que), <= (menor o igual que), > (mayor
que) y >= (mayor o igual que). La asociatividad de la evaluación es de izquierda a derecha.
Los operadores relacionales se usan para formar expresiones relacionales. Las expresiones
relacionales siempre producen un valor de verdadero o falso.
Operadores de igualdad
Los operadores de igualdad son: = (igual a) y != (diferente a). La asociatividad de los

operadores es de izquierda a derecha. Éstos se pueden usar en expresiones relacionales.
Algunos ejemplos válidos del uso de los operadores de igualdad se presentan a continuación:
a == b n != 10 b + c == c - d
3.3.3 Expresiones y operadores lógicos
Las expresiones relacionales conectadas por operadores lógicos se denominan expresiones

lógicas, ya que siempre producen un valor de verdadero o falso. El valor que retorna una
expresión lógica es de tipo Boolean, a saber: true y false. C# también provee operadores
lógicos, llamados conectores lógicos, los cuales se listan a continuación:
34
 && Y (AND)
 || O (OR)
 ! NO (NOT)
Se pueden usar los operadores lógicos para combinar expresiones lógicas. Algunos
ejemplos se dan a continuación:
(a + 2) == max && (n != 0)
(a == 3) && (max != -1) | | (i % 2 != 0)
El operador lógico && retorna el valor true sólo cuando ambos operandos son
verdaderos. El operador lógico | | retorna el valor false sólo si ambos operandos son falsos.
El operador lógico ! retorna el opuesto del operando, es decir, retorna true si el operando es
false, y viceversa.
3.3.4 Operadores incrementales y decrementales
C# también tiene el operador incremental unario (++) y el operador decremental unario (--),
los cuales permiten incrementar o decrementar en 1 el valor de una variable. Por ejemplo,
X++ es el equivalente de X = X + 1.
Operador Ejemplo Descripción

++ ++ a Se incrementa a en 1 y a continuación se utiliza el
nuevo valor de a en la expresión en la cual resida a
a ++ Utiliza el valor actual de a en la expresión en la cual
resida a, y después se incrementa a en 1
-- -- b Se decrementa b en 1 y a continuación se utiliza el
nuevo valor de b en la expresión en la cual resida b
b -- Utiliza el valor actual de b en la expresión en la cual
resida b, y después se decrementa b en 1
3.3.5 Operadores compuestos de asignación
C# proporciona operadores compuestos de asignación, los cuales pueden ser utilizados como
atajos al escribir las declaraciones de asignación.
35
Un operador de asignación compuesto consiste generalmente de un operador aritmético

binario y un operador de asignación simple. Éste ejecuta la operación de un operador binario
en ambos operandos y da el resultado de esa operación al operando izquierdo. Por ejemplo,
la declaración: X = X + 2 es equivalente a: X += 2. Los operadores compuestos más usados
son: += (suma), –= (resta), *= (producto), /= (división) y %= (módulo).
3.3.6 Operador condicional
El operador condicional “?:” retorna uno de dos valores de una expresión booleana. Su
sintaxis es como sigue:
Condición ? instrucción1 : instrucción2;
Como se puede observar, se trata de un operador ternario, ya que involucra 3

operandos. Aquí la condición se evalúa y, si el resultado es true se lleva a cabo la primera
instrucción, si es false ejecuta la segunda.
3.3.7 Precedencia de operadores
Las reglas de precedencia de operadores son guías de acción que permiten a C# calcular
expresiones en una secuencia precisa, es decir, permite establecer qué operaciones se
ejecutan primero, qué otras operaciones se ejecutan posteriormente.
Categoría Operadores Ejemplo de Uso Asociatividad

Acceso a Datos ()[]. a * (b + c) De izquierda a derecha
Unarios ++ -- + - (signo) -5 De derecha a izquierda
NOT Lógico ! !(k>f) De izquierda a derecha
Aritméticos * / % x%y De izquierda a derecha
+ - 3+2 De izquierda a derecha
Relacionales < <= > >= rel1 < rel2 De izquierda a derecha
Igualdad == != rel3 != rel4 De izquierda a derecha
AND Lógico && b<c && d>e De izquierda a derecha
OR Lógico || b<c || d>e De izquierda a derecha
Condicional ?: i>j ? k=1 : k=0 De izquierda a derecha
Asignación = += -= *= /= %= a += 5 De derecha a izquierda
36
Ejemplo 3.1: Escriba un programa que entre 3 enteros diferentes del teclado, y a continuación
imprima la suma, el producto y el promedio de estos números.
using System;
using System.Collections.Generic;
using System.Text;
namespace Ejemplo3_1
{
class Operaciones
{
private int a, b, c, prod=1; // Declaración de variables
public void lector()

{
Console.WriteLine("Ingrese 3 números enteros:");
a = int.Parse(Console.ReadLine());
b = int.Parse(Console.ReadLine());
c = int.Parse(Console.ReadLine());
}
public void ejemplo()

{
/* Declaración y asignación de variable interna. Nótese que
se declara SIEMPRE antes de usarla por primera vez */
int suma = a + b + c;
// Ejemplo de uso de operador compuesto de asignación:

prod *= a * b * c; // Es lo mismo que prod = prod * a * b * c
/* Ejemplo de uso de ley de precedencia: Dado que la división

tiene precedencia mayor que la suma, se fuerza a realizar
la suma primero con el uso de paréntesis (de precedencia
mayor) */
int prom = (a + b + c) / 3;
Console.WriteLine("La suma de los números es: "+suma);
Console.WriteLine("El producto de los números es: " + prod);
Console.WriteLine("El promedio de los números es: " + prom);
}
}
class Program
{
static void Main(string[] args)
{
Operaciones Ope = new Operaciones();
Ope.lector();
Ope.ejemplo();
Console.ReadLine();
}
}
}
37
3.4 Ejercicios propuestos
1) Escriba un programa que lea el radio de un círculo y que imprima el diámetro del mismo,
su circunsferencia y su área. Utilice el valor constante 3.14159 para Pi, y el tipo de
atributo double.
2) Escriba un programa que reciba un número de cinco dígitos, separe el número en sus
dígitos individuales e imprima los dígitos separados unos de otros mediante tres espacios.
Utilice los operadores / (división) y % (módulo).
38
UNIDAD IV: ESTRUCTURAS DE CONTROL
En un programa, por lo general, los enunciados son ejecutados uno después del otro, en el
orden en que aparecen escritos. Esto se conoce como ejecución secuencial.
Sin embargo, hay ocasiones en que se requiere que ciertas condiciones se verifiquen y
se tomen decisiones de acuerdo a éstas, es decir, realizar acciones específicas que bien
pudieran cambiar la secuencia de ejecución de un programa. Esto se denomina transferencia
de control, la cual puede realizarse mediante el uso de estructuras de selección o iterativas.
4.1 Estructuras de control selectivas
El control de decisión abarca desde verificar condiciones muy simples hasta estructuras muy
complejas, tomando decisiones basadas en ellas. C# proporciona 3 estructuras de selección,
a saber:
 if simple: Estructura de una sola selección. Ejecuta una acción si una condición es
verdadera, de ser falsa la ignora.
 if/else: Ejecuta una acción si una condición es verdadera, de ser falsa ejecuta una
acción distinta.
 switch/case: Ejecuta una entre muchas acciones diferentes, dependiendo del valor de
una expresión.
4.1.1 La estructura de selección simple: if
IF significa SI (condicional) en español, y consiste en una estructura de selección empleada

para elegir entre cursos alternativos de acción. Su funcionamiento es simple: Se evalúa una
condición, si es verdadera ejecuta un código, si es falsa, continúa con la ejecución del
programa.
39
Diagrama de Flujo Sintaxis

…
if(condición)
Sí {
condición instrucciones
<instrucciones>;
No }
…
Ejemplo 4.1: Escribir un método que tome como entrada la calificación de un alumno y
determinar si aprobó la asignatura.
void ejemplo4_1(int nota)

{
if(nota >= 5)
{
Console.WriteLine("Aprobado");
}
}
En este ejemplo, la condición que se verifica es nota >= 5, la cual es una expresión
relacional. Si el resultado es true, se imprime la palabra “Aprobado”, de lo contrario no
ejecuta ninguna acción. Nótese el uso de las llaves “{ }”: En este caso se emplearon
simplemente para evitar confusión, ya que al haber una única instrucción éstas pueden ser
omitidas. De haber 2 o más sentencias dentro del bloque if, dichas llaves son de uso
obligatorio.
4.1.2 La estructura de selección doble: if/else
ELSE significa SINO (condicional) en español. La estructura if/else se le llama estructura

de doble selección, porque elige entre dos opciones distintas: Ejecuta una acción si la
condición es verdadera o ejecuta una acción diferente si la condición es falsa.

…
if(condición)
Sí No { <instr_ni;> }
condición
else
{ <instr_no;> }
instr_si instruc_no …
40
Ejemplo 4.2: Modificar el método anterior, de tal manera que indique si un alumno aprobó
o reprobó la asignatura.

{
if(nota >= 5)
{
}
else
{
Console.WriteLine("Reprobado");
}
}
Como pudo observarse en el ejemplo, en esta oportunidad se realizan 2 acciones

distintas, dependiendo de la condición: Si el resultado es true, se imprime la palabra
“Aprobado”, de lo contrario se imprime Reprobado. Tal como en if simple, si hay una única
sentencia relacionada con if y/o con else, las llaves pueden ser omitidas. Es de resaltar que
ambas acciones son excluyentes entre sí, es decir, si se ejecuta una de ellas no puede
ejecutarse la otra.
Debe recordarse que el bloque else se ejecuta solamente si el resultado de la

condición es falso, en otras palabras, es una acción automática que no necesita de una nueva
verificación, por lo que una instrucción de tipo “else(nota < 5)” es totalmente incorrecta.
Las estructuras if/else anidadas
Las estructuras anidadas son aquellas que se encuentran dentro de otras estructuras
de control. En el caso de un if/else anidado, su forma es como sigue:
if(condicion)
sentencia1;
else
if(condicion)
sentencia2;
else
if(condicion)
sentencia3;
else ...
41
Esto tipo de estructuras resulta útil cuando existen relaciones que involucren al menos
3 posibles respuestas, ya que los operadores en programación son de tipo binario (es decir,
de la forma operando1 – operador – operando2), lo que implica que solamente se puede elegir
entre 2 alternativas, pudiéndose de esta forma realizar el descarte entre pares de opciones.
Por supuesto, se debe tener cuidado con los niveles de anidamiento para no elaborar un
programa demasiado confuso.
Ejemplo 4.3: Modificar el método anterior, de tal manera que indique si un alumno aprobó
la asignatura, sino, que indique si tiene o no derecho a examen final o reparación.

{
if(nota >= 5)
else
if(nota >= 3.5)
Console.WriteLine("Puede presentar examen final");
else
if(nota >= 2)
Console.WriteLine("Puede ir a reparación");
else
Console.WriteLine("Reprobado");
}
En este caso se estudian 3 condiciones: Si la nota es mayor o igual a 5, si es mayor o

igual a 3.5 y si es mayor o igual a 2. Si se cumple la primea condición, se imprime la palabra
Aprobado, de lo contrario se pasa a la siguiente sentencia if/else, hasta que se ejecute
cualquiera de las sentencias involucradas.
Problema del else colgante
El compilador de C# siempre asocia un else con el if anterior, a menos que se indique lo

contrario mediante el uso de las llaves { }. En vista de que a primera vista el programador no
estaría seguro de cuál if coincide con qué else, esto se conoce como el problema del else
colgante.
42
Ejemplo 4.4: Determine la salida para el siguiente bloque de código, cuando a es 9 y b es 11;
y cuando a es 11 y b es 9.
if(a < 10)

if(b > 10)
Console.WriteLine("*****");
else
Console.WriteLine("#####");
Console.WriteLine("$$$$$");
Se puede observar que el código ni está tabulado, ni incluye llaves. Un programador

sin experiencia puede confundirse al tratar de resolver este problema, sobretodo porque surge
la pregunta: ¿A quién le pertenece el else?
En este caso se debe tomar en cuenta lo siguiente:

 Un else nunca puede estar sin su correspondiente if, por lo tanto, cada instrucción else
dentro del código estará automáticamente asociada con el if inmediatamente anterior.
 Recuérdese que, cuando la instrucción asociada a un if o else es única, las llaves pueden
ser omitidas, pues funcionará de la misma manera.
 Es recomendable aplicar la indentación (o tabulado) en el código, para una correcta
identificación de los bloques.
Entonces, para resolver esto, lo primero que hay que hacer es tabular el código,
quedando como sigue:
if(a < 10)

if(b > 10)
else
Nótese que la última instrucción queda al mismo nivel del primer if. Esto es así porque,
como ya se ha mencionado, al no haber llaves se toma como parte de la estructura la
instrucción inmediatamente inferior al if o else. Si se desea que esta línea pertenezca al else,
se deben encerrar ambas instrucciones entre llaves.
43
Ahora que se tiene ordenado el código es visualmente más sencillo identificar la

secuencia de instrucciones, de acuerdo a las condiciones; por lo tanto, para a = 9 y b = 11 la
salida es:
*****
$$$$$
Por su parte, para a = 11 y b = 9, la salida es:

$$$$$
Hay que ser cuidadosos en el uso de las llaves, sobre todo cuando se desea agrupar
varias instrucciones en un mismo bloque, pues se podría encerrar a una instrucción else sin
su correspondiente if, lo que generaría un error de código. Esto se ilustra en el siguiente
ejemplo:
Ejemplo 4.5: Aplique la indentación y las llaves en el código que sigue para producir la salida
deseada. No puede hacer ningún otro cambio.
if(i == 5)
if(j == 8)
Console.WriteLine("@@@@@");
else
a) Suponiendo que i = 5 y j = 8, se genera la siguiente salida:

@@@@@
*****
b) Suponiendo que i = 5 y j = 8, se genera la siguiente salida:

@@@@@
Este tipo de ejercicios es un poco más complicado de resolver, pero con un análisis
detallado y cierta habilidad en el uso de una estructura doble se puede dar con una solución.
En el caso de la salida a, se nota que debe imprimirse la línea de arrobas. Al haber dos
instrucciones if consecutivas, es evidente que una está anidada dentro de la otra, y que ambas
se deben cumplir (y lo hacen, según los valores de i y j), para que dicha salida se ejecute.
44
Con respecto a las dos siguientes líneas, éstas no deben ser impresas. Se observa que
ambas siguen a una instrucción else, y como se mencionó antes, los if deben ejecutarse, por
lo tanto, estas líneas deben ser agrupadas en el else, ya que el mismo no ejecuta según la
condición. Ahora, ¿a cuál if pertenece? A cualquiera de los dos, pues el resultado es el mismo.
En este caso se decide que éste pertenezca al if más interno.
La última línea (asteriscos) debe imprimirse, entonces la misma puede, bien pertenecer
al if externo, o ser una instrucción independiente, ay que da el mismo resultado. Para este
ejercicio se opta por incluirlo en dicho if. Entonces, el código queda como sigue:
if(a == 5)
{
if(b == 8)
else
{
}
}
En el caso de b, solamente se requiere que se imprima la línea de arrobas. Aquí se

procede igual que con a, solo que ahora las tres últimas líneas deben incluirse en el else, ya
que, según los valores de i y j, esta serie de instrucciones no se ejecuta, ya que ambas
condiciones se cumplen. Por lo tanto se tiene lo siguiente:
if(a == 5)
{
if(b == 8)
else
{
}
}
Recuérdese que, al trabajar con las llaves, no debe haber una instrucción de tipo
“if(condicion){ else }”, ya que allí hay un error de sintaxis.
45
4.1.3 La estructura de selección múltiple: switch/case
Una construcción anidada if/else puede llegar a ser difícil de entender, sobre todo cuando un
número de condiciones alternas deben ser evaluadas. C# provee la estructura switch/case,
que prueba una variable o expresión por separado contra cada uno de los valores constantes
enteros que pude asumir, lo que conduce a tomar distintas acciones.

…
switch(variable o expresión)
{
case resp1: <instr_1>;
Por defecto
var o exp break;
case resp2: <instr_2>;
…
resp1 resp2 respN break;
…
instr_1 instr_2 instr_N instr_D
case respN: <instr_N>;
break;
… [default : <instr_D>;
break;]
}
Aquí pueden observarse varios aspectos:
 La condición a evaluar puede ser una variable, constante o expresiones algebraicas.

Sin embargo, el uso de expresiones relacionales en una selección múltiple puede verse
limitado por el lenguaje (por ejemplo, en C# no está permitido, pero en Pascal sí).
 Cada case debe culminar en una sentencia break (ruptura); la cual evita que, por
lógica, las otras sentencias case se ejecuten, de hecho, si se omite esa instrucción C#
muestra ese error.
 Default es una sentencia por defecto, la cual se ejecuta si no se cumplen los case.
Ésta, sin embargo, puede ser omitida. Si se incluye, al igual que los case debe
culminar en una sentencia break.
Ejemplo 4.6: Escriba un método que tome como entrada un valor del 1 al 7 e imprima el día
de la semana que corresponde al número ingresado (Domingo = 1, Lunes = 2, etc.). Si la
entrada no es válida se debe mostrar un mensaje de error.
46
public void ejemplo4_6(int dia)

{
switch (dia)
{
case 1: Console.WriteLine("Domingo");
break;
case 2: Console.WriteLine("Lunes");
break;
case 3: Console.WriteLine("Martes");
break;
case 4: Console.WriteLine("Miércoles");
break;
case 5: Console.WriteLine("Jueves");
break;
case 6: Console.WriteLine("Viernes");
break;
case 7: Console.WriteLine("Sábado");
break;
default: Console.WriteLine("Error!");
break;
}
}
Se debe prestar atención en el uso de esta estructura de control. Ya se ha mencionado

que un error común es la omisión de la instrucción break, sin embargo, existe otro error
bastante frecuente, conocido como código inalcanzable, debido a que el mismo se coloca
entre un break y el case siguiente (o el default), así:
case x: <instrucción_x>
break;
<alguna_instrucción> // <- Este es un código inalcanzable
case y: <instrucción_y>
break;
4.2 Estructuras de control iterativas
Muchos problemas en la vida real son una ejecución repetida de un conjunto de tareas, es
decir, realiza una serie de iteraciones, ciclos o bucles (loops). En programación existen las
estructuras de control iterativas, las cuales permiten repetir porciones de algoritmo un
determinado número de veces. Este tipo de estructuras involucra tres partes básicas, a saber:
47
 Inicialización de la variable de control: La variable de control es aquella que, como su

nombre lo indica, lleva el control de la ejecución de un ciclo. Ésta debe tener siempre un
valor inicial con el que inicia la ejecución del primer bucle.
 Condición de repetición: Es la expresión relacional (o variable lógica) que define en
qué momento va a finalizar el ciclo.
 Actualización de la variable de control: Instrucción que permite modificar el valor de
la variable de control, de forma tal que en algún momento alcance aquel que indique el
fin de ejecución de los bucles.
4.2.1 La estructura iterativa for
Un contador es una variable especial que incrementa o decrementa, contando el número de

veces que el proceso ha detectado una ocurrencia determinada. Esto es importante saberlo,
puesto que el ciclo for (en español “para”) maneja de manera automática todos los detalles
de la repetición controlada por contador, ya que incorpora los componentes del ciclo en
una misma instrucción, y se emplea cuando se conoce con certeza el número de iteraciones
que deben realizarse.
…
for(inicio;condición;actualización)
condición_cierta
{
ini; cond; act instrucciones <instrucciones>;
}
final_de_ciclo
…
El funcionamiento es como sigue: Cuando la estructura for inicia su ejecución, la

variable de control se inicializa a un valor dado. A continuación, se verifica si cumple con la
condición. Si se satisface, se ejecuta el conjunto de instrucciones contenidas dentro del ciclo.
A continuación, la variable de control se actualiza en forma automática, y el ciclo inicia otra
vez hasta que la condición sea false. Es allí cuando se termina la ejecución del bucle y se
continúa ejecutando el resto del programa.
48
Observaciones:
1. Tanto la inicialización, como la condición de continuación de ciclo, y la actualización
pueden contener expresiones aritméticas.
2. Si la condición de continuación de ciclo resulta falsa al inicio, la porción del cuerpo del
bucle no se ejecutará. En vez de ello, la ejecución seguirá adelante con el enunciado que
siga a la estructura for.
3. La variable de control con frecuencia se imprime o se utiliza en cálculos en el cuerpo de
un ciclo, pero esto no es necesario. Es común utilizar dicha variable para controlar la
repetición, aunque jamás se mencione la misma dentro del bucle.
4. En la sentencia for, se puede omitir cualquiera de los tres componentes del ciclo,
(inicialización, condición o actualización). En este caso, éstos deben colocarse antes o
dentro del mismo ciclo. Sin embargo, se requiere mucho dominio del manejo de ciclos
para realizar este tipo de cambios (sobre todo la omisión de la condición, la cual no es
recomendada).
5. No todos los lenguajes permiten definir la manera en que se actualiza la variable de
control. Por ejemplo, esta opción es inexistente en Pascal, puesto que allí el incremento
(o decremento) es por unidad. Por fortuna, este no es el caso de C#, el cual ofrece esta
facilidad.
Ejemplo 4.7: Escriba un método que imprima los números del 1 al 10.
public void ejemplo4_7()

{
for(int n = 0; n <=10; n++)
{
Console.WriteLine(n);
}
}
/* Nótese que "n" se ha inicializado dentro del ciclo FOR. Esto
es totalmente válido, ya que se declara antes de su uso.
Una vez que n > 10, se culmina el ciclo. */
Esta estructura permite ahorrar muchas líneas de código, ya que engloba todos los
elementos de un ciclo en una sencilla sentencia. Esto es sumamente importante, dado que
esta estructura for, es muy usada al trabajar con los arreglos (los cuales serán explicados en
la unidad V).
49
4.2.2 La estructura iterativa while
La estructura while (en español “mientras”), permite al programador repetir una acción, en
tanto cierta condición se mantenga verdadera. En otras palabras, realiza básicamente la
misma función que el ciclo for, sólo que aquí los componentes del ciclo son instrucciones
separadas.
valor_inicial
…
<valor_inicial>;
while(condición)
{
Verdadero <instrucciones>;
condición instrucciones }
Falso …
Aquí se muestra con claridad el flujo de control en la estructura de repetición mientras:

La línea de flujo que parte del bloque instrucciones retoma a la decisión misma, que es
probada cada vez dentro del ciclo, hasta que de forma eventual la decisión se convierte en
falsa. Llegado este momento, se sale de la estructura y el control pasa al siguiente enunciado
del algoritmo.
Ejemplo 4.8: Modifique el algoritmo anterior para que use la estructura while.

{
int n = 0;
while(n <=10)
{
Console.WriteLine(n);
n++;
}
}
Obsérvese que, entre las sentencias dentro del cuerpo debe haber una que actualice la
variable de control, de forma tal que modifique la condición de iteración del bucle,
asegurando así la ejecución finita del mismo. De no haberla, o de estar mal formulada, podría
generarse lo que se llama un bucle infinito. Igualmente, una incorrecta formulación de la
50
variable de control (valor inicial inadecuado, inicialización dentro del bucle) o su completa
omisión, puede derivar en un error de sintaxis o ejecución.
En ocasiones, no se conoce con certeza el número total de ciclos, por lo que se debe
llevar a cabo una repetición controlada por centinela, ya que usa una variable que, al recibir
un valor específico, determina el final del ciclo.
Ejemplo 4.9: Elabore un método que permita leer una serie de números enteros positivos y
calcule su promedio. Dicho conteo deberá terminar cuando se introduzca el 0.

{
int n=1, suma = 0, cont=0;
while(n > 0)
{
Console.Write("Ingrese un número: ");
n = int.Parse(Console.ReadLine());
if(n > 0)
{
suma += n; // <- Esta variable es un acumulador
cont++; // <- Y esta variable es un contador
}
}
// En este caso, "0" es el valor centinela
if(cont > 0) // Se verifica si se insertaron valores

{
double prom = suma/cont;
Console.WriteLine("El promedio es: " + prom);
}
}
Aquí se declara una variable n que, en este caso, es el controlador del ciclo de
repetición, de tal manera que el mismo se ejecute hasta que el usuario ingrese el 0, que es el
valor centinela, ya que permite que la relación n > 0 de un resultado falso, lo que culmina
el ciclo.
Como se ha dicho, si no hay una sentencia de control de repetición del ciclo, o si la

misma está mal formulada, el programa generaría un error de sintaxis (por ejemplo, si n no
está inicializada) o incluso un ciclo infinito (si se elimina la lectura del valor de n).
51
4.2.3 La estructura iterativa do-while
La sentencia do-while (“hacer-mientras”) es otra construcción iterativa que se usa cuando el

cuerpo de un bucle se debe ejecutar al menos una vez. En los bucles for y while, el cuerpo
del bucle se ejecuta sólo cuando la condición es verdadera. En el do-while la condición es
verificada al final, de este modo el cuerpo del bucle se ejecuta al menos una vez. Cuando
termina do/while, la ejecución continuará con el enunciado que aparezca después de la
cláusula while.
valor_inicial
…
<valor_inicial>
do
instrucciones {
<instrucciones>;
} while(condición);
condición …
Verdadero
Falso
En otros lenguajes existen variantes de este bucle, por ejemplo, en Pascal no existe el
do-while, sino el repeat-until (“repetir-hasta”), con una estructura idéntica a la mostrada en
la tabla, salvo que allí el ciclo se ejecuta mientras la condición sea falsa.
Ejemplo 4.10: Modifique el programa anterior para que utilice una estructura do-while.

{
int n, suma = 0, cont=0;
do
{
Console.Write("Ingrese un número: ");
n = int.Parse(Console.ReadLine());
if(n > 0)
{
suma += n;
cont++;
}
}while(n > 0);
52
/* Como puede observarse, el valor inicial se puede

obtener incluso dentro del cuerpo del bucle */
if(cont > 0)
{
double prom = suma/cont;
Console.WriteLine("El promedio es: " + prom);
}
}
4.2.4 Sentencias break y continue
Las sentencias break (romper) y continue (continuar) se utilizan para modificar el flujo de
control. El enunciado break, al ser ejecutado en una estructura while, for, do/while, o
switch, causa la salida inmediata de la misma. La ejecución del programa continúa con la
primera instrucción después de la estructura. Los usos comunes de esta sentencia son para
escapar en forma prematura de un ciclo, o para saltar el resto de una estructura switch (ver
4.1.3).
Ejemplo 4.11: Modifique el método mostrado en el ejemplo 4.7, para que utilice la sentencia
break cuando n = 5.

{
for(int n = 0; n <=10; n++)
{
if (x == 5)
break;
Console.WriteLine(x);
}
Console.WriteLine("El ciclo se rompe cuando X = 5");
}
La salida generada es la siguiente:
Por su parte, el enunciado continue, cuando se ejecuta dentro de un ciclo, salta los
enunciados restantes del cuerpo de dicha estructura, y ejecuta la siguiente iteración del bucle.
53
En estructuras while y do/while, la prueba de continuación de ciclo se valúa inmediatamente

después de que se haya ejecutado el enunciado continue. En la estructura for, se ejecuta la
actualización de la variable de control, y a continuación se valúa la prueba de continuación
de ciclo.
Ejemplo 4.12: Modifique el método anterior, para que utilice la sentencia continue cuando
n = 5.

{
for(int n = 0; n <=10; n++)
{
if (x == 5)
continue;
Console.WriteLine(x);
}
Console.WriteLine("El ciclo continúa cuando X = 5");
}
En este programa, la salida generada es la que sigue:
4.3 Ejercicios propuestos:
1) Escriba un programa que lea 3 valores enteros positivos (no ceros) y que determine e
imprima si pueden ser los lados de un triángulo rectángulo.
2) Escriba un programa que lea 5 números enteros y a continuación determine e imprima

cuál es el mayor y cuál es el menor del grupo.
3) Realizar un programa que sume todos los números impares comprendidos entre 1 y 1000.
54
4) Escriba un programa que lea un valor y a continuación imprima la figura mostrada. Éste
debería poder funcionar para todos los tamaños entre 5 y 30. Por ejemplo, si se lee un
tamaño de 5, debería imprimir:
*****
*****
*****
*****
*****
5) Escriba un programa que imprima los siguientes patrones. Cada * deberá ser impreso con
un enunciado Console.Write( ) (o WriteLine). Utilice ciclos for:
(a) (b) (c) (d)

* ********** ********** **********
** ********* ********** **********
*** ******** ********** **********
**** ******* ********** **********
***** ****** ********** **********
****** ***** ********** **********
******* **** ********** **********
******** *** ********** **********
********* ** ********** **********
********** * ********** **********
55
UNIDAD V: DATOS COMPUESTOS
5.1 Arreglos
(Pendiente)
56

Guía Programación Orientada A Objetos

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Guía Programación Orientada A Objetos

Încărcat de

Drepturi de autor:

Formate disponibile

PROGRAMACIÓN ORIENTADA A OBJETOS (072-2103)

Unidad II: Paradigma Orientado a Objetos

Unidad III: Datos Simples

Unidad IV: Estructuras de Control

Unidad V: Datos Compuestos

Unidad VI: Fundamentos Avanzados de Programación

Unidad II: Paradigma orientado a objetos

Unidad III: Datos Simples

Unidad IV: Estructuras de control

Unidad V: Datos compuestos

1.1 Historia de la computación

Es una colección de circuitos integrados y otros componentes relacionados capaz de efectuar

1.1.2 Prehistoria de la computación

Otros dispositivos mecánicos fueron la Pascalina, inventada por el francés Blaise

En el siglo XIX Charles Babbage trabajaba en el proyecto de la “máquina de

Unos 100 años después, concretamente en el año 1944, se construyó en la Universidad

En 1947 se construyó en la Universidad de Pensilvania la ENIAC (Electronic

1.1.3 Generaciones de la computadora

1ª Generación: Tubos de Vacío (1947 – 1958)

2ª Generación: Transistores (1958 – 1964)

3ª Generación: Circuitos Integrados (1964 – 1971)

4ª Generación: Microprocesadores (1971 – 1981)

5ª Generación: Inteligencia Artificial (1981 – 1990)

6ª Generación: Arquitectura Paralelo/Vectorial (1990 – 1999)

7ª Generación: LCD y Dispositivos Inteligentes (1999 – 2011)

8ª Generación: Nuevas Tecnologías (2011 – Presente)

1.2 Lenguajes de programación

Un programa es una secuencia de instrucciones mediante las cuales se ejecutan diferentes

Por su parte, la programación es el proceso de diseñar, escribir, probar, depurar y

Programar no involucra necesariamente otras tareas tales como el análisis y diseño de

Obviamente, para llevar a cabo esta tarea se requiere de un lenguaje de programación,

1.2.1 Tipos de lenguajes

 Lenguaje de Bajo Nivel (Ensamblador): En este lenguaje las instrucciones se escriben

1.2.2 Criterios del lenguaje

Son características interrelacionadas empleadas para considerar si un lenguaje tiene méritos,

 Sintaxis: Es la forma del lenguaje, es decir, una colección de instrucciones formadas al

 Semántica: Describe de manera precisa lo que significa una construcción particular, ya

 Confiabilidad: El programa se considera confiable si se comporta como es anunciado y

 Traducción Rápida: La traducción del código fuente a un lenguaje que la máquina

 Ortogonalidad: Las variables aleatorias se consideran ortogonales si son independientes

 Portabilidad: Cuando el programa puede compilarse y ejecutarse en una plataforma

1.3 Compilación de programas

Un compilador es un programa que permite traducir el código fuente (conjunto de

1.3.1 Tipos de compiladores

1.3.2 Proceso de compilación

Normalmente, la creación de un programa ejecutable conlleva dos pasos:

 Enlazado: Se enlaza el código de bajo nivel generado de todos los ficheros y

1.3.3 Etapas de la compilación

 Fase de Síntesis: Consiste en generar el código objeto equivalente al programa fuente, y

1.3.4 Otras herramientas de programación

 Ensamblador: Traduce un fichero fuente en lenguaje ensamblador (bajo nivel) a código

 Intérprete: Es un programa informático capaz de analizar y ejecutar otros programas. Se

1.4 Paradigmas de programación

Algunos tipos de paradigmas conocidos en la actualidad son:

UNIDAD II: PARADIGMA ORIENTADO A OBJETOS

La programación orientada a objetos ha tomado las mejores ideas de la programación

El término Programación Orientada a Objetos (POO), hoy en día ampliamente

2.1.1 Conceptos dentro de la POO

 Uniformidad: La representación de los objetos implica tanto el análisis como el diseño

2.2 Clases y objetos

La sintaxis básica para definir una clase es la mostrada a continuación:

o <modificador_de_acceso>: Es una palabra reservada que permite restringir el

public void agregar_datos() {