Как написать main() методом ООП?

StackOverflow https://stackoverflow.com/questions/325453

  •  11-07-2019
  •  | 
  •  

Вопрос

Когда я впервые начал программировать, я все писал в main.Но когда я научился, я старался делать как можно меньше в своей жизни. 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()?Или серебряной пули не существует?

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

Это было полезно?

Решение

По моему мнению, «основной» проект большого размера должен содержать около трех вызовов функций:

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

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

Подобный подход значительно упрощает поиск конкретных функций и обеспечивает лучшее разделение задач.

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

Другие советы

Код в основной функции:

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

Поэтому код в основной функции:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Но теперь давайте подумаем об этом с помощью закона модульности Парнаса: «каждый модуль скрывает секрет, и этот секрет может измениться». & Quot; секрет " модуля, который вызывается изначально, это детали взаимодействия процесса с операционной системой: такие как получение аргументов и обработка нерегулярных завершений. В 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 (); вы перехватываете все неперехваченные исключения и делаете с ними что-то умное, прежде чем программа умрет

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

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

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

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

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

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

Лицензировано под: CC-BY-SA с атрибуция
Не связан с StackOverflow
scroll top