Class designs enable you to pass subclass objects to superclass methods. The superclass method executes properly because the subclass object is a superclass object. However, subclasses can implement their own versions of superclass methods, which MATLAB® calls when passed subclass objects.
Subclasses override inherited methods (that is, implement a method of the same name) when there is a need to provide specialized behavior in the subclass. Here are some patterns that override superclass methods.
Extend the superclass method by calling it from within the subclass method. The subclass method can perform subclass-specific processing in addition to calling the superclass method.
In a superclass method, implement a series of steps in a procedure using protected methods. Then reimplement these steps in a subclass method by redefining the protected methods that are called from within a public superclass method.
Redefine the same-named method in the subclass, but use different implementations to perform the same operation differently on subclass objects.
Implement abstract superclass methods in the subclass. Abstract superclasses can define methods with no implementation and rely on subclasses to provide the implementation. For more information, see Define an Interface Superclass.
Subclass methods that override superclass methods must define the same value for the
Access attribute as is defined by the superclass method.
Calling the same-named superclass method from a subclass method enables you to extend the superclass method for subclass objects without affecting the superclass method.
For example, suppose that both superclass and subclass define a method called
foo. The subclass method calls the superclass method and performs other steps in addition to the call to the superclass method. The subclass method can operate on the specialized parts to the subclass that are not part of the superclass.
For example, this subclass defines a
foo method that calls the superclass
classdef Sub < Super methods function foo(obj) % preprocessing steps ... foo@Super(obj); % postprocessing steps ... end end end
A superclass method can define a process that executes in a series of steps using a method for each step (typically
Access attribute is set to
protected for the step methods). This pattern (referred to as a template method) enables subclasses to create their own versions of the protected methods that implement the individual steps in the process. The process is specialized for the subclass.
Implement this technique as shown here:
classdef Super methods (Sealed) function foo(obj) step1(obj) % Call step1 step2(obj) % Call step2 step3(obj) % Call step3 end end methods (Access = protected) function step1(obj) % Superclass version end function step2(obj) % Superclass version end function step3(obj) % Superclass version end end end
The subclass does not override the
foo method. Instead it overrides only the protected methods that perform the series of steps (
step3(obj)). This technique enables the subclass to specialize the actions taken by each step, but not control the order of the steps in the process. When you pass a subclass object to the superclass
foo method, MATLAB calls the subclass step methods because of the dispatching rules. For more information on method dispatching, see Method Invocation.
classdef Sub < Super ... methods (Access = protected) function step1(obj) % Subclass version end function step2(obj) % Subclass version end function step3(obj) % Subclass version end ... end end
You can completely redefine a superclass method in a subclass. In this case, both the superclass and the subclass would define a method with the same name. However, the implementation would be different and the subclass method would not call the superclass method. Creating independent versions of the same-named method can be necessary when the same operation requires different implementation on the superclass and subclass.
classdef Super methods function foo(obj) % Superclass implementation end end end
classdef Sub < Super methods function foo(obj) % Subclass implementation end end end
Abstract methods have no implementation. Subclasses that inherit abstract methods must provide a subclass-specific implementation for the subclass to be a concrete class. For more information, see Abstract Classes and Class Members.
classdef Super methods (Abstract) foo(obj) % Abstract method without implementation end end
classdef Sub < Super methods function foo(obj) % Subclass implementation of concrete method end end end