outer.new Inner(). Взамен внутренний класс получает доступ ко всем полям внешнего, включая private. Внутренние классы выделяют сущности, которые отдельно от внешнего класса не имеют смысла.Кратко
- Вложенные классы (nested classes) делятся на два вида: нестатические, они же внутренние (inner), и статические (static nested).
- У внутренних классов есть два особых подвида: локальный класс и анонимный класс.
- Объект внутреннего класса не создать без объекта внешнего:
Bicycle.Seat seat = peugeot.new Seat(); - Внутренний класс видит поля внешнего, даже приватные, и обращается к ним через
Bicycle.this.поле. - Внутренний класс уместен, когда сущность бессмысленна сама по себе (руль без велосипеда). Если часть самоценна (магазин запчастей), нужен обычный класс.
- Модификатор доступа внутреннего класса определяет, откуда можно создавать его объекты: от
public(отовсюду) доprivate(только внутри внешнего класса).
class OuterClass {
...
static class StaticNestedClass {
...
}
class InnerClass {
...
}
}
Виды вложенных классов
Они делятся на 2 вида:- Non-static nested classes, то есть нестатические вложенные классы. По-другому их еще называют inner classes, внутренние классы.
- Static nested classes, статические вложенные классы.
- локальным классом (local class)
- анонимным классом (anonymous class)
На сегодняшней лекции мы поговорим об Inner classes, то есть о внутренних классах (они же non static nested classes, нестатические вложенные классы).
Они специально выделены на общей схеме, чтобы ты не потерялся :)Что такое внутренний класс (inner class)
Начнем с очевидного вопроса: почему эти классы называются «внутренними»? Ответ достаточно прост: потому что они создаются внутри других классов. Вот пример:
public class Bicycle {
private String model;
private int weight;
public Bicycle(String model, int weight) {
this.model = model;
this.weight = weight;
}
public void start() {
System.out.println("Поехали!");
}
public class HandleBar {
public void right() {
System.out.println("Руль вправо!");
}
public void left() {
System.out.println("Руль влево!");
}
}
public class Seat {
public void up() {
System.out.println("Сиденье поднято выше!");
}
public void down() {
System.out.println("Сиденье опущено ниже!");
}
}
}
Bicycle, то есть велосипед. У него есть 2 поля и 1 метод: start().
Его отличие от обычного класса в том, что у него есть два класса, код которых написан внутри Bicycle: это классы HandleBar (руль) и Seat (сиденье).
Это полноценные классы: как видишь, у каждого из них есть собственные методы.
Зачем нужны внутренние классы
На этом моменте у тебя мог возникнуть вопрос: а зачем мы вообще засунули одни классы внутрь другого? Зачем делать их внутренними? Ну ладно, допустим, нам нужны в программе отдельные классы для руля и сидения. Но ведь необязательно делать их вложенными! Можно же сделать обычные классы. Например, вот так:
public class HandleBar {
public void right() {
System.out.println("Руль вправо!");
}
public void left() {
System.out.println("Руль влево");
}
}
public class Seat {
public void up() {
System.out.println("Сиденье поднято выше!");
}
public void down() {
System.out.println("Сиденье опущено ниже!");
}
}
public class Main {
public static void main(String[] args) {
HandleBar handleBar = new HandleBar();
handleBar.right();
}
}
public class Main {
public static void main(String[] args) {
Bicycle peugeot = new Bicycle("Peugeot", 120);
Bicycle.HandleBar handleBar = peugeot.new HandleBar();
Bicycle.Seat seat = peugeot.new Seat();
seat.up();
peugeot.start();
handleBar.left();
handleBar.right();
}
}
Сиденье поднято выше!
Поехали!
Руль влево!
Руль вправо!
Когда внутренние классы не нужны
Теперь давай рассмотрим другую ситуацию. Допустим, мы хотим создать программу, моделирующую магазин велосипедов и их запчастей.
В этой ситуации наше предыдущее решение будет неудачным.
В рамках магазина запчастей каждая отдельная часть велосипеда имеет смысл даже отдельно от сущности велосипеда. Например, нам понадобятся методы типа «продать покупателю педали», «купить новое сидение» и т.д.
Здесь использовать внутренние классы было бы ошибкой: каждая отдельная часть велосипеда в рамках нашей новой программы имеет собственный смысл: она отделима от сущности велосипеда, никак не привязана к нему.
Именно на это тебе следует обращать внимание, если ты задумался, нужно ли тебе использовать внутренние классы, или разнести все сущности по отдельным классам.
Объектно-ориентированное программирование хорошо тем, что позволяет легко моделировать сущности реального мира. Именно этим ты можешь руководствоваться, решая, нужно ли использовать внутренние классы. В реальном магазине запчасти отдельно от велосипедов это нормально. Значит, и при проектировании программы это будет правильно.
Ладно, с «философией» разобрались :)Шесть особенностей внутренних классов
Теперь давай познакомимся с важными «техническими» особенностями внутренних классов. Вот что тебе обязательно нужно помнить и понимать:Объект внутреннего класса не может существовать без объекта «внешнего» класса.
Это логично: для того мы и сделали
SeatиHandleBarвнутренними классами, чтобы в нашей программе не появлялись то тут, то там бесхозные рули и сиденья.Этот код не скомпилируется:
public static void main(String[] args) { HandleBar handleBar = new HandleBar(); }Из этого вытекает следующая важная особенность:
У объекта внутреннего класса есть доступ к переменным «внешнего» класса.
Для примера давай добавим в наш класс
Bicycleпеременнуюint seatPostDiameter, диаметр подседельного штыря.Тогда во внутреннем классе
Seatмы можем создать методgetSeatParam(), который сообщит нам параметр сиденья:public class Bicycle { private String model; private int weight; private int seatPostDiameter; public Bicycle(String model, int weight, int seatPostDiameter) { this.model = model; this.weight = weight; this.seatPostDiameter = seatPostDiameter; } public void start() { System.out.println("Поехали!"); } public class Seat { public void up() { System.out.println("Сиденье поднято выше!"); } public void down() { System.out.println("Сиденье опущено ниже!"); } public void getSeatParam() { System.out.println("Параметр сиденья: диаметр подседельного штыря = " + Bicycle.this.seatPostDiameter); } } }И теперь мы можем получить эту информацию в нашей программе:
public class Main { public static void main(String[] args) { Bicycle bicycle = new Bicycle("Peugeot", 120, 40); Bicycle.Seat seat = bicycle.new Seat(); seat.getSeatParam(); } }Вывод в консоль:
Параметр сиденья: диаметр подседельного штыря = 40Обрати внимание: новая переменная объявлена с самым строгим модификатором,
private. И все равно у внутреннего класса есть доступ!Объект внутреннего класса нельзя создать в статическом методе «внешнего» класса без ссылки на его объект.
Это объясняется особенностями устройства внутренних классов. У внутреннего класса могут быть конструкторы с параметрами или только конструктор по умолчанию. Но независимо от этого, когда мы создаем объект внутреннего класса, в него незаметно передается ссылка на объект «внешнего» класса. Ведь наличие такого объекта это обязательное условие. Иначе мы не сможем создавать объекты внутреннего класса.
Но если метод внешнего класса статический, значит, объект внешнего класса может вообще не существовать! А значит, логика работы внутреннего класса будет нарушена. В такой ситуации компилятор выбросит ошибку:
public static Seat createSeat() { //Bicycle.this cannot be referenced from a static context return new Seat(); }До Java 16 внутренний класс не мог содержать статические переменные и методы.
Логика здесь та же: статические методы и переменные могут существовать и вызываться даже при отсутствии объекта.
Но без объекта «внешнего» класса доступа к внутреннему классу у нас не будет.
Явное противоречие! Поэтому наличие статических переменных и методов во внутренних классах запрещено.
Компилятор выбросит ошибку при попытке их создать:
public class Bicycle { private int weight; private int seatPostDiameter; public class Seat { //до Java 16: inner class cannot have static declarations public static void getSeatParam() { System.out.println("Параметр сиденья: диаметр подседельного штыря = " + Bicycle.this.seatPostDiameter); } } }Начиная с Java 16 это ограничение сняли: внутренний класс может объявлять статические поля и методы. Но обращаться к полям внешнего объекта из статического метода все равно нельзя, объекта может и не быть.
При создании объекта внутреннего класса важную роль играет его модификатор доступа.
Внутренний класс можно обозначить стандартными модификаторами доступа:
public,private,protectedиpackage private.Почему это важно?
Это влияет на то, где в нашей программе мы сможем создавать экземпляры внутреннего класса.
Если наш класс
Seatобъявлен какpublic, мы можем создавать его объекты в любом другом классе. Единственное требование: объект «внешнего» класса тоже обязательно должен существовать.Кстати, мы уже это делали вот здесь:
public class Main { public static void main(String[] args) { Bicycle peugeot = new Bicycle("Peugeot", 120); Bicycle.HandleBar handleBar = peugeot.new HandleBar(); Bicycle.Seat seat = peugeot.new Seat(); seat.up(); peugeot.start(); handleBar.left(); handleBar.right(); } }Мы легко получили доступ к внутреннему классу
HandleBarиз классаMain.Если же мы объявим внутренний класс как
private, доступ к созданию объектов у нас будет только внутри «внешнего» класса.Создать объект
Seatснаружи мы уже не сможем:private class Seat { //методы } public class Main { public static void main(String[] args) { Bicycle bicycle = new Bicycle("Peugeot", 120, 40); //Bicycle.Seat has a private access in 'Bicycle' Bicycle.Seat seat = bicycle.new Seat(); } }Наверное, ты уже понял логику :)
Модификаторы доступа для внутренних классов работают так же, как и для обычных переменных.
Модификатор
protectedпредоставляет доступ к переменной класса в его классах-наследниках и в классах, которые находятся в том же пакете.Так же
protectedработает и для внутренних классов. Объектыprotectedвнутреннего класса можно создавать:- внутри «внешнего» класса;
- в его классах-наследниках;
- в тех классах, которые находятся в том же пакете.
Если у внутреннего класса нет модификатора доступа (
package private), объекты внутреннего класса можно создавать:- внутри «внешнего» класса;
- в классах, которые находятся в том же пакете.
С модификаторами ты уже давно знаком, так что тут проблем не будет.
Модификаторы доступа внутреннего класса: сводка
Соберем правила из двух последних пунктов в одну таблицу:| Модификатор внутреннего класса | Где можно создавать его объекты |
|---|---|
public | в любом классе, лишь бы существовал объект «внешнего» класса |
protected | внутри «внешнего» класса, в его классах-наследниках и в классах того же пакета |
без модификатора (package private) | внутри «внешнего» класса и в классах того же пакета |
private | только внутри «внешнего» класса |
ПЕРЕЙДИТЕ В ПОЛНУЮ ВЕРСИЮ
методахклассах можно объявлять статические переменные!