Clases y Objetos en C#

Programación Orientada a Objetos

Unidad 2
Temas
2.1 Declaración de clases: atributos, métodos,
encapsulamiento.
2.2 Instanciación de una clase.
2.3 Referencia al objeto actual.
2.4 Métodos: declaración, mensajes, paso de parámetros,
retorno de valores.
2.5 Constructores y destructores: declaración, uso y
aplicaciones.
2.6 Sobrecarga de métodos.
2.7 Sobrecarga de operadores: Concepto y utilidad,
operadores unarios y binarios.
Declaración de clases: atributos,
métodos, encapsulamiento
¿Qué es una clase?
¿COCHE?

● Para el filósofo…
● Un artefacto de clasificación humana
● Clasificamos según un comportamiento o atributos
comunes
● Acordamos descripciones y nombres de clases útiles
● Creamos vocabulario; nos comunicamos; ¡pensamos!
● Para el programador orientado a objetos…
● Una construcción sintáctica con nombre que describe un
comportamiento y atributos comunes
● Una estructura de datos que incluye datos y funciones
Declarar Clases
El nivel de acceso precede a
la palabra clave class. Las clases se
En este caso, se utiliza public definen mediante
, que significa que cualquiera
puede crear objetos a partir
la palabra clave
de esta clase class

El nombre de la
public class Customer clase sigue a la
palabra clave class
{
//Fields, properties, methods and events go here...

} El resto de la definición es el cuerpo

de clase, donde se definen el
comportamiento y los datos. Los
campos, propiedades, métodos y
eventos de una clase se conocen
colectivamente como miembros de
clase.
Miembros de una clase
● Atributos
Es un dato común a todos los objetos de una determinada clase.

Sintaxis dentro de la zona señalada como <miembros> en la

definición de la misma :

<tipoAtributo> <nombreAtributo>;

int edad;
Miembros de una clase
● Métodos
Es un conjunto de instrucciones a las que se les asocia un
nombre de modo que si se desea ejecutarlas basta
referenciarlas a través de dicho nombre.

<modificador de acceso> <tipoDevuelto> <nombreMetodo> (<parametros>)

{
<instrucciones>
}

public int Contar ( int x)

{
return x++;
}
Ejemplo 1
● Define la clase Persona, con los atributos públicos : nombre
de tipo string, edad de tipo int, nacionalidad de tipo string.
Agrega un método público de tipo void llamado
Cumpleaños que incremente la edad en uno.

public class Persona

{
// declaración de atributos
string nombre, nacionalidad;
int edad;

// métodos
public void Cumpleaños ( )
{
edad ++;
}
}
video
Compilar y crear .exe de aplicación “hola mundo” en
consola

https://www.youtube.com/watch?v=WFBe0K-B2ZI
Instanciación de una clase
¿Qué es un objeto?
● Un objeto es una instancia de una clase
● Los objetos se caracterizan por:
● Identidad: Los objetos se distinguen unos de otros
● Estado: Los objetos contienen información
● Comportamiento: Los objetos pueden realizar tareas
Creación de objetos

● Paso 1: Asignación de memoria

● Los objetos se pueden crear con la palabra clave new
seguida del nombre de la clase en la que se basará el objeto.

Fecha objeto = new Fecha();

 Constructores y destructores:
declaración, uso y aplicaciones
Paso 2: Inicialización del objeto usando un constructor
Uso del constructor por defecto

● Características de un constructor por defecto

● Acceso público
● Mismo nombre que la clase
● No tiene tipo de retorno (ni siquiera void)
● No recibe ningún argumento
● Inicializa todos los campos a cero, false o null
● Sintaxis del constructor

class Fecha
{
public Fecha( ) { ... }
}
Sustitución del constructor por defecto
● El constructor por defecto puede no ser adecuado, en
ese caso no hay que usarlo, sino escribir otro.

class Fecha
{
private int aa, mm, dd;
public Fecha( )
{
aa = 1970;
mm = 1;
dd = 1;
}
}
 Sobrecarga de constructores
