Structural Design Patterns

Structural Design Patterns (স্ট্রাকচারাল ডিজাইন প্যাটার্নস) হল এমন প্যাটার্ন যেগুলি সফটওয়্যার সিস্টেমের বিভিন্ন উপাদান বা ক্লাসের মধ্যে সম্পর্ক স্থাপন করার জন্য ব্যবহৃত হয়। এই প্যাটার্নগুলির উদ্দেশ্য হল উপাদানগুলির মধ্যে যোগাযোগ বা কাঠামো সহজতর করা, যাতে সিস্টেমের জটিলতা কমানো যায় এবং নতুন বৈশিষ্ট্য সহজে যুক্ত করা যায়। এই ধরনের ডিজাইন প্যাটার্নগুলো একে অপরের সাথে কাজ করা উপাদানগুলির মধ্যে একটি দৃঢ়, তবে নমনীয়, সম্পর্ক তৈরি করে।

স্ট্রাকচারাল প্যাটার্নের মধ্যে সাধারণভাবে ব্যবহৃত প্যাটার্নগুলির মধ্যে রয়েছে:

1. Adapter Pattern
2. Bridge Pattern
3. Composite Pattern
4. Decorator Pattern
5. Facade Pattern
6. Flyweight Pattern
7. Proxy Pattern

1. Adapter Pattern

Adapter Pattern হল একটি স্ট্রাকচারাল ডিজাইন প্যাটার্ন যা দুটি অক্ষত শ্রেণী বা ক্লাসের মধ্যে সমন্বয় স্থাপন করে। এটি একটি শ্রেণীর ইন্টারফেসকে অন্য ইন্টারফেসের সাথে সমন্বয় করতে সাহায্য করে। Adapter একটি মধ্যস্থতাকারী হিসেবে কাজ করে এবং এক ক্লাসের মেথডগুলোকে অন্য ক্লাসের জন্য পরিবর্তন বা মানানসই করে।

উদাহরণ:

// Target Interface
interface MediaPlayer {
    void play(String audioType, String fileName);
}

// Adapter Pattern - Adapter Class
class MediaAdapter implements MediaPlayer {
    AdvancedMediaPlayer advancedMusicPlayer;

    public MediaAdapter(String audioType) {
        if(audioType.equalsIgnoreCase("vlc") ){
            advancedMusicPlayer = new VlcPlayer();
        } else if(audioType.equalsIgnoreCase("mp4")){
            advancedMusicPlayer = new Mp4Player();
        }
    }

    @Override
    public void play(String audioType, String fileName) {
        if(audioType.equalsIgnoreCase("vlc")){
            advancedMusicPlayer.playVlc(fileName);
        }
        else if(audioType.equalsIgnoreCase("mp4")){
            advancedMusicPlayer.playMp4(fileName);
        }
    }
}

// Concrete classes implementing AdvancedMediaPlayer interface
interface AdvancedMediaPlayer {
    void playVlc(String fileName);
    void playMp4(String fileName);
}

class VlcPlayer implements AdvancedMediaPlayer {

    @Override
    public void playVlc(String fileName) {
        System.out.println("Playing VLC file: " + fileName);
    }

    @Override
    public void playMp4(String fileName) {
        // do nothing
    }
}

class Mp4Player implements AdvancedMediaPlayer {

    @Override
    public void playVlc(String fileName) {
        // do nothing
    }

    @Override
    public void playMp4(String fileName) {
        System.out.println("Playing MP4 file: " + fileName);
    }
}

public class AdapterPatternDemo {
    public static void main(String[] args) {
        AudioPlayer audioPlayer = new AudioPlayer();

        audioPlayer.play("mp3", "beyond the horizon.mp3");
        audioPlayer.play("mp4", "alone.mp4");
        audioPlayer.play("vlc", "far far away.vlc");
    }
}

2. Bridge Pattern

Bridge Pattern একটি স্ট্রাকচারাল ডিজাইন প্যাটার্ন যা একটি ক্লাসের ইন্টারফেস এবং এর বাস্তবায়নের মধ্যে একটি ব্রিজ তৈরি করে। এর ফলে, বাস্তবায়নকে পরিবর্তন করা হলে, ইন্টারফেসে কোনো পরিবর্তন প্রয়োজন হয় না। এটি প্রধানত ক্লাসের ইন্টারফেস এবং বাস্তবায়ন (implementation) এর মধ্যে সংযোগ তৈরি করতে ব্যবহৃত হয়।

উদাহরণ:

interface Shape {
    void draw();
}

interface Color {
    void fill();
}

class Circle implements Shape {
    Color color;
    
    public Circle(Color color) {
        this.color = color;
    }

    @Override
    public void draw() {
        System.out.print("Drawing Circle. ");
        color.fill();
    }
}

class Red implements Color {
    @Override
    public void fill() {
        System.out.println("Coloring it Red.");
    }
}

class Blue implements Color {
    @Override
    public void fill() {
        System.out.println("Coloring it Blue.");
    }
}

public class BridgePatternDemo {
    public static void main(String[] args) {
        Shape circle1 = new Circle(new Red());
        circle1.draw();
        
        Shape circle2 = new Circle(new Blue());
        circle2.draw();
    }
}

3. Composite Pattern

Composite Pattern একটি স্ট্রাকচারাল ডিজাইন প্যাটার্ন যা অবজেক্টগুলোকে হায়ারার্কি বা গাছের মতো সংগঠিত করে। এই প্যাটার্নে, ছোট ছোট অবজেক্টগুলোকে একত্রিত করে একটি বড় অবজেক্ট তৈরি করা হয়, যাতে তারা একসাথে একটি উপাদান হিসেবে কাজ করে।

উদাহরণ:

interface Employee {
    void showEmployeeDetails();
}

class Developer implements Employee {
    private String name;
    private String role;

    public Developer(String name, String role) {
        this.name = name;
        this.role = role;
    }

    @Override
    public void showEmployeeDetails() {
        System.out.println("Developer: " + name + " | Role: " + role);
    }
}

class Manager implements Employee {
    private String name;
    private String role;
    private List<Employee> employees = new ArrayList<>();

    public Manager(String name, String role) {
        this.name = name;
        this.role = role;
    }

    public void addEmployee(Employee employee) {
        employees.add(employee);
    }

    @Override
    public void showEmployeeDetails() {
        System.out.println("Manager: " + name + " | Role: " + role);
        for(Employee employee : employees) {
            employee.showEmployeeDetails();
        }
    }
}

public class CompositePatternDemo {
    public static void main(String[] args) {
        Employee dev1 = new Developer("John", "Java Developer");
        Employee dev2 = new Developer("Emma", "Python Developer");

        Manager manager = new Manager("Michael", "Engineering Manager");
        manager.addEmployee(dev1);
        manager.addEmployee(dev2);

        manager.showEmployeeDetails();
    }
}

4. Decorator Pattern

Decorator Pattern একটি স্ট্রাকচারাল ডিজাইন প্যাটার্ন যা কোনো অবজেক্টের কার্যকারিতা বাড়ানোর জন্য তার সাথে নতুন ফিচার বা আচরণ যোগ করতে ব্যবহৃত হয়। এটি অবজেক্টের মৌলিক আচরণ পরিবর্তন না করে তার মধ্যে নতুন বৈশিষ্ট্য যোগ করে।

উদাহরণ:

interface Coffee {
    String make();
}

class SimpleCoffee implements Coffee {
    @Override
    public String make() {
        return "Simple Coffee";
    }
}

class MilkDecorator implements Coffee {
    private Coffee coffee;

    public MilkDecorator(Coffee coffee) {
        this.coffee = coffee;
    }

    @Override
    public String make() {
        return coffee.make() + " + Milk";
    }
}

class SugarDecorator implements Coffee {
    private Coffee coffee;

    public SugarDecorator(Coffee coffee) {
        this.coffee = coffee;
    }

    @Override
    public String make() {
        return coffee.make() + " + Sugar";
    }
}

public class DecoratorPatternDemo {
    public static void main(String[] args) {
        Coffee coffee = new SimpleCoffee();
        System.out.println(coffee.make());

        Coffee milkCoffee = new MilkDecorator(new SimpleCoffee());
        System.out.println(milkCoffee.make());

        Coffee milkSugarCoffee = new SugarDecorator(new MilkDecorator(new SimpleCoffee()));
        System.out.println(milkSugarCoffee.make());
    }
}

5. Facade Pattern

Facade Pattern একটি স্ট্রাকচারাল ডিজাইন প্যাটার্ন যা একটি সিস্টেমের বিভিন্ন সাবসিস্টেম বা কম্পোনেন্টের ইন্টারফেসগুলিকে একত্রিত করে একটি সাধারণ ইন্টারফেস সরবরাহ করে। এটি ব্যবহারকারীকে একটি সহজ ইন্টারফেস প্রদান করে যা সিস্টেমের অন্দরস্থ কার্যকলাপ লুকিয়ে রাখে।

