UNIVERSIDAD INDUSTRIAL DE SANTANDER

FACULTAD DE INGENIERIAS FISICO MECANICAS

ESCUELA DE INGENIERIA METALURGICA Y CIENCIA DE MATERIALES

Asignatura: Programación Orientada a Objetos

Unidad: Clases y objetos

VARIABLES, OPERADORES Y EXPRESIONES

Todo lenguaje de programación tiene su propia sintaxis y semántica, es decir la forma

como se escriben las sentencias, cuales son las palabras clave que no podemos utilizar y
que características tienen los identificadores.

SENTENCIAS.

Una sentencia es un comando que lleva a cabo una acción. Las sentencias se encuentran
dentro de los métodos. Las sentencias en C# tienen que observar un conjunto de reglas
que se conocen como sintaxis. Sin embargo, la especificación de lo que hacen Ias
sentencias se conoce en su conjunto como sintaxis.

Una de las reglas sintácticas más sencilla de C# es que todas las sentencias terminan con
punto y coma. Además C# es un lenguaje de "formato libre", lo que significa que los espa-
cios vacíos, como el carácter espacio en blanco o nueva línea, no tienen más significado
que el de actuar como separadores. En otras palabras, se tiene la libertad para presentar
las sentencias con el estilo que se desee.

Para programar bien en cualquier lenguaje es necesario aprender su sintaxis y su

semántica para utilizar el lenguaje de una forma natural y lingüísticamente correcta,
consiguiendo programas legibles y sencillos de modificar.

IDENTIFICADORES

Los identificadores son los nombres que se utilizan para designar los elementos de los
programas, como variables, métodos, etc. En C# es necesario observar las siguientes
reglas de sintaxis a la hora de elegir un identificador:

Sólo se pueden utilizar letras, mayúsculas y minúsculas, y dígitos.

Un identificador tiene que comenzar por una letra. El guión de subrayado se
considera una letra.

Por ejemplo, resultado, marcador, cuarentayDos y plan9 son todos ellos identificadores
válidos, mientras que resultado%, cuarentayDos$ y 9plan no lo son. Se debe tener
igualmente en cuenta que c# es un lenguaje que distingue entre mayúsculas y
minúsculas: cuarentayDos y CuarentayDos son identificadores diferentes.

El lenguaje C# reserva setenta y seis identificadores para uso propio. Dichos

identificadores se conocen como palabras clave y cada una de ellas posee un significado
particular. Las palabras clave se muestran en la tabla siguiente.
abstract as base bool
break byte case catch
char checked class const
continue decimal default delegate
do double else enum
event explicit extern false
finally fixed float for
foreach goto if implicit
in int interface internal
is lock long namespace
new object null operator
out override params private
protected public readonly ref
return sbyte sealed short
sizeof static stackalloc string
struct switch this throw
true try typeof uint
ulong unchecked unsafe ushort
using virtual void while

VARIABLES.

Una variable es un espacio de almacenamiento que contiene un valor. Se pueden

considerar las variables como cajas que contienen información temporal. Toda variable de
un programa debe poseer un nombre único. Se utiliza el nombre de la variable para hacer
referencia al valor que contiene. Y debe tenerse en cuenta:

No utilizar guiones de subrayado.

No crear identificadores que sólo se diferencian en la utilización de mayúsculas y
minúsculas. Por ejemplo, no crear una variable denominada miVariable y otra
denominada MiVariable que se vayan a utilizar al mismo tiempo.

Declaración de variables

C# puede procesar muchos tipos diferentes de valores, números enteros, números en

coma flotante y cadenas de caracteres, por tanto, cuando se declara una variable es
necesario indicar el tipo de los datos que va a contener.

El tipo y el nombre de una variable se declara en una sentencia de declaración. Por

ejemplo, la sentencia siguiente declara que la variable de nombre edad contiene valores
int (enteros); y se incluye el punto y coma:

int edad;

Después de declarar una variable es posible asignarle un valor. La sentencia siguiente

asigna a edad el valor 42.

edad = 42;
Después de esta asignación, se puede utilizar la variable edad en el código para hacer
referencia al valor que contiene. La sentencia siguiente escribe 42 en la consola:

Console. WriteLine(edad);

Tipos de datos primitivos.

C# posee cierto número de tipos de datos incorporados, denominados tipos de datos

primitivos. La tabla siguiente muestra un listado con los tipos de datos primitivos de C#
utilizados habitualmente. Los tipos int y long contienen números enteros, donde long
puede contener números mayores que int, pero necesita más memoria; los tipos float y
double contienen números con puntos decimales, donde double contiene valores con una
precisión doble que float, de ahí su nombre; el tipo decimal se ha diseñado para contener
valores de moneda de hasta 28 cifras significativas; el tipo char contiene caracteres
individuales, en representación Unicode; el tipo string contiene secuencias de caracteres y
el tipo bool contiene true [verdadero) o false ~ falso).

Tipo de Descripción Tamaño Intervalo Ejemplo de uso

