Zugriffsmodifikatoren auf die Java-Tabelle. Funktionen zur Verwendung von Modifikatoren in Java. Zugriffskontroll- und Vererbungsregeln

Wir werden über Modifikatoren sprechen: Was Modifikatoren sind, Bereiche, Modifikatoren für Klassen, Felder, Methoden. Ich denke, es wird nicht langweilig.

Modifikatoren in Java sind Schlüsselwörter, die einer Klasse, einem Klassenfeld oder einer Methode bestimmte Eigenschaften verleihen.

Um die Sichtbarkeit einer Klasse ihrer Methoden und Felder anzuzeigen, gibt es 4 Zugriffsmodifikatoren:

Privat Auf Klassenmitglieder kann nur innerhalb der Klasse zugegriffen werden.
package-private oder default (Standard) Klassenmitglieder sind innerhalb des Pakets sichtbar;
geschützt Klassenmitglieder sind innerhalb des Pakets und in abgeleiteten Klassen verfügbar;
öffentlich Die Kursteilnehmer stehen allen zur Verfügung.

Wenn Sie sich erinnern, hatten wir am Ende, als wir die Cat-Klasse bereits importiert hatten, immer noch einen Kompilierungsfehler.

Die Sache ist, dass wir keine Zugriffsmodifikatoren für unsere Felder und Methoden angegeben haben und sie über eine Standardeigenschaft verfügen (Klassenmitglieder sind innerhalb des Pakets sichtbar). Um den Kompilierungsfehler für unseren Code zu beheben und ihn schließlich auszuführen, müssen wir unseren Konstruktor und unsere Methoden öffentlich machen. Dann können sie aus anderen Paketen aufgerufen werden.

Sie fragen sich vielleicht: Wozu dient das alles? Warum machen Sie den Code nicht von jedem Paket oder jeder Klasse aus sichtbar, müssen aber den Zugriff einschränken? Diese Fragen verschwinden von selbst, wenn es darum geht, komplexe und umständliche Projekte zu schreiben. Wenn wir nun Anwendungen schreiben, deren Funktionalität auf eine oder zwei Klassen beschränkt ist, scheint es keinen Sinn zu machen, irgendetwas einzuschränken.

Stellen Sie sich vor, Sie haben eine Klasse, die ein Objekt eines bestimmten Produkts anzeigt. Zum Beispiel ein Auto. Das Auto kann einen Preis haben. Sie haben ein Preisfeld und viele andere Felder erstellt, eine Reihe von Methoden, die für die Funktionalität verantwortlich sind. Alles scheint in Ordnung zu sein. Ihr Klassenwagen ist Teil eines riesigen Projekts und alle sind glücklich. Aber nehmen wir an, dass jemand versehentlich oder absichtlich eine Instanz der Autoklasse erstellt und einen negativen Preis festgelegt hat. Kann ein Produkt einen negativen Preis haben? Dies ist ein sehr primitives Beispiel und wird wahrscheinlich nicht passieren wahres Leben, aber ich denke, die Idee ist klar. Manchmal müssen Sie den Zugriff nicht direkt, sondern über bestimmte Methoden gewähren. Es kann sein, dass der Code für die Funktionalität eines anderen Codes verantwortlich ist und Sie nicht möchten, dass jemand einen Teil Ihres Codes ändert und bearbeitet. Zu diesem Zweck besteht eine Zugangsbeschränkung.

Der Zugriffsmodifikator für Konstruktoren, Methoden und Felder kann alles sein. Eine Klasse kann nur entweder öffentlich oder standardmäßig sein und es kann nur eine öffentliche Klasse in einer Datei geben.

Genug über Zugriffsmodifikatoren für jetzt. Im Artikel „Objektorientierte Programmierung“ werden wir ausführlicher darüber sprechen, aber jetzt wollen wir über andere Modifikatoren sprechen, von denen es übrigens viele gibt.

Jetzt kommt der Modifikator statisch. Es kann vor einer Methode, einem Feld und sogar einer Klasse verwendet werden, wenn wir eine verschachtelte Klasse deklarieren möchten. In Java können Sie Klassen innerhalb anderer Klassen schreiben. Wenn der Modifikator vor der Klasse innerhalb der Klasse statisch ist, wird eine solche Klasse als verschachtelt bezeichnet. Wenn ein anderer Modifikator oder Standardwert ist, wird eine solche Klasse als intern bezeichnet. Zu verschachtelten und inneren Klassen wird es einen eigenen Artikel geben, da dort nicht alles so einfach ist.

Der statische Modifikator vor einer Methode oder einem Feld gibt an, dass sie nicht zu einer Instanz dieser Klasse gehört. Was bedeutet das für uns? Wenn wir ein Klassenfeld oder eine Methode als statisch deklariert haben, kann es aufgerufen werden, ohne eine Instanz der Klasse zu verwenden. Das heißt, anstelle dieser Konstruktion: Katze= neue Katze(); cat.method() können Sie einfach Cat.method() schreiben. Vorausgesetzt, die Methode ist als statisch deklariert. Statische Variablen sind für alle Klassenobjekte gleich. Sie haben einen Link.

