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