Как написать 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()? Или нет серебряные пули?

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

6
main-method oop procedural

8 ответов

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

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

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

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

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

7

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

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

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

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

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

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

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

17

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

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

4

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

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

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

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

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

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

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

2

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

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 (); вы ловите все необработанные исключения и делаете что-то умное с ними, прежде чем программа умрет.

2

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

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

0

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

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

0

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

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

0