Статические классы, методы, переменные. Статические конструкторы. Ключевое слово 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()

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

Тема 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(...) поскольку первый вариант четко указывает, что вызывается статический метод.

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

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

Public static void main(String args) { }

Для объявления статических переменных, констант, методов и инициализаторов перед их объявлением указывается ключевое слово static .

Статические поля

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

Например, создадим статическую переменную:

Public class Program{ public static void main(String args) { Person tom = new Person(); Person bob = new Person(); tom.displayId(); // Id = 1 bob.displayId(); // Id = 2 System.out.println(Person.counter); // 3 // изменяем Person.counter Person.counter = 8; Person sam = new Person(); sam.displayId(); // Id = 8 } } class Person{ private int id; static int counter=1; Person(){ id = counter++; } public void displayId(){ System.out.printf("Id: %d \n", id); } }

Класс Person содержит статическую переменную counter, которая увеличивается в конструкторе и ее значение присваивается переменной id. То есть при создании каждого нового объекта Person эта переменная будет увеличиваться, поэтому у каждого нового объекта Person значение поля id будет на 1 больше чем у предыдущего.

Так как переменная counter статическая, то мы можем обратиться к ней в программе по имени класса:

System.out.println(Person.counter); // получаем значение Person.counter = 8; // изменяем значение

Консольный вывод программы:

Id = 1 Id = 2 3 Id = 8

Статические константы

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

Public class Program{ public static void main(String args) { double radius = 60; System.out.printf("Radisu: %f \n", radius); // 60 System.out.printf("Area: %f \n", Math.PI * radius); // 188,4 } } class Math{ public static final double PI = 3.14; }

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

System.out.println("hello");

out как раз представляет статическую константу класса System. Поэтому обращение к ней идет без создания объекта класса System.

Статические инициализаторы

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

Public class Program{ public static void main(String args) { Person tom = new Person(); Person bob = new Person(); tom.displayId(); // Id = 105 bob.displayId(); // Id = 106 } } class Person{ private int id; static int counter; static{ counter = 105; System.out.println("Static initializer"); } Person(){ id=counter++; System.out.println("Constructor"); } public void displayId(){ System.out.printf("Id: %d \n", id); } }

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

В самой программе создаются два объекта класса Person. Поэтому консольный вывод будет выглядеть следующим образом:

Static initializer Constructor Constructor Id: 105 Id: 106

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

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

Статические методы также относятся ко всему классу в целом. Например, в примере выше статическая переменная counter была доступна извне, и мы могли изменить ее значение вне класса Person. Сделаем ее недоступной для изменения извне, но доступной для чтения. Для этого используем статический метод:

Public class Program{ public static void main(String args) { Person.displayCounter(); // Counter: 1 Person tom = new Person(); Person bob = new Person(); Person.displayCounter(); // Counter: 3 } } class Person{ private int id; private static int counter = 1; Person(){ id = counter++; } // статический метод public static void displayCounter(){ System.out.printf("Counter: %d \n", counter); } public void displayId(){ System.out.printf("Id: %d \n", id); } }

Теперь статическая переменная недоступна извне, она приватная. А ее значение выводится с помощью статического метода displayCounter. Для обращения к статическому методу используется имя класса: Person.displayCounter() .

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

Вообще методы определяются как статические, когда методы не затрагиют состояние объекта, то есть его нестатические поля и константы, и для вызова метода нет смысла создавать экземпляр класса. Например:

Public class Program{ public static void main(String args) { System.out.println(Operation.sum(45, 23)); // 68 System.out.println(Operation.subtract(45, 23)); // 22 System.out.println(Operation.multiply(4, 23)); // 92 } } class Operation{ static int sum(int x, int y){ return x + y; } static int subtract(int x, int y){ return x - y; } static int multiply(int x, int y){ return x * y; } }

В данном случае для методов sum, subtract, multiply не имеет значения, какой именно экземпляр класса Operation используется. Эти методы работают только с параметрами, не затрагивая состояние класса. Поэтому их можно определить как статические.

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

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

1. class Ecstatic{
2. static int x = 0;
3. Ecstatic() { x++; }
4. }

Переменная x объявлена статичной. Это означает, что не важно, сколько объектов класса Ecstatic существует в данный момент - x всего лишь одна. При загрузке класса Ecstatic выделяется 4 байта под переменную x . И её инициализация происходит (см. строку №2) тоже в момент загрузки класса. И каждый раз, когда создаётся объект класса Ecstatic , x инкрементируется. Этот приём позволяет знать точное количество созданных объектов класса Ecstatic .

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

Через любой объект класса: обьект.переменная .
Через сам класс: класс.переменная .

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

3. e1.x = 100;
4. e2.x = 200;
5. reallyImportantVariable = e1.x;

Если вы заранее не знаете, что x - статичная переменная, то можете подумать, что в 5-й строке переменной reallyImportantVariable присваивается 100. Но на самом деле ей присваивается 200, потому что e1.x и e2.x - это всё одна и та же переменная х .

Поэтому лучше доступаться к статичным переменным через имя класса. Вот фрагмент кода, эквивалентный предыдущему:

1. Ecstatic e1 = new Ecstatic();
2. Ecstatic e2 = new Ecstatic();
3. Ecstatic.x = 100; // Бессмысленное действие
4. Ecstatic.x = 200;
5. reallyImportantVariable = Ecstatic.x;

Теперь всё встаёт на свои места: строка 3 не несёт никакого смысла - это всего лишь лишняя операция, а в 5-й строке переменной reallyImportantVariable присваивается сразу 200.

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

Каждое Java приложение содержит в себе статичный метод main() :

1. class SomeClass {
2. static int i = 48;
3. int j = 1;
4.
5. public static void main(String args) {
6. i += 100;
7. // j *= 5; Если раскомментировать, будет ошибка
8. }
9. }

Когда приложение запускается (то есть кто-то вызывает из коммандной строки java SomeClass ), не существует ни одного объекта класса SomeClass . Однако существует переменная i , которая инициализурется во 2-й строке и инкрементируется в 6-й строке. А если бы мы раскомметировали 7-ю строку, то вообще получили бы ошибку компиляции, потому что статичный метод не может использовать нестатичные переменные класса.

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

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