Arayüz tanımlama

Bir arayüz(interface) tanımlamak, kendisinden implemente olacak sınıfların ne yapacağını söyleyen bir anlaşma gibidir. Tanımladığınız bir interface’de eğer calculateAge() isimli bir method varsa, arayüzden implemente olan tüm sınıflarda aynı şekilde calculateAge() methodu bulunmak zorundadır.

Birbirleriyle kalıtık bağı olmayan sınıflar aynı arayüz tarafından implemente edilebilir. Kalıtık bağın olmaması, aynı arayüzü kullanmalarına mani değildir.

Siz eğer aşağıdaki gibi bir arayüz tanımlarsanız,

  1. interface Bounceable {
  2.  void bounce( );
  3.  void setBounceFactor(int bf);
  4. }

Derleyici bunu aşağıdaki gibi görecek ve okuyacaktır.

  1. interface Bounceable {
  2.  public abstract void bounce( );
  3.  public abstract void setBounceFactor(int bf);
  4. }

interface içerisine tanımlanan tüm yordamlar(method) hem soyuttur(abstract) hem de geneldir(public). Arayüz içerisine private ya da protected erişimli method yazamazsınız.

Peki yukarıdaki arayüzden implemente edilen sınıf nasıl olmalıdır? O da aşağıda yine belirtilmiştir.

  1.  
  2. Class Tire implements Bounceable
  3. public void bounce( ){}
  4. public void setBounceFactor(int bf){ }

Bir arayüz sınıfını, abstract(soyut) sınıf gibi düşünebilirsiniz. Aralarındaki en önemli farklardan birisi, soyut sınıflarda soyut olmayan yordamlar(methodlar) bulunabilir, buna karşın arayüzlerdeki tüm methodlar mutlaka abstract olmalıdır. Siz belirtmeseniz de o yordam, kendini abstract olarak tanımlayacaktır.

—–Abstract sınıflarda, private türünde method yazabilirsiniz fakat interfaces(arayüzlerde) tüm methodlar public anahtar kelimesi ile tanımlanır. Hatta o kadar kesin bir kaidedir ki bu, siz belirtmeseniz de (yani methodun önüne public -abstarct yazmasanız da) methodlar public ve abstract olarak tanımlanır.

—–Arayüzlerde tanımlanan tüm değişkenler hem final’dır, hem static’tir hem de public’tir.

—–Arayüzlerde tanımlanan methodlar static olamaz. Denemeniz halinde hata alırsınız. Methodlar abstract olduğu için strictfp,final olarak tanımlanamaz.

—–Bir arayüz, bir başka arayüzden implemente edilemez, extend edilebilir fakat extend edilmesi sadece interfaceler için geçerlidir. Sınıflarda kullanılamaz.

—–Bir arayüz, birden fazla arayüzden extend edilebilir.

Not: Aşağıdaki arayüz tanımlaması legaldir.

  1.  
  2. public abstract interface ITest {
  3.  
  4. }

Öyle ki aşağıdaki tüm tanımlamalar aynıdır ve geçerlidir.

  1.  
  2. void bounce();
  3. public void bounce();
  4. abstract void bounce();
  5. public abstract void bounce();
  6. abstract public void bounce();

Fakat aşağıdaki tanımlamalar hatalıdır..

  1.  
  2. final void bounce(); // final ve abstract tanımlamaları bir arada kullanılamaz
  3. static void bounce(); // interfaces methodlarında static tanımlama yapılamaz
  4. private void bounce(); // interface methodları her zaman public'itr
  5. protected void bounce();  // Bir üstteki kural, burada da geçerlidir

Son olarak arayüzlerde tanımlanan değişkenlerden bahsedelim. Bir arayüz içerisinde tanımlanan herhangi bir değişken, siz belirtmeseniz de hem public’tir, hem static’tir hem de final ‘dır.

Aşağıdaki örneği birlikte inceleyelim

  1.  
  2. interface Foo {
  3.  int BAR = 42;
  4.  void go();
  5. }
  6. class Zap implements Foo {
  7.  public void go() {
  8.  BAR = 27;
  9.  }
  10. }

Burada “BAR” değişkenini Zap sınıfında değiştirmeyi denediğinizde hata alırsınız. Normalde sadece int anahtar kelimesi ile tanımlanan bu değişken hem final’dır, hem static’tir, hem de public ‘tir.

Aşağıdaki tanımlanan interface içerisindeki tüm değişkenler aynıdır.

  1.  
  2. public int x = 1;
  3. int x = 1;
  4. static int x = 1;
  5. final int x = 1;
  6. public static int x = 1;
  7. public final int x = 1;
  8. static final int x = 1
  9. public static final int x = 1;


*** *** KANALIMIZA ABONE OLMAYI UNNUTMAYIN ** ***

*** *** KANALIMIZA ABONE OLMAYI UNNUTMAYIN *** ***