java внутренний класс и статический вложенный класс

<p>в чем основное различие между внутренним классом и статическим вложенным классом в java? играет ли дизайн/реализация роль в выборе одного из них?</p>

<p>из <a href="http://java.sun.com/docs/books/tutorial/java/javaoo/nested.html">учебник по java</a> :</p><blockquote> <p>вложенные классы делятся на две категории: статические и нестатические. вложенные классы, которые объявлены статическими, просто называются статическими вложенными классами. нестатические вложенные классы называются внутренними классами.</p> </blockquote><p>доступ к статическим вложенным классам осуществляется с использованием имени включающего класса:</p><pre><code>outerclass.staticnestedclass </code></pre><p>например, чтобы создать объект для статического вложенного класса, используйте этот синтаксис:</p><pre><code>outerclass.staticnestedclass nestedobject = new outerclass.staticnestedclass(); </code></pre><p>объекты, которые являются экземплярами внутреннего класса, существуют в экземпляре внешнего класса. рассмотрим следующие классы:</p><pre><code>class outerclass { ... class innerclass { ... } } </code></pre><p>экземпляр innerclass может существовать только внутри экземпляра outerclass и имеет прямой доступ к методам и полям его включающего экземпляра.</p><p>чтобы создать экземпляр внутреннего класса, вы должны сначала создать экземпляр внешнего класса. затем создайте внутренний объект во внешнем объекте с этим синтаксисом:</p><pre><code>outerclass.innerclass innerobject = outerobject.new innerclass(); </code></pre><p>смотрите: <a href="http://download.oracle.com/javase/tutorial/java/javaoo/nested.html">учебник по java - вложенные классы</a> </p><p>для полноты заметим, что существует также такая вещь, как <a href="https://stackoverflow.com/questions/20468856/is-it-true-that-every-inner-class-requires-an-enclosing-instance">внутренний класс <em> без </em> включающего экземпляра</a> :</p><pre><code>class a { int t() { return 1; } static a a = new a() { int t() { return 2; } }; } </code></pre><p>здесь <code>new a() { ... }</code> является <em> внутренним классом, определенным в статическом контексте </em>, и не имеет включающего экземпляра.</p>

