Внутренние классы. Часть 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.

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

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