Transcript Object Oriented Programming Development

Object Oriented Programming
Development - Polymorphism
 By:
Marc Conrad & Rob Manton
University of Luton
 Email:
[email protected]
[email protected]
 Room:
D104
1
Module Outline
Introduction
Non object oriented
basics
Classes
Inheritance
Aggregation
Polymorphism
Multifile Development
2
The Meaning of the word.
From the Greek:
Polus
(many )
+
Morphe = Polumorphos
(shape/form)
The English word "polymorphe" dates from
the 19th century and was applied to different
animal forms arising in the the same species.
3
The Meaning of the word.
In object-oriented computing it means:
different forms of data being handled by
the same type of process.
Example: The operator + has a different
meaning in the expression 2 + 3 (add two
integers) than in 1.7 + 3.3 (add two
floating point numbers)
4
Types of Polymorphism
 In Object Oriented Programming there
are three types of polymorphism:
a) method overloading, with the special
and important case of operator
overloading
b) method overriding
c) run-time polymorphism
5
Types of Polymorphism
 In Object Oriented Programming there
are three types of polymorphism:
a) method overloading, with the special
and important case of operator
overloading
Method overloading can
b) method overriding also be applied in nonobject oriented contexts
c) run-time polymorphism
and refers boths to
functions and methods.
6
Types of Polymorphism
 In Object Oriented
Programming
there
Method
overriding and
are three types ofrun-time
polymorphism:
polymorphism is
specific
to inheritance
a) method overloading,
with
the special
hierarchies
and object
and important case
of operator
oriented programming
overloading
b) method overriding
c) run-time polymorphism
7
Types of Polymorphism
 In Object Oriented Programming there
