Detaillierte Einführung in das Konzept des Polymorphismus in Java und seine prinzipielle Implementierung

Polymorphismus in JAVA ist die Verkörperung mehrerer Ausdrücke von Objekten. In objektorientiert tritt der häufigste Polymorphismus auf, wenn die Referenz einer übergeordneten Klasse verwendet wird, um auf ein Objekt einer Unterklasse zu verweisen. Der folgende Artikel stellt es Ihnen hauptsächlich vor. Freunde, die es benötigen, können sich auf

beziehen. 1. Was ist Polymorphismus?

1. Die Definition von Polymorphismus

bezieht sich darauf, dass Objekte unterschiedlichen Typs auf dieselbe Nachricht reagieren können. Das heißt, dieselbe Nachricht kann abhängig vom sendenden Objekt verschiedene Verhaltensweisen annehmen (Das Senden einer Nachricht ist ein Funktionsaufruf)

2. Die Rolle des Polymorphismus

Beseitigung von Kopplungsbeziehungen zwischen Typen

3. Erklärung des Polymorphismus

Modernes Internet Novels Flooding, wir können es als Beispiel verwenden

Eines Tages sehen Sie mehrere Romane auf Ihrem Telefon, die gleichzeitig aktualisiert werden, wie „Der große Meister“, „Lord Schneeadler“, Legende vom Drachenkönig... hier können wir es wie folgt beschreiben:

Roman a=Großer Herr

Roman b=Schneeadler-Herr

Roman c=Legende des Drachenkönigs

…

Was hier gezeigt wird, ist Polymorphismus, Lord Snow Eagle und Legend of the Dragon King. Wir können nur auf verschiedene Unterkategorien verweisen Durch die übergeordnete Kategorie von Romanen wissen wir erst zur Laufzeit, auf welches spezifische Instanzobjekt die Referenzvariable

verweist genug. Um mit dem Verständnis des Polymorphismus zu beginnen, müssen Sie verstehen, dass es sich um eine „Aufwärtstransformation“ handelt.

Im obigen Beispiel ist Roman (XS) die übergeordnete Kategorie, Großer Meister (DZZ), Schneeadlerlord (XYLZ) und Dragon King Legend (LWCS) sind alle seine Unterkategorien. Daher definieren wir den folgenden Code:

DZZ a=new DZZ();

Sie sollten sich damit nicht fremd fühlen Code. Es ist nichts weiter als die Instanziierung eines großen Masterobjekts. Was ist also mit diesem Code?

XS a=new DZZ();

Hier verstehen wir es so, an Hier wird der XS-Typ a definiert, der auf das

DZZ-Objekt Beispiel zeigt. Da DZZ von XS erbt, kann DZZ automatisch in XS umgewandelt werden, sodass a auf das DZZ-Instanzobjekt verweisen kann. Dies hat einen großen Vorteil: Wir wissen, dass die Unterklasse eine Erweiterung der übergeordneten Klasse ist. Sie kann leistungsfähigere Funktionen bereitstellen als die übergeordnete Klasse, wenn wir einen Referenztyp für die übergeordnete Klasse definieren Dann können Sie nicht nur auf die gemeinsamen Funktionen der übergeordneten Klasse verweisen, sondern auch auf die leistungsstarken Funktionen der Unterklasse

. Es gibt jedoch auch einige Mängel bei der Aufwärtstransformation , es wird definitiv zum Verlust einiger Methoden und

Attribute führen und wir können sie daher nicht erhalten. Daher kann die Anwendung des übergeordneten Klassentyps alle in der übergeordneten Klasse definierten -Attribute und -Methoden aufrufen. Dies liegt außerhalb der Reichweite der Methoden und Attribute, die nur in der Unterklasse

vorhanden sind

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

Wir können den Polymorphismus also wie folgt zusammenfassen:

Die Referenz der übergeordneten Klasse, die auf die Unterklasse verweist, wurde nach oben transformiert. Sie kann nur auf die Methoden und Attribute zugreifen, die der übergeordneten Klasse gehören. während für die Unterklasse, die vorhanden ist Für Methoden, die in der übergeordneten Klasse nicht vorhanden sind, kann die Referenz nicht verwendet werden, selbst wenn die Methode überladen ist. Wenn eine Unterklasse einige Methoden in der übergeordneten Klasse überschreibt, muss sie beim Aufrufen dieser Methoden die in der Unterklasse definierten Methoden verwenden (dynamische Verbindung, dynamischer Aufruf).

Für den orientierten Objektpolymorphismus wird die Kompilierung unterteilt. Zeitpolymorphismus und Laufzeitpolymorphismus sind

statisch, was sich hauptsächlich auf die Überladung von Methoden bezieht. Die Funktion wird nach der Bearbeitung zu zwei verschiedenen Funktionen. und es gibt keinen Polymorphismus zur Laufzeit. Laufzeitpolymorphismus ist dynamisch und wird durch dynamische Bindung erreicht, die wir Polymorphismus nennen.

2. Implementierung des Polymorphismus

1. Implementierungsbedingungen

Vererbung wurde zu Beginn eliminiert des Staates. Das Unterklassen-Kind erbt die übergeordnete Klassentypreferenz, die auf die Unterklasse verweist. Diese Referenz kann sowohl das Vaterobjekt der übergeordneten Klasse als auch das untergeordnete Objekt der Unterklasse verarbeiten Klasse Wenn ein Objekt verwendet wird, führt das Objekt je nach Referenz, zu der es gehört, unterschiedliche Verhaltensweisen aus. Dies ist Polymorphismus. Das heißt, Polymorphismus bedeutet, dass dieselbe Nachricht dazu führt, dass verschiedene Klassen unterschiedlich reagieren

Es gibt drei notwendige Bedingungen, um Polymorphismus zu erreichen: Vererbung, Umschreiben und Aufwärtstransformation Java

Vererbung: in In Polymorphismus, es muss eine Unterklasse und eine übergeordnete Klasse geben, die eine Vererbungsbeziehung haben

Umschreiben: Die Unterklasse definiert bestimmte Methoden in der übergeordneten Klasse neu, und wenn diese Methoden aufgerufen werden, werden die Methoden der Unterklasse aufgerufen

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

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

 对于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并不存在于该对象继承链中

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

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

Das obige ist der detaillierte Inhalt vonDetaillierte Einführung in das Konzept des Polymorphismus in Java und seine prinzipielle Implementierung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!