Java Interfaces

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:

1. Interface`in new ilə birbaşa obyekti yaradıla bilməz;
2. Interface`in daxilində heç bir metod olmaya da bilər, yəni hər hansı sayda metodun olmasını tələb etmir;
3. Interface final elan edilə bilməz;
4. 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’i private, protected və final etsək, compile xətası alarıq;
5. 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:

1. Əgər interface başqa bir interface`i extends edirsə, və yaxud abstract class interface`i implements edirsə, həmin interface`in bütün abstract metodlarını öz abstract metodu kimi miras alır.

2. Interface`i implements edən və ya interface`i implements 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]