Bonsoir!

Je suis toujours en plein apprentissage du langage Java et j'essaye aujourd'hui de comprendre les différents types d'égalité et leur implémentation dans un code.
Je pense avoir compris comment on réalise un méthode equals, mais d'un point de vue plus abstrait, quelle est la différence entre identité d'objets et égalité d'objet?

Si on modélise le jeu de Dominos à l’aide de l’entité Domino qui désigne une pièce d’un jeu de dominos et de l’entité Game qui représente une partie de dominos.
Qu serait la sémantique d'égalité sur Domino et sur Game? (je dirais à priori égalité d'objets sur game et identité sur domino mais peut-être que je me trompe...)

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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
 
//////////////////////////////   GAME   /////////////////////
 
package tdr.td_dominos.question123;
 
import java.util.*;
 
public class Game implements GameAbility{
	private List game; 
	public Game(Domino d){
		setGame( new LinkedList());
	      getGame().add(d);
	      }   
	private void setGame(List list){
		game=list;
		}   
	private List getGame(){
		return game;
		}
 
	// Seule methode publique appartenant a l'interface
	public boolean add(Domino d){
		boolean result= addLast(d);
		if (!result){result= addFirst(d);}
		return result;
		}
	private boolean isEmpty(){
		return getGame().isEmpty();
		}
	private Domino getFirst(){
	      return (Domino) getGame().get(0);
	      }
	private Domino getLast(){
	      return (Domino)  getGame().get(game.size()-1);
	      }
	private boolean addFirst(Domino d){
		Domino first = getFirst();
		boolean result= first.matchLeft(d);   
		// first peut se mettre a droite de d: d first ou retourne(d) first
		if (result) {
			( (LinkedList)getGame()).addFirst(d);
			} else{
				System.out.println(" AJOUT IMPOSSIBLE A GAUCHE DANS LE JEU  avec " + d);}
		return result;
		}
	    // Ajoute d en fin de jeu
	    // d peut se mettre ‡ droite du last: last d ou last retourne d   
	private boolean addLast(Domino d){
		Domino last = getLast();
		boolean result= last.matchRight(d); 
		// first peut se mettre ‡ droite de d: d first ou retourne(d) first
		if (result) {
			( (LinkedList)getGame()).addLast(d);
	     } else {
	    	 System.out.println(" AJOUT IMPOSSIBLE A DROITE DANS LE JEU avec  "+ d);}
	     return result;
	     }
 
	public boolean equals(Object object){
		if (object instanceof Game){
			return equals((Game)object);
			}
	     return false;
	     }
 
	private boolean equals(Game object){
		return getGame().equals(object.game);
		}
	public void clear(){
		getGame().clear();
		}
 
	public String toString(){
		return getGame().toString();
		}
	}
 
interface GameAbility{
    boolean add(Domino d);
	}
////////////////////////    DOMINO  ///////////////////////
package tdr.td_dominos.question123;
 
public class Domino {
    private int right;
    private int left;
 
    //create a domino
    public Domino(int left,int right){
    	  setLeft(left);
    	  setRight (right);
    	  }
    //by default
    public Domino(){
    	  this(0,0);
    	  }
    //ne devrait pas Ítre public
    private int getRight(){
    	  return right;
    	  }
    private int getLeft(){
    	  return left;
    	  }
    //ne devrait pas Ítre public
    private void setRight(int value){
    	  this.right=value;
    	  }
    private void setLeft(int value){
        this.left=value;
        }
 
    public String toString (){
    	  return ("["+getLeft()+";"+getRight()+"] ");
    	  }
 
    //return true if the domino may be placed straight or by turning over at the left side
    // otherwise, return false
    // d this  or turnOver(d) this
    public boolean matchLeft(Domino d){
    	  boolean result= turnAfter(d);
    	  if (result){
    		d.rotate();
    		return result;
    		}
    	result=isAfter(d);
    	return result;
    	}
    // d va-t-il a droite du jeu? on regarde si les parties dr. de d et du jeu sont =, si oui on retorne
    // sinon on examine s'il va sans retournement (this est le domino a la droite du jeu)
    public boolean matchRight(Domino d){
    	  boolean result= turnBefore(d);
    	  if (result){
    		d.rotate();
    		return result;
    		}
        result=isBefore(d);
    	  return result;
    	  }
 
