जावा मुख्य विधि स्थिर क्यों है?

Question

जावा मुख्य () विधि की विधि हस्ताक्षर है:

public static void main(String[] args){
    ...
}

क्या इस विधि के स्थिर होने का कोई कारण है?

Comments

इस मामले में, हमें विधि हस्ताक्षर नहीं कहना चाहिए , क्योंकि यह शब्द केवल विधि के नाम और इसके मापदंडों को संदर्भित करता है

— एंड्रयू टोबिल्को

जावा को जानबूझकर सी प्रोग्रामर से परिचित होने के लिए डिज़ाइन किया गया है। यह C कन्वेंशन के बहुत करीब है।

— थोरबजोरन रेव एंडरसन

Answer 1

विधि स्थिर है क्योंकि अन्यथा अस्पष्टता होगी: किस निर्माता को बुलाया जाना चाहिए? खासकर यदि आपकी कक्षा इस तरह दिखती है:

public class JavaClass{
  protected JavaClass(int x){}
  public void main(String[] args){
  }
}

क्या जेवीएम को बुलाना चाहिए new JavaClass(int)? इसके लिए क्या करना चाहिए x?

यदि नहीं, तो क्या जेवीएम को JavaClassबिना किसी निर्माता विधि के तुरंत चलना चाहिए ? मुझे लगता है कि ऐसा नहीं होना चाहिए, क्योंकि यह आपकी पूरी कक्षा को विशेष रूप से प्रभावित करेगा - कभी-कभी आपके पास एक ऐसा उदाहरण होता है जिसे आरंभीकृत नहीं किया जाता है, और आपको इसे हर विधि में जांचना होगा जिसे कॉल किया जा सकता है।

JVM को प्रवेश बिंदु कहे जाने से पहले किसी वर्ग को तत्काल भेजना होगा, इसके लिए बहुत सारे किनारे मामले और अस्पष्टताएं हैं। इसीलिए mainस्थिर है।

मुझे पता नहीं क्यों mainहमेशा चिह्नित किया जाता publicहै।

Comments

एक इंटरफ़ेस को लागू करने से तात्कालिकता की समस्या हल नहीं होती है।

— जैकब क्राल

मुझे व्यक्तिगत रूप से पसंद है कि public static void mainएक प्रवेश बिंदु के एक मार्कर के रूप में कार्य करता है - एक सार्वजनिक पैरामीटर रहित निर्माता चिल्लाता नहीं है "यह शायद एक प्रवेश बिंदु है!" उसी तरह से।

— जैकब क्रॉल

@EdwinDalorzo - प्रवेश बिंदु वर्ग को तत्काल करने के लिए मजबूर करने से क्या हासिल होगा? एक स्थिर विधि को कॉल करने से कक्षा पर कम से कम बोझ पड़ता है। अगर यह आपके डिजाइन के लिए अधिक समझ में आता है, तो यह तुरंत ही मुक्त करने के लिए स्वतंत्र है।

— डेविड हर्कनेस

"किस निर्माता को बुलाया जाना चाहिए?" कैसे यह भी एक समस्या है? निर्णय के लिए वही "समस्या" मौजूद है जिसे mainकॉल करना है। अजीब तरह से (आपके लिए), जेवीएम इसे ठीक करता है।

— कोनराड रूडोल्फ

मुख्य विधि हमेशा सार्वजनिक होती है क्योंकि इसे रनटाइम इंजन, जेवीएम द्वारा एक्सेस किया जाना होता है।

— gmm

Answer 2

यह सिर्फ कन्वेंशन है। वास्तव में, यहां तक ​​कि मुख्य नाम (), और पारित किए गए तर्क विशुद्ध रूप से सम्मेलन हैं।

जब आप java.exe (या विंडोज पर javaw.exe) चलाते हैं, तो वास्तव में क्या हो रहा है जावा नेटिव इंटरफ़ेस (JNI) कॉल की एक जोड़ी है। ये कॉल DLL को लोड करते हैं जो वास्तव में JVM है (यह सही है - java.exe JVM नहीं है)। जेएनआई वह उपकरण है जिसका उपयोग हम तब करते हैं जब हमें वर्चुअल मशीन की दुनिया, और सी, सी ++, आदि की दुनिया को पुल करना होता है ... रिवर्स भी सच है - यह वास्तव में संभव नहीं है (कम से कम मेरी जानकारी के लिए) JVI का उपयोग किए बिना JVM चल रहा है।

मूल रूप से, java.exe एक सुपर सरल सी एप्लिकेशन है जो कमांड लाइन को पार्स करता है, उन तर्कों को रखने के लिए जेवीएम में एक नया स्ट्रिंग ऐरे बनाता है, वर्ग नाम जिसे आपने मुख्य () के रूप में निर्दिष्ट किया है, जेएनएम कॉल का उपयोग करता है। मुख्य () विधि ही, फिर मुख्य () विधि को आमंत्रित करता है, एक पैरामीटर के रूप में नए बनाए गए स्ट्रिंग सरणी में गुजर रहा है। यह बहुत पसंद है, जब आप जावा से प्रतिबिंब का उपयोग करते हैं, तो यह बहुत पसंद होता है - यह सिर्फ इसके बजाय भ्रमित नाम फ़ंक्शन का उपयोग करता है।

आपके लिए java.exe (स्रोत JDK के साथ वितरित किया गया है) का अपना संस्करण लिखना आपके लिए पूरी तरह से कानूनी होगा और यह पूरी तरह से अलग कुछ करेगा। वास्तव में, यह वास्तव में हम अपने सभी जावा-आधारित ऐप के साथ करते हैं।

