mad_hhatter
05-09-2007, 12:04
problema : classificazione di gesti
dominio :
GestureClass = {Id, Gesture, Threshold}
Gesture = {List<Feature>}
Feature = {tipo1} | {tipo2}
vincoli:
un Gesture deve contenere Feature dello stesso tipo,
se una GetsureClass contiene un Gesture di tipo T allora la GestureClass è di tipo T (un Gesture è di tipo T se contiene Feature di tipo T).
vorrei modellare questa situazione rendendo espliciti i vincoli...
per ora la mia soluzione è la seguente:
interface IFeature, contenente un metodo "double Distance(IFeature feature)"
tale metodo dovrà essere implementato in modo che se this e feature non sono dello stesso tipo il risultato sia invalido. Già così non mi piace granché, ma andiamo avanti.
veniamo al Gesture.
interface IGesture {double Distance(IGesture anotherGesture);}
abstract class AbstractGesture<T extends IFeature> implements IGesture {
protected ArrayList<T> features;
public abstract double Distance(AbstractGesture<T> anotherGesture);
public double Distance(IGesture anotherGesture) {
if (anotherGesture e this non sono dello stesso tipo) { Exception }
return Distance((AbstractGesture<T>) anotherGesture);
}
}
e questo mi fa ancora più schifo.
Il motivo di usare una classe astratta E una interface è per dire:
class GestureClass {
String Id;
IGesture gesture;
double threshold;
}
nota:
risultano 2 tipi di gesti, quello avente feature di tipo1 e quello avente feature di tipo2. l'algoritmo di distanza tra i 2 è un po' diverso:
nel primo caso sfrutta il metodo distance delle sue feature, ma nel secondo considera il gesto nel suo insieme e il metodo Distance in Feature_tipo2 è una commonality un po' stiracchiata anche se valida
morale:
questo design mi disgusta, ma il design in cui da ciascuna delle interfacce/classi_astratte Feature, Gesture, GestureClass derivano due classi concrete e poi usare una Factory per creare tutti gli oggetti del tipo giusto non mi soddisfa del tutto perchè perdo i vincoli...
avete suggerimenti?
grazie mille e scusate per la descrizione non troppo chiara
dominio :
GestureClass = {Id, Gesture, Threshold}
Gesture = {List<Feature>}
Feature = {tipo1} | {tipo2}
vincoli:
un Gesture deve contenere Feature dello stesso tipo,
se una GetsureClass contiene un Gesture di tipo T allora la GestureClass è di tipo T (un Gesture è di tipo T se contiene Feature di tipo T).
vorrei modellare questa situazione rendendo espliciti i vincoli...
per ora la mia soluzione è la seguente:
interface IFeature, contenente un metodo "double Distance(IFeature feature)"
tale metodo dovrà essere implementato in modo che se this e feature non sono dello stesso tipo il risultato sia invalido. Già così non mi piace granché, ma andiamo avanti.
veniamo al Gesture.
interface IGesture {double Distance(IGesture anotherGesture);}
abstract class AbstractGesture<T extends IFeature> implements IGesture {
protected ArrayList<T> features;
public abstract double Distance(AbstractGesture<T> anotherGesture);
public double Distance(IGesture anotherGesture) {
if (anotherGesture e this non sono dello stesso tipo) { Exception }
return Distance((AbstractGesture<T>) anotherGesture);
}
}
e questo mi fa ancora più schifo.
Il motivo di usare una classe astratta E una interface è per dire:
class GestureClass {
String Id;
IGesture gesture;
double threshold;
}
nota:
risultano 2 tipi di gesti, quello avente feature di tipo1 e quello avente feature di tipo2. l'algoritmo di distanza tra i 2 è un po' diverso:
nel primo caso sfrutta il metodo distance delle sue feature, ma nel secondo considera il gesto nel suo insieme e il metodo Distance in Feature_tipo2 è una commonality un po' stiracchiata anche se valida
morale:
questo design mi disgusta, ma il design in cui da ciascuna delle interfacce/classi_astratte Feature, Gesture, GestureClass derivano due classi concrete e poi usare una Factory per creare tutti gli oggetti del tipo giusto non mi soddisfa del tutto perchè perdo i vincoli...
avete suggerimenti?
grazie mille e scusate per la descrizione non troppo chiara