如何以OOP方式编写main()？

发布于 2024-07-08 21:51:54 字数 686 浏览 9 评论 0原文

当我第一次开始编程时，我将所有内容都写在 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() 中应该做什么和不应该做什么？还是没有灵丹妙药？

谢谢你的时间！

原文

When I first started programming, I wrote everything in main. But as I learned, I tried to do as little as possible in my main() methods.

But where do you decide to give the other Class/Method the responsibility to take over the program from main()? How do you do it?

I've seen many ways of doing it, like this:

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

and some like:

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.
  }
}

What should and should not be done in main()? Or are there no silver bullets?

Thanks for the time!

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

执笔绘流年 2024-07-15 21:51:55

看，“主要”方法的内容和形式非常依赖于语言和环境。在 Java 中，每个类都可以有一个 public static void main() 方法，因此拥有多个方法是完全可行的。

但现在，让我们通过帕纳斯模块化定律来思考这个问题：“每个模块都隐藏着一个秘密，而这个秘密是可以改变的。” 最初调用的模块的“秘密”是进程与操作系统接口的细节：诸如获取参数和处理不规则终止之类的事情。在 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() 函数；您捕获所有未捕获的异常，并在程序终止之前对它们执行一些智能操作。

Look, the content and form of the "main" method is very language and environment dependent. In Java, every class can have a public static void main() method, so it's entirely feasible to have more than one.

But now, let's think about this via parnas's law of modularization: "every module conceals a secret, and that secret is something that can change." The "secret" of the module that is called initially is the details of interfacing the process with the operating system: things like getting the arguments and handling irregular terminations. In Python, this leads to something like this:

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

The point here being that you get everything from the environment you can, then call the main() function; you catch all uncaught exceptions and you do something intelligent with them before the program dies.

回复收藏 0 原文