OOPS - Introduction

Object Oriented Programming

What is OOP? - Introduction

This series will not be language -specific

Examples will be not require knowledge of the
language being used
What is OOP?

In order to understand what object oriented

programming is, It’s best to first understand what
objects are

In order to understand what objects are, it’s best to

first understand what primitive data types are
What is OOP? - Primitive Data

Primitive data types store single, simple values

Examples:
● Byte
● Int
● Float
● Boolean
● Double
● Char
What is OOP? - Primitive Data

Program at the time weren’t very complicated

compared to today standard

As programs became larger and more complex, only

using primitive data types wasn’t sufficient anymore

Programmers began to need to group similar pieces

of data together
What is OOP? - Chess Example
What is OOP? - The Structure

The Structure The Array

Stores many pieces of Stores many pieces of

data data

Can store different types Cannot store different

of data types of data
What is OOP? - The Structure

The Structure

Int Int

String double
What is OOP? - The Structure

Struct Knight

Position Color

Captured
What is OOP? - The Structure

Struct Knights

Knight 1 Knight 2

Knight 3 Knight 4
What is OOP? - The Structure
Struct Struct
WhiteKnights BlackKnights

Knight 1 Knight 2

Knight 3 Knight 4
What is OOP? - The Structure

The main issue with structures is that you cannot

define functions within one

Thinking about the chess example, this prevents you

from defining a function specific to the knights, such
as their move function, within the structure
What is OOP? - Objects

Objects are instances of a class

Classes are templates for objects

What is OOP? - Classes

Class knight

Function is specific to
move()
knights, as other pieces
move in a different
manner
What is OOP? - Classes

Class knight

move() position

Color and position are not initialized, as

color different instances of a knight will have
different values for these variables
What is OOP? - Classes
What is OOP? - Classes
What is OOP? - Classes
What is OOP? - Classes
What is OOP? - Classes

Whereas the knight class represents any given knight,

a knight, a knight object represents only one singular
knight
 What is OOP? - Classes

Object oriented programming helps programmers

create complex programs by grouping together related
data and functions

data function
data function
function data data function
data function data function
 Series - Overview

Throughout the video we will explain OOP using its

four main principles:
● Encapsulation
● Abstraction
● Inheritance
● Polymorphism
 Encapsulation - Introduction

Encapsulation refers to bundling data with methods

that can operate on that data within a class

Essentially, it is the idea of hiding data within a class,

preventing anything outside that class from directly
interacting with it
 Encapsulation - Introduction

This does not mean that members of other classes

cannot interact at all with the attributes of another
object
 Encapsulation - Introduction

Members of other classes can interact with the

attributes of another object through its methods

Remember, methods are the functions defined within

the class
 Encapsulation - Introduction

Getting Methods Setting Methods

Retrieving
Changing information
information
What is OOP? - Classes

piece.getColor()

Checks the color of any

given piece from
anywhere in the
program
 Encapsulation - Introduction

Setting methods also allow the programmer to easily

keep track of attributes that depend on one another

Method 1 Method 2
 Encapsulation - Game Example

Class Player

Player.maxHealth Player.levelUp()

Player.currentHealth Setting Method

 Encapsulation - Game Example

The setting method allows both attributes to be

changed as they should, rather than requiring you to
individually change them

currentHealth maxHealth
 Encapsulation - Game Example

The below example ensures that the change to the

attribute is within the bounds of what is allowed

def setCurrentHealth(newHealth):
player.currentHealth = newHealth
if player.currentHealth > player.maxHealth:
player.currentHealth = player.maxHealth
 Encapsulation - Methods

You may also want some attributes to be “read only”

from the outside

● To do this, you would define a getter method but not a setter

method

● The variable could only be referenced, not changed

 Encapsulation - Game Example

Class Piece

Piece.rank

Player.file
 Encapsulation - Game Example

Class Piece

Piece.rank

Player.file
 Encapsulation - Game Example

Class Piece

Piece.rank =newRank

Player.file =newFile
 Encapsulation - Game Example

Class Piece

Piece.rank =newRank

Player.file =newFile
 Encapsulation - Game Example

Class Piece

Piece.rank piece.move()

Allows validation and

