CONSTRUCTOR
Cada vez que se crea una clase o estructura, se llama a su constructor. Una clase o estructura
puede tener varios constructores que toman argumentos diferentes. Los constructores
permiten al programador establecer valores predeterminados, limitar la creación de instancias
y escribir código flexible y fácil de leer.
En C# podemos definir un método que se ejecute inicialmente y en forma automática. Este
método se lo llama constructor.
El constructor tiene las siguientes características:
Tiene el mismo nombre de la clase.
Es el primer método que se ejecuta.
Se ejecuta en forma automática.
No puede retornar datos.
Se ejecuta una única vez.
Un constructor tiene por objetivo inicializar atributos.
Sintaxis de un Constructor en C#
Modificador NombredelaClase (Parámetros)
{
Instrucciones
}
Constructor de la clase
En C# podemos definir un método que se ejecute inicialmente y en forma
automática. Este método se lo llama constructor.
El constructor tiene las siguientes características:
Tiene el mismo nombre de la clase.
Es el primer método que se ejecuta.
Se ejecuta en forma automática.
No puede retornar datos.
Se ejecuta una única vez.
Un constructor tiene por objetivo inicializar atributos.
Se desea guardar los sueldos de 5 operarios en un vector. Realizar la creación y carga del
vector en el constructor.
using System;
using [Link];
using [Link];
using [Link];
using [Link];
namespace PruebaConstructor1
{
class Operarios // propiedades de la clase
{
private int[] sueldos;
public Operarios() // construimos el constructor inicializa los atr ibutos
{
sueldos=new int[5];
for(int f = 0; f < [Link]; f++)
{
[Link]("Ingrese el sueldo:");
string linea = [Link]();
sueldos[f]=[Link](linea);
}
}
public void Imprimir()
{
for(int f = 0; f < [Link]; f++)
{
[Link](sueldos[f]);
}
[Link]();
}
static void Main(string[] args)
{
Operarios op = new Operarios(); // se esta ejecutando el constructor
[Link]();
}
}
}
**
Como podemos ver es el mismo problema que resolvimos cuando vimos vectores.
La diferencia es que hemos sustituido el método Cargar con el constructor:
public Operarios()
{
sueldos=new int[5];
for(int f = 0; f < [Link]; f++)
{
[Link]("Ingrese el sueldo:");
string linea = [Link]();
sueldos[f]=[Link](linea);
}
}
Como la clase se llama Operarios el constructor tiene el mismo nombre, no
disponemos la palabra clave void ya que el constructor no puede retornar datos.
La ventaja de plantear un constructor en lugar de definir un método con cualquier
nombre es que se llamará en forma automática cuando se crea un objeto de esta
clase:
Operarios op = new Operarios();
Cuando se crea el objeto op se llama al método constructor.
Finalmente llamamos al método imprimir:
[Link]();
otro ejmplo
Veamos un Ejemplo de un constructor en C#
using System;
namespace constructores
{
class EjConstructor
{
int a;
int b;
//declaramos el constructor
public EjConstructor(int x, int y)
{
a = x;
b = y;
}
public int Suma()
{
return a + b;
}
public int resta()
{
return a - b;
}
//class Principal
{
static void Main(string[] args)
{
//creamos objeto de la clase y le pasamos los parametros al
constructor
EjConstructor obj = new EjConstructor(10, 20);
[Link]("La suma es: "+[Link]());
[Link]("La resta es: "+[Link]());
[Link]();
}
}
}
}
[Link]
Problema 2:
Plantear una clase llamada Alumno y definir como atributos su nombre y su edad.
En el constructor realizar la carga de datos. Definir otros dos métodos para
imprimir los datos ingresados y un mensaje si es mayor o no de edad (edad >=18)
1. Confeccionar una clase que represente un empleado. Definir como atributos
su nombre y su sueldo. En el constructor cargar los atributos y luego en otro
método imprimir sus datos y por último uno que imprima un mensaje si
debe pagar impuestos (si el sueldo supera a 3000)
2. Implementar la clase operaciones. Se deben cargar dos valores enteros en
el constructor, calcular su suma, resta, multiplicación y división, cada una
en un método, imprimir dichos resultados.
3. Plantee un problema y soluciónelo.
Colaboración de clases
Normalmente un problema resuelto con la metodología de programación orientada
a objetos no interviene una sola clase, sino que hay muchas clases que
interactúan y se comunican.
Plantearemos un problema separando las actividades en dos clases.
Problema 1:
Un banco tiene 3 clientes que pueden hacer depósitos y extracciones. También el
banco requiere que al final del día calcule la cantidad de dinero que hay
depositado.
Lo primero que hacemos es identificar las clases:
Podemos identificar la clase Cliente y la clase Banco.
Luego debemos definir los atributos y los métodos de cada clase:
Cliente
atributos
nombre
monto
métodos
constructor
Depositar
Extraer
RetornarMonto
Banco
atributos
3 Cliente (3 objetos de la clase Cliente)
métodos
constructor
Operar
DepositosTotales
Creamos un proyecto llamado: Colaboracion1 y dentro del proyecto creamos dos
clases llamadas: Cliente y Banco.
using System;
using [Link];
using [Link];
using [Link];
using [Link];
namespace Colaboracion1
{
class Cliente
{
private string nombre;
private int monto;
public Cliente(string nom)
{
nombre = nom;
monto = 0;
}
public void Depositar(int m)
{
monto = monto + m;
}
public void Extraer(int m)
{
monto = monto - m;
}
public int RetornarMonto()
{
return monto;
}
public void Imprimir()
{
[Link](nombre+" tiene depositado la suma de "+monto);
}
}
class Banco
{
private Cliente cliente1, cliente2, cliente3;
public Banco()
{
cliente1=new Cliente("Juan");
cliente2=new Cliente("Ana");
cliente3=new Cliente("Pedro");
}
public void Operar()
{
[Link](100);
[Link](150);
[Link](200);
[Link](150);
}
public void DepositosTotales()
{
int t = [Link] () +
[Link] () +
[Link] ();
[Link] ("El total de dinero en el banco es:" + t);
[Link]();
[Link]();
[Link]();
}
static void Main(string[] args)
{
Banco banco1 = new Banco();
[Link]();
[Link]();
[Link]();
}
}
}
**
Analicemos la implementación del problema.
Los atributos de una clase normalmente son privados para que no se tenga
acceso directamente desde otra clase, los atributos son modificados por los
métodos de la misma clase:
private string nombre;
private int monto;
El constructor recibe como parámetro el nombre del cliente y lo almacena en el
atributo respectivo e inicializa el atributo monto en cero:
public Cliente(string nom)
{
nombre = nom;
monto = 0;
}
Los métodos Depositar y Extraer actualizan el atributo monto con el dinero que
llega como parámetro (para simplificar el problema no hemos validado que cuando
se extrae dinero el atributo monto quede con un valor negativo):
public void Depositar(int m)
{
monto = monto + m;
}
public void Extraer(int m)
{
monto = monto - m;
}
El método RetornarMonto tiene por objetivo comunicar al Banco la cantidad de
dinero que tiene el cliente (recordemos que como el atributo monto es privado de
la clase, debemos tener un método que lo retorne):
public int RetornarMonto()
{
return monto;
}
Por último el método imprimir muestra nombre y el monto de dinero del cliente:
public void Imprimir()
{
[Link](nombre+" tiene depositado la
suma de "+monto);
}
Como podemos observar la clase Cliente no tiene función Main. Entonces donde
definimos objetos de la clase Cliente?
La respuesta a esta pregunta es que en la clase Banco definimos tres objetos de
la clase Cliente.
Veamos ahora la clase Banco que requiere la colaboración de la clase Cliente.
Primero definimos tres atributos de tipo Cliente:
class Banco
{
private Cliente cliente1, cliente2, cliente3;
En le constructor creamos los tres objetos (cada vez que creamos un objeto de la
clase Cliente debemos pasar a su constructor el nombre del cliente, recordemos
que su monto de depósito se inicializa con cero):
public Banco()
{
cliente1=new Cliente("Juan");
cliente2=new Cliente("Ana");
cliente3=new Cliente("Pedro");
}
El método operar del banco (llamamos a los métodos Depositar y Extraer de los
clientes):
public void Operar()
{
[Link](100);
[Link](150);
[Link](200);
[Link](150);
}
El método DepositosTotales obtiene el monto depositado de cada uno de los tres
clientes, procede a mostrarlos y llama al método imprimir de cada cliente para
poder mostrar el nombre y depósito:
public void DepositosTotales()
{
int t = [Link] () +
[Link] () +
[Link] ();
[Link] ("El total de dinero en el
banco es:" + t);
[Link]();
[Link]();
[Link]();
}
Por último en la Main definimos un objeto de la clase Banco (la clase Banco es la
clase principal en nuestro problema):
static void Main(string[] args)
{
Banco banco1 = new Banco();
[Link]();
[Link]();
[Link]();
}
Problema 2:
Plantear un programa que permita jugar a los dados. Las reglas de juego son: se
tiran tres dados si los tres salen con el mismo valor mostrar un mensaje que
"gano", sino "perdió".
Lo primero que hacemos es identificar las clases:
Podemos identificar la clase Dado y la clase JuegoDeDados.
Luego los atributos y los métodos de cada clase:
Dado
atributos
valor
métodos
constructor
Tirar
Imprimir
RetornarValor
JuegoDeDados
atributos
3 Dado (3 objetos de la clase Dado)
métodos
constructor
Jugar
Creamos un proyecto llamado: Colaboracion2 y dentro del proyecto creamos dos
clases llamadas: Dado y JuegoDeDados.
