v Jave SOLID princípy sú objektovo orientovaný prístup, ktorý sa používa pri návrhu softvérovej štruktúry. Je konceptualizovaný podľa Robert C. Martin (tiež známy ako strýko Bob). Týchto päť princípov zmenilo svet objektovo orientovaného programovania a zmenilo aj spôsob písania softvéru. Zabezpečuje tiež, že softvér je modulárny, ľahko pochopiteľný, laditeľný a refaktorovateľný. V tejto časti budeme diskutovať Princípy SOLID v Jave so správnym príkladom .

Skratka slova SOLID pre:

• Princíp jednotnej zodpovednosti (SRP)
• Princíp otvoreného a uzavretého priestoru (OCP)
• Liskov substitučný princíp (LSP)
• Princíp segregácie rozhrania (ISP)
• Princíp inverzie závislosti (DIP)

Vysvetlime si princípy jeden po druhom podrobne.

Princíp jednotnej zodpovednosti

Princíp jednotnej zodpovednosti to uvádza každá trieda Java musí vykonávať jednu funkciu . Implementácia viacerých funkcionalít v jednej triede zmieša kód a ak je potrebná akákoľvek úprava, môže ovplyvniť celú triedu. Upresňuje kód a kód sa dá ľahko udržiavať. Poďme pochopiť princíp jedinej zodpovednosti na príklade.

Predpokladajme, Študent je trieda, ktorá má konkrétne tri metódy printDetails(), vypočítaťPercentage(), a addStudent(). Preto má trieda Študent tri povinnosti: vytlačiť podrobnosti o študentoch, vypočítať percentá a vytvoriť databázu. Použitím princípu jedinej zodpovednosti môžeme tieto funkcionality rozdeliť do troch samostatných tried, aby sme splnili cieľ princípu.

ako nájsť skryté aplikácie v systéme Android

Študent.java

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

Vyššie uvedený útržok kódu porušuje zásadu jednej zodpovednosti. Aby sme dosiahli cieľ princípu, mali by sme implementovať samostatnú triedu, ktorá vykonáva iba jednu funkčnosť.

Študent.java

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

PrintStudentDetails.java

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

Percento.java

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

Cieľ princípu jednotnej zodpovednosti sme teda dosiahli rozdelením funkčnosti do troch samostatných tried.

Princíp otvorený-zatvorený

Aplikácia alebo modul sú entitami metód, funkcií, premenných atď. Princíp otvorenosti hovorí, že podľa nových požiadaviek modul by mal byť otvorený na rozšírenie, ale zatvorený na úpravu. Rozšírenie nám umožňuje implementovať nové funkcie do modulu. Poďme pochopiť princíp na príklade.

Predpokladajme, Informácie o vozidle je trieda a má metódu vehicleNumber() ktorý vráti číslo vozidla.

VehicleInfo.java

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

Ak chceme pridať ďalšiu podtriedu s názvom Truck, jednoducho pridáme ešte jeden príkaz if, ktorý porušuje princíp otvoreného-zatvoreného. Jediný spôsob, ako pridať podtriedu a dosiahnuť cieľ princípu prepísaním podtriedy vehicleNumber() metódou, ako sme si ukázali nižšie.

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

Podobne môžeme pridať ďalšie vozidlá vytvorením ďalšej podtriedy rozšírenej z triedy vozidiel. prístup by neovplyvnil existujúcu aplikáciu.

Liskov substitučný princíp

Liskovský substitučný princíp (LSP) zaviedol o Barbara Liskov . Na dedenie sa vzťahuje tak, že odvodené triedy musia byť úplne zameniteľné za svoje základné triedy . Inými slovami, ak je trieda A podtypom triedy B, potom by sme mali byť schopní nahradiť B za A bez prerušenia správania programu.

Rozširuje princíp open-close a zameriava sa aj na správanie sa nadtriedy a jej podtypov. Triedy by sme mali navrhnúť tak, aby sa majetok zachoval, pokiaľ nemáme silný dôvod urobiť inak. Poďme pochopiť princíp na príklade.

Študent.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); } } 

Vyššie uvedené triedy porušili princíp Liskovovej substitúcie, pretože trieda StudentBMI má ďalšie obmedzenia, t. j. výšku a hmotnosť, ktoré musia byť rovnaké. Preto triedu Študent (základná trieda) nemožno nahradiť triedou StudentBMI (odvodená trieda).

Preto nahradenie triedy Študent triedou StudentBMI môže viesť k neočakávanému správaniu.

bourne again shell

Princíp segregácie rozhrania

Princíp hovorí, že väčšie rozhrania sa rozdelia na menšie. Pretože implementačné triedy používajú iba metódy, ktoré sú potrebné. Nemali by sme klienta nútiť používať metódy, ktoré nechce používať.

Cieľ princípu segregácie rozhrania je podobný princípu jednej zodpovednosti. Poďme pochopiť princíp na príklade.

Predpokladajme, že sme vytvorili rozhranie s názvom Konverzia majú tri metódy intToDouble(), intToChar(), a charToString() .

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

Vyššie uvedené rozhranie má tri spôsoby. Ak chceme použiť iba metódu intToChar(), nemáme inú možnosť implementovať jedinú metódu. Na prekonanie problému nám princíp umožňuje rozdeliť rozhranie na tri samostatné.

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

Teraz môžeme použiť len metódu, ktorá je potrebná. Predpokladajme, že chceme previesť celé číslo na double a znak na reťazec, potom použijeme iba metódy intToDouble() a charToString().

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

Princíp inverzie závislosti

Princíp hovorí, že namiesto konkrétnych implementácií musíme použiť abstrakciu (abstraktné triedy a rozhrania). Moduly vysokej úrovne by nemali závisieť od modulu nízkej úrovne, ale oba by mali závisieť od abstrakcie. Pretože abstrakcia nezávisí od detailu, ale detail závisí od abstrakcie. Oddeľuje softvér. Poďme pochopiť princíp na príklade.

 public class WindowsMachine { //functionality } 

Stojí za to, ak nemáme klávesnicu a myš pracovať na Windows. Aby sme tento problém vyriešili, vytvoríme konštruktor triedy a pridáme inštancie klávesnice a monitora. Po pridaní inštancií trieda vyzerá takto:

 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 } } 

Teraz môžeme pracovať na počítači so systémom Windows pomocou klávesnice a myši. Stále však čelíme problému. Pretože sme tieto tri triedy tesne spojili pomocou kľúčového slova new. Je ťažké otestovať stroj triedy Windows.

Aby bol kód voľne spojený, odpojíme WindowsMachine od klávesnice pomocou rozhrania klávesnice a tohto kľúčového slova.

Klávesnica.java

aktualizácia z join sql

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

Vo vyššie uvedenom kóde sme použili injekciu závislosti na pridanie závislosti klávesnice do triedy WindowsMachine. Preto sme triedy oddelili.

Prečo by sme mali používať princípy SOLID?

• Znižuje závislosti, takže blok kódu možno zmeniť bez ovplyvnenia ostatných blokov kódu.
• Princípy určené na to, aby bol dizajn jednoduchší a zrozumiteľnejší.
• Použitím princípov je systém udržiavateľný, testovateľný, škálovateľný a opakovane použiteľný.
• Vyhnete sa tak zlému dizajnu softvéru.

Keď budete nabudúce navrhovať softvér, pamätajte na týchto päť zásad. Aplikovaním týchto princípov bude kód oveľa prehľadnejší, testovateľnejší a spotrebnejší.