can carry out other
Player.file methods
Encapsulation - Game Example
Encapsulation - Game Example
 Encapsulation - Information Hiding

It’s generally best to not allow external classes to

directly edit an object’s attributes

This is very important when working on large and complex programs

Each piece should not have access to or rely on the inner working of
other sections of code
 Encapsulation - Information Hiding

This idea will be revisited very soon

Information hiding, or keeping the data of one class hidden from

external classes, helps you keep control of your program and
prevent it from becoming too complicated
 Encapsulation - Overview

Encapsulation is a vital principle in Object Oriented

Programming

Encapsulation:

● Keeps the programmer in control of access of data

● Prevents the program from ending up in any strange or
unwanted states
Abstraction - Introduction

This segment we will be looking at the next of the four

principles of object - oriented programming:
Abstraction

Abstraction refers to only showing essential details

and keeping everything else hidden
Abstraction - Car Example

How the steering wheel

steers the car

How the gas and brake

pedals affect the car

Important to most people

How much gas your car
has
Abstraction - Car Example

How exactly the car

functions internally

As long as you
understand the outcome,
the process is not very Important to most people
important to you
Abstraction - Explanation

This idea extends to object-oriented programming

The classes you create should act like your car. Users
of your classes should not worry about the inner
details of those classes
Abstraction - Explanation

This is similar to encapsulation that was discussed last

video

Classes should not directly interact with other classes’

data

This is very important when working on your program

incrementally
Abstraction - Explanation

This is very important when working on your program

incrementally

Section 1 Section 2 Section 3

Abstraction - Interface and Implementation

Interface

Implementation
Abstraction - Interface and Implementation

The interface refers to the way sections of code can

communicate with one another

This typically is done through methods that each class is

able to access
Abstraction - Interface and Implementation

The implementation of these methods, or how these

methods are coded, should be hidden

Car moves
car.pushGas()
forward

The “how” is not important

Abstraction - Chess Example
Abstraction - Chess Example

Interface
Abstraction - Chess Example

information
King’s methods

Interface
Abstraction - Chess Example

information
King’s methods

Interface
information
King’s methods
Abstraction - Chess Example
King’s implementation is not
important to you
information
King’s methods

Interface
information
King’s methods
Abstraction - Interface and Implementation

Data 1 Data 1

Data 2 Data 2

Data 3 Data 3
Abstraction - Interface and Implementation

Data 1 Data 2

Data 2 Data 1

Data 3 Data 3
Abstraction - Interface and Implementation

Data 1 Data 2

Data 2 Data 1

Data 3 Data 3
Abstraction - Interface and Implementation

If classes are entangled, then one change creates a ripple

effect that causes many more changes

Creating an interface through which classes can interact

ensures that each piece can be individually developed
Abstraction - Overview

Abstraction allows the program to be worked on

incrementally and prevents it from becoming entangled and
complex

Determine specific points of contact that can act as an

interface between classes, and only worry about the
implementation when coding it
Inheritance - Introduction

This segment we will be looking at the next of the four main

principles of object - oriented programming: Inheritance

Inheritance is the principle that allows classes to derive

from other classes.
Inheritance - Game Example

Class weapon

Class Sword Class Club

Weapon damageType : “sharp” Weapon damageType : “blunt”

Inheritance - Game Example

Class weapon

Subclass Subclass

Subclasses inherit from superclass

Inheritance - Game Example

Any sword or club would require the methods and

attributes present in the weapon class in order to function

In most cases the class hierarchy you create will have

many more layers with many more classes in each layer
Inheritance - class Hierarchy

Class Weapon

Class Sword Class Club

Inheritance - Class Hierarchy
Class Item

Class Weapon Class Tool

Class Sword Class Club

Inheritance - Class Hierarchy
Class Item

Class Weapon Class Tool

Class Sword Class Club

Class Sword Class Sword

Inheritance - Class Hierarchy

The class hierarchy acts as a web of classes with different

relationships to one another

Superclass

Subclass Subclass
Inheritance - Access Modifiers

Access modifiers change which classes have access to

other classes, methods, or attributes

The three main access modifiers we will be covering are:

● Public
● Private
● Protected
Inheritance - Access Modifiers

Public members can be accessed from anywhere in your

program

This includes anywhere both inside of the class hierarchy

