Внутренние классы. Часть 3 – inner classes.

Вот тут у нас и пойдет речь о внутренних (inner) классах, то есть о нестатических внутренних классах. Эти классы объявляются внутри внешних (окружающих) классов без ключевого слова static и они существенно отличаются от вложенных статических классов.

Если статический вложенный класс является аналогом поля или метода класса, то внутренний класс является аналогом поля или метода экземпляра.

Определение внутреннего класса может выглядеть так:

Подобно полям и методам экземпляра, каждый экземпляр внутреннего класса связан с экземпляром класса, внутри которого он определен (то есть каждый экземпляр внутреннего класса связан с экземпляром его окружающего класса). Вы не можете создать экземпляр внутреннего класса без привязки к экземпляру внешнего класса. То есть сперва должен быть создан экземпляр внешнего класса, а только затем уже вы можете создать экземпляр внутреннего класса.

Как правило внешний класс содержит метод, возвращающий ссылку на внутренний класс. Чтобы стало понятней обратимся к примерам представленным выше. У нас есть внешний класс OuterClass и внутренний класс InnerClass. OuterClass содержит приватную переменную типа int outInt. Класс OuterClass не имеет метода возвращающего значение этой переменной, но внутренний класс содержит метод getOutInt(), который возвращает значение переменной outInt принадлежащей внешнему классу. Класс же OuterClass имеет метод getInnerClass(), который создает экземпляр класса InnerClass и возвращает ссылку на него. Создать экземпляр внутреннего класса можно и другим способом который мы рассмотрим чуть позже.

В главном классе программы Main мы сперва создаем экземпляр класса OuterClass – outClass и затем используя его метод getInnerClass() создаем экземпляр внутреннего класса InnerClass – innerClass, который связан с экземпляром своего внешнего класса и поэтому имеет доступ к его приватной переменной outInt, для получения которой мы используем метод getOutInt класса InnerClass, который вызывается на экземпляре этого класса innerClass. Этот пример достаточно простой, как мне кажется.

Из этого примера так же видно, что код внутреннего класса имеет доступ ко всем полям и методам экземпляра (так же как и к статическим членам) окружающего класса, включая все члены, даже объявленные как private. А вот обратный доступ, до есть доступ из окружающего класса к членам внутреннего, имеет свои ограничения. Экземпляр внешнего класса не имеет доступа ни к каким членам экземпляра внутреннего класса на прямую, то есть без создания экземпляра внутреннего класса внутри своих методов. И это логично, так как экземпляров внутреннего класса может быть создано сколько угодно много, и к какому же из них тогда обращаться?

Чтобы лучше понять этот момент рассмотрим новую мутацию предыдущего примера:

Теперь в главном классе мы создаем два экземпляра внутреннего класса InnerClass который связан с одним и тем же экземпляром outClass внешнего класса OuterClass.

Вывод у этой программы следующий:

Как видно из вывода каждый экземпляр класса InnerClass хранит свое личное значение в поле innerInt, а вот при вызове метода getOutInt() выводит одно и то же значение, поскольку связаны с одним и тем же объектом.

Здесь еще раз стоит упомянуть об одном нюансе, который вы возможно не заметили. Объект внутреннего класса получает ссылку на внешний объект, который его создал, и поэтому может обращаться к членам внешнего объекта без дополнительных уточнений. Именно поэтому в методе getOutInt() внутреннего класса InnerClass мы можем возвратить значение поля outInt внешнего класса без каких либо уточнений. Это важный момент и его надо запомнить. Идем далее.

Теперь рассмотрим обращение к членам внутреннего класса из окружающего. Как я уже говорил это возможно лишь при создании экземпляра внутреннего класса, поскольку создание экземпляра внешнего класса еще не означает что будет создан экземпляр внутреннего.

Вывод программы простой. Обратите внимание на закомментированную строку в классе Outer. Такой номер не пройдет. Необходимо создать экземпляр внутреннего класса. И тогда уже по имени внутреннего класса можно будет обращаться на прямую к любым его членам, включая private члены. Это был достаточно простой пример. Теперь мы его немного усложним для лучшего понимания происходящего. Сразу приведу оба класса и вывод новой мутации. Суть в том, что экземпляров внутреннего класса может быть много, но экземпляр внешнего класса имеет прямой доступ к любым членам экземпляров внутренних классов, даже к private членам.

 