datos (bits)
int Números enteros 32 -231 a 231-1 int contador;
contador= 42;
long Números enteros 64 -263 a 263 -1 long espera; espera
(intervalo mayor) =42L;
float Números en coma 32 +3,4 x 1038 float lejos; lejos
flotante =0,42F;
double Números en coma 64 +1,7 x 10308 double problema;
flotante con precisión problema = 0,42;
doble (más exactos)
decimal Valores monetarios 128 28 cifras decimal moneda;
significativas moneda = 0,42M;
string Secuencia de 16 bits No aplicable string chaleco;
caracteres por chaleco = “42";
carácter
char Carácter individual 16 0 a 216 - 1 char parrilla; parrilla
='4';
bool Booleano (verdadero o 8 true (verdadero) o bool dientes; dientes
falso) false (falso) =false;

OPERADORES ARITMETICOS.

C# admite los símbolos aritméticos como operadores ya que "operan" sobre ciertos
valores para crear valores nuevos. Los valores sobre los que actúa un operador se
denominan operandos. En la expresión 500 * 20, el * es el operador y 500 y 20 son los
operandos.

C# también admite un operador aritmético menos familiar: el operador de resto, o módulo,

el cual utiliza el símbolo de porcentaje (%). El resultado de x%y es el resto que resulta
después de dividir x entre y.
PRECEDENCIA DE LOS OPERADORES.

La precedencia es el orden en que se realizan las operaciones de acuerdo a los

operadores, en C#, los operadores multiplicativos (*,/, %) tienen precedencia sobre los
operadores aditivos (+, -). Se pueden utilizar paréntesis para anular la precedencia e
imponer que los operandos se liguen a los operadores que se desee. Por ejemplo, en la
expresión siguiente, los paréntesis hacen que el 2 y el 3 se liguen al operador +, sumando
5, y el resultado de esta suma forma el operando izquierdo del operador * para conseguir
el valor 20 como resultado:

(2 + 3) * 4

Asociatividad es la dirección, izquierda o derecha, en que se unen los operadores de una

expresión, cuando la precedencia de dos operadores es la misma, entonces, los
operandos se evalúan de izquierda a derecha.

SENTENCIAS DE DECISION.

Normalmente los programas necesitan resolver problemas largos y complicados. Para

manejar esa complejidad es necesario tener la posibilidad de escribir métodos que
realicen, de forma selectiva, acciones diferentes en momentos diferentes, en función de
las circunstancias.

En el mundo de la programación todo es blanco o negro, correcto o incorrecto, verdadero

o falso. Por ejemplo, si se crea una variable entera denominada x, se le asigna el valor 99
y, a continuación, se formula la pregunta "¿contiene x el valor 99?", la respuesta será
verdadero. Si se formula la pregunta "¿es x menor que 10?", la respuesta será falso. Esos
son ejemplos de expresiones booleanas. La evaluación de una expresión booleana
siempre es verdadero o falso.

Microsoft Visual C# posee un tipo de datos primitivo denominado bool, que se utiliza para
declarar variables cuyo valor es verdadero o falso. Se puede asignar un valor a una
variable bool utilizando las palabras clave true y false.

Operadores booleanos

Un operador booleano es un operador cuyo resultado es verdadero o falso. C# dispone de

varios operadores booleanos muy útiles. El operador booleano más sencillo es el
operador NO, que utiliza el símbolo !. El operador ! se aplica a un único valor booleano y
devuelve su valor opuesto. En otras palabras, !false es true y !trae es false.

Los operadores que trabajan sobre un único operando se denominan operadores unarios
y los operadores que trabajan sobre dos operandos se denominan operadores binarios.

Operadores de igualdad y de relación

Dos operadores booleanos utilizados con mucha mayor frecuencia son los operadores de
igualdad y de desigualdad. Esos operadores binarios se utilizan para comprobar si dos
valores del mismo tipo son iguales. Muy relacionados con esos dos operadores están los
operadores de relación. Los operadores de relación se utilizan para comprobar si un valor
es menor o mayor que otro valor del mismo tipo. Los símbolos que utiliza C# para los
operadores de igualdad y de relación se muestran en la tabla siguiente.

== Igual a edad == 100 False

!= Distinto de edad != 0 True
< Menor que edad < 21 False
<= Menor o igual que edad <= 18 False
> Mayor que edad > 16 True
>= Mayor o igual que edad >= 30 True

No hay que confundir el operador de igualdad, ==, con el operador de asignación, =. El

código x==y compara x con y, y posee el valor true si los valores son los mismos. El
código x=y asigna a x el valor de y.

Operadores lógicos

C# proporciona también otros dos operadores booleanos: el operador lógico Y, que utiliza
el símbolo &&, y el operador lógico O, que utiliza el símbolo II. El objeto de esos
operadores consiste en combinar expresiones booleanas para formar expresiones más
grandes. Dichos operadores binarios son similares a los operadores de igualdad y de
relación en que su resultado es true o false, pero se diferencian en que los valores sobre
los que operan también deben ser, a su vez, true o false.

El resultado del operador && es true sí y sólo si las dos expresiones booleanas sobre las
que opera lo son. El operador && se utiliza para comprobar si todas las expresiones
booleanas de una combinación son true. El resultado del operador II es verdadero si
cualquiera de las expresiones booleanas sobre las que opera lo es. El operador II se
utiliza para comprobar si alguna expresión de una combinación es verdadera.

