Почему основной метод Java статичен?

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

Любой метод, объявленный как статический в Java, принадлежит самому классу. Снова к статическому методу определенного класса можно получить доступ, только обратившись к классу, подобному Class_name.method_name();

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

Таким образом, метод main () объявлен как static, поэтому к нему можно получить доступ без создания объекта этого класса.

Так как мы сохраняем программу с именем класса, в котором присутствует основной метод (или откуда программа должна начать свое выполнение, применимо для классов без метода main() () (Расширенный уровень)). Таким образом, вышеупомянутым способом:

Class_name.method_name();

основной метод может быть доступен.

Вкратце, когда программа компилируется, она ищет метод main(), имеющий String аргументов, таких как: main(String args[]) в упомянутом классе (то есть по имени программы), и так как в начале он имеет нет возможности создать экземпляр этого класса, поэтому метод main () объявлен как статический.

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

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

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

1. A static void main(), как мы видим это сегодня.
2. Экземпляр метода void main() вызвал только что созданный объект.
3. Использование конструктора типа в качестве точки входа (например, если класс входа был назван Program, то выполнение будет состоять из new Program()).

Разбивка:

static void main()

1. Вызывает статический конструктор класса включения.
2. Вызывает статический метод main().

void main()

1. Вызывает статический конструктор класса включения.
2. Создает экземпляр окружающего класса путем эффективного вызова new ClassName().
3. Вызывает метод экземпляра main().

new ClassName()

1. Вызывает статический конструктор класса включения.
2. Создает экземпляр класса (затем ничего не делает с ним и просто возвращает).

Обоснование:

Я пойду в обратном порядке для этого.

Имейте в виду, что одной из целей разработки Java было подчеркнуть (требовать, когда это возможно) хорошие практики объектно-ориентированного программирования. В этом контексте конструктор объекта инициализирует объект, но не должен отвечать за поведение объекта. Следовательно, спецификация, которая давала точку входа в new ClassName(), могла бы запутать ситуацию для новых разработчиков Java, вынудив сделать исключение из конструкции «идеального» конструктора в каждом приложении.

Сделав main() метод экземпляра, вышеуказанная проблема, безусловно, решена. Однако это создает сложность, требуя, чтобы спецификация перечисляла подпись конструктора класса входа, а также подпись метода main().

В итоге, , специфицируя static void main(), создает спецификацию с наименьшей сложностью, придерживаясь принципа помещения поведения в методы . Учитывая простоту реализации метода main(), который сам создает экземпляр класса и вызывает метод экземпляра, нет никакого реального преимущества в определении main() в качестве метода экземпляра.

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

существует больше информации об инициализации и осуществлении программ Java, доступных в Спецификация языка .

Прежде чем вызывается метод main, объекты не создаются. Наличие ключевого слова static означает, что метод может быть вызван без предварительного создания каких-либо объектов.

Это - просто соглашение. JVM могла, конечно, иметь дело с нестатическими основными методами, если это будет соглашением. В конце концов, можно определить статический инициализатор на классе и инстанцировать огромного количества объектов перед когда-либо получением к основному () метод.

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

Апплеты, midlets, сервлеты и бобы различных видов создаются и затем обратились к методам жизненного цикла их. Основной вызов является всем, что когда-либо делается к основному классу, таким образом, нет никакой потребности в состоянии, которое будет сохранено в объекте, который называют многократно. Довольно нормально прикрепить основной на другой класс (хотя не прекрасная идея), который помешал бы использованию класса для создания основного объекта.

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

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

Когда вы выполняете виртуальную машину Java (JVM) с помощью команды java,

java ClassName argument1 argument2 ...

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

JVM пытается вызвать основной метод класса, который вы укажете

- в этот момент никакие объекты класса не были созданы.

Объявление main как статического allows JVM для invoke основного without создания instance класса.

давайте вернемся к команде

