CSC/ECE 517 Fall 2009/wiki2 4 dn

From Expertiza_Wiki
Revision as of 20:44, 8 October 2009 by Prem (talk | contribs)
Jump to navigation Jump to search

A large fraction of the if-statements in o-o programs could be replaced by uses of polymorphism, which would lead to more modular and maintainable programs. Explain why if-statements are error prone if there is any chance that future development may require them to change. Give examples of if-statements that can be replaced by elegant uses of polymorphism, trying to find some useful replacements that are not obvious. Concentrate on polymorphism, not other reasons for avoiding use of ifs.


The If Statement

The if-then statement is the most basic of all the control flow statements. It tells a program to execute a certain section of code only if a particular test evaluates to true.

if (daytime is morning)
{
  print "good morning"
}
else if (daytime is afternoon)
{
  print "good afternoon"
}
....
....

When and why are if-statements error prone?

Maintainability and Extensibility

Methods that use conditional if-statements can be hard to maintain and extend.

if (operator = "+")
{
  result = a+b
}
else if(operator = "-")
{
  result = a-b
}

Testing:

Sometimes in a program the same condition may have to be checked in multiple places.

if(flag is enabled)
{
  read a
}
else if(flag is not enabled)
{
  read b
}

.....
.....

if(flag is enabled)
{
 write a 
}
else if(flag is not enabled)
{
 write b
}

In the above example, flag is checked multiple times. This scenario can be particularly difficult for testing and debugging because, the progaram needs to read a and write a or read b and write b. The program should not read a and write b or read b and write a. If the condition needs to be checked more than twice then testing and debugging becomes more complicated.

Polymorphism

In object-oriented programming, polymorphism refers to a programming language's ability to process objects differently depending on their data type or class. More specifically, it is the ability to redefine methods for derived classes.