JavaRush/Java блог/Java Developer/Анонимные классы в Java
Автор
John Selawsky
Senior Java-разработчик и преподаватель в LearningTree

Анонимные классы в Java

Статья из группы Java Developer
участников
Анонимный класс в Java это класс без имени, который объявляют и тут же создают его единственный объект прямо в месте использования: new Интерфейс() { ... };. Так обычно реализуют интерфейс или наследуют класс, когда реализация нужна ровно один раз и заводить отдельный именованный класс незачем. Анонимные классы это подвид внутренних классов.

Кратко

  • Анонимный класс объявляют и создают одним выражением: new MonitoringSystem() { ... };. Точка с запятой в конце обязательна, это обычное присваивание.
  • Имени у класса нет, поэтому обратиться к нему откуда-то еще нельзя: он живет только внутри того метода, где объявлен.
  • Компилятор требует реализовать все абстрактные методы интерфейса, который анонимный класс реализует.
  • Кроме методов интерфейса в анонимном классе можно объявить и свои дополнительные методы.
  • Как внутренний класс он видит поля внешнего класса, включая приватные и статические.
  • Анонимный класс берут там, где реализация нужна один раз. Если она понадобится в нескольких местах, лучше обычный именованный класс.
Привет! На сегодняшнем занятии мы продолжим рассматривать тему вложенных классов. Пришла очередь последней группы: анонимных внутренних классов в Java. Давай вернемся к нашей схеме: Схема видов вложенных классов, красным выделен Anonymous Inner Class: Nested classes делятся на Inner class и Static nested classes, а Inner class на обычный внутренний, method-local и anonymousКак и локальные классы, о которых мы говорили в прошлой лекции, анонимные это подвид внутренних классов. У них также есть несколько сходств и отличий между собой. Но для начала давай разберемся: а почему они, собственно, называются «анонимными»? Для этого рассмотрим простой пример.

Задача: система мониторинга

Представь, что у нас есть основная программа, которая постоянно работает и что-то делает. Мы хотим создать для этой программы систему мониторинга из нескольких модулей. Один модуль будет отслеживать общие показатели работы и вести лог, второй будет фиксировать и регистрировать ошибки в журнале ошибок, третий отслеживать подозрительную активность: например, попытки несанкционированного доступа и прочие связанные с безопасностью вещи. Поскольку все три модуля должны, по сути, просто стартовать в начале программы и работать в фоновом режиме, будет хорошей идеей создать для них общий интерфейс:
public interface MonitoringSystem {

   public void startMonitoring();
}
Его будут имплементировать 3 конкретных класса:
public class GeneralIndicatorsMonitoringModule implements MonitoringSystem {

@Override
   public void startMonitoring() {
       System.out.println("Мониторинг общих показателей стартовал!");
   }
}


public class ErrorMonitoringModule implements MonitoringSystem {

   @Override
   public void startMonitoring() {
       System.out.println("Мониторинг отслеживания ошибок стартовал!");
   }
}


public class SecurityModule implements MonitoringSystem {

   @Override
   public void startMonitoring() {
       System.out.println("Мониторинг безопасности стартовал!");
   }
}
Казалось бы, все в порядке. У нас есть довольно внятная система из нескольких модулей. У каждого из них есть собственное поведение. Если нам понадобятся новые модули, мы сможем их добавить, ведь у нас есть интерфейс, который достаточно легко имплементировать. Но давай подумаем о том, как будет работать наша система мониторинга. Пульт мониторинга: центральный компьютер и пять экранов с потоками двоичного кодаПо сути, мы должны просто создать 3 объекта (GeneralIndicatorsMonitoringModule, ErrorMonitoringModule, SecurityModule) и вызвать метод startMonitoring() у каждого из них. То есть все, что нужно сделать, это создать 3 объекта и вызвать у них 1 метод.
public class Main {

   public static void main(String[] args) {

       GeneralIndicatorsMonitoringModule generalModule = new GeneralIndicatorsMonitoringModule();
       ErrorMonitoringModule errorModule = new ErrorMonitoringModule();
       SecurityModule securityModule = new SecurityModule();

       generalModule.startMonitoring();
       errorModule.startMonitoring();
       securityModule.startMonitoring();
   }
}
Вывод в консоль:

Мониторинг общих показателей стартовал!
Мониторинг отслеживания ошибок стартовал!
Мониторинг безопасности стартовал!
И для такой небольшой работы мы написали целую систему: 3 класса и один интерфейс! И все это ради 6 строк кода. С другой стороны, какие у нас варианты? Да, не очень здорово, что мы понаписали таких вот «одноразовых» классов. Но как мы можем это исправить?

Как записать анонимный класс

Здесь нам и приходят на помощь анонимные внутренние классы! Вот как они выглядят в нашем случае:
public class Main {

   public static void main(String[] args) {

       MonitoringSystem generalModule = new MonitoringSystem() {
           @Override
           public void startMonitoring() {
               System.out.println("Мониторинг общих показателей стартовал!");
           }
       };



           MonitoringSystem errorModule = new MonitoringSystem() {
           @Override
           public void startMonitoring() {
               System.out.println("Мониторинг отслеживания ошибок стартовал!");
           }
       };

       MonitoringSystem securityModule = new MonitoringSystem() {
           @Override
           public void startMonitoring() {
               System.out.println("Мониторинг безопасности стартовал!");
           }
       };

       generalModule.startMonitoring();
       errorModule.startMonitoring();
       securityModule.startMonitoring();
   }
}

Что происходит внутри Java

Давай разбираться, что тут происходит! Выглядит так, как будто мы создаем объект интерфейса:
MonitoringSystem generalModule = new MonitoringSystem() {

@Override
   public void startMonitoring() {
       System.out.println("Мониторинг общих показателей стартовал!");
   }
};
Но ведь мы давно знаем, что создавать объекты интерфейсов нельзя! Так и есть, нельзя. На самом деле мы этого и не делаем. В тот момент, когда мы пишем:
MonitoringSystem generalModule = new MonitoringSystem() {

};
внутри Java-машины происходит следующее:
  1. Создается безымянный Java-класс, реализующий интерфейс MonitoringSystem.
  2. Компилятор, увидев такой класс, требует от тебя реализовать все методы интерфейса MonitoringSystem (мы это и сделали 3 раза).
  3. Создается один объект этого класса. Обрати внимание на код:
MonitoringSystem generalModule = new MonitoringSystem() {

};
В конце стоит точка с запятой! Она стоит там не просто так. Мы одновременно объявляем класс (посредством фигурных скобок) и создаем его объект с помощью (); Каждый из наших трех объектов переопределил метод startMonitoring() по-своему. В конце мы просто вызываем этот метод у каждого из них:
generalModule.startMonitoring();
errorModule.startMonitoring();
securityModule.startMonitoring();
Вывод в консоль:

Мониторинг общих показателей стартовал!
Мониторинг отслеживания ошибок стартовал!
Мониторинг безопасности стартовал!
Вот и все! Мы выполнили свою задачу: создали три объекта MonitoringSystem, переопределили его тремя разными способами и вызвали трижды. Все три модуля успешно запущены и работают. При этом структура нашей программы стала намного проще! Ведь классы GeneralIndicatorsMonitoringModule, ErrorMonitoringModule, SecurityModule теперь вообще можно удалить из программы! Они нам просто не нужны, мы прекрасно справились и без них.

Свои методы в анонимном классе

Если каждому из наших анонимных классов-модулей понадобится какое-то отличающееся поведение, свои специфические методы, которых нет у других, мы легко можем дописать их:
MonitoringSystem generalModule = new MonitoringSystem() {

   @Override
   public void startMonitoring() {
       System.out.println("Мониторинг общих показателей стартовал!");
   }

   public void someSpecificMethod() {

       System.out.println("Специфический метод только для первого модуля");
   }
};
В документации Oracle приведена хорошая рекомендация: «Применяйте анонимные классы, если вам нужен локальный класс для одноразового использования».

Анонимный класс или обычный: что выбрать

Сведем оба варианта из нашего примера в одну таблицу:
СвойствоОбычный именованный классАнонимный класс
Где объявленотдельно, со своим именемпрямо в месте использования, без имени
Где виденвезде, куда пускает модификатор доступатолько внутри метода, где объявлен
Сколько объектовсколько угодноодин, создается тут же
Когда выбиратьреализация нужна в нескольких местахреализация нужна ровно один раз

Доступ к переменным внешнего класса

Анонимный класс это полноценный внутренний класс. Поэтому у него есть доступ к переменным внешнего класса, в том числе к статическим и приватным:
public class Main {

