Merhaba Arkadaslar,
Bu dersimiz, Java ‘da Interface (arabirim) tanimlanmasi ile ilgili olacaktir.

Bir interface (arabirim) tanimladigimizda , metotlar govdesiz olarak tanimlanir. yani { } icermezler. Interface bir sablon, kontrattir yani bir interface i uygulayan sinif bu metotlari mutlaka uygulamak, (override) zorundadir.

abstract bir sinif , bir interface i uygulayabilir ve metotlarini uygulamak zorunda degildir, abstract olmayan bir sinif mutlaka metotlari uygulamak ,(override) , zorundadir.

Interface (arabirim) , herhangi bir sinif tarafindan uygulanabilir (implements) . Bu sayede kalitim hiyerarsisinde birbiriyle tamamen iliskisi olmayan siniflar dahi ayni arabirimi uygulayabilir. Bu Interface yapisinin en onemli ozelligidir.

interface kelimesi Javada bir anahtar kelimedir.

Basit bir interface ornegi,

interface NewInterface {
	void method1();
	void method2();
}

 
Yukaridaki sekilde tanimladigimiz interface ve metotlar compiler tarafindan su sekilde algilanir.

interface NewInterface {
	public abstract void method1();
	public abstract void method2();
}

Interface ‘ler %100 abstract tir. Dikkat ederseniz tanimlanan metotlar abstractir. Interfaceler de normal metotlar tanimlanamaz.

Interface i uygulayan bir sinifa bakalim simdi de.

class A implements NewInterface{

	public void method1() {	
	//kodlar
	}

	public void method2() {
	//kodlar	
	}

}

 

Abstract class’ larda abstract ve non-abstract metotlar tanimlanabilirken Interface ‘lerde sadece abstract metotlar tanimlanabilir.
Tum Interface metotlari belirtelim ya da belirtmeyelim public abstract tir. protected veya private olarak tanimlanamazlar.
Interface ‘lerde degisken tanimlanabilir ve bu degiskenler belirtilmese bile mutlaka public static ve final dir. Dolayisiyla degiskenden ziyade bir constant tir.
Interface metotlari static , final , strictfp veya native olamazlar . final ve abstract asla yanyana gelemez.
Bir interface bir ya da daha fazla interface i extend edebilir. Java da siniflar sadece 1 sinifi extend edebilirken bu durum interfaceler icin gecerli degildir.
Bir interface diger bir interface i implement edemez.
interface taniminda yazalim ya da yazmayalim abstract anahtar kelimesi vardir yani ;
public interface NewInterface
public abstract interface NewInterface ayni anlama gelmektedir.
interface ler default veya public olarak tanimlabilir. private interface olamaz.

Su tanimlanan metotlarin tanimlanma sekli farkli olsa da , hepsi aynidir. Cunku interface metotlarin hepsi abstract ve public tir ve tanimlarken abstract – public yer degistirebilir.

void method1();
public void method1();
abstract void method1();
public abstract void method1();

interface ve coklu kalitim a bir ornek ,

interface A {

}

interface B {

}

interface C extends A , B {

}

 

interface degiskenleri biz belirtelim ya da belirtmeyelim public static final dir demistik, yani sabittir. Interface de tanimlanan degiskenler implements eden sinifta degistirilemezler.

Bir interface icerisinde tanimlanabilecek degisken tanimlarindan hepsi birbirinin aynisidir.

public int x=1;
int x=1;
static int x=1;
final int x=1;
public static int x=1;
public final int x=1;
public static final in x=1;

Java 8 Interface New Features

Java 8 oncesinde interface’lerde sadece abstract (govdesiz) metotlar tanimlanabiliyordu.
Java 8 ile birlikte artik interface ‘ler default ve static metotlara sahip olabilmektedir!

interface default methods

default anahtar kelimesini ekleyerek artik govdeli metotlari Interface’lerde tanimlayabiliriz !

public interface Java8Interface {

	default void defaultMethod() {
		System.out.println("default method java 8 new feature!");
	}

	default void defaultMethod2() {
		System.out.println("default method2 java 8 new feature!");
	}

}

 

default metotlar , govdesiz metotlar gibi override edilmek zorunda degildir , dilersek override edebiliriz.

default metotlar icin access level govdesiz metotlar gibi public ‘ tir!

public class Java8InterfaceImpl implements Java8Interface{

}

 

Yukaridaki kodumuz herhangi bir derleme hatasi vermeyecektir, cunku default metotlari override etmek zorunda degiliz!

Ufak bir test sinifi yazalim ;

public class Java8InterfaceTest {

