🎯 Complete Guide to OOP Relationships & Coupling

📖 Simple Explanation:

When we say "A IS-A B", it means A is a type of B. Like saying "Dog is a type of Animal".

💻 Java Code Example:

// Parent class (general)
class Animal {
    void eat() {
        System.out.println("Animal is eating");
    }
    
    void sleep() {
        System.out.println("Animal is sleeping");
    }
}

// Child class (specific) - Dog IS-A Animal
class Dog extends Animal {
    void bark() {
        System.out.println("Dog is barking: Woof!");
    }
}

🎯 How to Use:

public class Main {
    public static void main(String[] args) {
        Dog myDog = new Dog();
        
        // Dog can do everything Animal can do
        myDog.eat();    // From Animal class
        myDog.sleep();  // From Animal class
        
        // Plus its own special things
        myDog.bark();   // From Dog class
    }
}

📖 Simple Explanation:

HAS-A means one class contains or uses another class. There are 3 types:

• Association: Just a link between two classes.
• Aggregation: HAS-A relationship where the part can exist independently.
• Composition: HAS-A relationship where the part cannot exist without the whole.

💻 Java Code Examples (With Comments):

🔹 Aggregation: Car HAS-A MusicPlayer

// Aggregation Example

// MusicPlayer class - can exist independently
class MusicPlayer {
    void play() {
        System.out.println("Playing music...");
    }
}

// Car class that receives MusicPlayer from outside (Aggregation)
class Car {
    private MusicPlayer player; // Aggregation: Car HAS-A MusicPlayer

    // Constructor that accepts a MusicPlayer object as parameter
    Car(MusicPlayer player) {
        // 'this' keyword refers to the current object's variable
        this.player = player;
        // This means: assign the passed-in MusicPlayer to the car's own player
    }

    void usePlayer() {
        System.out.println("Car using music player:");
        player.play(); // Using the aggregated MusicPlayer object
    }
}

🔸 Composition: Car HAS-A Engine

// Composition Example

// Engine class - represents the essential component of a Car
class Engine {
    String type;

    // Constructor to initialize engine type
    Engine(String type) {
        this.type = type;
    }

    void start() {
        System.out.println(type + " engine starting...");
    }
}

// Car class that creates its own Engine internally (Composition)
class Car {
    private Engine engine; // Composition: Car HAS-A Engine

    // Constructor that creates the Engine object inside
    Car(String engineType) {
        this.engine = new Engine(engineType); // Object created internally → strong binding
    }

    void startCar() {
        System.out.println("Starting car...");
        engine.start(); // Using the composed Engine object
    }
}

🎯 How to Use:

public class Main {
    public static void main(String[] args) {
        // Aggregation: passing the object from outside
        MusicPlayer player = new MusicPlayer();  // Independent object
        Car carWithMusic = new Car(player);      // Injected into Car
        carWithMusic.usePlayer();

        // Composition: object created inside the class
        Car carWithEngine = new Car("Diesel");   // Engine created within Car
        carWithEngine.startCar();
    }
}

📖 Simple Explanation:

When we say "A USES-A B", it means A uses B to do something, but doesn't own B. Like "Driver uses a Car".

💻 Java Code Example:

// Class that can be used
class Printer {
    void print(String document) {
        System.out.println("Printing: " + document);
    }
}

// Class that USES another class
class Student {
    private String name;
    
    Student(String name) {
        this.name = name;
    }
    
    // Student USES-A Printer
    void printAssignment(Printer printer, String assignment) {
        System.out.println(name + " wants to print assignment");
        printer.print(assignment);  // Using the printer
        System.out.println("Assignment printed successfully!");
    }
}

🎯 How to Use:

public class Main {
    public static void main(String[] args) {
        // Create objects
        Printer libraryPrinter = new Printer();
        Student john = new Student("John");
        Student mary = new Student("Mary");
        
        // Both students can USE the same printer
        john.printAssignment(libraryPrinter, "Math Homework");
        mary.printAssignment(libraryPrinter, "Science Project");
    }
}

📖 Simple Explanation:

Tight Coupling means classes are stuck together too much. If you change one, the other breaks. It's like having a phone charger that only works with one specific phone model.

💻 Bad Java Code Example:

// Tightly coupled - BAD!
class EmailSender {
    void sendEmail(String message) {
        System.out.println("Sending email: " + message);
    }
}

class NotificationService {
    private EmailSender emailSender = new EmailSender();  // Stuck with Email only!
    
    void notify(String message) {
        // Can ONLY send emails, nothing else
        emailSender.sendEmail(message);
    }
}

😢 Problems with Tight Coupling:

• Hard to change: Want SMS instead of Email? You have to modify NotificationService
• Hard to test: Can't test without actually sending real emails
• Not flexible: Stuck with one way of doing things

📖 Simple Explanation:

Loose Coupling means classes can work together but aren't stuck to each other. Like having a universal phone charger that works with any phone.

💻 Good Java Code Example:

// Interface - the "standard"
interface MessageSender {
    void sendMessage(String message);
}

// Different implementations
class EmailSender implements MessageSender {
    public void sendMessage(String message) {
        System.out.println("📧 Email sent: " + message);
    }
}

class SMSSender implements MessageSender {
    public void sendMessage(String message) {
        System.out.println("📱 SMS sent: " + message);
    }
}

class WhatsAppSender implements MessageSender {
    public void sendMessage(String message) {
        System.out.println("💬 WhatsApp sent: " + message);
    }
}

// Loosely coupled - GOOD!
class NotificationService {
    private MessageSender sender;
    
    // Can accept ANY type of sender
    NotificationService(MessageSender sender) {
        this.sender = sender;
    }
    
    void notify(String message) {
        sender.sendMessage(message);  // Don't care HOW it sends, just send!
    }
}

🎯 How to Use (The Magic!):

public class Main {
    public static void main(String[] args) {
        String message = "Hello! Your order is ready.";
        
        // Same NotificationService can use different senders!
        NotificationService emailNotifier = new NotificationService(new EmailSender());
        emailNotifier.notify(message);
        
        NotificationService smsNotifier = new NotificationService(new SMSSender());
        smsNotifier.notify(message);
        
        NotificationService whatsappNotifier = new NotificationService(new WhatsAppSender());
        whatsappNotifier.notify(message);
    }
}

😊 Benefits of Loose Coupling:

• Easy to change: Want to add Discord notifications? Just create DiscordSender!
• Easy to test: Create a FakeSender for testing
• Very flexible: Can switch between different methods anytime