<p> <a href="http://java.sun.com/docs/books/tutorial/java/javaoo/nested.html">в руководстве по java написано</a> :</p><blockquote> <p>терминология: вложенные классы делятся на две категории: статические и нестатические. вложенные классы, которые объявлены статическими, просто называются статическими вложенными классами. нестатические вложенные классы называются внутренними классами.</p> </blockquote><p>в общем, термины "вложенный" и "внутренний" используются большинством программистов взаимозаменяемо, но я буду использовать правильный термин "вложенный класс", который охватывает как внутренний, так и статический.</p><p>классы могут быть вложенными <em>до бесконечности</em>, например класс a может содержать класс b, который содержит класс c, который содержит класс d и т. д. тем не менее, несколько уровней вложенности классов встречаются редко, так как обычно это плохой дизайн.</p><p>есть три причины, по которым вы можете создать вложенный класс:</p><ul> <li>организация: иногда кажется наиболее разумным отсортировать класс в пространство имен другого класса, особенно когда он не будет использоваться ни в каком другом контексте</li> <li>доступ: вложенные классы имеют специальный доступ к переменным/полям содержащихся в них классов (какие именно переменные/поля зависят от типа вложенного класса, внутреннего или статического).</li> <li>удобство: необходимость создавать новый файл для каждого нового типа, опять же, утомительна, особенно когда тип будет использоваться только в одном контексте</li> </ul><p>в java существует <strong> четыре вида вложенных классов </strong>. вкратце, это:</p><ul> <li><strong> статический класс </strong>: объявлен как статический член другого класса</li> <li><strong> внутренний класс </strong>: объявлен как член экземпляра другого класса</li> <li><strong> локальный внутренний класс </strong>: объявлен внутри метода экземпляра другого класса</li> <li><strong> анонимный внутренний класс </strong>: как локальный внутренний класс, но записан как выражение, которое возвращает одноразовый объект</li> </ul><p>позвольте мне остановиться подробнее.</p><p><br></p><h2>статические классы</h2><p>статические классы легче всего понять, поскольку они не имеют ничего общего с экземплярами содержащего класса.</p><p>статический класс - это класс, объявленный как статический член другого класса. как и другие статические члены, такой класс на самом деле является просто вешалкой, который использует содержащий класс в качестве своего пространства имен, <em>например</em> класс <em>goat</em>, объявленный как статический член класса - <em>носорог</em> в упаковке <em>пицца</em> известна под именем <em>pizza.rhino.goat</em>.</p><pre><code>package pizza; public class rhino { ... public static class goat { ... } } </code></pre><p>откровенно говоря, статические классы - довольно бесполезная особенность, потому что классы уже разделены на пространства имен пакетами. единственная реальная причина создания статического класса заключается в том, что такой класс имеет доступ к закрытым статическим членам своего содержащего класса, но я считаю, что это довольно слабое оправдание существования функции статического класса.</p><p><br></p><h2>внутренние классы</h2><p>внутренний класс - это класс, объявленный как нестатический член другого класса:</p><pre><code>package pizza; public class rhino { public class goat { ... } private void jerry() { goat g = new goat(); } } </code></pre><p>как и в случае статического класса, внутренний класс известен как квалифицированный по имени содержащего его класса <em>pizza.rhino.goat</em>, но внутри содержащего класса его можно узнать по его простому имени. однако каждый экземпляр внутреннего класса привязан к конкретному экземпляру содержащего его класса: выше, <em>goat</em>, созданный в <em>jerry</em>, неявно привязан к <em>rhino</em> экземпляр <em>это</em> в <em>джерри</em>. в противном случае мы делаем явным связанный экземпляр <em>rhino</em> при создании экземпляра <em>goat</em>:</p><pre><code>rhino rhino = new rhino(); rhino.goat goat = rhino.new goat(); </code></pre><p>(обратите внимание, что вы ссылаетесь на внутренний тип как просто <em>goat</em> в странном синтаксисе <em>new</em>: java выводит содержащий тип из <em>rhino</em> часть. и, да <em>new rhino.goat ()</em> мне тоже было бы понятнее.)</p><p>так что это нам дает? ну, внутренний экземпляр класса имеет доступ к членам экземпляра содержащего экземпляра класса. эти включающие элементы экземпляра называются внутри внутреннего класса <em>через</em> только их простые имена, а не <em>через</em> <em>это</em> (<em>это</em> во внутреннем классе ссылается на экземпляр внутреннего класса, а не на связанный с ним экземпляр класса):</p><pre><code>public class rhino { private string barry; public class goat { public void colin() { system.out.println(barry); } } } </code></pre><p>во внутреннем классе вы можете ссылаться на <em>this</em> содержащего класса как <em>rhino.this</em>, и вы можете использовать <em>this</em> для ссылки на его члены , <em>например rhino.this.barry</em>.</p><p><br></p><h2>местные внутренние классы</h2><p>локальный внутренний класс - это класс, объявленный в теле метода. такой класс известен только в пределах его содержащего метода, поэтому он может быть создан только для экземпляра и получить доступ к его членам в пределах содержащего его метода. преимущество заключается в том, что локальный экземпляр внутреннего класса привязан и может получить доступ к последним локальным переменным его содержащего метода. когда экземпляр использует последний локальный элемент своего содержащего метода, переменная сохраняет значение, которое оно содержало во время создания экземпляра, даже если переменная вышла из области видимости (это, по сути, грубая ограниченная версия замыканий java).</p><p>поскольку локальный внутренний класс не является ни членом класса, ни пакета, он не объявляется с уровнем доступа. (однако, имейте в виду, что его собственные члены имеют уровни доступа, как в обычном классе.)</p><p>если в методе экземпляра объявлен локальный внутренний класс, создание экземпляра внутреннего класса привязывается к экземпляру, который содержится в содержащем методе <em>this</em> во время создания экземпляра, и, таким образом, экземпляр содержащего класса члены доступны как в экземпляре внутреннего класса. локальный внутренний класс создается просто <em>через</em> его имя, <em>например</em> локальный внутренний класс <em>cat</em> создается как <em>new cat ()</em> =, не новый this.cat (), как вы могли ожидать.</p><p><br></p><h2>анонимные внутренние классы</h2><p>анонимный внутренний класс - это синтаксически удобный способ написания локального внутреннего класса. чаще всего локальный внутренний класс создается не более одного раза при каждом запуске содержащего его метода. тогда было бы хорошо, если бы мы могли объединить определение локального внутреннего класса и его единственное создание в одну удобную синтаксическую форму, и было бы также хорошо, если бы нам не приходилось придумывать имя для класса (тем меньше бесполезного имена ваш код содержит, тем лучше). анонимный внутренний класс допускает обе эти вещи:</p><pre><code>new *parentclassname*(*constructorargs*) {*members*} </code></pre><p>это выражение возвращает новый экземпляр безымянного класса, который расширяется <em>parentclassname</em>. вы не можете предоставить свой собственный конструктор; скорее, неявно предоставляется один, который просто вызывает супер-конструктор, поэтому предоставленные аргументы должны соответствовать супер-конструктору. (если родительский объект содержит несколько конструкторов, то называется "самый простой", "самый простой", что определяется довольно сложным набором правил, которые не стоит беспокоиться, чтобы их детально изучить - просто обратите внимание на то, что говорят вам netbeans или eclipse.)</p><p>в качестве альтернативы вы можете указать интерфейс для реализации:</p><pre><code>new *interfacename*() {*members*} </code></pre><p>такое объявление создает новый экземпляр безымянного класса, который расширяет object и реализует <em>interfacename</em>. опять же, вы не можете предоставить свой собственный конструктор; в этом случае java неявно предоставляет конструктор без аргументов, ничего не делающий (поэтому в этом случае никогда не будет аргументов конструктора).</p><p>даже если вы не можете дать анонимному внутреннему классу конструктор, вы все равно можете выполнить любую настройку, которую хотите, используя блок инициализатора (блок {}, помещенный вне любого метода).</p><p>имейте в виду, что анонимный внутренний класс - это просто менее гибкий способ создания локального внутреннего класса с одним экземпляром. если вам нужен локальный внутренний класс, который реализует несколько интерфейсов или который реализует интерфейсы, расширяя какой-то класс, отличный от <em>object</em>, или который задает свой собственный конструктор, вы застряли в создании обычного локального внутреннего класса с именем.</p>

