Antarmuka Java

1. Ikhtisar

Dalam tutorial ini, kita akan berbicara tentang antarmuka di Java. Kita juga akan melihat bagaimana Java menggunakannya untuk mengimplementasikan polimorfisme dan banyak warisan.

2. Apakah Antarmuka di Java?

Di Java, antarmuka adalah tipe abstrak yang berisi kumpulan metode dan variabel konstan. Ini adalah salah satu konsep inti di Java dan digunakan untuk mencapai abstraksi, polimorfisme, dan beberapa pewarisan .

Mari kita lihat contoh sederhana antarmuka di Java:

public interface Electronic { // Constant variable String LED = "LED"; // Abstract method int getElectricityUse(); // Static method static boolean isEnergyEfficient(String electtronicType) { if (electtronicType.equals(LED)) { return true; } return false; } //Default method default void printDescription() { System.out.println("Electronic Description"); } } 

Kita dapat mengimplementasikan antarmuka dalam kelas Java dengan menggunakan kata kunci implements .

Selanjutnya, mari kita juga membuat kelas Komputer yang mengimplementasikan antarmuka Elektronik yang baru saja kita buat:

public class Computer implements Electronic { @Override public int getElectricityUse() { return 1000; } } 

2.1. Aturan untuk Membuat Antarmuka

Dalam sebuah antarmuka, kami diizinkan untuk menggunakan:

  • variabel konstanta
  • metode abstrak
  • metode statis
  • metode default

Kita juga harus ingat bahwa:

  • kita tidak dapat membuat contoh antarmuka secara langsung
  • sebuah antarmuka bisa kosong, tanpa metode atau variabel di dalamnya
  • kita tidak dapat menggunakan kata terakhir dalam definisi antarmuka, karena akan mengakibatkan kesalahan kompilator
  • semua deklarasi antarmuka harus memiliki pengubah akses publik atau default; yang abstrak pengubah akan ditambahkan secara otomatis oleh compiler
  • metode antarmuka tidak boleh pribadi , dilindungi , atau final
  • variabel antarmuka adalah publik , statis , dan final menurut definisi; kami tidak diizinkan untuk mengubah visibilitas mereka

3. Apa yang Dapat Kita Raih dengan Menggunakannya?

3.1. Fungsi Perilaku

Kami menggunakan antarmuka untuk menambahkan fungsionalitas perilaku tertentu yang dapat digunakan oleh kelas yang tidak terkait. Misalnya, Comparable , Comparator , dan Cloneable adalah antarmuka Java yang dapat diimplementasikan oleh kelas yang tidak terkait. Di bawah ini adalah contoh antarmuka Comparatoryang digunakan untuk membandingkan dua contoh kelas Karyawan :

public class Employee { private double salary; public double getSalary() { return salary; } public void setSalary(double salary) { this.salary = salary; } } public class EmployeeSalaryComparator implements Comparator { @Override public int compare(Employee employeeA, Employee employeeB) { if (employeeA.getSalary()  employeeB.getSalary()) { return 1; } else { return 0; } } } 

Untuk informasi lebih lanjut, silakan kunjungi tutorial kami di Comparator and Comparable in Java.

3.2. Beberapa Warisan

Kelas Java mendukung pewarisan tunggal. Namun, dengan menggunakan antarmuka, kami juga dapat menerapkan beberapa warisan.

Misalnya, pada contoh di bawah ini, kita memperhatikan bahwa class Carmengimplementasikan antarmuka Fly dan Transform . Dengan melakukan itu, ia mewarisi metode terbang dan transformasi :

public interface Transform { void transform(); } public interface Fly { void fly(); } public class Car implements Fly, Transform { @Override public void fly() { System.out.println("I can Fly!!"); } @Override public void transform() { System.out.println("I can Transform!!"); } } 

3.3. Polimorfisme

Mari kita mulai dengan mengajukan pertanyaan: apa itu polimorfisme? Ini adalah kemampuan suatu objek untuk mengambil bentuk berbeda selama runtime. Untuk lebih spesifiknya, eksekusi metode override yang terkait dengan tipe objek tertentu pada waktu proses.

Di Java, kita dapat mencapai polimorfisme menggunakan antarmuka. Misalnya, antarmuka Bentuk dapat mengambil berbagai bentuk - dapat berupa Lingkaran atau Kotak.

Mari kita mulai dengan mendefinisikan antarmuka Shape :

public interface Shape { String name(); } 

Sekarang mari juga membuat kelas Circle :

public class Circle implements Shape { @Override public String name() { return "Circle"; } } 

Dan juga kelas Square :

public class Square implements Shape { @Override public String name() { return "Square"; } } 

Terakhir, saatnya melihat polimorfisme beraksi menggunakan antarmuka Shape dan implementasinya. Mari kita membuat instance beberapa objek Shape , menambahkannya ke List , dan, terakhir, mencetak namanya dalam satu lingkaran:

List shapes = new ArrayList(); Shape circleShape = new Circle(); Shape squareShape = new Square(); shapes.add(circleShape); shapes.add(squareShape); for (Shape shape : shapes) { System.out.println(shape.name()); } 

4. Metode Default di Antarmuka

Antarmuka tradisional di Java 7 dan di bawahnya tidak menawarkan kompatibilitas ke belakang.

What this means is that if you have legacy code written in Java 7 or earlier, and you decide to add an abstract method to an existing interface, then all the classes that implement that interface must override the new abstract method. Otherwise, the code will break.

Java 8 solved this problem by introducing the default method that is optional and can be implemented at the interface level.

5. Interface Inheritance Rules

In order to achieve multiple inheritances thru interfaces, we have to remember a few rules. Let's go over these in detail.

5.1. Interface Extending Another Interface

When an interface extends another interface, it inherits all of that interface's abstract methods. Let's start by creating two interfaces, HasColor and Shape:

public interface HasColor { String getColor(); } public interface Box extends HasColor { int getHeight() } 

In the example above, Box inherits from HasColor using the keyword extends. By doing so, the Box interface inherits getColor. As a result, the Box interface now has two methods: getColor and getHeight.

5.2. Abstract Class Implementing an Interface

When an abstract class implements an interface, it inherits all of its abstract and default methods. Let's consider the Transform interface and the abstract class Vehicle that implements it:

public interface Transform { void transform(); default void printSpecs(){ System.out.println("Transform Specification"); } } public abstract class Vehicle implements Transform {} 

In this example, the Vehicle class inherits two methods: the abstract transform method and the default printSpecs method.

6. Functional Interfaces

Java has had many functional interfaces since its early days, such as Comparable (since Java 1.2) and Runnable (since Java 1.0).

Java 8 memperkenalkan antarmuka fungsional baru seperti Predikat , Konsumen , dan Fungsi . Untuk mempelajari lebih lanjut tentang ini, silakan kunjungi tutorial kami tentang Antarmuka Fungsional di Java 8.

7. Kesimpulan

Dalam tutorial ini, kami memberikan gambaran umum tentang antarmuka Java, dan kami berbicara tentang cara menggunakannya untuk mencapai polimorfisme dan beberapa pewarisan.

Seperti biasa, contoh kode lengkap tersedia di GitHub.