Този блог демонстрира използването и внедряването на динамично обвързване в Java.
Как да използвам динамично обвързване в Java?
Динамичното свързване позволява слабо свързване между обекти. Помага за лесното разширяване на функционалността чрез добавяне на нови подкласове, които заместват методите, без да променят съществуващия код. Динамичното обвързване се използва широко за диспечиране по време на изпълнение, обработка на събития или системи с добавки.
Нека преминем през няколко примера за подробно обяснение:
Пример 1: Внедряване на динамично обвързване
Чрез използването на динамично обвързване, програмистите могат да позволят на потребителите да персонализират и заменят поведението по подразбиране, за да изградят адаптивни приложения. За практическо приложение нека преминем през пример:
импортиране на java.util.Arrays;
импортиране на java.util.HashSet;
импортиране на java.util.List;
импортиране на java.util.Set;
публичен клас DynBind {
публичен статичен void main ( низ [ ] аргументи ) {
Gaming gameType1 = нов крикет ( ) ;
GameType2 = нов CallofDuty ( ) ;
gameType1.gameType ( ) ;
gameType2.gameType ( ) ;
}
}
клас игри {
public void gameType ( ) {
System.out.println ( „Физически или виртуални игри“ ) ;
}
}
клас Крикет разширява Gaming {
@ Замяна
public void gameType ( ) {
System.out.println ( „Крикетът е физическа игра“ ) ;
}
}
клас CallofDuty разширява Gaming {
@ Замяна
public void gameType ( ) {
System.out.println ( „CallofDuty е виртуална игра“ ) ;
}
}
Обяснение на горния код:
- Първо, класът „ DynBind ” се създава и два обекта от тип „ Игри ” се декларират.
- След това тези обекти се инициализират с нови „ Крикет ' и ' CallofDuty ” обекти, тази инициализация демонстрира динамичното обвързване. Референтният тип е „ Игри ”, но действителните типове обекти са „ Крикет ' и ' CallofDuty ”, съответно.
- Сега тези обекти се използват за извикване на „ gameType() ” функционира чрез заместване на функцията в дъщерни класове.
- Тогава родителят „ Игри ” е деклариран клас, който създава и инициализира „ gameType() ”, която отпечатва фиктивно текстово съобщение.
- След това се създават два дъщерни класа с името „ Крикет ' и ' CallofDuty ”. Тези класове са наследени от родителския ' Игри ” клас.
- След това „ @Override 'анотацията се използва за замяна на родителя' Игри ” клас методи с име “ gameType() ”.
- В крайна сметка се показва различно фиктивно съобщение и в двата заменени метода на дъщерен клас.
След края на фазата на изпълнение:
Изходът показва, че фиктивните съобщения на дъщерните класове се показват на конзолата с помощта на динамично обвързване.
Пример 2: Внедряване на многостепенно наследяване
Динамичното обвързване може също да бъде приложено за създаване на многостепенно наследяване. Два кодови блока на една и съща програма, както е показано по-долу:
клас игри {public void gameType ( ) {
System.out.println ( „Физически или виртуални игри“ ) ;
}
}
клас Крикет разширява Gaming {
@ Замяна
public void gameType ( ) {
System.out.println ( „Крикетът е физическа игра“ ) ;
}
public void playingFormat ( ) {
System.out.println ( „Крикетът има различни формати на игра“ ) ;
}
}
клас CallofDuty разширява Gaming {
@ Замяна
public void gameType ( ) {
System.out.println ( „CallofDuty е виртуална игра“ ) ;
}
public void gameMode ( ) {
System.out.println ( „CallofDuty има множество режими на игра“ ) ;
}
}
клас CricketGame разширява Cricket {
public void gameMode ( ) {
System.out.println ( „Крикетът има режим на единична игра“ ) ;
}
}
клас CallofDutyGame разширява CallofDuty {
}
Обяснение на горния код:
- Първо, родителят „ Игри ” е създаден клас и включва „ gameType() ”, която съдържа фиктивно съобщение.
- След това два дъщерни класа, наречени „ Крикет ' и ' CallofDuty “ се създават, като и двете заместват функцията на родителския клас с име „ gameType() ”.
- Тези класове съдържат една допълнителна функция, наречена „ playingFormat() ' и ' режим на игра() ” функции, съответно.
- След това създайте дете на много нива с име „ CricketGame ', което се удължава от детето' Крикет ” клас. Той съдържа „ режим на игра() ' функция, която е заменена от своя родител ' Крикет ” клас.
- След това „ CallofDutyGame ” е създаден като дъщерен за „ CallofDuty ” клас. Той създава многостепенно наследяване и позволява функционалността на динамичното обвързване.
Сега вмъкнете „ основен () ” метод:
публичен клас DynBind {публичен статичен void main ( низ [ ] аргументи ) {
CallofDutyGame codg = нова CallofDutyGame ( ) ;
codg.gameType ( ) ;
codg.gameMode ( ) ;
CricketGame cricg = нова игра на крикет ( ) ;
cricg.gameType ( ) ;
cricg.playingFormat ( ) ;
cricg.gameMode ( ) ;
}
}
Обяснение на горния код:
- Първо, обект на „ CallofDutyGame ” се създава клас, който извиква функциите на своите родителски класове.
- По същия начин „ CricketGame ” се декларира обект, който извиква функцията на неговия родителски клас, която е достъпна на много нива в йерархията.
След края на фазата на изпълнение:
Резултатът показва, че многостепенното наследяване се създава с помощта на динамично обвързване в Java.
Заключение
В Java, „ динамично обвързване ” предлага предимства като полиморфизъм, повторно използване на кода, гъвкавост и разширяемост. Внедрява се чрез спазване на правила за наследяване, отмяна на метода и преобразуване. Динамичното обвързване също позволява функции по време на изпълнение и подобрява гъвкавото и полиморфно поведение в концепцията на OOP. Това е всичко относно използването и внедряването на динамично обвързване в Java.