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. Статические методы не принимают параметр 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);
21 ответ
Одно правило большого пальца: спросите себя: "Имеет ли смысл называть этот метод, даже если Obj еще не построен?" Если это так, это определенно будет статичным.
Итак, в классе Car у вас может быть метод double convertMpgToKpl(double mpg) , который был бы статичным, потому что можно было бы узнать, к чему преобразуется 35mpg, даже если никто никогда не строил автомобиль. Но void setMileage(double mpg) (который устанавливает эффективность одного конкретного автомобиля) не может быть статическим, так как немыслимо вызвать метод до того, как был построен любой автомобиль.
(Btw, обратное не всегда верно: иногда вы можете иметь метод, который включает в себя два объекта Car и все еще хочет, чтобы он был статическим. Например Car theMoreEfficientOf(Car c1, Car c2) . Хотя это можно было бы преобразовать в не- статическая версия, некоторые утверждают, что, поскольку нет "привилегированного" выбора того, какой автомобиль более важен, вы не должны принуждать вызывающего выбрать один автомобиль как объект, на который вы будете ссылаться. довольно небольшая часть всех статических методов.)
Определите статические методы только в следующих сценариях:
Есть несколько веских причин использовать статические методы:
Производительность : если вы хотите, чтобы какой-то код запускался, и вы не хотите создавать экземпляр дополнительного объекта для этого, вставьте его в статический метод. JVM также может много оптимизировать статические методы (я думаю, что однажды я прочитал Джеймса Гослинга, заявив, что вам не нужны специальные инструкции в JVM, поскольку статические методы будут такими же быстрыми, но не могут найти источник - таким образом это может быть полностью ложным). Да, это микро-оптимизация и, вероятно, ненужная. И мы, программисты, никогда не делаем ненужных вещей только потому, что они классные, не так ли?
Практичность : вместо вызова new Util().method(arg) вызовите Util.method(arg) или method(arg) со статическим импортом. Легче, короче.
Добавление методов : вы действительно хотели, чтобы класс String имел метод экземпляра removeSpecialChars() , но он не существует (и он не должен, так как ваши специальные символы проекта могут быть разными из другого проекта), и вы не можете его добавить (поскольку Java является довольно нормальным), поэтому вы создаете класс утилиты и вызываете removeSpecialChars(s) вместо s.removeSpecialChars() . Сладкое.
Purity : принимая некоторые меры предосторожности, ваш статический метод будет чистой функцией , Единственное, от чего это зависит, это его параметры. Данные, данные. Это легче читать и отлаживать, так как у вас нет наследования для наследования, о которых нужно беспокоиться. Вы можете сделать это также с помощью методов экземпляра, но компилятор поможет вам немного больше со статическими методами (не позволяя ссылаться на атрибуты экземпляра, переопределять методы и т.д.).
Вам также понадобится создать статический метод, если вы хотите создать синглтон, но... не делайте этого. Я имею в виду, подумайте дважды.
Теперь, что еще более важно, почему вы не хотите создавать статический метод? В принципе, полиморфизм выходит из окна . Вы не сможете переопределить метод, и не объявить его в интерфейсе (pre-Java 8). Это требует большой гибкости от вашего дизайна. Кроме того, если вам нужно состояние , вы получите множество concurrency ошибок и/или узких мест, если вы не будете осторожны.
После чтения статей Misko я считаю, что статические методы являются плохими с точки зрения тестирования. Вместо этого вы должны иметь (возможно, используя инструмент инжекционного вложения, например Guice).
как я могу убедиться, что у меня есть только что-то из
есть только один из Проблема "как я могу обеспечить, чтобы я есть только одно из" красиво" уклонился. Вы создаете экземпляр только единый ApplicationFactory в вашем основной, и, как результат, вы только создать экземпляр всего экземпляра ваших синглетов.
Основная проблема со статическими методами - это процедурный код
Основная проблема со статическими методами: они являются процедурным кодом. У меня нет Идея процедуры модульного тестирования. Модульное тестирование предполагает, что я могу создать экземпляр части моего приложения в изоляции. Во время создания Я подключаю зависимости с помощью mocks/friendlies, которые заменяют реальных зависимостей. С процедурной программирование нечего "прокладывать", поскольку объектов нет, код и данные разделены.
A static метод - это один тип метода, который не требует инициализации объекта для его вызова. Вы заметили, что static используется в функции main в Java? Выполнение программы начинается оттуда без создания объекта.
Рассмотрим следующий пример:
Class Languages { public static void main(String args) { display(); } static void display() { System.out.println("Java is my favorite programming language."); } }
Статические методы в java относятся к классу (а не к экземпляру). Они не используют переменные экземпляра и обычно принимают входные данные из параметров, выполняют действия над ним, а затем возвращают некоторый результат. Методы экземпляров связаны с объектами и, как следует из названия, могут использовать переменные экземпляра.
Если вы применяете статическое ключевое слово с любым методом, он известен как статический метод.
- Статический метод относится к классу, а не к объекту класса.
- Статический метод, вызываемый без необходимости создания экземпляра класса.
- статический метод может получить доступ к статическому элементу данных и может изменить его значение.
//Программа изменения общего свойства всех объектов (статическое поле).
Class Student9{ int rollno; String name; static String college = "ITS"; static void change(){ college = "BBDIT"; } Student9(int r, String n){ rollno = r; name = n; } void display (){System.out.println(rollno+" "+name+" "+college);} public static void main(String args){ Student9.change(); Student9 s1 = new Student9 (111,"Indian"); Student9 s2 = new Student9 (222,"American"); Student9 s3 = new Student9 (333,"China"); s1.display(); s2.display(); s3.display(); } }
O/P: 111 Индийский BBDIT 222 Американский BBDIT 333 Китай BBDIT
Статические методы не связаны с экземпляром, поэтому они не могут получить доступ к нестатическим полям в классе.
Вы использовали бы статический метод, если метод не использует никаких полей (или только статических полей) класса.
Если используются нестатические поля класса, вы должны использовать нестатический метод.
На самом деле, мы используем статические свойства и методы в классе, когда мы хотим использовать часть нашей программы, должна существовать там до тех пор, пока наша программа не будет запущена. И мы знаем, что для управления статическими свойствами нам нужны статические методы, поскольку они не являются частью переменной экземпляра. И без статических методов управлять статическими свойствами занимает много времени.
Статические методы и переменные - это управляемая версия функций и переменных "Глобальная" в Java. К каким методам можно обращаться как classname.methodName() или classInstanceName.methodName() , то есть к статическим методам и переменным можно получить доступ с использованием имени класса, а также экземпляров класса.
Класс не может быть объявлен как статический (поскольку это не имеет смысла. Если класс объявлен общедоступным, к нему можно получить доступ из любого места), внутренние классы могут быть объявлены статическими.
Статические методы могут использоваться, если
Не нужно выполнять действие над экземпляром (методы утилиты)
1. new ABCClass(double farenheit).convertFarenheitToCelcium() 2. ABCClass.convertFarenheitToCelcium(double farenheit)Как упоминалось в нескольких из приведенных выше ответов в этом сообщении, преобразование миль в километры или вычисление температуры от Фаренгейта до Цельсия и наоборот. В этих примерах с использованием статического метода ему не нужно создавать экземпляр целого нового объекта в кучевой памяти. Рассмотрим ниже
Math.random() Math.sqrt(double) Math.min(int, int) StringUtils.isEmpty(String) StringUtils.isBlank(String)первый создает новый класс для каждого метода, Производительность, Практический . Примерами являются класс Math и Apache-Commons StringUtils ниже:
Один хочет использовать как простую функцию. Входы явно передаются и получают данные результата в качестве возвращаемого значения. Наследование, объектная инсталляция не возникает. Краткая, читаемая .
Примечание : Немногие люди возражают против тестирования статических методов, но статические методы также могут быть проверены! С помощью jMockit можно издеваться над статическими методами. Тестируемость . Пример ниже:
New MockUp
() { @Mock public int doSomething(Input input1, Input input2){ return returnValue; } }; Мне интересно, когда использовать статические методы?
- Общепринятым способом использования методов static является доступ к полям static .
Но вы можете иметь методы static , не ссылаясь на переменные static . Вспомогательные методы без ссылки static variable могут быть найдены в некоторых классах Java, таких как
Public static int min(int a, int b) { return (a <= b) ? a: b; }
В другом случае я могу думать об этих методах в сочетании с методом synchronized - это реализация блокировки уровня класса в многопоточной среде.
Скажем, если у меня есть класс с несколькими геттерами и сеттерами, метод или два, и я хочу, чтобы эти методы были только invokable для объекта экземпляра класса. Означает ли это, что я должен использовать статический метод?
Модификатор static (статичный) применяется переменным, методам и даже к странным фрагментам кода, которые не являются частью метода. Статичные фрагменты кода принадлежат не объекту класса, но ко всему классу.
Рассмотрим пример простого класса с одной статичной переменной:
1. class Ecstatic{ Переменная x
объявлена статичной. Это означает, что не важно, сколько объектов класса Ecstatic
существует в данный момент - x
всего лишь одна. При загрузке класса Ecstatic
выделяется 4 байта под переменную x
. И её инициализация происходит (см. строку №2) тоже в момент загрузки класса. И каждый раз, когда создаётся объект класса Ecstatic
, x
инкрементируется. Этот приём позволяет знать точное количество созданных объектов класса Ecstatic
. Получить доступ к статичным переменным можно двумя способами: Первый метод, однако, считается дурным тоном, так как очень сильно вводит в заблуждение. Давайте рассмотрим это на примере: Если вы заранее не знаете, что x
- статичная переменная, то можете подумать, что в 5-й строке переменной reallyImportantVariable
присваивается 100. Но на самом деле ей присваивается 200, потому что e1.x
и e2.x
- это всё одна и та же переменная х
. Поэтому лучше доступаться к статичным переменным через имя класса. Вот фрагмент кода, эквивалентный предыдущему: 1. Ecstatic e1 = new Ecstatic(); Теперь всё встаёт на свои места: строка 3 не несёт никакого смысла - это всего лишь лишняя операция, а в 5-й строке переменной reallyImportantVariable
присваивается сразу 200. Статичные методы не могут использовать нестатичные элементы (переменные и методы) своиего класса, но могут использовать другие статичные элементы. Статичные методы не принадлежат ни одному объекту класса. Поэтому они могут вообще вызваться до того, как класс инстанциирован. Каждое Java приложение содержит в себе статичный метод main()
: 1. class SomeClass { Когда приложение запускается (то есть кто-то вызывает из коммандной строки java SomeClass
), не существует ни одного объекта класса SomeClass
. Однако существует переменная i
, которая инициализурется во 2-й строке и инкрементируется в 6-й строке. А если бы мы раскомметировали 7-ю строку, то вообще получили бы ошибку компиляции, потому что статичный метод не может использовать нестатичные переменные класса.
2. static int x = 0;
3. Ecstatic() { x++; }
4. }
3. e1.x = 100;
4. e2.x = 200;
5. reallyImportantVariable = e1.x;
2. Ecstatic e2 = new Ecstatic();
3. Ecstatic.x = 100; // Бессмысленное действие
4. Ecstatic.x = 200;
5. reallyImportantVariable = Ecstatic.x;
2. static int i = 48;
3. int j = 1;
4.
5. public static void main(String args) {
6. i += 100;
7. // j *= 5; Если раскомментировать, будет ошибка
8. }
9. }
Статика - это глобальное состояние. Статический метод или статическая переменная абсолютно ничем не отличаются от глобальной переменной, потому что, ни статика ни глобальная переменная не были переданны в качестве аргументов нигде и никак, а значит поступают из глобального пространства.
Чем статика может быть опасна?
Представь, что ты пишешь утилиту для загрузки изображений. И вот наступил момент, когда нужно указывать параметры обрезки для превьюшек. Со статикой это может выглядеть так:
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
Там почти везде
все зависимости передаются в качестве аргументов, что есть хорошо, слабо связано, и тестируемо.
