CS 596 OODP
Polymorphism

1. Polymorphism
   1. Hot Shot Polymorphism and C++
   2. How to Increase the use of Pure Polymorphism
      1. Rules for Finding Standard Protocols

Programming entity that is permitted to hold values of differing types

Pure (Parametric) Polymorphism

An entity has more than one form

Ad Hoc Polymorphism (Overloading)

Different entities have the same name

The sort algorithm works on may different types

Verses Pascal implementation of a sort algorithm

Smalltalk, Objective-C, CLOS

All objects are potentially polymorphic

x := 5;

x := 5.5;

x := 'This is a string';

Requires use of pointers

class A { ... }

class B : public A { ... }

A* polyVariable;

polyVariable = new A;

polyVariable = new B;

#include <iostream.h>

class  Top {
public:
	void virtual DoIt();
};

void Top::DoIt() {
cout << "Top" << endl;
}


class Bottom : public Top {
	void virtual DoIt();
};

void Bottom::DoIt() {
	cout << "Bottom" << endl;
}


main() {
	Top*  WhyMe = new Top;

	WhyMe->DoIt();			// prints "Top"

	WhyMe = new Bottom;

	WhyMe->DoIt();			// prints "Bottom"

}

#include <iostream.h>

class  Top {
public:
	void DoIt();
	void virtual FunPart() {cout << "Part1 in Top" << endl;}
};

void Top::DoIt() {
	cout << "Top" << endl;
	FunPart();
}


class Bottom : public Top {
	void virtual FunPart();
};

void Bottom::FunPart() {
	cout << "This is it" << endl;
}


main() {
	Top*  WhyMe = new Top;

	WhyMe->DoIt();			// prints "Top \n Part1 in Top"

	WhyMe = new Bottom;

	WhyMe->DoIt();			// prints "Top \n This is it"
}

main()
{
	Account*  customer;

	customer = createNewAccount();

	customer->Transaction(amount);
}

class Account {
	public:	
		void virtual Transaction(float amount) 
									{ balance += amount;}
		Account(char* customerName, float InitialDeposit = 0);
	protected:
		char* name;
		float balance;
}

class JuniorAccount : public Account {
	public:	void Transaction(float amount) {//  put code here}
}

class SavingsAccount : public Account {
	public:	void Transaction(float amount) {//  put code here}
}

Account* createNewAccount()
{
	// code to query customer and determine what type of
	// account to create
};


main()
{
	Account*  customer;

	customer = createNewAccount();

	customer->Transaction(amount);
}

class Account {
	public:	
		void 	Transaction(float amount);
		void virtual TransactionSubpartA();
		void virtual TransactionSubpartB();
		void virtual TransactionSubpartC();
}

void Account::Transaction(float amount)  {
	TransactionSubpartA();		TransactionSubpartB();	
	TransactionSubpartC();		// EvenMoreCode;
}

class JuniorAccount : public Account {
	public:		void virtual TransactionSubpartA(); }

class SavingsAccount : public Account {
	public:		void virtual TransactionSubpartC(); }

Account*  customer;
customer = createNewAccount();
customer->Transaction(amount);

The Good

Adding new subclasses

Changing code that creates objects

The Bad

if X is a Account then
	X.AccountUpDate()
else if X is a JuniorAccount then
	X.JuniorAccountUpDate()

Case X
Account: X.AccountUpDate()
	JuniorAccount:  X.JuniorAccountUpDate()
end case

X->Update()

Composability                                 Continuity                                    

Upper bound for average size of an operation

Language

Lines of Code

Smalltalk

8

C++

24

Average number of operations per class should be less than 20

Large classes should be viewed with suspicion and held guilty of poor design until proven innocent

       Decomposability Composability          Understandability                             

Operations with few parameters are more likely to be usable in different classes

Breaking an operation into several smaller operations

Creating a new class that represents a group of arguments

       Decomposability Composability          Understandability                             

Name and arguments of public operations of an object

Objects with the same protocol

Smalltalk methods average about 3 - 5 lines of code

Methods with small number of arguments are more likely to be usable in different classes

Reduce number of arguments by:

* Breaking a message into several smaller messages

* Creating a new class that represents a group of arguments

*Checking class of an object

Implement Foo in all relevant classes to perform the equivalent operation

* Case analysis of values of variables

Can be more difficult, but no less important

If an operation X is implemented by performing a similar operation on the component of the receiver, then that operation should also be named X.