Discussion :

[proc02]

Bonjour à tous,
J'essai de comprendre des notion que sont

• Agregation
• heritage
• association
• composition
• ................

Mais j'arrive vraiment à cerner ces notions je sollicite votre comprehension de ses notions ,si possible quelques exemples pratique
Et aussi en niveau de l'heritage quand utilise t'on les class comme interface et ça sert a koi au juste......?
Vraiment un debutant
Merci d'avance

[joel.drigo]

Salut,

ce sont des notions de modélisation objet

1) héritage

principe de division d'un modèle suivant deux notions : spécialisation et généralisation

dans un modèle objet, les types d'objets sont réprésentés par des classes, qui sont définies par des méthodes (fonctions) et des attributs (variables).

spécialisation : relation d'héritage entre une classe spécialisée et une classe parent qui rend plus dédiée à des opération la classe enfant par rapport à la classe parent. par exemple, une classe Shape définit des formes et une classe Rectangle qui hérite de Shape définit des formes rectangulaires plus spécifiques.

généralisation : relation inverse (la classe Shape généralise la notion de forme par rapport à la classe Rectangle)

2) association

relation "sémantique" entre deux classes : par exemple quand on appelle une méthode d'une autre classe

3) agrégation : association de subordination : par exemple l'appartenance

une classe A peut avoir un attribut liste d'objet de classe B : B est subordonnée à A

4) composition : agrégation forte,

lorsque que A est une composition de B, les instances de classes B disparaissent lorsque l'instance de la classe A à laquelle elles appartiennent disparaissent

5) interface : il s'agit d'un motif d'architecture qui permet de définir comment communiquer entre 2 classes.

lorsqu'on réalise une API (un ensemble d'outils) qui doit réaliser une opération, on peut fournir une interface qui permet d'utiliser cet outil

par exemple, si on fait une API qui gère des statistiques sur des déplacements de machins (calcul de vitesse, de trajectoire, accélaration, etc) on peut définir une interface avec une méthode qui permet d'obtenir une position (x,y,z) dans l'espace.

ainsi, quand on veut utiliser cette api, pour calculer ces stats sur nos propres objets, il suffit d'implémenter cette interface conformément au contrat de définition de la méthode de l'interface (fournir la position de l'objet) et on peut obtenir les stats que cette api sait calculer.

A ne pas confondre avec la notion d'adaptation qui est de fournir une classe manipulée par une API A qui permet de manipuler une classe d'une API B que l'API A ne saura pas manipuler. Mais l'adapteur de classe de l'API B implémentera probablement une interface fournie par l'API A.

[proc02]

Salut,



5) interface : il s'agit d'un motif d'architecture qui permet de définir comment communiquer entre 2 classes.

lorsqu'on réalise une API (un ensemble d'outils) qui doit réaliser une opération, on peut fournir une interface qui permet d'utiliser cet outil

par exemple, si on fait une API qui gère des statistiques sur des déplacements de machins (calcul de vitesse, de trajectoire, accélaration, etc) on peut définir une interface avec une méthode qui permet d'obtenir une position (x,y,z) dans l'espace.

ainsi, quand on veut utiliser cette api, pour calculer ces stats sur nos propres objets, il suffit d'implémenter cette interface conformément au contrat de définition de la méthode de l'interface (fournir la position de l'objet) et on peut obtenir les stats que cette api sait calculer.

A ne pas confondre avec la notion d'adaptation qui est de fournir une classe manipulée par une API A qui permet de manipuler une classe d'une API B que l'API A ne saura pas manipuler. Mais l'adapteur de classe de l'API B implémentera probablement une interface fournie par l'API A.

Merci du temps accordé à ce post l'interface est un peu floux à part xa les autres je crois les avoir cernées.

[joel.drigo]

pour l'interface, prenons l'exemple java.util.Iterator :

c'est une interface fournie par java pour réprésenter une classe qui se comporte d'une certaine manière, sans savoir quelle implémentation elle pourrait avoir.

ensuite, quand on appelle la méthode iterator() d'un java.util.Set ou d'une java.util.List, on obtient des implémentations spécifiques d'une interface commune java.util.Iterator. on a pas besoin de savoir comment c'est implémenté, on a juste besoin de savoir ce que l'interface définit comme comportement.

le deuxième avantage c'est qu'on peut créer nos propres classes avec une méthode iterator() qui retourne une implémentation à nous mais conforme à la définition de l'interface, ce qui permet à toute classe qui manipule l'interface java.util.Iterator de manipuler cet iterateur sans se preoccuper de son implémentation, puisque l'interface lui garanti d'avoir les méthodes qu'elle veut;

par exemple :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
public class De {
 
     private int nbfaces;
     public De(int nbfaces) {
         this.nbfaces=nbfaces;
     }
 
     public Iterator<Integer> lance(int nombrelancements) {
           return new RandomIntIterator(nombrelancements,nbfaces);
     }
 
}

avec

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
public class RandomIntIterator implements Iterator<Integer> {
 
	private int nb;
	private int max;
 
	/**
         * Créée un itérateur qui itère sur nb nombres aléatoire compris en 0 inclus et max exclus
         * 
         * @param nb 
         * @param max 
         */
	public RandomIntIterator(int nb, int max) {
		this.nb=nb;
		this.max=max;
	}
 
	public boolean hasNext() {
		return this.nb>0;
	}
 
	public Integer next() {
		if ( this.nb>0 ) {
			this.nb--;
			return (int) (Math.random()*max);
		}
		throw new NoSuchElementException();
	}
 
	public void remove() {
		throw new UnsupportedOperationException();
	}
 
}

mais on peut également créer soit même une classe qui manipule des objets qui implémentent cet interface, sans se préoccuper de l'implémentation.

par exemple, j'ai fait il y a quelques années la classe suivante en exploitant une autre interface liée à java.util.Iterator, java.util.Iterable

Cette classe permet d'itérer en boucle sur un iterateur fourni par un interable. Pour éviter de boucle à l'infini, je fourni ma propre interface pour gérer un point d'arret, IStopCondition : je ne peux connaitre à l'avance quelle condition d'arrêt un futur process pourrait avoir besoin, mais je sais comment la gérer (ou plutôt je décide des limites que j'impose pour sa gestion)

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
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
public class CycleIterator<T> implements Iterator<T> {
 
