Object Oriented Programming Paradigm

Time to add another post under Programming Paradigms and here, let’s talk about Object Oriented Programming Paradigm. But before that, optionally, take a look at Imperative Programming Paradigm for more context.

What is Object Oriented Programming?

One of the most commonly used paradigm out there today is the Object Oriented Programming Paradigm (OOPP). An object is something bundles data and procedures within itself. Objects are the protagonist in this paradigm. The program is revolves around objects where the programmer writes code to create objects and tell them how to communicate with each other. This interaction between objects changes the state of the program eventually leading to the end result.

How does Object Oriented Programming work?

In OOPP, objects are modeled based on real-world entities. Just like how real-world entities interact with each other, the objects in an application communicates between each other. By interacting, real-world entities reach the final state and similarly, by communicating, the objects change the state of the application, eventually achieving the final result.

Modification of program state by the interactions and communications between objects to get the end result is the OOP style of programming.

Class-based and Prototype-based OOPP

In OOPP, objects are the protagonists and there are two ways to create objects. This is based on the style of programming dividing OOPP into two sub-paradigms.

• Class-based programming
• Prototype-based programming

If you have worked with Java, then you must be familiar with classes. Similarly, if you have worked with JavaScript, then you must be familiar with prototypes.

Class-based programming

In class-based programming, classes defines the structure of objects, i.e., it defines what variables and procedures should an object hold. An object created for a class will have it’s own identity and becomes an instance of the class. I’ll be talking more about class in under building blocks of OOPP.

Prototype-based programming

Prototype-based programming works by cloning and extending existing objects and there is no concept of class. Inheritance is by reusing existing objects that serves as prototypes.

Now, let’s dive deeper into OOPP. For this post, I’ll explain OOPP with examples based on class-based programming using Java since I have future plans for prototype-based programming.

Building Blocks of Object Oriented Programming

There are 4 building blocks for OOPP.

1. Class
2. Object
3. Attribute
4. Procedure

Class

As discussed earlier, a class is a blueprint that defines the structure of an object. By structure, I mean details like what data should the object hold and what procedures it can perform.

Let’s design a class for a real-world object. The below is the code to design a class for Car.

class Car {
    String model;
    String manufacturer;
    String color;
    boolean isDoorOpen;

    void openDoor() {
        this.isDoorOpen = true;
    }
    
    void closeDoor() {
        this.isDoorOpen = false;
    }

    void drive(String destination) {
        // do some driving
    }
}

Here, Car is a blueprint that defines the structure of a car object. It defines what attributes and procedures that the object should have. This makes the code more reusable since I can create n number of objects for this blueprint. Reusability is one of the virtues of OOPP. Note that while a real-world entity can have any number of attributes and can perform any number of actions, we do not have to model classes with all the attributes and actions. It is a good practice to design objects with data and procedures that are just enough for the application.

Object

In general, an object is a variable in the memory. In addition to that, in OOPP, an object contains a set of attributes (variables) and procedures (methods). The structure of an object is based on the class in class-based programming. The beauty is, the object can use it’s procedures to modify it’s attributes. Such modifications changes it’s state, eventually, leading to the end result. This makes OOPP stateful.

Usually in OOPP, objects are used to model real world elements. In a different perspective, we can say that our world is one giant application where everything in it are objects, including us. If we are objects, data like our name, age, gender, address, college degree becomes our attributes and our actions like walk, talk, run becomes our procedures. In a computer program, we can model objects based anything in the real-world.

Car carOne = new Car();         // created new object carOne
// Setting the state of the object.
carOne.model = "Carrera GT";
carOne.manufacturer = "Porsche";
carOne.color = "Guards Red";
carOne.numberOfSeats = 2;

In the above example, I created an object carOne for our class Car and set values to the attributes of the object. This sets up a state for the object. Now we know details of the car through these attributes. With the class Car as a blueprint, any number of objects with it’s own version of attributes and procedures can be created.

Note that we are using the dot operator on the variable to access it’s attributes. An object’s attributes and procedures can be accessed only by using the dot operator.

The dot operator, also known as separator or period used to separate a variable or method from a reference variable.

What is an instance?