উদাহরণ:

class CPU {
    public void process() {
        System.out.println("Processing...");
    }
}

class Memory {
    public void load() {
        System.out.println("Loading memory...");
    }
}

class HardDrive {
    public void read() {
        System.out.println("Reading from hard drive...");
    }
}

class ComputerFacade {
    private CPU cpu;
    private Memory memory;
    private HardDrive hardDrive;

    public ComputerFacade() {
        cpu = new CPU();
        memory = new Memory();
        hardDrive = new HardDrive();
    }

    public void startComputer() {
        cpu.process();
        memory.load();
        hardDrive.read();
        System.out.println("Computer is up and running!");
    }
}

public class FacadePatternDemo {
    public static void main(String[] args) {
        ComputerFacade computerFacade = new ComputerFacade();
        computerFacade.startComputer();
    }
}

সারাংশ

Structural Design Patterns (স্ট্রাকচারাল ডিজাইন প্যাটার্নস) সফটওয়্যার সিস্টেমের বিভিন্ন উপাদানের মধ্যে সম্পর্ক স্থাপন এবং কাঠামো তৈরি করার জন্য ব্যবহৃত হয়। Adapter, Bridge, Composite, Decorator, Facade ইত্যাদি প্যাটার্নগুলি সাধারণত বিভিন্ন সাব-সিস্টেম বা ক্লাসের মধ্যে সুসংগঠিত সম্পর্ক তৈরি করতে ব্যবহৃত হয়। এগুলোর সাহায্যে সফটওয়্যার সিস্টেমের জটিলতা কমানো এবং রক্ষণাবেক্ষণ সহজ করা হয়, পাশাপাশি নতুন বৈশিষ্ট্য সংযোজন আরও নমনীয় হয়।

Adapter Pattern একটি কাঠামোগত ডিজাইন প্যাটার্ন যা Structural Design Pattern শ্রেণিভুক্ত। এটি দুটি অপর্যাপ্ত ইন্টারফেসের মধ্যে একটি সেতু তৈরি করে, যাতে তারা একে অপরের সাথে কাজ করতে পারে। সাধারণভাবে, যখন দুটি ক্লাস বা সিস্টেমের মধ্যে সম্পর্ক স্থাপন করতে হয় এবং তাদের ইন্টারফেসগুলো মেলে না, তখন Adapter Pattern ব্যবহার করা হয়।

Adapter Pattern এর উদ্দেশ্য:

• এটি object compatibility প্রদান করে, যেখানে একটি ক্লাস অন্য ক্লাসের সাথে একত্রে কাজ করতে পারে, যদিও তাদের ইন্টারফেস একে অপরের সাথে মিলছে না।
• এটি একটি interface adapter হিসেবে কাজ করে, যা একটি সিস্টেমের ইন্টারফেসের সাথে অন্য সিস্টেমের ইন্টারফেসের অনুপযুক্ততার মধ্যে সেতুবন্ধন তৈরি করে।

Adapter Pattern এর প্রধান অংশ:

1. Target: এটি একটি সাধারণ ইন্টারফেস যা ক্লায়েন্ট (Client) ব্যবহারের জন্য প্রস্তুত থাকে।
2. Client: যে ক্লাসটি Adapter Pattern ব্যবহার করে সিস্টেমের ইন্টারফেসের সাথে কাজ করে।
3. Adaptee: এটি একটি সিস্টেম, যার ইন্টারফেস পরিবর্তন করতে হবে (অথবা তার সাথে মানানসই করা হবে) যাতে এটি ক্লায়েন্টের জন্য উপযুক্ত হয়।
4. Adapter: এটি মূলত Adaptee এর ইন্টারফেসকে Target ইন্টারফেসে রূপান্তরিত করে, যাতে এটি ক্লায়েন্ট দ্বারা ব্যবহৃত হতে পারে।

Adapter Pattern এর উদাহরণ

ধরা যাক, আমাদের একটি MediaPlayer ক্লাস এবং একটি MediaAdapter ক্লাস তৈরি করতে হবে। এখানে, MediaPlayer একটি সাধারণ ইন্টারফেস যেটি সমস্ত মিডিয়া ফাইল (যেমন mp3, mp4) প্লে করতে সক্ষম। তবে, আমাদের কাছে বিভিন্ন প্লেয়ার যেমন VLC এবং MP4Player এর জন্য আলাদা ইন্টারফেস রয়েছে, যেগুলি MediaPlayer ইন্টারফেসের সাথে কাজ করে না। এখানে Adapter Pattern ব্যবহার করে, আমরা একে অপরের সাথে কাজ করার উপযোগী করে তুলব।

১. Target Interface (MediaPlayer)

interface MediaPlayer {
    void play(String audioType, String fileName);
}

২. Adaptee Classes (VlcPlayer, Mp4Player)

interface AdvancedMediaPlayer {
    void playVlc(String fileName);
    void playMp4(String fileName);
}

class VlcPlayer implements AdvancedMediaPlayer {
    public void playVlc(String fileName) {
        System.out.println("Playing vlc file. Name: " + fileName);
    }

    public void playMp4(String fileName) {
        // Do nothing
    }
}

class Mp4Player implements AdvancedMediaPlayer {
    public void playVlc(String fileName) {
        // Do nothing
    }

    public void playMp4(String fileName) {
        System.out.println("Playing mp4 file. Name: " + fileName);
    }
}

৩. Adapter Class (MediaAdapter)

class MediaAdapter implements MediaPlayer {
    AdvancedMediaPlayer advancedMusicPlayer;

    public MediaAdapter(String audioType) {
        if(audioType.equalsIgnoreCase("vlc")){
            advancedMusicPlayer = new VlcPlayer();
        }
        else if(audioType.equalsIgnoreCase("mp4")){
            advancedMusicPlayer = new Mp4Player();
        }
    }

    public void play(String audioType, String fileName) {
        if(audioType.equalsIgnoreCase("vlc")){
            advancedMusicPlayer.playVlc(fileName);
        }
        else if(audioType.equalsIgnoreCase("mp4")){
            advancedMusicPlayer.playMp4(fileName);
        }
    }
}

৪. Client Code (AudioPlayer)

class AudioPlayer implements MediaPlayer {
    MediaAdapter mediaAdapter;

    public void play(String audioType, String fileName) {
        // Play the mp3 file
        if(audioType.equalsIgnoreCase("mp3")){
            System.out.println("Playing mp3 file. Name: " + fileName);
        }
        // Use MediaAdapter to play other formats
        else if(audioType.equalsIgnoreCase("vlc") || audioType.equalsIgnoreCase("mp4")){
            mediaAdapter = new MediaAdapter(audioType);
            mediaAdapter.play(audioType, fileName);
        }
        else{
            System.out.println("Invalid media type.");
        }
    }
}

৫. Main Method (Test)

public class AdapterPatternTest {
    public static void main(String[] args) {
        AudioPlayer audioPlayer = new AudioPlayer();

        audioPlayer.play("mp3", "beyond the horizon.mp3");
        audioPlayer.play("mp4", "alone.mp4");
        audioPlayer.play("vlc", "far far away.vlc");
        audioPlayer.play("avi", "mind me.avi");
    }
}

ব্যাখ্যা:

• MediaPlayer ইন্টারফেস হল Target যা ক্লায়েন্টে ব্যবহৃত হবে।
• VlcPlayer এবং Mp4Player হলো Adaptee যেগুলির ইন্টারফেস একে অপরের সাথে মেলে না।
• MediaAdapter ক্লাস Adapter হিসেবে কাজ করছে, এটি AdvancedMediaPlayer এর ইন্টারফেসকে MediaPlayer ইন্টারফেসে রূপান্তরিত করছে।
• AudioPlayer ক্লাস হচ্ছে ক্লায়েন্ট, যা MediaPlayer ইন্টারফেস ব্যবহার করছে।

আউটপুট:

Playing mp3 file. Name: beyond the horizon.mp3
Playing mp4 file. Name: alone.mp4
Playing vlc file. Name: far far away.vlc
Invalid media type.

Adapter Pattern এর সুবিধা

1. Class Incompatibility: যখন দুটি ক্লাস একে অপরের সাথে কাজ করতে পারে না, তখন তাদের মধ্যে একটি সেতুবন্ধন তৈরি করতে Adapter Pattern ব্যবহার করা হয়।
2. Reusability: Adapter প্যাটার্ন ব্যবহার করে আপনি ইতিমধ্যে বিদ্যমান ক্লাসের ইন্টারফেসকে নতুন ক্লাসের সাথে কাজ করার জন্য পুনরায় ব্যবহার করতে পারেন।
3. Code Maintainability: এই প্যাটার্নটি কোডের রক্ষণাবেক্ষণ সহজ করে, কারণ এটি কমপ্লেক্সিটি লুকিয়ে রাখে এবং কোডকে পরিষ্কার রাখে।
4. Flexibility: এটি আপনি বিভিন্ন সিস্টেমের মধ্যে যে কোন রকমের ইন্টারফেস সম্পর্কিত সমস্যা সমাধান করতে পারেন।

