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

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

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

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

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

Если нет, то какой конструктор следует использовать, если их больше одного?

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

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

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

Метод статический, потому что в противном случае возникла бы двусмысленность: какой конструктор следует вызвать? Особенно, если ваш класс выглядит так:

public class JavaClass{
  protected JavaClass(int x){}
  public void main(String[] args){
  }
}

Должна ли JVM вызывать new JavaClass(int)? Что он должен пройти для x?

Если нет, должна ли JVM создавать экземпляр JavaClass без запуска какого-либо метода конструктора? Я думаю, что этого не должно быть, потому что это будет особым случаем всего вашего класса - иногда у вас есть экземпляр, который не был инициализирован, и вам нужно проверять его в каждом методе, который можно вызвать.

Слишком много крайних случаев и двусмысленностей, чтобы JVM имела смысл создавать экземпляр класса до вызова точки входа. Вот почему main статичен.

Я понятия не имею, почему main всегда имеет маркировку public.

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

Это просто условность. Фактически, даже имя main () и переданные аргументы являются чисто условными.

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

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

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

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

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

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

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

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

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

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

Противоположностью public является private, который предотвращает использование члена кодом, определенным вне его класса.

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

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

Ключевое слово void просто сообщает компилятору, что main() не возвращает значение.

Часто задаваемый вопрос, почему main () статичен в Java.

Отвечать: Мы знаем, что в Java выполнение начинается с main () JVM. Когда JVM выполняет main () в это время, класс, содержащий main (), не создается, поэтому мы не можем вызвать нестатический метод без ссылки на его объект. Чтобы вызвать его, мы сделали его статическим, из-за чего загрузчик классов загружает все статические методы в пространство памяти контекста JVM, откуда JVM может их напрямую вызывать.

Статическое ключевое слово в основном методе используется, потому что в основном методе не выполняется никаких экземпляров. Но объект создается, а не вызывается, в результате мы используем статическое ключевое слово в основном методе. В контексте jvm память создается при загрузке в нее класса, и все статические члены присутствуют в этой памяти. если мы сделаем основной статический объект сейчас, он будет в памяти и будет доступен для jvm (class.main (..)), поэтому мы сможем вызвать основной метод без необходимости создания кучи.

Я думаю, что ключевое слово static делает основной метод методом класса, а методы класса имеют только одну его копию и могут использоваться всеми, а также не требуют объекта для ссылки. Поэтому, когда класс драйвера скомпилирован, можно вызвать основной метод. (Я просто на уровне алфавита java, извините, если я ошибаюсь)

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

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

Объектно-ориентированный подход хорош по миллионам очевидных причин. Однако прошли те времена, когда большинство разработчиков VB регулярно использовали в своем коде такие ключевые слова, как «goto». "goto" - это процедурная команда в VB, которая заменяется ее объектно-ориентированным аналогом: вызов метода.

Вы также можете рассматривать статическую точку входа (главную) как чистую свободу. Если бы Java была достаточно разной, чтобы создать экземпляр объекта и представить вам только этот экземпляр при запуске, у вас не было бы другого выбора, НО написать процедурное приложение. Каким бы невообразимым это ни звучало для Java, вполне возможно, что существует множество сценариев, требующих процедурных подходов.

Вероятно, это очень непонятный ответ. Помните, что «класс» - это всего лишь набор взаимосвязанного кода. «Экземпляр» - изолированное, живое и дышащее автономное поколение этого класса.

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

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

1. 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() в качестве метода экземпляра.

Это просто соглашение, как мы видим здесь:

The method must be declared public and static, it must not return any value, and it must accept a String array as a parameter. By default, the first non-option argument is the name of the class to be invoked. A fully-qualified class name should be used. If the -jar option is specified, the first non-option argument is the name of a JAR archive containing class and resource files for the application, with the startup class indicated by the Main-Class manifest header.

http://docs.oracle.com/javase/1.4.2/docs/tooldocs/windows/java.html#description

The public static void keywords mean the Java virtual machine (JVM) interpreter can call the program's main method to start the program (public) without creating an instance of the class (static), and the program does not return data to the Java VM interpreter (void) when it ends.