У внутреннего класса, как и у любого члена класса, может быть установлен один из трех уровней видимости: public, protected или private. Если ни один из этих модификаторов не указан, то по умолчанию применяется пакетная видимость.

Внутренний класс не может иметь имя, совпадающее с именем окружащего класса или пакета. Это важно помнить. Правило не распространяется ни на поля, ни на методы.

Внутренний класс не может иметь полей, методов или классов, объявленных как static (за исключением полей констант, объявленных как static и final). Статические поля, методы и классы являются конструкциями верхнего уровня, которые не связаны с конкретными объектами, в то время как каждый внутренний класс связан с экземпляром окружающего класса.

Еще немного попрактикуемся на примере приведенном слева. Он генерирует простой вывод:

Здесь мы еще раз видим, что внутренний класс может обращаться к любым полям и методам внешнего класса на примере класса SequnceSelector, в коде которого идет обращение к массиву Objects items, который является членом внешнего класса Sequence. Внутренний класс реализует интерфейс ISelector и вот тут есть немножко магии.

Как уже говорилось, внутренний класс можно создать только в связке с его внешним классом. В нашем примере внутренний класс создается строкой

ISelector selector = sequence.selector();

Метод selector() возвращает ссылку на экземпляр внутреннего класса SequnceSelector приведенную к типу интерфейса ISelector, что может вас немного запутать, но про такие трюки мы уже говорили когда изучали интерфейсы.

Ну и далее экземпляр внутреннего класса SequenceSelector – selector работает с данными экземпляра внешнего класса Sequence – sequence. То есть перебирает и выводит на консоль массив объектов items.

И чтобы плавно перейти к следующей теме приведу еще один пример который показывает, что из внутреннего класса любой вложенности доступны элементы любых внешних классов, даже объявленные как private.
Здесь у нас есть внешний класс Outer и внутри него класс Inner01 внутри которого, в свою очередь находится класс Inner02. Но обратите внимание что в методах getOutStr() классов Inner01 и Inner02 происходит обращение к приватному полю класса Outer outstr без каких либо уточнений. Так же и в классе Inner02 мы обращаемся к приватному полю strInn01 класса Inner01 тоже без каких либо уточнений. Но особый интерес представляет последняя строчка в данном коде.

Inner01.Inner02 getInner02() { return new Inner01().new Inner02();}

Здесь мы видим интересное применение оператора new. Данная строка возвращает нам ссылку на объект класса Inner02, который не может быть создан без привязки к экземплярам внешних классов. Таким образом, для его создания мы должны сперва создать и экземпляр класса Inner01, что и выполняет данная строка. Об этом более подробно мы расскажем уже скоро. Цель же этого примера в том, чтобы показать доступность элементов внешних классов из внутренних классов без каких либо уточнений. Хотя тут тоже есть некоторые интересные моменты, но мы рассмотрим их чуть позже.

Применение вложенных этих классов показано на скрине слева.

Как видите, сперва нам необходимо создать объект внешнего класса out, затем используя его мы создаем объекты внутренних классов in01 и in02. Обратите внимание на то как они создаются.

Так же эти объекты можно было бы создать при помощи оператора new.

Вывод у программы следующий:

.this  .super  .new

Как уже не однократно говорилось, создать объект внутреннего класса можно непосредственно при помощи особого синтаксиса оператора new. Как вы помните чтобы создать объект внутреннего класса обязательно должен присутствовать объект внешнего класса, поскольку каждый экземпляр внутреннего класса связан с экземпляром своего внешнего класса. До этого момента для создания объектов внутренних классов мы пользовались методами внешнего класса который возвращал ссылки на объекты внутренних классов. Но есть и другой способ. Рассмотрим его на предыдущем примере, модифицировав его:

Как видим для создания объекта внутреннего класса указывается не имя его внешнего класса, как можно было бы ожидать, а объект внешнего класса, за которым, через точку, следует  оператор .new.
Обратите внимание что для создания объекта класса Inner01 мы использовали объект out, а для создания объекта класса Inner02 мы использовали объект inn01.
Чтобы создать объект внутреннего класса обязательно должен существовать объект его внешнего класса.
Строку создания объекта внутреннего класса Inner02, можно записать и по другому. Но это будет очень длинный и не особо читабельный синтаксис и он будет отличаться тем, что будут созданы новые объекты классов Outer и Inner01, а не использоваться уже созданыне out и in01.

