निजी अंतिम स्थिर विशेषता बनाम निजी अंतिम विशेषता

Question

जावा में, क्या अंतर है:

private final static int NUMBER = 10;

तथा

private final int NUMBER = 10;

दोनों हैं privateऔर final, अंतर staticविशेषता है।

बेहतर क्या है? और क्यों?

Comments

निजी अंतिम स्थैतिक -> इस चर को केवल एक बार बनाएं। निजी अंतिम -> इस चर को हर वस्तु के लिए बनाएं। पहले एक स्मृति बचाता है, इसके लिए जाओ।

— user1923551

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

— LittleLittleQ

द्वारा "अंतिम अंतिम वैरिएबल वैरिएबल को क्लास 'कंस्ट्रक्टर में नहीं डाल सकते" मेरा मतलब है कि कोई final staticकंस्ट्रक्टर में वैरिएबल को इनिशियलाइज़ नहीं कर सकता है , एक ही तरीका है कि एक स्टैटिक इनिशियलाइज़र का उपयोग किया जाए :)

— LittleLittleQ

@ user1923551 प्रभाव सामान के लिए उलटा है जो केवल बड़े अनुप्रयोगों में सीमित समय के लिए आवश्यक है, मेमोरी दुर्लभ अनुप्रयोगों में या एक सिंगलटन का उपयोग करते समय। हर वर्ग में स्टैटिक स्टफ रखने से ज़रूरत के सामान के लिए मेमोरी का एक बड़ा (विशाल) हिस्सा सुरक्षित रहेगा। यह स्थिर अंतिम वस्तुओं या संग्रह को घोषित करने के लिए मेमोरी लीक भी हो सकता है।

— उम्मीद है कि

Answer 1

सामान्य तौर पर, का staticअर्थ है " प्रकार के साथ जुड़ा हुआ है, बजाय एक उदाहरण के ।"

इसका मतलब है कि आप कभी भी प्रकार के उदाहरणों को बनाए बिना एक स्थिर चर का संदर्भ दे सकते हैं, और चर का संदर्भ देने वाला कोई भी कोड सटीक समान डेटा का संदर्भ दे रहा है। एक उदाहरण चर के साथ इसकी तुलना करें: उस स्थिति में, कक्षा के प्रति चर का एक स्वतंत्र संस्करण है। उदाहरण के लिए:

Test x = new Test();
Test y = new Test();
x.instanceVariable = 10;
y.instanceVariable = 20;
System.out.println(x.instanceVariable);

प्रिंट 10: y.instanceVariableऔर x.instanceVariableअलग हैं, क्योंकि xऔरy अलग ऑब्जेक्ट्स को संदर्भित करते हैं।

आप स्थैतिक सदस्यों को संदर्भों के माध्यम से संदर्भित कर सकते हैं, हालांकि ऐसा करना एक बुरा विचार है। अगर हमने किया:

Test x = new Test();
Test y = new Test();
x.staticVariable = 10;
y.staticVariable = 20;
System.out.println(x.staticVariable);

तब वह 20 का प्रिंट आउट लेगा - केवल एक ही चर है, प्रति उदाहरण एक नहीं। इसे इस प्रकार लिखना स्पष्ट होगा:

Test x = new Test();
Test y = new Test();
Test.staticVariable = 10;
Test.staticVariable = 20;
System.out.println(Test.staticVariable);

यह व्यवहार को और अधिक स्पष्ट करता है। आधुनिक आईडीई आमतौर पर दूसरी लिस्टिंग को तीसरे में बदलने का सुझाव देगा।

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

private final int NUMBER = 10;

इसलिए यदि यह नहीं बदल सकता है, तो प्रति उदाहरण एक प्रति होने का कोई मतलब नहीं है।

लेकिन, यह समझ में आता है कि क्या इस तरह से एक निर्माणकर्ता में इनिशियलाइज़ किया गया है:

// No initialization when is declared
private final int number;

public MyClass(int n) {
   // The variable can be assigned in the constructor, but then
   // not modified later.
   number = n;
}

अब, प्रत्येक उदाहरण के लिए MyClass, हमारे पास एक अलग लेकिन अपरिवर्तनीय मूल्य हो सकता है number।

Comments

जब तक जावा 5 में एनम उपलब्ध नहीं थे, स्थैतिक अंतिम स्थिरांक घोषित करने का सामान्य तरीका था।

— विनीत रेनॉल्ड्स

@ विनीत: स्थैतिक फाइनल अभी भी आदिम स्थिरांक घोषित करने का तरीका है, जब तक कि आपके पास उनकी संख्या पर्याप्त न हो =)

— Chii

@ मैथ्यू: संभावित रूप से। निरंतर के लिए नहीं, बल्कि कुछ तार्किक रूप से संबंधित मूल्य के लिए। ऐसा नहीं है कि मैं वैसे भी सिंगलटन बहुत पसंद करता हूं।

— जॉन स्कीट

एक कट्टरपंथी सवाल। इसे प्रयोग के लायक है private finalसे अधिक private static final/ रीक्लेम वर्ग से थोड़ा याद है कि बाहर निचोड़ करने के लिए? चलो calculatorडिवाइस के लिए सीमित रैम के साथ लेकिन सीपीयू संसाधनों के बहुत सारे कहते हैं ।