Источник: Основы, часть 1, урок 2: Создание приложений

Почему public static void main (String [] args)?

Так разработан язык Java и создана и написана виртуальная машина Java.

Спецификация языка Oracle Java

Проверьте Глава 12 Выполнение - Раздел 12.1.4 Вызов Test.main:

Finally, after completion of the initialization for class Test (during which other consequential loading, linking, and initializing may have occurred), the method main of Test is invoked.

The method main must be declared public, static, and void. It must accept a single argument that is an array of strings. This method can be declared as either

public static void main(String[] args)

or

public static void main(String... args)

Спецификация виртуальной машины Oracle Java

Проверьте Глава 2 Концепции языка программирования Java - Раздел 2.17 Выполнение:

The Java virtual machine starts execution by invoking the method main of some specified class and passing it a single argument, which is an array of strings. This causes the specified class to be loaded (§2.17.2), linked (§2.17.3) to other types that it uses, and initialized (§2.17.4). The method main must be declared public, static, and void.

Исходный код Oracle OpenJDK

Загрузите и извлеките исходный jar-файл и посмотрите, как написана JVM, ознакомьтесь с ../launcher/java.c, который содержит собственный код C за командой java [-options] class [args...]:

/*
 * Get the application's main class.
 * ... ...
 */
if (jarfile != 0) {
    mainClassName = GetMainClassName(env, jarfile);

... ...

    mainClass = LoadClass(env, classname);
    if (mainClass == NULL) { /* exception occured */

... ...

/* Get the application's main method */
mainID = (*env)->GetStaticMethodID(env, mainClass, "main",
                                   "([Ljava/lang/String;)V");

... ...

{    /* Make sure the main method is public */
    jint mods;
    jmethodID mid;
    jobject obj = (*env)->ToReflectedMethod(env, mainClass,
                                            mainID, JNI_TRUE);

... ...

/* Build argument array */
mainArgs = NewPlatformStringArray(env, argv, argc);
if (mainArgs == NULL) {
    ReportExceptionDescription(env);
    goto leave;
}

/* Invoke main method. */
(*env)->CallStaticVoidMethod(env, mainClass, mainID, mainArgs);

... ...

Из java.sun.com (на сайте больше информации):

The main method is static to give the Java VM interpreter a way to start the class without creating an instance of the control class first. Instances of the control class are created in the main method after the program starts.

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

Прототип public static void main(String[]) - это соглашение, определенное в JLS:

The method main must be declared public, static, and void. It must specify a formal parameter (§8.4.1) whose declared type is array of String.

В спецификации JVM 5.2. Запуск виртуальной машины мы можем прочитать:

The Java virtual machine starts up by creating an initial class, which is specified in an implementation-dependent manner, using the bootstrap class loader (§5.3.1). The Java virtual machine then links the initial class, initializes it, and invokes the public class method void main(String[]). The invocation of this method drives all further execution. Execution of the Java virtual machine instructions constituting the main method may cause linking (and consequently creation) of additional classes and interfaces, as well as invocation of additional methods.

Забавно, но в спецификации JVM не упоминается, что основной метод должен быть статическим. Но в спецификации также говорится, что виртуальная машина Java выполняет два шага раньше:

• связывает начальный класс (5.4. Связывание)
• инициализирует его (5.5. Инициализация)

Initialization of a class or interface consists of executing its class or interface initialization method.

В 2.9. Специальные методы:

метод инициализации класса или интерфейса определяется:

A class or interface has at most one class or interface initialization method and is initialized (§5.5) by invoking that method. The initialization method of a class or interface has the special name <clinit>, takes no arguments, and is void.

И метод инициализации класса или интерфейса отличается от метод инициализации экземпляра, определенного следующим образом:

At the level of the Java virtual machine, every constructor written in the Java programming language (JLS §8.8) appears as an instance initialization method that has the special name <init>.

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

Давайте просто сделаем вид, что static не потребуется в качестве точки входа в приложение.

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

class MyApplication {
    public MyApplication(){
        // Some init code here
    }
    public void main(String[] args){
        // real application code here
    }
}

Различие между кодом конструктора и методом main необходимо, потому что в OO-режиме конструктор должен только следить за тем, чтобы экземпляр был инициализирован должным образом. После инициализации экземпляр можно использовать для предполагаемой «службы». Помещение полного кода приложения в конструктор испортит это.

Таким образом, этот подход заставит приложение три заключать разные контракты:

• Конструктор по умолчанию - должен. В противном случае JVM не будет знать, какой конструктор вызывать и какие параметры должны быть предоставлены.
• должен - это метод main¹. Хорошо, это не удивительно.
• Класс не должен должен быть abstract. В противном случае JVM не сможет его создать.

С другой стороны, подход static требует только контракта один:

• Должен быть метод main¹.

Здесь не имеет значения ни abstract, ни несколько конструкторов.

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

Обратите внимание: это аргумент нет о простоте внутри JVM или внутри JRE. Этот аргумент касается простоты Пользователь.

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

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

  Looking for a definitive answer from a primary or secondary source for why did (notably) Java and C# decide to have a static method as their entry point – rather than representing an application instance by an instance of an Application class, with the entry point being an appropriate constructor?

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

In Java, the reason of public static void main(String[] args) is that

1. Gosling wanted
2. the code written by someone experienced in C (not in Java)
3. to be executed by someone used to running PostScript on NeWS

 
For C#, the reasoning is transitively similar so to speak. Language designers kept the program entry point syntax familiar for programmers coming from Java. As C# architect Anders Hejlsberg puts it,

...our approach with C# has simply been to offer an alternative... to Java programmers...

...

Что означает public static void main(String args[])?

1. public - это спецификатор доступа, означающий, что любой может получить к нему доступ / вызвать его, например JVM (виртуальная машина Java.

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

   class demo {    
       private int length;
       private static int breadth;
       void output(){
           length=5;
           System.out.println(length);
       }
   
       static void staticOutput(){
           breadth=10; 
           System.out.println(breadth);
       }
   
       public static  void main(String args[]){
           demo d1=new demo();
           d1.output(); // Note here output() function is not static so here
           // we need to create object
           staticOutput(); // Note here staticOutput() function is  static so here
           // we needn't to create object Similar is the case with main
           /* Although:
           demo.staticOutput();  Works fine
           d1.staticOutput();  Works fine */
       }
   }
   

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

3. void указывает, что объявляемый метод main() не возвращает значение.

4. String[] args определяет единственный параметр в методе main().

   args - параметр, содержащий массив объектов типа String.

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

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

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

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

Class_name.method_name();

можно получить доступ к основному методу.

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

Позвольте мне объяснить эти вещи гораздо проще:

public static void main(String args[])

Все приложения Java, кроме апплетов, начинают выполнение с main().

Ключевое слово public - это модификатор доступа, который позволяет вызывать член извне класса.

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

void указывает, что main() не возвращает никакого значения.

Я не знаю, вызывает ли JVM основной метод до создания экземпляров объектов ... Но есть гораздо более веская причина, по которой метод main () является статическим ... Когда JVM вызывает основной метод класса (скажем, , Человек). он вызывает его "Person.main ()". Видите ли, JVM вызывает его по имени класса. Вот почему метод main () должен быть статическим и общедоступным, чтобы к нему могла получить доступ JVM.

Надеюсь, это помогло. Если да, дайте мне знать, комментируя.

По сути, мы делаем этих УЧАСТНИКОВ ДАННЫХ и ФУНКЦИИ УЧАСТНИКА как СТАТИЧЕСКИЕ, которые не выполняют никаких задач, связанных с объектом. А в случае основного метода мы делаем его как СТАТИЧЕСКИЙ, потому что он не имеет ничего общего с объектом, так как основной метод всегда выполняется независимо от того, создаем мы объект или нет.

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

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

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

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

java ClassName argument1 argument2 ...

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

JVM пытается вызвать основной метод указанного вами класса

—at this point, no objects of the class have been created.

Declaring main as static allows the JVM to invoke main without creating an instance of the class.

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

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

Ссылки: Java ™ Как программировать (ранние объекты), десятое издание

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

для получения дополнительной информации посетите это видео: https://thewikihow.com/video_Z7rPNwg-bfk&feature=youtu.be