Adapter, Composite & Facade

❓ Problems the Adapter solves

• How can a class be reused that doesn't have the interface a client requires?
• How can classes with incompatible interfaces work together?
• How can an alternative interface be provided for a class, without changing it?

📐 Structure — Object Adapter vs Class Adapter

🐦 Worked Example — Bird → ToyDuck

Setup: a Bird class has fly() and makeSound(). A ToyDuck interface only has squeak(). You're short on real ToyDuck objects and want to use a Bird (Sparrow) in its place. Target = ToyDuck, Adaptee = Bird.

interface ToyDuck { public void squeak(); } // Target
interface Bird { public void fly(); public void makeSound(); } // Adaptee interface

class Sparrow implements Bird {
  public void fly(){ System.out.println("Flying"); }
  public void makeSound(){ System.out.println("Chirp Chirp"); }
}

// The Adapter — implements Target, wraps an Adaptee
class BirdAdapter implements ToyDuck {
  Bird bird; // reference to the object we're adapting
  public BirdAdapter(Bird bird) { this.bird = bird; }
  public void squeak() {
    bird.makeSound(); // translate the call to the adaptee's method
  }
}

// Client
Sparrow sparrow = new Sparrow();
ToyDuck birdAdapter = new BirdAdapter(sparrow); // wrap it
birdAdapter.squeak(); // → "Chirp Chirp" — a bird behaving like a toy duck!

📐 Structure

Both Leaf (a single object) and Composite (a collection of Components) implement the same Component interface — that's the whole trick.

☕ Java — Component / Leaf / Composite

public interface Component {
  public void sayHello();
  public void sayGoodbye();
}

public class Leaf implements Component {
  String name;
  public Leaf(String name){ this.name = name; }
  public void sayHello(){ System.out.println(name + " leaf says hello"); }
  public void sayGoodbye(){ System.out.println(name + " leaf says goodbye"); }
}

public class Composite implements Component {
  List<Component> components = new ArrayList<>();
  public void add(Component c){ components.add(c); }
  public void sayHello(){ for(Component c : components) c.sayHello(); }
  public void sayGoodbye(){ for(Component c : components) c.sayGoodbye(); }
}

// Client
Composite composite1 = new Composite();
composite1.add(new Leaf("Bob"));
composite1.add(new Leaf("Fred"));
composite1.sayHello(); // → "Bob leaf says hello" then "Fred leaf says hello"
// composites can even nest inside other composites!

📐 Structure

The client never touches ClassA / ClassB directly — only the Facade.

📱 Worked Example — MobileShop

Setup: a MobileShop interface is implemented by Iphone, Samsung, Blackberry. Instead of the client juggling all three directly, a ShopKeeper Facade wraps them.

public interface MobileShop { void modelNo(); void price(); }

public class Iphone implements MobileShop { /* Iphone 6, Rs 65000 */ }
public class Samsung implements MobileShop { /* Galaxy Tab 3, Rs 45000 */ }
public class Blackberry implements MobileShop { /* Z10, Rs 55000 */ }

// The Facade
public class ShopKeeper {
  private MobileShop iphone, samsung, blackberry;
  public ShopKeeper(){
    iphone = new Iphone(); samsung = new Samsung(); blackberry = new Blackberry();
  }
  public void iphoneSale(){ iphone.modelNo(); iphone.price(); }
  public void samsungSale(){ samsung.modelNo(); samsung.price(); }
  public void blackberrySale(){ blackberry.modelNo(); blackberry.price(); }
}

// Client — never touches Iphone/Samsung/Blackberry directly
ShopKeeper sk = new ShopKeeper();
sk.iphoneSale(); // → "Iphone 6" · "Rs 65000.00"