Difference between object oriented and object based languages

Difference between object-oriented and object-based languages

Object-Oriented Languages and Object-Based Languages, this comparison highlights two important programming paradigms, each with its unique characteristics. Object-oriented languages, like Java and C++, emphasize the use of objects and classes to encapsulate data and behavior, enabling concepts like inheritance, polymorphism, and encapsulation.

In this OOPs tutorial, we'll explore how these paradigms differ. Object-based languages, such as JavaScript, focus on objects but do not support inheritance, making them more limited in terms of object-oriented features. Let's start with "What are Object-Oriented Languages?"

Top 50 OOPs Interview Questions and Answers

What is Object-Oriented Programming?

Object-oriented programming (OOP) is a paradigm of programming that is based on the concept of "objects" while designing software. The objects are instances of classes, and a class is essentially a blueprint that defines what properties and methods an object can have. OOPs foster four main principles:

• Encapsulation: Encapsulation hides the internal state of an object and requires all interaction to be done through methods of that object. It guarantees data integrity.
• Inheritance: It allows for the definition of new classes using already defined classes. This enables code reusability and better organization of applications.
• Polymorphism: This allows objects to be treated as instances of their superclass, hence adding flexibility.
• Abstraction: Abstraction simplifies systems by exposing just the necessary information to the outside world and concealing information that is not needed.

Examples of object-oriented programming languages are C++, Java, C#, Python, and Swift. These languages follow strict OOP principles and provide means to implement and manage objects, classes, and inheritance.

Example of Object-Oriented Programming in C#:

using System; // Importing the System namespace

// Base class 
public class Animal
{
    public virtual void Speak() // Virtual method to be overridden
    {
        Console.WriteLine("Animal speaks");
    }
}

// Derived class
public class Dog : Animal
{
    public override void Speak() // Override the Speak method for Dog
    {
        Console.WriteLine("Dog barks");
    }
}

// Derived class
public class Cat : Animal
{
    public override void Speak() // Override the Speak method for Cat
    {
        Console.WriteLine("Cat meows");
    }
}

// Main method
class Program
{
    static void Main(string[] args)
    {
        Animal myDog = new Dog(); // Animal reference to Dog object
        Animal myCat = new Cat(); // Animal reference to Cat object
        
        myDog.Speak(); // Output: Dog barks
        myCat.Speak(); // Output: Cat meows
    }
}
            

#include <iostream>
using namespace std;

// Base class
class Animal {
public:
    virtual void speak() { // Virtual method to be overridden
        cout << "Animal speaks" << endl;
    }
};

// Derived class
class Dog : public Animal {
public:
    void speak() override { // Override the speak method for Dog
        cout << "Dog barks" << endl;
    }
};

// Derived class
class Cat : public Animal {
public:
    void speak() override { // Override the speak method for Cat
        cout << "Cat meows" << endl;
    }
};

// Main function
int main() {
    Animal* myDog = new Dog(); // Animal reference to Dog object
    Animal* myCat = new Cat(); // Animal reference to Cat object

    myDog->speak(); // Output: Dog barks
    myCat->speak(); // Output: Cat meows

    delete myDog; // Free allocated memory
    delete myCat; // Free allocated memory

    return 0;
}
            

class Animal:
    def speak(self):  # Method to be overridden
        print("Animal speaks")

class Dog(Animal):
    def speak(self):  # Override the speak method for Dog
        print("Dog barks")

class Cat(Animal):
    def speak(self):  # Override the speak method for Cat
        print("Cat meows")

my_dog = Dog()  # Animal reference to Dog object
my_cat = Cat()  # Animal reference to Cat object

my_dog.speak()  # Output: Dog barks
my_cat.speak()  # Output: Cat meows
            

// Base class
class Animal {
    void speak() { // Method to be overridden
        System.out.println("Animal speaks");
    }
}

// Derived class
class Dog extends Animal {
    @Override
    void speak() { // Override the speak method for Dog
        System.out.println("Dog barks");
    }
}

// Derived class
class Cat extends Animal {
    @Override
    void speak() { // Override the speak method for Cat
        System.out.println("Cat meows");
    }
}