<p>я не думаю, что реальная разница стала ясна в ответах выше.</p><p>сначала, чтобы получить правильные условия:</p><ul> <li>вложенный класс - это класс, который содержится в другом классе на уровне исходного кода.</li> <li>это статично, если вы объявляете это с помощью модификатора <strong>static</strong>.</li> <li>нестатический вложенный класс называется внутренним классом. (я остаюсь с нестатическим вложенным классом.)</li> </ul><p>ответ мартина пока прав. однако актуальный вопрос таков: какова цель объявления вложенного класса статическим или нет?</p><p>вы используете <strong>статические вложенные классы</strong>, если вы просто хотите сохранить ваши классы вместе, если они тематически принадлежат друг другу или если вложенный класс используется исключительно во включающем классе. нет никакой семантической разницы между статическим вложенным классом и любым другим классом.</p><p><strong>нестатические вложенные классы</strong> это другой зверь. подобно анонимным внутренним классам, такие вложенные классы на самом деле являются замыканиями. это означает, что они фиксируют окружающий их объем и включающий их экземпляр и делают его доступным. возможно, пример прояснит это. посмотрите эту заглушку контейнера:</p><pre><code>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); } } </code></pre><p>в этом случае вы хотите иметь ссылку от дочернего элемента на родительский контейнер. используя нестатический вложенный класс, это работает без какой-либо работы. вы можете получить доступ к включающему экземпляру контейнера с помощью синтаксиса <code>container.this</code>.</p><p>более жесткие объяснения следующие:</p><p>если вы посмотрите на байт-коды java, которые генерирует компилятор для (нестатического) вложенного класса, это может стать еще яснее:</p><pre><code>// 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 } </code></pre><p>как видите, компилятор создает скрытое поле <code>container this$0</code>. это устанавливается в конструкторе, который имеет дополнительный параметр типа container для указания включающего экземпляра. вы не можете видеть этот параметр в исходном коде, но компилятор неявно генерирует его для вложенного класса.</p><p>пример мартина</p><pre><code>outerclass.innerclass innerobject = outerobject.new innerclass(); </code></pre><p>так будет скомпилировано для вызова чего-то вроде (в байт-кодах)</p><pre><code>new innerclass(outerobject) </code></pre><p>для полноты картины:</p><p>анонимный класс <strong>is</strong> прекрасный пример нестатического вложенного класса, с которым просто не связано имя, и на который нельзя ссылаться позже.</p>

<p>я думаю, что ни один из приведенных выше ответов не объясняет вам реальную разницу между вложенным классом и статическим вложенным классом с точки зрения разработки приложения:</p><h2>overview</h2><p><strong>вложенный класс</strong> может быть нестатическим или статическим и в каждом случае <strong>это класс, определенный в другом классе</strong>. <strong>вложенный класс должен существовать только для обслуживания включающего класса</strong>, если вложенный класс полезен другими классами (не только включающими), его следует объявить как класс верхнего уровня.</p><h2>разница</h2><p><strong>нестатический вложенный класс</strong>: неявно связан с включающим экземпляром содержащего класса, это означает, что можно вызывать методы и обращаться к переменным включающего экземпляра. одним из распространенных применений нестатического вложенного класса является определение класса adapter.</p><p><strong>статический вложенный класс</strong>: не может получить доступ к экземпляру включающего класса и вызвать для него методы, поэтому его следует использовать, когда вложенный класс не требует доступа к экземпляру включающего класса. обычным использованием статического вложенного класса является реализация компонентов внешнего объекта.</p><h2>заключение</h2><p>таким образом, основное различие между ними с точки зрения проектирования заключается в том, что <em> нестатический вложенный класс может обращаться к экземпляру класса контейнера, а статический - нет </em>.</p>

