È buona pratica OOP avere un metodo il cui unico scopo è inviare / recuperare dati da un'altra classe?

Ho una classe che esegue operazioni di base su MySQL. Questo è tutto in PHP.

class dbTables {
    public $name;
    protected $fields = array(); // array of dbTableField objects
    public $result_sets = array();
    protected $primary_key; // filled using getFields() from __construct()


    public function __construct($table_name) {
        $this->name = $table_name;
        $this->getFields();
    }
    public function removeWhitespace($table_name) {
        $this->name = $table_name;
        $this->getFields();
    }
    // etc...
}

Quindi tutto ciò di cui hai bisogno è il nome della tabella per creare l'oggetto, e il costrutto ottiene automaticamente una serie di dati di campo da INFORMATION_SCHEMA (nomi, tipi di dati, ecc.)

Ho anche un metodo per rimuovere gli spazi bianchi da una colonna Attualmente si trova in un'altra classe, ma sto pensando di passare alla classe dbTables precedente. Puoi vedere il metodo qui sotto. Non penso sia davvero necessario leggere il metodo per rispondere alla mia domanda, ma potrebbe essere utile.

protected function removeWhiteSpace($target_field,$abbrev_field,$from_size,$to_size,$options) {
    // optional conditions based on original character length and resulting character length.
    /* options: from_size = all/longer_than/shorter_than
    *   to_size = all/longer_than/shorter_than
    */
    $temp_table = $this->table_name;        
    $sql = "UPDATE '$temp_table' 
        SET 'undo_sku' = '$target_field', '$target_field' = REPLACE('$target_field',' ',''), '$abbrev_field' = 'w'";
    $where = array();
        if($options['from_size'] == 'longer_than') {
            $where[] = "'$target_field' > $from_size";
        } else if($options['from_size'] == 'shorter_than') {
            $where[] = "'$target_field' < $from_size";
        }
        if($options['to_size'] == 'longer_than') {
            $where[] = "LENGTH(REPLACE('$target_field',' ','')) > $to_size";
        } else if($options['from_size'] == 'shorter_than') {
            $where[] = "LENGTH(REPLACE('$target_field',' ','')) < $to_size";
        }               
        //WHERE '$target_field' = '' AND LENGTH(REPLACE('vnd_sku',' ','')) <= $string_length";
    $result = mysql_query($sql);
}

Ora, se lo spostamento in dbTables , voglio comunque utilizzare la funzionalità nell'altra classe. Devo istanziare un oggetto dbTables ogni volta che devo usare removeWhitespace ? Oppure, potrei dare a dbTables il proprio metodo removeWhitespace come questo:

protected function removeWhiteSpace($target_field,$abbrev_field,$from_size,$to_size,$options) {
  /* options: from_size = all/longer_than/shorter_than
  * to_size = all/longer_than/shorter_than
  */
  $dbtable = new dbTables($this->table_name);
  $temp_table = $this->table_name;

  $result = $dbtable->removeWhiteSpace($target_field,$abbrev_field,$from_size,$to_size,$options);
  return $result;
}

Il vantaggio che vedo è che ora ho un modo per limitare l'istanziazione dell'oggetto dbTables in varie altre classi. I metodi che devono utilizzare removeWhiteSpace possono utilizzare $this->removeWhiteSpace invece di creare un'istanza di un oggetto dbTables . Il metodo removeWhiteSpace della classe si occupa di questo.

Comunque, sono un po 'nuovo rispetto a OOP, quindi mi sto solo chiedendo se sia una buona pratica o una cattiva scelta.

Spero anche di porre questa domanda nel posto giusto. Sono abbastanza sicuro che non si tratti di una domanda StackOverflow.