de uso de la propiedad vs getters / setters en clases de negocios

Question

Cuando se trata de clases del negocio, al igual que las clases de los empleados y de los clientes típica, es mejor captadores y definidores de uso solamente o para propiedades de uso?

Estoy traduciendo a Delphi (para el autoaprendizaje) OO algunos ejemplos de libros de Java, en los ejemplos siempre hay GetName () y SetName (), propiedades que no se utilizan.

Ahora, puedo ver que si puedo crear un componente con propiedades publicadas tengo una muy buena razón para el uso de propiedades, pero en las clases normales, qué método es mejor? Es el código más legible con captadores y definidores (que hacen hincapié en el hecho de que estamos leyendo / escribiendo una propiedad) o con propiedades (que a primera vista puede confundirse con métodos sin parámetros)?

Answer 1

No. Captadores y definidores son sólo allí en Java, ya que no tiene propiedades. Se convierte en un código más limpio tanto a propiedades de uso. Y luego, si se necesita un comprador o un organismo, se puede construir en la propiedad, pero usted no tiene que ensucian el código de acceso a un montón de llamadas a funciones.

Answer 2

Wow. No es tan mucho más a las propiedades que "they'r envolturas sólo para los métodos get y set".

Las propiedades son un elegante y potente, forma de provoide acceso controlado a los campos de la clase.

Acceso a los campos

Como ya se ha dicho, puede acceder a los campos de la clase directamente. Esto es muy bonito y hace que el código más claro. También es una muy buena manera de poner en práctica una primera versión operable de su clase.

TMyClass = class
private
  FValue: String;
public
  property Value: String read FValue write FValue;
end; 

Más tarde, usted puede rediseñar su clase para validar el acceso y manipular el campo usando métodos. La voluntad interfaz pública sigue siendo la misma.

TMyClass = class
private
  FValue: String;
  procedure SetValue(AValue: String);
public
  property Value: String read FValue write SetValue;
end; 

procedure TMyClass.SetValue(AValue: String);
begin
  if AValue = '' 
  then FValue := 'No value!'
  else FValue := AValue;
end;

Control del acceso

Propiedades le da una descripción sencilla de los campos de sólo lectura / WriteOnly. P.ej. una clase de sólo lectura / inmutable:

TClient = class
private
  FName: String;
  FSite: String;
  FMail: String;
public
  constructor Create(AName, ASite, AMail: String);
  property Name: String read FName;
  property Site: String read FSite;
  property Mail: String read FMail;
end; 

Polimorfismo

TClient = class
private
  FName: String;
protected
  function GetName: String; virtual; abstract;
public
  property Name: String read GetName write FName;
end; 

TImportantClient = class(TClient)
protected
  function GetName: String; override;
end; 

TArgumentativeClient = class(TClient)
protected
  function GetName: String; override; 
end; 

function TImportantClient.GetName: String; 
begin
  Result := '+++ ' + FName;
end; 

function TArgumentativeClient.GetName: String; 
begin
  Result := ':-( ' + FName;
end; 

{----- ----- ----- ----- -----}
var
  ClientA,
  ClientB: TClient;
begin
  ClientA := TImportantClient.Create;
  ClientB := TArgumentativeClient.Create;

  ClientA.Name := 'Mr. Nice';
  ClientB.Name := 'Mr. Dumbhead';

  ShowMessage(ClientA.Name);
  ShowMessage(ClientB.Name);
end;
{----- ----- ----- ----- -----}

Por defecto propiedades

En su clase, se puede definir una clase predeterminada campos que significa que se puede acceder al campo directamente sin especificar el nombre de la propiedad.

A := MyStringList[i]:
MyStringList[i] := B;

{ instead of }

A := MyStringList.Strings[i];
MyStringList.Strings[i] := B;

{ or }

A := MyStringList.GetString(i);
MyStringList.SetString(i, B);

Índice

con la palabra clave Index, Delphi pasará un valor constante como un argumento a los métodos de captador / definidor.

TMyRect = class
private
  FValues: Array[0..3] of Integer;
  function GetProperty(Index: Integer): Integer;
public
  property Top    : Integer  Index 0  read GetProperty;
  property Left   : Integer  Index 1  read GetProperty;
  property Width  : Integer  Index 2  read GetProperty;
  property Height : Integer  Index 3  read GetProperty;
end;


function TMyRect.GetProperty(Index: Integer): Integer;
begin
  Result := FValues[Index];
end; 

Algunos recursos

Todavía hay algunos temas a la cubierta (implementación de interfaces, los valores almacenados, RTTI / propiedades de tiempo de diseño, etc), pero este post empezaron a ponerse un poco largo ...

Más se puede leer en estos sitios:

• http://www.delphibasics.co.uk
• http://delphi.about.com
• http://mc-computing.com

Answer 3

Las propiedades son una gran ventaja de Delphi. He hecho un poco de Java y Delphi mí y definitivamente iría por Propiedades. Prácticamente ambos enfoques con el tiempo hacer lo mismo, con la única diferencia de que las propiedades se ven más ordenado mucho que getters / setters.

Le sugiero que vaya a propiedades, y aprovechar al máximo de ellos!

Answer 4

Realmente es una cuestión de gusto y uso.

Para Pascal como programadores, que está muy claro si está leyendo o escribiendo un valor, así que creo que el código es más legible si no se utiliza captadores y definidores en el java-como forma en el que escribe getXXX o setXXX en cada frase de su programa.

Para mí, y supongo que para la mayoría de los programadores de Pascal, el código es más legible si se acaba de poner el nombre de la propiedad que usted está de lectura / escritura, y todos sabemos un método getter o setter se llama ( si es necesario).

Además, creo que es un gran beneficio (y elegancia) a partir del modelo de propiedad de Delphi que se puede obtener / establecer el valor de la propiedad directamente de un campo para que una gran cantidad de Obtener / métodos set con sólo una línea de código donde se le asigna el valor o leer de un campo es un total desperdicio de esfuerzo / tiempo.