Finale--
Das Finale wird verwendet, um anzuzeigen, dass die Klasse keine Unterklassen ableiten kann.
Finale wird verwendet, um anzuzeigen, dass die Methode nicht von einer Unterklasse neu geschrieben werden kann.
Das endgültige wird verwendet, um Konstanten bei Variablen darzustellen, ähnlich wie beim CONT -Schlüsselwort in C/C ++.
Das endgültige wird für Mitgliedsvariablen verwendet, um anzuzeigen, dass die Mitgliedsvariable eine Konstante ist und nicht geändert werden kann.
Das endgültige wird angezeigt, dass die lokale Variable eine Konstante ist und nicht geändert werden kann.
statisch---
Static wird verwendet, um anzuzeigen, dass es nur eine Kopie der Variablen gibt, dh die statische Mitgliedsvariable gehört zur Klasse, jedoch nicht zu einem bestimmten Klasseninstanzobjekt. Mitgliedsvariable, der entsprechende Klassenname ist abgeschlossen. Statische Mitgliedsvariablen können bei definiertem oder nicht initialisiert werden.
Static wird für Methoden verwendet, so dass statische Methoden durch Klassennamen aufgerufen werden können, ohne die Klasse zu instanziieren. verwiesen.
Static wird für Klassen verwendet, die sich hier auf die innere Klasse beziehen, sodass Sie diese statische innere Klasse über den Namen der äußeren Klasse an anderer Stelle verweisen können.
Statisch kann auch für Klassencodeblocke verwendet werden, die als statische Codeblöcke bezeichnet werden JVM lädt die Klasse, es führt diese statischen Codeblöcke aus.
Klassenzugriffsberechtigungen (y/n)
||
|
|
|
|
Die drei Keywords öffentlich, geschützt und privat für Klassen (interne Klassen), Mitgliedsvariablen und Mitgliedsfunktionen. Funktionen wählen Sie die Erlaubnis für den niedrigsten Zugriff.
Schnittstelle/implementiert/erweitert/Klasse - - -
Die Schnittstelle wird verwendet, um die Schnittstelle zu deklarieren.
Implements werden zur Implementierung von Schnittstellen verwendet, und alle Methoden in der Schnittstelle sind erforderlich, um mehrere Schnittstellen gleichzeitig zu implementieren.
Erweitert wird verwendet, um die Elternklasse oder die übergeordnete Schnittstelle zu erben.
Die Klasse wird verwendet, um Klassen zu deklarieren.
Abstrakt-
Zusammenfassung wird verwendet, um darzustellen, dass diese Klasse eine abstrakte Klasse ist und nicht instanziiert werden kann.
Abstract wird verwendet, um diese Methode eine abstrakte Methode darzustellen.
Konzentrieren wir uns auf die Verwendung dieses und Super:
Das
Das Java -Schlüsselwort Dies kann nur in der Methodenkörper verwendet werden. Wenn ein Objekt erstellt wird, weist die Java Virtual Machine (JVM) dem Objekt, das sich auf sich selbst bezieht, einen Zeiger zu, und der Name dieses Zeigers ist dies. Dies kann nur in nicht statischen Methoden in der Klasse verwendet werden. Und dies ist nur mit bestimmten Objekten verbunden, nicht mit Klassen, und verschiedene Objekte derselben Klasse haben dies unterschiedlich. Hier ist ein umfassendes Beispiel, das dies verwendet, um das Problem zu veranschaulichen:
Paket org. = n; ". this.username = userername; this. password = password;} // Der Standardkonstruktor ohne Parameter public test6 () {this (0," unbekannt "," leer "); // Rufen Sie einen anderen Konstruktor über diesen} öffentlichen Test6 an (String -Name) {this 1, Name, "leer"); Gast "); t1.outinfo (t1); t2.outinfo (t2);} private void outinfo (test6 t) {System.out.println (" ---------------- -"); system.out.println (t.number); this.f (); x = this.x ++;
Die Betriebsergebnisse sind wie folgt:
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------
Wenn wir uns das obige Beispiel ansehen, werden wir unter den Umständen erklären, welche Umstände dies benötigt wird:
Rufen Sie zunächst einen weiteren Konstruktor durch, und die Verwendung ist dies (Parameterliste).
Zweitens, wenn die Funktionsparameter oder lokale Variablen in der Funktion den gleichen Namen wie die Mitgliedsvariable haben, müssen Sie die Mitgliedsvariable zu diesem Zeitpunkt blockiert. Verweisen Sie auf die Mitgliedsvariable. Natürlich können Sie ohne denselben Namen den Namen der Mitgliedsvariablen direkt verwenden, anstatt dass es nicht falsch ist, ihn zu verwenden, haha.
Drittens verwenden Sie in der Funktion, wenn Sie sich auf das aktuelle Objekt der Klasse beziehen müssen, zu dem die Funktion gehört, diese direkt.
Tatsächlich sind diese Verwendungszusammenfassung aus einem tieferen Verständnis des Satzes "Dies ist ein Zeiger auf das Objekt selbst".
super
Der Schlüssel zu Super ist ähnlich, was darin besteht, dass die blockierte Elementvariable oder die Mitgliedsmethode sichtbar wird oder auf die blockierte Elementvariable und die Mitgliedsmessmethode bezeichnet.
Super wird jedoch in Unterklassen verwendet, um auf blockierte Mitglieder in der direkten übergeordneten Klasse zuzugreifen. Das Folgende ist ein Beispiel für die umfassende Verwendung von Super mit zwei Klassen: eine Vaterklasse und eine Unterklasse von Vaterklassensohn.
Paket org. ist genannt! ); ; In der Vorderseite des Konstruktors. void outinfo () {System.out.println ("Son -Outinfo () -Methode heißt"); System.out.println ("-----------"); (Unterklasse) Mitgliedsvariable V System.out.println (Super.V); println (x); -"); outinfo (); // Aufrufen der Outinfo () -Methode der Unterklasse this.outInfo (); // Aufrufen der Outinfo () -Methode Super.outinfo (); // Aufrufen der Outinfo () -Methode der Elternklasse} öffentliche statische void main (String [] args) {new Son (). Test ();
Subklass -Sohn Run -Ergebnisse:
Der Vaterkonstruktor heißt! -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- X !!! -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- --------