● Los constructores son métodos y pueden estar
sobrecargados
● Mismo ámbito, mismo nombre, distintos parámetros
● Permite inicializar objetos de distintas maneras
● AVISO
● Si se escribe un constructor para una clase, el
compilador no creará un constructor por defecto

class Fecha
{
public Fecha( ) { ... }
public Fecha(int año, int mes, int dia) { ... }
...
}
Propiedades
Las propiedades son miembros que ofrecen un mecanismo
flexible para leer, escribir o calcular los valores de campos
privados.

Se pueden utilizar las propiedades como si fuesen miembros de

datos públicos, aunque en realidad son métodos especiales
denominados descriptores de acceso.

De este modo, se puede tener acceso a los datos con facilidad, a

la vez que proporciona la seguridad y flexibilidad de los métodos.
Información general sobre propiedades
● Las propiedades permiten que una clase exponga una
manera pública de obtener y establecer valores, ocultando el
código de implementación o comprobación.

● El descriptor de acceso de una propiedad get se utiliza para

devolver el valor de la propiedad y el descriptor de acceso
set se utiliza para asignar un nuevo valor.

● La palabra clave value se utiliza para definir el valor asignado

por el indizador set.

● Las propiedades que no implementan un método set son de

sólo lectura.
 get set
Recupera el valor de la Establece el valor de la
propiedad o el elemento propiedad o el elemento
del indizador. del indizador.

class TimePeriod
{
private double _seconds;

public double Seconds

{
get { return _seconds; }
set { _seconds = value; }
}
}
Ejemplo 2

Se muestra una clase Person con dos

propiedades: Name (cadena) y Age (entero).

Ambas propiedades proporcionan

descriptores de acceso get y set, por lo que
se consideran propiedades de lectura y
escritura.
C#

public class Person public class TestPerson

{ {
private string m_name = "N/A"; public static void Main()
private int m_Age = 0; {
// Create a new Person object:
// Declare a Name property of type string: Person person = new Person();
public string Name
{ // Print out the name and the age associated
get { return m_name; } // with the person:
set { m_name = value; } Console.WriteLine("Person details - {0}", person);
}
// Set some values on the person object:
// Declare an Age property of type int: person.Name = "Joe";
public int Age person.Age = 99;
{ Console.WriteLine("Person details - {0}", person);
get { return m_Age; }
// Increment the Age property:
set { m_Age = value; }
person.Age += 1;
}
Console.WriteLine("Person details - {0}", person);
}
public override string ToString()
}
{
return "Name = " + Name + ", Age = " + Age;
}
}
-- Resultados --
Person details - Name = N/A, Age = 0
Person details - Name = Joe, Age = 99
Person details - Name = Joe, Age = 100
Referencia al objeto actual
Uso de la palabra reservada this
● La palabra reservada this apunta al objeto usado para
la llamada al método
● Es útil en caso de conflicto entre identificadores de distintos
ámbitos

class CuentaBancaria
{
private string nombre;
public void AsignarNombre(string nombre)
{ Si esta instrucción fuera
nombre = nombre;
this.nombre = nombre;
¿qué ocurriría?
}

}
Métodos: declaración, mensajes, paso de
parámetros, retorno de valores
Método
● Un método es un conjunto de instrucciones a las que se les
da un determinado nombre de tal manera que sea posible
ejecutarlas en cualquier momento sin tenerlas que reescribir
sino usando sólo su nombre.
● A estas instrucciones se les denomina cuerpo del método, y
a su ejecución a través de su nombre se le denomina
llamada al método.
● El uso de métodos mantiene el código legible porque las
instrucciones se colocan en bloques mas pequeños, en lugar
de en un gran bloque de código. Los métodos también
permiten tomar instrucciones que pueden ser ejecutadas
varias veces y colocarlas en un bloque de código que puede
ser llamado todas las veces que haga falta.

25
Método

● La ejecución de las instrucciones de un método puede producir

