जावा में एक स्थिर निर्माता के लिए तर्क पारित करें?

Question

मैं एक तर्क के साथ एक स्थैतिक वर्ग शुरू करने की कोशिश कर रहा हूं, और उसके बाद उस वर्ग में कुछ और स्थिर कोड चलाता हूं।
मुझे static ब्लॉक से अवगत है, लेकिन ऐसा लगता है कि यह कोई तर्क नहीं ले सकता है।
क्या एक स्थिर निर्माता को तर्क पारित करने का कोई तरीका है?
यदि नहीं, तो तर्क का उपयोग कर स्टेटिक क्लास को आरंभ करने के लिए अनुशंसित तकनीक क्या है?

संपादित करें: मेरी समझ के लिए एक स्थिर वर्ग (, सी # में वे स्थिर कक्षाओं कहा जाता है कर रहे हैं जावा उनके लिए एक अलग अवधि है, इसके बारे में पता नहीं होने के लिए खेद) एक वर्ग जो instantiated नहीं किया जा सकता है - इसे ऑब्जेक्ट नाम के बजाए इसके वर्ग के नाम से एक्सेस किया जाता है।

जो मैं प्राप्त करने की कोशिश कर रहा हूं (बहुत सरलीकृत) एक वर्ग है जो स्ट्रिंग के रूप में एक शब्दकोश प्राप्त करता है, इसे पार करता है, और इसमें GetRandomEntry जैसे तरीकों का उपयोग किया जाता है।

public class QuestionsRepository { 
private static Map<String,String[]> easyDefinitions = new HashMap<String,String[]>(); 

//... 

static  
    { 
    // need to receive and parse dictionary here  
    } 
//... 

एक कोड स्निपेट के प्रासंगिक भागों ले रहा है कभी नहीं आसान, आशा है कि मैं बुद्धिमानी से चुना है (:

यहाँ मेरी कोड की एक सविस्तार स्निपेट
एक और विस्तार है कि प्रासंगिक हो सकता है - मैं कर रहा हूँ एसी # प्रोग्रामर, आमतौर पर। बस जावा हाल ही में सीखने शुरू कर दिया।

धन्यवाद।

Answer 1

मुझे लगता है कि आपको कुछ इनपुट के अनुसार कक्षा के स्थिर क्षेत्रों को प्रारंभ करना होगा।

class ClassToInitialize { 
    static { 
     staticField = ParamPassClass.getParameter(); 
    } 

    private static String staticField; 

    ClassToInitialize() { 
     System.out.println("This is the parameter: " + staticField); 
    } 

} 

class ParamPassClass { 
    private static String parameter; 
    static String getParameter() { 
     return parameter; 
    } 

    static void setParameter(String parameter) { 
     ParamPassClass.parameter = parameter; 
    } 
} 

class Main { 
    public static void main(String args[]) { 
     ParamPassClass.setParameter("Test param"); 
     new ClassToInitialize(); 
    } 
} 

Answer 2

जावा स्थिर कंस्ट्रक्टर्स जरूरत नहीं है। यह केवल स्थिर initializers और स्थिर initializers किसी भी तर्क नहीं लेते है। यह कक्षा को पहली बार लोड होने पर निष्पादित किया जाता है, और इसे स्वयं कॉल करने का कोई तरीका नहीं है।

आपको या तो वास्तविक वस्तुओं का उपयोग करने की आवश्यकता है, या कक्षा को कॉन्फ़िगर करने का कुछ तरीका जोड़ें (उदाहरण के लिए एक स्थिर विधि के माध्यम से)।

Answer 3

आप एक स्थिर क्वालीफायर के साथ सदस्य वर्ग का उल्लेख करना चाहिए, नहीं तो एक स्थिर वर्ग Here आप इस संदर्भ में शब्द 'स्थिर' का उपयोग करने का स्पष्टीकरण प्राप्त कर सकते हैं के रूप में कोई ऐसी बात नहीं है।

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

मुझे समझ में नहीं आया कि आप यहां एक स्थिर प्रारंभिक ब्लॉक का उल्लेख क्यों करते हैं, क्या आप कृपया थोड़ा सा स्पष्टीकरण दे सकते हैं? बारे में पता भी है कि जावा में कोई ऐसी बात के रूप में स्थिर निर्माता है रहो ....

आशा इस मदद करता है

Answer 4

आप एक स्थिर विधि public static void setUp(Arg1 arg1, Arg2 arg2...) जो आपके सभी static क्षेत्रों सेट है और यह आह्वान जब कर सकते हैं अपने कार्यक्रम शुरू होता है।

आप इस पद्धति केवल एक बार [या केवल जब आप इन क्षेत्रों रीसेट करना चाहते हैं]

Answer 5

यह तर्क स्थिर आरंभ (JLS:static initializers) को सीधे पारित करने के लिए संभव नहीं है बुलाया जाएगा सुनिश्चित करने के लिए है।

यह अच्छा होगा अगर आप अपने लक्ष्यों के बारे में अधिक जानकारी साझा कर सकें।

Answer 6

आप इस

import java.util.*; 
class Data { 
    static Map<String,String[]> easyDefinitions = new HashMap<String,String[]>(); 
} 
public enum QuestionsRepository 
{ 
    repository("primary=red,green,blue;secondary=cyan,yellow,magenta"); 
    QuestionsRepository(String dictionary) { 
     String[] rules = dictionary.split(";"); 
     for (String rule:rules) { 
      String[] keyValuePair = rule.split("=",2); 
      Data.easyDefinitions.put(keyValuePair[0],keyValuePair[1].split(",")); 
     } 
    } 
}