В этом случае строка создания объекта класса Inner02 может выглядеть так:

Outer.Inner01.Inner02 in02 = new Outer().new Inner01().new Inner02();

Не правда ли немного замысловато :) Но если подумать то все логично.

Внутренние классы имеют право наследовать другие классы, реализовывать интерфейсы и выступать в роли объектов наследования.

Когда класс затеняет или замещает члены родительского класса, для ссылки на скрытый член можно применить ключевое слово super. Так же, данное ключевое слово можно задействовать и для работы во внутренних классах. Для этого используется имя текущего класса, затем точка, ключевое слово super, опять точка и имя затененного поля или метода. Хотя имя текущего класса можно и опускать (это зависит от версии JDK, все последние поддерживают упрощенный синтаксис). Рассмотрим это на простой новой мутации предыдущего примера.

В этом примере мы унаследовали классы Inner01 и Inner02 от внешнего класса Outer. Все три класса содержат строковое поле str. Соответственно оно затеняется в классах наследниках. Чтобы получить доступ к полю str класса Outer необходимо использовать ключевое слово super.

Вывод программы представлен слева. Последние четыре строки генерируются последними двумя строками в классе Main, которые вызывают переопределенный метод printStr(), на объектах классов Inner01 и Inner02.

Это был довольно таки простой пример наследования от внешнего класса Outer. А вот наследование от внутренних классов выглядит более сложным, так как конструктор внутреннего класса обязан присоединить к объекту ссылку на окружающий внешний объект. Проблема заключается в том, что ссылка на объект внешнего класса должна быть инициализирована, однако в производном классе больше не существует внешнего объекта по умолчанию, с которым можно было бы связаться. Поэтому надо использовать особую форму записи позволяющей явно указать объект внешнего класса.

И так в нашем примере слева у нас есть как иерархия вложенности, так и иерархия наследования. В нашем случае они параллельны, то есть класс Inner02 является внутренним классом класса Inner01, который в свою очередь является внутренним классом класса Outer. Так же и с наследованием. Класс Inner02 является наследником класса Inner01, который в свою очередь является наследником класса Outer. Все это кажется немного запутанным, хотя на самом деле так и есть :)

Самая изюминка тут заключается в конструкторах класса Inner02. В классе Inner01, такой изврат не нужен, так как он наследуется не от внутреннего класса, а от класса верхнего уровня, хотя при желании можно так же извратиться и там :)

Класс же Inner02 у нас расширяет внутренний класс Inner01 для которого, кстати он, так же еще, является и внутренним. Этот нюанс надо запомнить, так как унаследовать внутренний класс может и любой класс верхнего уровня и там будет немного другая ситуация с доступом к членам внешних классов.

Но сейчас поговорим о нашем текущем примере. Если не создавать ни каких конструкторов или просто сделать конструктор по умолчанию без какого либо кода, то наш класс Inner02 не скомпилируется, поскольку ему нужна ссылка на объект внешнего класса.

И наш конструктор собственно создает или использует эти объекты. Но и тут есть тонкость. Когда приходит время вызова конструктора, вы не можете просто использовать конструктор по умолчанию, а так же вы не можете использовать просто ссылку на внешний объект. Необходимо использовать синтаксис следующего вида в теле конструктора:

ссылкаНаВнешнийКласс.super();

Это создает ссылку на внешний класс и программ скомпилируется.
Вывод у нашей программы изменится, т.к. теперь из класса Inner02 будет возможно обратиться к затененному полю str класса Inner01.

Сравните этот вывод с предыдущим выводом программы.

Теперь код

Inner02.super.str

Выводит нам строку Inner02>strInner01, а до этого выводил строку Inner02>strOuter00.

Это произошло потому, что сейчас класс Inner02 является наследником класса Inner01.

Если внутренний класс наследуется обычным образом, то он теряет доступ к private членам своего внешнего класса, в котором он был объявлен. Но доступ к членам protected, public  и пакетного доступа сохраняется. Все то же самое справедливо при наследовании класса любой глубины вложенности. Это означает что любой внутренний класс любой глубины вложенности имеет доступ ко всем членам внешних классов без дополнительного уточнения в именах этих членов. Наследник внутреннего класса (который наследуется обычным образом), так же может обращаться к этим членам без дополнительного уточнения их имени. Исключение составляют только члены внешних классов объявленные как private.