como resultado un objeto de cualquier tipo. A este objeto se le
llama valor de retorno del método y es completamente opcional,
pudiéndose escribir métodos que no devuelvan ninguno.

● La ejecución de las instrucciones de un método puede depender

del valor de unas variables especiales denominadas parámetros
del método, de manera que en función del valor que se dé a estas
variables en cada llamada la ejecución del método se pueda
realizar de una u otra forma y podrá producir uno u otro valor de
retorno.

26
Estructura de un método
● En <tipoRetorno> se indica cuál es el tipo
de dato del objeto que el método
devuelve, y si no devuelve ninguno se ha
de escribir void en su lugar. ● Aunque es posible escribir métodos que no
tomen parámetros, si un método los toma se
ha de indicar en <parámetros> cuál es el
● Como nombre del método se puede nombre y tipo de cada uno, separándolos con
poner en <nombreMétodo> cualquier comas si son más de uno.
identificador válido.
● El <cuerpo> del método es el bloque de
instrucciones que compone el código del
método. El cuerpo del método esta entre
llaves. Si el método retorna algún tipo de
objeto entonces ha de incluir al menos una
instrucción return que indique cuál objeto
regresa.

sintaxis:
<tipoRetorno> <nombreMétodo> (<parámetros>)
{
<cuerpo>
}

27
Ejemplo 3
Definir un método de nombre Saluda cuyo cuerpo consista
en escribir en la consola el mensaje “Hola Mundo” y que
devuelva un objeto int de valor 1:

Nombre del
Tipo Lista de
método
devuelto parámetros

int Saluda( )
{
Console.WriteLine(“Hola Mundo”);
Cuerpo del
método return 1;
}

28
Llamada a métodos
● Para llamar a un método, se escribe su nombre en el lugar
donde debería ejecutarse el código de ese método. Después
del nombre del método se escriben dos paréntesis, la
instrucción de la llamada al método debe terminar con
punto y coma.

● Si el método se define con una lista de parámetros, sus

valores deben ser especificados en el momento de llamar al
método. Debe especificar los parámetros en el mismo orden
en que son especificados en la lista de parámetros del
método.

29
Llamada a métodos
● Una vez definido el método, se puede:

1. Llamar a un método desde dentro de la misma clase.

Se usa el nombre del método seguido de una lista de parámetros
entre paréntesis.

2. Llamar a un método que está en una clase diferente

Hay que indicar al compilador cuál es la clase que contiene el método
que se desea llamar. El método llamado se debe declarar con la palabra
reservada public.

3. Usar llamadas anidadas

Unos métodos pueden hacer llamadas a otros, que a su vez pueden
llamar a otros métodos, y así sucesivamente.

30
Llamar a un método desde dentro de la misma clase.
using System;
class ExampleClass
{
static void ExampleMethod( )
{
Console.WriteLine("Hola, mundo");
}

static void Main( )

{
Console.WriteLine("Comienza el programa.");
ExampleMethod( );
Console.WriteLine("Termina el programa.");
}
}

31
Llamadas a métodos desde otras clases
using System;
class A
{
public static void TestMethod( )
{
Console.WriteLine("Esto es TestMethod en clase A");
}
}
class B
{
static void Main( )
{
A.TestMethod ( );
}
}

32
Llamadas anidadas a métodos
using System;
class NextExample
{
static void Method1( )
{ Console.WriteLine("Method1"); }

static void Method2( )

{
Method1( );
Console.WriteLine("Method2");
Method1( );
}

static void Main( )

{
Method2( );
Method1( );
}
}

33
Uso de variables locales
● Variables locales
● Se crean cuando comienza el método
● Son privadas para el método
● Se destruyen a la salida

● Variables compartidas
● Para compartir se utilizan variables de clase

● Conflictos de ámbito
● El compilador no avisa si hay conflictos entre nombres
locales y de clase

34
Uso de la instrucción return
● return inmediato
● return con una instrucción condicional

