Привет! Давай поговорим о еще одной разновидности вложенных классов. А именно, о локальных классах (Method local inner classes).
Если коротко,
локальный класс (method local inner class) это класс, объявленный прямо внутри блока кода: чаще всего внутри метода, но так же законно внутри конструктора, блока инициализации или даже тела цикла. Виден он только внутри своего блока, снаружи создать объект такого класса не получится. Взамен он видит и поля внешнего класса, включая приватные, и локальные переменные того метода, в котором объявлен.
Кратко
- Локальный класс объявляют внутри блока кода: метода, конструктора, блока инициализации, даже тела цикла.
- Область видимости у него ровно один блок: снаружи нельзя ни объявить переменную такого типа, ни вернуть его из метода.
- Все поля и методы внешнего класса ему доступны, включая приватные и статические.
- Локальные переменные и параметры метода тоже доступны, но только те, что не меняют значения после инициализации. До Java 8 их приходилось помечать словом
final.
- Локальный класс это подвид внутреннего, поэтому сам он никогда не бывает статическим, а модификаторы
public, protected и private к нему неприменимы.
- Берут его тогда, когда вспомогательный тип нужен ровно в одном методе и больше нигде.
Первое, что нужно вспомнить перед изучением, это их место в структуре вложенных классов.
![Схема вложенных классов: Nested classes делятся на Inner class и Static nested classes, а внутри Inner class стоят Inner class, Method-local Inner Class и Anonymous Inner Class]()
Исходя из нашей схемы мы можем понять, что локальные классы это подвид внутренних классов, о которых мы говорили подробно в
одном из прошлых материалов.
Где можно объявить локальный класс
Однако, у локальных классов есть ряд важных особенностей и отличий от внутренних классов. Главное заключается в их объявлении:
Локальный класс объявляется только в блоке кода. Чаще всего внутри какого-то метода внешнего класса.
Например, это может выглядеть так:
public class PhoneNumberValidator {
public void validatePhoneNumber(String number) {
class PhoneNumber {
private String phoneNumber;
public PhoneNumber() {
this.phoneNumber = number;
}
public String getPhoneNumber() {
return phoneNumber;
}
public void setPhoneNumber(String phoneNumber) {
this.phoneNumber = phoneNumber;
}
}
}
}
ВАЖНО! Этот код не скомпилируется при вставке в IDEA, если у тебя установлена Java 7.
О причинах этого мы поговорим в конце лекции. В нескольких словах: работа локальных классов сильно зависит от версии языка. Если этот код у тебя не компилируется, ты можешь либо переключить версию языка в IDEA на Java 8, либо добавить слово
final к параметру метода, чтобы получилось так:
validatePhoneNumber(final String number).
После этого все заработает.
Это небольшая программа, валидатор телефонных номеров.
Ее метод
validatePhoneNumber() принимает на вход строку и определяет, является ли она номером телефона.
И внутри этого метода мы объявили наш локальный класс
PhoneNumber.
Зачем локальный класс, если есть внутренний
У тебя мог возникнуть логичный вопрос: зачем? Зачем объявлять класс именно внутри метода? Почему не использовать обычный внутренний класс?
Действительно, можно было бы поступить и так: сделать класс
PhoneNumber внутренним.
Другое дело, что итоговое решение зависит от структуры и предназначения твоей программы.
Давай вспомним наш пример из лекции про внутренние классы:
public class Bicycle {
private String model;
private int mawWeight;
public Bicycle(String model, int mawWeight) {
this.model = model;
this.mawWeight = mawWeight;
}
public void start() {
System.out.println("Поехали!");
}
public class HandleBar {
public void right() {
System.out.println("Руль вправо!");
}
public void left() {
System.out.println("Руль влево!");
}
}
}
В нем мы сделали
HandleBar (руль) внутренним классом велосипеда.
В чем же разница? Прежде всего, в использовании класса.
Класс
HandleBar из второго примера это сущность более сложная, чем
PhoneNumber из первого.
Во-первых, у
HandleBar есть публичные методы
right и
left (не являются сеттером и геттером). Во-вторых, нельзя заранее предположить, где он и его внешний класс
Bicycle могут нам понадобиться: это могут быть десятки разных мест и методов даже в рамках одной программы.
А вот с классом
PhoneNumber все гораздо проще. Программа у нас совсем простая. У нее всего одна функция: проверить, является ли число номером телефона.
В большинстве случаев наш
PhoneNumberValidator будет даже не самостоятельной программой, а просто частью в логике авторизации для основной программы.
Например, на разных сайтах при регистрации часто просят ввести номер телефона. И если напечатать какую-нибудь чушь вместо цифр, сайт выдаст ошибку: «Это не номер телефона!».
Для работы такого сайта (а точнее, механизма авторизации пользователя) его разработчики могут включить в код аналог нашего
PhoneNumberValidator.
Иными словами, у нас есть один внешний класс с одним методом, который будет использован в одном месте программы и больше нигде. А если и будет, то в нем ничего не изменится: один метод делает свою работу, и все.
В этом случае, раз уж вся логика работы собрана в одном методе, будет гораздо удобнее и правильнее инкапсулировать там и дополнительный класс.
Своих методов, кроме геттера и сеттера, у него нет. Нам, по сути, нужны только данные из его конструктора.
В других методах он не задействован. Поэтому нет причин выносить информацию о нем за пределы единственного метода, где он используется.
Мы и привели пример с объявлением локального класса в методе, но это не единственная возможность.
Его можно объявить просто в блоке кода:
public class PhoneNumberValidator {
{
class PhoneNumber {
private String phoneNumber;
public PhoneNumber(String phoneNumber) {
this.phoneNumber = phoneNumber;
}
}
}
public void validatePhoneNumber(String phoneNumber) {
}
}
Или даже в цикле
for!
public class PhoneNumberValidator {
public void validatePhoneNumber(String phoneNumber) {
for (int i = 0; i < 10; i++) {
class PhoneNumber {
private String phoneNumber;
public PhoneNumber(String phoneNumber) {
this.phoneNumber = phoneNumber;
}
}
}
}
}
Но такие случаи крайне редко встречаются. В большинстве случаев объявление будет происходить все же внутри метода.
Итак, с объявлением мы разобрались, про «философию» тоже поговорили :)
Какие же у локальных классов есть еще особенности и отличия от внутренних классов?
Объект локального класса не создать за пределами блока
Представь, что нам нужен метод
generatePhoneNumber(), который бы генерировал случайный номер телефона и возвращал объект
PhoneNumber.
Мы не сможем создать такой метод в нашем классе-валидаторе в текущей ситуации:
public class PhoneNumberValidator {
public void validatePhoneNumber(String number) {
class PhoneNumber {
private String phoneNumber;
public PhoneNumber() {
this.phoneNumber = number;
}
public String getPhoneNumber() {
return phoneNumber;
}
public void setPhoneNumber(String phoneNumber) {
this.phoneNumber = phoneNumber;
}
}
}
public PhoneNumber generatePhoneNumber() {
}
}
Доступ к локальным переменным и параметрам метода
Еще одна важная особенность локальных классов, это возможность добраться до локальных переменных и параметров того метода, где класс объявлен.
Если ты вдруг забыл, «локальной» называют переменную, объявленную внутри метода.
То есть, если мы создадим для каких-то своих целей локальную переменную
String russianCountryCode внутри метода
validatePhoneNumber(), мы можем получить к ней доступ из локального класса
PhoneNumber.
Однако, здесь есть очень много тонкостей, которые зависят от версии языка, используемого в программе.
В начале лекции мы сделали отметку о том, что код одного из примеров может не компилироваться в Java 7, помнишь? Сейчас рассмотрим причины этого :)
Java 7: только final
В Java 7 локальный класс мог получить доступ к локальной переменной или параметру метода, только если они объявлены в методе как
final:
public void validatePhoneNumber(String number) {
String russianCountryCode = "+7";
class PhoneNumber {
private String phoneNumber;
public PhoneNumber() {
this.phoneNumber = number;
}
public void printRussianCountryCode() {
System.out.println(russianCountryCode);
}
}
}
Здесь компилятор выбросил две ошибки.
А вот здесь все в порядке:
public void validatePhoneNumber(final String number) {
final String russianCountryCode = "+7";
class PhoneNumber {
private String phoneNumber;
public PhoneNumber() {
this.phoneNumber = number;
}
public void printRussianCountryCode() {
System.out.println(russianCountryCode);
}
}
}
Теперь ты знаешь причину, по которой код из начала лекции не компилировался: локальный класс в версии Java 7 имел доступ только к
final-параметрам метода и к
final-локальным переменным.
Java 8: достаточно effectively final
В Java 8 поведение локальных классов было изменено.
В этой версии языка локальный класс имеет доступ не только к
final-локальным переменным и параметрам, но и к
effectively final.
Effectively final называют переменную, значение которой не менялось после инициализации.
Например, в Java 8 мы без проблем можем вывести в консоль переменную
russianCountryCode, даже если она не
final. Главное, чтобы она не меняла своего значения.
Вот в этом примере все работает как надо:
public void validatePhoneNumber(String number) {
String russianCountryCode = "+7";
class PhoneNumber {
public void printRussianCountryCode() {
System.out.println(russianCountryCode);
}
}
}
А вот если мы изменим значение переменной сразу после инициализации, код не скомпилируется.
public void validatePhoneNumber(String number) {
String russianCountryCode = "+7";
russianCountryCode = "+8";
class PhoneNumber {
public void printRussianCountryCode() {
System.out.println(russianCountryCode);
}
}
}
Что у локального класса общего с внутренним
Но недаром локальный класс это подвид внутреннего класса! У них есть и общие моменты.
У локального класса есть доступ ко всем (даже приватным) полям и методам внешнего класса: и к статическим, и к нестатическим.
Для примера, добавим к нашему классу-валидатору статическое поле
String phoneNumberRegex:
public class PhoneNumberValidator {
private static String phoneNumberRegex = "[^0-9]";
public void validatePhoneNumber(String phoneNumber) {
class PhoneNumber {
}
}
}
С помощью этой статической переменной и будет выполняться валидация. Метод проверяет, есть ли в строке, которую ему передали, символы, подходящие под регулярное выражение "
[^0-9]": квадратные скобки с крышкой означают отрицание, так что под него попадает все, что не является цифрой от 0 до 9.
Мы легко можем получить доступ к этой переменной из локального класса
PhoneNumber. Например, написать геттер:
public String getPhoneNumberRegex() {
return phoneNumberRegex;
}
Ограничения на статические члены
Локальные классы похожи на внутренние классы еще и набором ограничений: до Java 16 ни те, ни другие не могли объявлять статические члены, кроме констант. А вот правило, которое действует и сейчас: локальные классы в статических методах могут ссылаться только на статические члены включающего класса (об этом же говорит и
руководство Oracle по локальным классам).
Например, если ты не определил переменную (поле) включающего класса как статическую, компилятор Java генерирует ошибку: «Из статического контекста нельзя ссылаться на нестатическую переменную». Локальные классы не статичные, потому что у них есть доступ к членам экземпляра вмещающего блока. Следовательно, до Java 16 они не могли содержать большинство видов статических объявлений.
До Java 16 нельзя было объявить интерфейс внутри блока: интерфейсы по своей природе статичны. На старых версиях этот код не компилируется:
public class PhoneNumberValidator {
public static void validatePhoneNumber(String number) {
interface I {}
class PhoneNumber implements I{
private String phoneNumber;
public PhoneNumber() {
this.phoneNumber = number;
}
}
}
}
Но если интерфейс объявлен внутри внешнего класса, класс
PhoneNumber может его реализовать:
public class PhoneNumberValidator {
interface I {}
public static void validatePhoneNumber(String number) {
class PhoneNumber implements I{
private String phoneNumber;
public PhoneNumber() {
this.phoneNumber = number;
}
}
}
}
Подведем черту под старым порядком: в локальных классах нельзя было объявлять ни статические инициализаторы (блоки инициализации), ни интерфейсы, а статические члены допускались только в виде констант (
static final).
Что изменилось в Java 16
Все три запрета выше сняты в Java 16. Вместе с записями (JEP 395) язык разрешил объявлять внутри блока не только классы, но и интерфейсы, перечисления и записи, а заодно снял давнее ограничение, по которому внутренний класс не мог иметь статических членов. Спецификация формулирует это прямо: внутренний класс может объявлять и наследовать статические члены и объявлять статические инициализаторы, хотя сам статическим не является, а до Java SE 16 его статическими членами могли быть только константы.
Так что на современной версии оба примера выше компилируются, а рядом с локальным классом можно объявить и локальный интерфейс, и локальную запись:
public void validatePhoneNumber(String number) {
interface Checker {
boolean check(String value);
}
record PhoneNumber(String value) { }
class Codes {
static final String RUSSIA = "+7";
static String withCode(String value) {
return RUSSIA + value;
}
}
}
Одна тонкость: локальные интерфейсы, перечисления и записи неявно статические, поэтому, в отличие от локального класса, локальные переменные метода они не видят. А сам локальный класс статическим быть по-прежнему не может, тут ничего не поменялось.
Локальный и внутренний класс: сводка
Соберем все различия, о которых шла речь, в одну таблицу:
|
Внутренний класс |
Локальный класс |
| Где объявляется |
В теле внешнего класса, рядом с полями и методами |
Внутри блока кода: метода, конструктора, инициализатора, цикла |
| Откуда виден |
Из всего внешнего класса, а с модификатором доступа и снаружи |
Только из того блока, где объявлен |
| Годится ли как тип возвращаемого значения |
Да |
Нет, за пределами блока такого типа просто не существует |
| Доступ к полям внешнего класса |
Есть, включая приватные |
Есть, включая приватные |
| Доступ к локальным переменным метода |
Нет, он объявлен не в методе |
Есть, если переменная не меняет значения после инициализации |
| Модификаторы доступа |
public, protected, private разрешены |
Запрещены, как и static |
| Когда брать |
Сущность нужна в нескольких методах внешнего класса |
Вспомогательный тип нужен ровно в одном методе |
Вот такие они, локальные классы! Как видишь, у них немало отличий от внутренних классов. Нам даже пришлось погрузиться в особенности версии языка, чтобы разобраться в их работе :)
На следующей лекции поговорим об
анонимных внутренних классах, последней группе вложенных классов.
Удачи в обучении! :)
Вопросы и ответы
Что такое локальный класс в Java?
Это класс, объявленный внутри блока кода, а не в теле внешнего класса: внутри метода, конструктора, блока инициализации или цикла. В официальной терминологии он называется method local inner class и является подвидом внутреннего класса. Существует он только внутри своего блока.
Чем локальный класс отличается от внутреннего?
Двумя вещами. Во-первых, областью видимости: внутренний класс доступен всему внешнему классу и может быть типом возвращаемого значения, а локальный не виден дальше своего блока. Во-вторых, доступом к локальным переменным: локальный класс видит переменные и параметры метода, в котором объявлен, а внутреннему такие переменные недоступны, он объявлен не в методе.
Почему локальный класс не видит переменную, которую изменили после инициализации?
Потому что объект локального класса может пережить метод, в котором создан, а локальная переменная умирает вместе с методом. Поэтому компилятор не ссылается на переменную, а копирует ее значение в скрытое поле объекта. Если бы переменную разрешили менять, копия и оригинал сразу разошлись бы. Отсюда и требование: переменная должна быть
final или хотя бы фактически неизменяемой.
Можно ли вернуть объект локального класса из метода?
Под своим именем нет: за пределами блока этого типа не существует, поэтому написать его в сигнатуре метода не выйдет. Но если локальный класс реализует интерфейс или наследует класс, объявленный снаружи, то вернуть объект можно, указав в сигнатуре этот интерфейс или родительский класс. Ровно так и работают анонимные классы.
Можно ли написать перед локальным классом public, private или static?
Нет. Спецификация языка (JLS, раздел 14.3) прямо называет ошибкой компиляции модификаторы
public,
protected,
private и
static у локального объявления. Логика простая: модификаторы доступа управляют видимостью снаружи, а локальный класс снаружи не виден в принципе. Разрешены только
final,
abstract и аннотации.
Где локальные классы применяются на практике?
Там, где нужен разовый вспомогательный тип: промежуточная структура данных внутри одного метода, компаратор или реализация интерфейса для одного алгоритма, оболочка для группы значений, которую незачем показывать остальной программе. Если такой тип понадобился во втором методе, это сигнал вынести его во внутренний или отдельный класс.
Читайте также