Design Patterns এর প্রকারভেদ (Creational, Structural, Behavioral)

Design Patterns হল পুনরায় ব্যবহারের উপযোগী, পরীক্ষিত এবং সমাধান করা হয়েছে এমন কোডের কাঠামো যা সফটওয়্যার ডিজাইন সমস্যা সমাধানে সাহায্য করে। বিভিন্ন ধরণের Design Patterns রয়েছে, এবং এগুলি সাধারণত তিনটি প্রধান ক্যাটাগরিতে ভাগ করা হয়:

1. Creational Patterns: এই প্যাটার্নগুলি অবজেক্ট তৈরির প্রক্রিয়া এবং ফ্যাক্টরিতে কিভাবে একটি অবজেক্ট তৈরি করা হয় তা নিয়ন্ত্রণ করে। এটি কোডের নমনীয়তা বৃদ্ধি করে এবং সিস্টেমের বিভিন্ন অংশের মধ্যে অবজেক্ট তৈরির দায়িত্ব বণ্টন করতে সাহায্য করে।
2. Structural Patterns: এই প্যাটার্নগুলি ক্লাস বা অবজেক্টগুলির মধ্যে সম্পর্ক এবং কাঠামো উন্নত করতে ব্যবহৃত হয়। এটি ডেটা স্ট্রাকচারের ব্যবহার, সংযোগ এবং রিওরগানাইজেশন প্রক্রিয়াকে সহজ করে।
3. Behavioral Patterns: এই প্যাটার্নগুলি অবজেক্ট বা ক্লাসের মধ্যে যোগাযোগ এবং তাদের আচরণ নিয়ন্ত্রণ করে। এটি পদ্ধতিগুলির মধ্যে সম্পর্ক তৈরি করতে সাহায্য করে এবং কার্যকরীভাবে দায়িত্ব বিভাজন করে।

এখানে আমরা প্রতিটি প্রকারের Design Pattern এর বিস্তারিত ব্যাখ্যা, উদ্দেশ্য এবং উদাহরণ দেখব।

১. Creational Patterns (ক্রিয়েশনাল প্যাটার্ন)

Creational Patterns হল এমন ডিজাইন প্যাটার্ন যা অবজেক্ট তৈরির প্রক্রিয়া নিয়ন্ত্রণ করে। এগুলি বিভিন্ন পদ্ধতির মাধ্যমে অবজেক্ট তৈরি করতে সহায়ক হয় এবং একটি সিস্টেমের মধ্যে অবজেক্ট তৈরি করতে যেভাবে পার্টিশন করা যায় তা নিয়ন্ত্রণ করে।

Creational Patterns এর কিছু উদাহরণ:

1. Singleton Pattern: একটি ক্লাসের জন্য একটি একক অবজেক্ট তৈরি এবং তাকে বিশ্বব্যাপী অ্যাক্সেসযোগ্য করা।
2. Factory Method Pattern: একটি সুক্ষ্ম সৃষ্টির মাধ্যমে অবজেক্ট তৈরি করার পদ্ধতি প্রদান করে।
3. Abstract Factory Pattern: সম্পর্কিত অবজেক্টগুলোকে গ্রুপ করে এবং একে একে তাদের ফ্যাক্টরি তৈরি করে।
4. Builder Pattern: একটি জটিল অবজেক্ট ধাপে ধাপে তৈরি করতে সহায়তা করে।
5. Prototype Pattern: একটি অবজেক্ট কপি করে নতুন অবজেক্ট তৈরি করে।

উদাহরণ: Singleton Pattern

class Singleton {
    // Private static variable to hold the instance of the class
    private static Singleton instance;

    // Private constructor to prevent instantiation
    private Singleton() {}

    // Public method to return the instance of the class
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

public class SingletonExample {
    public static void main(String[] args) {
        Singleton singleton1 = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();

        System.out.println(singleton1 == singleton2);  // Output: true
    }
}

ব্যাখ্যা:

• Singleton Pattern নিশ্চিত করে যে একটি ক্লাসের একটিমাত্র ইনস্ট্যান্স থাকবে এবং এটি সিস্টেমের যেকোনো জায়গা থেকে অ্যাক্সেস করা যাবে।

২. Structural Patterns (স্ট্রাকচারাল প্যাটার্ন)

Structural Patterns হল এমন ডিজাইন প্যাটার্ন যা ক্লাস বা অবজেক্টগুলির মধ্যে সম্পর্ক এবং কাঠামো উন্নত করতে ব্যবহৃত হয়। এর মাধ্যমে অবজেক্ট বা ক্লাসের মধ্যে একটি লজিক্যাল সংগঠন তৈরি করা হয়।

Structural Patterns এর কিছু উদাহরণ:

1. Adapter Pattern: একটি অবজেক্টের ইন্টারফেসকে অন্য ইন্টারফেসে রূপান্তরিত করে যাতে এটি অন্য ক্লাসের সাথে কাজ করতে পারে।
2. Bridge Pattern: একটি অবজেক্টের হ্যান্ডলিংয়ের দায়িত্ব এবং তার বাস্তবায়ন পৃথক করার জন্য ব্যবহৃত হয়।
3. Composite Pattern: একাধিক অবজেক্টকে একত্রিত করে তাদেরকে একক অবজেক্ট হিসেবে পরিচালনা করার জন্য ব্যবহৃত হয়।
4. Decorator Pattern: এক অবজেক্টের আচরণে নতুন ফিচার যোগ করতে ব্যবহৃত হয়।
5. Facade Pattern: জটিল সিস্টেমের ভিতরের লজিক গোপন করে একটি সহজ ইন্টারফেস সরবরাহ করা।

উদাহরণ: Adapter Pattern

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

// Adaptee class
class AudioPlayer implements MediaPlayer {
    @Override
    public void play(String audioType, String fileName) {
        if(audioType.equalsIgnoreCase("mp3")) {
            System.out.println("Playing mp3 file: " + fileName);
        } else {
            System.out.println("Invalid audio type");
        }
    }
}

// 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);
        }
    }
}

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

