7. Inheritance & Polymorphism. Not reinventing the wheel

Transcription

1 7. Inheritance & Polymorphism Not reinventing the wheel

2 Overview Code Inheritance Encapsulation control Abstract Classes Shared Members Interface Inheritance Strongly Typed Data Structures Polymorphism

3 Inheritance Inheritance is simple enough in concept Create a new class based on an existing one To be worthwhile, the new class has to differ in some way from the one inherited from New Properties and Methods can be added (Extension) Inherited Methods can be replaced (Specialization) A class that inherits from another is related to it They share an Interface, which makes the Child typecompatible with the Parent Not the other way round, since the Child can have additions to its interface

4 Simple Example of Extension Public Class Employee Public EmployeeNo As Integer Public Name As String Private Salary As Decimal Public Function GetPay(ByVal PWord As String) _ As Decimal If PWord = Then Return Salary / 52 Weekly pay Else Return 0 End If End Function End Class Public Class Manager Inherits Employee Public BossOf As String End Class Note: Both Worker and Boss variables can be type Employee. (Boss could also be type Manager) Sub Main() Dim Worker, Boss As Employee Worker = New Employee Worker.EmployeeNo = 1234 Worker.Name = Fred Smith Boss = New Manager Boss.EmployeeNo = 131 Boss.Name = Charles Smythe Boss.BossOf = Fred Smith

5 Specialization The inheriting class is allowed to redefine Methods and Properties The inherited class (Base Class) must allow it (using Overridable) The redefined method must conform to the original signature (same number and types of parameters, same return type for a Function) Result is two or more classes with the same interfaces, but their own methods of doing an operation

