Polymorphism

Dec 7, 2021
 Signatures
 In any programming language, a signature is what
distinguishes one function or method from another
 In C, every function has to have a different name
 In Java, two methods have to differ in their names
or in the number or types of their parameters
 foo(int i) and foo(int i, int j) are different
 foo(int i) and foo(int k) are the same
 foo(int i, double d) and foo(double d, int i) are
different
 In C++, the signature also includes the return type
 But not in Java!

2
 Polymorphism
 Polymorphism means many (poly) shapes (morph)
 In Java, polymorphism refers to the fact that you can
have multiple methods with the same name in the same
class
 There are two kinds of polymorphism:
 Overloading
 Two or more methods with different signatures
 Overriding
 Replacing an inherited method with another having the same signature

3
 Overloading
class Test {
public static void main(String args[]) {
myPrint(5);
myPrint(5.0);
}
static void myPrint(int i) {
System.out.println("int i = " + i);
}
static void myPrint(double d) { // same name, different parameters
System.out.println("double d = " + d);
}
}

int i = 5
double d = 5.0
4
 Why overload a method?
 So you can supply defaults for the parameters:
int increment(int amount) {
count = count + amount;
return count;
}
int increment() {
return increment(1);
}
 Notice that one method can call another of the same name
 So you can supply additional information:
void printResults() {
System.out.println("myArray = " + Arrays.toString(myArray));
}
void printResult(String message) {
System.out.println(message + ": ");
printResults();
}

5
 DRY (Don’t Repeat Yourself)
 When you overload a method with another, very similar method,
only one of them should do most of the work:

void debug() {
System.out.println("first = " + first + ", last = " + last);
for (int i = first; i <= last; i++) {
System.out.print(dictionary[i] + " ");
}
System.out.println();
}

void debug(String s) {
System.out.println("At checkpoint " + s + ":");
debug();
}

6
 Another reason to overload methods
 You may want to do “the same thing” with different kinds of data:
 class Student extends Person {
...
void printInformation() {
printPersonalInformation();
printGrades();
}
}
 class Professor extends Person() {
...
void printInformation() {
printPersonalInformation();
printResearchInterests();
}
}
 Java’s print and println methods are heavily overloaded

7
 Legal assignments
class Test {
public static void main(String args[]) {
double d;
int i;
d = 5; // legal
i = 3.5; // illegal
i = (int) 3.5; // legal
}
}
 Widening is legal
 Narrowing is illegal (unless you cast)

8
 Legal method calls
class Test {
public static void main(String args[]) {
myPrint(5);
}
static void myPrint(double d) {
System.out.println(d);
}
}

5.0
 Legal because parameter transmission is equivalent to
assignment
 myPrint(5) is like double d = 5; System.out.println(d);

9
 Illegal method calls
class Test {
public static void main(String args[]) {
myPrint(5.0);
}
static void myPrint(int i) {
System.out.println(i);
}
}

myPrint(int) in Test cannot be applied to (double)

 Illegal because parameter transmission is equivalent to

10
 Java uses the most specific method
 class Test {
public static void main(String args[]) {
myPrint(5);
myPrint(5.0);
}
 static void myPrint(double d) {
System.out.println("double: " + d);
}
 static void myPrint(int i) {
System.out.println("int: " + i);
}
}

 int:5
double: 5.0

11
 Multiple constructors I
 You can “overload” constructors as well as methods:

 Counter() {
count = 0;
}

Counter(int start) {
count = start;
}

12
 Multiple constructors II
 One constructor can “call” another constructor in the
same class, but there are special rules
 You call the other constructor with the keyword this
 The call must be the very first thing the constructor does
 Point(int x, int y) {
this.x = x;
this.y = y;
sum = x + y;
}
 Point() {
this(0, 0);
}
 A common reason for overloading constructors is (as above) to
provide default values for missing parameters
13
 Superclass construction I
 The very first thing any constructor does, automatically, is call
the default constructor for its superclass
 class Foo extends Bar {
Foo() { // constructor
super(); // invisible call to superclass constructor
...
 You can replace this with a call to a specific superclass
constructor
 Use the keyword super
 This must be the very first thing the constructor does
 class Foo extends Bar {
Foo(String name) { // constructor
super(name, 5); // explicit call to superclass constructor
...

14
 Superclass construction II
 Unless you specify otherwise, every constructor calls the default constructor
for its superclass
 class Foo extends Bar {
Foo() { // constructor
super(); // invisible call to superclass constructor
...
 You can use this(...) to call another constructor in the same class:
 class Foo extends Bar {
Foo(String message) { // constructor
this(message, 0, 0); // your explicit call to another constructor
...
 You can use super(...) to call a specific superclass constructor
 class Foo extends Bar {
Foo(String name) { // constructor
super(name, 5); // your explicit call to some superclass constructor
...
 Since the call to another constructor must be the very first thing you do in the
constructor, you can only do one of the above
15
 Shadowing
class Animal {
String name = "Animal";
public static void main(String args[]) {
Animal animal = new Animal();
Dog dog = new Dog();
System.out.println(animal.name + " " + dog.name);
}
}
public class Dog extends Animal {
String name = "Dog";
}

Animal Dog
 This is called shadowing—name in class Dog shadows
name in class Animal
16
 Overriding
class Animal {
public static void main(String args[]) {  This is called
Animal animal = new Animal(); overriding a method
Dog dog = new Dog();
animal.print();  Method print in Dog
dog.print(); overrides method
}
void print() {
print in Animal
System.out.println("Superclass Animal");  A subclass variable
}
}
can shadow a
superclass variable,
public class Dog extends Animal {
void print() { but a subclass method
System.out.println("Subclass Dog"); can override a
} superclass method
}
Superclass Animal
Subclass Dog
17
 How to override a method
 Create a method in a subclass having the same signature
as a method in a superclass
 That is, create a method in a subclass having the same
name and the same number and types of parameters
 Parameter names don’t matter, just their types
 Restrictions:
 The return type must be the same
 The overriding method cannot be more private than the
method it overrides

18
 Why override a method?
 Dog dog = new Dog();
System.out.println(dog);
 Prints something like Dog@feda4c00
 The println method calls the toString method, which is
defined in Java’s top-level Object class
 Hence, every object can be printed (though it might not look pretty)
 Java’s method public String toString() can be overridden
 If you add to class Dog the following:
public String toString() {
return name;
}
Then System.out.println(dog); will print the dog’s
name, which may be something like: Fido
19
 Calling an overridden method
 When your class overrides an inherited method, it
basically “hides” the inherited method
 Within this class (but not any other), you can still call
the overridden method, by prefixing the call with
super.
 Example: super.printEverything();
 You would most likely do this in order to observe the
DRY principle
 The superclass method will do most of the work, but you add
to it or adjust its results
 This isn’t a call to a constructor, and can occur anywhere in
your class (it doesn’t have to be first)

20
 Summary
 You should overload a method when you want to do
essentially the same thing, but with different parameters
 You should override an inherited method if you want to
do something slightly different than in the superclass
 It’s almost always a good idea to override public void
toString() -- it’s handy for debugging, and for many other
reasons
 You should never intentionally shadow a variable

21
The End

22