static void ExampleMethod( )

{
int numBeans;
//...

Console.WriteLine("Hello");
if (numBeans < 10)
return;
Console.WriteLine("World");
}

35
Uso de la instrucción return
Devolución de valores
● El método se debe declarar con un tipo que no sea
void
● Se añade una instrucción return con una expresión
● Fija el valor de retorno
● Se devuelve al llamador
● Los métodos que no son void deben devolver un valor

static int DosMasDos( ) {

int a,b; int x;
a = 2; x = DosMasDos( );
b = 2; Console.WriteLine(x);
return a + b;
}
36
Mecanismos de paso de parámetros

● Parámetros de valores
● Parámetros de referencias
● Parámetros de salida
● Matrices de parámetros
Declaración y llamadas a parámetros

● Declaración de parámetros
● Se ponen entre paréntesis después del nombre del
método
● Se definen el tipo y el nombre de cada parámetro
● Llamadas a métodos con parámetros
● Un valor para cada parámetro

static void MetodoConParametros(int n, string y)

{ ... }

MetodoConParametros(2, "Hola, mundo");

38
Parámetros de valores
Se utilizan para el paso "hacia dentro" de parámetros,
que consiste en pasar a un método los valores de un
argumento sin que las modificaciones del parámetro
afecten al argumento original.
Un parámetro de valores hace referencia a su propia
variable, que es exclusiva de la variable del argumento
correspondiente.
Para inicializar esta variable se copia el valor del
argumento correspondiente.

39
 Paso por valor
● Mecanismo predeterminado para el paso de parámetros:
● Se copia el valor del parámetro
● Se puede cambiar la variable dentro del método
● No afecta al valor fuera del método
● El parámetro debe ser de un tipo igual o compatible

static void SumaUno(int x)

{
x++; // Incrementar x
}
static void Main( )
{
int k = 6;
SumaUno(k);
Console.WriteLine(k);
}
// Muestra el valor 6, no 7
40
Ejemplo 4
using System;
class Test {
static void F(int p) {
Console.WriteLine("p = {0}", p);
p++;
}
static void Main() {
int a = 1;
Console.WriteLine("pre: a = {0}", a);
F(a);
Console.WriteLine("post: a = {0}", a);
}
}
resultado:
pre: a = 1
p=1
post: a = 1
41
Parámetro de referencias
Se utiliza cuando el parámetro se pasa "por referencia", es
decir, cuando actúa como alias de un argumento
suministrado por el llamador.
Un parámetro de referencias no define una variable por sí
mismo, sino que hace referencia a la variable del argumento
correspondiente.
Las modificaciones de un parámetro de referencia afectan al
argumento correspondiente. Un parámetro de referencias se
declara con un modificador ref.

42
Paso por referencia
● ¿Qué son los parámetros referencia?
● Una referencia a una posición de memoria

● Uso de parámetros referencia

● Se usa la palabra clave ref en la declaración y las llamadas al
método
● Los tipos y valores de variables deben coincidir
● Los cambios hechos en el método afectan al llamador
● Hay que asignar un valor al parámetro antes de la llamada al
método

43
 Ejemplo 5
using System;
class Test {
static void Swap(ref int a, ref int b) {
int t = a;
a = b;
b = t;
resultado:
}
pre: x = 1, y = 2
static void Main() { post: x = 2, y = 1
int x = 1;
int y = 2;
Console.WriteLine("pre: x = {0}, y = {1}", x, y);
Swap(ref x, ref y);
Console.WriteLine("post: x = {0}, y = {1}", x, y);
}
}

44
Parámetro de salida

Es similar a un parámetro de referencias, excepto en

que el valor inicial del argumento suministrado por el
llamador no es importante.

Un parámetro de salida se declara con un

modificador out.

45
Parámetros de salida
● ¿Qué son los parámetros de salida?
● Pasan valores hacia fuera, pero no hacia dentro
● Uso de parámetros de salida
● Como ref, pero no se pasan valores al método
● Se usa la palabra clave out en la declaración y las
llamadas al método

