Java’da arayüzler (interface)

Dün Java’da Abstraction (Soyutlama) hakkında yazdığım makalede belirttiğim gibi, javada kullanılan bir diğer soyutlama yöntemi olan arayüzlerden bahsedeceğim.

Java’da arayüzlerin, abstract class’lar ile çok fazla benzer yönleri bulunur. Aralarındaki en temel fark; arayüzler içerisinde sadece abstract (soyut) metotlar tanımlanabilir. Abstract (soyut) class’lar hem abstract metodları hem de normal metodları barındırabiliyorlardı. Normal metotdan kastım body kısmı olan metodlardır. Yani somut metodlardır. Yani arayüzler %100 soyuttur.

Dilerseniz arayüzler hakkında daha detaylı bilgiler öğrenmeye devam edelim.

Arayüzler tanımlanırken “interface” anahtar kelimesi kullanılır. Oluşturulan bir arayüzü implement edecek olan class ise “implements” anahtar kelimesini kullanır.

interface ArayüzClassi {
    //Soyut metotlar burada
}
 
class HerhangiBirClass implements ArayüzClassi {
    //İmplement edilmek istenen arayüzler "implements" anahtar kelimesinden sonra yazılır
    //"extends" anahtar kelimesi kullanılmaz.
}

Arayüzlerde sadece soyut metot tanımlamaları yapılabilir. Somut metotlara izin verilmez.

interface ArayuzClassi {
    abstract void soyutMetotBir();  //abstract metot
 
    abstract void soyutMetotIki();  //abstract metot
 
    void somutMetot() {
        //Compile Time (derleme zamanı) Hatası.
        //somut metodlara interface içinde izin verilmez.
    }
}

Arayüzlerin 2 tipte üyeleri olabilir.
1) Field (alan)
2) Abstract (soyut) metot

interface InterfaceClass {
    int i = 0;      //Field
 
    abstract void soyutMetotBir();  //abstract metot
 
    abstract void soyutMetotIki();  //abstract metot

Varsayılan olarak bütün field’lar interface içerisinde public, static ve final anahtar kelimelerini kullanır. Bu anahtar kelimelerin dışında her hangi bir anahtar kelime kullanılamaz.

interface ArayuzClassi {
    int i = 0;
    //Varsayılan olarak, field public, static ve final dir.
 
    //Aşağıdaki satırlarda compile time (derleme zamanı) hatası alınır.
 
    private double d = 10;
    protected long l = 15;
 
    //public, static ve final dışında bir anahtar kelime kullanılamaz.
}

Filed’lara herhangi bir değer atandıktan sonra bu değer değiştirilemez. çünkü field’lar static ve final olarak tanımlıdır.

interface ArayuzClassi {
    int i = 0;
}
 
class HerhangiBirClass implements ArayuzClassi {
    void metotBir() {
        //Aşağıdaki satırda compile time hatası alınır.
 
        ArayuzClassi.i = 10;
 
        //final olarak tanımlanmış bir alana yeniden değer atanamaz.
    }
}

Varsayılan olarak arayüz içerisinde tanımlanmış bütün metotlar public ve abstract dır.

interface ArayuzClassi {
    void abstractMetotBir();  //Abstract metot
 
    void abstractMetotIki();  //Abstract metot
 
    //abstract anahtar kelimesini kullanmaya gerekyok,
    //çünkü varsayılan olarak metodlar public ve abstract'dır.
}

Bütün arayüz class’larına ait .class dosyaları derleme sonrası oluşturulurlar.
Bir arayüz metodu implement ediliyorsa, bu metod public olmalıdır. Bu durum soyutlama kuralı değil, Method Overriding (Ezme) ile alakalıdır. Arayüz içinde tanımlı olan bütün metodlar, implement edildiği yerde public olarak tanımlanmalıdırlar.

interface ArayuzClassi {
    void metotBir();
}
 
class AnyClass implements ArayuzClassi {
    void metotBir() {
        //Burada compile time hatası alınır.
        //interface metodları public olarak tanımlanmalıdırlar.
    }
}

Varsayılan olarak arayüzler public değildir ancak hepsi abstract dır. Bu sebeple abstract keyword’ünü kullanmamıza gerek yoktur.

abstract interface ArayuzClassi {
    //Varsayılan olarak interface'ler abstract'dır
    //abstract anahtar kelimesinin kullanılmasına gerek yoktur.
}

Arayüzlerin içinde SIB -Static Initialization Block ve IIB – Instance Initialization Blok’larının kullanımına izin verilmez. SIB ve IIB konularından başka bir zaman bahsetmek isterim. Umarım fırsatım olur.

interface ArayuzClassiBir {
    static {
        //compile time hatası
        //Interface içerisinde SIB kullanımına izin verilmez.
    }
 
    {
        //Compile time hatası.
        //interface içerisinde IIB kullanımına izin verilmez.
    }
 
    void metotBir();  //abstract metot
}

Java’da class’lar sadece bir class’dan extend olurlar. Ancak istenilen sayıda interface’den implement olabilirler.

interface ArayuzClassiBir {
    void metotBir();
}
 
interface ArayuzClassiIki {
    void metotIki();
}
 
class HerhangiBirClass implements ArayuzClassiBir, ArayuzClassiIki {
    public void metotBir() {
        //bu metod ArayuzClassiBir arayüzünden implement edilmiştir.
    }
 
    //diğer metot da implement edilmelidir.
    //Aksi halde class'ı abstract class haline çevirmeliyiz.
 
    public void metotIki() {
        //Şimdi ikinci metotda implement edildi.
        //class'ı abstract olrak tanımlamamıza gerek kalmadı
    }
}

Umarım faydalı bir makale olmuştur. Aklınıza takılan herhangi bir şey olursa, lütfen benimle yorum yazarak iletişime geçiniz.

Java’da arayüzler (interface)

İlk Yorumu Siz Yapın

Bir yanıt yazın Yanıtı iptal et