Что такое 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. Статические методы не принимают параметр this. На использование статических методов накладывается ряд ограничений.
Статические методы могут непосредственно обращаться только к статическим членам класса.
Статический метод не может быть объявлен как виртуальный метод.
Вы не можете определить нестатический метод с тем же именем и тем же набором параметров, что и статический метод класса.
Статические методы имеют одну интересную особенность - вы можете вызывать их даже без создания объектов класса. Чтобы вызвать из программы статический метод, вы должны указать его полное имя, включая имя класса.
Ниже представлен класс Circle, в котором определена статический метод GetPi. Он используется для получения значения статического элемента класса fPi.
static void GetPi()
static float fPi;
float Circle::fPi = 3.1415;
Вы можете вызвать метод GetPi следующим образом:
fNumber = Circle::GetPi();
Обратите внимание, что объект класса Circle не создается.
Общие члены объектов класса
Иногда удобно, чтобы все объекты данного класса имели общие элементы данных, которые используются совместно. За счет этого можно существенно сократить количество глобальных переменных, улучшая структуру программы.
Общие элементы данных класса следует объявить с ключевым словом static. Все общие элементы класса надо определить в тексте программы, зарезервировав за ними место в оперативной памяти:
{ public: int xLeftTop, xRightBottom; int yLeftTop, yRightBottom; static char title; void SetTitle(char*); };char Cwindow::title = “заголовок окна”;
Каждый объект класса Cwindow будет иметь уникальные координаты, определяемые элементами данных xLeftTop, xRightBottom, yLeftTop, yRightBottom и одинаковый заголовок, хранимый элементом данных title.
Общие элементы данных находятся в области действия своего класса. Методы класса могут обращаться к общим элементам точно так же, как к остальным данным из класса:
void SetTitle(char* sSource)
{ strcpy(title, sSource); }
Чтобы получить доступ к общим элементам из программы, надо объявить их как public. Для обращения к такой переменной перед ее именем надо указать имя класса и оператор::.
printf(Cwindow::title);
Дружественные функции и дружественные классы
Доступ к элементам класса из программы и других классов ограничен. Вы можете непосредственно обращаться только к элементам класса, определенным или описанным после ключевого слова public. Однако, в некоторых случаях, требуется определить функцию вне класса или другой класс, методы которого могут обращаться непосредственно ко всем элементам класса, включая элементы объявленные как private и protect.
Дружественные функции
В Си++ вы можете определить для класса так называемую дружественную функцию, воспользовавшись ключевым словом friend. В классе содержится только объявление дружественной функции. Ее определение расположено вне класса. Вы можете объявить дружественную функцию в любой секции класса -public, private или protect.
Дружественная функция не является элементом класса, но может обращаться ко всем его элементам, включая private и protect. Одна и та же функция может быть дружественной для двух или более классов.
В следующем примере определена функция Clear, дружественная для классаpoint. Дружественная функция Clearиспользуется для изменения значения элементов данныхm_xиm_y, объявленных как private:
// Класс point
// Функция Clear объявляется дружественной классу point
friend void point::Clear(point*);
// Интерфейс класса...
//==========================================================
// Функция Clear
void Clear(point* ptrPoint)
// Обращаемся к элементам класса, объявленным как private
ptrPoint->m_x = 0;
ptrPoint->m_y = 0;
//==========================================================
// Главная функция
point pointTestPoint;
// Вызываем дружественную функцию
Clear(&pointTestPoint);
С помощью ключевого слова friend вы можете объявить некоторые методы одного класса дружественными для другого класса. Такие методы могут обращаться ко всем элементам класса, даже объявленным как private и protect, несмотря на то, что сами они входят в другой класс.
В следующем примере мы определяем два класса - line и point. В классе point определяем метод Set и объявляем его в классе line как дружественный. Дружественный метод Set может обращаться ко всем элементам класса line:
// Предварительное объявление класса line
//==========================================================
// Класс point
// Метод Set класса point
void Set(line*);
//==========================================================
// Класс line
// Метод Set класса point объявляется дружественной
// классу point
friend void point::Set(line*);
int begin_x, begin_y;
int end_x, end_y;
//==========================================================
// Функция Clear
void point::Set(line* ptrLine)
// Обращаемся к элементам класса line, объявленным как
ptrLine->begin_x = 0;
ptrLine->begin_y = 0;
//==========================================================
// Главная функция
point pointTestPoint;
line lineTestPoint;
// Вызываем дружественный метод
pointTestPoint.Set(&lineTestPoint);
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
Переменное число параметров метода
Иногда число аргументов, которые будут переданы методу, неизвестно до периода выполнения. Например, вам нужен класс, который чертит на графике линию, заданную последовательностями х- и у-координат. Этот класс должен содержать методом, принимающим единственный аргумент - объект типа 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);
Последним моментом, касающимся статических методов, является правило, определяющее, к каким членам класса можно обращаться из статического метода. Как вы можно догадаться, статический метод может обращаться к любому статическому члену в пределах класса, но не может обращаться к члену экземпляра.
