Java Modifikator

Java provides many modifiers, mainly divided into the following two categories:

• Access modifier

• Nicht-zugriffsmodifizierende Schlüsselworte

Modifiers are used to define classes, methods, or variables and are usually placed at the beginning of the statement. We use the following examples to illustrate:

public class ClassName　{
　　　//　...
}
private boolean myFlag;
static final double weeks =　9.5;
protected static final int BOXWIDTH =　42;
public static void main(String[] arguments) {
　　　//　Methodenkörper
}

Access control modifier

In Java, access control modifiers can be used to protect access to classes, variables, methods, and constructors. Java supports 4 different access permissions.

• default (i.e. default, nothing to write): Visible within the same package without any modifiers. Usage: classes, interfaces, variables, methods.

• private : Visible within the same class. Usage: variables, methods. Note: Cannot modify classes (external classes)

• öffentlich : Visible to all classes. Usage: classes, interfaces, variables, methods

• geschützt : Visible to classes and all subclasses within the same package. Usage: variables, methods. Note: Cannot modify classes (external classes)。

We can use the following table to explain access permissions:

Access control

default access modifier-without any keyword

Variables and methods declared with the default access modifier are visible to classes within the same package. Variables in interfaces are implicitly declared as public static final, and methods in interfaces have public access rights by default.

As shown in the following example, the declaration of variables and methods can be made without any modifiers.

package　defaultPackage;
class　Logger　{
　　　　void　message(){
　　　　　　　　System.out.println("This　is　a　message");
　　　　}
}

In this case, the Logger class has a default access modifier. And this class is visible to all classes in the defaultPackage package. However, if we try to use the Logger class in another class outside of defaultPackage, we will get a compilation error.

private access modifier-private

The private access modifier is the strictest access level, so those declared as private methods, variables, and constructors can only be accessed by the class they belong to, and classes and interfaces cannot be declared as private。

Variables declared as private access type can only be accessed by external classes through public getter methods of the class.

Die Verwendung des privaten Zugriffsmarkers dient hauptsächlich dazu, die Implementierungsdetails der Klasse zu verbergen und die Daten der Klasse zu schützen.

Die folgenden Klassen verwenden den privaten Zugriffsmarker:

public class Logger {
　　　private String format;
　　　public String getFormat() {
　　　　　　return this.format;
　　　}
　　　public void setFormat(String format) {
　　　　　　this.format = format;
　　　}
}

Im Beispiel ist das format -Variable des Logger-Klassen ein privates Variable, daher können andere Klassen den Wert der Variable nicht direkt erhalten und setzen. Um es anderen Klassen zu ermöglichen, die Variable zu verwalten, wurden zwei öffentliche Methoden definiert: getFormat() (gibt den Wert von format zurück) und setFormat(String) (setzt den Wert von format)

Öffentlicher Zugriffsmarker-öffentlich

Als öffentlich deklarierte Klassen, Methoden, Konstruktoren und Interfaces können von jeder anderen Klasse aufgerufen werden.

Wenn mehrere miteinander verknüpfte öffentliche Klassen in verschiedenen Paketen verteilt sind, muss das Paket, in dem sich die öffentliche Klasse befindet, importiert werden. Wegen der Vererbung können alle öffentlichen Methoden und Variablen der Klasse von ihren Unterklasse geerbt werden.

Die folgenden Funktionen verwenden öffentliche Zugriffssteuerungen:

public static void main(String[] arguments) {
　　　//　...
}

Der main() -Methoden der Java-Programme muss öffentlich gesetzt werden, sonst kann der Java-Interpreter die Klasse nicht ausführen.

geschützter Zugriffsmarker-geschützt

Geschützt muss aus zwei Punkten analysiert und erläutert werden:

• Die Unterklasse und die Basisklasse sind im selben Paket.Die als geschützt deklarierten Variablen, Methoden und Konstruktoren können von jeder anderen Klasse im selben Paket aufgerufen werden;

• Die Unterklasse und die Basisklasse sind nicht im selben Paket.Daher kann die Unterklasse in der Unterklasse auf die geschützten Methoden zugreifen, die sie von der Basisklasse geerbt hat, und kann nicht auf die geschützten Methoden der Basisklassensitzung zugreifen.

Geschützt kann für Datenmitglieder, Konstruktoren, Methodenmitglieder verwendet werden,Es kann nicht für Klassen (außer inneren Klassen) verwendet werden.。

Die Interface sowie die Member-variablen und -methoden des Interfaces können nicht als geschützt deklariert werden.

Die Unterklasse kann auf Methoden und Variablen zugreifen, die mit geschützt markiert sind, so dass unverbundene Klassen diese Methoden und Variablen schützen können.

