4 respuestas en este tema

[Delphius]

Hasta ahora venimos trabajando con instancias de una clase. También podemos hacer uso de una clase sin instanciar objeto alguno. Todo gracias a los métodos de clase.

Métodos de clase

Los métodos de clase son igual que los métodos de siempre. Lo que los diferencia de los "comunes" es que éstos se declaran anteponiendo la palabra "Class":

delphi

class function NombreMetodo(ListaParametros): Tipo;
class procedure NombreMetodo(ListaParametros);
...
 
class function NombreMetodo(ListaParametros): Tipo;
begin
...
end;
 
class procedure NombreMetodo(ListaParametros);
begin
....
end;

Como dije al comienzo: el método sirve para trabajar con la clase y como el método "apunta" a la clase (mediante el parámetro implícito self) y no a la instancia, no se puede emplear éstos métodos para acceder a propiedades, atributos, etc.

¿Entonces de que sirve tenerlos?
En realidad sirven para dar funcionalidad a nivel de clase, y no de una instancia. Es decir que los métodos son aplicados en un concepto mucho más abstracto.
Funcionan independientemente de si hay o no una clase, por ello es que se puede hacer cosas como éstas:

delphi

var Clase: TMiClase;
...
TMiClase.MetodoClase; // Se usa a la clase
Clase.MetodoClase; // se invoca al método a través de una instancia

Contar con métodos de clase nos permite trabajar fuera del contexto de una instancia y aplicar operaciones más generales (recuerde que una instancia es un caso particular, o concreto de una clase). Por ejemplo: ¿es necesario contar con un objeto para saber la cantidad que han sido creados? No necesariamente. Puede emplearse una variable privada u oculta que lleve el conteo de instancias a medida que se crean y liberan los objetos y emplear un método de clase para consultar su valor.

De modo similar, ¿es necesario contar con instancias si lo que deseamos saber es si una clase pertenece a una jerarquía u otra, o si cuenta con alguna funcionalidad?
No. Porque lo que define a éstas acciones no es a una instancia, sino al conjunto de éstas instancias: la clase.
Cualquier dato, funcionalidad, y/o comportamiento que desee conocer sobre una clase puede ser consultado, y aplicado mediante métodos de clase.

Existen muchos de hecho TObject ofrece los más básicos:

delphi

class function InitInstance(Instance: Pointer): TObject;
function ClassType: TClass;
class function ClassName: ShortString;
class function ClassNameIs(const Name: string): Boolean;
class function ClassParent: TClass;
class function ClassInfo: Pointer;
class function InstanceSize: Longint;
class function InheritsFrom(AClass: TClass): Boolean;
class function MethodAddress(const Name: ShortString): Pointer;
class function MethodName(Address: Pointer): ShortString;
class function GetInterfaceEntry(const IID: TGUID): PInterfaceEntry;
class function GetInterfaceTable: PInterfaceTable;
class function NewInstance: TObject; virtual;

Eso si, más comunes son las funciones que los procedimientos. Lo importante del concepto es que cualquier operatoria que el negocio o contexto nos indique que se aplica a un nivel conceptual puede ser enfocado mediante esta técnica.

A los métodos de clase le son aplicables todos los conceptos a cualquier método: sobrecargarlos, sobreescribirlos, etc.

En el próximo post dejo un ejemplo muy sencillo de uso.

[Delphius]

En este post voy a añadir un ejemplo muy sencillo de como usar lo visto.

Digamos que es de interés que nuestra clase TPerro, ya un tanto gastadita y cansada, cuente con la capacidad de saber la cantidad de hembras. Un enfoque de como se podría llevar a cabo es éste:

delphi

unit Unit2;
 
interface
 
type
  TSexo = (sHembra, sMacho);
 
  TPerro = class
  private
    FSexo: TSexo;
    procedure EstablecerSexo(Valor: TSexo);
  public
    // propiedades
    property Sexo: TSexo read FSexo write EstablecerSexo;
 
    // constructores y destructores
    constructor Create(TipoSexo: TSexo);
    destructor Destroy; override;
 
    // métodos de clase
    class function HayHembras(var Cantidad: integer): boolean;
    class procedure ResetearHembras;
  end;
 
implementation
 
var CantHembras: integer; // como puede apreciarse se oculta esta variable
 
{ TPerro }
 
constructor TPerro.Create(TipoSexo: TSexo);
begin
  inherited Create;
  Sexo := TipoSexo;
end;
 
destructor TPerro.Destroy;
begin
  if (Sexo = sHembra)
      then dec(CantHembras);
 
  inherited Destroy;
end;
 
procedure TPerro.EstablecerSexo(Valor: TSexo);
begin
  if (Valor = sHembra)
     then inc(CantHembras);
 
  FSexo := Valor;
end;
 
class function TPerro.HayHembras(var Cantidad: integer): boolean;
begin
  result := (CantHembras <> 0);
  Cantidad := CantHembras;
end;
 
class procedure TPerro.ResetearHembras;
begin
   CantHembras := 0;
end;
 
initialization
  CantHembras := 0;
 
end.

Como se puede apreciar, se decrementa e incrementa una variable oculta según se crean o liberan los objetos.