সারাংশ

Adapter Pattern একটি Structural Design Pattern যা একটি ক্লাসের ইন্টারফেসকে অন্য ক্লাসের সাথে উপযুক্ত করে তোলে। এটি এমন ক্ষেত্রগুলোতে ব্যবহৃত হয় যেখানে দুটি সিস্টেম বা ক্লাসের মধ্যে সম্পর্ক স্থাপন করতে গিয়ে ইন্টারফেসের অমিল ঘটে। Adapter প্যাটার্নটি সিস্টেমের মধ্যে সামঞ্জস্য তৈরির জন্য একটি ইন্টারফেসকে অন্য একটি ইন্টারফেসে রূপান্তরিত করে।

Adapter Pattern এর ব্যবহার:

• Plug-and-play সিস্টেমে, যেখানে নতুন প্লাগইন বা ইন্টারফেস সংযোজন করা হয়।
• Legacy code অথবা পুরনো সিস্টেমে যেখানে বর্তমান সিস্টেমের সাথে নতুন সিস্টেমের ইন্টারফেস মেলে না।
• বিভিন্ন ধরনের ড্রাইভার বা মিডিয়া প্লেয়ার সিস্টেমে যেখানে একাধিক প্ল্যাটফর্ম বা ফর্ম্যাটের জন্য সাপোর্ট প্রয়োজন।

Adapter Pattern ব্যবহারের মাধ্যমে সিস্টেমের কার্যক্ষমতা বৃদ্ধি পায় এবং কোডের মধ্যে মেলবন্ধন সৃষ্টির মাধ্যমে সিস্টেমের কার্যকরীতা নিশ্চিত করা যায়।

Bridge Pattern হল একটি Structural Design Pattern যা abstraction এবং implementation এর মধ্যে একটি পৃথক ব্রিজ তৈরি করে, যাতে তারা একে অপরের থেকে স্বাধীনভাবে বিকশিত হতে পারে। এটি মূলত এমন একটি কাঠামো তৈরি করে যা abstraction স্তর এবং implementation স্তরের মধ্যে পার্থক্য সৃষ্টি করে এবং সেগুলিকে একে অপর থেকে আলাদা করে।

Bridge Pattern এর উদ্দেশ্য হলো, abstraction (যা ক্লাসের বাইরের ব্যবহারকারীর জন্য ইন্টারফেস সরবরাহ করে) এবং implementation (যা প্রকৃত কার্যকারিতা নির্ধারণ করে) এর মধ্যে শক্তি সম্পর্ক প্রতিষ্ঠা করা, যাতে পরবর্তীতে এদের একে অপরের থেকে স্বাধীনভাবে পরিবর্তন করা যায়।

Bridge Pattern এর মৌলিক কাঠামো

• Abstraction: এটি একটি উচ্চ স্তরের ক্লাস যা ইউজার ইন্টারফেস বা পাবলিক ইন্টারফেস সরবরাহ করে এবং একটি Implementor অবজেক্টে যোগাযোগ করে।
• Refined Abstraction: এটি Abstraction ক্লাসের একটি সম্প্রসারণ যা অধিকাংশ ক্ষেত্রে অতিরিক্ত বৈশিষ্ট্য বা কার্যকারিতা প্রদান করে।
• Implementor: এটি একটি সাধারণ ইন্টারফেস যা ConcreteImplementor ক্লাস দ্বারা বাস্তবায়িত হয়। এটি কম্পিউটার কোডের কার্যকরী অংশ যা নির্দিষ্ট কাজ করে।
• Concrete Implementor: এটি Implementor ইন্টারফেসকে বাস্তবায়িত করে এবং কার্যকরী কোড সরবরাহ করে।

Bridge Pattern এর উদ্দেশ্য

Bridge Pattern ব্যবহার করলে কোডটি নিম্নলিখিত সুবিধা পাবে:

1. Independence of Abstraction and Implementation: abstraction এবং implementation একে অপরের থেকে স্বাধীনভাবে পরিবর্তন করা যেতে পারে। যদি আপনি abstraction বা implementation এ পরিবর্তন করতে চান, তবে অন্যটি প্রভাবিত হবে না।
2. Improved Flexibility: এর ফলে একে অপরের উপর নির্ভরশীলতা কমে যায়, এবং অ্যাপ্লিকেশনের মধ্যে পরিবর্তন এবং রক্ষণাবেক্ষণ সহজ হয়ে যায়।

Bridge Pattern এর ব্যবহার

• যখন abstraction এবং implementation একে অপরের উপর নির্ভরশীল থাকে, তবে Bridge Pattern ব্যবহার করা হয়।
• যখন আপনি একই abstraction এর জন্য বিভিন্ন types এর implementation তৈরি করতে চান।
• যখন আপনি একটি abstraction স্তরের মধ্যে ডাইনামিকভাবে বিভিন্ন implementation পছন্দ করতে চান।

উদাহরণ: Bridge Pattern in Java

ধরা যাক আমাদের একটি গাড়ির রঙ এবং ধরণের জন্য ব্রিজ প্যাটার্ন তৈরি করতে হবে। এখানে, Vehicle ক্লাস হচ্ছে abstraction এবং Color ক্লাস হচ্ছে implementation। Vehicle এর মধ্যে গাড়ির রঙ নির্ধারণের জন্য Bridge Pattern ব্যবহার করা হবে।

// Implementor Interface
interface Color {
    void fillColor();
}

// Concrete Implementor Classes
class Red implements Color {
    @Override
    public void fillColor() {
        System.out.println("Filling color with Red");
    }
}

class Blue implements Color {
    @Override
    public void fillColor() {
        System.out.println("Filling color with Blue");
    }
}

// Abstraction Class
abstract class Vehicle {
    protected Color color;

    // Constructor to initialize color
    public Vehicle(Color color) {
        this.color = color;
    }

    abstract void manufacture();
}

// Refined Abstraction Classes
class Car extends Vehicle {
    public Car(Color color) {
        super(color);
    }

    @Override
    void manufacture() {
        System.out.print("Manufacturing Car - ");
        color.fillColor();
    }
}

class Bike extends Vehicle {
    public Bike(Color color) {
        super(color);
    }

    @Override
    void manufacture() {
        System.out.print("Manufacturing Bike - ");
        color.fillColor();
    }
}

public class BridgePatternExample {
    public static void main(String[] args) {
        Vehicle redCar = new Car(new Red());  // Car with Red color
        Vehicle blueBike = new Bike(new Blue());  // Bike with Blue color

        redCar.manufacture();  // Output: Manufacturing Car - Filling color with Red
        blueBike.manufacture();  // Output: Manufacturing Bike - Filling color with Blue
    }
}

ব্যাখ্যা:

1. Color Interface: Color ইন্টারফেসটি Implementor হিসেবে কাজ করে। এটি রঙের সুনির্দিষ্ট পদ্ধতি fillColor() ডিফাইন করে।
2. Red and Blue Classes: Red এবং Blue ক্লাসগুলি ConcreteImplementor হিসেবে কাজ করে এবং fillColor() পদ্ধতিটি বাস্তবায়িত করে, যাতে তাদের নিজস্ব রঙ প্রদান করতে পারে।
3. Vehicle Class: Vehicle ক্লাসটি Abstraction হিসেবে কাজ করে এবং Color অবজেক্ট গ্রহণ করে। এর মধ্যে manufacture() পদ্ধতি যা গাড়ির নির্মাণের কাজ করে।
4. Car and Bike Classes: Car এবং Bike ক্লাসগুলি Vehicle এর Refined Abstraction ক্লাস। এগুলি manufacture() পদ্ধতি নির্দিষ্টভাবে অ্যাডজাস্ট করে।

আউটপুট:

Manufacturing Car - Filling color with Red
Manufacturing Bike - Filling color with Blue

Bridge Pattern এর সুবিধা:

1. Decouples abstraction from implementation: এটি abstraction এবং implementation এর মধ্যে একে অপরের ওপর নির্ভরশীলতা দূর করে। ফলে, একে অপরকে পরিবর্তন করা সহজ হয়ে যায়।
2. Scalability: নতুন abstraction বা implementation যুক্ত করা সহজ হয়।
3. Flexibility: একটি abstraction স্তর বা implementation পরিবর্তন করলে অন্যটি প্রভাবিত হয় না।

