Статический метод main c

Статический метод main c

Метод с именем Main является самым главным методом в программе на языке программирования c sharp (c#), потому что с него начинается выполнение приложения. Существует несколько вариантов написания метода Main():

static void Main()

static int Main() return Целое__число;

static void Main (string[] args)

static public int Main (string[] args) <

Обратите внимание, что все варианты метода Main() в языке программирования c# (c sharp) являются статичными (в начале стоит модификаторstatic).Это значит, что метод можно вызывать без создания экземпляра класса. Логично? Я думаю, что да, ведь при запуске приложе­ния еще никаких классов не создавалось, а значит, существуют только статичные методы и переменные, которые инициализируются автоматически при первом об­ращении.

Все эти объявления сводятся к одной простой истине — метод может возвра­щать пустое значение или число, а также может не принимать никаких параметров или принимать массив строк.

Метод Main() не обязан быть открытым, а может быть объявлен какprivate. В этом случае другие сборки не смогут вызывать метод напрямую. Если перед на­ми исполняемый файл, то он прекрасно будет запускаться и с закрытым методом

Почему в качестве параметра передается именно массив строк? Дело в том, что ОС, когда вызывает программу, может передать ей в качестве параметров одну строку. Это уже сама программа разбивает монолитную строку на массив, а в каче­стве разделителя используется пробел. Это значит, что если вы передадите про­грамме два СЛОВа, разделенных пробелом, например"parameterl parameter2’*,то В массиве значений будет создано две строки parameterl И parameter2.

Следующий пример показывает, как отобразить в консоли все переданные па­раметры:

private static void Main(string[] args) <

foreach (string s in args) Console.WriteLine(s);

Чтобы запустить пример из среды разработки и сразу же увидеть результат, вы можете прямо в среде разработки прописать параметры, которые должны будут передаваться программе. Для этого щелкните правой кнопкой мыши по имени про­екта и в контекстном меню выберите пункт Properties. Здесь выберите раздел Debug и в поле Command line arguments (Параметры командной строки) введите текст, который должен быть передан программе при запуске.

А что, если нужно передать программе имя файла, которое содержит пробелы? Интересный вопрос и мы часто можем встретиться с ним, но он решается легко — имя файла нужно заключить в двойные кавычки и передать в таком виде програм­ме в качестве параметра. Точно так же можно поступить с любой другой строкой, которая не должна быть разбита по пробелам. Все, что находится между кавычка­ми, не разбивается по параметрам.

Неужели доступ к параметрам командной строки можно получить только из метода Main() в языке программирования c# (c sharp)? А что если у нас большой проект и нужно узнать, что нам передали из совершенно другого места? И это возможно. Есть такой класс Environment, у которого есть статичный метод GetcommandLineArgs() (это значит, что для доступа к методу не нужно создавать класс), который вернет нам массив аргументов. Сле­дующий пример получает аргументы от класса и выводит их в консоль:

private static void Main() <

string[] args = Environment.GetcommandLineArgs();

foreach (string s in args) Console.WriteLine(s);

Запомните,ЧТО Environment.GetcommandLineArgs() возвращает массив пара­метров на один больше, потому что самым первым параметром (под индексом 0) всегда идет полный путь к запущенному файлу. В Интернете часто можно услы­шать вопрос о том, как узнать, откуда была запущена программа. Легко! Нужно посмотреть нулевой аргумент В Environment.GetcommandLineArgs(): stringfullpath= Environment.GetcommandLineArgs()[0];

Эта строка кода сохранит в переменной fullpathполный путь, включая имя файла запущенной программы.

Метод Main() в языке программирования c sharp (c#) не может быть перегружен, т. е. в одном классе не может существовать несколько методов с этим именем, в отличие от любых других методов. Это связано с тем, что иначе ОС не сможет определить, какой из методов Main() является входной точкой программы.

Статический класс — сущность в объекто-ориентированном языке программирования. Является одной из разновидностей класса. Суть данного вида состоит в том, что каждая функция данного класса является статической. Как правило, у данных типов класса не описаны конструктор и деструктор. Использовать статические функции класса можно, не создавая самого экземпляра класса. Это бывает удобно для создания списка функций, вложенных в какое-нибудь имя.

Статический класс в основном такой же, что и нестатический класс, но имеется одно отличие: нельзя создавать экземпляры статического класса. Другими словами, нельзя использовать ключевое слово new для создания переменной типа класса. Поскольку нет переменной экземпляра, доступ к членам статического класса осуществляется с использованием самого имени класса. Например, если имеется статический класс, называемый UtilityClass, имеющий открытый метод, называемый MethodA, вызов метода выполняется, как показано в следующем примере.

Статический класс может использоваться как обычный контейнер для наборов методов, работающих на входных параметрах, и не должен возвращать или устанавливать каких-либо внутренних полей экземпляра. Например, в библиотеке классов платформы .NET Framework статический класс System.Math содержит методы, выполняющие математические операции, без требования сохранять или извлекать данные, уникальные для конкретного экземпляра класса Math. Это значит, что члены класса применяются путем задания имени класса и имени метода, как показано в следующем примере.

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

Следующий список предоставляет основные характеристики статического класса:

· Содержит только статические члены.

· Создавать его экземпляры нельзя.

· Не может содержать конструкторов экземпляров.

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

Статические классы запечатаны, поэтому их нельзя наследовать. Они не могут быть унаследованы ни от каких классов, кроме Object. Статические классы не могут содержать конструктор экземпляров, но могут содержать статический конструктор. Нестатические классы также должен определять статический конструктор, если класс содержит статические члены, для которых нужна нетривиальная инициализация. Дополнительные сведения см. в разделе Статические конструкторы (Руководство по программированию в C#).

Читайте также:  Микроволновая резонансная терапия отзывы

37 Наследование является одним из трех

основополагающих принципов объектно-ориентированного

программирования, поскольку оно допускает создание

иерархических классификаций. Благодаря наследованию

можно создать общий класс, в котором определяются

характерные особенности, присущие множеству связанных

элементов. От этого класса могут затем наследовать другие,

более конкретные классы, добавляя в него свои

В языке С# класс, который наследуется, называется

базовым, а класс, который наследует, — производным.

Следовательно, производный класс представляет собой

специализированный вариант базового класса. Он наследует

все переменные, методы, свойства и индексаторы,

определяемые в базовом классе, добавляя к ним свои собственные

Поддержка наследования в С# состоит в том, что в

объявление одного класса разрешается вводить другой класс. Для

этого при объявлении производного класса указывается

базовый класс. Рассмотрим для начала простой пример.

Ниже приведен класс TwoDShape, содержащий ширину

и высоту двухмерного объекта, например квадрата,

прямоугольника, треугольника и т.д.

// Класс для двумерных объектов,

public double Width;

public double Heights-

public void ShowDimO <

Console.WriteLine("Ширина и высота равны " +

Width + " и " + Height);

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

описывающих конкретные типы двумерных объектов. Например, в приведенной ниже

программе класс TwoDShape служит для порождения производного класса Triangle.

Обратите особое внимание на объявление класса Triangle.

// Пример простой иерархии классов.

// Класс для двумерных объектов,

public double Width;

public double Height;

public void ShowDimO <

Console.WriteLine("Ширина и высота равны " +

Width + " и " + Height);

// Класс Triangle, производный от класса TwoDShape.

class Triangle : TwoDShape <

public string Style; // тип треугольника

// Возвратить площадь треугольника,

public double Area() <

return Width * Height / 2;

// Показать тип треугольника,

public void ShowStyleO <

static void Main() <

Triangle tl = new Triangle();

Triangle t2 = new Triangle();

Console.WriteLine("Сведения об объекте tl: ");

Console.WriteLine("Сведения об объекте t2: ");

Console.WriteLine("Площадь равна " + t2.Area()

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

Сведения об объекте tl:

Ширина и высота равны 4 и 4

Площадь равна 8

Сведения об объекте t2:

Ширина и высота равны 8 и 12

Площадь равна 4 8

В классе Triangle создается особый тип объекта класса TwoDShape (в данном

случае — треугольник). Кроме того, в класс Triangle входят все члены класса TwoDShape,

к которым, в частности, добавляются методы Area () и ShowStyle (). Так, описание

типа треугольника сохраняется в переменной Style, метод Area () рассчитывает и

возвращает площадь треугольника, а метод ShowStyle () отображает тип треугольника.

Обратите внимание на синтаксис, используемый в классе Triangle для

наследования класса TwoDShape.

class Triangle : TwoDShape <

Этот синтаксис может быть обобщен. Всякий раз, когда один класс наследует от

другого, после имени базового класса указывается имя производного класса,

отделяемое двоеточием. В С# синтаксис наследования класса удивительно прост и удобен в

В класс Triangle входят все члены его базового класса TwoDShape, и поэтому

в нем переменные Width и Height доступны для метода Area (). Кроме того, объекты

tl и t2 в методе Main () могут обращаться непосредственно к переменным Width и

Height, как будто они являются членами класса Triangle. На рис. 11.1 схематически

показано, каким образом класс TwoDShape вводится в класс Triangle.

Несмотря на то что класс TwoDShape является базовым для класса Triangle, в то

же время он представляет собой совершенно независимый и самодостаточный класс.

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

не может быть использован самостоятельно. Например, следующий фрагмент кода

считается вполне допустимым.

TwoDShape shape = new TwoDShape();

Разумеется, объект класса TwoDShape никак не связан с любым из классов,

производных от класса TwoDShape, и вообще не имеет к ним доступа.

Ниже приведена общая форма объявления класса, наследующего от базового класса.

class имя_производного_класса : имя_базового_класса <

Для любого производного класса можно указать только один базовый класс. В С# не

предусмотрено наследование нескольких базовых классов в одном производном

классе. (В этом отношении С# отличается от С-н-, где допускается наследование нескольких

базовых классов. Данное обстоятельство следует принимать во внимание при переносе

кода C++ в С#.) Тем не менее можно создать иерархию наследования, в которой

производный класс становится базовым для другого производного класса. (Разумеется, ни

один из классов не может быть базовым для самого себя как непосредственно, так и

косвенно.) Но в любом случае производный класс наследует все члены своего базового

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

Главное преимущество наследования заключается в следующем: как только будет

создан базовый класс, в котором определены общие для множества объектов

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

производных классов. А в каждом производном классе может быть точно выстроена своя

собственная классификация. В качестве примера ниже приведен еще один класс,

производный от класса TwoDShape и инкапсулирующий прямоугольники.

// Класс для прямоугольников, производный от класса TwoDShape.

class Rectangle : TwoDShape <

// Возвратить логическое значение true, если

// прямоугольник является квадратом,

public bool IsSquareO <

if(Width == Height) return true;

// Возвратить площадь прямоугольника,

public double Area() <

return Width * Height;

В класс Rectangle входят все члены класса TwoDShape, к которым добавлен метод

IsSquare (), определяющий, является ли прямоугольник квадратом, а также метод

Area (), вычисляющий площадь прямоугольника.

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

Читайте также:  Как удалить резервный аккаунт

Если член класса объявляется как static, то он становится доступным до создания любых объектов своего класса и без ссылки на какой-нибудь объект. С помощью ключевого слова static можно объявлять как переменные, так и методы. Наиболее характерным примером члена типа static служит метод Main(), который объявляется таковым потому, что он должен вызываться операционной системой в самом начале выполняемой программы.

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

Переменные, объявляемые как static, по существу, являются глобальными. Когда же объекты объявляются в своем классе, то копия переменной типа static не создается. Вместо этого все экземпляры класса совместно пользуются одной и той же переменной типа static. Такая переменная инициализируется перед ее применением в классе.

Пример использования ключевого слова static:

На применение методов типа static накладывается ряд следующих ограничений:

В методе типа static должна отсутствовать ссылка this, поскольку такой метод не выполняется относительно какого-либо объекта

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

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

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

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

Обратите внимание на то, что конструктор типа static вызывается автоматически, когда класс загружается впервые, причем до конструктора экземпляра. Из этого можно сделать более общий вывод: статический конструктор должен выполняться до любого конструктора экземпляра. Более того, у статических конструкторов отсутствуют модификаторы доступа — они пользуются доступом по умолчанию, а следовательно, их нельзя вызывать из программы.

Статические классы

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

Статические классы применяются главным образом в двух случаях. Во-первых, статический класс требуется при создании метода расширения. Методы расширения связаны в основном с языком LINQ. И во-вторых, статический класс служит для хранения совокупности связанных друг с другом статических методов:

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

Эту статью я написал несколько лет назад для другого сайта, но она так и не была опубликована. Тогда 7-я версия Java только-только появилась на свет, а 6-я была всё ещё актуальна. Статья адресована, в первую очередь тем, кто начинает знакомиться с языком Java. Я решил стряхнуть с неё пыль и опубликовать: пусть будет!

Здравствуйте, уважаемый читатель! Эта статья состоит из двух частей.

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

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

Новичкам

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

Метод main() , так и любой другой метод, должен быть обязательно вложен в класс. После компиляции класс, содержащий метод main() , запускается на выполнение командой

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

Метод main() должен объявляться в классе следующим образом:

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

Запись ( String[] args ) после имени метода представляет собой список его параметров. Имеется лишь один параметр args , содержащий ссылку на массив строк. Этот массив формируется из строки, переданной классу, содержащему метод main() , при запуске этого класса на выполнение командой java.

Если строка передана не была, то массив args содержит 0 элементов. В противном случае строка разбивается на части, которые в строке отделёны друг от друга пробельными символами. Эти части будем в дальнейшем называть аргументами командной строки. Данными аргументами и заполняется массив args .

Вместо имени массива args можно использовать любое другое имя. Например, следующее описание main() вполне корректно.

Что касается типа и количества параметров метода main() , то они изменению не подлежат.

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

Рассмотрим пример, в котором на консоль построчно выводятся все аргументы командной строки, переданные программе при её запуске. Под программой в данном случае мы будем понимать класс, содержащий метод main() . Этот класс мы назовём MainTest . Вот его код:

Читайте также:  Стиральная машина коричневого цвета

Здесь в методе main() содержится цикл, поочерёдно перебирающий элементы массива args . Ссылки на элементы массива поочерёдно присваиваются переменной s и выводятся на консоль методом println() объекта System.out . Этот метод после каждого вывода осуществляет перевод строки.

Сохраним код класса MainTest в файле с именем MainTest.java и скомпилируем этот файл командой

В результате компиляции получаем файл MainTest.class . Запускаем его на выполнение с несколькими аргументами командной строки:

java MainTest Это всего лишь проверка!

Если нет проблем с отображением кириллицы, то в результате выполнения команды на консоль будет выведено:

Это
всего
лишь
проверка!

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

В следующем примере (весьма вычурном) метод main() рекурсивен. При каждом вызове метода, за исключением последнего, на печать выводится один аргумент командной строки.

Здесь в методе main() выясняется, не является ли пустым массив args . Если нет, то на печать выводится первый его элемент. После этого метод main() вызывается рекурсивно. В качестве параметра ему передаётся новый массив, отличающийся от старого отсутствием первого элемента. Если же массив args пуст, то работа main() на этом завершается.

Результат выполнение класса RexMain совпадает с результатом выполнения класса MainTest .

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

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

Новичкам и не только

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

В Интернете на форумах, посвящённых Java, я нередко встречал любопытную задачку: написать класс, метод main() которого имеет пустое тело, выводящий на консоль надпись “Hello world!”. Полагаю, что эта задача известна многим из тех, кто интересуется Java.

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

Статический блок имеет некоторое сходство со статическим методом. Отличается он от последнего тем, что не имеет имени, не принимает параметров, не возвращает значения (а значит, не может содержать инструкции return ) и не вызывается явно. Так же как и статический метод, статический блок может содержать обращения к статическим полям и методам класса.

Статические блоки используются редко. Как правило, в их задачи входит инициализация статических полей класса.

Ну а мы поместим в статический блок инструкцию вывода на консоль строки “Hello world!”:

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

Тот факт, что статический блок выполняется до метода main() , легко проверить, скомпилировав и выполнив следующий класс:

На консоль будет выведено:

Привет от static-блока!
Привет от метода main()!

Заметим, что задачу, поставленную в начале статьи, можно решить, не прибегая к использованию статического блока. Для этого достаточно написать статический метод, печатающий строку “Hello world!” и возвращающий значение какого-либо типа, например, типа int , после чего создать статическое поле того же типа, инициализирующееся посредством вызова данного метода.

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

Вот код, демонстрирующий данный подход:

Выполнение класса WithoutStatic приводит к тому же выводу на консоль, что и выполнение класса HelloWorld .

Резонно задаться вопросом: а можно ли вообще обойтись без метода main() , пусть даже имеющего пустое тело? Для ответа на вопрос изменим класс HelloWorld , удалив из него main() :

И вот тут начинается самое интересное! Я компилировал и запускал этот класс с использованием комплектов разработки на языке Java (JDK) трёх разных версий: jdk1.6_021, jdk1.6_024 и jdk1.7.0_01. Во всех трёх случаях код компилировался без проблем. А вот с запуском класса проблемы возникали.

Для начала, оговорюсь, что каждый файл с расширением class запускался под управлением “своей” виртуальной машины Java, т. е. входящей в тот JDK, посредством которого этот файл был получен в результате компиляции.

Итак, в последних двух случаях на экран выводилась надпись:

Error: Main method not found in class WithoutMain, please define the main method as: public static void main(String[] args)

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

HelloWorld!
Exception in thread "main" java.lang.NoSuchMethodError: main

На этот раз виртуальная машина, всё же, выполняет статический блок и только после этого, не обнаружив метода main() , спохватывается и выдаёт по данному поводу ругательство. Можно ли избежать сообщения об исключении? Оказывается, можно!

Для этого достаточно после инструкции печати вызвать статический метод exit() класса System . Данный метод прерывает работу виртуальной машины и возвращает родительскому процессу (как правило, операционной системе) целое значение, переданное методу в качестве аргумента. Считается, что ненулевое значение свидетельствует об аварийном прерывании.

Итак, ниже приведён код работоспособной программы, не содержащей метода main() .

Выполнение программы приводит к следующему выводу на консоль:

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

Ссылка на основную публикацию
Смарт часы что они умеют
В этой статье мы поговорим о том, для чего нужны умные часы, а также какими функциями они располагают чаще всего....
Сервер не поддерживает символы не ascii
Многие из нас пользуются замечательным FTP сервером FileZilla Server. Думаю, не я один столкнулся с проблемой некорректного отображения русских букв...
Сервера для обновления nod32 бесплатно
Отличие полной версии от триальной Полные (не триальные) антивирусные базы и программные компоненты Eset Antivirus и Eset Smart Security! Отличия...
Смарт часы самсунг с сим картой
Хотите быть современным и модным человеком? Перестать зависеть от своего громоздкого смартфона? Только представьте, вы можете не брать телефон на...
Adblock detector