Java статические методы и переменные. Статические методы не имеют указателя this

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 и Apache-Commons StringUtils ниже:

Math.random() Math.sqrt(double) Math.min(int, int) StringUtils.isEmpty(String) StringUtils.isBlank(String)

• Один хочет использовать как простую функцию. Входы явно передаются и получают данные результата в качестве возвращаемого значения. Наследование, объектная инсталляция не возникает. Краткая, читаемая .

Примечание : Немногие люди возражают против тестирования статических методов, но статические методы также могут быть проверены! С помощью 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 в 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.

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

public class Counter { private int count; public static void main (String args ) { System. out. println (count) ; //compile time error } }

Это одна из наиболее распространённых ошибок допускаемых программистами 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). Это означает, что при обращении к статическому методу, который объявлен как в родительском, так и в дочернем классе, во время компиляции всегда будет вызван метод исходя из типа переменной. В отличие от переопределения, такие методы не будут выполнены во время работы программы. Рассмотрим пример:

class Vehicle { public static void kmToMiles (int km) { System. out. println ("Внутри родительского класса/статического метода" ) ; } } class Car extends Vehicle { public static void kmToMiles (int km) { System. out. println ("Внутри дочернего класса/статического метода " ) ; } } public class Demo { public static void main (String args ) { Vehicle v = new Car () ; v. kmToMiles (10 ) ; } }

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

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

Код наглядно демонстрирует: несмотря на то, что объект имеет тип 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. Я надеюсь, что каждый разработчик доведёт свои навыки использования статических концептов до совершенства, т.к. это очень важно для серьёзного программирования."

То мы можем получить к ним доступ напрямую через имя класса и оператор разрешения области видимости. Но что, если статические переменные-члены являются закрытыми? Рассмотрим следующий код:

В этом случае мы не можем напрямую получить доступ к 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; }

Результат:

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 s_mychars; }; std::vector Something::s_mychars = { "o", "a", "u", "i", "e" }; // определяем статическую переменную-член

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

#include #include class Something { private: static std::vector 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"); } }; // статический метод для вывода s_mychars static void getSomething() { for (auto const &element: s_mychars) std::cout << element << " "; } private: static _nested s_initializer; // используем статический объект класса _nested для гарантии того, что конструктор _nested выполнится }; std::vector Something::s_mychars; // определяем нашу статическую переменную-член Something::_nested Something::s_initializer; // определяем наш статический s_initializer, который вызовет конструктор _nested для инициализации s_mychars int main() { Something::getSomething(); return 0; }

#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" ) ; Модификатора 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); Последним моментом, касающимся статических методов, является правило, определяющее, к каким членам класса можно обращаться из статического метода. Как вы можно догадаться, статический метод может обращаться к любому статическому члену в пределах класса, но не может обращаться к члену экземпляра. Рекомендуем почитать Использование эквалайзера Windows Сегодня мы рассмотрим: Настоящие ценители музыки знают, что для качественного... Скачать примеры Excel с формулами и функциями Файлы *.xlsx с примерами вычислений формул и функций. А так же бесплатные... Использование эквалайзера Windows В операционных системах Windows, начиная с Vista, используется встроенный... Наверх Детские товары Авто Электроника Инструмент Бытовая техника Детские товары × Поиск по сайту