Java Technologies Generics এর মাধ্যমে Builder Pattern গাইড ও নোট

Builder Pattern হলো একটি ডিজাইন প্যাটার্ন যা জটিল অবজেক্ট তৈরির জন্য ধাপে ধাপে একটি পদ্ধতি প্রদান করে। জেনেরিক্স ব্যবহার করে এই প্যাটার্ন আরও ফ্লেক্সিবল ও পুনঃব্যবহারযোগ্য করা যায়।

Generics ব্যবহার করে Builder Pattern এর সুবিধা

1. টাইপ সেফটি নিশ্চিত করে: জেনেরিক্সের মাধ্যমে টাইপ মিসম্যাচ সমস্যা এড়ানো যায়।
2. পুনঃব্যবহারযোগ্য কোড: বিভিন্ন টাইপের অবজেক্ট তৈরি করার জন্য একই বিল্ডার ব্যবহার করা যায়।
3. ফ্লুয়েন্ট API: কোড পড়া ও ব্যবহার করা সহজ হয়।

Generics সহ Builder Pattern এর গঠন

1. Basic Generic Builder Pattern

উদাহরণ:

public class GenericBuilder<T> {
    private T instance;

    public GenericBuilder(T instance) {
        this.instance = instance;
    }

    public T build() {
        return instance;
    }

    public GenericBuilder<T> with(Consumer<T> consumer) {
        consumer.accept(instance);
        return this;
    }

    public static void main(String[] args) {
        // Example of building a StringBuilder using the generic builder
        StringBuilder sb = new GenericBuilder<>(new StringBuilder())
                .with(builder -> builder.append("Hello"))
                .with(builder -> builder.append(", Generics!"))
                .build();

        System.out.println(sb); // Output: Hello, Generics!
    }
}

2. Generics সহ Complex Builder Pattern

উদাহরণ:

public class GenericBuilder<T> {
    private final T instance;

    private GenericBuilder(Class<T> clazz) {
        try {
            this.instance = clazz.getDeclaredConstructor().newInstance();
        } catch (Exception e) {
            throw new RuntimeException("Error creating instance", e);
        }
    }

    public static <T> GenericBuilder<T> of(Class<T> clazz) {
        return new GenericBuilder<>(clazz);
    }

    public GenericBuilder<T> with(Consumer<T> consumer) {
        consumer.accept(instance);
        return this;
    }

    public T build() {
        return instance;
    }
}

// Example class to build
class User {
    private String name;
    private int age;

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

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{name='" + name + "', age=" + age + "}";
    }
}

// Main method
public class Main {
    public static void main(String[] args) {
        User user = GenericBuilder.of(User.class)
                .with(u -> u.setName("Alice"))
                .with(u -> u.setAge(25))
                .build();

        System.out.println(user); // Output: User{name='Alice', age=25}
    }
}

3. Inheritance সহ Generics এবং Builder Pattern

জেনেরিক বিল্ডার প্যাটার্ন ইনহেরিটেন্স সমর্থন করে।

উদাহরণ:

class Person {
    private String name;

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

    @Override
    public String toString() {
        return "Person{name='" + name + "'}";
    }
}

class Employee extends Person {
    private String position;

    public void setPosition(String position) {
        this.position = position;
    }

    @Override
    public String toString() {
        return super.toString() + ", position='" + position + "'";
    }
}

class PersonBuilder<T extends Person, B extends PersonBuilder<T, B>> {
    protected final T instance;

    public PersonBuilder(T instance) {
        this.instance = instance;
    }

    public B withName(String name) {
        instance.setName(name);
        return (B) this;
    }

    public T build() {
        return instance;
    }
}

class EmployeeBuilder extends PersonBuilder<Employee, EmployeeBuilder> {
    public EmployeeBuilder() {
        super(new Employee());
    }

    public EmployeeBuilder withPosition(String position) {
        instance.setPosition(position);
        return this;
    }
}

// Main method
public class Main {
    public static void main(String[] args) {
        Employee employee = new EmployeeBuilder()
                .withName("Bob")
                .withPosition("Developer")
                .build();

        System.out.println(employee); // Output: Person{name='Bob'}, position='Developer'
    }
}

Generics এর মাধ্যমে Builder Pattern:

1. Reusable এবং Flexible হয়।
2. টাইপ সেফ কোড তৈরি নিশ্চিত করে।
3. কমপ্লেক্স ক্লাসের ইনহেরিটেন্স ব্যবস্থাপনা সহজ করে।

এই প্যাটার্ন বড় ও জটিল অবজেক্ট তৈরির জন্য অত্যন্ত কার্যকর এবং কোড রিডেবিলিটি বাড়ায়।