Статические классы, методы, переменные. Статические конструкторы. Ключевое слово static. Статические методы

1. Какие элементы языка программирования C# можно объявлять статическими?

В языке программирования C# статическими могут быть:

• классы;
• методы;
• переменные.

Чтобы класс (метод, переменная) был статическим, перед его объявлением ставится ключевое слово static .

2. Понятие статического класса. Какие особенности использования статических классов в программах на C#? Ключевое слово static

С точки зрения синтаксиса C# статический класс – это класс, который объявляется с ключевым словом static.

Общая форма объявления статического класса:

static class ClassName { // поля и методы класса // ... }

где ClassName – имя статического класса.

3. Свойства статического класса

Реализация программного кода статического класса ничем не отличается от программного кода обычного класса за исключением двух основных свойств. В сравнении с нестатическим классом, статический класс имеет следующие свойства (отличия):

• нельзя создавать объекты статического класса;
• статический класс должен содержать только статические члены.

4. Примеры, которые демонстрируют свойства статического класса

Пример 1. Пусть задан статический класс MyStaticClass . В этом классе объявляется один статический член с именем d .

// статический класс static class MyStaticClass { public static int d = 0; }

Если попробовать создать объект статического класса

// попытка создать объект статического класса MyStaticClass ms; // ошибка - нельзя создавать объект статического класса

то возникнет ошибка компиляции с сообщением:

Cannot declare a variable of static type

что означает:

Невозможно объявить переменную статического типа

Пример 2. Данный пример демонстрирует правило, что статический класс должен содержать только статические члены. Пусть задан статический класс MyStaticClass . Если в статическом классе MyStaticClass попробовать объявить нестатический член d целого типа

// статический класс static class MyStaticClass { // нестатический член, без ключевого слова static public int d = 0; // ошибка - нельзя объявлять нестатический экземпляр в статическом классе }

то во время компиляции компилятор выдаст следующую ошибку:

Cannot declare instance members in a static class

что значит

Нельзя объявлять члены-экземпляры в статическом классе

5. Примеры статических классов

Пример 1 . В данном примере демонстрируется использование статической переменной в статическом классе. Объявляется статический класс с именем Count , в котором помещается одна статическая переменная count . Эта статическая переменная есть счетчиком, который совместно используется в нестатических методах Add1() , Add2() другого класса Methods .

Программный код классов Count и Methods следующий:

// статический класс Count static class Count { public static int count; } // нестатический класс class Methods { // методы нестатического класса имеют доступ // к статической переменной count статического класса Count public void Add1() // нестатический метод { // изменение значения статической переменной Count .count++; } public static void Add2() // статический метод { Count .count = Count .count + 2; } }

В нижеследующем коде продемонстрированы обращения к переменной count класса Count и изменение значения этой переменной из методов Add1() , Add2() .

Methods M = new Methods (); // создать объект класса Methods // проверить значения статического члена int n = Count .count; // n = 0 // вызвать нестатический метод Add1() класса Methods M.Add1(); // увеличение Count.count на 1 n = Count .count; // n = 1

Как видно из примера, статический член данных Count.count есть общим для методов Add1() , Add2() класса Methods . Если бы в программе были реализованы другие классы с некоторыми методами, то к этому члену данных можно было бы обращаться из этих методов.

Если в данном примере класс Count объявить как нестатический (без ключевого слова static )

// класс Count - нестатический class Count { // статическая переменная count в классе Count - общий ресурс public static int count; } ...

то результат работы программы не изменится. Статическую переменную Count.count можно использовать как общий ресурс.

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

В примере объявляется статический метод AbsComplex() , находящий модуль комплексного числа. Метод объявляется в классе ComplexLibrary . Также объявляются 2 класса, которые содержат методы, использующие метод AbsComplex() в своих вычислениях.

// нестатический класс, содержащий статический метод class ComplexLibrary { // статический метод, вычисляет модуль комплексного числа // получает значение действительной (а) и мнимой (b) части комплексного числа public static double AbsComplex(double a, double b) { return Math .Sqrt(a * a + b * b); } } // класс, который содержит нестатический метод, использующий статический метод AbsComplex class CalcComplex1 { // нестатический метод // определяет, равны ли модули 2 комплексных чисел // данный метод использует статический метод ComplexLibrary.AbsComplex() для вычислений public bool EqualComplex(double a1, double b1, double a2, double b2) { double value1, value2; // использование статического метода AbsComplex() value1 = ComplexLibrary .AbsComplex(a1, b1); value2 = ComplexLibrary .AbsComplex(a2, b2); return value1 == value2; } } // еще один класс, который использует метод AbsComplex() из класса ComplexLibrary class CalcComplex2 { // метод, который определяет, равна ли длина комплексного числа значению 0 public bool ZeroComplex(double a, double b) { double value = ComplexLibrary .AbsComplex(a, b); return value == 0.0; } }

Использование методов классов CalcComplex1 , CalcComplex2 может быть следующим:

CalcComplex1 c1 = new CalcComplex1 (); // создать экземпляр (объект) класса CalcComplex2 c2 = new CalcComplex2 (); bool f; f = c1.EqualComplex(3, 4, 2, 5); // f = False f = c1.EqualComplex(1, 2, 2, 1); // f = True f = c1.EqualComplex(-1, 2, -2, 1); // f = True f = c2.ZeroComplex(0, 0); // f = True f = c2.ZeroComplex(1, -5); // f = False

6. Какие преимущества применения статических классов, методов и переменных в программах на C#?

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

• если нужно создать так называемые методы расширения. Методы расширения используются для расширения функций класса. Эти методы являются статическими;
• если в программе есть некоторый общий ресурс, к которому могут иметь обращение методы разных классов что обрабатывают данный ресурс (читают или изменяют его значение). Этот общий ресурс объявляется как статическая переменная. Например, таким ресурсом может быть некоторый счетчик вызовов, метод что реализует уникальную обработку, уникальная файловая переменная (ресурс) и т.п.;
• статические классы являются эффективными, когда нужно объединить между собой группы статических методов;
• если нужно использовать общие скрытые (private ) данные класса и организовывать доступ к этим данным из статических и нестатических методов.

7. Чем отличается вызов статического метода от нестатического?

В любом нестатическом классе могут быть объявлены как статические методы, так и нестатические. Отличие между вызовом статического и нестатического метода класса состоит в следующем:

• чтобы вызвать нестатический метод класса, нужно создать экземпляр (объект) этого класса. Статический метод вызывается без создания объекта класса – перед именем метода указывается имя класса, в котором этот статический метод объявлен.

Например. Задан нестатический класс Sqr , содержащий следующие два метода, которые возвращают квадрат целочисленного значения:

• GetSqr() – нестатический метод;
• GetSqrStatic() – статический метод.

class Sqr { // нестатический метод public int GetSqr(int x) { return x * x; } // статический метод public static int GetSqrStatic(int x) { return x * x; } }

Ниже демонстрируется вызов и использование этих методов:

// Демонстрация вызова статического и нестатического методов класса int t; // 1. Вызов нестатического метода класса Sqr // Нужно создать объект класса Sqr sc = new Sqr(); t = sc.GetSqr(7); // t = 49 // 2. Вызов статического метода класса Sqr t = Sqr .GetSqrStatic(7); // t = 49

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

8. Можно ли объявить скрытый (private ) статический член в некотором классе?

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

9. Можно ли объявлять статический член класса с модификатором доступа protected ?

Да можно. В этом случае, доступ к статического члену класса будут иметь методы класса, которые унаследованы от данного класса.

Например. Задан класс A , содержащий один статический член a , который объявлен как protected . Также задан класс B , который наследует (расширяет) класс A . Из метода SomeMethod() класса B осуществляется доступ к protected -переменной класса A .

// нестатический класс, который содержит нестатический и статический методы class A { protected static int a; } // класс B наследует (расширяет) класс A class B : A { void SomeMethod() { a = 10; // доступ к protected-переменной класса A } }

10. Может ли нестатический класс содержать статические переменные и статические методы?

Да может. Примеры использования статических методов в нестатическом классе приведены в пунктах 5 и 7.

11. Можно ли объединять статические и нестатические методы в одном классе?

Да, можно. Но только в нестатическом классе. Если класс объявлен как статический, то все методы и переменные класса должны быть также статическими (см. п. 4 — Пример 2).

Например. Пример демонстрирует объединение статического и нестатического методов класса для доступа к скрытой статической переменной t в классе. Объявляется нестатический класс CMyClass , содержащий статическую переменную, статический и нестатический методы доступа к ней.

// нестатический класс class CMyClass { // статическая переменная, объявленная как private private static int t; // статический метод, который изменяет значение статической переменной t public static void Set(int _t) { t = _t; } // нестатический метод, который читает значение статической переменной t public int Get() { return t; } }

В нижеследующем коде продемонстрирован доступ к скрытой статической переменной t класса CMyClass

// демонстрация объединения статических и нестатических членов класса int x; // 1. Доступ к скрытой (private) статической переменной через статический метод Set CMyClass .Set(777); // статическая переменная t = 777 // 2. Прочитать значение скрытой (private) статической переменной t // 2.1. Создать объект класса CMyClass mc = new CMyClass (); // 2.2. Вызвать нестатический метод Get() через экземпляр класса x = mc.Get(); // x = 777 - текущее значение статической переменной

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

12. Можно ли в статическом методе статического класса создать объект нестатического класса?

Да, можно. Классический пример этому, функция Main() для консольных приложений. Эта функция объявлена как static . Однако, создавать экземпляры любых нестатических классов в этой функции можно.

13. Что такое статические конструкторы? Пример

Статические конструкторы позволяют инициализировать статические переменные класса.

Пример. Демонстрируется объявление статического конструктора в классе.

// класс, который содержит статический конструктор class CCount { private static int count; static CCount() { count = 7; // инициализация статической переменной count } // доступ к внутренней статической переменной count public static int Get() { return count; } }

Демонстрация работы класса CCount в некотором методе

int x; x = CCount .Get(); // x = 7

14. Какие правила (особенности) использования статических конструкторов?

При использовании статических конструкторов нужно обратить внимание на следующие правила:

• перед статическим конструктором может указываться ключевое слово static ;
• статические конструкторы вызываются автоматически, если класс загружается первый раз;
• у статических конструкторов не может быть модификаторов доступа (public , private ). То есть, статические конструкторы пользуются доступом по умолчанию. Это связано с тем, что статические конструкторы вызываются в классе первыми – перед созданием первого экземпляра класса в программе;
• статический конструктор не может иметь параметров. Если попробовать создать параметризированный статический конструктор в классе, то возникнет ошибка компиляции.

15. Можно ли из статических конструкторов инициализировать нестатические переменные класса?

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

Например.

class CFileName { private static string fname; // скрытая статическая переменная private string folder; // скрытая нестатическая переменная // статический конструктор static CFileName(string _fname) { fname = _fname; // доступ только к статическим переменным класса // folder = ""; // ошибка, folder - нестатическая переменная } }

Связанные темы

• Понятие класса. Общая форма объявления класса. Объект Следующая запись Позднее связывание (late binding). Вызов метода. Пример. Класс System.Activator. Метод Invoke()

Модификатора 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. Бывают и другие, но их мы рассмотрим позже.

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. Статические методы не принимают параметр 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);

В объектно-ориентированном программировании метод - это именованный блок кода, который объявляется внутри класса и может быть использован многократно. Если вы знакомы с процедурным программированием (Pascal, Basic), вспомните, что такое функция - по принципу работы у неё и метода много общего.

Хорошо написанный метод решает одну практическую задачу: находит квадратный корень из числа (как штатный метод sqrt() в Java), преобразует число в строку (метод toString()), присваивает значения полям объекта и так далее.

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

Штатные - встроенные - методы языка работают со служебными объектами. Например, метод print в Java выводит значения в консоль. Вызывают его так:

System . out. print("Привет, мир!" );

Обратите внимание на структуру: у класса System есть поле out - поток ввода/вывода. Поле - тоже объект, и у него есть метод print(), который мы вызываем.

Ещё есть метод println(), который при выводе значений автоматически переводит каретку на следующую строку. Это избавляет от необходимости ставить «\n» в месте переноса строки.

Чтобы Java-приложение могло работать, в его базовом классе обязательно нужно объявить метод main.

public static void main(String args) { // здесь основной код и вызовы других методов }

Как видите, в качестве параметра main принимает массив строк, в данном случае - параметров запуска.

Объявление и определение метода в Java

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

В примере ниже метод должен найти большее из двух целых чисел, поэтому тип возвращаемого значения - int:

public static int maxFinder(int a, int b) { //заголовок метода //ниже - тело метода int max; if (a < b) max = b; else max = a; return max; }

В заголовке метода сначала идут модификаторы, определяющие, на каких условиях он доступен для вызова. Об этом чуть ниже. Вернёмся к заголовку: int - возвращаемый тип, maxFinder - имя метода, в скобках - параметры.

В теле метода заводим переменную max, куда потом запишем большее число. Далее сравниваем значения, фиксируем большее в max и возвращаем.

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

return a+ b;

Когда метод не должен ничего возвращать, тип возвращаемого значения указывают как void. А если методу для работы не нужны входные параметры, скобки оставляют пустыми:

static void theWarning() { System . out. println("Мне ничего не надо, и вы от меня ничего не получите." ); }

Как вызвать метод в Java

Метод с модификатором public можно вызывать из любого класса, в том числе размещенного во внешнем файле. Если нужно, чтобы метод был доступен исключительно внутри своего класса, применяют модификатор private. Есть и более мягкий вариант ограничения доступа: методы с модификатором protected доступны подклассам своего класса и другим классам из того же пакета. Чем сложнее получить доступ к методу извне, тем безопаснее - ниже риск ошибок.

Статический метод в Java принадлежит классу, а не объектам (и экземплярам) класса. Поэтому его вызывают без создания экземпляра.

Для простоты мы сделали методы публичными и статическими и разместили их в главном классе программы.

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

public static void main(String args) { System . out. print(maxFinder(3 ,8 )); }

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

После вызова метод управляет программой до окончания своей работы: пока в его теле не сработает оператор возврата или прерывания, либо пока не будут выполнены все находящиеся в нём инструкции.

Вызовем theWarning, который ничего не возвращает:

public static void main(String args) { theWarning(); System . out. print(“theWarning завершил свою работу. Идём дальшe. ”); }

Этот метод обходится без помощников - делает, что должен, и передаёт управление последующему коду.

Вызов метода из другого класса

А если бы maxFinder находился в отдельном классе и был не статическим? Тогда для его вызова пришлось бы сначала создать объект класса, в котором он находится. Допустим, метод находится в классе SampleClass. Вызываем:

public void main(String args) { SampleClass sc= new SampleClass (); System . out. print(sc. maxFinder(5 ,8 )); }

Статический метод вызывают через точку от имени класса - вот так:

System . out. print(SomeClass . maxFinder(5 ,8 ));

Перегрузка методов в Java

Что, если нам нужно сравнивать не только целые числа, но и числа с плавающей точкой? Реализовать это поможет перегрузка метода. Копипастим метод maxFinder в тот же класс, заменяем типы всех задействованных значений на double:

public static double maxFinder(double a, double b) { double max; //остальную часть тела метода оставляем без изменений }

Имя метода не меняем! Это и есть перегрузка: компилятор сам выберет, какую из версий метода использовать - в зависимости от того, значения какого типа сравниваем.

Ключевое слово this в методах Java

Ключевое слово this позволяет ссылаться на экземпляры класса: их переменные, методы и конструкторы. Используют this только внутри метода или конструктора экземпляра. Например, вот так можно связать входные параметры метода с одноименными параметрами конкретного экземпляра класса:

class UserData { int id, age, phone; void setProfileData (int id , int age , int phone ) { this . id= id; this . age= age; this . phone= phone; } }

Ещё пример - вызов одного конструктора из другого:

class ProfileData { int id; ProfileData () { this (100 ); } ProfileData (int id ) { this . id = id; } }

Это называется «явный вызов конструктора».

Абстрактные методы в Джаве

Абстрактным называют метод, который объявлен без реализации - он не имеет ни тела, ни даже фигурных скобок. Перед именем такого метода ставят модификатор abstract:

abstract void methodName();

Зачем он такой нужен? В качестве шаблона для других методов из других классов. Вот есть у нас абстрактный класс «Строение», а в нём - абстрактный метод «возвести». Реализовывать эти абстракции нужно через несколько неабстрактных классов-наследников и их методы. Пример: класс «Хижина» - метод «стройХижину», класс «Мост» - метод «стройМост» и др.

package ru.your.classes ; abstract class Construction { abstract void build_it (String msg1 ); abstract void sell_it (String msg2 ); } public class Hut extends Construction { // неабстрактный класс @Override // переопределяем метод void build_it (String msg1 ) { System . out. println("Хижина построена!" ); } @Override void sell_it (String msg2 ) { System . out. println("Хижина продана." ); } } public abstract class Bridge extends Construction { @Override void build_it (String msg1 ) { System . out. println("Мост построен!" ); } // Допустим, продавать объекты класса Bridge не предполагается. // Тогда sell_it можем не переопределять. // Но обязательно создадим абстрактный дочерний метод: abstract void sell_it (String msg2 ); }

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