Bridge Pattern এর সীমাবদ্ধতা:

1. Increased Complexity: সাধারণত, Bridge Pattern প্রয়োগ করলে কোডের জটিলতা বাড়ে কারণ দুটি স্তরের মধ্যে সম্পর্ক স্থাপন করা হয়। ছোট এবং সহজ সমস্যার জন্য এটি অতিরিক্ত জটিলতা সৃষ্টি করতে পারে।
2. Extra Classes: ক্লাসের সংখ্যা বাড়ে, কারণ abstraction এবং implementation এর জন্য আলাদা আলাদা ক্লাস তৈরি করতে হয়।

সারাংশ

Bridge Pattern হল একটি structural design pattern যা abstraction এবং implementation এর মধ্যে সম্পর্ক আলাদা করে। এটি দুইটি স্তরের মধ্যে স্বাধীনতা বজায় রাখে এবং তাদের মধ্যে সমন্বয় সহজ করে। Java তে Bridge Pattern এর ব্যবহার বিভিন্ন ক্লাসের মধ্যে পারস্পরিক সম্পর্ক সহজভাবে তৈরি করে এবং কোডের নমনীয়তা বাড়ায়। এই প্যাটার্নটি বিশেষত তখন ব্যবহারযোগ্য যখন একটি সিস্টেমের মধ্যে abstraction এবং implementation পরিবর্তন করা প্রয়োজন, তবে একে অপরের ওপর নির্ভরশীলতা কমানোর জন্য।

Composite Pattern হল একটি স্ট্রাকচারাল ডিজাইন প্যাটার্ন যা অবজেক্টগুলোকে গঠনমূলকভাবে হায়ারার্কিক্যাল ট্রি আকারে সংগঠিত করে। এটি leaf এবং composite অবজেক্টগুলোকে একত্রে পরিচালনা করতে সাহায্য করে। এক কথায়, এটি tree structures বা hierarchical structures তৈরির জন্য ব্যবহৃত হয় যেখানে আপনি leaf এবং composite অবজেক্টগুলোকে একত্রে ব্যবহার করতে পারেন।

Composite Pattern এর মাধ্যমে single objects এবং groups of objects (কমপোজিট অবজেক্ট) একইভাবে ব্যবহার করা যায়। এর মাধ্যমে আপনি ক্লায়েন্ট কোডে একে অপরের মধ্যে পার্থক্য না রেখে একাধিক অবজেক্টকে একত্রে পরিচালনা করতে পারবেন।

উদাহরণ:

ধরা যাক একটি File System যেখানে ফাইল এবং ফোল্ডার উভয়ই FileSystemComponent হিসেবে ব্যবহার হতে পারে। ফাইলগুলো হল leaf অবজেক্ট এবং ফোল্ডারগুলো হল composite অবজেক্ট, যেগুলোর মধ্যে ফাইল এবং অন্য ফোল্ডার থাকতে পারে। আপনি একইভাবে ফাইল এবং ফোল্ডারকে প্রসেস করতে পারবেন।

1. Composite Pattern এর মৌলিক ধারণা

Composite Pattern তিনটি প্রধান উপাদান দিয়ে গঠিত:

1. Component: এটি একটি সাধারণ ইন্টারফেস যা leaf এবং composite উভয়ের জন্য ব্যবহৃত হয়।
2. Leaf: এটি এমন একটি অবজেক্ট যা কোনো উপাদান ধারণ করে না এবং একে সরাসরি প্রক্রিয়া করা হয়।
3. Composite: এটি এমন একটি অবজেক্ট যা এক বা একাধিক leaf অথবা composite অবজেক্ট ধারণ করতে পারে এবং তাদের সাথে কার্যকরভাবে কাজ করে।

2. Composite Pattern এর বাস্তবায়ন

ধরা যাক আমরা একটি FileSystem ডিজাইন করতে চাই, যেখানে ফাইল এবং ফোল্ডার উভয়কেই একইভাবে পরিচালনা করা হবে। এর জন্য আমরা Composite Pattern ব্যবহার করতে পারি।

উদাহরণ: FileSystem Composite Pattern

import java.util.ArrayList;
import java.util.List;

// Component - FileSystemComponent Interface
interface FileSystemComponent {
    void showDetails();
}

// Leaf - File class
class File implements FileSystemComponent {
    private String name;
    private int size;

    public File(String name, int size) {
        this.name = name;
        this.size = size;
    }

    @Override
    public void showDetails() {
        System.out.println("File: " + name + ", Size: " + size + " KB");
    }
}

// Composite - Folder class
class Folder implements FileSystemComponent {
    private String name;
    private List<FileSystemComponent> components = new ArrayList<>();

    public Folder(String name) {
        this.name = name;
    }

    // Add a component (either file or folder)
    public void addComponent(FileSystemComponent component) {
        components.add(component);
    }

    @Override
    public void showDetails() {
        System.out.println("Folder: " + name);
        for (FileSystemComponent component : components) {
            component.showDetails();
        }
    }
}

public class CompositePatternExample {
    public static void main(String[] args) {
        // Creating leaf components
        File file1 = new File("file1.txt", 10);
        File file2 = new File("file2.txt", 20);
        File file3 = new File("file3.txt", 30);

        // Creating composite components (folders)
        Folder folder1 = new Folder("Folder1");
        Folder folder2 = new Folder("Folder2");

        // Adding files to folders
        folder1.addComponent(file1);
        folder1.addComponent(file2);

        folder2.addComponent(file3);
        folder2.addComponent(folder1);  // Adding folder1 into folder2

        // Displaying folder and file details
        folder2.showDetails();
    }
}

ব্যাখ্যা:

• FileSystemComponent ইন্টারফেসটি File এবং Folder উভয় ক্লাসের জন্য কমন ফাংশনালিটি সরবরাহ করে।
• File ক্লাসটি leaf অবজেক্ট, যেখানে শুধুমাত্র ফাইলের নাম এবং আকার সংরক্ষিত থাকে এবং এর showDetails() ফাংশনটি ফাইলের তথ্য প্রদর্শন করে।
• Folder ক্লাসটি composite অবজেক্ট, যা ফাইল এবং অন্যান্য ফোল্ডারকে ধারণ করে এবং তাদের showDetails() ফাংশনটি কল করে।

আউটপুট:

Folder: Folder2
File: file3.txt, Size: 30 KB
Folder: Folder1
File: file1.txt, Size: 10 KB
File: file2.txt, Size: 20 KB

3. Composite Pattern এর সুবিধা

• Uniform Interface: Composite Pattern সব ধরনের অবজেক্ট (leaf এবং composite) এর জন্য একটি সাধারণ ইন্টারফেস প্রদান করে, যার ফলে ক্লায়েন্ট কোড সহজ হয় এবং একসাথে leaf এবং composite অবজেক্টগুলির সাথে কাজ করা যায়।
• Flexibility: এটি গঠনগতভাবে ফোল্ডার এবং ফাইলের মতো অবজেক্টগুলোকে একত্রে পরিচালনা করতে সহায়তা করে।
• Scalability: নতুন ধরনের অবজেক্ট (যেমন, নতুন ধরনের ফাইল বা ফোল্ডার) যোগ করা সহজ হয়।
• Reusability: এটি পুনঃব্যবহারযোগ্য, কারণ নতুন অবজেক্টগুলো পূর্ববর্তী ইন্টারফেসের সাথে সামঞ্জস্যপূর্ণ।

4. Composite Pattern এর বাস্তব প্রয়োগ

Composite Pattern অনেক ক্ষেত্রে ব্যবহৃত হয় যেখানে প্যারেন্ট এবং চিল্ড (leaf) অবজেক্টগুলো একত্রে পরিচালনা করতে হয়। কিছু সাধারণ বাস্তব প্রয়োগ হল:

• File Systems: ফাইল এবং ফোল্ডারগুলোকে একত্রে পরিচালনা করার জন্য ব্যবহৃত হয়।
• Graphics Systems: গ্রাফিক্যাল অবজেক্ট যেমন আয়তক্ষেত্র, বৃত্ত, লাইন ইত্যাদি, যেগুলি একটি গ্রাফিক্যাল কাঠামোতে একত্রে ব্যবহৃত হয়।
• UI Components: বিভিন্ন UI কম্পোনেন্ট যেমন প্যানেল, বোতাম, লেবেল, টেক্সট ফিল্ড, যা একত্রে কাজ করে এবং তাদের উপর একটি কমন ইন্টারফেস প্রয়োগ করা যায়।

