java - जावा आंतरिक वर्ग और स्थैतिक घोंसला वर्ग




inner-classes (16)

जावा में एक आंतरिक वर्ग और एक स्थिर नेस्टेड कक्षा के बीच मुख्य अंतर क्या है? क्या इनमें से किसी एक को चुनने में डिजाइन / कार्यान्वयन एक भूमिका निभाता है?


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

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

class A
{
  class B
  {
    // static int x; not allowed here…..    
  }
  static class C
  {
    static int x; // allowed here
  }
}

class Test
{
  public static void main(String… str)
  {
    A o=new A();
    A.B obj1 =o.new B();//need of inclosing instance

    A.C obj2 =new A.C();

    // not need of reference of object of outer class….
  }
}

जावा आंतरिक वर्ग और स्थैतिक घोंसला वर्ग के बीच महत्वपूर्ण अंतर और समानताएं यहां दी गई हैं।

आशा करता हूँ की ये काम करेगा!

आंतरिक वर्ग

  • बाहरी वर्ग दोनों उदाहरण और स्थिर तरीकों और क्षेत्रों तक पहुंच सकते हैं
  • कक्षा को घेरने के उदाहरण के साथ संबद्ध, ताकि इसे तुरंत चालू करने के लिए बाहरी वर्ग (नोट नया कीवर्ड स्थान) की आवश्यकता हो:

    Outerclass.InnerClass innerObject = outerObject.new Innerclass();
    
  • किसी स्थिर सदस्य को परिभाषित नहीं कर सकते हैं

  • कक्षा या इंटरफ़ेस घोषणा नहीं हो सकती है

स्टेटिक नेस्टेड क्लास

  • बाहरी वर्ग उदाहरण विधियों या क्षेत्रों तक नहीं पहुंच सकता है

  • कक्षा को संलग्न करने के किसी भी उदाहरण से जुड़ा नहीं है तो इसे तुरंत चालू करें:

    OuterClass.StaticNestedClass nestedObject = new OuterClass.StaticNestedClass();
    

समानताएँ

  • दोनों आंतरिक कक्षाएं भी निजी क्षेत्र और बाहरी वर्ग के तरीकों तक पहुंच सकती हैं
  • इसके अलावा बाहरी वर्ग के पास निजी क्षेत्रों और आंतरिक कक्षाओं के तरीकों तक पहुंच है
  • दोनों वर्गों में निजी, संरक्षित या सार्वजनिक पहुंच संशोधक हो सकता है

नेस्टेड क्लासेस का उपयोग क्यों करें?

ओरेकल दस्तावेज के अनुसार कई कारण हैं ( पूर्ण दस्तावेज ):

  • यह तार्किक रूप से वर्गीकृत वर्गों का एक तरीका है जो केवल एक ही स्थान पर उपयोग किया जाता है: यदि कोई वर्ग केवल एक अन्य वर्ग के लिए उपयोगी है, तो यह उस वर्ग में एम्बेड करने और दोनों को एक साथ रखने के लिए तार्किक है। इस तरह के "सहायक वर्ग" नेस्टिंग अपने पैकेज को अधिक सुव्यवस्थित बनाता है।

  • यह encapsulation बढ़ता है: दो शीर्ष स्तरीय वर्गों, ए और बी पर विचार करें, जहां बी को ए के सदस्यों तक पहुंच की आवश्यकता है जो अन्यथा निजी घोषित किया जाएगा। कक्षा ए के भीतर कक्षा बी को छुपाकर, ए के सदस्यों को निजी घोषित किया जा सकता है और बी उन्हें एक्सेस कर सकता है। इसके अलावा, बी को बाहरी दुनिया से छुपाया जा सकता है।

  • यह अधिक पठनीय और रखरखाव योग्य कोड का कारण बन सकता है: शीर्ष-स्तरीय कक्षाओं के भीतर छोटे वर्गों को घोंसला करना कोड को उस स्थान के करीब रखता है जहां इसका उपयोग किया जाता है।


