Kaedah Overriding dalam Java

Hai! Anda sudah menggunakan kaedah Java dan mengetahui banyak perkara tentangnya. Anda mungkin pernah menghadapi situasi di mana satu kelas mempunyai banyak kaedah dengan nama yang sama tetapi parameter yang berbeza. Anda akan ingat bahawa dalam kes tersebut kami menggunakan kaedah lebih muatan. Hari ini kita sedang mempertimbangkan situasi lain. Bayangkan bahawa kita mempunyai satu kaedah dikongsi, tetapi ia mesti melakukan perkara yang berbeza dalam kelas yang berbeza. Bagaimanakah kita melaksanakan tingkah laku ini? Untuk memahami, mari pertimbangkan kelas induk Haiwan , yang mewakili haiwan, dan kami akan mencipta kaedah bercakap di dalamnya:

public class Animal {

   public void speak() {

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

Walaupun kami baru sahaja mula menulis program, anda mungkin melihat masalah yang berpotensi: terdapat banyak haiwan di dunia, dan mereka semua 'bercakap' secara berbeza: kucing mengeong, itik berdesis dan ular mendesis. Matlamat kami adalah mudah: elakkan membuat banyak kaedah pertuturan. Daripada mencipta kaedah catSpeak() untuk mengeong, kaedah snakeSpeak() untuk mendesis, dsb., kami mahu memanggil speak()kaedah dan minta ular mendesis, kucing mengeong, dan anjing menyalak. Kita boleh mencapai ini dengan mudah menggunakan kaedah mengatasi. Wikipedia memberikan penjelasan berikut tentang istilah 'overriding': Kaedah overriding, dalam pengaturcaraan berorientasikan objek, ialah ciri bahasa yang membenarkan subkelas atau kelas kanak-kanak menyediakan pelaksanaan khusus kaedah yang telah disediakan oleh salah satu superclass atau kelas induk Itu pada asasnya betul. Penggantian kaedah membolehkan anda mengambil beberapa kaedah kelas induk dan menulis pelaksanaan anda sendiri dalam setiap kelas anak. Pelaksanaan baharu 'menggantikan' pelaksanaan ibu bapa dalam kelas anak. Mari lihat bagaimana ini kelihatan dalam contoh. Buat 4 kelas yang mewarisi kelas Haiwan kami :

public class Bear extends Animal {
   @Override
   public void speak() {
       System.out.println("Growl!");
   }
}
public class Cat extends Animal {

   @Override
   public void speak() {
       System.out.println("Meow!");
   }
}

public class Dog extends Animal {

   @Override
   public void speak() {
       System.out.println("Woof!");
   }
}


public class Snake extends Animal {

   @Override
   public void speak() {
       System.out.println("Hiss!");
   }
}

"Berikut ialah rekaan hayat kecil untuk masa hadapan: untuk mengatasi kaedah kelas induk, pergi ke kod kelas anak dalam IntelliJ IDE, Klik Ctrl+O dan pilih "Timpa kaedah..." dalam menu. Biasakan menggunakan kekunci panas dari awal lagi — ia akan membantu anda menulis atur cara dengan lebih pantas! Untuk menentukan tingkah laku yang kami perlukan, kami melakukan beberapa perkara:

1. Dalam setiap kelas kanak-kanak, kami mencipta kaedah dengan nama yang sama dengan kaedah kelas induk.


2. Kami memberitahu pengkompil bahawa menamakan kaedah yang sama seperti dalam kelas induk bukanlah kebetulan: kami mahu mengatasi kelakuannya. Untuk menyampaikan perkara ini kepada pengkompil, kami menetapkan anotasi @Override di atas kaedah.
   Apabila diletakkan di atas kaedah, anotasi @Override memberitahu pengkompil (serta pengaturcara membaca kod anda): 'Semuanya baik-baik saja. Ini bukan satu kesilapan. Saya bukan pelupa. Saya sedar bahawa kaedah sedemikian sudah wujud dan saya mahu mengatasinya'.


3. Kami menulis pelaksanaan yang kami perlukan untuk setiap kelas kanak-kanak. Apabila kaedah speak() dipanggil, ular harus mendesis, beruang harus menggeram, dsb.

Mari lihat bagaimana ini berfungsi dalam program:

public class Main {

   public static void main(String[] args) {

       Animal animal1 = new Dog();
       Animal animal2 = new Cat();
       Animal animal3 = new Bear();
       Animal animal4 = new Snake();

       animal1.speak();
       animal2.speak();
       animal3.speak();
       animal4.speak();
   }
}

Output konsol:

Woof!
Meow!
Growl!
Hiss!

Cemerlang! Semuanya berfungsi sebagaimana mestinya! Kami mencipta 4 pembolehubah rujukan yang menyimpan objek kelas induk Haiwan dan kami menetapkan tika 4 kelas kanak-kanak yang berbeza kepada mereka. Akibatnya, setiap objek mempamerkan tingkah lakunya sendiri. Untuk setiap kelas kanak-kanak, kaedah speak() yang ditindih menggantikan kaedah 'native' speak() dalam kelas Animal (yang hanya memaparkan 'Hello!'). Mengatasi mempunyai beberapa batasan:

1. Kaedah yang diganti mesti mempunyai parameter yang sama seperti kaedah induk.

   Jika kaedah pertuturan kelas induk mempunyai parameter String , kaedah ganti dalam kelas anak mesti juga mempunyai parameter String . Jika tidak, pengkompil akan menghasilkan ralat:

   public class Animal {
   
      public void speak(String s) {
   
          System.out.println("Hello! " + s);
      }
   }
   
   public class Cat extends Animal {
   
      @Override // Error!
      public void speak() {
          System.out.println("Meow!");
      }
   }




2. Kaedah yang diganti mesti mempunyai jenis pulangan yang sama seperti kaedah induk.

   Jika tidak, kami akan mendapat ralat pengkompil:

   public class Animal {
   
      public void speak() {
   
          System.out.println("Hello!");
      }
   }
   
   
   public class Cat extends Animal {
   
      @Override
      public String speak() {         // Error!
          System.out.println("Meow!");
          return "Meow!";
      }
   }




3. Pengubah suai akses pada kaedah yang diganti juga mestilah sama dengan kaedah 'asal':

   public class Animal {
   
         public void speak() {
   
               System.out.println("Hello!");
         }
   }
   
   public class Cat extends Animal {
   
          @Override
          private void speak() {      // Error!
              System.out.println("Meow!");
          }
   }

Kaedah mengatasi dalam Java ialah satu cara untuk melaksanakan polimorfisme (prinsip OOP yang kami terangkan dalam pelajaran lepas). Ini bermakna kelebihan utamanya ialah fleksibiliti yang sama yang kita bincangkan sebelum ini. Kita boleh membina sistem kelas yang mudah dan logik, masing-masing mempunyai tingkah laku tertentu (anjing menyalak, kucing mengeong), dengan antara muka yang sama — satu kaedah speak() untuk mereka semua dan bukannya banyak kaedah, cth dogSpeak() , speakCat () , dsb.