notes-shivam

01 Object oriented programming

4 min read

1. Definition of OOP in Java

Object-Oriented Programming in Java is a programming paradigm that uses objects to model real-world entities. Java is designed with OOP principles in mind, allowing developers to create modular, reusable, and organized code.

2. Core Principles of OOP in Java

Java incorporates four main principles of OOP:

a. Encapsulation

  • Definition: Encapsulation involves bundling the data (attributes) and methods (functions) that operate on that data within a single unit, typically a class.

  • Implementation:

    • Use access modifiers (private, protected, public) to restrict access to class members.
    • Provide public getter and setter methods to allow controlled access to private fields.

    Example:

    public class Person {
    private String name; // private field
 
    // Constructor
    public Person(String name) {
        this.name = name;
    }
 
    // Getter method
    public String getName() {
        return name;
    }
 
    // Setter method
    public void setName(String name) {
        this.name = name;
    }
}

b. Inheritance

  • Definition: Inheritance allows one class (subclass) to inherit fields and methods from another class (superclass), promoting code reuse and establishing a hierarchical relationship.

  • Implementation: Use the extends keyword to create a subclass from a superclass.

    Example:

    public class Animal {
    public void eat() {
        System.out.println("This animal eats food.");
    }
}
 
public class Dog extends Animal {
    public void bark() {
        System.out.println("The dog barks.");
    }
}
 
// Usage
Dog dog = new Dog();
dog.eat(); // Inherited method
dog.bark(); // Subclass method

c. Polymorphism

  • Definition: Polymorphism allows objects to be treated as instances of their parent class, enabling a single interface to represent different underlying forms (data types).

  • Types:

    • Compile-Time Polymorphism (Method Overloading): Multiple methods in the same class with the same name but different parameters.
    • Runtime Polymorphism (Method Overriding): A subclass provides a specific implementation of a method that is already defined in its superclass.

    Example:

    public class Shape {
    public void draw() {
        System.out.println("Drawing a shape.");
    }
}
 
public class Circle extends Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a circle.");
    }
}
 
public class Square extends Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a square.");
    }
}
 
// Usage
Shape shape1 = new Circle();
Shape shape2 = new Square();
shape1.draw(); // Outputs: Drawing a circle.
shape2.draw(); // Outputs: Drawing a square.

d. Abstraction

  • Definition: Abstraction involves hiding complex implementation details and exposing only the essential features of an object.

  • Implementation: Achieved using abstract classes and interfaces.

    Example:

    // Abstract class
public abstract class Vehicle {
    abstract void start(); // Abstract method
}
 
public class Car extends Vehicle {
    @Override
    void start() {
        System.out.println("Car is starting.");
    }
}
 
// Usage
Vehicle myCar = new Car();
myCar.start(); // Outputs: Car is starting.

3. Key Features of OOP in Java

  • Classes and Objects: The foundation of OOP in Java, where classes define the blueprint for objects.
  • Access Modifiers: Control the visibility of class members (private, protected, public, default).
  • Method Overloading and Overriding: Allows multiple methods with the same name but different signatures (overloading) and redefining methods in subclasses (overriding).
  • Interfaces: Define a contract that classes can implement, allowing for multiple inheritance in terms of behavior.

4. Advantages of OOP in Java

  • Modularity: Code is organized into reusable classes and objects, making it easier to manage and maintain.
  • Reusability: Inheritance promotes the reuse of existing code, reducing redundancy.
  • Flexibility and Maintainability: Changes in one part of the code can be made with minimal impact on other parts, thanks to encapsulation and abstraction.
  • Real-World Modeling: OOP allows for modeling real-world entities more intuitively, making code easier to understand.

5. Disadvantages of OOP in Java

  • Complexity: OOP can introduce additional complexity, especially for beginners who may find concepts like inheritance and polymorphism challenging.
  • Performance Overhead: Object-oriented design may lead to additional memory overhead and slower performance compared to procedural programming due to object management and dynamic dispatch.
  • Steeper Learning Curve: Mastering OOP concepts takes time and effort, which can be a barrier for some developers.

6. Conclusion

Object-Oriented Programming in Java provides a robust framework for designing modular and maintainable applications. With principles such as encapsulation, inheritance, polymorphism, and abstraction, Java enables developers to create code that is both reusable and easy to understand. While OOP offers numerous advantages, it also comes with challenges that require careful consideration in software design and development. Understanding these principles is essential for anyone looking to leverage the full potential of Java as an object-oriented programming language.

Graph View

Backlinks