Java में SOLID सिद्धांत: सिद्धांत से कोड तक पूर्ण गाइड

Java में SOLID सिद्धांत: सिद्धांत से अभ्यास तक

SOLID — रॉबर्ट मार्टिन (अंकल बॉब) द्वारा प्रतिपादित ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग के पांच मूलभूत सिद्धांतों का संक्षिप्त नाम है। ये सिद्धांत डेवलपर्स को लचीला, रखरखाव योग्य और आसानी से विस्तार योग्य कोड बनाने में मदद करते हैं। इस लेख में, हम Java उदाहरणों के साथ प्रत्येक SOLID सिद्धांत को सरल सिद्धांत से वास्तविक अभ्यास तक समझेंगे।

1. Single Responsibility Principle (SRP) — एकल उत्तरदायित्व का सिद्धांत

सिद्धांत: एक क्लास में बदलाव का केवल एक ही कारण होना चाहिए। दूसरे शब्दों में, प्रत्येक क्लास को केवल एक कार्यक्षमता के लिए जिम्मेदार होना चाहिए।

SRP का उल्लंघन:

public class Employee {\n    public void calculatePay() { /* वेतन गणना */ }\n    public void saveToDatabase() { /* डेटाबेस में सहेजना */ }\n    public void generateReport() { /* रिपोर्ट तैयार करना */ }\n}

सुधार:

public class Employee { /* केवल डेटा */ }\n\npublic class PayCalculator {\n    public void calculatePay(Employee emp) { /* ... */ }\n}\n\npublic class EmployeeRepository {\n    public void save(Employee emp) { /* ... */ }\n}\n\npublic class ReportGenerator {\n    public void generate(Employee emp) { /* ... */ }\n}

अब प्रत्येक क्लास की एक स्पष्ट जिम्मेदारी है, जो परीक्षण और रखरखाव को सरल बनाती है।

2. Open-Closed Principle (OCP) — खुले/बंद का सिद्धांत

सिद्धांत: सॉफ्टवेयर संस्थाएं (क्लास, मॉड्यूल, फंक्शन) विस्तार के लिए खुली होनी चाहिए, लेकिन संशोधन के लिए बंद होनी चाहिए।

OCP का उल्लंघन:

public class ShapeDrawer {\n    public void draw(String shapeType) {\n        if ("circle".equals(shapeType)) {\n            // वृत्त बनाएं\n        } else if ("rectangle".equals(shapeType)) {\n            // आयत बनाएं\n        }\n    }\n}

पॉलीमॉर्फिज्म के साथ सुधार:

public interface Shape {\n    void draw();\n}\n\npublic class Circle implements Shape {\n    @Override\n    public void draw() { /* वृत्त बनाएं */ }\n}\n\npublic class Rectangle implements Shape {\n    @Override\n    public void draw() { /* आयत बनाएं */ }\n}\n\npublic class ShapeDrawer {\n    public void draw(Shape shape) {\n        shape.draw();\n    }\n}

अब एक नई आकृति (जैसे, Triangle) जोड़ने के लिए मौजूदा कोड को बदलने की आवश्यकता नहीं है — बस Shape इंटरफ़ेस को लागू करने वाली एक नई क्लास बनाएं।

3. Liskov Substitution Principle (LSP) — बारबरा लिस्कोव का प्रतिस्थापन सिद्धांत

सिद्धांत: प्रोग्राम में ऑब्जेक्ट्स को प्रोग्राम की शुद्धता को बदले बिना उनके उपप्रकारों के उदाहरणों से बदला जा सकना चाहिए। यदि S, T का उपप्रकार है, तो T प्रकार के ऑब्जेक्ट्स को कार्य में बाधा डाले बिना S प्रकार के ऑब्जेक्ट्स से बदला जा सकता है।

LSP का क्लासिक उल्लंघन:

public class Rectangle {\n    protected int width, height;\n    public void setWidth(int w) { width = w; }\n    public void setHeight(int h) { height = h; }\n    public int getArea() { return width * height; }\n}\n\npublic class Square extends Rectangle {\n    @Override\n    public void setWidth(int w) {\n        super.setWidth(w);\n        super.setHeight(w);\n    }\n    @Override\n    public void setHeight(int h) {\n        super.setWidth(h);\n        super.setHeight(h);\n    }\n}

Rectangle के साथ काम करने वाला क्लाइंट उम्मीद करता है कि चौड़ाई बदलने से ऊंचाई प्रभावित नहीं होगी। वर्ग इस उम्मीद का उल्लंघन करता है। समाधान: एक सामान्य इंटरफ़ेस या विरासत के बिना अलग-अलग क्लास का उपयोग करें।

4. Interface Segregation Principle (ISP) — इंटरफ़ेस पृथक्करण का सिद्धांत

सिद्धांत: क्लाइंट को उन विधियों पर निर्भर नहीं होना चाहिए जिनका वे उपयोग नहीं करते। एक "मोटे" इंटरफ़ेस के बजाय कई विशिष्ट इंटरफ़ेस रखना बेहतर है।

ISP का उल्लंघन: