Post on 16-Mar-2016
description
Puzzle 3
1
Write the class Enigma, which extends Object, so that the following program prints false:
public class Conundrum { public static void main(String[] args) { Enigma e = new Enigma(); System.out.println( e.equals(e) ); } }
You must not override Object.equals() [Java Puzzlers by Joshua Block and Neal Gaffer]
Solution
2
the puzzle does not allow you to override equals() but it says nothing about overloading
public class Enigma { public boolean equals(Enigma other) { return false; } }
Equality of Instances of Different Types
3
our implementation of equals() is correct in that it obeys the equals() contract however, it returns true if and only if two objects
have the exact same type because we used getClass()
Goals for Today
4
implication of getClass() in equals() implement a simple mutable vector class
delegating to accessor and mutator methods constructor chaining
Implication of Same Type Equality
5
suppose PhoneNumber was not declared final we might consider extending PhoneNumber to
keep track of the total number of phone numbers created
public class CountedPhoneNumber extends PhoneNumber { private static final AtomicInteger counter = new AtomicInteger();
// constructor and equals not shown
public int numberCreated() { return counter.get(); }} // adapted from Effective Java (Item 8)
6
our implementation of equals() says that a PhoneNumber is never equal to a CountedPhoneNumber because they have different types
// client code somewherePhoneNumber x = new PhoneNumber(416, 736, 2100);
CountedPhoneNumber y = new CountedPhoneNumber(416, 736, 2100);
System.out.println( x.equals(y) ); // falseSystem.out.println( y.equals(x) ); // false
7
classes that use equals() might not work the way you want them to for example, HashSet uses equals() to organize the
way it stores objects
// client code somewherePhoneNumber x = new PhoneNumber(416, 736, 2100);
CountedPhoneNumber y = new CountedPhoneNumber(416, 736, 2100);
HashSet<PhoneNumber> h = new HashSet<PhoneNumber>();h.add(y);System.out.println( h.contains(x) ); // false
Substituting Types
8
it would be nice if a client could write methods that expect a PhoneNumber but work as expected when given a CountedPhoneNumber after all, a CountedPhoneNumber is a kind of PhoneNumber we can as long as we don't use equals()
the ability to substitute a subtype (CountedPhoneNumber) for a supertype (PhoneNumber) in client code without changing the behaviour of the client code is related to the Liskov Substitution Principle
Liskov Substitution Principle
9
often cited as a fundamental principle of object-oriented design (but this is fiercely debated) Let (x) be a property provable about objects x of
type T. Then (y) should be true for objects y of type S where S is a subtype of T.
observe that by using getClass() we never get equality (provable property) between PhoneNumber objects (objects of type T) and CountedPhoneNumber objects (objects of type S)
[don't get hung up on this slide; it's beyond the scope of this course]
10
use getClass() when implementing equals() in this course it will satisfy the equals() contract but be aware of its limitation
if you need equality between different types: http://www.angelikalanger.com/Articles/JavaSolutions/SecretsOfEquals/Equals.html http://www.angelikalanger.com/Articles/JavaSolutions/SecretsOfEquals/Equals-2.html
Mutable Classes
11
Mutable Classes
12
a mutable class can change how its state appears to clients recall that immutable classes are generally easier
to implement and use so why would we want a mutable class?
because you need a separate immutable object for every value you need to represent
we will implement a simple class that represents 2-dimensional mathematical vectors
What Can Mathematical Vectors Do?
13
add subtract multiply by scalar set components get components construct equals toString
Vector2d- x: double
- y: double
- name: String
+ Vector2d(): Vector2d
+ Vector2d(double, double): Vector2d
+ Vector2d(String, double, double): Vector2d
+ Vector2d(Vector2d): Vector2d
+ add(Vector2d): void
+ equals(Object): boolean
+ getX(): double
+ getY(): double
+ length(): double
+ multiply(double): void
...
equals()
14
@Override public boolean equals(Object obj) { boolean eq = false; if (obj == this) { eq = true; }
return eq;}
15
@Override public boolean equals(Object obj) { boolean eq = false; if (obj == this) { eq = true; } else if (obj != null && this.getClass() == obj.getClass()) {
} return eq;
}
16
@Override public boolean equals(Object obj) { boolean eq = false; if (obj == this) { eq = true; } else if (obj != null && this.getClass() == obj.getClass()) { Vector2d v = (Vector2d) obj;
} return eq;}
17
@Override public boolean equals(Object obj) { boolean eq = false; if (obj == this) { eq = true; } else if (obj != null && this.getClass() == obj.getClass()) { Vector2d v = (Vector2d) obj; if (this.getName() == null && v.getName() != null) { eq = false; }
} return eq;}
18
@Override public boolean equals(Object obj) { boolean eq = false; if (obj == this) { eq = true; } else if (obj != null && this.getClass() == obj.getClass()) { Vector2d v = (Vector2d) obj; if (this.getName() == null && v.getName() != null) { eq = false; } else { eq = this.getName().equals( v.getName() ) && Double.compare( this.getX(), v.getX() ) == 0 && Double.compare( this.getY(), v.getY() ) == 0; } } return eq;}
Observe That...
19
instead of directly using the attributes, we use accessor methods where possible this reduces code duplication, especially if accessing
an attribute requires a lot of code this gives us the possibility to change the
representation of the attributes in the future as long as we update the accessor methods (but we would
have to do that anyway to preserve the API) for example, instead of two attributes x and y, we
might want to use an array or some sort of Container
the notes [notes 2.3.1] call this delegating to accessors
setX(), setY(), and set()
20
public void setX(double x){ this.x = x; }
public void setY(double y){ this.y = y; }
public void set(double x, double y){ this.x = x; this.y = y; this.setX(x); this.setY(y);}
public void set(String name, double x, double y){ this.name = name; this.x = x; this.y = y; this.name = name; this.set(x, y);}
delegate to mutator
delegate to mutator
Observe That...
21
instead of directly modifying the attributes, we use mutator methods where possible this reduces code duplication, especially if modifying
an attribute requires a lot of code this gives us the possibility to change the
representation of the attributes in the future as long as we update the mutator methods (but we would
have to do that anyway to preserve the API) for example, instead of two attributes x and y, we
might want to use an array or some sort of Container
the notes [notes 2.3.1] call this delegating to mutators
Constructors
22
public Vector2d(String name, double x, double y) { this.name = name; this.x = x; this.y = y; this.set(name, x, y);}
public Vector2d(Vector2d v) { this.name = v.name; this.x = v.x; this.y = v.y; this(v.getName(), v.getX(), v.getY());}
delegate to mutator
delegate to constructor and accessors
More Constructors
23
public Vector2d(double x, double y){ this(null, x, y);}
public Vector2d(){ this(null, 0.0, 0.0);}
good, delegate to constructor
good, delegate to constructor
Observe That...
24
all of the simpler constructors do nothing except call the most general constructor again, this reduces code duplication notes [notes 2.3.1] call this constructor chaining
the most general constructor calls a mutator again, this reduces code duplication
Things to Think About
25
how do you implement Vector2d using an array to store the coordinates?
how do you implement Vector2d using a Container to store the coordinates?
how do you implement VectorNd, an N-dimensional vector?