Object oriented programming Fundamental Concepts

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
2

Classes and Interfaces
 Classes define attributes and behavior
 Fields, properties, methods, etc.
 Methods contain code for execution
 Interfaces define a set of operations
 Empty methods and properties, left to be
implemented later
4
public class Labyrinth { … }
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
5

Types of Inheritance
 Inheritance terminology
derived class
base class /
inherits parent class
class implements interface
derived interface implements base interface
6

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)
7

Inheritance – Example
Person
+Name: String
+Address: String
Derived class Derived class
Employee
+Company: String
+Salary: double
Base class
Student
+School: String
8

Class Hierarchies
 Inheritance leads to a hierarchy of classes
and/or interfaces in an application:
9
Game
MultiplePlayersGame
BoardGame
Chess Backgammon
SinglePlayerGame
Minesweeper Solitaire …
…

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>
10

How to Define Inheritance?
 We must specify the name of the base class after
the name of the derived
 In the constructor of the derived class we use the
keyword base to invoke the constructor of the base
class
11
public class Shape
{...}
public class Circle : Shape
{...}
public Circle (int x, int y) : base(x)
{...}

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!");
}
}
12

Simple Inheritance Example
p(ub2l)ic 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...");
}
}
13

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
15

Inheritance and
class Accessibility 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
}
16

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
}
}
17

Inheritance and
AcceLsivse iDebmiolity

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
19

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
20

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
22

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
23

Abstraction in .NET
 In .NET abstraction is achieved in several
ways:
 Abstract classes
 Interfaces
 Inheritance
Control
+click()
ButtonBase
+Color : long
Button RadioButton CheckBox
24

Abstraction in .NET –
Example
25
System.Object
System.MarshalByRefObject
System.ComponentModel.Component
System.Windows.Forms.Control
System.Windows.Forms.ButtonBase
System.Windows.Forms.Button

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
26

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
27

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>
28

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
29

UML Class Diagram – Example
30
Shape
#Position:Point
struct
Point
+X:int
+Y:int
+Point
interface
ISurfaceCalculatable
+CalculateSurface:float
Rectangle
-Width:float
-Height:float
+Rectangle
Square
-Size:float
+Square
FilledSquare
-Color:Color
+FilledSquare
struct
Color
+RedValue:byte
+GreenValue:byte
+BlueValue:byte
+Color
FilledRectangle
-Color:Color
+FilledRectangle

Class
Diagrams in
Visual
Studio
Live Demo

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
33

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; }
34

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
35

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
36

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
38

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
39

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 40

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
41

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
42

Polymorphism – Example
override CalcSurface()
{
return size * size;
}
override CalcSurface()
{
return PI * radius * raduis;
}
Abstract
class
Abstract
action
Concrete
class
Overriden
action
Overriden
action
Figure
+CalcSurface() : double
Square
-x : int
-y : int
-size : int
Circle
-x : int
-y : int
-radius: int
43

Polymorphism – Example (2)
44
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();

Class Hierarchies:
Real World Example

Real World Example:
Calculator
 Creating an application like the Windows
Calculator
 Typical scenario for applying the object-oriented
approach
47

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.
48

 So(m3e) 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
49

(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
50

Calculator Classes
51
TextBox
«interface»
IPaintable
Paint()
Control
-location
-size
-text
-bgColor
-faceColor
-font
Container
Form
Calculator
AbstractButton
Button CheckBox RadioButton
MainMenu MenuItem
Panel

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
53

Good and Bad Cohesion
 Good: hard disk, cdrom, floppy
 BAD: spaghetti code
54

Strong Cohesion
 Strong cohesion example
 Class Math that has methods:
Sin(), Cos(), Asin()
Sqrt(), Pow(), Exp()
Math.PI, Math.E
55
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);

Bad Cohesion
 Bad cohesion example
 Class Magic that has these methods:
 Another example:
56
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)
MagicClass.MakePizza("Fat Pepperoni");
MagicClass.WithdrawMoney("999e6");
MagicClass.OpenDBConnection();

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
57

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?
58

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);
}
}
59

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);
}
}
60

Spaghetti Code  Combination of bad cohesion and tight coupling:
61
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() {…}
}

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
62

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.
64

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.
65

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.
66

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.
67

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.
68

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.
69

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.
70

Object oriented programming Fundamental Concepts

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Object oriented programming Fundamental Concepts (20)

More from Bharat Kalia (10)

Recently uploaded (20)

Object oriented programming Fundamental Concepts

Editor's Notes