{"id":3814,"date":"2025-01-01T09:00:00","date_gmt":"2025-01-01T04:00:00","guid":{"rendered":"https:\/\/afzalbadshah.com\/?p=3814"},"modified":"2025-09-15T09:10:18","modified_gmt":"2025-09-15T04:10:18","slug":"introduction-to-object-oriented-programming-oop","status":"publish","type":"post","link":"https:\/\/afzalbadshah.com\/index.php\/2025\/01\/01\/introduction-to-object-oriented-programming-oop\/","title":{"rendered":"Introduction to Object-Oriented Programming (OOP)"},"content":{"rendered":"\n

Object-Oriented Programming, or OOP, is a way of writing programs by focusing on real-life objects. In the real world, everything we deal with is an object, such as a car, a book, or a student. Each of these objects has certain features and can perform specific actions. In OOP, we try to represent these features as attributes<\/strong> and the actions as functions<\/strong>. The detailed tutorial can be visited here. <\/a><\/p>\n\n\n\n

This programming style helps us organize our code in a way that is closer to how we understand things in real life. It makes large programs easier to design, manage, and extend<\/p>\n\n\n\n

Aspect<\/strong><\/th>Procedural Programming<\/strong><\/th>Object-Oriented Programming (OOP)<\/strong><\/th><\/tr><\/thead>
Approach<\/strong><\/td>Top-down<\/td>Bottom-up<\/td><\/tr>
Structure<\/strong><\/td>Program is divided into functions<\/td>Program is divided into objects and classes<\/td><\/tr>
Data & Functions<\/strong><\/td>Data and functions are separate<\/td>Data and functions are bundled together in objects<\/td><\/tr>
Reusability<\/strong><\/td>Limited<\/td>High (through inheritance and modularity)<\/td><\/tr>
Security<\/strong><\/td>Less secure (data is exposed)<\/td>More secure (data hidden using encapsulation)<\/td><\/tr>
Real-world Modeling<\/strong><\/td>Difficult to model real-world scenarios<\/td>Easier to model real-world entities and interactions<\/td><\/tr>
Examples<\/strong><\/td>C, Pascal<\/td>Java, C++, Python (with OOP), C#<\/td><\/tr>
Function Reuse<\/strong><\/td>Uses functions repeatedly<\/td>Uses objects and methods repeatedly<\/td><\/tr>
Code Maintenance<\/strong><\/td>Harder to manage and scale in large programs<\/td>Easier to manage due to modular structure<\/td><\/tr>
Main Focus<\/strong><\/td>Focuses on functions (actions)<\/td>Focuses on objects (entities)<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n

What is OOP?<\/h2>\n\n\n\n

Object-oriented programming is a programming model that allows developers to organize and build programs around real-world concepts. In this model, we define objects that contain both data (attributes) and actions (functions or methods).<\/p>\n\n\n\n

The main concepts of OOP are:<\/p>\n\n\n\n

    \n
  • Classes\n
      \n
    • Objects<\/li>\n\n\n\n
    • Attributes<\/li>\n\n\n\n
    • Functions<\/li>\n<\/ul>\n<\/li>\n\n\n\n
    • Encapsulation<\/li>\n\n\n\n
    • Inheritance<\/li>\n\n\n\n
    • Polymorphism<\/li>\n<\/ul>\n\n\n\n

      Each of these will be explained step-by-step below.<\/p>\n\n\n\n

      \"\"
      What is OOP?<\/figcaption><\/figure>\n\n\n\n

      Why Use Object-Oriented Programming (OOP)?<\/h3>\n\n\n\n

      OOP<\/strong> offers several significant advantages that make it a popular programming paradigm:<\/p>\n\n\n\n

      Reusability:<\/strong> One of the core benefits of OOP is code reusability<\/strong>. Through inheritance<\/strong>, new classes can be created based on existing ones, inheriting their properties and methods. This means that you can reuse code from previously developed classes, saving time and effort.<\/p>\n\n\n\n

      Modularity:<\/strong> OOP promotes modularity<\/strong> by breaking down complex problems into smaller, more manageable objects. Each object encapsulates its data and behavior, making it easier to understand, modify, and test independently. This modular approach improves code organization and maintainability.<\/p>\n\n\n\n

      Maintainability:<\/strong> OOP code is generally easier to maintain<\/strong> than procedural code. The encapsulation of data and behavior within objects helps to isolate changes, making it less likely that modifications in one part of the code will have unintended consequences in another. This reduces the risk of introducing bugs and makes it easier to update and extend the software over time.<\/p>\n\n\n\n

      Flexibility:<\/strong> Polymorphism<\/strong> is a fundamental concept in OOP that allows objects of different classes to be treated as if they were of the same type. This provides flexibility<\/strong> and adaptability<\/strong> in your code. For example, you can create a function that takes a generic object as an argument, and it can work with objects of different classes as long as they have the necessary methods.<\/p>\n\n\n\n

      Key Concepts in Object-Oriented Programming (OOP)<\/h2>\n\n\n\n
      \"\"
      Key concepts of OOP<\/figcaption><\/figure>\n\n\n\n

      Class <\/strong>is the template, design or blueprint for creating real-world objects. It defines what attributes and functions an object will have, but it doesn\u2019t store real data itself.<\/p>\n\n\n\n

      Objects<\/strong> are instances of a class. They possess specific attributes<\/strong> (properties) and behaviors<\/strong> (methods). Each object has a unique identity, allowing it to be distinguished from others. For example my car is an object of the class car. <\/p>\n\n\n\n

      Encapsulation<\/strong> is the practice of hiding the internal implementation details of an object<\/strong>. This is achieved through access control<\/strong> mechanisms that determine how other parts of the program can interact with an object’s properties and methods. Encapsulation promotes modularity<\/strong> and maintainability<\/strong> by making objects more self-contained and easier to understand and modify. In example fo the car, the controls hides the inner functinalities of the car.<\/p>\n\n\n\n

      Inheritance<\/strong> is a mechanism that allows you to create new classes based on existing ones<\/strong>. The new class has an “is-a” relationship<\/strong> with the parent class, meaning it is a specialized version of the parent class. Inheritance promotes code reuse<\/strong> by allowing you to avoid duplicating code. For examole, animal is a base class and we create its subclass ‘cow’, which will inherit the functionalities of inheritance. <\/p>\n\n\n\n

      Class<\/h2>\n\n\n\n

      A class is like a blueprint<\/strong> or design<\/strong> for creating objects. It defines what attributes and functions an object will have, but it doesn\u2019t store real data itself.<\/p>\n\n\n\n

      \"\"
      Representation of class in OOP<\/figcaption><\/figure>\n\n\n\n

      For example, a Student<\/code> class can define:<\/p>\n\n\n\n

        \n
      • Attributes like name<\/code>, rollNo<\/code>, and department<\/code><\/li>\n\n\n\n
      • Functions like giveExam()<\/code> and submitAssignment()<\/code><\/li>\n<\/ul>\n\n\n\n

        You can then create many student objects from this one class.<\/p>\n\n\n\n

        Object<\/h2>\n\n\n\n

        An object is a real instance of a class<\/strong>. It is created using the blueprint defined by the class and stores actual data.<\/p>\n\n\n\n

        \"\"
        Class and its objects in OOP<\/figcaption><\/figure>\n\n\n\n

        For example, once you define a Student<\/code> class, you can create:<\/p>\n\n\n\n

        Student s1 = new Student();\ns1.name = \"Ali\";\ns1.giveExam();\n<\/code><\/pre>\n\n\n\n
        Here, s1<\/code> is an object of class Student<\/code>. Each object can have different values for the same attributes, like different names or roll numbers.<\/p>\n\n\n\n
        Attributes<\/h2>\n\n\n\n
        Attributes are the properties or characteristics<\/strong> of an object. These are also called data members<\/strong>. They describe what an object has.<\/p>\n\n\n\n
        \"\"
        Object attributes in OOP<\/figcaption><\/figure>\n\n\n\n
        Attributes are written inside a class and accessed through objects.<\/p>\n\n\n\n
        For example:<\/p>\n\n\n\n
        class Book {\n    String title;\n    String author;\n    int pages;\n}\n<\/code><\/pre>\n\n\n\n
        Here, title<\/code>, author<\/code>, and pages<\/code> are attributes. Each book object will have its own values for these.<\/p>\n\n\n\n
        Functions<\/h2>\n\n\n\n
        Functions, also called methods<\/strong>, define the actions<\/strong> an object can perform. These are written inside the class and can be called using the object.<\/p>\n\n\n\n
        \"\"
        Function of the object in OOP<\/figcaption><\/figure>\n\n\n\n
        For example:<\/p>\n\n\n\n
        class Book {\n    void read() {\n        System.out.println(\"Reading the book...\");\n    }\n\n    void bookmarkPage() {\n        System.out.println(\"Page bookmarked.\");\n    }\n}\n<\/code><\/pre>\n\n\n\n
        When we create a Book<\/code> object, it can call these functions to perform tasks.<\/p>\n\n\n\n
        Encapsulation<\/h2>\n\n\n\n
        Encapsulation means protecting the internal data<\/strong> of an object by keeping attributes private and accessing them only through special functions (getters and setters).<\/p>\n\n\n\n
        \"\"
        Encapsulation in OOP<\/figcaption><\/figure>\n\n\n\n
        This improves security and keeps the data safe from direct changes.<\/p>\n\n\n\n
        Example:<\/p>\n\n\n\n
        class Student {\n    private int marks;\n\n    public int getMarks() {\n        return marks;\n    }\n\n    public void setMarks(int m) {\n        marks = m;\n    }\n}\n<\/code><\/pre>\n\n\n\n
        Here, marks<\/code> is private, so it cannot be accessed directly.<\/p>\n\n\n\n
        Inheritance<\/h2>\n\n\n\n
        Inheritance means creating a new class based on an existing class<\/strong>. The new class (called child) can use everything from the old class (called parent) and also add its own features.<\/p>\n\n\n\n
        \"\"
        Inheritance in OOP<\/figcaption><\/figure>\n\n\n\n
        Example:<\/p>\n\n\n\n
        class Vehicle {\n    void start() {\n        System.out.println(\"Starting...\");\n    }\n}\n\nclass Car extends Vehicle {\n    void playMusic() {\n        System.out.println(\"Playing music...\");\n    }\n}\n<\/code><\/pre>\n\n\n\n
        Car<\/code> is using start()<\/code> from Vehicle<\/code> and also has its own function playMusic()<\/code>.<\/p>\n\n\n\n
        Polymorphism<\/h2>\n\n\n\n
        Polymorphism means one function behaves differently for different classes<\/strong>. It allows the same function name to do different jobs based on the object.<\/p>\n\n\n\n
        \"\"
        Polymorphism in OOP<\/figcaption><\/figure>\n\n\n\n
        Example:<\/p>\n\n\n\n
        class Animal {\n    void speak() {\n        System.out.println(\"Animal speaks\");\n    }\n}\n\nclass Dog extends Animal {\n    void speak() {\n        System.out.println(\"Dog barks\");\n    }\n}\n<\/code><\/pre>\n\n\n\n
        When we call speak()<\/code>, the result depends on whether the object is an Animal or Dog.<\/p>\n\n\n\n
        Task<\/h2>\n\n\n\n
        Take a Book<\/strong> as an example. Now apply OOP concepts:<\/p>\n\n\n\n
          \n
        • Object<\/strong>: A specific book like book1<\/code><\/li>\n\n\n\n
        • Attributes<\/strong>: title, author, price<\/li>\n\n\n\n
        • Functions<\/strong>: read(), bookmarkPage()<\/li>\n\n\n\n
        • Encapsulation<\/strong>: Keep price<\/code> private, use methods to get\/set it<\/li>\n\n\n\n
        • Inheritance<\/strong>: Make EBook<\/code> a child class of Book<\/code><\/li>\n\n\n\n
        • Polymorphism<\/strong>: Override read()<\/code> in EBook<\/code> and PrintedBook<\/code><\/li>\n<\/ul>\n\n\n\n
          \n