Java - Method Default di atas Interfaces

Hai di sana, penyihir Java masa depan! Hari ini, kita akan melakukan perjalanan yang menarik ke atas dunia method default Java. Jangan khawatir jika kamu baru mengenal pemrograman; saya akan menjadi pemandu kamu yang mesra, dan kita akan menjelajahi konsep ini bersama-sama langkah demi langkah. Jadi, pegang kayu penyihir virtual kamu (atau papan tombol), dan mari kita melompat masuk!

Apa itu Method Default?

Bayangkan jika kamu adalah sebahagian dari keluarga besar (kita panggilnya keluarga Interface), dan kamu selalu memiliki satu set peraturan yang semua anggota ikuti. Tetapi tiba-tiba, kamu menyadari kamu perlu satu peraturan baru, dan kamu tidak mahu untuk memaksa semua anggota keluarga kamu untuk melaksanakannya segera. Itu tempat method default datang untuk penyelamat!

Dalam istilah Java, method default membolehkan kamu untuk menambah method baru ke atas interfaces tanpa menghentikan kelas yang melaksanakan interfaces ini. Itu seperti menambah satu peraturan baru ke atas keluarga kamu, tetapi memberikan setiap orang cara default untuk mengikutinya jika mereka tidak mahu untuk membuat cara mereka sendiri.

Sintaks

Berikut adalah cara kamu mendeklarasikan satu method default:

public interface MyInterface {
default void myDefaultMethod() {
System.out.println("Ini adalah method default");
}
}

Perhatikan kata kunci default sebelum deklarasi method. Itu seperti mengatakan, "Hai, jika kamu tidak punya cara kamu sendiri untuk melakukan ini, di sini ada cara default untuk kamu!"

Contoh Method Default Java

Mari kita lihat contoh yang lebih konkret. Bayangkan jika kita membuat permainan sederhana di mana karakter berbeda dapat melakukan tindakan.

public interface Character {
void move();

default void speak() {
System.out.println("Halo, saya adalah karakter dalam permainan ini!");
}
}

public class Hero implements Character {
@Override
public void move() {
System.out.println("Hero bergerak cepat");
}
}

public class Villain implements Character {
@Override
public void move() {
System.out.println("Villain menyelinap");
}

@Override
public void speak() {
System.out.println("Saya adalah penjahat! Takutkan saya!");
}
}

public class GameDemo {
public static void main(String[] args) {
Character hero = new Hero();
Character villain = new Villain();

hero.move();    // Output: Hero bergerak cepat
hero.speak();   // Output: Halo, saya adalah karakter dalam permainan ini!

villain.move(); // Output: Villain menyelinap
villain.speak(); // Output: Saya adalah penjahat! Takutkan saya!
}
}

Dalam contoh ini, kita memiliki satu Character interface dengan method default speak(). Kelas Hero menggunakan implementasi default, sementara kelas Villain menimpa itu. Itu seperti memberikan karakter baris default, tetapi membolehkan penjahat untuk memiliki dialog dramatik mereka sendiri!

Method Default dalam Warisannya Berbilang

Sekarang, mari kita tambahkan sedikit rempah. Apa yang terjadi jika satu kelas melaksanakan interface berbilang yang memiliki method default dengan nama yang sama? Itu seperti memiliki dua anggota keluarga yang memberikan kamu nasihat berbeda tentang cara melakukan sesuatu!

public interface Flyer {
default void takeOff() {
System.out.println("Flyer sedang meluncur");
}
}

public interface Spaceship {
default void takeOff() {
System.out.println("Spaceship sedang meluncur");
}
}

public class FlyingSpaceship implements Flyer, Spaceship {
// Kita mesti timpa method takeOff untuk mengurai konflik
@Override
public void takeOff() {
Flyer.super.takeOff(); // Memanggil method takeOff Flyer
Spaceship.super.takeOff(); // Memanggil method takeOff Spaceship
}
}

public class SpaceDemo {
public static void main(String[] args) {
FlyingSpaceship ship = new FlyingSpaceship();
ship.takeOff();
}
}

Dalam kasus ini, FlyingSpaceship mesti timpa method takeOff() untuk mengurai konflik. Itu seperti menjadi diplomat di keluarga dan menemukan cara untuk mengikuti kedua nasihat!

Method Default Statik di atas Java

Tahan atas topi kamu, karena di sini adalah_plot twist: Java tidak membolehkan method default statik di atas interfaces! Tetapi jangan khawatir, ada alasan yang baik untuk ini. Method statik milik interface itu sendiri, bukan objek yang melaksanakan interface.

Walau bagaimanapun, Java 8 memperkenalkan method statik di atas interfaces. Mari kita lihat bagaimana mereka bekerja:

public interface MathOperations {
static int add(int a, int b) {
return a + b;
}

default int subtract(int a, int b) {
return a - b;
}
}

public class Calculator implements MathOperations {
// Tidak perlu untuk melaksanakan method statik
}

public class MathDemo {
public static void main(String[] args) {
Calculator calc = new Calculator();

System.out.println("5 + 3 = " + MathOperations.add(5, 3)); // Method statik dipanggil di atas interface
System.out.println("5 - 3 = " + calc.subtract(5, 3)); // Method default dipanggil di atas objek
}
}

Di sini, add() adalah method statik yang milik MathOperations interface, sementara subtract() adalah method default yang dapat digunakan oleh mana-mana kelas yang melaksanakan interface.

Kesimpulan

Dan itu adalah, penyiswa Java tercinta! Kita telah melakukan perjalanan melalui wilayah method default, menjelajahi skenario warisannya berbilang, dan bahkan menyentuh method statik di atas interfaces. Method default adalah seperti rakit penyihir di atas toolkit Java kamu – mereka membantu kamu menambah fungsi baru ke atas interfaces tanpa menghentikan implementasi yang ada.

Ingat, dengan kuasa yang besar datang tanggung jawab yang besar. Gunakan method default dengan bijak untuk mengembangkan interfaces kamu sambil menjaga keseimbangan ke belakang. Happy coding, dan semoga pengalaman Java kamu bebas dari bug dan penuh dengan sihir method default!

Credits: Image by storyset