हमारे प्रत्येक जावा ऐप का अपना लांचर है। हम मुख्य रूप से ऐसा करते हैं इसलिए हमें अपना स्वयं का आइकन और प्रक्रिया का नाम मिलता है, लेकिन यह अन्य स्थितियों में काम आया है जहां हम नियमित रूप से मुख्य के अलावा कुछ करना चाहते हैं () कॉल जा रही चीजों को प्राप्त करने के लिए (उदाहरण के लिए, एक मामले में हम कर रहे हैं COM इंटरऑपरेबिलिटी, और हम वास्तव में एक स्ट्रिंग एरे के बजाय एक COM हैंडल को मुख्य () में पास करते हैं।

तो, लंबी और छोटी: यह स्थिर है कारण है b / c कि सुविधाजनक है। इसे 'मुख्य' कहने का कारण यह है कि यह कुछ होना था, और मुख्य () वही है जो उन्होंने सी के पुराने दिनों में किया था (और उन दिनों में, फ़ंक्शन का नाम महत्वपूर्ण था )। मुझे लगता है कि java.exe आपको सिर्फ क्लास (java com.mycompany.Foo.someSpecialMain) के बजाय पूरी तरह से योग्य मुख्य विधि का नाम निर्दिष्ट करने की अनुमति दे सकता है - लेकिन यह सिर्फ IDEs को ऑटो-डिटेक्ट करने के लिए कठिन बनाता है ' एक परियोजना में प्रशंसनीय कक्षाएं।

Comments

+1: बहुत आकर्षक (विशेष रूप से एक रिवाज लिखने के बारे में हिस्सा java.exe)

— एडम पेन्नटर

दिलचस्प है, मैं "यह सिर्फ सम्मेलन है।" उत्तर का हिस्सा। ओपी का प्राथमिक प्रश्न घोषणा में स्थैतिक होने का कारण था। मुझे नहीं लगता staticकि main()घोषणा पत्र सिर्फ सम्मेलन के लिए है। तथ्य यह है कि यह `मुख्य () है और कुछ और नहीं बल्कि संभव है।

— जारेड

@ दाविद तो यह किया। मैं वास्तव में मूल रूप से शामिल लोगों में से एक से एक उत्तर को प्राथमिकता देता था - लेकिन यह एक बहुत दूर की गोली थी। अन्य अधिकांश उत्तर दुर्भाग्य से तदर्थ तर्क में एक अभ्यास है। यह एक काफी दिलचस्प विवरण देता है, इसके अलावा विनम्रता गलत तकनीकी विवरण का आविष्कार नहीं करने के लिए दूर (शायद) गैर-तकनीकी कारण है।

— कोनराड रुडोल्फ

@ जारेड - उन्हें एक सार्वजनिक नो-आर्ग कंस्ट्रक्टर की आवश्यकता हो सकती है और mainगैर-स्थिर और अभी भी भाषा की सीमा के भीतर फिट है। डिजाइनरों से सुनने के बिना, हम सिर्फ असहमत होने के लिए सहमत होंगे। :)

— डेविड हर्कनेस

@BenVoigt आप jvm dll प्राप्त करने के लिए LoadLibrary () को कॉल करते हैं। फिर आप getprocaddress ("JNI_CreateJavaVM") को कॉल करते हैं, फिर आप JNI_CreateJavaVM फ़ंक्शन ( डॉक्स .oracle.com/javase/1.4.2.docs/guide/jni/spec/… ) को आमंत्रित करते हैं । वीएम लोड होने के बाद आप मानक वर्ग को खोजने के लिए मानक जेएनआई कॉल का उपयोग करते हैं, स्थैतिक मुख्य विधि को लोड करते हैं और इसे लागू करते हैं। वहाँ गलत व्याख्या के लिए बहुत जगह नहीं है। जेएनआई पूरी तरह से है कि आप वीएम को कैसे लोड करते हैं। आपको केवल क्लाइंट साइड JNI लिखने के लिए उपयोग किया जा सकता है देशी कीवर्ड, javah -jni, आदि का उपयोग करके ... लेकिन यह JNI का केवल आधा हिस्सा है।

— केविन डे

Answer 3

main()में विधि C++, C#और Javaस्थिर हैं
क्योंकि वे तो क्रम इंजन द्वारा लागू किया जा सकता है बिना शरीर में किसी भी वस्तुओं तो कोड का दृष्टांत के होने main()बाकी करेंगे।

Comments

ठीक है, लेकिन रनटाइम क्लास के एक ऑब्जेक्ट को तुरंत नहीं कर सकता है? और फिर मुख्य विधि को बुलाओ? क्यों?

— आंद्रेई रोनेया

जेवीएम को पता होगा कि किस कंस्ट्रक्टर को कॉल करना है, अगर आपके मुख्य वर्ग ने कंस्ट्रक्टरों को ओवरलोड किया है? यह किन मापदंडों से गुजरेगा?

— याकूब क्राल

@ नोहा जब आप कहते हैं कि मूल कक्षा का मतलब है कि मुख्य विधि से युक्त वर्ग क्या है? क्योंकि यदि ऐसा है, तो "मूल वर्ग" शब्द यहाँ भ्रमित कर रहा है, और अन्यथा मुझे इससे कोई मतलब नहीं होगा। इसके अलावा, यदि हम सम्मेलन का उपयोग करते हैं, तो सम्मेलन public static void main...क्यों नहीं हो सकता है कि आवेदन प्रविष्टि बिंदु वर्ग में सार्वजनिक डिफ़ॉल्ट निर्माता होना चाहिए?

— एडविन डेलोरजो

@ जैकब जेवीएम को कैसे पता चलेगा कि किसने static void mainकॉल करने के लिए ओवरलोड किया था? कोईबातनही।

— कोनराड रुडोल्फ

@ नम्रता: हाँ, तुम कुछ याद कर रहे हो। यह सिर्फ सच नहीं है कि "स्थैतिक विधि गैर-स्थैतिक विधि का संदर्भ नहीं दे सकती है"। सही कथन है: "किसी भी गैर-स्थिर पद्धति का उपयोग करते समय प्रत्येक स्थिर विधि को एक वस्तु प्रदान करनी चाहिए"। और देखो, staticइस तरह की वस्तु बनाने के लिए mainअक्सर तरीकों का उपयोग newकिया जाता है।

— बेन Voigt

Answer 4

सार्वजनिक स्थैतिक शून्य मुख्य (स्ट्रिंग [] args) क्यों?

इस तरह से जावा लैंग्वेज को डिज़ाइन किया गया है और जावा वर्चुअल मशीन को डिज़ाइन और लिखा गया है।

ओरेकल जावा लैंग्वेज स्पेसिफिकेशन

अध्याय 12 निष्पादन की जाँच करें - धारा 12.1.4 Test.main शामिल करें :

अंत में, क्लास टेस्ट (जिसके दौरान अन्य परिणामी लोडिंग, लिंकिंग, और इनिशियलाइज़िंग हो सकता है) के लिए इनिशियलाइज़ेशन पूरा होने के बाद, टेस्ट का मुख्य तरीका लागू किया जाता है।

विधि मुख्य को सार्वजनिक, स्थिर और शून्य घोषित किया जाना चाहिए। इसे एकल तर्क को स्वीकार करना चाहिए जो कि एक सरणी है। इस विधि को भी घोषित किया जा सकता है

public static void main(String[] args)

या

public static void main(String... args)

ओरेकल जावा वर्चुअल मशीन विशिष्टता

की जाँच करें अध्याय 2 जावा प्रोग्रामिंग भाषा अवधारणाओं - धारा 2.17 निष्पादन :

जावा वर्चुअल मशीन कुछ निर्दिष्ट वर्ग की मुख्य विधि को लागू करके और इसे एक ही तर्क से पारित करना शुरू करती है, जो कि एक सरणी है। यह निर्दिष्ट वर्ग को लोड किया जाता है (§2.17.2), अन्य प्रकार से जुड़ा हुआ (.12.17.3) जो इसे उपयोग करता है, और आरंभीकृत (§2.17.4)। विधि मुख्य को सार्वजनिक, स्थिर और शून्य घोषित किया जाना चाहिए।

Oracle OpenJDK स्रोत

स्रोत जार डाउनलोड करें और निकालें और देखें कि JVM कैसे लिखा जाता है, देखें ../launcher/java.c, जिसमें कमांड के पीछे मूल C कोड है java [-options] class [args...]:

/*
 * Get the application's main class.
 * ... ...
 */
if (jarfile != 0) {
    mainClassName = GetMainClassName(env, jarfile);

... ...

    mainClass = LoadClass(env, classname);
    if(mainClass == NULL) { /* exception occured */

... ...

/* Get the application's main method */
mainID = (*env)->GetStaticMethodID(env, mainClass, "main",
                                   "([Ljava/lang/String;)V");

... ...

{    /* Make sure the main method is public */
    jint mods;
    jmethodID mid;
    jobject obj = (*env)->ToReflectedMethod(env, mainClass,
                                            mainID, JNI_TRUE);

... ...

/* Build argument array */
mainArgs = NewPlatformStringArray(env, argv, argc);
if (mainArgs == NULL) {
    ReportExceptionDescription(env);
    goto leave;
}

/* Invoke main method. */
(*env)->CallStaticVoidMethod(env, mainClass, mainID, mainArgs);

... ...

Comments

यहाँ समस्या यह है कि यह वास्तव में अपने मूल रूप में प्रश्न का बहुत अच्छा उत्तर है, जिसमें बहुत सारे संदर्भ (+1) हैं। हालाँकि, मैं रचनाकार या उदाहरण विधि के बजाय एक स्थैतिक विधि को प्रविष्टि बिंदु बनाने के डिज़ाइन निर्णय के बारे में सीखना पसंद करूँगा ।

— कोनराड रूडोल्फ

@KonradRudolph, भाषा और JVM विनिर्देशन डिज़ाइन से संबंधित प्रश्नों के लिए, शायद आप Oracle से मूल स्रोत से संपर्क करने का प्रयास कर सकते हैं और देखें कि क्या आपको कोई सकारात्मक प्रतिक्रिया मिल सकती है।

— yorkw

सामान्यतया जब कोई विधि परिणाम संगणना केवल उसके मापदंडों पर निर्भर करती है, ताकि वह वस्तु उदाहरण आंतरिक स्थिति पर निर्भर न हो, तो वह स्थिर हो सकती है। और इसे कोड स्थिरता / पुनः प्रयोज्य के लिए स्थिर के रूप में सेट करने की सिफारिश की जाती है। यदि विधि mainस्थिर नहीं थी, तो इसका मतलब है कि कक्षा का उदाहरण राज्य को ज्ञात होना चाहिए और इसे परिभाषित करना अधिक जटिल है, जैसे कि किस निर्माता को पहले उपयोग करना है।

— यवेस मार्टिन

@KonradRudolph दिलचस्प है, ओक (जावा के पूर्ववर्ती) को पहले से ही एक समान प्रोटोटाइप के लिए मुख्य विधि की आवश्यकता थी: public static void main(String arguments[])- संदर्भ: ओक 0.2 कल्पना ।

— जूल

@ यह हो सकता है। अगर दूसरे डिजाइन से समझ में आता है तो इसकी जरूरत नहीं है। मैं यहाँ टिप्पणी में कुछ अच्छे तर्क सुना है लेकिन मैं अभी भी लगता है कि एक प्रक्रिया बहुत ज्यादा एक धागा (ऐसा लगता है कि प्रभावी ढंग से है है ), और जावा में एक धागा आमतौर पर का एक उदाहरण के रूप में प्रस्तुत किया जाता है Runnable। पूरी प्रक्रिया का उसी तरह से प्रतिनिधित्व करना (अर्थात Runnable.Runप्रवेश बिंदु के रूप में) निश्चित रूप से जावा में समझ में आता है। बेशक, Runnableअपने आप में एक डिजाइन दोष है, इस तथ्य के कारण कि जावा में अनाम तरीके (अभी तक) नहीं हैं। लेकिन जब से यह पहले से ही है ...

— कोनराड रूडोल्फ

Answer 5

चलो बस दिखावा करते हैं, कि staticआवेदन प्रविष्टि बिंदु के रूप में आवश्यक नहीं होगा।

एक आवेदन वर्ग तो इस तरह दिखेगा:

class MyApplication {
    public MyApplication(){
        // Some init code here
    }
    public void main(String[] args){
        // real application code here
    }
}

कंस्ट्रक्टर कोड और mainविधि के बीच अंतर आवश्यक है क्योंकि OO बोलते हैं कि एक कंस्ट्रक्टर केवल यह सुनिश्चित करेगा, कि एक उदाहरण ठीक से आरम्भ किया गया है। आरंभीकरण के बाद, उदाहरण का उपयोग इच्छित "सेवा" के लिए किया जा सकता है। कंस्ट्रक्टर में पूरा एप्लीकेशन कोड डालने से वह खराब हो जाएगा।

तो यह दृष्टिकोण आवेदन पर तीन अलग-अलग अनुबंधों को बाध्य करेगा :

• वहाँ चाहिए एक डिफ़ॉल्ट निर्माता हो। अन्यथा, जेवीएम को पता नहीं होगा कि किस निर्माता को कॉल करना है और कौन से पैरामीटर प्रदान किए जाने चाहिए।
• वहाँ चाहिए एक हो mainविधि ¹ । ठीक है, यह आश्चर्य की बात नहीं है।
• कक्षा नहीं होनी चाहिए abstract। अन्यथा, JVM इसे तुरंत नहीं कर सकता था।

staticदूसरी ओर दृष्टिकोण केवल आवश्यकता है एक अनुबंध:

• एक mainविधि ¹ होनी चाहिए ।

यहां न तो abstractकई कंस्ट्रक्टर मायने रखते हैं।

चूंकि जावा को उपयोगकर्ता के लिए एक सरल भाषा होने के लिए डिज़ाइन किया गया था, इसलिए यह आश्चर्यजनक नहीं है कि आवेदन प्रविष्टि बिंदु को एक अनुबंध का उपयोग करके सरल तरीके से डिज़ाइन किया गया है और तीन स्वतंत्र और भंगुर अनुबंधों का उपयोग करके जटिल तरीके से नहीं ।

कृपया ध्यान दें: यह तर्क जेवीएम के अंदर या जेआरई के अंदर सरलता के बारे में नहीं है । यह तर्क उपयोगकर्ता के लिए सरलता के बारे में है ।

---

¹ यहाँ पूर्ण हस्ताक्षर केवल एक अनुबंध के रूप में गिना जाता है।

Comments

वास्तव में, आवश्यकताओं और अधिक जटिल हैं: वहाँ एक होना चाहिए mainविधि है जो है public, staticऔर हस्ताक्षर हैं void main(String[])। मैं इस बात से सहमत हूं कि, यदि विधि एक उदाहरण विधि होती, तो JRE थोड़ा होता और काम होता लेकिन जिस तरह का काम होता है, वैसा ही होता और जटिलता बहुत अधिक नहीं होती (पिछले उत्तर की टिप्पणियों में चर्चा देखें)। मुझे विश्वास नहीं है कि यह अंतर एंट्री पॉइंट को स्थिर बनाने के निर्णय के लिए है, विशेष रूप से क्योंकि इंस्टेंस विधि के समाधान के लिए आवश्यक तरीके मौजूद हैं, और आसानी से उपयोग करने योग्य हैं।

— कोनराड रूडोल्फ

@KonradRudolph: मेरी बात उस काम के बारे में नहीं है जो JRE को करना होगा। मेरी बात भाषा के प्रत्येक उपयोगकर्ता को अधिक अनुबंधों का पालन करने के लिए मजबूर करने के बारे में है। इस अर्थ में एक static public main(String[])विधि एक हस्ताक्षर है और इसलिए एक अनुबंध है। अन्यथा तीन स्वतंत्र अनुबंधों का पालन किया जाना चाहिए।

— एएच

आह। मैं अब भी असहमत हूं कि इससे कोई फर्क नहीं पड़ता। प्रवेश बिंदु कक्षाएं अच्छी तरह से लागू हो सकती हैं Runnable। स्पष्ट रूप से, जावा डेवलपर्स से हर समय उस अनुबंध का पालन करने की अपेक्षा करता है, तो आवेदन प्रविष्टि बिंदु के लिए बहुत अधिक क्यों होना चाहिए? इसका कोई अर्थ नही बन रहा है।

— कोनराड रुडोल्फ

@KonradRudolph: कोई विरोधाभास नहीं है: एक मामले में सिस्टम उपयोगकर्ता पर तीन अनुबंधों को बाध्य करेगा। अनुबंध जो संदिग्ध हैं, जो संकलक के माध्यम से जांच योग्य नहीं हैं और जो उपयोगकर्ता के दृष्टिकोण से स्वतंत्र हैं। सामान्य Threadऔर Runnableमामले में उपयोगकर्ता से कुछ भी छिपा नहीं है, वह स्पष्ट रूप से देख सकता है कि क्या चल रहा है और उसके पास केवल लागू करने के लिए परिवर्तन है उन अनुबंधों जो उसे सूट करते हैं - वह नियंत्रण में है, सिस्टम नहीं।

— एएच

यह यहां सबसे अच्छा जवाब है। यह शर्म की बात है कि कई उपयोगकर्ता केवल पृष्ठ पर शीर्ष 2 या 3 उत्तर पढ़ेंगे; और यह जल्द ही वहां पहुंचने की संभावना नहीं है। यह एक निर्माता के महत्वपूर्ण बिंदु का केवल उल्लेख करने के लिए करता है - और इसलिए यह उस शैली में कोड करने के लिए कोई मतलब नहीं है जहां निर्माणकर्ता पूरे आवेदन को चलाता है।

— दाऊद इब्न करीम

Answer 6

यदि यह नहीं था, तो एक से अधिक होने पर किस निर्माणकर्ता का उपयोग किया जाना चाहिए?

जावा लैंग्वेज स्पेसिफिकेशन में उपलब्ध जावा प्रोग्राम्स के इनिशियलाइजेशन और एक्जीक्यूशन पर अधिक जानकारी है ।

Answer 7

मुख्य विधि को कहा जाता है, इससे पहले कि कोई भी वस्तु त्वरित न हो। स्टैटिक कीवर्ड होने का मतलब है कि पहले कोई ऑब्जेक्ट बनाए बिना विधि को कॉल किया जा सकता है।

Comments

गलत। या कम से कम बहुत अनिश्चित है। सार्वजनिक वर्ग मुख्य {स्थिर वस्तु वस्तु = नई वस्तु () {{System.out.println ("ऑब्जेक्ट निर्मित"); }}; सार्वजनिक स्थैतिक शून्य मुख्य (स्ट्रिंग [] आर्ग्स) {System.out.println ("मुख्य"); }}

— एलजेन्सो

निष्पक्ष टिप्पणी। तकनीकी रूप से, मुझे यह कहना चाहिए था कि मुख्य पद्धति को कॉल करने से पहले, मुख्य विधि वाले वर्ग को तुरंत नहीं किया जाता है।

— ब्लैकवैप

Answer 8

क्योंकि अन्यथा, इसे निष्पादित किए जाने वाले ऑब्जेक्ट के उदाहरण की आवश्यकता होगी। लेकिन इसे पहले ऑब्जेक्ट का निर्माण किए बिना, खरोंच से बुलाया जाना चाहिए, क्योंकि यह आमतौर पर मुख्य () फ़ंक्शन (बूटस्ट्रैप) का कार्य होता है, तर्कों को पार्स करने और ऑब्जेक्ट का निर्माण करने के लिए, आमतौर पर इन तर्कों / प्रोग्राम मापदंडों का उपयोग करके।

Answer 9

मुझे इन बातों को बहुत सरल तरीके से समझाएं:

public static void main(String args[])

एप्लेट्स को छोड़कर सभी जावा एप्लिकेशन, उनके निष्पादन को शुरू करते हैं main() ।

कीवर्ड publicएक एक्सेस मोडिफायर है जो सदस्य को क्लास के बाहर से कॉल करने की अनुमति देता है।

static उपयोग किया जाता है क्योंकि यह अनुमति देता है main() उस वर्ग के किसी विशेष उदाहरण को तत्काल किए बिना कॉल करने की है।

voidइंगित करता है कि main()कोई मूल्य वापस नहीं करता है।

Answer 10

का अर्थ क्या है public static void main(String args[])?

1. public एक एक्सेस स्पेसियर है जिसका अर्थ है कि कोई भी इसे JVM (जावा वर्चुअल मशीन) तक एक्सेस / इनवोक कर सकता है।

2. staticmain()वर्ग के किसी ऑब्जेक्ट को बनाए जाने से पहले कॉल करने की अनुमति देता है। यह neccesary है क्योंकि main()JVM द्वारा किसी भी वस्तु को बनाने से पहले बुलाया जाता है। चूंकि यह स्थिर है इसलिए इसे कक्षा के माध्यम से सीधे लागू किया जा सकता है।

   class demo {    
       private int length;
       private static int breadth;
       void output(){
           length=5;
           System.out.println(length);
       }
   
       static void staticOutput(){
           breadth=10; 
           System.out.println(breadth);
       }
   
       public static  void main(String args[]){
           demo d1=new demo();
           d1.output(); // Note here output() function is not static so here
           // we need to create object
           staticOutput(); // Note here staticOutput() function is  static so here
           // we needn't to create object Similar is the case with main
           /* Although:
           demo.staticOutput();  Works fine
           d1.staticOutput();  Works fine */
       }
   }

   इसी तरह, हम उपयोगकर्ता परिभाषित तरीकों के लिए कुछ समय स्थिर का उपयोग करते हैं ताकि हमें ऑब्जेक्ट बनाने की आवश्यकता न हो।

3. voidइंगित करता है कि main()घोषित की जा रही विधि एक मान नहीं लौटाती है।

4. String[] argsmain()विधि में एकमात्र पैरामीटर निर्दिष्ट करता है ।

   args- एक पैरामीटर जिसमें वर्ग प्रकार की वस्तुओं की एक सरणी होती है String।

Answer 11

ऐप्पल, मिडलेट्स, सर्वलेट्स और विभिन्न प्रकार के बीन्स का निर्माण किया जाता है और फिर उन पर जीवनचक्र के तरीकों का आह्वान किया जाता है। मुख्य को शामिल करना वह सब है जो कभी मुख्य वर्ग के लिए किया जाता है, इसलिए किसी राज्य को किसी वस्तु में रखने की आवश्यकता नहीं होती है जिसे कई बार कहा जाता है। किसी अन्य वर्ग (हालांकि एक महान विचार नहीं) पर मुख्य पिन करना काफी सामान्य है, जो मुख्य वस्तु बनाने के लिए कक्षा का उपयोग करने के तरीके में मिलेगा।

Answer 12

यह सिर्फ एक सम्मेलन है, लेकिन शायद विकल्प की तुलना में अधिक सुविधाजनक है। एक स्थैतिक मुख्य के साथ, आपको जावा प्रोग्राम को लागू करने के लिए पता होना चाहिए कि एक वर्ग का नाम और स्थान क्या है। यदि यह स्थिर नहीं थे, तो आपको यह भी जानना होगा कि उस वर्ग को कैसे त्वरित किया जाए, या यह आवश्यक है कि कक्षा में एक खाली कंस्ट्रक्टर है।

Comments

यह एक सम्मेलन नहीं है; यह भाषा विनिर्देश का हिस्सा है; रनटाइम एक मान्य एंट्री पॉइंट के रूप में एक स्थिर मुख्य विधि के बिना एक वर्ग को मान्यता नहीं देगा।

— रॉब

भाषा कल्पना ही सम्मेलन का अनुसरण करती है। स्थैतिक मुख्य की आवश्यकता के लिए जावा डिजाइनरों की कोई वास्तविक आवश्यकता नहीं है। हालांकि, जैसा कि लोगन बताते हैं, विकल्प अधिक जटिल हैं।

— डेविड अर्नो

@DavidArno यह कहना अधिक समझ में आता है कि सम्मेलन भाषा विनिर्देश का अनुसरण करता है।

— लोर्ने

Answer 13

यदि मुख्य विधि स्थिर नहीं होगी, तो आपको प्रोग्राम के बाहर से अपनी मुख्य कक्षा का एक ऑब्जेक्ट बनाने की आवश्यकता होगी। आप ऐसा कैसे करना चाहेंगे?

Answer 14

जब आप जावा वर्चुअल मशीन (JVM) को javaकमांड के साथ निष्पादित करते हैं ,

java ClassName argument1 argument2 ...

जब आप अपने आवेदन को निष्पादित करते हैं, तो आप इसके वर्ग नाम को जावा कमांड के तर्क के रूप में, ऊपर बताए अनुसार निर्दिष्ट करते हैं

जेवीएम आपके द्वारा निर्दिष्ट वर्ग की मुख्य विधि को लागू करने का प्रयास करता है

—इस बिंदु पर, कक्षा की कोई भी वस्तु नहीं बनाई गई है।

वर्ग के मुख्य बनाने के लिए JVM को mainस्थिर बनाने की घोषणा ।allowsinvokewithoutinstance

आज्ञा पर वापस लौटते हैं

ClassNameएक command-line argumentजेवीएम है जो इसे बताता है कि किस वर्ग को निष्पादित करना है। क्लासनेम के बाद, आप भी निर्दिष्ट कर सकते हैंlist of Strings कमांड लाइन तर्क के रूप में (रिक्त स्थान से अलग) कि जेवीएम आपके आवेदन को पास करेगा। -आवेदन को चलाने के लिए विकल्प (जैसे, फ़ाइल नाम) निर्दिष्ट करने के लिए कुछ दलीलों का उपयोग किया जा सकता है- यही कारण है कि String[] argsमुख्य में एक पैरामीटर कहा जाता है

संदर्भ: जावा ™ प्रोग्राम (प्रारंभिक वस्तुएँ), दसवां संस्करण

Answer 15

हाल ही में, इसी तरह के सवाल को Programmers.SE पर पोस्ट किया गया है

• जावा और सी # में एक स्थिर मुख्य विधि क्यों, एक निर्माता की बजाय?

  क्यों (विशेष रूप से) के लिए एक प्राथमिक या द्वितीयक स्रोत से एक निश्चित उत्तर की तलाश में, जावा और सी # ने अपने प्रवेश बिंदु के रूप में एक स्थिर विधि का निर्णय लिया - एक Applicationवर्ग के एक उदाहरण द्वारा एक आवेदन उदाहरण का प्रतिनिधित्व करने के बजाय , प्रवेश बिंदु के साथ उपयुक्त निर्माता?

टीएल; डीआर स्वीकृत उत्तर का हिस्सा है,

जावा में, इसका कारण public static void main(String[] args)यह है

1. गोसलिंग चाहते थे
2. सी में अनुभव किए गए किसी व्यक्ति द्वारा लिखा गया कोड (जावा में नहीं)
3. किसी के द्वारा निष्पादित करने के लिए NeWS पर पोस्टस्क्रिप्ट चल रहा था

 
C # के लिए, रीज़निंग समान रूप से बोलने के लिए समान है। भाषा डिजाइनरों ने जावा से आने वाले प्रोग्रामरों के लिए प्रोग्राम एंट्री पॉइंट सिंटैक्स को परिचित रखा । जैसा कि C # वास्तुकार एंडर्स हेजलसबर्ग इसे कहते हैं ,

... सी # के साथ हमारा दृष्टिकोण केवल जावा प्रोग्रामर के लिए एक विकल्प की पेशकश करने के लिए किया गया है ...

...

Answer 16

मुझे लगता है कि कीवर्ड 'स्टैटिक' मुख्य विधि को एक क्लास विधि बनाता है, और क्लास के तरीकों की केवल एक प्रति है और इसे सभी द्वारा साझा किया जा सकता है, और इसके अलावा, इसे संदर्भ के लिए ऑब्जेक्ट की आवश्यकता नहीं है। इसलिए जब ड्राइवर वर्ग को संकलित किया जाता है तो मुख्य विधि को लागू किया जा सकता है। (मैं जावा के वर्णमाला के स्तर पर हूं, अगर मैं गलत हूं तो क्षमा करें)

Comments

सभी तरीकों 'इसकी केवल एक प्रति है'।

— लोर्ने

Answer 17

मुख्य () स्थिर है क्योंकि; अनुप्रयोग के जीवनचक्र में उस बिंदु पर, अनुप्रयोग स्टैक प्रकृति में प्रक्रियात्मक है क्योंकि कोई वस्तु अभी तक तत्काल नहीं है।

यह एक साफ स्लेट है। आपका आवेदन इस बिंदु पर चल रहा है, यहां तक ​​कि किसी भी ऑब्जेक्ट को घोषित किए बिना भी (याद रखें, प्रक्रियात्मक और ऊ कोडिंग पैटर्न है)। आप, डेवलपर के रूप में, अपनी वस्तुओं के उदाहरणों को बनाकर और ऑब्जेक्ट को एक-उन्मुख समाधान में बदल देते हैं और उसके भीतर संकलित कोड के आधार पर।

वस्तु-उन्मुख लाखों स्पष्ट कारणों के लिए महान है। हालांकि, ऐसे दिन गए जब अधिकांश VB डेवलपर्स नियमित रूप से अपने कोड में "गोटो" जैसे कीवर्ड का उपयोग करते थे। "गोटो" VB में एक प्रक्रियात्मक कमांड है जिसे इसके OO समकक्ष द्वारा प्रतिस्थापित किया गया है: विधि मंगलाचरण।

आप स्थिर प्रविष्टि बिंदु (मुख्य) को शुद्ध स्वतंत्रता के रूप में भी देख सकते हैं। अगर जावा किसी ऑब्जेक्ट को तुरंत इंस्टेंट करने के लिए पर्याप्त था और केवल उस उदाहरण को आपको चलाने के लिए प्रस्तुत करता है, तो आपके पास प्रक्रियात्मक ऐप लिखने के लिए कोई विकल्प नहीं होगा। जैसा कि अकल्पनीय है क्योंकि यह जावा के लिए ध्वनि कर सकता है, यह संभव है कि कई परिदृश्य हैं जो प्रक्रियात्मक दृष्टिकोण के लिए कहते हैं।

यह शायद बहुत अस्पष्ट उत्तर है। याद रखें, "वर्ग" केवल अंतर-संबंधित कोड का एक संग्रह है। "इंस्टेंस" उस वर्ग की एक अलग, जीवित और सांस लेने वाली स्वायत्त पीढ़ी है।

Comments

यह गलत है। mainपहुंचने से पहले ही बहुत सी वस्तुओं का त्वरित मूल्यांकन किया जाता है। और यदि आप मुख्य वाले वर्ग में एक स्थिर रचनाकार शामिल करते हैं, जो mainइसी तरह से पहले निष्पादित हो जाता है ।

— कोनराड रूडोल्फ

Answer 18

यह सिर्फ एक सम्मेलन है। JVM निश्चित रूप से गैर-स्थैतिक मुख्य विधियों से निपट सकता है यदि यह सम्मेलन होता। आखिरकार, आप अपनी कक्षा पर एक स्टैटिक इनिशियलाइज़र को परिभाषित कर सकते हैं, और अपने मुख्य () तरीके से मिलने से पहले एक ज़िलियन ऑब्जेक्ट को तुरंत इंस्टेंट कर सकते हैं।

Answer 19

प्रोटॉयपे JLSpublic static void main(String[]) में परिभाषित एक सम्मेलन है :

विधि मुख्य को सार्वजनिक, स्थिर और शून्य घोषित किया जाना चाहिए। यह एक औपचारिक पैरामीटर (§8.4.1) निर्दिष्ट करना चाहिए जिसका घोषित प्रकार स्ट्रिंग का सरणी है।

जेवीएम विनिर्देश में 5.2 में। वर्चुअल मशीन स्टार्ट-अप हम पढ़ सकते हैं:

जावा वर्चुअल मशीन एक प्रारंभिक कक्षा बनाकर शुरू होती है, जो कि बूटस्ट्रैप क्लास लोडर (load5.3.1) का उपयोग करके, कार्यान्वयन-निर्भर तरीके से निर्दिष्ट होती है। जावा वर्चुअल मशीन तब प्रारंभिक वर्ग को जोड़ता है, इसे इनिशियलाइज़ करता है, और इनवोक करता है पब्लिक क्लास मेथड मेन (स्ट्रिंग []) को लागू करती है । इस पद्धति का आह्वान सभी को आगे बढ़ाता है। जावा वर्चुअल मशीन निर्देशों का निष्पादन मुख्य विधि का गठन अतिरिक्त कक्षाओं और इंटरफेस के लिंक (और परिणामस्वरूप निर्माण), साथ ही साथ अतिरिक्त तरीकों के आह्वान का कारण हो सकता है।

मज़ेदार बात, जेवीएम विनिर्देश में यह उल्लेख नहीं है कि मुख्य विधि को स्थिर होना है। लेकिन युक्ति यह भी कहती है कि जावा वर्चुअल मशीन 2 कदम पहले प्रदर्शन करती है:

• लिंक प्रारंभिक कक्षा ( 5.4। लिंकिंग) )
• इसे प्रारंभ करता है ( 5.5! प्रारंभिक )

किसी वर्ग या इंटरफ़ेस के प्रारंभ में इसकी कक्षा या इंटरफ़ेस आरंभीकरण विधि निष्पादित होती है।

में 2.9। विशेष तरीके :

एक वर्ग या इंटरफ़ेस आरंभीकरण विधि परिभाषित की गई है:

एक क्लास या इंटरफ़ेस में एक ही क्लास या इंटरफ़ेस इनिशियलाइज़ेशन मेथड होता है और उस तरीके को लागू करके इनिशियलाइज़ ()5.5) किया जाता है। किसी वर्ग या इंटरफ़ेस की प्रारंभिक विधि का विशेष नाम है<clinit> , कोई तर्क नहीं लेता है, और शून्य है।

और एक वर्ग या इंटरफ़ेस आरंभीकरण विधि एक उदाहरण आरंभीकरण विधि से अलग है जिसे फॉलो किया जाता है:

जावा वर्चुअल मशीन के स्तर पर, जावा प्रोग्रामिंग लैंग्वेज (JLS of8.8) में लिखा गया हर कंस्ट्रक्टर एक इनिशियल इनिशियलाइज़ेशन मेथड के रूप में दिखाई देता है जिसका विशेष नाम है <init>।

तो JVM एक वर्ग या इंटरफ़ेस इनिशियलाइज़ेशन विधि को इनिशियलाइज़ करता है न कि इंस्टेंस इनिशियलाइज़ेशन मेथड जो वास्तव में एक कंस्ट्रक्टर है। इसलिए उन्हें यह उल्लेख करने की आवश्यकता नहीं है कि मुख्य विधि को जेवीएम कल्पना में स्थिर होना है क्योंकि यह इस तथ्य से निहित है कि मुख्य विधि को कॉल करने से पहले कोई उदाहरण नहीं बनाया गया है।

Answer 20

publicकीवर्ड एक पहुँच संशोधक, जो प्रोग्रामर वर्ग के सदस्यों की दृश्यता को नियंत्रित करने की अनुमति देता है। जब एक वर्ग के सदस्य से पहले हैpublic , तो उस सदस्य को उस वर्ग के बाहर कोड द्वारा एक्सेस किया जा सकता है जिसमें यह घोषित किया गया है।

इसका विपरीत publicहै private, जो किसी सदस्य को अपनी कक्षा के बाहर परिभाषित कोड द्वारा उपयोग किए जाने से रोकता है।

इस मामले में, main()घोषित किया जाना चाहिएpublic , क्योंकि यह कार्यक्रम शुरू होने पर अपनी कक्षा के बाहर कोड द्वारा बुलाया जाना चाहिए।

कीवर्ड को वर्ग के किसी विशेष उदाहरण को तत्काल किए बिना कॉल करने की staticअनुमति देता main()है। यह तब से आवश्यक हैmain()किसी वस्तु के बनने से पहले जावा दुभाषिया द्वारा कॉल किए जाने के है।

कीवर्ड voidकेवल संकलक को बताता है जो main()मान नहीं लौटाता है।

Answer 21

किसी भी आवेदन के लिए सही प्रविष्टि बिंदु एक स्थिर विधि है। यदि जावा भाषा ने "एंट्री पॉइंट" के रूप में एक इंस्टेंस विधि का समर्थन किया है, तो रनटाइम को आंतरिक रूप से एक स्टैटिक विधि के रूप में कार्यान्वित करने की आवश्यकता होगी, जिसने इंस्टेंस विधि का अनुसरण करके ऑब्जेक्ट का एक उदाहरण निर्मित किया है।

उस रास्ते से, मैं निम्नलिखित तीन विकल्पों में से एक को चुनने के लिए औचित्य की जांच करूँगा:

1. एक static void main()हम आज देखते हैं।
2. एक void main()ताजा विधि पर निर्मित एक उदाहरण विधि ।
3. प्रवेश बिंदु के रूप में एक प्रकार के निर्माता का उपयोग करना (उदाहरण के लिए, यदि प्रविष्टि वर्ग को बुलाया गया था Program, तो निष्पादन प्रभावी रूप से शामिल होगा new Program())।

टूट - फूट:

static void main()

1. एनक्लोजिंग क्लास के स्थिर कंस्ट्रक्टर को कॉल करता है।
2. स्थैतिक विधि का आह्वान करता है main()।

void main()

1. एनक्लोजिंग क्लास के स्थिर कंस्ट्रक्टर को कॉल करता है।
2. प्रभावी ढंग से कॉल करके संलग्न वर्ग के एक उदाहरण का निर्माण करता है new ClassName()।
3. आवृत्ति विधि को कॉल करता है main()।

new ClassName()

1. एनक्लोजिंग क्लास के स्थिर कंस्ट्रक्टर को कॉल करता है।
2. वर्ग की एक आवृत्ति का निर्माण करता है (फिर इसके साथ कुछ भी नहीं करता है और केवल रिटर्न करता है)।

दलील:

मैं इस एक के लिए रिवर्स ऑर्डर में जाऊंगा।

ध्यान रखें कि जावा के डिजाइन लक्ष्यों में से एक अच्छी वस्तु-उन्मुख प्रोग्रामिंग प्रथाओं पर जोर देना (जब संभव हो) की आवश्यकता थी। इस संदर्भ में, ऑब्जेक्ट का निर्माता ऑब्जेक्ट को इनिशियलाइज़ करता है, लेकिन ऑब्जेक्ट के व्यवहार के लिए ज़िम्मेदार नहीं होना चाहिए। इसलिए, एक विनिर्देश जिसने एक प्रविष्टि बिंदु दियाnew ClassName() वह नए जावा डेवलपर्स के लिए हर एप्लिकेशन पर "आदर्श" निर्माता के डिजाइन के लिए एक अपवाद के रूप में स्थिति को भ्रमित करेगा।

main()एक उदाहरण विधि बनाने से , उपरोक्त समस्या निश्चित रूप से हल हो गई है। हालांकि, यह प्रविष्टि वर्ग के निर्माता के हस्ताक्षर के साथ-साथ main()विधि के हस्ताक्षर को सूचीबद्ध करने के लिए विनिर्देशन की आवश्यकता के द्वारा जटिलता पैदा करता है ।

सारांश में, एक को निर्दिष्ट static void main()करते हुए तरीकों में व्यवहार रखने के सिद्धांत का पालन कर कम से कम जटिलता के साथ एक विनिर्देश बनाता है । यह देखते हुए कि एक main()विधि को लागू करना कितना सरल है, जो स्वयं एक वर्ग की आवृत्ति का निर्माण करता है और एक आवृत्ति विधि कहता है, उदाहरण विधि के main()रूप में निर्दिष्ट करने का कोई वास्तविक लाभ नहीं है ।

Comments

यह सिर्फ सवाल से भीख मांग रहा है। जावा को वैसे भी एक एप्लिकेशन लोडर की आवश्यकता होती है जो कॉल करने से पहले भारी लिफ्टिंग करता है main। mainशुरुआती लोगों के लिए बहुत जटिल होने के बारे में आपका तर्क अविश्वसनीय लगता है। वास्तव में, स्थिर mainहै बहुत शुरुआती के लिए भ्रमित, मुझे शक है एक निर्माता ज्यादा होगा। आप कहते हैं, "निर्माता को वस्तु के व्यवहार के लिए जिम्मेदार नहीं होना चाहिए"। यह दिलचस्प लगता है, लेकिन मुझे यकीन नहीं है कि मैं सहमत हूँ। क्यों नहीं करता है? इससे क्या रोकता है?

— कोनराड रुडोल्फ

Answer 22

स्टैटिक - जब जेवीएम मुख्य विधि से कॉल करता है तो क्लास के लिए मौजूद कोई वस्तु नहीं होती है, इसलिए इसे क्लास से मंगाने की अनुमति देने के लिए स्टैटिक विधि होनी चाहिए।

Answer 23

मुझे नहीं पता कि क्या JVM ऑब्जेक्ट्स को इंस्टेंट करने से पहले मुख्य विधि को कॉल करता है ... लेकिन एक और अधिक शक्तिशाली कारण है कि मुख्य () विधि स्थिर है ... जब JVM वर्ग की मुख्य विधि कहता है (कहो , व्यक्ति)। इसे " Person.main () द्वारा आमंत्रित किया गया है " । आप देखते हैं, जेवीएम इसे वर्ग नाम से आमंत्रित करता है। इसीलिए मुख्य () विधि को स्थिर और सार्वजनिक माना जाता है ताकि इसे JVM द्वारा एक्सेस किया जा सके।

आशा है कि यह मदद की। अगर यह किया है, मुझे टिप्पणी करके पता है।

Answer 24

स्थैतिक तरीकों को किसी भी वस्तु की आवश्यकता नहीं होती है। यह सीधे-सीधे इतना मुख्य रन बनाता है।

Answer 25

मुख्य विधि में स्थिर कुंजी शब्द का उपयोग किया जाता है क्योंकि मुख्य पद्धति में कोई भी तात्कालिकता नहीं होती है। लेकिन वस्तु का निर्माण आह्वान के बजाय किया जाता है जिसके परिणामस्वरूप हम मुख्य विधि में स्थिर कुंजी शब्द का उपयोग करते हैं। Jvm सन्दर्भ में मेमोरी तब बनती है जब क्लास इसमें लोड होती है। और सभी स्टैटिक सदस्य उस मेमोरी में मौजूद होते हैं। यदि हम मुख्य स्टैटिक बनाते हैं तो यह मेमोरी में होगा और jvm (class.main (..)) तक पहुँचा जा सकता है इसलिए हम मुख्य विधि को कॉल कर सकते हैं।

Answer 26

जैसा कि हम यहां देख सकते हैं यह एक सम्मेलन है:

विधि को सार्वजनिक और स्थिर घोषित किया जाना चाहिए , इसे किसी भी मूल्य पर वापस नहीं लौटना चाहिए, और इसे स्ट्रिंग सरणी को एक पैरामीटर के रूप में स्वीकार करना होगा। डिफ़ॉल्ट रूप से, पहले गैर-विकल्प तर्क को लागू करने के लिए वर्ग का नाम है। एक पूरी तरह से योग्य वर्ग नाम का उपयोग किया जाना चाहिए। यदि -jar विकल्प निर्दिष्ट किया गया है, तो पहला गैर-विकल्प तर्क एक JAR संग्रह का नाम है जिसमें अनुप्रयोग के लिए क्लास और संसाधन फ़ाइलें हैं, जिसमें मुख्य-वर्ग के प्रकट हेडर द्वारा इंगित स्टार्टअप वर्ग है।

http://docs.oracle.com/javase/1.4.2/docs/tooldocs/windows/java.html#description

Comments

भाषा का नियम, आपका मतलब है।

— लोरेन

Answer 27

सार्वजनिक स्थैतिक शून्य कीवर्ड का अर्थ है कि जावा वर्चुअल मशीन (JVM) दुभाषिया, प्रोग्राम (पब्लिक) को क्लास (स्टैटिक) का उदाहरण दिए बिना प्रोग्राम शुरू करने के लिए मुख्य विधि कह सकता है, और प्रोग्राम जावा वीएम इंटरप्रेटर के लिए डेटा वापस नहीं करता है। (शून्य) जब यह समाप्त होता है।

स्रोत: अनिवार्य, भाग १, पाठ २: भवन अनुप्रयोग

Answer 28

मूल रूप से हम उन डेटा सदस्यों और सदस्य फ़ंक्शंस को स्टेटिक बनाते हैं जो किसी ऑब्जेक्ट से संबंधित कोई कार्य नहीं कर रहे हैं। और मुख्य विधि के मामले में, हम इसे एक स्टेटिक के रूप में बना रहे हैं क्योंकि इसका ऑब्जेक्ट से कोई लेना-देना नहीं है, क्योंकि मुख्य विधि हमेशा चलती है कि हम ऑब्जेक्ट बना रहे हैं या नहीं।

Answer 29

जावा में स्थिर के रूप में घोषित कोई भी विधि वर्ग के अंतर्गत आती है। फिर से किसी विशेष वर्ग की स्थैतिक विधि को कक्षा की तरह संदर्भित करके ही पहुँचा जा सकता हैClass_name.method_name();

तो एक स्थिर विधि तक पहुँचने से पहले एक वर्ग को तत्काल करने की आवश्यकता नहीं है।

तो मुख्य () पद्धति को घोषित किया जाता है staticताकि इसे उस वर्ग की वस्तु बनाए बिना पहुँचा जा सके।

चूंकि हम प्रोग्राम को उस वर्ग के नाम से सहेजते हैं, जहां मुख्य विधि मौजूद है (या जहां से प्रोग्राम को अपना निष्पादन शुरू करना चाहिए, बिना main()विधि () (उन्नत स्तर) के कक्षाओं के लिए लागू होता है । तो उपर्युक्त तरीके से:

Class_name.method_name();

मुख्य विधि तक पहुँचा जा सकता है।

संक्षिप्त में जब कार्यक्रम संकलित किया जाता है, तो वह main()विधि की खोज करता Stringहै जैसे कि तर्क: main(String args[])कक्षा में उल्लिखित (अर्थात कार्यक्रम के नाम से), और शुरुआत में चूंकि उस वर्ग को तत्काल करने की कोई गुंजाइश नहीं है, इसलिए मुख्य () विधि को स्थिर के रूप में घोषित किया गया है।

Comments

यह तब होता है जब कार्यक्रम निष्पादित होता है, संकलित नहीं।

— लोर्ने

Answer 30

से java.sun.com (वहाँ साइट पर अधिक जानकारी है):

मुख्य विधि जावा वीएम दुभाषिया को पहले नियंत्रण वर्ग का एक उदाहरण बनाए बिना कक्षा शुरू करने का एक तरीका देने के लिए स्थिर है। कार्यक्रम शुरू होने के बाद मुख्य विधि में नियंत्रण वर्ग के उदाहरण बनाए जाते हैं।

मेरी समझ हमेशा से यह रही है कि किसी भी स्थैतिक विधि की तरह मुख्य विधि को संबंधित वर्ग के उदाहरण के बिना बनाया जा सकता है, जिससे उसे प्रोग्राम में किसी अन्य चीज से पहले चलने की अनुमति मिलती है। यदि यह स्थिर नहीं था, तो आपको इसे कॉल करने से पहले किसी ऑब्जेक्ट को इंस्टेंट करना होगा - जो 'चिकन और अंडे' की समस्या पैदा करता है, क्योंकि मुख्य विधि आम तौर पर प्रोग्राम की शुरुआत में आप ऑब्जेक्ट्स को त्वरित करने के लिए उपयोग करते हैं।

Comments

लेकिन यह "कार्यक्रम में कुछ और करने से पहले" नहीं चलता है। पूरा तर्क एक गिरावट है, और क्या अधिक है, यह इसका उल्लेख करने वाला पहला उत्तर नहीं है, न ही दूसरा या तीसरा।

— कोनराड रुडोल्फ

मुझे खेद है कि मेरा उत्तर वही है जो दूसरों ने कहा है; मैंने केवल अपनी समझ का सबसे अच्छा उत्तर दिया और जो मुझे ऑनलाइन मिला, उससे। जिन परिणामों पर मैंने गौर किया है उनमें से कोई अन्य कारण नहीं है कि मुख्य विधि स्थिर क्यों है; जब तक कहीं एक गहरा छिपा हुआ नहीं है शायद यही एकमात्र उत्तर है। जावा के बारे में मेरी समझ काफी बुनियादी है, लेकिन मैंने उपरोक्त कारण (प्रोफेसरों, पाठ्य पुस्तकों आदि) से सुना है और कभी भी कोई अन्य नहीं।

— जेसी एम

@ जेसे एम आपकी टिप्पणी केवल तभी समझ में आती है जब आपने पहले अन्य उत्तरों को पढ़ने पर भी विचार नहीं किया था। जिस तरह से करने के लिए एक बहुत दूर की बात नहीं है। जैसा कि आपने खुद का उल्लेख किया है, आपकी समझ काफी बुनियादी है, इसलिए यह बहुत संभव है कि किसी और ने पहले ही सवाल का जवाब अधिक सक्षम रूप से दिया हो। और आपकी टिप्पणी आपके उत्तर को बेहतर बनाने के लिए एक युक्तिकरण लगती है। यह एक असाधारण दावा है कि आपके पास जावा पाठ्यपुस्तकें और प्रोफेसर हैं जो सोचते हैं कि आप क्या दावा करते हैं और स्पष्ट रूप से मुझे विश्वास नहीं है कि वे करते हैं। (कोई संदर्भ?)

— सिंह

@KonradRudolph शीर्ष टिप्पणियाँ बहुत उचित लगती हैं। main () का उपयोग प्रोग्राम के एंट्री पॉइंट के रूप में किया जाता है और जावा वेबसाइट पर कई संदर्भ हैं जो यह कहते हैं कि यह C / C ++ के मुख्य () फ़ंक्शन के समान है। क्योंकि जावा सभी ऑब्जेक्ट्स हैं, इसलिए ऑब्जेक्ट इंस्टेंटेशन से बचने के लिए इसे स्टैटिक होना चाहिए। स्थिर होने से यह रनवे पर JVM में लोड और निष्पादन योग्य हो जाता है। मैं सिर्फ पिछले उत्तरों को पुन: प्राप्त कर रहा हूं, लेकिन मैं सोच रहा हूं कि आप एक संतोषजनक उत्तर पर क्या विचार करेंगे। मुझे लगता है कि आपको जो सबसे अच्छा मिलेगा वह है "यह है कि वे इसे कैसे चाहते थे"। ध्यान रखें कि जावा बनाया गया था।

— trevor-e

@ जेसे स्पॉट-ऑन। यह पूरी तरह से संभव है कि यह केवल सम्मेलन का मामला है (हालांकि मुझे उम्मीद है कि ऐसा नहीं है, यह ऐसा उबाऊ जवाब होगा)। इस सवाल में मेरी मूल दिलचस्पी इसलिए थी क्योंकि मैंने सोचा था कि ऑब्जेक्ट को "रनिंग एप्लिकेशन" का प्रतिनिधित्व करने के लिए एक उचित उदाहरण का उपयोग करना, और प्रवेश बिंदु होना इस वर्ग का एक तरीका (या कंस्ट्रक्टर) होगा जो जावा के बाद से बहुत अधिक स्पष्ट डिजाइन होगा। get-जाने से उन्मुख वस्तु होने के लिए डिजाइन किया गया था, और तब से मालूम होता है अनुरूप वस्तुओं (सूत्र, के माध्यम से Runnable) जावा में करना इस डिजाइन का उपयोग करें। यहाँ (स्पष्ट) अपवाद क्यों?

— कोनराड रुडोल्फ