नेस्टेड क्लास: क्लास के अंदर कक्षा

प्रकार:

  1. स्टेटिक नेस्टेड क्लास
  2. गैर स्थैतिक घोंसला वर्ग [आंतरिक वर्ग]

अंतर:

गैर स्थैतिक घोंसला वर्ग [आंतरिक वर्ग]

आंतरिक वर्ग की गैर स्थैतिक घोंसला वाली कक्षा वस्तु बाहरी वर्ग की वस्तु के भीतर मौजूद है। ताकि बाहरी वर्ग का डेटा सदस्य आंतरिक वर्ग तक पहुंच योग्य हो। तो आंतरिक वर्ग की वस्तु बनाने के लिए हमें पहले बाहरी वर्ग की वस्तु बनाना होगा।

outerclass outerobject=new outerobject();
outerclass.innerclass innerobjcet=outerobject.new innerclass(); 

स्टेटिक नेस्टेड क्लास

आंतरिक कक्षा के स्थिर नेस्टेड वर्ग वस्तु में बाहरी वर्ग की वस्तु की आवश्यकता नहीं होती है, क्योंकि "स्थैतिक" शब्द वस्तु बनाने की कोई आवश्यकता नहीं दर्शाता है।

class outerclass A {
    static class nestedclass B {
        static int x = 10;
    }
}

यदि आप एक्स तक पहुंचना चाहते हैं, तो निम्न अंदरूनी विधि लिखें

  outerclass.nestedclass.x;  i.e. System.out.prinltn( outerclass.nestedclass.x);

नेस्टेड स्थैतिक वर्गों के उपयोग के बारे में एक सूक्ष्मता है जो कुछ स्थितियों में उपयोगी हो सकती है।

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

इस उदाहरण पर विचार करें:

public class C0 {

    static C0 instance = null;

    // Uncomment the following line and a null pointer exception will be
    // generated before anything gets printed.
    //public static final String outerItem = instance.makeString(98.6);

    public C0() {
        instance = this;
    }

    public String makeString(int i) {
        return ((new Integer(i)).toString());
    }

    public String makeString(double d) {
        return ((new Double(d)).toString());
    }

    public static final class nested {
        public static final String innerItem = instance.makeString(42);
    }

    static public void main(String[] argv) {
        System.out.println("start");
        // Comment out this line and a null pointer exception will be
        // generated after "start" prints and before the following
        // try/catch block even gets entered.
        new C0();
        try {
            System.out.println("retrieve item: " + nested.innerItem);
        }
        catch (Exception e) {
            System.out.println("failed to retrieve item: " + e.toString());
        }
        System.out.println("finish");
    }
}

भले ही 'नेस्टेड' और 'आंतरिक इटिम' दोनों को 'स्थिर अंतिम' घोषित किया गया हो। nested.innerItem की सेटिंग तब तक नहीं होती है जब तक वर्ग को तत्काल नहीं किया जाता है (या कम से कम तब तक नहीं जब तक नेस्टेड स्थिर आइटम को संदर्भित नहीं किया जाता है), जैसा कि आप उन पंक्तियों पर टिप्पणी करके और टिप्पणी कर सकते हैं जिन्हें मैं संदर्भित करता हूं, ऊपर। 'OuterItem' के लिए भी यह सच नहीं है।

कम से कम यह मैं जावा 6.0 में देख रहा हूँ।


मुझे नहीं लगता कि उपरोक्त उत्तरों में वास्तविक अंतर स्पष्ट हो गया है।

शर्तों को सही करने के लिए सबसे पहले:

  • एक नेस्टेड क्लास एक वर्ग है जो स्रोत कोड स्तर पर किसी अन्य वर्ग में निहित है।
  • यदि आप स्थिर संशोधक के साथ इसे घोषित करते हैं तो यह स्थिर है
  • एक गैर स्थैतिक घोंसला वर्ग को आंतरिक कक्षा कहा जाता है। (मैं गैर स्थैतिक घोंसला वर्ग के साथ रहना।)

