What is the 'natural' way to return a class instance as an object of another through a constructor

Question

Assuming that in situation X I want to return a class instance through variables, I see no problem in doing this:

$rs = "\\" .$Namespace . "\\" . $Class;
$inst = new $rs();
return $inst;

In an example, where, I want to have the option of using a class object in another class to modify something that wouldn’t be modified by default, something like an abnormal thing, then I would have this:

class Dados{

   public function dado1(){
      return [1 => 'dado1',2 =>'dado2',3 =>'dado3'];
   }

   public function dado2(){
      return [4 => 'dado4',5=>'dado5',6 =>'dado6'];
   }

}    
class Componentes {

   public function junta($array1,$array2){
       return array_merge($array1,$array2);
   }

   public function transformaEmJson($array){
      return json_encode($array);
   }

}
class DevolverAsDuasClassesComOConstrutor {

    public $Componentes;
    public $Dados

    public function __construct() {

        $inst1 = new Dados();
        $this->Dados = $inst;
        $inst1 = new Componentes();
        $this->Componentes = $inst;
    }

}

$class = new DevolverAsDuasClassesComOConstrutor();

$dado1 = $class->Dados->dado1();
$dado2 = $class->Dados->dado2();
$arr = $class->Componentes->junta($dado1,$dado2);
$json = $class->Componentes->transformaEmJson($arr);
echo $json;

The idea is to use a class without methods, to return other instances, and use this class with the instances as an extensible class, since it will contain the instances of what is being done.

In what I’m doing, it’s working right, but it seems strange to me,I want to know if it’s a good idea to do this (have instances as an object) from the point of view of maintenance and performance of the code?

In my view it does not seem to be good practice, but functional, if I am correct in that (in not being good), as it would be a good way to get the same result ?

NOTE: Doubt is about having the instance of one class as the object of another.