Introduction détaillée au concept de polymorphisme en Java et à son principe de mise en œuvre

Le polymorphisme en JAVA est l'incarnation de multiples expressions d'objets. En orienté objet, le polymorphisme le plus courant se produit lors de l'utilisation de la référence d'une classe parent pour faire référence à un objet d'une sous-classe. L'article suivant vous le présente principalement. Les amis qui en ont besoin peuvent se référer à

1. Qu'est-ce que le polymorphisme ?

1. La définition du polymorphisme

fait référence au fait de permettre à des objets de types différents de répondre au même message. Autrement dit, le même message peut adopter une variété de méthodes de comportements différentes en fonction de l'objet d'envoi (Envoyer un message est un appel de fonction)

2. Le rôle du polymorphisme

Éliminer les relations de couplage entre les types

3.Explication du polymorphisme

Internet moderne. Novels Flooding, nous pouvons l'utiliser pour donner un exemple

Un jour, vous voyez plusieurs romans sur votre téléphone qui sont mis à jour en même temps, comme Le Grand Maître, Lord Snow Eagle, Légende du Roi Dragon... dans Ici, nous pouvons le décrire comme suit :

Roman a=Grand Seigneur

Roman b=Snow Eagle Lord

Roman c=Légende du Roi Dragon

…

Ce qui est montré ici est du polymorphisme. Le Grand Maître, Lord Snow Eagle et la Légende du Roi Dragon sont tous des sous-catégories de romans. Nous pouvons simplement référencer différentes sous-catégories. à travers la catégorie parent des romans. Il s'agit du polymorphisme - ce n'est qu'au moment de l'exécution que vous connaîtrez l'objet d'instance spécifique pointé par la variable de référence

Bien sûr, cette compréhension est loin d'être le cas. Assez. Pour commencer à comprendre le polymorphisme, vous devez comprendre qu'il s'agit d'une « transformation vers le haut »

Dans l'exemple ci-dessus, roman (XS) est la catégorie parent, Grand Maître (DZZ), Snow Eagle Lord. (XYLZ) et Dragon King Legend (LWCS) sont toutes ses sous-catégories. Nous définissons donc le code suivant

DZZ a=new DZZ();

Vous ne devriez pas vous sentir étranger à cela. Ce n'est rien de plus que d'instancier un gros objet maître. Donc pour ce qui suit : Qu'en est-il de ce code ?

XS a=new DZZ();

Ici, nous le comprenons de cette façon, un. Le type XS a est défini ici, lui permettant de pointer vers l'Exemple d'objet DZZ . Puisque DZZ hérite de XS, DZZ peut être automatiquement transformé vers le haut en XS, donc a peut pointer vers l'objet instance DZZ. Cela présente un très grand avantage. En héritage, nous savons que la sous-classe est une extension de la classe parent. Elle peut fournir des fonctions plus puissantes que la classe parent si nous définissons un type de référence de classe parent qui pointe vers la sous-classe. , puis en plus de pouvoir référencer les caractéristiques communes de la classe parent, vous pouvez également utiliser les fonctions puissantes de la sous-classe

Cependant, il y a aussi quelques lacunes dans la transformation vers le haut, c'est-à-dire. , cela entraînera certainement la perte de certaines méthodes et attributs , et par conséquent nous ne pourrons pas les obtenir. Par conséquent, l'application du type classe parent peut appeler tous les attributs et méthodes définis dans la classe parent. Elle est hors de portée des méthodes et attributs qui n'existent que dans la sous-classe

public class XS {

    public void fun1() {
      System.out.println("XS中的fun1");
      fun2();
    }


  public void fun2() {
     System.out.println("XS中的fun2");    
  }
}

.

public class DZZ extends XS{

  /*
   * 子类重载父类方法
   * 父类中不存在该方法，向上转型后，父类是不能引用该方法的
   */
   public void fun1(String a) {
     System.out.println("DZZ中的fun1");
     fun2();
   }

   /*
    * 子类重写父类方法 
    * 调用必定使用这个方法
    */
   public void fun2() {
     System.out.println("DZZ中的fun2");
   }
}

public class DuoTaiTest {

   public static void main(String[] args) {
     XS a=new DZZ();
     a.fun1();
  }
}
output:
XS中的fun1
DZZ中的fun2

On peut donc résumer le polymorphisme comme suit :
La référence de la classe parent pointant vers la sous-classe a été transformée vers le haut. Elle ne peut accéder qu'aux méthodes et attributs appartenant à la classe parent, tandis que pour la sous-classe qui existe Pour les méthodes qui n'existent pas dans la classe parent, la référence ne peut pas être utilisée, même si la méthode est surchargée. Si une sous-classe remplace certaines méthodes de la classe parent, lors de l'appel de ces méthodes, elle doit utiliser les méthodes définies dans la sous-classe (connexion dynamique, appel dynamique)