मार्टिन का जवाब अभी तक सही है। हालांकि, वास्तविक सवाल यह है कि: नेस्टेड क्लास को स्थैतिक घोषित करने का उद्देश्य क्या है या नहीं?

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

गैर स्थैतिक घोंसला वाले वर्ग एक अलग जानवर हैं। गुमनाम आंतरिक कक्षाओं के समान, ऐसे घोंसला वाले वर्ग वास्तव में बंद होते हैं। इसका मतलब है कि वे अपने आसपास के दायरे और उनके संलग्न उदाहरण को पकड़ते हैं और इसे सुलभ बनाते हैं। शायद एक उदाहरण यह स्पष्ट करेगा। कंटेनर का यह स्टब देखें:

public class Container {
    public class Item{
        Object data;
        public Container getContainer(){
            return Container.this;
        }
        public Item(Object data) {
            super();
            this.data = data;
        }

    }

    public static Item create(Object data){
        // does not compile since no instance of Container is available
        return new Item(data);
    }
    public Item createSubItem(Object data){
        // compiles, since 'this' Container is available
        return new Item(data);
    }
}

इस मामले में आप एक बच्चे के आइटम से मूल कंटेनर में एक संदर्भ चाहते हैं। एक गैर स्थैतिक घोंसला वर्ग का उपयोग करना, यह कुछ काम के बिना काम करता है। आप कंटेनर कंटेनर के साथ कंटेनर के संलग्न उदाहरण तक पहुंच सकते हैं। यह।

निम्नलिखित अधिक कट्टर स्पष्टीकरण:

यदि आप जावा बाइटकोड देखते हैं तो संकलक एक (गैर स्थैतिक) नेस्टेड क्लास के लिए उत्पन्न करता है, यह भी स्पष्ट हो सकता है:

// class version 49.0 (49)
// access flags 33
public class Container$Item {

  // compiled from: Container.java
  // access flags 1
  public INNERCLASS Container$Item Container Item

  // access flags 0
  Object data

  // access flags 4112
  final Container this$0

  // access flags 1
  public getContainer() : Container
   L0
    LINENUMBER 7 L0
    ALOAD 0: this
    GETFIELD Container$Item.this$0 : Container
    ARETURN
   L1
    LOCALVARIABLE this Container$Item L0 L1 0
    MAXSTACK = 1
    MAXLOCALS = 1

  // access flags 1
  public <init>(Container,Object) : void
   L0
    LINENUMBER 12 L0
    ALOAD 0: this
    ALOAD 1
    PUTFIELD Container$Item.this$0 : Container
   L1
    LINENUMBER 10 L1
    ALOAD 0: this
    INVOKESPECIAL Object.<init>() : void
   L2
    LINENUMBER 11 L2
    ALOAD 0: this
    ALOAD 2: data
    PUTFIELD Container$Item.data : Object
    RETURN
   L3
    LOCALVARIABLE this Container$Item L0 L3 0
    LOCALVARIABLE data Object L0 L3 2
    MAXSTACK = 2
    MAXLOCALS = 3
}

जैसा कि आप देख सकते हैं कि कंपाइलर एक छिपे हुए फ़ील्ड Container this$0 बनाता है। यह कन्स्ट्रक्टर में सेट है जिसमें संलग्न उदाहरण निर्दिष्ट करने के लिए कंटेनर का एक अतिरिक्त पैरामीटर है। आप इस पैरामीटर को स्रोत में नहीं देख सकते हैं लेकिन संकलक पूरी तरह से इसे नेस्टेड क्लास के लिए उत्पन्न करता है।

मार्टिन का उदाहरण

OuterClass.InnerClass innerObject = outerObject.new InnerClass();

तो कुछ (जैसे बाइटकोड में) की कॉल के लिए संकलित किया जाएगा