Composite Pattern একটি শক্তিশালী ডিজাইন প্যাটার্ন যা কমপ্লেক্স এবং হায়ারার্কিক্যাল অবজেক্ট কাঠামো তৈরি করতে সাহায্য করে। এটি leaf এবং composite অবজেক্টগুলির মধ্যে এক ধরনের সম্পর্ক তৈরি করে এবং একটি সাধারণ ইন্টারফেসের মাধ্যমে তাদের পরিচালনা করতে সহায়তা করে। Java তে এই প্যাটার্ন ব্যবহার করে আপনি যেকোনো tree structure বা hierarchical structure কার্যকরীভাবে ম্যানেজ করতে পারবেন।

Decorator Pattern একটি স্ট্রাকচারাল ডিজাইন প্যাটার্ন, যা একটি অবজেক্টের আচরণ বা ক্ষমতাকে নতুনভাবে সাজানোর জন্য ব্যবহৃত হয়। এটি একটি ক্লাসের উপরে পরিবর্তন বা বাড়তি ফিচার যোগ করতে সক্ষম, এবং এর জন্য ক্লাসের কাঠামো পরিবর্তন না করে সেগুলিকে আড়াল করে বা প্রসারিত করে। এই প্যাটার্নটি অনেক সময় ব্যবহৃত হয় যখন কোনো ক্লাসে নতুন কার্যকারিতা যোগ করতে হয় তবে তা ঐ ক্লাসের মধ্যে সরাসরি পরিবর্তন না করে।

Decorator Pattern-এর মাধ্যমে আপনি কোনও অবজেক্টের ফাংশনালিটি সম্প্রসারিত করতে পারেন, যেটি মূল অবজেক্টকে ডিকোরেট করতে সক্ষম।

Decorator Pattern এর কাঠামো

Decorator Pattern সাধারণত তিনটি প্রধান উপাদান নিয়ে কাজ করে:

1. Component: একটি সাধারণ ইন্টারফেস বা ক্লাস যা আসল বা মৌলিক আচরণ নির্ধারণ করে।
2. ConcreteComponent: আসল অবজেক্ট যা Component ইন্টারফেসের ইমপ্লিমেন্টেশন।
3. Decorator: Component ইন্টারফেস বা ক্লাসের উপরে একটি ডেকোরেটর ক্লাস, যা আসল ক্লাসের ফাংশনালিটি প্রসারিত বা পরিবর্তন করে।

Decorator Pattern এর উদাহরণ

ধরা যাক, আমরা একটি কার তৈরি করছি, এবং আমাদেরকে একটি সাধারণ গাড়ির উপর বিভিন্ন অতিরিক্ত ফিচার (যেমন: এসি, সনি স্পিকার, আরামদায়ক সিট) যোগ করতে হবে। এই ফিচারগুলি গাড়ির উপরে সাজানো (decorating) হবে।

1. Component Interface

প্রথমে, আমরা একটি সাধারণ Car ইন্টারফেস তৈরি করব যা সাধারণ কারের গুণাবলী নির্দেশ করবে।

public interface Car {
    void assemble();  // Method to assemble the car
}

2. ConcreteComponent

এখানে আমরা একটি কনক্রিট ক্লাস তৈরি করব যা Car ইন্টারফেস ইমপ্লিমেন্ট করবে এবং একটি সাধারণ কারের বৈশিষ্ট্য নির্দেশ করবে।

public class BasicCar implements Car {
    @Override
    public void assemble() {
        System.out.println("Basic Car.");
    }
}

3. Decorator Class

এখন আমরা একটি Decorator ক্লাস তৈরি করব, যা Car ইন্টারফেসে নির্দিষ্ট ফিচার যোগ করতে সক্ষম হবে।

public class CarDecorator implements Car {
    protected Car decoratedCar;  // A reference to the decorated car

    public CarDecorator(Car car) {
        this.decoratedCar = car;
    }

    @Override
    public void assemble() {
        this.decoratedCar.assemble();  // Delegates the call to the decorated car
    }
}

4. Concrete Decorators

এখন আমরা বিভিন্ন কনক্রিট ডেকোরেটর তৈরি করব যা CarDecorator থেকে ইনহেরিট করবে এবং গাড়ির উপর নতুন ফিচার যোগ করবে।

public class SportsCar extends CarDecorator {
    public SportsCar(Car car) {
        super(car);
    }

    @Override
    public void assemble() {
        super.assemble();
        System.out.println("Adding features of Sports Car.");
    }
}

public class LuxuryCar extends CarDecorator {
    public LuxuryCar(Car car) {
        super(car);
    }

    @Override
    public void assemble() {
        super.assemble();
        System.out.println("Adding features of Luxury Car.");
    }
}

5. Testing the Decorator Pattern

এখন আমরা ডেকোরেটর প্যাটার্নের ব্যবহার দেখব যেখানে প্রথমে একটি সাধারণ গাড়ি তৈরি করা হবে এবং তারপর তা বিভিন্ন ফিচার দিয়ে সাজানো হবে।

public class DecoratorPatternExample {
    public static void main(String[] args) {
        // Create a basic car
        Car sportsCar = new SportsCar(new BasicCar());
        sportsCar.assemble();  // Output: Basic Car. Adding features of Sports Car.

        // Create a luxury car
        Car sportsLuxuryCar = new SportsCar(new LuxuryCar(new BasicCar()));
        sportsLuxuryCar.assemble();  
        // Output: Basic Car. Adding features of Luxury Car. Adding features of Sports Car.
    }
}

আউটপুট:

Basic Car.
Adding features of Sports Car.

Basic Car.
Adding features of Luxury Car.
Adding features of Sports Car.

Decorator Pattern এর ব্যাখ্যা:

1. BasicCar: এটি একটি সাধারণ গাড়ি, যা assemble() মেথডের মাধ্যমে একটি সাধারণ গাড়ি তৈরি করবে।
2. SportsCar এবং LuxuryCar: এই দুটি ক্লাস CarDecorator ইন্টারফেস ইমপ্লিমেন্ট করে এবং একটি সাধারণ গাড়িতে অতিরিক্ত ফিচার যোগ করে।
3. Decorator Pattern: ডেকোরেটর প্যাটার্নের মাধ্যমে আমরা একাধিক ফিচার একসাথে যুক্ত করতে পারি, যেমন SportsCar এবং LuxuryCar একসাথে যোগ করা যেতে পারে। এতে করে নতুন ফিচার যোগ করার জন্য পূর্ববর্তী ক্লাসে পরিবর্তন না করে আমরা অবজেক্টের ফাংশনালিটি প্রসারিত করতে পারি।

Advantages of Decorator Pattern:

1. Flexible: ডেকোরেটর প্যাটার্নের মাধ্যমে আমরা সহজেই নতুন ফিচার যুক্ত করতে পারি। এটি কার্যকরীভাবে ফিচার পরিবর্তন বা সম্প্রসারণ করতে সাহায্য করে।
2. Avoids subclassing: নতুন ফিচার যোগ করার জন্য নতুন সাবক্লাস তৈরি করার প্রয়োজন নেই। ডেকোরেটর ক্লাস দ্বারা বৈশিষ্ট্য যোগ করা যেতে পারে।
3. Open/Closed Principle: ডেকোরেটর প্যাটার্ন open/closed principle অনুসরণ করে, অর্থাৎ ক্লাসটি নতুন ফিচারের জন্য উন্মুক্ত, তবে বিদ্যমান কোডে পরিবর্তন না করে তা সম্প্রসারিত করা যায়।

Decorator Pattern একটি শক্তিশালী ডিজাইন প্যাটার্ন যা অবজেক্টের আচরণ বা ফিচারকে ডায়নামিকভাবে এবং নমনীয়ভাবে পরিবর্তন করতে সক্ষম। এটি বিশেষত তখন উপকারী যখন একটি ক্লাসের মৌলিক কার্যকারিতার উপর নতুন ফিচার যোগ করা প্রয়োজন, কিন্তু মূল কোড বা ক্লাসের কাঠামো পরিবর্তন করা সম্ভব নয় বা প্রয়োজন নেই। ডেকোরেটর প্যাটার্ন সাধারণত UI ডিজাইন, লগিং, এবং একাধিক ধরণের কনফিগারেশনে ব্যবহৃত হয়, যেখানে প্রতিটি অবজেক্টের উপর কার্যকারিতা যুক্ত করা হয় বিভিন্ন উপায়ে।

Facade Pattern হল একটি Structural Design Pattern যা একটি সিস্টেমের বিভিন্ন ক্লাস বা সাব-সিস্টেমগুলিকে একত্রিত করে একটি সহজ ইন্টারফেস প্রদান করে। এর মূল উদ্দেশ্য হল ক্লায়েন্ট বা ব্যবহারকারীকে জটিল সিস্টেম থেকে বিমূর্ত করা এবং তাদের শুধুমাত্র একটি সহজ, সহজবোধ্য ইন্টারফেস প্রদান করা, যাতে তারা সিস্টেমের অন্যান্য অংশে প্রবেশ না করেই কার্য সম্পাদন করতে পারে।

