classi anonime

[newutente]

Il concetto mi è chiaro, volevo però fare una considerazione.
Da quello che ho capito le classi anonime vanno dichiarate all'interno del corpo di un metodo o passate come parametro ad un metodo e trovano l'utilizzo migliore quando vogliamo fare in una classe override di un metodo di un'altra classe/interfaccia/classe astratta.
Per semplicità vi posto nuovamente i 2 esempi più concreti dove si notano i due utilizzi:

ESEMPIO 1

public class Outer4 
{
    
    private String messaggio = "Nella classe ";

    
    
    public void metodoConClasse(final int a) 
    {
        
        ClasseEsistente ce = new ClasseEsistente()    
        {
            
            @Override

                    public void metodo() 
            {
    
                    System.out.println(messaggio+"anonima numero "+ a);
            
            }
        
        };
        
        ce.metodo();
    
    }

}

public class ClasseEsistente
{
    public void metodo()
    {
        System.out.println("Nella classe esistente");
    }
}

ESEMPIO 2

public class TestPersona {

    public static void main(String args[])
        {
        System.out.println(new Persona("Arjen","Lucassen","03/04/1960","Compositore","Olanda")
                {
                     @Override
                     public String toString()
                     {
                                             ...
                     }
                } );
    }    
}


public class Persona 
{
    ...

    @Override
    public String toString() {
        return "Persona{" + "nome=" + nome + ", cognome=" + cognome + '}';
    }
}

In entrambi i casi è come se andassimo ad istanziare un oggetto di una classe già esistente e lo facciamo per avere accesso ad un particolare metodo su cui vogliamo appunto fare l'override.
E' corretto? Se si, allora la mia domanda è: non avremmo ottenuto lo stesso risultato estendendo la classe già esistente piuttosto che utilizzando una classe anonima? Avremmo lo stesso avuto l'accesso al metodo su cui fare l'override.

[andbin]

Da quello che ho capito le classi anonime vanno dichiarate all'interno del corpo di un metodo o passate come parametro ad un metodo

Una anonymous inner class può essere usata dovunque si possa assegnare un reference. Quindi: assegnamenti a variabili (locali, di istanza, di classe), argomenti di costruttori/metodi.

e trovano l'utilizzo migliore quando vogliamo fare in una classe override di un metodo di un'altra classe/interfaccia/classe astratta.

L'uso principale è per l'override "al volo" di uno o pochi metodi quando non c'è bisogno di particolare riutilizzo di quella implementazione.
E si parla solo di override, perché siccome la classe è "anonima", il nome non lo sai e se mettessi dei metodi "nuovi", in più rispetto al super-tipo che estendi/implementi, non sapendo il nome classe, non potresti usarli! (a parte istanziare e invocare subito al volo 1 metodo).

non avremmo ottenuto lo stesso risultato estendendo la classe già esistente piuttosto che utilizzando una classe anonima? Avremmo lo stesso avuto l'accesso al metodo su cui fare l'override.

Ai fini del override, non c'è differenza tra l'usare una classe anonima e una classe "regolare" (top-level o inner). Conta più che altro la brevità o meno e il (più o meno) interesse per il riutilizzo.

Le differenze tecniche ovviamente ci sono: in una classe anonima non puoi definire tu un costruttore. In una classe regolare, sì ovviamente. Poi ad esempio in una classe anonima non puoi definire membri static (al massimo li puoi ereditare) per lo stesso motivo detto sopra: non sapendo il nome della classe, non potresti usarli. In una classe regolare puoi definire membri static.

[newutente]

Una anonymous inner class può essere usata dovunque si possa assegnare un reference. Quindi: assegnamenti a variabili (locali, di istanza, di classe), argomenti di costruttori/metodi.

Un esempio di utilizzo in assegnazioni a variabili può essere questo?

public class TestPersona {

    public static void main(String args[])
    {
             String stringa = new Persona("Arjen","Lucassen","03/04/1960","Compositore","Olanda")
                                  {
                                             @Override
                                              public String toString()
                                              {
                                                      ...
                                              }
                                  };
    }    
}


public class Persona 
{
    ...

    @Override
    public String toString() {
        return "Persona{" + "nome=" + nome + ", cognome=" + cognome + '}';
    }
}

[andbin]

Un esempio di utilizzo in assegnazioni a variabili può essere questo?

             String stringa = new Persona("Arjen","Lucassen","03/04/1960","Compositore","Olanda")
                                  {
                                             @Override
                                              public String toString()
                                              {
                                                      ...
                                              }
                                  };

Strutturalmente sì, ma occhio che hai messo la variabile String ... ovviamente no, non va bene.