Warum sollte der Unterricht nicht so gestaltet werden, dass er „offen“ ist?

Beim Lesen verschiedener Stapelüberlauffragen und des Codes anderer wird der allgemeine Konsens zum Entwerfen von Klassen geschlossen. Dies bedeutet, dass in Java und C # standardmäßig alles privat ist, Felder final sind, einige Methoden final sind und manchmal Klassen sogar final sind .

Die Idee dahinter ist, Implementierungsdetails zu verbergen, was ein sehr guter Grund ist. Bei den protectedmeisten OOP-Sprachen und Polymorphismen funktioniert dies jedoch nicht.

Jedes Mal, wenn ich einer Klasse Funktionen hinzufügen oder ändern möchte, werde ich normalerweise durch private und endgültige Platzierungen behindert. Hier sind Implementierungsdetails wichtig: Sie übernehmen die Implementierung und erweitern sie, wobei Sie die Konsequenzen genau kennen. Da ich jedoch keinen Zugriff auf private und endgültige Felder und Methoden bekomme, habe ich drei Möglichkeiten:

• Erweitern Sie die Klasse nicht, sondern umgehen Sie das Problem, das zu komplexerem Code führt
• Kopieren Sie die gesamte Klasse und fügen Sie sie ein, um die Wiederverwendbarkeit des Codes zu beenden
• Fork das Projekt

Das sind keine guten Optionen. Warum wird es nicht protectedin Projekten verwendet, die in Sprachen geschrieben sind, die es unterstützen? Warum verbieten einige Projekte explizit das Erben von Klassen?

Das Entwerfen von Klassen, die im erweiterten Zustand ordnungsgemäß funktionieren, insbesondere wenn der Programmierer, der das Erweitern ausführt, nicht vollständig versteht, wie die Klasse funktionieren soll, ist mit erheblichem zusätzlichen Aufwand verbunden. Sie können nicht einfach alles, was privat ist, öffentlich (oder geschützt) machen und das als "offen" bezeichnen. Wenn Sie zulassen, dass eine andere Person den Wert einer Variablen ändert, müssen Sie berücksichtigen, wie sich alle möglichen Werte auf die Klasse auswirken. (Was ist, wenn sie die Variable auf null setzen? Ein leeres Array? Eine negative Zahl?) Dasselbe gilt, wenn andere Personen eine Methode aufrufen dürfen. Es bedarf sorgfältiger Überlegungen.

Es ist also nicht so sehr wichtig, dass Klassen nicht geöffnet sind, aber manchmal ist es die Mühe nicht wert, sie zu öffnen.

Natürlich ist es auch möglich, dass die Bibliotheksautoren nur faul waren. Kommt darauf an, von welcher Bibliothek du sprichst. :-)

Standardmäßig alles privat zu machen, klingt hart, aber sehen Sie es sich von der anderen Seite an: Wenn alles standardmäßig privat ist, sollte es eine bewusste Entscheidung sein, etwas öffentlich zu machen (oder zu schützen, was fast dasselbe ist); Es ist der Vertrag des Klassenautors mit Ihnen, dem Verbraucher, über die Verwendung der Klasse. Dies ist für Sie beide ein Vorteil: Der Autor kann das Innenleben der Klasse ändern, solange die Benutzeroberfläche unverändert bleibt. und Sie wissen genau, auf welche Teile der Klasse Sie sich verlassen können und welche Änderungen unterliegen.

Die zugrunde liegende Idee ist "lose Kopplung" (auch als "schmale Schnittstellen" bezeichnet); Sein Wert liegt darin, die Komplexität gering zu halten. Durch Verringern der Anzahl der Arten, in denen Komponenten interagieren können, wird auch das Ausmaß der gegenseitigen Abhängigkeit zwischen ihnen verringert. und gegenseitige Abhängigkeit ist eine der schlimmsten Arten von Komplexität, wenn es um Wartung und Änderungsmanagement geht.

In gut gestalteten Bibliotheken haben Klassen, die es wert sind, durch Vererbung erweitert zu werden, geschützte und öffentliche Mitglieder an genau den richtigen Stellen und verbergen alles andere.

Alles, was nicht privat ist, soll in jeder zukünftigen Version der Klasse mehr oder weniger mit unverändertem Verhalten existieren . Tatsächlich kann es als Teil der API betrachtet werden, dokumentiert oder nicht. Aus diesem Grund kann es später zu Kompatibilitätsproblemen kommen, wenn zu viele Details angezeigt werden.

In Bezug auf "final" resp. "versiegelte" Klassen, ein typischer Fall sind unveränderliche Klassen. Viele Teile des Frameworks hängen davon ab, dass Zeichenfolgen unveränderlich sind. Wenn die String-Klasse nicht final wäre, wäre es einfach (sogar verlockend), eine veränderbare String-Unterklasse zu erstellen, die in vielen anderen Klassen alle Arten von Fehlern verursacht, wenn sie anstelle der unveränderlichen String-Klasse verwendet wird.

In OO gibt es zwei Möglichkeiten, dem vorhandenen Code Funktionalität hinzuzufügen.

Der erste ist durch Vererbung: Sie nehmen eine Klasse und leiten daraus ab. Vererbung sollte jedoch mit Vorsicht verwendet werden. Sie sollten die öffentliche Vererbung hauptsächlich verwenden, wenn Sie eine isA- Beziehung zwischen der Basis und der abgeleiteten Klasse haben (z. B. ist ein Rechteck eine Form). Vermeiden Sie stattdessen die öffentliche Vererbung, um eine vorhandene Implementierung wiederzuverwenden. Grundsätzlich wird die öffentliche Vererbung verwendet, um sicherzustellen, dass die abgeleitete Klasse dieselbe Schnittstelle wie die Basisklasse (oder eine größere) hat, sodass Sie das Substitutionsprinzip von Liskov anwenden können .

Die andere Methode zum Hinzufügen von Funktionen ist die Verwendung der Delegierung oder Komposition. Sie schreiben Ihre eigene Klasse, die die vorhandene Klasse als internes Objekt verwendet, und delegieren einen Teil der Implementierungsarbeit an sie.

Ich bin mir nicht sicher, welche Idee hinter all den Finalen in der Bibliothek steckt, die Sie verwenden möchten. Wahrscheinlich wollten die Programmierer sicherstellen, dass Sie keine neue Klasse von ihren erben, da dies nicht der beste Weg ist, ihren Code zu erweitern.

Die meisten Antworten haben Recht: Klassen sollten versiegelt werden (final, NotOverridable usw.), wenn das Objekt nicht entworfen oder erweitert werden soll.

Ich würde jedoch nicht in Betracht ziehen, einfach alles richtige Code-Design zu schließen. Das "O" in SOLID steht für "Open-Closed-Prinzip" und besagt, dass eine Klasse für Änderungen "geschlossen", für Erweiterungen jedoch "offen" sein soll. Die Idee ist, dass Sie Code in einem Objekt haben. Es funktioniert gut. Das Hinzufügen von Funktionen sollte nicht das Öffnen dieses Codes und das Vornehmen von chirurgischen Änderungen erfordern, die das bisherige Arbeitsverhalten beeinträchtigen könnten. Stattdessen sollte man Vererbung oder Abhängigkeitsinjektion verwenden können, um die Klasse zu "erweitern", um zusätzliche Dinge zu tun.

Beispielsweise kann eine Klasse "ConsoleWriter" Text abrufen und an die Konsole ausgeben. Das macht es gut. In bestimmten Fällen muss jedoch AUCH die gleiche Ausgabe in eine Datei geschrieben werden. Das Öffnen des ConsoleWriter-Codes, das Ändern der externen Schnittstelle, um den Hauptfunktionen den Parameter "WriteToFile" hinzuzufügen, und das Platzieren des zusätzlichen Datei-Schreibcodes neben dem Konsole-Schreibcode wird im Allgemeinen als eine schlechte Sache angesehen.

