Java @Override

Anotasi @Override digunakan apabila pembangun mengatasi fungsi dalam Java untuk menggunakan nama fungsi yang sama tetapi menetapkan fungsi ini dengan sifat yang berbeza. Jika anda mengetahui tentang fungsi over rise dalam Java tetapi tidak menggunakan anotasi @override kerana anda tidak mahu menggunakannya sebagai pilihan wajib untuk menulisnya secara eksplisit. Ia secara lalai diaktifkan sejak Java 1.5 diperkenalkan. Ia menggalakkan polimorfisme masa larian. Ini kerana kita boleh mengatasi sebarang fungsi tanpa menggunakan anotasi. Namun, ia telah mendapat satu kelebihan utama: jika pengkompil, secara kebetulan, terlepas yang mengatasi (seperti pembangun melakukan kesilapan ejaan dalam nama fungsi mengatasi). Dengan bantuan anotasi mengatasi, pengkompil akan memahami dan mengatasi fungsi asas dengan fungsi anak. Ia juga memajukan kebolehbacaan kod yang mengurangkan masa dan usaha penyelenggaraan.

Mulakan Kursus Pembangunan Perisian Percuma Anda

Pembangunan web, bahasa pengaturcaraan, ujian perisian & lain-lain

Sintaks:

public @interface Override

Tandatangan “@” hendaklah hadir sebelum menggantikan kata kunci untuk pengkompil memahami sama ada ini anotasi atau bukan. Fungsi override harus mempunyai definisi yang sama bersama-sama dengan jenis pulangan dan beberapa parameter dalam kedua-dua kelas asas dan warisan. Jika terdapat perbezaan dalam mana-mana daripada ini, ia tidak akan dianggap sebagai fungsi penggantian sambil memahami fungsi ini sebagai fungsi baharu.

Bagaimana @Override Anotasi berfungsi dalam Java?

• Anotasi ganti digunakan sejurus sebelum fungsi ganti yang ditakrifkan dalam kelas yang diwarisi untuk memastikan pengkompil memahami bahawa fungsi ini sengaja ditakrifkan dengan parameter yang sama dan jenis pulangan dalam dua kelas yang berbeza.
• Supaya sistem memahami fungsi mana yang hendak dipanggil kerana fungsi mempunyai parameter yang sama dalam kedua-dua kelas asas dan warisan, kita perlu memanggil fungsi menggunakan contoh.
• Jika sesuatu fungsi dipanggil menggunakan objek kelas induk, maka fungsi kelas induk dengan definisi fungsi setempatnya dipanggil manakala jika objek kelas yang diwarisi digunakan, maka fungsi kelas yang diwarisi akan dipanggil.

Contoh:

Base class {}
Child class{}
Base object1= new Base();// Here Base class is instantiated so the function definition will be called from base class.
Base object2= new Child(); /// Here Child class is instantiated so the
function definition will be called from child class

• Kini objek yang ditakrifkan di atas dinamakan "objek1" dan "objek2" digunakan bersama dengan pengendali titik untuk menarik definisi fungsi.
• Semua fungsi ini hanya berfungsi jika dikekalkan di bawah kelas utama dari mana pelaksanaan kod sebenar bermula.
• Kawalan akan memukul kelas Utama dan kemudian akan mencari contoh objek bagi kelas yang dipratakrifkan di atas kelas utama.
• Objek kemudian akan menggunakan fungsi yang dipanggil.
• Seseorang juga boleh menghantar parameter yang dikehendaki dalam fungsi jika sudah ditakrifkan dalam definisi kelas sebagai prototaip.
• Satu kelas asas boleh diwarisi oleh lebih daripada satu kelas; satu-satunya perbezaan ialah penciptaan objek dan panggilan fungsi menggunakan objek itu.

Contoh Java @Override

Diberikan di bawah adalah contoh:

Contoh #1

Contoh untuk menunjukkan cara mengatasi anotasi.

Penjelasan:

Terdapat dua kelas yang ditakrifkan dalam program di bawah: satu ialah kelas asas, yang juga dipanggil kelas induk "Pclass", manakala kelas lain ", Cclass" yang mewarisi sifat dan fungsi ahli asas, ialah dipanggil kelas warisan atau anak. Fungsi ini pertama sekali diisytiharkan dalam kelas induk. Dalam contoh ini, nama fungsi ialah printfunction() yang diperuntukkan dengan kerja mencetak rentetan yang diluluskan sebagai parameter.

Fungsi dengan nama yang sama diisytiharkan dan ditakrifkan dalam kelas yang diwarisi dipanggil "Cclass" dengan anotasi @override mendahuluinya. Rentetan lain diluluskan sebagai parameter kepadanya. Dalam kelas utama, kelas yang ditakrifkan di atas dijadikan instantiated dengan mencipta objek mereka. "object1" mengenal pasti objek Pclass dan "object2" mengenal pasti objek untuk Cclass. Fungsi yang sama dipanggil menggunakan objek yang berbeza ini. Dalam kes pertama, object1 mendapat rentetan daripada Pclass, iaitu kelas induk. Sementara kemudian, apabila object2 dipanggil, maka @override anotasi akan bertindak dan menukar rentetan kandungan. Ini adalah kemudahan utama yang disediakan di bawah Java untuk kod yang boleh difahami dan kefungsian yang lebih baik.

Kod:

// This is Base class
class Pclass {
void printfunction()
{
System.out.println("This is the output of function present in parent class \"Pclass\". ");
}
}
// This is Child class
class Cclass extends Pclass {
// The below function is override function along with override annotation
@Override
void printfunction()
{
System.out.println("This is the output of function present in child class \"Cclass\".");
}
}
// Thi is Main class from here the contro; execution starts. JAVA compiler searches for main class to start executing any code.
public class Main {
public static void main(String[] args)
{
Pclass object1 = new Pclass();
object1.printfunction();
Pclass object2 = new Cclass();
object2.printfunction();
}
}

Output:

Berikut ialah skrin keluaran dengan dua baris rentetan. Baris rentetan pertama berasal daripada fungsi asas, manakala baris rentetan kedua berasal daripada fungsi mengatasi yang ditakrifkan dalam kelas yang diwarisi.

Example #2

Here we have one base class with two child classes inheriting it. The second inherited class is instantiated, and the output string is triggered from the 2^nd inherited class.

Code:

class Pclass {
void printfunction()
{
System.out.println("This is the output of function present in parent class \"Pclass\". ");
}
}
// This is Child class
class Cclass extends Pclass {
// The below function is override function along with override annotation
@Override
void printfunction()
{
System.out.println("This is the output of function present in child class \"Cclass\".");
}
}
// This is Child class
class Cclass2 extends Pclass {
// The below function is override function along with override annotation
@Override
void printfunction()
{
System.out.println("This is the output of function present in child class number 2 \"Cclass\".");
}
}
// This is Main class from here the contro; execution starts. JAVA compiler searches for main class to start executing any code.
public class Main {
public static void main(String[] args)
{
Pclass object1 = new Pclass();
object1.printfunction();
Pclass object2 = new Cclass2();
object2.printfunction();
}
}

Output:

Conclusion

Hence Java override function comes with a lot of benefits like providing run-time polymorphism, easy code access, clean code and many more. Adding override annotation assures that the compiler understands the intention of function definition via function declarations in classes. This is one of the important properties of the oops concept called polymorphism.

Atas ialah kandungan terperinci Java @Override. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!