Masukkan Password

50 Memperluas Interface

Akhlis 02 September 2026

8 Min Read

Inti lecture ini adalah bagaimana sebuah class bisa mengimplementasikan beberapa interface, dan bagaimana sebuah interface bisa mewarisi (extend) beberapa interface lain.

Saya jelaskan dari konsep paling dasar supaya alurnya mudah dipahami.

1. Apa itu interface?

Interface bisa kita anggap sebagai kontrak atau aturan yang harus dipenuhi oleh sebuah class.

Misalnya kita punya interface User:

interface User {
    getUser(): string;
    getFullName(): string;
}

Artinya:

“Setiap class yang mengimplementasikan User wajib menyediakan getUser() dan getFullName().”

Interface biasanya menentukan apa yang harus dimiliki, bukan bagaimana cara kerjanya.

Contohnya:

interface User {
    getUser(): string;
}

Interface hanya mengatakan bahwa getUser() harus ada.

Implementasinya ditentukan oleh class:

class Admin implements User {
    getUser(): string {
        return "Admin User";
    }
}

2. Sebuah class bisa `implements` lebih dari satu interface

Ini adalah poin pertama yang dibahas dalam lecture.

Misalnya kita mempunyai dua interface:

interface User {
    getUser(): string;
    getFullName(): string;
}

interface Roles {
    getRole(): string;
}

Sekarang kita memiliki class Admin.

Awalnya:

class Admin implements User {
    // ...
}

Artinya Admin hanya mengikuti kontrak dari User.

Tetapi kita juga ingin Admin memiliki kontrak dari Roles.

Kita bisa menulis:

class Admin implements User, Roles {
    // ...
}

Perhatikan:

implements User, Roles
                 ↑
             pakai koma

Jadi:

Satu class bisa mengimplementasikan banyak interface.

3. Kalau implements banyak interface, semua harus dipenuhi

Misalnya:

interface User {
    getUser(): string;
    getFullName(): string;
}

interface Roles {
    getRole(): string;
}

Kemudian:

class Admin implements User, Roles {
    
}

Ini akan menghasilkan error.

Kenapa?

Karena Admin sekarang mempunyai dua kontrak:

User
 ├── getUser()
 └── getFullName()

Roles
 └── getRole()

Jadi Admin harus menyediakan semua method tersebut.

Contohnya:

class Admin implements User, Roles {

    getUser(): string {
        return "admin";
    }

    getFullName(): string {
        return "John Doe";
    }

    getRole(): string {
        return "admin";
    }
}

Sekarang tidak ada masalah karena semua method sudah diimplementasikan.

4. Bisa lebih dari dua interface?

Bisa.

Misalnya kita mempunyai:

interface User {
    getUser(): string;
}

interface Roles {
    getRole(): string;
}

interface Permissions {
    getPermissions(): string;
}

Class bisa melakukan:

class Admin implements User, Roles, Permissions {
    
    getUser(): string {
        return "admin";
    }

    getRole(): string {
        return "admin";
    }

    getPermissions(): string {
        return "all";
    }
}

Jadi secara konsep:

             User
              │
              │
Roles ────── Admin ────── Permissions

Admin harus memenuhi kontrak dari ketiganya.

5. Bagaimana dengan class `Member`?

Misalnya kita mempunyai:

class Member implements User {
    // implementasi User
}

Karena Member hanya menggunakan:

implements User

maka Member hanya wajib memenuhi aturan dari User.

Dia tidak wajib mempunyai getRole() dari Roles.

Tetapi kalau kita ubah menjadi:

class Member implements User, Roles {
    
}

maka sekarang Member juga wajib mempunyai:

getRole()

Jadi gampangnya:

Semakin banyak interface yang di-implements, semakin banyak kontrak yang harus dipenuhi oleh class tersebut.

6. Sekarang masuk ke konsep kedua: interface bisa `extends` interface lain

Ini berbeda dengan class yang implements interface.

Misalnya:

interface Roles {
    getRole(): string;
}

Kemudian kita mempunyai:

interface User {
    getUser(): string;
    getFullName(): string;
}

Sekarang kita ingin mengatakan:

User juga mempunyai semua aturan yang ada di Roles.

Kita bisa menulis:

interface User extends Roles {
    getUser(): string;
    getFullName(): string;
}

Perhatikan keyword-nya:

interface User extends Roles

Bukan:

interface User implements Roles

Untuk interface yang mewarisi interface lain, kita menggunakan:

extends

7. Apa yang terjadi setelah `User extends Roles`?

Sebelumnya:

interface User {
    getUser(): string;
    getFullName(): string;
}

User hanya mempunyai:

User
├── getUser()
└── getFullName()

Kemudian kita lakukan:

interface User extends Roles {
    getUser(): string;
    getFullName(): string;
}