— विन मायो हेट

@WinMyoHtet: यदि आप एक स्थिर क्षेत्र का उपयोग करते हैं, तो कुल मिलाकर केवल एक ही है । यदि आप एक इंस्टेंस फ़ील्ड का उपयोग करते हैं, तो एक प्रति इंस्टेंस है। एक स्थिर क्षेत्र का उपयोग करना बेहतर होगा जब तक कि आपके पास कोई उदाहरण नहीं है, इस मामले में यह वैसे भी बेकार है।

— जॉन स्कीट

Answer 2

के लिए अंतिम है, यह क्रम में विभिन्न मूल्यों सौंपा जा सकता है जब प्रारंभ। उदाहरण के लिए

Class Test{
  public final int a;
}

Test t1  = new Test();
t1.a = 10;
Test t2  = new Test();
t2.a = 20; //fixed

इस प्रकार प्रत्येक उदाहरण में फ़ील्ड a का अलग-अलग मान होता है ।

के लिए स्थिर अंतिम , सभी उदाहरणों में एक ही मूल्य का हिस्सा है, और पहले प्रारंभ के बाद बदला नहीं जा सकता है।

Class TestStatic{
      public static final int a;
}

TestStatic t1  = new TestStatic();
t1.a = 10;
TestStatic t2  = new TestStatic();
t1.a = 20;   // ERROR, CAN'T BE ALTERED AFTER THE FIRST INITIALIZATION.

Comments

यह संकलन नहीं होगा! एक अंतिम चर को या तो एक मान सौंपा जाना चाहिए, या उसके निर्माणकर्ताओं में एक मान दिया जाना चाहिए। यह उत्तर सही होगा यदि 2 निर्माणकर्ताओं को दिया गया था, प्रत्येक के लिए एक 'a' एक अलग मूल्य पर है।

— 18

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

— रुडी करशव

जैसा कि मैटसी ने बताया है, आप उस वस्तु को बनाने के बाद एक अंतिम चर को निर्दिष्ट नहीं कर सकते - वास्तव में, आप इसके अंतिम चर को मान दिए बिना भी एक वस्तु नहीं बना सकते हैं ...

— jamesdeath123

बस अगर कोई इस पर ठोकर खाता है, तो कृपया मैटसी के जवाब का पालन करें।

— फ़ैज़

यह वही है जो मुझे लगता है कि ओपी पूछ रहा था, मैं यह भूल गया था कि फाइनल को तुरंत मूल्य पर असाइन किया जा सकता है अगर यह घोषणा में प्रदान नहीं किया गया था।

— सालसरो 69

Answer 3

एक staticचर एप्लिकेशन के पूरे जीवनकाल के लिए मेमोरी में रहता है, और इसे क्लास लोडिंग के दौरान आरम्भ किया जाता है। staticहर बार जब आप किसी newऑब्जेक्ट का निर्माण करते हैं तो एक नॉन- वैरिएबल को इनिशियलाइज़ किया जा रहा है । यह आमतौर पर उपयोग करने के लिए बेहतर है:

private static final int NUMBER = 10;

क्यों? यह प्रति मिनट मेमोरी फ़ुटप्रिंट को कम करता है। यह संभवतः कैश हिट के लिए भी अनुकूल है। और यह सिर्फ समझ में आता है: staticएक निश्चित प्रकार (उर्फ class) के सभी उदाहरणों (उर्फ वस्तुओं) में साझा की जाने वाली चीजों के लिए उपयोग किया जाना चाहिए ।

Comments

एक स्थिर चर भी रनटाइम पर बनाया गया है। इसलिए आप उक्त चर या विधि का उपयोग वस्तु के बनने से पहले कर सकते हैं।

— बॉबी

जावा कोडिंग कन्वेंशन द्वारा स्टैटिक फाइनल वेरिएबल का नाम सभी अपरकेस होना चाहिए।

— Starblue

@Martijn कोर्टो, कैसे एक ऐसी स्थिति के बारे में जहां एक ऐप के जीवनकाल में एक बार उपयोग किया जाएगा! private final intस्मृति से हटा दिया जाएगा जब उदाहरण GC'ed हो जाएगा, जबकि private static final intउस एप्लिकेशन के जीवन भर स्मृति में रहेगा। उपरोक्त परिदृश्य में आप क्या सुझाव देते हैं?

— MANN

@MANN: यह अत्यधिक सैद्धांतिक है। उसके लिए वस्तुतः कोई उपयोगी उपयोग का मामला नहीं है। यह फायदेमंद हो सकता है यदि आपके पास एक वर्ग में 50000 इंट संस्करण हैं। इस मामले में भी, यह 200kb मेमोरी को बचाएगा। चूंकि हम जावा की बात कर रहे हैं, यह पूरी तरह अप्रासंगिक है। मेमोरी के महत्वपूर्ण उपकरणों के मामले में, एक सभ्य C या C ++ कंपाइलर उन पूर्णांक मानों को हमेशा इनलाइन करता है, जिससे मेमोरी पूरी तरह से मुक्त होने की आवश्यकता समाप्त हो जाती है।

