Arayüz
(Interface)
Java’da arayüz soyut sınıf yerine kullanılır, ama soyut sınıftan farklı ve daha kullanışlıdır. Arayüz kullanarak, bir sınıfın neler yapacağını belirlerken, onları nasıl yapacağını gizleyebiliriz. Arayüzün yapısı sınıfın yapısına benzerse de aralarında önemli farklar vardır.
- Arayüz ,interface anahtar sözcüğü ile tanımlanır. Arayüz abstract metotlar içerir.
- Arayüz, anlık (instance) değişkenler içeremez. Ancak, belirtkeleri konmamış olsa bile, arayüz içindeki değişkenler final ve static olur. Bu demektir ki, arayüzde tanımlanan değişkenler, onu çağıran sınıflar tarafından değiştirilemez.
- Arayüz, yalnızca public ve ön-tanımlı (dafault) erişim belirtkesi alabilir, başka erişim belirtkesi alamaz.
- public damgalı arayüz, public damgalı class gibidir. Her kod ona erişebilir.
- Erişim damgasız arayüz, erişim damgasız class gibidir. Bu durumda, arayüze, ait olduğu paket içindeki bütün kodlar ona erişebilir. Paket dışındaki kodlar erişemez.
- Arayüz, public erişim belirtkesi ile nitelenmişse, içindeki bütün metotlar ve değişkenler otomatik olarak public nitelemesine sahip olur.
- Bir sınıf birden çok arayüze çağırabilir (implement).
- Aynı arayüzü birden çok sınıf çağırabilir.
- Sınıftaki metotlar tam olarak tanımlıdır, ama arayüzde metotların gövdeleri yoktur. Onlar abstract metotlardır. Metodun tipi, adı, parametreleri vardır, ama gövde tanımı yoktur; yani yaptığı iş belirli değildir. Metotların gövdesi, o arayüzü çağıran sınıf içinde yapılır. Böylece bir metot, farklı sınıflarda farklı tanımlanabilir. Bu özelik, Java’da polymorphismi olanaklı kılan önemli bir niteliktir.
Arayüzün Yapısı
Arayüzün genel yapısı aşağıdaki gibidir. Erişim-belirtkesi ya public olur ya da hiç konmaz, o zaman default erişim etkin olur.
[erişim_belirtkesi] interface adı {
tip metot_adı_01 (parametre_listesi);
tip metot_adı_02 (parametre_listesi);
tip final değişken_adı_01 = değer_01;
tip final değişken_adı_02 = değer_01;
// …
tip metot_adı_N (parametre_listesi);
tip final değişken_adı_N = değer_N;
}
Örnek 1: Aşağıdaki arayüz iki tane metot içermektedir.
public interface arayuz01{
public void topla(int x, int y);
public void hacim(int x, int y, int z);
}
Örnek 2: Aşağıdaki arayüz iki tane sabit değişken içermektedir.
public interface arayuz02{
public static final double fiyat = 1250.00;
public static final int sayac = 5;
}
Örnek 3: Aşağıdaki sınıf, yukarıdaki iki arayüzü var etmektedir. Sınıf içinde, arayüzün metotlarının serbestçe tanımladığına dikkat ediniz. Aynı arayüzü var edecek başka sınıflar, bu metotları başka başka tanımlayabilirler. Bu, bir metodun farklı işler görmesini sağlar ve polymorphism diye bilinir.
import java.io.*;
class Deneme01 implements arayuz01, arayuz02{
public void topla(int x, int y){
System.out.println("x+y = " + (x+y));
}
public void hacim(int a, int b, int c){
System.out.println("Hacim = " + (a*b*c));
}
public static void main(String[] args){
Demo d01 = new Deneme01();
D01.topla(12,15);
D01.hacim(3,5,7);
}
}
Örnek 4:
interface Aryz {
void aryzMet(int param);
}
class Deneme02 implements Aryz {
// Implement Aryz's interface
public void aryzMet(int p) {
System.out.println("aryzMet metodu " + p + “ ile çağrılıyor. “ );
}
}
class Deneme03 implements Aryz {
// Implement Aryz's interface
public void aryzMet(int p) {
System.out.println("aryzMet metodu " + p + “ ile çağrılıyor. “ );
}
void insMet() {
System.out.println("Arayüzü çağıran sınıf, istenirse " +
"başka öğeler de tanımlayabilir.");
}
}
class Deneme04 {
public static void main(String args[]) {
Aryz d04 = new Deneme02();
d04.aryzMet(23);
}
}
class Deneme05 implements Aryz {
// Implement Aryz's interface
public void aryzMet(int p) {
System.out.println("Başka bir aryzMet");
System.out.println("p nin karesi = " + (p*p));
}
}
class Deneme06 {
public static void main(String args[]) {
Aryz c = new Deneme02();
Deneme05 d05 = new Deneme05();
c.aryzMet(23);
c = d05; // c şimdi Deneme05’in bir nesnesini işaret ediyor
c.aryzMet(23);
}
}
Örnek 4: Aşağıdaki sınıf Aryz arayüzünü çağırıyor, ama onun metotlarını tanımlamıyor. Dolayısıyla soyut bir sınıftır, önüne abstract nitelemesi konmalıdır.
abstract class EksikClass implements Aryz {
int a, b;
void show() {
System.out.println(a + " " + b);
}
// ...
}
Örnek 5: Aşağıdaki örnek, interface kullanarak bir stack oluşturmaktadır.
// Define an integer stack interface.
interface IntStack {
void push(int item); // store an item
int pop(); // retrieve an item
}
// An implementation of IntStack that uses fixed storage.
class FixedStack implements IntStack {
private int stck[];
private int tos;
// allocate and initialize stack
FixedStack(int size) {
stck = new int[size];
tos = -1;
}
// Push an item onto the stack
public void push(int item) {
if(tos==stck.length-1) // use length member
System.out.println("Stack is full.");
else
stck[++tos] = item;
}
// Pop an item from the stack
public int pop() {
if(tos < 0) {
System.out.println("Stack underflow.");
return 0;
}
else
return stck[tos--];
}
}
class IFTest {
public static void main(String args[]) {
FixedStack mystack1 = new FixedStack(5);
FixedStack mystack2 = new FixedStack(8);
// push some numbers onto the stack
for(int i=0; i<5; i++) mystack1.push(i);
for(int i=0; i<8; i++) mystack2.push(i);
// pop those numbers off the stack
System.out.println("Stack in mystack1:");
for(int i=0; i<5; i++)
System.out.println(mystack1.pop());
System.out.println("Stack in mystack2:");
for(int i=0; i<8; i++)
System.out.println(mystack2.pop());
}
}
Örnek 6: Aşağıdaki örnek gerektikçe artabilen bir stack oluşturuyor.
// Implement a "growable" stack.
class DynStack implements IntStack {
private int stck[];
private int tos;
// allocate and initialize stack
DynStack(int size) {
stck = new int[size];
tos = -1;
}
// Push an item onto the stack
public void push(int item) {
// if stack is full, allocate a larger stack
if(tos==stck.length-1) {
int temp[] = new int[stck.length * 2]; // double size
for(int i=0; i<stck.length; i++) temp[i] = stck[i];
stck = temp;
stck[++tos] = item;
}
else
stck[++tos] = item;
}
// Pop an item from the stack
public int pop() {
if(tos < 0) {
System.out.println("Stack underflow.");
return 0;
}
else
return stck[tos--];
}
}
class IFTest2 {
public static void main(String args[]) {
DynStack mystack1 = new DynStack(5);
DynStack mystack2 = new DynStack(8);
// these loops cause each stack to grow
for(int i=0; i<12; i++) mystack1.push(i);
for(int i=0; i<20; i++) mystack2.push(i);
System.out.println("Stack in mystack1:");
for(int i=0; i<12; i++)
System.out.println(mystack1.pop());
System.out.println("Stack in mystack2:");
for(int i=0; i<20; i++)
System.out.println(mystack2.pop());
}
}
Örnek 6: Aşağıdaki örnek, bir interface değişkeni yardımıyla, daha önce tanımlanan FixedStack ve DynStack sınıflarına erişmektedir.
/* Create an interface variable and
access stacks through it.
*/
class IFTest3 {
public static void main(String args[]) {
IntStack mystack; // create an interface reference variable
DynStack ds = new DynStack(5);
FixedStack fs = new FixedStack(8);
mystack = ds; // load dynamic stack
// push some numbers onto the stack
for(int i=0; i<12; i++) mystack.push(i);
mystack = fs; // load fixed stack
for(int i=0; i<8; i++) mystack.push(i);
mystack = ds;
System.out.println("Values in dynamic stack:");
for(int i=0; i<12; i++)
System.out.println(mystack.pop());
mystack = fs;
System.out.println("Values in fixed stack:");
for(int i=0; i<8; i++)
System.out.println(mystack.pop());
}
}
Örnek 7: Aşağıdaki örnek, interface içinde değişken kullanılışını göstermektedir.
import java.util.Random;
interface SharedConstants {
int NO = 0;
int YES = 1;
int MAYBE = 2;
int LATER = 3;
int SOON = 4;
int NEVER = 5;
}
class Question implements SharedConstants {
Random rand = new Random();
int ask() {
int prob = (int) (100 * rand.nextDouble());
if (prob < 30)
return NO; // 30%
else if (prob < 60)
return YES; // 30%
else if (prob < 75)
return LATER; // 15%
else if (prob < 98)
return SOON; // 13%
else
return NEVER; // 2%
}
}
class AskMe implements SharedConstants {
static void answer(int result) {
switch(result) {
case NO:
System.out.println("No");
break;
case YES:
System.out.println("Yes");
break;
case MAYBE:
System.out.println("Maybe");
break;
case LATER:
System.out.println("Later");
break;
case SOON:
System.out.println("Soon");
break;
case NEVER:
System.out.println("Never");
break;
}
}
public static void main(String args[]) {
Question q = new Question();
answer(q.ask());
answer(q.ask());
answer(q.ask());
answer(q.ask());
}
}
Örnek 8: Aşağıdaki örnek, sınıflarda olduğu gibi, arayüzlerin de alt-arayüzlerinin yaratılabileceğini göstermektedir.
// One interface an extend another.
interface A {
void meth1();
void meth2();
}
// B now includes meth1() and meth2() -- it adds meth3().
interface B extends A {
void meth3();
}
// This class must implement all of A and B
class MyClass implements B {
public void meth1() {
System.out.println("Implement meth1().");
}
public void meth2() {
System.out.println("Implement meth2().");
}
public void meth3() {
System.out.println("Implement meth3().");
}
}
class IFExtend {
public static void main(String arg[]) {
MyClass ob = new MyClass();
ob.meth1();
ob.meth2();
ob.meth3();
}
}