Sedangkan Roles mempunyai:

interface Roles {
    getRole(): string;
}

Sekarang secara konsep User mempunyai:

User
├── getUser()
├── getFullName()
└── getRole()       ← berasal dari Roles

Jadi walaupun getRole() tidak ditulis langsung di dalam User, method tersebut tetap menjadi bagian dari kontrak User karena User mewarisi Roles.

8. Dampaknya terhadap class

Ini bagian yang sangat penting.

Misalnya:

interface Roles {
    getRole(): string;
}

interface User extends Roles {
    getUser(): string;
    getFullName(): string;
}

Kemudian:

class Admin implements User {
    
}

Banyak pemula mungkin berpikir:

“Admin cuma implements User, berarti cukup membuat getUser() dan getFullName().”

Tidak.

Karena:

User
  │
  └── extends Roles
            │
            └── getRole()

Maka User sebenarnya membawa kontrak dari Roles.

Akibatnya Admin harus mempunyai:

class Admin implements User {

    getUser(): string {
        return "admin";
    }

    getFullName(): string {
        return "John Doe";
    }

    getRole(): string {
        return "admin";
    }
}

9. Analogi sederhana

Bayangkan interface adalah sertifikat/kontrak pekerjaan.

Roles mengatakan:

“Orang yang mengikuti kontrak ini harus bisa menunjukkan role-nya.”

interface Roles {
    getRole(): string;
}

Kemudian User mengatakan:

“Saya punya semua aturan dari Roles, ditambah aturan saya sendiri.”

interface User extends Roles {
    getUser(): string;
    getFullName(): string;
}

Maka orang yang memenuhi kontrak User harus bisa:

User
├── getUser()
├── getFullName()
└── getRole()

10. Kenapa pada awalnya `Admin implements User, Roles`?

Di bagian awal lecture, bentuknya kira-kira:

interface User {
    getUser(): string;
    getFullName(): string;
}

interface Roles {
    getRole(): string;
}

class Admin implements User, Roles {
    // ...
}

Ini berarti:

Admin
 ├── implements User
 │      ├── getUser()
 │      └── getFullName()
 │
 └── implements Roles
        └── getRole()

Admin secara langsung mengatakan:

“Saya mengikuti kontrak User DAN Roles.”

11. Kemudian dibuat lebih sederhana dengan `extends`

Lecture kemudian mengubah desainnya menjadi:

interface Roles {
    getRole(): string;
}

interface User extends Roles {
    getUser(): string;
    getFullName(): string;
}

Lalu:

class Admin implements User {
    // ...
}

Sekarang Admin tidak perlu menulis:

implements User, Roles

Cukup:

implements User

Karena:

Admin
  │
  │ implements
  ▼
 User
  │
  │ extends
  ▼
Roles

Sehingga Admin tetap wajib mengimplementasikan getRole().

12. Kenapa ini berguna?

Misalnya kita mempunyai banyak class:

class Admin implements User
class Member implements User
class Guest implements User
class Moderator implements User

Kalau User memiliki:

interface User extends Roles {
    getUser(): string;
    getFullName(): string;
}

Maka semua class tersebut otomatis harus memenuhi Roles.

Jadi kita tidak perlu menulis:

class Admin implements User, Roles
class Member implements User, Roles
class Guest implements User, Roles
class Moderator implements User, Roles

Cukup:

class Admin implements User
class Member implements User
class Guest implements User
class Moderator implements User

Karena Roles sudah menjadi bagian dari User.

Ini membuat struktur kode lebih terorganisir.

13. Interface juga bisa extends banyak interface

Ini juga dibahas dalam lecture.

Misalnya:

interface Roles {
    getRole(): string;
}

interface Permissions {
    getPermissions(): string;
}

interface Profile {
    getProfile(): string;
}

Kita bisa membuat:

interface User extends Roles, Permissions, Profile {
    getUser(): string;
    getFullName(): string;
}

Sekarang User mendapatkan semua kontrak:

                    ┌── Roles
                    │    └── getRole()
                    │
User ───────────────┼── Permissions
                    │    └── getPermissions()
                    │
                    ├── Profile
                    │    └── getProfile()
                    │
                    ├── getUser()
                    └── getFullName()

Jadi class:

class Admin implements User {
    // ...
}

harus menyediakan semua:

getRole()
getPermissions()
getProfile()
getUser()
getFullName()

14. Bedakan `extends` dan `implements`

Ini bagian paling penting dari lecture.

`class implements interface`

Contoh:

class Admin implements User {
}

Artinya:

Class Admin berjanji untuk memenuhi kontrak User.

`interface extends interface`

Contoh:

interface User extends Roles {
}

Artinya:

Interface User mewarisi/menambahkan kontrak dari Roles.

Secara sederhana:

