Типы переменных Java

В языке Java все переменные должны быть объявлены до их использования.

Базовый формат объявления переменной выглядит следующим образом:

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

Описание формата:

  • type -- тип данных.
  • идентификатор -- это имя переменной, и запятые можно использовать,для разделения и объявления нескольких переменных одного типа.

Ниже приведены некоторые примеры объявления переменных. Обратите внимание, что некоторые включают процесс инициализации.

int a, b, c;         //Объявите три целых числа int: a, b, c int d = 3, e = 4, f = 5; //Объявите три целых числа и присвойте начальные значения byte z = 22;         //Объявите и инициализируйте z String s = "example"; //Объявите и инициализируйте строку s double pi = 3.14159; //Объявлена переменная pi с плавающей запятой двойной точности char x = 'x';        //Объявите переменную x со значением символа 'x'.

Типы переменных, поддерживаемые языком Java:

  • Локальные переменные:Локальные переменные — это переменные, объявленные внутри метода, конструктора или блока. Они уничтожаются, когда метод, конструктор или блок, в котором они объявлены, завершает выполнение. Локальные переменные необходимо инициализировать при объявлении; иначе возникнет ошибка компиляции.

    public void exampleMethod() {
    int localVar = 10; // 局部变量
    // ...
}

  • Переменные экземпляра:Переменные экземпляра объявляются в классе, но вне методов, конструкторов или блоков. Они принадлежат экземплярам класса, и каждый экземпляр класса имеет свою собственную копию. Если они явно не инициализированы, переменным экземпляра присваиваются значения по умолчанию (0 для числовых типов, false для boolean, null для ссылочных типов объектов).

    public class ExampleClass {
    int instanceVar; // 实例变量
}

  • Статические переменные или переменные класса:Переменные класса — это переменные, объявленные с ключевым словом static в классе. Они принадлежат классу, а не экземплярам. Все экземпляры класса совместно используют одно и то же значение переменной класса. Переменные класса инициализируются при загрузке класса и инициализируются только один раз.

    public class ExampleClass {
    static int classVar; // 类变量
}

  • Параметры:Параметры — это переменные в объявлениях методов или конструкторов, используемые для получения значений, передаваемых при вызове метода или конструктора. Область видимости переменных-параметров ограничена пределами метода.

    public void exampleMethod(int parameterVar) {
    // 参数变量
    // ...
}

В следующем примере определяется класс ExampleTest, который содержит переменную экземпляра instanceVar и статическую переменную staticVar.

В методе method() определяются переменная-параметр paramVar и локальная переменная localVar. Внутри метода мы присваиваем значение локальной переменной переменной-члену, присваиваем значение переменной-параметра статической переменной, а затем выводим значения этих переменных.

В методе main() мы создаём объект ExampleTest и вызываем его метод method().

Пример

public class ExampleTest { //Переменная-член private int instanceVar; //Статическая переменная private static int staticVar; public void method(int paramVar) { //Локальная переменная int localVar = 10; //Использование переменных instanceVar = localVar; staticVar = paramVar; System.out.println("Переменная-член:" + instanceVar); System.out.println("Статическая переменная:" + staticVar); System.out.println("Переменная-параметр:" + paramVar); System.out.println("Локальная переменная:" + localVar); } public static void main(String[] args) { ExampleTest v = new ExampleTest(); v.method(20); } }

Запустите приведённый выше код, и вывод будет следующим:

成员变量: 10
静态变量: 20
参数变量: 20
局部变量: 10

Переменные-параметры Java

Переменные-параметры в Java — это переменные, объявленные в методах или конструкторах, используемые для получения значений, передаваемых методу или конструктору. Переменные-параметры похожи на локальные переменные, но они существуют только при вызове метода или конструктора и могут использоваться только внутри метода или конструктора.

Синтаксис объявления метода в Java выглядит следующим образом:

accessModifier returnType methodName(parameterType parameterName1, parameterType parameterName2, ...) {
    // 方法体
}
  • parameterType -- обозначает тип переменной-параметра.
  • parameterName -- обозначает имя переменной-параметра.

При вызове метода мы должны передавать значения переменным-параметрам; эти значения могут быть константами, переменными или выражениями.

Существует два способа передачи значений переменным параметров метода:Передача по значениюиПередача по ссылке。

