Résumé du concept Java pour comprendre le polymorphisme

Cet article vous apporte des connaissances pertinentes sur java. Il parle principalement de l'explication détaillée du polymorphisme en Java. La relation d'héritage permet à une sous-classe d'hériter des caractéristiques de la classe parent et d'ajouter de nouvelles caractéristiques. Une sous-classe est une spécialisation de sa classe parent. Chaque instance d'une sous-classe est une instance de sa classe parent, mais l'inverse n'est pas vrai, j'espère que cela sera utile à tout le monde.

Étude recommandée : "Tutoriel vidéo Java"

1. Le concept de polymorphisme

La relation d'héritage permet à une sous-classe d'hériter des caractéristiques de la classe parent et d'ajouter de nouvelles caractéristiques. Une sous-classe est une spécialisation de sa classe parent, et chaque instance d'une sous-classe est une instance de sa classe parent, mais l'inverse n'est pas vrai. Par exemple : chaque cercle est un objet géométrique, mais tous les objets géométriques ne sont pas un cercle. Par conséquent, vous pouvez toujours transmettre une instance d’une sous-classe à un paramètre nécessitant un type parent. Le cas de référence est le suivant :

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());
}
}

Créé le lundi 9 mars 19:25:20 EDT 2011. La couleur est rouge

Créé le lundi 9 mars 19:25:20 EDT 2011. La couleur est noire

Méthode displayObject a des paramètres de type GeometricObject. displayObject peut être appelé en passant n’importe quelle instance de GeographicObject. Les objets des sous-classes peuvent être utilisés partout où des objets de la classe parent sont utilisés. C'est ce qu'on appelle communément le polymorphisme. En termes simples, Le polymorphisme signifie qu'une variable d'un type parent peut faire référence à un objet d'un sous-type.

2. Caractéristiques du polymorphisme

La prémisse du polymorphisme : l'héritage (c'est-à-dire qu'il doit y avoir une relation de classe enfant-parent.) Lors de l'appel d'une méthode utilisant une variable de référence de classe parent polymorphe, la méthode réécrite de la sous-classe sera appelé. Format de définition : nom de la variable de type de classe parent = nouveau type de sous-classe ();

3 Le symbole opérationnel

Instanceof est le mot-clé de Java. Chaque lettre des mots-clés Java est en

minuscule.

Afin de mieux comprendre la conversion de type, ils peuvent être considérés comme similaires à la relation entre les animaux, les ours polaires et les pandas. La classe animale Animal est la classe parent de la classe des ours polaires. Ours polaire et de la classe panda. Classe Panda. . Les ours polaires sont des animaux, vous pouvez donc toujours attribuer en toute sécurité une instance d'ours polaire à une variable animale.

L'utilisation de ce mot-clé est de déterminer si un objet appartient à un certain type de données, et la valeur de retour est de type booléen.

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

4. Transformation polymorphe

1. Upcasting

Vous pouvez toujours convertir une instance d'une sous-classe en une variable d'une classe parent, appelée

upcasting, car l'instance de la sous-classe est toujours son instance de. la classe parent.

Fonction :

Réduisez certains codes répétitifs. Lors de l'instanciation d'objets, vous pouvez instancier différents objets en fonction de différents besoins

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();
		}
	}

Résultats d'exécution :

100

C'est un chat.

Transformation vers le haut Ne forcez pas la transformation, parent. La méthode pointée ou appelée par la référence de classe est la méthode de la sous-classe. C'est ce qu'on appelle la liaison dynamique. Après une transformation ascendante, la référence de la classe parent ne peut pas appeler les propres méthodes de la sous-classe.

2. Downcast

Convertissez une instance d'une classe parent en sa variable de sous-classe. Vous devez utiliser des marqueurs de conversion (noms de sous-classes) pour effectuer des conversions explicites afin d'indiquer vos intentions au compilateur. Pour que la conversion réussisse, vous devez vous assurer que l'objet en cours de conversion est une instance de la sous-classe.

Fonction :

Lors d'une transformation vers le haut, les autres méthodes propres à l'objet de sous-classe seront perdues ; elles peuvent être retransférées via une transformation vers le bas.

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();
	}
}

Résultat d'exécution :

50

C'est un chat.
Miaou miaou !

5. Réécriture de méthode

Conseils : Pour réécrire une méthode, vous devez utiliser la même signature que la classe parent dans la sous-classe pour définir cette méthode.

Les sous-classes héritent des méthodes des classes parentes. Parfois, une sous-classe doit modifier l'implémentation d'une méthode définie dans la classe parent. C'est ce qu'on appelle le remplacement de méthode.

Les points suivants méritent d'être notés :

La méthode surchargée doit avoir la même signature que la méthode surchargée, et le même type de retour ou compatible. La compatibilité signifie que le type de retour d'une méthode remplacée peut être un sous-type du type de retour de la méthode remplacée. Une méthode d'instance ne peut être remplacée que si elle est accessible. Si la méthode définie dans la sous-classe est privée dans la classe parent, alors ces deux méthodes n'ont aucune relation. Comme les méthodes d’instance, les méthodes statiques peuvent également être héritées. Cependant, les méthodes statiques ne peuvent pas être remplacées. Si une méthode statique définie dans la classe parent est redéfinie dans la classe enfant, la méthode statique définie dans la classe parent sera masquée. Les méthodes statiques masquées peuvent être appelées en utilisant la syntaxe « nom de classe parent.nom de méthode statique ». Empêcher l'héritage et le remplacement

       一个被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视频教程》

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!