Модификатор static в Java: методы

Для Windows Phone 26.07.2019

Последнее обновление: 19.04.2018

Кроме обычных методов и полей класс может иметь статические поля, методы, константы и инициализаторы. Например, главный класс программы имеет метод main, который является статическим:

Public static void main(String args) { }

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

Статические поля

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

Например, создадим статическую переменную:

Public class Program{ public static void main(String args) { Person tom = new Person(); Person bob = new Person(); tom.displayId(); // Id = 1 bob.displayId(); // Id = 2 System.out.println(Person.counter); // 3 // изменяем Person.counter Person.counter = 8; Person sam = new Person(); sam.displayId(); // Id = 8 } } class Person{ private int id; static int counter=1; Person(){ id = counter++; } public void displayId(){ System.out.printf("Id: %d \n", id); } }

Класс Person содержит статическую переменную counter, которая увеличивается в конструкторе и ее значение присваивается переменной id. То есть при создании каждого нового объекта Person эта переменная будет увеличиваться, поэтому у каждого нового объекта Person значение поля id будет на 1 больше чем у предыдущего.

Так как переменная counter статическая, то мы можем обратиться к ней в программе по имени класса:

System.out.println(Person.counter); // получаем значение Person.counter = 8; // изменяем значение

Консольный вывод программы:

Id = 1 Id = 2 3 Id = 8

Статические константы

Также статическими бывают константы, которые являются общими для всего класса.

Public class Program{ public static void main(String args) { double radius = 60; System.out.printf("Radisu: %f \n", radius); // 60 System.out.printf("Area: %f \n", Math.PI * radius); // 188,4 } } class Math{ public static final double PI = 3.14; }

Стоит отметить, что на протяжении всех предыдущих тем уже активно использовались статические константы. В частности, в выражении:

System.out.println("hello");

out как раз представляет статическую константу класса System. Поэтому обращение к ней идет без создания объекта класса System.

Статические инициализаторы

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

Public class Program{ public static void main(String args) { Person tom = new Person(); Person bob = new Person(); tom.displayId(); // Id = 105 bob.displayId(); // Id = 106 } } class Person{ private int id; static int counter; static{ counter = 105; System.out.println("Static initializer"); } Person(){ id=counter++; System.out.println("Constructor"); } public void displayId(){ System.out.printf("Id: %d \n", id); } }

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

В самой программе создаются два объекта класса Person. Поэтому консольный вывод будет выглядеть следующим образом:

Static initializer Constructor Constructor Id: 105 Id: 106

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

Статические методы

Статические методы также относятся ко всему классу в целом. Например, в примере выше статическая переменная counter была доступна извне, и мы могли изменить ее значение вне класса Person. Сделаем ее недоступной для изменения извне, но доступной для чтения. Для этого используем статический метод:

Public class Program{ public static void main(String args) { Person.displayCounter(); // Counter: 1 Person tom = new Person(); Person bob = new Person(); Person.displayCounter(); // Counter: 3 } } class Person{ private int id; private static int counter = 1; Person(){ id = counter++; } // статический метод public static void displayCounter(){ System.out.printf("Counter: %d \n", counter); } public void displayId(){ System.out.printf("Id: %d \n", id); } }

Теперь статическая переменная недоступна извне, она приватная. А ее значение выводится с помощью статического метода displayCounter. Для обращения к статическому методу используется имя класса: Person.displayCounter() .

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

Вообще методы определяются как статические, когда методы не затрагиют состояние объекта, то есть его нестатические поля и константы, и для вызова метода нет смысла создавать экземпляр класса. Например:

Public class Program{ public static void main(String args) { System.out.println(Operation.sum(45, 23)); // 68 System.out.println(Operation.subtract(45, 23)); // 22 System.out.println(Operation.multiply(4, 23)); // 92 } } class Operation{ static int sum(int x, int y){ return x + y; } static int subtract(int x, int y){ return x - y; } static int multiply(int x, int y){ return x * y; } }

В данном случае для методов sum, subtract, multiply не имеет значения, какой именно экземпляр класса Operation используется. Эти методы работают только с параметрами, не затрагивая состояние класса. Поэтому их можно определить как статические.

Что такое static

В некоторых случаях желательно определить член класса, который будет использоваться независимо от любого объекта этого класса. Обычно обращение к члену класса должно выполняться только в сочетании с объектом его класса. Однако можно создать член класса, который может использоваться самостоятельно, без ссылки на конкретный экземпляр. Чтобы создать такой член, в начало его объявления нужно поместить ключевое слово static. Когда член класса объявлен как static (статический), он доступен до создания каких-либо объектов его класса и без ссылки на какой-либо объект. Статическими могут быть объявлены как методы, так и переменные. Наиболее распространенный пример статического члена - метод main (). Этот метод объявляют как static, поскольку он должен быть объявлен до создания любых объектов.

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

На методы, объявленные как static, накладывается ряд ограничений.

Они могут вызывать только другие статические методы.
Они должны осуществлять доступ только к статическим переменным.
Они ни коим образом не могут ссылаться на члены типа this или super. (Ключевое слово super связано с наследованием и описывается в следующей главе.)

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

// Демонстрация статических переменных, методов и блоков.
class UseStatic {
static int a = 3;
static int b;
static void meth(int x) {
System.out.println ("x = " + x) ;
System.out.println ("a = " + a);
System.out.println("b = " + b) ;
}
static {
System.out.println("Статический блок инициализирован.");
b = a * 4;
}

meth(42);
}
}

Сразу после загрузки класса UseStatic программа выполняет все операторы static. Вначале значение а устанавливается равным 3, затем программа выполняет блок static, который выводит сообщение, а затем инициализирует переменную b значением а*4, или 12. Затем программа вызывает метод main (), который обращается к методу meth (), передавая параметру х значение 42. Три оператора println () ссылаются на две статических переменные а и b на локальную переменную х.

Вывод этой программы имеет такой вид:

Статический блок инициализирован, х = 42 а = 3 b = 12

За пределами класса, в котором они определены, статические методы и переменные могут использоваться независимо от какого-либо объекта. Для этого достаточно указать имя их класса, за которым должна следовать операция точки. Например, если метод типа static нужно вызвать извне его класса, это можно выполнить, используя следующую общую форму:

имя_класса.метод()

Здесь имя_класса - имя класса, в котором объявлен метод тип static. Как видите, этот формат аналогичен применяемому для вызова нестатических методов через переменные объектных ссылок. Статическая переменная доступна аналогичным образом - посредством операции точки, следующей за именем класса. Так в Java реализованы управляемые версии глобальных методов и переменных.

Приведем пример. Внутри метода main () обращение к статическому методу callme () и статической переменной b осуществляется посредством имени их класса StaticDemo.

class StaticDemo {
static int a = 42;
static int b = 99;
static void callme () {
System.out.println("a = " + a);
}
}
class StaticByName {
public static void main(String args) {
StaticDemo.callme () ;
System.out.println("b = " + StaticDemo.b);
}
}

Вывод этой программы выглядит следующим образом.

Модификатор static в Java напрямую связан с классом, если поле статично, значит оно принадлежит классу, если метод статичный, аналогично - он принадлежит классу. Исходя из этого, можно обращаться к статическому методу или полю используя имя класса. Например, если поле count статично в классе Counter , значит, вы можете обратиться к переменной запросом вида: Counter.count . Конечно, следует учитывать модификаторы доступа. Например, поля private доступны только внутри класса, в котором они объявлены. Поля protected доступны всем классам внутри пакета (package ), а также всем классам-наследникам вне пакета. Для более подробной информации ознакомьтесь со статьей “private vs protected vs public ”. Предположим, существует статический метод increment() в классе Counter , задачей которого является инкрементирование счётчика count . Для вызова данного метода можно использовать обращение вида Counter.increment() . Нет необходимости создавать экземпляр класса Counter для доступа к статическому полю или методу. Это фундаментальное отличие между статическими и НЕ статическими объектами (членами класса). Важное замечание. Не забывайте, что статические члены класса напрямую принадлежат классу, а не его экземпляру. То есть, значение статической переменной count будет одинаковое для всех объектов типа Counter . В этой статье мы рассмотрим основополагающие аспекты применения модификатора static в Java, а также некоторые особенности, которые помогут понять ключевые концепции программирования.

Что должен знать каждый программист о модификаторе Static в Java.

В этом разделе мы рассмотрим основные моменты использования статических методов, полей и классов. Начнём с переменных.

Вы НЕ можете получить доступ к НЕ статическим членам класса, внутри статического контекста, как вариант, метода или блока. Результатом компиляции приведенного ниже кода будет ошибка:

Это одна из наиболее распространённых ошибок допускаемых программистами Java, особенно новичками. Так как метод main статичный, а переменная count нет, в этом случае метод println , внутри метода main выбросит “Compile time error”.

В отличие от локальных переменных, статические поля и методы НЕ потокобезопасны (Thread-safe) в Java. На практике это одна из наиболее частых причин возникновения проблем связанных с безопасностью мультипоточного программирования. Учитывая что каждый экземпляр класса имеет одну и ту же копию статической переменной, то такая переменная нуждается в защите - «залочивании» классом. Поэтому при использовании статических переменных, убедитесь, что они должным образом синхронизированы (synchronized), во избежание проблем, например таких как «состояние гонки» (race condition).

Статические методы имеют преимущество в применении, т.к. отсутствует необходимость каждый раз создавать новый объект для доступа к таким методам. Статический метод можно вызвать, используя тип класса, в котором эти методы описаны. Именно поэтому, подобные методы как нельзя лучше подходят в качестве методов-фабрик (factory), и методов-утилит (utility). Класс java.lang.Math - замечательный пример, в котором почти все методы статичны, по этой же причине классы-утилиты в Java финализированы (final).

Другим важным моментом является то, что вы НЕ можете переопределять (Override) статические методы. Если вы объявите такой же метод в классе-наследнике (subclass), т.е. метод с таким же именем и сигнатурой, вы лишь «спрячете» метод суперкласса (superclass) вместо переопределения. Это явление известно как сокрытие методов (hiding methods). Это означает, что при обращении к статическому методу, который объявлен как в родительском, так и в дочернем классе, во время компиляции всегда будет вызван метод исходя из типа переменной. В отличие от переопределения, такие методы не будут выполнены во время работы программы. Рассмотрим пример:

"Внутри родительского класса/статического метода"

"Внутри дочернего класса/статического метода "

Вывод в консоль:

Внутри родительского класса/статического метода

Код наглядно демонстрирует: несмотря на то, что объект имеет тип Car , вызван статический метод из класса Vehicle , т.к. произошло обращение к методу во время компиляции. И заметьте, ошибки во время компиляции не возникло!

Объявить статическим также можно и класс, за исключением классов верхнего уровня. Такие классы известны как «вложенные статические классы» (nested static class). Они бывают полезными для представления улучшенных связей. Яркий пример вложенного статического класса - HashMap.Entry , который предоставляет структуру данных внутри HashMap . Стоит заметить, также как и любой другой внутренний класс, вложенные классы находятся в отдельном файле.class. Таким образом, если вы объявили пять вложенных классов в вашем главном классе, у вас будет 6 файлов с расширением.class. Ещё одним примером использования является объявление собственного компаратора (Comparator), например компаратор по возрасту (AgeComparator) в классе сотрудники (Employee).

Модификатор static также может быть объявлен в статичном блоке, более известным как «Статический блок инициализации» (Static initializer block), который будет выполнен во время загрузки класса. Если вы не объявите такой блок, то Java соберёт все статические поля в один список и выполнит его во время загрузки класса. Однако, статичный блок НЕ может пробросить перехваченные исключения, но может выбросить не перехваченные. В таком случае возникнет «Exception Initializer Error». На практике, любое исключение возникшее во время выполнения и инициализации статических полей, будет завёрнуто Java в эту ошибку. Это также самая частая причина ошибки «No Class Def Found Error», т.к. класс не находился в памяти во время обращения к нему.

Полезно знать, что статические методы связываются во время компиляции, в отличие от связывания виртуальных или не статических методов, которые связываются во время исполнения на реальном объекте. Следовательно, статические методы не могут быть переопределены в Java, т.к. полиморфизм во время выполнения не распространяется на них. Это важное ограничение, которое необходимо учитывать, объявляя метод статическим. В этом есть смысл, только тогда, когда нет возможности или необходимости переопределения такого метода классами-наследниками. Методы-фабрики и методы-утилиты хорошие образцы применения модификатора static . Джошуа Блох выделил несколько преимуществ использования статичного метода-фабрики перед конструктором, в книге «Effective Java », которая является обязательной для прочтения каждым программистом данного языка.

Важным свойством статического блока является инициализация. Статические поля или переменные инициализируются после загрузки класса в память. Порядок инициализации сверху вниз, в том же порядке, в каком они описаны в исходном файле Java класса. Поскольку статические поля инициализируются на потокобезопасный манер, это свойство также используется для реализации паттерна Singleton . Если вы не используется список Enum как Singleton , по тем или иным причинам, то для вас есть хорошая альтернатива. Но в таком случае необходимо учесть, что это не «ленивая» инициализация. Это означает, что статическое поле будет проинициализировано ещё ДО того как кто-нибудь об этом «попросит». Если объект ресурсоёмкий или редко используется, то инициализация его в статическом блоке сыграет не в вашу пользу.

Во время сериализации, также как и transient переменные, статические поля не сериализуются. Действительно, если сохранить любые данные в статическом поле, то после десериализации новый объект будет содержать его первичное (по-умолчанию) значение, например, если статическим полем была переменная типа int , то её значение после десериализации будет равно нулю, если типа float – 0.0, если типа Object – null . Честно говоря, это один из наиболее часто задаваемых вопросов касательно сериализации на собеседованиях по Java. Не храните наиболее важные данные об объекте в статическом поле!

И напоследок, поговорим о static import . Данный модификатор имеет много общего со стандартным оператором import , но в отличие от него позволяет импортировать один или все статические члены класса. При импортировании статических методов, к ним можно обращаться как будто они определены в этом же классе, аналогично при импортировании полей, мы можем получить доступ без указания имени класса. Данная возможность появилась в Java версии 1.5, и при должном использовании улучшает читабельность кода. Наиболее часто данная конструкция встречается в тестах JUnit , т.к. почти все разработчики тестов используют static import для assert методов, например assertEquals() и для их перегруженных дубликатов. Если ничего не понятно – добро пожаловать за дополнительной информацией .

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

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

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

Public function upload() { $width = Config::read("width"); $height = Config::read("height"); // .. Do upload.. }
(На заметку CakePHP кишит такими подходами)
Проблемы такого подхода?

1. Нужно знать и быть точно уверенным, что статичный класс Config, был где-то там далеко инициализирован. А вдруг он не был инициализированным?

2. А что если ты решишь сменить источник конфига? Например читать, это все не из класса `Config` а откуда-нибудь из REST? Придется все переписывать, затем опять тестировать. Эта проблема известна как сильная связка .

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

4. Скрытые зависимости.

Например инициализуруя класс, в случае статики:

$uploader = new Uploader(); $uploader->upload(...);

Ты и твои пользователи не видят какие у класса зависимости и от работы чего вообще он зависит. Проблема заметна особо, когда ты пишешь библиотеку или компонет.

Но тогда почему такие популярные фреймворки как Yii или Laravel полностью покрыты статикой?

Для того чтобы понять какие последствия несет статика, попробуй воспользоватся хоть одним компонентом Yii фреймворка отдельно. Например, если тебе нужна только CAPTCHA ты не сможешь её вытащить оттуда не переписав почти весь компонент, потому что везде внутри присутвует глобальное состояние, в виде `Yii::$app->`. То есть чтобы воспользоватся только капчей, придется подключать весь фреймворк и все его внутренние механизмы, когда это абсолютно не нужно.

Что касается Laravel, то статики там меньше, поскольку некоторые компоненты, вроде Eloquent могут использоватся по отдельности. Статика в ларе, она существует как обёртка, но не как реализация, во многих местах в отличии от Yii.

Вообще посмотри, как задачи решаются в Zend / Symfony
Там почти везде все зависимости передаются в качестве аргументов, что есть хорошо, слабо связано, и тестируемо.

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

статические методы в статических классах;

статические методы в нестатических классах.

Если программист объявляет класс статическим, то все члены этого класса становятся статическими, в том числе и методы. Это методы классов - контейнеров инструкций, они принимают объекты других типов для обработки и выдают нужное программисту значение типа.

Более распространен случай, когда программисту необходимо реализовать блок инструкций, независимый от объекта типа. Таким блоком инструкций выступает статический метод, поскольку вызывается до создания экземпляра типа.

Объявление и вызов статического метода

Метод объявляется статическим посредством ключевого слова static перед типом возвращаемого значения в определении метода в области видимости класса:

Public class Somenonstaticclass { // Объявляем статические поля. static int firststaticfield; static string secondstaticfield; // Объявляем нестатические поля. double firstnonstaticfield; float secondnonstaticfield; // Объявляем статический метод. static void FirstStaticMethod() { // Реализация статического метода. Console.WriteLine(firststaticfield); Console.WriteLine(secondstaticfield); } }

Программист может вызвать статический метод через имя типа, в котором он определен:

Class UseStaticMethods { static void Main() { // Вызываем статический метод через имя типа. Somenonstaticclass.FirstStaticMethod(); } }

Ограничения использования

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

Public class Somenonstaticclass { // Объявляем статические поля класса. static int firststaticfield; static string secondstaticfield; double firstnonstaticfield; float secondnonstaticfield; // Объявляем статический метод. static void FirstStaticMethod() { // Реализация статического метода. Console.WriteLine(firststaticfield); Console.WriteLine(secondstaticfield); } // Перегружаем метод FirstStaticMethod(). static int FirstStaticMethod(string a) { Console.WriteLine("Выводится введенный вами аргумент метода: "+a); } }

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

Public class Somenonstaticclass { // Объявляем статические поля класса. static int firststaticfield; static string secondstaticfield; double firstnonstaticfield; float secondnonstaticfield; // Объявляем статический метод. static void FirstStaticMethod() { // Реализация статического метода. Console.WriteLine(firststaticfield); Console.WriteLine(secondstaticfield); Console.WriteLine(firstnonstaticfield); // Строка вызовет ошибку компиляции, так как внутри статического члена использован нестатический. } }