AAA Check - Yash-777/MyWorld GitHub Wiki

// Product interface
class Button {
  render() {}
}

class DarkButton extends Button {
  render() { return "🖤 Dark Button"; }
}

class LightButton extends Button {
  render() { return "🤍 Light Button"; }
}

class NightButton extends Button {
  render() { return "🌙 Night Button"; }
}

// Factory — creates ONE type of object based on input
class ButtonFactory {
  static create(theme) {
    switch (theme) {
      case "dark":  return new DarkButton();
      case "light": return new LightButton();
      case "night": return new NightButton();
      default: throw new Error("Unknown theme");
    }
  }
}

// Usage
const btn = ButtonFactory.create("dark");
console.log(btn.render()); // 🖤 Dark Button

// === Product Interfaces ===
// Buttons
class DarkButton  { render() { return "🖤 Dark Button"; } }
class LightButton { render() { return "🤍 Light Button"; } }
class NightButton { render() { return "🌙 Night Button"; } }

// Checkboxes
class DarkCheckbox  { render() { return "🖤 Dark Checkbox"; } }
class LightCheckbox { render() { return "🤍 Light Checkbox"; } }
class NightCheckbox { render() { return "🌙 Night Checkbox"; } }

// Modals
class DarkModal  { render() { return "🖤 Dark Modal"; } }
class LightModal { render() { return "🤍 Light Modal"; } }
class NightModal { render() { return "🌙 Night Modal"; } }

// === Abstract Factories (one per theme) ===
class DarkThemeFactory {
  createButton()   { return new DarkButton(); }
  createCheckbox() { return new DarkCheckbox(); }
  createModal()    { return new DarkModal(); }
}

class LightThemeFactory {
  createButton()   { return new LightButton(); }
  createCheckbox() { return new LightCheckbox(); }
  createModal()    { return new LightModal(); }
}

class NightThemeFactory {
  createButton()   { return new NightButton(); }
  createCheckbox() { return new NightCheckbox(); }
  createModal()    { return new NightModal(); }
}

// === Factory Selector ===
function getThemeFactory(theme) {
  switch (theme) {
    case "dark":  return new DarkThemeFactory();
    case "light": return new LightThemeFactory();
    case "night": return new NightThemeFactory();
    default: throw new Error("Unknown theme");
  }
}

// === Client Code ===
function buildUI(factory) {
  const button   = factory.createButton();
  const checkbox = factory.createCheckbox();
  const modal    = factory.createModal();
console.log(button.render());    // 🖤 Dark Button
console.log(checkbox.render());  // 🖤 Dark Checkbox
console.log(modal.render());     // 🖤 Dark Modal
}

const factory = getThemeFactory("dark");
buildUI(factory);

Lombok's @Builder annotation automatically generates a static nested builder class, a builder() method, 
and a build() method to create instances of the annotated class, reducing boilerplate code for the Builder design pattern.
It enables fluent API usage like Class.builder().field1(val).build(). 

Key Components of Generated Code
Static Inner Class: Creates ClassNameBuilder (e.g., PersonBuilder) to hold temporary state.
Builder Methods   : Generates methods for each field, returning the builder instance for chaining.
build() Method    : Contains the logic to call the actual class constructor, returning a new instance.
builder() Method  : Creates a new instance of the builder class.

@Builder
public class User {
    private String username;
    private int age;
}

public class User {
    private String username;
    private int age;

    // Generated Constructor
    User(String username, int age) {
        this.username = username;
        this.age = age;
    }

    // Generated Builder Method
    public static UserBuilder builder() {
        return new UserBuilder();
    }

    // Generated Static Inner Builder Class
    public static class UserBuilder {
        private String username;
        private int age;

        UserBuilder() {}

        public UserBuilder username(String username) {
            this.username = username;
            return this;
        }

        public UserBuilder age(int age) {
            this.age = age;
            return this;
        }

        public User build() {
            return new User(this.username, this.age);
        }
    }
}

A complex object may require many values to initialize. Using a large constructor or setting values in different places makes the code confusing and difficult to manage.
For example, let’s think about how to create a House object. To build a simple house, you need to construct four walls and a floor, install a door, 
fit a pair of windows, and build a roof. But what if you want a bigger, brighter house, with a backyard and other goodies 
(like a heating system, plumbing, and electrical wiring)?

The Builder pattern suggests that you extract the object construction code out of its own class and move it to separate objects called builders.

The Builder pattern divides object creation into multiple steps (such as buildWalls, buildDoor, etc.).
To create an object, these steps are executed using a builder object.
You do not need to perform all the steps — only the steps required to create a specific version or configuration of the object are used.