


Wie setzen Unterklassen private Eigenschaften durch Erben der SetName -Methode der übergeordneten Klasse?
Mechanismus für Unterklassen zur Erben von übergeordneten Klassenmethoden, um auf private Attribute zuzugreifen
Der Vererbungsmechanismus in Java, insbesondere der Zugriff auf die privaten Eigenschaften der übergeordneten Klasse durch die übergeordnete Klassenmethode, ist häufig verwirrend. In diesem Artikel wird dieses Problem eingehend untersucht und es mit einem bestimmten Beispiel veranschaulicht.
Szenenbeschreibung
Angenommen, wir haben einen Employee
der Elternklasse und einen Unterklass Manager
:
Employee
:
öffentliche abstrakte Klasse Angestellte { privater Zeichenfolge Name; public String getName () {return name; } public void setName (String name) {this.name = name; } öffentliche abstrakte void Showmsg (); }
Unterklasse Manager
:
Der öffentliche Klassenmanager erweitert Mitarbeiter { Privatschreiber; öffentlicher Manager () {} public Manager (Clerk Clerk) {this.clerk = Clerk; } @Override public void Showmsg () {System.out.println (this.getName ()); } }
Im Testcode können wir feststellen, dass Manager
Managerinstanz auch dann, wenn name
in Employee
private
erklärt wird, den Wert des Attributs über die setName
-Methode einstellen und drucken kann.
Antwort
Der Schlüssel liegt in Javas Zugriffskontrolle und Objektpolymorphismus.
Einkapselung privater Attribute: Das
private
Schlüsselwort stellt sicher, dassname
nur mit Methoden innerhalbEmployee
zugegriffen werden kann.Manager
Unterklassenmanager kann nicht direkt aufname
zugreifen.Vererbung der Methode:
Manager
erbt diesetName
-Methode desEmployee
. Dies bedeutet nicht, dassManager
direkten Zugriff aufname
erhalten hat.Polymorphismus: Wenn wir ein
Manager
-Objekt erstellen und diesetName
-Methode aufrufen, obwohl die Methode imManager
-Objekt aufgerufen wird, wird die inEmployee
definiertesetName
-Methode tatsächlich ausgeführt. Da diesetName
-Methode in derEmployee
definiert ist, verfügt sie über die Erlaubnis, auf private MitgliederEmployee
(einschließlichname
) zuzugreifen.
Daher greift Manager
nicht direkt auf name
zu, sondern betreibt name
indirekt über die ererbte setName
-Methode. Dies spiegelt die Einkapselung und den Polymorphismus von Java wider: Die Kapselung schützt die Integrität der Daten, und Polymorphismus ermöglicht es Unterklassen, private Mitglieder der Elternklasse indirekt mit den Methoden der Elternklasse zu betreiben. Dies bricht die Kapselung nicht durch, sondern nutzt die Merkmale der objektorientierten Programmierung.
Das obige ist der detaillierte Inhalt vonWie setzen Unterklassen private Eigenschaften durch Erben der SetName -Methode der übergeordneten Klasse?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!

Heiße KI -Werkzeuge

Undresser.AI Undress
KI-gestützte App zum Erstellen realistischer Aktfotos

AI Clothes Remover
Online-KI-Tool zum Entfernen von Kleidung aus Fotos.

Undress AI Tool
Ausziehbilder kostenlos

Clothoff.io
KI-Kleiderentferner

Video Face Swap
Tauschen Sie Gesichter in jedem Video mühelos mit unserem völlig kostenlosen KI-Gesichtstausch-Tool aus!

Heißer Artikel

Heiße Werkzeuge

Notepad++7.3.1
Einfach zu bedienender und kostenloser Code-Editor

SublimeText3 chinesische Version
Chinesische Version, sehr einfach zu bedienen

Senden Sie Studio 13.0.1
Leistungsstarke integrierte PHP-Entwicklungsumgebung

Dreamweaver CS6
Visuelle Webentwicklungstools

SublimeText3 Mac-Version
Codebearbeitungssoftware auf Gottesniveau (SublimeText3)

Heiße Themen











In C++ ist ein Abschluss ein Lambda-Ausdruck, der auf externe Variablen zugreifen kann. Um einen Abschluss zu erstellen, erfassen Sie die äußere Variable im Lambda-Ausdruck. Abschlüsse bieten Vorteile wie Wiederverwendbarkeit, Ausblenden von Informationen und verzögerte Auswertung. Sie sind in realen Situationen nützlich, beispielsweise bei Ereignishandlern, bei denen der Abschluss auch dann noch auf die äußeren Variablen zugreifen kann, wenn diese zerstört werden.

Dürfen. C++ erlaubt verschachtelte Funktionsdefinitionen und Aufrufe. Externe Funktionen können integrierte Funktionen definieren und interne Funktionen können direkt innerhalb des Bereichs aufgerufen werden. Verschachtelte Funktionen verbessern die Kapselung, Wiederverwendbarkeit und Bereichskontrolle. Interne Funktionen können jedoch nicht direkt auf lokale Variablen externer Funktionen zugreifen, und der Rückgabewerttyp muss mit der Deklaration der externen Funktion übereinstimmen. Interne Funktionen können nicht selbstrekursiv sein.

