Проучване на наследството в езика за програмиране на Java

Наследяването е една от основните концепции на обектно-ориентираното програмиране. При програмирането думата наследяване представлява връзка, при която детски клас приема състоянието и поведението на родителски клас.

Целта на наследяването при разработването на софтуер е да улесни повторната употреба на безопасен и надежден софтуер. Едно от основните предимства на използването на наследяване е, че то премахва излишния код във вашите програми.

Как работи наследството

Идеята зад наследяването е, че много класове или обекти имат едни и същи набор от атрибути и методи. Следователно, в духа на производството на надежден софтуер, новите класове вече могат да черпят от вече съществуващи свързани класове и ако е необходимо да се разширят върху съществуващите състояния и поведения.

Реален пример за това как работи наследството би бил разглеждането на плодовете. Това е широк етикет, който служи за капсулиране на редица различни елементи.

Ябълката е плод, а портокалът също. Оранжевият обаче не е ябълка, така че няма да имате плодове като един от запасите си, ако сте собственик на магазин. Може би бихте могли да имате раздел с плодове в инвентара си, а в този раздел бихте имали по-специфични елементи като ябълки и портокали.

Ето как работи наследството.

Използване на наследяване в Java

Наследството може да се използва във всеки език за програмиране, който използва обектно-ориентирана парадигма на програмиране. Точният начин, по който се използва наследяването, зависи от конкретния език за програмиране.

Например, C ++ също е обектно-ориентиран език за програмиране. C ++ поддържа това, което е известно като множествено наследяване, докато Java поддържа само едно наследяване.

Това означава, че в Java родителският клас може да има много дъщерни класове, но всеки дъщерен клас може да има само един родителски клас (единично наследство). Има обаче начин да се постигне непряко множествено наследяване в Java, чрез създаване на взаимоотношения между баба и дядо, родител и дете.

Създаване на родителски клас в Java

Процесът на избор на родителски клас от документ със софтуерни изисквания е известен като обектно-ориентиран анализ. По време на този процес фразата „е a“ често се използва за идентифициране на възможни отношения на наследяване. Като черпим от нашия пример по-горе, бихте могли да видите, че плодовете ще бъдат нашият родителски клас.

Пример за клас на плодове за родители

публична класа Плодове {
// Декларация на променлива
защитено семе от струни;
защитен String skinColor;
защитен Струнен вкус;
// Конструктор по подразбиране
обществени плодове () {
семе = "";
skinColor = "";
вкус = "";
}
// Първичен конструктор
обществени плодове (семена от струни, цвят на струната, вкус на струни) {
this.seed = семе;
this.skinColor = skinColor;
this.taste = вкус;
}
// гетери и сетери
публичен низ getSeed () {
връщане на семе;
}
public void setSeed (String seed) {
this.seed = семе;
}
публичен низ getSkinColor () {
връщане skinColor;
}
public void setSkinColor (String skinColor) {
this.skinColor = skinColor;
}
публичен низ getTaste () {
връщане на вкуса;
}
public void setTaste (String taste) {
this.taste = вкус;
}
// метод за ядене
публично празно яде () {
// общ код за това как да се яде плод
}
// метод за сок
обществен празен сок () {
// общ код за това как да сокам плод
}
}

Един от най-забележителните аспекти на родителския клас по-горе е модификаторът на достъп, който се използва с всяка декларация на променлива. Модификаторът „защитен“ достъп е идеален за използване в родителски класове, тъй като пречи на не-дъщерни класове да получат достъп до атрибутите на данни на родителския клас.

По-надолу в кода се запознавате с конструктори, гетери и сетери, които са общи градивни елементи за всеки клас Java. И накрая, вие се запознахте с два метода (сок и ядене), които са създадени в родителския клас на нашата програма, тъй като те са универсални за всички плодове - всички плодове могат да се ядат и сочат.

Създаване на детски класове в Java