new InnerClass(outerObject)

परिपूर्णता के लिए:

एक अज्ञात वर्ग एक गैर स्थैतिक घोंसला वाले वर्ग का एक आदर्श उदाहरण है जिसका अभी कोई नाम नहीं है और बाद में संदर्भित नहीं किया जा सकता है।


मुझे नहीं लगता कि यहां जोड़ने के लिए बहुत कुछ है, ज्यादातर जवाब स्थिर नेस्टेड क्लास और इनर क्लास के बीच मतभेदों को पूरी तरह समझाते हैं। हालांकि, नेस्टेड कक्षाओं बनाम आंतरिक कक्षाओं का उपयोग करते समय निम्नलिखित मुद्दे पर विचार करें। जैसा कि कुछ उत्तरों में उल्लेख किया गया है, आंतरिक वर्गों को उनके संलग्न वर्ग के बिना तत्काल नहीं किया जा सकता है, जिसका अर्थ यह है कि उन्होंने अपनी संलग्न कक्षा के उदाहरण के लिए एक पॉइंटर रखा है जो जीसी तथ्य के कारण मेमोरी ओवरफ्लो या स्टैक ओवरफ़्लो अपवाद का कारण बन सकता है कचरा कक्षाओं को इकट्ठा करने में सक्षम नहीं होंगे, भले ही उनका उपयोग नहीं किया जाता है। यह स्पष्ट करने के लिए निम्न कोड को जांचें:

public class Outer {


    public  class Inner {

    }


    public Inner inner(){
        return new Inner();
    }

    @Override
    protected void finalize() throws Throwable {
    // as you know finalize is called by the garbage collector due to destroying an object instance
        System.out.println("I am destroyed !");
    }
}


public static void main(String arg[]) {

    Outer outer = new Outer();
    Outer.Inner inner = outer.new Inner();

    // out instance is no more used and should be garbage collected !!!
    // However this will not happen as inner instance is still alive i.e used, not null !
    // and outer will be kept in memory until inner is destroyed
    outer = null;

    //
    // inner = null;

    //kick out garbage collector
    System.gc();

}

यदि आप // inner = null; पर टिप्पणी हटाते हैं // inner = null; कार्यक्रम " मैं नष्ट हो गया हूँ " डाल दिया जाएगा, लेकिन इस टिप्पणी को ध्यान में रखते हुए यह नहीं होगा।
इसका कारण यह है कि सफेद आंतरिक उदाहरण अभी भी संदर्भित है जीसी इसे एकत्र नहीं कर सकता है और क्योंकि यह बाहरी उदाहरण के लिए संदर्भ (एक सूचक है) इसे भी एकत्र नहीं किया जाता है। अपनी परियोजना में इन वस्तुओं में से पर्याप्त होने और स्मृति से बाहर हो सकता है।
स्थैतिक आंतरिक कक्षाओं की तुलना में जो आंतरिक कक्षा के उदाहरण को इंगित नहीं करता है क्योंकि यह उदाहरण से संबंधित नहीं है लेकिन वर्ग से संबंधित है। उपर्युक्त प्रोग्राम प्रिंट कर सकता है " मैं नष्ट हो गया हूं! " यदि आप आंतरिक कक्षा स्थिर करते हैं और Outer.Inner i = new Outer.Inner(); साथ तत्काल होते हैं। Outer.Inner i = new Outer.Inner();


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

अवलोकन

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

अंतर

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

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

निष्कर्ष

इसलिए डिजाइन स्टैंडपॉइंट से दोनों के बीच मुख्य अंतर यह है कि: नॉनस्टैटिक नेस्टेड क्लास कंटेनर क्लास के उदाहरण तक पहुंच सकता है, जबकि स्थिर नहीं हो सकता है


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

public class Outer {
    public class Inner {}

    public static class Nested {}
}

हालांकि यह वास्तव में व्यापक रूप से स्वीकार्य परिभाषा नहीं है।


