Die C ++ Freund Schlüsselwort erlaubt eine class A
bezeichnen class B
als Freund. Dies ermöglicht Class B
den Zugriff auf die private
/ protected
Mitglieder von class A
.
Ich habe nie etwas darüber gelesen, warum dies in C # (und VB.NET) weggelassen wurde. Die meisten Antworten auf diese frühere StackOverflow-Frage scheinen zu sagen, dass es ein nützlicher Teil von C ++ ist und es gute Gründe gibt, es zu verwenden. Nach meiner Erfahrung müsste ich zustimmen.
Eine andere Frage scheint mir wirklich zu sein, wie man etwas Ähnliches wie friend
in einer C # -Anwendung macht. Während sich die Antworten im Allgemeinen um verschachtelte Klassen drehen, wirkt sie nicht ganz so elegant wie die Verwendung des friend
Schlüsselworts.
Das ursprüngliche Buch über Entwurfsmuster verwendet es regelmäßig in seinen Beispielen.
Zusammenfassend gesagt, warum friend
fehlt in C # und was ist die "beste Vorgehensweise" (oder die besten Methoden), um es in C # zu simulieren?
(Das internal
Schlüsselwort ist übrigens nicht dasselbe, es ermöglicht allen Klassen in der gesamten Assembly den Zugriff auf internal
Mitglieder, während friend
Sie einer bestimmten Klasse vollständigen Zugriff auf genau eine andere Klasse gewähren können .)
Antworten:
Freunde in der Programmierung zu haben, wird mehr oder weniger als "schmutzig" angesehen und ist leicht zu missbrauchen. Es unterbricht die Beziehungen zwischen Klassen und untergräbt einige grundlegende Attribute einer OO-Sprache.
Davon abgesehen ist es eine nette Funktion und ich habe sie selbst oft in C ++ verwendet. und möchte es auch in C # verwenden. Aber ich wette, wegen C # 's "reinem" OOness (im Vergleich zu C ++' s Pseudo-OOness) hat MS entschieden, dass C #, weil Java kein Freund-Schlüsselwort hat, auch nicht sollte (nur ein Scherz;))
Im Ernst: Intern ist nicht so gut wie Freund, aber es erledigt den Job. Denken Sie daran, dass Sie Ihren Code nur selten über eine DLL an Entwickler von Drittanbietern verteilen. Solange Sie und Ihr Team über die internen Klassen und deren Verwendung Bescheid wissen, sollte es Ihnen gut gehen.
BEARBEITEN Lassen Sie mich klarstellen, wie das Schlüsselwort friend OOP untergräbt.
Private und geschützte Variablen und Methoden sind möglicherweise einer der wichtigsten Bestandteile von OOP. Die Idee, dass Objekte Daten oder Logik enthalten können, die nur sie verwenden können, ermöglicht es Ihnen, Ihre Implementierung von Funktionen unabhängig von Ihrer Umgebung zu schreiben - und dass Ihre Umgebung keine Statusinformationen ändern kann, für die sie nicht geeignet ist. Wenn Sie friend verwenden, koppeln Sie die Implementierungen zweier Klassen miteinander - was viel schlimmer ist, als wenn Sie nur deren Schnittstelle gekoppelt haben.
quelle
friend
Ermöglicht nicht, dass beliebige Klassen oder Funktionen auf private Mitglieder zugreifen. Damit können die spezifischen Funktionen oder Klassen, die als Freund markiert wurden, dies tun. Die Klasse, die das private Mitglied besitzt, kontrolliert den Zugriff weiterhin zu 100%. Sie könnten genauso gut argumentieren, dass öffentliche Mitglieder Methoden. Beide stellen sicher, dass die in der Klasse speziell aufgeführten Methoden Zugriff auf private Mitglieder der Klasse erhalten.Als Randnotiz. Bei der Verwendung von friend geht es nicht darum, die Kapselung zu verletzen, sondern im Gegenteil darum, sie durchzusetzen. Wie Accessors + Mutatoren, Überladung von Operatoren, öffentliche Vererbung, Downcasting usw. wird es häufig missbraucht, aber dies bedeutet nicht, dass das Schlüsselwort keinen oder noch schlimmer einen schlechten Zweck hat.
Siehe Konrad Rudolph ‚s Nachricht in dem anderen Thread, oder wenn Sie es vorziehen , sehen Sie den entsprechenden Eintrag in der C ++ FAQ.
quelle
friend
Sie Zugriff auf ALLE Ihre privaten Mitglieder, auch wenn Sie nur eines davon festlegen müssen. Es gibt ein starkes Argument dafür, dass das Bereitstellen von Feldern für eine andere Klasse, die sie nicht benötigt, als "Verletzung der Kapselung" gilt. Es gibt Stellen in C ++, an denen dies erforderlich ist (Überladen von Operatoren), aber es gibt einen Kompromiss bei der Kapselung, der sorgfältig abgewogen werden muss. Es scheint, dass die C # -Designer der Meinung waren, dass sich ein Kompromiss nicht gelohnt hat.Zur Information ist eine andere verwandte, aber nicht ganz dieselbe Sache in .NET
[InternalsVisibleTo]
, mit der eine Assembly eine andere Assembly (z. B. eine Unit-Test-Assembly) bestimmen kann, die (effektiv) "internen" Zugriff auf Typen / Mitglieder in hat die ursprüngliche Baugruppe.quelle
Sie sollten in der Lage sein, die gleichen Dinge zu erreichen, für die "Freund" in C ++ verwendet wird, indem Sie Schnittstellen in C # verwenden. Sie müssen explizit definieren, welche Mitglieder zwischen den beiden Klassen übergeben werden. Dies ist zusätzliche Arbeit, kann aber auch das Verständnis des Codes erleichtern.
Wenn jemand ein Beispiel für eine vernünftige Verwendung von "Freund" hat, das nicht über Schnittstellen simuliert werden kann, teilen Sie es bitte mit! Ich möchte die Unterschiede zwischen C ++ und C # besser verstehen.
quelle
Mit
friend
einem C ++ hat der Designer eine genaue Kontrolle darüber, wem die privaten * Mitglieder ausgesetzt sind. Aber er ist gezwungen, jedes der privaten Mitglieder zu entlarven.Mit
internal
einem C # hat der Designer die genaue Kontrolle über die Gruppe der privaten Mitglieder, die er ausstellt. Offensichtlich kann er nur ein einziges privates Mitglied entlarven. Es wird jedoch allen Klassen in der Assembly ausgesetzt.In der Regel möchte ein Designer nur einige wenige private Methoden ausgewählten wenigen anderen Klassen zur Verfügung stellen. Beispielsweise kann in einem Klassenfabrikmuster erwünscht sein, dass die Klasse C1 nur durch die Klassenfabrik CF1 instanziiert wird. Daher kann die Klasse C1 einen geschützten Konstruktor und eine Friend-Class-Factory CF1 haben.
Wie Sie sehen können, haben wir zwei Dimensionen, entlang derer die Kapselung verletzt werden kann.
friend
bricht es entlang einer Dimension,internal
tut es entlang der anderen. Welches ist ein schlimmerer Verstoß gegen das Kapselungskonzept? Schwer zu sagen. Aber es wäre schön, beidesfriend
undinternal
verfügbar zu haben . Eine gute Ergänzung zu diesen beiden wäre außerdem der dritte Typ von Schlüsselwort, der von Mitglied zu Mitglied verwendet wird (wieinternal
) und die Zielklasse angibt (wiefriend
).* Der Kürze halber verwende ich "privat" anstelle von "privat und / oder geschützt".
- Nick
quelle
Tatsächlich bietet C # die Möglichkeit, dasselbe Verhalten auf reine OOP-Weise ohne spezielle Wörter zu erzielen - es handelt sich um private Schnittstellen.
Was die Frage betrifft Was ist das C # -Äquivalent eines Freundes? wurde als Duplikat zu diesem Artikel markiert und niemand schlägt dort eine wirklich gute Realisierung vor - ich werde hier auf beide Fragen eine Antwort zeigen.
Die Hauptidee war von hier aus: Was ist eine private Schnittstelle?
Angenommen, wir benötigen eine Klasse, die Instanzen anderer Klassen verwalten und spezielle Methoden für diese aufrufen kann. Wir möchten nicht die Möglichkeit geben, diese Methoden für andere Klassen aufzurufen. Dies ist genau das gleiche, was das C ++ - Schlüsselwort eines Freundes in der C ++ - Welt tut.
Ich denke, ein gutes Beispiel in der Praxis könnte das Full State Machine-Muster sein, bei dem einige Controller das aktuelle Statusobjekt aktualisieren und bei Bedarf zu einem anderen Statusobjekt wechseln.
Du könntest:
Controller.cs
Program.cs
Was ist mit der Vererbung?
Wir müssen die unter Da explizite Implementierungen von Schnittstellenelementen nicht als virtuell deklariert werden können , verwendete Technik verwenden und IState als geschützt markieren, um die Möglichkeit zu geben, auch von Controller abzuleiten.
Controller.cs
PlayerIdleState.cs
Und schließlich ein Beispiel zum Testen der Vererbung der Klasse Controller: ControllerTest.cs
Ich hoffe, ich decke alle Fälle ab und meine Antwort war nützlich.
quelle
Freund ist äußerst nützlich beim Schreiben von Unit-Tests.
Dies führt zwar zu einer geringfügigen Verschmutzung Ihrer Klassendeklaration, ist jedoch auch eine vom Compiler erzwungene Erinnerung daran, welche Tests tatsächlich den internen Status der Klasse betreffen könnten.
Eine sehr nützliche und saubere Redewendung, die ich gefunden habe, ist, wenn ich Factory-Klassen habe, die sie zu Freunden der von ihnen erstellten Elemente machen, die einen geschützten Konstruktor haben. Dies war insbesondere der Fall, als ich eine einzige Factory hatte, die für die Erstellung passender Rendering-Objekte für Report Writer-Objekte verantwortlich war und in einer bestimmten Umgebung gerendert wurde. In diesem Fall verfügen Sie über einen einzigen Wissenspunkt über die Beziehung zwischen den Report-Writer-Klassen (z. B. Bildblöcke, Layoutbänder, Seitenkopfzeilen usw.) und den entsprechenden Rendering-Objekten.
quelle
In C # fehlt das Schlüsselwort "friend" aus demselben Grund, aus dem die deterministische Zerstörung fehlt. Durch das Ändern von Konventionen fühlen sich die Menschen schlau, als ob ihre neuen Wege den alten Wegen anderer überlegen wären. Es geht nur um Stolz.
Zu sagen, dass "Freundklassen schlecht sind", ist genauso kurzsichtig wie andere unqualifizierte Aussagen wie "Keine Gotos verwenden" oder "Linux ist besser als Windows".
Das Schlüsselwort "friend" in Kombination mit einer Proxy-Klasse ist eine hervorragende Möglichkeit, nur bestimmte Teile einer Klasse bestimmten anderen Klassen zugänglich zu machen. Eine Proxy-Klasse kann als vertrauenswürdige Barriere gegen alle anderen Klassen fungieren. "public" erlaubt kein solches Targeting, und die Verwendung von "protected", um den Effekt mit der Vererbung zu erzielen, ist umständlich, wenn es wirklich keine konzeptionelle "is a" -Beziehung gibt.
quelle
Sie können C ++ "Freund" mit dem C # -Schlüsselwort "intern" nähern .
quelle
internal
ist dies viel sinnvoller und bietet einen hervorragenden Kompromiss zwischen Kapselung und Nutzen. Der Standardzugriff von Java ist jedoch noch besser.Dies ist eigentlich kein Problem mit C #. Dies ist eine grundlegende Einschränkung in IL. C # ist dadurch eingeschränkt, ebenso wie jede andere .Net-Sprache, die überprüfbar sein soll. Diese Einschränkung umfasst auch verwaltete Klassen, die in C ++ / CLI definiert sind ( Spezifikationsabschnitt 20.5 ).
Davon abgesehen denke ich, dass Nelson eine gute Erklärung dafür hat, warum dies eine schlechte Sache ist.
quelle
friend
ist keine schlechte Sache; im Gegenteil, es ist weitaus besser alsinternal
. Und Nelsons Erklärung ist schlecht und falsch.Hören Sie auf, sich für diese Einschränkung zu entschuldigen. Freund ist schlecht, aber intern ist gut? Sie sind dasselbe, nur dieser Freund gibt Ihnen eine genauere Kontrolle darüber, wer Zugriff haben darf und wer nicht.
Dies ist, um das Kapselungsparadigma durchzusetzen? Sie müssen also Accessor-Methoden schreiben und was nun? Wie sollen Sie alle (außer den Methoden der Klasse B) davon abhalten, diese Methoden aufzurufen? Sie können nicht, weil Sie dies auch nicht kontrollieren können, weil "Freund" fehlt.
Keine Programmiersprache ist perfekt. C # ist eine der besten Sprachen, die ich je gesehen habe, aber dumme Ausreden für fehlende Funktionen zu machen, hilft niemandem. In C ++ vermisse ich das einfache Ereignis- / Delegatensystem, die Reflexion (+ automatische De- / Serialisierung) und foreach, aber in C # vermisse ich das Überladen von Operatoren (ja, sag mir immer wieder, dass du es nicht brauchst), Standardparameter, eine Konstante Das kann nicht umgangen werden, Mehrfachvererbung (ja, sagen Sie mir immer wieder, dass Sie es nicht brauchten und Schnittstellen ein ausreichender Ersatz waren) und die Möglichkeit, eine Instanz aus dem Speicher zu löschen (nein, das ist nicht schrecklich schlecht, es sei denn, Sie sind eine Bastler)
quelle
||
/ überschreiben,&&
während Sie sie kurzschließen. Standardparameter wurden in C # 4 hinzugefügt.Es gibt das InternalsVisibleToAttribute seit .Net 3, aber ich vermute, dass es nur hinzugefügt wurde, um Testbaugruppen nach dem Aufkommen von Unit-Tests zu bedienen. Ich kann nicht viele andere Gründe sehen, es zu benutzen.
Es funktioniert auf Baugruppenebene, aber es erledigt die Arbeit dort, wo es nicht intern ist. Das heißt, Sie möchten eine Assembly verteilen, möchten jedoch, dass eine andere nicht verteilte Assembly privilegierten Zugriff darauf hat.
Zu Recht müssen die Freund-Assembly einen starken Schlüssel haben, um zu vermeiden, dass jemand neben Ihrer geschützten Assembly einen vorgetäuschten Freund erstellt.
quelle
Ich habe viele kluge Kommentare zum Schlüsselwort "Freund" gelesen und stimme zu, was nützlich ist, aber ich denke, welches Schlüsselwort "intern" weniger nützlich ist, und beide sind immer noch schlecht für die reine OO-Programmierung.
Was wir haben? (Sprichwort über "Freund" Ich sage auch über "intern")
Ja;
Wird "Freund" nicht verwendet, wird der Code besser?
Die Verwendung von friend verursacht einige lokale Probleme, die Nichtverwendung führt zu Problemen für Benutzer von Codebibliotheken.
Die Lösung für die Programmiersprache, die ich so sehe:
Was denkst du darüber? Ich denke, es ist die häufigste und rein objektorientierte Lösung. Sie können jede Methode, die Sie auswählen, auf eine beliebige Klasse zugreifen.
quelle
Ich werde nur die Frage "Wie" beantworten.
Hier gibt es so viele Antworten, aber ich möchte eine Art "Entwurfsmuster" vorschlagen, um dieses Merkmal zu erreichen. Ich werde einen einfachen Sprachmechanismus verwenden, der Folgendes umfasst:
Zum Beispiel haben wir 2 Hauptklassen: Student und Universität. Der Student hat einen GPA, auf den nur die Universität zugreifen darf. Hier ist der Code:
quelle
Ich vermute, dass es etwas mit dem C # -Kompilierungsmodell zu tun hat - IL zu erstellen, das JIT, das das zur Laufzeit kompiliert. dh: der gleiche Grund, warum sich C # -Generika grundlegend von C ++ - Generika unterscheiden.
quelle
Sie können es privat halten und mithilfe von Reflection Funktionen aufrufen. Das Test-Framework kann dies tun, wenn Sie es auffordern, eine private Funktion zu testen
quelle
Früher habe ich regelmäßig Freunde verwendet, und ich glaube nicht, dass dies eine Verletzung von OOP oder ein Zeichen für einen Designfehler ist. Es gibt mehrere Stellen, an denen es das effizienteste Mittel zum richtigen Zweck mit der geringsten Menge an Code ist.
Ein konkretes Beispiel ist das Erstellen von Schnittstellenbaugruppen, die eine Kommunikationsschnittstelle zu einer anderen Software bereitstellen. Im Allgemeinen gibt es einige Schwergewichtsklassen, die sich mit der Komplexität des Protokolls und den Peer-Besonderheiten befassen und ein relativ einfaches Modell zum Verbinden / Lesen / Schreiben / Weiterleiten / Trennen bereitstellen, bei dem Nachrichten und Benachrichtigungen zwischen der Client-App und der Assembly weitergeleitet werden. Diese Nachrichten / Benachrichtigungen müssen in Klassen eingeschlossen werden. Die Attribute müssen im Allgemeinen von der Protokollsoftware manipuliert werden, da sie deren Ersteller ist, aber viele Dinge müssen für die Außenwelt schreibgeschützt bleiben.
Es ist einfach albern zu erklären, dass es eine Verletzung von OOP für die Protokoll- / "Ersteller" -Klasse ist, intimen Zugriff auf alle erstellten Klassen zu haben - die Erstellerklasse musste auf dem Weg nach oben jedes Datenbit missen. Was ich als am wichtigsten empfunden habe, ist die Minimierung aller zusätzlichen BS-Codezeilen, zu denen das Modell "OOP for OOP's Sake" normalerweise führt. Zusätzliche Spaghetti machen einfach mehr Käfer.
Wissen die Leute, dass Sie das interne Schlüsselwort auf Attribut-, Eigenschafts- und Methodenebene anwenden können? Dies gilt nicht nur für die Klassendeklaration der obersten Ebene (obwohl die meisten Beispiele dies zu zeigen scheinen).
Wenn Sie eine C ++ - Klasse haben, die das Schlüsselwort friend verwendet, und dies in einer C # -Klasse emulieren möchten: 1. Deklarieren Sie die C # -Klasse als öffentlich. 2. Deklarieren Sie alle Attribute / Eigenschaften / Methoden, die in C ++ geschützt sind und somit Freunden als zugänglich sind intern in C # 3. Erstellen Sie schreibgeschützte Eigenschaften für den öffentlichen Zugriff auf alle internen Attribute und Eigenschaften
Ich bin damit einverstanden, dass es nicht zu 100% mit einem Freund identisch ist, und der Komponententest ist ein sehr wertvolles Beispiel für die Notwendigkeit eines Freundes (ebenso wie der Protokollierungscode des Protokollanalysators). Intern bietet jedoch die Belichtung für die Klassen, die Sie belichten möchten, und [InternalVisibleTo ()] übernimmt den Rest - es scheint, als wäre es speziell für Unit-Tests geboren worden.
Was Freunde angeht, "die besser sind, weil Sie explizit steuern können, welche Klassen Zugriff haben" - was zum Teufel machen überhaupt eine Gruppe verdächtiger böser Klassen in derselben Versammlung? Partitionieren Sie Ihre Baugruppen!
quelle
Die Freundschaft kann simuliert werden, indem Schnittstellen und Implementierungen getrennt werden. Die Idee ist: " Eine konkrete Instanz erforderlich, aber den Konstruktionszugriff dieser Instanz einschränken ".
Beispielsweise
Trotz der Tatsache, dass
ItsMeYourFriend()
nur eine öffentlicheFriend
Klasse darauf zugreifen kann, kann möglicherweise niemand eine konkrete Instanz derFriend
Klasse erhalten. Es hat einen privaten Konstruktor, während die Factory-New()
Methode eine Schnittstelle zurückgibt.Weitere Informationen finden Sie in meinem Artikel Freunde und interne Schnittstellenmitglieder kostenlos mit Codierung für Schnittstellen .
quelle
Einige haben vorgeschlagen, dass die Dinge durch die Verwendung von Freunden außer Kontrolle geraten können. Ich würde zustimmen, aber das mindert nicht seine Nützlichkeit. Ich bin mir nicht sicher, ob ein Freund das OO-Paradigma notwendigerweise mehr verletzt, als alle Ihre Klassenmitglieder öffentlich zu machen. Sicherlich erlaubt Ihnen die Sprache, alle Ihre Mitglieder öffentlich zu machen, aber es ist ein disziplinierter Programmierer, der diese Art von Entwurfsmuster vermeidet. Ebenso würde ein disziplinierter Programmierer die Verwendung von Freunden für bestimmte Fälle reservieren, in denen dies sinnvoll ist. Ich fühle, dass interne Belichtungen in einigen Fällen zu viel sind. Warum sollte eine Klasse oder Methode für alles in der Assembly verfügbar gemacht werden?
Ich habe eine ASP.NET-Seite, die meine eigene Basisseite erbt, die wiederum System.Web.UI.Page erbt. Auf dieser Seite habe ich Code, der die Fehlerberichterstattung für Endbenutzer für die Anwendung in einer geschützten Methode behandelt
Jetzt habe ich ein Benutzersteuerelement, das auf der Seite enthalten ist. Ich möchte, dass das Benutzersteuerelement die Fehlerberichterstattungsmethoden auf der Seite aufrufen kann.
Dies ist nicht möglich, wenn die ReportError-Methode geschützt ist. Ich kann es intern machen, aber es ist jedem Code in der Assembly ausgesetzt. Ich möchte nur, dass es den UI-Elementen angezeigt wird, die Teil der aktuellen Seite sind (einschließlich untergeordneter Steuerelemente). Insbesondere möchte ich, dass meine Basissteuerungsklasse genau dieselben Fehlerberichtsmethoden definiert und einfach Methoden auf der Basisseite aufruft.
Ich glaube, dass so etwas wie "Freund" nützlich und in der Sprache implementiert sein könnte, ohne die Sprache weniger "OO" zu machen, vielleicht als Attribute, so dass Klassen oder Methoden Freunde bestimmter Klassen oder Methoden sein können, so dass der Entwickler sehr viel bereitstellen kann spezifischer Zugang. Vielleicht so etwas wie ... (Pseudocode)
Im Fall meines vorherigen Beispiels haben Sie vielleicht etwas wie das Folgende (man kann die Semantik argumentieren, aber ich versuche nur, die Idee zu vermitteln):
Aus meiner Sicht besteht für das Freund-Konzept kein größeres Risiko, als Dinge öffentlich zu machen oder öffentliche Methoden oder Eigenschaften für den Zugriff auf Mitglieder zu erstellen. Wenn überhaupt, erlaubt ein Freund ein anderes Maß an Granularität bei der Zugänglichkeit von Daten und ermöglicht es Ihnen, diese Zugänglichkeit einzugrenzen, anstatt sie mit internen oder öffentlichen zu erweitern.
quelle
Wenn Sie mit C ++ arbeiten und sich selbst mit dem Schlüsselwort friend finden, ist dies ein sehr starker Hinweis darauf, dass Sie ein Designproblem haben. Warum zum Teufel muss eine Klasse auf die privaten Mitglieder einer anderen Klasse zugreifen?
quelle
Bsd
Es wurde gesagt, dass Freunde reine OOness verletzen. Dem stimme ich zu.
Es wurde auch festgestellt, dass Freunde bei der Kapselung helfen, was ich auch zustimme.
Ich denke, Freundschaft sollte zur OO-Methodik hinzugefügt werden, aber nicht ganz so wie in C ++. Ich möchte einige Felder / Methoden haben, auf die meine Freundesklasse zugreifen kann, aber ich möchte NICHT, dass sie auf ALLE meine Felder / Methoden zugreifen. Wie im wirklichen Leben ließ ich meine Freunde auf meinen persönlichen Kühlschrank zugreifen, aber ich ließ sie nicht auf mein Bankkonto zugreifen.
Man kann das wie folgt umsetzen
Das wird natürlich eine Compiler-Warnung erzeugen und den Intellisense verletzen. Aber es wird die Arbeit machen.
Nebenbei bemerkt denke ich, dass ein selbstbewusster Programmierer die Testeinheit durchführen sollte, ohne auf die privaten Mitglieder zuzugreifen. Dies ist völlig außerhalb des Rahmens, aber versuchen Sie, über TDD zu lesen. Wenn Sie dies dennoch tun möchten (mit C ++ wie Freunden), versuchen Sie etwas wie
Sie schreiben also Ihren gesamten Code, ohne UNIT_TESTING zu definieren, und wenn Sie den Komponententest durchführen möchten, fügen Sie #define UNIT_TESTING in die erste Zeile der Datei ein (und schreiben den gesamten Code, der den Komponententest durchführt, unter #if UNIT_TESTING). Das sollte sorgfältig gehandhabt werden.
Da ich denke, dass Unit-Tests ein schlechtes Beispiel für die Verwendung von Freunden sind, würde ich ein Beispiel geben, warum ich denke, dass Freunde gut sein können. Angenommen, Sie haben ein Bremssystem (Klasse). Mit der Zeit wird das Bremssystem abgenutzt und muss renoviert werden. Nun möchten Sie, dass nur ein lizenzierter Mechaniker das Problem beheben kann. Um das Beispiel weniger trivial zu machen, würde ich sagen, dass der Mechaniker seinen persönlichen (privaten) Schraubendreher verwenden würde, um es zu reparieren. Deshalb sollte die Mechanikerklasse mit der BreakingSystem-Klasse befreundet sein.
quelle
c.MyMethod((FriendClass) null, 5.5, 3)
von jeder Klasse aus aufrufen .Die Freundschaft kann auch mit "Agenten" simuliert werden - einigen inneren Klassen. Betrachten Sie folgendes Beispiel:
Es könnte viel einfacher sein, wenn es nur für den Zugriff auf statische Elemente verwendet wird. Vorteile für eine solche Implementierung sind, dass alle Typen im inneren Bereich von Freundschaftsklassen deklariert sind und im Gegensatz zu Schnittstellen der Zugriff auf statische Mitglieder ermöglicht.
quelle