Discussion :

[yann_DZ]

Bonjour,

J'ai un petit souci sur une notion en programmation.

Exemple : je veux créer une classe boulon qui comprend la classe vis et la classe écrou. Pour que la vis s'assemble avec l'écrou, il faut qu'ils aient (toujours par exemple) le même diamètre.

Quand je code, je peux définir toutes les propriétés et méthodes pour la vis.
Idem pour l'écrou. Je définis donc des classes indépendantes.

Question : comment puis-je faire pour que la propriété diamètre, soit la même pour les deux classes ? Est-il possible de définir une propriété commune ?

Je peux bidouiller bien sûr, en déplaçant la propriété commune vers la classe boulon mais cette méthode devient franchement pénible dans des cas plus complexes, avec des dizaines d'objets inbriqués.

Une idée ?

Merci

[StringBuilder]

Dans un premier temps, tu peux faire une assertion lorsque tu déclare la vis et l'écrou au niveau du boulon.

Ensuite, tu peux mettre une seconde assertion dans le set {} du diamètre de la vis et de l'écrou lorsqu'ils sont membre d'un boulon.

Un truc du genre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
 
using System;
 
namespace TestBoulon
{
    public class CVis
    {
        private int _diametre;
        private CBoulon _boulon;
 
        public CVis(int diametre)
        {
            _diametre = diametre;
        }
 
        public int Diametre
        {
            get
            {
                return _diametre;
            }
            set
            {
                if (_boulon != null && _boulon.Ecrou != null && value != _boulon.Ecrou.Diametre)
                {
                    throw new Exception("Nan, pas possible.");
                }
                _diametre = value;
            }
        }
 
        public void SetBoulon(CBoulon boulon)
        {
            if (_boulon.Ecrou != null && _diametre != boulon.Ecrou.Diametre)
            {
                throw new Exception("Nan, pas possible.");
            }
            _boulon = boulon;
        }
    }
 
    public class CEcrou
    {
        private int _diametre;
        private CBoulon _boulon;
 
        public CEcrou(int diametre)
        {
            _diametre = diametre;
        }
 
        public int Diametre
        {
            get
            {
                return _diametre;
            }
            set
            {
                if (_boulon != null && _boulon.Vis != null && value != _boulon.Vis.Diametre)
                {
                    throw new Exception("Nan, pas possible.");
                }
                _diametre = value;
            }
        }
 
        public void SetBoulon(CBoulon boulon)
        {
            if (_boulon.Vis != null && _diametre != boulon.Vis.Diametre)
            {
                throw new Exception("Nan, pas possible.");
            }
            _boulon = boulon;
        }
    }
 
    public class CBoulon
    {
        public CVis Vis;
        public CEcrou Ecrou;
 
        public CBoulon(CVis vis, CEcrou ecrou)
        {
            if (vis.Diametre != ecrou.Diametre)
            {
                throw new Exception("Nan, pas possible.");
            }
            Vis = vis;
            Ecrou = ecrou;
 
            Vis.SetBoulon(this);
            Ecrou.SetBoulon(this);
        }
 
        public int Diametre
        {
            get
            {
                return Vis.Diametre;
            }
        }
    }
}

Le truc chiant, c'est quand tu vas vouloir changer le diamètre du boulon une fois la vis et l'écrou déclarés... Si tu veux pouvoir le faire, il va falloir complexifier un peu.

[yann_DZ]

Merci pour ta réponse rapide et précise.

Je comprends bien que c'est faisable mais pas simple.

Imaginons maintenant que je travaille avec un moteur entier qui peut mécaniquement se définir comme un assemblage d'objets (de pièces).

Ces nombreux objets, j'aimerais les modéliser séparément ! Puis les assembler dans une grosse classe moteur.

Et là, avec la méthode qui vient d'être proposée, je vais avoir une architecture globale ingérable. Il me faut une autre solution (certains objets peuvent avoir des dizaines de propriétés communes).

Globalement, je m'étonne que la notion d'interface (propriétés comunes) ne soit pas plus simple en langage objet (je ne suis pas informaticien de formation).

[DonQuiche]

Bonjour.

Il est possible de définir une propriété commune via les interfaces. Par exemple IHasDiameter avec une propriété Diameter. Ecrou, Vis et Boulon peuvent alors déclarer cette interface et la propriété correspondante.