Die übergeordnete Klasse verwendet den geschützten Zugriffsmarker, und die Unterklasse überschreibt die Methode openSpeaker() der übergeordneten Klasse.

class AudioPlayer {
　　　protected boolean openSpeaker(Speaker sp) {}}
　　　　　　//　Implementierungsdetails
　　　}
}
　
class StreamingAudioPlayer extends AudioPlayer {
　　　protected boolean openSpeaker(Speaker sp) {}}
　　　　　　//　Implementierungsdetails
　　　}
}

Wenn openSpeaker() als private deklariert wird, können außer AudioPlayer keine anderen Klassen auf diese Methode zugreifen.

Wenn openSpeaker() als public deklariert wird, können alle Klassen auf diese Methode zugreifen.

Wenn wir möchten, dass die Methode nur für die abgeleitete Klasse der Klasse sichtbar ist, dann wird die Methode als protected deklariert.

protected ist der am schwersten zu verstehende Java-Klasse-Mitgliedszugriffsmodifikator.

Zugriffssteuerung und Vererbung

Bitte beachten Sie die folgenden Regeln der Methode-Vererbung:

• Methoden, die im Elternklasse als public deklariert wurden, müssen in der abgeleiteten Klasse auch als public sein.

• Methoden, die im Elternklasse als protected deklariert wurden, müssen in der abgeleiteten Klasse entweder als protected oder als public deklariert werden, nicht jedoch als private.

• Methoden, die im Elternklasse als private deklariert wurden, können nicht vererbt werden.

Nicht-zugriffsmodifizierende Schlüsselworte

Um einige andere Funktionen zu realisieren, bietet Java auch viele nicht-zugriffsmodifizierende Schlüsselworte.

static-Bezeichner, der verwendet wird, um Klasse-Methode und Klasse-Variable zu modellieren.

final-Bezeichner, der verwendet wird, um Klasse, Methode und Variable zu modellieren. Eine durch final modellierte Klasse kann nicht vererbt werden, eine durch final modellierte Methode kann von einer abgeleiteten Klasse nicht neu definiert werden, und eine durch final modellierte Variable ist ein Konstante und kann nicht geändert werden.

abstract-Bezeichner, der verwendet wird, um abstrakte Klasse und abstrakte Methode zu erstellen.

synchronized und volatile-Bezeichner, die hauptsächlich für die Programmierung von Threads verwendet werden.

static-Bezeichner

• Statische Variable:

  Der static-Schlüsselworte wird verwendet, um unabhängige von Objekten statische Variablen zu deklarieren. Unabhängig davon, wie viele Objekte eine Klasse instanziert, hat die statische Variable nur eine Kopie. Statische Variablen werden auch als Klasse-Variable bezeichnet. Lokale Variablen können nicht als static-Variablen deklariert werden.

• Statische Methoden:

  Der static-Schlüsselworte wird verwendet, um unabhängige von Objekten statische Methoden zu deklarieren. Statische Methoden können keine nicht-statischen Variablen der Klasse verwenden. Statische Methoden erhalten Daten aus der Parameterliste, berechnen diese Daten dann.

Der Zugriff auf Klasse-Variable und Methode kann direkt mit classname.variablename und classname.methodname durch die Art und Weise zuzugreifen.

Wie im Beispiel gezeigt, wird der static-Bezeichner verwendet, um Klasse-Methode und Klasse-Variable zu erstellen.

public class 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[] arguments) {
　　　　　　System.out.println("Von ",　+
　　　　　　InstanceCounter.getCount()　+　"von 0 Instanzen beginnen");
　　　　　　for (int i = 0; i <　500;　++i){
　　　　　　　　　new InstanceCounter();
　　　　　　　　　　}
　　　　　　System.out.println("Erstellt ",　+
　　　　　　InstanceCounter.getCount()　+　"　instances");
　　　}
}

Das Ergebnis des Laufens des obigen Beispiels ist wie folgt:

Von 0 Instanzen beginnen
Erstellen　500 Instanzen

final Bezeichner

final Variable:

final bedeutet "letzter, endgültiger", eine Variable kann nach der Zuweisung nicht neu zugewiesen werden. Variablen, die mit final markiert sind, müssen eine explizite Initialwertangabe haben.

Der final Bezeichner wird normalerweise zusammen mit dem static Bezeichner verwendet, um Klassenkonstanten zu erstellen.

public class Test{
　　final int value =　10;
　　//　Hier ist ein Beispiel für die Deklaration von Konstanten
　　public static final int BOXWIDTH =　6;
　　static final String TITLE = "Manager";
　
　　public void changeValue(){
　　　　　value =　12;　//Gibt einen Fehler aus
　　}
}

final Methode