जावा ट्यूटोरियल कहता है :

शब्दावली: नेस्टेड कक्षाओं को दो श्रेणियों में विभाजित किया जाता है: स्थैतिक और गैर स्थैतिक। स्थाई घोषित किए गए नेस्टेड कक्षाओं को केवल स्थैतिक घोंसला वाले वर्ग कहा जाता है। गैर स्थैतिक घोंसले वाले वर्गों को आंतरिक कक्षाएं कहा जाता है।

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

कक्षाओं को विज्ञापन infinitum घोंसला जा सकता है, उदाहरण के लिए कक्षा ए कक्षा बी हो सकता है जिसमें कक्षा सी शामिल है जिसमें कक्षा डी, आदि शामिल हैं। हालांकि, कक्षा घोंसले के एक से अधिक स्तर दुर्लभ हैं, क्योंकि यह आमतौर पर खराब डिजाइन है।

नेस्टेड क्लास बनाने के तीन कारण हैं:

  • संगठन: कभी-कभी किसी वर्ग को किसी अन्य वर्ग के नामस्थान में क्रमबद्ध करने के लिए सबसे समझदार लगता है, खासकर जब इसका उपयोग किसी अन्य संदर्भ में नहीं किया जाएगा
  • पहुंच: नेस्टेड कक्षाओं में उनके युक्त वर्गों के चर / फ़ील्ड के लिए विशेष पहुंच होती है (ठीक है कि वेरिएबल्स / फ़ील्ड नेस्टेड क्लास की तरह, आंतरिक या स्थिर) पर निर्भर करता है।
  • सुविधा: हर नए प्रकार के लिए एक नई फाइल बनाने के लिए परेशान है, फिर, खासकर जब प्रकार केवल एक संदर्भ में उपयोग किया जाएगा

जावा में चार प्रकार की नेस्टेड कक्षाएं हैं । संक्षेप में, वे हैं:

  • स्थैतिक वर्ग : किसी अन्य वर्ग के स्थिर सदस्य के रूप में घोषित किया गया
  • आंतरिक वर्ग : किसी अन्य वर्ग के उदाहरण सदस्य के रूप में घोषित किया गया
  • स्थानीय आंतरिक वर्ग : किसी अन्य वर्ग की एक उदाहरण विधि के अंदर घोषित किया गया
  • गुमनाम आंतरिक वर्ग : स्थानीय आंतरिक वर्ग की तरह, लेकिन एक अभिव्यक्ति के रूप में लिखा जाता है जो एक-ऑफ ऑब्जेक्ट देता है

मुझे अधिक जानकारी में विस्तार से बताएं।


स्टेटिक क्लासेस

स्टेटिक क्लास समझने का सबसे आसान तरीका है क्योंकि उनके पास कक्षा के उदाहरणों के साथ कुछ लेना देना नहीं है।

एक स्थैतिक वर्ग एक वर्ग है जो किसी अन्य वर्ग के स्थिर सदस्य के रूप में घोषित किया जाता है। अन्य स्थिर सदस्यों की तरह, इस तरह की कक्षा वास्तव में केवल एक हैंगर है जो उस वर्ग को अपने नामस्थान के रूप में उपयोग करती है, उदाहरण के लिए पैकेज पिट में कक्षा राइनो के स्थिर सदस्य के रूप में घोषित कक्षा बकरी को पिज्जा नाम से जाना जाता है। Rino.Goat

package pizza;

public class Rhino {

    ...

    public static class Goat {
        ...
    }
}

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


आंतरिक कक्षाएं

एक आंतरिक वर्ग एक वर्ग है जो किसी अन्य वर्ग के गैर-स्थैतिक सदस्य के रूप में घोषित किया जाता है:

package pizza;

public class Rhino {

    public class Goat {
        ...
    }

    private void jerry() {
        Goat g = new Goat();
    }
}

