[Java-Tutorial] Java-Variablentypen

Java-Variablentypen

In der Java-Sprache müssen alle Variablen vor der Verwendung deklariert werden. Das Grundformat zum Deklarieren von Variablen lautet wie folgt:

type identifier [ = value][, identifier [= value] ...] ;

Formatbeschreibung: Typ ist ein Java-Datentyp. Bezeichner ist der Variablenname. Mehrere Variablen desselben Typs können durch Kommas getrennt deklariert werden.

Im Folgenden sind einige Beispiele für Variablendeklarationen aufgeführt. Beachten Sie, dass einige einen Initialisierungsprozess beinhalten.

int a, b, c;         // 声明三个int型整数：a、 b、c。
int d = 3, e, f = 5; // d声明三个整数并赋予初值。
byte z = 22;         // 声明并初始化z。
double pi = 3.14159; // 声明了pi。
char x = 'x';        // 变量x的值是字符'x'。

Die von der Java-Sprache unterstützten Variablentypen sind:

Lokale Variablen

Mitgliedsvariablen

Klassenvariablen

Java lokal Variablen

Lokale Variablen werden in Methoden, Konstruktoren oder Anweisungsblöcken deklariert.

Lokale Variablen werden erstellt, wenn Methoden, Konstruktoren oder Anweisungsblöcke ausgeführt werden zerstört;

Zugriffsmodifikatoren können nicht für lokale Variablen verwendet werden;

lokale Variablen sind nur in der Methode, dem Konstruktor oder dem Anweisungsblock sichtbar, in dem sie deklariert sind; wird auf dem Stapel zugewiesen.

Lokale Variablen haben keinen Standardwert. Nachdem die lokale Variable deklariert wurde, muss sie daher initialisiert werden, bevor sie verwendet werden kann.

Beispiel 1

Im folgenden Beispiel ist das Alter eine lokale Variable. Es wird in der Methode pubAge() definiert und sein Gültigkeitsbereich ist auf diese Methode beschränkt.

Die Kompilierungs- und Ausführungsergebnisse des obigen Beispiels lauten wie folgt:

public class Test{ 
   public void pupAge(){
      int age = 0;
      age = age + 7;
      System.out.println("Puppy age is : " + age);
   }
   
   public static void main(String args[]){
      Test test = new Test();
      test.pupAge();
   }
}

Beispiel 2

Puppy age is: 7

Im folgenden Beispiel wird die Altersvariable nicht initialisiert , sodass beim Kompilieren ein Fehler auftritt.

Die obigen Beispiele für die Kompilierung und Ausführung lauten wie folgt:

public class Test{ 
   public void pupAge(){
      int age;
      age = age + 7;
      System.out.println("Puppy age is : " + age);
   }
   
   public static void main(String args[]){
      Test test = new Test();
      test.pupAge();
   }
}

Instanzvariablen

Test.java:4:variable number might not have been initialized
age = age + 7;
         ^
1 error

Instanzvariablen werden in einer Klasse deklariert, aber in Methoden und Konstruktoren und Anweisungsblöcke.

Bei der Instanziierung wird der Wert jeder Instanzvariablen bestimmt.

Instanzvariablen werden bei der Erstellung des Objekts erstellt und bei der Zerstörung des Objekts zerstört.

Der Wert einer Instanzvariablen sollte von mindestens einer Methode, einem Konstruktor oder einem Anweisungsblock referenziert werden, damit die Außenseite über diese Methoden Informationen zu Instanzvariablen erhalten kann.

Instanzvariablen können deklariert werden vor oder nach der Verwendung ;

Zugriffsmodifikatoren können Instanzvariablen ändern

Instanzvariablen sind für Methoden, Konstruktoren oder Anweisungsblöcke in der Klasse sichtbar. Im Allgemeinen sollten Instanzvariablen privat gemacht werden. Instanzvariablen können mithilfe von Zugriffsmodifikatoren für Unterklassen sichtbar gemacht werden.

Instanzvariablen haben Standardwerte. Der Standardwert numerischer Variablen ist 0, der Standardwert boolescher Variablen ist falsch und der Standardwert von Referenztypvariablen ist null. Der Wert einer Variablen kann zum Zeitpunkt der Deklaration oder im Konstruktor angegeben werden;

Auf Instanzvariablen kann direkt über den Variablennamen zugegriffen werden. In statischen Methoden und anderen Klassen sollten Sie jedoch den vollständig qualifizierten Namen verwenden: ObjectReference.VariableName.

Beispiel:

Die Kompilierungs- und Ausführungsergebnisse des obigen Beispiels lauten wie folgt:

import java.io.*;
public class Employee{
   // 这个成员变量对子类可见
   public String name;
   // 私有变量，仅在该类可见
   private double salary;
   //在构造器中对name赋值
   public Employee (String empName){
      name = empName;
   }
   //设定salary的值
   public void setSalary(double empSal){
      salary = empSal;
   }  
   // 打印信息
   public void printEmp(){
      System.out.println("name  : " + name );
      System.out.println("salary :" + salary);
   }

   public static void main(String args[]){
      Employee empOne = new Employee("Ransika");
      empOne.setSalary(1000);
      empOne.printEmp();
   }
}

Klassenvariable (statische Variable)

name  : Ransika
salary :1000.0

Klassenvariable heißt auch Statische Variablen werden mit dem Schlüsselwort static in der Klasse deklariert, müssen sich jedoch außerhalb des Methodenkonstruktors und des Anweisungsblocks befinden.

Egal wie viele Objekte eine Klasse erstellt, die Klasse verfügt nur über eine Kopie der Klassenvariablen.

Statische Variablen werden selten verwendet, außer wenn sie als Konstanten deklariert sind. Konstanten beziehen sich auf Variablen, die als öffentliche/private, endgültige und statische Typen deklariert sind. Konstanten können nach der Initialisierung nicht mehr geändert werden.

Statische Variablen werden im statischen Speicherbereich gespeichert. Variablen werden oft als Konstanten deklariert, selten jedoch nur mit statischen Variablen.

Statische Variablen werden am Anfang des Programms erstellt und am Ende des Programms zerstört.

hat eine ähnliche Sichtbarkeit wie Instanzvariablen. Um jedoch für Benutzer der Klasse sichtbar zu sein, werden die meisten statischen Variablen als öffentliche Typen deklariert.

Standardwerte ähneln Instanzvariablen. Der Standardwert numerischer Variablen ist 0, der Standardwert boolescher Variablen ist falsch und der Standardwert von Referenztypen ist null. Der Wert einer Variablen kann bei der Deklaration oder im Konstruktor angegeben werden. Darüber hinaus können statische Variablen auch in statischen Anweisungsblöcken initialisiert werden.

Auf statische Variablen kann zugegriffen werden über: ClassName.VariableName.

类变量被声明为public static final类型时，类变量名称必须使用大写字母。如果静态变量不是public和final类型，其命名方式与实例变量以及局部变量的命名方式一致。

实例：

import java.io.*;
public class Employee{
   //salary是静态的私有变量
   private static double salary;
   // DEPARTMENT是一个常量
   public static final String DEPARTMENT = "Development ";
   public static void main(String args[]){
      salary = 1000;
      System.out.println(DEPARTMENT+"average salary:"+salary);
   }
}

以上实例编译运行结果如下:

Development average salary:1000

注意：如果其他类想要访问该变量，可以这样访问：Employee.DEPARTMENT。

本章节中我们学习了Java的变量类型，下一章节中我们将介绍Java修饰符的使用。

 以上就是【java教程】Java变量类型的内容，更多相关内容请关注PHP中文网（www.php.cn）！