	private Iterable<T> iterable;
	private int max;
	private int nb;
	private Iterator<T> iterator;
	private boolean remove;
	private IStopCondition<T> stopCondition;
	private Boolean hasNext;
	private int cyclecount;
 
	public CycleIterator(Iterable<T> iterable) {
		this(iterable, null);
	}
	public CycleIterator(Iterable<T> iterable, IStopCondition<T> stopCondition) {
		this.iterable=iterable;
		this.max=-1;
		this.stopCondition=stopCondition;
	}
	public CycleIterator(Iterable<T> iterable, int max) {
		this.iterable=iterable;
		this.max=max<0?0:max;
	}
 
	public boolean hasNext() {
		hasNext=null;
		if ( max>=0 && nb>=max ) {
			hasNext = false;
		}
		else if ( iterator==null || !iterator.hasNext() ) {
			iterator=iterable.iterator();
			if ( stopCondition.stopOnCycle(iterator, cyclecount) || !iterator.hasNext() ) {
				hasNext = false;
			}
			cyclecount++;
		}
		if ( hasNext==null && stopCondition!=null ) {
			if ( stopCondition.stop(iterator) ) {
				hasNext = false;
			}
		}
		if ( hasNext==null ) {
			hasNext=true;
		}
		return hasNext;
	}
 
	public T next() {
		if ( hasNext==null ) {
			hasNext();
		}
		if ( hasNext ) {
			remove=true; 
			hasNext=null;
			nb++;
			return iterator.next();
		}
		throw new NoSuchElementException();
	}
 
	public void remove() {
		if ( remove ) {
			iterator.remove();
			remove=false;
		}
		else {
			throw new IllegalStateException();
		}
	}
 
	public static interface IStopCondition<U> {
 
		boolean stop(Iterator<U> iter);
 
		boolean stopOnCycle(Iterator<U> iter, int cycleCount);
 
	}
 
	/*public static void main(String[] args) {
 
		List<String> list = new ArrayList<String>();
		for(int i=0; i<10; i++) {
			list.add(String.valueOf(i));
		}
 
		class Tester {
 
			void test(Iterator<String> iter) {
				int n=0;
				for( ; iter.hasNext(); ) {
					System.out.println(n++ + " " +iter.next());
				}
			}
 
			void testrem(Iterator<String> iter) {
				int n=0;
				for( ; iter.hasNext(); ) {
					System.out.println(n++ + " " +iter.next());
					if ( n%2==0 ) {
						iter.remove();
					}
				}
			}
 
		}
 
		//new Tester().test(new CycleIterator<String>(list, 45));
		//new Tester().test(new CycleIterator<String>(list, 5));
 
		//new Tester().test(new CycleIterator<String>(list.subList(0, 0), 5));
 
		//new Tester().testrem(new CycleIterator<String>(list, 15));
		//new Tester().testrem(new CycleIterator<String>(list));
 
		new Tester().test(new CycleIterator<String>(list, new IStopCondition<String>() {
 
			public boolean stop(Iterator<String> iter) {
				return !iter.hasNext() || Math.random()<0.5;
			}
 
			public boolean stopOnCycle(Iterator<String> iter, int cycleCount) {
				return false;
			}
		}));
 
	}*/
 
}

[proc02]

Merci pour tout