Детските класове обикновено се наричат ​​специализирани или производни класове, защото наследяват състояние и поведение от родител и често персонализират тези атрибути, за да бъдат по-конкретни.

Продължавайки с нашия пример, бихте могли да разберете защо портокалът би бил подходящ детски клас от горния клас плодове.

Пример за Orange Child Class

обществена класа Orange разширява Fruit {
// променлива декларация
частни int supremes;
// конструктор по подразбиране
публичен Orange () {
супремеси = 0;
}
// първичен конструктор
публично оранжево (String seed, String skinColor, String taste, int supremes) {
супер (семена, кожаЦвят, вкус);
this.supremes = supremes;
}
// гетери и сетери
public int getsupremes () {
връщане на супреми;
}
public void setsupremes (int supremes) {
this.supremes = supremes;
}
// метод за ядене
публично празно яде () {
// как се яде портокал
}
// метод за сок
обществен празен сок () {
// как да сок и портокал
}
// пилинг метод
публична празнина кора () {
// как се бели портокал
}
}

Има разлика между това как изглежда обикновената декларация на Java клас и това, което имаме в нашия код по-горе. Ключовата дума “extends” е това, което се използва в Java, за да направи наследяването възможно.

В нашия пример по-горе класът дете (оранжево) разширява родителския клас (плод). Следователно състоянието и поведението на плодовия клас вече могат да бъдат достъпни и модифицирани от оранжевия клас.

Уникалният атрибут, който има нашият оранжев клас, се идентифицира с името на променливата supremes (което е официалното име за малките сегменти, открити в портокалите). Тук се появява специализацията; не всички плодове имат супреми, но всички портокали имат, така че запазването на променливата супреми за клас оранжево е логично.

Добавянето на метода „кора“ към вече съществуващите методи „ядене“ и „сок“ също е логично, защото макар че не всички плодове могат да се белят, портокалите често се белят.

Трябва да имате предвид, че ако не възнамеряваме да променяме съществуващите методи за „ядене“ и „сок“, няма да е необходимо да ги включваме в нашия оранжев клас. Методите в клас портокал заменят всеки подобен метод в класа плодове. Така че, ако всички плодове се ядат и сочат по един и същи начин, не би трябвало да създаваме тези методи в портокаловия клас.

Конструкторите на роли играят по наследство

По подразбиране конструкторите на родителски клас се наследяват от дъщерни класове. Следователно, ако се създаде обект на детски клас, това означава, че обектът на родителски клас също се създава автоматично.

Връщайки се към нашия пример, всеки път, когато се създава нов оранжев обект, се създава и плодов обект, защото портокалът е плод.

Зад кулисите, когато се създава обект на детски клас, първо се извиква конструкторът на родителския клас, последван от конструктора на дъщерния клас. В нашия портокалов клас по-горе, ако се създаде оранжев обект без никакви параметри, ще се извика конструкторът ни по подразбиране за плодов клас, последван от изпълнителя на оранжевия клас по подразбиране.

Методът „super“ в нашия първичен конструктор по-горе е необходим, тъй като указва, че основният конструктор — и не конструкторът по подразбиране - на родителския клас плодове трябва да се извиква винаги, когато е оранжев обект с параметри създаден.

Сега можете да използвате наследяване в Java

От тази статия успяхте да научите какво е наследяване, как работи и защо е толкова важна концепция в програмирането. Вече можете да създавате връзките си за наследяване с помощта на езика за програмиране Java. Освен това вече знаете как да заобиколите правилото за единично наследяване на Java, като създадете връзка между баба и дядо.

Кредит за изображението: Andreas Wohlfahrt /Пексели

Как да организирате вашия обектно-ориентиран код с наследяване

Получаването на обектно ориентирано програмиране правилно означава, че трябва да знаете за наследяването и как то може да опрости кодирането и да намали грешките.

Прочетете Напред

За автора