Wenn eine Variable Getter und Setter hat, sollte sie öffentlich sein?

Ich habe eine Klasse mit einer Variablen, die privat ist, und die Klasse hat einen Getter und einen Setter für diese Variable. Warum diese Variable nicht öffentlich machen?

Der einzige Fall, den ich denke, dass Sie Getter und Setter verwenden müssen, ist, wenn Sie eine Operation neben dem Set oder dem Get ausführen müssen. Beispiel:

void my_class::set_variable(int x){
   /* Some operation like updating a log */
   this->variable = x;
}

Haben Sie jemals von einer Immobilie gehört?

Eine Eigenschaft ist ein Feld mit "eingebauten" Zugriffsmechanismen (Gettern und Setzern). Java zum Beispiel hat keine Eigenschaften, aber es wird empfohlen, die Getter und Setter in ein privates Feld zu schreiben. C # hat Eigenschaften.

Also, warum brauchen wir Getter und Setter? Grundsätzlich brauchen wir es, um das Feld zu schützen / abzuschirmen . Wenn Sie beispielsweise nicht auf das Feld in der Speicherreferenz zugreifen, greifen Sie auf eine Methode zu, mit der das Feld (die Referenz) geändert wird. Diese Methode ist in der Lage, einige Vorgänge auszuführen, die ein Benutzer nicht wissen möchte ( Verkapselung von Verhalten ), wie in Ihrem Beispiel. Stellen Sie sich zum Beispiel vor, dass ein Dutzend Klassen Ihr öffentliches Feld verwenden und Sie die Art und Weise ändern müssen, wie es verwendet wird. Sie müssten sich jede dieser Klassen ansehen, um die Art und Weise zu ändern, in der sie das Feld verwenden also "OOlysh".

Aber zum Beispiel, wenn Sie ein boolesches Feld haben, das als tot bezeichnet wird. Sie sollten zweimal überlegen, bevor Sie setDead und isDead deklarieren. Sie sollten für Menschen lesbare Accessoren schreiben , z. B. kill () anstelle von setDead.

Es gibt jedoch viele Frameworks, die davon ausgehen, dass Sie die JavaBean-Namenskonvention befolgen (hier wird über Java gesprochen). In diesen Fällen sollten Sie daher alle Get- und Setter deklarieren, die der Namenskonvektion folgen.

Dies ist nicht die populärste Meinung, aber ich sehe keinen großen Unterschied.

Setter und Getter sind eine ziemlich schlechte Idee. Ich habe darüber nachgedacht und ehrlich gesagt kann ich in der Praxis keinen Unterschied zwischen einem Setter / Getter einer Eigenschaft und einer öffentlichen Variablen finden.

In THEORY fügen ein Setter und Getter oder eine Eigenschaft einen Ort hinzu, an dem zusätzliche Aktionen ausgeführt werden können, wenn eine Variable gesetzt / geholt wird. Theoretisch isolieren sie Ihren Code von Änderungen.

In Wirklichkeit sehe ich selten Setter und Getter, die zum Hinzufügen einer Aktion verwendet werden, und wenn Sie eine Aktion hinzufügen möchten, möchten Sie sie ALLEN Settern oder Gettern einer Klasse (wie dem Protokollieren) hinzufügen, die Sie zu der Annahme veranlassen sollten, dass dies erforderlich ist sei eine bessere Lösung.

Wenn Sie beim Isolieren von Entwurfsentscheidungen ein Int in ein Long ändern, müssen Sie immer noch Ihre Setter ändern und mindestens jede Zeile überprüfen, die von Hand darauf zugreift - da ist nicht viel Isolation.

Veränderliche Klassen sollten ohnehin standardmäßig vermieden werden, daher sollte das Hinzufügen eines Setters das letzte Mittel sein. Dies wird durch das Builder-Muster verringert, bei dem ein Wert festgelegt werden kann, bis sich das Objekt in einem gewünschten Zustand befindet. Dann kann die Klasse unveränderlich werden und Ihre Setter Ausnahmen auslösen.

Was Getter betrifft, kann ich immer noch keinen großen Unterschied zwischen einem Getter und einer öffentlichen Endvariablen feststellen. Das Problem hierbei ist, dass es in beiden Fällen schlecht ist. Sie sollten nicht nach einem Wert von einem Objekt fragen und daran arbeiten - Sie sollten ein Objekt bitten, eine Operation für Sie durchzuführen.

Übrigens befürworte ich keine öffentlichen Variablen - ich sage, Setter und Getter (und sogar Eigenschaften) sind viel zu nahe dran, bereits öffentliche Variablen zu sein.

Das große Problem ist einfach, dass Leute, die keine OO-Programmierer sind, zu versucht sind, Setter und Getter zu verwenden, um Objekte in Eigenschaftskugeln (Strukturen) zu verwandeln, die herumgereicht und bearbeitet werden, so ziemlich das Gegenteil von der Funktionsweise von objektorientiertem Code.

