Diferencia entre modificadores de acceso "estrictamente privados" y "protegidos" en Delphi?

Question

pero aprendo la programación y después de la programación estructurada con lenguaje Pascal, estoy empezando a aprender acerca de OOP con Delphi.

lo tanto, no entiendo muy bien la diferencia entre la instrucción strict private y la protected uno .. Así que aquí es mi código, se trata de una creación "bolsa", es sólo la introducción de la lección que mi de Delphi, profesor nos muestran 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 declaración pública (interfaz accesible por el exterior) pero no veo cuál es la diferencia entre las declaraciones privadas y las protegidas .. Gracias por intentar ayudarme ...

Answer 1

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

• Los miembros/métodos privados solo son visibles dentro de la clase que los declara.
• Los miembros/métodos protegidos están visibles dentro de la clase, y en todas las subclases.
• Los miembros y métodos públicos 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 strict corrige este comportamiento, por lo 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.

Ejemplo código:

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

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

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

Answer 3

estricto privado: visible y accesible solo desde dentro de esta clase.

privado - visible y accesible solo dentro de esta clase Y esta unidad de clase.

protegida - el mismo que el PLUS privada desde dentro de clases descendientes

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

Answer 4

Un caso está ausente en las otras respuestas: private e incluso strict privatecampos de otros casos se puede acceder 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 5

Falta otro otro caso en el otro nswers. Hay posibilidades de "extender" las reglas de encapsulación de clase.

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

Este 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; 

Ver este post para más información: access-a-strict-protected-property-of-a-delphi-class.