Java Override/Overload


Timpa

Timpa ialah penulisan semula subkelas proses pelaksanaan kaedah kelas induk yang membenarkan akses! Nilai pulangan mahupun parameter formal tidak boleh diubah. Iaitu, cangkerang kekal tidak berubah dan intinya ditulis semula!

Kelebihan mengatasi ialah subkelas boleh menentukan tingkah laku khusus mereka sendiri mengikut keperluan.

Maksudnya, subkelas boleh melaksanakan kaedah kelas induk mengikut keperluan.

Dalam prinsip berorientasikan objek, mengatasi bermakna mana-mana kaedah sedia ada boleh ditindih. Contohnya adalah seperti berikut: 

class Animal{

   public void move(){
      System.out.println("动物可以移动");
   }
}

class Dog extends Animal{

   public void move(){
      System.out.println("狗可以跑和走");
   }
}

public class TestDog{

   public static void main(String args[]){
      Animal a = new Animal(); // Animal 对象
      Animal b = new Dog(); // Dog 对象

      a.move();// 执行 Animal 类的方法

      b.move();//执行 Dog 类的方法
   }
}

Hasil kompilasi dan larian contoh di atas adalah seperti berikut: 

动物可以移动
狗可以跑和走

Seperti yang anda boleh lihat dalam contoh di atas, walaupun b tergolong dalam jenis Haiwan, ia menjalankan kaedah pergerakan kelas Anjing.

Ini kerana semasa fasa penyusunan, hanya jenis rujukan parameter disemak.

Walau bagaimanapun, pada masa jalan, Mesin Maya Java (JVM) menentukan jenis objek dan menjalankan kaedah objek.

Jadi dalam contoh di atas, kompilasi berjaya kerana kaedah pergerakan wujud dalam kelas Haiwan Namun, pada masa jalan, kaedah objek tertentu dijalankan.

Pertimbangkan contoh berikut: 

class Animal{

   public void move(){
      System.out.println("动物可以移动");
   }
}

class Dog extends Animal{

   public void move(){
      System.out.println("狗可以跑和走");
   }
   public void bark(){
      System.out.println("狗可以吠叫");
   }
}

public class TestDog{

   public static void main(String args[]){
      Animal a = new Animal(); // Animal 对象
      Animal b = new Dog(); // Dog 对象

      a.move();// 执行 Animal 类的方法
      b.move();//执行 Dog 类的方法
      b.bark();
   }
}

Hasil penyusunan dan larian contoh di atas adalah seperti berikut: 

TestDog.java:30: cannot find symbol
symbol  : method bark()
location: class Animal
                b.bark();
                 ^

Atur cara ini akan membuang ralat kompilasi kerana jenis rujukan b, Haiwan, tidak mempunyai kaedah kulit kayu.

Menulis semula peraturan untuk kaedah

  • Senarai parameter mestilah betul-betul sama dengan kaedah yang ditindih; Jenis pemulangan mestilah sama dengan jenis pemulangan kaedah yang diganti; Hak akses tidak boleh lebih rendah daripada hak akses kaedah yang diganti dalam kelas induk. Sebagai contoh: Jika kaedah kelas induk diisytiharkan sebagai awam, maka kaedah itu tidak boleh diisytiharkan sebagai dilindungi apabila mengatasinya dalam subkelas.

  • Kaedah ahli kelas induk hanya boleh ditindih oleh subkelasnya.

  • Kaedah yang diisytiharkan muktamad tidak boleh ditindih.

  • Kaedah yang diisytiharkan statik tidak boleh ditindih, tetapi ia boleh diisytiharkan semula.

  • Jika subkelas dan kelas induk berada dalam pakej yang sama, subkelas boleh mengatasi semua kaedah kelas induk, kecuali kaedah yang diisytiharkan sebagai peribadi dan muktamad.

  • Jika subkelas dan kelas induk tidak berada dalam pakej yang sama, subkelas hanya boleh mengatasi kaedah bukan akhir kelas induk yang diisytiharkan awam dan dilindungi.

  • Kaedah yang ditindih boleh membuang sebarang pengecualian yang tidak dipaksa, tidak kira sama ada kaedah yang ditindih itu membuang pengecualian. Walau bagaimanapun, kaedah yang ditindih tidak boleh membuang pengecualian mandatori baharu, atau pengecualian mandatori yang lebih luas daripada yang diisytiharkan oleh kaedah yang diganti, dan sebaliknya.

  • Pembina tidak boleh ditindih.

  • Jika sesuatu kaedah tidak boleh diwarisi, ia tidak boleh ditindih.

Penggunaan kata kunci Super

Apabila anda perlu memanggil kaedah ganti kelas induk dalam subkelas, gunakan kata kunci super. 

class Animal{

   public void move(){
      System.out.println("动物可以移动");
   }
}

class Dog extends Animal{

   public void move(){
      super.move(); // 应用super类的方法
      System.out.println("狗可以跑和走");
   }
}

public class TestDog{

   public static void main(String args[]){

      Animal b = new Dog(); // Dog 对象
      b.move(); //执行 Dog类的方法

   }
}

Contoh kompilasi dan hasil larian di atas adalah seperti berikut: 

动物可以移动
狗可以跑和走

Lebihan beban (Lebih muatan)

Lebih muatan (lebih muatan) berada dalam kelas, nama kaedah adalah sama , tetapi parameternya berbeza . Jenis pulangan boleh sama atau berbeza.

Setiap kaedah terlampau beban (atau pembina) mesti mempunyai senarai jenis parameter yang unik.

Hanya pembina boleh terlebih beban

Peraturan terlebih muatan

  • Kaedah terlebih beban mesti menukar senarai parameter; 🎜>Kaedah terlebih beban boleh menukar jenis pemulangan;

  • Kaedah terlebih beban boleh menukar pengubah akses; pengecualian yang disemak yang lebih luas; kaedah

  • boleh terlebih beban dalam kelas yang sama atau dalam subkelas.

  • Instance

    public class Overloading {
 
	public int test(){
		System.out.println("test1");
		return 1;
	}
 
	public void test(int a){
		System.out.println("test2");
	}	
 
	//以下两个参数类型顺序不同
	public String test(int a,String s){
		System.out.println("test3");
		return "returntest3";
	}	
 
	public String test(String s,int a){
		System.out.println("test4");
		return "returntest4";
	}	
 
	public static void main(String[] args){
		Overloading o = new Overloading();
		System.out.println(o.test());
		o.test(1);
		System.out.println(o.test(1,"test3"));
		System.out.println(o.test("test4",1));
	}
}
  • Perbezaan antara menulis ganti dan terlebih muatan

←
→