Stattdessen können Sie eine der beiden folgenden Aktionen ausführen: Sie können von ConsoleWriter das Format ConsoleAndFileWriter ableiten und die Write () - Methode erweitern, um zuerst die Basisimplementierung aufzurufen und dann auch in eine Datei zu schreiben. Sie können auch ein Interface IWriter aus ConsoleWriter extrahieren und dieses Interface erneut implementieren, um zwei neue Klassen zu erstellen. einen FileWriter und einen "MultiWriter", der anderen IWriter zugewiesen werden kann und jeden Aufruf seiner Methoden an alle angegebenen Writer "sendet". Welches Sie wählen, hängt davon ab, was Sie brauchen werden. Einfache Ableitung ist zwar einfacher, aber wenn Sie nicht genau wissen, ob Sie die Nachricht irgendwann an einen Netzwerkclient senden müssen, müssen Sie drei Dateien, zwei Named Pipes und die Konsole extrahieren und die Schnittstelle erstellen "Y-Adapter"; es'

Wenn die Write () - Funktion noch nie als virtuell deklariert wurde (oder versiegelt wurde), haben Sie jetzt Probleme, wenn Sie den Quellcode nicht kontrollieren. Manchmal sogar, wenn du es tust. Dies ist im Allgemeinen eine schlechte Position, und es frustriert Benutzer von Closed-Source- oder Limited-Source-APIs, wenn dies geschieht. Es gibt jedoch berechtigte Gründe, warum Write () oder die gesamte Klasse ConsoleWriter versiegelt sind. In einem geschützten Feld können sich vertrauliche Informationen befinden (die wiederum von einer Basisklasse überschrieben werden, um diese Informationen bereitzustellen). Möglicherweise ist die Validierung unzureichend. Wenn Sie eine API schreiben, müssen Sie davon ausgehen, dass die Programmierer, die Ihren Code verwenden, nicht schlauer oder gütiger sind als der durchschnittliche "Endbenutzer" des endgültigen Systems. so wirst du nie enttäuscht.

Ich denke, es ist wahrscheinlich von allen Leuten, die eine OO-Sprache für C-Programmierung verwenden. Ich sehe dich an, Java. Wenn Ihr Hammer wie ein Objekt geformt ist, Sie jedoch ein prozedurales System möchten und / oder Klassen nicht wirklich verstehen, muss Ihr Projekt gesperrt werden.

Grundsätzlich muss Ihr Projekt, wenn Sie in einer oo-Sprache schreiben möchten, dem oo-Paradigma folgen, das die Erweiterung umfasst. Natürlich, wenn jemand eine Bibliothek in einem anderen Paradigma geschrieben hat, sollte man sie vielleicht sowieso nicht erweitern.

Weil sie es nicht besser wissen.

Die ursprünglichen Autoren klammern sich wahrscheinlich an ein Missverständnis der SOLID-Prinzipien, das aus einer verwirrten und komplizierten C ++ - Welt stammt.

Ich hoffe, Sie werden feststellen, dass die Rubin-, Python- und Perlwelten nicht die Probleme haben, die die Antworten hier für den Grund der Versiegelung halten. Beachten Sie, dass es orthogonal zur dynamischen Typisierung ist. Zugriffsmodifikatoren sind in den meisten (allen?) Sprachen einfach zu bedienen. C ++ - Felder können durch Umwandeln in einen anderen Typ verworfen werden (C ++ ist schwächer). Java und C # können Reflektion verwenden. Zugriffsmodifikatoren machen die Dinge gerade so schwierig, dass Sie es nicht tun können, es sei denn, Sie möchten WIRKLICH.

Das Versiegeln von Klassen und das Markieren von Mitgliedern als privat verstößt ausdrücklich gegen das Prinzip, dass einfache Dinge einfach sein sollten und schwierige Dinge möglich sein sollten. Plötzlich sollten Dinge einfach sein, nicht wahr?

Ich möchte Sie ermutigen, den Standpunkt der ursprünglichen Autoren zu verstehen. Ein Großteil davon stammt von einer akademischen Idee der Verkapselung, die in der realen Welt niemals absoluten Erfolg gezeigt hat. Ich habe noch nie ein Framework oder eine Bibliothek gesehen, in der sich ein Entwickler irgendwo nicht gewünscht hätte, dass es ein wenig anders funktioniert, und keinen guten Grund hatte, es zu ändern. Es gibt zwei Möglichkeiten, die die ursprünglichen Softwareentwickler geplagt haben, die Mitglieder besiegelt und privat gemacht haben.

1. Arroganz - sie glaubten wirklich, sie seien offen für Erweiterungen und geschlossen für Modifikationen
2. Selbstzufriedenheit - sie wussten, dass es andere Anwendungsfälle geben könnte, entschieden sich jedoch, nicht für diese Anwendungsfälle zu schreiben

