Différence entre les modificateurs d'accès "strict private" et "protected" dans Delphi?

Question

mais j'apprends la programmation et après la programmation structurée avec le langage Pascal, je commence à apprendre sur la POO avec Delphi.

Alors, je ne comprends pas vraiment la différence entre l'instruction strict private et le protected un .. Donc, voici mon code, il est sur une création « sac », il est juste l'introduction de ma leçon de Delphi, professeur nous montre comment nous pouvons créer des objets:

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; 

Donc c'est juste un exemple de création d'objet; Je comprends ce qu'est la déclaration publique (interface accessible par l'extérieur) mais je ne vois pas quelle est la différence entre les déclarations privées et protégées .. Merci d'essayer de m'aider ..

Answer 1

La différence entre le privé, protégé et public est assez simple:

• Les membres/méthodes privés sont uniquement visibles dans la classe qui les déclare.
• Les membres/méthodes protégés sont visibles dans la classe, et pour toutes les sous-classes.
• Les membres publics et les méthodes sont visibles pour toutes les autres classes.

En Delphi, il y a un "bug" qui rend la visibilité de tous les membres publics au sein de la même unité. Le mot-clé strict corrige ce comportement, de sorte que privé est réellement privé, même au sein d'une seule unité. Pour une bonne encapsulation, je recommande de toujours utiliser le mot clé strict.

code Exemple:

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

Vous auriez pu regarder partout (le mot-clé serait "modificateurs d'accès")

Fondamentalement, protégé signifie que les membres seront visibles dans les classes enfant et dans toute l'unité. privé signifie que vous avez accès au membre dans les méthodes membres de cette classe SEULEMENT.

Answer 3

strictement privé - visible et accessible seulement à partir de cette classe. Privé - visible et accessible uniquement depuis cette classe ET cette unité de classe.

protégée - le même que PLUS privée à l'intérieur des classes descendant

Vous pouvez en savoir plus sur et l'idée d'encapsulation ici: http://en.wikipedia.org/wiki/Encapsulation_%28computer_science%29#Encapsulation

Answer 4

Un cas est absent dans les autres réponses: private et même strict privatechamps d'autres instances est accessible à partir du code dans leur 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; 

(C'est le même comportement qu'en Java.)

Answer 5

Un autre cas manquant dans l'autre nswers. Il existe des possibilités pour "étendre" les règles d'encapsulation de classe.Avec les assistants de classe, introduits dans Delphi 8 (pour la compatibilité .NET), il est possible de contourner la différence de visibilité entre privé, protégé et public (et même les notations strictes). La déclaration d'aide de classe peut être dans une autre unité que la classe d'origine.

Voici un exemple:

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; 

Voir cet article pour plus d'informations: access-a-strict-protected-property-of-a-delphi-class.