¿Diferencia entre los modificadores de acceso “privados estrictos” y “protegidos” en Delphi?

access-modifiers

Question

pero aprendo programación y luego de programación estructurada con lenguaje Pascal, estoy empezando a aprender sobre OOP con Delphi.

Entonces, realmente no entiendo la diferencia entre la instrucción strict private y la protected . Así que aquí está mi código, se trata de una creación de "bolsa", es solo la introducción de mi lección de Delphi, el maestro nos muestra cómo podemos crear objetos:

    uses
  SysUtils;

Type

  Tbag= class (Tobject)                                                          
    strict private                                                                
      FcontenM : single;
      Fcontent : single;
    protected
      function getisempty : boolean;
      function getisfull: boolean;
    public
      constructor creer (nbliters : single);
      procedure add     (nbliters : single);
      procedure clear   (nbliters : single);
      property contenM : single read FcontenM;
      property content : single read Fcontent;
      property isempty : boolean read getisempty;
      property isfull : boolean read getisfull;
    end;


function Tseau.getisempty;
  begin
    result := Fcontent = 0;
  end;

function Tseau.getisfull;
  begin
    result := Fcontent = FcontenM;
  end;

constructor Tseau.creer(nbliters: Single);
  begin
    inherited create;
    FcontenM := nbliters;
  end;

procedure Tbag.add (nbliters: Single);
  begin
    if ((FcontenM - Fcontent) < nbliters) then fcontent := fcontenM
      else Fcontent := (Fcontent + nbliters);
  end;

procedure Tbag.clear (nbliters: Single);
  begin
    if (Fcontent > nbliters) then Fcontent := (Fcontent - nbliters)
      else Fcontent := 0;
  end;

Así que es solo un ejemplo de creación de objetos; Entiendo lo que es una declaración pública (interfaz accesible desde el exterior) pero no veo cuál es la diferencia entre declaraciones privadas y protegidas. Gracias por intentar ayudarme.

Answer 1

Falta un caso en las otras respuestas: se puede acceder a strict private campos private e incluso strict private de otras instancias desde el código dentro de su clase :

type
  TSO1516493= class
  strict private
    A: Integer;
  public
    procedure ChangeOther(Param: TSO1516493);
  end;

{ TSO1516493 }

procedure TSO1516493.ChangeOther(Param: TSO1516493);
begin
  Param.A := -1; // accessing a strict private variable in other instance !
end;

(Este es el mismo comportamiento que en Java.)

Answer 2

La diferencia entre privado, protegido y público es bastante simple:

• Los miembros / métodos privados solo son visibles dentro de la clase que los declara.
• Los miembros / métodos protegidos son visibles dentro de la clase, y para todas las subclases.
• Los miembros públicos y los métodos son visibles para todas las demás clases.

En Delphi hay un "error" que hace que la visibilidad de todos los miembros sea pública dentro de la misma unidad. La palabra clave estricta corrige este comportamiento, de modo que privado es en realidad privado, incluso dentro de una sola unidad. Para una buena encapsulación recomendaría usar siempre la palabra clave estricta.

Código de ejemplo:

type
  TFather = class
  private
    FPriv : integer;
  strict private
    FStrPriv : integer;
  protected
    FProt : integer;
  strict protected
    FStrProt : integer;
  public
    FPublic : integer;
  end;

  TSon = class(TFather)
  public
    procedure DoStuff;
  end;

  TUnrelated = class
  public
    procedure DoStuff;
  end;

procedure TSon.DoStuff;
begin
  FProt := 10;       // Legal, as it should be. Accessible to descendants.
  FPriv := 100;      // Legal, even though private. This won''t work from another unit!
  FStrictPriv := 10; // <- Compiler Error, FStrictPrivFather is private to TFather
  FPublic := 100;    // Legal, naturally. Public members are accessible from everywhere.
end;

procedure TUnrelated.DoStuff;
var
  F : TFather;
begin
  F := TFather.Create;
  try
    F.FProt := 10;     // Legal, but it shouldn''t be!
    F.FStrProt := 100; // <- Compiler error, the strict keyword has "made the protection work"
    F.FPublic := 100;  // Legal, naturally.
  finally
    F.Free;
  end;
end;

Answer 3

Otro caso que falta en las otras respuestas. Hay posibilidades de "extender" las reglas de encapsulación de clase.

Con los ayudantes de clase, introducidos en Delphi 8 (para compatibilidad con .NET), es posible sortear la diferencia de visibilidad entre privado, protegido y público (e incluso las notaciones estrictas). La declaración del ayudante de clase puede estar en otra unidad que la clase original.

Esto es un ejemplo :

type
  TMyOrgClass = class
  strict private
    FMyPrivateProp: Integer;
  strict protected
    property MyPrivateProp: Integer read FMyPrivateProp;
  end;

  TMyClassHelper = class helper for TMyOrgClass
  private
    function GetMyPublicProp: Integer;
  public
    property MyPublicProp: Integer read GetMyPublicProp;
  end;

function TMyClassHelper.GetMyPublicProp: Integer;
begin
  Result:= Self.FMyPrivateProp;  // Access the org class members with Self
end;

Consulte esta publicación para obtener más información: access-a-strict-protected-property-of-a-delphi-class .

Answer 4

Podría haber buscado esto en todas partes (la palabra clave sería "modificadores de acceso")

Básicamente, protegido significa que los miembros serán visibles en las clases de niños y en toda la unidad. estricto privado significa que tiene acceso al miembro en los métodos de miembro de esta clase SOLAMENTE.

Answer 5

estricto privado: visible y accesible solo desde esta clase.

Privado: visible y accesible solo desde esta clase Y esta unidad de clase.

protegido - lo mismo que el PLUS privado desde dentro de las clases descendientes

Puede leer más sobre e idea de encapsulación aquí: http://en.wikipedia.org/wiki/Encapsulation_%28computer_science%29#Encapsulation