Eine Erklärung der Zugriffsmodifikatoren und des Variablenbereichs von Java

Java-Zugriffsmodifikatoren (Zugriffskontrollzeichen)
Java verwendet Modifikatoren, um Zugriffsrechte und andere Funktionen von Klassen, Eigenschaften und Methoden zu steuern, die normalerweise am Anfang der Anweisung platziert werden. Beispiel:

public class className {
  // body of class
}
private boolean myFlag;
static final double weeks = 9.5;
protected static final int BOXWIDTH = 42;
public static void main(String[] arguments) {
  // body of method
}

Java verfügt über viele Modifikatoren, die in Zugriffsmodifikatoren und Nichtzugriffsmodifikatoren unterteilt sind. In diesem Abschnitt werden nur Zugriffsmodifikatoren vorgestellt. Nichtzugriffsmodifikatoren werden später eingeführt.

Zugriffsmodifikatoren werden auch als Zugriffskontrollzeichen bezeichnet und beziehen sich auf Schlüsselwörter, die die Nutzungsrechte von Klassen, Mitgliedsvariablen und Methoden steuern können.

In der objektorientierten Programmierung sind Zugriffskontrollzeichen ein sehr wichtiges Konzept, mit dem der Zugriff auf Klassen, Variablen, Methoden und Konstruktoren geschützt werden kann.

Java unterstützt vier verschiedene Zugriffsrechte:

public: public

Klassen, Methoden und Strukturen, die als öffentliche Methoden und Schnittstellen deklariert werden können auf die jede andere Klasse zugreifen kann.

Wenn mehrere öffentliche Klassen, die aufeinander zugreifen, in verschiedenen Paketen verteilt sind, müssen Sie das Paket dort importieren, wo sich die entsprechende öffentliche Klasse befindet. Aufgrund der Klassenvererbung können alle öffentlichen Methoden und Variablen einer Klasse von ihren Unterklassen geerbt werden.

Die folgenden Methoden verwenden die öffentliche Zugriffskontrolle:

public static void main(String[] arguments) {
  // body of method
}

Die main()-Methode des Java-Programms muss auf öffentlich gesetzt sein, andernfalls wird dies der Java-Interpreter tun Diese Klasse kann nicht ausgeführt werden.
geschützt: geschützt

Variablen, Methoden und Konstruktoren, die als geschützt deklariert sind, können von jeder anderen Klasse im selben Paket und auch von Unterklassen in anderen Paketen aufgerufen werden.

Der geschützte Zugriffsmodifikator kann keine Klassen und Schnittstellen ändern. Methoden und Mitgliedsvariablen können als geschützt deklariert werden, Mitgliedsvariablen und Mitgliedsmethoden von Schnittstellen können jedoch nicht als geschützt deklariert werden.

Unterklassen können auf die mit dem geschützten Modifikator deklarierten Methoden und Variablen zugreifen und so nicht verwandte Klassen vor der Verwendung dieser Methoden und Variablen schützen.

Die folgende übergeordnete Klasse verwendet den geschützten Zugriffsmodifikator und die Unterklasse überlädt die bark()-Methode der übergeordneten Klasse.

public class Dog{
  protected void bark() {
    System.out.println("汪汪，不要过来");
  }
}
class Teddy extends Dog{ // 泰迪
  void bark() {
    System.out.println("汪汪，我好怕，不要跟着我");
  }
}

Wenn die bark()-Methode als privat deklariert ist, können andere Klassen als Dog nicht auf diese Methode zugreifen. Wenn bark() als öffentlich deklariert ist, können alle Klassen auf diese Methode zugreifen. Wenn wir möchten, dass die Methode nur für Unterklassen ihrer Klasse sichtbar ist, deklarieren Sie die Methode als geschützt.
privat: privat

Der private Zugriffsmodifikator ist die restriktivste Zugriffsebene, sodass als privat deklarierte Methoden, Variablen und Konstruktoren nur von der Klasse zugegriffen werden können, zu der sie gehören, Klassen und Schnittstellen jedoch nicht als privat deklariert.

Variablen, die als private Zugriffstypen deklariert sind, können nur von externen Klassen über die öffentlichen Getter/Setter-Methoden in der Klasse aufgerufen werden.

Die Verwendung des privaten Zugriffsmodifikators wird hauptsächlich dazu verwendet, die Implementierungsdetails der Klasse auszublenden und die Daten der Klasse zu schützen.

Die folgenden Klassen verwenden private Zugriffsmodifikatoren:

public class Dog{
  private String name;
  private int age;
  public String getName() {
    return name;
  }
  public void setName(String name) {
    this.name = name;
  }
  public int getAge() {
    return age;
  }
  public void setAge(int age) {
    this.age = age;
  }
}

Im Beispiel sind die Variablen „Name“ und „Alter“ in der Klasse „Hund“ private Variablen, andere Klassen können dies nicht Rufen Sie den Wert dieser Variablen direkt ab und legen Sie ihn fest. Um es anderen Klassen zu ermöglichen, die Variable zu bedienen, werden zwei Paare öffentlicher Methoden definiert, getName()/setName() und getAge()/setAge(), die zum Abrufen und Festlegen des Werts der privaten Variablen verwendet werden.