На примере слева красными стрелками показаны ошибки компиляции. Это произошло потому что данные поля объявлены как private во внешнем классе Outer и в классе родителе Inner01. Поэтому они не доступны.

Для этого примера я пока не менял модификаторы доступа для указанных полей, чтобы продемонстрировать что происходит. То есть они остались такие как были в предыдущем примере, скриншот которого вы можете видеть чуть выше (с пояснением с красной стрелкой).

 

В новой мутации нашей программы все работает без ошибок.

Особое внимание обращайте на модификаторы доступа для членов классов и то каким образом к ним происходит обращение в классе External.

Клас External это класс верхнего уровня, который унаследовался от внутреннего класса Inner01.

На этом примере видна разница между обычным наследованием от внутреннего класса, как в классе External и между наследованием внутренним классом от от своего внешнего класса, как в классе Inner02.

Вывод у программы следующий:

В классе Main были добавлены толкьо эти строки:

По существу весь вывод после звездочек генерируется вызовом метода printStr() на объекте ex класса External.

Работа метода printStr() достаточно проста поэтому расписывать ее не буду.

तत् त्वम् असि

тат твам аси

ты есть то

Теперь будем говорить об этом или о том :) короче… о .this

Как уже не раз говорилось вложенный класс содержит ссылку на внешний класс и именно поэтому он имеет доступ ко всем членам внешнего класса. Хотя в определении внутреннего класса эта ссылка явным образом не присутствует, но она есть!

Ты видишь суслика?

Теперь попытаемся увидеть суслика эту с…  ссылку.

Как вы уже знаете this хранит ссылку на текущий объект.  На простом примере слева у нас есть два класса, внешний – Outer, и внутренний – Inner, который к тому же является наследником внешнего.

Вывод программы представлен ниже:

Метод getThis() возвращает this :) как это ни странно :) И далее мы просто выводим это значение в консоль.

Тут все просто и нет ни чего такого чтобы мы еще не знали.

Если же вам потребуется получить ссылку на объект внешнего класса из объекта внутреннего класса, то укажите имя внешнего класса и через точку this:

имя_внешнего_класса.this;

Выведем новы штамм нашей программы, который представлен слева.

Здесь видно каким образом происходит обращение к объекту внешнего класса из объекта внутреннего класса.

 

Вывод у программы следующий:

Обратите внимание что первая и третья строка вывода программы возвращают ссылку на один и тот же объект, то есть на внешний класс Outer.

Теперь подвергнем прогу новой мутации и посмотрим как будет происходить обращение к затененным полям и родительским методам которые были переопределены в классе наследнике.

Вывод обновленной программы:

Если вы помните, то мы так же могли обращаться к затененным полям и переопределенным методам родителей через ключевое слово .super. А сейчас мы это сделали с помощью ключевого слова .this. Но все таки между двумя этими способами есть разница. И сейчас мы попробуем разобраться с этим. Кроме того стоит напомнить, что в начале я сказал, что имя текущего класса перед .super можно опускать и тогда можно просто использовать обычно ключевое слово super (без точки в начале), для обращения к членам класса родителя. А вот с .this так уже сделать не получиться, для получения ссылки на объект внешнего класса это ключевое слово всегда необходимо предварять именем внешнего класса. Надеюсь вы уже поняли разницу в применении и значении этих ключевых слов при работе с внутренними классами? И так ключевое слово super относится к наследованию классов, в то время как ключевое слово .this предваренное именем внешнего класса относится к вложенности классов, то есть позволяет обращаться к объекту внешнего класса. И при этом совсем не обязательно, что вложенный класс должен быть наследником внешнего класса. Он может быть наследником любого другого класса. Точно так же любой класс может быть наследником внутреннего класса, если у него для этого достаточно прав. Не стоит путать линии наследования и линии вложенности – это разные вещи. Теперь рассмотрим пример и его вывод:

В данном примере у нас есть внешний класс Outer в него вложены два класса Inner и SuperInner. Класс SuperInner является наследником класса Inner. А класс Inner является наследником класса Outer. Уровень вложенности классов Inner и SuperInner одинаковый, а вот уровень наследования разный.

Вывод программы представлен слева. Желтым подсвечена интересная строка.