// Main class
public class Main {
    public static void main(String[] args) {
        Animal myDog = new Dog(); // Animal reference to Dog object
        Animal myCat = new Cat(); // Animal reference to Cat object
        
        myDog.speak(); // Output: Dog barks
        myCat.speak(); // Output: Cat meows
    }
}
            

class Animal {
    speak() { // Method to be overridden
        console.log("Animal speaks");
    }
}

class Dog extends Animal {
    speak() { // Override the speak method for Dog
        console.log("Dog barks");
    }
}

class Cat extends Animal {
    speak() { // Override the speak method for Cat
        console.log("Cat meows");
    }
}

const myDog = new Dog(); // Animal reference to Dog object
const myCat = new Cat(); // Animal reference to Cat object

myDog.speak(); // Output: Dog barks
myCat.speak(); // Output: Cat meows
            

Output

Dog barks
Cat meows

Explanation

• This C# code shows how inheritance works in object-oriented programming.
• You create a base class called Animal with the method Speak(), and then you make Dog and Cat as derived classes that override the Speak() method to provide their specific sounds.
• When you call Speak() on each animal, it uses the method from the derived class, showing how polymorphism allows objects to behave differently.

What is Object-Based Programming?

• Object-based programming is a programming paradigm wherein objects are used; however, it lacks some features, such as inheritance and polymorphism. 
• With an object-based language, one can also create objects and define the behavior of the objects, but it cannot encompass classes inheriting properties and methods from other classes.
• In a nutshell, object-based programming allows enclosure and abstraction but does not employ most of the features of OOPs. 
• You can still adhere to organizing your code with objects that have limited or no rich class hierarchies.

Examples of object-based languages are JavaScript in some of its earlier versions, VBScript, and earlier versions of Visual Basic. They do support objects but don't provide the completeness of the OOPs functionality seen in languages like Java or C++.

Example of Object-Based Programming in JavaScript

// Creating an object for Dog
const dog = {
    name: 'Buddy', // Dog's name
    breed: 'Golden Retriever', // Dog's breed
    speak: function() {
        console.log(`${this.name} barks!`);  // Using template literals for output
    }
};

// Creating another object for Cat
const cat = {
    name: 'Whiskers', // Cat's name
    breed: 'Siamese', // Cat's breed
    speak: function() {
        console.log(`${this.name} meows!`);  // Using template literals for output
    }
};

// Using the objects to call their methods
dog.speak(); // Output: Buddy barks!
cat.speak(); // Output: Whiskers meows!
            

using System;

// Class for Dog
public class Dog
{
    public string Name { get; set; }
    public string Breed { get; set; }

    public void Speak()
    {
        Console.WriteLine($"{Name} barks!"); // Using string interpolation
    }
}

// Class for Cat
public class Cat
{
    public string Name { get; set; }
    public string Breed { get; set; }

    public void Speak()
    {
        Console.WriteLine($"{Name} meows!"); // Using string interpolation
    }
}

// Main method
class Program
{
    static void Main(string[] args)
    {
        Dog dog = new Dog { Name = "Buddy", Breed = "Golden Retriever" }; // Creating a Dog object
        Cat cat = new Cat { Name = "Whiskers", Breed = "Siamese" }; // Creating a Cat object

        dog.Speak(); // Output: Buddy barks!
        cat.Speak(); // Output: Whiskers meows!
    }
}
            

#include <iostream>
using namespace std;

// Class for Dog
class Dog {
public:
    string name;
    string breed;

    void speak() {
        cout << name << " barks!" << endl; // Output for Dog
    }
};

// Class for Cat
class Cat {
public:
    string name;
    string breed;

    void speak() {
        cout << name << " meows!" << endl; // Output for Cat
    }
};

// Main function
int main() {
    Dog dog; // Creating Dog object
    dog.name = "Buddy";
    dog.breed = "Golden Retriever";

    Cat cat; // Creating Cat object
    cat.name = "Whiskers";
    cat.breed = "Siamese";

    dog.speak(); // Output: Buddy barks!
    cat.speak(); // Output: Whiskers meows!

    return 0;
}
            

# Class for Dog
class Dog:
    def __init__(self, name, breed):
        self.name = name
        self.breed = breed

    def speak(self):
        print(f"{self.name} barks!")  # Using f-string for output

# Class for Cat
class Cat:
    def __init__(self, name, breed):
        self.name = name
        self.breed = breed

    def speak(self):
        print(f"{self.name} meows!")  # Using f-string for output

