В чем основное различие между внутренним классом и статическим вложенным классом в Java? Играет ли дизайн / реализация роль в выборе одного из них?
java
inner-classes
static-classes
всемогущий
источник
источник
item 22 : Favor static member classes over non static
Ответы:
Из учебника по Java :
Доступ к статическим вложенным классам осуществляется с использованием имени включающего класса:
Например, чтобы создать объект для статического вложенного класса, используйте этот синтаксис:
Объекты, которые являются экземплярами внутреннего класса, существуют в экземпляре внешнего класса. Рассмотрим следующие классы:
Экземпляр InnerClass может существовать только внутри экземпляра OuterClass и имеет прямой доступ к методам и полям его включающего экземпляра.
Чтобы создать экземпляр внутреннего класса, вы должны сначала создать экземпляр внешнего класса. Затем создайте внутренний объект во внешнем объекте с этим синтаксисом:
см. Java Tutorial - Вложенные классы
Для полноты заметим, что существует также такая вещь, как внутренний класс без включающего экземпляра :
Здесь
new A() { ... }
- внутренний класс, определенный в статическом контексте и не имеющий включающего экземпляра.источник
import OuterClass.StaticNestedClass;
затем ссылаться на класс так же, как OuterClass.OuterClass.InnerClass innerObject = outerObject.new InnerClass();
?Учебник Java говорит :
В общем, термины «вложенный» и «внутренний» используются большинством программистов взаимозаменяемо, но я буду использовать правильный термин «вложенный класс», который охватывает как внутренний, так и статический.
Классы могут быть вложенными до бесконечности , например, класс A может содержать класс B, который содержит класс C, который содержит класс D, и т. Д. Тем не менее, более одного уровня вложенности классов встречается редко, так как обычно это плохой дизайн.
Есть три причины, по которым вы можете создать вложенный класс:
В Java есть четыре вида вложенных классов . Вкратце, это:
Позвольте мне остановиться подробнее.
Статические классы
Статические классы легче всего понять, потому что они не имеют ничего общего с экземплярами содержащего класса.
Статический класс - это класс, объявленный как статический член другого класса. Как и другие статические члены, такой класс на самом деле является просто вешалкой, который использует содержащий класс в качестве своего пространства имен, например, класс Goat, объявленный как статический член класса Rhino в пакете pizza , известен под именем pizza.Rhino.Goat ,
Откровенно говоря, статические классы - довольно бесполезная особенность, потому что классы уже разделены на пространства имен пакетами. Единственная реальная причина создания статического класса заключается в том, что такой класс имеет доступ к закрытым статическим членам своего содержащего класса, но я считаю, что это довольно слабое оправдание существования функции статического класса.
Внутренние классы
Внутренний класс - это класс, объявленный как нестатический член другого класса:
Как и в случае статического класса, внутренний класс известен как квалифицированный по имени содержащего класса, pizza.Rhino.Goat , но внутри содержащего класса он может быть известен по его простому имени. Однако каждый экземпляр внутреннего класса привязан к конкретному экземпляру содержащего его класса: выше, козел, созданный в jerry , неявно привязан к экземпляру Rhino this в jerry . В противном случае мы делаем явный связанный экземпляр Rhino при создании экземпляра Goat :
(Обратите внимание, что вы называете внутренний тип просто Goat в странном новом синтаксисе: Java выводит содержащий тип из носорога части А, да. Новый rhino.Goat () сделали бы больше смысла для меня тоже.)
Так что это нам дает? Ну, внутренний экземпляр класса имеет доступ к членам экземпляра содержащего экземпляра класса. Эти включающие элементы экземпляра упоминаются внутри внутреннего класса только через их простые имена, а не через это ( это во внутреннем классе относится к экземпляру внутреннего класса, а не к связанному экземпляру содержащего класса):
Во внутреннем классе вы можете ссылаться на этот содержащий класс как Rhino.this , и вы можете использовать это для ссылки на его члены, например Rhino.this.barry .
Местные Внутренние Классы
Локальный внутренний класс - это класс, объявленный в теле метода. Такой класс известен только в пределах его содержащего метода, поэтому он может быть создан только для экземпляра и получить доступ к его членам в пределах содержащего его метода. Преимущество заключается в том, что локальный экземпляр внутреннего класса привязан и может получить доступ к последним локальным переменным его содержащего метода. Когда экземпляр использует последний локальный элемент содержащего его метода, переменная сохраняет значение, которое оно содержало во время создания экземпляра, даже если переменная вышла из области видимости (это, по сути, грубая ограниченная версия замыканий Java).
Поскольку локальный внутренний класс не является ни членом класса, ни пакета, он не объявлен с уровнем доступа. (Однако, имейте в виду, что его собственные члены имеют уровни доступа, как в обычном классе.)
Если в методе экземпляра объявлен локальный внутренний класс, создание экземпляра внутреннего класса привязывается к экземпляру, который содержится в содержащем методе this во время создания экземпляра, и поэтому члены экземпляра содержащего класса доступны, как в экземпляре. внутренний класс. Локальный внутренний класс создается просто через его имя, например, локальный внутренний класс Cat создается как новый Cat () , а не новый this.Cat (), как вы могли ожидать.
Анонимные Внутренние Классы
Анонимный внутренний класс - это синтаксически удобный способ написания локального внутреннего класса. Чаще всего локальный внутренний класс создается не более одного раза при каждом запуске содержащего его метода. Было бы хорошо, если бы мы могли объединить определение локального внутреннего класса и его единственное создание в одну удобную синтаксическую форму, и было бы также хорошо, если бы нам не приходилось придумывать имя для этого класса (тем меньше бесполезного имена ваш код содержит, тем лучше). Анонимный внутренний класс допускает обе эти вещи:
Это выражение, возвращающее новый экземпляр безымянного класса, который расширяет ParentClassName . Вы не можете предоставить свой собственный конструктор; скорее, неявно предоставляется один, который просто вызывает супер-конструктор, поэтому предоставленные аргументы должны соответствовать супер-конструктору. (Если родительский объект содержит несколько конструкторов, то называется «самый простой», «самый простой», что определяется довольно сложным набором правил, которые не стоит беспокоиться, чтобы изучать их подробно - просто обратите внимание на то, что говорят вам NetBeans или Eclipse.)
Кроме того, вы можете указать интерфейс для реализации:
Такое объявление создает новый экземпляр безымянного класса, который расширяет Object и реализует InterfaceName . Опять же, вы не можете предоставить свой собственный конструктор; в этом случае Java неявно предоставляет конструктор без аргументов, бездействия (поэтому в этом случае никогда не будет аргументов конструктора).
Даже если вы не можете дать анонимному внутреннему классу конструктор, вы все равно можете выполнить любую настройку, которую хотите, используя блок инициализатора (блок {}, помещенный вне любого метода).
Имейте в виду, что анонимный внутренний класс - это просто менее гибкий способ создания локального внутреннего класса с одним экземпляром. Если вам нужен локальный внутренний класс, который реализует несколько интерфейсов или который реализует интерфейсы, расширяя какой-то класс, отличный от Object, или который задает свой собственный конструктор, вы застряли в создании обычного локального внутреннего класса с именем.
источник
Я не думаю, что реальная разница стала ясна в ответах выше.
Сначала, чтобы получить правильные условия:
Ответ Мартина пока прав. Однако актуальный вопрос таков: какова цель объявления вложенного класса статическим или нет?
Вы используете статические вложенные классы, если вы просто хотите сохранить свои классы вместе, если они тематически связаны друг с другом или если вложенный класс используется исключительно во включающем классе. Нет никакой семантической разницы между статическим вложенным классом и любым другим классом.
Нестатические вложенные классы - это другой зверь. Подобно анонимным внутренним классам, такие вложенные классы на самом деле являются замыканиями. Это означает, что они фиксируют окружающий их объем и включающий их экземпляр и делают его доступным. Возможно, пример прояснит это. Посмотрите эту заглушку контейнера:
В этом случае вы хотите иметь ссылку от дочернего элемента на родительский контейнер. Используя нестатический вложенный класс, это работает без какой-либо работы. Вы можете получить доступ к включающему экземпляру Контейнера с помощью синтаксиса
Container.this
.Более жесткие объяснения следующие:
Если вы посмотрите на байт-коды Java, которые генерирует компилятор для (нестатического) вложенного класса, это может стать еще яснее:
Как видите, компилятор создает скрытое поле
Container this$0
. Это устанавливается в конструкторе, который имеет дополнительный параметр типа Container для указания включающего экземпляра. Вы не можете видеть этот параметр в исходном коде, но компилятор неявно генерирует его для вложенного класса.Пример Мартина
будет скомпилировано для вызова чего-то вроде (в байт-кодах)
Для полноты картины:
Анонимный класс является прекрасным примером нестатического вложенного класса, с которым просто не связано имя, и на который нельзя ссылаться позже.
источник
Я думаю, что ни один из приведенных выше ответов не объясняет вам реальной разницы между вложенным классом и статическим вложенным классом с точки зрения разработки приложения:
OverView
Вложенный класс может быть нестатическим или статическим, и в каждом случае это класс, определенный в другом классе . Вложенный класс должен существовать только для обслуживания включающего класса , если вложенный класс полезен другими классами (не только включающими), должен быть объявлен как класс верхнего уровня.
разница
Нестатический вложенный класс : неявно связан с включающим экземпляром содержащего класса, это означает, что можно вызывать методы и обращаться к переменным включающего экземпляра. Одним из распространенных применений нестатического вложенного класса является определение класса Adapter.
Статический вложенный класс : не может получить доступ к экземпляру включающего класса и вызвать для него методы, поэтому его следует использовать, когда вложенный класс не требует доступа к экземпляру включающего класса. Обычным использованием статического вложенного класса является реализация компонентов внешнего объекта.
Вывод
Таким образом, основное различие между ними с точки зрения проектирования заключается в том, что нестатический вложенный класс может обращаться к экземпляру класса контейнера, а статический - нет .
источник
Проще говоря, нам нужны вложенные классы в первую очередь потому, что Java не обеспечивает замыкания.
Вложенные классы - это классы, определенные внутри тела другого включающего класса. Они бывают двух типов - статические и нестатические.
Они рассматриваются как члены окружающего класса, поэтому вы можете указать любой из четырех спецификаторов доступа -
private, package, protected, public
. У нас нет такой роскоши с классами высшего уровня, которые могут быть объявлены толькоpublic
или являются частными.Внутренние классы, иначе говоря, не-стековые классы имеют доступ к другим членам высшего класса, даже если они объявлены закрытыми, в то время как статические вложенные классы не имеют доступа к другим членам высшего класса.
Inner1
это наш статический внутренний класс иInner2
это наш внутренний класс, который не является статическим. Ключевое различие между ними заключается в том, что вы не можете создатьInner2
экземпляр без Outer, где вы можете создатьInner1
объект самостоятельно.Когда вы будете использовать Inner class?
Подумайте о ситуации, когда
Class A
иClass B
связаны,Class B
должны получить доступ кClass A
членам, иClass B
связан только сClass A
. Внутренние классы входят в картину.Для создания экземпляра внутреннего класса вам нужно создать экземпляр вашего внешнего класса.
или
Когда бы вы использовали статический Inner класс?
Вы бы определили статический внутренний класс, когда знаете, что он не имеет никакого отношения к экземпляру включающего класса / верхнего класса. Если ваш внутренний класс не использует методы или поля внешнего класса, это просто пустая трата пространства, поэтому сделайте его статичным.
Например, чтобы создать объект для статического вложенного класса, используйте этот синтаксис:
Преимущество статического вложенного класса в том, что ему не нужен объект содержащего класса / верхнего класса для работы. Это может помочь вам уменьшить количество объектов, создаваемых вашим приложением во время выполнения.
источник
OuterClass.Inner2 inner = outer.new Inner2();
?static inner
противоречие в терминах.Вот ключевые различия и сходства между внутренним классом Java и статическим вложенным классом.
Надеюсь, поможет!
Внутренний класс
Связанный с экземпляром включающего класса, для того, чтобы создать его экземпляр, сначала необходим экземпляр внешнего класса (обратите внимание на новое ключевое слово place):
Сам не может определять статические элементы
Статический вложенный класс
Невозможно получить доступ к методам или полям экземпляра внешнего класса
Не связано ни с одним экземпляром включающего класса. Итак, чтобы создать его экземпляр:
сходства
Зачем использовать вложенные классы?
Согласно документации Oracle есть несколько причин ( полная документация ):
источник
Я думаю, что соглашение, которое обычно соблюдается, таково:
Однако, несколько других моментов, которые следует помнить :
Классы верхнего уровня и статический вложенный класс семантически одинаковы, за исключением того, что в случае статического вложенного класса он может делать статическую ссылку на частные статические поля / методы своего внешнего класса [parent] и наоборот.
Внутренние классы имеют доступ к переменным экземпляра окружающего экземпляра класса Outer [parent]. Однако не все внутренние классы имеют вложенные экземпляры, например, внутренние классы в статических контекстах, как анонимный класс, используемый в статическом блоке инициализатора, не имеют.
По умолчанию анонимный класс расширяет родительский класс или реализует родительский интерфейс, и больше нет условий для расширения какого-либо другого класса или реализации каких-либо дополнительных интерфейсов. Так,
new YourClass(){};
средстваclass [Anonymous] extends YourClass {}
new YourInterface(){};
средстваclass [Anonymous] implements YourInterface {}
Я чувствую, что большой вопрос, который остается открытым, какой использовать и когда? Ну, это в основном зависит от того, с каким сценарием вы имеете дело, но чтение ответа @jrudolph может помочь вам принять какое-то решение.
источник
Вложенный класс: класс внутри класса
Типы:
Разница:
Нестатический вложенный класс [Внутренний класс]
В нестатическом вложенном классе объект внутреннего класса существует внутри объекта внешнего класса. Так что член данных внешнего класса доступен для внутреннего класса. Таким образом, чтобы создать объект внутреннего класса, мы должны сначала создать объект внешнего класса.
Статический вложенный класс
В статическом вложенном классе объект внутреннего класса не нуждается в объекте внешнего класса, потому что слово «статический» указывает на отсутствие необходимости создавать объект.
Если вы хотите получить доступ к x, напишите следующий внутренний метод
источник
Экземпляр внутреннего класса создается при создании экземпляра внешнего класса. Поэтому члены и методы внутреннего класса имеют доступ к членам и методам экземпляра (объекта) внешнего класса. Когда экземпляр внешнего класса выходит из области видимости, также экземпляры внутреннего класса перестают существовать.
Статический вложенный класс не имеет конкретного экземпляра. Он просто загружается при первом использовании (как статические методы). Это полностью независимая сущность, чьи методы и переменные не имеют доступа к экземплярам внешнего класса.
Статические вложенные классы не связаны с внешним объектом, они быстрее, и они не занимают память кучи / стека, потому что нет необходимости создавать экземпляр такого класса. Поэтому практическое правило состоит в том, чтобы попытаться определить статический вложенный класс с максимально возможной ограниченной областью (private> = class> = protected> = public), а затем преобразовать его во внутренний класс (удалив «статический» идентификатор) и ослабить сфера, если это действительно необходимо.
источник
Есть тонкость в использовании вложенных статических классов, которые могут быть полезны в определенных ситуациях.
В то время как статические атрибуты создаются до того, как создается экземпляр класса через его конструктор, статические атрибуты внутри вложенных статических классов, похоже, не создаются, пока не будет вызван конструктор класса, или, по крайней мере, до тех пор, пока атрибуты не будут впервые упомянуты, даже если они помечены как «окончательные».
Рассмотрим этот пример:
Даже если 'nested' и 'innerItem' оба объявлены как 'static final'. установка nested.innerItem не происходит до тех пор, пока не будет создан экземпляр класса (или, по крайней мере, до тех пор, пока в первый раз не будет указана ссылка на вложенный статический элемент), как вы можете убедиться сами, комментируя и раскомментируя строки, на которые я ссылаюсь, над. То же самое не относится к «externalItem».
По крайней мере, это то, что я вижу в Java 6.0.
источник
Термины используются взаимозаменяемо. Если вы хотите быть по-настоящему педантичным, то вы можете определить «вложенный класс» для ссылки на статический внутренний класс, у которого нет включающего экземпляра. В коде у вас может быть что-то вроде этого:
Это не совсем общепринятое определение.
источник
В случае создания экземпляра экземпляр нестатического внутреннего класса создается со ссылкой на объект внешнего класса, в котором он определен. Это значит, что есть включающий экземпляр. Но экземпляр статического внутреннего класса создается с ссылкой на класс Outer, а не с ссылкой на объект внешнего класса. Это означает, что он не имеет включающего экземпляра.
Например:
источник
Я не думаю, что здесь есть что добавить, большинство ответов прекрасно объясняют различия между статическим вложенным классом и внутренним классом. Однако при использовании вложенных классов и внутренних классов учтите следующую проблему. Как упоминается в паре ответов внутренние классы не могут быть созданы без и экземпляр их ограждающих класса , который означает , что они ДЕРЖАТЬ в указатель на экземпляр своего класса ограждающей , что может привести к переполнению памяти или переполнение стека исключения из - за факта GC не сможет собрать мусор окружающих классов, даже если они больше не используются. Чтобы сделать это понятным, проверьте следующий код:
Если вы удалите комментарий к
// inner = null;
программе, будет выведено « Я уничтожен! », Но оставить комментарий будет не так.Причина в том, что на внутренний внутренний экземпляр по-прежнему ссылаются, GC не может собрать его, и поскольку он ссылается (имеет указатель на) на внешний экземпляр, он тоже не собирается. Наличие достаточного количества этих объектов в вашем проекте и может не хватить памяти.
По сравнению со статическими внутренними классами, которые не содержат указателя на экземпляр внутреннего класса, потому что он не связан с экземпляром, а связан с классом. Приведенная выше программа может вывести « Я уничтожен! », Если вы сделаете класс Inner статическим и создадите его с помощью
Outer.Inner i = new Outer.Inner();
источник
Вложенный класс - это очень общий термин: каждый класс, который не является верхним уровнем, является вложенным классом. Внутренний класс - это нестатический вложенный класс. Джозеф Дарси написал очень хорошее объяснение о классах Nested, Inner, Member и Top-Level .
источник
Ммм ... внутренний класс - это вложенный класс ... ты имеешь в виду анонимный класс и внутренний класс?
Изменить: Если вы на самом деле имели в виду внутренний против анонимного ... внутренний класс это просто класс, определенный в классе, например:
Принимая во внимание, что анонимный класс является расширением класса, определенного анонимно, поэтому фактический «класс» не определен, как в:
Дальнейшее редактирование:
Википедия утверждает, что есть разница в Java , но я работаю с Java уже 8 лет, и это первое, что я услышал о таком различии ... не говоря уже о том, что там нет ссылок, подтверждающих заявление ... line, внутренний класс - это класс, определенный внутри класса (статический или нет), а вложенный - это просто еще один термин, означающий то же самое.
Существует небольшая разница между статическим и нестатическим вложенным классом ... в основном нестатические внутренние классы имеют неявный доступ к полям экземпляра и методам включающего класса (поэтому они не могут быть созданы в статическом контексте, это будет компилятор ошибка). Статические вложенные классы, с другой стороны, не имеют неявного доступа к полям и методам экземпляра и МОГУТ быть сконструированы в статическом контексте.
источник
Ориентация на учащихся, которые являются новичками в Java и / или во вложенных классах
Вложенные классы могут быть следующими:
1. Статические Вложенные классы.
2. Нестатические вложенные классы. (также известный как Внутренние классы ) => Пожалуйста, помните это
1. Внутренние классы
Пример:
Внутренние классы - это подмножества вложенных классов:
Специальность внутреннего класса:
2.Статические вложенные классы:
пример:
Случай 1: создание статического вложенного класса из не включающего класса
Случай 2: создание статического вложенного класса из включающего класса
Специальность статических классов:
Вывод:
Вопрос: В чем главное отличие внутреннего класса от статического вложенного класса в Java?
Ответ: просто пройдите специфику каждого класса, упомянутого выше.
источник
Внутренний класс и вложенный статический класс в Java - это классы, объявленные внутри другого класса, известного как класс верхнего уровня в Java. В терминологии Java: если вы объявляете вложенный класс статическим, он будет называться вложенным статическим классом в Java, тогда как нестатический вложенный класс просто называется внутренним классом.
Что такое внутренний класс в Java?
Любой класс, который не является верхним уровнем или объявлен внутри другого класса, известен как вложенный класс, и из этих вложенных классов класс, который объявлен нестатическим, известен как внутренний класс в Java. Есть три вида внутреннего класса в Java:
1) Локальный внутренний класс - объявляется внутри блока кода или метода.
2) Анонимный внутренний класс - это класс, который не имеет имени для ссылки и инициализируется в том же месте, где он создается.
3) Член внутреннего класса - объявлен как нестатический член внешнего класса.
Что такое вложенный статический класс в Java?
Вложенный статический класс - это другой класс, который объявлен внутри класса как член и сделан статическим. Вложенный статический класс также объявляется как член внешнего класса и может быть закрытым, открытым или защищенным, как любой другой член. Одним из основных преимуществ вложенного статического класса перед внутренним классом является то, что экземпляр вложенного статического класса не привязан ни к какому включающему экземпляру класса Outer. Вам также не нужен ни один экземпляр класса Outer для создания экземпляра вложенного статического класса в Java .
1) Он может получить доступ к статическим данным членов внешнего класса, включая private.
2) Статический вложенный класс не может получить доступ к нестатическому (экземпляру) элементу данных или методу .
Ссылка: внутренний класс и вложенный статический класс в Java с примером
источник
Я думаю, что люди здесь должны заметить для Афиши, что Классический Гнездовой Класс - это только первый внутренний класс. Например:
Итак, подведем итог: статический класс не зависит от того, какой класс он содержит. Таким образом, они не могут в обычном классе. (потому что нормальному классу нужен экземпляр).
источник
Когда мы объявляем статический класс-член внутри класса, он называется вложенным классом верхнего уровня или статическим вложенным классом. Это можно продемонстрировать, как показано ниже:
Когда мы объявляем нестатический класс-член внутри класса, он называется внутренним классом. Внутренний класс можно продемонстрировать, как показано ниже:
источник
Ниже приведен пример
static nested class
иinner class
:OuterClass.java
OuterClassTest:
источник
Я думаю, что ни один из приведенных выше ответов не дает вам реального примера различия между вложенным классом и статическим вложенным классом с точки зрения разработки приложения. И главное различие между статическим вложенным классом и внутренним классом заключается в возможности доступа к полю экземпляра внешнего класса.
Давайте посмотрим на два следующих примера.
Статический вложенный класс. Хорошим примером использования статических вложенных классов является шаблон компоновщика ( https://dzone.com/articles/design-patterns-the-builder-pattern ).
Для BankAccount мы используем статический вложенный класс, главным образом потому, что
Статический экземпляр класса гнезда может быть создан перед внешним классом.
В шаблоне компоновщика компоновщик является вспомогательным классом, который используется для создания BankAccount.
Внутренний класс. Обычно используются внутренние классы для определения обработчика событий. https://docs.oracle.com/javase/tutorial/uiswing/events/generalrules.html
Для MyClass мы используем внутренний класс, главным образом потому, что:
Внутренний класс MyAdapter должен получить доступ к внешнему члену класса.
В этом примере MyAdapter связан только с MyClass. Другие классы не связаны с MyAdapter. так что лучше организовать их вместе, не используя соглашение об именах
источник
Диаграмма
Основное различие между классами
static nested
иnon-static nested
классами заключается в том, чтоstatic nested
они не имеют доступа к нестатическим членам внешнего класса.источник
Прежде всего, не существует такого класса, называемого Static class. Использование модификатора Static с внутренним классом (называемым Nested Class) говорит о том, что он является статическим членом Outer Class, что означает, что мы можем получить к нему доступ, как и с другими статическими членами, и без экземпляр Внешнего класса. (Что является преимуществом статического изначально.)
Разница между использованием вложенного класса и обычного внутреннего класса заключается в следующем:
Сначала мы можем создать экземпляр Outerclass, затем мы можем получить доступ к Inner.
Но если класс является вложенным, то синтаксис:
Который использует статический синтаксис в качестве обычной реализации статического ключевого слова.
источник
Язык программирования Java позволяет вам определять класс в другом классе. Такой класс называется вложенным классом и иллюстрируется здесь:
Вложенные классы делятся на две категории: статические и нестатические. Вложенные классы, которые объявлены статическими, называются статическими вложенными классами. Нестатические вложенные классы называются внутренними классами. Мы должны помнить одну вещь: нестатические вложенные классы (внутренние классы) имеют доступ к другим членам включающего класса, даже если они объявлены закрытыми. Статические вложенные классы имеют доступ к другим членам включающего класса, только если они являются статическими. Он не может получить доступ к нестатическим членам внешнего класса. Как и в случае методов и переменных класса, статический вложенный класс связан с его внешним классом. Например, чтобы создать объект для статического вложенного класса, используйте этот синтаксис:
Чтобы создать экземпляр внутреннего класса, вы должны сначала создать экземпляр внешнего класса. Затем создайте внутренний объект во внешнем объекте с этим синтаксисом:
Почему мы используем вложенные классы
Источник: Учебные руководства Java ™ - Вложенные классы
источник
Разница заключается в том, что объявление вложенного класса, которое также является статическим, может создаваться вне внешнего класса.
Если у вас есть объявление вложенного класса, которое не является статическим, также известным как внутренний класс , Java не позволит вам создать его экземпляр, кроме как через включающий класс. Объект, созданный из внутреннего класса, связан с объектом, созданным из внешнего класса, поэтому внутренний класс может ссылаться на поля внешнего.
Но если она статическая, то ссылка не существует, внешние поля не могут быть доступны (кроме как через обычную ссылку, как любой другой объект), и поэтому вы можете создать экземпляр вложенного класса самостоятельно.
источник
Это довольно просто, сравнивая статические локальные классы и нестатические внутренние классы.
Различия:
Статический локальный класс:
может получить доступ только к статическим членам внешнего класса.
Не может иметь статические инициализаторы.
Невозможно получить доступ напрямую из-за пределов функции, в которой она объявлена
источник
Я проиллюстрировал различные возможные сценарии исправления ошибок и ошибок, которые могут возникнуть в коде Java.
источник