<p>проще говоря, нам нужны вложенные классы в первую очередь потому, что java не обеспечивает замыкания.</p><p>вложенные классы - это классы, определенные внутри тела другого включающего класса. они бывают двух типов - статические и нестатические.</p><p>они рассматриваются как члены включающего класса, поэтому вы можете указать любой из четырех спецификаторов доступа - <code>private, package, protected, public</code>. у нас нет такой роскоши с классами верхнего уровня, которые могут быть объявлены только <code>public</code> или package-private.</p><p>внутренние классы или классы, не являющиеся стеками, имеют доступ к другим членам высшего класса, даже если они объявлены закрытыми, в то время как статические вложенные классы не имеют доступа к другим членам высшего класса.</p><pre><code>public class outerclass { public static class inner1 { } public class inner2 { } } </code></pre><p><code>inner1</code> это наш статический внутренний класс, а <code>inner2</code> это наш внутренний класс, который не является статическим. основное различие между ними заключается в том, что вы не можете создать экземпляр <code>inner2</code> без outer, где вы можете создать объект <code>inner1</code> независимо.</p><p>когда вы будете использовать inner class?</p><p>подумайте о ситуации, когда <code>class a</code> и <code>class b</code> связаны, <code>class b</code> должен иметь доступ к членам <code>class a</code>, а <code>class b</code> связан только с <code>class a</code>. внутренние классы входят в картину.</p><p>для создания экземпляра внутреннего класса вам нужно создать экземпляр вашего внешнего класса.</p><pre><code>outerclass outer = new outerclass(); outerclass.inner2 inner = outer.new inner2(); </code></pre><p>или же</p><pre><code>outerclass.inner2 inner = new outerclass().new inner2(); </code></pre><p>когда бы вы использовали статический inner класс?</p><p>вы бы определили статический внутренний класс, когда знаете, что он не имеет никакого отношения к экземпляру включающего класса/верхнего класса. если ваш внутренний класс не использует методы или поля внешнего класса, это просто пустая трата пространства, поэтому сделайте его статичным.</p><p>например, чтобы создать объект для статического вложенного класса, используйте этот синтаксис:</p><pre><code>outerclass.inner1 nestedobject = new outerclass.inner1(); </code></pre><p>преимущество статического вложенного класса в том, что ему не нужен объект содержащего класса/верхнего класса для работы. это может помочь вам уменьшить количество объектов, создаваемых вашим приложением во время выполнения.</p>

<p>я думаю, что соглашение, которое обычно соблюдается, таково:</p><ul> <li><strong>статический класс</strong> внутри класса верхнего уровня является <strong>вложенный класс</strong></li> <li><strong>нестатический класс</strong> внутри класса верхнего уровня является <strong>внутренний класс</strong>, который дополнительно имеет еще две формы: <ul> <li><strong>локальный класс</strong> - именованные классы, объявленные внутри блока, как тело метода или конструктора</li> <li><strong>анонимный класс</strong> - безымянные классы, экземпляры которых создаются в выражениях и выражениях</li> </ul> </li> </ul><p>тем не менее, несколько других <strong>указывает на помнить</strong> являются:</p><ul> <li> <p>классы верхнего уровня и статический вложенный класс семантически одинаковы, за исключением того, что в случае статического вложенного класса он может делать статическую ссылку на частные статические поля/методы своего класса outer [parent] и наоборот.</p> </li> <li> <p>внутренние классы имеют доступ к переменным экземпляра окружающего экземпляра класса outer [parent]. однако не все внутренние классы имеют вложенные экземпляры, например, внутренние классы в статических контекстах, как анонимный класс, используемый в статическом блоке инициализатора, не имеют.</p> </li> <li> <p>по умолчанию анонимный класс расширяет родительский класс или реализует родительский интерфейс, и больше нет условий для расширения какого-либо другого класса или реализации каких-либо дополнительных интерфейсов. так,</p> <ul> <li><code>new yourclass(){};</code> означает <code>class [anonymous] extends yourclass {}</code></li> <li><code>new yourinterface(){};</code> означает <code>class [anonymous] implements yourinterface {}</code></li> </ul> </li> </ul><hr><p>я чувствую, что большой вопрос, который остается открытым, какой использовать и когда? ну, это в основном зависит от того, с каким сценарием вы имеете дело, но чтение ответа, данного @jrudolph, может помочь вам принять какое-то решение.</p>

<p>вот ключевые различия и сходства между внутренним классом java и статическим вложенным классом.</p><p>надеюсь, поможет!</p><h3>внутренний класс</h3><ul> <li><strong>может обращаться</strong> к внешнему классу <strong>как экземпляр, так и статические</strong> методы и поля</li> <li> <p><strong>связано с экземпляром включающего класса</strong>, поэтому для создания экземпляра сначала необходим экземпляр внешнего класса (примечание <em> new </em> ключевое место):</p> <pre><code>outerclass.innerclass innerobject = outerobject.new innerclass(); </code></pre></li> <li> <p><strong>не могу</strong> определить любой <strong>статические члены</strong> сам</p> </li> <li><strong>cannot</strong> иметь <strong>class</strong> или <strong>interface</strong> объявление</li> </ul><h3>статический вложенный класс</h3><ul> <li> <p><strong>невозможно получить доступ</strong> внешний класс <strong>экземпляр</strong> методы или поля</p> </li> <li> <p><strong>не связано ни с одним экземпляром включающего класса</strong> итак, чтобы создать его экземпляр:</p> <pre><code>outerclass.staticnestedclass nestedobject = new outerclass.staticnestedclass(); </code></pre></li> </ul><h3>сходства</h3><ul> <li>оба <strong>внутренние классы</strong> могут получить доступ даже к <strong>приватным полям и методам</strong> of <strong>внешний класс</strong></li> <li>также у <strong>outer class</strong> есть доступ к <strong>приватным полям и методам</strong> of <strong>внутренним классам</strong></li> <li>оба класса могут иметь закрытый, защищенный или общедоступный модификатор</li> </ul><h3>зачем использовать вложенные классы?</h3><p>согласно документации oracle есть несколько причин ( <a href="https://docs.oracle.com/javase/tutorial/java/javaoo/nested.html">полная документация</a> ):</p><blockquote> <ul> <li> <p><strong>это способ логически сгруппировать классы, которые используются только в одном месте:</strong> если класс полезен только для одного другого класса, то логично встраивать его в этот класс и сохранять их вместе. вложение таких "вспомогательных классов" делает их пакет более упорядоченным.</p> </li> <li> <p><strong>это увеличивает инкапсуляцию:</strong> рассмотрим два класса верхнего уровня, a и b, где b необходим доступ к членам a, которые в противном случае были бы объявлены закрытыми. скрывая класс b в классе a, члены a могут быть объявлены частными, и b может получить к ним доступ. кроме того, сам b может быть скрыт от внешнего мира.</p> </li> <li> <p><strong>это может привести к более удобочитаемому и поддерживаемому коду:</strong> вложение небольших классов в классы верхнего уровня размещает код ближе к месту его использования.</p> </li> </ul> </blockquote>