  • Передача по значению:При вызове метода передается копия значения фактического параметра. Когда переменной параметра присваивается новое значение, изменяется только значение копии, а исходное значение не затрагивается. Базовые типы данных в Java используют передачу по значению для передачи значений переменных параметров.

  • Передача по ссылке:При вызове метода передается ссылка (то есть адрес памяти) на параметр. Когда переменной параметра присваивается новое значение, содержимое исходного значения изменяется. Объектные типы в Java используют передачу по ссылке для передачи значений переменных параметров.

Ниже приведен простой пример, демонстрирующий использование переменных параметров метода:

Пример

public class ExampleTest {
    public static void main(String[] args) {
        int a = 10, b = 20;
        swap(a, b); // Вызов метода swap
        System.out.println("a = " + a + ", b = " + b); // Вывод значений a и b
    }
   
    public static void swap(int x, int y) {
        int temp = x;
        x = y;
        y = temp;
    }
}

Запустите приведённый выше код, и вывод будет следующим:

a = 10, b = 20

Локальные переменные Java

Локальные переменные в Java — это переменные, объявленные внутри метода, конструктора или блока операторов, и их область видимости ограничена блоком кода, в котором они объявлены.

Синтаксис объявления локальных переменных:

type variableName;
  • type -- представляет тип переменной.
  • variableName -- представляет имя переменной.

Описание:

  • Область видимости: Область видимости локальной переменной ограничена методом, конструктором или блоком кода, в котором она объявлена. Как только поток выполнения покидает эту область, локальная переменная становится недоступной.

  • Жизненный цикл: Жизненный цикл локальной переменной начинается при ее объявлении и заканчивается, когда метод, конструктор или блок кода завершает выполнение. После этого локальная переменная будет собрана сборщиком мусора.

  • Инициализация: Локальные переменные должны быть инициализированы перед использованием. Если они не инициализированы, компилятор сообщит об ошибке, поскольку Java не предоставляет значения по умолчанию для локальных переменных.

  • Объявление: Локальные переменные должны быть объявлены в начале метода или блока кода. При объявлении можно указать тип данных, а затем имя переменной, например:int count;。

  • Присваивание: Локальной переменной после объявления должно быть присвоено значение, прежде чем ее можно будет использовать в методе. Присваивание может быть прямым, либо через вызов метода или выражение.

  • Ограничения: Локальные переменные не могут напрямую использоваться другими методами класса; они доступны только внутри метода или блока кода, в котором они объявлены.

  • Управление памятью: Локальные переменные хранятся в стеке виртуальной машины Java (JVM), в отличие от переменных экземпляра или объектов, которые хранятся в куче.

  • Сборка мусора: Поскольку жизненный цикл локальных переменных строго ограничен выполнением метода или блока кода, после завершения выполнения метода или блока кода на них больше не ссылаются. Поэтому сборщик мусора JVM автоматически освобождает занимаемую ими память.

  • Повторное использование: Имена локальных переменных можно повторно использовать в разных методах или блоках кода, поскольку их область видимости локальна и не вызывает конфликтов имен.

