у Јави, СОЛИД принципи су објектно оријентисани приступ који се примењују на дизајн структуре софтвера. То је концептуализовано од Роберт Ц. Мартин (познат и као ујак Боб). Ових пет принципа су променили свет објектно оријентисаног програмирања, а такође су променили и начин писања софтвера. Такође осигурава да је софтвер модуларан, лак за разумевање, отклањање грешака и рефакторисање. У овом одељку ћемо разговарати СОЛИД принципи у Јави са правим примером .
Реч СОЛИД акроним за:
- Принцип јединствене одговорности (СРП)
- Отворено-затворено начело (ОЦП)
- Принцип замене Лискова (ЛСП)
- Принцип сегрегације интерфејса (ИСП)
- Принцип инверзије зависности (ДИП)
Хајде да детаљно објаснимо принципе један по један.
Принцип јединствене одговорности
Принцип јединствене одговорности то каже свака Јава класа мора да обавља једну функцију . Имплементација више функционалности у једној класи комбинује код и ако је потребна било каква модификација може утицати на целу класу. Прецизан је код и код се може лако одржавати. Хајде да разумемо принцип јединствене одговорности кроз пример.
Претпоставимо, Ученик је класа која има три методе наиме принтДетаилс(), израчунатиПерцентаге(), и аддСтудент(). Дакле, класа Студент има три одговорности да штампа детаље о ученицима, израчуна проценте и базу података. Коришћењем принципа јединствене одговорности, можемо раздвојити ове функционалности у три одвојене класе да бисмо испунили циљ принципа.
Студент.јава
public class Student { public void printDetails(); { //functionality of the method } pubic void calculatePercentage(); { //functionality of the method } public void addStudent(); { //functionality of the method } } Горњи исечак кода крши принцип јединствене одговорности. Да бисмо постигли циљ принципа, требало би да имплементирамо посебну класу која обавља само једну функционалност.
Студент.јава
public class Student { public void addStudent(); { //functionality of the method } } ПринтСтудентДетаилс.јава
public class PrintStudentDetails { public void printDetails(); { //functionality of the method } } Перцентаге.јава
кат тимпф висина
public class Percentage { public void calculatePercentage(); { //functionality of the method } } Дакле, постигли смо циљ принципа јединствене одговорности раздвајањем функционалности у три одвојене класе.
Отворено-затворено начело
Апликација или модул ентитети методе, функције, варијабле итд. Принцип отворено-затворено наводи да према новим захтевима модул треба да буде отворен за проширење, али затворен за модификацију. Проширење нам омогућава да имплементирамо нову функционалност у модул. Хајде да разумемо принцип кроз пример.
Претпоставимо, ВехицлеИнфо је класа и има метод број возила() који враћа број возила.
ВехицлеИнфо.јава
public class VehicleInfo { public double vehicleNumber(Vehicle vcl) { if (vcl instanceof Car) { return vcl.getNumber(); if (vcl instanceof Bike) { return vcl.getNumber(); } } Ако желимо да додамо још једну подкласу под називом Камион, једноставно, додајемо још једну иф наредбу која крши принцип отворено-затворено. Једини начин да се дода поткласа и постигне циљ принципа тако што се прегласи број возила() метод, као што смо показали у наставку.
ВехицлеИнфо.јава
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(); } Слично томе, можемо додати још возила тако што ћемо направити још једну поткласу која се протеже од класе возила. приступ не би утицао на постојећу примену.
Принцип замене Лискова
Принцип замене Лисков (ЛСП) је уведен од Барбара Лисков . Примењује се на наслеђивање на начин да се изведене класе морају бити потпуно заменљиве за своје основне класе . Другим речима, ако је класа А подтип класе Б, онда би требало да можемо да заменимо Б са А без прекидања понашања програма.
Он проширује принцип отворено-затварање и такође се фокусира на понашање суперкласе и њених подтипова. Требало би да дизајнирамо класе да сачувамо својство осим ако немамо јак разлог да урадимо другачије. Хајде да разумемо принцип кроз пример.
Студент.јава
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); } } Горе наведене класе су прекршиле принцип замене Лискова јер класа СтудентБМИ има додатна ограничења, односно висину и тежину које морају бити исте. Стога, класа Студент (основна класа) не може бити замењена класом СтудентБМИ (изведена класа).
Стога, замена класе Студент са класом СтудентБМИ може довести до неочекиваног понашања.
Принцип сегрегације интерфејса
Принцип каже да се већи интерфејси деле на мање. Зато што класе имплементације користе само методе које су потребне. Не треба да терамо клијента да користи методе које не жели да користи.
Циљ принципа раздвајања интерфејса је сличан принципу јединствене одговорности. Хајде да разумемо принцип кроз пример.
Претпоставимо да смо креирали интерфејс под називом Конверзија има три методе интТоДоубле(), интТоЦхар(), и цхарТоСтринг() .
public interface Conversion { public void intToDouble(); public void intToChar(); public void charToString(); } Горњи интерфејс има три методе. Ако желимо да користимо само метод интТоЦхар(), немамо избора да имплементирамо један метод. Да бисмо превазишли проблем, принцип нам омогућава да поделимо интерфејс на три одвојена.
public interface ConvertIntToDouble { public void intToDouble(); } public interface ConvertIntToChar { public void intToChar(); } public interface ConvertCharToString { public void charToString(); } Сада можемо користити само метод који је потребан. Претпоставимо да желимо да конвертујемо цео број у дупли, а знак у низ, тада ћемо користити само методе интТоДоубле() и цхарТоСтринг().
public class DataTypeConversion implements ConvertIntToDouble, ConvertCharToString { public void intToDouble() { //conversion logic } public void charToString() { //conversion logic } } Принцип инверзије зависности
Принцип каже да морамо користити апстракцију (апстрактне класе и интерфејсе) уместо конкретних имплементација. Модули високог нивоа не би требало да зависе од модула ниског нивоа, али оба треба да зависе од апстракције. Зато што апстракција не зависи од детаља, већ детаљ зависи од апстракције. То раздваја софтвер. Хајде да разумемо принцип кроз пример.
public class WindowsMachine { //functionality } Вреди, ако немамо тастатуру и миша за рад на Виндовс-у. Да бисмо решили овај проблем, креирамо конструктор класе и додајемо инстанце тастатуре и монитора. Након додавања инстанци, класа изгледа овако:
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 } } Сада можемо да радимо на Виндовс машини уз помоћ тастатуре и миша. Али и даље се суочавамо са проблемом. Зато што смо те три класе чврсто повезали користећи нову кључну реч. Тешко је тестирати класну Виндовс машину.
Да би код био лабаво повезан, одвајамо ВиндовсМацхине од тастатуре помоћу интерфејса тастатуре и ове кључне речи.
Кеибоард.јава
може ли андроид да игра гамепигеон
public interface Keyboard { //functionality } ВиндовсМацхине.јава
public class WindowsMachine { private final Keyboard keyboard; private final Monitor monitor; public WindowsMachine(Keyboard keyboard, Monitor monitor) { this.keyboard = keyboard; this.monitor = monitor; } } У горњем коду смо користили ињекцију зависности да бисмо додали зависност тастатуре у класу ВиндовсМацхине. Због тога смо раздвојили наставу.
Зашто би требало да користимо СОЛИД принципе?
- Смањује зависности тако да се блок кода може променити без утицаја на друге блокове кода.
- Принципи намењени да дизајн учине лакшим, разумљивим.
- Користећи принципе, систем се може одржавати, тестирати, скалабилан и поново користити.
- Тиме се избегава лош дизајн софтвера.
Следећи пут када дизајнирате софтвер, имајте на уму ових пет принципа. Применом ових принципа, код ће бити много јаснији, проверљивији и потрошњи.