The English dictionary says, an instance is single occurrence of something. In programming, an instance is a single occurrence of a class. Technically, an instance is an object. While objects refer to all the objects in general, an instance refers to a specific representation of an object. Like our class Car, we can create several other classes like Plane, Boat, Bike, etc. Each of these classes can have many number of objects. Regardless of the class, all the objects are termed as “objects”. But from our previous example, carOne is an object but an instance of Car.

In the previous example, I created the object carOne using the new keyword and assigned the newly created object to the variable carOne by using = operator. By using new keyword, we create a new “instance” of the class Car, allocating memory to the instance. Memory to an instance is allocated only when it is created. This process is called instantiating a class. Based on the variables bundled inside, the memory size of an instance varies.

Each instance is unique and has it’s own place in the memory having it’s own version of attributes and procedures.

Car carOne = new Car();
carOne.model = "Carrera GT";

Car carTwo = new Car();
carOne.model = "Gallardo";

Car carThree = new Car();
carOne.model = "Mustang";

In the above example, we create 3 instances, carOne, carTwo and carThree, for the class Car. Each object will have it’s own version of the attribute model.

The above image is a rough representation of how these objects will be in the memory. When an instance is created, the variables inside the instance are also instantiated and allocated memory. When I access the variable model bundled inside carOne with the statement carOne.model, the program will navigate through the addresses to get the actual value. For the statement carOne.model, the value at address 300 is accessed since the model bundled inside carOne points to 300 but it cannot access 301 since it belongs to carTwo.

class Car {
    private String color;

    public void setColor(String color) {
        color = color;          // The variable color is in the procedure's scope. This doesn't work.
        this.color = color;     // 'this.color' is the instance level variable and 'color' is in method's scope
    }
}

Car carOne = new Car();         // created new object carOne
// Setting the state of the object.
carOne.model = "Carrera GT";
carOne.color = "Guards Red";

Procedure

A procedure, is a series of steps that can compute on the given data. They contain step-by-step instructions on how the computation should be done. Note the word “how“. That’s because Procedural Paradigm is a subset of Imperative Programming Paradigm.

Huh.. wait what? Weren’t we talking about OOPP? Where did Procedural Paradigm came from?

😅 yeah.. Procedures are part of Procedural Programming which is a sub-paradigm of Imperative Paradigm like Object Oriented Programming. Both Procedural and OOPP are siblings under Imperative Paradigm.

In Procedural Paradigm, there are no objects and the procedures existence is independent/standalone. They compute on the variables passed to them and return the result. Think of functions in functional programming.

An example

function add(var1, var2) {
    return var1 + var2;
}

add(1, 2)    // returns 3

In the above example, the procedure add is independent. It computes on the input variables to return the result.

But in OOPP, the procedures and the variables are bundled inside an object. The procedures in OOPP are,

1. Tied to the object, hence they are not independent anymore.
2. Can compute only on the variables of the object.
3. Only the object can invoke the procedure.

class Counter {
    int total;

    public void increment() {
        this.total++;
    }
}

public class Oopp {
    public static void main(String[] args) {
        Counter counter = new Counter();
        counter.increment();                            // increments count to 1
        counter.increment();                            // increments count to 2
        System.out.println("Count: " + counter.total);  // prints 2
    }
}

In the above example program, I have a class Counter and I have created an object counter for it in the main method. Now note the below points.

1. The class Counter has a procedure increment and an attribute total.
2. The procedure increment can only be invoked by the object counter.
3. The object counter uses the procedure increment to perform computation on it’s own attribute total. This changes the state of the object counter.

So, in OOPP, only an object can operate it’s procedures on itself, changing it’s state or the state of the program.

Concepts of Object Oriented Programming

The below is a list of basic concepts in OOPP. Out of the 6 below, we already covered class and object above. Let’s see the remaining 4.

• Class
• Object
• Inheritance
• Encapsulation
• Abstraction
• Polymorphism

class Human {
    String name;
    String gender;
    int age;
    String collegeDegree;

    public void walk() {}
    public void run() {}
    public void readBook() {}
}

class Dog {
    String name;
    String gender;
    int age;
    String breed;

    public void walk() {}
    public void run() {}
    public void wagTail() {}
}