— मार्टिग्न कोर्टो जूल

Answer 4

स्थैतिक का अर्थ है "वर्ग के साथ जुड़ा हुआ"; इसके बिना, चर वर्ग के प्रत्येक उदाहरण के साथ जुड़ा हुआ है। यदि यह स्थिर है, तो इसका मतलब है कि आपके पास मेमोरी में केवल एक ही होगा; यदि नहीं, तो आपके पास आपके द्वारा बनाए गए प्रत्येक उदाहरण के लिए एक होगा। स्थैतिक का अर्थ है जब तक कक्षा लोड होती है तब तक चर स्मृति में रहेगा; इसके बिना, जब इसका उदाहरण है, तो चर को gc'd किया जा सकता है।

Comments

इंस्टेंस वैरिएबल को gc'd मिलेगा जब भी सभी रेफरेंस / ऑब्जेक्ट्स इसमें मरेंगे, है ना?

— रुचिर बरोनिया

उदाहरण gc'd हैं, लेकिन आंकड़े कक्षाओं से जुड़े हैं, उदाहरण नहीं। जब तक वर्ग स्मृति में रहेगा तब तक आप उसके सार्वजनिक स्थैतिक उदाहरणों और विधियों का उल्लेख कर सकेंगे। वे परमिट जीन (या जो भी उसके JDK 8 समतुल्य है) में जाते हैं और gc'd नहीं होते हैं।

— duffymo

गलत। यदि आपके पास स्मृति में इंस्टेंस का संदर्भ है तो आप इसके उपलब्ध तरीकों और उदाहरणों तक पहुँच सकते हैं। बाकी गलत है। आप एक वर्ग और उसके उदाहरणों के बीच के अंतर को समझने में विफल रहते हैं।

— duffymo

Answer 5

जवाबों को पढ़कर मुझे लगा कि वास्तव में इस मुद्दे पर कोई वास्तविक परीक्षा नहीं हो रही है। यहाँ मेरे 2 सेंट हैं:

public class ConstTest
{

    private final int         value             = 10;
    private static final int  valueStatic       = 20;
    private final File        valueObject       = new File("");
    private static final File valueObjectStatic = new File("");

    public void printAddresses() {


        System.out.println("final int address " +
                ObjectUtils.identityToString(value));
        System.out.println("final static int address " +
                ObjectUtils.identityToString(valueStatic));
        System.out.println("final file address " + 
                ObjectUtils.identityToString(valueObject));
        System.out.println("final static file address " + 
                ObjectUtils.identityToString(valueObjectStatic));
    }


    public static void main(final String args[]) {


        final ConstTest firstObj = new ConstTest();
        final ConstTest sndObj = new ConstTest();

        firstObj.printAdresses();
        sndObj.printAdresses();
    }

}

पहली वस्तु के लिए परिणाम:

final int address java.lang.Integer@6d9efb05
final static int address java.lang.Integer@60723d7c
final file address java.io.File@6c22c95b
final static file address java.io.File@5fd1acd3

2 वस्तु के लिए परिणाम:

final int address java.lang.Integer@6d9efb05
final static int address java.lang.Integer@60723d7c
final file address java.io.File@3ea981ca
final static file address java.io.File@5fd1acd3

निष्कर्ष:

जैसा कि मैंने सोचा था कि जावा आदिम और अन्य प्रकारों के बीच अंतर करता है। जावा में आदिम प्रकार हमेशा "कैश्ड" होते हैं, स्ट्रिंग्स शाब्दिकों के लिए समान (नई स्ट्रिंग ऑब्जेक्ट्स नहीं), इसलिए स्थिर और गैर-स्थिर सदस्यों के बीच कोई अंतर नहीं है।

हालांकि, गैर-स्थैतिक सदस्यों के लिए एक स्मृति दोहराव है यदि वे एक आदिम प्रकार के उदाहरण नहीं हैं।

वैल्यूस्टैटिक का मूल्य 10 में बदलना और भी आगे बढ़ जाएगा क्योंकि जावा दो इंट वैरिएबल्स को समान पते देगा।

Comments

'Int' -> पूर्णांक के ऑटोबॉक्सिंग से यहां भ्रम पैदा हो रहा है। आप देख रहे हैं कि कुछ (छोटे) इंट वैल्यू के ऑटोबॉक्सिंग एक ही इंटेगर ऑब्जेक्ट की ओर ले जाते हैं।

— डेकेलर

@StackHola @dkneller वास्तव में, ऑटोबॉक्सिंग एक बहुत ही महत्वपूर्ण विवरण है जो यहां होता है। हस्ताक्षर है ObjectUtils.identityToString(Object)। (इसके अलावा, जावा के पास संदर्भ मार्ग से कोई पास नहीं है)। एक वास्तविक उपयोगी परीक्षण दो वस्तुओं को आवंटित करने और public final int FOO = 10एक मजबूर तरीके से जावा प्रतिबिंबों का उपयोग करके एक चर के मूल्य को बदलने के लिए होगा । फिर जांचें कि क्या दूसरी वस्तु ने भी इसका मूल्य बदल दिया है।