Dies ist ein Schlüsselwort in Java, das in diesem Kapitel besprochen wird. Sie können auf die detaillierte Erklärung dieses Schlüsselworts klicken, um eine Vorschau anzuzeigen.

Definieren Sie Methoden für den Zugriff auf private Variablen in einer Klasse. Es ist üblich, sie wie folgt zu benennen: Fügen Sie „get“ oder „set“ vor dem Variablennamen hinzu und schreiben Sie den ersten Buchstaben der Variablen groß. Die Methode zum Abrufen des Namens der privaten Variablen lautet beispielsweise getName() und die Methode zum Festlegen des Namens lautet setName(). Diese Methoden werden häufig verwendet und haben spezifische Namen, die als Getter- und Setter-Methoden bezeichnet werden.
Standard: Keine Schlüsselwörter verwenden

Attribute und Methoden, die ohne Modifikatoren deklariert werden, sind für Klassen im selben Paket sichtbar. Die Variablen in der Schnittstelle werden implizit als öffentliches statisches Finale deklariert, und die Zugriffsrechte der Methoden in der Schnittstelle sind standardmäßig öffentlich.

Wie im folgenden Beispiel gezeigt, werden Klassen, Variablen und Methoden ohne Modifikatoren definiert:

class Dog{
  String name;
  int age;
  
  void bark(){ // 汪汪叫
    System.out.println("汪汪，不要过来");
  }
  void hungry(){ // 饥饿
    System.out.println("主人，我饿了");
  }
}

Zugriffskontrolle und Vererbung

Bitte Beachten Sie die folgenden Regeln der Methodenvererbung (Leser, die das Konzept der Vererbung nicht verstehen, können hier überspringen oder auf Java-Vererbung und Polymorphismus-Vorschau klicken):
Methoden, die in der übergeordneten Klasse als öffentlich deklariert wurden, müssen auch in der untergeordneten Klasse öffentlich sein Klasse.
Methoden, die in der übergeordneten Klasse als geschützt deklariert wurden, werden in der Unterklasse entweder als geschützt oder öffentlich deklariert. Kann nicht als privat deklariert werden.
Methoden, die mit Standardmodifikatoren in der übergeordneten Klasse deklariert wurden, können in der Unterklasse als privat deklariert werden.
Methoden, die in der übergeordneten Klasse als privat deklariert wurden, können nicht vererbt werden.
So verwenden Sie Zugriffskontrollzeichen

Mit Zugriffskontrollzeichen können wir die Berechtigungen des Codes einfach steuern:
Wenn Sie dafür sorgen müssen, dass die von Ihnen geschriebene Klasse für alle anderen Klassen zugänglich ist, dann sind Sie es kann die Klasse hinzufügen. Das Zugriffskontrollzeichen wird als öffentlich deklariert.
Wenn Sie Ihre Klasse nur für Klassen in Ihrem eigenen Paket zugänglich machen müssen, können Sie das Zugriffskontrollzeichen weglassen.
Wenn Sie Mitgliedsdaten in einer Klasse kontrollieren müssen, können Sie die Zugriffskontrolle für Mitgliedsdaten in der Klasse auf „öffentlich“, „geschützt“ oder „ausgelassen“ festlegen.

Umfang von Java-Variablen
In Java ist der Umfang von Variablen in vier Ebenen unterteilt: Klassenebene, Objektinstanzebene, Methodenebene und Blockebene.

类级变量又称全局级变量或静态变量，需要使用static关键字修饰，你可以与 C/C++ 中的 static 变量对比学习。类级变量在类定义后就已经存在，占用内存空间，可以通过类名来访问，不需要实例化。

对象实例级变量就是成员变量，实例化后才会分配内存空间，才能访问。

方法级变量就是在方法内部定义的变量，就是局部变量。

块级变量就是定义在一个块内部的变量，变量的生存周期就是这个块，出了这个块就消失了，比如 if、for 语句的块。块是指由大括号包围的代码，例如：

{
  int age = 3;
  String name = "www.weixueyuan.net";
  // 正确，在块内部可以访问 age 和 name 变量
  System.out.println( name + "已经" + age + "岁了");
}
// 错误，在块外部无法访问 age 和 name 变量
System.out.println( name + "已经" + age + "岁了");

说明：
方法内部除了能访问方法级的变量，还可以访问类级和实例级的变量。
块内部能够访问类级、实例级变量，如果块被包含在方法内部，它还可以访问方法级的变量。
方法级和块级的变量必须被显示地初始化，否则不能访问。

演示代码：

public class Demo{
public static String name = "微学苑"; // 类级变量
public int i; // 对象实例级变量
// 属性块，在类初始化属性时候运行
{
int j = 2;// 块级变量
}
public void test1() {
int j = 3; // 方法级变量
if(j == 3) {
int k = 5; // 块级变量
}
// 这里不能访问块级变量，块级变量只能在块内部访问
System.out.println("name=" + name + ", i=" + i + ", j=" + j);
}
public static void main(String[] args) {
// 不创建对象，直接通过类名访问类级变量
System.out.println(Demo.name);
 
// 创建对象并访问它的方法
Demo t = new Demo();
t.test1();
}
}

运行结果：

微学苑
name=微学苑, i=0, j=3

更多Eine Erklärung der Zugriffsmodifikatoren und des Variablenbereichs von Java相关文章请关注PHP中文网！