Pour le polymorphisme objet orienté, il est divisé en compilation- le polymorphisme temporel et le polymorphisme au moment de l'exécution. Le polymorphisme au moment de l'édition est statique, qui fait principalement référence à la surcharge des méthodes. Il se distingue en fonction des différentes listes de paramètres. La fonction deviendra deux fonctions différentes après l'édition. et il n'y a pas de polymorphisme au moment de l'exécution. Le polymorphisme d'exécution est dynamique et est obtenu grâce à une liaison dynamique, ce que nous appelons le polymorphisme.

2. Mise en œuvre du polymorphisme

1. Conditions de mise en œuvre

L'héritage a été éliminé au début. mise en œuvre de l’État. La sous-classe Child hérite de la classe parent Father. Nous pouvons écrire une référence de type de classe parent pointant vers la sous-classe. Cette référence peut gérer à la fois l'objet Father de la classe parent et l'objet Child de la sous-classe. classe, Lorsqu'un objet est un objet, l'objet aura des comportements différents selon la référence à laquelle il appartient. C'est le polymorphisme. Autrement dit, le polymorphisme signifie que le même message amène différentes classes à réagir différemment

JavaIl y a trois conditions nécessaires pour réaliser le polymorphisme : l'héritage, la réécriture et la transformation ascendante

Héritage : dans In polymorphisme, il doit y avoir une sous-classe et une classe parent qui ont une relation d'héritage

Réécriture : la sous-classe redéfinit certaines méthodes dans la classe parent, et lorsque ces méthodes sont appelées, les méthodes de la sous-classe seront appelées

向上转型:在多态中需要将子类的引用赋给父类对象,只有这样该引用才能够具备技能调用父类的方法和子类的方法

只有满足了上述三个条件,我们才能够在同一个继承结构中使用同一的逻辑实现代码处理不同的对象,从而达到执行不同的行为

对于Java而言,它多态的实现机制遵循一个原则:当超类对象引用变量引用子类对象时,被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法,但是这个被调用的方法必须是在超类中定义过的,也就是说被子类覆盖的方法

2.实现形式

继承

public class XS {

      private String name;

    public String getName() {
      return name;
    }

    public void setName(String name) {
      this.name = name;
    }

    public XS() {

    }

    public String drink() {
      return "你看的小说名字:"+getName();
    }

    public String toString() {
       return null;
    }


}
public class DZZ extends XS{


  public DZZ() {
    setName("DZZ");
  }

  public String drink() {
    return "你看的小说名字:"+getName();
  }

  public String toString() {

    return "小说名:"+getName();
  }
}
public class XYLZ extends XS{

  /**
   * 
   */
  public XYLZ() {
     setName("XYLZ");
  }

  public String drink() {
    return "你看的小说名字:"+getName();
  }

  public String toString() {

    return "小说名:"+getName();
  }
}   
public class DuoTaiTest {
    public static void main(String[] args) {
      XS [] xs=new XS[2];

      DZZ a=new DZZ();
      XYLZ b=new XYLZ();

      xs[0]=a;
      xs[1]=b;

      for(int i=0;i<2;i++) {
       System.out.println(xs[i].toString()+"::::"+xs[i].drink());
      }

      System.out.println("-------------------");
  }
}
ouput:
小说名:DZZ::::你看的小说名字:DZZ
小说名:XYLZ::::你看的小说名字:XYLZ
-------------------

在上面的代码中DZZ,XYLZ继承XS 并且重写了drink(),toString()方法,程序运行结果是调用子类中方法,输出DZZ,XYLZ的名称,这就是多态的表现。不同的对象可以执行相同的行为,但是他们都需要通过自己的实现方式来执行,这就要得益于向上转型了

我们都知道所有的类都继承自超类Object,toString()方法也是Object中方法,当我们这样写时:

Object o = new DZZ();
System.out.println(o.toString());

output:
小说名:DZZ

Object,XS,DZZ三者继承链关系是:DZZ—>XS—>Object。所以我们可以这样说:当子类重写父类的方法被调用时,只有对象继承链中的最末端的方法才会被调用。但是注意如果这样写:

Object o = new xs();

System.out.println(o.toString());

output:
null//因为DZZ并不存在于该对象继承链中

所以基于继承实现的多态可以总结如下:对于引用子类的父类类型,在处理该引用时,它适用于继承该父类的所有子类,子类对象的不同,对方法的实现也就不同,执行相同动作产生的行为也就不同。

如果父类是抽象类,那么子类必须要实现父类中所有的抽象方法,这样该父类所有的子类一定存在统一的对外接口,但其内部的具体实现可以各异。这样我们就可以使用顶层类提供的统一接口来处理该层次的方法。

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!