Tags

, , , , , , ,

Quizá intuyan de qué trata éste post, quizá no. Los que sepan de programación entenderán que en programación orientada a objetos es más que común (casi obligado) usar métodos Set y métodos Get para acceder a la información de los atributos y modificar o leer el estado de un objeto. Es más, ahora que estuve viendo JSP, los beans ocupan de manera obligatoria, métodos Set y métodos Get para que el JSP almacene información.

Desarrollaré mi tésis de la siguiente manera, digamos que existe una clase genérica pero con muchos atributos, algo típico de la enseñanza de orientación a objetos, una clase persona, que en C++ sería algo como:

class Persona{
private:
    genero_h genero;
    int edad;
    int estatura;
    char* nombre;
    char* apellido_p;
    char* apellido_m;
};

Por mencionar algunas cosas, genero_h es una enumeración que tiene cosas como… H y M xD si quisiéramos manipular los atributos de la clase habría que hacer una lista de métodos Set y Get sobrecargados para un montón de opciones, quizá aquí no haya tantas pero a veces las hay. Veamos cómo queda esa lista:

class Persona{
private:
    genero_h genero;
    int edad;
    int estatura;
    char* nombre;
    char* apellido_p;
    char* apellido_m;
public:
    Persona();
    ~Persona();
    void setGenero(genero_h);
    void setEdad(int);
    void setEstatura(int);
    void setNombre(char*);
    void setApellidoP(char*);
    void setApellidoM(char*);
    genero_h getGenero();
    int getEdad();
    int getEstatura();
    char* getNombre();
    char* getApellidoP();
    char* getApellidoM();
};

A mi por lo menos, esta visión de la clase me resulta confusa, ofuscada, extensiva, hartante y demás adjetivos negativos que pudieran quedar. Este problema crece exponencialmente (sólo para exagerar) si la clase va a realizar otras operaciones y lleva sobrecarga de métodos y de operadores y de etcétera, etcétera, etcétera.

Es por ello, que propongo lo siguiente, en lugar de hacer operaciones Set y Get, la filosofía de la programación orientada a objetos nos provee un mecanismo técnico que ayuda en la tarea de escribir clases elegantes: SOBRECARGA.

Veamos la clase según yo, antes de explicar:

class Persona{
private:
    genero_h genero;
    int edad;
    int estatura;
    char* nombre;
    char* apellido_p;
    char* apellido_m;
public:
    Persona();
    ~Persona();
    void Genero(genero_h);
    genero_h Genero();
    void Edad(int);
    int Edad();
    void Estatura(int);
    int Estatura();
    void Nombre(char*);
    char* Nombre();
    void ApellidoP(char*);
    char* ApellidoP();
    void ApellidoM(char*);
    char* ApellidoM();
};

Quizá la diferencia no sea tan clara, si tomamos en cuenta que en teoria es la misma cantidad de métodos, entonces, ¿cuál es la diferencia? Nosotros estamos sobrecargando los métodos para que en la implementación hagamos cosas como:

Persona persona1();
...
cout << persona1.Nombre() << endl;
...
persona1.Nombre("Maximiliano");
...

Que de otra forma se vería como:

Persona persona1();
...
cout << persona1.getNombre() << endl;
...
persona1.setNombre("Maximiliano");
...

En lo personal, los cambios que propongo sirven para hacer clases elegantes con una implementación igual de elegante, sé que Class.setAttrName() y Class.getAttrName() es significativo, ¿pero qué puede ser más intuitivo que Class.AttrName() y cambiar los parametros?

En conclusión, es como todo, depende del programador y del edificio cognoscitivo que cargue, habrá ocasiones en las que sea indispensable usar Set y Get (como en los beans) y otras en las que haya que recurrir a otros sufijos, es una buena práctica a pesar de todo…