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

Последнее обновление: 25.12.2018

Кроме обычных полей, методов, свойств класс может иметь статические поля, методы, свойства. Статические поля, методы, свойства относятся ко всему классу и для обращения к подобным членам класса необязательно создавать экземпляр класса. Например:

Class Account { public static decimal bonus = 100; public decimal totalSum; public Account(decimal sum) { totalSum = sum + bonus; } } class Program { static void Main(string args) { Console.WriteLine(Account.bonus); // 100 Account.bonus += 200; Account account1 = new Account(150); Console.WriteLine(account1.totalSum); // 450 Account account2 = new Account(1000); Console.WriteLine(account2.totalSum); // 1300 Console.ReadKey(); } }

В данном случае класс Account имеет два поля: bonus и totalSum. Поле bonus является статическим, поэтому оно хранит состояние класса в целом, а не отдельного объекта. И поэтому мы можем обращаться к этому полю по имени класса:

Console.WriteLine(Account.bonus); Account.bonus += 200;

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

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

Статические свойства и методы

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

Class Account { public Account(decimal sum, decimal rate) { if (sum < MinSum) throw new Exception("Недопустимая сумма!"); Sum = sum; Rate = rate; } private static decimal minSum = 100; // минимальная допустимая сумма для всех счетов public static decimal MinSum { get { return minSum; } set { if(value>0) minSum = value; } } public decimal Sum { get; private set; } // сумма на счете public decimal Rate { get; private set; } // процентная ставка // подсчет суммы на счете через определенный период по определенной ставке public static decimal GetSum(decimal sum, decimal rate, int period) { decimal result = sum; for (int i = 1; i <= period; i++) result = result + result * rate / 100; return result; } }

Переменная minSum, свойство MinSum, а также метод GetSum здесь определены с ключевым словом static , то есть они являются статическими.

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

То же самое с методом GetSum - он вычисляет сумму на счете через определенный период по определенной процентной ставке для определенной начальной суммы. Вызов и результат этого метода не зависит от конкретного объекта или его состояния.

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

Статические члены класса являются общими для всех объектов этого класса, поэтому к ним надо обращаться по имени класса:

Следует учитывать, что статические методы могут обращаться только статическим членам класса. Обращаться к нестатическим методам, полям, свойствам внутри статического метода мы не можем.

Нередко статические поля применяются для хранения счетчиков. Например, пусть у нас есть класс User, и мы хотим иметь счетчик, который позволял бы узнать, сколько объектов User создано:

Class User { private static int counter = 0; public User() { counter++; } public static void DisplayCounter() { Console.WriteLine($"Создано {counter} объектов User"); } } class Program { static void Main(string args) { User user1 = new User(); User user2 = new User(); User user3 = new User(); User user4 = new User(); User user5 = new User(); User.DisplayCounter(); // 5 Console.ReadKey(); } }

Статический конструктор

Кроме обычных конструкторов у класса также могут быть статические конструкторы. Статические конструкторы имеют следующие отличительные черты:

Статические конструкторы не должны иметь модификатор доступа и не принимают параметров

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

Статические конструкторы нельзя вызвать в программе вручную. Они выполняются автоматически при самом первом создании объекта данного класса или при первом обращении к его статическим членам (если таковые имеются)

Статические конструкторы обычно используются для инициализации статических данных, либо же выполняют действия, которые требуется выполнить только один раз

Определим статический конструктор:

Class User { static User() { Console.WriteLine("Создан первый пользователь"); } } class Program { static void Main(string args) { User user1 = new User(); // здесь сработает статический конструктор User user2 = new User(); Console.Read(); } }

Статические классы

Статические классы объявляются с модификатором static и могут содержать только статические поля, свойства и методы. Например, если бы класс Account имел бы только статические переменные, свойства и методы, то его можно было бы объявить как статический:

Static class Account { private static decimal minSum = 100; // минимальная допустимая сумма для всех счетов public static decimal MinSum { get { return minSum; } set { if(value>0) minSum = value; } } // подсчет суммы на счете через определенный период по определенной ставке public static decimal GetSum(decimal sum, decimal rate, int period) { decimal result = sum; for (int i = 1; i <= period; i++) result = result + result * rate / 100; return result; } }

В C# показательным примером статического класса является класс Math, который применяется для различных математических операций.

Модификатор 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.

В этом разделе мы рассмотрим основные моменты использования статических методов, полей и классов. Начнём с переменных.

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

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

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

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

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

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

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

Что такое 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);
}
}

Вывод этой программы выглядит следующим образом.

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

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

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

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

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

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

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

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

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

Метод::=

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

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

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

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

<Операторы>

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

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

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

::= public

::= private

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

::= <Тип>

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

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

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

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

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

public static void Average(…)

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

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

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

myClass A = new myClass();

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

MyClass.Average(. ..)...

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

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 для объекта экземпляра класса. Означает ли это, что я должен использовать статический метод?