a

Saturday, 25 May 2013

INTERFACE

INTERFACE

  • interface dapat dianggap sebagai suatu kontrak tentang apa yang dapat dilakukan oleh suatu kelas, tanpa menyebutkan bagaimana kelas akan melakukannya. [1&2]
  • interface dapat dianggap sebagai 100% abstract class. Akan tetapi, bila abstract class dapat memiliki method abstract dan method non-abstract, maka interface hanya dapat memiliki method abstract saja. [1&2]
  • Suatu interface dapat diimplementasikan oleh setiap kelas, tanpa memandang pohon inheritance dari kelas tersebut. [2]

1. DEKLARASI INTERFACE

1.1 Syarat-syarat deklarasi interface

  • Sintak deklarasi interface adalah sebagai berikut : [1&2]

AccessModifier [abstract] interface NamaInterface extends A, B, C
{
//……
}

  • Suatu interface pasti abstract, oleh karena itu, keyword abstract dalam sintaks di atas adalah optional.[1&2]
Contoh : 2 deklarasi interface dibawah ini memiliki arti yang sama  [1]

1

interface MyInterface


2

abstract interface MyInterface


  • Suatu interface boleh meng-extends satu atau lebih interface yang lain. [2]
Contoh : [1]
Program 01

interface A
{
    public abstract void namaMethodSama();
    public abstract void haha();
}

interface B
{
    public abstract void namaMethodSama();
    public abstract void hihi();
}

interface C extends A, B
{
    public abstract void huhu();
}

  • Suatu interface tidak dapat meng-extends selain interface. [2]
Contoh : [1]
Program 02

class A {}

interface Z extends A {}
Bila dicompile, program di atas akan menghasilkan :
E:\Data\Data NetBeans\Belajar SCJP\src\myInterface\MyInterface04.java:5: interface expected here
interface Z extends A {}
1 error

  • Suatu interface tidak dapat meng-implements interface atau class yang lain. [2]
Contoh : [1]
Program 03

interface A {}

//Error !!!
interface B implements A {}

  • Kesimpulan perbedaan extends dan implements pada class dan interface : [1]
extends
implements
class
Hanya dapat meng-extends satu buah superclass secara langsung.
Dapat meng-implements nol atau lebih dari nol buah interface.
interface
Dapat meng-extends nol atau lebih dari nol buah interface.
Tidak dapat meng-implement apapun.

1.2 Syarat-syarat deklarasi method dalam interface

  • Method-method yang dideklarasikan di dalam interface tidak memiliki badan method, langsung diikuti oleh titik koma. [1]
Contoh : [1]
Program 04

interface A
{
    void myMethod();
    String yourMethod();
    int outMethod();
}

  • Setiap method yang dideklarasikan di dalam interface pasti secara implisit memiliki dua modifier berikut : [2]
    1. public
    2. abstract
Dengan kata lain, setiap method pasti bermodifier public dan abstract, baik kita berikan kedua modifier tersebut saat deklarasi method atau tidak. [1&2]
Contoh : lima deklarasi method di dalam interface berikut memiliki arti yang sama [1]

1

public abstract void myMethod();

2

Abstract public void myMethod();

3

abstract void myMethod();

4

public void myMethod();

5

void myMethod();

  • Method di dalam interface tidak boleh memiliki modifier-modifier berikut :
1.      static
2.      final
3.      strictfp
4.      native
Contoh : [1]
Program 05

interface Z
{
    static void A();
    final void B();
    strictfp void C();
    native void D();
}
Bila dicompile, maka akan mengeluarkan error-error sebagai berikut :
E:\Data\Data NetBeans\Belajar SCJP\src\myInterface\MyInterface06.java:5: modifier static not allowed here
    static void A();
E:\Data\Data NetBeans\Belajar SCJP\src\myInterface\MyInterface06.java:6: modifier final not allowed here
    final void B();
E:\Data\Data NetBeans\Belajar SCJP\src\myInterface\MyInterface06.java:7: modifier strictfp not allowed here
    strictfp void C();
E:\Data\Data NetBeans\Belajar SCJP\src\myInterface\MyInterface06.java:8: modifier native not allowed here
    native void D();
4 errors

1.3 Syarat-syarat deklarasi variabel dalam interface

  • Setiap variabel yang dideklarasikan di dalam interface pasti secara implisit memiliki tiga modifier berikut : [2]
    1. public
    2. static
    3. final
Dengan kata lain, setiap variabel pasti bermodifier public, static dan final, baik kita berikan ketiga modifier tersebut saat deklarasi variabel atau tidak. [1&2]
Contoh : lima deklarasi variabel di dalam interface berikut memiliki arti yang sama [1]

1

Int i = 10;

2

Public int i = 10;

3

Static int i = 10;

4

Final int i = 10;

5

Public static int i = 10;