— 21:39 पर मार्टिज़न कोर्टो जूल

Answer 6

हालांकि अन्य उत्तर स्पष्ट रूप से स्पष्ट करते हैं कि गैर-स्थैतिक स्थिरांक का उपयोग करने का कोई कारण नहीं है, मैं किसी को भी इंगित नहीं कर पाया कि उनके निरंतर चर पर विभिन्न मूल्यों के साथ विभिन्न उदाहरण होना संभव है।

निम्नलिखित उदाहरण पर विचार करें:

public class TestClass {
    private final static double NUMBER = Math.random();

    public TestClass () {
        System.out.println(NUMBER);
    }
}

टेस्टक्लास के तीन उदाहरण बनाने से एक ही यादृच्छिक मूल्य तीन बार प्रिंट होता है, क्योंकि केवल एक मूल्य उत्पन्न होता है और स्थिर स्थिर में संग्रहीत होता है।

हालांकि, जब इसके बजाय निम्नलिखित उदाहरण की कोशिश कर रहा है:

public class TestClass {
    private final double NUMBER = Math.random();

    public TestClass () {
        System.out.println(NUMBER);
    }
}

टेस्टक्लास के तीन उदाहरण बनाना अब तीन अलग-अलग यादृच्छिक मूल्यों को मुद्रित करेगा, क्योंकि प्रत्येक उदाहरण का अपना यादृच्छिक रूप से निरंतर मूल्य है।

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

Answer 7

जैसा कि पहले ही जॉन ने कहा, एक स्थिर चर, जिसे एक वर्ग चर के रूप में भी जाना जाता है, एक चर है जो एक वर्ग के उदाहरणों में मौजूद है।

मुझे इसका एक उदाहरण यहाँ मिला :

public class StaticVariable
{
  static int noOfInstances;
  StaticVariable()
  {
    noOfInstances++;
  }
  public static void main(String[] args)
  {
    StaticVariable sv1 = new StaticVariable();
    System.out.println("No. of instances for sv1 : " + sv1.noOfInstances);

    StaticVariable sv2 = new StaticVariable();
    System.out.println("No. of instances for sv1 : "  + sv1.noOfInstances);
    System.out.println("No. of instances for st2 : "  + sv2.noOfInstances);

    StaticVariable sv3 = new StaticVariable();
    System.out.println("No. of instances for sv1 : "  + sv1.noOfInstances);
    System.out.println("No. of instances for sv2 : "  + sv2.noOfInstances);
    System.out.println("No. of instances for sv3 : "  + sv3.noOfInstances);
  }
}

कार्यक्रम का आउटपुट नीचे दिया गया है:

जैसा कि हम इस उदाहरण में देख सकते हैं कि प्रत्येक वस्तु की कक्षा चर की अपनी प्रति है।

C:\java>java StaticVariable
No. of instances for sv1 : 1
No. of instances for sv1 : 2
No. of instances for st2 : 2
No. of instances for sv1 : 3
No. of instances for sv2 : 3
No. of instances for sv3 : 3

Answer 8

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

उदाहरण के लिए:

class A
{
    final int f;
    static final int sf = 5;

    A(int num)
    {
        this.f = num;
    }

    void show()
    {
        System.out.printf("About Object: %s\n Final: %d\n Static Final: %d\n\n", this.toString(), this.f, sf);
    }

    public static void main(String[] args)
    {
        A ob1 = new A(14);
        ob1.show();

        A ob2 = new A(21);
        ob2.show();

    }
}

स्क्रीन पर क्या दिखता है:

ऑब्जेक्ट के बारे में: A @ addbf1 फाइनल: 14 स्टेटिक फाइनल: 5

ऑब्जेक्ट के बारे में: A @ 530daa फाइनल: 21 स्टेटिक फाइनल: 5

अनाम प्रथम वर्ष का आईटी छात्र, ग्रीस

Comments