Un posible uso, muy sencillo para comprobar si esto funciona es el siguiente:

delphi

var Perro1, Perro2, Perro3: TPerro;
    cant: integer;
    hay: boolean;
begin
  hay := TPerro.HayHembras(cant); // Mire: ¡ estamos usando la clase!
  ShowMessage(IntToStr(cant)); // debería haber hembras todavía
 
  Perro1 := TPerro.Create(sHembra);
  hay := Perro1.HayHembras(cant); // ¡Y ahora usamos un objeto!
  ShowMessage(IntToStr(cant));    // debería haber 1
 
  Perro2 := TPerro.Create(sMacho);
  hay := Perro2.HayHembras(cant);
  ShowMessage(IntToStr(cant));    // deberían seguir habiendo 1
 
  Perro3 := TPerro.Create(sHembra);
  hay := Perro3.HayHembras(cant);
  ShowMessage(IntToStr(cant));    // ahora debería haber 2
 
  Perro3.Free;
  hay := Perro1.HayHembras(cant);  //no iteresa que perro se use!
  ShowMessage(IntToStr(cant));    // ahora debería haber 1
 
  Perro2.Free;
  Perro1.Free;
 
  hay := Perro1.HayHembras(cant);  //no iteresa que perro se use!
  ShowMessage(IntToStr(cant));    // ahora debería haber 1

Si ejecuta el código anterior, deberá recibir mensajes con la cantidad de hembras: 0, 1, 1, 2, 1, 0.

Algo muy común en éstos métodos es que cualquier dato que necesiten es consultado y/o guardado temporalmente en algún sector oculto. Puede complementarse la técnica con funciones y métodos externos a una clase ("sueltos") para facilitar el código.

Espero que con este sencillo código quede ilustrado como se usa los métodos de clase.

Saludos,

[JoseAntonio]

Hola, bueno yo uso los metodos de clase generalmente para traer un resultado con una funcion de clase, esta funcion de clase crea un formulario, intercepta las interacciones del usuario con dicho formulario y finalmente retorna el resultado deseado en un parametro o en el mismo result de la funcion, aqui el ejemplo:

delphi

class function TfrmSelBeneficio.GetBeneficio(ACurrentType: string): string;
var
  SQLStr: string;
  ADataSet: IrsClientDataSet;
  AfrmSelBeneficio: TfrmSelBeneficio;
begin
  try
    AfrmSelBeneficio := TfrmSelBeneficio.Create(Application);
    SQLStr := ' SELECT COD_BENEFICIO, DESCRIPCION, DES_TIP FROM MA_TABLABENEFICIO ' +
              ' WHERE COD_BENEFICIO LIKE ' + QuotedStr('%' +ACurrentType + '%') +
              ' ORDER BY COD_BENEFICIO';
    ADataSet := CentralClient.Database[''].GetDataset(SQLStr);
    AfrmSelBeneficio.dscBeneficio.DataSet := ADataSet.Dataset;
    AfrmSelBeneficio.edtBeneficio.Text := ACurrentType;
    if AfrmSelBeneficio.ShowModal = mrOk then
      result := AfrmSelBeneficio.fCodBeneficio
    else
      result := ''
  finally
    AfrmSelBeneficio.free;
  end;
end;

[Delphius]

Hola JoseAntonio,
Gracias por aportar más al tema.

No discuto que se puede aprovechar los métodos de Clase para propósitos como el que describes, pero si debo admitir que me siento intrigado por él.
Generalmente para un método de clase se espera trabajar a un nivel de clase, en lo general, y esto lleva a pensar que no deberí­a interferir en otros objetos.

Hay que tener presente que en un método de clase no puede tenerse acceso a propiedades ni métodos del propio objeto (1). Es por ello que hay que analizar objetivamente si debe ser método a nivel de clase o a nivel de objeto.

En tu ejemplo creas en memoria unos componentes y luego lo liberas. Esto no siempre podrá ser recomendable. Todo dependerá de las necesidades y conveniencia.

(1) En realidad si es posible acceder a ciertas propiedades, al menos en la etapa del método de clase NewInstance cuando se está llevando a cabo la creación del objeto. Pero esto requiere bajarse al nivel de ensamblador, emplear algunas variables auxiliares, tal vez algún que otro cast... A mi humilde punto de vista, no creo que existan demasiadas ventajas y mucha necesidad de valerse de una técnica como ésta.

De todas formas no deja de ser interesante tu punto de vista.

Saludos,

[JoseAntonio]

En tu ejemplo creas en memoria unos componentes y luego lo liberas. Esto no siempre podrá ser recomendable. Todo dependerá de las necesidades y conveniencia..

Saludos,

Bueno en mi caso no creo componentes en memoria sino un formulario completo: TfrmSelBeneficio (generalmente modales con sus propios controles) y si bien confieso que nunca he usado funciones de clase para otros aspectos, esta tecnica me resulta muy util en los proyectos que desarrollo  puesto que permite abstraer toda una interaccion de usuario en una sola linea de codigo que es la que llama a la funcion de clase, muy acorde con el principio de encapsulamiento.