Facade Pattern প্রায়ই ব্যবহৃত হয় যখন সিস্টেম খুব জটিল হয়ে যায় এবং ক্লায়েন্টের জন্য সেটা পরিচালনা করা কঠিন হয়। ফেসেড প্যাটার্ন একটি সহজ ইন্টারফেস প্রদান করে যা ক্লায়েন্টকে সিস্টেমের বিভিন্ন উপাদানগুলির সাথে যোগাযোগ করতে সহজতর করে।

1. Facade Pattern এর বৈশিষ্ট্য

• Simplification: Facade Pattern মূলত জটিল সিস্টেমের জন্য একটি সহজ ইন্টারফেস তৈরি করে।
• Encapsulation: এটি সিস্টেমের অভ্যন্তরীণ জটিলতা লুকিয়ে রাখে এবং শুধু একটি সহজ ইন্টারফেস প্রদান করে।
• Loose Coupling: ক্লায়েন্ট ফেসেডের সাথে যোগাযোগ করে, কিন্তু এটি সিস্টেমের অভ্যন্তরীণ কন্সট্রাকশন বা অন্যান্য সাব-সিস্টেমের সাথে সরাসরি কাজ করে না, ফলে কোডের মধ্যে কম জোড় (coupling) তৈরি হয়।

2. Facade Pattern এর উপকারিতা

1. সিস্টেম সহজতর করা: এটি সিস্টেমের বিভিন্ন উপাদানগুলিকে একত্রিত করে একটি সহজ ইন্টারফেস প্রদান করে, ফলে ক্লায়েন্টের জন্য কাজ করা অনেক সহজ হয়ে যায়।
2. লোস কপ্লিং (Loose Coupling): ক্লায়েন্ট ফেসেডের সাথে যোগাযোগ করে, তবে অন্যান্য সাব-সিস্টেমের সাথে সরাসরি যোগাযোগ করতে হয় না, ফলে সিস্টেমের মডিউলগুলির মধ্যে কম নির্ভরশীলতা থাকে।
3. Maintenance সহজ: এটি কোডের রক্ষণাবেক্ষণ এবং এক্সটেনশন সহজ করে, কারণ অভ্যন্তরীণ সিস্টেম পরিবর্তন হলে ক্লায়েন্টের কাছে কোন পরিবর্তন না এনে শুধুমাত্র ফেসেডে পরিবর্তন করা যেতে পারে।
4. প্রয়োগে দ্রুততা: ফেসেড প্যাটার্ন সফটওয়্যার ডিজাইনে দ্রুত ফলাফল আনতে সহায়ক হতে পারে কারণ ক্লায়েন্ট খুব সহজে সিস্টেমে কাজ করতে পারে।

3. Facade Pattern এর উদাহরণ

ধরা যাক, একটি Home Theater System তৈরি করা হয়েছে, যেখানে TV, DVD Player, Surround Sound System ইত্যাদি বিভিন্ন কম্পোনেন্ট রয়েছে। যখন ব্যবহারকারী সিনেমা দেখতে চায়, তখন তাকে প্রতিটি ডিভাইস চালু করার জন্য আলাদা আলাদা কমান্ড দিতে হবে, যা একটি জটিল প্রক্রিয়া হতে পারে। তবে, Facade Pattern ব্যবহার করে আমরা একটিমাত্র ইন্টারফেস বা ফেসেড তৈরি করতে পারি, যা সিস্টেমের সকল কম্পোনেন্টকে একত্রিত করে এবং ক্লায়েন্টকে সহজে সিনেমা দেখার জন্য একটি ইন্টারফেস প্রদান করবে।

Facade Pattern এর কোড উদাহরণ:

// Subsystem 1: TV
class TV {
    public void on() {
        System.out.println("Turning on the TV");
    }

    public void off() {
        System.out.println("Turning off the TV");
    }
}

// Subsystem 2: DVD Player
class DVDPlayer {
    public void on() {
        System.out.println("Turning on the DVD Player");
    }

    public void off() {
        System.out.println("Turning off the DVD Player");
    }

    public void play() {
        System.out.println("Playing DVD");
    }

    public void stop() {
        System.out.println("Stopping DVD");
    }
}

// Subsystem 3: Surround Sound System
class SurroundSoundSystem {
    public void on() {
        System.out.println("Turning on the Surround Sound System");
    }

    public void off() {
        System.out.println("Turning off the Surround Sound System");
    }

    public void setVolume(int level) {
        System.out.println("Setting volume to " + level);
    }
}

// Facade Class: HomeTheaterFacade
class HomeTheaterFacade {
    private TV tv;
    private DVDPlayer dvdPlayer;
    private SurroundSoundSystem surroundSoundSystem;

    public HomeTheaterFacade(TV tv, DVDPlayer dvdPlayer, SurroundSoundSystem surroundSoundSystem) {
        this.tv = tv;
        this.dvdPlayer = dvdPlayer;
        this.surroundSoundSystem = surroundSoundSystem;
    }

    public void watchMovie() {
        System.out.println("Getting ready to watch a movie...");
        tv.on();
        surroundSoundSystem.on();
        surroundSoundSystem.setVolume(5);
        dvdPlayer.on();
        dvdPlayer.play();
    }

    public void endMovie() {
        System.out.println("Shutting down the movie...");
        dvdPlayer.stop();
        dvdPlayer.off();
        surroundSoundSystem.off();
        tv.off();
    }
}

// Client code
public class Main {
    public static void main(String[] args) {
        // Subsystem components
        TV tv = new TV();
        DVDPlayer dvdPlayer = new DVDPlayer();
        SurroundSoundSystem surroundSoundSystem = new SurroundSoundSystem();

        // Facade
        HomeTheaterFacade homeTheater = new HomeTheaterFacade(tv, dvdPlayer, surroundSoundSystem);

        // Using the Facade to simplify the process
        homeTheater.watchMovie(); // Starting the movie
        System.out.println();
        homeTheater.endMovie(); // Ending the movie
    }
}

Output:

Getting ready to watch a movie...
Turning on the TV
Turning on the Surround Sound System
Setting volume to 5
Turning on the DVD Player
Playing DVD

Shutting down the movie...
Stopping DVD
Turning off the DVD Player
Turning off the Surround Sound System
Turning off the TV

ব্যাখ্যা:

• এখানে, HomeTheaterFacade একটি ফেসেড ক্লাস হিসেবে কাজ করছে। এটি সিস্টেমের বিভিন্ন উপাদানগুলির (TV, DVD Player, Surround Sound System) সাথে যোগাযোগ করছে এবং ক্লায়েন্টকে watchMovie() এবং endMovie() মেথডের মাধ্যমে একটি সহজ ইন্টারফেস প্রদান করছে।
• ক্লায়েন্ট এখন বিভিন্ন উপাদানের সাথে সরাসরি কাজ না করে, শুধুমাত্র HomeTheaterFacade ক্লাসের মেথড ব্যবহার করে সিস্টেম নিয়ন্ত্রণ করতে পারছে।

4. Facade Pattern এর সুবিধা ও অসুবিধা

সুবিধা:

1. Simplification: ফেসেড প্যাটার্ন সিস্টেমের জটিলতা লুকিয়ে রেখে একটি সহজ ইন্টারফেস প্রদান করে।
2. Loose Coupling: ক্লায়েন্ট সিস্টেমের অভ্যন্তরীণ কন্সট্রাকশন সম্পর্কে কিছুই জানে না এবং শুধুমাত্র ফেসেডের মাধ্যমে সিস্টেমের সাথে যোগাযোগ করে, ফলে কম coupling হয়।
3. Code Maintenance: সিস্টেমের অভ্যন্তরীণ অংশে পরিবর্তন করা সহজ, কারণ ক্লায়েন্টের কোডে কোনো পরিবর্তন করতে হয় না।
4. Scalability: নতুন সাব-সিস্টেম যুক্ত করার জন্য শুধুমাত্র ফেসেড ক্লাসে পরিবর্তন করতে হয়, অন্য অংশে কোনো পরিবর্তন হয় না।

অসুবিধা:

1. Overuse of Facade: ফেসেড প্যাটার্নের অতিরিক্ত ব্যবহার সিস্টেমের জটিলতা আরও বাড়িয়ে দিতে পারে। যদি সিস্টেমের অভ্যন্তরীণ অংশে বেশি কাস্টমাইজেশন প্রয়োজন হয়, তবে ফেসেড প্যাটার্নের মধ্যে তা রাখতে সমস্যা হতে পারে।
2. Hidden Functionality: ফেসেড প্যাটার্ন অনেক ক্ষেত্রেই সিস্টেমের জটিল কাজগুলো লুকিয়ে রাখে, যা কিছু ক্ষেত্রে বিপদজনক হতে পারে, বিশেষত যদি ক্লায়েন্টদের ওইসব অংশের প্রতি আরও গভীর অ্যাক্সেস প্রয়োজন হয়।

