What is the purpose of anonymous classes in Java?

Anonymous classes in java are used a lot for example in listeners, callbacks or events. The advantage of an anonymous class is that it can access local variables in its scope.

An example. We're using a Dao that gives us the result of a database request in a 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);
}

We want to access this DB in a controller and put the results in the corresponding views.

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
    }
}

We could also use any local variable in the scope of the anonymous class that is declared with the final modifier .

In a nutshell, using an anonymous class allows you to create an object that implements a particular interface and be able to use it freely without the hassle of having to explicitly define a class.

Although it is never strictly necessary to use anonymous classes (it is always possible to achieve equivalent code using normal classes), there are at least 3 advantages to using them that I can think of, and which apply under certain circumstances:

1. If there is only one place in your code where an instance of a particular class would be needed, having to go through the trouble of defining an entire class for a single use can get tiresome. An anonymous class is ideal for these situations, and saves you from polluting your project with classes you don't plan on reusing elsewhere anyway.
2. Especially when the implementation is short, having the class implementation directly where it is used can make the code more readable and understandable.
3. It allows you to conveniently access local variables and class members without the hassle of having to define a constructor in order to receive and use them. (Although as for class members, the same can be achieved with nested classes.)

To better understand these 3 points, let's look at an example where anonymous classes are typically used: event listeners.

For example, let's say you're working on a project with a visual interface that includes several buttons and you need to define what should happen in the Click events of each button. This is achieved by specifying a ActionListenerfor each button.

Using a normal class

Without anonymous classes, you have to define a full class that implements the interface 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");
    }
}

... which you can then use like this on the form that has the button:

    jButton1.addActionListener(new Button1ActionListener(jText));

Although at first glance it doesn't look too bad with a single button, imagine the hassle of having to define a class ButtonXActionListenerfor each button if your form has several.

Also, if you're looking at the form code, it's not immediately obvious what happens when you click the button. It is necessary to open the class Button1ActionListenerto be able to have the complete picture of what is going to happen. Again, if you have multiple buttons, in order to get the full picture of actions, you would need to open and examine multiple different classes.

And finally, notice that the action in this case is to modify the text of a field in the form. But since the class Button1ActionListenerdoes not have access to the form, it is necessary to define a constructor just to be able to access the field in question. This is not ideal.

Using an anonymous class

With an anonymous class, you don't need to define a class apart from the form. You can define the action for the button directly in the form code like this:

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

Again, imagine that you have to define this type of action for several buttons on your form. We can immediately see the advantages in contrast to the previous example:

1. There is no need to create countless separate classes that have no other use outside of the form.
2. Examining the form code, I can immediately see the full picture of the actions related to the buttons. I don't need to open countless classes to understand what is going to happen.
3. Note that the method actionPerformed()has direct and convenient access to the variable jTextand any other variables in the form's method or class. This saves you code compared to a normal class (as I mentioned before, to a degree, nested classes can help with this too, but I don't want to get off topic).

Using a lambda expression

It is worth mentioning that, as of Java 8, many of the typical uses for anonymous classes can be enhanced by using lambdas expressions instead . Basically, anywhere you happen to work with an interface that has a single method (as is the case with event listeners like ActionListener), you can use a lambda expression rather than an anonymous class. So while anonymous classes still have their uses, as of Java 8 there are fewer situations where their use would be favored.

Notice how compact the equivalent code looks using a lambda expression :

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

Once you learn and get used to the lambda expression syntax, you can see that it has all the advantages of anonymous classes but with a much more compact syntax.

The advantage of anonymous classes are many, but the root of all this is the use of so-called "interfaces" which are helpful in creating classes as abstract as possible so that they can be reused later (code reuse). One of those advantages is that by passing an interface as a parameter in an anonymous class, you have the possibility to customize the action to execute and in the process you can use local objects at your fingertips. That way you don't have to create another class that has to fetch them via a catch method:

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

If not, being in local overwriting the interface method, you only call that local JLabel and do whatever you feel like with it.

And apart from everything you can reuse the code with another different action that you fancy. And so we take advantage of object-oriented which saves us a lot of work and a huge mess in our code. Let's avoid code redundancy.

Sometimes we make classes that almost do the same thing but only change some action or parameters. And it is better to make a single class that supports everything.

It's like a tamale maker who not only knows how to make rajas tamales, but also makes them with mole, green, sweet, jarochos, etc. And such a class is much more powerful. Because he puts up with everything.

I don't know if I made myself understood. Greetings.

In fact, it is a common and current method.

BUT...

That method, which is actually an interface, is going to be sent as a parameter so that another method processes it and makes use of the content of that code.

Obviously when being sent to another method, the function is not only going to be what you are putting in the anonymous class, but it is also going to be used with an extra function:

Like for example executing that method in a different thread.

Which you can't do with a simple method alone. In this case, the Thread Object requires it as a parameter of its run() method so that, by means of an algorithm, that custom action, which can be a hello world or whatever, is executed in a different thread.