Here are 5 important questions and solutions related to Object-Oriented Programming (OOP),
including one program.
### 1. **What are the main principles of Object-Oriented Programming?**
The four main principles of OOP are:
- **Encapsulation**: The concept of wrapping data (variables) and the methods (functions) that
operate on the data into a single unit called a class.
- **Abstraction**: Hiding the complex implementation details and showing only the essential
features of the object.
- **Inheritance**: The ability to create a new class (derived class) from an existing class (base
class), inheriting attributes and methods.
- **Polymorphism**: The ability of a single function, method, or operator to work in different ways
based on the objects involved.
---
### 2. **What is the difference between a class and an object in OOP?**
- **Class**: A class is a blueprint or prototype for creating objects. It defines attributes
(variables) and behaviors (methods) that the objects created from the class will have.
- **Object**: An object is an instance of a class. When a class is defined, no memory is
allocated. The object represents the actual entity that occupies memory.
---
### 3. **What is the concept of constructor and destructor in OOP?**
- **Constructor**: A constructor is a special method used to initialize objects. It is called
automatically when an object of a class is created. Its primary purpose is to initialize the object.
- **Destructor**: A destructor is a special method used to clean up when an object is no longer
in use. It is called when an object is destroyed or goes out of scope.
---
### 4. **What is polymorphism in OOP?**
Polymorphism is the ability of one method, function, or operator to behave differently based on
the object or data type involved. There are two types of polymorphism:
- **Compile-time Polymorphism (Method Overloading)**: Occurs when two or more methods
have the same name but differ in parameters (number or type).
- **Runtime Polymorphism (Method Overriding)**: Occurs when a method in a derived class
overrides a method in a base class with the same name and signature.
---
### 5. **Write a simple program that demonstrates inheritance, polymorphism, and
encapsulation in OOP.**
Here is a simple Python program that demonstrates inheritance, polymorphism, and
encapsulation:
```python
# Parent class
class Animal:
def __init__(self, name, age):
self.name = name # Encapsulation: Attribute (name) is encapsulated
self.age = age # Encapsulation: Attribute (age) is encapsulated
def speak(self): # Method to be overridden
pass
# Child class 1
class Dog(Animal):
def __init__(self, name, age, breed):
super().__init__(name, age) # Inheritance: Inheriting from Animal class
self.breed = breed
def speak(self): # Polymorphism: Method overriding
return f"{self.name} says Woof!"
# Child class 2
class Cat(Animal):
def __init__(self, name, age, color):
super().__init__(name, age) # Inheritance: Inheriting from Animal class
self.color = color
def speak(self): # Polymorphism: Method overriding
return f"{self.name} says Meow!"
# Creating objects of the classes
dog = Dog("Buddy", 3, "Golden Retriever")
cat = Cat("Whiskers", 2, "White")
# Accessing methods and attributes
print(dog.speak()) # Polymorphism: Dog class overrides speak method
print(cat.speak()) # Polymorphism: Cat class overrides speak method
print(f"{dog.name} is {dog.age} years old and is a {dog.breed}.") # Encapsulation: Accessing
private attribute
```
### **Explanation of the Program:**
- **Encapsulation**: The attributes `name` and `age` in the `Animal` class are encapsulated,
meaning they are contained within the class and can be accessed or modified only via methods.
- **Inheritance**: The `Dog` and `Cat` classes inherit from the `Animal` class, allowing them to
reuse the attributes (`name`, `age`) and methods of the `Animal` class.
- **Polymorphism**: Both `Dog` and `Cat` classes override the `speak()` method of the parent
`Animal` class. When `speak()` is called on instances of these classes, they behave differently,
displaying "Woof!" and "Meow!", respectively.
---
### Output of the program:
```
Buddy says Woof!
Whiskers says Meow!
Buddy is 3 years old and is a Golden Retriever.
```
This program demonstrates how encapsulation, inheritance, and polymorphism are
implemented in Object-Oriented Programming.
