Analyse de la définition et de l'utilisation du polymorphisme en Java

Cet article présente principalement la définition et l'utilisation du polymorphisme Java. Il analyse plus en détail le concept et les fonctions du polymorphisme ainsi que les compétences opérationnelles associées à la définition et à la mise en œuvre du polymorphisme orienté objet de Java. it

Les exemples de cet article décrivent la définition et l'utilisation du polymorphisme Java. Partagez-le avec tout le monde pour votre référence, les détails sont les suivants :

Le polymorphisme passe par :

1 interface et plusieurs classes différentes qui implémentent l'interface et couvrent la même méthode dans l'interface Incarnant

2, la classe parent et l'implémentation de plusieurs sous-classes différentes qui héritent de la classe parent et couvrent la même méthode dans la classe parent.

1. Concepts de base

Polymorphisme : envoyer un message à un objet et laisser l'objet décider du comportement auquel répondre. L'invocation de méthode dynamique est implémentée en attribuant la référence d'objet de sous-classe à la variable de référence d'objet de superclasse.

Ce mécanisme de Java suit un principe : lorsqu'une variable de référence d'objet de superclasse fait référence à un objet de sous-classe, le type de l'objet référencé plutôt que le type de la variable de référence détermine quelle méthode membre est appelée, mais c'est appelée La méthode doit être définie dans la super classe, c'est-à-dire que la méthode est remplacée par la sous-classe.

Si a est une référence de classe A, alors a peut pointer vers une instance de classe A, ou vers une sous-classe de classe A.

Si a est une référence à l'interface A, alors a doit pointer vers une instance d'une classe qui implémente l'interface A.

2. Mécanisme d'implémentation du polymorphisme Java

Mécanisme d'implémentation JVM actuel de SUN, la référence d'une instance de classe pointe vers un pointeur de handle (handle). , ce handle est une paire de pointeurs :

Un pointeur pointe vers une table En fait, cette table possède également deux pointeurs (un pointeur pointe vers une table de méthodes contenant des objets, et l'autre pointe vers un objet de classe. , indiquant le type de l'objet);

Un autre pointeur pointe vers un espace mémoire alloué à partir du tas Java.

3. Résumé

1. L'invocation de méthode dynamique est obtenue en attribuant la référence d'objet de sous-classe à la variable de référence d'objet de superclasse.

DerivedC c2=new DerivedC();
BaseClass a1= c2; //BaseClass 基类，DerivedC是继承自BaseClass的子类
a1.play(); //play()在BaseClass，DerivedC中均有定义，即子类覆写了该方法

Analyse :

1 Pourquoi les instances d'objet de types de sous-classes peuvent-elles être remplacées par des superclasses ? ?

Réalisez automatiquement une transformation ascendante. Grâce à cette instruction, le compilateur déplace automatiquement l'instance de sous-classe vers le haut et devient le type universel BaseClass

2. a.play() exécutera-t-il la méthode définie par la sous-classe ou la classe parent ?

sous-classe de . Pendant l'exécution, la méthode correspondante sera obtenue en fonction du type réel de la référence d'objet a. C'est pourquoi il y a du polymorphisme. Si une référence d'objet de classe de base est affectée à une référence d'objet de sous-classe différente, elle affichera des comportements différents lorsque la méthode est exécutée.

Quand a1=c2, il y a toujours deux poignées, a1 et c2, mais a1 et c2 ont le même bloc de mémoire de données et des tables de fonctions différentes.

2. Vous ne pouvez pas attribuer la référence d'objet de classe parent à la variable de référence d'objet de sous-classe

BaseClass a2=new BaseClass();
DerivedC c1=a2;//出错

En Java, en haut La transformation est automatique, mais la transformation vers le bas ne l’est pas. Nous devons la définir nous-mêmes et la forcer.

c1=(DerivedC)a2; Effectuer une conversion forcée, c'est-à-dire une conversion vers le bas

3. N'oubliez pas une règle très simple mais complexe, une référence de type ne peut faire référence qu'au type de référence lui-même. méthodes et variables.

Vous pouvez dire que cette règle est fausse, car lorsque la référence de la classe parent pointe vers l'objet de la sous-classe, la méthode de la sous-classe est finalement exécutée.

En fait, ce n'est pas une contradiction. En effet, la liaison tardive est utilisée et la méthode de sous-classe est appelée en fonction du type lors du fonctionnement dynamique. Et si cette méthode de sous-classe n'est pas définie dans la classe parent, une erreur se produira.

Par exemple, en plus d'hériter des fonctions définies dans BaseClass, la classe DerivedC ajoute également plusieurs fonctions (telles que myFun())

Analyse :

Lorsque vous utilisez une référence de classe parent pour pointer vers une sous-classe, le jvm a en fait utilisé les informations de type générées par le compilateur pour ajuster la conversion.

Vous pouvez le comprendre de cette façon, ce qui équivaut à définir les fonctions qui ne sont pas incluses dans la classe parent comme invisibles depuis la table des fonctions virtuelles. Notez qu'il est possible que certaines adresses de fonction dans la table de fonctions virtuelles aient été réécrites dans la sous-classe, de sorte que l'adresse de l'élément de fonction virtuelle dans la table de fonctions virtuelles de l'objet a été définie sur l'adresse du corps de méthode complété dans la sous-classe.

4. Comparaison du polymorphisme entre Java et C++