Precedencia y asociatividad de operadores

En la tabla siguiente aparece un resumen de la precedencia y asociatividad de todos los

operadores aparecidos hasta el momento. Los operadores de la misma categoría poseen
la misma precedencia. Los operadores de una categoría superior tienen precedencia
sobre los operadores de una categoría inferior.

Categoria Operadores Asociatividad

Primarios ( ) Imposición de Izquierda
precedencia
Unarios ! NO Izquierda
Multiplicativos * Multiplicar Izquierda
/ Dividir
% Resto de división
Aditivos + Suma Izquierda
- Resta
De relación < Menor que Izquierda
<= Menor o igual que
> Mayor que
>= Mayor o igual que
De igualdad == Igual a Izquierda
!= Distinto de
Booleanos && Y lógico Izquierda
 II 0 lógico
De asignación = Derecha

Sentencias if

Una sentencia if se utiliza cuando se desea ejecutar una o más sentencias si el resultado
de una expresión booleana es verdadero. También se puede utilizar una cláusula opcional
else cuando se desea ejecutar una o más sentencias si el resultado de la expresión
booleana es falso.

Sintaxis de la sentencia if

La sintaxis de una sentencia if es la siguiente (if y else son palabras clave):

if (expresionBooleana)
sentencia-1
else
sentencia-2

Si la evaluación de expresionBooleana resulta verdadera, se ejecuta sentencia-1; en caso

contrario, expresionBooleana es falso y se ejecuta sentencia-2. La palabra clave else y
sentencia-2 son opcionales. Si no existe cláusula else no ocurre nada cuando
expresionBooleana es falso.

Cuando se desea ejecutar dos o más sentencias se deben agrupar las sentencias dentro
de un bloque. Un bloque es, sencillamente, una secuencia de sentencias encerradas
entre una llave de apertura y una llave de cierre.

Sentencias if en cascada

Las sentencias if se pueden anidar dentro de otras sentencias if. De esta forma se puede
encadenar una secuencia de expresiones booleanas, que se comprueban una después
de otra hasta que una de ellas resulta verdadera. En el ejemplo siguiente, si el valor de
dia es cero, la primera comprobación resulta verdadera y se asigna Lunes a nombreDia.
Si el valor de dia no es cero, la primera comprobación es falsa y el control pasa a la
cláusula else, donde se ejecuta la segunda sentencia if y se comprueba si el valor de dia
es uno. A la segunda sentencia if se llega solamente si la primera comprobación es falsa.
De forma similar, a la tercera sentencia if sólo se llega si las dos primeras
comprobaciones resultan-falsas.

if (dia == O)
nombreDia = "Lunes";
else if (dia == 1)
nombreDia = "Martes"; else if (día == 2)
nombreDia = "Miércoles"; else if (dia == 3)
nombreDia "Jueves"; else if (dia == 4)
nombreDia "Viernes"; else if (dia == 5)
nombreDia = "Sábado"; else if (día == 6)
nombreDia "Domingo"; else
 nombreDia = "desconocido";

Sentencias switch

Cuando se escribe una sentencia if en cascada, a veces ocurre que todas las sentencias
if tienen un aspecto muy similar; evalúan una expresión idéntica. La única diferencia
estriba en que cada if compara el resultado de la expresión con un valor diferente· Por
ejemplo:

if (día := 0)
nombreDia = "Lunes";
else if (dia == 1)
nombreDia = "Martes"; else if (dia == 2)
nombreDia = "Miércoles"; else ir (día == 3)

else
nombreDia = "desconocido";

En esas situaciones, normalmente es posible volver a escribir las sentencias if en cascada

como una sentencia switch para que el programa sea más eficiente y fácil de leer.

Sintaxis de una sentencia switch

La sintaxis de una sentencia switch es la siguiente (switch, case y default son palabras
clave):
switch (expresionDeControl )
{
case expresionConstante : sentencias break;
case expresionConstante: sentencias break;

default : sentencias break;

)

No se produce ningún error si el valor de la expresión de control no coincide con ninguna

de las etiquetas case en el caso de que no exista una etiqueta default. La ejecución del
programa continúa con la primera sentencia después de la llave de cierre de la sentencia
switch.

Reglas de la sentencia switch

Las sentencias switch resultan muy útiles, pero, desgraciadamente, no es posible
utilizarlas siempre que se desea. Las sentencias switch tienen que cumplir las siguientes
reglas:
· Sólo se puede utilizar switch con tipos de datos primitivos, como int y string. Con
cualquier otro tipo habrá que utilizar una sentencia if.
· Las etiquetas case deben ser expresiones constantes, como 42 o "42". Si es
necesario calcular los valores de las etiquetas case en tiempo de ejecución, habrá que
utilizar una sentencia if.
· Las etiquetas case deben ser expresiones únicas. En otras palabras, no está permitido
escribir dos etiquetas case con el mismo valor.
· Es necesario repetir la sintaxis de la etiqueta case para cada valor individual