<p>вложенный класс: класс внутри класса</p><p>типы:</p><ol> <li>статический вложенный класс</li> <li>нестатический вложенный класс [внутренний класс]</li> </ol><p>разница:</p><p><strong>нестатический вложенный класс [внутренний класс]</strong></p><p>в нестатическом вложенном классе объект внутреннего класса существует внутри объекта внешнего класса. так что член данных внешнего класса доступен для внутреннего класса. таким образом, чтобы создать объект внутреннего класса, мы должны сначала создать объект внешнего класса.</p><pre><code>outerclass outerobject=new outerobject(); outerclass.innerclass innerobjcet=outerobject.new innerclass(); </code></pre><p><strong>статический вложенный класс</strong></p><p>в статическом вложенном классе объект внутреннего класса не нуждается в объекте внешнего класса, потому что слово "статический" указывает на отсутствие необходимости создавать объект.</p><pre><code>class outerclass a { static class nestedclass b { static int x = 10; } } </code></pre><p>если вы хотите получить доступ к x, напишите следующий внутренний метод</p><pre><code> outerclass.nestedclass.x; i.e. system.out.prinltn( outerclass.nestedclass.x); </code></pre>

<p>есть тонкость в использовании вложенных статических классов, которые могут быть полезны в определенных ситуациях.</p><p>в то время как статические атрибуты создаются до того, как создается экземпляр класса через его конструктор, статические атрибуты внутри вложенных статических классов, похоже, не создаются, пока не будет вызван конструктор класса, или, по крайней мере, до тех пор, пока атрибуты не будут впервые упомянуты, даже если они помечены как "окончательные".</p><p>рассмотрим этот пример:</p><pre><code>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"); } } </code></pre><p>даже если 'nested' и 'inneritem' оба объявлены как 'static final'. установка nested.inneritem не происходит до тех пор, пока не будет создан экземпляр класса (или, по крайней мере, до тех пор, пока в первый раз не будет указана ссылка на вложенный статический элемент), как вы можете убедиться сами, комментируя и раскомментируя строки, на которые я ссылаюсь, выше. то же самое не относится к "externalitem".</p><p>по крайней мере, это то, что я вижу в java 6.0.</p>

<p>экземпляр внутреннего класса создается при создании экземпляра внешнего класса. поэтому члены и методы внутреннего класса имеют доступ к членам и методам экземпляра (объекта) внешнего класса. когда экземпляр внешнего класса выходит из области видимости, также экземпляры внутреннего класса перестают существовать.</p><p>статический вложенный класс не имеет конкретного экземпляра. он просто загружается при первом использовании (как статические методы). это полностью независимая сущность, чьи методы и переменные не имеют доступа к экземплярам внешнего класса.</p><p>статические вложенные классы не связаны с внешним объектом, они быстрее, и они не занимают память кучи/стека, потому что нет необходимости создавать экземпляр такого класса. поэтому практическое правило состоит в том, чтобы попытаться определить статический вложенный класс с максимально возможной ограниченной областью (private> = class> = protected> = public), а затем преобразовать его во внутренний класс (удалив "статический" идентификатор) и ослабить сфера, если это действительно необходимо.</p>

