Behavior of Inherited Built-In Methods

Subclass double

Most built-in functions used with built-in classes are actually methods of the built-in class. For example, the double and single classes define several methods to perform arithmetic operations, indexing, matrix operation, and so on. All these built-in class methods work with subclasses of the built-in class.

Subclassing double enables your class to use features without implementing the methods that a MATLAB^® built-in class defines.

The DocSimpleDouble class subclasses the built-in double class.

classdef DocSimpleDouble < double
   methods
      function obj = DocSimpleDouble(data)
         if nargin == 0
            data = 0;
         end
         obj = obj@double(data);
      end
   end
end

Create an instance of the class DocSimpleDouble.

sc = DocSimpleDouble(1:10)

sc = 
   1x10 DocSimpleDouble:
  double data:
     1     2     3     4     5     6     7     8     9    10

Call a method inherited from class double that operates on the data, such as sum. sum returns a double and, therefore, uses the display method of class double:

sum(sc)

ans =
    55

Index sc like an array of doubles. The returned value is the class of the subclass:

a = sc(2:4)

a = 
  1x3 DocSimpleDouble:
  double data:
     2     3     4

Indexed assignment works the same as the built-in class. The returned value is the class of the subclass:

sc(1:5) = 5:-1:1

sc = 
   1x10 DocSimpleDouble:
  double data:
     5     4     3     2     1     6     7     8     9    10

Calling a method that modifies the order of the data elements operates on the data, but returns an object of the subclass:

sc = DocSimpleDouble(1:10);
sc(1:5) = 5:-1:1;
a = sort(sc)

a = 
   1x10 DocSimpleDouble:
  double data:
     1     2     3     4     5     6     7     8     9    10

Built-In Data Value Methods

When you call a built-in data value method on a subclass object, MATLAB uses the superclass part of the subclass object as inputs to the method. The value returned is same class as the built-in class. For example:

sc = DocSimpleDouble(1:10);
a = sin(sc);
class(a)

ans =

double

Built-In Data Organization Methods

This group of built-in methods reorders or reshapes the input argument array. These methods operate on the superclass part of the subclass object, but return an object of the same type as the subclass.

sc = DocSimpleDouble(randi(9,1,10))

sc = DocSimpleDouble(randi(9,1,10))

sc = 

  1x10 DocSimpleDouble:

  double data:
     6     1     8     9     7     7     7     4     6     2

b = sort(sc)

b = 

  1x10 DocSimpleDouble:

  double data:
     1     2     4     6     6     7     7     7     8     9

Methods in this group include:

Built-In Indexing Methods

When you use indexing to reference into an object that inherits from a built-in class, only the built-in data is referenced, not the properties defined by your subclass. You cannot make indexed references if your subclass defines properties, unless your subclass overrides the default subsref method.

For example, indexing element 2 in the DocSimpleDouble subclass object returns the second element in the vector.

sc = DocSimpleDouble(1:10);
a = sc(2)

a = 
  DocSimpleDouble
  double data:
     2

The value returned from an indexing operation is an object of the subclass.

Assigning a new value to the second element in the DocSimpleDouble object operates only on the superclass data.

sc(2) = 12

sc = 
   1x10 DocSimpleDouble:
  double data:
     1    12     3     4     5     6     7     8     9    10

The subsref method also implements dot notation for methods.

Built-In Concatenation Methods

Built-in classes use the functions horzcat, vertcat, and cat to implement concatenation. When you use these functions with subclass objects of the same type, MATLAB concatenates the superclass data to form a new object. For example, you can concatenate objects of the DocSimpleDouble class:

sc1 = DocSimpleDouble(1:10);
sc2 = DocSimpleDouble(11:20);
[sc1,sc2]

ans = 
  1x20 DocSimpleDouble:
  double data:
  Columns 1 through 13
     1     2     3     4     5     6     7     8     9    10    11    12    13
  Columns 14 through 20
    14    15    16    17    18    19    20

[sc1;sc2]

ans = 
  2x10 DocSimpleDouble:
  double data:
     1     2     3     4     5     6     7     8     9    10
    11    12    13    14    15    16    17    18    19    20

Concatenate two objects along a third dimension:

c = cat(3,sc1,sc2)

c = 

  1x10x2 DocSimpleDouble:

  double data:

(:,:,1) =

     1     2     3     4     5     6     7     8     9    10


(:,:,2) =

    11    12    13    14    15    16    17    18    19    20

If the subclass of a built-in class defines properties, you cannot concatenate objects of the subclass. There is no way to determine how to combine properties of different objects. However, your subclass can define custom horzcat and vertcat methods to support concatenation in whatever way makes sense for your subclass.