जावा में स्थिर चर का उपयोग

मुझे पता था कि स्टेटिक वैरिएबल बनाए जाते हैं और केवल एक बार शुरू होते हैं Ie जब वर्ग लोड होता है और प्रति ऑब्जेक्ट नहीं होता है।

नीचे दिए गए कोड में मैं जो करने की कोशिश कर रहा हूं वह है: मैंने कक्षा ए में स्थिर के रूप में एक int वैरिएबल "ए" घोषित किया है और इसे 5 का मान दिया है। जब मुख्य निष्पादित किया जाता है तो मैंने अपना मान 6 तक बदल दिया और प्रोग्राम को लूप असीम रूप से। तो वर्तमान में "ए" मान 6 है।

अब मैंने जो करने की कोशिश की है, मैंने क्लास ए को अभी भी लूपिंग के दौरान इस वैरिएबल तक पहुंचने का प्रयास किया है और मुझे उम्मीद है कि जब मैं कक्षा बी चलाता हूं तो 6 मुद्रित किया जाना चाहिए (क्योंकि जब तक मैं कक्षा बी "ए" मूल्य चलाता था 6 में बदल गया है) लेकिन आश्चर्य की बात है कि यह अभी भी मुझे 5 दिया।

यह क्यों हो रहा है भले ही मैंने "ए" को स्थैतिक घोषित किया हो? इस दृष्टिकोण के साथ क्या गलत है यह जानने में असमर्थ।

class A{
    static int a=5;

    public static void main(String args[]){
        System.out.println(A.a+"");
        a=6;
        while(true){
        }
    }
}

class B{    
    public static void main(String args[]){
        System.out.println(A.a+"");
    }
}
2
जोड़ा संपादित
विचारों: 1
आप A.main और bmain के माध्यम से दो अलग-अलग प्रोग्राम चला रहे हैं। आपको जो भी देखने की उम्मीद है, उसे प्रदर्शित करने के लिए आपको उसी प्रक्रिया के भीतर धागे का उपयोग करना होगा।
जोड़ा लेखक Steve Townsend, स्रोत
या बेहतर - एक स्थिर प्रारंभकर्ता ब्लॉक।
जोड़ा लेखक Hovercraft Full Of Eels, स्रोत
मुझे नहीं लगता कि धागे जरूरी हैं। बी में; 'जघन स्थिर शून्य मुख्य (स्ट्रिंग [] तर्क) {ए। मुख्य (तर्क); सिस्टम बाहर । println (ए। ए + ""); }
जोड़ा लेखक emory, स्रोत

4 उत्तर

आपके पास जो समस्या है वह यह है कि आप दो अलग-अलग JVM प्रक्रियाएं चला रहे हैं। आपको क्या करना चाहिए अपने प्रत्येक "मुख्य" विधियों को अपने धागे में चलाना है। इस तरह वे एक ही स्मृति को साझा करते हैं (और इसलिए संशोधित कर सकते हैं)। धागे का उपयोग करने के लिए आपका उदाहरण संशोधित है:

public class Main{
    public static int v = 5;

    public static void main(String[] args) throws Exception{
        new Thread(new A()).start();
        Thread.sleep(5000);
        new Thread(new B()).start();
    }
}

class A implements Runnable{
    public void run(){
        System.out.println(Main.v);
        Main.v = 6;
    }
}

class B implements Runnable{
    public void run(){
        System.out.println(Main.v);
    }
}

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

4
जोड़ा
या फिर मैं सही प्रक्रियाओं में दो कार्यक्रमों को लोड करने की कोशिश करता हूं जो गलती है। धन्यवाद!
जोड़ा लेखक user1406427, स्रोत

आप वास्तव में ए में मुख्य लूप कभी नहीं चलाते

मूल्य बदलने के लिए बस एक विधि बनाओ।

0
जोड़ा
आप पहले "ए" कहां चलाते हैं? आप जो चाहते हैं उसे प्राप्त करने के लिए, आपको उन दोनों को एक ही कक्षा में चलाने होंगे। वे अभी भी दो अलग-अलग वस्तुएं हैं, जिनके पास एक दूसरे के साथ कुछ लेना देना नहीं है। तो आप केवल वैरिएबल तक पहुंच रहे हैं, बी से इसे एक्सेस करने से पहले इसे वास्तव में नहीं बदल रहे हैं।
जोड़ा लेखक OmniOwl, स्रोत
मैंने प्रथम श्रेणी में भाग लिया था इसलिए "ए" मान 6 में बदला जाना चाहिए। इसके बाद, जबकि ए को थोड़ी देर में मारा जाता है, मैंने कक्षा बी में "ए" तक पहुंचने का प्रयास किया, मुझे जवाब के रूप में 5 मिला।
जोड़ा लेखक user1406427, स्रोत
या फिर मैं सही प्रक्रियाओं में दो कार्यक्रमों को लोड करने की कोशिश करता हूं जो गलती है। धन्यवाद!
जोड़ा लेखक user1406427, स्रोत

ऐसा इसलिए है क्योंकि ए की मुख्य विधि कभी नहीं आती है।

0
जोड़ा

आप दो जावा प्रक्रियाओं और दो कार्यक्रम चला रहे हैं। दूसरा क्लासलोडर class A लोड करता है और इसके स्थिर चर को 5 पर सेट करता है लेकिन कक्षा ए में परिभाषित उस स्थिर मुख्य() विधि को आमंत्रित करने के लिए class B में कोई कॉल नहीं है। जो इसे 6 तक बढ़ाता है।

0
जोड़ा
या फिर मैं सही प्रक्रियाओं में दो कार्यक्रमों को लोड करने की कोशिश करता हूं जो गलती है। धन्यवाद!
जोड़ा लेखक user1406427, स्रोत