SOLID માં સિદ્ધાંતો લાગુ કરવા Java: ઉદાહરણો અને શ્રેષ્ઠ વ્યવહારો

Single Responsibility Principle(SRP)

આ સિદ્ધાંત જણાવે છે કે દરેક વર્ગની એક જ જવાબદારી હોવી જોઈએ. તે ભાર મૂકે છે કે વર્ગે એક ચોક્કસ કાર્ય કરવું જોઈએ અને તેને બદલવા માટે ઘણા બધા કારણો ન હોવા જોઈએ.

ઉદાહરણ: વપરાશકર્તાની માહિતીનું સંચાલન કરવું અને ઇમેઇલ સૂચનાઓ મોકલવી.

class UserManager {  
  void createUser(UserData userData) {  
    // Logic for creating a user  
  }  
}  
  
class EmailService {  
  void sendEmail(EmailData emailData) {  
    // Logic for sending an email  
  }  
}  

Open/Closed Principle(OCP)

આ સિદ્ધાંત હાલના કોડમાં ફેરફાર કરવાને બદલે નવો કોડ ઉમેરીને કાર્યક્ષમતાને વિસ્તૃત કરવા પ્રોત્સાહિત કરે છે.

ઉદાહરણ: ઈ-કોમર્સ એપ્લિકેશનમાં વિવિધ ચુકવણી પદ્ધતિઓનું સંચાલન કરવું.

abstract class PaymentProcessor {  
  abstract void processPayment();  
}  
  
class CreditCardPaymentProcessor extends PaymentProcessor {  
  void processPayment() {  
    // Logic for processing credit card payment  
  }  
}  
  
class PayPalPaymentProcessor extends PaymentProcessor {  
  void processPayment() {  
    // Logic for processing PayPal payment  
  }  
}  

Liskov Substitution Principle(LSP)

આ સિદ્ધાંત ભારપૂર્વક જણાવે છે કે પ્રોગ્રામની ચોકસાઈને અસર કર્યા વિના વ્યુત્પન્ન વર્ગના ઑબ્જેક્ટ્સ બેઝ ક્લાસના ઑબ્જેક્ટ્સ માટે અવેજીપાત્ર હોવા જોઈએ.

ઉદાહરણ: ભૌમિતિક આકારોનું સંચાલન.

abstract class Shape {  
  abstract double area();  
}  
  
class Rectangle extends Shape {  
  double area() {  
    // Logic for calculating area of rectangle  
  }  
}  
  
class Square extends Shape {  
  double area() {  
    // Logic for calculating area of square  
  }  
}  

ઇન્ટરફેસ સેગ્રિગેશન પ્રિન્સિપલ(ISP)

આ સિદ્ધાંત વર્ગોને જરૂરી ન હોય તેવી પદ્ધતિઓ અમલમાં મૂકવા માટે દબાણ કરવાનું ટાળવા માટે ઇન્ટરફેસને નાનામાં વિભાજીત કરવાની સલાહ આપે છે.

ઉદાહરણ: ડેટાને અપડેટ કરવા અને પ્રદર્શિત કરવા માટેના ઇન્ટરફેસ.

interface UpdateableFeature {  
  void updateFeature();  
}  
  
interface DisplayableFeature {  
  void displayFeature();  
}  

Dependency Inversion Principle(DIP)

આ સિદ્ધાંત નિર્ભરતાને સંચાલિત કરવા માટે નિર્ભરતા ઇન્જેક્શનનો ઉપયોગ કરવાનું સૂચવે છે.

ઉદાહરણ: નિર્ભરતાને સંચાલિત કરવા માટે નિર્ભરતા ઇન્જેક્શનનો ઉપયોગ કરવો.

class OrderProcessor {  
  private final DBConnection dbConnection;  
  private final EmailService emailService;  
  
  OrderProcessor(DBConnection dbConnection, EmailService emailService) {  
    this.dbConnection = dbConnection;  
    this.emailService = emailService;  
  }  
}  

યાદ રાખો કે SOLID માં સિદ્ધાંતો લાગુ કરવાનું તમારા પ્રોજેક્ટના વિશિષ્ટ હેતુ અને અને અને Java વિશેની તમારી સમજના આધારે લવચીક રીતે થવું જોઈએ. SOLID Java