Ci sono motivi validi per usare DI per le sottoclassi che sono note per essere strettamente accoppiate ai loro contenitori genitori?

Ho delle classi di prodotti per i prodotti dalla A alla Z. E ogni classe di prodotto ha il proprio insieme di sottoclassi specifiche del prodotto, che direi strettamente ad esse, in questo modo:

//specific product class inherits from generic product
class ProductA extends Product
{
    function __construct()
    {
        parent::__construct();

        //product-specific subclasses that are tightly coupled to the product
        //note that they are not DI-ed, although they *could be*
        $this->weight = new WeightA();
        $this->spec = new SpecA();
    }
}

class Product
{
    public $weight;
    public $spec;

    function __construct()
    {
        //these are generic versions in case someone calls a generic product class   
        $this->weight = new Weight();
        $this->spec = new Spec();
    }    
}

//example instantiation
$p = new ProductA();
$p->weight->a_specific = 4;

Domanda:

Ho dedicato un po 'di tempo a riflettere se volevo passare le mie sottoclassi Weight e Spec utilizzando tecniche di In-dipendenza-Dependenza, ad esempio (aggiustando le mie classi rispettivamente):

$p = new ProductA(new WeightA(), new SpecA());

Ma finora non ho trovato nessuna buona ragione per farlo. In effetti, farlo potrebbe aumentare la possibilità di errore, dove posso per caso fare qualcosa di simile a questo:

$p = new ProductA(new WeightB(), new SpecC()); //note the disparate classes

Domanda:

• C'è qualche buona ragione per dividere sottoclassi strettamente accoppiate in contenitori di classi generiche?
• c'è un nome comune per questo problema (pattern) con cui mi sto occupando?
• ci sono altri (migliori) modelli disponibili da usare nella mia istanza?

Sfondo:

Sto refactoring una grande applicazione di palla di fango e sta prendendo forma, ma uno dei modelli che ho identificato è che ci sono classi specifiche del prodotto che contengono molte sottoclassi specifiche del prodotto, come come nell'esempio sopra.

Possible Middle-Ground:

Nota: in alternativa se voglio davvero DI, posso usare DI in sottoclassi specifiche del prodotto, iniettando sottoclassi nel contenitore genitore (opposto a iniettarlo dall'esterno nelle stesse classi specifiche del prodotto come ho fatto sopra) , così:

class ProductA extends Product
{
    function __construct()
    {
        parent::__construct(new WeightA(), new SpecA());
    }
}

class Product
{
    function __construct($weight, $spec)
    {
        $this->weight = $weight;
        $this->spec = $spec;
    }    
}

Mi chiedo se sarà un'opzione migliore in generale. Un problema è che ProductA() non ha parametri ma Product($weight, $spec) avrà due parametri, che è un'inconsistenza.