INTRODUCTION TO OOP

INTRODUCTION TO OOP

 Object-Oriented Programming (OOP) is the term used to describe a

programming approach based on objects and classes.
 The object-oriented paradigm allows us to organize software as a collection of
objects that consist of both data and behavior. This is in contrast to
conventional functional programming practice that only loosely connects data
and behavior.
 An object-oriented application uses a collection of objects, which communicate
by passing messages to request services.
 Objects are capable of passing messages, receiving messages, and processing
data.
INTRODUCTION TO OOP

 OOP allows decomposition of a problem into a number of entities called

objects and then builds data and behaviors around these objects.
 The software is divided into a number of small units called objects. The data and
behaviors are built around these objects.
 The data of the objects can be accessed only by the behaviors associated with that
object.
 The behaviors of one object can access the behaviors of another object.
BRIEF HISTORY OF OOP
 Simula 67 – the first OO programming language; extension of ALGOL60
 Smalltalk – conceived by Alan Kay (Smalltalk-72, Smalltalk-80); dynamically typed;
Strongtalk (1993) – Smalltalk + type system
 mid 80’s – many languages added support for OO: Objective C, C++, Object Pascal,
Modula 3, Oberon, Objective CAML, CLOS.
 Eiffel – Bertrand Meyer (1988) – Pascal-like syntax, design-by-contract
 Other “exotic” OO languages: Sather, Trellis/Owl, Emerald, Beta (evolution of
Simula), Self
 Java – James Gosling (1995); Java 1.5 (2004) – support for generic programming
 (Theoretical) extensions to Java: e.g. GJ (1998)
PROCEDURAL VS. OBJECT-ORIENTED PROGRAMMING

 Object-oriented programming is the successor of procedural (structural)

programming.
 Procedural programming describes programs as groups of reusable code units
(procedures) which define input and output parameters.
 Procedural programs consist of procedures, which invoke each other.
 In procedural languages (i.e. C), procedures are a sequence of imperative
statements, such as assignments, tests, loops and invocations of sub procedures.
 These procedures are functions, which map arguments to return statements.
PROCEDURAL VS. OBJECT-ORIENTED PROGRAMMING

 The problem with procedural programming is that code reusability is hard and
limited.
 The difficulties with this type of programming, is that software maintenance can be
difficult and time consuming.
 When changes are made to the main procedure (top), those changes can cascade to
the sub procedures of main, and the sub-sub procedures and so on, where the change
may impact all procedures in the pyramid.
 The aim of object-oriented programming is to try to increase the flexibility and
maintainability of programs. Because programs created using an OO language are
modular, they can be easier to develop, and simpler to understand after development.
OOP FUNDAMENTAL: UNDERSTANDING CLASS &
OBJECT

 In object-oriented terminology, a class is a template for defining objects.

Class defines object data (attributes/properties) & object behaviors
(methods/functions).
 Multiple objects, or instances of a class can be created from a single
class.
OOP FUNDAMENTAL: CLASS

 Class is a Template/Blueprint/Plans for defining objects.

 Classes describes the characteristics of the object – in JAVA programming
they are referred as data or field – private double price;
 Classes describes the behaviors of the object – in JAVA programming its
called methods – public int getUpdate(){return d;};
 Data and Methods can be visible only within the scope of the class, which
declared them and their descendants (private / protected), or visible to all
other classes (public) – Access Modifier.
OOP FUNDAMENTAL: OBJECT

 Objects are instances of classes or the realization of the classes.

 Objects are units of abstraction.
 Object can communicate with other objects using messages. It can passes a
message to another object, which results in the invocation of a method.
Objects then perform the actions that are required to get a response from the
system.
 Software objects are conceptually similar to real world objects. An object
stores its state in fields/data, and it exposes its behaviors through its methods.
 Example – Car proton = new Car();
CLASS VS OBJECT
CLASS VS OBJECT
 OOP & JAVA
 Class Example  Object Example
public class Car { public class CarApp {
private String model; public static void main(String[] args) {
private double cc;
Car proton = new Car();
public Car() { Car nissan = new Car();
this.model = “model”;
this.cc = 1.3; proton.move();
} nissan.move();
}
public void move() { }
System.out.println(“Vrom-vrom”)
}
}
FOUR PRINCIPLES OF OOP

 In order for a programming language to be object-oriented, it has to

enable working with classes and objects as well as the implementation
and use of the fundamental object-oriented principles and concepts:
Inheritance, Abstraction, Encapsulation and Polymorphism.
FOUR PRINCIPLES OF OOP: INHERITANCE

 Inheritance is a way to reuse a written code, and used is it again and

again.
 The class which is inherited is called the Base class & the class which
inherits is called the Derived class. They are also called parent/super and
child/sub class.
 Derived class inherits a base class, the derived class can use all the
methods which are defined in base class, hence making code reusable.
FOUR PRINCIPLES OF OOP: ENCAPSULATION
 The action of enclosing something in or as if in a capsule.
 Hide unnecessary details in the classes and provide a clear and simple interface for
working with them.
 It describes the idea of bundling data and methods that work on that data within one unit,
e.g., a class in Java.
 This concept is also often used to hide the internal representation, or state, of an object
from the outside - This is called Information Hiding.
 Getter method retrieves an attribute; Setter method changes it – Implement this
information-hiding mechanism by making your class data inaccessible from the outside
and by providing getter and/or setter methods for data that shall be readable or updatable
by other classes.
FOUR PRINCIPLES OF OOP: ABSTRACTION

 “An abstraction denotes the essential characteristics of an object that

distinguish it from all other kinds of object and thus provide crisply
defined conceptual boundaries, relative to the perspective of the viewer”
— G. Booch.
 Abstraction is the process of hiding all but the relevant information
about a thing to make things less complex and more efficient for the user
– shows only essential characteristics.
FOUR PRINCIPLES OF OOP: POLYMORPHISM

 Methods with same name but different arguments, which will perform
different actions – methods with same name, but functioning in different
ways.
 Polymorphism means one name, many forms.
 There are 2 basic types of polymorphism – Overloading & Overriding.
ACCESS MODIFIERS OF CLASS MEMBERS

 Java provides a number of access modifiers to set access levels for

classes, variables, methods, and constructors. The four access levels are:-
 Visible to the package, the default. No modifiers are needed.
 Visible to the class only – private .
 Visible to the world – public.
 Visible to the package and all subclasses – protected.
ACCESS MODIFIERS OF CLASS MEMBERS