// Concrete classes for AdvancedMediaPlayer
class VlcPlayer implements AdvancedMediaPlayer {
    @Override
    public void playVlc(String fileName) {
        System.out.println("Playing VLC file: " + fileName);
    }

    @Override
    public void playMp4(String fileName) {}
}

class Mp4Player implements AdvancedMediaPlayer {
    @Override
    public void playVlc(String fileName) {}

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

public class AdapterPatternExample {
    public static void main(String[] args) {
        AudioPlayer audioPlayer = new AudioPlayer();
        
        audioPlayer.play("mp3", "beyond the horizon.mp3");
        audioPlayer.play("mp4", "alone.mp4");

        MediaAdapter mediaAdapter = new MediaAdapter("vlc");
        mediaAdapter.play("vlc", "far far away.vlc");
    }
}

ব্যাখ্যা:

• Adapter Pattern: এখানে AudioPlayer ক্লাস শুধুমাত্র mp3 ফরম্যাট সাপোর্ট করে, কিন্তু MediaAdapter ক্লাসের মাধ্যমে অন্যান্য ফরম্যাট (যেমন mp4, vlc) সাপোর্ট যোগ করা হয়।

৩. Behavioral Patterns (বিহেভিরাল প্যাটার্ন)

Behavioral Patterns হল এমন ডিজাইন প্যাটার্ন যা অবজেক্ট বা ক্লাসের মধ্যে যোগাযোগ এবং আচরণ নিয়ন্ত্রণ করে। এই প্যাটার্নগুলি সফটওয়্যার সিস্টেমের মধ্যে অবজেক্ট বা ক্লাসের মধ্যে সম্পর্ক এবং আচরণের ওপর ফোকাস করে।

Behavioral Patterns এর কিছু উদাহরণ:

1. Chain of Responsibility Pattern: একাধিক হ্যান্ডলার দ্বারা একটি রিকোয়েস্ট প্রক্রিয়া করা, যেখানে প্রতিটি হ্যান্ডলার সিদ্ধান্ত নিতে পারে অথবা পরবর্তী হ্যান্ডলারে পাঠিয়ে দিতে পারে।
2. Command Pattern: অবজেক্টগুলোকে কমান্ড হিসাবে ইনক্যাপসুলেট করা এবং পরে সেই কমান্ডগুলো এক্সিকিউট করা।
3. Iterator Pattern: একটি ডেটা স্ট্রাকচারে প্রতিটি উপাদান একে একে ভ্রমণ করার জন্য একটি ইটারেটর প্রদান করা।
4. Observer Pattern: একটি অবজেক্টের স্টেট পরিবর্তন হলে, অন্য অবজেক্টগুলিকে জানানো।
5. State Pattern: অবজেক্টের আচরণ পরিবর্তিত হয় যখন তার স্টেট পরিবর্তিত হয়।

উদাহরণ: Observer Pattern

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

// Subject class
class Subject {
    private List<Observer> observers = new ArrayList<>();

    public void addObserver(Observer observer) {
        observers.add(observer);
    }

    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }

    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update();
        }
    }
}

// Observer interface
interface Observer {
    void update();
}

// Concrete Observer class
class ConcreteObserver implements Observer {
    @Override
    public void update() {
        System.out.println("Observer notified of the change.");
    }
}

public class ObserverPatternExample {
    public static void main(String[] args) {
        Subject subject = new Subject();

        Observer observer1 = new ConcreteObserver();
        Observer observer2 = new ConcreteObserver();
        
        subject.addObserver(observer1);
        subject.addObserver(observer2);

        // Notify all observers
        subject.notifyObservers();
    }
}

ব্যাখ্যা:

• Observer Pattern: এখানে Subject অবজেক্টের স্টেট পরিবর্তিত হলে, Observer অবজেক্টগুলোকে notify() মেথডের মাধ্যমে অবগত করা হয়।

সারাংশ

Design Patterns একটি শক্তিশালী টুল যা সফটওয়্যার ডেভেলপমেন্টে সমস্যাগুলির সমাধান সরবরাহ করে। এই প্যাটার্নগুলির তিনটি প্রধান শ্রেণী রয়েছে:

1. Creational Patterns: যেগুলি অবজেক্ট তৈরি করার প্রক্রিয়া নিয়ন্ত্রণ করে।
2. Structural Patterns: যেগুলি ক্লাস এবং অবজেক্টগুলির সম্পর্ক এবং কাঠামো উন্নত করে।
3. Behavioral Patterns: যেগুলি অবজেক্ট এবং ক্লাসের মধ্যে যোগাযোগ এবং আচরণ নিয়ন্ত্রণ করে।

এই প্যাটার্নগুলির সাহায্যে আপনি ডেটা স্ট্রাকচার এবং অ্যালগরিদম ইমপ্লিমেন্টেশনের সময় আরও ভালো, আরও কার্যকরী এবং পুনঃব্যবহারযোগ্য কোড তৈরি করতে পারবেন।