6 Example of Specialization Public Class Manager Inherits Employee Public BossOf As String Public Overrides Function GetPay(ByVal PWord As String) As Decimal Return MyBase.GetPay(PWord) * 52 / 12 Convert to monthly. End Function End Class Public Class Employee Other stuff Public Overridable Function GetPay( End Class Note: Base class method must be marked as Overridable Note : the Manager class calculates Pay differently (monthly instead of weekly). However, the GetPay function is in exactly The same format as the original it just Does the job slightly differently. In general, the original and specialized methods should be semantically similar.

7 Vocabulary of Inheritance Employee Base-Class of Manager Ancestor of SeniorManager Base-Class of SeniorManager Sub-Class Of Employee Manager Also: Super-Class Child Class Parent Class SeniorManager Sub-Class of Manager Descendent of Employee

8 Inheritance: Advantages and Disadvantages Advantages Less work to inherit that to create from scratch Changes to a base class (e.g. fixes) will propagate through the descendant classes Descendants are type-compatible with their ancestors, so Polymorphism allows generalized code to be written for using objects (one message can apply to many classes of object) Disadvantages Can be difficult to find a subtle bug, which may be in a class or one of its ancestors Complexity increases with the number of levels of inheritance Extra work in learning how to use a family of classes properly Can lead to Not-Invented-Here syndrome

9 Access Specifiers A potential conflict Encapsulation requires that we are able to hide the details of the implementation of a class from users of it (usually programs) Private allows us to do this private member variables, properties, methods are allowed Inheritance usually requires better access to a class s internals, so Inheriting classes need to be able to access members that other users can not The solution to this is provided by Protected and Friend access Protected access is provided specifically for inheriting classes Friend access is provided to allow any class in the same assembly. Friend access is also the default

10 Public Class Employee Friend EmployeeNo As Integer Small alteration Public Name As String Protected Salary As Decimal Small alteration Public Function GetPay(ByVal PWord As String) _ As Decimal If PWord = Then Return Salary / 52 Weekly pay Else Return 0 End If End Function End Class Access examples Public Class Manager Inherits Employee Public BossOf As String Public Function GetPay(ByVal PWord As String) As Decimal If PWord = Then Return Salary / 12 End If End Function End Class This can be accessed anywhere in the assembly, but not from a module that uses the assembly This can be accessed directly by descendants only Now possible to access this directly compare with previous Manager.GetPay() method shown

11 Inheritance and Constructors Recall: a constructor is a special purpose method (called Sub New() that is used to create an object and put it into a valid state immediately With an class built on inheritance, the inherited class MUST have a constructor if the base class constructor has parameters. The inheriting class must first invoke its base class s constructor (using MyBase.New(<params>)) New (Inheriting) Class Base Class Construct this Extensions to Base Class Then this It can then go on to initialize its own properties as usual

12 Example constructors Public Class Employee Other stuff Public Sub New(ByVal name As String, ByVal Salary As Decimal) EmployeeNo = ********** More on this later Me.Name = Name Me.Salary = Salary End Class Public Class Manager Inherits Employee Public Sub New(ByVal Name As String, ByVal Salary As Decimal, _ ByVal BossOf As String) MyBase.New(Name, Salary) Me.BossOf = BossOf

13 Abstract Classes Usual to think of inheritance as a way of creating a variant of some useful base class It is possible to create a base class that can not be used to create objects, because it is defined purely to inherit from This is an Abstract class, and is useful because It allows us to create a family of descendant class that all conform to the same interface It allows us to factor out the common properties and methods of a range of classes and implement these one, to be inherited from

14 Sample Abstract class Public Class Shape Public Size As Single Public MustOverride _ Function Area() As Single Public MustOverride _ Function Perimeter() As Single Public Class Square Inherits Shape Public Overrides Function Area() As Single Return Size * Size Public Overrides Function Perimeter() As Single Return 4 * Size Public Class Circle Inherits Shape Public Overrides Function Area() As Single Return PI * Size * Size Public Overrides Function Perimeter() As Single Return 2 * PI * Size

15 Accessing the Base Class A class that inherits from a base class may wish to invoke one of its methods or access one of its properties Problem is, they will have the same name as methods in the class itself if they are overridden MyBase gets around this problem (as we have already seen with constructors) Note, we can not access earlier ancestors methods so easily

16 Shared Members Instance variables (member variables) in a class are defined so that each object gets its own copy Sometimes, this can lead to inefficiency and possible problems e.g. the InterestRate of a BankAccount class should be the same for each object, so if each object has its own copy, memory is wasted each object s copy could have a different value In this situation, a Shared variable can be used one variable, defined for the class that can be accessed by all objects Can also have shared methods

17 Shared Variables and Methods Public Class Employee Private Shared EmployeeCount As Integer Other stuff Public Sub New(ByVal name As String, ByVal Salary As Decimal) EmployeeCount += 1 EmployeeNo = EmployeeCount Me.Name = Name Me.Salary = Salary Public Shared Function GetNumberOfEmployees() As Integer Return EmployeeCount End Function End Class This ensures that each employee (including descend classes) gets the next number in the sequence all are numbered individually A Shared method can only access Shared variables (since there is no guarantee of an object with member variables)

18 Interface Inheritance Allows definition of Pure Abstract Classes No method definitions, no member variables Only method signatures While a class can only Inherit one base class, it can Implement any number of interfaces This allows a new class to conform to any number of pre-defined behavioural characteristics e.g..net defines IComparable (objects can be compared and sorted) interface We can therefore, regardless of code inheritance, create classes whose objects behave like several of interfaces simultaneously

19 Example Interface and Use Interface IComparable Function CompareTo(O As Object) As Integer End Interface Class Person Implements IComparable Public Name As String Function CompareTo(O As Object) As Integer Implements IComparable.CompareTo If Name < O.Name Then Return -1 ElseIf Name > O.Name Then Return 1 Else Return 0 End If End Function Other stuff End Interface Function is to define how to compare two objects of a class By conforming to the IComparable interface, Person objects can be added to a SortedList collection or an array for which the Sort() method can be called. The objects will be ordered alphabetically by name

20 Inheriting Data Structures CollectionBase and DictionaryBase classes are part of the.net CLR, and are designed to be inherited (abstract classes) This allows to quickly create a strongly-typed collection (a collection that can only contain one type of object (a class or its descendants) All that is required is to define Add and Remove methods and the Item property

21 A Strongly Typed Employee Collection Public Class EmployeeCollection Inherits System.Collections.CollectionBase Public Sub Add(ByVal E As Employee) List.Add(E) Public Function Remove(ByVal index As Integer) As Boolean If index > Count - 1 Or index < 0 Then Return False No employee exists at this index Else List.RemoveAt(index) Remove the employee object Return True End If End Function Public ReadOnly Property Item(ByVal Index As integer) As Employee Get If index >= 0 Or Index < Count Then Return CType(List(index), Employee) Else Return Nothing End If End Get End Property End Class Can only add employees to this collection. Other methods could be added to perform classspecific operations

22 Polymorphism Using Code or Interface inheritance, we can create families of classes that are compatible over a range or methods This principle (polymorphism many forms) allows us to define general operations that can be applied to any of a range of classes This is true object-oriented programming, which can be defined as: Programming by sending messages to objects whose class is unknown Polymorphism allows us to generalize in programming, and reduces the effort necessary to extend systems to incorporate new data items

23 Polymorphism example Public Class Employee Implementation End Class Public Class Manager Inherits Employee Implementation End Class Public Class Director Inherits Manager Implementation End Class Once an object has been created, we do not need to know its class provided it is type compatible (by inheritance or interface) Sub Main Dim E As Employee Dim Staff As New EmployeeCollection E = New Employee( Fred Bloggs, 20000) Staff.Add(E) E = New Manager( Peter Green, 35000) Staff.Add(E) E = New Director( Charles Smythe, 68000) Staff.Add(E) For Each E In Staff Console.WriteLine( {0} : {1}, E.Name, _ E.GetPay( )) Next

24 Summary Inheritance can be Code or Interface Code Inheritance by Extension and or Specialization Base class, sub class, parent, child, descendant, ancestor Protected and Friend access provide better control over encapsulation Constructors important in inheritance relationship Abstract classes provide a class template for other classes to conform to Shared members useful for efficient use of information or behaviour shared among objects Interface inheritance enables classes to conform in a number of areas Strongly typed data structures based on inheritance Polymorphism an important goal of object-oriented programming