<p>я не думаю, что здесь есть что добавить, большинство ответов прекрасно объясняют различия между статическим вложенным классом и внутренним классом. однако при использовании вложенных классов и внутренних классов учтите следующую проблему. как упомянуто в нескольких ответах, внутренние классы не могут быть созданы без экземпляра и включающего их класса, что означает, что они <strong>hold</strong> a <strong>указатель</strong> на экземпляр своего включающего класса что может привести к переполнению памяти или исключению переполнения стека из-за того факта, что сборщик мусора не сможет собирать окружающие классы, даже если они больше не используются. чтобы сделать это понятным, проверьте следующий код:</p><pre><code>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(); } </code></pre><p>если вы удалите комментарий к <code>// inner = null;</code> программа выведет "<strong>я уничтожен!</strong>", но оставить комментарий так и не удастся.<br> причина в том, что на внутренний внутренний экземпляр по-прежнему ссылаются, gc не может собрать его, и поскольку он ссылается (имеет указатель на) на внешний экземпляр, он также не собирается. наличие достаточного количества этих объектов в вашем проекте и может не хватить памяти.<br> по сравнению со статическими внутренними классами, которые не содержат указателя на экземпляр внутреннего класса, потому что он не связан с экземпляром, а связан с классом. приведенная выше программа может вывести "<strong>я уничтожен!</strong>", если вы сделаете класс inner статическим и создаете его с помощью <code>outer.inner i = new outer.inner();</code></p>

<p>в случае создания экземпляра экземпляр нестатического внутреннего класса создается со ссылкой на объект внешнего класса, в котором он определен. это значит, что есть включающий экземпляр. но экземпляр статического внутреннего класса создается с ссылкой на класс outer, а не с ссылкой на объект внешнего класса. это означает, что он не имеет включающего экземпляра.</p><p>например:</p><pre><code>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…. } } </code></pre>

<p>термины используются взаимозаменяемо. если вы хотите быть по-настоящему педантичным по этому поводу, то вы <em>можете</em> определить "вложенный класс" для ссылки на статический внутренний класс, который не имеет вложенного экземпляра. в коде у вас может быть что-то вроде этого:</p><pre><code>public class outer { public class inner {} public static class nested {} } </code></pre><p>это не очень широко распространенное определение, хотя.</p>

<p>вложенный класс - это очень общий термин: каждый класс, который не является верхним уровнем, является вложенным классом. внутренний класс - это нестатический вложенный класс. джозеф дарси написал очень приятное объяснение о <a href="http://blogs.oracle.com/darcy/entry/nested\_inner\_member\_and\_top">вложенные, внутренние, членские и классы верхнего уровня</a> .</p>

<p><em> ориентация на учащихся, которые являются новичками в java и / или во вложенных классах </em></p><p>вложенные классы могут быть:<br> 1. статические вложенные классы.<br> 2. нестатические вложенные классы. (также известный как <strong>внутренние классы</strong>) => пожалуйста, помните это<br></p><p><br> <strong>1. внутренние классы</strong><br> пример:</p><pre><code>class outerclass { /* some code here...*/ class innerclass { } /* some code here...*/ } </code></pre><p><br> <strong>внутренние классы - это подмножества вложенных классов:</strong></p><ul> <li>внутренний класс - это особый тип вложенного класса</li> <li>внутренние классы являются подмножествами вложенных классов</li> <li>вы можете сказать, что <em> внутренний класс также является вложенным классом, но вы можете <strong>не</strong> сказать, что вложенный класс также является внутренним классом </em>.</li> </ul><p><strong>специальность внутреннего класса:</strong></p><ul> <li>экземпляр внутреннего класса имеет <strong>доступ ко всем</strong> членов внешнего класса, даже тех, которые помечены как "частные".</li> </ul><p><br> <strong>2.статические вложенные классы:</strong><br> пример:</p><pre><code>class enclosingclass { static class nested { void somemethod() { system.out.println("hello so"); } } } </code></pre><p><strong>случай 1: создание статического вложенного класса из не включающего класса</strong></p><pre><code>class nonenclosingclass { public static void main(string[] args) { /*instantiate the nested class that is a static member of the enclosingclass class: */ enclosingclass.nested n = new enclosingclass.nested(); n.somemethod(); //prints out "hello" } } </code></pre><p><strong>случай 2: создание статического вложенного класса из включающего класса</strong></p><pre><code>class enclosingclass { static class nested { void anothermethod() { system.out.println("hi again"); } } public static void main(string[] args) { //access enclosed class: nested n = new nested(); n.anothermethod(); //prints out "hi again" } } </code></pre><p><strong>специальность статических классов:</strong></p><ul> <li>статический внутренний класс будет иметь доступ только к статическим членам внешнего класса и не будет иметь доступа к нестатическим членам.</li> </ul><p><strong>вывод:</strong><br> <em> вопрос: </em> в чем главное отличие внутреннего класса от статического вложенного класса в java?<br> <em> ответ: </em> просто изучите специфику каждого класса, упомянутого выше.</p>

<p>ммм ... внутренний класс is вложенный класс ... вы имеете в виду анонимный класс и внутренний класс?</p><p>правка: если вы на самом деле имели в виду внутренний против анонимного ... внутренний класс это просто класс, определенный в классе, например:</p><pre><code>public class a { public class b { } } </code></pre><p>принимая во внимание, что анонимный класс является расширением класса, определенного анонимно, поэтому фактический "класс" не определен, как в:</p><pre><code>public class a { } a anon = new a() { /* you could change behavior of a here */ }; </code></pre><p>дальнейшее редактирование:</p><p>википедия <a href="http://en.wikipedia.org/wiki/inner\_class">утверждает, что есть разница</a> в java, но я работаю с java в течение 8 лет, и это первое, что я услышал такое различие ... не говоря уже о там нет ссылок, подтверждающих утверждение ... нижняя строка, внутренний класс - это класс, определенный внутри класса (статический или нет), а вложенный - это просто еще один термин, означающий то же самое.</p><p>существует небольшая разница между статическим и нестатическим вложенным классом ... в основном нестатические внутренние классы имеют неявный доступ к полям экземпляра и методам включающего класса (поэтому они не могут быть созданы в статическом контексте, это будет компилятор ошибка). статические вложенные классы, с другой стороны, не имеют неявного доступа к полям и методам экземпляра и могут быть сконструированы в статическом контексте.</p>

<p><strong> внутренний класс </strong> и <strong> вложенный статический класс </strong> в java оба являются классами, объявленными внутри другого класса, известного как класс верхнего уровня в java. в терминологии java, если вы объявляете вложенный класс статическим, он будет называться вложенным статическим классом в java, тогда как нестатический вложенный класс просто называется внутренним классом.</p><p><strong> что такое внутренний класс в java? </strong></p><p>любой класс, который не является верхним уровнем или объявлен внутри другого класса, известен как вложенный класс, и из этих вложенных классов класс, который объявлен нестатическим, известен как внутренний класс в java. есть три вида внутреннего класса в java:</p><p>1) локальный внутренний класс - объявляется внутри блока кода или метода.<br> 2) анонимный внутренний класс - это класс, который не имеет имени для ссылки и инициализируется в том же месте, где он создается.<br> 3) член внутреннего класса - объявлен как нестатический член внешнего класса.</p><pre><code>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"); } } } </code></pre><p><strong> что такое вложенный статический класс в java? </strong></p><p>вложенный статический класс - это другой класс, который объявлен внутри класса как член и сделан статическим. вложенный статический класс также объявляется как член внешнего класса и может быть закрытым, открытым или защищенным, как любой другой член. одним из основных преимуществ вложенного статического класса перед внутренним классом является то, что экземпляр вложенного статического класса не привязан ни к какому включающему экземпляру класса outer. <em> вам также не нужен какой-либо экземпляр класса outer для создания экземпляра вложенного статического класса в java </em>.</p><p>1) он может получить доступ <em> к статическим элементам данных </em> внешнего класса, включая private.<br> 2) статический вложенный класс не может получить доступ к <em> нестатическому (экземпляр) элементу данных </em> или <em> методу </em>.</p><pre><code>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"); } } } </code></pre><p>ссылка: <a href="http://javarevisited.blogspot.in/2012/12/inner-class-and-nested-static-class-in-java-difference.html">внутренний класс и вложенный статический класс в java с примером</a> </p>

