Object-Oriented Programming and Polymorphism

Lesson1

Objects

• Abstraction = ability of programmatic objects to represent real-world things
• Class = template for object
• Object created -> copy of instance data defined by class created in memory and assigned to reference variable
• Each object independent of one another

Members

• Objects composed of members
  • properties - data
  • fields - data
  • methods - actions object can perform
  • events - notifications object receives

Object Model

• hierarchical organisation of objects contained and exposed within main object
  • Car object contains Engine object, Wheel objects and Transmission object. Composition of subordinate objects affects how Car behaves - e.g. value of cylinders property of Engine modifies performance

Encapsulation

• Object implementation independent from its interface
• App interacts with object through its interface (public properties and methods)
• If interface remains constant, implementation can change without impacting app
• Internal object data should never be exposed - ensure fields are private

Polymorphism

• Different classes providing different implementations of same public interface

• e.g. Driver object can interact with both Car and Truck object through same interface

• Interface Polymorphism

  • Interface = behaviour contract
  • Defines members to be implemented, but not how
  • Object can implement multiple interfaces
  • Many objects can implement same interface
  • By convention interfaces start with I, e.g. IDrivable

• Inheritance polymorphism

  • Inheritance allows class to incorporate functionality of previously defined class, implementing different members as needed
  • Can only inherit form one class (the base class)
  • Inherited class has is-a relationship with base (e.g. PickupTruck is-a Truck)
  • Can add additional members - extend functionality
  • Can override base class members - modify functionality

Lesson 2

Overloading Members

• Multiple methods with same name but different signatures
• Access level and return type may vary
• Run time calls method matching signature provided - if no match then error!

Overloading Methods

public void DisplayMessage(int i)
{
 MessageBox.Show(i.ToString());
}

public void DisplayMessage(string s)
{
 MessageBox.show(s);
}

Overloading Operators

• For user defined types may be desirable to overload operator (e.g. complicated structure

public struct HoursWorked
{
 float RegularHours;
 float OvertimeHours;
}

• Overload operator using

public static _type_ operator _op_ (Arg1[, Arg 2])
{
 ...
}

• Unary operators - provide one argument
• Binary operators - provide two arguments (at least one same type)
• Must be static
• Must be public
• Must be defined within user defined type

public struct HoursWorked
{
 float RegularHours;
 float OvertimeHours;

 public static HoursWorked operator + (HoursWorked a, HoursWorked b)
 {
  HoursWorked Result = new HoursWorked();
  
  Result.RegularHours = a.RegularHours + b.RegularHours;
  Result.OvertimeHours = a.OvertimeHours + b.OvertimeHours;
  
  return Result;
 }

 public static HoursWorked operator + (HoursWorked a, int b)
 {
  HoursWorked Result = new HoursWorked();
 
  Result.RegularHours = a.RegularHours + b;
 
  return Result;
 }
}

...

HoursWorked tot = new HoursWorked();

tot = Sunday + Monday;

Lesson 3

Interface Polymorphism

• Interface defined using interface keyword
• Member methods signature provided, but not access modifiers
• Can not defined fields
• Objects implementing interface are obliged to implement its methods, clients do not need to use them, implement event handlers, etc.

public interface IDrivable
{
  void GoForward();
  
  void Halt();
  
  int DistanceTravelled();
  
  int FuelLevel
  
  {
   get:
   ..
}

 event System.EventHandler OutOfFuel;
}

• Method signature may indicate an interface is required

public void GoSomewhere(IDrivable v)
{
 ...
}

• Any object implementing required interface may be passed to method
• Object will be cast to appropriate interface - only interface members will be accessible within method implementation

Implement Interface

• Classes can implement multiple interfaces
• Specify interfaces as comma separated list
• Implementation below makes interface members available both via interface and class

public class Truck : IDrivable, IFuelBurning
{
 public void GoForward(int Speed)
 {

 }
} 

• Implementation below makes interface members available only via interface. No access modifier - has same level as member defined by class

public class Truck : IDrivable, IFuelBurning
{
 void IDrivable.GoForward(int Speed)
 {

 }
}

Inheritance Polymorphism

• Instance of derived class can polymorphically behave as instance of its base
• If method requires Truck object can pass PickupTruck
• When cast to base, methods implemented by derived are unavailable
• Class inherit one base, multiple interfaces. List interfaces following base

public class FourWheelDrivePickupTruck : PickupTruck, IFourWheelDrive
{
...
}

• Stop class acting as base by others using sealed keyword

public sealed class AClass
{

}

Overriding Base Class Members

• Substitute new implementation for base class member
• Only override methods and properties
• Can not override fields and events
• New implementation must have same access level, signature and return type

public class SportsCar : Car
{
 public override void GoForward(int Speed)
 {

 }
}

• Overridden member called in place of base version - regardless of context called in. If inherited class is cast to base and method called, new implementation still called. Type of object, not variable, determines which member called
• To override base member must be marked virtual

public virtual void OverrideMe()
{

...

}

Hiding Base Class Members

• Obscure base class members and replace with new implementation
• Must have same kind and have same signature as original
• Access level and return type can be different
• Use new keyword to indicate that base implementation should be hidden
• Can have interoperability implications (change to return type and accessibility) - only use where certain about compatibility
• Base implementation can be accessed on occasions - dependent on type of variable not object (unlike overriding)
• On inheritance hidden implementations not exposed - the base implementation is exposed

public class MyBaseClass
{

 public string MyMethod(int I)
 {

 }
}

public class MyInheritedClass : MyBaseClass
{
 internal new int MyMethod(int I)
 {

 }
}

Access Base Implementation

• Can access base implementation from inherited one using base keyword

public override void MyMethod()
{
 base.MyMethod();
}

Abstract Classes and Members

• Allows creation of base class providing some invariant functionality, whilst leaving implementation of others to inheriting classes

• Abstract class can not be instantiated

• Regular members of abstract class can be virtual (allowing inheriting classes to provide own implementations) or non-virtual (i.e. fixed)

• Abstract members provide declaration, but not implementation

public abstract class AbstractClass
{
 public abstract void GoForward(int I);

 public abstract string Colour
 {
  get:
  
  set:
 }
}

• Inheriting classes must implement abstract members
• If inheriting class is abstract it is not required to implement abstract members

Downloads

• ooprogramming.rtf