Методы Java — как вызывать и использовать. Статические методы

The static can be:

Let"s look at static variables and static methods first.

What is Static Variable in Java?

Static variable in Java is variable which belongs to the class and initialized only once at the start of the execution.

• It is a variable which belongs to the class and not to object(instance)
• Static variables are initialized only once, at the start of the execution. These variables will be initialized first, before the initialization of any instance variables
• A single copy to be shared by all instances of the class
• A static variable can be accessed directly by the class name and doesn’t need any object

<class-name>.

What is Static Method in Java?

Static method in Java is a method which belongs to the class and not to the object. A static method can access only static data.

• It is a method which belongs to the class and not to the object(instance)
• A static method can access only static data. It can not access non-static data (instance variables)
• A static method can call only other static methods and can not call a non-static method from it.
• A static method can be accessed directly by the class name and doesn’t need any object
• A static method cannot refer to "this" or "super" keywords in anyway

<class-name>.

Note: main method is static, since it must be accessible for an application to run, before any instantiation takes place.

Lets learn the nuances of the static keywords by doing some excercises!

Example: How to call static variables & methods

Step 1) Copy the following code into a editor

Public class Demo{ public static void main(String args){ Student s1 = new Student(); s1.showData(); Student s2 = new Student(); s2.showData(); //Student.b++; //s1.showData(); } } class Student { int a; //initialized to zero static int b; //initialized to zero only when class is loaded not for each object created. Student(){ //Constructor incrementing static variable b b++; } public void showData(){ System.out.println("Value of a = "+a); System.out.println("Value of b = "+b); } //public static void increment(){ //a++; //} }

Step 2) Save & Compile the code. Run the code as, java Demo .

Step 3) Expected output show below

Following diagram shows, how reference variables & objects are created and static variables are accessed by the different instances.

Step 4) It is possible to access a static variable from outside the class using the syntax ClassName.Variable_Name . Uncomment line # 7 & 8 . Save , Compile & Run . Observe the output.

Value of a = 0 Value of b = 1 Value of a = 0 Value of b = 2 Value of a = 0 Value of b = 3 Step 5) Uncomment line 25,26 & 27 . Save , Compile & Run.
error: non-static variable a cannot be referenced from a static context a++;

Step 6) Error = ? This is because it is not possible to access instance variable "a " from java static class method "increment ".

Java Static Block

The static block is a block of statement inside a Java class that will be executed when a class is first loaded into the JVM

