Java polymorphism _jsp programming at runtime

Run-time polymorphism is one of the most powerful mechanisms for object-oriented programming code reuse, and dynamic concepts can be said to be "an interface, multiple methods". The basis of Java implementation Run-time polymorphism is dynamic method scheduling, which is a mechanism to invoke overloaded methods at runtime rather than at compile time, and then discuss the implementation of Java Run-time Polymorphism in two aspects of inheritance and interface implementation.

one, by inheriting the superclass object reference variable referencing the subclass object to implement

An example is provided:

Define Superclass SuperA
Class SuperA
{
int i = 100;
void Fun ()
{
System.out.println ("This is SuperA");
}
}
Defines a subclass of SuperA Subb
Class Subb extends SuperA
{
int m = 1;
void Fun ()
{
System.out.println ("This is Subb");
}
}
Defines a subclass of SuperA SUBC
Class SUBC extends SuperA
{
int n = 1;
void Fun ()
{
System.out.println ("This is SUBC");
}
}

Class Test
{
public static void Main (string[] args)
{
SuperA A;
Subb B = new Subb ();
SUBC C = new SUBC ();
A=b;
A.fun (); (1)
A=c;
A.fun (); (2)
}
}

The results of the operation are:

This is Subb
This is SUBC

Subb and SUBC in the above code are subclasses of superclass SuperA, we declare 3 reference variables A, B, C in class test to implement dynamic method invocation by assigning a subclass object reference to a superclass object reference variable. Some may ask: "Why (1) and (2) do not output: This is SuperA". This mechanism of Java follows a principle: When a Superclass object references a variable referencing a subclass object, the type of the referenced object, rather than the type of the reference variable, determines whose member method to invoke, but the invoked method must be defined in the superclass, that is, the method overridden by the quilt class.

So, don't be fooled by the example (1) and (2), although written as A.fun (), because a in (1) is assigned a value to an instance of the subclass Subb, the fun () invoked by (1) is actually a member method fun () of the subclass Subb. It overrides the Member method fun () of the superclass SuperA, and likewise (2) calls the Member Method fun () of the subclass SUBC.

In addition, if a subclass inherits a superclass that is an abstract class, although an abstract class cannot be instantiated by the new operator, an object reference that can create an abstract class points to a subclass object to achieve Run-time polymorphism. The implementation of the specific methods in the above example.

　　However, subclasses of an abstract class must override all abstract methods in the implementation superclass, otherwise subclasses must be decorated by the abstract modifier and, of course, cannot be instantiated.