Ringkasan pemahaman konsep Java tentang polimorfisme

Artikel ini membawakan anda pengetahuan yang berkaitan tentang java Ia terutamanya bercakap tentang penjelasan terperinci polimorfisme dalam Java Hubungan warisan membolehkan subkelas mewarisi ciri kelas induk dan menambah beberapa ciri Baharu. Subkelas ialah pengkhususan kelas induknya Setiap contoh subkelas ialah contoh kelas induknya, tetapi sebaliknya saya harap ia akan membantu semua orang.

Kajian yang disyorkan: "tutorial video java"

1. Konsep polimorfisme

Hubungan warisan Subkelas boleh mewarisi ciri kelas induk dan menambah beberapa ciri baharu. Subkelas ialah pengkhususan kelas induknya, dan setiap contoh subkelas ialah contoh kelas induknya, tetapi sebaliknya adalah tidak benar. Contohnya: setiap bulatan ialah objek geometri, tetapi bukan setiap objek geometri ialah bulatan. Oleh itu, anda sentiasa boleh menghantar contoh subkelas kepada parameter yang memerlukan jenis induk. Kes rujukan adalah seperti berikut:

public class PolymorphismDemo{
/** Main method */
public static void main(String[] args){
  displayObject(new Circle(1,"red",false));
  displayObject(new Rectangle(1,1,"black",true));
}
 
public static void displayObject(GeometriicObject object){
  System.out.println("Created on "+ object.getDateCreated()+".Color is"+object.getColor());
}
}

Dicipta pada Isn Mac 09 19:25:20 EDT 2011.Warna merah

Dicipta pada Isn Mac 09 19:25: 20 EDT 2011 .Warna hitam

Kaedah paparanObject mempunyai parameter jenis GeometricObject. displayObject boleh dipanggil dengan menghantar sebarang contoh GeometricObject. Objek subkelas boleh digunakan di mana-mana objek kelas induk digunakan. Ini biasanya dirujuk sebagai polimorfisme. Ringkasnya, polimorfisme bermaksud pembolehubah jenis induk boleh merujuk kepada objek subjenis .

2. Ciri polimorfisme

Premis polimorfisme: pewarisan (iaitu, mesti ada hubungan kelas anak-ibu bapa.) Apabila memanggil kaedah menggunakan pembolehubah rujukan kelas induk polimorf, ia akan dipanggil Kaedah ditindih oleh subkelas. Format definisi: nama pembolehubah jenis kelas induk = jenis subkelas baharu (); 🎜>

3 instanceof operator

Instanceof ialah kata kunci Java. Setiap huruf dalam kata kunci Java ialah

huruf kecil.

Untuk lebih memahami penukaran jenis, mereka boleh dianggap sama dengan hubungan antara haiwan, beruang kutub dan panda Kelas haiwan Haiwan ialah kelas induk bagi kelas beruang kutub dan beruang kutub kelas panda Kelas panda. Beruang kutub ialah haiwan, jadi anda sentiasa boleh menetapkan contoh beruang kutub kepada pembolehubah Haiwan.

Penggunaan kata kunci ini adalah untuk menentukan sama ada objek tergolong dalam jenis data tertentu dan nilai pulangan ialah jenis Boolean.

 
        Fu Zz=new Xu();
        Fu Zzz=new yiting();
        if(f1 instanceof Xu){
            System.out.println("Zz是Xu的类型");
        }
        else{
            System.out.println("Zzz是yiting的类型");
        }

4 Transformasi polimorfik

1 Transformasi ke atas

Anda sentiasa boleh menukar contoh subkelas kepada pembolehubah kelas induk, yang dipanggil <.>Upcast

kerana tika subkelas sentiasa menjadi tika kelas induknya. Fungsi:

Kurangkan beberapa kod berulang Apabila membuat instantiat objek, anda boleh membuat instantiate objek yang berbeza mengikut keperluan yang berbeza

Jalankan hasil:

package project2;
	class Animal{
		int num=100;
		void say(){
			System.out.println("It's an Animal.");
		}
	}
 
	class Cat extends Animal{
		int num=50;
		void say(){
			System.out.println("It's a Cat.");
		}	
		void bark(){
			System.out.println("喵喵喵!");
		}
	}
 
	public class project2{
		public static void main(String[] args) {
			Animal cat=new Cat();//向上转型	
			System.out.println(cat.num);
			cat.say();
//			cat.bark();
		}
	}

100

Ia Kucing.

Jangan paksa transformasi ke atas Kaedah yang ditunjuk atau dipanggil oleh rujukan kelas induk ialah kaedah subkelas ini dipanggil pengikatan dinamik . Selepas transformasi ke atas, rujukan kelas induk tidak boleh memanggil kaedah subkelas itu sendiri.

2. Downcast

Tukar tika kelas induk kepada pembolehubah subkelasnya. Anda mesti menggunakan penanda penukaran (nama subkelas) untuk melakukan penukaran eksplisit untuk menunjukkan niat anda kepada pengkompil. Untuk penukaran berjaya, anda mesti memastikan bahawa objek yang ditukar adalah contoh subkelas.

Fungsi:

Apabila upcasting, kaedah lain yang unik untuk objek subkelas akan hilang;

Hasil lari:

package project2;
class Animal{
	int num=100;
	void say(){
		System.out.println("It's an Animal.");
	}
}
 
class Cat extends Animal{
	int num=50;
	void say(){
		System.out.println("It's a Cat.");
	}	
	void bark(){
		System.out.println("喵喵喵!");
	}
}
 
public class project2{
	public static void main(String[] args) {
		Animal cat=new Cat();//向上转型
		Cat cat2=(Cat) cat;//向下转型
		System.out.println(cat2.num);
		cat2.say();
		cat2.bark();
	}
}

50

Ia Kucing.

Meow meow meow!

5 🎜>

Petua: Untuk mengatasi kaedah, anda perlu mentakrifkan kaedah dalam subkelas dengan tandatangan yang sama seperti kelas induk.

Subkelas mewarisi kaedah daripada kelas induk. Kadangkala, subkelas perlu mengubah suai pelaksanaan kaedah yang ditakrifkan dalam kelas induk Ini dipanggil kaedah mengatasi.

Perkara berikut perlu diberi perhatian:

Kaedah yang ditindih mesti mempunyai tandatangan yang sama dengan kaedah yang ditindih, dan jenis pemulangan yang sama atau serasi. Keserasian bermaksud bahawa jenis pemulangan kaedah mengatasi boleh menjadi subjenis jenis pemulangan kaedah yang diganti. Ia boleh diganti hanya jika kaedah contoh boleh diakses. Jika kaedah yang ditakrifkan dalam subkelas adalah peribadi dalam kelas induk, maka kedua-dua kaedah ini tidak mempunyai hubungan sama sekali. Seperti kaedah contoh, kaedah statik juga boleh diwarisi. Walau bagaimanapun, kaedah statik tidak boleh ditindih. Jika kaedah statik yang ditakrifkan dalam kelas induk ditakrifkan semula dalam kelas anak, kaedah statik yang ditakrifkan dalam kelas induk akan disembunyikan. Kaedah statik tersembunyi boleh dipanggil menggunakan sintaks "nama kelas induk. nama kaedah statik". Mencegah pewarisan dan mengatasi

       一个被final修饰的类和方法都不能被继承。被final修饰的数据域是一个常数。

       有时候，可能希望防止类被继承。在这种情况下，使用final修饰符表明一个类是最终类，是不能作为父类的。Math类就是一个最终类。String、StringBuilder和StringBuffer类以及所有基本数据类型的包装类也都是最终类。例如，如下类A 就是最终类，不能被继承：

public final class A{
  //Data fields,constructors, and methods omitted
}

也可以定义一个方法为最终，最终方法不能被它的子类重写。例如如下，不能被重写：

public class Test {
  //Data fields,constructors, and methods omitted
 
  public final void m() {
    // Do something
 }
}

注：修饰符public、protected、private、static、abstract以及final可以用在类和类的成员上，只有final修饰符还可以用在方法中的局部变量上。方法内的final局部变量就是常量。

六、小结

为了重写一个方法，必须使用与它的父类中的方法一样的签名、一样或者兼容的返回类型来定义子类中的方法。实例方法只有在可访问时才能重写。这样，私有方法是不能重写的，因为它是不能在类本身之外访问的。如果子类中定义的方法在父类中是私有的，那么这两个方法是完全没有关系的噢！静态方法与实例方法一样可以继承。但是，静态方法不能重写，如果父类中定义的静态方法在子类中重新定义，那么父类中定义的方法被隐藏。可以使用表达式obj instanceof AClass 测试一个对象是否是一个类的实例。可以使用final修饰符来表明一个类是最终类，是不能被继承的；也可以表明一个方法是最终的，是不能被重写的。

推荐学习：《java视频教程》

Atas ialah kandungan terperinci Ringkasan pemahaman konsep Java tentang polimorfisme. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!