Эта интересная строка вводится кодом, так же подсвеченным желтым, в классе Inner. Если эту строку закомментировать, то вывод будет несколько другой:

Это происходит по причине описанной здесь и частично здесь. Если кратко, то метод суперкласса знает только о поле своего класса и поэтому если метод в классе наследнике не переопределен, то унаследованный метод будет использовать поле своего класса.

Но это так, напоминание о прошлом материале. Самое интересное и нужное для понимания текущего разговора о this и super находится в переопределенном методе getStr() в классе SuperInner. Там мы сперва обращаемся к локальному полю str, затем к полю str класса Inner (от которого унаследовались) при помощи ключевого слова super и затем обращаемся к полю str внешнего класса Outer используя ключевое слово .this предваренное именем внешнего класса.

Так же здесь стоит отметить один очень интересный момент. Как вы видите метод getThis() у нас определен только в классе Outer. Классы Inner и SuperInner его наследуют. Но в отличие от последнего случая, когда мы закомментировали метод getStr() в классе Inner, он всегда возвращает ссылку this на текущий объект для которого был вызван, в то время как унаследованный (не переопределенный) метод getStr() вернул нам строку str класса Outer хотя и был вызван на экземпляре класса Inner (это поведение было объяснено чуть выше).

Надеюсь ни кто не запутался? :) Ну тогда еще один интересный пример:

Вся хитрость состоит в том, что класс Inner является внутренним для класса Outer и наследником класса External и оба этих класса имеют поле str.

Вопрос на засыпку, какое значение выведет команда println(str) и почему?  Ведь для класса Inner видны и доступны оба поля str в классах External и Outer.

Из вывода программы слева видно, что команда println(str) вывела значение унаследованного поля str от класса External. Хотя при этом поле str в классе Outer так же доступно через имя_класса.this.

С введением внутренних классов появляются две отдельные иерархии, к которым может принадлежать любой класс. Первая – это иерархия классов, от родителя к подклассу, определяющая поля и методы, наследуемые внутренним классом. Вторая – это иерархия вложенности, от окружающего класса к внутреннему классу, определяющая набор полей и методов, который входит в область видимости внутреннего класса (и поэтому этот набор ему доступен).

Эти две иерархии полностью отличаются друг от друга; важно, чтобы вы их не путали. Следует избегать конфликтов имен, когда поля или методы родительского класса носят такие же имена, как поля или методы окружающего класса. В случае конфликта имен унаследованное поле или метод имеют более высокий приоритет, чем поле или метод окружающего класса. Такое поведение логично: когда класс наследует поле или метод, то поле или метод становится частью класса. Поэтому унаследованные поля и методы в области видимости класса, который их наследует, имеют преимущество перед полями и методами с такими же именами во внешнем классе.

Я надеюсь что новая мутация класса Outer данной программы добавит ясности в этом вопросе. Теперь мы добавили поле str еще и в класс Inner. А так же строку для его вывода и строку для вывода поля str родительского класса. После этого вывод у программы стал такой:

Первая строка println(str) выводит поле str класса Inner, вторя строка println(super.str) выводит поле str родительского класса External, а третья строка println(Outer.this.str) – поле str внешнего класса Outer.

Хотя конечно затенения полей в таких случаях лучше избегать, проще давать полям разные имена, поскольку тогда к ним будет проще и обращаться, то есть просто по имени поля. По отношению к методам можно дать подобную рекомендацию, хотя их работа и отличается от полей.

Лучше всего избегать глубокой вложенности классов и глубокого наследования, так как проблем можно получить больше чем выгод.

Внутренние классы. Часть 2 – статические вложенные классы.

Статические вложенные классы (nested) очень похожи на классы верхнего уровня. Их обычно используют если необходимо логически связать два класса – внешний и внутренний. Интерфейсы так же могут быть статическими вложенными интерфейсами располагающимися внутри внешнего класса или интерфейса.

Статический вложенный класс определяется внутри другого внешнего класса. Это может выглядеть так:

Как видно из кода, внешним классом является класс OuterClass, статическим вложенным классом является StaticNesterdClass, статическим вложенным интерфейсом является StaticNestedInterface.

Обратите внимание на границы внешнего класса, а так же вложенного статического класса и интерфейса.

По существу внешний класс для статического вложенного класса является как бы мини пакетом.

 