ClassName - это command-line argument для JVM, которая сообщает ему, какой класс выполнять. Следуя ClassName, вы также можете указать list of Strings (разделенный пробелами) в качестве аргументов командной строки, которые JVM передаст вашему приложению. -Такие аргументы могут быть использованы для указания параметров (например, имени файла) для запуска приложения - вот почему в главном

указан параметр String[] args Ссылки: Java ™ How To Program (Ранние объекты), десятое издание

Недавно аналогичный вопрос был размещен на сайте Programmers.SE

• Почему статический метод main в Java и C #, а не конструктор?

  В поисках окончательного ответа из первичного или вторичного источника, почему (в частности) Java и C # решили использовать статический метод в качестве своей точки входа, а не представлять экземпляр приложения экземпляром класса Application с записью точка является подходящим конструктором?

TL; DR часть принятого ответа:

В Java Причина public static void main(String[] args) заключается в том, что

1. Гослинг хотел
2. код, написанный кем-то, имеющим опыт работы в C (не на Java)
3. для исполняться кем-то, кто привык запускать PostScript в NeWS

& nbsp;
Для C # аргументация транзитивно аналогична , так сказать. Разработчики языка сохранили синтаксис точки входа в программу , знакомый программистам, пришедшим с Java. Как говорит архитектор C # Андерс Хейлсберг ,

... наш подход с C # просто предлагал альтернативу ... программистам на Java ...

...

main() метод в C++, C# и Java статичен
, поскольку они могут тогда быть вызваны механизмом исполнения без необходимость инстанцировать любых объектов тогда, код в теле main() сделает остальных.

Это - просто соглашение. На самом деле даже основное имя (), и аргументы передало в, просто соглашение.

то, Когда Вы выполняете java.exe (или javaw.exe в Windows), что действительно происходит, является несколькими вызовами Собственного интерфейса Java (JNI). Эти вызовы загружают DLL, который является действительно JVM (правильно - java.exe НЕ является JVM). JNI является инструментом, который мы используем, когда мы должны соединить мостом мир виртуальной машины и мир C, C++, и т.д... Реверс также верен - не возможно (по крайней мере, к моему знанию) на самом деле получить JVM, работающую, не используя JNI.

В основном, java.exe является супер простым приложением C, которое анализирует командную строку, создает новый Массив строк в JVM для содержания тех аргументов, синтаксические анализы, имя класса, которое Вы определили как содержащий основной (), использует вызовы JNI для нахождения основного () самим методом, затем вызывает основное () метод, передающий в недавно созданном массиве строк в качестве параметра. Это очень, очень как то, что Вы делаете при использовании отражения от Java - это просто использует смутно названные собственные вызовы функции вместо этого.

было бы совершенно законно для Вас записать Вашу собственную версию java.exe (источник распределяется с JDK), и имейте его, делают что-то совершенно различное. На самом деле это точно, что мы делаем со всеми нашими основанными на Java приложениями.

Каждое из наших приложений Java имеет свое собственное средство запуска. Мы, прежде всего, делаем это так, мы получаем наш собственный значок и обрабатываем имя, но это пригодилось в других ситуациях, где мы хотим сделать что-то помимо регулярного основного (), звонят для получения вещей, идущих (Например, в одном случае, мы делаем совместимость COM, и мы на самом деле передаем дескриптор COM в основной () вместо массива строк).

Так, длинный и короткий: причиной это статично, является b/c, это удобно. Причина это называют 'основным', состоит в том, что это должно было быть что-то, и основной () то, что они сделали в былые времена C (и в те дни, название функции было важно). Я предполагаю, что java.exe, возможно, позволил Вам просто определять полностью определенное имя основного метода вместо просто класса (Java com.mycompany. Foo.someSpecialMain) - но это просто делает его тяжелее на IDE, чтобы автоматически обнаружить 'launchable' классы в проекте.

Статические методы не требуют никакого объекта. Они запускаются напрямую, поэтому main запускается напрямую.

static указывает, что этот метод является методом класса. И вызывается без требования какого-либо объекта класса.

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