Java 变量

在本文中，我们将向所有 Java 学习者解释什么是 Java 变量以及如何使用它们。

什么是Java变量

Java 中的变量可以被认为是一个盒子。这个“盒子”有一定的大小：分配给它的内存。分配多少内存取决于变量的类型，但我们稍后会讨论这个问题。同时，框本身的大小在创建后不能更改，但内容可以。盒子可能是空的。您可以向其中“插入”一些值，然后提取并放入其他一些值。由此可见，变量是Java程序执行过程中存储数据值的字段。这个盒子有重要的特点：

• 它总是只能包含一个值（或者可以为空，在这种情况下它将包含默认值），
• 它有一个数据类型。它的大小取决于数据的类型，以及为它分配位置的内存的哪个特定区域（它位于何处）。

如何声明变量

要在 Java 中声明变量，您需要指定其类型和名称。这是声明三个变量的示例：

int myInt;
String s;
Object variableName;

这里int、String和Object是数据类型，myInt、s、variableName是变量名。数据类型一定要根据程序的需要来选择，而且最好选择一个名字，让人一目了然。当然，对于初学者来说并没有那么严格，但是在大型项目中，像's'这样的变量名会损害代码的可读性。因此，最好习惯于以一种从一开始就清楚它们的用途的方式命名变量。当然，在合理范围内。

如何初始化变量

当你声明一个变量时，你就为它分配了内存。初始化就是你把某个值“放入”到“盒子”中。这可以在变量声明期间或之后立即完成。此外，变量的值可以在程序执行期间更改。例子：

public class VariableTest {
    public static void main(String[] args) {
        int myInt = 5;
        String s;
        s = "init";
        System.out.println(s);
        s = s+5;
        System.out.println(s);
    }
}

在这里，我们在一行中声明并初始化了 myInt变量，立即为其分配内存（每个 int 数字 32 位），为其命名，然后将值 5 放入分配的内存中。然后我们声明我们正在为字符串s分配内存空间，并且已经有一个单独的命令将值“init”放入其中。之后，我们打印出字符串并更改变量s的值。在这个程序中，我们打印出了这些行，如果你运行它，你会看到以下结果：

Java中变量的数据类型：原始和非原始

Java 中变量的数据类型分为两组：

• 原始数据类型包括byte、short、int、long、float、double、boolean和char
• 非原始数据类型，例如String、Arrays和Classes

下面是一个使用变量的例子：

public class VariableTest {
   public static void main(String[] args) {

       int myInt = - 5;               // integer (whole number)
       float myFloat = 2.718281828459045f;    // Floating point number
       char myLetter = 'a';         // character
       boolean myBool = true;       // boolean
       String myText = "Hero";     // String
       System.out.println(myInt + " " +
               myFloat +" " + myLetter + " " +  myBool + " " + myText);
       Student myStudent = new Student("Walker","Johnny", "Kyle", null);
      
   }
}

int、char、boolean和float是原语。字符串是非原始的。myStudent变量呢？这是用户创建的类Student的对象。它的创建只是为了说明非原始变量的工作。它们在 Java 中占多数，因为在这种编程语言中几乎所有东西都是对象。为了便于理解，这里是Student类的代码：

import java.util.Date;

public class Student {
   String surname;
   String name;
   String secondName;
   Long birthday; // Long instead of long is used by Gson/Jackson json parsers and various orm databases

   public Student(String surname, String name, String secondName, Date birthday ){
       this.surname = surname;
       this.name = name;
       this.secondName = secondName;
       this.birthday = birthday == null ? 0 : birthday.getTime();
   }

   @Override
   public int hashCode(){
       //TODO: check for nulls
       //return surname.hashCode() ^ name.hashCode() ^ secondName.hashCode() ^ (birthday.hashCode());
       return (surname + name + secondName + birthday).hashCode();
   }
   @Override
   public boolean equals(Object other_) {
       Student other = (Student)other_;
       return (surname == null || surname.equals(other.surname) )
               && (name == null || name.equals(other.name))
               && (secondName == null || secondName.equals(other.secondName))
               && (birthday == null || birthday.equals(other.birthday));
   }
}

