Какова цель анонимных классов в Java?

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

Пример. Мы используем Dao , который дает нам результат запроса к базе данных в ResultCallback .

public class MiDao extends AlgunDao{

    // buscar datos según nombre de columna para devolverlo en un callback
    public void getDatos(List<String> columnas, ResultCallback callback){
         // despues de ejecutar la solicitud, el DAO llama al callback
         // con un mapa de columnas y resultados
    } 

public interface ResultCallback {

    public void setResult(Map<String,Object> result);
}

Мы хотим получить доступ к этой БД в контроллере и поместить результаты в соответствующие представления.

public class Controlador {

    private MiDao dao = new MiDao();

    // un método que agrega datos a vistas identificadas por un nombre que 
    // corresponde al nombre de la columna en la BD
    private void agregarDato(String vista, Object data){
        // logica que agrega los datos a las vistas
    }

    // un método para solicitar datos a un dao
    public void llenarVistas(List<String> vistas){

        // llamamos el dao con una clase anónima que implementa el interfaz
        // ResultCallback
        dao.getDatos(vistas, new ResultCallback(){

            @Override
            public void setResult(Map<String,Object> result){

                 // aquí podemos acceder métodos de la clase
                 Iterator<Entry<String,Object>> it =
                            result.entrySet().iterator();

                 while (it.hasNext()){
                     Entry<String,Object> e = it.next();
                     // llamamos un método privado del Controlador
                     agregarDato(e.getKey(), e.getValue());
                 }
             }
         }); // final de la clase anónima
    }
}

Мы также могли бы использовать любую локальную переменную в области действия анонимного класса, объявленного с модификатором final .

В двух словах, использование анонимного класса позволяет вам создать объект, который реализует определенный интерфейс, и иметь возможность использовать его свободно без необходимости явно определять класс.

Хотя использование анонимных классов никогда не является строго обязательным (всегда можно получить эквивалентный код, используя обычные классы), есть по крайней мере 3 преимущества их использования, о которых я могу думать и которые применимы при определенных обстоятельствах:

1. Если в вашем коде есть только одно место , где может понадобиться экземпляр определенного класса, то определение целого класса для одноразового использования может стать утомительным. Анонимный класс идеально подходит для таких ситуаций и избавляет вас от загрязнения вашего проекта классами, которые вы в любом случае не планируете повторно использовать в другом месте.
2. Особенно, когда реализация короткая, наличие реализации класса непосредственно там, где он используется, может сделать код более читабельным и понятным.
3. Это позволяет вам удобно получать доступ к локальным переменным и членам класса без необходимости определять конструктор для их получения и использования. (Хотя, что касается членов класса, то же самое может быть достигнуто с помощью вложенных классов.)

Чтобы лучше понять эти 3 пункта, давайте рассмотрим пример, где обычно используются анонимные классы: прослушиватели событий.

Например, допустим, вы работаете над проектом с визуальным интерфейсом, который включает несколько кнопок, и вам нужно определить, что должно происходить в событиях Click каждой кнопки. Это достигается указанием a ActionListenerдля каждой кнопки.

Использование обычного класса

Без анонимных классов вы должны определить полный класс, реализующий интерфейс ActionListener:

public class Button1ActionListener implements ActionListener {
    private JTextField jText;

    public Button1ActionListener(JTextField jText) {
        this.jText = jText;
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        jText.setText("button 1 clicked");
    }
}

... который вы затем можете использовать в форме с кнопкой:

