Warum Getter und Setter/Accessors verwenden?

Question

Was ist der Vorteil der Verwendung von Gettern und Settern - die nur abfragen und setzen - anstatt einfach öffentliche Felder für diese Variablen zu verwenden?

Wenn Getter und Setter jemals mehr tun als nur das einfache Get/Set, kann ich dies sehr schnell herausfinden, aber ich bin nicht 100% klar, wie:

public String foo;

schlechter ist als:

private String foo;
public void setFoo(String foo) { this.foo = foo; }
public String getFoo() { return foo; }

Ersteres hingegen erfordert viel weniger Standardcode.

Answer 1

Obwohl nicht üblich für Getter und Setter, kann die Verwendung dieser Methoden auch in AOP/Proxy-Muster verwendet werden. z.B. für die Prüfung von Variablen können Sie AOP verwenden, um die Aktualisierung eines beliebigen Wertes zu prüfen. Ohne Getter/Setter ist es nicht möglich, außer man ändert den Code überall. Ich persönlich habe AOP nie dafür verwendet, aber es zeigt einen weiteren Vorteil der Verwendung von Getter/Setter.

Answer 2

Ein relativ moderner Vorteil von Gettern/Settern ist, dass sie das Durchsuchen von Code in getaggten (indizierten) Code-Editoren erleichtern. Wenn Sie z.B. sehen wollen, wer ein Element setzt, können Sie die Aufrufhierarchie des Setters öffnen.

Ist das Mitglied hingegen öffentlich, ist es mit den Tools nicht möglich, den Lese-/Schreibzugriff auf das Mitglied zu filtern. Sie müssen sich also durch alle Verwendungen des Mitglieds kämpfen.

Answer 3

Wenn Sie eine schreibgeschützte Variable benötigen, aber nicht wollen, dass der Client die Art des Zugriffs auf die Variable ändern muss, können Sie diese Vorlagenklasse verwenden:

template<typename MemberOfWhichClass, typename primative>                                       
class ReadOnly {
    friend MemberOfWhichClass;
public:
    template<typename number> inline bool   operator==(const number& y) const { return x == y; } 
    template<typename number> inline number operator+ (const number& y) const { return x + y; } 
    template<typename number> inline number operator- (const number& y) const { return x - y; } 
    template<typename number> inline number operator* (const number& y) const { return x * y; }  
    template<typename number> inline number operator/ (const number& y) const { return x / y; } 
    template<typename number> inline number operator<<(const number& y) const { return x << y; }
    template<typename number> inline number operator^(const number& y) const  { return x^y; }
    template<typename number> inline number operator~() const                 { return ~x; }
    template<typename number> inline operator number() const                  { return x; }
protected:
    template<typename number> inline number operator= (const number& y) { return x = y; }       
    template<typename number> inline number operator+=(const number& y) { return x += y; }      
    template<typename number> inline number operator-=(const number& y) { return x -= y; }      
    template<typename number> inline number operator*=(const number& y) { return x *= y; }      
    template<typename number> inline number operator/=(const number& y) { return x /= y; }      
    primative x;                                                                                
};      

Beispiel Verwendung:

class Foo {
public:
    ReadOnly<Foo, int> cantChangeMe;
};

Denken Sie daran, dass Sie auch bitweise und unäre Operatoren hinzufügen müssen! Dies ist nur der Einstieg für Sie

Answer 4

Ich wollte ein Beispiel aus der Praxis veröffentlichen, das ich gerade fertiggestellt habe:

Hintergrund - Ich verwende Hibernate Tools, um die Mappings für meine Datenbank zu generieren, eine Datenbank, die ich im Laufe der Entwicklung verändere. Ich ändere das Datenbankschema, stoße die Änderungen an und lasse dann die Hibernate-Tools laufen, um den Java-Code zu generieren. Alles ist gut und schön, bis ich diesen zugeordneten Entitäten Methoden hinzufügen möchte. Wenn ich die generierten Dateien ändere, werden sie jedes Mal überschrieben, wenn ich eine Änderung an der Datenbank vornehme. Also erweitere ich die generierten Klassen wie folgt:

package com.foo.entities.custom
class User extends com.foo.entities.User{
     public Integer getSomething(){
         return super.getSomething();             
     }
     public void setSomething(Integer something){
         something+=1;
         super.setSomething(something); 
     }
}

Was ich oben getan habe, ist, die vorhandenen Methoden der Superklasse mit meiner neuen Funktionalität (something+1) zu überschreiben, ohne die Basisklasse jemals zu berühren. Dasselbe Szenario, wenn Sie eine Klasse vor einem Jahr geschrieben haben und zu Version 2 übergehen wollen, ohne Ihre Basisklassen zu ändern (Test-Albtraum). hoffentlich hilft das.

Answer 5

Ich werde den Code für sich selbst sprechen lassen:

Mesh mesh = new Mesh();
BoundingVolume vol = new BoundingVolume();
mesh.boundingVolume = vol;
vol.mesh = mesh;
vol.compute(); 

Gefällt er Ihnen? Hier ist mit den Setzern:

Mesh mesh = new Mesh();
BoundingVolume vol = new BoundingVolume();
mesh.setBoundingVolume(vol);