Статический вложенный класс или интерфейс определен как static член окружающего класса, что делает его аналогом поля и метода класса, которые так же объявлены как static. Как и метод класса, статический вложенный класс не связан ни с одним экземпляром внешнего класса, то есть может использоваться без создания экземпляра внешнего класса. Тем не менее статический вложенный класс имеет доступ ко всем static членам окружающего класса, включая любые другие статические вложенные классы и интерфейсы. Статический вложенный класс может использовать любой статический член окружающего класса без указания имени этого окружающего класса.

Статический вложенный класс имеет доступ ко всем статическим членам окружающего класса, включая private члены. Обратное тоже верно: методы окружающего класса имеют доступ ко всем static членам статического вложенного класса, включая его private static члены, однако при обращении к ним необходимо указывать имя статического вложенного класса, которому они принадлежат.

Поскольку статические вложенные классы сами являются членами класса, то статический вложенный класс может быть объявлен с любыми модификаторами доступа. Эти модификаторы имеют одно и то же значение для статических вложенных классов и для остальных членов класса.

Статический вложенный класс не может называться так же, как называется любой из окружающих классов. Кроме того, статические вложенные классы и интерфейсы могут быть объявлены только в классах верхнего уровня и других статических вложенных классах и интерфейсах. В действительности это часть более общего запрета на использование static членов любого вида во внутренних, локальных и анонимных классах.

Из статических вложенных классов вы не можете обращаться к нестатическим членам внешнего класса. Обратное тоже верно – из внешних классов вы не можете обращаться к нестатическим членам вложенного статического класса. Статический вложенный класс для доступа к нестатическим членам и методам внешнего класса должен создавать его объект. Обратное так же верно – для доступа к нестатическим членам вложенного класса, внешний должен создать его объект.

Если в статический вложенный класс вкладывается еще один класс, то это не делает его автоматически статическим, он будет вложенным inner классом, даже если его окружающий класс является вложенным в интерфейс. Чтобы класс вложенный в статический класс был статическим необходимо это явно указать при помощи ключевого слова static.

Ну и теперь немного практики…

Вывод данной программы представлен слева. Обратите внимание на то, каким образом был создан экземпляр класса Nested. Перед ним использовалось уточняющее имя внешнего класса Outer. Данный синтаксис можно изменить импортом внутреннего класса Nested.

nst.getName() выводит private поле nestedName. Заметьте что оно не статическое и private. nst.getOuterName() выводит статическое private поле outerName внешнего класса Outer. Далее выводиться статическое поле out внешнего класса Outer. Мы смогли это сделать так как оно статическое. Далее выводится статическое поле nst вложенного класса Nested через уточнение именем класса Outer.

Затем мы создаем экземпляр класса Outer и получаем через него доступ к private static полю outerName через вызов метода getName() на экземпляре класса Outer. И последняя строка выводит private static поле вложенного класса через метод внешнего класса getStnst(), который имеет доступ даже к private static полям вложенного класса. Ну как не запутались? :) По идее пока все не очень сложно :)

Ну и еще стоит отметить, что компилятор все равно нам создал три .class файла. Но вложенный класс Nested создан с уточняющим именем внешнего класса Outer через знак $. Поэтому все вложенные классы являются чистым синтаксическим сахарком, но достаточно нужным и удобным.

В коде, расположенном вне окружающего класса, на статический вложенный класс или интерфейс ссылаются по имени внешнего класса с последующим добавлением имени внутреннего класса (например, Outer.Nested). Для импорта статических классов-членов можно применять директиву import:

import pro.java.nested.Outer.Nested; // импорт вложенного класса Nested
import pro.java.nested.Outer.*; // импорт всех вложенных классов из класса Outer

Импортировать внутренние классы не рекомендуется, потому что данная операция скрывает факт того, что класс тесно связан с содержащим его классом. Поскольку строка создания экземпляра класса будет уже выглядеть, например, вот так:

Nested nst = new Nested("MyNested");

То есть в данном случае мы уже не видим что класс Nested является вложенным классом класса Outer, как это было явно видно до импорта:

Outer.Nested nst = new Outer.Nested("MyNested");

 

Теперь еще немного поговорим о вложенных интерфейсах. Я добавил в класс Outer вложенный интерфейс IGetNames и вложенный класс GetNames в котором реализовал этот интерфейс, а так же в класс Main добавил создание экземпляра класса GetNames и использование его методов.

