class OuterClass {
...
static class StaticNestedClass {
...
}
class InnerClass {
...
}
}
- Non-static nested classes — нестатические вложенные классы. По-другому их еще называют inner classes — внутренние классы.
- Static nested classes — статические вложенные классы.
- локальным классом (local class)
- анонимным классом (anonymous class)
На сегодняшней лекции мы поговорим об Inner classes — внутренних классах (они же — non static nested classes, нестатические вложенные классы).
Они специально выделены на общей схеме, чтобы ты не потерялся :)
Начнем с очевидного вопроса: почему эти классы называются «внутренними»?
Ответ достаточно прост: потому что они создаются внутри других классов.
Вот пример:
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(); }Внутренний класс не может содержать статические переменные и методы.
Логика здесь та же: статические методы и переменные могут существовать и вызваться даже при отсутствии объекта.
Но без объекта «внешнего» класса доступа к внутреннему классу у нас не будет.
Явное противоречие! Поэтому наличие статических переменных и методов во внутренних классах запрещено.
Компилятор выбросит ошибку при попытке их создать:
public class Bicycle { private int weight; public class Seat { //inner class cannot have static declarations public static void getSeatParam() { System.out.println("Параметр сиденья: диаметр подседельного штыря = " + Bicycle.this.seatPostDiameter); } } }При создании объекта внутреннего класса важную роль играет его модификатор доступа.
Внутренний класс можно обозначить стандартными модификаторами доступа —
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), объекты внутреннего класса можно создавать- внутри «внешнего» класса;
- в классах, которые находятся в том же пакете.
С модификаторами ты уже давно знаком, так что тут проблем не будет.
ПЕРЕЙДИТЕ В ПОЛНУЮ ВЕРСИЮ
методахклассах можно объявлять статические переменные!