Class 访问内部嵌套类中的外部类

这是一个对象Pascal，我想知道在不干扰外部实例指针并将其传递给内部的情况下，这是否可能 我想做的是使用内部方法获得对outter（ClassOne）类的完全访问权。 我一直在努力：

{ this class should be able to access by all clases inside it }
ClassOne = class
    type
        { can be accessed by ClassThree, can access: ClassOne }
        ClassTwo = class
            type
                { can be accessed by / can access: ClassOne and ClassTwo }
                ClassThree = class 
                    public
                        procedure MethodOne();
                end;

            private
                FieldOne: Array[1 .. 10] of ClassThree;
                FieldTwo: integer;

            public
                procedure MethodOne();
        end;

    private
        FieldOne: Array[1 .. 5] of ClassTwo;
        FieldTwo: Byte;

    public
        procedure MethodOne(Something: Byte);
end;

实施：

procedure ClassOne.MethodOne(Something: Byte);
begin
    FieldTwo := Something;
end;    

procedure ClassOne.ClassTwo.MethodOne();
begin
    { does something but not important in this case }
end;

procedure ClassOne.ClassTwo.ClassThree.MethodOne();
begin
    { here i need the FieldTwo value of ClassOne of the current instance }
    ClassOne(self).FieldTwo; // Does not work
end;

访问：

var Test: ClassOne;

...

Test := ClassOne.Create();
Test.FieldOne[2] := ClassOne.ClassTwo.Create;
Test.FieldOne[2].FieldOne[5] := ClassOne.ClassTwo.ClassThree.Create;

Test.MethodOne(15);
Test.FieldOne[2].MethodOne();
Test.FieldOne[2].FieldOne[5].MethodOne();

迭代和数组大小只是随机的例子

我认为在Java中类似于

OuterClass.self.OuterClassField但这在这里不起作用。

我知道，这可以通过在创建后立即传递外部实例来实现，但这会给以后的构造函数和实例带来很多麻烦。

我怎样才能让它像那样工作

更新

也许这需要和祖先一起做？

这一个可以编译，但在调用class2或class3的构造函数后立即崩溃，为什么

ClassOne = class
    type
        ClassTwo = class(ClassOne) { changed ancestor }
            type
                ClassThree = class(ClassTwo) { changed ancestor }
                    public
                        procedure MethodOne();
                end;

            private
                FieldOne: Array[1 .. 10] of ClassThree;
                FieldTwo: integer;

            public
                procedure MethodOne();
        end;

    private
        FieldOne: Array[1 .. 5] of ClassTwo;
        FieldTwo: Byte;

    public
        procedure MethodOne(Something: Byte);
end;

好的，看来只有一种方法可以做到这一点，将外部类的和实例传递给内部类。

最好的方法是使用内部类构造函数。

这需要在每个嵌套类中包含一个实例的附加字段。

从这个级别，您可以完全访问outter类（甚至是严格的私有字段）。

下面是一个使用我上面文章中的类结构的简单示例：

Test := ClassOne.Create();

{ Test is a ClassTwo parent }
Test.FieldOne[2] := ClassOne.ClassTwo.Create(Test);

{ Test.FieldOne[2] is a ClassThree parent }
Test.FieldOne[2].FieldOne[5] := ClassOne.ClassTwo.ClassThree.Create(Test.FieldOne[2]);

然后，每个嵌套类都需要一个字段，即父字段：

{ ClassTwo }
Strict Private
    Parent: ClassOne;
    ...
    { ClassThree}
    Strict Private
        Parent: ClassTwo;

用法：

Procedure ClassOne.ClassTwo.ClassThree.Test();
Begin
    { Access ClassOne FieldTwo from ClassThree }
    Parent.Parent.FieldTwo;
End;

我不这么认为。例如，“嵌套类型可以访问其容器类的实例变量（字段、属性或方法），但必须有对象引用才能访问。”看起来您是对的，唯一的方法是将外部类的实例传递给内部类的构造函数。这给了我一个答案。