Здесь я привел лишь отрывки кода который был добавлен. В этом примере класс GetNames является вложенным в класс Outer, но ни что не мешает вложить его в интерфейс IGetNames.

 

Но тогда уже придется уточнять имя класса вложенного в интерфейс через имя внешнего класса и имя вложенного интерфейса:

Outer.IGetNames.GetNames gn = new Outer.IGetNames.GetNames();

Для наглядности, так же приведу отрывки измененного кода в классе Outer. в классе Main была изменена лишь строка создания экземпляра класса GetNames, которая уже была приведена выше.

Оба два предыдущих примера генерируют следующий вывод:

Три последние строки генерируются вызовом методов на экземпляре класса GetNames.

Вызов этих методов приведен на отрывке кода представленного на скриншоте выше.

Интересно так же посмотреть на те .class файлы которые получились в результате наших изменений в коде классов.

Как видим у нас получилось пять .class файлов. По одному на каждый из наших классов и интерфейсу. Особое внимание следует обратить на имена вложенных классов и интерфейса. Уровень вложенности классов разделяется знаком $. Знак доллара является валидным символов в именах классов, но предназначен для использования только компилятором и JVM.

Кстати сказать избавиться от длинной строки создания экземпляра класса GetNames можно все тем же импортом. Для этого нам надо импортировать этот класс по его полному имени:

import pro.java.nested.Outer.IGetNames.GetNames;

Тогда строка создания экземпляра класса GetNames будет выглядеть так:

GetNames gn = new GetNames();

Но опять же тут не очевидно что GetNames это вложенный класс, хотя эта запись гораздо короче.

Вложенные классы можно размещать и просто в интерфейсах. Любой класс, помещенный в интерфейс, автоматически объявляется как открытый (public) и статический (static). Так как класс объявляется как static, он не нарушает правил обращения с интерфейсом – этот вложенный класс всего лишь размещается в пространстве имен интерфейса. И как я уже показывал, вы даже можете реализовать окружающий интерфейс во внутреннем классе. Хитрый пример показан слева. И если вы его просто попробуете запустить из Eclipse, то ни чего не выйдет, хотя этот файл без проблем и ошибок скомпилируется. И он даже работает и его даже можно запустить, но используя магию правильное понимание. Это понимание можно почерпнуть здесь. Но все же его стоит чуть обновить до нынешних наших знаний.

И поможет нам в этом магия утилиты javap

То есть нам надо запускать класс содержащий метод main() по его полному имени и делать это правильным образом из правильного места.

Но можно сделать это и из Eclipse указав класс где находится метод main():

Вложение классов в интерфейсы особенно удобно при создании общего кода, который должен использоваться со всеми реализациями этого интерфейса.

Статические вложенные классы можно так же использовать для проверки работоспособности классов, то есть для их тестирования. Поскольку в них вы можете расположить метод main(). Как вы уже знаете при компиляции будет скомпилирован отдельный .class файл для вложенного класса, который вы можете запускать для тестирования работы отдельного класса не запуская всю программу. Кроме того, в окончательную сборку программы можно не включать файлы .class которые были сгенерированы для тестирования, их можно просто удалить и собрать программу, таким образом в ней не будет лишнего кода, который вы создали для тестирования.

На примерах слева и сверху представлены два класса Main, содержащий метод main() и SomeClass, содержащий вложенный класс Test, который так же содержит метод main().

После компиляции получается соответственно три файла с расширением .class:

Если посмотреть на содержимое файлов SomeClass.class и SomeClass$Test.class при помощи javap, то увидим следующее:

Как видим в байт коде класса SomeClass не присутствует код вложенного в него класса Test, поскольку он находится в отдельном своем .class файле, в котором есть метод main(). И этот .class файл мы можем запустить отдельно от класса Main. Так же мы можем запустить на исполнение и класс Main, и даже если мы удалим откомпилированный .class файл класса Test, то наша программа все равно будет работать правильно.

В дополнение ко всему вышесказанному предлагаю посмотреть хорошее видео по вложенным статическим классам:

Практики ради, я написал почти такой же код, как и в этом видео, но естественно его немного изменил дабы лишний раз запутать напомнить о пространстве видимости имен в коде.

