Annoso problema delle interfacce

[GoldEmish]

oronze, provo a risponderti io...
le interfacce hanno un loro utilità indubbia, la mia riflessione era su un probabile abuso.

Un esempio è questo. Tu hai degli utenti nella tua applicazione (es. un forum), quindi crei un'interfaccia comune

public interface User{
 public String view(String name);
 public void add(String name, String text);
}

esistono però degli utenti Amministratori e utenti Normali:

public class BaseUser implements User{
 public String view(String name){ ... }
 public void add(String name, String text){ ...}
}


public class AdminUser implements User{
 public String view(String name){ ... }
 public void add(String name, String text){ ...}
 public void edit(String name, String text){ ...}
 public void delete(String name){ ...}
}

Come vedi entrambi implementano User, quindi quando io nella mia applicazione devo elaborare una richiesta di "visualizzazione" (view) non mi pongo il problema del "tipo" di utente sapendo che tutti possono vedere, quindi farò:

User currentUser=getSession()....;
currentUser.view("Interfacce");

In questo codice qui sopra, io non distinguo proprio tra BaseUser o AdminUser, prendo quello che è tanto so che il metodo "view()" è implementato da entrambi in quanto seguono l'interfaccia User.

Spero di essermi spiegato...

rimane cmq il problema che avevo posto 2 post fa...

[GoldEmish]

Originariamente inviato da satifal
Uno dei tantissimi pattern implementati da Spring è l'IoC (Inversion of Control) tramite il quale è possibile mantenere disaccoppiati i singoli componenti di un sistema. Utilizzando tale pattern le dipendenze non vengono scritte nel codice del componente ma gli vengono iniettate dall'esterno. Per l'attuabilità di tale meccanismo è assolutamente necessario l'utilizzo delle interfacce. In pratica, all'interno del codice si ragiona per interfacce, mentre dall'esterno tramite file di configurazione XML vengono iniettate nel codice le implementazioni di tali interfacce, le quali, possono facilmente essere sostituite in base alle esigenze semplicemente modificando il file di configurazione. Si tratta di un pattern relativamente nuovo ed assolutamente innovativo.

Certo, ma su Spring 3 (e forse anche dal 2.5) essistono le annotation, in questo modo io (ho testato!!) posso scrivere tutti i servizi senza nessuna interfaccia...

[valia]

bella domanda: in quella struttura mi serviva mettere insieme diversi componenti come textfield, combobox, jxdatepicker e mi serviva raggrupparli per caratteristiche: mi serviva scorrere un'array di oggetti validabili e richiamare la validazione su tutti.
Ora come accomuno tutti questi oggetti, come mi assicuro che tutti abbiano il metodo validate()?
Imponendo l'implementazione dell'interfaccia runtime avevo

//mettevo qui tutti gli oggetti validabili
List<Validator> oggetti = new ArrayList<Validator>();

//qui valido 

for (Validator valid : oggetti){
    valid.validate();
}

non trovi sia molto comodo così? Ho una proprietà valida per tutti. Come avrei fatto nel tuo caso?

Ancora non hai fatto pattern e per questo ti è poco chiara, resta di fatto che a volte hai bisogno di una dichiarazione di intenti e per questo motivo usi le interfaccia (ricorda molto i prototipi in C anche se non è la stessa cosa (prima che mi picchiano))

[oronze]

grazie Valia...ora è chiaro il motivo per cui hai usato l'interfaccia

@GoldEmish: Ok, mi è chiaro anche il tuo caso!

Grazie 1000 a entrambi...mi avete chiarito uno dei miei dubbi su teoriaOK/praticaBOOOHH
Ahahahahahaha

[valia]

Originariamente inviato da satifal
Uno dei tantissimi pattern implementati da Spring è l'IoC (Inversion of Control) tramite il quale è possibile mantenere disaccoppiati i singoli componenti di un sistema. Utilizzando tale pattern le dipendenze non vengono scritte nel codice del componente ma gli vengono iniettate dall'esterno. Per l'attuabilità di tale meccanismo è assolutamente necessario l'utilizzo delle interfacce. In pratica, all'interno del codice si ragiona per interfacce, mentre dall'esterno tramite file di configurazione XML vengono iniettate nel codice le implementazioni di tali interfacce, le quali, possono facilmente essere sostituite in base alle esigenze semplicemente modificando il file di configurazione. Si tratta di un pattern relativamente nuovo ed assolutamente innovativo.

infatti non ne avevo mai sentito parlare, mi passi qualche doc?? dopo faccio qualche ricerca, almeno ho dei riferimenti

[satifal]

Il sito di riferimento lo trovi QUI

[valia]

Originariamente inviato da satifal
Il sito di riferimento lo trovi QUI

thankssssss
ora devo uscire, dopo gli dò un'occhio

[n00b_new]

La risposta è semplice se contestualizzata bene...le interfacce ti rendono la vita facile!
La base della programmazione è nell'astrazione, principio base dell'ing. del software.
Esempio:
Applicazione che legge da input, scrive su output e poi su file.
Bene uso interfaccia leggi,scrivi e scriviFile come sono implementate? livello più basso...
In un progetto semplice l'interfaccia potrebbe sembrare inutile ma in un progetto che potremmo definire GROSSO, esempio 100 classi, non puoi definire funzioni e implementazione tutto insieme!

Infine la potenzialità di java è la portabilità, ho un'interfaccia Leggi oggi leggerà da input, domani da file, dopodomani da server remoto, e poi ancora da db...non posso mica scrivere 4 funzioni per leggere! --> uso interfaccia Leggi da dove? sarà java a decidere quale implementazione del codice passare.