Documentos de Académico
Documentos de Profesional
Documentos de Cultura
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
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
2
Programación Orientada a Objetos
3
Programación Orientada a Objetos
UNIDAD I: INTRODUCCIÓN
1.1.1 La computadora
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.
4
Programación Orientada a Objetos
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.
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.
5
Programación Orientada a Objetos
6
Programación Orientada a Objetos
7
Programación Orientada a Objetos
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
Programación Orientada a Objetos
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.
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
Programación Orientada a Objetos
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.
10
Programación Orientada a Objetos
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.
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.
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.
11
Programación Orientada a Objetos
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 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.
Además del compilador, existen otras herramientas de programación con funciones muy
similares, las cuales son:
12
Programación Orientada a Objetos
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.
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
Programación Orientada a Objetos
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
Programación Orientada a Objetos
2.1 Generalidades
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
Programación Orientada a Objetos
2.1.2 Ventajas
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.
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
Programación Orientada a Objetos
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
Programación Orientada a Objetos
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;
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).
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
Programación Orientada a Objetos
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();
class Program {
static void Main(string[] args) {
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
Programación Orientada a Objetos
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.
class Program {
static void Main(string[] args) {
empleado e = new empleado();
e.cargar_datos();
}
}
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
Programación Orientada a Objetos
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.
class empleado {
private string nombre, dpto;
private int edad;
private float salario;
public empleado() {
//Sentencias para construir el objeto
}
}
class Program {
static void Main(string[] args) {
empleado e = new empleado();
e.cargar_datos();
e.mostrar_datos();
}
}
21
Programación Orientada a Objetos
El programa del Ejemplo 5 muestra la misma salida que uno donde se trabaje sólo con el
método Main, así:
class Program {
static void Main(string[] args) {
string nombre, dpto;
int edad;
float salario;
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 {
static void Main(string[] args) {
empleado a = new empleado();
empleado b = new empleado();
empleado c = new empleado();
22
Programación Orientada a Objetos
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.
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
Programación Orientada a Objetos
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.
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
Programación Orientada a Objetos
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");
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);
25
Programación Orientada a Objetos
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
Programación Orientada a Objetos
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.
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:
27
Programación Orientada a Objetos
De acuerdo al ejemplo, se asigna como color de fondo uno de los colores disponibles para
consola (en este caso el azul oscuro).
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;
class Program
{
static void Main(string[] args)
{
// Personalización de la Consola:
Console.BackgroundColor = ConsoleColor.DarkBlue;
Console.ForegroundColor = ConsoleColor.Yellow;
Console.Clear();
28
Programación Orientada a Objetos
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 */
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
Programación Orientada a Objetos
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.
La declaración de una variable se puede realizar en cualquier parte del programa, siempre
y cuando sea antes de su primer uso
30
Programación Orientada a Objetos
No puede ser una palabra reservada del lenguaje (se trata en este caso de un
identificador predefinido que tiene un significado especial).
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
Programación Orientada a Objetos
Cada uno de los tipos de datos básicos se almacena en forma diferente en la memoria
de la computadora:
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;
32
Programación Orientada a Objetos
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
Programación Orientada a Objetos
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
34
Programación Orientada a Objetos
&& 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.
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.
C# proporciona operadores compuestos de asignación, los cuales pueden ser utilizados como
atajos al escribir las declaraciones de asignación.
35
Programación Orientada a Objetos
El operador condicional “?:” retorna uno de dos valores de una expresión booleana. Su
sintaxis es como sigue:
Condición ? instrucción1 : instrucción2;
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.
36
Programación Orientada a Objetos
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
class Program
{
static void Main(string[] args)
{
Operaciones Ope = new Operaciones();
Ope.lector();
Ope.ejemplo();
Console.ReadLine();
}
}
}
37
Programación Orientada a Objetos
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
Programación Orientada a Objetos
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.
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.
39
Programación Orientada a Objetos
Ejemplo 4.1: Escribir un método que tome como entrada la calificación de un alumno y
determinar si aprobó la asignatura.
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.
40
Programación Orientada a Objetos
Ejemplo 4.2: Modificar el método anterior, de tal manera que indique si un alumno aprobó
o reprobó la asignatura.
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
Programación Orientada a Objetos
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.
42
Programación Orientada a Objetos
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.
Entonces, para resolver esto, lo primero que hay que hacer es tabular el código,
quedando como sigue:
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
Programación Orientada a Objetos
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
Console.WriteLine("#####");
Console.WriteLine("$$$$$");
Console.WriteLine("*****");
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
Programación Orientada a Objetos
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)
Console.WriteLine("@@@@@");
else
{
Console.WriteLine("#####");
Console.WriteLine("$$$$$");
}
Console.WriteLine("*****");
}
if(a == 5)
{
if(b == 8)
Console.WriteLine("@@@@@");
else
{
Console.WriteLine("#####");
Console.WriteLine("$$$$$");
Console.WriteLine("*****");
}
}
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
Programación Orientada a Objetos
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.
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
Programación Orientada a Objetos
case x: <instrucción_x>
break;
<alguna_instrucción> // <- Este es un código inalcanzable
case y: <instrucción_y>
break;
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
Programación Orientada a Objetos
…
for(inicio;condición;actualización)
condición_cierta
{
ini; cond; act instrucciones <instrucciones>;
}
final_de_ciclo
…
48
Programación Orientada a Objetos
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.
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
Programación Orientada a Objetos
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 …
Ejemplo 4.8: Modifique el algoritmo anterior para que use la estructura while.
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
Programación Orientada a Objetos
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.
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.
51
Programación Orientada a Objetos
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.
52
Programación Orientada a Objetos
if(cont > 0)
{
double prom = suma/cont;
Console.WriteLine("El promedio es: " + prom);
}
}
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.
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
Programación Orientada a Objetos
Ejemplo 4.12: Modifique el método anterior, para que utilice la sentencia continue cuando
n = 5.
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.
3) Realizar un programa que sume todos los números impares comprendidos entre 1 y 1000.
54
Programación Orientada a Objetos
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:
55
Programación Orientada a Objetos
5.1 Arreglos
(Pendiente)
56