	public static void main(String[] args) {
		Java8InterfaceImpl java8 = new Java8InterfaceImpl();
		java8.defaultMethod();
		java8.defaultMethod2();
	}
}

 

Ornegimizi calistirdigimizda Console’da

default method java 8 new feature!
default method2 java 8 new feature!

Simdi de default metodu override edelim ;

public class Java8InterfaceImpl implements Java8Interface {

public class Java8InterfaceImpl implements Java8Interface {

	@Override
	public void defaultMethod() {
		System.out.println("default method override !!");
	}
}

Test sinifimizi tekrar calistirdigimizda Console’da

default method override !!
default method2 java 8 new feature!

Java da bir class sadece bir class ‘i kalitabilir (extends) fakat bir class birden fazla interface’i uygulayabilir (implements)

Multiple extends mekanizmasinda Diamond Problemi ortaya cikabilir , bu nedenle Javada multiple extends mekanizmasi class’lar icin yoktur. Diamond Problemi default metotlar icin de ortaya cikabilir ;

2 tane interface tanimlayalim ve ayni isimde metot tanimlayalim. Bu durudmda bu 2 interface i uygulayan (implements) class hangi super metodu kullanacak ? Eger bu default metot override edilmezse bu durumda derleme hatasi olacaktir.

public interface DiamondInterface1 {
	
	public default void diamondProblem(){
		System.out.println("Diamond");
	}
}

 

public interface DiamondInterface2 {
	public default void diamondProblem() {
		System.out.println("Diamond");
	}
}

Dikkat edecek olursak 2 tane Interface tanimladik ve ayni isimle default metot tanimladik.

public class DiamondClass implements DiamondInterface1, DiamondInterface2 {
	// eger override edilmezse derleme hatasi verecektir.
	// Duplicate default methods named diamondProblem
	// public void diamondProblem(){
	// System.out.println("Diamond override");
	// }
}

Kafamizda kalmasi icin bir baska ornek ile aciklamaya calisalim ;
3 tane interface olsun.

Developer
JavaDeveloper
CSharpDeveloper

public interface Developer {
	public void code();
}

public interface JavaDeveloper extends Developer {

	@Override
	public default void code() {
		System.out.println("Code Java");
	}
}

 

public interface CSharpDeveloper extends Developer{
	@Override
	public default void code() {
		System.out.println("Code C#");
	}
}

Developer interface’inde code adinda abstract bir metot tanimladik ve JavaDeveloper , CSharpDeveloper interface’leri bu metodu override etti.

JuniorDeveloper adinda bir class tanimlarsak ve hem JavaDeveloper hem de CSharpDeveloper interface’lerini uygularsa (implements) bu durumda derleme hatasi verecektir.

Bu durumda code metodu JuniorDeveloper sinifinda override edilmelidir.

public class JuniorDeveloper implements JavaDeveloper, CSharpDeveloper {
	@Override
	public void code() {
		System.out.println("Override Code");
	}
	// eger code metodu override edilmezse derleme hatasi verir.
}

Bu durumun aklimizda kalmasi icin su diamond(karo) seklini hatirlayabiliriz.

 

interface static methods

Bir diger ozellik olarak Interface’te static metotlar tanimlayabiliriz. Interface’te tanimladigimiz default ve abstract metotlar gibi static metotlar da public metotlardir.

static metotlar override edilmez. Interface’te tanimlanan static metotlarin bir kisiti daha bulunmaktadir ; sadece InterfaceName.staticMethodName olarak bu static metodu cagirabiliriz. Diger durumlarda derleme hatasi verecektir.

public interface Java8InterfaceStaticMethod {

	public static void staticMethod() {
		System.out.println("This is Java8 interface static method.");
	}
}

public class Java8InterfaceStaticMethodImpl implements Java8InterfaceStaticMethod{

}

Ufak bir test sinifi yazalim;

public class Java8InterfaceStaticMethodTest {

	public static void main(String[] args) {
		Java8InterfaceStaticMethod java8 = new Java8InterfaceStaticMethodImpl();
		Java8InterfaceStaticMethod.staticMethod();

		// derleme hatasi verir!
		// Java8InterfaceStaticMethodImpl.staticMethod();
		// derleme hatasi verir!
		// java8.staticMethod();
	}
}

Dikkat edecek olursak sadece Java8InterfaceStaticMethod.staticMethod(); olarak bu static metoda ulasim saglayabildik , diger durumlarda derleme hatasi verecektir.

Utility metotlari static tanimlanir , dolayisiyla interface’lerde utility metotlarina uygun olacak sekilde static metotlari kullanabiliriz.