Object-Oriented Programming in Java

1. Introduction

Object-Oriented Programming (OOP) is a programming paradigm based on the concept of "objects", which can contain data and code to manipulate that data. Java is a widely-used programming language that implements OOP concepts, making it a powerful tool for software development.

2. Key Concepts

• Classes and Objects
• Inheritance
• Polymorphism
• Encapsulation
• Abstraction

Understanding these concepts is essential for effectively using Java's OOP features.

3. Class and Object

A class in Java is a blueprint for creating objects, defining properties (attributes) and behaviors (methods). An object is an instance of a class.

Example:

class Car {
    String color;
    String model;

    void displayInfo() {
        System.out.println("Model: " + model + ", Color: " + color);
    }
}

public class Main {
    public static void main(String[] args) {
        Car myCar = new Car();
        myCar.color = "Red";
        myCar.model = "Toyota";
        myCar.displayInfo();
    }
}

4. Inheritance

Inheritance allows a new class to inherit properties and methods from an existing class. This promotes code reusability.

Example:

class Vehicle {
    void start() {
        System.out.println("Vehicle started");
    }
}

class Bike extends Vehicle {
    void ringBell() {
        System.out.println("Bike bell rung");
    }
}

public class Main {
    public static void main(String[] args) {
        Bike myBike = new Bike();
        myBike.start();
        myBike.ringBell();
    }
}

5. Polymorphism

Polymorphism allows methods to do different things based on the object that it is acting upon. It can be achieved through method overriding and method overloading.

Example of method overriding:

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

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

public class Main {
    public static void main(String[] args) {
        Animal myDog = new Dog();
        myDog.sound();
    }
}

6. Encapsulation

Encapsulation is the mechanism of restricting access to certain details of an object and exposing only the necessary functionalities. It is typically achieved using access modifiers.

Example:

class Account {
    private double balance;

    public void deposit(double amount) {
        balance += amount;
    }

    public double getBalance() {
        return balance;
    }
}

public class Main {
    public static void main(String[] args) {
        Account myAccount = new Account();
        myAccount.deposit(100);
        System.out.println("Balance: " + myAccount.getBalance());
    }
}

7. Abstraction

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

Example:

abstract class Animal {
    abstract void sound();
}

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

public class Main {
    public static void main(String[] args) {
        Animal myCat = new Cat();
        myCat.sound();
    }
}

8. Best Practices

• Use meaningful names for classes and methods.
• Keep classes focused on a single responsibility.
• Use interfaces to define contracts for classes.
• Encapsulate fields and expose them through getter and setter methods.
• Favor composition over inheritance where appropriate.

9. FAQ