Überladen und Umschreiben von Beispielcode von Java-Funktionen

Polymorphismus wird in Java in zwei Typen unterteilt: Polymorphismus zur Kompilierungszeit (Überladung) und Polymorphismus zur Laufzeit (Umschreiben). Polymorphismus zur Kompilierungszeit wird auch als Frontbindung bezeichnet, und Laufzeitpolymorphismus wird auch als Postbindung bezeichnet.

Das Folgende ist ein Beispiel:

public class OverloadAndOverwrite { 
  public static void main(String[] args) { 
    A a1 = new A(); 
    A a2 = new B(); 
    B b = new B(); 
    C c = new C(); 
    D d = new D(); 
    System.out.print("a1.print(a1): "); 
    a1.print(a1);//输出A and A 
    System.out.print("a1.print(b): "); 
    a1.print(b);//输出A and A:原因是因为A中不存在参数为B的方法，因此会调用参数为A的方法，因为B是继承自A的 
    System.out.print("a1.print(c): "); 
    a1.print(c);//输出A and A:原因是因为A中不存在参数为C的方法，因此会调用参数为A的方法，因为C是继承自B的,B是继承自A的 
    System.out.print("a1.print(d): "); 
    a1.print(d);//输出A and D:原因是因为A中存在参数为D的方法，因此会调用参数为D的方法 
    System.out.print("a2.print(b): "); 
    a2.print(b);//输出B and A:原因在于首先入口是A,首先查看A中是否有参数为B的print方法,发现没有那就寻找有没有参数为A的方法,因为B是继承自A的，发现存在这样的方法,那么再次查看B中有没有重写这个方法，发现有重新，直接调用B中这个重写的方法 
    System.out.print("a2.print(c): "); 
    a2.print(c);//输出B and A:原因在于首先入口是A,首先查看A中是否有参数为C的print方法,发现没有那就寻找有没有参数为B的方法,因为C是继承自B的，发现也不存在这样的方法，那就寻找存在参数为A的print方法，因为B继承自A,发现存在这样的方法,那么再次查看B中有没有重写这个方法，发现有重新，直接调用B中这个重写的方法 
    System.out.print("a2.print(d): "); 
    a2.print(d);//输出 A and D：原因在于入口是A，查看A中存在参数为D的方法，再次查看B中没有重写这个方法，因此输出A中这个方法的结果即可； 
    System.out.print("a2.print(a2): "); 
    a2.print(a2);//输出B and A;原因在于a2的类型是A，因此会调用A里面参数为A的print方法,但是a2右边new的是B，所以因为B中有参数为A的方法，因此采用的是B里面的这个方法 
    System.out.print("b.print(b): "); 
    b.print(b);//输出B and B;原因:入口是B，因此查看B中存不存在参数为B的print函数，存在则直接输出; 
    System.out.print("b.print(c): "); 
    b.print(c);//输出B and B;原因:入口是B，因此查看B中存不存在参数为C的print函数，发现不存在，则查看存不存在参数为B的print函数，发现存在，并且C中并没有重写该方法，则直接输出;有一点需要注意的是还需要查看一下A中是否存在参数为C的print方法，因为B继承自A，有的话会及成果来这个方法，这样的话输出的结果将变为A and C 
    System.out.print("b.print(d): "); 
    b.print(d);//输出A and D;原因:入口是B，虽然B中不存在参数为D的print函数,但是B继承自A,A中是存在参数为D的print函数的,因此输出的是A中参数为D的结果; 
  } 
} 
class A 
{ 
  public void print(A a) 
  { 
    System.out.println("A and A"); 
  } 
  public void print(D d) 
  { 
    System.out.println("A and D"); 
  } 
// public void print(C c) 
// { 
//   System.out.println("A and C"); 
// } 
} 
class B extends A 
{ 
  public void print(B b) 
  { 
    System.out.println("B and B"); 
  } 
  public void print(A a) 
  { 
    System.out.println("B and A"); 
  } 
} 
class C extends B{} 
class D extends C{}

Was hier erklärt werden muss, ist:

Für A a2 = neues B( );

Wenn a2 separat ausgedruckt wird, ist das Druckergebnis B@ (Hash-Code) und nicht A@ (Hash-Code). Dies bedeutet jedoch nicht, dass der Typ von a2 vom Typ B ist, denn wenn wir a2.print( in aufrufen Das obige Programm a2); das Ausgabeergebnis ist B und A anstelle von A und A (wenn Sie davon ausgehen, dass a2 vom Typ B ist, sollten Sie die Druckmethode mit Parameter B in Klasse A aufrufen, da es keine solche Methode gibt. dann zurückgreifen Zweitens sollte der Aufruf der Methode mit Parameter A A und A ausgeben, da B eine Unterklasse von A ist.

Das Obige ist eine Beispielcodeanalyse für das Umschreiben und Überladen. Ich hoffe, dass es für Studenten, die Java lernen, hilfreich sein wird.

Weitere Artikel zum Überladen von Java-Funktionen und zum Umschreiben von Beispielcodes finden Sie auf der chinesischen PHP-Website!