   private static int currentErrorsCount = 23;

   public static void main(String[] args) {

       MonitoringSystem errorModule = new MonitoringSystem() {

           @Override
           public void startMonitoring() {
               System.out.println("Мониторинг отслеживания ошибок стартовал!");
           }

           public int getCurrentErrorsCount() {

               return currentErrorsCount;
           }
       };
   }
}

Ограничения анонимных классов

Есть у них кое-что общее и с локальными классами: они видны только внутри того метода, в котором определены. В примере выше, любые попытки обратиться к объекту errorModule за пределами метода main() будут неудачными. И еще одно важное ограничение, которое досталось анонимным классам от их «предков», внутренних классов: до Java 16 анонимный класс не мог содержать статические переменные и методы. Если на Java до 16 попробовать сделать метод getCurrentErrorsCount() из примера выше статическим, компилятор выбросит ошибку:
//до Java 16 ошибка: Inner classes cannot have static declarations
public static int getCurrentErrorsCount() {

   return currentErrorsCount;
}
Тот же результат мы получим, если попробуем объявить статическую переменную:
MonitoringSystem errorModule = new MonitoringSystem() {

   //до Java 16 ошибка: Inner classes cannot have static declarations!
   static int staticInt = 10;

   @Override
   public void startMonitoring() {
       System.out.println("Мониторинг отслеживания ошибок стартовал!");
   }

};
Начиная с Java 16 это ограничение сняли: анонимный класс, как и любой другой внутренний класс, может объявлять статические поля и методы. Напоследок могу порекомендовать тебе отличное видео по теме анонимных классов, где данная тема объясняется максимально просто и понятно :)
А наше сегодняшнее занятие подошло к концу! И хотя мы разобрали последнюю группу вложенных классов, с этой темой мы еще не закончили. Что же мы будем изучать по вложенным классам дальше? Скоро ты обязательно узнаешь! :)

Вопросы и ответы

Как объявить анонимный класс?

Написать new, имя интерфейса или класса, круглые скобки, а сразу за ними тело в фигурных скобках и точку с запятой: new MonitoringSystem() { ... };. Класс и его единственный объект создаются одним выражением.

Почему после закрывающей фигурной скобки анонимного класса стоит точка с запятой?

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

Разве можно создать объект интерфейса?

Нет, и запись new MonitoringSystem() { ... } этого не делает. Java создает безымянный класс, который реализует интерфейс, и уже у него создает объект. Переменная типа интерфейса просто хранит ссылку на этот объект.

Может ли анонимный класс обращаться к приватным полям внешнего класса?

Да. Анонимный класс это внутренний класс, поэтому ему доступны поля внешнего класса, включая private и static.

Может ли анонимный класс содержать статические поля и методы?

До Java 16 нет, компилятор выдавал ошибку Inner classes cannot have static declarations. Начиная с Java 16 ограничение сняли, и статические члены в анонимном классе объявлять можно.

Когда использовать анонимный класс, а когда обычный?

Анонимный подходит, когда реализация нужна ровно один раз и в одном методе. Если тот же класс понадобится в нескольких местах или нужно создавать много его объектов, заводят обычный именованный класс. Источник: Oracle Java Tutorials: When to Use Nested, Local and Anonymous Classes.

Читайте также

Комментарии (90)
  • популярные
  • новые
  • старые