itw कोई उत्तर नहीं है :(

— संजय पांडे

Answer 9

जॉन के जवाब के अलावा यदि आप स्थैतिक फाइनल का उपयोग करते हैं तो यह एक तरह का "परिभाषा" के रूप में व्यवहार करेगा। एक बार जब आप इसका उपयोग करने वाले वर्ग को संकलित करते हैं, तो यह संकलित .class फ़ाइल में जला दिया जाएगा। इसके बारे में मेरे धागे को यहाँ देखें ।

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

आपको यह दिखाने के लिए कि विभिन्न उदाहरणों में विभिन्न मूल्यों का उपयोग कैसे करें इस कोड की जांच करें:

public class JustFinalAttr {
  public final int Number;

  public JustFinalAttr(int a){
    Number=a;
  }
}

...System.out.println(new JustFinalAttr(4).Number);

Comments

विस्तृत तुलना के लिए मेरे पास यहां एक लिंक था। मुझे खेद है दोस्तों, यह मैंने अनुमान लगाया है।

— BlondCode

लिंक वापस आ गया है। एक संपादक ने इसे मृत मान लिया था। लगता है अब जीना है।

— एरिक जी। हेगस्ट्रोम

Answer 10

यहाँ मेरे दो सेंट हैं:

final           String CENT_1 = new Random().nextInt(2) == 0 ? "HEADS" : "TAILS";
final   static  String CENT_2 = new Random().nextInt(2) == 0 ? "HEADS" : "TAILS";

उदाहरण:

package test;

public class Test {

    final long OBJECT_ID = new Random().nextLong();
    final static long CLASSS_ID = new Random().nextLong();

    public static void main(String[] args) {
        Test[] test = new Test[5];
        for (int i = 0; i < test.length; i++){
            test[i] = new Test();
            System.out.println("Class id: "+test[i].CLASSS_ID);//<- Always the same value
            System.out.println("Object id: "+test[i].OBJECT_ID);//<- Always different
        }
    }
}

कुंजी यह है कि चर और फ़ंक्शन अलग-अलग मान लौटा सकते हैं। अंतिम चर को विभिन्न मूल्यों के साथ सौंपा जा सकता है।

Comments

क्या आप कृपया बता सकते हैं कि कौन सा बेहतर है और क्यों?

— डैनियल

Answer 11

स्थिर, स्थिर अंतिम, अंतिम चर के उपयोग को समझने के लिए बस एक और सरल उदाहरण। कोड टिप्पणियों की उचित व्याख्या है।

public class City {

    // base price that is always same for all objects[For all cities].
    private static double iphone_base_price = 10000;

    // this is total price = iphone_base_price+iphone_diff;
    private double iphone_citi_price;

    // extra price added to iphone_base_price. It is constant per city. Every
    // city has its own difference defined,
    private final double iphone_diff;

    private String cityName = "";

    // static final will be accessible everywhere within the class but cant be
    // changed once initialized.
    private static final String countryName = "India";

    public City(String cityName, double iphone_diff) {
        super();
        this.iphone_diff = iphone_diff;
        iphone_citi_price = iphone_base_price + iphone_diff;
        this.cityName = cityName;

    }

    /**
     * get phone price
     * 
     * @return
     */
    private double getPrice() {

        return iphone_citi_price;
    }

    /**
     * Get city name
     * 
     * @return
     */
    private String getCityName() {

        return cityName;
    }

    public static void main(String[] args) {

        // 300 is the
        City newyork = new City("Newyork", 300);
        System.out.println(newyork.getPrice() + "  " + newyork.getCityName());

        City california = new City("California", 800);
        System.out.println(california.getPrice() + "  " + california.getCityName());

        // We cant write below statement as a final variable can not be
        // reassigned
        // california.iphone_diff=1000; //************************

        // base price is defined for a class and not per instances.
        // For any number of object creation, static variable's value would be the same
        // for all instances until and unless changed.
        // Also it is accessible anywhere inside a class.
        iphone_base_price = 9000;

        City delhi = new City("delhi", 400);
        System.out.println(delhi.getPrice() + "  " + delhi.getCityName());

        City moscow = new City("delhi", 500);
        System.out.println(moscow.getPrice() + "  " + moscow.getCityName());

        // Here countryName is accessible as it is static but we can not change it as it is final as well. 
        //Something are meant to be accessible with no permission to modify it. 
        //Try un-commenting below statements
        System.out.println(countryName);

        // countryName="INDIA";
        // System.out.println(countryName);

    }

}

Answer 12

बहुत कम, और स्थिर

वहाँ कोई अंतर नहीं है क्योंकि वे दोनों स्थिरांक हैं। अधिकांश वर्ग डेटा ऑब्जेक्ट्स के लिए, स्थैतिक का अर्थ होगा क्लास के साथ जुड़ा हुआ कुछ, केवल एक ही कॉपी होने से कोई फर्क नहीं पड़ता कि कितने ऑब्जेक्ट्स नए के साथ बनाए गए थे।

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

Answer 13

चूँकि किसी वर्ग में एक चर को अंतिम रूप में घोषित किया जाता है और उसी कमांड में आरंभ किया जाता है, इसलिए इसे स्थिर घोषित नहीं करने का कोई कारण नहीं है, क्योंकि इसका वही मूल्य होगा, जिसका कोई उदाहरण नहीं है। इसलिए, सभी उदाहरण एक ही मेमोरी एड्रेस को एक मूल्य के लिए साझा कर सकते हैं, इस प्रकार प्रत्येक आवृत्ति के लिए एक नया चर बनाने की आवश्यकता को समाप्त करके प्रसंस्करण समय की बचत करते हैं और 1 सामान्य पते को साझा करके मेमोरी को बचाते हैं।

Answer 14

निजी स्थैतिक फाइनल को स्थिर माना जाएगा और इस वर्ग के भीतर ही स्थाई तक पहुँचा जा सकता है। चूंकि, कीवर्ड स्टैटिक में शामिल होता है, इसलिए मूल्य वर्ग की सभी वस्तुओं के लिए स्थिर रहेगा।

निजी अंतिम परिवर्तनीय मूल्य प्रति वस्तु स्थिर की तरह होगा।

आप java.lang.String को देखें या नीचे दिए गए उदाहरण को देखें।

public final class Foo
{

    private final int i;
    private static final int j=20;

    public Foo(int val){
        this.i=val;
    }

    public static void main(String[] args) {
        Foo foo1= new Foo(10);

        Foo foo2= new Foo(40);

        System.out.println(foo1.i);
        System.out.println(foo2.i);
        System.out.println(check.j);
    }
}

// आउटपुट:

10
40
20

Answer 15

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

Answer 16

यदि आप इस चर को स्थिर करते हैं, तो जैसा कि आप जानते हैं, आपको इन मूल्यों को फिर से उपयोग करने के लिए स्थैतिक तरीकों की आवश्यकता होगी, यह उपयोगी होगा यदि आप पहले से ही इन चर का उपयोग केवल स्थैतिक तरीकों से करने के बारे में सोचते हैं। अगर ऐसा है तो यह सबसे अच्छा होगा।

हालाँकि आप अब चर को सार्वजनिक कर सकते हैं क्योंकि कोई भी इसे "System.out" की तरह संशोधित नहीं कर सकता है, यह फिर से आपके इरादों पर निर्भर करता है और आप क्या हासिल करना चाहते हैं।

Comments

स्टेटिक वैरिएबल को एक्सेस करने के लिए स्टेटिक तरीकों की आवश्यकता नहीं होगी - मुझे लगता है कि आप "स्टैटिक विधियों से इंस्टेंस वेरिएबल एक्सेस करने की सोच रहे हैं" (अनुमति नहीं है)।

— ataulm

Answer 17

आइए हम बताते हैं कि यदि कक्षा में एक से अधिक उदाहरण नहीं होंगे, तो कौन सा अधिक मेमोरी लेता है:

निजी स्थिर अंतिम इंट आईडी = 250; या निजी अंतिम इंट आईडी = 250;

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

Comments

कृपया केवल दोहराएं नहीं, अन्य उत्तर पहले से ही क्या शामिल हैं।

— उपयोगकर्ता अनजान

Answer 18

स्थैतिक चर वर्ग से संबंधित है (जिसका अर्थ है कि सभी वस्तुएँ उस चर को साझा करती हैं)। गैर स्थिर चर प्रत्येक ऑब्जेक्ट के अंतर्गत आता है।

public class ExperimentFinal {

private final int a;
private static final int b = 999; 

public ExperimentFinal(int a) {
    super();
    this.a = a;
}
public int getA() {
    return a;
}
public int getB() {
    return b;
}
public void print(int a, int b) {
    System.out.println("final int: " + a + " \nstatic final int: " + b);
}
public static void main(String[] args) {
    ExperimentFinal test = new ExperimentFinal(9);
    test.print(test.getA(), test.getB());
} }

जैसा कि आप उपरोक्त उदाहरण देख सकते हैं, "फाइनल इंट" के लिए हम कक्षा के प्रत्येक उदाहरण (ऑब्जेक्ट) के लिए अपना वेरिएबल असाइन कर सकते हैं, हालांकि "स्टैटिक फाइनल इंट" के लिए, हमें क्लास में एक वेरिएबल असाइन करना चाहिए (स्टैटिक वेरिएबल क्लास से संबंधित है) )।

