“严格的私人”和“保护”访问修饰符德尔福之间的区别是什么？(Difference between “

但我学习编程和Pascal语言结构化程序后，我开始了解与德尔福OOP。

所以，我真的不明白之间的差别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;

所以它只是创建对象的实例; 我明白了什么是公共声明（接口平易近人由外），但我不明白什么是private和protected声明之间的区别..感谢试图帮助我..

Answer 1:

私人之间的区别，protected和public是非常简单的：

私有成员/方法只能在声明这些类中可见。
受保护的成员/方法的类中是可见的，并且所有子类。
公共成员和方法对所有其他类可见。

在德尔福有一个“错误”，使得在同一单位内的公共所有成员的可见性。严格的关键字纠正这种行为，使民营实际上是私人的，即使在一个单元。为了获得良好的封装我总是会使用严格的关键字建议。

示例代码：

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:

严格的私人 - 可见，只有从这个类中入店。

私人 - 可见，只有从这个和这个类单元内入店。

保护 - 同私人PLUS从派生类中

你可以阅读更多有关此封装的想法： http://en.wikipedia.org/wiki/Encapsulation_%28computer_science%29#Encapsulation

Answer 3:

你可能已经到处找这件事（的关键词将是“访问修饰符”）

基本上，保护意味着该成员将在子类和整个单元可见。严格的私人意味着你有机会获得这个班只有成员方法成员。

Answer 4:

一种情况是在缺少其他答案： private ，甚至strict private 其他情况下的字段可以从它们的类内代码访问 ：

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;

（这是相同的行为在Java中。）

Answer 5:

另一起案件中的其他答案丢失。有可能性“扩展”之类的封装规则。

凭借一流的帮手，在Delphi 8中引入（对于.NET兼容），可以规避私有，保护和公共（甚至严格的符号）之间的可见性的差异。类帮手声明可以在另一个单元比原来的班级。

这是一个例子：

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;

看到这个帖子以了解更多信息：访问一个严格保护的财产的-A-德尔福级。

文章来源: Difference between “strict private” and “protected” Access Modifiers in Delphi?