öffentliche Klassenmodifikatoren (

static int anotherStaticField = 5 ;

public static void myStaticMethod() (

someField = "Mein Feld" ;

//nonStaticField = ""; Kompilierungsfehler

//Sie können keine nicht statischen Felder verwenden

//in statischen Methoden

public void myNonStaticMethod() (

anotherStaticField = 4 ; //statische Felder können verwendet werden

//in nicht statischen Methoden

// Die Hauptmethode verfügt auch über einen statischen Modifikator

new Modificators() .myNonStaticMethod() ;

Modificators.myStaticMethod(); //statische Methoden und Felder aufrufen

//über Classname.method

Ein weiterer wichtiger Punkt bei statischen Modifikatoren ist, dass statische Felder beim Laden der Klasse initialisiert werden. In verschiedenen Arten von Java-Tests finden Sie häufig den folgenden Code:

Frage: Was wird auf der Konsole ausgegeben? Sie müssen bedenken, dass der statische Block in jedem Fall zuerst ausgegeben wird. Als nächstes kommt der Standardblock. Schauen Sie sich als Nächstes den Konsolenbildschirm an:

Der nächste Modifikator, den wir uns ansehen werden, ist Finale.

Ich denke, das Wort „final“ spricht für sich. Durch die Verwendung des finalen Modifikators sagen Sie, dass Felder nicht geändert werden können, Methoden nicht überschrieben werden können und Klassen nicht vererbt werden können (zur Vererbung wird es einen separaten Artikel geben). Dieser Modifikator gilt nur für Klassen, Methoden und Variablen (auch lokale Variablen).

Wir werden im OOP-Artikel über den letzten Modifikator für Methoden und Klassen sprechen.

Als nächstes folgen Modifikatoren, die für Anfänger oder diejenigen, die diese Artikelserie von Grund auf lesen, nicht ganz klar sind. Und auch wenn ich Ihnen noch nicht alles erklären kann (da Sie das Begleitmaterial nicht kennen), rate ich Ihnen dennoch, sich einfach damit vertraut zu machen. Wenn es an der Zeit ist, diese Modifikatoren zu verwenden, werden Sie die meisten der unten verwendeten Begriffe bereits verstehen.

Modifikator synchronisiert– gibt an, dass die Methode jeweils nur von einem Thread verwendet werden kann. Auch wenn Ihnen das vielleicht nichts sagt, wird sich der Nutzen dieses Modifikators zeigen, wenn wir uns mit Multithreading befassen.

Modifikator vergänglich– gibt an, dass ein bestimmtes Feld während der Objektserialisierung ignoriert werden soll. Solche Felder speichern in der Regel Zwischenwerte.

Modifikator flüchtig- Wird für Multithreading verwendet. Wenn ein Feld mit dem Modifikator „volatil“ von mehreren Threads verwendet und geändert wird, stellt dieser Modifikator sicher, dass das Feld der Reihe nach geändert wird und es keine Verwechslungen damit gibt.

Modifikator einheimisch Zeigt vor der Deklaration einer Methode an, dass die Methode in einer anderen Programmiersprache geschrieben ist. Normalerweise in C-Sprache.

Modifikator strictfp— Stellt sicher, dass Operationen mit Float- und Double-Zahlen (Gleitkommazahlen) gemäß dem IEEE 754-Standard ausgeführt werden. Oder einfacher gesagt, es garantiert, dass innerhalb der Methode die Ergebnisse der Berechnungen auf allen Plattformen gleich sind.

Über den Modifikator habe ich noch nicht gesprochen abstrakt. Ich werde kurz darauf eingehen, denn ohne Kenntnisse der Grundlagen der objektorientierten Programmierung sehe ich keinen Sinn darin, darüber zu sprechen.

Eine Klasse mit dem abstrakten Modifikator kann keine Instanz erstellen. Der einzige Zweck besteht darin, es zu erweitern. Die abstrakte Klasse kann sowohl abstrakte als auch reguläre Methoden enthalten.

Wir werden im OOP-Artikel mehr über den abstrakten Modifikator sprechen.

Hier können wir den Artikel über Modifikatoren beenden. Über sie wurde nicht viel gesagt. Dies liegt jedoch daran, dass wir noch nicht über die Konzepte von OOP verfügen. Im Laufe mehrerer Artikel werden wir das Wissen über Modifikatoren erweitern und die Lücken schließen.

Schauen wir uns zunächst die Zugriffsmodifikatoren an. Es gibt nur vier davon:

Privat Auf Klassenmitglieder kann nur innerhalb der Klasse zugegriffen werden
package-private oder default (Standard) Klassenmitglieder sind im Paket sichtbar
geschützt Klassenmitglieder sind innerhalb des Pakets und in abgeleiteten Klassen verfügbar
öffentlich Die Kursteilnehmer stehen allen zur Verfügung

Während der Vererbung ist es möglich, Zugriffsmodifikatoren in Richtung MEHR Sichtbarkeit zu ändern.

Konstruktoren, Methoden und Felder können beliebige Zugriffsmodifikatoren haben, aber bei Klassen und ihren Blöcken ist nicht alles so einfach. Eine Klasse kann nur entweder öffentlich oder standardmäßig sein und es kann nur eine öffentliche Klasse in einer Datei geben. Ein Block kann nur einen Modifikator haben – Standard.

Modifikatoren statisch, abstrakt und endgültig

Statisch

Gilt für innere Klassen, Methoden, Variablen und logische Blöcke
Statische Variablen werden beim Laden der Klasse initialisiert
Statische Variablen sind für alle Klassenobjekte gleich (gleiche Referenz)
Statische Methoden haben nur Zugriff auf statische Variablen
Auf statische Methoden und Variablen kann über den Klassennamen zugegriffen werden
Statische Blöcke werden beim Laden der Klasse ausgeführt
Nicht statische Methoden können nicht als statisch überschrieben werden
Lokale Variablen können nicht als statisch deklariert werden
Abstrakte Methoden können nicht statisch sein
Statische Felder werden nicht serialisiert (nur bei Implementierung der Serializable-Schnittstelle)
Nur statische Klassenvariablen können an einen parametrisierten Konstruktor übergeben werden, der über super(//parameter//) oder this(//parameter//) aufgerufen wird.

Abstrakt

Gilt nur für Methoden und Klassen
Abstrakte Methoden haben keinen Methodenkörper
Es ist das Gegenteil von final: Eine finale Klasse kann nicht vererbt werden, eine abstrakte Klasse muss vererbt werden
Eine Klasse muss als abstrakt deklariert werden, wenn:

es enthält mindestens eine abstrakte Methode
Es bietet keine Implementierung geerbter abstrakter Methoden
Es stellt keine Implementierung der Methoden der Schnittstelle bereit, deren Implementierung es deklariert hat
Es ist notwendig, die Erstellung von Instanzen der Klasse zu verbieten

Finale

Felder können nicht geändert werden, Methoden werden überschrieben
Klassen können nicht vererbt werden
Dieser Modifikator gilt nur für Klassen, Methoden und Variablen (auch lokale Variablen).
Als final markierte Methodenargumente sind schreibgeschützt; der Versuch, sie zu ändern, führt zu einem Kompilierungsfehler.
Endgültige Variablen werden standardmäßig nicht initialisiert; ihnen muss bei der Deklaration oder im Konstruktor explizit ein Wert zugewiesen werden, andernfalls kommt es zu einem Kompilierungsfehler.
Wenn eine endgültige Variable einen Verweis auf ein Objekt enthält, kann das Objekt geändert werden, die Variable verweist jedoch immer auf dasselbe Objekt
Dies gilt auch für Arrays, da Arrays Objekte sind – das Array kann geändert werden, aber die Variable verweist immer auf dasselbe Array
Wenn eine Klasse als final und abstrakt (sich gegenseitig ausschließend) deklariert wird, tritt ein Kompilierungsfehler auf
Da eine letzte Klasse nicht vererbt werden kann, können ihre Methoden niemals überschrieben werden

Konstrukteur kann nicht statisch, abstrakt oder endgültig sein

Modifikatoren strictfp, transient, volatile, synchronisiert, nativ

Strictfp

Gilt für Methoden und Klassen
Bietet Operationen für Float- und Double-Zahlen (Gleitkomma) gemäß dem IEEE 754-Standard

Vorübergehend

Gilt nur für Variablen auf Klassenebene (lokale Variablen können nicht als transient deklariert werden)
Transiente Variablen sind möglicherweise nicht endgültig oder statisch.
Transiente Variablen werden nicht serialisiert

Flüchtig

Wird nur mit Variablen verwendet
Kann mit statischen Variablen verwendet werden
Wird nicht mit endgültigen Variablen verwendet – Der Wert einer als flüchtig deklarierten Variablen, die von einem Thread geändert wird, wird für andere Threads asynchron geändert
Wird in Multithread-Anwendungen verwendet

Synchronisiert

Gilt nur für Methoden oder Teile von Methoden
Wird verwendet, um den Zugriff auf wichtige Teile des Codes in Multithread-Programmen zu steuern

Einheimisch

Wird nur für Methoden verwendet
Zeigt an, dass die Methode in einer anderen Programmiersprache geschrieben ist
Klassen in Java verwenden viele native Methoden, um die Leistung und den Zugriff auf Hardware zu verbessern
Sie können Java-Objekte von nativen Methoden übergeben/zurückgeben
Die Methodensignatur muss mit „;“ enden, geschweifte Klammern führen zu einem Kompilierungsfehler

Funktionen in Schnittstellen

Methoden sind immer öffentlich und abstrakt, auch wenn sie nicht deklariert sind
Methoden können nicht statisch, final, strictfp, nativ, privat oder geschützt sein
Variablen sind nur öffentliche statische Endvariablen, auch wenn sie nicht deklariert sind
Variablen können nicht strictfp, nativ, privat oder geschützt sein
Kann nur eine andere Schnittstelle erweitern, aber keine Schnittstelle oder Klasse implementieren.

Fassen wir alle Modifikatoren zusammen:

	Klasse	Innere Klasse	Variable	Methode	Konstrukteur	Logikblock
öffentlich	Ja	Ja	Ja	Ja	Ja	Nein
geschützt	Nein	Ja (außer lokale und anonyme Klassen)	Ja	Ja	Ja	Nein
Standard	Ja	Ja		Ja	Ja	Ja
Privat	Nein	Ja (außer lokale und anonyme Klassen)	Ja	Ja	Ja	Nein
Finale	Ja		Ja (und für lokale Variable)	Ja	Nein	Nein
abstrakt	Ja	Ja (außer anonyme Kurse)	Nein	Ja	Nein	Nein
statisch	Nein	Ja (außer lokale und anonyme Klassen)	Ja	Ja	Nein	Ja
einheimisch	Nein	Nein	Nein	Ja	Nein	Nein
vergänglich	Nein	Nein	Ja	Nein	Nein	Nein
synchronisiert	Nein	Nein	Nein	Ja	Nein	Ja (nur im Rahmen der Methode)
flüchtig	Nein	Nein	Ja	Nein	Nein	Nein
strictfp	Ja	Ja	Nein	Ja	Nein	Nein

Die Java-Sprache bietet viele Modifikatoren, die in die folgenden Kategorien unterteilt sind:

Zugriffsmodifikator
Nichtzugriffsmodifikator

Ein Modifikator wird zum Definieren einer Klasse, Methode oder Variablen verwendet, normalerweise am Anfang einer Anweisung. Zur Veranschaulichung das folgende Beispiel:

Öffentliche Klasse className ( // ... ) private boolean myFlag; statische letzte Doppelwochen = 9,5; protected static final int BOXWIDTH = 42; public static void main(String-Argumente) ( // Referenz )

Zugriffskontrollmodifikator

In Java können Sie Zugriffskontrollsymbole verwenden, um den Zugriff auf Klassen, Variablen, Methoden und Konstruktoren zu schützen. Java unterstützt vier verschiedene Berechtigungen.

Standard, auch Standard genannt Standard, im selben Paket sichtbar sind, verwenden Sie keinen Modifikator.

Privat bis angegeben Privat ein Modifikator, der innerhalb derselben Klasse sichtbar ist.

Ja, um anzuzeigen allgemein ein Modifikator, der für alle Klassen sichtbar ist.

Geschützt, in geschützt Der Modifikator gibt an, dass alle Klassen und Unterklassen innerhalb desselben Pakets sichtbar sind.

Der Standardzugriffsmodifikator besteht darin, keine Schlüsselwörter zu verwenden

Verwenden Sie Variablen und Methoden, die im Standardzugriffsmodifikator für eine Klasse innerhalb desselben sichtbaren Pakets deklariert sind. Eine Schnittstelle, bei der die Variablen implizit als öffentliches statisches Finale deklariert werden, und eine Schnittstelle, bei der der Standardzugriffsmechanismus für die Öffentlichkeit bestimmt ist.

Im folgenden Beispiel können Variablen und Methoden keine Modifikatoren verwenden.

String-Version = „1.5.1“; boolescher ProzessOrder() ( true zurückgeben; )

Privater Zugriffsmodifikator -private

Der private Zugriffsmodifikator ist die restriktivste Zugriffsebene. Er wird als private Methode und Variable deklariert und gehört zur Konstruktorklasse, auf die nur zugegriffen werden kann. Klassen und Schnittstellen können nicht als privat deklariert werden.

Auf Variablen, die als privater Zugriffstyp deklariert sind, kann außerhalb der Klasse nur über die öffentliche Getter-Methode der Klasse zugegriffen werden.

Der Modifikator „Privater Zugriff“ wird hauptsächlich zum Schutz von Implementierungsdetails und -daten für jede Klasse verwendet.

Die folgenden Klassen verwenden den privaten Zugriffsmodifikator:

Öffentliche Klasse Logger ( privates String-Format; öffentlicher String getFormat() ( return this.format; ) public void setFormat(String format) ( this.format = format; ) )

Beispielsweise ist das Variablenformat der Logger-Klasse eine private Variable, sodass andere Klassen den Wert der Variablen nicht direkt abrufen und festlegen können. Um mit einer anderen Klassenvariablen arbeiten zu können, definiert sie zwei öffentliche Methoden: GetFormat () (Rückgabewertformat) und SetFormat (String) (Formateinstellung).

Open-Access-Modifikator – öffentlich

Es wird als öffentliche Klasse deklariert, Methoden, Konstruktoren und Schnittstellen können jeden anderen Zugriffstyp haben.

Bei mehreren gegenseitigen Besuchen öffentlicher Klassen in unterschiedlichen Paketen müssen Sie das entsprechende Paket der dauerhaft lokalisierten öffentlichen Klasse importieren. Seit der Klassenvererbung können alle öffentlichen Methoden und Variablen einer Klasse von ihren Unterklassen geerbt werden.

Die folgenden Funktionen nutzen die öffentliche Zugriffskontrolle:

Public static void main(String-Argumente) ( // ... )

Hauptmethode Java-Programme() muss auf public gesetzt sein, sonst kann der Java-Interpreter die Klasse nicht ausführen.

Geschützte Zugriffsmodifikatoren geschützt

Als geschützte Variablen deklariert, können Methoden und Konstruktoren im selben Paket jeden anderen Zugriffstyp haben und in verschiedenen Unterklassenpaketen darauf zugegriffen werden.

Geschützte Zugriffsmodifikatorklassen und Schnittstellen können nicht geändert werden; Methoden und Mitgliedsvariablen können als geschützt deklariert werden, Schnittstellenvariablen und Mitgliedsmethoden können jedoch nicht als geschützt deklariert werden.

Modifikator-Unterklassen können auf deklarierte geschützte Methoden und Variablen zugreifen, sodass wir nicht verwandte Klassen mithilfe dieser Methoden und Variablen schützen können.

Die folgende übergeordnete Klasse verwendet einen geschützten Zugriffsmodifikator. Unterklassen überschreiben die openSpeaker()-Methode der übergeordneten Klasse.

Klasse AudioPlayer ( protected boolean openSpeaker(Speaker sp) ( // Sprachausgabe ) ) class StreamingAudioPlayer ( boolean openSpeaker(Speaker sp) ( // Sprachausgabe ) )

Wenn die openSpeaker()-Methode als privat deklariert ist, kann zusätzlich zur AudioPlayer-Klasse nicht auf die Methode zugegriffen werden. Wenn openSpeaker() als öffentlich deklariert ist, können alle Klassen auf die Methode zugreifen. Wenn wir den Prozess für Unterklassen der Klasse sichtbar machen wollen, dann wird die Methode als geschützt deklariert.

Zugriffskontrolle und Vererbung

Bitte beachten Sie, dass die folgenden Methoden die Regeln erben:

Die übergeordnete Klasse wird als öffentliche Methode deklariert, in der Unterklasse muss sie ebenfalls öffentlich sein.

Die übergeordnete Klasse wird als geschützte Methode in einer Unterklasse deklariert, entweder als geschützt oder öffentlich deklariert. Sie können nicht als privat deklariert werden.

Eine als private Methode deklarierte übergeordnete Klasse kann nicht vererbt werden.

Nichtzugriffsmodifikator

Um eine Reihe weiterer Funktionen zu erreichen, stellt Java auch eine Reihe von Nichtzugriffsmodifikatoren bereit.

Der statische Modifikator wird zum Erstellen von Klassenmethoden und Klassenvariablen verwendet.

Der endgültige Modifikator wird zum Dekorieren von Klassen, Methoden und Variablen verwendet. Die endgültige geänderte Klasse kann nicht vererbt werden, die geänderte Klassenmethode kann nicht vererbt werden, überschrieben werden und geänderte konstante Variablen können nicht geändert werden.

Der abstrakte Modifikator wird zum Erstellen abstrakter Klassen und abstrakter Methoden verwendet.

Synchrone und flüchtige Modifikatoren, hauptsächlich für Programmierthreads.

Statischer Modifikator

Statische Variablen:

Statisch verwendet Stichwort Um statische Variablen unabhängig von einem Objekt zu deklarieren, ist es unabhängig von der Anzahl der Objekte einer Klasseninstanz nur eine Kopie der statischen Variablen. Statische Variablen werden auch als Klassenvariablen bezeichnet. Lokale Variablen können nicht als statische Variablen deklariert werden.

Statische Methoden:

Das Schlüsselwort static wird verwendet, um ein Objekt unabhängig von einer statischen Methode zu deklarieren. Statische Methoden können keine nicht statische Variablenklasse verwenden. Statische Methode, um Daten aus einer Liste von Parametern abzurufen und die Daten dann zu berechnen.

Der Zugriff auf Klassenvariablen und Methoden kann direkt durch Zugriff auf Klassenname.variablenname und Klassenname.methodenname verwendet werden.

Im folgenden Beispiel wird ein statischer Modifikator verwendet, um Klassenmethoden und Klassenvariablen zu erstellen.

Öffentliche Klasse InstanceCounter ( private static int numInstances = 0; protected static int getCount() ( return numInstances; ) private static void addInstance() ( numInstances++; ) InstanceCounter() ( InstanceCounter.addInstance(); ) public static void main(String-Argumente ) ( System.out.println("Beginnend mit " + InstanceCounter.getCount() + " Instanzen"); for (int i = 0; i< 500; ++i){ new InstanceCounter(); } System.out.println("Created " + InstanceCounter.getCount() + " instances"); } }

Beispiele für die oben genannten Ergebnisse des Bearbeitungsvorgangs sind wie folgt:

Begonnen mit 0 Instanzen. Erstellt 500 Instanzen

Endgültiger Klassifikator

Endgültige Variablen:

Endgültige Variablen können explizit initialisiert werden und werden nur einmal initialisiert. Ein Verzeichnis wird deklariert, da Endobjekte nicht auf ein anderes Objekt verweisen können. Aber das Endziel ist, wo die Daten geändert werden können. Dies ist ein endgültiger Verweis auf ein Objekt, das nicht geändert werden kann, dessen Wert jedoch geändert werden kann.

Der letzte Modifikator wird normalerweise zusammen verwendet, um eine statische Modifikatorklassenkonstante zu erstellen.

Öffentliche Klasse Test( final int value = 10; // public static final int BOXWIDTH = 6; static final String TITLE = "Manager"; public void changeValue(){ value = 12; //将输出一个错误 } } !}

Endgültige Methode

Methoden einer endgültigen Klasse werden von Unterklassen geerbt, aber Unterklassen können sie nicht ändern.

Der Hauptzweck einer Methode besteht darin, zu verhindern, dass die endgültige Anweisung dieser Methode geändert wird.

Wie unten gezeigt wird, werden die endgültigen Methoden zur Deklaration von Modifikatoren verwendet.

Öffentlicher Klassentest( public final void changeName())( // 方法体 ) )

Letzte Kategorie

Endgültige Klassen können nicht vererbt werden; keine Klasse kann Merkmale einer endgültigen Klasse erben.

Öffentlicher Abschlusstest ( // 类体 )

Abstrakter Modifikator

Abstrakte Klasse:

Eine abstrakte Klasse kann nicht zum Instanziieren eines Objekts verwendet werden; der einzige Zweck der Anweisung besteht darin, eine abstrakte Klasse für die zukünftige Erweiterung dieser Klasse zu erstellen.

Eine Klasse kann nicht abstrakt und endgültig geändert werden. Wenn eine Klasse abstrakte Methoden enthält, muss die Klasse als abstrakte Klasse deklariert werden, andernfalls tritt ein Compilerfehler auf.

Eine abstrakte Klasse kann abstrakte Methoden und nicht abstrakte Methoden enthalten.

Abstrakte Klasse Caravan( privater doppelter Preis; privates String-Modell; privates String-Jahr; öffentliche Zusammenfassung void goFast(); //抽象方法 öffentliche Zusammenfassung void changeColor(); )

Abstrakte Methode

Keine Methode ist eine abstrakte Methodenimplementierung, eine konkrete Methodenimplementierung wird durch Unterklassen bereitgestellt. Abstrakte Methoden können nicht als endgültig und streng deklariert werden.

Jede Unterklasse, die eine abstrakte Klasse erbt, muss alle abstrakten Methoden der übergeordneten Klasse implementieren, es sei denn, die Unterklasse ist eine abstrakte Klasse.

Enthält eine Klasse mehrere abstrakte Methoden, muss die Klasse als abstrakte Klasse deklariert werden. Eine abstrakte Klasse kann keine abstrakten Methoden enthalten.

Eine abstrakte Methodendeklaration endet mit einem Semikolon, zum Beispiel: public abstract sample();

Öffentliche abstrakte Klasse SuperClass( abstract void m(); //抽象方法 ) class SubClass erweitert SuperClass( //实现抽象方法 void m())( ......... ) )

Synchroner Modifikator

Methode Synchrones Schlüsselwort, um zu deklarieren, dass nur ein Thread gleichzeitig zugreift. Der Synchronmodifikator kann auf vier Zugriffsmodifikatoren angewendet werden.

Öffentliche synchronisierte void showDetails() ( ....... )

Übergangsmodifikator

Das serialisierte Objekt enthält vorübergehende Variablen, die von der Java Virtual Machine (JVM)-Instanz geändert wurden, um diese bestimmte Variable zu überspringen.

Der Modifikator ist in der Definition von Anweisungsvariablen enthalten, um Datentypklassen und -variablen vorzuverarbeiten.

Öffentliches transientes Int-Limit = 55; // bleibt nicht bestehen public int b; // wird bestehen bleiben

Flüchtige Modifikatoren

Eine flüchtig geänderte Mitgliedsvariable zwingt Threads dazu, den Wert der Mitgliedsvariablen bei jedem Zugriff erneut aus dem gemeinsam genutzten Speicher zu lesen. Wenn sich Mitgliedsvariablen ändern, ist der Thread außerdem gezwungen, den in den gemeinsam genutzten Speicher zurückgeschriebenen Wert zu ändern. Also jederzeit zwei andere Themen immer sehen gleichen Wert Mitgliedsvariable.

Die öffentliche Klasse MyRunnable implementiert Runnable ( private volatile boolean active; public void run() ( active = true; while (active) // Funktion ( // Funktion ) ) public void stop() ( active = false; // Funktion行 ) )

Unter normalen Umständen ruft ein Thread die Run()-Methode (im Runnable eines offenen Threads) auf, während ein anderer Thread die Stop()-Methode aufruft. Wenn der aktive Wert in erste Linie Puffer wird verwendet zweite Reihe Wenn die aktive Schleife falsch ist, stoppt sie nicht.

Im obigen Code verwenden wir jedoch ein modifiziertes flüchtiges Aktiv, sodass die Schleife stoppt.

Letzte Aktualisierung: 03.10.2019

Alle Mitglieder einer Klasse – Felder, Methoden, Eigenschaften – haben sie alle Zugriffsmodifikatoren. Mit Zugriffsmodifikatoren können Sie den zulässigen Bereich für Klassenmitglieder angeben. Das heißt, Zugriffsmodifikatoren bestimmen den Kontext, in dem eine bestimmte Variable oder Methode verwendet werden kann. In früheren Themen sind wir bereits darauf gestoßen, als wir die Felder einer Klasse als öffentlich deklariert haben (also mit dem Modifikator public).

Die folgenden Zugriffsmodifikatoren werden in C# verwendet:

public: Eine öffentliche, öffentliche Klasse oder ein Mitglied einer Klasse. Auf ein solches Klassenmitglied kann von überall im Code sowie von anderen Programmen und Assemblys aus zugegriffen werden.

privat: Eine private Klasse oder ein Klassenmitglied. Stellt das genaue Gegenteil des öffentlichen Modifikators dar. Auf eine solche private Klasse oder ein solches Klassenmitglied kann nur über Code in derselben Klasse oder demselben Kontext zugegriffen werden.

protected: Auf dieses Klassenmitglied kann von überall in der aktuellen Klasse oder in abgeleiteten Klassen zugegriffen werden. In diesem Fall können abgeleitete Klassen in anderen Assemblys liegen.

intern: Auf eine Klasse und Klassenmitglieder mit einem ähnlichen Modifikator kann von überall im Code in derselben Assembly zugegriffen werden, andere Programme oder Assemblys können jedoch nicht darauf zugreifen (wie es beim öffentlichen Modifikator der Fall ist).

protected internal: kombiniert die Funktionalität zweier Modifikatoren. Auf Klassen und Klassenmitglieder mit diesem Modifikator kann von der aktuellen Assembly und von abgeleiteten Klassen aus zugegriffen werden.

privat geschützt: Auf dieses Klassenmitglied kann von überall in der aktuellen Klasse oder in abgeleiteten Klassen zugegriffen werden, die in derselben Assembly definiert sind.

Wir können den Zugriffsmodifikator explizit festlegen, zum Beispiel:

Private geschützte Klasse State ( internal int a; protected void Print() ( Console.WriteLine($"a = (a)"); ) )

Oder wir geben möglicherweise nicht an:

Klassenstatus ( int a; void Print() ( Console.WriteLine($"a = (a)"); ) )

Wenn für Felder und Methoden kein Zugriffsmodifikator definiert ist, ist der Standardmodifikator private .

Ohne Modifikator deklarierte Klassen und Strukturen verfügen standardmäßig über internen Zugriff.

Alle Klassen und Strukturen, die direkt in Namespaces definiert und nicht in anderen Klassen verschachtelt sind, können nur die öffentlichen oder internen Modifikatoren haben.

Schauen wir uns ein Beispiel an und erstellen wir die folgende State-Klasse:

Public class State ( // das Gleiche wie private int defaultVar; int defaultVar; // das Feld ist nur von der aktuellen Klasse aus zugänglich private int privateVar; // zugänglich von der aktuellen Klasse und abgeleiteten Klassen, die im selben Projekt definiert sind protected privat int protectedPrivateVar; // verfügbar von der aktuellen Klasse und abgeleiteten Klassen protected int protectedVar; // überall im aktuellen Projekt verfügbar internal int internalVar; // überall im aktuellen Projekt und von abgeleiteten Klassen in anderen Projekten verfügbar protected internal int protectedInternalVar; / / überall im Programm sowie für andere Programme und Assemblys verfügbar public int publicVar; // hat standardmäßig einen Modifikator private void defaultMethod() => Console.WriteLine($"defaultVar = (defaultVar)"); // Auf die Methode kann nur von der aktuellen Klasse aus zugegriffen werden private void privateMethod() => Console.WriteLine($"privateVar = (privateVar)"); // Zugriff von der aktuellen Klasse und abgeleiteten Klassen, die im selben Projekt definiert sind protected private void protectedPrivateMethod() => Console.WriteLine($ "protectedPrivateVar = (protectedPrivateVar)"); // Zugriff von der aktuellen Klasse und abgeleiteten Klassen protected void protectedMethod()=> Console.WriteLine($"protectedVar = (protectedVar)"); // überall im aktuellen Projekt verfügbar internal void internalMethod() => Console.WriteLine($"internalVar = (internalVar)"); // überall im aktuellen Projekt und von abgeleiteten Klassen in anderen Projekten zugänglich protected internal void protectedInternalMethod() => Console.WriteLine($"protectedInternalVar = (protectedInternalVar)"); // überall im Programm sowie für andere Programme und Assemblys verfügbar public void publicMethod() => Console.WriteLine($"publicVar = (publicVar)"); )

Da die State-Klasse mit dem öffentlichen Modifikator deklariert wird, ist sie von überall im Programm sowie von anderen Programmen und Assemblys aus zugänglich. Die State-Klasse verfügt über fünf Felder für jede Zugriffsebene. Plus eine Variable ohne Modifikator, die standardmäßig privat ist.

Es gibt außerdem sechs Methoden, mit denen die Klassenfeldwerte auf dem Bildschirm angezeigt werden. Bitte beachten Sie, dass, da alle Modifikatoren die Verwendung von Klassenmitgliedern innerhalb einer bestimmten Klasse ermöglichen, alle Klassenvariablen, einschließlich privater, für alle Methoden verfügbar sind, da alle im Kontext der State-Klasse stehen.

Sehen wir uns nun an, wie wir unsere Klassenvariablen in einem Programm (d. h. in der Main-Methode der Program-Klasse) verwenden können, wenn sich die State- und Program-Klassen im selben Projekt befinden:

Klassenprogramm ( static void Main(string args) ( State state1 = new State(); // Wir können der Variablen defaultVar keinen Wert zuweisen, // da sie einen privaten Modifikator hat und die Programmklasse ihn nicht sieht it // Und wenn diese Zeichenfolge für die Umgebung nicht sichtbar ist, wird sie als falsch hervorgehoben. state1.defaultVar = 5; //Fehler, Zugriff kann nicht erhalten werden // Gleiches gilt für die Variable privateVar state1.privateVar = 5; // Fehler, Zugriff kann nicht abgerufen werden // das Zuweisen eines Werts zur Variable protectedPrivateVar funktioniert nicht, // da die Program-Klasse keine abgeleitete Klasse der State-Klasse ist state1.protectedPrivateVar =5; // Fehler, Zugriff kann nicht abgerufen werden // beim Zuweisen eines Werts auf die Variable protectedVar funktioniert auch nicht, // da die Program-Klasse keine abgeleitete Klasse der State-Klasse ist state1.protectedVar = 5; // Fehler, Zugriff kann nicht erhalten werden // Auf die Variable internalVar mit dem internen Modifikator kann zugegriffen werden irgendwo im aktuellen Projekt // also ruhig den Wert zuweisen state1.internalVar = 5; // Auf die Variable protectedInternalVar kann auch von überall im aktuellen Projekt zugegriffen werden state1.protectedInternalVar = 5; // publicVar-Variable ist öffentlich state1.publicVar = 5; ) )

Daher konnten wir nur die Variablen internalVar, protectedInternalVar und publicVar setzen, da deren Modifikatoren die Verwendung in diesem Kontext zulassen.

Ähnlich verhält es sich mit den Methoden:

Klassenprogramm ( static void Main(string args) ( State state1 = new State(); state1.defaultMethod(); // Fehler, auf den Zugriff kann nicht zugegriffen werden state1.privateMethod(); // Fehler, auf den Zugriff kann nicht zugegriffen werden state1.protectedPrivateMethod () ; // Fehler, Zugriff kann nicht erhalten werden state1.protectedMethod(); // Fehler, Zugriff kann nicht erhalten werden state1.internalMethod(); // ok state1.protectedInternalMethod(); // ok state1.publicMethod(); / / OK ) )

Hier standen uns nur drei Methoden zur Verfügung: internalMethod, protectedInternalMethod, publicMethod, die jeweils die Modifikatoren internal, protected internal und public haben.

Dank dieses Systems von Zugriffsmodifikatoren ist es möglich, einige Aspekte der Klassenimplementierung vor anderen Teilen des Programms zu verbergen.

Obwohl die öffentlichen und internen Modifikatoren in ihrer Wirkung ähnlich sind, gibt es einen großen Unterschied. Klassen und Klassenmitglieder mit dem öffentlichen Modifikator stehen auch anderen Programmen zur Verfügung, wenn diese Klasse in einer dynamischen Bibliotheks-DLL abgelegt und dann in diesen Programmen verwendet wird.

Was Sie während der Initialisierung hinzufügen, um Werte zu ändern. Die Java-Sprache verfügt über eine Vielzahl von Modifikatoren. Die wichtigsten sind:

Zugriffsmodifikatoren;
Klassen-, Methoden-, Variablen- und Thread-Modifikatoren, die für Nichtzugriffszwecke verwendet werden.

Um einen Modifikator in Java zu verwenden, müssen Sie sein Schlüsselwort in die Definition einer Klasse, Methode oder Variable aufnehmen. Der Modifikator muss vor dem Rest der Anweisung stehen, wie in den folgenden Beispielen gezeigt:

Zugriffsmodifikatoren

Java bietet eine Reihe von Zugriffsmodifikatoren, um Zugriffsebenen für Klassen, Variablen, Methoden und Konstruktoren festzulegen. Es gibt vier Zugänge:

Sichtbar im Paket (dies ist die Standardeinstellung und es ist kein Modifikator erforderlich).
Nur für die Klasse sichtbar (privat).
Für alle sichtbar (öffentlich).
Sichtbar für das Paket und alle Unterklassen (geschützt).

Standardzugriffsmodifikator – kein Schlüsselwort

Standardzugriffsmodifikator- bedeutet, dass wir in Java keinen Zugriffsmodifikator für eine Klasse, ein Feld, eine Methode usw. explizit deklarieren.

Auf eine ohne Zugriffskontrollmodifikator deklarierte Variable oder Methode kann jede andere Klasse im selben Paket zugreifen. Felder in einer Schnittstelle sind implizit öffentlich, statisch und endgültig, und Methoden in einer Schnittstelle sind standardmäßig öffentlich.

Beispiel

Variablen und Methoden können in Java ohne Modifikatoren deklariert werden, wie im folgenden Beispiel gezeigt:

String-Version = „1.5.1“; boolescher ProzessOrder() ( true zurückgeben; )

Modifikator für privaten Zugriff

Modifikator privat- Auf Methoden, Variablen und Konstruktoren, die in Java als privat deklariert sind, kann nur innerhalb der deklarierten Klasse selbst zugegriffen werden.

Der private Zugriffsmodifikator ist die restriktivste Zugriffsebene. Klasse und Schnittstellen können nicht privat sein.

Auf als privat deklarierte Variablen kann außerhalb der Klasse zugegriffen werden, wenn die öffentlichen Methoden, die sie empfangen, in der Klasse vorhanden sind (siehe Beispiel und Erklärung unten).

Die Verwendung des privaten Modifikators in Java ist die wichtigste Möglichkeit, Daten auszublenden.

Beispiel

Die folgende Klasse verwendet private Zugriffskontrolle:

Öffentliche Klasse Logger ( privates String-Format; öffentlicher String getFormat() ( return this.format; ) public void setFormat(String format) ( this.format = format; ) )

Hier die Variable Format Klasse Logger ist privat, daher gibt es für andere Klassen keine Möglichkeit, seinen Wert direkt abzurufen und festzulegen.

Um diese Variable allen zugänglich zu machen, haben wir zwei öffentliche Methoden definiert: getFormat() was einen Wert zurückgibt Format, Und setFormat(String), wodurch der Wert festgelegt wird.

Modifikator für den öffentlichen Zugriff

öffentlicher Modifikator- Klasse, Methode, Konstruktor, Schnittstelle usw. Auf die als öffentlich deklarierte Klasse kann von jeder anderen Klasse aus zugegriffen werden. Daher kann auf innerhalb einer öffentlichen Klasse deklarierte Felder, Methoden und Blöcke von jeder Klasse aus zugegriffen werden, die zum Java-„Universum“ gehört.

Wenn wir jedoch versuchen, auf eine öffentliche Klasse in einem anderen Paket zuzugreifen, muss die öffentliche Klasse importiert werden.

Dank der Klassenvererbung werden in Java alle öffentlichen Methoden und Variablen einer Klasse von ihren Unterklassen geerbt.

Beispiel

Die folgende Funktion verwendet die öffentliche Zugriffskontrolle:

Public static void main(String-Argumente) ( // ... )

Methode hauptsächlich() muss öffentlich sein. Andernfalls kann es nicht mit dem Java-Interpreter aufgerufen werden, um die Klasse auszuführen.

Zugriffsmodifikator geschützt

Modifikator geschützt- Auf Variablen, Methoden und Konstruktoren, die in einer Oberklasse als geschützt deklariert sind, können nur Unterklassen in einem anderen Paket oder eine beliebige Klasse in einem Paket der geschützten Klasse zugreifen.

Der geschützte Zugriffsmodifikator in Java kann nicht auf Klassen und Schnittstellen angewendet werden. Methoden und Felder können als geschützt deklariert werden, Methoden und Felder in einer Schnittstelle können jedoch nicht als geschützt deklariert werden.

Der geschützte Zugriff gibt einer Unterklasse die Möglichkeit, eine Hilfsmethode oder -variable zu verwenden, wodurch verhindert wird, dass eine nicht verwandte Klasse versucht, sie zu verwenden.

Beispiel

Die folgende übergeordnete Klasse verwendet die geschützte Zugriffskontrolle, sodass ihre untergeordnete Klasse die Methode überschreibt openSpeaker():

Klasse AudioPlayer ( protected boolean openSpeaker(Speaker sp) ( // Implementierungsdetails ) ) class StreamingAudioPlayer ( boolean openSpeaker(Speaker sp) ( // Implementierungsdetails ) )

Darüber hinaus, wenn wir eine Methode definieren openSpeaker() als geschützt festgelegt ist, kann von keiner anderen Klasse außer AudioPlayer darauf zugegriffen werden. Wenn wir es als öffentlich definieren, wird es für alle verfügbar. Aber unsere Absicht ist, diese Methode nur der Unterklasse zugänglich zu machen, deshalb haben wir den geschützten Modifikator verwendet.

Zugriffskontroll- und Vererbungsregeln

Für geerbte Methoden gelten in Java die folgenden Regeln:

In der Oberklasse als öffentlich deklarierte Methoden müssen auch in allen Unterklassen öffentlich sein.
In der Oberklasse als geschützt deklarierte Methoden müssen in Unterklassen entweder geschützt oder öffentlich sein; Sie können nicht privat sein.
Als privat deklarierte Methoden werden nicht von allen vererbt, daher gibt es keine Regel für sie.

Klassen-, Methoden-, Variablen- und Thread-Modifikatoren, die für Nichtzugriffszwecke verwendet werden

Java bietet eine Reihe von Modifikatoren nicht für den Zugriff, sondern für die Implementierung vieler anderer Funktionalitäten:

Modifikator statisch Wird zum Erstellen von Klassenmethoden und -variablen verwendet.
Modifikator Finale Wird verwendet, um die Implementierung von Klassen, Methoden und Variablen abzuschließen.
Modifikator abstrakt notwendig zum Erstellen abstrakter Klassen und Methoden;
Modifikatoren synchronisiert Und flüchtig Wird in Java für Threads verwendet.

Modifikator statisch

Modifikator statisch– wird zum Erstellen von Klassenmethoden und -variablen verwendet.

statische Variablen

Das Schlüsselwort static wird zum Erstellen von Variablen verwendet, die unabhängig von für die Klasse erstellten Instanzen existieren. Unabhängig von der Anzahl der Instanzen der Klasse existiert in Java nur eine Kopie einer statischen Variablen.

Statische Variablen werden auch als Klassenvariablen bezeichnet. In Java können lokale Variablen nicht als statisch deklariert werden.

statische Methoden

Das Schlüsselwort static wird zum Erstellen von Methoden verwendet, die unabhängig von den für die Klasse erstellten Instanzen existieren.

In Java verwenden statische Methoden oder statische Methoden keine Instanzvariablen eines Klassenobjekts, sie sind definiert. Die statischen Methoden akzeptieren alle Daten der Parameter und einige dieser Parameter werden ohne Bezug auf die Variablen berechnet.

Auf Klassenvariablen und -methoden kann zugegriffen werden, indem der Klassenname gefolgt von einem Punkt und dem Namen der Variablen oder Methode verwendet wird.

Beispiel

Der statische Modifikator in Java wird zum Erstellen von Methoden von Klassen und Variablen verwendet, wie im folgenden Beispiel gezeigt:

Es ergibt sich folgendes Ergebnis:

Ab 0 Instanz werden 500 Instanzen erstellt

letzter Modifikator

letzter Modifikator- Wird verwendet, um die Implementierung von Klassen, Methoden und Variablen abzuschließen.

Endgültige Variablen

Eine letzte Variable kann nur einmal initialisiert werden. Einer als final deklarierten Referenzvariablen kann niemals zugewiesen werden, auf ein anderes Objekt zu verweisen.

Die Daten innerhalb des Objekts können jedoch geändert werden. Somit kann der Zustand eines Objekts geändert werden, nicht jedoch die Referenz.

Bei Variablen in Java wird der letzte Modifikator oft zusammen mit static verwendet, um eine Klassenvariable konstant zu machen.

Beispiel

public class Test( final int value = 10; // Nachfolgend finden Sie Beispiele für Konstantendeklarationen: public static final int BOXWIDTH = 6; static final String TITLE = "Manager"; public void changeValue(){ value = 12; //будет получена ошибка } } !}

endgültige Methoden

Die letzte Methode kann von keiner Unterklasse überschrieben werden. Wie bereits erwähnt, verhindert der letzte Modifikator in Java, dass eine Methode von einer Unterklasse geändert wird.

Der Hauptzweck einer endgültigen Methode besteht darin, dass die Inhalte der Methode nicht gleichzeitig geändert werden.

Beispiel

Eine Methodendeklaration, die den finalen Modifikator in einer Klassendeklaration verwendet, wird im folgenden Beispiel gezeigt:

Öffentliche Klasse Test( public final void changeName())( // Methodenkörper ) )

Abschlussklasse

Der Hauptzweck der Verwendung einer als final deklarierten Klasse in Java besteht darin, zu verhindern, dass die Klasse eine Unterklasse ist. Wenn eine Klasse als final markiert ist, kann keine Klasse eine Funktion von der finalen Klasse erben.

Beispiel

öffentlicher finaler Klassentest (//Klassenkörper)

abstrakter Modifikator

abstrakter Modifikator- Wird zum Erstellen abstrakter Klassen und Methoden verwendet.

Zusammenfassung der Klasse

Eine abstrakte Klasse kann nicht instanziiert werden. Wenn eine Klasse als abstrakt deklariert ist, besteht ihr einziger Zweck darin, sie zu erweitern.

Eine Klasse kann nicht sowohl abstrakt als auch final sein, da eine finale Klasse nicht erweitert werden kann. Wenn eine Klasse abstrakte Methoden enthält, muss sie als abstrakt deklariert werden. Andernfalls wird ein Kompilierungsfehler generiert.

Die abstrakte Klasse kann sowohl abstrakte als auch reguläre Methoden enthalten.

Beispiel

abstrakte Klasse Caravan( privater doppelter Preis; privates String-Modell; privates String-Jahr; öffentliches abstraktes void goFast(); //abstrakte Methode öffentliches abstraktes void changeColor(); )

abstrakte Methode

Eine abstrakte Methode ist eine Methode, die mit einer beliebigen Implementierung deklariert wird. Der Methodenkörper (Implementierung) wird von der Unterklasse bereitgestellt. Abstrakte Methoden können niemals endgültig oder streng sein.

Jede Klasse, die eine abstrakte Klasse erweitert, muss alle abstrakten Methoden der Oberklasse implementieren, es sei denn, die Unterklasse ist eine abstrakte Klasse.

Wenn eine Klasse in Java eine oder mehrere abstrakte Methoden enthält, muss die Klasse als abstrakt deklariert werden. Eine abstrakte Klasse muss keine abstrakten Methoden enthalten.

Eine abstrakte Methode endet mit einem Semikolon. Beispiel: öffentliches abstraktes Beispiel ();

Beispiel

öffentliche abstrakte Klasse SuperClass( abstract void m(); //abstrakte Methode ) class SubClass erweitert SuperClass( // implementiert abstrakte Methode void m())( ......... ) )

synchronisierter Modifikator

synchronisierter Modifikator

Das synchronisierte Schlüsselwort wird verwendet, um anzugeben, dass jeweils nur ein Thread auf eine Methode zugreifen kann. In Java kann der synchronisierte Modifikator mit jedem der vier Zugriffsebenenmodifikatoren angewendet werden.

Beispiel

öffentlich synchronisiert void showDetails() ( ....... )

Transientenmodifikator

Eine als transient gekennzeichnete Instanzvariable weist auf virtuell hin Java-Maschine(JVM), um eine bestimmte Variable zu überspringen, wenn das Objekt, das sie enthält, serialisiert wird.

Dieser Modifikator ist in einer Anweisung enthalten, die eine Variable der vorhergehenden Klasse oder des Datentyps der Variablen erstellt.

Beispiel

öffentliches transientes int limit = 55; // wird nicht gespeichert public int b; // wird gespeichert

flüchtiger Modifikator

flüchtiger Modifikator– wird in Java für Threads verwendet.

In Java wird der Modifikator volatile verwendet, um der JVM mitzuteilen, dass ein Thread, der auf eine Variable zugreift, immer seine eigene Kopie der Variablen mit der Masterkopie im Speicher zusammenführen soll.

Durch den Zugriff auf eine flüchtige Variable werden alle zwischengespeicherten kopierten Variablen synchronisiert Arbeitsspeicher. Volatile kann nur auf Instanzvariablen angewendet werden, die vom Typ Objekt oder Privat sind. Eine flüchtige Objektreferenz kann null sein.

Beispiel

Die öffentliche Klasse MyRunnable implementiert Runnable( private volatile boolean active; public void run())( active = true; while (active)( // line 1 // some code here ) ) public void stop())( active = false; / / Zeile 2 ) )

Normalerweise wird run() in einem Thread aufgerufen (wenn Sie Runnable zum ersten Mal in Java verwenden) und stop() in einem anderen Thread. Wenn Zeile 1 den zwischengespeicherten Wert „Aktiv“ verwendet, kann die Schleife erst angehalten werden, wenn Sie „Aktiv“ in Zeile 2 auf „Falsch“ setzen.

In der nächsten Lektion besprechen wir die grundlegenden Operatoren, die in der Java-Sprache verwendet werden. In diesem Abschnitt erhalten Sie einen Überblick darüber, wie Sie sie während der Anwendungsentwicklung verwenden können.