Cela dit, j'ai l'impression que tu fais fausse route quelque part. Pourrais-tu nous donner un exemple d'usage de la propriété diamètre ? Des scénarios où elle sera utilisée en nous précisant qui la consultera ? Et plus généralement qui parcourera ta hiérarchie d'objets et comment ?

S'il s'agit par exemple de faire des tests mécaniques, j'ai dans l'idée que ce n'est pas la bonne voie.

[yann_DZ]

Je fais sans doute fausse route, je ne sais pas.
Je cherche juste à bien programmer tout ça.

L'usage de mes applications est le calcul mécanique.
La problématique peut concerner tout autre type d'activité.
Cela peut aussi être les classes racine + tronc + feuille formant un arbre.

Le but, dans mon cas est le calcul.
Sur l'exemple boulon, le diamètre permet avec une autre propriété matériau de définir une méthode charge maximale supportée (je simplifie).

Je passe mes classes d'une application à l'autre suivant les besoins.
Je n'ai pas envie de les réécrire à chaque fois.

Si je fais fausse route, quel serait le bon chemin ?

[DonQuiche]

En fait, il existe en développement logiciel un motif de conception (Information Expert) qui préconise de confier une tâche à la classe ayant la plus grande part des informations nécessaires. En l’occurrence, ce principe nous conseille donc de ne pas chercher à faire un grand superviseur qui se chargerait de tous les calculs mais plutôt de laisser chaque pièce effectuer les calculs la concernant.

Dans ce cas de figure, vis, écrou et boulon n'ont pas besoin de clamer au monde entier qu'ils sont de ceux qui un diamètre. Boulon sait qu'il a une vis et un écrou et, puisqu'il connaît le type de ces deux pièces, il sait spontanément qu'ils ont tous deux un diamètre sans qu'une interface soit nécessaire. Ici, boulon a donc ce qu'il faut pour interagir avec eux et effectuer les calculs à son propre sujet en interagissant avec les méthodes fournies par vis et écrou.

Par exemple (implémentation naïve), pour le calcul, tous les pièces mécaniques pourraient hériter d'une même classe de base ayant une fonction abstraite GetTorseur(Vector position). Chaque classe se chargerait d'implémenter ce code. L'appelant n'aurait pas besoin de savoir si c'est un chou ou un boulon, s'il a un diamètre ou un poids, etc...

Comme en réalité il y aura vraisemblablement plusieurs types de calculs, selon le type d'action mécanique à évaluer, c'est plutôt en fonction des méthodes que chacun devra exposer pour ces calculs que l'on créer des interfaces ad hoc ou de nouvelles classes de base. Par exemple, tu pourrais avoir une interface IFluidVolume commune aux gaz et liquides qui exposerait les méthodes et propriétés nécessaires au traitement d'un fluide. C'est plus logique que d'essayer de faire une batterie d'interfaces IHasDensity, IHasCompressibility, etc. Dans ce cas, un objet Pompe serait rattachée à deux objets du type IFluidVolume.

[StringBuilder]

Hmmm, j'avais cru comprendre que la question n'était pas de savoir si Ecrou et Vis avaient ou non un diamètre, mais de vérifier que dans un même Boulon, Ecrou et Vis avaient forcément le même diamètre (c'est à dire la même valeur).

=> Une Vis et un Ecrou ne peuvent pas avoir de diamètre qui évolue dans le temps : c'est donc une propriété qui est propre à la vis à et l'écrou. Si la Vis ou l'Ecrou se retrouvent séparés, ils doivent conserver la valeur de leur diamètre.

=> Si on tente de mettre une Vis et un Ecrou dans un Boulon, alors que la Vis et l'Ecrou n'ont pas le même diamètre, on ne doit pas le permettre.

C'est en tout cas dans ce sens que j'ai répondu avec mon exemple.

La classe Boulon ne peut avoir seule la propriété diamètre, et elle n'est pas la seule à pouvoir faire le contrôle de la compatibilité du diamètre : on peut tout à fait imaginer passer dans un écrou une tige filleté qui ne soit pas une Vis, et glisser une Vis dans un pas de vis qui n'est pas un écrou. Il faut donc que Ecrou et Vis soient chacun capable de vérifier la compatibilité avec l' (les) objet(s) au(x)quel il est lié.