26 - 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.
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 depositada.
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 System.Collections.Generic;
using System.Linq;
using System.Text;
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()
{
Console.WriteLine(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()
{
cliente1.Depositar(100);
cliente2.Depositar(150);
cliente3.Depositar(200);
cliente3.Extraer(150);
}
public void DepositosTotales()
{
int t = cliente1.RetornarMonto () +
cliente2.RetornarMonto () +
cliente3.RetornarMonto ();
Console.WriteLine ("El total de dinero en el banco es:" + t);
cliente1.Imprimir();
cliente2.Imprimir();
cliente3.Imprimir();
}
static void Main(string[] args)
{
Banco banco1 = new Banco();
banco1.Operar();
banco1.DepositosTotales();
Console.ReadKey();
}
}
}
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()
{
Console.WriteLine(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()
{
cliente1.Depositar(100);
cliente2.Depositar(150);
cliente3.Depositar(200);
cliente3.Extraer(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 = cliente1.RetornarMonto () +
cliente2.RetornarMonto () +
cliente3.RetornarMonto ();
Console.WriteLine ("El total de dinero en el banco es:" + t);
cliente1.Imprimir();
cliente2.Imprimir();
cliente3.Imprimir();
}
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();
banco1.Operar();
banco1.DepositosTotales();
Console.ReadKey();
}
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.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Colaboracion2
{
class Dado
{
private int valor;
private static Random aleatorio;
public Dado()
{
aleatorio = new Random();
}
public void Tirar()
{
valor = aleatorio.Next(1, 7);
}
public void Imprimir()
{
Console.WriteLine("El valor del dado es:"+valor);
}
public int RetornarValor()
{
return valor;
}
}
class JuegoDeDados
{
private Dado dado1,dado2,dado3;
public JuegoDeDados()
{
dado1=new Dado();
dado2=new Dado();
dado3=new Dado();
}
public void Jugar()
{
dado1.Tirar();
dado1.Imprimir();
dado2.Tirar();
dado2.Imprimir();
dado3.Tirar();
dado3.Imprimir();
if (dado1.RetornarValor()==dado2.RetornarValor() &&
dado1.RetornarValor()==dado3.RetornarValor())
{
Console.WriteLine("Ganó");
}
else
{
Console.WriteLine("Perdió");
}
Console.ReadKey();
}
static void Main(string[] args)
{
JuegoDeDados j = new JuegoDeDados();
j.Jugar();
}
}
}
La clase Dado define el atributo "valor" donde almacenamos un valor aleatorio que representa el número que sale al tirarlo.
Definimos otro atributo de la clase Random. Esta clase nos facilita la generación de un número aleatorio que nos indicará el valor del dato. Como luego se crearán tres objetos de la clase dado y nosotros solo requerimos un objeto de la clase Random luego definimos el atributo de tipo static, con esto todos los objetos de la clase Dado acceden al mismo objeto de la clase Random:
private int valor;
private static Random aleatorio;
En el constructor creamos el objeto de la clase Random:
public Dado()
{
aleatorio = new Random();
}
El método Tirar almacena el valor aleatorio (para generar un valor aleatorio utilizamos el método Next de la clase Random, el mismo genera un valor entero comprendido entre los dos parámetros que le pasamos (nunca genera la cota superior):
public void Tirar()
{
valor = aleatorio.Next(1, 7);
}
El método Imprimir de la clase Dado muestra por pantalla el valor del dado:
public void Imprimir()
{
Console.WriteLine("El valor del dado es:"+valor);
}
Por último el método que retorna el valor del dado (se utiliza en la otra clase para ver si los tres dados generaron el mismo valor):
public int RetornarValor()
{
return valor;
}
La clase JuegoDeDatos define tres atributos de la clase Dado (con esto decimos que la clase Dado colabora con la clase JuegoDeDados):
class JuegoDeDados
{
private Dado dado1,dado2,dado3;
En el constructor procedemos a crear los tres objetos de la clase Dado:
public JuegoDeDados()
{
dado1=new Dado();
dado2=new Dado();
dado3=new Dado();
}
En el método Jugar llamamos al método Tirar de cada dado, pedimos que se imprima el valor generado y finalmente procedemos a verificar si se ganó o no:
public void Jugar()
{
dado1.Tirar();
dado1.Imprimir();
dado2.Tirar();
dado2.Imprimir();
dado3.Tirar();
dado3.Imprimir();
if (dado1.RetornarValor()==dado2.RetornarValor() &&
dado1.RetornarValor()==dado3.RetornarValor())
{
Console.WriteLine("Ganó");
}
else
{
Console.WriteLine("Perdió");
}
Console.ReadKey();
}
En la Main creamos solo un objeto de la clase principal (en este caso la clase principal es el JuegoDeDados):
static void Main(string[] args)
{
JuegoDeDados j = new JuegoDeDados();
j.Jugar();
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Colaboracion3
{
class Socio
{
private string nombre;
private int antiguedad;
public Socio()
{
Console.Write("Ingrese el nombre del socio:");
nombre = Console.ReadLine(); ;
Console.Write("Ingrese la antiguedad:");
string linea = Console.ReadLine();
antiguedad=int.Parse(linea);
}
public void Imprimir()
{
Console.WriteLine(nombre+" tiene una antiguedad de "+antiguedad);
}
public int RetornarAntiguedad()
{
return antiguedad;
}
}
class Club
{
private Socio socio1, socio2, socio3;
public Club()
{
socio1=new Socio();
socio2=new Socio();
socio3=new Socio();
}
public void MayorAntiguedad()
{
Console.Write("Socio con mayor antiguedad:");
if (socio1.RetornarAntiguedad() > socio2.RetornarAntiguedad() &&
socio1.RetornarAntiguedad() > socio3.RetornarAntiguedad())
{
socio1.Imprimir();
}
else
{
if (socio2.RetornarAntiguedad() > socio3.RetornarAntiguedad())
{
socio2.Imprimir();
}
else
{
socio3.Imprimir();
}
}
}
static void Main(string[] args)
{
Club club1 = new Club();
club1.MayorAntiguedad();
Console.ReadKey();
}
}
}