    private void rotate(){
    	  int temp=getLeft();
        setLeft(getRight());
        setRight (temp);
        }
    // d peut-il être placé à la droite de this ?
    private boolean isBefore(Domino d){
    	  return this.getRight()==d.getLeft();
    	  }
    // d peut-il être placé à la droite de this après retournement ?
    private boolean turnBefore(Domino d){
    	  return this.getRight()==d.getRight();
    	  }
    private boolean isAfter(Domino d){
        return this.getLeft()==d.getRight();
    	  }
    private boolean turnAfter(Domino d){
    	  return this.getLeft()==d.getLeft();
    	  }
 
    public boolean equals(Object object){
        if (object instanceof Domino){
             return equals((Domino)object);
             }
        return false;
        }
 
    private boolean equals(Domino object){
        return   turnBefore(object)&&turnAfter(object)||isBefore(object)&&isAfter(object);
        }
}
 
 
////////////////    DominoTest  ///////////////////
package tdr.td_dominos.question123;
import java.util.*;
/*
game = [[2;3] , [3;4] ]
 AJOUT IMPOSSIBLE A DROITE DANS LE JEU avec  [3;5] 
 AJOUT IMPOSSIBLE A GAUCHE DANS LE JEU  avec [3;5] 
game = [[2;3] , [3;4] ]
 AJOUT IMPOSSIBLE A DROITE DANS LE JEU avec  [2;6] 
game must be [[6,2] , [2;3] , [3;4]]  :: [[6;2] , [2;3] , [3;4] ]
game must be [[6,2] , [2;3] , [3;4] , [4;5]]  :: [[6;2] , [2;3] , [3;4] , [4;5] ]
d23.equals(d34) must be false :: false
d34.equals(new Domino(3,4)) must be true :: true
d34.equals(new Domino(4,3)) must be true :: true
 AJOUT IMPOSSIBLE A DROITE DANS LE JEU avec  [6;2] 
game2 = [[6;2] , [2;3] ]
game3 = [[6;2] , [2;3] ]
game2.equals(game3) must be true :: true
*/
 
public class DominoTest {
 
    public static void main(String[] args){
	//construction du jeu, melange, distribution
        Domino d23=new Domino(2,3);
        Domino d34=new Domino(3,4);
        Domino d35=new Domino(3,5);
        Domino d37=new Domino(3,7);
        Domino d26=new Domino(2,6);
 
        GameAbility game= new Game(d23);
        //game.add(d23);
        game.add(d34);
        System.out.println("game = " + game);
        game.add(d35);
        System.out.println("game = " + game);
        //System.out.println("Test = : " + game.equals(game));
        //System.out.println("Test = dom " + d23.equals(d));
        //System.out.println("game must be [[2;3]] :: "+game);
        game.add(d26);
        System.out.println("game must be [[6,2] , [2;3] , [3;4]]  :: "+game);
        Domino d54=new Domino(5,4);
        game.add(d54);
        System.out.println("game must be [[6,2] , [2;3] , [3;4] , [4;5]]  :: "+game);
        // Test égalité    
        System.out.println("d23.equals(d34) must be false :: " + d23.equals(d34));
        System.out.println("d34.equals(new Domino(3,4)) must be true :: "+ d34.equals(new Domino(3,4)));
        System.out.println("d34.equals(new Domino(4,3)) must be true :: "+ d34.equals(new Domino(4,3)));
        GameAbility game2 = new Game(d26);
        game2.add(d23);
        GameAbility game3 = new Game(d23);
        game3.add(d26);
        System.out.println("game2 = " + game2);
        System.out.println("game3 = " + game3);
        System.out.println("game2.equals(game3) must be true :: "+ game2.equals(game3));
    }
}