Док је један од Јава'с предности је концепт насљеђивања у којем класа може произаћи из другог, понекад је пожељно спречити наслеђивање од стране друге класе. Да бисте спречили наслеђивање, приликом креирања класе користите кључну реч "финал".
На пример, ако класу вероватно користе други програмери, можда бисте желели да спречите наследство ако било која креирана подкласа може проузроковати проблеме. Типичан пример је Класа струне. Ако смо желели да створимо стринг класу:
МиСтринг јавна класа проширује стринг {
}
Били бисмо суочени са овом грешком:
не може наслиједити од коначног јава.ланг. Низ
Дизајнери класе Стринг схватили су да није кандидат за наследство и спречили су је да се продужи.
Зашто спречити наслеђивање?
Главни разлог за спречавање наслеђивање је осигурати да се подкласа не понаша на начин на који се класа понаша.
Претпоставимо да имамо рачун класе и подразред који га проширује, ОвердрафтАццоунт. Налог класе има методу гетБаланце ():
јавни дупли гетБаланце ()
{
вратити овај.баланце;
}
У овом тренутку наше дискусије, подразред ОвердрафтАццоунт није надјачао ову методу.
(Белешка: За још једну расправу о коришћењу класа Аццоунт и ОвердрафтАццоунт, погледајте како подразред се може третирати као суперкласа).
Креирајмо инстанцу сваке класе Аццоунт и ОвердрафтАццоунт:
Аццоунт бобсАццоунт = нови налог (10);
бобсАццоунт.депоситМонеи (50);
ОвердрафтАццоунт јимсАццоунт = нови ОвердрафтАццоунт (15.05,500,0.05);
јимсАццоунт.депоситМонеи (50);
// креирајте низ објеката Аццоунт
// можемо укључити јимсАццоунт јер ми
// желе само да га третирају као објект налога
Налог [] рачуни = {бобсАццоунт, јимсАццоунт};
// за сваки рачун у низу прикажите стање
за (налог а: рачуни)
{
Систем.оут.принтф ("Салдо је% .2ф% н", а.гетБаланце ());
}
Излаз је:
Биланс је 60.00
Биланс је 65.05
Чини се да овде све делује како се очекује. Али шта ако ОвердрафтАццоунт поништи методу гетБаланце ()? Ништа га не спречава да учини нешто овако:
Јавна класа ОвердрафтАццоунт проширује рачун {
приватни двоструки овердрафтЛимит;
приватни двоструки овердрафтФее;
// није укључена остала дефиниција класе
јавни дупли гетБаланце ()
{
повратак 25.00;
}
}
Ако се пример горњег кода поново изврши, излаз ће бити другачији, јер се понашање тхегетБаланце () у класи ОвердрафтАццоунт позива за јимсАццоунт:
Излаз је:
Биланс је 60.00
Биланс је 25.00
Нажалост, подразред ОвердрафтАццоунт ће никад обезбедите тачан биланс јер смо оштетили понашање класе рачуна наслеђивањем.
Ако дизајнирате класу коју ће користити други програмери, увек размислите о импликацијама било којих потенцијалних поткласа. То је разлог што се класа стрингова не може проширити. Изузетно је важно да програмери знају да када стварају Стринг објект увек ће се понашати као Стринг.
Како спречити наслеђивање
Да би се спречило проширење класе, декларација класе мора изричито рећи да се не може наследити. Ово се постиже коришћењем кључне речи "финал":
Јавни рачун завршне класе {
}
То значи да класа рачуна не може бити суперкласа, а класа ОвердрафтАццоунт више не може бити њен подразред.
Понекад ћете можда желети да ограничите само одређена понашања суперкласе да бисте избегли корупцију од стране подразреда. На пример, ОвердрафтАццоунт и даље може бити подразред рачуна, али га треба спречити да надјача гетБаланце () методу.
У овом случају користите кључну реч „финал“ у декларацији метода:
Рачун у јавној класи {
приватни двоструки биланс;
// није укључена остала дефиниција класе
јавни финални дупли гетБаланце ()
{
вратити овај.баланце;
}
}
Примјетите како се коначна кључна ријеч не користи у дефиницији класе. Подкласе Рачуна се могу креирати, али више не могу надјачати гетБаланце () методу. Сваки код који позива ову методу може бити сигуран да ће радити онако како је оригинални програмер замислио.