6

Public final int i = 10;

7

Static final int i = 10;

8

Public static final int i = 10;

9

Static final public int  i = 10;

10

Final static public int i = 10;

2. IMPLEMENTASI INTERFACE

  • Ketika kita meng-implements interface, maka kita setuju untuk menyediakan implementasi dari setiap method yang didefinisikan di interface. [1&2]
  • Bila suatu class hendak meng-implements suatu interface, maka sintaks deklarasi kelas tersebut menjadi sbb : [1]

Modifier class NamaKelas implements interface1, interface2,...
{
//………
}

Contoh : [1]
Program 06

interface A
{
    void methodDiA();
}

interface B
{
    void methodDiB();
}

interface C extends B
{
    void methodDiC();
}

class MyImplementation01 implements A, C
{
    public void methodDiA()
    {
        System.out.println("Implementasi dari A.methodDiA()");
    }
   
    public void methodDiB()
    {
        System.out.println("Implementasi dari B.methodDiB()");
    }
   
    public void methodDiC()
    {
        System.out.println("Implementasi dari C.methodDiC()");
    }
   
    public static void main(String[] args)
    {
        MyImplementation01 myI = new MyImplementation01();
        myI.methodDiA();
        myI.methodDiB();
        myI.methodDiC();
    }
}
Program di atas akan menghasilkan :
Implementasi dari A.methodDiA()
Implementasi dari B.methodDiB()
Implementasi dari C.methodDiC()

  • Suatu interface dapat di-implements oleh :
    1. abstract class
    2. non-abstract class.

  • Bila kelas yang meng-implements suatu interface adalah non-abstract class, maka harus memenuhi syarat-syarat sebagai berikut : [2]
1.      Menyediakan semua implementasi dari semua method yang ada di interface tersebut.
2.      Mengikuti semua peraturan tentang override method.

  • Peraturan tentang override yang harus diikuti adalah : [1]
1.      Harus beraccess modifier public
2.      Return type adalah harus compatible (dengan yang ada di interface)
3.      Checked exception yang dilempar harus tidak lebih luas dan tidak baru (dengan yang ada di interface)
Contoh : [1]
Program 07

class A {}
class B extends A {}
class ExceptionC extends Exception {}
class ExceptionD extends ExceptionC {}

interface X
{
    A myMethod() throws ExceptionC;
    void myOtherMethod() throws ExceptionD;
}

class MyImplementation03 implements X
{
    //Meski method di bawah ini berbeda dalam return type
    //dan exception yang dilempar dari yang ada di interface,
    //akan tetapi method di bawah ini tetap implementasi dari
    //method yang ada di interface.

    public B myMethod() throws ExceptionD
    {
        System.out.println("Implementasi dari X.myMethod()");
        return new B();
    }

    //Implementasi method di bawah ini tanpa melemparkan exception
    //(BOLEH !!!)
    public void myOtherMethod()
    {
        System.out.println("Implementasi dari X.myOtherMethod()");
    }
  
    public static void main(String[] args)
    {
        MyImplementation03 myI = new MyImplementation03();
       
        try
        {
            myI.myMethod();
        }
        catch(ExceptionD eD) {}

        //Tanpa try-catch, padahal di interface dinyatakan melempar
        //exception (BOLEH)
        myI.myOtherMethod();
    }

}
Program di atas akan menghasilkan :
Implementasi dari X.myMethod()
Implementasi dari X.myOtherMethod()


  • Bila kelas yang meng-implements interface adalah abstract class, maka dapat tidak menyediakan implementasi dari semua method yang ada di interface, akan tetapi method-method yang diimplementasikan tetap harus mengikuti semua peraturan tentang override method. [1&2]
Non-abstract class pertama dari pohon inheritance dari abstract class yang meng-implements harus menyediakan semua implementasi dari interface yang di-implement oleh abstract class tersebut. Bila ternyata interface yang diimplement meng-extends interface lain, maka method-method di interface lain itu juga harus diimplementasikan oleh non-abstract class.
Contoh : [1]
Program 08

interface A
{
    void x();
}

interface B extends A
{
    void y();
    void z();
}

abstract class K implements B
{
    public void y()
    {
        System.out.println("Implementasi dari B.y()");
    }
}

class MyImplementation02 extends K
{
    public void x()
    {
        System.out.println("Implementasi dari A.x()");
    }
   
    public void z()
    {
        System.out.println("Implementasi dari B.z()");
    }
   
    public static void main(String[] args)
    {
        MyImplementation02 myI = new MyImplementation02();
        myI.x();
        myI.y();
        myI.z();
    }
}
Program di atas akan menghasilkan :
Implementasi dari A.x()
Implementasi dari B.y()
Implementasi dari B.z()

Post di
Label: ,

No comments:

Post a Comment

Subscribe to: Post Comments (Atom)