Статические методы. Java: когда использовать статические методы

Что такое 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 - с англ. "статичный", "постоянный" - делает переменную или метод "независимыми" от объекта. Давайте рассмотрим, как модификатор применяется к методам.

Модификатор static для методов

1. Метод вызывается без создания объекта класса.

Как и в случае с полями, статические методы можно вызывать без создания объекта. Например, представим, что у нас есть класс MyClass - а внутри его два метода, статический и "обычный":

class MyClass{ public static void firstMethod (){ System.out.println("Это статический метод!"); } public void secondMethod (){ System.out.println("Это НЕ статический метод!"); } }

class MyClass { public static void firstMethod () { System . out . println ("Это статический метод!" ) ; public void secondMethod () { System . out . println ("Это НЕ статический метод!" ) ;

Мы можем вызвать оба метода, создав объект класса MyClass:

class Test { public static void main (String args){ MyClass c1 = new MyClass(); c1.firstMethod(); c1.secondMethod(); } }

class Test { MyClass c1 = new MyClass () ; c1 . firstMethod () ; c1 . secondMethod () ;

Тем не менее, попробуем записать то же самое без создания объекта - вот так:

class Test { public static void main (String args){ MyClass.firstMethod(); MyClass.secondMethod(); } }

class Test { public static void main (String args ) { MyClass . firstMethod () ; MyClass . secondMethod () ;

Тут мы заменили название объекта - c1 - на название класса (ведь ни одного объекта теперь у нас нет! :)).

Как Вы думаете, что произойдет?

Естественно, такой код работать не будет. Дело в том, что так обращаться можно только к одному из этих методов - статическому:

class Test { public static void main (String args){ MyClass.firstMethod(); } }

class Test { public static void main (String args ) { MyClass . firstMethod () ;

Если нам понадобится второй, не статический метод, понадобится создавать объект класса MyClass . Как видите, если обращаться к статическим методам и через название объекта, и название класса, код будет работать. К нестатическим методам нужно обращаться исключительно через название объектов класса.

2. Статические методы нельзя переопределять.

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

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

3. Статическим методам нужен "статический контекст".

Есть такое правило: статический метод не может ссылаться на нестатическую переменную . Что это значит?

Представьте, что у нас в каком-то классе есть статический метод. То есть это метод, к которому, как Вы знаете, можно обращаться без создания объекта класса . Это значит, что если статический метод будет обращаться к нестатическим переменным (которые попросту "не будут существовать", потому что объект не объявлен), то возникнет ошибка. Поэтому, статические методы могут ссылаться только на статические переменные . Это гарантирует, что во время выполнения нашего метода все элементы будут инициализированы и будут работать. Именно это и называется "статическим контекстом".

Итог двух частей - зачем применяется модификатор static

Итак, Вы в общих чертах поняли, в чем заключается принцип работы модификатора static. Давайте подытожим - как он применяется?

1. Если нужно объявить любую константу - например, = 3,14 - обязательно нужно использовать static. Они объявляются с использованием сочетание "static final":public class Test {

public static final double pi = 3.14159265359 ;

2. Если Вам нужно иметь доступ к переменной или методу без создания экземпляра класса. Например, представим, что у нас есть класс Cat. Логически, нет смысла делать статической переменную "имя кошки" - ведь оно будет индивидуальным для каждого экземпляра класс - т.е. для каждого кота. И метод "мяукать" делать статическим нет смысла - ведь без кошки (без создания объекта класса) вроде как некому будет мяукать 🙂

Но если представить, что у нас есть класс Math, в котором будет метод "найти корень квадратный". Это метод мы можем сделать статическим - ведь он нам явно очень пригодится, и будет часто использоваться. А зачем писать две строчки кода (создание экземпляра класса + вызов метода), если можно обойтись одной (вызов метода)? При этом, класс Math не несет никакой логическом нагрузки, в отличии от классов Cat, Dog или Car, и нам совершенно не нужен объект Math чтобы находить квадратные корни 🙂

3. У статических переменных и методов есть еще одно полезное свойство - они общие для всех экземпляров класса .

С одной стороны, это перекликается с установкой констант - пункт 1. Например, представьте, что у нас есть класс Cat, в котором есть два поля - "количество_лап" и "количество_хвостов". Понятно, что для всех экземпляров этого класса переменная "количество_лап" будет равна 4, а "количество_хвостов" равна 1. Мы можем сделать эти поля static, потому что они будут общими. Кроме того, это нам поможет сэкономить память, потому что эти переменные не будут "создаваться заново" для каждого экземпляра. Наоборот, все эти экземпляры будут ссылаться на одну и ту же - статическую - переменную.

Тот факт, что статическая переменная общая для всех классов, можно использовать и по-другому. Например, представьте, что у нас есть класс Dog. В этом классе, у нас будет статическая переменная "количество_собак", и мы сделаем так, чтобы каждый раз при создании объекта класса Dog она увеличивалась на 1. Таким образом, мы сможем посчитать, сколько мы создавали объектов! Или, как вариант, эту цифру можно использовать для присвоения уникального идентификационного номера каждой собаке.

Теперь Вы знаете основные способы применения модификатора static. Бывают и другие, но их мы рассмотрим позже.

Объявление методов.

Тема 9. Методы

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

Методы можно разделить на две основные группы - методы экземпляра (определенные без ключевого слова static ) , которые принадлежат группе функций экземпляра и статические методы с ключевым словом static , которые принадлежат к группе статических функций.

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

Определение метода состоит из заголовка и тела метода. В заголовке указываются важные атрибуты, определяющие, как другие части про­граммы осуществляют доступ к методу. Тело метода состоит из операторов, выполняю­щихся при его вызове.

Уровень доступа к методу определяется необязательным спецификатором в его за­головке.

На данный момент применялись два из возможных спецификаторов: public иprivate, public указывает, что к методу имеет доступ любая часть программы, a private ограничивает его применение за пределами класса.

Приведем синтаксический блок применения метода.

Метод::=

<3аголовок_метода>

<Тело_метода>

<3аголовок_метода>::=[<Спецификаторы_метода>] <Тип_возвращаемого_значения> <Идентификатор метода> ([<Список_формальных_параметров>])

< Тело_метода>: :=

<Операторы>

<Спецификаторы_метода>

::=<Спецификатор_доступности>

<Спецификатор_доступности>

::= public

::= private

<Тип_возвращаемого_значения>

::= <Тип>

Вызов метода состоит из его имени, за которым следует пара круглых скобок со спис­ком аргументов, последний должен соответствовать списку формальных параметров, определенных в заголовке метода.

Привести пример.

Известно, что исполнение программы в среде.NET начинается с вызова метода Main(). Среда исполнения не создает никаких объектов, поэтому Main() должен вызы­ваться независимо от них. Объявление метода Main() статическим указывает, что он принадлежит классу. Тем самым, среда исполнения вызывает Main () непосредственно через имя класса.

Статический метод можно вызвать тремя способами:

1. Из объекта класса, которому он принадлежит. В этом случае префикс (имя класса или объекта) не нужен.

public static void Average(…)

2. Извне данного класса.

При этом существуют две возможности:

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

myClass A = new myClass();

2. Независимо от существования объектов класса, а котором метод определен, он вызывается для класса посредством операции уточнения:

MyClass.Average(. ..)...

В вызоае метода предпочтительнее использовать имя класса (myClass.Average(...)), а не объекта A.Average(...) поскольку первый вариант четко указывает, что вызывается статический метод.

Последнее обновление: 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 перед типом возвращаемого значения в определении метода в области видимости класса:

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); // Строка вызовет ошибку компиляции, так как внутри статического члена использован нестатический. } }