  • Параметры и возвращаемые значения: Параметры метода можно рассматривать как особый вид локальных переменных. Они инициализируются при вызове метода, а их жизненный цикл заканчивается после возврата из метода.

Пример

Ниже приведён простой пример, демонстрирующий использование локальных переменных:

Пример

public class LocalVariablesExample {
    public static void main(String[] args) {
        int a = 10; // Объявление и инициализация локальной переменной a
        int b;     // Объявление локальной переменной b
        b = 20;    // Инициализация локальной переменной b
       
        System.out.println("a = " + a);
        System.out.println("b = " + b);
       
        // Если локальная переменная не инициализирована перед использованием, компилятор сообщит об ошибке
        // int c;
        // System.out.println("c = " + c);
    }
}

В приведённом выше примере мы объявили и инициализировали две локальные переменные a и b, а затем вывели их значения. Обратите внимание: если не инициализировать локальную переменную перед её использованием, компилятор сообщит об ошибке.

В следующем примере age — локальная переменная, определённая в методе pupAge(), и её область действия ограничена этим методом:

package com.example.test; public class Test{ public void pupAge(){ int age = 0; age = age + 7; System.out.println("Возраст щенка:" + age); } public static void main(String[] args){ Test test = new Test(); test.pupAge(); } }

Результат компиляции и выполнения приведенного выше примера выглядит следующим образом:

小狗的年龄是: 7

В следующем примере переменная age не инициализирована, поэтому возникает ошибка компиляции:

package com.example.test; public class Test{ public void pupAge(){ int age; age = age + 7; System.out.println("Возраст щенка:" + age); } public static void main(String[] args){ Test test = new Test(); test.pupAge(); } }

Результат компиляции и выполнения приведенного выше примера выглядит следующим образом:

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

Переменные-члены (переменные экземпляра)

  • Переменные-члены объявляются в классе, но вне методов, конструкторов и блоков операторов.
  • При создании экземпляра объекта значение каждой переменной-члена определяется соответствующим образом.
  • Переменные-члены создаются при создании объекта и уничтожаются при уничтожении объекта.
  • На значения переменных-членов должен ссылаться хотя бы один метод, конструктор или блок операторов, чтобы внешний код мог получать информацию о переменных экземпляра через эти средства.
  • Переменные-члены можно объявлять до или после их использования.
  • Модификаторы доступа могут модифицировать переменные-члены.
  • Переменные-члены видимы для методов, конструкторов или блоков операторов внутри класса. Как правило, переменные-члены должны быть объявлены как private. С помощью модификаторов доступа переменные-члены можно сделать видимыми для подклассов.
  • Переменные-члены имеют значения по умолчанию. Значение по умолчанию для числовых переменных — 0, для переменных типа boolean — false, а для переменных ссылочного типа — null. Значение переменной можно задать при объявлении или в конструкторе.
  • К переменным-членам можно обращаться напрямую по имени переменной. Однако в статических методах и других классах следует использовать полное имя:ObjectReference.VariableName。

Синтаксис объявления переменных-членов:

accessModifier type variableName;
  • accessModifier -- обозначает модификатор доступа, который может быть public, protected, private или уровнем доступа по умолчанию (т. е. без явно указанного модификатора доступа).
  • type -- обозначает тип переменной.
  • variableName -- обозначает имя переменной.

В отличие от локальных переменных, переменные-члены получают память для своих значений при создании объекта. Даже если они не инициализированы, им присваиваются значения по умолчанию. Например, переменные типа int по умолчанию равны 0, а переменные типа boolean по умолчанию равны false.

К переменным-членам можно обращаться через объект или через имя класса (если они являются статическими переменными-членами). Если переменные-члены явно не инициализированы, им присваиваются значения по умолчанию. Вы можете инициализировать переменные-члены в конструкторах или других методах либо обращаться к ним через объект или имя класса, чтобы задать их значения.

Пример

В следующем примере мы объявляем две переменные-члены a и b, а также обращаемся к ним и задаём их. Обратите внимание, что к переменным-членам можно обращаться через объект, а к статическим переменным-членам — также через имя класса.

Пример

public class ExampleTest {
      private int a; // Приватная переменная-член a
      public String b = "Hello"; // Открытая переменная-член b
     
      public static void main(String[] args) {
         ExampleTest obj = new ExampleTest(); // Создать объект
         
          obj.a = 10; // Обратиться к переменной-члену a и задать её значение равным 10
          System.out.println("a = " + obj.a);
         
          obj.b = "World"; // Обратиться к переменной-члену b и задать ей значение "World"
          System.out.println("b = " + obj.b);
      }
  }

Приведённый выше пример компилируется и выполняется со следующим результатом:

a = 10
b = World

В следующем примере мы объявляем две переменные-члены name и salary, а также получаем к ним доступ и устанавливаем их.

Код файла Employee.java:

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 ); System.out.println("Зарплата :" + salary); } public static void main(String[] args){ Employee empOne = new Employee("EXAMPLE"); empOne.setSalary(1000.0); empOne.printEmp(); } }

