Oop 如何在不降低性能的情况下处理对象内部对象的最佳技术？

我有很多属性的类，在某些情况下，这些属性由其他复杂的类组成。并非所有情况下我都会使用这个完整的模式，但有时我会这样做。创建对象、处理对象然后根据需要检索信息的最佳实践是什么

我举一个非常简单的例子来说明：

提供一个班级

学生

，该班级与一个班级

教授

相关。该类与其他类相关，如

类

，

计划

，等等。并非所有情况下我都需要使用所有这些信息

我是否需要在object

student

中保存教授的ID，然后在需要时加载信息？我应该创建一个只用于存储professorID的属性，还是创建一个

新的
professor
对象而不将所有其他数据加载到其中，只存储
ID
？或者两者都没有？最佳做法是什么

谢谢。
听起来像你在描述。
听起来像你在描述。
使用。
使用。
在一般情况下，你需要一些实体从你的域加入实体。比如说，你将有一个
学生注册处
，保存学生与其教授/讲师之间的通信。这确实类似于RDBMS模式设计，因此您可以参考（显然，您将使用类而不是表。）
在一般情况下，您将需要一些实体从您的域连接实体。比如说，你将有一个
学生注册处
，保存学生与其教授/讲师之间的通信。这确实类似于RDBMS模式设计，因此您可以参考（显然，您将使用类而不是表）。
建议1


应用程序是否需要保存和加载对象和属性的值（也称为“序列化”或“持久化”）

应用程序是否需要具有同一类的多个实例


如果这个问题的答案是真的，那么您似乎需要像@larsmans建议的那样将数据存储在D.B.中

建议2

还有一件事。你没有提到你在用什么编程语言。像C++、Delphi（Object Pascal）、D这样的编程语言，可以用2种方式来处理另一个对象中的对象：作为对象的一部分，或者作为指向子对象的指针。p>
我建议针对您的场景使用指向对象的指针方法

在Java、PHP、C#、VB.NET等编程语言中，有一个称为引用的概念，实际上，它与指向对象的指针相同，因此不需要做任何其他事情

非指针示例：

class SubClass
{
  public: 
    int X;
    int Y;      
}; // class SubClass

class MainClass
{
  public:
    int Color;
    SubClass SubObject;

  public:
    /* constructor */ MainClass()
    {
      this.Color = 7;
      this.SubObject();
    } // /* constructor */ MainClass(...)

    /* destructor */ ~MainClass()
    {
      this.~SubObject();
      this.Color = 0;
    } // /* destructor */ MainClass(...)
}; // class MainClass

void main()
{
  MainClass* MainObject = new MainClass();
    MainObject->Color = 5;
    MainObject->SubObject.X = 19;
    MainObject->SubObject.Y = 32;
  delete MainObject();
}  // void main(...)

指向对象的指针示例：

class SubClass
{
  public: 
    int X;
    int Y;      
}; // class SubClass

class MainClass
{
  public:
    int Color;
    SubClass* SubObject;

  public:
    /* constructor */ MainClass()
    {
      this.Color = 7;
      this.SubObject = new SubClass();
    } // /* constructor */ MainClass(...)

    /* destructor */ ~MainClass()
    {
      delete this.SubObject();
      this.Color = 0;
    } // /* destructor */ MainClass(...)
}; // class MainClass

void main()
{
  MainClass* MainObject = new MainClass();
    MainObject->Color = 5;
    MainObject->SubObject->X = 19;
    MainObject->SubObject->Y = 32;
  delete MainObject();
}  // void main(...)

干杯。
建议1


应用程序是否需要保存和加载对象和属性的值（也称为“序列化”或“持久化”）

应用程序是否需要具有同一类的多个实例


如果这个问题的答案是真的，那么您似乎需要像@larsmans建议的那样将数据存储在D.B.中

建议2

还有一件事。你没有提到你在用什么编程语言。像C++、Delphi（Object Pascal）、D这样的编程语言，可以用2种方式来处理另一个对象中的对象：作为对象的一部分，或者作为指向子对象的指针。p>
我建议针对您的场景使用指向对象的指针方法

在Java、PHP、C#、VB.NET等编程语言中，有一个称为引用的概念，实际上，它与指向对象的指针相同，因此不需要做任何其他事情

非指针示例：

class SubClass
{
  public: 
    int X;
    int Y;      
}; // class SubClass

class MainClass
{
  public:
    int Color;
    SubClass SubObject;

  public:
    /* constructor */ MainClass()
    {
      this.Color = 7;
      this.SubObject();
    } // /* constructor */ MainClass(...)

    /* destructor */ ~MainClass()
    {
      this.~SubObject();
      this.Color = 0;
    } // /* destructor */ MainClass(...)
}; // class MainClass

void main()
{
  MainClass* MainObject = new MainClass();
    MainObject->Color = 5;
    MainObject->SubObject.X = 19;
    MainObject->SubObject.Y = 32;
  delete MainObject();
}  // void main(...)

指向对象的指针示例：

class SubClass
{
  public: 
    int X;
    int Y;      
}; // class SubClass

class MainClass
{
  public:
    int Color;
    SubClass* SubObject;

  public:
    /* constructor */ MainClass()
    {
      this.Color = 7;
      this.SubObject = new SubClass();
    } // /* constructor */ MainClass(...)

    /* destructor */ ~MainClass()
    {
      delete this.SubObject();
      this.Color = 0;
    } // /* destructor */ MainClass(...)
}; // class MainClass

void main()
{
  MainClass* MainObject = new MainClass();
    MainObject->Color = 5;
    MainObject->SubObject->X = 19;
    MainObject->SubObject->Y = 32;
  delete MainObject();
}  // void main(...)

干杯。
听起来你需要的是RDBMS而不是OO系统。听起来你需要的是RDBMS而不是OO系统。是的，我发现我的项目需要“懒惰的非专业化”。但我不知道是否一个好的做法是只在自己的对象中存储与对象ID相关的信息，在整个父对象的生命周期中保持它的活动性，然后在一个机会瞬间加载整个数据。您的数据是否存储在关系数据库管理系统中？如果是这样，那么理想情况下，您应该使用对象关系映射器将关系数据加载到对象中（并将它们再次持久化到数据库中）。在这种情况下，如果您的学生类型具有多对一关系中的professor type属性（professor是关系的主体）然后ORM在默认情况下会使用延迟加载，因此只会从数据库中为教授请求Id列，并且只会在访问student上的professor type属性时检索所有映射属性。是的，我发现我的项目需要“lazy Incialization”。但我不知道是否一个好的做法是只在自己的对象中存储与对象ID相关的信息，在整个父对象的生命周期中保持它的活动性，然后在一个机会瞬间加载整个数据。您的数据是否存储在关系数据库管理系统中？如果是这样，那么理想情况下，您应该使用对象关系映射器将关系数据加载到对象中（并将它们再次持久化到数据库中）。在这种情况下，如果您的学生类型具有多对一关系中的professor type属性（professor是关系的主体）然后ORM通常会默认使用延迟加载，因此只会从数据库中为教授请求Id列，并且只会在访问student上的professor type属性时检索所有映射属性。但我的问题是要处理大量的延迟和资源