What is oops in Java?

Object-Oriented Programming (OOP) in Java is a programming paradigm that uses objects and classes to structure software programs. It emphasizes the organization of code into reusable and modular components, making it easier to manage complexity. Here are the key principles of OOP in Java:

1. Encapsulation

Encapsulation is the practice of bundling the data (attributes) and methods (functions) that operate on the data into a single unit called a class. It restricts direct access to some of the object's components and can prevent the accidental modification of data. This is typically achieved using access modifiers (private, public, protected).

Example:

public class Employee {
    private String name; // private field

    // Public method to access private field
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

2. Abstraction

Abstraction is the concept of hiding the complex implementation details and showing only the essential features of the object. In Java, abstraction can be achieved using abstract classes and interfaces.

Example:

abstract class Animal {
    abstract void sound(); // abstract method
}

class Dog extends Animal {
    void sound() {
        System.out.println("Bark");
    }
}

3. Inheritance

Inheritance allows one class (the subclass) to inherit the properties and methods of another class (the superclass). This promotes code reuse and establishes a relationship between classes.

Example:

class Animal {
    void eat() {
        System.out.println("Eating...");
    }
}

class Dog extends Animal {
    void bark() {
        System.out.println("Barking...");
    }
}

// Usage
Dog dog = new Dog();
dog.eat(); // Inherited method
dog.bark(); // Dog's own method

4. Polymorphism

Polymorphism allows methods to do different things based on the object that it is acting upon, even if they share the same name. This can be achieved through method overloading (compile-time polymorphism) and method overriding (runtime polymorphism).

Example:

class Animal {
    void sound() {
        System.out.println("Animal sound");
    }
}

class Cat extends Animal {
    void sound() {
        System.out.println("Meow");
    }
}

// Usage
Animal myCat = new Cat();
myCat.sound(); // Output: Meow (runtime polymorphism)

Conclusion

OOP in Java is a powerful paradigm that helps developers create modular, maintainable, and reusable code. By understanding the principles of encapsulation, abstraction, inheritance, and polymorphism, developers can design robust applications.

For further reading and a deeper understanding, you can explore these resources:

• Oracle: The Java Tutorials - Object-Oriented Programming Concepts
• GeeksforGeeks: Object-Oriented Programming in Java