class Animal {
    String name;
    String gender;
    int age;

    public void walk() {}
    public void run() {}
}

class Human extends Animal {
    String collegeDegree;
    public void readBook() {}
}

class Dog extends Animal {
    String breed;
    public void wagTail() {}
}

class Counter {
    int total;

    public void increment() {
        this.total++;
    }
}

public class Oopp {
    public static void main(String[] args) {
        Counter counter = new Counter();
        counter.increment();                            // increments count to 1
        counter.increment();                            // increments count to 2
        System.out.println("Count: " + counter.total);  // prints 2
    }
}

// ...
System.out.println("Count: " + counter.total);  // prints 2
counter.total = 1000;
System.out.println("Count: " + counter.total);  // prints 1000
// ...

class Counter {
    private int total;

    public void increment() {
        this.total++;
    }

    public int getTotal() {
        return total;
    }
}

public class Oopp {
    public static void main(String[] args) {
        Counter counter = new Counter();
        counter.increment();                                // increments count to 1
        counter.increment();                                // increments count to 2
        System.out.println("Count: " + counter.total);      // compile time error
        System.out.println("Count: " + counter.getTotal()); // prints 2
    }
}

class Customer {
    private String name;
    private String address;
    private int phoneNumber;
    private String favoriteMovie;
    private String collegeDegree;
    private String maritalStatus;

    // rest of the code
}

class Human {
    String collegeDegree;
    private String favoriteMovie;
    private String maritalStatus;

    // rest of the code
}

class Customer extends Human {
    private String name;
    private String address;
    private int phoneNumber;

    // rest of the code
}

class Human {
    public void performAction() {
        // live daily life
    }
    // rest of the code
}

class Teacher extends Human {
    @Override
    public void performAction() {
        // Teach students
    }
    // rest of the code
}

class Student extends Human {
    @Override
    public void performAction() {
        // Learn from teachers
    }
    // rest of the code
}

class Counter {
    private int total;

    public void increment() {
        this.total++;
    }

    public void increment(int delta) {
        this.total = this.total + delta;
    }

    public int getTotal() {
        return total;
    }
}

public void increment() {
    this.total++;
}
public void increment(int delta) {
    this.total = this.total + delta;
}
public void increment(String delta) {
    int intDelta = Integer.parseInt(delta);
    this.total = this.total + intDelta;
}

Advantages and disadvantages of Object Oriented Programming

Advantages

1. Objects are modeled based on real-world entities which helps to write modular codes. While defining behavior of an object, the programmer doesn’t have to consider the behavior of other objects.
2. Extensibility is another advantage of OOP. When we need to add more procedures or attributes to an object, the programmer can simply define a new one extending the older one.
3. The fundamental concepts encourage reusability in OOP. An object can be reused across the project.
4. Modularity, extensibility and reusability helps in faster and low-cost development.

Disadvantages

1. Object Oriented Programming requires the programmer to have an object-oriented thinking which might not be easy for few.
2. It is not suitable for all types of problems. It is more suitable for larger applications.

Object oriented programming and gaming

As a gamer, I wanted to add this part to this post 😁. Most of the video games are object oriented. I’d take Grand Theft Auto series for example. It has various objects like vehicles, weapons, people, mobile phones, etc. Each object have their own properties, procedures and a state. For example, let’s take a car.

A car in the game have it’s own color, top speed limit, type, durability, number of seats, etc. They can have procedures like accelerate, stop, open door, start, close door, explode, etc. We can even paint the car and it’s state will be maintained throughout the game or till it’s destroyed. The concepts of OOP would have applied for this code as well where class for Car would have inherited from a parent class Vehicle, overriding or overloading some of it’s methods.

What’s next?

Read how functions differ from methods in this post.

Check out other paradigms below.

• Imperative Programming Paradigm
• Declarative Programming Paradigm
• Functional Programming Paradigm

I hope this post was helpful 😊. If you find this post informative, support us by sharing this with fellow programmers in your circle 😀.

For any suggestions, improvements, reviews or if you like us to cover a specific topic, please leave a comment.
Follow us on twitter @thegeeksclan and in Facebook.
#TheGeeksClan #DevCommunity