Antarmuka di Java

Halo! Hari ini kita akan berbicara tentang konsep penting dalam Java - antarmuka. Kata tersebut mungkin sudah tidak asing lagi bagi Anda. Misalnya, sebagian besar program komputer dan permainan memiliki antarmuka. Dalam arti luas, antarmuka adalah semacam “pengendali jarak jauh” yang menghubungkan dua pihak yang berinteraksi satu sama lain. Contoh sederhana antarmuka dari kehidupan sehari-hari adalah remote control TV. Ini menghubungkan dua objek, seseorang dan TV, dan melakukan tugas yang berbeda: menaikkan atau menurunkan volume, mengganti saluran, menghidupkan atau mematikan TV. Satu sisi (orang) perlu mengakses antarmuka (tekan tombol remote control) agar sisi lain dapat melakukan tindakan. Misalnya saja agar TV berpindah saluran ke saluran berikutnya. Dalam hal ini, pengguna tidak perlu mengetahui perangkat TV dan bagaimana proses penggantian saluran diterapkan di dalamnya. Yang dapat diakses pengguna hanyalah antarmuka . Tugas utamanya adalah mendapatkan hasil yang diinginkan. Apa hubungannya ini dengan pemrograman dan Java? Langsung :) Membuat antarmuka sangat mirip dengan membuat kelas biasa, hanya saja sebagai ganti kata classkita menentukan kata interface. Mari kita lihat antarmuka Java yang paling sederhana dan mencari tahu cara kerjanya dan untuk apa:

public interface Swimmable  {

     public void swim();
}

Kami membuat antarmuka Swimmableyang bisa berenang . Ini seperti remote control kita, yang memiliki satu “tombol”: metodenya swim() adalah “berenang”. Bagaimana kita bisa menggunakan “ remote control ” ini? Untuk tujuan ini metodenya, yaitu. tombol pada remote control kami perlu diterapkan. Untuk menggunakan antarmuka, metodenya harus diimplementasikan oleh beberapa kelas program kita. Mari kita buat kelas yang objeknya sesuai dengan deskripsi “bisa berenang.” Misalnya kelas bebek yang cocok Duck:

public class Duck implements Swimmable {

    public void swim() {
        System.out.println("Duck, swim!");
    }

    public static void main(String[] args) {

        Duck duck = new Duck();
        duck.swim();
    }
}

Apa yang kita lihat di sini? Sebuah kelas Duckdikaitkan dengan antarmuka Swimmablemenggunakan kata kunci implements. Jika Anda ingat, kami menggunakan mekanisme serupa untuk menghubungkan dua kelas dalam warisan, hanya saja ada kata “ extends ”. “ public class Duck implements Swimmable” dapat diterjemahkan secara harfiah untuk kejelasan: “kelas publik Duckmengimplementasikan antarmuka Swimmable.” Ini berarti bahwa kelas yang terkait dengan antarmuka harus mengimplementasikan semua metodenya. Harap diperhatikan: di kelas kita, Duckseperti di antarmuka , Swimmableada metode swim(), dan di dalamnya ada semacam logika. Ini adalah persyaratan wajib. Jika kita hanya menulis “ public class Duck implements Swimmable” dan tidak membuat metode swim()di kelas Duck, kompiler akan memberi kita kesalahan: Duck is not abstract and do not override abstract method swim() in Swimmable Mengapa hal ini terjadi? Jika kita jelaskan errornya dengan menggunakan contoh TV, ternyata kita memberikan remote control kepada seseorang dengan tombol “ganti saluran” dari TV yang tidak bisa mengganti saluran. Pada titik ini, tekan tombol sebanyak yang Anda suka, tidak ada yang berhasil. Remote control itu sendiri tidak mengubah saluran: ia hanya memberikan sinyal ke TV, di dalamnya diterapkan proses kompleks untuk mengubah saluran. Begitu pula dengan bebek kita: ia harus bisa berenang agar bisa diakses menggunakan antarmuka Swimmable. Jika dia tidak tahu cara melakukan ini, antarmuka Swimmabletidak akan menghubungkan kedua sisi - orang dan program. Seseorang tidak akan bisa menggunakan metode swim()untuk membuat objek Duckdi dalam program melayang. Sekarang Anda telah melihat dengan lebih jelas apa gunanya antarmuka. Antarmuka mendeskripsikan perilaku yang harus dimiliki oleh kelas yang mengimplementasikan antarmuka tersebut. “Perilaku” adalah kumpulan metode. Jika kita ingin membuat banyak messenger, cara termudah untuk melakukannya adalah dengan membuat antarmuka Messenger. Apa yang harus bisa dilakukan oleh utusan mana pun? Dalam bentuk yang disederhanakan, terima dan kirim pesan.