Class Test{ static { //Code goes here } }

A static block helps to initialize the static data members , just like constructors help to initialize instance members

Последнее обновление: 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.

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

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

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

Это одна из наиболее распространённых ошибок допускаемых программистами Java, особенно новичками. Так как метод main статичный, а переменная count нет, в этом случае метод println , внутри метода main выбросит “Compile time error”.

В отличие от локальных переменных, статические поля и методы НЕ потокобезопасны (Thread-safe) в Java. На практике это одна из наиболее частых причин возникновения проблем связанных с безопасностью мультипоточного программирования. Учитывая что каждый экземпляр класса имеет одну и ту же копию статической переменной, то такая переменная нуждается в защите - «залочивании» классом. Поэтому при использовании статических переменных, убедитесь, что они должным образом синхронизированы (synchronized), во избежание проблем, например таких как «состояние гонки» (race condition).

Статические методы имеют преимущество в применении, т.к. отсутствует необходимость каждый раз создавать новый объект для доступа к таким методам. Статический метод можно вызвать, используя тип класса, в котором эти методы описаны. Именно поэтому, подобные методы как нельзя лучше подходят в качестве методов-фабрик (factory), и методов-утилит (utility). Класс java.lang.Math - замечательный пример, в котором почти все методы статичны, по этой же причине классы-утилиты в Java финализированы (final).

Другим важным моментом является то, что вы НЕ можете переопределять (Override) статические методы. Если вы объявите такой же метод в классе-наследнике (subclass), т.е. метод с таким же именем и сигнатурой, вы лишь «спрячете» метод суперкласса (superclass) вместо переопределения. Это явление известно как сокрытие методов (hiding methods). Это означает, что при обращении к статическому методу, который объявлен как в родительском, так и в дочернем классе, во время компиляции всегда будет вызван метод исходя из типа переменной. В отличие от переопределения, такие методы не будут выполнены во время работы программы. Рассмотрим пример:

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

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

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

Код наглядно демонстрирует: несмотря на то, что объект имеет тип Car , вызван статический метод из класса Vehicle , т.к. произошло обращение к методу во время компиляции. И заметьте, ошибки во время компиляции не возникло!

Объявить статическим также можно и класс, за исключением классов верхнего уровня. Такие классы известны как «вложенные статические классы» (nested static class). Они бывают полезными для представления улучшенных связей. Яркий пример вложенного статического класса - HashMap.Entry , который предоставляет структуру данных внутри HashMap . Стоит заметить, также как и любой другой внутренний класс, вложенные классы находятся в отдельном файле.class. Таким образом, если вы объявили пять вложенных классов в вашем главном классе, у вас будет 6 файлов с расширением.class. Ещё одним примером использования является объявление собственного компаратора (Comparator), например компаратор по возрасту (AgeComparator) в классе сотрудники (Employee).

Модификатор static также может быть объявлен в статичном блоке, более известным как «Статический блок инициализации» (Static initializer block), который будет выполнен во время загрузки класса. Если вы не объявите такой блок, то Java соберёт все статические поля в один список и выполнит его во время загрузки класса. Однако, статичный блок НЕ может пробросить перехваченные исключения, но может выбросить не перехваченные. В таком случае возникнет «Exception Initializer Error». На практике, любое исключение возникшее во время выполнения и инициализации статических полей, будет завёрнуто Java в эту ошибку. Это также самая частая причина ошибки «No Class Def Found Error», т.к. класс не находился в памяти во время обращения к нему.

Полезно знать, что статические методы связываются во время компиляции, в отличие от связывания виртуальных или не статических методов, которые связываются во время исполнения на реальном объекте. Следовательно, статические методы не могут быть переопределены в Java, т.к. полиморфизм во время выполнения не распространяется на них. Это важное ограничение, которое необходимо учитывать, объявляя метод статическим. В этом есть смысл, только тогда, когда нет возможности или необходимости переопределения такого метода классами-наследниками. Методы-фабрики и методы-утилиты хорошие образцы применения модификатора static . Джошуа Блох выделил несколько преимуществ использования статичного метода-фабрики перед конструктором, в книге «Effective Java », которая является обязательной для прочтения каждым программистом данного языка.

Важным свойством статического блока является инициализация. Статические поля или переменные инициализируются после загрузки класса в память. Порядок инициализации сверху вниз, в том же порядке, в каком они описаны в исходном файле Java класса. Поскольку статические поля инициализируются на потокобезопасный манер, это свойство также используется для реализации паттерна Singleton . Если вы не используется список Enum как Singleton , по тем или иным причинам, то для вас есть хорошая альтернатива. Но в таком случае необходимо учесть, что это не «ленивая» инициализация. Это означает, что статическое поле будет проинициализировано ещё ДО того как кто-нибудь об этом «попросит». Если объект ресурсоёмкий или редко используется, то инициализация его в статическом блоке сыграет не в вашу пользу.

Во время сериализации, также как и transient переменные, статические поля не сериализуются. Действительно, если сохранить любые данные в статическом поле, то после десериализации новый объект будет содержать его первичное (по-умолчанию) значение, например, если статическим полем была переменная типа int , то её значение после десериализации будет равно нулю, если типа float – 0.0, если типа Object – null . Честно говоря, это один из наиболее часто задаваемых вопросов касательно сериализации на собеседованиях по Java. Не храните наиболее важные данные об объекте в статическом поле!

И напоследок, поговорим о static import . Данный модификатор имеет много общего со стандартным оператором import , но в отличие от него позволяет импортировать один или все статические члены класса. При импортировании статических методов, к ним можно обращаться как будто они определены в этом же классе, аналогично при импортировании полей, мы можем получить доступ без указания имени класса. Данная возможность появилась в Java версии 1.5, и при должном использовании улучшает читабельность кода. Наиболее часто данная конструкция встречается в тестах JUnit , т.к. почти все разработчики тестов используют static import для assert методов, например assertEquals() и для их перегруженных дубликатов. Если ничего не понятно – добро пожаловать за дополнительной информацией .

На этом всё. Все вышеперечисленные пункты о модификаторе static в Java обязан знать каждый программист. В данной статье была рассмотрена базовая информация о статических переменных, полях, методах, блоках инициализации и импорте. В том числе некоторые важные свойства, знание которых является критичным при написании и понимании программ на Java. Я надеюсь, что каждый разработчик доведёт свои навыки использования статических концептов до совершенства, т.к. это очень важно для серьёзного программирования."

В объектно-ориентированном программировании метод - это именованный блок кода, который объявляется внутри класса и может быть использован многократно. Если вы знакомы с процедурным программированием (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 ); }

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

Модификатор 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-ю строку, то вообще получили бы ошибку компиляции, потому что статичный метод не может использовать нестатичные переменные класса.