Der Benutzer von Gettern und Setzern befasst sich mit dem Prinzip der Kapselung . Auf diese Weise können Sie die Funktionsweise innerhalb der Klasse ändern und alles am Laufen halten.

Wenn zum Beispiel 3 andere Objekte aufrufen foo.bar, um den Wert von bar zu erhalten, und Sie beschließen, den Namen von bar so weit zu ändern, dass Sie ein Problem haben. Wenn die Objekte aufgerufen foo.barwürden, müssten Sie alle Klassen ändern, die dies haben. Wenn ein Setter / Getter verwendet wird, müssen Sie nichts ändern. Eine andere Möglichkeit besteht darin, den Typ der Variablen zu ändern. In diesem Fall fügen Sie dem Getter / Setter einfach etwas Transformationscode hinzu, und schon geht es Ihnen gut.

Mit Gettern und Setzern können Sie auch steuern, welche Inhalte in einer bestimmten Variablen gespeichert werden. Wenn der Inhalt einen bestimmten Typ oder Wert haben muss, kann ein Teil Ihres Setter-Codes sicherstellen, dass der neue Wert diese Anforderungen erfüllt. Wenn die Variable öffentlich ist, können Sie nicht sicherstellen, dass diese Anforderungen erfüllt sind.

Dieser Ansatz macht Ihren Code außerdem anpassungsfähiger und verwaltbarer. Es ist viel einfacher, Änderungen an der Architektur einer Klasse vorzunehmen, wenn Funktionen vorhanden sind, die diese Architektur vor allen anderen Klassen oder Funktionen, die diese Klasse verwenden, verbergen. Die bereits erwähnte Änderung eines Variablennamens ist nur eine von vielen Änderungen, die viel einfacher durchzuführen sind, wenn Sie Funktionen wie Getter und Setter haben. Die allgemeine Idee ist, so viel wie möglich privat zu halten, insbesondere Ihre Klassenvariablen.

Sie sagen: "Ich denke, Sie müssen Getter und Setter nur dann verwenden, wenn Sie eine andere Operation als das Set oder das Get ausführen müssen."

Sie sollten Getter und Setter verwenden, wenn Sie zu einem späteren Zeitpunkt möglicherweise eine andere Operation als set and get ausführen müssen und in diesem Fall nicht Tausende von Quellcodezeilen ändern möchten.

Sie sollten Getter und Setter verwenden, wenn Sie nicht möchten, dass jemand die Adresse der Variablen nimmt und weitergibt, was katastrophale Folgen hat, wenn diese Variable dann geändert werden kann, ohne dass der Quellcode dies erwähnt, oder auch nachdem das Objekt nicht mehr vorhanden ist .

Lassen Sie uns zunächst das Paradigma klarstellen.

• Datenstrukturen -> Ein Layout des Speichers, das von sachkundigen Funktionen durchlaufen und bearbeitet werden kann.
• Objekte -> Ein eigenständiges Modul, das seine Implementierung verbirgt und eine Schnittstelle bereitstellt, über die kommuniziert werden kann.

Wo ist ein Getter / Setter nützlich?

Sind Getter / Setter in Datenstrukturen nützlich? Nein.

Eine Datenstruktur ist eine Speicherlayoutspezifikation, die einer Reihe von Funktionen gemeinsam ist und von diesen manipuliert wird.

Im Allgemeinen kann jede alte neue Funktion eine Datenstruktur manipulieren, wenn dies so geschieht, dass die anderen Funktionen es noch verstehen können, dann wird die Funktion der Familie hinzugefügt. Ansonsten ist es eine Schurkenfunktion und eine Fehlerquelle.

Verstehen Sie mich nicht falsch, es könnte mehrere Funktionsfamilien geben, die überall über diese Datenstruktur mit Snitches, Turncoats und Double-Agents streiten. Es ist in Ordnung, wenn jeder seine eigene Datenstruktur hat, mit der er spielen kann, aber wenn er sie teilt ... Stellen Sie sich vor, mehrere kriminelle Familien sind sich nicht einig über Politik, es kann sehr schnell zu einem Durcheinander kommen.

Gibt es eine Möglichkeit, die Datenstruktur zu verschlüsseln, damit Schurkenfunktionen nicht alles durcheinander bringen, wenn die erweiterten Funktionsfamilien dies erreichen können? Ja, sie heißen Objekte.

Sind Getter / Setter in Objekten nützlich? Nein.

Der springende Punkt beim Einbinden einer Datenstruktur in ein Objekt war, sicherzustellen, dass keine unerwünschten Funktionen vorhanden sind. Wenn die Funktion der Familie beitreten wollte, musste sie zuerst gründlich überprüft werden und dann Teil des Objekts werden.

Der Zweck eines Get- und Setters besteht darin, Funktionen außerhalb des Objekts die Möglichkeit zu geben, das Speicherlayout des Objekts direkt zu ändern. Das klingt nach einer offenen Tür, die es Schurken erlaubt ...

Der Edge-Fall

Es gibt zwei Situationen, in denen ein öffentlicher Getter / Setter Sinn macht.

