# Object Oriented Programming (OOP) Object Oriented Programming (OOP) is a programming paradigm in which a software system is designed around objects rather than only around functions and procedures. An object represents a real-world or conceptual entity and contains both data and the operations that can be performed on that data. OOP helps programmers develop software that is modular, reusable, secure, maintainable, and easier to understand. Languages such as Java, C++, C#, and Python support object-oriented programming. Java is fundamentally object-oriented and provides strong support for the major concepts of OOP through classes, objects, methods, access modifiers, inheritance, interfaces, and method overriding. A class is a blueprint or template from which objects are created. It defines the properties and behaviours that its objects will possess. For example, a `Student` class may contain data members such as `name`, `rollNo`, and `marks`, together with methods such as `displayDetails()` and `calculateGrade()`. An object is an actual instance of a class. Thus, `Student s1 = new Student();` creates an object `s1` of the `Student` class. The four fundamental principles of OOP are Encapsulation, Abstraction, Inheritance, and Polymorphism. Encapsulation is the process of combining data and the methods that operate on that data into a single unit, generally a class, while restricting direct access to the internal data. It is an important mechanism for data protection and information hiding. In Java, encapsulation is commonly achieved by declaring data members as `private` and providing public getter and setter methods to access or modify them in a controlled manner. For example: ```java class BankAccount { private double balance; public void deposit(double amount) { if (amount > 0) balance += amount; } public double getBalance() { return balance; } } ``` In this example, `balance` is declared `private`, so it cannot be directly modified from outside the class. The `deposit()` method controls how money is added to the account, while `getBalance()` provides controlled access to the balance. A statement such as `account.balance = -5000;` is not permitted because the variable is private. Encapsulation therefore protects the object's state and prevents unauthorized or inappropriate modification. It also improves maintainability because changes to the internal implementation can be made without affecting the external code that uses the class. Abstraction means representing only the essential features of an object while hiding unnecessary implementation details. It allows a programmer to concentrate on what an object does rather than how it does it. In Java, abstraction can be implemented mainly through abstract classes and interfaces. For example: ```java abstract class Shape { abstract void draw(); } class Circle extends Shape {