Object-Oriented Programming Fundamental Concepts

Svetlin Nakov
Telerik Corporation
www.telerik.com

Contents
1. 2. 3. 4.

Fundamental Principles of OOP Inheritance Abstraction Encapsulation

5.
6.

Polymorphism
Cohesion and Coupling

Fundamental Principles of OOP

Fundamental Principles of OOP

Inheritance

Inherit members from parent class

Abstraction

Define and execute abstract actions

Encapsulation

Hide the internals of a class

Polymorphism
Access a class through its parent interface
4

Inheritance

Classes and Interfaces

Classes

define attributes and behavior

Fields, properties, methods, etc. Methods contain code for execution

public class Labyrinth { }

Interfaces define a set of operations

Empty methods and properties, left to be implemented later

public interface IFigure { }

Inheritance
Inheritance

allows child classes inherits the characteristics of existing parent class

Attributes (fields and properties) Operations (methods)

Child

class can extend the parent class

Add new fields and methods

Redefine methods (modify existing behavior)

A class can implement an interface by

providing implementation for all its methods

7

Types of Inheritance
Inheritance terminology

derived class

inherits

base class / parent class

class

implements

interface

derived interface

implements

base interface

Inheritance Benefits
Inheritance has a lot of benefits

Extensibility Reusability Provides abstraction

Eliminates redundant code

Use inheritance

for buidling is-a relationships

E.g. dog is-a animal (dogs are kind of animals)

Don't use it to build has-a relationship

E.g. dog has-a name (dog is not kind of name)

9

Inheritance Example
Base class Person
+Name: String +Address: String

Derived class

Derived class

Employee
+Company: String +Salary: double

Student
+School: String

10

Class Hierarchies
Inheritance leads to a hierarchy

of classes and/or interfaces in an application:

Game

SinglePlayerGame

MultiplePlayersGame

Minesweeper

Solitaire

BoardGame

Chess Backgammon
11

Inheritance in .NET

A class can inherit only one base class

E.g. IOException derives from SystemException and it derives from Exception

A class can implement several interfaces

This is .NETs form of multiple inheritance
E.g. List<T> implements IList<T>, ICollection<T>, IEnumerable<T>

An interface can implement several interfaces

E.g. IList<T> implements ICollection<T> and IEnumerable<T>
12

How to Define Inheritance?

We must specify the name of the base class

after the name of the derived

public class Shape {...} public class Circle : Shape {...}

In the constructor of the derived class we use

the keyword base to invoke the constructor of the base class

public Circle (int x, int y) : base(x) {...}
13

Simple Inheritance Example

public class Mammal { public int Age { get; set; } public Mammal(int age) { this.Age = age; } public void Sleep() { Console.WriteLine("Shhh! I'm sleeping!"); } }
14

Simple Inheritance Example (2)

public class Dog : Mammal { public string Breed { get; set; } public Dog(int age, string breed) : base(age) { this.Breed = breed; } public void WagTail() { Console.WriteLine("Tail wagging..."); } }
15

Simple Inheritance
Live Demo

Accessibility Levels

Access modifiers in C#
public access is not restricted private access is restricted to the containing type protected access is limited to the containing type and types derived from it internal access is limited to the current assembly protected internal access is limited to the current assembly or types derived from the containing class

17

Inheritance and Accessibility

