Как написать main() в режиме ООП?

Question

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

Но где вы решите дать другому классу/методу ответственность за выполнение программы от main()? Как ты делаешь это?

Я видел много способов сделать это, например:

class Main 
{ 
    public static void main(String[] args) 
    { 
    new Main(); 
    } 
} 

и некоторые, как:

class Main { 

    public static void main(String[] args) { 

    GetOpt.parse(args); 

    // Decide what to do based on the arguments passed 
    Database.initialize(); 
    MyAwesomeLogicManager.initialize(); 
    // And main waits for all others to end or shutdown signal to kill all threads. 
    } 
} 

Что следует и не следует делать в main()? Или нет серебряных пуль?

Спасибо за то же время!

Answer 1

На моем взгляде, «главный» в значительном проекте должны содержать около 3 вызовов функций:

• Вызова функции инициализации, которая устанавливает все необходимые настройки, настройку и т.д. для приложения.
• Запуск главного «контроллера» приложения
• Ожидание завершения основного контроллера, а затем вызов функции «Прекращение», которая очищает все, что необходимо очистить в «главном» (хотя контроллер будет иметь позаботился о большей части очистки уже).

Любое значительное приложение будет разделено на куски функциональности, обычно с некоторой иерархией. Основной контроллер может иметь несколько дочерних контроллеров для определенных функций.

Выполнение этого способа облегчает поиск конкретных функций, а разделение проблем - лучше.

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

Answer 2

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

В вашем примере я бы не создал метод Main(), но поместил его в исходный.

Answer 3

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

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

Answer 4

Дизайн вашей программы будет определять форму вашего «основного».

Имея «правило», в котором говорится, что ваша главная функция должна быть, - ИМХО - это не-смысл.

Answer 5

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

Это все о читаемости код. Может ли кто-то еще, кто никогда не видел вашу программу, прежде чем наткнуться на нее, и сначала получить хорошее обобщенное представление о том, что он делает?

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

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

Разбивайте свой код так, чтобы его можно было обслуживать внешним источником.

Причина небеса знает, когда дело доходит до этого, если кто-то -else- может исправить ошибку, это все лучше =)

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

Answer 6

код в главной функции:

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

Поэтому код в главной функции:

• Должно быть так просто, что вы счастливы только с функциональной/системных тестов.
• Должен нести ответственность за настройку шаровой качки для зависимостей, используемых всем вашим другим кодом (т. Е. Основной действует как фабрика uber, которая создает ваше приложение).
• Должны делать только то, что особенно важно для настройки вашего приложения (т. Е. Ничего, что может проверить код теста или демоверсия).

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

Собственно, некоторые из того, что я говорю выше, являются специфическими для C++. Конечно, основные методы Java могут быть вызваны тестовым кодом или вариантами приложений. Но они по-прежнему не принимают объекты в качестве параметров, а только аргументы командной строки, поэтому степень, в которой они могут быть изолированы под тестом, или вести себя хорошо с точки зрения повторного использования, довольно низка. Я думаю, вы могли бы передать имена классов для их создания и использования для создания остальной части приложения.

[Изменить: кто-то удалил теги «C++, Java» из этого вопроса. Итак: то, что я говорю выше, является специфичным для C++ и Java.Другие языки могут относиться к основным таким образом, который не является особо особенным, и в этом случае не может быть особых причин, чтобы вы его рассматривали специально.]

Answer 7

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

Но теперь давайте подумаем об этом через закон модульности parnas: «каждый модуль скрывает секрет, и этот секрет - это то, что может измениться». «Секрет» модуля, который изначально называется, - это детали взаимодействия процесса с операционной системой: такие вещи, как получение аргументов и обработка неправильных окончаний. В Python, это приводит к чему-то вроде этого:

def main(args=None): 
    #argument processing 
    #construct instances of your top level objects 
    #do stuff 

if __name__ == "__main__": 
    try: 
     main(Sys.Argv) 
    except: # everything 
     # clean up as much as you can 
    else: 
     # normal cleanup, no exceptions 

Дело здесь в том, что вы получите все из окружающей среды вы можете, а затем вызвать функцию Main(); вы поймаете все неперехваченные исключения, и вы делаете что-то умное с ними, прежде чем программа умрет.

Answer 8

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

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