Un groupe d'étudiants a juste un nom au début. Dès leur premier examen, ils auront à la fois le nom et le score. Comment concevoir ceci est un moyen simple?

Question

je un ensemble de Individual s au premier:

class Individual { 
    double characteristics[]; 
    abstract double CalculateValue(); 
    ... 
} 

Chaque individu a un ensemble de caractéristiques. Ces caractéristiques seront mises en œuvre par l'utilisateur de ma bibliothèque par héritage:

class MyIndividualABC : Individual { 
    public MyIndividualABC() { 
     characteristics = new double[2]; 
     characteristics[0] = 123; 
     characteristics[1] = 456; 
    } 

    public override double CalculateValue() { 
     return characteristics[0]/characteristics[1]; //for example 
    } 
} 

Je vais donc les prendre et donner à chacun d'eux un score (en fonction de leur valeur). Je vais appeler cela faire une itération.

class EvaluatedIndividual { 
    double value; 
    double score; //score was calculated based on value 
} 

De iteration2 et au-delà, je serai toujours à avoir des objets à la main de type EvaluatedIndividual. Mais la première fois, je vais devoir mener avec des objets de type Individual.

Je n'aimerais pas avoir à traiter la première itération différemment des autres. Comment dois-je aborder cela?

Une analogie serait d'avoir une classe d'étudiants. Avant le premier examen, vous connaissez simplement leurs noms, et à partir du 1er examen, vous aurez à la fois leurs noms et la moyenne des résultats de leurs examens jusqu'à ce moment.

J'ai mis au point 3 différentes façons de gérer cela:

1. J'ai une méthode Start() sur mon programme, puis un Iteration(). Le Start() prend Individual[] tandis que le Iteration() prend EvaluatedIndividual[]. Hacky, mais fera des merveilles. Utilisera ceci si rien ne se passe mieux.

2. EvaluatedIndividual hérite de Individual. Cela semble propre, mais je ne suis pas trop sûr à ce sujet parce que je voudrais Individual être une interface et mon idée serait de permettre au client de ma bibliothèque/framework d'en hériter et de définir un ensemble de méthodes/champs sur Individual comme il le souhaite (Individual pourrait avoir plusieurs valeurs qui seraient prises en considération pour le calcul value, par exemple). Si je suis cette approche, je devrais lui faire implémenter un cours de EvaluatedIndividual. L'individu est formé par la valeur et à la fois evaluation et wasEvaluated. Au début wasEvaluated était faux, donc toute tentative de rassembler value lève une exception. Je ne suis pas particulièrement comme ça, mais je ne sais pas pourquoi.

Comment avez-vous abordé cela? Ceci est probablement un modèle assez commun, mais je crains que je ne connais aucun motif GoF qui correspond à ce scénario :(

Merci

Answer 1

Hé, si ce n'est pas une sorte d'exercice en classe, n » Les modèles de GoF ne sont pas pour tout ce que vous savez

Answer 2

Je suis tout pour simple, je voudrais juste avoir un cours ici.En C# peut-être utiliser Nullable<T>:

double? Score {get;set;} 

En Java (qui manque évidemment Nullable<T>), peut-être juste exposer le score avec un drapeau isEvaluated (ou un compte du nombre d'examens évalués) - si cela est false (ou 0) vous ignorez simplement le score.

Answer 3

J'ai une classe avec une valeur spéciale pour score qui indique que l'individu n'a pas été évalué:

class Individual { 
    private double value; 
    private double score = -1; // score was calculated based on value, 
           // -1 means not evaluated 

    public boolean isEvaluated() { return score != -1; } 
} 

héritage à mon humble avis est un surpuissant ici.

Answer 4

class Individual { 
    double score; 
    ScoreState scoreState; 
} 

J'ai trouvé chaque fois que je besoin d'un état, je dois 2, et je peu besoin 2 + n, donc peut-être aussi bien faire un ENUM, cela permet à des situations comme « en attente d'examen » et d'autres considérations, qui peuvent être utiles à l'avenir, et il empêche contre un excès de drapeaux, ce qui peut être source de confusion.