// definizione classe con metodi statici
class MiaClasse {
public static void metodo1() { ... }
public static Object metodo2(int valore) { ... }
}
// utilizzo classe con metodi statici
MiaClasse.metodo1();
...
Object r = MiaClasse.metodo2(10);
// classe singleton
class MiaClasse {
private MiaClasse() { ... }
private static MiaClasse instance = null;
public static getInstance() {
if (instance == null) instance = new MiaClasse();
return instance;
}
public void metodo1() { ... }
public Object metodo2(int valore) { ... }
}
// utilizzo classe singleton
MiaClasse.getInstance().metodo1();
...
Object r = MiaClasse.getInstance().metodo2(10);
Il singleton è indubbiamente una soluzione che aggiunge complessità, almeno in un primo momento. Però ha un vantaggio: permette di trattare il componente funzionale come un oggetto, con tutto quello che ne consegue. Ad esempio, se il singleton implementa una certa interfaccia M, è possibile passare il singleton ad un metodo che accetta un parametro di tipo M.
class MiaClasse implements M {
...
}
class AltraClasse {
public void metodoM(M param) { ... }
...
}
AltraClasse a = ...;
a.metodoM(MiaClasse.getInstance());
E' possibile fare la stessa cosa utilizzando l'oggetto Class?
La risposta è... forse... penso di si, ma in modo più complicato, così complicato che il singleton alla fine sarebbe la soluzione migliore.
Queste considerazioni mi fanno venire in mente un fatto: in Objective C le classi sono oggetti al pari di altri e potete permettervi di passarle come parametri ad un metodo ed usarle per richiamare i metodi della classe come si fa con i metodi delle istanze. Ad esempio:
@interface ClasseA
{
...
}
+ (int) metodo1: (int) valore;
...
@interface ClasseB
{
...
}
- (void) metodo2: (id) oggetto;
...
@interface ClasseC
{
...
}
- (int) metodo1: (int) valore;
...
@implementation ClasseB
- (void) metodo2: (id) oggetto
{
int y = ... ;
....
int x = [oggetto metodo1: y]
...
}
...
// utilizzo ClasseA come parametro metodo2
ClasseB* b = ... ;
[b metodo2: ClasseA];
// utilizzo istanza di ClasseC come parametro di metodo2.
ClasseC* c = ...;
[b metodo2: c];
Insomma, se Java fosse come l'Objective C, probabilmente si potrebbe evitare il ricorso ai singleton tutte quelle volte che vorrebbe trattare la classe come un oggetto. Il problema è capire quando questo è, più che necessario, possibile. Cioè, che probabilità ci sia che questo prima o poi diventi una necessità.