Что тут стоить отметить, так это то что в классе Human, а так же в его вложенном классе Relations используется идентификатор relations во множестве мест и при этом не происходит ни какой путаницы. Кроме того, в отличие от примера на видео, я сперва создал объект статического вложенного класса, а уже только потом создал объект внешнего класса, чтобы подчеркнуть независимость одного от другого.

Теперь еще стоит поговорить о наследовании в статических вложенных классах.

Статический вложенный класс способен наследовать другие классы, реализовывать интерфейсы и являться объектом наследования для любого класса, обладающего необходимыми правами доступа. Подкласс вложенного класса не способен унаследовать возможность доступа к членам внешнего класса, которыми наделен его суперкласс, если он не является вложенным классом своего суперкласса. Похоже опять получилось сильно заумно :), хотя как всегда ни чего сложного нет.

И теперь опять попрактикуемся…

Вывод у программы следующий:

Как видим в этом примере у нас есть два класса наследника вложенного класса Nested. Это классы Ext1 и Ext2. Причем Ext1 является внутренним классом для класса Nested и соответственно имеет доступ ко всем полям внешнего класса Outer. Обращаю внимание что класс Ext1 не статический, а внутренний, то есть inner (это наша следующая тема). Класс же Ext2 не является внутренним классом Nested хотя и наследует его и поэтому он не имеет доступа к полям класса Nested. Следует обратить внимание на интересный синтаксис создания экземпляра класса Ext1. Поскольку класс Ext1 не статический, то он не может быть создан без привязки к экземпляру его внешнего класса.

Если же класс Ext1 сделать статическим, то строка создания его экземпляра будет выглядеть для нас уже привычным образом:

Outer.Nested.Ext1 ext1 = new Outer.Nested.Ext1();

Во всем остальном программа не изменится и будет работать так же как и работала.

Можно так же привести примеры использования статических вложенных классов из реальной жизни. Что может быть более реального чем стандартная библиотека java в которой существует класс java.awt.geom.Rectangle2D который имеет два вложенных класса, Float и Double. Это очень простые классы форм и было бы просто ни к чему умножать количество высокоуровневых классов в этом пакете еще на два.

Ну и завершим все небольшим примером реализации простенького стека с помощью вложенных классов. Это несколько измененный пример стека который мы уже делали, но там я не приводил вывода данной программы. Да и вообще текущий пример я сильно переделал. Теперь в стеке можно размещать вообще любые объекты а не только целые числа, кроме того я добавил наследование, что сократило код класса вложенного класса DynStack. Данный пример я сделал двумя коммитами, первый без реализации динамического стека, второй с реализацией.

Тут представлен окончательный вариант с реализацией интерфейса IStack двумя классами FixedStack и DynStack. Причем класс DynStack является вложенным в класс FixedStack, который в свою очередь вложен в интерфейс IStack. Класс DynStack наследуется от класса FixedStack и поэтому там переопределен только один метод push(), который увеличивает размер стека в два раза при его заполнении.

Стоит обратить внимание на то что для класса FixedStack мы не писали слово static, хотя он таковым и является поскольку является вложенным в интерфейс классом. А вот для класса DynStack нам уже пришлось написать слово static, так как если бы мы этого не сделали, то этот класс был бы внутренним, то есть inner – не статическим.

Ну и на последок длинная портянка вывода данной программы:

Первая строка выводится сразу же после создания объекта fix. Тогда еще стек пустой.

Затем мы добавили в стек единицу и вывели его состояние.

После добавили строку и опять вывели состояние.

Затем добавили значение типа double 55.55 и вывели состояние.

Затем попытались добавить ссылку null, что вполне легитимно для Object, но нам выдалось сообщение что стек полон.

После этого мы произвели операцию изъятия из стека значения и вывели опять стек, теперь у нас там два элемента – строка и единица.

После этого напечатали звездочки и создали объект динамического стека.

Добавили туда 10 вывели значение.

Добавили другую строку и снова вывели значение.

Затем добавили туда значение 77.77, но поскольку стек у нас был из двух элементов, то произошло увеличение размера стека, о чем мы и получили сообщение и уже в увеличенные стек было помещено значение 77.77 что мы и видим в выводе программы.

После этого значение 77.77 было изъято из стека и содержимое стека было выведено на экран.

За сим все! Кино про статические вложенные классы закончено :)

Далее в программе изучение внутренних inner классов.

Да и вообще далее еще много чего :)