Что же это такое — public static void main(String[] args) — введение в Java 022 #
Давайте попробуем приподнять завесу тайны с метода, который мы писали чаще всего. Надо всё-таки понимать хоть немного, то что мы пишем.
Мы уже знаем, что такое main — точка входа в нашу программу. Мы знаем что такое void — это просто метод который выполняет код. Пришло время понять, что мы знаем, что String[] args это просто переменная args, которая является строковым массивом.
Давайте попробуем программировать без IDE по олдскульному.
Создадим файл Main.java
public class Main public static void main(String[] args) for (String str : args) System.out.println("My arguments = " + str); > > > Надеюсь мы ещё помним цикл фор ич, с помощью которого я хочу распечатать массив args.
Выйдем в консоль или терминал:
javac Main.java java Main ich lerne deutsch на экране мы получим:
My arguments = ich My arguments = lerne My arguments = deutsch 
Теперь мы должны в принципе осознавать, что String[] это массив, args имя переменной массива. И что при запуске мы можем передать эти аргументы, и в теле метода обработать.
Ещё раз. Наш метод принимает массив и выводит его на экран. При запуске программы в терминале мы передаём эти аргументы. Точно так же мы могли не вывести их на экран, а в зависимости от проверки выполнить команды. Например при передаче кодового слова кофе -> запустить метод готовки кофе.
Запуск программы main с аргументами в intellij idea #
- Находим в меню “Run”
- Нажимаем “Edit Configurations”
- В поле “Program arguments” вписываем свои аргументы, например “ich lerne deutsch”
- Результат будет выведен в привычном терминале IDEA.
Домашнее задание #
Напишите программу, которая запускает метод готовки кофе, если переданный аргумент в командной строке “coffee” или “c”.
Java: Метод main
Возможно вы удивитесь, но на протяжении всех предыдущих уроков, мы создавали свой собственный метод. Каркас метода был заранее написан, а от вас требовалось добавить его тело. Практика выглядела так:
public class App < public static void main(String[] args) < // BEGIN // А здесь вы писали свой код // END >> Зачем мы создавали метод? Java так устроена, что в ней невозможно выполнять код вне методов. Вы не можете просто написать код на уровне файла и запустить его. Компилятор выдаст ошибку:
// Файл с таким кодом не компилируется System.out.println("Хотя казалось бы"); А вот такой код уже сработает:
public class App < public static void main(String[] args) < System.out.println("Хотя казалось бы"); >> В работе вы часто будете видеть примеры вне методов. Почему мы и другие так делают? Исключительно для удобства.
Если на каждую строчку добавлять обертку в виде класса и метода, то объем шума и материала вырастет значительно. Всегда учитывайте это, ведь создатели этих материалов рассчитывают на то, что вы понимаете как работает Java.
Видите код, который вызывается без методов, всегда добавляйте обертку, как показано выше. Тогда вы легко сможете запустить этот код, например, локально.
Метод main
Почему метод в наших примерах называется main ? Мы ведь могли написать какой-то такой пример:
public class App < // run - имя выбрано произвольно // имя может быть любым, как захочет автор кода public static void run() < // здесь какой-то код >> Мы могли бы так сделать, и все бы работало, но есть один момент. В таком виде метод main , как мы его определяем, имеет особенное значение для Java.
Java автоматически его вызывает, когда программа запускается из консоли:
# В файле App находится класс с именем App java App.java # компилирует и запускает на исполнение # Внутри запустится метод App.main, если он определен Любой другой метод автоматически не вызывается. Именно поэтому мы везде используем main , ведь так можно легко перенести код из тренажера к себе в редактор и запустить его на выполнение.
Обязательно ли его определять? Нет, Java не накладывает никакого ограничения на то, какие и сколько методов вы определите в классе.
Так же как и нет ограничения на количество и имена классов.
Для простоты мы всегда используем имя App , но в реальном коде вы встретите тысячи разных имен и классов. Правда с условием, что в одном файле находится ровно один класс:
class MySuperClassName < public static void oneMethod() < >public static void twoMethod() < >public static void threeMethod() < >> Об этом мы поговорим в курсе по ООП в Java.
Главное, что нужно сейчас запомнить — любые статические методы вызываются через точку после имени класса, а сами вызовы происходят внутри других методов:
// Просто пример вызовов методов друг из друга class MySuperClassName < public static void oneMethod() < MySuperClassName.twoMethod(); >public static void twoMethod() < MySuperClassName.threeMethod(); >public static void threeMethod() < >> Задание
Реализуйте класс с именем App и двумя методами:
- Метод gogo() , который печатает на экран строку It works!
- main() , как в определении выше, который вызывает метод gogo()
Результат вызова main() в таком случае будет таким:
// => "It works!" Упражнение не проходит проверку — что делать? ��
Если вы зашли в тупик, то самое время задать вопрос в «Обсуждениях». Как правильно задать вопрос:
- Обязательно приложите вывод тестов, без него практически невозможно понять что не так, даже если вы покажете свой код. Программисты плохо исполняют код в голове, но по полученной ошибке почти всегда понятно, куда смотреть.
В моей среде код работает, а здесь нет ��
Тесты устроены таким образом, что они проверяют решение разными способами и на разных данных. Часто решение работает с одними входными данными, но не работает с другими. Чтобы разобраться с этим моментом, изучите вкладку «Тесты» и внимательно посмотрите на вывод ошибок, в котором есть подсказки.
Мой код отличается от решения учителя ��
Это нормально ��, в программировании одну задачу можно выполнить множеством способов. Если ваш код прошел проверку, то он соответствует условиям задачи.
В редких случаях бывает, что решение подогнано под тесты, но это видно сразу.
Прочитал урок — ничего не понятно ��
Создавать обучающие материалы, понятные для всех без исключения, довольно сложно. Мы очень стараемся, но всегда есть что улучшать. Если вы встретили материал, который вам непонятен, опишите проблему в «Обсуждениях». Идеально, если вы сформулируете непонятные моменты в виде вопросов. Обычно нам нужно несколько дней для внесения правок.
Кстати, вы тоже можете участвовать в улучшении курсов: внизу есть ссылка на исходный код уроков, который можно править прямо из браузера.
Урок 14. Метод public static void main
В этой статье из моего курса Java я буду обсуждать метод public static void main (String[] args). До этого момента в серии мы запускали наш код только через фреймворк JUnit. Это здравая, методологическая практика, однако она отличается от того, как наша программа будет работать в производстве. Теперь давайте рассмотрим, как наш код будет работать вне среды разработки.
public static void main
Изначально код, который вы пишете в компьютерной программе, — это просто статический текст, пассивно лежащий в файле. Для выполнения кода среда выполнения Java (JRE) отвечает за загрузку скомпилированной программы и запуск ее запуска. Для выполнения кода JRE нужна точка входа. При запуске класса Java из командной строки точкой входа, которую ищет JRE, является следующий метод:
public static void main (String[] args) < /* * JRE начинается с выполнения любого кода здесь */ >
Давайте рассмотрим каждую часть метода в деталях:
- public — позволяет вызывать метод из-за пределов класса.
- static — позволяет вызывать метод без создания экземпляра класса.
- void — не возвращает значения.
- main () — чтобы выполнить вашу программу, Java будет специально искать метод с именем «main».
- String [] args — вы можете вызвать свою программу с несколькими аргументами. Ваша программа может получить доступ к этим аргументам из этого массива.
public static void main(String[] arguments) < /* * JRE начинается с выполнения любого кода здесь */ >
Оба кода распознаются JRE. Кроме того, одна вещь о главном методе, который вы можете найти интересным, заключается в том, что вам даже не нужно использовать массив – вы можете заменить массив параметром переменной длины:
ublic static void main(String. arguments) < /* * JRE начинается с выполнения любого кода здесь */ >
Входной параметр, показанный здесь похож на более гибкую версию массива – если вы непосредственно вызываете этот метод, например из теста, он имеет преимущество в принятии переменного числа строковых аргументов, например main(“BMW”, “Porsche”, “Mercedes”), без необходимости создавать массив заранее. Честно говоря, я никогда не использую такой параметр для основного метода, но я думаю, что это хорошая деталь, чтобы знать и хвастаться ;-).
Статический основной метод, который мы используем в качестве точки доступа, очень специфичен. Если вы измените его сверх того, что я обсуждал, он не будет работать так, как вы намереваетесь. Если вы хотите свести своих коллег с ума ; -), вы можете отклониться от этого шаблона, например, сделав метод int вместо void, как показано ниже:
public int main(String[] arguments)
Это код создаст метод с именем main, но он не будет распознан как «основной» метод, и поэтому программа не сможет работать, используя этот метод в качестве отправной точки.
Примеры кода
Давайте создадим класс calledCarSelector и добавим к нему метод main. Он выводит каждый из аргументов командной строки обратно на консоль:
public class CarSelector < public static void main(String[] arguments)< for (String argument: arguments) < System.out.println(“processing car:“ + argument); >>
С помощью основного метода мы можем выполнить этот код без использования тест для вызова, как мы делали до текущего момента.
Компиляция c помощью командной строки
Чтобы запустить нашу программу из командной строки, мы должны сначала перейти в корневую папку нашего исходного кода. В нашем случае это src/main/ java. Кроме того, это структура папок по умолчанию для “Maven», инструмента управления сборкой, который я выделил ранее, когда говорил об инструментах Java.
Для компиляции кода мы вводим:
javac ru/upread/javacourse/car/CarSelector.java
Это создаст файл под названием CarSelector.класс в той же папке, что и CarSelector.java, и мы, наконец, можем выполнить нашу программу:
java ru/upread/javacourse/car/CarSelector
Как вы можете видеть, вызов нашего класса без каких-либо аргументов на самом деле ничего не делает. Так что давайте добавим несколько аргументов:
java ru/upread/javacourse/car/CarSelector BMW Porsche Mercedes processing car: BMW processing car: Porsche processing car: Mercedes
Ура! Мы успешно выполнили нашу собственную программу с консоли!
Запуск программы с помощью IntelliJ IDEA
Чтобы запустить нашу программу из IntelliJ IDEA, мы просто щелкаем правой кнопкой мыши метод и выбираем » Run ‘CarSelector.main’ » из контекстного меню.
Если мы изменим сигнатуру метода main(), то запустим CarSelector.команда main исчезнет из контекстного меню, так как у нас больше не будет действительной точки входа. Однако, когда мы запускаем его, ничего не печатается. Это происходит потому, что никто не передает методу main() никаких аргументов. Для этого в IDE: в меню «Run“ выберите ”edit configurations…. “, а во вкладке ”конфигурация“ добавьте разделенные пробелами строки в ” Program Parameters».
Теперь, когда мы запускаем метод main (), мы видим, что наши автомобили успешно выводятся на консоль.
Комментарий
Если вы закончили еще один курс Java до этого, или даже если это ваш первый курс, вы можете задаться вопросом, почему я отложил введение метода main() до этого относительно продвинутого этапа в курсе. Я сделал это по нескольким причинам. Во-первых, я считаю, что важно дать вам инструменты, чтобы полностью понять что-то, прежде чем я представлю его. Если бы вы не знали, что такое public static void, или не знали, что такое массив, было бы нечестно учить вас этому. Теперь, когда у вас есть некоторые знания обо всех этих вещах, вы можете начать полностью понимать, как работает этот метод.
Еще одна причина, по которой я решил отложить это обсуждение на столь долгое время, заключается в том, что в объектно-ориентированной разработке статические переменные и методы должны использоваться редко. Есть несколько случаев, когда вы используете статический модификатор, но я не хочу продвигать его использование в этом курсе.
Наконец, вам редко придется писать основной метод самостоятельно (если вы не будете программировать в одиночку). Для каждой программы (любого размера) существует только один основной метод, и к тому времени, когда вы присоединились к проекту, он, вероятно, уже был написан кем-то другим.
Автор этого материала — я — Пахолков Юрий. Я оказываю услуги по написанию программ на языках Java, C++, C# (а также консультирую по ним) и созданию сайтов. Работаю с сайтами на CMS OpenCart, WordPress, ModX и самописными. Кроме этого, работаю напрямую с JavaScript, PHP, CSS, HTML — то есть могу доработать ваш сайт или помочь с веб-программированием. Пишите сюда.
статьи IT, уроки по java, java, методы
Оставить комментарий
Отправляя сообщение я подтверждаю, что ознакомлен и согласен с политикой конфиденциальности данного сайта.
Main() и аргументы командной строки
Метод Main — это точка входа приложения C#. (Библиотекам и службам не требуется Main метод в качестве точки входа.) При запуске Main приложения метод является первым вызываемого метода.
В программе на C# может существовать только одна точка входа. Если у вас есть несколько классов с методом Main , программу нужно компилировать с параметром компилятора StartupObject, чтобы указать, какой из методов Main будет использоваться в качестве точки входа. Дополнительные сведения см. в разделе StartupObject (параметры компилятора C#).
class TestClass < static void Main(string[] args) < // Display the number of command line arguments. Console.WriteLine(args.Length); >> Инструкции верхнего уровня можно также использовать в одном файле в качестве точки входа для приложения:
using System.Text; StringBuilder builder = new(); builder.AppendLine("Hello"); builder.AppendLine("World!"); Console.WriteLine(builder.ToString()); Обзор
- Метод Main — это точка входа для выполняемой программы. Это начальный и завершающий этапы управления программой.
- Main объявляется внутри класса или структуры. Main должно быть static , и это не должно быть public . (В предыдущем примере он получает доступ private по умолчанию .) Вложенный класс или структуру не требуется быть статическим.
- Main может иметь void тип , int Task или Task возвращаемый тип.
- Если только Main возвращает Task или Task , объявление Main может включать модификатор async . Это, в частности, исключает async void Main метод.
- Метод Main может быть объявлен с параметром string[] , который содержит аргументы командной строки, или без него. При использовании Visual Studio для создания приложений Windows можно добавить параметр вручную или использовать GetCommandLineArgs() метод для получения аргументов командной строки. Параметры считываются как аргументы командной строки, индексы которых начинаются с нуля. В отличие от C и C++, имя программы не рассматривается как первый аргумент командной строки в массиве args , но является первым элементом метода GetCommandLineArgs().
В следующем списке показаны допустимые Main подписи:
public static void Main() < >public static int Main() < >public static void Main(string[] args) < >public static int Main(string[] args) < >public static async Task Main() < >public static async Task Main() < >public static async Task Main(string[] args) < >public static async Task Main(string[] args)
В предыдущих примерах все используют public модификатор доступа. Это типично, но не обязательно.
Добавление значений async и Task , а также типов возвращаемого значения Task упрощает код программы, когда консольным приложениям требуется запустить и ожидать ( await ) асинхронные операции в Main .
Возвращаемые значения Main()
Вы можете возвратить int из метода Main , определив метод одним из следующих способов:
| Код метода Main | Сигнатура Main |
|---|---|
| Без использования args или await | static int Main() |
| С использованием args , без использования await | static int Main(string[] args) |
| Без использования args , с использованием await | static async Task Main() |
| С использованием args и await | static async Task Main(string[] args) |
Если значение, возвращаемое методом Main , не используется, возврат void или Task несколько упрощает код.
| Код метода Main | Сигнатура Main |
|---|---|
| Без использования args или await | static void Main() |
| С использованием args , без использования await | static void Main(string[] args) |
| Без использования args , с использованием await | static async Task Main() |
| С использованием args и await | static async Task Main(string[] args) |
Однако возврат int или Task позволяет программе передавать информацию о своем состоянии другим программам и скриптам, которые вызывают исполняемый файл.
В следующем примере показано, как можно получить доступ к коду завершения для процесса.
В этом примере используются программы командной строки .NET Core. Если вы не знакомы с программами командной строки .NET Core, можете обратиться к этой статье по началу работы.
Создайте приложение, выполнив команду dotnet new console . Измените Main метод в Program.cs следующим образом:
// Save this program as MainReturnValTest.cs. class MainReturnValTest < static int Main() < //. return 0; >> При запуске программы в Windows значение, возвращаемое функцией Main , сохраняется в переменной среды. Эту переменную среды можно получить из пакетного файла с помощью ERRORLEVEL или в PowerShell с помощью $LastExitCode .
Для сборки приложения можно выполнить команду dotnet build интерфейса командной строки .NET.
Затем создайте скрипт PowerShell для запуска приложения и отображения результата. Вставьте следующий код в текстовый файл и сохраните его под именем test.ps1 в папке проекта. Запустите скрипт PowerShell, введя команду test.ps1 в командной строке PowerShell.
Так как код возвращает нулевое значение, пакетный файл сообщает об успехе. Но если изменить файл MainReturnValTest.cs, чтобы он возвращал ненулевое значение, и затем повторно скомпилировать программу, то при последующем выполнении скрипта PowerShell будет выдано сообщение об ошибке.
dotnet run if ($LastExitCode -eq 0) < Write-Host "Execution succeeded" >else < Write-Host "Execution Failed" >Write-Host "Return value = " $LastExitCode Execution succeeded Return value = 0 Значения, возвращаемые асинхронным методом main
При объявлении возвращаемого значения Main компилятор создает стандартный async код для вызова асинхронных методов в Main . Если вы не указываете async ключевое слово, необходимо самостоятельно написать этот код, как показано в следующем примере. Код в примере гарантирует, что программа выполняется до завершения асинхронной операции:
class AsyncMainReturnValTest < public static void Main() < AsyncConsoleWork().GetAwaiter().GetResult(); >private static async Task AsyncConsoleWork() < // Main body here return 0; >> Этот стандартный код можно заменить следующими способами:
class Program < static async TaskMain(string[] args) < return await AsyncConsoleWork(); >private static async Task AsyncConsoleWork() < // main body here return 0; >> Преимущество объявления Main как async того, что компилятор всегда создает правильный код.
Если точка входа приложения возвращает Task или Task , то компилятор создает новую точку входа, которая вызывает метод точки входа, объявленный в коде приложения. Предположим, что эта точка входа называется $GeneratedMain . В этом случае компилятор создает следующий код для этих точек входа:
- static Task Main() приводит к тому, что компилятор формирует эквивалент private static void $GeneratedMain() => Main().GetAwaiter().GetResult();
- static Task Main(string[]) приводит к тому, что компилятор формирует эквивалент private static void $GeneratedMain(string[] args) => Main(args).GetAwaiter().GetResult();
- static Task Main() приводит к тому, что компилятор формирует эквивалент private static int $GeneratedMain() => Main().GetAwaiter().GetResult();
- static Task Main(string[]) приводит к тому, что компилятор формирует эквивалент private static int $GeneratedMain(string[] args) => Main(args).GetAwaiter().GetResult();
Если бы в примерах использовался модификатор async метода Main , компилятор сформировал бы точно такой же код.
Аргументы командной строки
Вы можете передавать аргументы в метод Main , определив метод одним из следующих способов:
| Код метода Main | Сигнатура Main |
|---|---|
| Без возвращаемого значения, без использования await | static void Main(string[] args) |
| С возвращаемым значением, без использования await | static int Main(string[] args) |
| Без возвращаемого значения, с использованием await | static async Task Main(string[] args) |
| С возвращаемым значением, с использованием await | static async Task Main(string[] args) |
Если аргументы не используются, можно опустить args в сигнатуре метода, чтобы немного упростить код:
| Код метода Main | Сигнатура Main |
|---|---|
| Без возвращаемого значения, без использования await | static void Main() |
| С возвращаемым значением, без использования await | static int Main() |
| Без возвращаемого значения, с использованием await | static async Task Main() |
| С возвращаемым значением, с использованием await | static async Task Main() |
Вы также можете использовать Environment.CommandLine или Environment.GetCommandLineArgs получать доступ к аргументам командной строки из любой точки в консоли или приложении Windows Forms. Чтобы включить аргументы командной строки в Main сигнатуре метода в приложении Windows Forms, необходимо вручную изменить подпись Main . Код, созданный конструктором Windows Forms, создает Main без входного параметра.
Параметр метода Main — это массив String, представляющий аргументы командной строки. Как правило, определить, существуют ли аргументы, можно, проверив свойство Length , например:
if (args.Length == 0)
Массив args не может иметь значение NULL. Поэтому доступ к свойству Length можно получить без проверки значения NULL.
Строковые аргументы также можно преобразовать в числовые типы с помощью класса Convert или метода Parse . Например, следующая инструкция преобразует string в число long с помощью метода Parse:
long num = Int64.Parse(args[0]); Можно также использовать тип C# long , который является псевдонимом Int64 :
long num = long.Parse(args[0]); Кроме того, можно использовать метод класса Convert , ToInt64 :
long num = Convert.ToInt64(s); Дополнительные сведения см. в разделах Parse и Convert.
В следующем примере показано использование аргументов командной строки в консольном приложении. Приложение принимает один аргумент времени выполнения, преобразует аргумент в целое число и вычисляет факториал числа. Если не указано никаких аргументов, приложение выдает сообщение, поясняющее правильное использование программы.
Чтобы скомпилировать и запустить приложение из командной строки, выполните следующие действия.
-
Вставьте следующий код в любой текстовый редактор и сохраните файл как текстовый файл с именем Factorial.cs.
public class Functions < public static long Factorial(int n) < // Test for invalid input. if ((n < 0) || (n >20)) < return -1; >// Calculate the factorial iteratively rather than recursively. long tempResult = 1; for (int i = 1; i return tempResult; > > class MainClass < static int Main(string[] args) < // Test if input arguments were supplied. if (args.Length == 0) < Console.WriteLine("Please enter a numeric argument."); Console.WriteLine("Usage: Factorial "); return 1; > // Try to convert the input arguments to numbers. This will throw // an exception if the argument is not a number. // num = int.Parse(args[0]); int num; bool test = int.TryParse(args[0], out num); if (!test) < Console.WriteLine("Please enter a numeric argument."); Console.WriteLine("Usage: Factorial "); return 1; > // Calculate factorial. long result = Functions.Factorial(num); // Print result. if (result == -1) Console.WriteLine("Input must be >= 0 and <= 20."); else Console.WriteLine($"The Factorial of is ."); return 0; > > // If 3 is entered on command line, the // output reads: The factorial of 3 is 6. При выполнении приложения в Visual Studio аргументы командной строки можно указать на странице «Отладка» в конструкторе проектов.
Спецификация языка C#
Дополнительные сведения см. в спецификации языка C#. Спецификация языка является предписывающим источником информации о синтаксисе и использовании языка C#.
См. также
- System.Environment
- Отображение аргументов командной строки
Совместная работа с нами на GitHub
Источник этого содержимого можно найти на GitHub, где также можно создавать и просматривать проблемы и запросы на вытягивание. Дополнительные сведения см. в нашем руководстве для участников.