Diferença entre modificadores de acesso “estrito privado” e “protegido” no Delphi?

Question

mas estou aprendendo programação e depois da programação estruturada com linguagem Pascal, estou começando a aprender sobre OOP com Delphi.

Então, eu realmente não entendo a diferença entre o strict private instrução e o protected um..Então aqui está o meu código, é sobre a criação de uma "bolsa", é apenas a introdução da minha aula de Delphi, professor nos mostra como podemos criar 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;

Então é apenas um exemplo de criação de objetos;Entendo o que é declaração pública (interface acessível externamente), mas não vejo qual é a diferença entre declarações privadas e protegidas.Obrigado por tentar me ajudar..

Answer 1

A diferença entre privada, protegida e pública é bem direta:

• Os membros/métodos privados são visíveis apenas dentro da classe que os declara.
• Membros/métodos protegidos são visíveis dentro da classe, e Para todas as subclasses.
• Membros e métodos públicos são visíveis para todas as outras classes.

Em Delphi, há um "bug" que torna a visibilidade de todos os membros públicos dentro da mesma unidade. o rigoroso A palavra -chave corrige esse comportamento, para que privado seja realmente privado, mesmo dentro de uma única unidade. Para um bom encapsulamento, eu recomendaria sempre usar a palavra -chave estrita.

Código de exemplo:

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 2

Privado rigoroso - visível e acessível apenas de dentro desta classe.

Privado - visível e acessível apenas de dentro desta classe e desta unidade de classe.

protegido - o mesmo que privado e de classes descendentes

Você pode ler mais e a ideia de encapsulamento aqui: http://en.wikipedia.org/wiki/encapsulation_%28Computer_science%29#encapsulussult

Answer 3

Você poderia ter procurado isso em todos os lugares (a palavra -chave seria "Modificadores de acesso")

Basicamente, protegido significa que os membros serão visíveis nas classes infantis e em toda a unidade. Estrito privado significa que você tem acesso ao membro apenas nos métodos de membro desta classe.

Answer 4

Um caso está faltando nas outras respostas: private e até mesmo strict private campos de outras instâncias podem ser acessados ​​a partir do código dentro de sua classe:

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 é o mesmo comportamento que em Java.)

Answer 5

Outro caso ausente nas outras respostas. Existem possibilidades de "estender" as regras de encapsulamento da classe.

Com os ajudantes de classe, introduzidos no Delphi 8 (para compatibilidade .NET), é possível contornar a diferença na visibilidade entre privado, protegido e público (e até mesmo as notações estritas). A declaração auxiliar de classe pode estar em outra unidade que não a classe original.

Isto é um exemplo :

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;

Veja este post para obter mais informações:Acesso-A-Strict-Protected-Property-of-A-Delphi-Class.