public interface Messenger{

     public void sendMessage();

     public void getMessage();
}

Dan sekarang kita cukup membuat kelas messenger dengan mengimplementasikan antarmuka ini. Kompiler itu sendiri akan “memaksa” kita untuk mengimplementasikannya di dalam kelas. Telegram:

public class Telegram implements Messenger {

    public void sendMessage() {

        System.out.println("Sending a message to Telegram!");
    }

     public void getMessage() {
         System.out.println("Reading the message in Telegram!");
     }
}

Ada apa:

public class WhatsApp implements Messenger {

    public void sendMessage() {

        System.out.println("Sending a WhatsApp message!");
    }

     public void getMessage() {
         System.out.println("Reading a WhatsApp message!");
     }
}

getaran:

public class Viber implements Messenger {

    public void sendMessage() {

        System.out.println("Sending a message to Viber!");
    }

     public void getMessage() {
         System.out.println("Reading a message in Viber!");
     }
}

Manfaat apa yang diberikan hal ini? Yang paling penting adalah kopling longgar. Bayangkan kita sedang merancang sebuah program di mana kita akan mengumpulkan data pelanggan. Kelas Clientharus memiliki bidang yang menunjukkan messenger mana yang digunakan klien. Tanpa antarmuka, ini akan terlihat aneh:

public class Client {

    private WhatsApp whatsApp;
    private Telegram telegram;
    private Viber viber;
}

Kami membuat tiga bidang, namun klien dapat dengan mudah hanya memiliki satu messenger. Kami hanya tidak tahu yang mana. Dan agar tidak dibiarkan tanpa komunikasi dengan klien, Anda harus “mendorong” semua opsi yang memungkinkan ke dalam kelas. Ternyata satu atau dua di antaranya akan selalu ada null, dan tidak diperlukan sama sekali agar program dapat berjalan. Sebaliknya, lebih baik menggunakan antarmuka kami:

public class Client {

    private Messenger messenger;
}

Ini adalah contoh “kopling longgar”! Daripada menentukan kelas messenger tertentu di kelas tersebut Client, kami hanya menyebutkan bahwa klien memiliki messenger. Yang mana akan ditentukan selama program berlangsung. Tapi mengapa kita memerlukan antarmuka untuk ini? Mengapa mereka ditambahkan ke bahasa tersebut? Pertanyaannya baik dan benar! Hasil yang sama bisa dicapai dengan menggunakan warisan biasa, bukan? Kelas tersebut Messengeradalah kelas induk, dan Viber, Telegramdan WhatsAppmerupakan ahli warisnya. Memang, hal itu mungkin dilakukan. Tapi ada satu kendala. Seperti yang sudah Anda ketahui, tidak ada pewarisan berganda di Java. Namun ada banyak implementasi antarmuka. Sebuah kelas dapat mengimplementasikan antarmuka sebanyak yang diinginkannya. Bayangkan kita mempunyai sebuah kelas Smartphoneyang mempunyai field Application- aplikasi yang terinstal di smartphone.

public class Smartphone {

    private Application application;
}

Aplikasi dan messenger tentu saja serupa, tetapi tetap saja berbeda. Messenger dapat berupa seluler dan desktop, sedangkan Aplikasi adalah aplikasi seluler. Jadi, jika kita menggunakan warisan, kita tidak akan bisa menambahkan objek Telegramke kelas tersebut Smartphone. Lagi pula, suatu kelas Telegramtidak dapat mewarisi dari Applicationdan dari Messenger! Dan kita telah berhasil mewarisinya Messenger, dan menambahkannya ke kelas dalam bentuk ini Client. Tapi sebuah kelas Telegramdapat dengan mudah mengimplementasikan kedua antarmuka! Oleh karena itu, di kelas Clientkita bisa mengimplementasikan objek Telegramsebagai Messenger, dan di kelas Smartphonesebagai Application. Begini cara melakukannya:

public class Telegram implements Application, Messenger {

    //...methods
}

public class Client {

    private Messenger messenger;

    public Client() {
        this.messenger = new Telegram();
    }
}


public class Smartphone {

    private Application application;

    public Smartphone() {
        this.application = new Telegram();
    }
}

Sekarang kita bisa menggunakan kelas Telegramsesuka kita. Di suatu tempat dia akan berperan sebagai Application, di suatu tempat dalam peran Messenger. Anda mungkin telah memperhatikan bahwa metode dalam antarmuka selalu "kosong", artinya tidak ada implementasi. Alasannya sederhana: antarmuka mendeskripsikan perilaku, bukan mengimplementasikannya. “Semua objek kelas yang mengimplementasikan antarmuka Swimmableharus dapat mengapung”: hanya itu yang diberitahukan oleh antarmuka kepada kita. Bagaimana tepatnya ikan, bebek atau kuda akan berenang, ada pertanyaan untuk kelas Fish, Duckdan Horse, dan bukan untuk antarmuka. Ibarat mengganti saluran adalah tugas sebuah TV. Remote hanya memberi Anda tombol untuk melakukannya. Namun, Java8 memiliki tambahan yang menarik - metode default. Misalnya, antarmuka Anda memiliki 10 metode. 9 di antaranya diimplementasikan secara berbeda di kelas yang berbeda, tetapi satu diimplementasikan sama di semua kelas. Sebelumnya, sebelum Java8 dirilis, metode di dalam antarmuka tidak memiliki implementasi sama sekali: kompiler langsung memberikan kesalahan. Sekarang Anda dapat melakukannya seperti ini:

public interface Swimmable {

   public default void swim() {
       System.out.println("Swim!");
   }

   public void eat();

   public void run();
}

Dengan menggunakan kata kunci default, kami telah membuat metode di antarmuka dengan implementasi default. Kita perlu mengimplementasikan dua metode lainnya, eat()dan run(), diri kita sendiri di semua kelas yang akan mengimplementasikan Swimmable. Tidak perlu melakukan ini dengan metode ini swim(): implementasinya akan sama di semua kelas. Omong-omong, Anda telah menemukan antarmuka lebih dari sekali dalam tugas sebelumnya, meskipun Anda sendiri tidak menyadarinya :) Berikut adalah contoh nyata: Anda bekerja dengan antarmuka Listdan Set! Lebih tepatnya, dengan implementasinya - ArrayList, LinkedList, HashSetdan lain-lain. Diagram yang sama menunjukkan contoh ketika satu kelas mengimplementasikan beberapa antarmuka sekaligus. Misalnya, LinkedListia mengimplementasikan antarmuka Listdan Deque(antrian dua sisi). Anda juga familiar dengan antarmukanya Map, atau lebih tepatnya, dengan implementasinya - HashMap. Omong-omong, dalam diagram ini Anda dapat melihat satu fitur: antarmuka dapat diwarisi satu sama lain. Antarmuka SortedMapdiwarisi dari Map, dan Dequediwarisi dari antrian Queue. Ini diperlukan jika Anda ingin menunjukkan hubungan antar antarmuka, tetapi satu antarmuka merupakan versi lanjutan dari antarmuka lainnya. Mari kita lihat contoh antarmuka Queue- antrian. Kami belum melihat koleksinya Queue, tapi cukup sederhana dan ditata seperti antrean biasa di toko. Anda dapat menambahkan elemen hanya di akhir antrean, dan menghapusnya hanya dari awal. Pada tahap tertentu, pengembang memerlukan versi antrian yang diperluas sehingga elemen dapat ditambahkan dan diterima dari kedua sisi. Beginilah cara antarmuka dibuat Deque- antrian dua arah. Ini berisi semua metode antrian reguler karena merupakan "induk" dari antrian dua arah, tetapi metode baru telah ditambahkan.