Basic Building Blocks of OOP

1. Basic Building Blocks of OOP
Muhammad Hammad Waseem
m.hammad.wasim@gmail.com

2. Basic Building Blocks of OOP
• Object-oriented programming (OOP) involves programming using
objects.
• An object represents an entity in the real world that can be distinctly
identified.
• For example, a student, a desk, a circle and button all be viewed as objects.
• An object has a unique identity, state, and behaviors.
• The state of an object consists of a set of data fields (also known as
properties) with their current values.
• The behavior of an object is defined by a set of functions.

3. Objects
• An object can be a variable, a data structure, or a function.
• In the class-based object-oriented programming paradigm, "object"
refers to a particular instance of a class
• where the object can be a combination of
• variables,
• functions, and
• data structures.

4. Objects

5. Classes
• A class is a blueprint for creating many similar objects.
• The created object is an instance of that class.
• Objects created from the same class will have the same basic
structure and functionality.
• All cars created from the same Ford Escort blueprints will look and work
basically the same.
• Many instances can be created from a single class.
• Just as many Ford Escorts can be created from the same set of Ford Escort
blueprints.

6. Classes and Instances

7. Instance Variables
• An instance variable (attribute) of an object is a piece of information
attached to an instance (object).
• The name of a Person object, the model and year of a Car object, etc.
• The instance variables that an object has are defined in the object's
class:
• An object can usually have many instance variables, of many different types.
• Each object is given its own private space to hold its instance
variables.
• Assigning a new value to an instance variable of one object does not
affect the instance variables of any other object.

8. Instance Methods
• When we define objects, we usually have an idea of what we want to
do with them...
• – I'm dealing with Person objects in an employee database... I want to be able
to ask each Person object their name, weight, and age.
• – I'm dealing with Car objects in a driving simulation... I want to be able to
start a Car, change its speed, turn its steering wheel, etc.
• An action that involves a single object is usually implemented as a
special kind of function/subroutine attached to that object's class,
called an instance method (or, more commonly, just a method).

9. An OO bestiary

10. Constructor
• As mentioned before, constructors are special functions (usually class
or instance methods) used to initialize or return a new object.
• Depending on the OO environment, a class might have many
constructors, each of which builds an object a different way.
• Different constructors might have the same name but be
distinguished by having different numbers/types of their arguments.

11. Sample Constructor
• In C++, constructors are special unnamed instance methods, invoked
when you declare object variables:
// Create a Person from nothing:
Person anonymous;
// Create a Person from name, age, and weight:
Person nsolo("Napoleon Solo", 35, 190.0);
// Create a Person from another Person:
Person clone(nsolo);

12. Destructor
• Objects often end their lives be being explicitly deleted (C++), going
out of scope (C++).
• We sometimes want to get control of the object just before it
vanishes, to clean up after it properly:
• – We may have opened files, which we want to close.
• – We may have allocated memory, which we want to free.
• The special instance method invoked just as an object is about to
disappear is called the destructor.
• Classes generally have one destructor, which takes no arguments.

13. OO Features/Benefits
• Encapsulation
• Polymorphism
• Subclasses and inheritance
• Abstract/concrete classes
• Static/dynamic binding

14. Encapsulation
• Encapsulation means that some or all of an object's internal structure
is "hidden" from the outside world.
• Hidden information may only be accessed through the object's
methods, called the object's public interface.
• Access to object is safe, controlled.
• Methods, like instance variables, may also be hidden to create private
"helper functions".
• Analogy:
• ATM machine can only update accounts of one person or object only.

15. Encapsulation

16. Polymorphism
• Literally, "one entity, many forms.“
• Means the same name can be assigned to different functions/methods:
• The actual function triggered by the name is determined by the types of the arguments.
• Sometimes called overloading.
• Allows designers to use the most "natural" and understandable names for functions:
• Analogy:
• In English, bank can mean side of a river or a place to put money.

17. With/without polymorphism
• Without polymorphism, we need a unique name for every function:
• With polymorphism, we can use natural names and operators,
shrinking code and increasing readability:

18. Subclasses
• It is often desirable to create a new class which is a special case of an
existing class, possibly with some small changes in structure or
methods:
• To re-use the existing code, make the new class a subclass of the
existing one...

19. Subclasses and inheritance
• If class C is a subclass of class P, then C is a child class of P, and P is a
parent class or superclass of C.
• A child class automatically inherits all the structure and functionality
of its parent class.
• When defining a subclass, you will usually choose to:
• – Add new instance variables and methods.
• – Override some methods of the parent class, providing new methods.
• – Exclude some of the instance variables and methods of the parent class.

20. Adding structure/behavior in subclasses
• When you specify instance variables/methods in a child class that are
not present in the parent class, instances of the child class get the
new structure and functionality in addition to what they would get
from the parent alone:

21. Overriding behavior in subclasses
• When you specify a method in a child class that already exists in the
parent class, the child's method overrides the parent's method:
instances of the child will execute the child's method.

22. Overriding with default behavior
• Sometimes it is desirable to override a parent's method, and yet also
to invoke the parent's method to do some of the work:

23. Class hierarchies
• Usually, a class can have many child classes, each of which can have
their own child classes. A "family tree" of all the classes in a program
is called a class hierarchy...

24. Inheritance schemes
• One important way we characterize an OO language is by the kind of
inheritance we are allowed to use...

25. Abstract classes vs. Concrete classes
• Abstract classes are classes which do not have instances of their own
• They exist solely so that their child classes may inherit structure and/or
functionality.
• Concrete classes are classes which may have instances.
• A concrete class may also have child classes.

26. Static binding vs Dynamic binding
• In Static Binding, objects don't keep track of their types:
• – An object's class (and, therefore, its behavior) is determined at compile
time by the class of the variable it's placed in (or referenced through).
• In Dynamic Binding, objects know their types:
• – An object's class is determined at run-time. Not affected by the class of the
variable the object it's placed in (or referenced through).