एक स्थिर वर्ग की तरह, आंतरिक वर्ग को इसके वर्ग के नाम, पिज्जा द्वारा योग्यता के रूप में जाना जाता है। Rino.Goat , लेकिन युक्त वर्ग के अंदर, इसे अपने सरल नाम से जाना जा सकता है। हालांकि, एक आंतरिक वर्ग का हर उदाहरण अपनी कक्षा के एक विशेष उदाहरण से जुड़ा हुआ है: उपरोक्त, जेरी में बनाई गई बकरी , जेरी में राइनो उदाहरण के साथ पूरी तरह से बंधी हुई है। अन्यथा, जब हम बकरी को तत्काल करते हैं तो हम जुड़े राइनो इंस्टेंस को स्पष्ट करते हैं:

Rhino rhino = new Rhino();
Rhino.Goat goat = rhino.new Goat();

(ध्यान दें कि आप अजीब नए वाक्यविन्यास में केवल बकरी के रूप में आंतरिक प्रकार को संदर्भित करते हैं: जावा राइनो भाग से युक्त प्रकार का अनुमान लगाता है। और, हाँ नया rhino.Goat () मुझे भी अधिक समझ में आता।)

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

public class Rhino {

    private String barry;

    public class Goat {
        public void colin() {
            System.out.println(barry);
        }
    }
}

आंतरिक कक्षा में, आप इस श्रेणी के राइनो के रूप में संदर्भित कर सकते हैं। यह आप इसका उपयोग अपने सदस्यों, जैसे Rhino.this.barry के संदर्भ में कर सकते हैं।


स्थानीय आंतरिक कक्षाएं

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

चूंकि स्थानीय आंतरिक वर्ग न तो वर्ग या पैकेज का सदस्य होता है, इसलिए इसे पहुंच स्तर के साथ घोषित नहीं किया जाता है। (हालांकि, स्पष्ट रहें कि अपने सदस्यों के पास सामान्य वर्ग की तरह पहुंच स्तर हैं।)

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


बेनामी आंतरिक कक्षाएं

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

new *ParentClassName*(*constructorArgs*) {*members*}

यह एक अज्ञात वर्ग का एक नया उदाहरण लौटने वाला एक अभिव्यक्ति है जो ParentClassName को बढ़ाता है। आप अपना खुद का कन्स्ट्रक्टर नहीं दे सकते; बल्कि, एक को पूरी तरह से आपूर्ति की जाती है जो केवल सुपर कन्स्ट्रक्टर को कॉल करती है, इसलिए प्रदान किए गए तर्क सुपर कन्स्ट्रक्टर फिट होना चाहिए। (यदि अभिभावक में कई रचनाकार होते हैं, तो "सरलतम" को नियमों के बजाय जटिल नियमों के आधार पर "सरलतम" कहा जाता है, जो विस्तार से सीखने के लिए परेशान नहीं हैं - केवल नेटबीन या ग्रहण के बारे में आपको ध्यान दें।)

वैकल्पिक रूप से, आप कार्यान्वित करने के लिए एक इंटरफ़ेस निर्दिष्ट कर सकते हैं:

new *InterfaceName*() {*members*}

इस तरह की एक घोषणा एक अज्ञात वर्ग का एक नया उदाहरण बनाती है जो ऑब्जेक्ट और कार्यान्वयन इंटरफेसनाम को बढ़ाती है। फिर, आप अपने स्वयं के कन्स्ट्रक्टर की आपूर्ति नहीं कर सकते; इस मामले में, जावा निस्संदेह नो-एर्ग, डू-कन्फ कन्स्ट्रक्टर की आपूर्ति नहीं करता है (इसलिए इस मामले में कभी भी कन्स्ट्रक्टर तर्क नहीं होंगे)।

भले ही आप अज्ञात आंतरिक वर्ग को एक कन्स्ट्रक्टर नहीं दे सकते हैं, फिर भी आप किसी भी सेटअप को प्रारंभकर्ता ब्लॉक (किसी भी विधि के बाहर रखा गया {} ब्लॉक) का उपयोग करके कर सकते हैं।

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