Situasi	Keyword
Class → Interface	`implements`
Interface → Interface	`extends`
Class → Class	`extends`

15. Class bisa extend berapa class?

Hanya satu.

Misalnya:

class Animal {
}

Kemudian:

class Dog extends Animal {
}

Ini boleh.

Tetapi:

class Dog extends Animal, Mammal {
}

❌ Tidak boleh.

Sebuah class tidak bisa melakukan multiple inheritance terhadap class.

16. Tapi class bisa implements banyak interface

Ini boleh:

class Admin implements User, Roles, Permissions {
}

Jadi:

CLASS
  │
  ├── extends → hanya 1 class
  │
  └── implements → bisa banyak interface

Contohnya:

class Admin extends Employee implements User, Roles, Permissions {
}

Ini valid secara konsep:

              Employee
                  │
                extends
                  │
                  ▼
                Admin
              /   |   \
             /    |    \
        implements implements implements
          /        |        \
       User      Roles    Permissions

17. Interface bisa extends banyak interface

Kebalikannya, interface juga bisa mempunyai banyak parent interface.

Contoh:

interface A {
    methodA(): void;
}

interface B {
    methodB(): void;
}

interface C {
    methodC(): void;
}

interface D extends A, B, C {
}

Maka D secara konsep memiliki:

D
├── methodA()  ← dari A
├── methodB()  ← dari B
└── methodC()  ← dari C

Class yang melakukan:

class MyClass implements D {
}

harus mengimplementasikan semuanya.

18. Gambaran keseluruhan lecture

Kalau diringkas, struktur yang dibahas adalah seperti ini:

                 ┌──────────────┐
                 │    Roles     │
                 │              │
                 │ getRole()    │
                 └──────┬───────┘
                        │
                     extends
                        │
                        ▼
                 ┌──────────────┐
                 │     User     │
                 │              │
                 │ getUser()    │
                 │ getFullName()│
                 └──────┬───────┘
                        │
                    implements
                    ┌───┴───┐
                    ▼       ▼
               ┌────────┐ ┌────────┐
               │ Admin  │ │ Member │
               └────────┘ └────────┘

Karena User extends Roles, maka:

Admin  → wajib User + Roles
Member → wajib User + Roles

19. Kesimpulan paling mudah diingat

Ada 3 aturan utama dari lecture ini:

① Class bisa implement banyak interface

class Admin implements User, Roles, Permissions

✅ Boleh.

② Interface bisa extend banyak interface

interface User extends Roles, Permissions

✅ Boleh.

③ Class hanya bisa extend satu class

class Admin extends Employee

✅ Boleh.

Tetapi:

class Admin extends Employee, Person

❌ Tidak boleh.

Cheat sheet

CLASS
│
├── extends → 1 class saja
│
└── implements → bisa banyak interface


INTERFACE
│
└── extends → bisa banyak interface

Dan hubungan implements berarti:

“Saya akan memenuhi kontrak ini.”

Sedangkan extends berarti:

“Saya mewarisi kontrak dari yang lain.”

Jadi kalimat paling penting untuk mengingat lecture ini adalah:

Class bisa implements banyak interface, interface bisa extends banyak interface, tetapi class hanya bisa extends satu class.

Kalau mau, saya juga bisa membuat diagram visual alur extends vs implements agar konsepnya lebih mudah diingat.

1. Apa itu interface?

2. Sebuah class bisa implements lebih dari satu interface

3. Kalau implements banyak interface, semua harus dipenuhi

4. Bisa lebih dari dua interface?

5. Bagaimana dengan class Member?

6. Sekarang masuk ke konsep kedua: interface bisa extends interface lain

7. Apa yang terjadi setelah User extends Roles?

8. Dampaknya terhadap class

9. Analogi sederhana

10. Kenapa pada awalnya Admin implements User, Roles?

11. Kemudian dibuat lebih sederhana dengan extends

12. Kenapa ini berguna?

13. Interface juga bisa extends banyak interface

14. Bedakan extends dan implements

class implements interface

interface extends interface

15. Class bisa extend berapa class?

16. Tapi class bisa implements banyak interface

17. Interface bisa extends banyak interface

18. Gambaran keseluruhan lecture

19. Kesimpulan paling mudah diingat

① Class bisa implement banyak interface

② Interface bisa extend banyak interface

③ Class hanya bisa extend satu class

Cheat sheet

2. Sebuah class bisa `implements` lebih dari satu interface

5. Bagaimana dengan class `Member`?

6. Sekarang masuk ke konsep kedua: interface bisa `extends` interface lain

7. Apa yang terjadi setelah `User extends Roles`?

10. Kenapa pada awalnya `Admin implements User, Roles`?

11. Kemudian dibuat lebih sederhana dengan `extends`

14. Bedakan `extends` dan `implements`

`class implements interface`

`interface extends interface`