Exercise Move the declaration of
equals
to class
BParticle
, changing the code as needed. What now is the value of
c1.equals(b1)
? Explain.
Clone
Concept Assigning a variable containing a reference to another
of the same type merely copies thereference so that two fields refer to the same object. The method
clone
is used to copy the content of an object into a new one.
clone
is defined in class
Object
and can be
overridden in any class definition.
Program: Inheritance08.java
// Learning Object Inheritance08
// cloneclass Particle implements Cloneable {
int position;
Particle(int p) { position = p;
}
void newPosition(int delta) { position = position + delta;
}
protected Object clone() { try {
Particle p = (Particle) super.clone(); p.newPosition(10);
return p; }
catch (CloneNotSupportedException e) { e.printStackTrace();
throw new Error(); }
}}
class Inheritance08 {
public static void main(String[] args) {
Particle p1 = new Particle(20); Particle p2 = p1;
p1.newPosition(10); System.out.println(p1.position);
System.out.println(p2.position);
Particle p3 = (Particle) p1.clone(); System.out.println(p1.position);
System.out.println(p3.position);
p3.newPosition(10); System.out.println(p1.position);
System.out.println(p3.position); }
}
clone
is overridden in class
Particle
.
The class must implement the interface
Cloneable
, the
method of the superclass should be called, and we have to take intoaccount that the method might raise an exception. The method returns
the object returned by superclass method after calling
newPosition
.
- An object of class
Particle
is allocated and its reference assigned to the fieldp1
. - An assignment statement copies this reference to the field
p2
. Check that they have the same value. - The method
newPosition
is called onp1
, but the value ofp2.position
is also changed, showing that the two fields point to the same object. - An object of class
Particle
is obtained by callingp1.clone()
and its reference assigned to the fieldp3
. Sinceclone
returns a value of typeObject
, it must be cast to typeParticle
before the assignment. Check that the objects referenced byp1
andp3
have different values. - Calling
p3.newPosition
changes only the field in the object referenced byp3
and not the separate object referenced byp1
.
Exercise The method
clone
can perform arbitrary
computation. Modify the program so that new objects are initialized withthe absolute value of the field of the object that is being cloned.
Overloading vs. overriding
Concept Overloading is the use of the same method name with a different parameter signature. Overriding is the use in a subclass of the same method name with the same parameter signature as a method of the superclass.
Program: Inheritance09.java
// Learning Object Inheritance09
// overloading vs. overridingclass Particle {
int position;
Particle(int p) { position = p;
}
void newPosition(int delta) { position = position + delta;
}}
class AParticle extends Particle {
double spin;
AParticle(int p, double s) { super(p);
spin = s; }
void newPosition(int delta) {
if (spin < delta)
position = position + delta; }
void newPosition(double delta) {
if (position < delta)
spin = spin + delta; }
}
class Inheritance09 { public static void main(/*String[] args*/) { Particle p = new Particle(10);
AParticle a1 = new AParticle(20, -1.0); AParticle a2 = new AParticle(20, -1.0);
p.newPosition(10);
int pPosition = p.position; a1.newPosition(10);
int a1Position = a1.position; a2.newPosition(10.0);
int a2Position = a2.position; }
}
The method
newPosition(int delta)
is declared in
Particle
and
overridden in
AParticle
. It is also
overloaded by a method
with the same name takes a parameter of type
double
.
- After allocating three objects
p
,a1
anda2
,newPosition
is called on each one. -
p.newPosition
calls the method declared in classParticle
. -
a1.newPosition
calls the method declared in classAParticle
that overrides the method inParticle
. -
a2.newPosition
calls the overloaded method because the actual parameter is of typedouble
.
Exercise At the end of the program add an assignment
p =
a1
. Add the method invocations
p.newPosition(10)
and
p.newPosition(10.0)
in the main method. Explain what happens.