डेल्फी में "सख्त निजी" और "संरक्षित" एक्सेस संशोधक के बीच अंतर?

Question

लेकिन मैं प्रोग्रामिंग सीखता हूं और पास्कल भाषा के साथ संरचित प्रोग्रामिंग के बाद, मैं डेल्फी के साथ ओओपी के बारे में जानना शुरू कर रहा हूं।

तो, मैं वास्तव में strict private शिक्षा और protected एक के बीच का अंतर समझ में नहीं आता .. तो यहाँ है, मेरे कोड है कि यह एक "बैग" निर्माण के बारे में है, यह सिर्फ मेरी डेल्फी के सबक की शुरूआत है, शिक्षक हमें दिखा हम वस्तुओं को कैसे बना सकते हैं:

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; 

तो यह ऑब्जेक्ट सृजन का एक उदाहरण है; मैं समझता हूं कि सार्वजनिक घोषणा क्या है (बाहर से इंटरफ़ेस इंटरफ़ेस) लेकिन मुझे नहीं पता कि निजी और संरक्षित घोषणाओं के बीच क्या अंतर है .. मेरी मदद करने के लिए धन्यवाद ..

Answer 1

के बीच का अंतर निजी, संरक्षित और सार्वजनिक बिल्कुल स्पष्ट है:

• निजी सदस्य/विधियां केवल उन वर्गों के भीतर दिखाई देती हैं जो उन्हें घोषित करती हैं।
• संरक्षित सदस्यों/विधियों वर्ग, और सभी उप-वर्गों में दिखाई दे रहे हैं।
• सार्वजनिक सदस्यों और विधियां अन्य सभी वर्गों के लिए दृश्यमान हैं।

डेल्फी में एक "बग" है जो सभी सदस्यों की एक ही इकाई के भीतर सार्वजनिक रूप से दृश्यता बनाता है। सख्त कीवर्ड इस व्यवहार को सुधारता है, ताकि निजी वास्तव में निजी हो, यहां तक ​​कि एक इकाई के भीतर भी। अच्छे encapsulation के लिए मैं हमेशा सख्त कीवर्ड का उपयोग करने की सिफारिश करेंगे।

उदाहरण कोड:

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

आप इसे हर जगह देख सकते थे (कीवर्ड "एक्सेस मॉडिफायर्स" होगा)

असल में, संरक्षित मतलब है कि सदस्य बाल कक्षाओं और पूरे इकाई में दिखाई देंगे। सख्त निजी माध्यमों का मतलब है कि आप केवल इस वर्ग के सदस्य तरीकों में सदस्य तक पहुंच सकते हैं।

Answer 3

सख्त निजी - दृश्यमान और केवल इस कक्षा के भीतर से स्वीकार्य।

केवल इस वर्ग और इस कक्षा इकाई के भीतर से निजी - दृश्यमान और स्वीकार्य।

संरक्षित - वंशज वर्गों के भीतर से

आप अधिक पढ़ सकते हैं निजी प्लस के रूप में ही के बारे में और यहाँ कैप्सूलीकरण के विचार: http://en.wikipedia.org/wiki/Encapsulation_%28computer_science%29#Encapsulation

Answer 4

ही एक मामला अन्य उत्तर में याद आ रही है:

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; 

(: private और अन्य उदाहरण भी strict privateक्षेत्रों कोड से अपनी कक्षा से पहुंचा जा सकता जावा में यह वही व्यवहार है।)

Answer 5

दूसरे मामले में एक अन्य मामला गायब है nswers। कक्षा encapsulation नियमों को "विस्तार" करने की संभावनाएं हैं।

क्लास हेल्पर्स के साथ, डेल्फी 8 (.NET संगतता के लिए) में पेश किया गया, निजी, संरक्षित और सार्वजनिक (और यहां तक ​​कि सख्त नोटेशन) के बीच दृश्यता में अंतर को बाधित करना संभव है। कक्षा सहायक घोषणा मूल वर्ग की तुलना में किसी अन्य इकाई में हो सकती है। access-a-strict-protected-property-of-a-delphi-class:

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; 

अधिक जानकारी के लिए यह पोस्ट देखें:

यह एक उदाहरण है।