La solution de support du polymorphisme de jvm est presque la même que celle en c++, sauf qu'il existe de nombreux compilateurs en c++. à la fois les informations de type et les informations de fonction virtuelle dans une table de fonctions virtuelles, mais utilise une technologie pour les distinguer.

Java sépare les informations de type et les informations de fonction. Après l'héritage en Java, la sous-classe réinitialisera sa propre table de fonctions virtuelles. Les éléments de cette table de fonctions virtuelles sont composés de deux parties. Fonctions virtuelles héritées des propres fonctions virtuelles de la classe parent et de la sous-classe.

Les appels de fonctions virtuelles sont appelés indirectement via la table de fonctions virtuelles, ce qui permet d'obtenir un polymorphisme. Toutes les fonctions en Java, à l'exception de celles déclarées comme finales, utilisent la liaison tardive.

四. 1个行为,不同的对象,他们具体体现出来的方式不一样,

比如: 方法重载 overloading 以及 方法重写(覆盖)override

class Human{
void run(){输出 人在跑}
}
class Man extends Human{
void run(){输出 男人在跑}
}

这个时候,同是跑,不同的对象,不一样(这个是方法覆盖的例子)

class Test{
void out(String str){输出 str}
void out(int i){输出 i}
}

这个例子是方法重载,方法名相同,参数表不同

ok,明白了这些还不够,还用人在跑举例

Human ahuman=new Man();

这样我等于实例化了一个Man的对象,并声明了一个Human的引用,让它去指向Man这个对象

意思是说,把 Man这个对象当 Human看了.

比如去动物园,你看见了一个动物,不知道它是什么, “这是什么动物? ” “这是大熊猫! “

这2句话,就是最好的证明,因为不知道它是大熊猫,但知道它的父类是动物,所以,这个大熊猫对象,你把它当成其父类 动物看,这样子合情合理.这种方式下要注意 new Man();的确实例化了Man对象,所以ahuman.run()这个方法 输出的 是 “男人在跑 “如果在子类 Man下你 写了一些它独有的方法 比如 eat(),而Human没有这个方法,在调用eat方法时,一定要注意 强制类型转换 ((Man)ahuman).eat(),这样才可以…

对接口来说,情况是类似的…

package domatic;
//定义超类superA
class superA {
int i = 100;
void fun(int j) {
j = i;
System.out.println("This is superA");
}
}
// 定义superA的子类subB
class subB extends superA {
int m = 1;
void fun(int aa) {
System.out.println("This is subB");
}
}
// 定义superA的子类subC
class subC extends superA {
int n = 1;
void fun(int cc) {
System.out.println("This is subC");
}
}
class Test {
public static void main(String[] args) {
superA a = new superA();
subB b = new subB();
subC c = new subC();
a = b;
a.fun(100);
a = c;
a.fun(200);
}
}

/*
* 上述代码中subB和subC是超类superA的子类,我们在类Test中声明了3个引用变量a, b,
* c,通过将子类对象引用赋值给超类对象引用变量来实现动态方法调用 。也许有人会问：
* “为什么(1)和(2)不输出：This is superA” 。
* java的这种机制遵循一个原则：当超类对象引用变量引用子类对象时,
* 被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法,
* 但是这个被调用的方法必须是在超类中定义过的,
* 也就是说被子类覆盖的方法 。
* 所以,不要被上例中(1)和(2)所迷惑,虽然写成a.fun(),但是由于(1)中的a被b赋值,
* 指向了子类subB的一个实例,因而(1)所调用的fun()实际上是子类subB的成员方法fun(),
* 它覆盖了超类superA的成员方法fun()；同样(2)调用的是子类subC的成员方法fun() 。
* 另外,如果子类继承的超类是一个抽象类,虽然抽象类不能通过new操作符实例化,
* 但是可以创建抽象类的对象引用指向子类对象,以实现运行时多态性 。具体的实现方法同上例 。
* 不过,抽象类的子类必须覆盖实现超类中的所有的抽象方法,
* 否则子类必须被abstract修饰符修饰,当然也就不能被实例化了
*/

以上大多数是以子类覆盖父类的方法实现多态.下面是另一种实现多态的方法———–重写父类方法

1.JAVA里没有多继承，一个类之能有一个父类 。而继承的表现就是多态 。一个父类可以有多个子类，而在子类里可以重写父类的方法（例如方法print()），这样每个子类里重写的代码不一样，自然表现形式就不一样 。这样用父类的变量去引用不同的子类，在调用这个相同的方法print()的时候得到的结果和表现形式就不一样了，这就是多态，相同的消息（也就是调用相同的方法）会有不同的结果 。举例说明：

//父类
public class Father{
//父类有一个打孩子方法
public void hitChild(){
}
}
//子类1
public class Son1 extends Father{
//重写父类打孩子方法
public void hitChild(){
System.out.println("为什么打我？我做错什么了！");
}
}
//子类2
public class Son2 extends Father{
//重写父类打孩子方法
public void hitChild(){
System.out.println("我知道错了，别打了！");
}
}
//子类3
public class Son3 extends Father{
//重写父类打孩子方法
public void hitChild(){
System.out.println("我跑，你打不着！");
}
}
//测试类
public class Test{
public static void main(String args[]){
Father father;
father = new Son1();
father.hitChild();
father = new Son2();
father.hitChild();
father = new Son3();
father.hitChild();
}
}

都调用了相同的方法，出现了不同的结果！这就是多态的表现！

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!