Object-Oriented

Programming
Fundamental Concepts

Svetlin Nakov
Telerik
Corporation
www.telerik.
com
 Contents
1. Fundamental Principles of OOP
2. Inheritance
3. Abstraction
4. Encapsulation
5. Polymorphism
6. Cohesion and Coupling

2
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
Inheritanc
e
 Classes and Interfaces
 Classes define attributes and
behavior
 Fields, properties, methods, etc.
 Methods contain
public class Labyrinth { … code
} for execution

 Interfaces define a set of

operations
 Empty methods and properties, left
public interface IFigure { … }
to be implemented later
6
 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
 Inheritance terminology

base class /
derived inherits parent class
class

class implements interface

derived implements base

interface interface

8
 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
Person class
+Name: String
+Address: String
Derived Derived
class class

Employee Student
+Company: String +School: String
+Salary: double

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 .NET’s 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 (int
public Circle constructor of the base
x, int y) : base(x)
class
{...}
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
Abstractio
n
 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
Control
 Interfaces +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»
 Example: IList<T>
+Add(item : Object)
+Remove(item : Object)
+Clear()
…

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 Shape struct
ISurfaceCalculatable Point
#Position:Point
+CalculateSurface:float +X:int
+Y:int

+Point

Square Rectangle struct

Color
-Size:float -Width:float
-Height:float +RedValue:byte
+Square +GreenValue:byte
+CalculateSurface:float
+Rectangle +BlueValue:byte
+CalculateSurface:float
+Color

FilledSquare FilledRectangle

-Color:Color -Color:Color

+FilledSquare +FilledRectangle

32
 Class
Diagrams
in Visual
Studio
Live Demo
Encapsulatio
n
 Encapsulation
 Encapsulation hides the
implementation details
 Class announces some operations
(methods) available for its clients –
its public interface
 All data members (fields) of a class
should be hidden
 Accessed via properties (read-only
and read-write)
 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 public
 Interface methods are always
public
 Not explicitly declared with public
 Non-interface methods are
declared private / protected 37
 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
Polymorphis
m
 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()
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
 You cannot override a non-virtual
or static method
 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
 Polymorphism is implemented using a
technique called late method binding
 Exact method to be called is determined
at runtime, just before performing the call
 Applied for all abstract / virtual methods
 Note: Late binding is slower than normal
(early) binding

44
 Polymorphism –
Example
Abstra
Figure Abstra
ct
ct
class +CalcSurface() : action
double

Concret
e class Square Circle
-x : int -x : int
Overrid -y : int -y : int Overrid
-size : -radius:
en int int
en
action action

override CalcSurface() override CalcSurface()

{ {
return size * size; 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
Polymorphis
m
Live Demo
 Class
Hierarchies:
Real World
Example
 Real World Example:
Calculator
 Creating an application like the
Windows Calculator
 Typical scenario for applying the
object-oriented 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
 Cohesion must be strong
 Well-defined abstractions keep
cohesion strong
 Classes must contain strongly related
functionality and aim for single
purpose
 Cohesion is a useful tool for
managing complexity 55
 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
 Coupling must be kept loose
 Modules must depend little on each
other
 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 Print() {…}
public void InitPrinter() {…}
public void LoadPrinterDriver(string fileName)
{…}
public bool SaveReport(string fileName) {…}
public void 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