<p>когда мы объявляем статический класс-член внутри класса, он называется вложенным классом верхнего уровня или статическим вложенным классом. это можно продемонстрировать, как показано ниже:</p><pre><code>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()); } } </code></pre><p>когда мы объявляем нестатический класс-член внутри класса, он называется внутренним классом. внутренний класс можно продемонстрировать, как показано ниже:</p><pre><code> 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); } } } </code></pre>

<p>я думаю, что люди здесь должны заметить для афиши, что: статический гнездовой класс - только первый внутренний класс например:</p><pre><code> public static class a {} //error public class a { public class b { public static class c {} //error } } public class a { public static class b {} //compile !!! } </code></pre><p>итак, подведем итог: статический класс не зависит от того, какой класс он содержит. таким образом, они не могут в обычном классе. (потому что нормальному классу нужен экземпляр).</p>

<p>ниже приведен пример <code>static nested class</code> и <code>inner class</code>:</p><p><strong>outerclass.java</strong></p><pre><code>public class outerclass { private string somevariable = "non static"; private static string anotherstaticvariable = "static"; outerclass(){ } //nested classes are static static class staticnestedclass{ private static string privatestaticnestedclassvariable = "private static nested class variable"; //can access private variables declared in the outer class public static void getprivatevariableofouterclass(){ system.out.println(anotherstaticvariable); } } //non static class innerclass{ //can access private variables of outer class public string getprivatenonstaticvariableofouterclass(){ return somevariable; } } public static void accessstaticclass(){ //can access any variable declared inside the static nested class //even if it private string var = outerclass.staticnestedclass.privatestaticnestedclassvariable; system.out.println(var); } } </code></pre><p><strong>outerclasstest:</strong></p><pre><code>public class outerclasstest { public static void main(string[] args) { //access the static nested class outerclass.staticnestedclass.getprivatevariableofouterclass(); //test the private variable declared inside the static nested class outerclass.accessstaticclass(); /* * inner class test * */ //declaration //first instantiate the outer class outerclass outerclass = new outerclass(); //then instantiate the inner class outerclass.innerclass innerclassexample = outerclass. new innerclass(); //test the non static private variable system.out.println(innerclassexample.getprivatenonstaticvariableofouterclass()); } } </code></pre>

<p>я думаю, что ни один из приведенных выше ответов не дает вам реального примера различия между вложенным классом и статическим вложенным классом с точки зрения разработки приложения. и главное различие между статическим вложенным классом и внутренним классом заключается в возможности доступа к полю экземпляра внешнего класса.</p><p>давайте посмотрим на два следующих примера.</p><p>статический вложенный класс. хорошим примером использования статических вложенных классов является шаблон компоновщика ( <a href="https://dzone.com/articles/design-patterns-the-builder-pattern">https://dzone.com/articles/design-patterns-the-builder-pattern</a> ).</p><p>для bankaccount мы используем статический вложенный класс, главным образом потому, что</p><ol> <li> <p>статический экземпляр класса гнезда может быть создан перед внешним классом.</p> </li> <li> <p>в шаблоне компоновщика компоновщик является вспомогательным классом, который используется для создания bankaccount.</p> </li> <li>bankaccount.builder связан только с bankaccount. никакие другие классы не связаны с bankaccount.builder. так что лучше организовать их вместе, не используя соглашение об именах.</li> </ol><pre class="lang-java prettyprint-override"><code>public class bankaccount { private long accountnumber; private string owner; ... public static class builder { private long accountnumber; private string owner; ... static public builder(long accountnumber) { this.accountnumber = accountnumber; } public builder withowner(string owner){ this.owner = owner; return this; } ... public bankaccount build(){ bankaccount account = new bankaccount(); account.accountnumber = this.accountnumber; account.owner = this.owner; ... return account; } } } </code></pre><p>внутренний класс. обычно используются внутренние классы для определения обработчика событий. <a href="https://docs.oracle.com/javase/tutorial/uiswing/events/generalrules.html">https://docs.oracle.com/javase/tutorial/uiswing/events/generalrules.html</a> </p><p>для myclass мы используем внутренний класс, главным образом потому, что:</p><ol> <li> <p>внутренний класс myadapter должен получить доступ к внешнему члену класса.</p> </li> <li> <p>в этом примере myadapter связан только с myclass. другие классы не связаны с myadapter. так что лучше организовать их вместе, не используя соглашение об именах</p> </li> </ol><pre class="lang-java prettyprint-override"><code>public class myclass extends applet { ... someobject.addmouselistener(new myadapter()); ... class myadapter extends mouseadapter { public void mouseclicked(mouseevent e) { ...// event listener implementation goes here... ...// change some outer class instance property depend on the event } } } </code></pre>

<p>язык программирования java позволяет вам определять класс внутри другого класса. такой класс называется вложенным классом и иллюстрируется здесь:</p><pre><code>class outerclass { ... class nestedclass { ... } } </code></pre><p>вложенные классы делятся на две категории: статические и нестатические. вложенные классы, которые объявлены статическими, называются статическими вложенными классами. нестатические вложенные классы называются внутренними классами. мы должны помнить одну вещь: нестатические вложенные классы (внутренние классы) имеют доступ к другим членам включающего класса, даже если они объявлены закрытыми. статические вложенные классы имеют доступ к другим членам включающего класса, только если они являются статическими. он не может получить доступ к нестатическим членам внешнего класса. как и в случае методов и переменных класса, статический вложенный класс связан с его внешним классом. например, чтобы создать объект для статического вложенного класса, используйте этот синтаксис:</p><pre><code>outerclass.staticnestedclass nestedobject = new outerclass.staticnestedclass(); </code></pre><p>чтобы создать экземпляр внутреннего класса, вы должны сначала создать экземпляр внешнего класса. затем создайте внутренний объект во внешнем объекте с этим синтаксисом:</p><pre><code>outerclass.innerclass innerobject = new outerclass().new innerclass(); </code></pre><p>почему мы используем вложенные классы</p><ol> <li>это способ логической группировки классов, которые используются только в одном месте.</li> <li>это увеличивает инкапсуляцию.</li> <li>это может привести к более удобочитаемому и поддерживаемому коду.</li> </ol><p>источник: <a href="https://docs.oracle.com/javase/tutorial/java/javaoo/nested.html">учебные руководства java ™ - вложенные классы</a> </p>

<p>прежде всего, нет такого класса, называемого static class. использование модификатора static с внутренним классом (называемым nested class) говорит о том, что это статический член outer class, что означает, что мы можем получить к нему доступ, как и с другими статическими членами, без экземпляр внешнего класса. (что является преимуществом статического изначально.)</p><p>разница между использованием вложенного класса и обычного внутреннего класса заключается в следующем:</p><pre><code>outerclass.innerclass inner = new outerclass().new innerclass(); </code></pre><p>сначала мы можем создать экземпляр outerclass, затем мы можем получить доступ к inner.</p><p>но если класс является вложенным, то синтаксис:</p><pre><code>outerclass.innerclass inner = new outerclass.innerclass(); </code></pre><p>который использует статический синтаксис в качестве обычной реализации статического ключевого слова.</p>