Facade Pattern হল একটি শক্তিশালী Structural Design Pattern যা জটিল সিস্টেমের জন্য একটি সহজ ইন্টারফেস প্রদান করে, যাতে ক্লায়েন্টরা সিস্টেমের বিভিন্ন অংশের সাথে যোগাযোগ করতে পারে। এটি সফটওয়্যার ডিজাইনে কোড সহজ এবং রক্ষণাবেক্ষণযোগ্য করে তোলে। Java তে ফেসেড প্যাটার্ন ব্যবহার করলে, সফটওয়্যার সিস্টেমকে আরো পরিষ্কার, সহজবোধ্য এবং মডুলার করা যায়, যার ফলে কোডের রক্ষণাবেক্ষণ ও এক্সটেনশন সহজ হয়।

Flyweight Pattern কি?

Flyweight Pattern হল একটি Structural Design Pattern যা মূলত মেমরি অপটিমাইজেশন (memory optimization) এর জন্য ব্যবহৃত হয়। এটি এমন একটি কৌশল যা অনেকগুলো অবজেক্টের মধ্যে শেয়ার করা তথ্য বা স্টেট ব্যবহার করে, যাতে মেমরির ব্যবহার কমানো যায়। এই প্যাটার্নটি বিশেষ করে তখন ব্যবহৃত হয়, যখন অনেক অবজেক্ট একই বা প্রায় একই স্টেট ধারণ করে এবং এই অবজেক্টগুলির একাধিক ইনস্ট্যান্স তৈরি করা হয়ে থাকে।

Flyweight Pattern এ দুটি ধরনের ডেটা থাকে:

1. Intrinsic State: তথ্য যা একটি অবজেক্টের মধ্যে শেয়ার করা হয় (যা অভ্যন্তরীণ তথ্য বা স্টেট)।
2. Extrinsic State: তথ্য যা অবজেক্টের মধ্যে শেয়ার করা যায় না এবং প্রতিটি অবজেক্টের জন্য আলাদা থাকে (যে তথ্য প্লেসহোল্ডার হিসেবে থাকে এবং অবজেক্টের বাহ্যিক অবস্থা নির্ধারণ করে)।

Flyweight Pattern মূলত "Shareable Objects" তৈরি করে যাতে মেমরি খরচ কমানো যায়।

Flyweight Pattern এর উপাদান:

1. Flyweight Interface: এটি শেয়ারযোগ্য অবজেক্টের সাধারণ ইন্টারফেস।
2. ConcreteFlyweight: এটি Flyweight ইন্টারফেসের কনক্রিট ক্লাস, যেখানে শেয়ারযোগ্য স্টেট থাকবে।
3. FlyweightFactory: এটি একটি ফ্যাক্টরি ক্লাস যা নিশ্চিত করে যে একই অবজেক্টের একটি একক ইনস্ট্যান্স ব্যবহৃত হবে এবং তা পুনরায় শেয়ার করা হবে।
4. Client: ক্লায়েন্ট কোড যেটি Flyweight অবজেক্ট ব্যবহার করে এবং বাহ্যিক স্টেট পাস করে।

Flyweight Pattern এর উদাহরণ

ধরা যাক, একটি সফটওয়্যার সিস্টেমে গেমের চরিত্র তৈরি করা হচ্ছে, যেখানে অনেক চরিত্র একই ধরনের বৈশিষ্ট্য শেয়ার করবে, যেমন গেমের চরিত্রের রং বা সাইজ। Flyweight Pattern ব্যবহার করে আমরা এই ধরনের অবজেক্টের জন্য মেমরি অপটিমাইজেশন করতে পারি, কারণ চরিত্রগুলির শেয়ারযোগ্য বৈশিষ্ট্য একাধিকবার তৈরি করার পরিবর্তে শেয়ার করা হবে।

Step 1: Flyweight Interface

// Flyweight Interface
public interface Character {
    void draw(int x, int y);  // Method to draw the character at a specific position
}

Step 2: ConcreteFlyweight

// ConcreteFlyweight: Specific character (like 'A', 'B', etc.)
public class ConcreteCharacter implements Character {
    private char symbol;  // Intrinsic state (shared)

    // Constructor to set the symbol (shared state)
    public ConcreteCharacter(char symbol) {
        this.symbol = symbol;
    }

    @Override
    public void draw(int x, int y) {
        System.out.println("Drawing " + symbol + " at (" + x + ", " + y + ")");
    }
}

Step 3: FlyweightFactory

import java.util.HashMap;
import java.util.Map;

// FlyweightFactory: Ensures shared instances of characters
public class CharacterFactory {
    private Map<Character, Character> characterMap;

    public CharacterFactory() {
        characterMap = new HashMap<>();
    }

    public Character getCharacter(char symbol) {
        if (!characterMap.containsKey(symbol)) {
            characterMap.put(symbol, new ConcreteCharacter(symbol));
        }
        return characterMap.get(symbol);
    }
}

Step 4: Client

public class FlyweightPatternExample {
    public static void main(String[] args) {
        CharacterFactory factory = new CharacterFactory();

        // Reusing character objects instead of creating new ones
        Character characterA = factory.getCharacter('A');
        characterA.draw(1, 1);

        Character characterB = factory.getCharacter('B');
        characterB.draw(2, 3);

        // Reuse the 'A' object
        Character characterA2 = factory.getCharacter('A');
        characterA2.draw(4, 5);

        // Check if 'A' and 'A2' are the same instance
        System.out.println(characterA == characterA2);  // Output: true
    }
}

ব্যাখ্যা:

1. ConcreteCharacter: এটি একটি কনক্রিট ক্লাস যা Character ইন্টারফেসকে ইমপ্লিমেন্ট করে এবং গেম চরিত্রের intrinsic state (যেমন, চরিত্রের চিহ্ন বা symbol) ধারণ করে। একে একাধিক গেমের চরিত্রের জন্য শেয়ার করা হয়।
2. CharacterFactory: এটি Flyweight অবজেক্ট তৈরি এবং পুনরায় ব্যবহারের দায়িত্বে থাকে। CharacterFactory নিশ্চিত করে যে 'A' এর জন্য শুধুমাত্র একটি অবজেক্ট তৈরি হবে, এবং সেটা পুনরায় ব্যবহার করা যাবে।
3. Client: ক্লায়েন্ট কোড CharacterFactory এর মাধ্যমে Character অবজেক্ট ব্যবহার করে এবং বিভিন্ন অবস্থানে (x, y) সেট করে প্রদর্শন করে।

Flyweight Pattern এর সুবিধা:

1. Memory Optimization: Flyweight Pattern মূলত মেমরি অপটিমাইজেশনে ব্যবহৃত হয়, কারণ এটি শেয়ারযোগ্য অবজেক্টের একাধিক ইনস্ট্যান্স তৈরি না করে একই ইনস্ট্যান্স ব্যবহার করে।
2. Improved Performance: অনেক অবজেক্টের জন্য একই ডেটা ব্যবহার করতে পারলে, এটি কর্মক্ষমতা বৃদ্ধি করতে পারে।
3. Separation of Intrinsic and Extrinsic States: Flyweight Pattern এর মাধ্যমে আপনি অবজেক্টের শেয়ারযোগ্য অংশ এবং বাহ্যিক অংশ আলাদা করতে পারেন, যা কোডের গঠন এবং রক্ষণাবেক্ষণ সহজ করে।

Flyweight Pattern এর ব্যবহার:

1. Text Formatting: টেক্সট এডিটর বা ওয়েব পেজে বিভিন্ন চরিত্রের ফন্ট এবং স্টাইল শেয়ার করা।
2. Rendering Large Sets of Objects: গেমে অনেক চরিত্র বা ইউনিট যেখানে একই ধরনের অবস্থা শেয়ার করা হয়, যেমন গেমে বিভিন্ন ইউনিটের অবস্থান এবং ধরণ।
3. Graphics Rendering: গ্রাফিক্স সিস্টেমে অনেক অবজেক্টের জন্য একই ধরনের গ্রাফিক্যাল উপাদান শেয়ার করা।

সারাংশ

Flyweight Pattern হল একটি মেমরি অপটিমাইজেশন প্যাটার্ন যা অবজেক্ট তৈরি করার প্রক্রিয়ায় শেয়ার করা উপাদান ব্যবহার করে মেমরি খরচ কমায়। এটি যখন অনেক অবজেক্ট একে অপরের মতো একই বা প্রায় একই ডেটা শেয়ার করে, তখন এই প্যাটার্নটি খুব কার্যকরী হয়ে ওঠে। Intrinsic state শেয়ার করা হয়, কিন্তু extrinsic state (বাহ্যিক স্টেট) প্রতিটি অবজেক্টের জন্য আলাদা থাকে। Flyweight Pattern ব্যবহার করে আমরা মেমরি ব্যবহারে সাশ্রয়ী হতে পারি এবং বড় সিস্টেমের পারফরম্যান্স উন্নত করতে পারি।