Finalen Methoden in der Elternklasse können von der Unterklasse vererbt werden, aber sie können nicht von der Unterklasse überschrieben werden.

Der Hauptzweck der Deklaration eines finalen Methods ist es, zu verhindern, dass der Inhalt der Methode geändert wird.

Wie gezeigt, wird die Methode mit dem final Bezeichner deklariert.

public class Test{
　　　　public final void changeName(){
　　　　　　　//　Methodenkörper
　　　　}
}

final Klasse

final Klassen können nicht vererbt werden, keine Klasse kann irgendwelche Eigenschaften einer finalen Klasse vererben.

public final class Test {
　　　//　Klassenkörper
}

abstract Bezeichner

Abstrakte Klasse:

Abstrakte Klassen können nicht zum Beispielisieren von Objekten verwendet werden, der einzige Zweck der Deklaration einer abstrakten Klasse ist es, die Klasse in der Zukunft zu erweitern.

Eine Klasse kann nicht gleichzeitig abstract und final modifiziert werden. Wenn eine Klasse abstrakte Methoden enthält, muss diese Klasse unbedingt als abstrakte Klasse deklariert werden, anderenfalls tritt ein Kompilierungsfehler auf.

Eine abstrakte Klasse kann sowohl abstrakte als auch nicht-abstrakte Methoden enthalten.

abstract class Caravan{
　　　private double price;
　　　private String model;
　　　private String year;
　　　public abstract void goFast();　//Abstrakte Methoden
　　　public abstract void changeColor();
}

Abstrakte Methoden

Abstrakte Methoden sind Methoden ohne Implementierung, deren spezifische Implementierung von den Unterklassen bereitgestellt wird.

Abstrakte Methoden können nicht als final und static deklariert werden.

Jegliche Unterklasse, die eine abstrakte Klasse vererbt, muss alle abstrakten Methoden des Elternklasse implementieren, es sei denn, die Unterklasse ist ebenfalls eine abstrakte Klasse.

Wenn eine Klasse mehrere abstrakte Methoden enthält, muss diese Klasse als abstrakte Klasse deklariert werden. Eine abstrakte Klasse kann keine abstrakten Methoden enthalten.

Die Deklaration der abstrakten Methoden endet mit einem Semikolon, z.B.:public abstract sample();。

public abstract class SuperClass{
　　　　abstract void m();　//Abstrakte Methoden
}
　
class SubClass extends SuperClass{
　　　　　//Implementierung abstrakter Methoden
　　　　　　void m(){
　　　　　　　　　　.......
　　　　　　}
}

synchronized Dekorator

Die durch den synchronized Schlüsselwort erklärten Methoden können zu jeder Zeit nur von einem Thread aufgerufen werden. Der synchronized Dekorator kann auf die vier Zugriffsmodifikatoren angewendet werden.

public synchronized void showDetails(){
.......
}

transient Dekorator

Wenn ein serialisierter Objekt eine von transient dekorierte Beispielvariable enthält, überspringt der Java Virtual Machine (JVM) diese spezifische Variable.

Dieser Dekorator ist in der Definitionssatz des Variablen enthalten und wird verwendet, um die Datenart von Klassen und Variablen vorzupreparieren.

public transient int limit =;　55;　　　//　Wird nicht persistiert
public int b;　//　Persistenz

volatile Dekorator

Die von volatile dekorierten Member-Variable werden bei jedem Zugriff durch einen Thread gezwungen, den Wert des Member-Variables neu aus dem Shared-Memory zu lesen. Und wenn der Member-Variable ein Wertänderung auftritt, wird der geänderte Wert gezwungen, in das Shared-Memory zurückgeschrieben zu werden. Auf diese Weise sehen zwei verschiedene Threads zu jeder Zeit denselben Wert eines Member-Variables.

Eine volatile Objektreferenz kann null sein.

public class MyRunnable implements Runnable
{
　　　　private volatile boolean active;
　　　　public void run()
　　　　{
　　　　　　　　active = true;
　　　　　　　　while (active)　//　Erste Zeile
　　　　　　　　{
　　　　　　　　　　　　//　Code
　　　　　　　　}
　　　　}
　　　　public void stop()
　　　　{
　　　　　　　　active = false;　//　Zweite Zeile
　　　　}
}

In der Regel wird die Methode run() von einem Thread aufgerufen (in einem Thread, der von Runnable gestartet wurde), und die Methode stop() von einem anderen Thread aufgerufen. Wenn Erste Zeile Wenn der Wert von active im Puffer verwendet wird, dann in Zweite Zeile Wenn der Wert von active false ist, wird der Zyklus nicht beendet.

Aber in diesem Code haben wir volatile verwendet, um active zu modizieren, daher wird der Zyklus beendet.