it is defined as well as outside in the rest of the program
Inheritance - Access Modifiers

Food

Fruit Vegetables

Apple Orange Broccoli

Inheritance - Access Modifiers

Food

Fruit Vegetables

Apple Orange Broccoli

Inheritance - Access Modifiers

Private members can only be accessed from within the

same class that the member is defined

This allows you to create multiple private members of the

same name in different locations so that they do not
conflict with one another
Inheritance - Access Modifiers

Food

Fruit Vegetables

Apple Orange Broccoli

Inheritance - Access Modifiers

Private members can only be accessed from within the

class it is defined, as well as any subclasses on that class.

This essentially makes protected members private to the

hierarchy in which they are defined
Inheritance - Access Modifiers

Food

Fruit Vegetables

Apple Orange Broccoli

Polymorphism - Introduction

Polymorphism describes methods that are able to take on

many forms

There are two types of polymorphism

The first type is known as dynamic polymorphism

Polymorphism - Introduction

Dynamic polymorphism occurs during the runtime of the

program

This type of polymorphism describe when a method

signature is in both a subclass and a superclass
Polymorphism - Introduction

The methods share the same name but have different

implementation

The implementation of the subclass that the object is an

instance of overrides that of the superclass
Polymorphism - Car Example

Class Car .drive()

Class sportsCar .drive()

Polymorphism - Car Example

Class Car Class sportsCar

.drive(miles) .drive(miles)

{ Car.gas -= 0.04 * { Car.gas -= 0.02 *

miles } miles }
Polymorphism - Car Example

Class Car Class sportsCar

.drive(miles) .drive(miles)

mySportsCar.drive()
Polymorphism - Car Example

Class Car Class sportsCar

.drive(miles) .drive(miles)

mySportsCar.drive()
Polymorphism - Car Example

Class Car Class sportsCar

.drive(miles) .drive(miles)

myCar.drive()
Polymorphism - Car Example

Class Car Class sportsCar

.drive(miles) .drive(miles)

myCar.drive()
Polymorphism - Dynamic

This works because the form of the method is decided

based on where in the class hierarchy it is called

The implementation of method signature that will be used

is determined dynamically as the program is run
Polymorphism - Car Example

Class Car

Class sportsCar

Class Porsche Class BMW

Polymorphism - Static

Static polymorphism occurs during compile-time rather

than during runtime

This refers to when multiple methods with the same name

but different arguments are defined in the same class
Polymorphism - Static

Ways to differentiate methods of the same name:

Polymorphism - Static

Ways to differentiate methods of the same name:

Different number of parameters

Polymorphism - Static

Ways to differentiate methods of the same name:

Different number of parameters

Different types of
parameters
Polymorphism - Static

Ways to differentiate methods of the same name:

Different number of parameters

Different types of Different order of
parameters parameters
Polymorphism - Static

This is known as method overloading

Despite the methods having the same name, their

signatures are different due to their different arguments
Polymorphism - Car Example

Class Car

1 .drive( int spd, string dest )

1 .drive( int spd, int dist ) myCar.drive( 45, “Work”

1 .drive( string dest, int spd )

Polymorphism - Car Example

Class Car

1 .drive( int spd, string dest )

1 .drive( int spd, int dist ) myCar.drive( 45, “Work”

1 .drive( string dest, int spd )

Polymorphism - Car Example

Class Car

1 .drive( int spd, string dest )

1 .drive( int spd, int dist ) myCar.drive( 45, “Work”

1 .drive( string dest, int spd )

Polymorphism - Car Example

Class Car

1 .drive( int spd, string dest )

1 .drive( int spd, int dist ) myCar.drive( 45, “Work”

1 .drive( string dest, int spd )

Polymorphism - Car Example

Class Car

1 .drive( int spd, string dest )

1 .drive( int spd, int dist ) myCar.drive( 45, “Work”

1 .drive( string dest, int spd )

Polymorphism - Car Example

Class Car

1 .drive( int spd, string dest )

1 .drive( int spd, int dist )
1 .drive( string dest, int spd )
Polymorphism - Overview

Overall, polymorphism allows methods to take on many

different forms

When utilizing polymorphism and method overloading, be

sure that your are calling the correct form the method