ב-Java, עקרונות מוצקים הם גישה מכוונת עצמים המיושמת לעיצוב מבנה תוכנה. זה מושג על ידי רוברט סי מרטין (ידוע גם בשם דוד בוב). חמשת העקרונות הללו שינו את עולם התכנות מונחה עצמים, וגם שינו את דרך כתיבת התוכנה. זה גם מבטיח שהתוכנה מודולרית, קלה להבנה, איתור באגים ומשתקפת. בחלק זה, נדון עקרונות מוצקים בג'אווה עם דוגמה ראויה .

המילה SOLID ראשי תיבות של:

• עיקרון אחריות יחידה (SRP)
• עקרון פתוח-סגור (OCP)
• עיקרון החלפת ליסקוב (LSP)
• עיקרון הפרדת ממשק (ISP)
• עקרון היפוך תלות (DIP)

בואו נסביר את העקרונות אחד אחד בפירוט.

עיקרון אחריות יחידה

עקרון האחריות היחידה קובע זאת כל מחלקת Java חייבת לבצע פונקציונליות אחת . הטמעה של פונקציות מרובות במחלקה יחידה משלבת את הקוד ואם נדרש שינוי כלשהו עשוי להשפיע על המחלקה כולה. זה מדויק את הקוד וניתן לתחזק את הקוד בקלות. בואו נבין את עקרון האחריות היחידה באמצעות דוגמה.

לְהַנִיחַ, סטוּדֶנט היא מחלקה בעלת שלוש שיטות כלומר printDetails(), calculatePercentage(), ו addStudent(). לפיכך, לכיתת הסטודנטים יש שלוש תחומי אחריות להדפיס את פרטי התלמידים, לחשב אחוזים ומסד נתונים. על ידי שימוש בעקרון האחריות היחידה, אנו יכולים להפריד את הפונקציות הללו לשלוש מחלקות נפרדות כדי להגשים את מטרת העיקרון.

Student.java