Приведённый выше пример компилируется и выполняется со следующим результатом:

$ javac Employee.java 
$ java Employee
名字 : EXAMPLE
薪水 : 1000.0

Переменные класса (статические переменные)

Статическая переменная в Java — это переменная, определённая в классе. Она связана с классом, а не с экземплярами. То есть, независимо от того, сколько экземпляров класса создано, в памяти существует только одна копия статической переменной, общая для всех экземпляров.

Статические переменные создаются при загрузке класса и существуют на протяжении всего выполнения программы.

Определение метода

Чтобы определить статическую переменную, нужно использовать ключевое словоstaticдля модификации переменной, которое также обычно называют переменной класса.

В следующем примере мы определяем статическую переменнуюcountс начальным значением 0:

Пример

public class MyClass {
    public static int count = 0;
    // Другие переменные-члены и методы
}

Способ доступа

Поскольку статические переменные связаны с классом, вы можете получать доступ к статическим переменным через имя класса, а также через имя экземпляра.

Пример

MyClass.count = 10; // Доступ через имя класса
MyClass obj = new MyClass();
obj.count = 20; // Доступ через имя экземпляра

Жизненный цикл

Время жизни статических переменных совпадает со временем жизни программы. То есть они создаются при загрузке класса и существуют в течение всего выполнения программы, и не уничтожаются до её завершения. Поэтому статические переменные можно использовать для хранения данных, необходимых всей программе, таких как информация о конфигурации, глобальные переменные и т. д.

Время инициализации

Статические переменные инициализируются при загрузке класса, и порядок их инициализации связан с порядком определения.

Если статическая переменная зависит от другой статической переменной, она должна быть определена после другой.

Пример

public class MyClass {
    public static int count1 = 0;
    public static int count2 = count1 + 1;
    // Другие переменные-члены и методы
}

В приведённом выше примере count1 должен быть инициализирован до count2; иначе возникнет ошибка компиляции.

Разница между константами и статическими переменными

Константы также связаны с классом, но это переменные, объявленные с ключевым словом final, и после присваивания их нельзя изменить. В отличие от статических переменных, значение константы определяется на этапе компиляции, тогда как значение статической переменной может изменяться во время выполнения. Кроме того, константы обычно используются для хранения фиксированных значений, таких как математические константы, информация о конфигурации и т. д., тогда как статические переменные обычно используются для хранения изменяемых данных, таких как счётчики, глобальное состояние и т. д.

В итоге, статические переменные — это переменные, связанные с классом, обладающие уникальностью и совместным использованием. Они могут использоваться для хранения данных, необходимых всей программе, но следует обращать внимание на время инициализации и отличие от констант.

Модификаторы доступа для статических переменных

Модификатором доступа для статических переменных может быть public, protected, private или модификатор доступа по умолчанию (т. е. отсутствие модификатора доступа).

Следует отметить, что права доступа у статических переменных отличаются от прав доступа у переменных экземпляра, поскольку статические переменные связаны с классом и не зависят ни от какого экземпляра.

Потокобезопасность статических переменных

Статические переменные в Java принадлежат классу, а не экземплярам объектов. Поэтому, когда несколько потоков одновременно обращаются к классу, содержащему статические переменные, необходимо учитывать их потокобезопасность.

Статические переменные имеют только одну копию в памяти, общую для всех экземпляров. Поэтому, если один поток изменяет значение статической переменной, другие потоки при доступе к этой статической переменной также увидят изменённое значение. Это может вызвать проблемы с многопоточностью, поскольку несколько потоков могут одновременно изменять статическую переменную, что приводит к неопределённым результатам или проблемам с согласованностью данных.

Чтобы обеспечить потокобезопасность статических переменных, необходимы соответствующие меры синхронизации, такие как механизмы синхронизации, атомарные классы или ключевое слово volatile, чтобы значения статических переменных можно было корректно читать и изменять в многопоточной среде.

