Programming is the process of designing, writing, testing, and maintaining computer programs, which are sets of instructions that a computer can execute.
Programs are written using programming languages such as Python, Java, C++, and others. The process of programming involves breaking down a problem into smaller parts, designing an algorithm to solve each part, and then writing code that implements the algorithm.
Programming can be used to create a wide variety of software, including web applications, mobile apps, video games, and desktop applications. It is a valuable skill that is in high demand in today’s technology-driven world and can be a rewarding career for those who enjoy solving problems and working with computers.
Object Oriented programming
Object-oriented programming (OOP) is a programming paradigm based on the concept of objects, which can contain data (attributes) and behavior (methods).
In OOP, programs are designed by creating classes, which define objects of a particular type. A class is a blueprint or template that defines the attributes and methods of an object. Objects are instances of classes, which means that they have the same attributes and methods as the class they are created from.
The four main principles of OOP are:
- Encapsulation: The idea of bundling data and methods together into a single unit, and hiding the implementation details from the outside world.
- Inheritance: The ability of a subclass to inherit properties and methods from its superclass, allowing for code reuse and modularity.
- Polymorphism: The ability of objects to take on multiple forms or behaviors, depending on the context in which they are used.
- Abstraction: The idea of focusing on the essential features of an object, while ignoring the details that are not relevant to its use.
OOP allows for modular, maintainable, and reusable code, which can make software development more efficient and less error-prone. It is used in a wide range of programming languages, including Java, C++, Python, and Ruby.
Encapsulation
Encapsulation is a fundamental concept in object-oriented programming (OOP) that refers to the practice of hiding the internal details of an object and exposing only what is necessary to interact with it.
In other words, encapsulation is a mechanism that allows an object to control its own data and behavior by providing a public interface through which other objects can access it. The internal workings of the object are kept private, which prevents other objects from interfering with its state or behavior.
Encapsulation is achieved in OOP by using access modifiers such as public, private, and protected to control the visibility of an object’s data and methods. The public interface provides a set of methods and properties that other objects can use to interact with the encapsulated object, while the private interface is hidden from external objects.
Encapsulation helps to improve the maintainability, reliability, and security of code by preventing unintended modification of an object’s state or behavior. It also facilitates modular programming and code reuse by allowing objects to be developed and tested independently of one another.
#include <iostream>
using namespace std;
class Circle {
private:
double radius;
public:
void setRadius(double r) {
if (r > 0) {
radius = r;
} else {
cout << "Invalid radius value." << endl;
}
}
double getRadius() {
return radius;
}
double getArea() {
return 3.14 * radius * radius;
}
};
int main() {
Circle myCircle;
myCircle.setRadius(5);
cout << "Radius: " << myCircle.getRadius() << endl;
cout << "Area: " << myCircle.getArea() << endl;
return 0;
}Inheritance
Inheritance is a key concept in object-oriented programming (OOP) that allows a new class to be based on an existing class. Inheritance enables the creation of new classes that are built upon existing classes, thereby reusing code and reducing development time.
Inheritance works by allowing a new class (called the “subclass” or “derived class”) to inherit properties and methods from an existing class (called the “superclass” or “base class”). The subclass can then extend or modify the properties and methods inherited from the superclass, or add new properties and methods of its own.
The advantage of inheritance is that it promotes code reuse and modularity by allowing related classes to share code and functionality. This makes it easier to maintain and update the codebase, since changes made to the superclass are automatically inherited by all its subclasses.
Inheritance also supports the concept of polymorphism, which allows objects of different classes to be treated as if they are of the same class. This means that a method defined in the superclass can be called on an object of the subclass, and the subclass can override or extend the behavior of the method as needed.
Overall, inheritance is a powerful tool for creating flexible and reusable code in OOP, and is widely used in many programming languages, including Java, Python, and C++.
#Inheritance
#include <iostream>
using namespace std;
// Base class
class Animal {
public:
void eat() {
cout << "Animal is eating" << endl;
}
void sleep() {
cout << "Animal is sleeping" << endl;
}
};
// Derived class
class Dog : public Animal {
public:
void bark() {
cout << "Dog is barking" << endl;
}
};
// Derived class
class Bird : public Animal {
public:
void fly() {
cout << "Bird is flying" << endl;
}
};
int main() {
Dog dog;
dog.eat();
dog.sleep();
dog.bark();
Bird bird;
bird.eat();
bird.sleep();
bird.fly();
return 0;
}Polymorphism
Polymorphism is a fundamental concept in object-oriented programming (OOP) that refers to the ability of objects to take on many forms. It allows objects of different classes to be treated as if they are of the same class, making code more flexible, reusable, and easier to maintain.
Polymorphism is enabled by inheritance and method overriding, which allow a subclass to inherit methods from a superclass and override them with its own implementation. This means that objects of the subclass can be treated as objects of the superclass, and can be used interchangeably in code that uses the superclass.
For example, consider a program that has a superclass called “Shape” and two subclasses called “Circle” and “Rectangle”. Each of these classes has a method called “getArea()”, which calculates the area of the shape. The Circle and Rectangle classes override the getArea() method with their own implementation to calculate the area of a circle or rectangle.
Now, if we have a variable of type Shape, we can assign it to an object of either Circle or Rectangle, since both of these classes are subclasses of Shape. Then, we can call the getArea() method on the Shape variable, and the correct implementation of the method will be called based on the actual type of the object.
This allows us to write code that is more flexible and adaptable, since it can work with a variety of different objects without needing to know their specific types. Polymorphism is a powerful tool for creating extensible and reusable code in OOP, and is widely used in many programming languages, including Java, Python, and C++.
#include <iostream>
using namespace std;
class Shape {
public:
// Virtual function
virtual void draw() {
cout << "Drawing Shape" << endl;
}
};
class Circle : public Shape {
public:
// Override draw function for Circle
void draw() override {
cout << "Drawing Circle" << endl;
}
};
class Square : public Shape {
public:
// Override draw function for Square
void draw() override {
cout << "Drawing Square" << endl;
}
};
int main() {
Shape* shape1 = new Circle();
Shape* shape2 = new Square();
shape1->draw(); // Calls draw() from Circle class
shape2->draw(); // Calls draw() from Square class
delete shape1;
delete shape2;
return 0;
}Abstraction
Abstraction is a fundamental concept in object-oriented programming (OOP) that refers to the process of representing complex real-world entities as simplified models or representations in code. Abstraction allows developers to focus on the essential features of an object or system, while hiding irrelevant details.
In OOP, abstraction is achieved through the use of abstract classes, interfaces, and methods. An abstract class is a class that cannot be instantiated, but serves as a template or blueprint for other classes. It can define abstract methods, which are methods that have no implementation but must be implemented by any concrete subclass of the abstract class.
An interface is similar to an abstract class, but it contains only abstract methods and cannot define any implementation. It is used to define a contract that a class must adhere to in order to be considered a particular type.
Abstraction helps to simplify complex systems and make them more manageable by providing a clear separation between the essential features of an object and the implementation details. It also allows for greater flexibility and modularity in code, since changes can be made to the implementation of an object without affecting the external interface.
Overall, abstraction is a powerful tool for creating modular, flexible, and maintainable code in OOP, and is a key component of many programming languages, including Java, C++, and Python.
#include <iostream>
using namespace std;
class BankAccount {
private:
int accountNumber;
float balance;
public:
BankAccount(int accNo, float bal) {
accountNumber = accNo;
balance = bal;
}
void deposit(float amount) {
balance += amount;
}
void withdraw(float amount) {
if (amount > balance) {
cout << "Insufficient balance." << endl;
}
else {
balance -= amount;
}
}
float getBalance() const {
return balance;
}
};
int main() {
BankAccount account(123456, 1000.00);
account.deposit(500.00);
cout << "Balance after deposit: " << account.getBalance() << endl;
account.withdraw(1500.00);
cout << "Balance after withdrawal: " << account.getBalance() << endl;
return 0;
}