Proxy Pattern একটি স্ট্রাকচারাল ডিজাইন প্যাটার্ন, যা একটি অবজেক্টের রিপ্রেজেন্টেশন প্রদান করে, অর্থাৎ একটি অবজেক্টের প্রক্সি (প্রতিনিধি) তৈরি করে। এটি আসল অবজেক্টের সাথে সংযোগ স্থাপন করার আগে কিছু অতিরিক্ত কাজ (যেমন, নিরাপত্তা যাচাইকরণ, লেজি লোডিং, লগিং, বা এক্সেস কন্ট্রোল) সম্পাদন করার জন্য ব্যবহৃত হয়। সহজ ভাষায়, Proxy Pattern আসল অবজেক্টের মাধ্যমে এক্সেস নিয়ন্ত্রণের একটি মেকানিজম প্রদান করে।

1. Proxy Pattern কী?

Proxy Pattern একটি অবজেক্টের জন্য অন্য একটি অবজেক্ট তৈরি করে যা আসল অবজেক্টের সঙ্গে ইন্টারঅ্যাক্ট করে। এটি ক্লায়েন্টকে আসল অবজেক্টের উপর সরাসরি অ্যাক্সেস প্রদান না করে, তার পরিবর্তে এক বা একাধিক প্রকারের কার্যকারিতা সম্পাদন করে।

Proxy Pattern সাধারণত ব্যবহার করা হয়:

• Lazy Initialization: অবজেক্ট তৈরির কাজটি বিলম্বিত করতে, যাতে শুধুমাত্র যখন প্রয়োজন হয় তখনই অবজেক্টটি তৈরি করা হয়।
• Access Control: যখন কিছু নিরাপত্তা বা এক্সেস কন্ট্রোল প্রক্রিয়া দরকার থাকে।
• Remote Proxy: একটি অবজেক্ট ক্লায়েন্ট এবং সেবার মধ্যে দূরবর্তী ইন্টারঅ্যাকশন পরিচালনা করতে সাহায্য করে।
• Virtual Proxy: অবজেক্টের ভারী রিসোর্স লোডিং বিলম্বিত করতে ব্যবহৃত হয়।

2. Proxy Pattern এর উপাদানসমূহ

1. Subject: একটি সাধারণ ইন্টারফেস যা আসল এবং প্রক্সি ক্লাস দ্বারা বাস্তবায়িত হয়। এটি আসল অবজেক্টের সাথে ইন্টারঅ্যাক্ট করার জন্য ব্যবহৃত হয়।
2. RealSubject: আসল অবজেক্ট যা প্রক্সি দ্বারা প্রতিনিধিত্ব করা হয়।
3. Proxy: এটি Subject ইন্টারফেসের বাস্তবায়ন প্রদান করে এবং আসল অবজেক্টের উপর কিছু অতিরিক্ত কার্যকারিতা যোগ করে।

3. Proxy Pattern এর উদাহরণ

ধরা যাক আমাদের একটি Image অবজেক্ট রয়েছে, যেখানে Image একটি ভারী অবজেক্ট এবং শুধুমাত্র যখন প্রয়োজন হয় তখনই এটি লোড করা উচিত। এখানে, আমরা Proxy ব্যবহার করব যাতে Lazy Initialization করতে পারি এবং শুধুমাত্র যখন সেই ইমেজটি প্রদর্শন করার প্রয়োজন হবে তখন সেটি লোড করা হবে।

3.1. Proxy Pattern Implementation Example in Java

// Subject Interface
interface Image {
    void display();
}

// RealSubject: Actual Image class
class RealImage implements Image {
    private String fileName;

    public RealImage(String fileName) {
        this.fileName = fileName;
        loadImageFromDisk();
    }

    private void loadImageFromDisk() {
        System.out.println("Loading image: " + fileName);
    }

    @Override
    public void display() {
        System.out.println("Displaying image: " + fileName);
    }
}

// Proxy class: Controls access to RealImage
class ProxyImage implements Image {
    private RealImage realImage;
    private String fileName;

    public ProxyImage(String fileName) {
        this.fileName = fileName;
    }

    @Override
    public void display() {
        if (realImage == null) {
            realImage = new RealImage(fileName);  // Lazy initialization
        }
        realImage.display();
    }
}

// Client Code
public class ProxyPatternDemo {
    public static void main(String[] args) {
        Image image1 = new ProxyImage("image1.jpg");
        Image image2 = new ProxyImage("image2.jpg");

        // Image will be loaded only when needed
        image1.display();  // First time loading image
        image1.display();  // Image already loaded, no need to load again

        image2.display();  // First time loading image
    }
}

ব্যাখ্যা:

• Image ইন্টারফেসটি হল Subject, যা display() মেথড ঘোষণা করে।
• RealImage হল আসল অবজেক্ট, যা আসল ইমেজ লোড এবং প্রদর্শন করে।
• ProxyImage হল প্রক্সি ক্লাস, যা RealImage এর উপর Lazy Initialization এবং অন্যান্য কার্যকারিতা (যেমন, এক্সেস কন্ট্রোল) প্রদান করে।
• Lazy Initialization: প্রথমবারের জন্য ইমেজটি Proxy ক্লাসে লোড হবে, এবং পরবর্তী সময়ে ইমেজটি পুনরায় লোড করা হবে না।

আউটপুট:

Loading image: image1.jpg
Displaying image: image1.jpg
Displaying image: image1.jpg
Loading image: image2.jpg
Displaying image: image2.jpg

4. Proxy Pattern এর ব্যবহার

Proxy Pattern বিভিন্ন ক্ষেত্রে ব্যবহার করা যায়, যেমন:

1. Lazy Initialization: ভারী অবজেক্ট বা রিসোর্স লোডিং বিলম্বিত করতে।
2. Access Control: ব্যবহারকারীর অধিকার বা অনুমতি যাচাই করতে।
3. Remote Proxy: একটি অবজেক্টের দূরবর্তী অ্যাক্সেস পরিচালনা করতে।
4. Virtual Proxy: একটি ভারী রিসোর্স লোডিংয়ের ক্ষেত্রে ব্যবহৃত হয়, যেমন ডেটাবেস কুয়েরি বা গ্রাফিক্স।

5. Proxy Pattern এর সুবিধা

• Performance Optimization: ভারী রিসোর্সগুলি কেবল তখনই লোড করা হয় যখন সেগুলি প্রয়োজন হয়, যা স্মৃতি এবং প্রসেসিং ক্ষমতা সংরক্ষণ করতে সাহায্য করে।
• Access Control: নিরাপত্তা এবং অনুমতি যাচাইয়ের জন্য ব্যবহার করা যেতে পারে।
• Separation of Concerns: প্রক্সি ক্লাসটি মূল অবজেক্টের বাস্তবায়ন থেকে আলাদা থাকে, যা separation of concerns নিশ্চিত করে এবং কোডের পুনঃব্যবহারযোগ্যতা বাড়ায়।
• Encapsulation: আসল অবজেক্টের কার্যকারিতা ক্লায়েন্ট থেকে লুকিয়ে রাখা যায়।

6. Proxy Pattern এর অসুবিধা

• Overhead: প্রক্সি ব্যবহারের জন্য অতিরিক্ত লেয়ারের কারণে কিছু পারফরম্যান্স ওভারহেড হতে পারে।
• Complexity: প্রক্সি প্যাটার্নের প্রয়োগ কিছু ক্ষেত্রে কোডের জটিলতা বাড়াতে পারে, বিশেষত যখন বিভিন্ন ধরনের প্রক্সি ব্যবহৃত হয়।

সারাংশ

Proxy Pattern হল একটি স্ট্রাকচারাল ডিজাইন প্যাটার্ন যা আসল অবজেক্টের মাধ্যমে এক্সেস নিয়ন্ত্রণের জন্য একটি প্রতিনিধির (proxy) ব্যবহার করে। এটি মূলত Lazy Initialization, Access Control, Remote Proxy, এবং Virtual Proxy এর মতো সমস্যা সমাধান করতে ব্যবহৃত হয়। Java তে Proxy Pattern ব্যবহার করা হয় যখন আমাদের আসল অবজেক্টের সঙ্গে সরাসরি ইন্টারঅ্যাক্ট না করে কিছু অতিরিক্ত কার্যকারিতা প্রয়োগ করতে হয়, যেমন সুরক্ষা যাচাই বা দেরিতে রিসোর্স লোডিং।