[tutoriel Java] Types de variables Java

Types de variables Java

Dans le langage Java, toutes les variables doivent être déclarées avant utilisation. Le format de base pour déclarer des variables est le suivant :

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

Description du format : le type est un type de données Java. identifiant est le nom de la variable. Vous pouvez déclarer plusieurs variables du même type séparées par des virgules.

Ce qui suit répertorie quelques exemples de déclarations de variables. Notez que certains incluent un processus d’initialisation.

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'。

Les types de variables pris en charge par le langage Java sont :

Variables locales

Variables membres

Variables de classe

Java local variables

Les variables locales sont déclarées dans les méthodes, les constructeurs ou les blocs d'instructions ;

Les variables locales sont créées lorsque les méthodes, les constructeurs ou les blocs d'instructions sont exécutés. Lorsqu'ils sont exécutés, les variables le seront. détruit ; les

les modificateurs d'accès ne peuvent pas être utilisés pour les variables locales ;

les variables locales ne sont visibles que dans la méthode, le constructeur ou le bloc d'instructions dans lequel elles sont déclarées ; est alloué sur la pile.

Les variables locales n'ont pas de valeur par défaut, donc une fois la variable locale déclarée, elle doit être initialisée avant de pouvoir être utilisée.

Exemple 1

Dans l'exemple suivant, l'âge est une variable locale. Il est défini dans la méthode pubAge() et sa portée est limitée à cette méthode.

Les résultats de compilation et d'exécution de l'exemple ci-dessus sont les suivants :

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();
   }
}

Exemple 2

Puppy age is: 7

Dans l'exemple suivant, la variable age n'est pas initialisée , donc une erreur se produit lors de la compilation.

L'exemple de compilation et les résultats d'exécution ci-dessus sont les suivants :

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();
   }
}

Variables d'instance

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

Les variables d'instance sont déclarées dans une classe, mais dans les méthodes, les constructeurs et blocs d'instructions De plus :

Lorsqu'un objet est instancié, la valeur de chaque variable d'instance est déterminée

Les variables d'instance sont créées lorsque l'objet est créé et détruites lorsque l'objet est détruit ;

La valeur d'une variable d'instance doit être référencée par au moins une méthode, un constructeur ou un bloc d'instructions, afin que l'extérieur puisse obtenir des informations sur la variable d'instance via ces méthodes

Les variables d'instance peuvent être déclarées ; avant ou après utilisation ;

Les modificateurs d'accès peuvent modifier les variables d'instance ;

Les variables d'instance sont visibles par les méthodes, les constructeurs ou les blocs d'instructions de la classe. En général, les variables d'instance doivent être rendues privées. Les variables d'instance peuvent être rendues visibles aux sous-classes en utilisant des modificateurs d'accès ;

Les variables d'instance ont des valeurs par défaut. La valeur par défaut des variables numériques est 0, la valeur par défaut des variables booléennes est fausse et la valeur par défaut des variables de type référence est nulle. La valeur d'une variable peut être spécifiée au moment de la déclaration ou dans le constructeur ;

Les variables d'instance sont accessibles directement via le nom de la variable. Mais dans les méthodes statiques et autres classes, vous devez utiliser le nom complet : ObjectReference.VariableName.

Exemple :

Les résultats de compilation et d'exécution de l'exemple ci-dessus sont les suivants :

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();
   }
}

Variable de classe (variable statique)

name  : Ransika
salary :1000.0

La variable de classe est également appelée Les variables statiques sont déclarées avec le mot-clé static dans la classe, mais doivent être en dehors du constructeur de méthode et du bloc d'instructions.

Peu importe le nombre d'objets qu'une classe crée, la classe n'a qu'une seule copie des variables de classe.

Les variables statiques sont rarement utilisées, sauf lorsqu'elles sont déclarées comme constantes. Les constantes font référence aux variables déclarées comme types public/privé, final et statique. Les constantes ne peuvent pas être modifiées après l'initialisation.

Les variables statiques sont stockées dans la zone de stockage statique. Souvent déclarées comme constantes, les variables sont rarement déclarées en utilisant uniquement la valeur statique.

Les variables statiques sont créées au début du programme et détruites à la fin du programme.

a une visibilité similaire aux variables d'instance. Mais afin d'être visibles par les utilisateurs de la classe, la plupart des variables statiques sont déclarées comme types publics.

Les valeurs par défaut sont similaires aux variables d'instance. La valeur par défaut des variables numériques est 0, la valeur par défaut des variables booléennes est fausse et la valeur par défaut des types référence est nulle. La valeur d'une variable peut être spécifiée lors de sa déclaration ou dans le constructeur. De plus, les variables statiques peuvent également être initialisées dans des blocs d'instructions statiques.

Les variables statiques sont accessibles via : 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）！