Answer 19

यदि आप स्थैतिक का उपयोग करते हैं तो चर का मान आपके सभी उदाहरणों में समान होगा, यदि एक उदाहरण में बदला गया तो दूसरे भी बदल जाएंगे।

Answer 20

अंतिम: एक बार अंतिम चर सौंपा जाने के बाद, इसमें हमेशा समान मान होता है। जहाँ भी वैरिएबल स्थिर या स्थिर नहीं है: यह मेमोरी में एक बार इनिशियलाइज़ किए गए सभी उदाहरणों के लिए केवल एक वैरिएबल होगा

Answer 21

यह मदद कर सकता है

public class LengthDemo {
public static void main(String[] args) {
    Rectangle box = new Rectangle();
    System.out.println("Sending the value 10.0 "
            + "to the setLength method.");
    box.setLength(10.0);
    System.out.println("Done.");
    }
}

Comments

यकीन है कि इस quesiton के लिए इसका जवाब?

— मिकस

Answer 22

"स्टेटिक" कीवर्ड वर्ग के अलग-अलग उदाहरणों के बजाय कक्षा की परिवर्तनीय संपत्ति बनाता है। उस चर की एक प्रति होगी जो उस वर्ग के सभी उदाहरणों के बीच साझा की जाती है। स्थिर चर की स्थिति में कोई भी परिवर्तन सभी उदाहरणों में परिलक्षित होगा। फाइनल को स्टेटिक में जोड़ें और हमें एक ऐसा वेरिएबल मिलता है जिसे एक बार और सभी क्लास लोडिंग टाइम पर इनिशियलाइज़ किया जाता है और बाद में क्लास के किसी भी इंस्टेंस से इसे बदला नहीं जा सकता। स्टेटिक अंतिम चर को घोषणा समय पर आरंभ करने की आवश्यकता है अन्यथा हमारे पास संकलन समय त्रुटि है। जहां तक ​​निजी उदाहरण क्षेत्र का संबंध है, यह किसी वर्ग की वस्तु / आवृत्ति की संपत्ति / स्थिति को संदर्भित करता है। कक्षा के प्रत्येक उदाहरण / वस्तु के पास आवृत्ति चर की अपनी प्रति होगी। जब उदाहरण चर को अंतिम घोषित किया जाता है, इसका अर्थ है कि हम इस उदाहरण के लिए इसका मान नहीं बदल सकते हैं। इसके लिए हमें अंतिम चर को या तो घोषणा में या कंस्ट्रक्टर में डालने की जरूरत है। यदि यह दोनों में से किसी में भी नहीं किया गया है, तो संकलन समय त्रुटि दिखाई देगी। एक बार आरंभ करने के बाद, यदि आप किसी मूल्य को फिर से असाइन करने का प्रयास करते हैं तो आपको एक संकलन समय त्रुटि मिलेगी। स्थिर अंतिम चर का उपयोग करें जहां डेटा को कक्षा के सभी उदाहरणों में साझा किया जाएगा और आप चाहते हैं कि डेटा केवल पढ़ा जाए। उदाहरण के लिए अंतिम चर यदि आप कुछ डेटा का प्रतिनिधित्व करना चाहते हैं, जो कक्षा के प्रत्येक व्यक्तिगत उदाहरण से संबंधित है, लेकिन एक बार संग्रहीत बदला नहीं जा सकता। स्थिर और उदाहरण कुंजी शब्द का उपयोग आपकी डिज़ाइन आवश्यकताओं और डोमेन में डेटा का प्रतिनिधित्व करता है पर निर्भर करता है। यदि डेटा का उपयोग कक्षा के उदाहरणों में किया जाता है, तो प्रत्येक ऑब्जेक्ट के लिए अलग-अलग प्रतियां / मेमोरी संदर्भों की आवश्यकता नहीं है। इसके लिए हमें अंतिम चर को या तो घोषणा में या कंस्ट्रक्टर में डालने की जरूरत है। यदि यह दोनों में से किसी में भी नहीं किया गया है, तो संकलन समय त्रुटि दिखाई देगी। एक बार आरंभ करने के बाद, यदि आप किसी मूल्य को फिर से असाइन करने का प्रयास करते हैं तो आपको एक संकलन समय त्रुटि मिलेगी। स्थिर अंतिम चर का उपयोग करें जहां डेटा को कक्षा के सभी उदाहरणों में साझा किया जाएगा और आप चाहते हैं कि डेटा केवल पढ़ा जाए। उदाहरण के लिए अंतिम चर यदि आप कुछ डेटा का प्रतिनिधित्व करना चाहते हैं, जो कक्षा के प्रत्येक व्यक्तिगत उदाहरण से संबंधित है, लेकिन एक बार संग्रहीत बदला नहीं जा सकता। स्थिर और उदाहरण कुंजी शब्द का उपयोग आपकी डिज़ाइन आवश्यकताओं और डोमेन में डेटा का प्रतिनिधित्व करता है पर निर्भर करता है। यदि डेटा का उपयोग कक्षा के उदाहरणों में किया जाता है, तो प्रत्येक ऑब्जेक्ट के लिए अलग-अलग प्रतियां / मेमोरी संदर्भों की आवश्यकता नहीं है। इसके लिए हमें अंतिम चर को या तो घोषणा में या कंस्ट्रक्टर में डालने की जरूरत है। यदि यह दोनों में से किसी में भी नहीं किया गया है, तो संकलन समय त्रुटि दिखाई देगी। एक बार आरंभ करने के बाद, यदि आप किसी मूल्य को फिर से असाइन करने का प्रयास करते हैं तो आपको एक संकलन समय त्रुटि मिलेगी। स्थिर अंतिम चर का उपयोग करें जहां डेटा को कक्षा के सभी उदाहरणों में साझा किया जाएगा और आप चाहते हैं कि डेटा केवल पढ़ा जाए। उदाहरण के लिए अंतिम चर यदि आप कुछ डेटा का प्रतिनिधित्व करना चाहते हैं, जो कक्षा के प्रत्येक व्यक्तिगत उदाहरण से संबंधित है, लेकिन एक बार संग्रहीत बदला नहीं जा सकता। स्थिर और उदाहरण कुंजी शब्द का उपयोग आपकी डिज़ाइन आवश्यकताओं और डोमेन में डेटा का प्रतिनिधित्व करता है पर निर्भर करता है। यदि डेटा का उपयोग कक्षा के उदाहरणों में किया जाता है, तो प्रत्येक ऑब्जेक्ट के लिए अलग-अलग प्रतियां / मेमोरी संदर्भों की आवश्यकता नहीं है। यदि यह दोनों में से किसी में नहीं किया जाता है, तो संकलन समय त्रुटि दिखाई देगी। एक बार आरंभ करने के बाद, यदि आप किसी मूल्य को फिर से असाइन करने का प्रयास करते हैं तो आपको एक संकलन समय त्रुटि मिलेगी। स्थिर अंतिम चर का उपयोग करें जहां डेटा को कक्षा के सभी उदाहरणों में साझा किया जाएगा और आप चाहते हैं कि डेटा केवल पढ़ा जाए। उदाहरण के लिए अंतिम चर यदि आप कुछ डेटा का प्रतिनिधित्व करना चाहते हैं, जो कक्षा के प्रत्येक व्यक्तिगत उदाहरण से संबंधित है, लेकिन एक बार संग्रहीत बदला नहीं जा सकता। स्थिर और उदाहरण कुंजी शब्द का उपयोग आपकी डिज़ाइन आवश्यकताओं और डोमेन में डेटा का प्रतिनिधित्व करता है पर निर्भर करता है। यदि डेटा का उपयोग कक्षा के उदाहरणों में किया जाता है, तो प्रत्येक ऑब्जेक्ट के लिए अलग-अलग प्रतियां / मेमोरी संदर्भों की आवश्यकता नहीं है। यदि यह दोनों में से किसी में नहीं किया जाता है, तो संकलन समय त्रुटि दिखाई देगी। एक बार आरंभ करने के बाद, यदि आप किसी मूल्य को फिर से असाइन करने का प्रयास करते हैं तो आपको एक संकलन समय त्रुटि मिलेगी। स्थिर अंतिम चर का उपयोग करें जहां डेटा को कक्षा के सभी उदाहरणों में साझा किया जाएगा और आप चाहते हैं कि डेटा केवल पढ़ा जाए। उदाहरण के लिए अंतिम चर यदि आप कुछ डेटा का प्रतिनिधित्व करना चाहते हैं, जो कक्षा के प्रत्येक व्यक्तिगत उदाहरण से संबंधित है, लेकिन एक बार संग्रहीत बदला नहीं जा सकता। स्थिर और उदाहरण कुंजी शब्द का उपयोग आपकी डिज़ाइन आवश्यकताओं और डोमेन में डेटा का प्रतिनिधित्व करता है पर निर्भर करता है। यदि डेटा का उपयोग कक्षा के उदाहरणों में किया जाता है, तो प्रत्येक ऑब्जेक्ट के लिए अलग-अलग प्रतियां / मेमोरी संदर्भों की आवश्यकता नहीं है। स्थिर अंतिम चर का उपयोग करें जहां डेटा को कक्षा के सभी उदाहरणों में साझा किया जाएगा और आप चाहते हैं कि डेटा केवल पढ़ा जाए। उदाहरण के लिए अंतिम चर यदि आप कुछ डेटा का प्रतिनिधित्व करना चाहते हैं, जो कक्षा के प्रत्येक व्यक्तिगत उदाहरण से संबंधित है, लेकिन एक बार संग्रहीत बदला नहीं जा सकता। स्थिर और उदाहरण कुंजी शब्द का उपयोग आपकी डिज़ाइन आवश्यकताओं और डोमेन में डेटा का प्रतिनिधित्व करता है पर निर्भर करता है। यदि डेटा का उपयोग कक्षा के उदाहरणों में किया जाता है, तो प्रत्येक ऑब्जेक्ट के लिए अलग-अलग प्रतियां / मेमोरी संदर्भों की आवश्यकता नहीं है। स्थिर अंतिम चर का उपयोग करें जहां डेटा को कक्षा के सभी उदाहरणों में साझा किया जाएगा और आप चाहते हैं कि डेटा केवल पढ़ा जाए। उदाहरण के लिए अंतिम चर यदि आप कुछ डेटा का प्रतिनिधित्व करना चाहते हैं, जो कक्षा के प्रत्येक व्यक्तिगत उदाहरण से संबंधित है, लेकिन एक बार संग्रहीत बदला नहीं जा सकता। स्थिर और उदाहरण कुंजी शब्द का उपयोग आपकी डिज़ाइन आवश्यकताओं और डोमेन में डेटा का प्रतिनिधित्व करता है पर निर्भर करता है। यदि डेटा का उपयोग कक्षा के उदाहरणों में किया जाता है, तो प्रत्येक ऑब्जेक्ट के लिए अलग-अलग प्रतियां / मेमोरी संदर्भों की आवश्यकता नहीं है। स्थिर और उदाहरण कुंजी शब्द का उपयोग आपकी डिज़ाइन आवश्यकताओं और डोमेन में डेटा का प्रतिनिधित्व करता है पर निर्भर करता है। यदि डेटा का उपयोग कक्षा के उदाहरणों में किया जाता है, तो प्रत्येक ऑब्जेक्ट के लिए अलग-अलग प्रतियां / मेमोरी संदर्भों की आवश्यकता नहीं है। स्थिर और उदाहरण कुंजी शब्द का उपयोग आपकी डिज़ाइन आवश्यकताओं और डोमेन में डेटा का प्रतिनिधित्व करता है पर निर्भर करता है। यदि डेटा का उपयोग कक्षा के उदाहरणों में किया जाता है, तो प्रत्येक ऑब्जेक्ट के लिए अलग-अलग प्रतियां / मेमोरी संदर्भों की आवश्यकता नहीं है।