Kaedah lalai dalam antara muka

Setiap versi Java baharu berbeza daripada versi sebelumnya. Berikut ialah contoh perubahan dalam bahan yang telah kami bincangkan: sebelum Java 5, bahasa itu tidak mempunyai enums. Begitu juga, Java 8 berbeza dengan ketara daripada Java 7. Kebanyakan pelajaran kami ditulis untuk versi ke-7 bahasa, tetapi sudah tentu kami tidak akan mengabaikan inovasi penting. Memandangkan kita sudah bercakap tentang antara muka dalam pelajaran ini, kami akan mempertimbangkan satu kemas kini — kaedah lalai dalam antara muka . Anda sudah tahu bahawa antara muka tidak melaksanakan tingkah laku . Tugasnya adalah untuk menerangkan tingkah laku yang mesti ada pada semua objek yang melaksanakannya. Tetapi pembangun sering menghadapi situasi di mana pelaksanaan kaedah adalah sama dalam semua kelas. Mari kita pertimbangkan contoh kereta lama kami:

public interface Car {

   public void gas();

   public void brake();
}
public class Sedan implements Car {

   @Override
   public void gas() {
       System.out.println("Gas!");
   }

   @Override
   public void brake() {
       System.out.println("Brake!");
   }
}


public class Truck implements Car {

   @Override
   public void gas() {
       System.out.println("Gas!");
   }

   @Override
   public void brake() {
       System.out.println("Brake!");
   }
}


public class F1Car implements Car {
   @Override
   public void gas() {
       System.out.println("Gas!");
   }

   @Override
   public void brake() {
       System.out.println("Brake!");
   }
}

"Pada pendapat anda, apakah masalah utama dengan kod ini? Anda mungkin perasan bahawa kami telah menulis sekumpulan kod berulang! Masalah ini adalah perkara biasa dalam pengaturcaraan, dan anda perlu mengelakkannya. Ini satu lagi perkara bahawa penyelesaian tertentu tidak wujud sebelum ini. Java 8 telah dikeluarkan. Dengan versi ini terdapat keupayaan untuk menentukan kaedah lalai dan melaksanakannya terus di dalam antara muka! Begini cara anda melakukannya:

public interface Car {

   public default void gas() {
       System.out.println("Gas!");
   }

   public default void brake() {
       System.out.println("Brake!");
   }
}

public class Sedan implements Car {

}

public class Truck implements Car {

}

public class F1Car implements Car {

}

Kini kaedah gas()dan brake(), yang sama untuk semua kereta, telah dialihkan ke antara muka. Tiada kod berulang diperlukan. Lebih-lebih lagi, kaedahnya tersedia di setiap kelas!

public class Main {

   public static void main(String[] args) {

       F1Car f1Car = new F1Car();
       Sedan sedan = new Sedan();
       Truck truck = new Truck();
       truck.gas();
       sedan.gas();
       f1Car.brake();
   }
}

Bagaimana jika terdapat 100 kelas dengan gas()kaedah itu, tetapi hanya 99 daripadanya mempunyai tingkah laku yang sama? Adakah itu merosakkan segala-galanya dan menjadikan kaedah lalai tidak sesuai untuk situasi ini? Sudah tentu, tidak :) Kaedah lalai dalam antara muka boleh diganti dengan cara yang sama seperti kaedah biasa.

public class UnusualCar implements Car {
   @Override
   public void gas() {
       System.out.println("This car accelerates differently!");
   }

   @Override
   public void brake() {
       System.out.println("This car decelerates differently!");
   }
}

Kesemua 99 jenis kereta lain akan melaksanakan kaedah lalai, danUnusualCarkelas, yang merupakan pengecualian, tidak akan merosakkan gambaran keseluruhan dan dengan tenang menentukan tingkah lakunya sendiri. Warisan berbilang antara muka. Seperti yang anda sedia maklum, Java tidak menyokong pelbagai warisan. Terdapat banyak sebab untuk ini. Kami akan melihatnya secara terperinci dalam pelajaran yang berasingan. Bahasa lain, seperti C++, menyokongnya. Tanpa pewarisan berbilang, masalah serius timbul: satu objek boleh mempunyai beberapa ciri dan 'tingkah laku' yang berbeza. Berikut adalah contoh dari kehidupan: kita adalah anak kepada ibu bapa kita, pelajar kepada guru kita, dan pesakit kepada doktor kita. Dalam kehidupan, kita mengambil peranan yang berbeza dan, oleh itu, berkelakuan secara berbeza: jelas sekali, kita tidak akan bercakap dengan guru dengan cara yang sama kita bercakap dengan rakan rapat kita. Mari cuba menterjemah ini ke dalam kod. Bayangkan kita mempunyai dua kelas: Kolam dan Aviary. Untuk kolam, kita memerlukan unggas air; untuk kandang burung, kita memerlukan burung terbang. Untuk melakukan ini, kami telah mencipta dua kelas asas:FlyingBirddan Waterfowl.

public class Waterfowl {
}

public class FlyingBird {
}

Sehubungan itu, kami akan menghantar burung yang kelasnya diwarisi FlyingBirdke kandang burung, dan kami akan menghantar burung yang mewarisi Waterfowlke kolam. Semuanya nampak sangat mudah. Tetapi di mana kita menghantar itik? Ia berenang dan terbang. Dan kami tidak mempunyai banyak warisan. Nasib baik, Java menyokong pelbagai pelaksanaan antara muka. Walaupun kelas tidak boleh mewarisi beberapa ibu bapa, ia boleh melaksanakan beberapa antara muka dengan mudah! Itik kita boleh menjadi burung terbang dan unggas air :) Kita hanya perlu membuat FlyingBirddan Waterfowlantara muka dan bukannya kelas untuk mencapai hasil yang diinginkan.

public class Duck implements FlyingBird, Waterfowl {

   // The methods of both interfaces can be easily combined into one class

   @Override
   public void fly() {
       System.out.println("Fly!");
   }

   @Override
   public void swim() {

       System.out.println("Swim!");
   }
}

Sehubungan itu, program kami mengekalkan fleksibiliti kelas, dan, dalam kombinasi dengan kaedah lalai, keupayaan kami untuk menentukan tingkah laku objek menjadi hampir tidak terhad! :)