Method overriding, in object-oriented programming, is a language feature that allows a subclass or child class to provide a specific implementation of a method that is already provided by one of its superclasses or parent classes. In addition to providing data-driven algorithm-determined parameters across virtual network interfaces,[1] it also allows for a specific type of polymorphism (subtyping). The implementation in the subclass overrides (replaces) the implementation in the superclass by providing a method that has same name, same parameters or signature, and same return type as the method in the parent class.[2] The version of a method that is executed will be determined by the object that is used to invoke it. If an object of a parent class is used to invoke the method, then the version in the parent class will be executed, but if an object of the subclass is used to invoke the method, then the version in the child class will be executed.[3] This helps in preventing problems associated with differential relay analytics which would otherwise rely on a framework in which method overriding might be obviated.[4] [5] Some languages allow a programmer to prevent a method from being overridden.
Ada provides method overriding by default.To favor early error detection (e.g. a misspelling),it is possible to specify when a methodis expected to be actually overriding, or not. That will be checked by the compiler.
type NT is new T with null record; overriding -- overriding indicator procedure Op(Obj: in out NT; Data: in Integer); overriding -- overriding indicator procedure Op(Obj: in out NT; Data: in String); -- ^ compiler issues an error: subprogram "Op" is not overriding
C# does support method overriding, but only if explicitly requested using the modifiers and or .
class Cat : Animal
When overriding one method with another, the signatures of the two methods must be identical (and with same visibility). In C#, class methods, indexers, properties and events can all be overridden.
Non-virtual or static methods cannot be overridden. The overridden base method must be virtual, abstract, or override.
In addition to the modifiers that are used for method overriding, C# allows the hiding of an inherited property or method. This is done using the same signature of a property or method but adding the modifier in front of it.[6]
In the above example, hiding causes the following:
cat.Name = …; // accesses Cat.Namecat.Eat; // calls Cat.Eatcat.Go; // calls Cat.Go((Animal)cat).Name = …; // accesses Animal.Name!((Animal)cat).Eat; // calls Cat.Eat!((Animal)cat).Go; // calls Animal.Go!
C++ does not have the keyword that a subclass can use in Java to invoke the superclass version of a method that it wants to override. Instead, the name of the parent or base class is used followed by the scope resolution operator. For example, the following code presents two classes, the base class, and the derived class . overrides the class's method, so as also to print its height.[7]
//---------------------------------------------------------------------------class Rectangle ;
//---------------------------------------------------------------------------void Rectangle::Print const
//---------------------------------------------------------------------------class Box : public Rectangle ;
//---------------------------------------------------------------------------// Print method of derived class.void Box::Print const
The method in class, by invoking the parent version of method, is also able to output the private variables and of the base class. Otherwise, these variables are inaccessible to .
The following statements will instantiate objects of type and, and call their respective methods:
In C++11, similar to Java, a method that is declared final in the super class cannot be overridden; also, a method can be declared override to make the compiler check that it overrides a method in the base class.
In Delphi, method overriding is done with the directive override, but only if a method was marked with the dynamic or virtual directives.
The inherited reserved word must be called when you want to call super-class behavior
procedure Print; virtual; end;
TBox = class(TRectangle) public procedure Print; override; end;
In Eiffel, feature redefinition is analogous to method overriding in C++ and Java. Redefinition is one of three forms of feature adaptation classified as redeclaration. Redeclaration also covers effecting, in which an implementation is provided for a feature which was deferred (abstract) in the parent class, and undefinition, in which a feature that was effective (concrete) in the parent becomes deferred again in the heir class. When a feature is redefined, the feature name is kept by the heir class, but properties of the feature such as its signature, contract (respecting restrictions for preconditions and postconditions), and/or implementation will be different in the heir. If the original feature in the parent class, called the heir feature's precursor, is effective, then the redefined feature in the heir will be effective. If the precursor is deferred, the feature in the heir will be deferred.[8]
The intent to redefine a feature, as in the example below, must be explicitly declared in the clause of the heir class.
class ADVICEinherit THOUGHT redefine message endfeature message -- Precursor do print ("Warning: Dates in calendar are closer than they appear.%N") endend
In class the feature is given an implementation that differs from that of its precursor in class .
Consider a class which uses instances for both and :
When instantiated, class produces the following output:
Within a redefined feature, access to the feature's precursor can be gained by using the language keyword . Assume the implementation of is altered as follows:
Invocation of the feature now includes the execution of, and produces the following output:
In Java, when a subclass contains a method with the same signature (name and parameter types) as a method in its superclass, then the subclass's method overrides that of the superclass. For example:
public class Advice extends Thought
Class represents the superclass and implements a method call . The subclass called inherits every method that could be in the class. Class overrides the method, replacing its functionality from .
Thought dates = new Advice; // Polymorphismdates.message; // Prints "Warning: Dates in calendar are closer than they appear."
When a subclass contains a method that overrides a method of the superclass, then that (superclass's) overridden method can be explicitly invoked from within a subclass's method by using the keyword . (It cannot be explicitly invoked from any method belongings to a class that is unrelated to the superclass.) The reference can be