Hi friend,

Dynamic polymorphism is run time polymorphism.


Thanks

The term static polymorphism is associated with overloaded methods
because it gives the impression that a single named method will accept
a number of different argument types. The System.out.println() method
is an example that may take String or Object references, boolean and
other primitive types as an argument. In fact, each overloaded method
is separate and the compiler can see the difference between them. In
this case, the argument types are fixed at compile time and are
considered static. This has nothing to do with the Java keyword
static.

Dynamic polymorphism is where a class overrides a superclass method or
implements an interface. For example, any class may override the
Object.toString() method and provide its own implementation, and this
is known at compile time. However, for a simple Java program that
instantiates a series of objects and calls their toString() method,
the compiler does not consider the object references differently. Any
differences in the objects' toString() implementations are only seen
at runtime, so they are considered dynamic.

The term static polymorphism is associated with overloaded methods
because it gives the impression that a single named method will accept
a number of different argument types. The System.out.println() method
is an example that may take String or Object references, boolean and
other primitive types as an argument. In fact, each overloaded method
is separate and the compiler can see the difference between them. In
this case, the argument types are fixed at compile time and are
considered static. This has nothing to do with the Java keyword
static.

Dynamic polymorphism is where a class overrides a superclass method or
implements an interface. For example, any class may override the
Object.toString() method and provide its own implementation, and this
is known at compile time. However, for a simple Java program that
instantiates a series of objects and calls their toString() method,
the compiler does not consider the object references differently. Any
differences in the objects' toString() implementations are only seen
at runtime, so they are considered dynamic.

hai friend

The term static polymorphism is associated with overloaded methods
because it gives the impression that a single named method will accept
a number of different argument types. The System.out.println() method
is an example that may take String or Object references, boolean and
other primitive types as an argument. In fact, each overloaded method
is separate and the compiler can see the difference between them. In
this case, the argument types are fixed at compile time and are
considered static. This has nothing to do with the Java keyword
static.

Dynamic polymorphism is where a class overrides a superclass method or
implements an interface. For example, any class may override the
Object.toString() method and provide its own implementation, and this
is known at compile time. However, for a simple Java program that
instantiates a series of objects and calls their toString() method,
the compiler does not consider the object references differently. Any
differences in the objects' toString() implementations are only seen
at runtime, so they are considered dynamic.

thank you