• Ein Teil der Datenstruktur innerhalb des Objekts wird vom Objekt verwaltet, aber nicht vom Objekt gesteuert.
• Eine Schnittstelle, die eine allgemeine Abstraktion einer Datenstruktur beschreibt, bei der erwartet wird, dass einige Elemente nicht die Kontrolle über das implementierende Objekt haben.

Container und Containerschnittstellen sind perfekte Beispiele für diese beiden Situationen. Der Container verwaltet die Datenstrukturen (verknüpfte Liste, Karte, Baum) intern, übergibt jedoch die Kontrolle über das spezifische Element an alle und verschiedene. Die Schnittstelle abstrahiert dies und ignoriert die Implementierung vollständig und beschreibt nur die Erwartungen.

Leider machen viele Implementierungen das falsch und definieren die Schnittstelle dieser Art von Objekten, um einen direkten Zugriff auf das eigentliche Objekt zu ermöglichen. So etwas wie:

interface Container<T>
{
    typedef ...T... TRef; //<somehow make TRef to be a reference or pointer to the memory location of T
    TRef item(int index); 
}

Das ist kaputt. Die Implementierungen von Container müssen die Kontrolle über ihre Interna explizit an denjenigen übergeben, der sie verwendet. Ich habe noch keine Sprache mit veränderlichem Wert gesehen, bei der dies in Ordnung ist (Sprachen mit Semantik mit unveränderlichem Wert sind per Definition in Bezug auf Datenkorruption in Ordnung, jedoch nicht unbedingt in Bezug auf Datenspionage).

Sie können den Get / Setter verbessern / korrigieren, indem Sie nur die Kopiersemantik oder einen Proxy verwenden:

interface Proxy<T>
{
     operator T(); //<returns a copy
     ... operator ->(); //<permits a function call to be forwarded to an element
     Proxy<T> operator=(T); //< permits the specific element to be replaced/assigned by another T.
}

interface Container<T>
{
     Proxy<T> item(int index);
     T item(int index); //<When T is a copy of the original value.
     void item(int index, T new_value); //<where new_value is used to replace the old value
}

Möglicherweise könnte eine Rogue-Funktion hier noch Chaos anrichten (mit genügend Aufwand sind die meisten Dinge möglich), aber die Kopiersemantik und / oder der Proxy verringern die Wahrscheinlichkeit für eine Reihe von Fehlern.

• Überlauf
• Unterlauf
• Interaktionen mit dem Unterelement sind typüberprüft / typüberprüfbar (in Typ-Lose-Sprachen ist dies ein Segen)
• Das tatsächliche Element kann speicherresident sein oder nicht.

Private Getter / Setter

Dies ist die letzte Bastion von Gettern und Setzern, die direkt an dem Typ arbeiten. Tatsächlich würde ich diese Getter und Setter nicht einmal als Accessoren und Manipulatoren bezeichnen.

In diesem Zusammenhang erfordert die Manipulation eines bestimmten Teils der Datenstruktur manchmal immer / fast immer / im Allgemeinen eine bestimmte Buchführung. Sagen wir, wenn Sie das Stammverzeichnis eines Baums aktualisieren, muss der Look-Aside-Cache gelöscht werden, oder wenn Sie auf das externe Datenelement zugreifen, muss eine Sperre erlangt / aufgehoben werden. In diesen Fällen ist es sinnvoll, den DRY-Principal anzuwenden und diese Aktionen zusammenzufassen.

Im privaten Kontext ist es für die anderen Funktionen in der Familie immer noch möglich, diese "Get-and-Setter" zu umgehen und die Datenstruktur zu manipulieren. Deshalb betrachte ich sie eher als Accessoren und Manipulatoren. Sie können direkt auf die Daten zugreifen oder sich auf ein anderes Familienmitglied verlassen, um diesen Teil richtig zu machen.

Geschützte Getter / Setter

In einem geschützten Kontext unterscheidet es sich nicht sonderlich von einem öffentlichen Kontext. Fremd möglicherweise Rogue-Funktionen wollen Zugriff auf die Datenstruktur. Also nein, wenn sie existieren, funktionieren sie wie öffentliche Getter / Setter.

Aus C ++ - Erfahrung ist der Setter / Getter für zwei Szenarien hilfreich:

1. Wenn Sie vor dem Zuweisen von Werten wie Zeichenfolgen oder Arrays eine Überprüfung der Integrität durchführen müssen.
2. Dies kann hilfreich sein, wenn eine Überladung von Funktionen erforderlich ist, z. B. die Zuweisung von int zu bool, wenn -1 (oder negative Werte) falsch ist. und umgekehrt für Getter.

Abgesehen davon ist Sicherheit ein wichtiger Punkt, aber seine Bedeutung ist auf sehr wenige Entwicklungsanwendungen wie Login- oder Datenbankzugriffsmodule beschränkt. Warum sich die Mühe machen, extra zu programmieren, wenn nur wenige Leute Ihr Modul benutzen?