static void OutDemo(out int p)

{
// ...
}
static void Main()
{
int n;
OutDemo(out n);
}

46
Ejemplo 6
using System;
class Test
{
static void Divide(int a, int b, out int result,out int remainder)
{
result = a / b;
remainder = a % b;
}
static void Main()
{
for (int i = 1; i < 10; i++)
for (int j = 1; j < 10; j++)
{
int ans, r;
Divide(i, j, out ans, out r);
Console.WriteLine("{0} / {1} = {2}r{3}", i, j, ans, r);
}
}
}

47
Matriz de parámetros

Se declara con un modificador params. Para un

método dado, sólo puede existir una matriz de
parámetros, que debe ser siempre el último
parámetro especificado. El tipo de una matriz de
parámetros siempre es un tipo de matriz de una sola
dimensión.
Un llamador puede pasar un solo argumento de este
tipo de matriz o cualquier número de argumentos del
tipo de elemento de este tipo de matriz.

48
Uso de listas de parámetros de longitud
variable
● Se usa la palabra clave params
● Se declara como tabla al final de la lista de
parámetros
● Siempre paso por valor

static long AddList(params long[ ] v)

{
long total, i;
for (i = 0, total = 0; i < v.Length; i++)
total += v[i];
return total;
}
static void Main( )
{
long x = AddList(63,21,84);
}
49
 Ejemplo 7

using System;
class Test
{ Resultado:
static void F(params int[] args) { # of arguments: 0
Console.WriteLine("# of arguments:{0}", # of arguments: 1
args.Length); args[0] = 1
for (int i = 0; i < args.Length; i++) # of arguments: 2
{ Console.WriteLine("\targs[{0}] = {1}", i, args[0] = 1
args[i]); } args[1] = 2
static void Main() # of arguments: 3
{ F(); args[0] = 1
F(1); args[1] = 2
F(1, 2); args[2] = 3
F(1, 2, 3); # of arguments: 4
F(new int[] {1, 2, 3, 4}); args[0] = 1
} args[1] = 2
args[2] = 3
}
args[3] = 4

50
Normas para el paso de parámetros

● Mecanismos
● El paso por valor es el más habitual
● El valor de retorno del método es útil para un solo valor
● ref y/o out son útiles para más de un valor de retorno
● ref sólo se usa si los datos se pasan en ambos sentidos
● Eficiencia
● El paso por valor suele ser el más eficaz

51
Sobrecarga de métodos
Uso de métodos sobrecargados

● Al conjunto formado por el nombre de un método y el

número y tipo de sus parámetros se le conoce como
signatura del método. La signatura de un método es lo
que verdaderamente lo identifica, de modo que es
posible definir en un mismo tipo varios métodos con
idéntico nombre siempre y cuando tengan distintos
parámetros. Cuando esto ocurre se dice que el método
que tiene ese nombre está sobrecargado.

53
Declaración de métodos sobrecargados
● Métodos que comparten un nombre en una clase
● Se distinguen examinando la lista de parámetros

class EjemplodeSobrecargado
{
static int Suma(int a, int b)
{
return a + b;
}
static int Suma(int a, int b, int c)
{
return a + b + c;
}
static void Main( )
{
Console.WriteLine(Suma(1,2) + Suma(1,2,3));
}
}

54
Signaturas de métodos
● Las signaturas de métodos deben ser únicas
dentro de una clase
● Definición de signatura

Forman la definición No afectan a la

de la signatura signatura

■ Nombre de
■ Nombre del parámetro
método ■ Tipo de retorno de
■ Tipo de parámetro método
■ Modificador
55
Uso de métodos sobrecargados
● Conviene usar métodos sobrecargados si:
● Hay métodos similares que requieren parámetros diferentes
● Se quiere añadir funcionalidad al código existente

● No hay que abusar, ya que:

● Son difíciles de depurar
● Son difíciles de mantener

56