定义一含链表的结构(100分)

从简：

type
TmyObj = class
private
fMyI:integer;
fMyEdit:TEdit;
public
constructor Create(AOwner: TComponent);
destructor Destroy;override;
function GetText:String;
end;

TMyObjs = class
private
FmyObjs: TList;
function GetMyObj(AIndex: Integer): TmyObj;
public
constructor Create(AOwner: TComponent);
destructor Destroy;override;
function Count:integer;
procedure ObjInsert(AObj: TmyObj);
property MyList[Index: Integer]: TMyObj read GetMyObj;
end;

constructor TmyObjs.Create(AOwner: TComponent);
begin
FmyObjs:=TList.Create;
end;

procedure TmyObjs.ObjInsert(AObj: TmyObj);
begin
FmyObjs.Add(AObj);
end;
...
实例上需要：
myObj:=TmyObj.Create(self);
if not Assigned(myObjs) then
myObjs:=TmyObjs.Create(self);
myObjs.ObjInsert(myObj);

问题一：
如何实现myObj创建时让myObjs ObjInsert，也就是说当myObj Create 时，myObjs会自动计数，不用象上面一样每次引用的实例都必须myObjs.ObjInsert(myObj)。

问题二：
如何将TmyObj TmyObjs合并成一个类？
当成为一个类时，
由于TList在类的域成员，每次在类的构造时TList也被构造，怎么办？

1.在myObj.Create()里面传入TmyObjs作为参数,如:myObjs.Create(parent: TmyObjs);这个tmyObjs类要进行前向定义(forward)
TmyObjs = class
// forward declare
Tmyobj = class
Constructor Create(Parent: TmyObjs);
end;
TmyObjs = class // imp it
//...
end;

constructor Tmyobj.Create(Parent: TmyObjs);
begin
Parent.objInsert(Self);
end

2.tmyobjs应该属于一个容器类,个人觉得这两个类应该分开.参考Class.pas里面的TCollection和TCollectionItem类.

多谢 hsgrass

用参数是不是唯一的办法？ 有没有不用实例化访问跨类成员？

问题一：
如何实现myObj创建时让myObjs ObjInsert，也就是说当myObj Create 时，myObjs会自动计数，不用象上面一样每次引用的实例都必须myObjs.ObjInsert

<<<重载构造函数

问题二：
如何将TmyObj TmyObjs合并成一个类？
当成为一个类时，
由于TList在类的域成员，每次在类的构造时TList也被构造，怎么办？

<<从数据结构的角度来将链表并不需要一个聚合类
通过某一算法总是能找到想要得到的结点

有没有不用实例化访问跨类成员？
<<成员函数是可以的
定义成class function....

to 52free
层次不同，高手的一席话，对我来说还是雾里看花，能不能多一点代码来说明问题，不胜感激

to 52free
关于第二点
//从数据结构的角度来将链表并不需要一个聚合类
//通过某一算法总是能找到想要得到的结点
是不是类似这样的写法，参照类TComponent
TmyObj = class
private
FOwner:TComponent;
fText:String;
fMyEdit:TEdit;
FmyObjs: TList;
public
constructor Create(AOwner: TComponent);
destructor Destroy;override;
function GetMyObj(AIndex: Integer): TmyObj;
procedure Insert(AmyObj: TmyObj);
procedure Remove(AmyObj: TmyObj);
end;
不知道这个结构和初衷（那个聚合类，供你一说知道这个名词）影响大不大？

今天再想想这个问题:
用参数是不是唯一的办法？ 有没有不用实例化访问跨类成员？
1.参数只是实现目的的一人办法,应该还有其它办法的, 如果属性,但应该遵守OOP法则的&quot;单一职责&quot;.
2.如果一个类没有实例化,它在内存里面不存在,你怎样访问经的成员?

//这是参考Tcollection写的, 这样可以只实例化TMyObjs而且由它來管理TmyObj.
TmyObjs = class;
TmyObj = class
private
FmyObjs: TmyObjs;
public
constructor Create(MyObjs: TmyObjs);
end;

constructor Create(MyObjs: TmyObjs);
begin
FmyObjs := MyObjs;
end;

TmyObjClass = class of TmyObj;
TmyObjs = class
private
FmyObjClass: TmyObjClass;
Flist: Tlist;
public
constructor Create(myObjClass: TmyObjClass);
function Add: Tmyobj

end;

constructor Create(myObjClass: TmyObjClass);
begin
FmyObjClass := myObjClass

end;

function Add: Tmyobj

begin
Flist.Add(FmyObjsClass.Create);
result := TmyObj(Flist.Count - 1);
end;
....destory的时候释放.....TLIST和它里面的实例.


/////////////
var
myObjs: TmyObjs;
myObj: TmyObj;
begin
myObjs := TmyObjs.create(TmyObj);
myObj := myObjs.Add;
end;

result := TmyObj(Flist.Count - 1);-----> result := TmyObj(FList[Flist.Count - 1]);趕工寫的.....

再次多谢 hsgrass

多人接受答案了。