# Creating objects
dog = Dog("Buddy", "Golden Retriever")
cat = Cat("Whiskers", "Siamese")

# Calling methods
dog.speak()  # Output: Buddy barks!
cat.speak()  # Output: Whiskers meows!
            

// Class for Dog
class Dog {
    String name;
    String breed;

    Dog(String name, String breed) {
        this.name = name;
        this.breed = breed;
    }

    void speak() {
        System.out.println(name + " barks!"); // Output for Dog
    }
}

// Class for Cat
class Cat {
    String name;
    String breed;

    Cat(String name, String breed) {
        this.name = name;
        this.breed = breed;
    }

    void speak() {
        System.out.println(name + " meows!"); // Output for Cat
    }
}

// Main class
public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog("Buddy", "Golden Retriever"); // Creating Dog object
        Cat cat = new Cat("Whiskers", "Siamese"); // Creating Cat object

        dog.speak(); // Output: Buddy barks!
        cat.speak(); // Output: Whiskers meows!
    }
}
            

Output

Buddy barks!
Whiskers meows!

Explanation

• This code creates two objects, a dog and a cat, each with properties like name and breed.
• Each object has a speak() method that prints a message when called.
• When you call a dog.speak(), it outputs "Buddy barks!" and when you call cat.speak(), it outputs "Whiskers meows!" This shows how objects can have their own behaviors in JavaScript.

Difference between object-oriented language and object-based languages

Now that you have a basic understanding of both concepts let’s explore the differences between object-oriented and object-based programming languages.

Advantages of Object-Oriented Programming

• Code Reusability: Inheritance allows you to reuse code by creating new classes from old ones. Besides, this feature simplifies big projects and reduces redundancy.
• Flexibility: Polymorphism allows you to write programs in which you can process a variety of object types using the same written code; therefore, your programs will be more adaptable and easier to extend.
• Modularity in design: OOPs encourage a modular approach so that any complex problem must be divided into small, workable pieces.

Advantages of Object-Based Programming

• Simplicity: Without the need to understand complex concepts like inheritance and polymorphism, object-based programming is easier for beginners or for developing simple applications.
• Ease of Use: Object-based languages are generally more straightforward, making them a good choice for scripting or smaller projects where the overhead of full OOPs might not be necessary.
• Faster Development: Without the need to design complex class structures, development time can be faster, especially for small-scale applications.

Object-Based vs. Object-Oriented: When to Use Each

• Object-Oriented Programming: OOP is useful when complex applications are being developed that are bigger. It offers certain advantages from a code reusability, flexibility, and maintainability point of view. If one has to deal with a bunch of objects with similar behaviors, an OOP language would be ideal, especially if one needs to write a class hierarchy.
• Object-Based Programming: This is more suitable in little applications or scripts where the overhead of OOP isn't needed. It is also a good starting point for learning programming concepts, as it offers the possibility to work with objects with their ability to store data and methods that operate on that data without needing to know about classes, inheritance, and polymorphism.

Common Misconceptions

Sometimes, there are some misconceptions when comparing object-oriented with object-based programming. Let's discuss a few:

• “Object-based programming is a subset of object-oriented programming.” Whereas that may appear true, object-based programming lacks some basic features, such as inheritance and polymorphism, which are significant in OOP. Hence, this is not just an inferior edition but another way with its peculiar features.
• “JavaScript is object-oriented.” JavaScript, JavaScript, in earlier versions of the language, was object-based since it allowed you to create and manipulate objects. However, it did not support modern OOP languages with regard to classes and inheritance. Modern JavaScript finally came up with class syntax starting with ES6 and above versions.

Summary

Object-oriented programming (OOP) supports key features like inheritance, polymorphism, and encapsulation, allowing for more structured and reusable code, making it ideal for large, complex applications. In contrast, Object-based programming focuses on objects but lacks inheritance and polymorphism, making it simpler but less flexible. While OOP is best for scalable projects, object-based programming is suitable for smaller tasks or simpler applications. Understanding these differences helps developers choose the right paradigm based on their project needs. By using object-oriented programming (OOP) concepts, Scholarhat offers training programs such as C programming, CPP, C#, Java, and Python. You can enroll in any one of them and kickstart your career.