วิธีการหลักควรเป็นเพียงการสร้างวัตถุและการเรียกเมธอดเท่านั้น

เพื่อนของฉันบอกฉันว่าวิธีปฏิบัติที่ดีที่สุดคือคลาสที่มีmainเมธอดควรตั้งชื่อMainและมีmainเมธอดเท่านั้น นอกจากนี้mainวิธีการควรแยกวิเคราะห์อินพุตสร้างวัตถุอื่น ๆ และเรียกวิธีการอื่น ๆ Mainชั้นเรียนและmainวิธีการที่ไม่ควรจะทำอะไรก็ได้ โดยพื้นฐานสิ่งที่เขาพูดว่าคลาสที่มีmainเมธอดควรเป็นดังนี้

public class Main
{
    public static void main(String[] args)
    {
        //parse inputs
        //create other objects
        //call methods
    }
}

มันเป็นวิธีปฏิบัติที่ดีที่สุด?

ประเด็นที่เพื่อนของคุณกำลังทำอยู่ก็คือแอปพลิเคชันควรบูตด้วยวิธีหลักเท่านั้นและไม่มีอะไรเพิ่มเติม ด้วยการมีวิธีการหลักในชั้นเรียนของตัวเองคุณเพียงแค่ตอกย้ำความจริงนั้นโดยทำให้มันเป็นอิสระจากตรรกะการใช้งานใด ๆ บทบาทของวิธีการหลักคือการแยกวิเคราะห์อินพุตและเริ่มต้นแอปพลิเคชันด้วยอินพุตเหล่านั้นและอื่น ๆ ที่อาจเป็นไปได้

public static void main(String[] args){
    new Foo().start(args[0]);
}

ความคิดคือการที่คุณไม่จำเป็นต้องใช้Fooวิธีการหลักในการที่จะเริ่มต้น สิ่งนี้ช่วยให้คุณสามารถเริ่มต้นและเริ่มต้นFooในบริบทอื่นได้อย่างง่ายดายซึ่งอาจมีความหมายต่างกัน

public Foo initSomewhereElse(String arg){
    Foo f = new Foo();
    f.start(arg);
    return f;
}

เมธอด main () เป็นวิธีการเขียนโปรแกรมแบบโพรเซสซิงซึ่งเป็นจุดเริ่มต้นที่น่าเกลียด มีความพยายามในการเขียนโปรแกรมภาษาต่าง ๆ เพื่อห่อหุ้มมัน แต่ธรรมชาติของมันทำให้มันยาก (ต้องเป็นสาธารณะและไม่ขยับเขยื้อน แต่มันไม่ควรถูกเรียกจากสิ่งอื่นใดในโปรแกรมซึ่งขัดแย้งกันอย่างมาก) WPF ประสบความสำเร็จ (โดยการซ่อน main () จากคุณในส่วนลึกของแอพพลิเคชั่น WPF และมอบ "hooks" ที่สามารถกำหนดค่าได้สำหรับการประมวลผลแบบกำหนดเอง) เช่นเดียวกับ Java (ในทำนองเดียวกันสำหรับแอป Android) แต่ WinForms และประเภทอื่น ๆ แอพยังคงทำให้คุณจัดการกับ main ()

ดังนั้นผู้เชี่ยวชาญส่วนใหญ่กล่าวว่าฟังก์ชั่น LOC ของ main () ควรจะต่ำที่สุด มีวิธีหนึ่ง (ซึ่งฉันคิดว่าเป็น overkill เล็กน้อย) ซึ่งฟังก์ชัน main () มีหนึ่งบรรทัด:

public class Program
{
   private Program(string[] args)
   {
      //parse args and perform basic program setup
   }

   //Reduce the ugliness to the absolute minimum
   public static void main(string[] args)
   {
      new Program(args).Run();  
   }

   private void Run()
   {
      //kick off the driving O-O code for the app; i.e. Application.Run()
   }    
}

นี่เป็นเรื่องเล็กน้อย แต่ฉันเห็นด้วยกับหลักการพื้นฐาน main () ควรให้น้อยที่สุดเท่าที่จะเป็นไปได้เพื่อให้แอปพลิเคชันเชิงวัตถุขับเคลื่อนเหตุการณ์เข้าสู่สถานะ "พร้อม"

ในภาษาที่รองรับฟังก์ชั่นmainเป็นเพียงฟังก์ชั่นปกติดังนั้นจึงไม่มีอะไรที่คุณสามารถทำได้นอกเหนือจากสิ่งที่คุณพูด แล้วมีงี่เง่าภาษาที่ฟังก์ชั่นคูในความโปรดปรานของการมีทุกอย่างที่เป็นวัตถุซึ่งหมายความว่าเวลาที่คุณต้องการฟังก์ชั่นทุกครั้งที่คุณต้องห่อไว้ในระดับที่ไม่จำเป็น

ดีท่องเที่ยวเพียงพอ จุดที่ฉันพยายามทำคือMainไม่ได้เป็นคลาสจริงๆ แต่เป็นฟังก์ชั่นดังนั้นคุณไม่ควรทำอะไรเลยนอกจากแยกวิเคราะห์อินพุตสร้างวัตถุอื่นและเรียกวิธีอื่น ๆ เพราะนั่นคือทั้งหมดที่ฟังก์ชั่นสามารถทำได้