Implementing Interfaces
Java çoxvarisliliyə icazə verməsə də, bir classın istənilən sayda interface`i implements
etməsinə icazə verir və həmin interface`lər bir-birindən vergüllə ayrılır.
Interface`in strukturunu aşağıdakı şəkildən aydın görmək olar:
Figure 1. Defining an interface*
Figure 2. Implementing an interface**
Defining an Interface
Interface ilə bağlı bilməli olduğumuz vacib qaydalar aşağıdakılardır:
- Interface`in
new
ilə birbaşa obyekti yaradıla bilməz; - Interface`in daxilində heç bir metod olmaya da bilər, yəni hər hansı sayda metodun olmasını tələb etmir;
- Interface
final
elan edilə bilməz; - Bütün top-level interface’lər access level olaraq ancaq
public
və default ola bilərlər. Və həmçinin aşkar qeyd olunmamış olsa belə, bütün interface’lərin
abstract
olduğu güman/qəbul edilməlidir. Buna görə də interface’iprivate
,protected
vəfinal
etsək, compile xətası alarıq; - Interface daxilindəki bütün metodlar (
default
vəstatic
metodlar istisna olmaqla) aşkar qeyd olunmamış olsa beləabstract
vəpublic
metodlardır. Ona görə də interface metodlarınıprivate
,protected
vəfinal
etsək, qeyd etdiyimiz qayda ilə ziddiyyət təşkil etdiyinə görə compile xətası alarıq (Java 9-cu versiyadan etibarən artıq interface-dəprivate
metodlar da elan etmək mümkündür, amma bu OCA SE 8 imtahanının mövzusuna daxil deyil).
Birinci 3 qayda abstract class üçün qeyd etdiyimiz qaydalarla eynidir.
4-cü qayda daxili (inner) interface`lərə aid deyil (daxili interface`lər OCA imtahanı mövzusuna daxil deyil).
Qaydalarla bağlı nümunələrə baxaq:
/* example for second rule */ public interface TestInterface { }
/* example for first rule */ public class TestClass { public static void main(String[] args) { TestInterface example = new TestInterface (); // DOES NOT COMPILE } }
/* example for third rule */ public final interface TestInterface { } // DOES NOT COMPILE
4-cü və 5-ci qaydalar isə “assumed keywords” ilə əlaqəlidir. Həmin qaydalarda qeyd etdiyimiz açar sözləri əgər biz özümüz qeyd etməsək, compiler onları bizim əvəzimizə avtomatik olaraq əlavə edəcəkdir. Yəni aşağıda qeyd etdiyimiz nümunələr bir-biri ilə ekvivalentdir. 1-ci nümunəki kod compiler tərəfindən 2-ci nümunədəki koda çevrilir:
interface Activity { // example-1 void run(int speed); abstract void stop(); public abstract double jump(); }
abstract interface Activity { // example-2 public abstract void run(int speed); public abstract void stop(); public abstract double jump(); }
Aşağıdakı kodlar isə compile olunmur:
private final interface CanCrawl { // DOES NOT COMPILE private void dig(int depth); // DOES NOT COMPILE protected abstract double depth(); // DOES NOT COMPILE public final void surface(); // DOES NOT COMPILE }
5-ci qayda ilə bağlı bir haşiyəyə çıxacam, orada qeyd etdik ki, interface metodları aşkar qeyd olunmasa da public
metodlardır. İmtahanda sizi ən çox çaşdıran məqamlardan biri bu metodların override edilməsi zamanı access modifier’ə fikir verməmək ola bilər. Biz override qaydalarında qeyd etmişdik ki, child classdakı metodun access modifier`i parent classdakı metodla ən azı eyni olmalıdır, ya da ki, daha yüksək. Siz interface’də metodların qarşısında public
açar sözünü görmədikdə, onu override edən zaman subclassda metodun qarşısında diqqətinizdən yayınıb public
açar sözünü unuda bilərsiniz. Artıq bu vaxt siz compile xətası alacaqsınız, bu məqama diqqət etmək lazımdır:
interface MyInterface { void myMethod(); } class MyClass implements MyInterface { void myMethod() { // DOES NOT COMPILE System.out.println("This is my method"); } }
Aşağıda qeyd olunan kod nümunəsi sizin üçün maraqlı ola bilər. Gördüyünüz kimi interface-in daxilində main(String[] )
metod, Instance Initializer Block, Static Initializer Block və Constructor yazmışıq. Print ifadələri özü izah edir, amma təkrar olaraq qeyd edim ki, Instance Initializer Block, Static Initializer Block və Constructor interface-in daxilində compile olunmur, xəta verir. Amma maraqlıdır ki, main(String[] )
metod compile xətası vermir, hətta siz kodu run etdikdə main
metod daxilindəki print ifadə çap edilir. Səbəb isə odur ki, Java 8-ci versiyadan etibarən interface-də static
metoda icazə verir (bu haqda daha ətraflı ayrıca bir mövzuda baxacağıq):
interface ITest { public static void main(String[] args) { System.out.println("This method compile successfully and print this"); } { System.out.println("Instance block doesn't compile in Interface"); } static { System.out.println("Static block doesn't compile in Interface"); } public ITest() { System.out.println("Constructor does not compile in Interface"); } }
Inheriting an Interface
Interface ilə bağlı bu iki qaydanı yadda saxlamaq lazımdır:
- Əgər interface başqa bir interface`i
extends
edirsə, və yaxud abstract class interface`iimplements
edirsə, həmin interface`in bütün abstract metodlarını öz abstract metodu kimi miras alır.
- Interface`i
implements
edən və ya interface`iimplements
etmiş abstract classıextends
edən birinci konkret class (first concrete class) bütün abstract metodları override etməlidir.
1-ci bənddəki ilk cümlə sizi çaşdırmasın, əgər interface başqa bir interface`i miras olaraq almaq istəyirsə, bu zaman implements
deyil, extends
açar sözü istifadə edilməlidir. Abstract classın əksinə olaraq interface eyni zamanda bir neçə interface`i extends
edə bilər:
interface HasTail { public int getTailLength(); } interface HasWhiskers { public int getNumberOfWhiskers(); } public interface Seal extends HasTail, HasWhiskers { }
Seal
interface`ini implements
edən istənilən konkret class HasTail
və HasWhiskers
interface`lərinin də abstract metodlarını (getTailLength()
və getNumberOfWhiskers()
) override etməlidir:
interface HasTail { public int getTailLength(); } interface HasWhiskers { public int getNumberOfWhiskers(); } abstract class HarborSeal implements HasTail, HasWhiskers {} class LeopardSeal implements HasTail, HasWhiskers {} // DOES NOT COMPILE
Classes, Interfaces, and Keywords
Class interface`i ancaq implements
edə bilər, extends
edə bilməz. Eləcə də interface başqa bir interface`i ancaq extends
edə bilər, implements
edə bilməz.
public interface CanRun {} class Cheetah extends CanRun {} // DOES NOT COMPILE class Hyena {} interface HasFur extends Hyena {} // DOES NOT COMPILE
Interface ilə class arasında ancaq bir əlaqə var və o da bu sintaksis ilə mümkündür:
class implements interface
“Multiple Inheritance”, interface dəyişənləri, java 8 ilə gələn interface’də static
və default
metodlar haqqında isə sağlıq olsun növbəti məqalələrdə məlumat paylaşacam.
P.S. Kod nümunələri imtahana hazırlaşkən kitabdan götürdüyüm qeydlərdir, olduğu formada da qalıb. Könül istərdi ki, bu adlandırılmalar dəyişdirilib daha münasib adlandırılmalardan istifadə edilsin, amma bu mənim heç sevmədiyim və vaxtımı çox aparan iş olduğundan hələ ki əl dəyməmək qərarına gəldim 🙂 Əvəzində bilmədiyiniz bəzi qəribə ingilis sözləri öyrənmiş olarsınız 😀
[topics lang=az]