Documentation

Purpose of Class Constructor Methods

A constructor method is a special function that creates an instance of the class. Typically, constructor methods accept input arguments to assign the data stored in properties and return an initialized object.

For a basic example, see Create a Simple Class.

All MATLAB^® classes have a default constructor method. This method returns an object of the class that is created with no input arguments. A class can define a constructor method that overrides the default constructor. An explicitly defined constructor can accept input arguments, initialize property values, call other methods, and perform other operations necessary to create objects of the class.

Basic Structure of Constructor Methods

Constructor methods can be structured into three basic sections:

This code illustrates the basic operations performed in each section:

classdef ConstructorDesign < BaseClass1
   properties
      ComputedValue
   end
   methods
      function obj = ConstructorDesign(a,b,c)
         
         %% Pre Initialization %%
         % Any code not using output argument (obj)
         if nargin == 0
            % Provide values for superclass constructor
            % and initialize other inputs
            a = someDefaultValue;
            args{1} = someDefaultValue;
            args{2} = someDefaultValue;
         else
            % When nargin ~= 0, assign to cell array,
            % which is passed to supclass constructor
            args{1} = b;
            args{2} = c;
         end
         compvalue = myClass.staticMethod(a);
         
         %% Object Initialization %%
         % Call superclass constructor before accessing object
         % You cannot conditionalize this statement
         obj = obj@BaseClass1(args{:});
         
         %% Post Initialization %%
         % Any code, including access to object
         obj.classMethod(arg);
         obj.ComputedValue = compvalue;
         ...
      end
   ...
   end
...
end

Call the constructor like any function, passing arguments and returning an object of the class.

obj = ConstructorDesign(a,b,c);

Guidelines for Constructors

Default Constructor

If a class does not define a constructor, MATLAB supplies a constructor that takes no arguments and returns a scalar object whose properties are initialized to property default values. The default constructor supplied by MATLAB also calls all superclass constructors with no arguments or with any argument passed to the default subclass constructor.

When a subclass does not define a constructor, the default constructor passes its inputs to the direct supeclass constructor. This behavior is useful when there is not need for a subclass to define a constructor, but the superclass constructor does require input arguments.

When to Define Constructors

Define a constructor method to perform object initialization that a default constructor cannot perform. For example, when creating an object of the class requires:

Related Information

For information specific to constructing enumerations, see Enumeration Class Constructor Calling Sequence.

For information on creating object arrays in the constructor, see Construct Object Arrays.

If the class being created is a subclass, MATLAB calls the constructor of each superclass class to initialize the object. Implicit calls to the superclass constructor are made with no arguments. If superclass constructors require arguments, call them from the subclass constructor explicitly. See Control Sequence of Constructor Calls

Initializing Objects in Constructor

Constructor methods must return an initialized object as the only output argument. The output argument is created when the constructor executes, before executing the first line of code.

For example, the following constructor function can assign the value of the object's property A as the first statement because the object obj has already been assigned to an instance of myClass.

function obj = myClass(a,b,c)
   obj.A = a;
      ...
end

You can call other class methods from the constructor because the object is already initialized.

The constructor also creates an object whose properties have their default values—either empty ([]) or the default value specified in the property definition block.

For example, the following code calls the class method CalculateValue to assign the value of the property Value.

function obj = myClass(a,b,c)
   obj.Value = obj.CalculateValue(a,b);
      ...
end

% obj is the object being constructed
function obj = myClass(arg) 
   obj.propert1 = arg*10;
   obj.method1;
      ...
end

No Input Argument Constructor Requirement

There are cases where the constructor must be able to be called with no input argument:

If there are no input arguments, the constructor creates an object using only default properties values. A good practice is to add a check for zero arguments to the class constructor to prevent an error if either of these two cases occur:

function obj = myClass(a,b,c)
   if  nargin > 0
      obj.A = a;
      obj.B = b;
      obj.C = c;
      ...
   end
end

For ways to handle superclass constructors, see Basic Structure of Constructor Methods.

Subclass Constructors

Subclass constructor methods can explicitly call superclass constructors to pass arguments to the superclass constructor. The subclass constructor must specify these arguments in the call to the superclass constructor using the constructor output argument. Here is the syntax:

classdef MyClass < SuperClass 
   function obj = MyClass(arg)
      obj@SuperClass(SuperArgList);
         ...
   end
end

The class constructor must make all calls to superclass constructors before any other references to the object (obj). This restriction include assigning property values or calling ordinary class methods. Also, a subclass constructor can call a superclass constructor only once.

classdef MyClass < SuperClass

classdef Cube < Shape
   properties
      SideLength = 0
      Color = [0 0 0]
   end
   methods
      function cubeObj = Cube(length,color,upvector,viewangle)
         if nargin == 0
            super_args{1} = [0 0 1];
            super_args{2} = 10;
         elseif nargin == 4
            super_args{1} = upvector;
            super_args{2} = viewangle;
         else
            error('Wrong number of input arguments')
         end
         cubeObj@Shape(super_args{:});
         if nargin > 0 % Use value if provided
            cubeObj.SideLength = length;
            cubeObj.Color = color;
         end
         ...
      end
   ...
   end
end

methods
   function cubeObj = Cube(length,color,upvector,viewangle)
      if nargin == 0 
         super_args = {};
      elseif nargin == 4
         super_args{1} = upvector;
         super_args{2} = viewangle;
      else
         error('Wrong number of input arguments')
      end
      cubeObj@Shape(super_args{:});
      if nargin > 0 
         cubeObj.SideLength = length;
         cubeObj.Color = color;
      end
   ...
   end
end

Implicit Call to Inherited Constructor

MATLAB passes arguments implicitly from a default subclass constructor to the superclass constructor. This behavior eliminates the need to implement a constructor method for a subclass only to pass arguments to the superclass constructor.

For example, the following class constructor requires one input argument (a datetime object), which the constructor assigns to the CurrentDate property.

classdef BaseClassWithConstr
   properties
      CurrentDate datetime
   end
   methods
      function obj = BaseClassWithConstr(dt)
         obj.CurrentDate = dt;
      end
   end        
end

Suppose you create a subclass of BaseClassWithConstr, but your subclass does not require an explicit constructor method.

classdef SubclassDefaultConstr < BaseClassWithConstr
   ...
end

You can construct an object of the SubclassDefaultConstr by calling its default constructor with the superclass argument:

obj = SubclassDefaultConstr(datetime);

For information on subclass constructors, see Subclass Constructors and Default Constructor.

Errors During Class Construction

For handle classes, MATLAB calls the delete method when an error occurs under the following conditions:

MATLAB calls the delete method on the object, the delete methods for any objects contained in properties, and the delete methods for any initialized base classes.

Depending on when the error occurs, MATLAB can call the class destructor before the object is fully constructed. Therefore class delete methods must be able to operate on partially constructed objects that might not have values for all properties. For more information, see Support Destruction of Partially Constructed Objects.

For information on how objects are destroyed, see Handle Class Destructor.

Output Object Suppressed

You can suppress the assignment of the class instance to the ans variable when no output variable is assigned in a call to the constructor. This technique is useful for apps that creates graphical interface windows that hold onto the constructed objects. These apps do not need to return the object.

Use nargout to determine if the constructor has been called with an output argument. For example, the class constructor for the MyApp class clears the object variable, obj, if called with no output assigned:

classdef MyApp
   methods
      function obj = MyApp
         ...
         if nargout == 0
            clear obj
         end
      end
      ...
   end
end

When a class constructor does not return an object, MATLAB does not trigger the meta.class InstanceCreated event.