Zugriffsbeschränkungen: Die Kapselung schränkt den Zugriff auf interne Daten ein und manchmal kann es schwierig sein, auf notwendige Informationen zuzugreifen. Mögliche Inflexibilität: Eine strikte Kapselung kann die Anpassbarkeit des Codes einschränken und es schwierig machen, ihn an spezifische Anforderungen anzupassen. Testschwierigkeit: Die Kapselung kann das Testen der internen Implementierung erschweren, da der externe Zugriff eingeschränkt ist. Code-Redundanz: Um die Kapselung aufrechtzuerhalten, ist es manchmal erforderlich, Code zu duplizieren, beispielsweise durch die Erstellung mehrerer Getter- und Setter-Methoden. Leistungsaufwand: Für den Zugriff auf private Mitglieder sind Getter- und Setter-Methoden erforderlich, was zu zusätzlichem Leistungsaufwand führen kann. Abwägen von Datenschutz und Wartbarkeit: Bei der Abwägung von Datenschutz und Wartbarkeit sollten die folgenden Faktoren berücksichtigt werden: Sicherheitsanforderungen: Wenn die Daten hochsensibel sind, kann die Priorität für den Datenschutz hoch sein

Symbole, einschließlich Funktionen, Variablen und Klassen, werden in C++ über das externe Schlüsselwort „C“ exportiert. Exportierte Symbole werden extrahiert und gemäß den C-Sprachregeln zwischen Kompilierungseinheiten oder bei der Interaktion mit anderen Sprachen verwendet.

1Unix-Philosophie Die Unix-Philosophie legt Wert auf Praktikabilität, basiert auf umfangreicher Erfahrung und ist nicht durch traditionelle Methoden oder Standards eingeschränkt. Dieses Wissen ist eher latent und halbinstinktiv. Das Wissen, das Unix-Programmierer durch Entwicklungserfahrung sammeln, kann anderen Programmierern zugute kommen. (1) Jedes Programm sollte sich auf die Erledigung einer Aufgabe konzentrieren und bei einer neuen Aufgabe von vorne beginnen, um zu vermeiden, dass dem ursprünglichen Programm neue Funktionen hinzugefügt werden, was zu einer erhöhten Komplexität führt. (2) Unter der Annahme, dass die Ausgabe eines Programms zur Eingabe eines anderen Programms wird, stellen Sie sicher, dass die Ausgabe keine irrelevanten Informationen enthält, auch wenn das nächste Programm nicht klar ist. (3) Testen Sie die entworfene und geschriebene Software so schnell wie möglich, verwerfen Sie minderwertigen Code entschieden und schreiben Sie ihn neu. (4) Verwenden Sie Werkzeuge vor ineffizienten Hilfsmitteln, um die Belastung durch Programmieraufgaben zu verringern und nach Exzellenz zu streben.

Die Verwendung von STL-Funktionsobjekten kann die Wiederverwendbarkeit verbessern und umfasst die folgenden Schritte: Definieren Sie die Funktionsobjektschnittstelle (erstellen Sie eine Klasse und erben Sie von std::unary_function oder std::binary_function). Überladen Sie „operator()“, um das Funktionsverhalten im überladenen „operator()“ zu definieren. Implementieren Sie die erforderliche Funktionalität durch STL-Algorithmen (z. B. std::transform) mithilfe von Funktionsobjekten

C++-Lambda-Ausdrücke bringen Vorteile für die funktionale Programmierung, darunter: Einfachheit: Anonyme Inline-Funktionen verbessern die Lesbarkeit des Codes. Wiederverwendung von Code: Lambda-Ausdrücke können übergeben oder gespeichert werden, um die Wiederverwendung von Code zu erleichtern. Kapselung: Bietet eine Möglichkeit, einen Codeabschnitt zu kapseln, ohne eine separate Funktion zu erstellen. Praktischer Fall: Filterung ungerader Zahlen in der Liste. Berechnen Sie die Summe der Elemente in einer Liste. Lambda-Ausdrücke erreichen die Einfachheit, Wiederverwendbarkeit und Kapselung funktionaler Programmierung.

Best Practice für Zugriffsmodifikatoren für Java-Funktionen: Verwenden Sie den restriktivsten Modifikator, der standardmäßig auf „privat“ eingestellt ist. Innere Klassen verwenden den privaten Modifikator. Geschützte Methoden verwenden den geschützten Modifikator, um den Zugriff durch Unterklassen zu ermöglichen. Alle Eigenschaften in der unveränderlichen Klasse werden auf privat gesetzt und über Getter-Methoden auf sie zugegriffen. Öffentliche APIs verwenden den öffentlichen Modifikator, damit externe Klassen auf sie zugreifen können.
