Métodos que utilizan miembros privados o accesadores públicos

Question

Me doy cuenta de que esto probablemente no puede ser respondido, pero estoy buscando si hay algún tipo de orientación sobre si usar miembros privados directamente o acceso público dentro de los métodos de clase.

Por ejemplo, considere el siguiente código (en Java, pero que se vería muy similar en C++):

public class Matrix { 

    // Private Members 
    private int[][] e; 
    private int numRows; 
    private int numCols; 

    // Accessors 
    public int rows(){ return this.numRows; } 
    public int cols(){ return this.numCols; } 

    // Class Methods 
    // ... 
    public void printDimensions() 
    { 
     // [A] Using private members 
     System.out.format("Matrix[%d*%d]\n", this.numRows, this.numCols); 


     // [B] Using accessors 
     System.out.format("Matrix[%d*%d]\n", this.rows(), this.cols()); 
    } 

La función printDimensions() ilustra dos formas de obtener la misma información, [A] con miembros privados (this.numRows, this.numCols) o [B] a través de los usuarios (this.rows(), this.cols()).

Por un lado, es posible que prefiera usar los accesadores ya que no hay manera de que pueda cambiar inadvertidamente el valor de las variables de miembro privado. Por otro lado, es posible que prefiera acceder directamente a los miembros privados con la esperanza de que elimine la llamada de función innecesaria.

Supongo que mi pregunta es, ¿es el estándar de facto o preferido?

Answer 1

Es una llamada de estilo. Prefiero usar los descriptores de acceso, porque en mi humilde opinión, la sobrecarga de llamada de función es lo suficientemente pequeña como para que en la mayoría de los casos no importe, y este uso preserva la abstracción de datos. Si más adelante quiero cambiar la forma en que se almacenan los datos, solo necesito cambiar los accesadores, en lugar de buscar todos los lugares donde toqué las variables.

No me siento muy convencido, sin embargo, y rompería esta "regla" si pensara que tengo una buena razón para hacerlo.

Answer 2

Tengo otros objetos, incluidas las subclases del objeto, uso los accesos, pero hago que el objeto use los campos. De esta manera, hay una clara distinción entre las partes internas y la interfaz con el resto del mundo. Ocultar el contenido de la clase de sí mismo parece innecesario y potencialmente confuso. Si algo realmente se beneficia al tener su implementación oculta de otras partes del objeto, divídala en un objeto separado.

Answer 3

En mi humilde opinión, los usuarios de acceso son más una cuestión de gestión de la estructura y los datos en lugar de los usuarios en sí. A veces, necesita preprocesar algunos datos antes de devolverlos. Piense en este ejemplo:

public class Foo { 

    private List<Bar> bars = null; 

    //Methods and stuff 

    public List<Bar> getBars() { 
     if(bars == null) 
      bars = SomeClass.loadBars(); 
      // You can also use 
      // setBars(SomeClass.loadBars()); 
     return bars; 
    } 

} 

En este caso, el comprador no sólo está terminando su campo, pero volviendo un campo iniciado siempre que se invoca. El uso de los accesorios dentro de una clase ofrece los mismos beneficios que para los externos, se abstrae de los detalles particulares de un campo y puede obtenerlo después de procesarlo.

Por otro lado, si su campo es devuelto directamente (por ejemplo, una Cadena) no importa si usa un get o no, pero puede usar un get para respetar un estándar en tu codigo.

Al final, todo se reduce a un estilo de codificación.