Run-time
polymorphism,
are three types of
polymorphism:
also called dynamic
a) method overloading, with the special
binding, or late binding is
and important case
of operator
often
considered as the
overloading
object oriented feature of
b) method overridingC++.
c) run-time polymorphism
8
Method & Function
Overloading
Overloading a function simply means, that a
function is not only defined its name but by
its name and parameter types.
The following functions are different in C++:
int makeBreakfast(int i, int k);
void makeBreakfast(Creature who);
float makeBreakfast();
9
Example: The Creature class
class Creature {
private:
int yearOfBirth;
public:
void setYearOfBirth(int year) {
yearOfBirth = year;
}
void setYearOfBirth(Creature other) {
yearOfBirth = other.yearOfBirth;
}
int getYearOfBirth() {
return yearOfBirth;
}
};
born1997
Example: The Creature class
class Creature {
private:
These two methods
int yearOfBirth;
are different.
public:
void setYearOfBirth(int year) {
yearOfBirth = year;
}
void setYearOfBirth(Creature other) {
yearOfBirth = other.yearOfBirth;
}
int getYearOfBirth() {
return yearOfBirth;
born1997
}
};
Example: The Creature
class
These two methods
class Creature {
are different
private:
because they have
int yearOfBirth;
different argument
public:
void setYearOfBirth(int year) {
types.
yearOfBirth = year;
}
void setYearOfBirth(Creature other) {
yearOfBirth = other.yearOfBirth;
}
int getYearOfBirth() {
return yearOfBirth;
born1997
}
};
Operator Overloading Motivation
Question: How many function calls are
involved in the following statement?
a=2+3
13
Operator Overloading Motivation
Question: How many function calls are
involved in the following statement?
a=2+3
There are two functions implicitly
involved:
+ and =.
Look at this statement as
“assign(a, add(2,3));”
14
Operator Overloading
So, operators as +, -, *, <<, =, etc. can
be seen as “functions” as well. That
means we can overload operators.
The C++ syntax uses “function names”
prefixed with “operator” for overloading
operators.
15
Overloading Operators Example
A Sandwich filling.
class BLT {
public:
may contain bacon (yes/no).
bool bacon;
a fraction of a lettuce-leaf.
float lettuce;
a number of tomato slices.
int tomatoes;
// Constructor:
BLT(bool b, float l, int t);
// … (more code)
};
16
Overloading Operators Example
BLT filling1(true,0.5,2);
BLT filling2(false,0.2,0);
class BLT {
...
public:
BLT filling3 = filling1 + filling2;
bool bacon;
...
float lettuce;
/* Should give a filling with
int tomatoes;
bacon, 0.7 lettuce and 2
// Constructor:
tomatoes*/
BLT(bool b, float l, int t);
// … (more code)
};
17
Overloading Operators Example
BLT filling1(true,0.5,2);
BLT filling2(false,0.2,0);
class BLT {
…
public:
BLT filling3 = filling1 + filling2;
bool bacon;
...
float lettuce;
/* Should give a filling with 3
int tomatoes;
bacon slices, 0.7 lettuce and
// Constructor:
2 tomatoes */
BLT(bool b, float l, int t);
This is the operator
// … (more code)
we want to overload
};
18
Overloading Operators Example // The C++ Syntax
BLT operator+(BLT y, BLT z) {
class BLT {
bool b = y.bacon || z.bacon;
public:
float l = y.lettuce + z.lettuce;
bool bacon;
int t = y.tomatoes = z.tomatoes;
float lettuce;
BLT result(b,l,t);
int tomatoes;
return result;
// Constructor:
}
BLT(bool b, float l, int t);
// … (more code)
};
19
Operator Overloading
Operators can also be overloaded as
methods, e.g. the operator +=:
 class BLT {
 // …
 BLT operator+=(BLT other) {

bacon ||= other.bacon;

tomatoes += other.tomatoes;

lettuce += other.lettuce;

}
 //…
20
BLT filling1(true,0.5,2);
BLT filling2(false,0.2,0);
Operator Overloading
…
filling1 += filling2;
Operators can also be
... overloaded as
methods, e.g. the operator +=:
/* Should give a filling with
 class BLT {
bacon, 0.7 lettuce and 2
 // …
tomatoes*/
 BLT operator+=(BLT other)
{




 //…
bacon ||= other.bacon;
tomatoes += other.tomatoes;
lettuce += other.lettuce;
}
21
Operator Overloading
Operators can also have other types as
parameter:
 class BLT {
 // …
 BLT operator*=(int factor) {

tomatoes *= 2;

lettuce *= 2;

}
 //…
22
BLT filling1(false,0.5,2);
…
Operator Overloading
filling1 *= 2;
...
Operators can also
have other
as no
/* Should
give a types
filling with
parameters:
bacon, 1 lettuce and 4
 class BLT {
tomatoes
 // …
*/
 BLT operator*=(int factor) {

tomatoes *= factor;

lettuce *= factor;

}
 //…
23
Operator Overloading
The following operators can be
overloaded:
new, delete, +, -, *, /, %, ^, &, |, ~, !, =, <,
>, +=, -=, *=, /=, %=, ^=, &=, |=, <<,
>>, >>=, <<=, ==, !=, <=, >=, &&, ||,
++, --, , , ->*. ->, (), []
Note that "=" has already a default behaviour.
When "overloaded" it will be in fact overridden.
24
Operator Overloading Interesting Observation
cout << “Hello World\n”;
Overloaded << operator
25
Operator Overloading Summary
 Operators may be overloaded to work
with user defined data types (objects).
 The syntax for overloading involves the
'operator' keyword and the operator.
 Note: In a good design it is important, that
the normal meanings of operators are not
distorted (don't subtract with a + operator)
26
Polymorphic Pointers
In C++ a pointer of a parent class is allowed to
point to an object of the child class. E.g.
class Vehicle {
// ...
};
class Car : public Vehicle {
// ...
};
// ...
Vehicle vp = new Car();
27
Overriding Methods
Methods in the parent class can be redifined in
the child class.
 class Vehicle {
void move(int i);
};
class Car : public Vehicle {
void move(int i);
};
// ...
Vehicle vp = new Car();
vp->move(100);
28
Overriding Methods
Methods in the parent class can be redifined in
the child class.
BUT:
 class Vehicle {
void move(int i);
Which of these
};
two move()
class Car : public Vehicle {
void move(int i);
methods will be
};
called?
// ...
Vehicle vp = new Car();
vp->move(100);
29
Overriding Methods
Methods in the parent class can be redifined in
the child class.
 class Vehicle {
void move(int i);
};
class Car : public Vehicle {
void move(int i);
};
// ...
Vehicle vp = new Car();
vp->move(100);
static typing
30
Overriding Methods
Methods in the parent class can be redifined in
the child class.
 class Vehicle {
void move(int i);
};
class Car : public Vehicle {
void move(int i);
};
// ...
Vehicle vp = new Car();
vp->move(100);
dynamic binding?
31
Overriding Methods
Methods in the parent class can be redifined in
the child class.
static typing!
 class Vehicle {
void move(int i);
};
class Car : public Vehicle {
void move(int i);
};
// ...
Vehicle vp = new Car();
vp->move(100);
 In C++, static
typing is the
default behaviour.
As vp is of type pointer to a Vehicle, the
method of the Vehicle is called. 32
Overriding Methods The keyword virtual
Methods in the parent class can be redifined in
the child class.
dynamic binding!
 class Vehicle {
virtual void move(int i);
};
class Car : public Vehicle {
virtual void move(int i);
};
// ...
Vehicle vp = new Car();
vp->move(100);
The keyword
virtual allows the
use of dynamic
binding.
As vp points to a Car object the
method of the Car is called
33
Abstract Methods & Classes
Abstract methods are methods without any
implementation (pure virtual methods).
 class Vehicle {
virtual void move(int i) = 0;
};
class Car : public Vehicle {
virtual void move(int i);
};
// ...
Vehicle vp = new Car();
vp->move(100);
Syntax for declaring
abstract methods.
Note that Vehicle objects cannot be
instantiated (but Car objects).
34
Static typing &
Dynamic binding
 Static typing means that
the legality of a member
function invocation is
checked at the earliest
possible moment: by the
compiler at compile time.
The compiler uses the
static type of the pointer
to determine whether the
member function
invocation is legal.
 Dynamic binding means
that the address of the
code in a member function
invocation is determined
at the last possible
moment: based on the
dynamic type of the object
at run time. It is called
"dynamic binding"
because the binding to the
code that actually gets
called is accomplished
dynamically (at run time).
35
Important stuff to remember
Overriding methods
Polymorphic pointers
Static binding
Dynamic binding - the virtual keyword
Abstract methods
36