जावा ट्यूटोरियल से :

नेस्टेड कक्षाओं को दो श्रेणियों में बांटा गया है: स्थैतिक और गैर स्थैतिक। स्थाई घोषित किए गए नेस्टेड कक्षाओं को केवल स्थैतिक घोंसला वाले वर्ग कहा जाता है। गैर स्थैतिक घोंसले वाले वर्गों को आंतरिक कक्षाएं कहा जाता है।

संलग्न कक्षा के नाम का उपयोग करके स्टेटिक नेस्टेड कक्षाओं का उपयोग किया जाता है:

OuterClass.StaticNestedClass

उदाहरण के लिए, स्थिर नेस्टेड क्लास के लिए ऑब्जेक्ट बनाने के लिए, इस वाक्यविन्यास का उपयोग करें:

OuterClass.StaticNestedClass nestedObject = new OuterClass.StaticNestedClass();

ऑब्जेक्ट्स जो एक आंतरिक वर्ग के उदाहरण हैं बाहरी वर्ग के उदाहरण के भीतर मौजूद हैं। निम्नलिखित वर्गों पर विचार करें:

class OuterClass {
    ...
    class InnerClass {
        ...
    }
}

इनरक्लास का एक उदाहरण केवल ऑउटर क्लास के उदाहरण के भीतर मौजूद हो सकता है और इसके संलग्न उदाहरण के तरीकों और क्षेत्रों तक सीधे पहुंच हो सकती है।

एक आंतरिक वर्ग को तुरंत चालू करने के लिए, आपको पहले बाहरी वर्ग को तुरंत चालू करना होगा। फिर, इस वाक्यविन्यास के साथ बाहरी वस्तु के भीतर आंतरिक वस्तु बनाएं:

OuterClass.InnerClass innerObject = outerObject.new InnerClass();

देखें: जावा ट्यूटोरियल - नेस्टेड क्लासेस

पूर्णता के लिए ध्यान दें कि एक संलग्न वर्ग के बिना एक आंतरिक वर्ग के रूप में ऐसी चीज भी है:

class A {
  int t() { return 1; }
  static A a =  new A() { int t() { return 2; } };
}

यहां, new A() { ... } एक स्थिर संदर्भ में परिभाषित एक आंतरिक वर्ग है और इसमें एक संलग्न उदाहरण नहीं है।


Inner class and nested static class in Java both are classes declared inside another class, known as top level class in Java. In Java terminology, If you declare a nested class static, it will called nested static class in Java while non static nested class are simply referred as Inner Class.

What is Inner Class in Java?

Any class which is not a top level or declared inside another class is known as nested class and out of those nested classes, class which are declared non static are known as Inner class in Java. there are three kinds of Inner class in Java:

1) Local inner class - is declared inside a code block or method.
2) Anonymous inner class - is a class which doesn't have name to reference and initialized at same place where it gets created.
3) Member inner class - is declared as non static member of outer class.

public class InnerClassTest {
    public static void main(String args[]) {      
        //creating local inner class inside method i.e. main() 
        class Local {
            public void name() {
                System.out.println("Example of Local class in Java");

            }
        }      
        //creating instance of local inner class
        Local local = new Local();
        local.name(); //calling method from local inner class

        //Creating anonymous inner class in Java for implementing thread
        Thread anonymous = new Thread(){
            @Override
            public void run(){
                System.out.println("Anonymous class example in java");
            }
        };
        anonymous.start();

        //example of creating instance of inner class
        InnerClassTest test = new InnerClassTest();
        InnerClassTest.Inner inner = test.new Inner();
        inner.name(); //calling method of inner class
    }

     //Creating Inner class in Java
    private class Inner{
        public void name(){
            System.out.println("Inner class example in java");
        }
    }
}

