2 replies to this topic

[Delphius]

Hola,
Ahora voy a tocar otro concepto: la sobrecarga de métodos, o comunmente conocido como overload (inglés).

Concepto
¿Se han preguntado si es posible tener dos o más funciones o procedimientos de igual nombre que hagan algo similar?
La respuesta es SI. Se puede, y todo gracias a la sobrecarga de métodos.

La sobrecarga nos permite emplear dos o más métodos con el mismo nombre. Lo que los hace diferente a cada uno es el/los tipo/s y/o la cantida de parámetros.

El requisito para que esto funcione es que se incluya la cláusula overload al final de la declaración de los mismos.

Caso Práctico
Deseamos calcular la suma de números, por un lado reales y por el otro de enteros. No se nos ocurren nombres originales para cada una por tanto los sobrecargamos:

delphi

type
  Toperacion = class(TObject)
  public
    function Suma(A,B: integer): integer; overload;
    function Suma(A,B: double): double; overload;
  end;
 
implementation
 
function TOperacion.Suma(A,B: integer): integer;
begin
  result := A + B;
end;
 
function TOperacion.Suma(A,B: double): double;
begin
  result := A + B;
end;

Como se vé, El nombre es el mismo, tienen igual cantidad de parámetros pero sus tipos son diferentes.
Esta técnica es incluso aplicable fuera de las clases. Es decir que podemos declarar funciones y procedimientos "sueltos" en una unit y aplicar la sobrecarga.

¿Cómo es que funciona?
En tiempo de ejecución, el compilador interpreta los tipos y cantidades de parámetros que posee y aplica el algoritmo adecuado. En tiempo de diseño no se aplica esta técnica.

¿Cúando es conveniente esta técnica?
Puede ser utilizada, y se la recomienda, cuando se necesita aplicar diversos algoritmos que en definitiva necesita dar soporte a una misma funcionalidad.

Vamos a dar un ejemplo un tantito más complejo, pero que ilustra enormemente este técnica.
Por ejemplo, en los casos de TMamifero, TPerro, de los manuales anteriores, podríanos sernos útil un método Cazar(). Pero como somos un tanto "exquisitos" podemos interpretar a Cazar() en los siguientes contextos:
1. Caza una presa en particular.
2. Escojer una presa, dada una posición determinada del mapa.
3. Que escoja una presa al azar.

Entonces necesitamos sobrecargar el método tres veces:

delphi

TMamifero = class(TObject)
  public
    // Otros métodos interesantes
    function MatarPresa(Presa: TMamifero): boolean;
    function PresaEnMapa(X,Y: integer; var Presa: TMamifero): boolean;
 
    // métodos de caza
    function Cazar(Presa: TMamifero): boolean; overload;
    function Cazar(X,Y: integer): boolean; overload;
    function Cazar: boolean; overload;
  end;

Las implementaciones de cada uno podrían ser como las siguientes:

delphi

// cazar a una presa específica
function TMamifero.Cazar(Presa: TMamifero): boolean;
var Puede: boolean;
begin
  result := MatarPresa(Presa);
end;
 
// cazar a la presa ubicada en X,Y
function TMamifero.Cazar(X, Y: integer): boolean;
var Puede: boolean;
    Presa: TMamifero;
begin
  Puede := PresaEnMapa(X,Y,Presa);
  if Puede
     then result := MatarPresa(Presa)
     else result := False;
end;
 
// cazar al azar
function TMamifero.Cazar: boolean;
var X,Y, intentos: integer;
    Presa: TMamifero;
    Puede: boolean;
begin
  Puede := False;
  intentos := 0;
  // repetir busqueda al azar hasta encontrar una o se nos terminen
  // los intentos.
  repeat
    Puede := PresaEnMapa(Random(200),Random(200),Presa);
    inc(intentos);
  until (Puede = True) OR (intentos > 50);
 
  if Puede
     then result := MatarPresa(Presa)
     else result := False;
end;

Como puede verse, en todos los Cazar() se llama a un método en común: MatarPresa(). La particularidad que nos ofrece la sobrecarga es de aplicar MatarPresa() en diferentes contextos. De este modo nos evitamos estar inventando nombres rebuscados para cada método: CazarAPresa, CazarEnMapa, CazarAlAzar.

La implementación de MatarPresa puede encargarse de verificar algunas cuestiones técnicas. Por ejemplo:
1. Determinar si la presa es "fácil".
2. Ver si el parámetro Presa es válido (un objeto válido, creado: existe en memoria).
3. Etc

PresaEnMapa, lleva otro algoritmo y su función es la de comprobar de si en la posición X,Y hay una presa. Si la hay, queda en el parámetro Presa la referencia a dicha Presa.

Saludos,

[Delphius]

Para completar la idea, unos ejemplos de como se lo puede utilizar.

delphi

var Perro, Gato: TMamifero;
begin
  // Creamos los objetos
  Perro := TPerro.Create; // según polimorfismo
  Gato := TGato.Create;  // según polimorfismo
  ....
  
  Perro.Cazar(Gato);       // cazará al gato
  Perro.Cazar(50,100);    // cazará en la posición (50,100) del mapa
  Perro.Cazar;               // cazará en alguna posición al azar
  ...
  // Liberamos los objetos
  Gato.Free;
  Perro.Free;
end;

Saludos,

[enecumene]

Otro aporte de excelentissima calidad amigo, Muchas Gracias

Saludos.