Ich denke, im Unternehmensrahmen wird # 2 wahrscheinlich der Fall sein. Diese C ++ -, Java- und .NET-Frameworks müssen "fertig" sein und bestimmten Richtlinien folgen. Diese Richtlinien beziehen sich normalerweise auf versiegelte Typen, es sei denn, der Typ wurde explizit als Teil einer Typhierarchie und privater Member für viele Dinge entworfen, die für andere nützlich sein könnten. Da sie sich jedoch nicht direkt auf diese Klasse beziehen, werden sie nicht verfügbar gemacht . Das Extrahieren eines neuen Typs wäre zu teuer, um ihn zu unterstützen, zu dokumentieren usw.

Die gesamte Idee hinter Zugriffsmodifikatoren ist, dass Programmierer vor sich selbst geschützt werden sollten. "C-Programmierung ist schlecht, weil Sie sich damit in den Fuß schießen können." Es ist keine Philosophie, der ich als Programmierer zustimme.

Ich bevorzuge Pythons Name Mangling-Ansatz. Sie können ganz einfach (viel einfacher als Nachdenken) Privates ersetzen, wenn Sie dies benötigen. Eine großartige Beschreibung dazu finden Sie hier: http://bytebaker.com/2009/03/31/python-properties-vs-java-access-modifiers/

Rubys privater Modifizierer ist eigentlich eher wie in C # geschützt und hat keinen privaten als C # Modifizierer. Geschützt ist ein bisschen anders. Hier gibt es eine gute Erklärung: http://www.ruby-lang.org/en/documentation/ruby-from-other-languages/

Denken Sie daran, dass Ihre statische Sprache nicht den veralteten Stilen des in dieser Sprache verfassten Codes entsprechen muss.

EDIT: Ich glaube, Klassen sollten so gestaltet sein, dass sie offen sind. Mit einigen Einschränkungen, sollte aber nicht für die Vererbung geschlossen werden.

Warum: "Final Classes" oder "Sealed Classes" erscheinen mir komisch. Ich muss nie eine meiner eigenen Klassen als "final" ("versiegelt") markieren, weil ich diese Klassen möglicherweise später vererben muss.

Ich habe Bibliotheken von Drittanbietern mit Klassen gekauft / heruntergeladen (die meisten visuellen Steuerelemente), und wirklich dankbar, dass keine dieser Bibliotheken "final" verwendet hat, auch wenn dies von der Programmiersprache unterstützt wird, in der sie codiert wurden, da ich diese Klassen nicht mehr erweitert habe. auch wenn ich bibliotheken ohne den quellcode kompiliert habe.

Manchmal muss ich mich mit einigen gelegentlichen "versiegelten" Klassen auseinandersetzen und habe damit aufgehört, einen neuen "Wrapper" für die Klasse zu erstellen, der ähnliche Mitglieder hat.

class MyBaseWrapper {
  protected FinalClass _FinalObject;

  public virtual DoSomething()
  {
    // these method cannot be overriden,
    // its from a "final" class
    // the wrapper method can  be open and virtual:
    FinalObject.DoSomething();
  }
} // class MyBaseWrapper


class MyBaseWrapper: MyBaseWrapper {

  public override DoSomething()
  {
    // the wrapper method allows "overriding",
    // a method from a "final" class:
    DoSomethingNewBefore();
    FinalObject.DoSomething();
    DoSomethingNewAfter();
  }
} // class MyBaseWrapper

Scope-Clasifier ermöglichen das "Versiegeln" einiger Features, ohne die Vererbung einzuschränken.

Als ich von Structured Progr. Bei OOP habe ich angefangen, private Klassenmitglieder zu verwenden, aber nach vielen Projekten habe ich die Verwendung von protected beendet und diese Eigenschaften oder Methoden gegebenenfalls öffentlich gemacht .

PS Ich mag "final" nicht als Schlüsselwort in C #, sondern verwende "sealed" wie Java oder "sterile" nach der Vererbungsmetapher. Außerdem ist "final" ein mehrdeutiges Wort, das in verschiedenen Zusammenhängen verwendet wird.