Java 中的变量类型：局部变量、实例变量和静态变量

Java 中存在三种不同类型的变量，我们将它们列举如下：

1. 局部变量
2. 实例变量
3. 静态变量

局部变量

在方法体内声明的变量称为局部变量。此外，局部变量在构造函数和块中声明。您只能在创建局部变量的方法、构造函数或块中使用局部变量，而类中的其他方法甚至不知道该变量的存在。因此，局部变量是在方法、构造函数或块进入时创建的，一旦方法、构造函数或块不起作用，变量就会被销毁。不能使用static关键字定义局部变量。更重要的是：您不能对局部变量使用访问修饰符。这是一个例子：

public class VariableTest {
   public static void main(String[] args) {
       System.out.println(myMethod("C plus "));
   }
           private static String myMethod(String myString) {
       String myOtherString = "plus";
       return myString + myOtherString;
   }
}

这里myOtherString是一个局部变量。您不能从其他方法使用它，但myMethod。局部变量不能有默认值。如果程序中至少有一个局部变量没有被初始化，程序将无法正常运行。让我们对前面的一个示例做一个小改动，并“忘记”初始化myBool变量：

public class VariableTest {
   public static void main(String[] args) {

       int myInt = - 5;               // integer (whole number)
       float myFloat = 2.718281828459045f;    // Floating point 
       char myLetter = 'a';         // character
       boolean myBool;       // boolean
       String myText = "Hero";     // String
       System.out.println(myInt + " " +
               myFloat +" " + myLetter + " " +  myBool + " " + myText);
       Student myStudent = new Student("Walker","Johnny", "Kyle", null);

   }
}

如果我们尝试运行该程序，它会抛出一个错误：

实例变量

在类内部但在任何方法、构造函数或块的主体之外声明的变量称为实例变量。实例变量是在使用new关键字创建对象时创建的。它在对象被销毁时被销毁。它不能声明为静态的，但您可以对实例变量使用访问修饰符。实例变量对于类中的所有方法、构造函数和块都是可见的。通常实例变量是私有的，但您可以更改子类的可见性。与局部变量相反的实例变量具有默认值。对于所有数字原始类型，默认值为 0，对于布尔值，默认值为 false，对于对象引用，默认值为 null。可以在声明期间或在构造函数中分配值。这是一个例子：

//instance variable example
public class Employee {

   // here we have a public instance variable. It is visible for this class and child classes
   public String name;

   //this instance variable is private so it’s visible for the Employee class only. You can use setters and getters to get it
   private double salary;

   public Employee (String empName) {
       name = empName;
   }

   public String getName() {
       return name;
   }

   public void setName(String name) {
       this.name = name;
   }

   public double getSalary() {
       return salary;
   }

   public void setSalary(double employeeSalary) {
       salary = employeeSalary;
   }

   public static void main(String args[]) {
       Employee employee = new Employee("Johnny");
       employee.setSalary(1500);
       System.out.println("name = " + employee.getName());
       System.out.println("salary = " + employee.getSalary());
   }
}

静态变量

声明为静态的变量称为静态变量。Java 允许您在方法、构造函数或块之外声明此类变量。它不能是本地的，它们属于类，而不是实例。这意味着静态变量的单个副本一旦创建并在类的所有实例之间共享。当类加载到内存中时，静态变量的内存分配只会发生一次。它们可以具有任何可见性，但通常它们被声明为公开的。它们也有默认值，例如实例变量。

public class Box
{
   public void add(int data)
   {
       Storage.sum = Storage.sum + data;
       Storage.count++;
   }

   public void remove(int data)
   {
       Storage.sum = Storage.sum - data;
       Storage.count--;
   }
}

public class Storage
{
   public static int count = 0;
   public static int sum = 0;
}

在上面的示例中，我们创建了一个单独的Storage类，将 count 和 sum 变量移入其中，并将它们声明为静态。公共静态变量可以从任何程序方法访问（而不仅仅是从一个方法）。 为了巩固您所学的知识，我们建议您观看我们的 Java 课程中的视频课程