区别于；“严格保密”；及；“受保护”；Delphi中的访问修饰符？

但是我学习了编程，在使用Pascal语言进行结构化编程之后，我开始学习使用Delphi进行OOP

所以，我真的不明白

严格私有

指令和

受保护

指令之间的区别。。这是我的代码，是关于一个“包”的创建，这只是我的Delphi课程的介绍，老师告诉我们如何创建对象：

    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;

使用
SysUtils；
类型
Tbag=类别（Tobject）
严格保密
FcontenM：单个；
内容：单一；
受保护的
函数getisempty:布尔型；
函数getisfull:boolean；
公众的
构造器筒子架（NBL：单个）；
程序添加（NBL：单个）；
程序清晰（NBL：单个）；
属性contentnm：单读FcontenM；
属性内容：单读Fcontent；
属性isempty：布尔读取getisempty；
属性isfull：布尔读取getisfull；
结束；
函数Tseau.getisempty；
开始
结果：=Fcontent=0；
结束；
函数Tseau.getisfull；
开始
结果：=Fcontent=FcontenM；
结束；
建造商Tseau.creer（NBL：单个）；
开始
继承创造；
FcontenM:=n升；
结束；
程序Tbag.add（NBL：单个）；
开始
如果（（FcontenM-Fcontent）NBL），则Fcontent:=（Fcontent-NBL）
其他f内容：=0；
结束；

---

所以这只是一个物体创造的例子；我理解什么是公共声明（外部可以访问接口），但我不明白私有声明和受保护声明之间的区别。。感谢您尝试帮助我。

您可以在任何地方查找此内容（关键字为“访问修饰符”）

---

基本上，受保护意味着成员将在子类和整个单元中可见。strict private表示您只能在此类的成员方法中访问该成员。

strict private-只能在此类中看到和访问

private-仅在此类和此类单元中可见和可访问

受保护-与子类中的private PLUS相同

---

您可以在此处阅读有关封装的更多信息和想法：

私有、受保护和公共之间的区别非常简单：

• 私有成员/方法仅在声明它们的类中可见
• 受保护的成员/方法在类内以及对所有子类可见
• 公共成员和方法对所有其他类都可见

在Delphi中，有一个“bug”，使得同一单元中所有成员的可见性都是公共的。strict关键字纠正了这种行为，因此private实际上是private，即使在单个单元中也是如此。为了实现良好的封装，我建议始终使用strict关键字

示例代码：

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;

类型
TFather=类
私有的
FPriv：整数；
严格保密
FStrPriv：整数；
受保护的
FProt：整数；
严格保护
FStrProt：整数；
公众的
FPublic：整数；
结束；
TSon=类（TFather）
公众的
程序凝灰岩；
结束；
类
公众的
程序凝灰岩；
结束；
程序TSon.DoStuff；
开始
FProt:=10；//应该是合法的。后代可以访问。
FPriv:=100；//合法的，即使是私人的。这在其他单位是行不通的！
FStrictPriv:=10；// 其他答案中缺少一个案例：
private
甚至可以从类中的代码访问其他实例的
strict private
字段：

（这与Java中的行为相同。）
其他答案中缺少另一个案例。
有可能“扩展”类封装规则

使用Delphi8中引入的类助手（用于.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;

有关更多信息，请参阅本文：。
这不是错误，这是预期行为，VCL经常使用它。这就是我写“错误”的原因：-）这是Delphi的工作方式，但不是标准OOP。那么谁定义了“标准OOP”呢？我不知道有一些OOP标准委员会。OOP仅仅定义了一个围绕封装、继承和多态性的范例。关于如何实现访问修饰符，没有严格的（双关语）规则。为了更好地说明，访问规则在单元级实现了隐式的“友谊”，而没有添加显式语法。可以说Delphi行为不符合“我的”OOP标准吗？；-）说真的，我觉得根据类定义的文件赋予访问修饰符不同的含义是一件坏事。最好是使用某种类型的朋友声明（如您所提到的）。IMHO通过引入额外的“严格”可见性级别来解决问题比（局限在一个单元中）问题更糟糕。我从不使用strict，因为它给我带来可移植性问题（到旧版本）的可能性比它真正避免bug等的可能性更大。
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;