Модификатор static в Java: методы. Статические классы, методы, переменные
Последнее обновление: 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 используется. Эти методы работают только с параметрами, не затрагивая состояние класса. Поэтому их можно определить как статические.
The static can be:
Let"s look at static variables and static methods first.
What is Static Variable in Java?
Static variable in Java is variable which belongs to the class and initialized only once at the start of the execution.
- It is a variable which belongs to the class and not to object(instance)
- Static variables are initialized only once, at the start of the execution. These variables will be initialized first, before the initialization of any instance variables
- A single copy to be shared by all instances of the class
- A static variable can be accessed directly by the class name and doesn’t need any object
<class-name>.
What is Static Method in Java?
Static method in Java is a method which belongs to the class and not to the object. A static method can access only static data.
- It is a method which belongs to the class and not to the object(instance)
- A static method can access only static data. It can not access non-static data (instance variables)
- A static method can call only other static methods and can not call a non-static method from it.
- A static method can be accessed directly by the class name and doesn’t need any object
- A static method cannot refer to "this" or "super" keywords in anyway
<class-name>.
Note: main method is static, since it must be accessible for an application to run, before any instantiation takes place.
Lets learn the nuances of the static keywords by doing some excercises!
Example: How to call static variables & methods
Step 1) Copy the following code into a editor
Public class Demo{ public static void main(String args){ Student s1 = new Student(); s1.showData(); Student s2 = new Student(); s2.showData(); //Student.b++; //s1.showData(); } } class Student { int a; //initialized to zero static int b; //initialized to zero only when class is loaded not for each object created. Student(){ //Constructor incrementing static variable b b++; } public void showData(){ System.out.println("Value of a = "+a); System.out.println("Value of b = "+b); } //public static void increment(){ //a++; //} }
Step 2) Save & Compile the code. Run the code as, java Demo .
Step 3) Expected output show below
Following diagram shows, how reference variables & objects are created and static variables are accessed by the different instances.
Step 4) It is possible to access a static variable from outside the class using the syntax ClassName.Variable_Name . Uncomment line # 7 & 8 . Save , Compile & Run . Observe the output.
Value of a = 0
Value of b = 1
Value of a = 0
Value of b = 2
Value of a = 0
Value of b = 3
Step 5)
Uncomment line 25,26 & 27 . Save , Compile & Run.
error: non-static variable a cannot be referenced from a static context a++;
Step 6)
Error = ? This is because it is not possible to access instance variable "a
" from java static class method "increment
".
Java Static Block
The static block is a block of statement inside a Java class that will be executed when a class is first loaded into the JVM
Class Test{
static {
//Code goes here
}
}
A static block helps to initialize the static data members , just like constructors help to initialize instance members
Модификатора 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. Бывают и другие, но их мы рассмотрим позже.
Переменное число параметров метода
Иногда число аргументов, которые будут переданы методу, неизвестно до периода выполнения. Например, вам нужен класс, который чертит на графике линию, заданную последовательностями х- и у-координат. Этот класс должен содержать методом, принимающим единственный аргумент - объект типа Point, представляющий значения обеих координат х и у. Этот метод должен сохранять каждый объект типа Point в связанном списке или в элементах массива, пока вызывающая программа не даст команду на вывод всей последовательности точек. Однако такое решение может быть не очень эффективным потому, что оно требует наличия в классе связанного списка. Но ведь можно было бы использовать единственный метод - DrawLine, которому этот список может и не потребоваться. Эту проблему эффективно решает метод с переменным количеством аргументов.
Такому методу можно задать переменное число аргументов через ключевое слово params в видемассива. Рассмотрим пример класса Chart, написанного на C#, позволяющего пользователю одним вызовом получить и вывести произвольное число объектов Point:
using System;
class Point //Класс точки
public Point(int x, int y) { this.x = x; this.у = у; }
public int x; public int y;
class Chart //Класс рисовальщика
public void DrawLine(Graphics g, params Point p)
Console.WriteLine("\пЭтот метод позволяет нарисовать линию " +
"по следующим точкам:");
for (int i = 0; i < p.GetLength(0); i++)
{ Console.WriteLine("{0), {1}". p[i].x, p[i].y); }
class ChartApp
public static void Main()
Point p1 = new Point(5,10);
Point p2 = new Point(5, 15);
Point p3 = new Point(5, 20);
Chart chart = new Chart();
chart.DrawLine(p1, p2, p3);
Метод DrawLine сообщает компилятору C#, что он может принимать переменное число объектов типа Point. Затем в период выполнения метод использует простой цикл for для прохода по всем объектам Point и вывода всех точек.
Статическим называется метод, который существует в классе как в таковом, а не в отдельных его экземплярах. Как и в случае других статических членов, главное преимущество статических методов в том, что они расположены вне конкретных экземпляров класса, не засоряя глобальное пространство приложения. При этом они и не нарушают принципов ООП, поскольку ассоциированы с определенным классом.
Определить метод как статический позволяет ключевое слово static. Затем для вызова метода пользователь применяет синтаксис вида Класс. Метод. Этот синтаксис необходим, даже если у пользователя есть ссылка на экземпляр класса.
Статические (static ) методы, или методы класса, можно вызывать, не создавая экземпляр объекта. Именно таким образом используется метод Main .
public class Sample
public static int a;
public int b;
public static void DoubleA(){ a *= 2; }
public void SetB(){ b = a; }
public class Application
public static void Main()
Sample sc1 = new Sample(), sc2 = new Sample();
Sample.a = 1;
sc1.SetB();
Sample.a = 2;
sc2.SetB();
Console.WriteLine("sc1.b = {0}, sc2.b = {1}", sc1.b, sc2.b);
Последним моментом, касающимся статических методов, является правило, определяющее, к каким членам класса можно обращаться из статического метода. Как вы можно догадаться, статический метод может обращаться к любому статическому члену в пределах класса, но не может обращаться к члену экземпляра.
То мы можем получить к ним доступ напрямую через имя класса и оператор разрешения области видимости. Но что, если статические переменные-члены являются закрытыми? Рассмотрим следующий код:
В этом случае мы не можем напрямую получить доступ к Anything::s_value из main(), так как этот член является private. Обычно доступ к закрытым членам класса осуществляется через методы public. Хотя мы могли бы создать обычный метод для получения доступа к s_value, но нам тогда бы пришлось создавать объект этого класса для использования метода! Есть вариант получше – мы можем сделать метод статическим.
Подобно статическим переменным-членам, статические методы не привязаны к какому-либо одному объекту класса. Вот пример выше, но уже со статическим методом:
class Anything { private: static int s_value; public: static int getValue() { return s_value; } // статический метод }; int Anything::s_value = 3; // определение статической переменной-члена класса int main() { std::cout << Anything::getValue() << "\n"; }
Поскольку статические методы не привязаны к определенному объекту, то их можно вызывать напрямую через имя класса и оператор разрешения области видимости, их также можно вызвать и через объекты класса (но это не рекомендуется).
Статические методы не имеют указателя this *
У статических методов есть две интересные особенности. Во-первых, поскольку статические методы не привязаны к объекту, то они не имеют ! Здесь есть смысл, так как указатель this всегда указывает на объект, с которым работает метод. Статические методы могут не работать через объект, поэтому и указатель this не нужен.
Во-вторых, статические методы могут напрямую обращаться к другим статическим членам (переменным или функциям), но не могут к нестатическим членам. Это связано с тем, что нестатические члены принадлежат объекту класса, а статические методы — нет!
Еще пример
Статические методы можно определять вне тела класса. Это работает так же, как и с обычными методами. Например:
class IDGenerator { private: static int s_nextID; // объявление статической переменной-члена public: static int getNextID(); // объявление статического метода }; // Определение статической переменной-члена находится вне тела класса. Обратите внимание, мы не используем здесь ключевое слово static // Начинаем генерировать ID с 1 int IDGenerator::s_nextID = 1; // Определение статического метода находится вне тела класса. Обратите внимание, мы не используем здесь ключевое слово static int IDGenerator::getNextID() { return s_nextID++; } int main() { for (int count=0; count < 4; ++count) std::cout << "The next ID is: " << IDGenerator::getNextID() << "\n"; return 0; }
class IDGenerator private : static int s_nextID ; // объявление статической переменной-члена public : static int getNextID () ; // объявление статического метода // Начинаем генерировать ID с 1 int IDGenerator :: s_nextID = 1 ; int IDGenerator :: getNextID () { return s_nextID ++ ; } int main () for (int count = 0 ; count < 4 ; ++ count ) std :: cout << "The next ID is: " << IDGenerator :: getNextID () << "\n" ; return 0 ; |
Результат:
The next ID is: 1
The next ID is: 2
The next ID is: 3
The next ID is: 4
Обратите внимание, поскольку все переменные и функции этого класса являются статическими, то нам не нужно создавать объект этого класса для работы с ним! Статическая переменная-член используется для хранения значения следующего идентификатора, который должен быть ей присвоен, а статический метод — для возврата идентификатора и его увеличения.
Предупреждение о классах со всеми статическими членами
Будьте осторожны при написании классов со всеми статическими членами. Хотя такие «чисто статические классы» могут быть полезны, но они также имеют свои недостатки.
Во-первых, поскольку все статические члены создаются только один раз, то несколько копий «чисто статического класса» быть не может (без клонирования класса и его дальнейшего переименования). Например, если нам нужны два независимых объекта IDGenerator, то это будет невозможно через «чисто статический» класс.
Во-вторых, из урока о мы знаем, что глобальные переменные опасны, поскольку любая часть кода может изменить их значения и в конечном итоге изменит другие фрагменты, казалось бы, не связанного кода (детальнее ). То же самое справедливо и для «чисто статических» классов. Поскольку все члены принадлежат классу (а не его объектам), а классы имеют глобальную область видимости, то в «чисто статическом классе» мы объявляем глобальные функции и переменные со всеми минусами, которые они имеют.
C++ не поддерживает статические конструкторы
Если вы можете инициализировать обычную переменную-член через , то по логике вещей вы должны иметь возможность инициализировать статические переменные-члены через статический конструктор. И хотя некоторые современные языки действительно поддерживают статические конструкторы именно для этой цели, C++, к сожалению, не является одним из них.
Если ваша статическая переменная может быть инициализирована напрямую, то конструктор не нужен: вы можете определить статическую переменную-член, даже если она является private. Мы делаем это в примере выше с s_nextID. Вот еще один пример:
class Something
{
public:
static std::vector
class Something public : static std :: vector < char > s_mychars ; std :: vector < char > Something :: s_mychars = { "o" , "a" , "u" , "i" , "e" } ; // определяем статическую переменную-член |
Если для инициализации вашей статической переменной-члена требуется выполнить код (например, цикл), то есть несколько разных способов это сделать. Следующий способ является лучшим из них. Хотя это может быть немного сложно (сейчас), и, вероятно, вам это никогда не понадобится, то вы можете спокойно пропустить оставшуюся часть этого урока, если хотите.
#include
#include #include class Something private : static std :: vector < char > s_mychars ; public : class _nested // определяем вложенный класс с именем _nested public : Nested () // конструктор _nested инициализирует нашу статическую переменную-член s_mychars . push_back ("o" ) ; s_mychars . push_back ("a" ) ; s_mychars . push_back ("u" ) ; s_mychars . push_back ("i" ) ; s_mychars . push_back ("e" ) ;  Загрузка...Возможно вам будет интересно:
Последние статьи
|
