जावा में डिज़ाइन पैटर्न उदाहरण सहित: A से Z तक

जावा में डिज़ाइन पैटर्न: उदाहरणों के साथ पूरी गाइड

डिज़ाइन पैटर्न (design patterns) सॉफ्टवेयर विकास के दौरान आने वाली सामान्य समस्याओं के सिद्ध समाधान हैं। जावा में, एक सख्ती से टाइप की गई ऑब्जेक्ट-ओरिएंटेड भाषा के रूप में, पैटर्न विशेष रूप से प्रभावी होते हैं। वे कोड को लचीला, पुन: प्रयोज्य और आसानी से बनाए रखने योग्य बनाने में मदद करते हैं। इस लेख में, हम पैटर्न के तीन मुख्य समूहों (GoF वर्गीकरण के अनुसार): क्रिएशनल, स्ट्रक्चरल और बिहेवियरल को जावा पर वास्तविक उदाहरणों के साथ समझेंगे।

1. क्रिएशनल पैटर्न (Creational Patterns)

ये पैटर्न ऑब्जेक्ट बनाने की प्रक्रिया को प्रबंधित करते हैं, जिससे सिस्टम इस बात से स्वतंत्र हो जाता है कि ऑब्जेक्ट कैसे बनाए, संयोजित और प्रस्तुत किए जाते हैं।

1.1. Singleton (सिंगलटन)

यह सुनिश्चित करता है कि क्लास का केवल एक इंस्टेंस हो, और उस तक वैश्विक पहुँच प्रदान करता है। क्लासिक उदाहरण डेटाबेस कनेक्शन पूल या लॉगर है।

public class DatabaseConnection {\n    private static volatile DatabaseConnection instance;\n    private String connectionString;\n\n    private DatabaseConnection(String connectionString) {\n        this.connectionString = connectionString;\n    }\n\n    public static DatabaseConnection getInstance(String connectionString) {\n        if (instance == null) {\n            synchronized (DatabaseConnection.class) {\n                if (instance == null) {\n                    instance = new DatabaseConnection(connectionString);\n                }\n            }\n        }\n        return instance;\n    }\n\n    public void connect() {\n        System.out.println("Connected to: " + connectionString);\n    }\n}\n\n// उपयोग\nDatabaseConnection conn = DatabaseConnection.getInstance("jdbc:mysql://localhost:3306/mydb");\nconn.connect();

1.2. Factory Method (फैक्ट्री मेथड)

ऑब्जेक्ट बनाने के लिए एक इंटरफ़ेस परिभाषित करता है, लेकिन उपवर्गों को बनाए जाने वाले ऑब्जेक्ट के प्रकार को बदलने की अनुमति देता है। यह तब उपयुक्त होता है जब ऑब्जेक्ट का सटीक प्रकार पहले से ज्ञात न हो।

interface Transport {\n    void deliver();\n}\n\nclass Truck implements Transport {\n    public void deliver() { System.out.println("जमीन पर ट्रक द्वारा डिलीवरी"); }\n}\n\nclass Ship implements Transport {\n    public void deliver() { System.out.println("समुद्र के रास्ते जहाज द्वारा डिलीवरी"); }\n}\n\nabstract class Logistics {\n    abstract Transport createTransport();\n    \n    public void planDelivery() {\n        Transport t = createTransport();\n        t.deliver();\n    }\n}\n\nclass RoadLogistics extends Logistics {\n    Transport createTransport() { return new Truck(); }\n}\n\nclass SeaLogistics extends Logistics {\n    Transport createTransport() { return new Ship(); }\n}\n\n// उपयोग\nLogistics logistics = new RoadLogistics();\nlogistics.planDelivery(); // आउटपुट: जमीन पर ट्रक द्वारा डिलीवरी

2. स्ट्रक्चरल पैटर्न (Structural Patterns)

ये क्लासेस और ऑब्जेक्ट्स की संरचना के लिए जिम्मेदार होते हैं, सरल घटकों से जटिल संरचनाएँ बनाने में मदद करते हैं।

2.1. Adapter (एडेप्टर)

असंगत इंटरफ़ेस वाले ऑब्जेक्ट्स को एक साथ काम करने की अनुमति देता है। इसका उपयोग अक्सर पुराने कोड (legacy) को नए कोड के साथ एकीकृत करने के लिए किया जाता है।

// पुराना इंटरफ़ेस\ninterface OldSystem {\n    String getDataInXML();\n}\n\n// नया इंटरफ़ेस\ninterface NewSystem {\n    String getDataInJSON();\n}\n\n// पुरानी प्रणाली का कार्यान्वयन\nclass LegacySystem implements OldSystem {\n    public String getDataInXML() { return "<data>Hello</data>"; }\n}\n\n// एडेप्टर\nclass XMLToJSONAdapter implements NewSystem {\n    private OldSystem oldSystem;\n    \n    public XMLToJSONAdapter(OldSystem oldSystem) {\n        this.oldSystem = oldSystem;\n    }\n    \n    public String getDataInJSON() {\n        String xml = oldSystem.getDataInXML();\n        return "{\\"data\\": \\"" + xml.replaceAll("<.*?>", "") + "\\"}";\n    }\n}\n\n// और