Le polymorphisme en Java est divisé en deux types : le polymorphisme au moment de la compilation (surcharge) et le polymorphisme au moment de l'exécution (réécriture). Le polymorphisme au moment de la compilation est également appelé liaison frontale, et le polymorphisme au moment de l'exécution est également appelé post-liaison.
Ce qui suit est un exemple :
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{}
Ce qui doit être expliqué ici est :
Pour A a2 = new B( );
Si Si a2 est imprimé séparément, le résultat de l'impression est B@ (code de hachage), et non A@ (code de hachage), mais cela ne signifie pas que le type de a2 est de type B, car lorsque nous appelons a2.print( dans le programme ci-dessus a2);, le résultat de sortie est B et A au lieu de A et A (si vous supposez que a2 est de type B, vous devez appeler la méthode d'impression avec le paramètre B dans la classe A, car une telle méthode n'existe pas, puis revenez Deuxièmement, appeler la méthode avec le paramètre A devrait générer A et A, car B est une sous-classe de A).
Ce qui précède est un exemple d'analyse de code de réécriture et de surcharge. J'espère que cela sera utile aux étudiants qui apprennent Java.
Pour plus d'articles liés à la surcharge de fonctions Java et à la réécriture d'exemples de code, veuillez faire attention au site Web PHP chinois !