![]() |
Name implies Services (interface syntax + semantics)
James Gosling: What is the API to Windows? Nobody knows. In fact, even Microsoft doesn't know what the Windows API is. Because they publish an API, but lots of people sneak in through back doors. [...]Because there isn't a really good, strong interface notion in C, people just sort of reach in through the back doors. And they do God knows what. And so when Microsoft goes to release a new version of Windows, what they essentially have to do is test everything.
It was a very important property of interfaces that they are very strict. That wasn't just me deciding to be nasty. That was the world is madness if the contracts aren't strict. Because then all of a sudden--the whole notion of object-oriented programming falls apart. You lose the ability to unplug this and plug that in. If you don't know what the shape of the plug is, how do you know it can plug in?
get()
and set()
methods are very data
oriented
1 package com.artima.examples.matrix.ex1;
2
3 import java.io.Serializable;
4
5 /**
6 * Represents a matrix each of whose elements is an <CODE>int</CODE>.
7 *
8 * @author Bill Venners
9 */
10 public class Matrix implements Serializable, Cloneable {
11
12 private int[][] elements;
13 private int rowCount;
14 private int colCount;
15
16 /**
17 * Construct a new <EM>square zero matrix</EM> whose order is determined
18 * by the passed number of rows. (The matrix is square. It has the same
19 * number of rows and columns.) All elements of the new
20 * <CODE>Matrix</CODE> will be initialized to zero.
21 *
22 * @param rows The number of rows and columns in the new
23 * <CODE>Matrix</CODE>
24 * @exception IllegalArgumentException if <code>rows</code> is less than
25 * zero
26 */
27 public Matrix(int rows) {
28
29 if (rows < 1) {
30 throw new IllegalArgumentException();
31 }
32
33 elements = new int[rows][rows];
34 rowCount = rows;
35 colCount = rows;
36 }
37
38 /**
39 * Construct a new <EM>zero matrix</EM> whose order is determined by the
40 * passed number of rows and columns. The order is (rows by columns).
41 * All elements of the new <CODE>Matrix</CODE> will be initialized to
42 * zero.
43 *
44 * @param rows The number of rows in the new <CODE>Matrix</CODE>
45 * @param cols The number of columns in the new <CODE>Matrix</CODE>
46 * @exception IllegalArgumentException if <code>rows</code> or
47 * <code>cols</code> is less than zero
48 */
49 public Matrix(int rows, int cols) {
50
51 if (rows < 1 || cols < 1) {
52 throw new IllegalArgumentException();
53 }
54
55 elements = new int[rows][cols];
56 rowCount = rows;
57 colCount = cols;
58 }
59
60 /**
61 * Construct a new <CODE>Matrix</CODE> whose elements will be initialized
62 * with values from the passed two-dimensional array of
63 * <CODE>int</CODE>s. The order of the matrix will be determined by the
64 * sizes of the passed arrays. For example, a two dimensional array
65 * constructed with <CODE>new int[4][9]</CODE>, would yield a matrix
66 * whose order is 4 by 9. The lengths of each of the arrays held from the
67 * initial array must be the same. The two-dimensional array passed as
68 * <CODE>init</CODE> will not be used as part of the state of the newly
69 * constructed <CODE>Matrix</CODE> object.
70 *
71 * @param init A two-dimensional array of <code>int</code>s with which
72 * to initialize the new <code>Matrix</code>
73 * @exception IllegalArgumentException if the length of any passed array
74 * is zero, or if the length of all the secondary arrays are not
75 * equivalent.
76 */
77 public Matrix(int[][] init) {
78
79 checkValidity(init);
80
81 elements = (int[][]) init.clone();
82 rowCount = init.length;
83 colCount = init[0].length;
84 }
85
86 /**
87 * Returns the element value at the specified row and column.
88 *
89 * @param row The row of the element whose value is to be returned
90 * @param col The column of the element whose value is to be returned
91 * @return value of element at specified row and column
92 * @exception IndexOutOfBoundsException if <code>row</code> is less than
93 * zero or greater than the number of rows minus 1, or if
94 * <code>col</code> is less than 0 or greater than the number of
95 * columns minus 1.
96 */
97 public int get(int row, int col) {
98 checkIndices(row, col);
99 return elements[row][col];
100 }
101
102 /**
103 * Sets the element value at the specified row and column to the
104 * passed value.
105 *
106 * @param row The row of the element whose value is to be set
107 * @param col The column of the element whose value is to be set
108 * @param value The new value of the element indicated by row and col
109 * @exception IndexOutOfBoundsException if <code>row</code> is less than
110 * zero or greater than the number of rows minus 1, or if
111 * <code>col</code> is less than 0 or greater than the number of
112 * columns minus 1.
113 */
114 public void set(int row, int col, int value) {
115 checkIndices(row, col);
116 elements[row][col] = value;
117 }
118
119 /**
120 * Returns the number of rows in this matrix.
121 *
122 * @return number of rows in this <code>Matrix</code>
123 */
124 public int getRows() {
125 return rowCount;
126 }
127
128 /**
129 * Returns the number of cols in this matrix.
130 *
131 * @return number of columns in this <code>Matrix</code>
132 */
133 public int getCols() {
134 return colCount;
135 }
136
137 /**
138 * Clones this object.
139 *
140 * @return A clone of this <code>Matrix</code>
141 */
142 public Object clone() {
143 try {
144 Matrix clone = (Matrix) super.clone();
145 clone.elements = (int[][]) elements.clone();
146 return clone;
147 }
148 catch (CloneNotSupportedException e) {
149 // Can't happen
150 throw new InternalError();
151 }
152 }
153
154 /**
155 * Compares passed <CODE>Matrix</CODE> to this <code>Matrix</code> for
156 * equality. Two <code>Matrix</code> objects are semantically equal if
157 * they have the same order (i.e., same number of rows and columns), and
158 * the <code>int</code> value of each element in this <code>Matrix</code>
159 * is equal to the corresponding <code>int</code> value in the passed
160 * <code>Matrix</code>.
161 *
162 * @param An object to compare to this <code>Matrix</code>
163 * @return <code>true</code> if this <code>Matrix</code> is semantically
164 * equal to the passed <code>Matrix</code>
165 */
166 public boolean equals(Object o) {
167
168 if ((o == null) || (getClass() != o.getClass())) {
169 return false;
170 }
171
172 // This can't fail because the class of o is exactly Matrix
,
173 // as was proven when (getClass() != o.getClass()) returned false
174 Matrix m = (Matrix) o;
175
176 // Because this class extends Object, don't call super.equals()
177
178 // To be semantically equal, both matrices must have the same order
179 if ((rowCount != m.rowCount) || (colCount != m.colCount)) {
180 return false;
181 }
182
183 // To be semantically equal, corresponding elements of both
184 // matrices must be equal
185 for (int row = 0; row < rowCount; ++row) {
186 for (int col = 0; col < colCount; ++col) {
187
188 if (elements[row][col] != m.elements[row][col]) {
189 return false;
190 }
191 }
192 }
193
194 return true;
195 }
196
197 /**
198 * Computes the hash code for this <code>Matrix</code>.
199 *
200 * @return a hashcode value for this <code>Matrix</code>
201 */
202 public int hashcode() {
203
204 int retVal = rowCount * colCount;
205
206 for (int row = 0; row < rowCount; ++row) {
207 for (int col = 0; col < colCount; ++col) {
208
209 retVal ^= elements[row][col];
210 }
211 }
212
213 return retVal;
214 }
215 /**
216 * Ensures passed two-dimensional array is valid for initializing a
217 * <CODE>Matrix</CODE> object.
218 */
219 private static void checkValidity(int[][] val) {
220
221 try {
222 int rows = val.length;
223 if (rows == 0) {
224 throw new IllegalArgumentException();
225 }
226 int cols = val[0].length;
227 if (cols == 0) {
228 throw new IllegalArgumentException();
229 }
230 for (int i = 1; i < rows; ++i) {
231 if (val[i].length != cols) {
232 throw new IllegalArgumentException();
233 }
234 }
235 }
236 catch (NullPointerException e) {
237 throw new IllegalArgumentException();
238 }
239 }
240
241 /**
242 * Ensures passed row and column represent valid indices into this
243 * <CODE>Matrix</CODE>.
244 */
245 private void checkIndices(int row, int col) {
246 if (row >= rowCount || row < 0 || col >= colCount || col < 0) {
247 throw new IndexOutOfBoundsException();
248 }
249 }
250 }
1 package com.artima.examples.matrix.ex1;
2
3 class Example1 {
4
5 public static void main(String[] args) {
6
7 int[][] init1 = { {2, 2}, {2, 2} };
8 int[][] init2 = { {1, 2}, {3, 4} };
9
10 Matrix m1 = new Matrix(init1);
11 Matrix m2 = new Matrix(init2);
12
13 // Add m1 & m2, store result in a new Matrix object
14 Matrix sum = new Matrix(2, 2);
15 for (int i = 0; i < 2; ++i) {
16 for (int j = 0; j < 2; ++j) {
17 int addend1 = m1.get(i, j);
18 int addend2 = m2.get(i, j);
19 sum.set(i, j, addend1 + addend2);
20 }
21 }
22
23 // Print out the sum
24 System.out.print("Sum: {");
25 for (int i = 0; i < 2; ++i) {
26 for (int j = 0; j < 2; ++j) {
27 int val = sum.get(i, j);
28 System.out.print(val);
29 if (i == 0 || j == 0) {
30 System.out.print(", ");
31 }
32 }
33 }
34 System.out.println("}");
35
36 }
37 }
set()
method replaced by service-oriented methods
1 package com.artima.examples.matrix.ex2; 2 3 import java.io.Serializable; 4 5 /** 6 * A two-dimensional matrix of <CODE>int</CODE>s. 7 * 8 * <P> 9 * The <em>order</em> of the matrix is its number of rows and columns. For 10 * example, the order of a matrix with 5 rows and 4 columns is "5 by 4." A 11 * matrix with the same number of rows and columns, such as a 3 by 3 matrix, 12 * is a <em>square matrix</em>. A matrix all of whose elements is zero is a 13 * <em>zero matrix</em>. 14 * 15 * <P> 16 * Instances of <CODE>Matrix</CODE> are immutable. 17 * 18 * @author Bill Venners 19 */ 20 public class Matrix implements Serializable, Cloneable { 21 22 private int[][] elements; 23 private int rowCount; 24 private int colCount; 25 26 /** 27 * Construct a new square <code>Matrix</code> whose order is determined 28 * by the passed number of rows. Yields a zero matrix, i.e., all elements 29 * of the new <CODE>Matrix</CODE> will be initialized to zero. 30 * 31 * @param rows The number of rows and columns in the new square 32 * <CODE>Matrix</CODE> 33 * @exception IllegalArgumentException if <code>rows</code> is less than 34 * one 35 */ 36 public Matrix(int rows) { 37 38 if (rows < 1) { 39 throw new IllegalArgumentException(); 40 } 41 42 elements = new int[rows][rows]; 43 rowCount = rows; 44 colCount = rows; 45 } 46 47 /** 48 * Construct a new <EM>zero matrix</EM> whose order is determined by the 49 * passed number of rows and columns. The order is (rows by columns). 50 * Yields a zero matrix, i.e., all elements of the new 51 * <CODE>Matrix</CODE> will be initialized to zero. 52 * 53 * @param rows The number of rows in the new <CODE>Matrix</CODE> 54 * @param cols The number of columns in the new <CODE>Matrix</CODE> 55 * @exception IllegalArgumentException if <code>rows</code> or 56 * <code>cols</code> is less than 1 57 */ 58 public Matrix(int rows, int cols) { 59 60 if (rows < 1 || cols < 1) { 61 throw new IllegalArgumentException(); 62 } 63 64 elements = new int[rows][cols]; 65 rowCount = rows; 66 colCount = cols; 67 } 68 69 /** 70 * Construct a new <CODE>Matrix</CODE> whose elements will be initialized 71 * with values from the passed two-dimensional array of 72 * <CODE>int</CODE>s. The order of the matrix will be determined by the 73 * sizes of the passed arrays. For example, a two dimensional array 74 * constructed with <CODE>new int[4][9]</CODE>, would yield a matrix 75 * whose order is 4 by 9. The lengths of each of the arrays held from the 76 * initial array must be the same. The two-dimensional array passed as 77 * <CODE>init</CODE> will not be used as part of the state of the newly 78 * constructed <CODE>Matrix</CODE> object. 79 * 80 * @param init A two-dimensional array of <code>int</code>s with which 81 * to initialize the new <code>Matrix</code> 82 * @param cols The number of columns in the new <CODE>Matrix</CODE> 83 * @exception IllegalArgumentException if the length of any passed array 84 * is zero, or if the length of all the secondary arrays are not 85 * equivalent. 86 */ 87 public Matrix(int[][] init) { 88 89 checkValidity(init); 90 91 elements = (int[][]) init.clone(); 92 rowCount = init.length; 93 colCount = init[0].length; 94 } 95 96 /** 97 * Returns the element value at the specified row and column. 98 * 99 * @param row The row of the element whose value is to be returned 100 * @param col The column of the element whose value is to be returned 101 * @return value of element at specified row and column 102 * @exception IndexOutOfBoundsException if <code>row</code> is less than 103 * zero or greater than the number of rows minus 1, or if 104 * <code>col</code> is less than 0 or greater than the number of 105 * columns minus 1. 106 */ 107 public int get(int row, int col) { 108 109 if (row >= rowCount || row < 0 || col >= colCount || col < 0) { 110 throw new IndexOutOfBoundsException(); 111 } 112 113 return elements[row][col]; 114 } 115 116 /** 117 * Returns the number of rows in this <code>Matrix</code>. 118 * 119 * @return number of rows in this <code>Matrix</code> 120 */ 121 public int getRows() { 122 return rowCount; 123 } 124 125 /** 126 * Returns the number of columns in this <code>Matrix</code>. 127 * 128 * @return number of columns in this <code>Matrix</code> 129 */ 130 public int getCols() { 131 return colCount; 132 } 133 134 /** 135 * Adds the passed <code>Matrix</code> to this one. The order of the 136 * passed <code>Matrix</code> must be identical to the order of this 137 * <code>Matrix</code>. 138 * 139 * <P> 140 * The sum of two <code>Matrix</code> objects is a <code>Matrix</code> of 141 * the same order of the two addends. Each element of the sum 142 * <code>Matrix</code> is equal to the sum of the corresponding elements 143 * in the <code>Matrix</code> addends. For example: 144 * 145 * <PRE> 146 * | 1 2 3 | | 9 -8 7 | | 10 -6 10 | 147 * | 4 5 6 | + | -6 5 -4 | = | -2 10 2 | 148 * | 7 8 9 | | -3 2 -1 | | 4 10 8 | 149 * </PRE> 150 * 151 * <P> 152 * This method does not throw any exception on overflow. 153 * 154 * @param addend the <code>Matrix</code> to add to this one 155 * @return The sum of this <code>Matrix</code> and the passed 156 * <code>Matrix</code> 157 * @exception IllegalArgumentException if the order of the passed 158 * <code>Matrix</code> object differs from the order of this 159 * <code>Matrix</code> 160 */ 161 public Matrix add(Matrix addend) { 162 163 // Make sure addend has the same order as this matrix 164 if ((addend.rowCount != rowCount) 165 || (addend.colCount != colCount)) { 166 167 throw new IllegalArgumentException(); 168 } 169 170 Matrix retVal = new Matrix(elements); 171 for (int row = 0; row < rowCount; ++row) { 172 for (int col = 0; col < colCount; ++col) { 173 retVal.elements[row][col] += addend.elements[row][col]; 174 } 175 } 176 return retVal; 177 } 178 179 /** 180 * Subtracts the passed <code>Matrix</code> from this one. The order of 181 * the passed <code>Matrix</code> must be identical to the order of this 182 * <code>Matrix</code>. Returned <code>Matrix</code> equals the sum of 183 * this <code>Matrix</code> and the negation of the passed 184 * <code>Matrix</code>. 185 * 186 * <P> 187 * The difference of two <code>Matrix</code> objects is a 188 * <code>Matrix</code> of the same order of the minuend and subtrahend. 189 * Each element of the sum <code>Matrix</code> is equal to the difference 190 * of the corresponding elements in the minuend (this) and subtrahend 191 * (passed) <code>Matrix</code> objects. For example: 192 * 193 * <PRE> 194 * | 1 2 3 | | 9 -8 7 | | -8 10 -4 | 195 * | 4 5 6 | - | -6 5 -4 | = | 10 0 10 | 196 * | 7 8 9 | | -3 2 -1 | | 10 6 10 | 197 * </PRE> 198 * 199 * <P> 200 * This method does not throw any exception on overflow. 201 * 202 * @param subtrahend the <code>Matrix</code> to subtract from this one 203 * @return The difference of this <code>Matrix</code> and the passed 204 * <code>Matrix</code> 205 * @exception IllegalArgumentException if the order of the passed 206 * <code>Matrix</code> object differs from the order of this 207 * <code>Matrix</code> 208 */ 209 public Matrix subtract(Matrix subtrahend) { 210 211 // To be subtracted, subtrahend must have the same order 212 if ((subtrahend.rowCount != rowCount) 213 || (subtrahend.colCount != colCount)) { 214 215 throw new IllegalArgumentException(); 216 } 217 218 Matrix retVal = new Matrix(elements); 219 for (int row = 0; row < rowCount; ++row) { 220 for (int col = 0; col < colCount; ++col) { 221 retVal.elements[row][col] -= subtrahend.elements[row][col]; 222 } 223 } 224 return retVal; 225 } 226 227 /** 228 * Multiplies this matrix by the passed scalar. Returns a new matrix 229 * representing the result of the multiplication. To negate a matrix, for 230 * example, just multiply it by -1. 231 * 232 * <P> 233 * The product of a <code>Matrix</code> and a scalar is a 234 * <code>Matrix</code> of the same order as the <code>Matrix</code> 235 * multiplicand. Each element of the product <code>Matrix</code> is equal 236 * to the product of the corresponding element in the <code>Matrix</code> 237 * multiplicand and the scalar multiplier. For example: 238 * 239 * <PRE> 240 * | 1 2 3 | | -2 -4 -6 | 241 * -2 * | 4 5 6 | = | -8 -10 -12 | 242 * | 7 8 9 | | -14 -16 -18 | 243 * </PRE> 244 * 245 * <P> 246 * This method does not throw any exception on overflow. 247 * 248 * @param addend the <code>Matrix</code> to add to this one 249 * @return The sum of this <code>Matrix</code> and the passed 250 * <code>Matrix</code> 251 * @exception IllegalArgumentException if the order of the passed 252 * <code>Matrix</code> object differs from the order of this 253 * <code>Matrix</code> 254 */ 255 public Matrix multiply(int scalar) { 256 257 Matrix retVal = new Matrix(elements); 258 for (int row = 0; row < rowCount; ++row) { 259 for (int col = 0; col < colCount; ++col) { 260 retVal.elements[row][col] *= scalar; 261 } 262 } 263 return retVal; 264 } 265 266 /** 267 * Multiplies this <code>Matrix</code> (the multiplicand) by the passed 268 * <code>Matrix</code> (the multiplier). The number of columns in this 269 * multiplicand <code>Matrix</code> must equal the number rows in the 270 * passed multiplier <code>Matrix</code>. 271 * 272 * <P> 273 * The product of two <code>Matrix</code> objects is a 274 * <code>Matrix</code> that has the same number of rows as the 275 * multiplicand (this <code>Matrix</code>) and the same number of columns 276 * as the multiplier (passed <code>Matrix</code>). Each element of the 277 * product <code>Matrix</code> is equal to sum of the products of the 278 * elements of corresponding multiplicand row and multiplier column. 279 * For example: 280 * 281 * <PRE> 282 * | 0 1 | | 6 7 | | (0*6 + 1*8) (0*7 + 1*9) | | 8 9 | 283 * | 2 3 | * | 8 9 | = | (2*6 + 3*8) (2*7 + 3*9) | = | 36 41 | 284 * | 4 5 | | (4*6 + 5*8) (4*7 + 5*9) | | 64 73 | 285 * </PRE> 286 * 287 * <P> 288 * This method does not throw any exception on overflow. 289 * 290 * @param multiplier the <code>Matrix</code> to multiply to this one 291 * @return A new <code>Matrix</code> representing the product of this 292 * <code>Matrix</code> and the passed <code>Matrix</code> 293 * @exception IllegalArgumentException if the number of rows of the 294 * passed <code>Matrix</code> object differs from the number of 295 * columns of this <code>Matrix</code> 296 */ 297 public Matrix multiply(Matrix multiplier) { 298 299 // To do a matrix multiplication, the number of columns in this 300 // matrix must equal the number of rows of the passed multiplicand. 301 if (colCount != multiplier.rowCount) { 302 throw new IllegalArgumentException(); 303 } 304 305 // Calculate order of result 306 int resultRows = rowCount; 307 int resultCols = multiplier.colCount; 308 309 // Create array for result 310 int[][] resultArray = new int[resultRows][resultCols]; 311 312 Matrix retVal = new Matrix(elements); 313 314 for (int row = 0; row < resultRows; ++row) { 315 for (int col = 0; col < resultCols; ++col) { 316 for (int i = 0; i < colCount; ++i) { 317 318 resultArray[row][col] += elements[row][i] 319 * multiplier.elements[i][col]; 320 } 321 } 322 } 323 return retVal; 324 } 325 326 /** 327 * Returns a <code>String</code> that contains the integer values of the 328 * elements of this <code>Matrix</code>. Each row of element values is 329 * enclosed in parentheses and separated by commas, and the entire result 330 * is enclosed in a set of parentheses. For example, for the matrix: 331 * 332 * <PRE> 333 * | 1 2 3 | 334 * | 4 5 6 | 335 * | 7 8 9 | 336 * </PRE> 337 * 338 * This method would return the string: 339 * 340 * <PRE> 341 * ((1, 2, 3), (4, 5, 6), (7, 8, 9)) 342 * </PRE> 343 * 344 * @return A new <code>String</code> representation of the state of this 345 * <code>Matrix</code> 346 */ 347 public String toString() { 348 349 StringBuffer retVal = new StringBuffer("("); 350 351 for (int row = 0; row < rowCount; ++row) { 352 retVal.append("("); 353 for (int col = 0; col < colCount; ++col) { 354 retVal.append(elements[row][col]); 355 if (col != colCount - 1) { 356 retVal.append(", "); 357 } 358 } 359 retVal.append(")"); 360 if (row != rowCount - 1) { 361 retVal.append(", "); 362 } 363 } 364 retVal.append(")"); 365 return retVal.toString(); 366 } 367 368 /** 369 * Clones this object. 370 * 371 * @return A clone of this <code>Matrix</code> 372 */ 373 public Object clone() { 374 try { 375 Matrix clone = (Matrix) super.clone(); 376 clone.elements = (int[][]) elements.clone(); 377 return clone; 378 } 379 catch (CloneNotSupportedException e) { 380 // Can't happen 381 throw new InternalError(); 382 } 383 } 384 385 /** 386 * Compares passed <CODE>Matrix</CODE> to this <code>Matrix</code> for 387 * equality. Two <code>Matrix</code> objects are semantically equal if 388 * they have the same order (i.e., same number of rows and columns), and 389 * the <code>int</code> value of each element in this <code>Matrix</code> 390 * is equal to the corresponding <code>int</code> value in the passed 391 * <code>Matrix</code>. 392 * 393 * @param An object to compare to this <code>Matrix</code> 394 * @return <code>true</code> if this <code>Matrix</code> is semantically 395 * equal to the passed <code>Matrix</code> 396 */ 397 public boolean equals(Object o) { 398 399 if ((o == null) || (getClass() != o.getClass())) { 400 return false; 401 } 402 403 Matrix m = (Matrix) o; 404 405 // Because this class extends Object, don't 406 // call super.equals() 407 408 // To be semantically equal, both matrices must 409 // have the same order 410 if ((rowCount != m.rowCount) || (colCount != m.colCount)) { 411 return false; 412 } 413 414 // To be semantically equal, corresponding 415 // elements of both matrices must be equal 416 for (int row = 0; row < rowCount; ++row) { 417 for (int col = 0; col < colCount; ++col) { 418 419 if (elements[row][col] != m.elements[row][col]) { 420 return false; 421 } 422 } 423 } 424 425 return true; 426 } 427 428 /** 429 * Computes the hash code for this <code>Matrix</code>. 430 * 431 * @return a hashcode value for this <code>Matrix</code> 432 */ 433 public int hashcode() { 434 435 int retVal = rowCount * colCount; 436 437 for (int row = 0; row < rowCount; ++row) { 438 for (int col = 0; col < colCount; ++col) { 439 440 retVal *= elements[row][col]; 441 } 442 } 443 444 return retVal; 445 } 446 447 /** 448 * Ensures passed two-dimensional array is valid for initializing a 449 * <CODE>Matrix</CODE> object. 450 */ 451 private static void checkValidity(int[][] val) { 452 453 try { 454 int rows = val.length; 455 if (rows == 0) { 456 throw new IllegalArgumentException(); 457 } 458 int cols = val[0].length; 459 if (cols == 0) { 460 throw new IllegalArgumentException(); 461 } 462 for (int i = 1; i < rows; ++i) { 463 if (val[i].length != cols) { 464 throw new IllegalArgumentException(); 465 } 466 } 467 } 468 catch (NullPointerException e) { 469 throw new IllegalArgumentException(); 470 } 471 } 472 } 1 package com.artima.examples.matrix.ex2; 2 3 class Example2 { 4 5 public static void main(String[] args) { 6 7 int[][] init1 = { {2, 2}, {2, 2} }; 8 int[][] init2 = { {1, 2}, {3, 4} }; 9 10 Matrix m1 = new Matrix(init1); 11 Matrix m2 = new Matrix(init2); 12 13 // Add m1 & m2, store result in a new matrix object 14 Matrix sum = m1.add(m2); 15 16 // Print out the sum 17 System.out.println("Sum: " + sum.toString()); 18 } 19 }
Matrix
to add()
to itself
set()
and get()
methods are not evil
get
and set
,
code that manipulates that
data gets spread across the program.
1 package com.artima.examples.stampdispenser.ex1; 2 3 import java.util.Set; 4 import java.util.Iterator; 5 import java.util.HashSet; 6 7 /** 8 * A stamp dispenser that accepts nickels and dimes and dispenses twenty cent 9 * stamps. 10 * 11 * @author Bill Venners 12 */ 13 public class StampDispenser { 14 15 private final static int STAMP_VALUE = 20; 16 private int balance; 17 private Set listeners = new HashSet(); 18 19 /** 20 * Constructs a new stamp dispenser with a starting balance of zero. 21 */ 22 public StampDispenser() { 23 } 24 25 /** 26 * Adds the specified stamp dispenser listener to receive stamp dispenser 27 * events from this stamp dispenser. If <code>l</code> is 28 * <code>null</code>, no exception is thrown and no action is performed. 29 * If <code>l</code> is already registered as a listener, no action is 30 * performed. 31 */ 32 public synchronized void addStampDispenserListener( 33 StampDispenserListener l) { 34 35 listeners.add(l); 36 } 37 38 /** 39 * Removes the specified stamp dispenser listener so that it no longer 40 * receives stamp dispenser events from this stamp dispenser. This method 41 * performs no function, nor does it throw an exception, if the listener 42 * specified by the argument was not previously added to this component. 43 * If <code>l</code> is <code>null</code>, no exception is thrown and no 44 * action is performed. 45 */ 46 public synchronized void removeStampDispenserListener( 47 StampDispenserListener l) { 48 49 listeners.remove(l); 50 } 51 52 /** 53 * Add either 5 or 10 cents to the stamp dispenser. If the amount added 54 * causes the balance to become or exceed 20 cents, the price of a stamp, 55 * the stamp will be automatically dispensed. If the stamp is dispensed, 56 * the amount of the balance after the stamp is dispensed is returned to 57 * the client. 58 * 59 * @throws IllegalArgumentException if passed <code>amount</code> doesn't 60 * equal either 5 or 10 61 */ 62 public synchronized void add(int amount) { 63 64 if ((amount != 5) && (amount != 10)) { 65 throw new IllegalArgumentException(); 66 } 67 68 balance += amount; 69 70 if (balance >= STAMP_VALUE) { 71 72 // Dispense a stamp and return any change 73 // balance - STAMP_VALUE is amount in excess of twenty cents 74 // (the stamp price) to return as change. After dispensing the 75 // stamp and returning any change, the new balance will be zero. 76 StampDispenserEvent event = new StampDispenserEvent(this, 77 balance - STAMP_VALUE, 0); 78 balance = 0; 79 fireStampDispensed(event, listeners); 80 } 81 else { 82 83 // Fire an event to indicate the balance has increased 84 StampDispenserEvent event = new StampDispenserEvent(this, 85 amount, balance); 86 fireCoinAccepted(event, listeners); 87 } 88 } 89 90 /** 91 * Returns coins. If the balance is zero, no action is performed. 92 */ 93 public synchronized void returnCoins() { 94 95 // Make sure balance is greater than zero, because no event should 96 // be fired if the coin return lever is pressed when the stamp 97 // dispenser has a zero balance 98 if (balance > 0) { 99 100 // Return the entire balance to the client 101 StampDispenserEvent event = new StampDispenserEvent(this, 102 balance, 0); 103 balance = 0; 104 fireCoinsReturned(event, listeners); 105 } 106 } 107 108 /** 109 * Helper method that fires coinAccepted events. 110 * 111 * @param event <code>StampDispenserEvent</code> to propagate 112 * @param listeners <code>Set</code> containing zero to many (and only) 113 * <code>StampDispenserListener</code>s 114 */ 115 private static void fireCoinAccepted(StampDispenserEvent event, 116 Set listeners) { 117 118 Iterator it = listeners.iterator(); 119 while (it.hasNext()) { 120 StampDispenserListener l = (StampDispenserListener) it.next(); 121 l.coinAccepted(event); 122 } 123 } 124 125 /** 126 * Helper method that fires stampDispensed events. 127 * 128 * @param event <code>StampDispenserEvent</code> to propagate 129 * @param listeners <code>Set</code> containing zero to many (and only) 130 * <code>StampDispenserListener</code>s 131 */ 132 private static void fireStampDispensed(StampDispenserEvent event, 133 Set listeners) { 134 135 Iterator it = listeners.iterator(); 136 while (it.hasNext()) { 137 StampDispenserListener l = (StampDispenserListener) it.next(); 138 l.stampDispensed(event); 139 } 140 } 141 142 /** 143 * Helper method that fires coinsReturned events. 144 * 145 * @param event <code>StampDispenserEvent</code> to propagate 146 * @param listeners <code>Set</code> containing zero to many (and only) 147 * <code>StampDispenserListener</code>s 148 */ 149 private static void fireCoinsReturned(StampDispenserEvent event, 150 Set listeners) { 151 152 Iterator it = listeners.iterator(); 153 while (it.hasNext()) { 154 StampDispenserListener l = (StampDispenserListener) it.next(); 155 l.coinsReturned(event); 156 } 157 } 158 } 1 package com.artima.examples.stampdispenser.ex1; 2 3 import java.util.EventObject; 4 5 /** 6 * Event that indicates a stamp dispenser has performed an action. The three 7 * kinds of actions that cause a stamp dispenser event to be propagated are: 8 * (1) accepting a coin, (2) dispensing a stamp, (3) returning coins. 9 * 10 * @author Bill Venners 11 */ 12 public class StampDispenserEvent extends java.util.EventObject { 13 14 private int amountReturned; 15 private int balance; 16 17 /** 18 * Constructs a <code>StampDispenserEvent</code> with 19 * <code>amountReturned</code>, and <code>balance</code>. 20 * 21 * @param amountReturned the amount of money, if any, returned to the 22 * client, either as the result of a coin return or as change when 23 * dispensing a stamp. 24 * @param balance the amount of money, if any, remaining as the current 25 * balance of the stamp dispenser after this event has occurred. 26 * @throws IllegalArgumentException if balance is not one of 0, 5, 10, or 27 * 15; or if amountReturned is not one of 0, 5, 10, or 15. 28 */ 29 public StampDispenserEvent(StampDispenser source, int amountReturned, 30 int balance) { 31 32 super(source); 33 34 if (balance != 0 && balance != 5 && balance != 10 35 && balance != 15) { 36 37 throw new IllegalArgumentException(); 38 } 39 40 if (amountReturned != 0 && amountReturned != 5 41 && amountReturned != 10 && amountReturned != 15) { 42 43 throw new IllegalArgumentException(); 44 } 45 46 this.amountReturned = amountReturned; 47 this.balance = balance; 48 } 49 50 /** 51 * Returns the amount of money returned to the client, expressed in units 52 * of American pennies. 53 */ 54 public int getAmountReturned() { 55 return amountReturned; 56 } 57 58 /** 59 * Returns the current balance: the amount of money that has been 60 * inserted into the stamp dispenser, but not returned via a coin return 61 * or consumed in exchange for a dispensed stamp. For example, if the 62 * <code>balance</code> is zero and a nickel is added, the 63 * <code>balance</code> in the resulting stamp dispenser event will be 5. 64 * If another dime is added, the <code>balance</code> in the resulting 65 * stamp dispenser event will be 15. If the <code>returnCoins</code> 66 * method is then invoked on the stamp dispenser, the 67 * <code>balance</code> of the resulting stamp dispenser event will be 0. 68 */ 69 public int getBalance() { 70 return balance; 71 } 72 } 1 package com.artima.examples.stampdispenser.ex1; 2 3 /** 4 * Listener interface for receiving stamp dispenser events. 5 * 6 * @author Bill Venners 7 */ 8 public interface StampDispenserListener { 9 10 /** 11 * Invoked when a stamp has been dispensed. If coins have also been 12 * returned as change, the amount is indicated by the return value of 13 * <CODE>getReturnedAmount</CODE> method of the passed 14 * <code>StampDispenserEvent</code>. 15 */ 16 void stampDispensed(StampDispenserEvent e); 17 18 /** 19 * Invoked when coins have been returned as the result of the 20 * <code>returnCoins</code> method being invoked on a 21 * <code>StampDispenser</code>. Coins that are returned as change when a 22 * stamp is dispensed are reported via the event passed to 23 * <code>stampDispensed</code>. 24 */ 25 void coinsReturned(StampDispenserEvent e); 26 27 /** 28 * Invoked when coins have been accepted but no stamp has been dispensed. 29 * A coin that causes a stamp to be dispensed does not generate a 30 * <code>coinsAccepted</code> method invocation, just a 31 * <code>stampDispensed</code> method invocation. 32 */ 33 void coinAccepted(StampDispenserEvent e); 34 }
get()
methods
package com.artima.examples.account.ex1; /** * Exception thrown byAccount
s to indicate that a requested * withdrawal has failed because of insufficient funds. */ public class InsufficientFundsException extends Exception { /** * Minimum additional balance required for the requested withdrawal to * succeed. */ private long shortfall; /** * Constructs anInsufficientFundsException
with the passed * shortfall and no specified detail message. * * @param shortfall the amount in excess of available funds that caused a * withdrawal request to fail. * @throws IllegalArgumentException if passed shortfall is less than or * equal to zero */ public InsufficientFundsException(long shortfall) { if (shortfall <= 0) { throw new IllegalArgumentException(); } this.shortfall = shortfall; } /** * Constructs anInsufficientFundsException
with the passed * detail message and shortfall. * * @param message the detail message * @param shortfall the amount in excess of available funds that caused a * withdrawal request to fail. * @throws IllegalArgumentException if passed shortfall is less than or * equal to zero */ public InsufficientFundsException(String message, long shortfall) { super(message); if (shortfall <= 0) { throw new IllegalArgumentException(); } this.shortfall = shortfall; } /** * Returns the shortfall that caused a withrawal request to fail. The * shortfall is the minimum additional balance required for the requested * withdrawal to succeed. * * @returns shortfall the amount in excess of available funds that caused * a withdrawal request to fail. */ public long getShortfall() { return shortfall; } }
1 package com.artima.examples.stampdispenser.ex1; 2 3 import java.util.EventObject; 4 5 /** 6 * Event that indicates a stamp dispenser has performed an action. The three 7 * kinds of actions that cause a stamp dispenser event to be propagated are: 8 * (1) accepting a coin, (2) dispensing a stamp, (3) returning coins. 9 * 10 * @author Bill Venners 11 */ 12 public class StampDispenserEvent extends java.util.EventObject { 13 14 private int amountReturned; 15 private int balance; 16 17 /** 18 * Constructs a <code>StampDispenserEvent</code> with 19 * <code>amountReturned</code>, and <code>balance</code>. 20 * 21 * @param amountReturned the amount of money, if any, returned to the 22 * client, either as the result of a coin return or as change when 23 * dispensing a stamp. 24 * @param balance the amount of money, if any, remaining as the current 25 * balance of the stamp dispenser after this event has occurred. 26 * @throws IllegalArgumentException if balance is not one of 0, 5, 10, or 27 * 15; or if amountReturned is not one of 0, 5, 10, or 15. 28 */ 29 public StampDispenserEvent(StampDispenser source, int amountReturned, 30 int balance) { 31 32 super(source); 33 34 if (balance != 0 && balance != 5 && balance != 10 35 && balance != 15) { 36 37 throw new IllegalArgumentException(); 38 } 39 40 if (amountReturned != 0 && amountReturned != 5 41 && amountReturned != 10 && amountReturned != 15) { 42 43 throw new IllegalArgumentException(); 44 } 45 46 this.amountReturned = amountReturned; 47 this.balance = balance; 48 } 49 50 /** 51 * Returns the amount of money returned to the client, expressed in units 52 * of American pennies. 53 */ 54 public int getAmountReturned() { 55 return amountReturned; 56 } 57 58 /** 59 * Returns the current balance: the amount of money that has been 60 * inserted into the stamp dispenser, but not returned via a coin return 61 * or consumed in exchange for a dispensed stamp. For example, if the 62 * <code>balance</code> is zero and a nickel is added, the 63 * <code>balance</code> in the resulting stamp dispenser event will be 5. 64 * If another dime is added, the <code>balance</code> in the resulting 65 * stamp dispenser event will be 15. If the <code>returnCoins</code> 66 * method is then invoked on the stamp dispenser, the 67 * <code>balance</code> of the resulting stamp dispenser event will be 0. 68 */ 69 public int getBalance() { 70 return balance; 71 } 72 }
1 /*
2 * This source code (.java) file is Copyright (C) 2000 Artima Software, Inc.
3 * All rights reserved. This file accompanies the Jini Place Service Draft
4 * Specification, written by Bill Venners and published on the World Wide
5 * Web at:
6 *
7 * http://www.artima.com/jini/cyberspace/DraftSpec.html,
8 *
9 * This source file may not be copied, modified, or redistributed EXCEPT as
10 * allowed by the following statements: From August 11, 2000 through
11 * December 31, 2000, you may copy and/or modify these files to test and
12 * experiment with the Place API, described in the Jini Place Service Draft
13 * Specification. Any bug fixes must be given back to Artima Software, Inc.
14 * You may not redistribute this file or any binary (such as .class) files
15 * generated from this file. You may not distribute modified versions this
16 * files or any binary (such as .class) files generated from modified
17 * versions of this file. You may not remove this copyright notice. You may
18 * not use this file in printed media without the express permission of Bill
19 * Venners. And if that weren't enough, you must destroy all copies of this
20 * file, and any binary (such as .class) files generated from this file, by
21 * December 31, 2000.
22 *
23 * ARTIMA SOFTWARE, INC. MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE
24 * SUITABILITY OF THIS SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT
25 * NOT LIMITED TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR
26 * PARTICULAR PURPOSE, OR NON-INFRINGEMENT. BILL VENNERS SHALL NOT BE LIABLE
27 * FOR ANY DAMAGES SUFFERED BY A LICENSEE AS A RESULT OF USING, MODIFYING OR
28 * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.
29 */
30 package net.artima.place;
31
32 import java.io.Serializable;
33
34 /**
35 * Associates a <CODE>Link</CODE> to a <CODE>ResourceInfo</CODE>. Keeping the
36 * <CODE>ResourceInfo</CODE> outside of the <CODE>Link</CODE>, enables
37 * modifiable places to more easily change the <CODE>ResourceInfo</CODE> data
38 * for a particular <CODE>Link</CODE>.
39 *
40 * @author Bill Venners
41 */
42 public class LinkItem implements Serializable {
43
44 private Link link;
45 private ResourceInfo resourceInfo;
46
47 /**
48 * Constructs a <CODE>LinkItem</CODE> with passed <CODE>Link</CODE> and
49 * <CODE>ResourceInfo</CODE>.
50 *
51 * @param link The <code>Link</code> to hold in this
52 * <code>LinkItem</code>
53 * @param resourceInfo The <code>ResourceInfo</code> to hold in this
54 * <code>LinkItem</code>
55 * @throws NullPointerException if the <code>Link</code> or
56 * <code>ResourceInfo</code> reference passed to this constructor is
57 * <code>null</code>
58 */
59 public LinkItem(Link link, ResourceInfo resourceInfo) {
60
61 if (link == null || resourceInfo == null) {
62 throw new NullPointerException();
63 }
64
65 this.link = link;
66 this.resourceInfo = resourceInfo;
67 }
68
69 /**
70 * Returns the <CODE>Link</CODE> object that's stored in this
71 * <CODE>LinkItem</CODE>.
72 *
73 * @return the <code>Link</code> held in this <code>LinkItem</code>
74 */
75 public Link getLink() {
76 return link;
77 }
78
79 /**
80 * Returns the <CODE>ResourceInfo</CODE> object that's stored in this
81 * <CODE>LinkItem</CODE>. The <CODE>ResourceInfo</CODE> provides
82 * information, suitable for display to users, about the linked-to
83 * resource.
84 *
85 * @return the <code>ResourceInfo</code> held in this
86 * <code>LinkItem</code>
87 */
88 public ResourceInfo getResourceInfo() {
89 return resourceInfo;
90 }
91
92 /**
93 * Compares the specified <CODE>Object</CODE> with this
94 * <CODE>LinkItem</CODE> for equality. Two <code>LinkItem</code>s are
95 * semantically equal if their <code>Link</code>s are semantically equal
96 * and their <code>ResourceInfo</code>s are semantically equal.
97 */
98 public boolean equals(Object o) {
99
100 if (o == null || (o.getClass() != getClass())) {
101 return false;
102 }
103
104 // This can't fail because the class o is exactly LinkItem
,
105 // as was proven when (getClass() != o.getClass()) returned false
106 LinkItem li = (LinkItem) o;
107
108 // Both Link and ResourceInfo must be semantically equal
109 if (!link.equals(li.link) || !resourceInfo.equals(li.resourceInfo)) {
110 return false;
111 }
112
113 return true;
114 }
115
116 /**
117 * Returns the hash code value for this <CODE>LinkItem</CODE>. The
118 * hashcode for a <code>LinkItem</code> is the exclusive OR of the
119 * hashcodes for the <code>LinkItem</code>'s constituent
120 * <code>Link</code> and <code>ResourceInfo</code>.
121 */
122 public int hashCode() {
123
124 return link.hashCode() ^ resourceInfo.hashCode();
125 }
126 }
127
HAS_0
, HAS_5
, HAS_10
,
HAS_15
add5
, add10
, returnCoins
dispenseStamp
, ret5
,
ret10
, ret15
Current State | Message | Action | Next State |
HAS_0 | add5 | HAS_5 | |
HAS_0 | add10 | HAS_10 | |
HAS_0 | returnCoins | HAS_0 | |
HAS_5 | add5 | HAS_10 | |
HAS_5 | add10 | HAS_15 | |
HAS_5 | returnCoins | ret5 | HAS_0 |
HAS_10 | add5 | HAS_15 | |
HAS_10 | add10 | dispenseStamp | HAS_0 |
HAS_10 | returnCoins | ret10 | HAS_0 |
HAS_15 | add5 | dispenseStamp | HAS_0 |
HAS_15 | add10 | dispenseStamp,ret5 | HAS_0 |
HAS_15 | returnCoins | ret15 | HAS_0 |
Initial State: HAS_0 |
1 package com.artima.examples.stampdispenser.ex2; 2 3 import java.util.Set; 4 import java.util.Iterator; 5 import java.util.HashSet; 6 7 /** 8 * A stamp dispenser that accepts nickels and dimes and dispenses twenty cent 9 * stamps. 10 * 11 * @author Bill Venners 12 */ 13 public class StampDispenser { 14 15 private static final int HAS_0 = 0; 16 private static final int HAS_5 = 1; 17 private static final int HAS_10 = 2; 18 private static final int HAS_15 = 3; 19 20 private int currentState = HAS_0; 21 private Set listeners = new HashSet(); 22 23 /** 24 * Constructs a new stamp dispenser with a starting balance of zero. 25 */ 26 public StampDispenser() { 27 } 28 29 /** 30 * Adds the specified stamp dispenser listener to receive stamp dispenser 31 * events from this stamp dispenser. If <code>l</code> is 32 * <code>null</code>, no exception is thrown and no action is performed. 33 * If <code>l</code> is already registered as a listener, no action is 34 * performed. 35 */ 36 public synchronized void addStampDispenserListener( 37 StampDispenserListener l) { 38 39 listeners.add(l); 40 } 41 42 /** 43 * Removes the specified stamp dispenser listener so that it no longer 44 * receives stamp dispenser events from this stamp dispenser. This method 45 * performs no function, nor does it throw an exception, if the listener 46 * specified by the argument was not previously added to this component. 47 * If <code>l</code> is <code>null</code>, no exception is thrown and no 48 * action is performed. 49 */ 50 public synchronized void removeStampDispenserListener( 51 StampDispenserListener l) { 52 53 listeners.remove(l); 54 } 55 56 /** 57 * Add 5 cents to the stamp dispenser. If the amount added causes the 58 * current value to become or exceed 20 cents, the price of a stamp, the 59 * stamp will be automatically dispensed. 60 */ 61 public synchronized void add5() { 62 63 switch (currentState) { 64 65 case HAS_0: 66 StampDispenserEvent event = new StampDispenserEvent(this, 0, 5); 67 fireCoinAccepted(event, listeners); 68 currentState = HAS_5; 69 break; 70 71 case HAS_5: 72 event = new StampDispenserEvent(this, 0, 10); 73 fireCoinAccepted(event, listeners); 74 currentState = HAS_10; 75 break; 76 77 case HAS_10: 78 event = new StampDispenserEvent(this, 0, 15); 79 fireCoinAccepted(event, listeners); 80 currentState = HAS_15; 81 break; 82 83 case HAS_15: 84 85 event = new StampDispenserEvent(this, 0, 0); 86 fireStampDispensed(event, listeners); 87 currentState = HAS_0; 88 break; 89 } 90 } 91 92 /** 93 * Add 10 cents to the stamp dispenser. If the amount added causes the 94 * current value to become or exceed 20 cents, the price of a stamp, the 95 * stamp will be automatically dispensed. 96 */ 97 public synchronized void add10() { 98 99 switch (currentState) { 100 101 case HAS_0: 102 StampDispenserEvent event = new StampDispenserEvent(this, 103 0, 10); 104 fireCoinAccepted(event, listeners); 105 currentState = HAS_10; 106 break; 107 108 case HAS_5: 109 event = new StampDispenserEvent(this, 0, 15); 110 fireCoinAccepted(event, listeners); 111 currentState = HAS_15; 112 break; 113 114 case HAS_10: 115 event = new StampDispenserEvent(this, 0, 0); 116 fireStampDispensed(event, listeners); 117 currentState = HAS_0; 118 break; 119 120 case HAS_15: 121 122 event = new StampDispenserEvent(this, 5, 0); 123 fireStampDispensed(event, listeners); 124 currentState = HAS_0; 125 break; 126 } 127 } 128 129 /** 130 * Returns coins. If the balance is zero, no action is performed. 131 */ 132 public synchronized void returnCoins() { 133 134 switch (currentState) { 135 136 case HAS_0: 137 currentState = HAS_0; 138 break; 139 140 case HAS_5: 141 StampDispenserEvent event = new StampDispenserEvent(this, 5, 0); 142 fireCoinsReturned(event, listeners); 143 currentState = HAS_0; 144 break; 145 146 case HAS_10: 147 event = new StampDispenserEvent(this, 10, 0); 148 fireCoinsReturned(event, listeners); 149 currentState = HAS_0; 150 break; 151 152 case HAS_15: 153 154 event = new StampDispenserEvent(this, 15, 0); 155 fireCoinsReturned(event, listeners); 156 currentState = HAS_0; 157 break; 158 } 159 } 160 161 /** 162 * Helper method that fires coinAccepted events. 163 * 164 * @param event <code>StampDispenserEvent</code> to propagate 165 * @param listeners <code>Set</code> containing zero to many (and only) 166 * <code>StampDispenserListener</code>s 167 */ 168 private static void fireCoinAccepted(StampDispenserEvent event, 169 Set listeners) { 170 171 Iterator it = listeners.iterator(); 172 while (it.hasNext()) { 173 StampDispenserListener l = (StampDispenserListener) it.next(); 174 l.coinAccepted(event); 175 } 176 } 177 178 /** 179 * Helper method that fires stampDispensed events. 180 * 181 * @param event <code>StampDispenserEvent</code> to propagate 182 * @param listeners <code>Set</code> containing zero to many (and only) 183 * <code>StampDispenserListener</code>s 184 */ 185 private static void fireStampDispensed(StampDispenserEvent event, 186 Set listeners) { 187 188 Iterator it = listeners.iterator(); 189 while (it.hasNext()) { 190 StampDispenserListener l = (StampDispenserListener) it.next(); 191 l.stampDispensed(event); 192 } 193 } 194 195 /** 196 * Helper method that fires coinsReturned events. 197 * 198 * @param event <code>StampDispenserEvent</code> to propagate 199 * @param listeners <code>Set</code> containing zero to many (and only) 200 * <code>StampDispenserListener</code>s 201 */ 202 private static void fireCoinsReturned(StampDispenserEvent event, 203 Set listeners) { 204 205 Iterator it = listeners.iterator(); 206 while (it.hasNext()) { 207 StampDispenserListener l = (StampDispenserListener) it.next(); 208 l.coinsReturned(event); 209 } 210 } 211 }
1 package com.artima.examples.stampdispenser.ex3; 2 3 import java.util.Set; 4 import java.util.HashSet; 5 6 /** 7 * A stamp dispenser that accepts nickels and dimes and dispenses twenty cent 8 * stamps. 9 * 10 * @author Bill Venners 11 */ 12 public class StampDispenser { 13 14 private State currentState = Has0State.getState(); 15 private Set listeners = new HashSet(); 16 17 /** 18 * Constructs a new stamp dispenser with a starting balance of zero. 19 */ 20 public StampDispenser() { 21 } 22 23 /** 24 * Adds the specified stamp dispenser listener to receive stamp dispenser 25 * events from this stamp dispenser. If <code>l</code> is 26 * <code>null</code>, no exception is thrown and no action is performed. 27 * If <code>l</code> is already registered as a listener, no action is 28 * performed. 29 */ 30 public synchronized void addStampDispenserListener( 31 StampDispenserListener l) { 32 33 listeners.add(l); 34 } 35 36 /** 37 * Removes the specified stamp dispenser listener so that it no longer 38 * receives stamp dispenser events from this stamp dispenser. This method 39 * performs no function, nor does it throw an exception, if the listener 40 * specified by the argument was not previously added to this component. 41 * If <code>l</code> is <code>null</code>, no exception is thrown and no 42 * action is performed. 43 */ 44 public synchronized void removeStampDispenserListener( 45 StampDispenserListener l) { 46 47 listeners.remove(l); 48 } 49 50 /** 51 * Add 5 cents to the stamp dispenser. If the amount added causes the 52 * current value to become or exceed 20 cents, the price of a stamp, the 53 * stamp will be automatically dispensed. 54 */ 55 public void add5() { 56 57 currentState = currentState.add5(this, listeners); 58 } 59 60 /** 61 * Add 10 cents to the stamp dispenser. If the amount added causes the 62 * current value to become or exceed 20 cents, the price of a stamp, the 63 * stamp will be automatically dispensed. 64 */ 65 public void add10() { 66 67 currentState = currentState.add10(this, listeners); 68 } 69 70 /** 71 * Returns coins. If the balance is zero, no action is performed. 72 */ 73 public void returnCoins() { 74 75 currentState = currentState.returnCoins(this, listeners); 76 } 77 } 1 package com.artima.examples.stampdispenser.ex3; 2 3 import java.util.Iterator; 4 import java.util.Set; 5 6 /** 7 * Abstract superclass for all stamp dispenser state classes. 8 * 9 * The state machine that embodies the behavior of the stamp dispenser (which 10 * determines the behavior of the <CODE>State</code> subclasses) is described 11 * in this <a href="../../../../../statemachine.html">state transition 12 * table</a>. 13 * 14 * @author Bill Venners 15 */ 16 abstract class State { 17 18 /** 19 * Performs actions appropriate for the state represented by the class of 20 * this object for the add5 message. Returns a reference to the state 21 * object that represents the next state to transition to as a result of 22 * the arrival of this add5 message. 23 * 24 * @param stampDispenser the <code>StampDispenser</code> whose state this 25 * object represents 26 * @param listeners <code>Set</code> containing zero to many (and only) 27 * <code>StampDispenserListener</code>s 28 */ 29 abstract State add5(StampDispenser stampDispenser, Set listeners); 30 31 /** 32 * Performs actions appropriate for the state represented by the class of 33 * this object for the add10 message. Returns a reference to the state 34 * object that represents the next state to transition to as a result of 35 * the arrival of this add10 message. 36 * 37 * @param stampDispenser the <code>StampDispenser</code> whose state this 38 * object represents 39 * @param listeners <code>Set</code> containing zero to many (and only) 40 * <code>StampDispenserListener</code>s 41 */ 42 abstract State add10(StampDispenser stampDispenser, Set listeners); 43 44 /** 45 * Performs actions appropriate for the state represented by the class of 46 * this object for the returnCoins message. Returns a reference to the 47 * state object that represents the next state to transition to as a 48 * result of the arrival of this returnCoins message. 49 * 50 * @param stampDispenser the <code>StampDispenser</code> whose state this 51 * object represents 52 * @param listeners <code>Set</code> containing zero to many (and only) 53 * <code>StampDispenserListener</code>s 54 */ 55 abstract State returnCoins(StampDispenser stampDispenser, 56 Set listeners); 57 58 /** 59 * Helper method that fires coinAccepted events. 60 * 61 * @param event <code>StampDispenserEvent</code> to propagate 62 * @param listeners <code>Set</code> containing zero to many (and only) 63 * <code>StampDispenserListener</code>s 64 */ 65 static void fireCoinAccepted(StampDispenserEvent event, Set listeners) { 66 67 Iterator it = listeners.iterator(); 68 while (it.hasNext()) { 69 StampDispenserListener l = (StampDispenserListener) it.next(); 70 l.coinAccepted(event); 71 } 72 } 73 74 /** 75 * Helper method that fires stampDispensed events. 76 * 77 * @param event <code>StampDispenserEvent</code> to propagate 78 * @param listeners <code>Set</code> containing zero to many (and only) 79 * <code>StampDispenserListener</code>s 80 */ 81 static void fireStampDispensed(StampDispenserEvent event, 82 Set listeners) { 83 84 Iterator it = listeners.iterator(); 85 while (it.hasNext()) { 86 StampDispenserListener l = (StampDispenserListener) it.next(); 87 l.stampDispensed(event); 88 } 89 } 90 91 /** 92 * Helper method that fires coinsReturned events. 93 * 94 * @param event <code>StampDispenserEvent</code> to propagate 95 * @param listeners <code>Set</code> containing zero to many (and only) 96 * <code>StampDispenserListener</code>s 97 */ 98 static void fireCoinsReturned(StampDispenserEvent event, 99 Set listeners) { 100 101 Iterator it = listeners.iterator(); 102 while (it.hasNext()) { 103 StampDispenserListener l = (StampDispenserListener) it.next(); 104 l.coinsReturned(event); 105 } 106 } 107 } 1 package com.artima.examples.stampdispenser.ex3; 2 3 import java.util.Set; 4 5 /** 6 * <code>State</code> subclass that represents the <em>Has0</em> stamp 7 * dispenser state. See the documentation for class <code>State</code> for a 8 * state transition table that specifies the required behavior of instances 9 * of this class. 10 * 11 * @author Bill Venners 12 */ 13 class Has0State extends State { 14 15 /** 16 * The single instance of <code>Has0State</code> 17 */ 18 private static Has0State singleton = new Has0State(); 19 20 /** 21 * Constructs a <code>Has0State</code> instance. This constructor is 22 * private to enable this class to restrict the number of instances of 23 * <code>Has0State</code> to one. I.e., <code>Has0State</code> is a 24 * singleton. 25 */ 26 private Has0State() { 27 } 28 29 /** 30 * Factory method that returns the single instance of 31 * <code>Has0State</code>. 32 */ 33 static State getState() { 34 return singleton; 35 } 36 37 /** 38 * Performs actions appropriate for the state represented by the class of 39 * this object for the add5 message. Returns a reference to the state 40 * object that represents the next state to transition to as a result of 41 * the arrival of this add5 message. 42 * 43 * @param stampDispenser the <code>StampDispenser</code> whose state this 44 * object represents 45 * @param listeners <code>Set</code> containing zero to many (and only) 46 * <code>StampDispenserListener</code>s 47 */ 48 State add5(StampDispenser stampDispenser, Set listeners) { 49 50 StampDispenserEvent event = new StampDispenserEvent(stampDispenser, 51 0, 5); 52 fireCoinAccepted(event, listeners); 53 return Has5State.getState(); 54 } 55 56 /** 57 * Performs actions appropriate for the state represented by the class of 58 * this object for the add10 message. Returns a reference to the state 59 * object that represents the next state to transition to as a result of 60 * the arrival of this add10 message. 61 * 62 * @param stampDispenser the <code>StampDispenser</code> whose state this 63 * object represents 64 * @param listeners <code>Set</code> containing zero to many (and only) 65 * <code>StampDispenserListener</code>s 66 */ 67 State add10(StampDispenser stampDispenser, Set listeners) { 68 69 StampDispenserEvent event = new StampDispenserEvent(stampDispenser, 70 0, 10); 71 fireCoinAccepted(event, listeners); 72 return Has10State.getState(); 73 } 74 75 /** 76 * Performs actions appropriate for the state represented by the class of 77 * this object for the returnCoins message. Returns a reference to the 78 * state object that represents the next state to transition to as a 79 * result of the arrival of this returnCoins message. 80 * 81 * @param stampDispenser the <code>StampDispenser</code> whose state this 82 * object represents 83 * @param listeners <code>Set</code> containing zero to many (and only) 84 * <code>StampDispenserListener</code>s 85 */ 86 State returnCoins(StampDispenser stampDispenser, Set listeners) { 87 return this; 88 } 89 } 1 package com.artima.examples.stampdispenser.ex3; 2 3 import java.util.Set; 4 5 /** 6 * <code>State</code> subclass that represents the <em>Has5</em> stamp 7 * dispenser state. See the documentation for class <code>State</code> for a 8 * state transition table that specifies the required behavior of instances 9 * of this class. 10 * 11 * @author Bill Venners 12 */ 13 class Has5State extends State { 14 15 /** 16 * The single instance of <code>Has5State</code> 17 */ 18 private static Has5State singleton = new Has5State(); 19 20 /** 21 * Constructs a <code>Has5State</code> instance. This constructor is 22 * private to enable this class to restrict the number of instances of 23 * <code>Has5State</code> to one. I.e., <code>Has5State</code> is a 24 * singleton. 25 */ 26 private Has5State() { 27 } 28 29 /** 30 * Factory method that returns the single instance of 31 * <code>Has5State</code>. 32 */ 33 static State getState() { 34 return singleton; 35 } 36 37 /** 38 * Performs actions appropriate for the state represented by the class of 39 * this object for the add5 message. Returns a reference to the state 40 * object that represents the next state to transition to as a result of 41 * the arrival of this add5 message. 42 * 43 * @param stampDispenser the <code>StampDispenser</code> whose state this 44 * object represents 45 * @param listeners <code>Set</code> containing zero to many (and only) 46 * <code>StampDispenserListener</code>s 47 */ 48 State add5(StampDispenser stampDispenser, Set listeners) { 49 50 StampDispenserEvent event = new StampDispenserEvent(stampDispenser, 51 0, 10); 52 fireCoinAccepted(event, listeners); 53 return Has10State.getState(); 54 } 55 56 /** 57 * Performs actions appropriate for the state represented by the class of 58 * this object for the add10 message. Returns a reference to the state 59 * object that represents the next state to transition to as a result of 60 * the arrival of this add10 message. 61 * 62 * @param stampDispenser the <code>StampDispenser</code> whose state this 63 * object represents 64 * @param listeners <code>Set</code> containing zero to many (and only) 65 * <code>StampDispenserListener</code>s 66 */ 67 State add10(StampDispenser stampDispenser, Set listeners) { 68 69 StampDispenserEvent event = new StampDispenserEvent(stampDispenser, 70 0, 15); 71 fireCoinAccepted(event, listeners); 72 return Has15State.getState(); 73 } 74 75 /** 76 * Performs actions appropriate for the state represented by the class of 77 * this object for the returnCoins message. Returns a reference to the 78 * state object that represents the next state to transition to as a 79 * result of the arrival of this returnCoins message. 80 * 81 * @param stampDispenser the <code>StampDispenser</code> whose state this 82 * object represents 83 * @param listeners <code>Set</code> containing zero to many (and only) 84 * <code>StampDispenserListener</code>s 85 */ 86 State returnCoins(StampDispenser stampDispenser, Set listeners) { 87 88 StampDispenserEvent event = new StampDispenserEvent(stampDispenser, 89 5, 0); 90 fireCoinsReturned(event, listeners); 91 return Has0State.getState(); 92 } 93 } 1 package com.artima.examples.stampdispenser.ex3; 2 3 import java.util.Set; 4 5 /** 6 * <code>State</code> subclass that represents the <em>Has10</em> stamp 7 * dispenser state. See the documentation for class <code>State</code> for a 8 * state transition table that specifies the required behavior of instances 9 * of this class. 10 * 11 * @author Bill Venners 12 */ 13 class Has10State extends State { 14 15 /** 16 * The single instance of <code>Has10State</code> 17 */ 18 private static Has10State singleton = new Has10State(); 19 20 /** 21 * Constructs a <code>Has10State</code> instance. This constructor is 22 * private to enable this class to restrict the number of instances of 23 * <code>Has10State</code> to one. I.e., <code>Has10State</code> is a 24 * singleton. 25 */ 26 private Has10State() { 27 } 28 29 /** 30 * Factory method that returns the single instance of 31 * <code>Has10State</code>. 32 */ 33 static State getState() { 34 return singleton; 35 } 36 37 /** 38 * Performs actions appropriate for the state represented by the class of 39 * this object for the add5 message. Returns a reference to the state 40 * object that represents the next state to transition to as a result of 41 * the arrival of this add5 message. 42 * 43 * @param stampDispenser the <code>StampDispenser</code> whose state this 44 * object represents 45 * @param listeners <code>Set</code> containing zero to many (and only) 46 * <code>StampDispenserListener</code>s 47 */ 48 State add5(StampDispenser stampDispenser, Set listeners) { 49 50 StampDispenserEvent event = new StampDispenserEvent(stampDispenser, 0, 15); 51 fireCoinAccepted(event, listeners); 52 return Has15State.getState(); 53 } 54 55 /** 56 * Performs actions appropriate for the state represented by the class of 57 * this object for the add10 message. Returns a reference to the state 58 * object that represents the next state to transition to as a result of 59 * the arrival of this add10 message. 60 * 61 * @param stampDispenser the <code>StampDispenser</code> whose state this 62 * object represents 63 * @param listeners <code>Set</code> containing zero to many (and only) 64 * <code>StampDispenserListener</code>s 65 */ 66 State add10(StampDispenser stampDispenser, Set listeners) { 67 68 StampDispenserEvent event = new StampDispenserEvent(stampDispenser, 69 0, 0); 70 fireStampDispensed(event, listeners); 71 return Has0State.getState(); 72 } 73 74 /** 75 * Performs actions appropriate for the state represented by the class of 76 * this object for the returnCoins message. Returns a reference to the 77 * state object that represents the next state to transition to as a 78 * result of the arrival of this returnCoins message. 79 * 80 * @param stampDispenser the <code>StampDispenser</code> whose state this 81 * object represents 82 * @param listeners <code>Set</code> containing zero to many (and only) 83 * <code>StampDispenserListener</code>s 84 */ 85 State returnCoins(StampDispenser stampDispenser, Set listeners) { 86 87 StampDispenserEvent event = new StampDispenserEvent(stampDispenser, 88 10, 0); 89 fireCoinsReturned(event, listeners); 90 return Has0State.getState(); 91 } 92 } 1 package com.artima.examples.stampdispenser.ex3; 2 3 import java.util.Set; 4 5 /** 6 * <code>State</code> subclass that represents the <em>Has15</em> stamp 7 * dispenser state. See the documentation for class <code>State</code> for a 8 * state transition table that specifies the required behavior of instances 9 * of this class. 10 * 11 * @author Bill Venners 12 */ 13 class Has15State extends State { 14 15 /** 16 * The single instance of <code>Has15State</code> 17 */ 18 private static Has15State singleton = new Has15State(); 19 20 /** 21 * Constructs a <code>Has15State</code> instance. This constructor is 22 * private to enable this class to restrict the number of instances of 23 * <code>Has15State</code> to one. I.e., <code>Has15State</code> is a 24 * singleton. 25 */ 26 private Has15State() { 27 } 28 29 /** 30 * Factory method that returns the single instance of 31 * <code>Has15State</code>. 32 */ 33 static State getState() { 34 return singleton; 35 } 36 37 /** 38 * Performs actions appropriate for the state represented by the class of 39 * this object for the add5 message. Returns a reference to the state 40 * object that represents the next state to transition to as a result of 41 * the arrival of this add5 message. 42 * 43 * @param stampDispenser the <code>StampDispenser</code> whose state this 44 * object represents 45 * @param listeners <code>Set</code> containing zero to many (and only) 46 * <code>StampDispenserListener</code>s 47 */ 48 State add5(StampDispenser stampDispenser, Set listeners) { 49 50 StampDispenserEvent event = new StampDispenserEvent(stampDispenser, 51 0, 0); 52 fireStampDispensed(event, listeners); 53 return Has0State.getState(); 54 } 55 56 /** 57 * Performs actions appropriate for the state represented by the class of 58 * this object for the add10 message. Returns a reference to the state 59 * object that represents the next state to transition to as a result of 60 * the arrival of this add10 message. 61 * 62 * @param stampDispenser the <code>StampDispenser</code> whose state this 63 * object represents 64 * @param listeners <code>Set</code> containing zero to many (and only) 65 * <code>StampDispenserListener</code>s 66 */ 67 State add10(StampDispenser stampDispenser, Set listeners) { 68 69 StampDispenserEvent event = new StampDispenserEvent(stampDispenser, 70 5, 0); 71 fireStampDispensed(event, listeners); 72 return Has0State.getState(); 73 } 74 75 /** 76 * Performs actions appropriate for the state represented by the class of 77 * this object for the returnCoins message. Returns a reference to the 78 * state object that represents the next state to transition to as a 79 * result of the arrival of this returnCoins message. 80 * 81 * @param stampDispenser the <code>StampDispenser</code> whose state this 82 * object represents 83 * @param listeners <code>Set</code> containing zero to many (and only) 84 * <code>StampDispenserListener</code>s 85 */ 86 State returnCoins(StampDispenser stampDispenser, Set listeners) { 87 88 StampDispenserEvent event = new StampDispenserEvent(stampDispenser, 89 15, 0); 90 fireCoinsReturned(event, listeners); 91 return Has0State.getState(); 92 } 93 }
StampDispenser
Has0State
has no state
1 package com.artima.examples.stampdispenser.ex3; 2 3 import java.util.Set; 4 5 /** 6 * <code>State</code> subclass that represents the <em>Has0</em> stamp 7 * dispenser state. See the documentation for class <code>State</code> for a 8 * state transition table that specifies the required behavior of instances 9 * of this class. 10 * 11 * @author Bill Venners 12 */ 13 class Has0State extends State { 14 15 /** 16 * The single instance of <code>Has0State</code> 17 */ 18 private static Has0State singleton = new Has0State(); 19 20 /** 21 * Constructs a <code>Has0State</code> instance. This constructor is 22 * private to enable this class to restrict the number of instances of 23 * <code>Has0State</code> to one. I.e., <code>Has0State</code> is a 24 * singleton. 25 */ 26 private Has0State() { 27 } 28 29 /** 30 * Factory method that returns the single instance of 31 * <code>Has0State</code>. 32 */ 33 static State getState() { 34 return singleton; 35 } 36 37 /** 38 * Performs actions appropriate for the state represented by the class of 39 * this object for the add5 message. Returns a reference to the state 40 * object that represents the next state to transition to as a result of 41 * the arrival of this add5 message. 42 * 43 * @param stampDispenser the <code>StampDispenser</code> whose state this 44 * object represents 45 * @param listeners <code>Set</code> containing zero to many (and only) 46 * <code>StampDispenserListener</code>s 47 */ 48 State add5(StampDispenser stampDispenser, Set listeners) { 49 50 StampDispenserEvent event = new StampDispenserEvent(stampDispenser, 51 0, 5); 52 fireCoinAccepted(event, listeners); 53 return Has5State.getState(); 54 } 55 56 /** 57 * Performs actions appropriate for the state represented by the class of 58 * this object for the add10 message. Returns a reference to the state 59 * object that represents the next state to transition to as a result of 60 * the arrival of this add10 message. 61 * 62 * @param stampDispenser the <code>StampDispenser</code> whose state this 63 * object represents 64 * @param listeners <code>Set</code> containing zero to many (and only) 65 * <code>StampDispenserListener</code>s 66 */ 67 State add10(StampDispenser stampDispenser, Set listeners) { 68 69 StampDispenserEvent event = new StampDispenserEvent(stampDispenser, 70 0, 10); 71 fireCoinAccepted(event, listeners); 72 return Has10State.getState(); 73 } 74 75 /** 76 * Performs actions appropriate for the state represented by the class of 77 * this object for the returnCoins message. Returns a reference to the 78 * state object that represents the next state to transition to as a 79 * result of the arrival of this returnCoins message. 80 * 81 * @param stampDispenser the <code>StampDispenser</code> whose state this 82 * object represents 83 * @param listeners <code>Set</code> containing zero to many (and only) 84 * <code>StampDispenserListener</code>s 85 */ 86 State returnCoins(StampDispenser stampDispenser, Set listeners) { 87 return this; 88 } 89 }
ComplexNumber
Object1 package com.artima.examples.complexnum.ex1; 2 3 /** 4 * Represents a complex number whose real and imaginary components are 5 * <CODE>double</CODE>s. 6 * 7 * @author Bill Venners 8 */ 9 public class ComplexNumber { 10 11 private double real; 12 private double imaginary; 13 14 /** 15 * Construct a new <code>ComplexNumber</code> with the passed real and 16 * imaginary components. 17 * 18 * @param real the real component of this <code>ComplexNumber</code> 19 * @param imaginary the imaginary component of this 20 * <code>ComplexNumber</code> 21 */ 22 public ComplexNumber(double real, double imaginary) { 23 24 this.real = real; 25 this.imaginary = imaginary; 26 } 27 28 /** 29 * Returns the real component of this <code>ComplexNumber</code>. 30 * 31 * @return the real component of this <code>ComplexNumber</code> 32 */ 33 public double getReal() { 34 return real; 35 } 36 37 /** 38 * Returns the imaginary component of this <code>ComplexNumber</code>. 39 * 40 * @return the imaginary component of this <code>ComplexNumber</code> 41 */ 42 public double getImaginary() { 43 return real; 44 } 45 46 /** 47 * Returns the conjugate of this complex number. The conjugate of complex 48 * number a + <em>i</em>b is a - <em>i</em>b. 49 * 50 * @return the conjugate of this <code>ComplexNumber</code> 51 */ 52 public ComplexNumber getConjugate() { 53 54 return new ComplexNumber(real, -imaginary); 55 } 56 57 /** 58 * Compares the passed <CODE>ComplexNumber</CODE> to this 59 * <code>ComplexNumber</code> for equality. Two 60 * <code>ComplexNumber</code> objects are semantically equal if their 61 * real components are equal and their imaginary components are equal. 62 * 63 * @param An object to compare to this <code>ComplexNumber</code> 64 * @return <code>true</code> if this <code>ComplexNumber</code> is 65 * semantically equal to the passed <code>ComplexNumber</code> 66 */ 67 public boolean equals(Object o) { 68 69 if ((o == null) || (getClass() != o.getClass())) { 70 return false; 71 } 72 73 // This can't fail because the class of o is exactly ComplexNumber, 74 // as was proven when (getClass() != o.getClass()) returned false 75 ComplexNumber cn = (ComplexNumber) o; 76 77 // Because this class extends Object, don't call super.equals() 78 79 // To be semantically equal, the complex numbers must have equal 80 // real and imaginary components 81 if ((real != cn.real) || (imaginary != cn.imaginary)) { 82 return false; 83 } 84 85 return true; 86 } 87 88 /** 89 * Computes the hash code for this <code>ComplexNumber</code>. 90 * 91 * @return a hashcode value for this <code>ComplexNumber</code> 92 */ 93 public int hashcode() { 94 95 // Got this idea from Double's hashcode method. 96 long re = Double.doubleToLongBits(real); 97 long im = Double.doubleToLongBits(imaginary); 98 99 int rex = (int) (re ^ (re >>> 32)); 100 int imx = (int) (im ^ (im >>> 32)); 101 102 return rex ^ imx; 103 } 104 105 /** 106 * Adds the passed <code>ComplexNumber</code> to this one. The sum of two 107 * complex numbers a + <em>i</em>b and c + <em>i</em>d is (a + c) + 108 * <em>i</em>(c + d). 109 * 110 * @param addend the <code>ComplexNumber</code> to add to this one 111 * @returns the sum of this and the passed <code>ComplexNumber</code> 112 */ 113 public ComplexNumber add(ComplexNumber addend) { 114 115 return new ComplexNumber(real + addend.real, 116 imaginary + addend.imaginary); 117 } 118 119 /** 120 * Subtracts the passed <code>ComplexNumber</code> from this one. The 121 * difference between two complex numbers, a + <em>i</em>b - c + 122 * <em>i</em>d, is (a - c) + <em>i</em>(b - d). 123 * 124 * @param subtrahend the <code>ComplexNumber</code> to subtract from this 125 * <code>ComplexNumber</code> 126 * @return the difference of this and the passed 127 * <code>ComplexNumber</code>s 128 */ 129 public ComplexNumber subtract(ComplexNumber subtrahend) { 130 131 return new ComplexNumber(real - subtrahend.real, 132 imaginary - subtrahend.imaginary); 133 } 134 135 /** 136 * Multiplies this <code>ComplexNumber</code> (the multiplicand) with the 137 * passed <code>ComplexNumber</code> (multiplier). The product of two 138 * complex numbers a + <em>i</em>b and c + <em>i</em>d is (ac - bd) + 139 * <em>i</em>(bc + ad). 140 * 141 * @param multiplier the <code>ComplexNumber</code> with which to 142 * multiply this <code>ComplexNumber</code> 143 * @return the product of this and the passed 144 * <code>ComplexNumber</code> 145 */ 146 public ComplexNumber multiply(ComplexNumber multiplier) { 147 148 double prodReal = (real * multiplier.real) 149 - (imaginary * multiplier.imaginary); 150 double prodImaginary = (imaginary * multiplier.real) 151 + (real * multiplier.imaginary); 152 153 return new ComplexNumber(prodReal, prodImaginary); 154 } 155 156 /** 157 * Divides this <code>ComplexNumber</code> (the numerator) by the passed 158 * <code>ComplexNumber</code> (denominator). The quotient of two complex 159 * numbers a + <em>i</em>b / c + <em>i</em>d is ((ac + bd) + 160 * <em>i</em>(bc - ad)) / (c*c + d*d). 161 * 162 * @param denominator the <code>ComplexNumber</code> by which to divide 163 * this <code>ComplexNumber</code> 164 * @return the quotient of this divided by the passed 165 * <code>ComplexNumber</code>s 166 */ 167 public ComplexNumber divide(ComplexNumber denominator) { 168 169 // Perform division by first multiplying both the numerator and 170 // denominator by the conjugate of the denominator. 171 ComplexNumber conj = denominator.getConjugate(); 172 ComplexNumber tempNumerator = multiply(conj); 173 ComplexNumber tempDenominator = denominator.multiply(conj); 174 175 // By multiplying the denominator by its conjugate, its imaginary 176 // component drops to zero. Can then just divide the real and 177 // imaginary components of the numerator by the denominator's real 178 // value. 179 return new ComplexNumber(tempNumerator.real / tempDenominator.real, 180 tempNumerator.imaginary / tempDenominator.real); 181 } 182 }
int
, float
, ...
ComplexNumber
, a Matrix
,
or a Bitmap
?