Duda sobre teoria de clases

[Keysher]

Coincido en que en la mayoría de los casos ese planteamiento es el correcto.

De hecho reconozco que estaba equivocado en algunas de las premisas, había errado en el análisis inicial.

Pero sigo creyendo que en un caso concreto no me interesa que el objeto se cree por sí mismo.

Tenemos una clase parecida a esta (es muy básica):

Código php:

class Template {
    private $templateName;
    private $vars;
    private $templateFile;
 
    function __construct($auxTemplate, $auxFile) {
        $this->templateName = $auxTemplate;
        $this->templateFile = $auxFile;
        $this->vars = array();  
    }
 
    public function setVar($auxVar, $auxValue) {
        if (!array_key_exists($auxVar, $this->vars))
            $this->vars[$auxVar] = $auxValue;
    }
    public function getVar($auxVar=NULL) {
        if ($auxVar == NULL)
            return $this->getVars();
 
        if (!array_key_exists($auxVar, $this->vars))
            return NULL;
 
        return $this->vars[$auxVar];
    }
            
    public function getTemplate() {
        return $this->templateName;
    }
            
    public function getFile() {
        return $this->templateFile;
    }
            
    public function getVars() {
        return $this->vars;
    }
}
 

Para instanciarla se necesita un nombre de plantilla y un fichero asociado, y eso lo tengo en un array dentro de otra clase.

Código php:

class Style {
 
    
    private $style;
    private $templates;
    private $cssFiles;
    private $jsFiles;
    private $currentTemplate;
    private $basePath;
    private $preparedTemplates;
        
    function __construct($auxStyle, $auxStyleConfigFile, $auxStylePath) {
 
(...)
    }
 
    public function selectTemplate($auxTemplate) {
        if (isset($this->templates[$auxTemplate])) {
            $auxPath = $this->basePath.$this->templates[$auxTemplate];
            if (file_exists($auxPath)) {
                $this->emptyTemplate();
                $this->currentTemplate = new Template($auxTemplate, $this->templates[$auxTemplate]);
            } else
                trigger_error($this->msgError['TEMPLATE_FILE_NOT_FOUND'].$auxTemplate, E_USER_ERROR);
        }
        else    
            trigger_error($this->msgError['TEMPLATE_NOT_FOUND'].$auxTemplate, E_USER_ERROR);
    }
 
    public function addVar($auxVar, $auxValue) {        
        if (isset($this->currentTemplate)) {
            $this->currentTemplate->setVar($auxVar, $auxValue);
        } else
            trigger_error($this->msgError['TEMPLATE_NOT_SELECTED'], E_USER_ERROR);
    }
 

Entiendo que es menos flexible esta forma y que es más costoso hacer cambios en el código. Pero tampoco veo muy lógico el tener que sacar primero el nombre de la plantilla y su fichero de la clase Style, para crear luego un objeto de la clase Template con estos datos, y añadirlo a la primera clase.

Entonces, ¿debo cambiar la forma en la que se crea la clase Template? ¿lo dejo como está pero creo otro método para atar un Template creado al Estilo?

Gracias!