Соглашения об именовании статических переменных

Соглашение об именовании статических переменных (также называемых переменными класса) обычно следует camelCase и обычно использует все заглавные буквы с подчёркиваниями между словами, а также должно явно помечаться ключевым словом static.

  • Используйте camelCase:Имена статических переменных должны использовать camelCase, то есть первая буква строчная, а первая буква каждого последующего слова заглавная. Например:myStaticVariable。

  • Все заглавные буквы:Статические переменные обычно используют все заглавные буквы с подчёркиваниями между словами. Это называется "Upper Snake Case". Например:MY_STATIC_VARIABLE。

  • Описательность:Имена переменных должны быть осмысленными и чётко выражать назначение переменной. Избегайте использования одиночных символов или сокращений без ясного значения.

  • Избегайте использования сокращений:Старайтесь избегать использования сокращений, чтобы повысить читаемость кода. Если использование сокращений необходимо, убедитесь, что они широко понятны, и поясните их в комментариях.

Пример

public class MyClass {
    // Используйте camelCase
    public static int myStaticVariable;

    // Используйте Upper Snake Case
    public static final int MAX_SIZE = 100;

    // Избегайте использования сокращений
    public static final String employeeName;

    // Описательные имена переменных
    public static double defaultInterestRate;
}

Сценарии использования статических переменных

Статические переменные обычно используются в следующих сценариях:

  • Хранение глобального состояния или информации о конфигурации
  • Счётчики или статистическая информация
  • Кэширование данных или общих ресурсов
  • Константы или методы в служебных классах
  • Переменные экземпляра в шаблоне Singleton

Пример

В следующем примере определяется класс AppConfig, содержащий три статические переменные: APP_NAME, APP_VERSION и DATABASE_URL, используемые для хранения имени приложения, версии и URL подключения к базе данных. Все эти переменные объявлены как final, что указывает на то, что они являются неизменяемыми константами.

В методе main() мы выводим значения этих статических переменных.

Код файла AppConfig.java:

public class AppConfig { public static final String APP_NAME = "MyApp"; public static final String APP_VERSION = "1.0.0"; public static final String DATABASE_URL = "jdbc:mysql://localhost:3306/mydb"; public static void main(String[] args) { System.out.println("Имя приложения: " + AppConfig.APP_NAME); System.out.println("Версия приложения: " + AppConfig.APP_VERSION); System.out.println("URL базы данных: " + AppConfig.DATABASE_URL); } }

Приведённый выше пример компилируется и выполняется со следующим результатом:

Application name: MyApp
Application version: 1.0.0
Database URL: jdbc:mysql://localhost:3306/mydb

Видно, что глобальная конфигурационная информация, хранящаяся в этих статических переменных, может использоваться во всей программе и не будет изменяться. Этот пример демонстрирует ещё одно распространённое применение статических переменных, с помощью которого можно удобно хранить глобальную конфигурационную информацию или реализовывать другие данные, которые должны быть глобально общими.

В следующем примере определяется класс Counter, который содержит статическую переменную count, используемую для записи того, сколько объектов Counter было создано.

Всякий раз, когда создается новый объект, конструктор увеличивает счетчик на единицу. Статический метод getCount() используется для получения текущего значения счетчика.

В методе main() мы создаем три объекта Counter и выводим значение счетчика.

Код файла Counter.java:

public class Counter { private static int count = 0; public Counter() { count++; } public static int getCount() { return count; } public static void main(String[] args) { Counter c1 = new Counter(); Counter c2 = new Counter(); Counter c3 = new Counter(); System.out.println("Количество созданных на данный момент объектов:" + Counter.getCount()); } }

Приведённый выше пример компилируется и выполняется со следующим результатом:

目前为止创建的对象数: 3

Видно, что счётчик фиксирует, что было создано три объекта. Этот пример показывает простое применение статических переменных, с помощью которых мы можем легко подсчитывать количество созданных объектов или записывать другие данные, которые должны совместно использоваться глобально.

В этой главе мы изучили типы переменных Java. В следующей главе мы познакомимся с использованием модификаторов Java.

Другие расширения