class Creature { protected string Name { get; private set; }

private void Talk() { Console.WriteLine("I am creature ..."); }

protected void Walk() { Console.WriteLine("Walking ..."); } } class Mammal : Creature { // base.Talk() can be invoked here // this.Name can be read but cannot be modified here }
18

Inheritance and Accessibility (2)

class Dog : Mammal { public string Breed { get; private set; } // base.Talk() cannot be invoked here (it is private) } class InheritanceAndAccessibility { static void Main() { Dog joe = new Dog(6, "Labrador"); Console.WriteLine(joe.Breed); // joe.Walk() is protected and can not be invoked // joe.Talk() is private and can not be invoked // joe.Name = "Rex"; // Name cannot be accessed here // joe.Breed = "Shih Tzu"; // Can't modify Breed } }
19

Inheritance and Accessibility

Live Demo

Inheritance: Important Aspects

Structures cannot be inherited

In C# there is no multiple inheritance

Only multiple interfaces can be implemented

Instance and static constructors are not inherited

Inheritance is transitive relation
If C is derived from B, and B is derived from A, then C inherits A as well
21

Inheritance: Important Features

A derived class

extends its base class

It can add new members but cannot remove derived ones

Declaring new members with the same name

or signature hides the inherited ones

A class

can declare virtual methods and properties

Derived classes can override the implementation of these members
E.g. Object.Equals() is virtual method
22

Abstraction

Abstraction
Abstraction

means ignoring irrelevant features, properties, or functions and emphasizing the relevant ones ...
"Relevant" to what?

... relevant to the given project (with an eye to

future reuse in similar projects)

Abstraction

= managing complexity
24

Abstraction (2)

Abstraction is something we do every day

Looking at an object, we see those things about it that have meaning to us We abstract the properties of the object, and keep only what we need E.g. students get "name" but not "color of eyes"

Allows us to represent a complex reality in terms of a simplified model Abstraction highlights the properties of an entity that we need and hides the others
25

Abstraction in .NET
In .NET abstraction

is achieved in several

ways:
Abstract classes Interfaces
Control +click()

Inheritance
ButtonBase +Color : long

Button RadioButton CheckBox

26

Abstraction in .NET Example

System.Object

System.MarshalByRefObject

System.ComponentModel.Component

System.Windows.Forms.Control

System.Windows.Forms.ButtonBase

System.Windows.Forms.Button
27

Interfaces in C#
An interface is a set of operations (methods)

that given object can perform

Also called "contract" for supplying a set of operations

Defines abstract behavior

Interfaces provide abstractions

You shouldn't have to know anything about what is in the implementation in order to use it
28

Abstract Classes in C#
Abstract

classes are special classes defined with the keyword abstract

Mix between class and interface Partially implemented or fully unimplemented

Not implemented methods are declared abstract and are left empty
Cannot be instantiated
Child

classes should implement abstract methods or declare them as abstract

29

Abstract Data Types

Abstract

Data Types (ADT) are data types defined by a set of operations (interface)
interface IList<T> +Add(item : Object) +Remove(item : Object) +Clear()

Example:

LinkedList<T>

List<T>
30

Inheritance Hierarchies
Using inheritance we can create inheritance

hierarchies
Easily represented by UML class diagrams
UML class diagrams

Classes are represented by rectangles containing their methods and data

Relations between classes are shown as arrows
Closed triangle arrow means inheritance Other arrows mean some kind of associations
31

UML Class Diagram Example

interface ISurfaceCalculatable +CalculateSurface:float Shape #Position:Point +X:int +Y:int +Point struct Point

Square -Size:float +Square +CalculateSurface:float

Rectangle -Width:float -Height:float +Rectangle +CalculateSurface:float

struct Color

+RedValue:byte +GreenValue:byte +BlueValue:byte

+Color

FilledSquare -Color:Color +FilledSquare

FilledRectangle -Color:Color +FilledRectangle

32

Class Diagrams in Visual Studio

Live Demo

Encapsulation

Encapsulation
Encapsulation hides the implementation

details
Class All

announces some operations (methods) available for its clients its public interface

data members (fields) of a class should be hidden

Accessed via properties (read-only and readwrite)

No interface members should be hidden

35

Encapsulation Example
Data fields are private Constructors

and accessors are defined (getters and setters)

Person -name : string -age : TimeSpan +Person(string name, int age) +Name : string { get; set; } +Age : TimeSpan { get; set; }
36

Encapsulation in .NET
Fields are always

declared private

Accessed through properties in read-only or read-write mode

Constructors

are almost always declared always public private /

37

public
Interface methods are

Not explicitly declared with public

Non-interface methods are declared

protected

Encapsulation Benefits
Ensures that structural

changes remain local:

Changing the class internals does not affect any code outside of the class Changing methods' implementation does not reflect the clients using them
Encapsulation allows

adding some logic when accessing client's data

E.g. validation on modifying a property value

Hiding

implementation details reduces complexity easier maintenance

38

Polymorphism

Polymorphism

Polymorphism = ability to take more than one form (objects have more than one type)
A class can be used through its parent interface
A child class may override some of the behaviors of the parent class

Polymorphism allows abstract operations to be defined and used

Abstract operations are defined in the base class' interface and implemented in the child classes
Declared as abstract or virtual
40

Polymorphism (2)
Why handle an

object of given type as object of its base type?

To invoke abstract operations
To mix different related types in the same collection
E.g. List<object> can hold anything

To pass more specific object to a method that expects a parameter of a more generic type To declare a more generic field which will be initialized and "specialized" later
41

Virtual Methods
Virtual method is method that can be used in

the same way on instances of base and derived classes but its implementation is different
A method is said

to be a virtual when it is

declared as virtual
public virtual void CalculateSurface()

Methods that are

declared as virtual in a base class can be overridden using the keyword override in the derived class
42

The override Modifier

Using override we can modify a method or

property
An override

method provides a new implementation of a member inherited from a base class a non-virtual or static method

You cannot override

The overridden base method must be virtual,

abstract, or override
43

Polymorphism How it Works?

Polymorphism

ensures that the appropriate method of the subclass is called through its base class' interface is implemented using a technique called late method binding
Exact method to be called is determined at runtime, just before performing the call

Polymorphism

Applied for all abstract / virtual methods

Note: Late binding

is slower than normal

44

(early) binding

Polymorphism Example
Abstract class
Figure +CalcSurface() : double

Abstract action

Concrete class
Overriden action

Square -x : int -y : int -size : int

Circle -x : int -y : int -radius: int

Overriden action

override CalcSurface() { return size * size; }

override CalcSurface() { return PI * radius * raduis; }

45

Polymorphism Example (2)

abstract class Figure { public abstract double CalcSurface(); } abstract class Square { public override double CalcSurface() { return } } Figure f1 = new Square(...); Figure f2 = new Circle(...); // This will call Square.CalcSurface() int surface = f1.CalcSurface(); // This will call Square.CalcSurface() int surface = f2.CalcSurface();
46

Polymorphism
Live Demo

Class Hierarchies: Real World Example

Real World Example: Calculator

Creating

an application like the Windows Calculator

Typical scenario for applying the objectoriented approach

49

Real World Example: Calculator (2)

The calculator consists

of controls:

Buttons, panels, text boxes, menus, check boxes, radio buttons, etc.
Class

Control the root of our OO hierarchy

All controls can be painted on the screen

Should implement an interface IPaintable with a method Paint()

Common properties: location, size, text, face color, font, background color, etc.
50

Real World Example: Calculator (3)

Some controls

could contain other (nested) controls inside (e. g. panels and toolbars)
We should have class Container that extends Control holding a collection of child controls

The Calculator itself is a

Form

Form is a special kind of Container Contains also border, title (text derived from Control), icon and system buttons
How the Calculator paints itself?

Invokes Paint() for all child controls inside it

51

Real World Example: Calculator (4)

How a Container paints itself?

Invokes Paint() for all controls inside it Each control knows how to visualize itself
What is the common between buttons, check

boxes and radio buttons?

Can be pressed

Can be selected
We can define class

AbstractButton and all buttons can derive from it

52

Calculator Classes
interface IPaintable Paint()

Control
-location -size -text -bgColor -faceColor -font

Container

AbstractButton

TextBox

MainMenu

MenuItem

Panel

Form

Button

CheckBox

RadioButton

Calculator
53

Cohesion and Coupling

Cohesion
Cohesion describes how closely

all the routines in a class or all the code in a routine support a central purpose
Well-defined abstractions keep cohesion strong

Cohesion must be strong

Classes

must contain strongly related functionality and aim for single purpose complexity
55

Cohesion is a useful tool for managing

Good and Bad Cohesion

Good: hard disk, cdrom, floppy

BAD: spaghetti code

56

Strong Cohesion
Strong cohesion example

Class Math that has methods:

Sin(), Cos(), Asin() Sqrt(), Pow(), Exp() Math.PI, Math.E
double sideA = 40, sideB = 69; double angleAB = Math.PI / 3; double sideC = Math.Pow(sideA, 2) + Math.Pow(sideB, 2) - 2 * sideA * sideB * Math.Cos(angleAB); double sidesSqrtSum = Math.Sqrt(sideA) + Math.Sqrt(sideB) + Math.Sqrt(sideC);
57

Bad Cohesion
Bad cohesion example

Class Magic that has these methods:

public void PrintDocument(Document d); public void SendEmail( string recipient, string subject, string text); public void CalculateDistanceBetweenPoints( int x1, int y1, int x2, int y2)

Another example:
MagicClass.MakePizza("Fat Pepperoni"); MagicClass.WithdrawMoney("999e6"); MagicClass.OpenDBConnection();
58

Coupling
Coupling describes

how tightly a class or routine is related to other classes or routines

Modules must depend little on each other

Coupling must be kept loose

All classes and routines must have small, direct, visible, and flexible relations to other classes and routines One module must be easily used by other modules
59

Loose and Tight Coupling

Loose Coupling:
Easily replace old HDD Easily place this HDD to another motherboard

Tight Coupling:
Where is the video adapter? Can you change the video controller?
60

Loose Coupling Example

class Report { public bool LoadFromFile(string fileName) {} public bool SaveToFile(string fileName) {} } class Printer { public static int Print(Report report) {} } class Program { static void Main() { Report myReport = new Report(); myReport.LoadFromFile("C:\\DailyReport.rep"); Printer.Print(myReport); } }
61

Tight Coupling Example

class MathParams { public static double operand; public static double result; } class MathUtil { public static void Sqrt() { MathParams.result = CalcSqrt(MathParams.operand); } } class MainClass { static void Main() { MathParams.operand = 64; MathUtil.Sqrt(); Console.WriteLine(MathParams.result); } }
62

Spaghetti Code

Combination of bad cohesion and tight coupling:

class Report { public void public void public void public bool public void }

Print() {} InitPrinter() {} LoadPrinterDriver(string fileName) {} SaveReport(string fileName) {} SetPrinter(string printer) {}

class Printer { public void SetFileName() {} public static bool LoadReport() {} public static bool CheckReport() {} }
63

Summary

OOP fundamental principals are: inheritance, encapsulation, abstraction, polymorphism

Inheritance allows inheriting members form another class
Abstraction and encapsulation hide internal data and allow working through abstract interface Polymorphism allows working with objects through their parent interface and invoke abstract actions

Strong cohesion and loose coupling avoid spaghetti code

64

Object-Oriented Programming Fundamental Concepts

Questions?
http://academy.telerik.com

Exercises
1.

We are given a school. In the school there are classes of students. Each class has a set of teachers. Each teacher teaches a set of disciplines. Students have name and unique class number. Classes have unique text identifier. Teachers have name. Disciplines have name, number of lectures and number of exercises. Both teachers and students are people. Your task is to identify the classes (in terms of OOP) and their attributes and operations, define the class hierarchy and create a class diagram with Visual Studio.
66

Exercises (2)
2.

Define class Human with first name and last name. Define new class Student which is derived from Human and has new field grade. Define class Worker derived from Human with new field weekSalary and work-hours per day and method MoneyPerHour() that returns money earned by hour by the worker. Define the proper constructors and properties for this hierarchy. Initialize an array of 10 students and sort them by grade in ascending order. Initialize an array of 10 workers and sort them by money per hour in descending order.
67

Exercises (3)
3.

Define abstract class Shape with only one virtual method CalculateSurface() and fields width and height. Define two new classes Triangle and Rectangle that implement the virtual method and return the surface of the figure (height*width for rectangle and height*width/2 for triangle). Define class Circle and suitable constructor so that on initialization height must be kept equal to width and implement the CalculateSurface() method. Write a program that tests the behavior of the CalculateSurface() method for different shapes (Circle, Rectangle, Triangle) stored in an array.
68

Exercises (4)
4.

Create a hierarchy Dog, Frog, Cat, Kitten, Tomcat and define suitable constructors and methods according to the following rules: all of this are Animals. Kittens and tomcats are cats. All animals are described by age, name and sex. Kittens can be only female and tomcats can be only male. Each animal produce a sound. Create arrays of different kinds of animals and calculate the average age of each kind of animal using static methods. Create static method in the animal class that identifies the animal by its sound.
69

Exercises (5)
5.

A bank holds different types of accounts for its customers: deposit accounts, loan accounts and mortgage accounts. Customers could be individuals or companies. All accounts have customer, balance and interest rate (monthly based). Deposit accounts are allowed to deposit and with draw money. Loan and mortgage accounts can only deposit money.

70

Exercises (6)
All accounts can calculate their interest amount for a given period (in months). In the common case its is calculated as follows: number_of_months * interest_rate. Loan accounts have no interest for the first 3 months if are held by individuals and for the first 2 months if are held by a company. Deposit accounts have no interest if their balance is positive and less than 1000. Mortgage accounts have interest for the first 12 months for companies and no interest for the first 6 months for individuals.
71

Exercises (7)
Your task is to write a program to model the bank system by classes and interfaces. You should identify the classes, interfaces, base classes and abstract actions and implement the calculation of the interest functionality.

72