np.concatenate

 public class Student { public void printDetails(); { //functionality of the method } pubic void calculatePercentage(); { //functionality of the method } public void addStudent(); { //functionality of the method } } 

קטע הקוד שלמעלה מפר את עקרון האחריות היחידה. כדי להשיג את מטרת העיקרון, עלינו ליישם מחלקה נפרדת שמבצעת פונקציונליות אחת בלבד.

Student.java

 public class Student { public void addStudent(); { //functionality of the method } } 

PrintStudentDetails.java

 public class PrintStudentDetails { public void printDetails(); { //functionality of the method } } 

אחוז.ג'אווה

 public class Percentage { public void calculatePercentage(); { //functionality of the method } } 

לפיכך, השגנו את המטרה של עקרון האחריות היחידה על ידי הפרדת הפונקציונליות לשלוש מחלקות נפרדות.

עקרון פתוח-סגור

היישום או המודול מרכיבים את השיטות, הפונקציות, המשתנים וכו'. העיקרון הפתוח-סגור קובע שעל פי דרישות חדשות המודול צריך להיות פתוח להרחבה אך סגור לצורך שינוי. ההרחבה מאפשרת לנו ליישם פונקציונליות חדשה למודול. בואו נבין את העיקרון באמצעות דוגמה.

לְהַנִיחַ, מידע על רכב היא מחלקה ויש לה את השיטה מספר רכב() שמחזיר את מספר הרכב.

VehicleInfo.java

 public class VehicleInfo { public double vehicleNumber(Vehicle vcl) { if (vcl instanceof Car) { return vcl.getNumber(); if (vcl instanceof Bike) { return vcl.getNumber(); } } 

אם ברצוננו להוסיף עוד תת מחלקה בשם משאית, פשוט, נוסיף עוד משפט if שמפר את עקרון הפתוח-סגור. הדרך היחידה להוסיף את תת המחלקה ולהשיג את המטרה העקרונית על ידי עקיפת מספר רכב() השיטה, כפי שהצגנו להלן.

VehicleInfo.java

 public class VehicleInfo { public double vehicleNumber() { //functionality } } public class Car extends VehicleInfo { public double vehicleNumber() { return this.getValue(); } public class Car extends Truck { public double vehicleNumber() { return this.getValue(); } 

באופן דומה, אנו יכולים להוסיף כלי רכב נוספים על ידי יצירת תת מחלקה נוספת המשתרעת ממחלקת הרכב. הגישה לא תשפיע על היישום הקיים.

עקרון ההחלפה של ליסקוב

עקרון החלפת ליסקוב (LSP) הוצג על ידי ברברה ליסקוב . זה חל על ירושה באופן כזה שה מחלקות נגזרות חייבות להיות תחליף לחלוטין למחלקות הבסיס שלהן . במילים אחרות, אם מחלקה A היא תת-סוג של מחלקה B, אז אנחנו אמורים להיות מסוגלים להחליף את B ב-A מבלי להפריע להתנהגות התוכנית.

הוא מרחיב את עקרון הפתיחה-סגור ומתמקד גם בהתנהגות של מעמד-על ותתי-הסוגים שלו. אנחנו צריכים לעצב את המעמדות כדי לשמור על הנכס אלא אם יש לנו סיבה חזקה לעשות אחרת. בואו נבין את העיקרון באמצעות דוגמה.

Student.java

 public class Student { private double height; private double weight; public void setHeight(double h) { height = h; } public void setWeight(double w) { weight= w; } ... } public class StudentBMI extends Student { public void setHeight(double h) { super.setHeight(h); super.setWeight(w); } public void setWeight(double h) { super.setHeight(h); super.setWeight(w); } } 

השיעורים לעיל הפרו את עקרון ההחלפה של Liskov מכיוון שלכיתה StudentBMI יש אילוצים נוספים כלומר גובה ומשקל שחייבים להיות זהים. לכן, לא ניתן להחליף את כיתת הסטודנט (כיתה בסיס) בכיתה StudentBMI (כיתה נגזרת).

לפיכך, החלפת תלמיד הכיתה בכיתה StudentBMI עשויה לגרום להתנהגות בלתי צפויה.

עקרון הפרדת ממשק

העיקרון קובע שהממשקים הגדולים מתפצלים לממשקים קטנים יותר. כי מחלקות היישום משתמשות רק בשיטות הנדרשות. אל לנו להכריח את הלקוח להשתמש בשיטות שהוא לא רוצה להשתמש בהן.

המטרה של עקרון הפרדת הממשק דומה לעקרון האחריות היחידה. בואו נבין את העיקרון באמצעות דוגמה.

נניח, יצרנו ממשק בשם הֲמָרָה בעל שלוש שיטות intToDouble(), intToChar(), ו charToString() .

 public interface Conversion { public void intToDouble(); public void intToChar(); public void charToString(); } 

לממשק לעיל יש שלוש שיטות. אם אנחנו רוצים להשתמש רק בשיטה intToChar(), אין לנו ברירה ליישם את השיטה הבודדת. כדי להתגבר על הבעיה, העיקרון מאפשר לנו לפצל את הממשק לשלושה נפרדים.

 public interface ConvertIntToDouble { public void intToDouble(); } public interface ConvertIntToChar { public void intToChar(); } public interface ConvertCharToString { public void charToString(); } 

כעת נוכל להשתמש רק בשיטה הנדרשת. נניח שאנו רוצים להמיר את המספר השלם לכפול ואת התו למחרוזת, אז נשתמש רק בשיטות intToDouble() ו charToString().

 public class DataTypeConversion implements ConvertIntToDouble, ConvertCharToString { public void intToDouble() { //conversion logic } public void charToString() { //conversion logic } } 

עקרון היפוך תלות

העיקרון קובע שעלינו להשתמש בהפשטה (מחלקות מופשטות וממשקים) במקום מימושים קונקרטיים. מודולים ברמה גבוהה לא צריכים להיות תלויים במודול ברמה נמוכה אבל שניהם צריכים להיות תלויים בהפשטה. כי ההפשטה אינה תלויה בפרט אלא הפרט תלוי בהפשטה. זה מנתק את התוכנה. בואו נבין את העיקרון באמצעות דוגמה.

 public class WindowsMachine { //functionality } 

זה שווה, אם אין לנו מקלדת ועכבר לעבוד על Windows. כדי לפתור בעיה זו, אנו יוצרים בנאי של המחלקה ומוסיפים את המופעים של המקלדת והמוניטור. לאחר הוספת המופעים, המחלקה נראית כך:

 public class WindowsMachine { public final keyboard; public final monitor; public WindowsMachine() { monitor = new monitor(); //instance of monitor class keyboard = new keyboard(); //instance of keyboard class } } 

כעת נוכל לעבוד על מכונת Windows בעזרת מקלדת ועכבר. אבל אנחנו עדיין מתמודדים עם הבעיה. מכיוון שחיברנו היטב את שלושת הכיתות יחד באמצעות מילת המפתח החדשה. קשה לבדוק את מכונת חלונות הכיתה.

כדי להפוך את הקוד לחיבור רופף, אנו מנתקים את WindowsMachine מהמקלדת על ידי שימוש בממשק המקלדת ובמילת המפתח הזו.

Keyboard.java

 public interface Keyboard { //functionality } 

WindowsMachine.java

 public class WindowsMachine { private final Keyboard keyboard; private final Monitor monitor; public WindowsMachine(Keyboard keyboard, Monitor monitor) { this.keyboard = keyboard; this.monitor = monitor; } } 

בקוד לעיל, השתמשנו בהזרקת התלות כדי להוסיף את התלות של המקלדת במחלקה של WindowsMachine. לכן, ניתקנו את המעמדות.

מדוע עלינו להשתמש בעקרונות SOLID?

• זה מקטין את התלות כך שניתן לשנות גוש קוד מבלי להשפיע על שאר קוביות הקוד.
• העקרונות שנועדו להפוך את העיצוב לקל יותר, מובן.
• על ידי שימוש בעקרונות, המערכת ניתנת לתחזוקה, לבדיקה, להרחבה וניתנת לשימוש חוזר.
• זה נמנע מהעיצוב הגרוע של התוכנה.

בפעם הבאה כשאתה מעצב תוכנה, זכור את חמשת העקרונות האלה. על ידי יישום העקרונות הללו, הקוד יהיה הרבה יותר ברור, בר בדיקה וניתן להתכלה.