classi anonime

[andbin]

Non riesco a capire questi pezzi di codice:
[...]
ma perchè si sceglie di implementare una interfaccia piuttosto che usare una classe ed estenderla?

FiltroFilm è una normalissima interfaccia che definisce un "contratto" di filtro (per questo, è meglio che sia una interfaccia ... non una classe) del tipo "qualcuno ti passa un oggetto Film, digli se true o false". Poi si potrebbe discutere sul senso del boolean, cosa significano true e false. In linea di massima e sensatamente si può pensare: true = il film è ok (insomma, lo accetto).

In questo caso non capisco cosa fa questo metodo. Dovrebbe restituire i film filtrati

Se noti, prima passa il Film (films[i]) a filtra che è implementato nell'oggetto passato al metodo getFilmFiltrati. Poi se filtra restituisce true, allora il Film lo mette in un elemento dell'array.
Insomma, qui è evidente che "true" significa che il Film è accettato, altrimenti viene scartato.

ma in base a che criterio?

Questi, chiaramente differenti per ottenere liste differenti:

Film[] filmDiFantascienza = videoteca.getFilmFiltrati(new FiltroFilm() {
                public boolean filtra(Film film) {
                return"Fantascienza".equals(film.getGenere());  // <-------- QUESTO criterio
                }
          } );

Film[] beiFilms =  videoteca.getFilmFiltrati(new FiltroFilm() {
                public boolean filtra(Film film) {
                return film.getMediaRecensioni() >3;  // <-------- QUESTO criterio
                }
          } );

Quello che però non capisco è cosa realmente accade in quelle righe di codice, in modo particolare il metodo filtra restituisce un booleano. E allora cosa fa quel codice? Passa un booleano al metodo getFilmFiltrati?

getFilmFiltrati riceve un oggetto che "vede" solo come tipo FiltroFilm (la interfaccia). A getFilmFiltrati NON importa dove è implementata la interfaccia, se in una classe top-level, se in una inner-class "regular" oppure "anonymous" (anonima) o altro.

A getFilmFiltrati interessa solo che l'oggetto è un FiltroFilm, quindi di sicuro ha quel metodo filtra. Quindi il metodo getFilmFiltrati passerà tutti i Film presenti, uno per volta, al metodo filtra, ovvero invoca filtra sull'oggetto FiltroFilm. filtra restituisce un boolean, in base a questo, getFilmFiltrati si comporta di conseguenza.

[newutente]

FiltroFilm è una normalissima interfaccia che definisce un "contratto" di filtro

Ti riferisci al fatto che definendo una interfaccia si è in qualche modo costretti poi a implementare i suoi metodi?

A getFilmFiltrati NON importa dove è implementata la interfaccia, se in una classe top-level, se in una inner-class "regular" oppure "anonymous" (anonima) o altro.

Ah ecco, quindi diciamo che questo esempio mostra che volendo è possibile implementare i metodi di una interfaccia anche tramite una classe anonima. Giusto?

[andbin]

Ti riferisci al fatto che definendo una interfaccia si è in qualche modo costretti poi a implementare i suoi metodi?

Anche facendo una classe astratta con metodo astratto avresti lo stesso obbligo (ovviamente in una classe concreta):

public abstract class FiltroFilm {
    public abstract boolean filtra(Film film);
}

A livello di "contratto" e di obblighi non ci sono differenze: in una classe concreta che estende FiltroFilm devi implementare filtra. La dichiarazione-istanziazione con una classe anonima è esattamente la stessa con FiltroFilm come interfaccia o come classe astratta.
Il punto è che una interfaccia la puoi implementare in qualunque classe. Una classe astratta .... no, non è detto (una classe può già estendere altro).

Ah ecco, quindi diciamo che questo esempio mostra che volendo è possibile implementare i metodi di una interfaccia anche tramite una classe anonima. Giusto?

Sì, se quel comportamento non deve essere riutilizzabile altrove.

[newutente]

Il punto è che una interfaccia la puoi implementare in qualunque classe. Una classe astratta .... no, non è detto (una classe può già estendere altro).

cioè una interfaccia è sufficiente che la implementi per implementare quel metodo, una classe astratta invece la devi comunque estendere tramite un'altra classe e quindi devi comunque creare una relazione di ereditarietà. Giusto?


p.s. vado un attimo off topic perchè vorrei segnalarti il mio ultimo post ( http://forum.html.it/forum/showthrea...readid=2918433 ) che forse è sfuggito.

[andbin]

cioè una interfaccia è sufficiente che la implementi per implementare quel metodo, una classe astratta invece la devi comunque estendere tramite un'altra classe e quindi devi comunque creare una relazione di ereditarietà. Giusto?

Ma anche implementando una interfaccia si ha una relazione di "ereditarietà".

Che FiltroFilm sia interfaccia:

public class MyCustomFiltroFilm implements FiltroFilm { .... }

Oppure che FiltroFilm sia classe astratta (con filtra abstract):

public class MyCustomFiltroFilm extends FiltroFilm { .... }

In entrambi i casi FiltroFilm è comunque un "super" tipo di MyCustomFiltroFilm. E per quanto riguarda MyCustomFiltroFilm, gli obblighi sono gli stessi: se non è astratta (come definizione sopra), allora deve implementare quel metodo filtra.

p.s. vado un attimo off topic perchè vorrei segnalarti il mio ultimo post ( http://forum.html.it/forum/showthrea...readid=2918433 ) che forse è sfuggito.

Vedo di risponderti appena posso.