What is nested static class in Java?

Nested static class is another class which is declared inside a class as member and made static. Nested static class is also declared as member of outer class and can be make private, public or protected like any other member. One of the main benefit of nested static class over inner class is that instance of nested static class is not attached to any enclosing instance of Outer class. You also don't need any instance of Outer class to create instance of nested static class in Java .

1) It can access static data members of outer class including private.
2) Static nested class cannot access non-static (instance) data member or method .

public class NestedStaticExample {
    public static void main(String args[]){  
        StaticNested nested = new StaticNested();
        nested.name();
    }  
    //static nested class in java
    private static class StaticNested{
        public void name(){
            System.out.println("static nested class example in java");
        }
    }
}

Ref: Inner class and nested Static Class in Java with Example


First of all There is no such class called Static class.The Static modifier use with inner class (called as Nested Class) says that it is a static member of Outer Class which means we can access it as with other static members and without having any instance of Outer class. (Which is benefit of static originally.)

Difference between using Nested class and regular Inner class is:

OuterClass.InnerClass inner = new OuterClass().new InnerClass();

First We can to instantiate Outerclass then we Can access Inner.

But if Class is Nested then syntax is:

OuterClass.InnerClass inner = new OuterClass.InnerClass();

Which uses the static Syntax as normal implementation of static keyword.


I think people here should notice to Poster that : Static Nest Class just only the first inner class. उदाहरण के लिए:

 public static class A {} //ERROR

 public class A {
     public class B {
         public static class C {} //ERROR
     }
 }

 public class A {
     public static class B {} //COMPILE !!!

 }

So, summarize, static class doesn't depend which class its contains. So, they cannot in normal class. (because normal class need an instance).


The difference is that a nested class declaration that is also static can be instantiated outside of the enclosing class.

When you have a nested class declaration that is not static, also known as an inner class , Java won't let you instantiate it except via the enclosing class. The object created out of the inner class is linked to the object created from the outer class, so the inner class can reference the fields of the outer.

But if it's static, then the link does not exist, the outer fields cannot be accessed (except via an ordinary reference like any other object) and you can therefore instantiate the nested class by itself.


Ummm... an inner class IS a nested class... do you mean anonymous class and inner class?

Edit: If you actually meant inner vs anonymous... an inner class is just a class defined within a class such as:

public class A {
    public class B {
    }
}

Whereas an anonymous class is an extension of a class defined anonymously, so no actual "class is defined, as in:

public class A {
}

A anon = new A() { /* you could change behavior of A here */ };

Further Edit:

Wikipedia claims there is a difference in Java, but I've been working with Java for 8 years, and it's the first I heard such a distinction... not to mention there are no references there to back up the claim... bottom line, an inner class is a class defined within a class (static or not), and nested is just another term to mean the same thing.

There is a subtle difference between static and non-static nested class... basically non-static inner classes have implicit access to instance fields and methods of the enclosing class (thus they cannot be constructed in a static context, it will be a compiler error). Static nested classes, on the other hand, don't have implicit access to instance fields and methods, and CAN be constructed in a static context.


When we declare static member class inside a class, it is known as top level nested class or a static nested class. It can be demonstrated as below :

class Test{
    private static int x = 1;
        static class A{
        private static int y = 2;
        public static int getZ(){
            return B.z+x;
        }
    }
    static class B{
        private static int z = 3;
        public static int getY(){
            return A.y;
        }
    }
}

class TestDemo{
     public static void main(String[] args){
        Test t = new Test();
        System.out.println(Test.A.getZ());
        System.out.println(Test.B.getY());
    }
}

When we declare non-static member class inside a class it is known as inner class. Inner class can be demonstrated as below :

    class Test{
        private int i = 10;
        class A{
            private int i =20;
            void display(){
            int i = 30;
            System.out.println(i);
            System.out.println(this.i);
            System.out.println(Test.this.i);
        }
    }
}




inner-classes