Для того, чтобы оставить комментарий Вы должны авторизоваться
30 июля, 10:52
Малосодержательная статья. У кого авторы взяли такую манеру объяснения материала? Возможно, у Эккеля? Получается бестолково. Увы!
Rei
Уровень 32
24 февраля, 14:47
Done
Aleksey63
Уровень 36
25 декабря 2024, 07:58
Видео с ютуба? не работает
Cryptosin Crypto Magnat
7 января 2025, 13:52
пора переезжать значит оттуда
Nikolay
Уровень 24
14 марта 2025, 14:33
Vpn включай просто
Private Joker
Уровень 36
4 июля 2024, 14:23
Лекция кривая, код из лекции не рабочий. Слава Кисусию, что есть GPT: В вашем коде есть несколько проблем, которые могут вызывать ошибки. Давайте рассмотрим их по порядку и исправим. Отсутствие интерфейса или абстрактного класса MonitoringSystem. Поскольку вы создаете анонимный класс на основе MonitoringSystem, он должен быть либо интерфейсом, либо абстрактным классом. Давайте предположим, что это интерфейс. Отсутствие использования объекта errorModule. После создания объекта errorModule его методы нигде не вызываются. Давайте добавим вызов методов. Ошибки доступа к переменной currentErrorsCount. Анонимный класс не имеет доступа к нестатическим переменным внешнего класса, если они не являются final или static.
Dr.Alexcemen9Врач в Поликлиника в деревн
3 сентября 2024, 09:13
Спасибо Вам за отзыв! Ваше мнение является очень важным!✍🤡
Denzol255Frontend Developer в Sber
5 сентября 2024, 09:00
Дружище, я конечно понимаю, что ты просто троль, но если ты при любых проблемах с кодом лезешь сразу в GPT, тебе не стоит заниматься программирование...
Igoreek
Уровень 43
7 сентября 2024, 07:23
GPT походу единственный кто способен терпеть твой гнилой базар...
Private Joker
Уровень 36
24 сентября 2024, 15:06
ты бы прикрыл свою щель, опущенный
Андрей Зоммер
Уровень 32
24 ноября 2024, 12:44
"Отсутствие интерфейса или абстрактного класса MonitoringSystem. Поскольку вы создаете анонимный класс на основе MonitoringSystem, он должен быть либо интерфейсом, либо абстрактным классом. Давайте предположим, что это интерфейс." Он и не должен. Приведи в таком случае ссылку из спецификации, где написано, что анонимный класс можно создавать только на абстрактных классах или интерфейсах. "Отсутствие использования объекта errorModule. После создания объекта errorModule его методы нигде не вызываются. Давайте добавим вызов методов." Надо ли давать какие-то комментарии по этому поводу? Это учебная статья и в рамках это статьи цель автора создать не код на продакшен, а показать синтаксис "Ошибки доступа к переменной currentErrorsCount. Анонимный класс не имеет доступа к нестатическим переменным внешнего класса, если они не являются final или static." Все примеры корректные, там где явно допущена ошибка в об этом пишется в комментарии Ты даже толком не удосужился переформатировать текст ответа гпт, тупо не думая, скопировал. Почему модеры не удалили твой коммент - не ясно
Aman Efer
Уровень 40
14 июня 2024, 12:00
Внутренние классы, в т.ч локальные и анонимные, начиная с jdk16, могут иметь статические члены (переменные и методы).
Kirill
Уровень 46
14 мая 2024, 04:32
Если каждому из наших анонимных классов-модулей понадобится какое-то отличающееся поведение, свои специфические методы, которых нет у других, мы легко можем дописать их: Вот только вызвать мы их не сможем, потому что эти "специфические методы" не объявлены в интерфейсе. Ну точнее можем конечно... Танцуя с бубном через рефлексию :)))
Kirill
Уровень 46
14 мая 2024, 04:27
И для такой небольшой работы мы написали целую систему: 3 класса и один интерфейс! И все это — ради 6 строк кода. Так а что, собственно, в итоге поменялось? Мы получили все те же 1 интерфейс и 3 реализующих его анонимных класса :))) С точки зрения проектирования системы, как раз логичней было бы объявить все 3 класса как приватные статические вложенные где-нибудь в самом конце объявления класса, сделав их при этом синглтонами - так и код наглядней, и не нужно городить простыню из 3 анонимных классов.
Dmytrii
Уровень 70
21 февраля, 15:20
Кстати тоже не понял этого момента. Ведь стало ещё запутанней наоборот
Максим Li Backend Developer
1 апреля 2024, 05:55
Замечательно
1 марта 2024, 07:48
Perfect
Anonymous #3380648
Уровень 2
6 января 2024, 10:37
Серия статей (4) о вложенных классах: 1. Нестатические. Вложенные внутренние классы или Inner Class в Java: https://javarush.com/groups/posts/2181-vlozhennihe-vnutrennie-klassih 2. Нестатические. Внутренние классы в локальном методе (Method local inner classes): https://javarush.com/groups/posts/2190-vnutrennie-klassih-v-lokaljhnom-metode 3. Нестатические. Анонимные классы в Java (Anonymous Inner Class): https://javarush.com/groups/posts/2193-anonimnihe-klassih 4. Статические. Статические вложенные классы (Static Nested Classes): https://javarush.com/groups/posts/2183-staticheskie-vlozhennihe-klassih