Relación entre objetos y bases de datos relacionales

[Lechu]

Hola. Muy buen día a todos.

Quiero hacer una consulta que quizás resulte algo compleja y difícil de contestar por este medio. Pero bueno, al menos, es posible que me puedan orientar un poco. Les cuento:

Mi duda, básicamente, radica en lo siguiente: ¿cuál es la forma "óptima" o más adecuada de usar la programación orientada a objetos con una base de datos relacional como SQL Server?

Sucede lo siguiente: estoy casi a punto de terminar mis estudios superiores y, para mis trabajos, siempre usé la programación estructurada con bases de datos hechas en SQL Server. Hasta ahí, ningún problema. El tema surge cuando tengo que hacer un trabajo para la materia POO (programación orientada a objetos).

Voy a poner un ejemplo de mi duda/problema:

Tengo dos clases asociadas. Una es TProducto y la otra es TProveedor. Todo producto tiene un único proveedor asociado. Supongamos que estas son mis clases (todo esto es un ejemplo):

Código Delphi [-]
TProveedor = Class
Private
  ID: Integer;
  Descripcion: String[50];
Public
  Constructor CrearProveedor();
  Procedure EstablecerID(I: Integer);
  Procedure EstablecerDescripcion(D: String);
  Function ObtenerID(): Integer;
  Function ObtenerDescripcion(): String;
End;

TProducto = Class
Private
  ID: Integer;
  Descripcion: String[50];
  Proveedor: TProveedor;
Public
  Constructor CrearProducto();
  Procedure EstablecerID(I: Integer);
  Procedure EstablecerDescripcion(D: String);
  Procedure EstablecerProveedor(P: TProveedor);
  Function ObtenerID(): Integer;
  Function ObtenerDescripcion(): String;
  Function ObtenerProveedor(): TProveedor;
End;

Ahora bien. Durante mis estudios, se me enseñó a guardar todo esto en un arreglo (clase TArreglo con todos los métodos necesarios de librería operacional para poder llevar a cabo las operaciones básicas). Acá dejo la clase TArreglo para que se den una idea.

Código Delphi [-]
Const

Maximo = 1000;

Type

TIndice = 1..Maximo;
TPosicion = 0..Maximo;
TElemento = TProducto;

TArreglo = Class
Private
  Conjunto: Array[TIndice] of TElemento;
  Ultimo: TPosicion;
Public
  Constructor CrearEstructuraVacia();
  Procedure Insertar(Elemento: TElemento);
  Procedure Eliminar(Posicion: TIndice);
  Function Buscar(X: TClave): TPosicion;
  Function VectorLleno: Boolean;
  Function VectorVacio: Boolean;
  Function ObtenerUltimo: TPosicion;
  Function ObtenerElemento(Posicion: TPosicion): TElemento;
End;

El problema de esto es que todo se almacenaba temporalmente en memoria, por lo que, al salir del programa, se perdían todos los datos.
Ahora, después de tanta introducción, voy al punto: si yo hago una base de datos en SQL Server estaría integrada por dos tablas, por supuesto: Productos y Proveedores. Ambas serían algo así:

Productos = (Prod_ID, Prod_Descripcion, Prod_ProveedorID)
Proveedores = (Prov_ID, Prov_Descripcion)

El campo Prod_ProveedorID es una clave foránea que apunta hacia la clave Prov_ID de la tabla Proveedores. Bien. El problema es que yo, viendo desde el punto de vista de mis objetos, una instancia de la clase PRODUCTO no tiene un simple entero que apunta a otra instancia de PROVEEDORES sino que el producto tiene "dentro" una instancia proveedor. A lo que voy: no son dos cosas "separadas" sino que son una está dentro de la otra (producto tiene un atributo de tipo TProveedor). Eso, trabajándolo en memoria con el arreglo se podía hacer sin problemas; pero, con la base de datos, supongo que debo dar un paso extra.
¿Cuál sería la mejor forma de manejar esto?

Gracias de antemano y espero haberme explicado bien.