    jButton1.addActionListener(new Button1ActionListener(jText));

Хотя на первый взгляд это выглядит не так уж плохо с одной кнопкой, представьте себе сложность определения класса ButtonXActionListenerдля каждой кнопки, если в вашей форме их несколько.

Кроме того, если вы посмотрите на код формы, не сразу станет понятно, что происходит, когда вы нажимаете кнопку. Необходимо открыть класс Button1ActionListener, чтобы иметь полную картину того, что должно произойти. Опять же, если у вас есть несколько кнопок, чтобы получить полную картину действий, вам нужно будет открыть и изучить несколько разных классов.

И, наконец, обратите внимание, что в данном случае действие заключается в изменении текста поля в форме. Но поскольку у класса Button1ActionListenerнет доступа к форме, необходимо определить конструктор только для того, чтобы иметь доступ к рассматриваемому полю. Это не идеально.

Использование анонимного класса

С анонимным классом вам не нужно определять класс отдельно от формы. Вы можете определить действие для кнопки непосредственно в коде формы следующим образом:

jButton1.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
        jText.setText("button 1 clicked");
    }
});

Опять же, представьте, что вам нужно определить этот тип действия для нескольких кнопок на форме. Сразу видны преимущества по сравнению с предыдущим примером:

1. Нет необходимости создавать бесчисленное количество отдельных классов, которые не имеют другого применения вне формы.
2. Изучив код формы, я сразу вижу полную картину действий, связанных с кнопками. Мне не нужно открывать бесчисленные классы, чтобы понять, что произойдет.
3. Обратите внимание, что метод actionPerformed()имеет прямой и удобный доступ к переменной jTextи любым другим переменным в методе или классе формы. Это экономит ваш код по сравнению с обычным классом (как я упоминал ранее, в некоторой степени вложенные классы тоже могут помочь с этим, но я не хочу отходить от темы).

Использование лямбда-выражения

Стоит отметить, что, начиная с Java 8, многие из типичных применений анонимных классов можно улучшить, используя вместо них лямбда-выражения . По сути, везде, где вам приходится работать с интерфейсом, который имеет один метод (как в случае с прослушивателями событий, такими как ActionListener), вы можете использовать лямбда-выражение , а не анонимный класс. Таким образом, хотя анонимные классы все еще используются, в Java 8 стало меньше ситуаций, в которых их использование было бы предпочтительным.

Обратите внимание, как компактно выглядит эквивалентный код с использованием лямбда-выражения :

jButton1.addActionListener(e -> jText.setText("button 1 clicked"));

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

Преимуществ анонимных классов много, но корень всего этого заключается в использовании так называемых «интерфейсов», которые помогают создавать как можно более абстрактные классы, чтобы их можно было повторно использовать позже (повторное использование кода). Одно из этих преимуществ заключается в том, что, передавая интерфейс в качестве параметра в анонимном классе, у вас есть возможность настроить действие для выполнения, и в процессе вы можете использовать локальные объекты под рукой. Таким образом, вам не нужно создавать еще один класс, который должен извлекать их с помощью метода catch:

void (JLabel lbl){ //Si quiero utilizar por ejemplo un jLabel para actualizarlo por medio de un cronometro en tiempo real
...
}

Если нет, находясь в локальной перезаписывая метод интерфейса, вы вызываете только эту локальную JLabel и делаете с ней все, что хотите.

И помимо всего прочего, вы можете повторно использовать код с другим действием, которое вам нравится. Таким образом, мы пользуемся преимуществами объектно-ориентированного подхода, что избавляет нас от большого количества работы и огромного беспорядка в нашем коде. Давайте избегать избыточности кода.

Иногда мы делаем классы, которые делают почти то же самое, но только изменяют какое-то действие или параметры. А лучше сделать один класс, поддерживающий все.

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

Не знаю, правильно ли я себя понял. Привет.

На самом деле, это распространенный и актуальный метод.

НО...

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

Очевидно, что при отправке в другой метод функция будет не только той, что вы помещаете в анонимный класс, но также будет использоваться с дополнительной функцией:

Например, выполнение этого метода в другом потоке.

Что вы не можете сделать с помощью одного простого метода. В этом случае объект Thread требует его в качестве параметра своего метода run(), чтобы с помощью алгоритма это пользовательское действие, которым может быть привет, мир или что-то еще, выполнялось в другом потоке.