MATLAB: Editing superclass properties from subclasses

classoopsubclasssuperclass

Hi!

I have a question related to the Matlab example http://www.mathworks.com/help/matlab/matlab_oop/a-simple-class-hierarchy.html. For testing I use:

ds = DocSavings;
db = DocBond;

I can change the superclass property "Description" with

ds.Description = 'test';

However, listing "db" properties shows an empty "Description" string. Is there a way to synchronize superclass properties? Is using events and listeners of handle classes the only possible way?

Maybe: Another way is to use the subclasses as normal classes and define objects of these classes as properties of the former superclass?

Is there a better solution?

Best Answer

Why do you want different objects to share ( "synchronize" ) property values? However, without looking at the documentation you refer to.

    super = SuperClass;
    sub = SubClass;
    sub.handle.Description = 'Hello';
    super.handle.Description
    super.handle.Description = 'World';
    sub.handle.Description

returns

    ans =
    Hello
    ans =
    World

where

    classdef   SuperClass < handle
        properties
            handle = DescriptionContainer();
        end
    end

and

    classdef   DescriptionContainer < handle
        properties
            Description
        end
    end

and

    classdef    SubClass < SuperClass
        properties
            another_property
        end
    end

With the help of a dependent property together with set and get methods, I think it would be possible to hide (Access=protected) the property, which I call "handle".

The word, "Editing", in the subject line makes me unsure regarding your intent.

"Maybe: Another way ..." sounds strange to me. Wouldn't that overly complicate the dependencies.

"events and listeners" if nothing else it complicates the debugging.

Related Solutions

MATLAB: Using builtin assignment for classes that overload the assignment operator ‘=’

You are correct, your code does throw an error about recursion limits. However, I believe the operator you are interested in overloading is the subscripted assignment operator, "subsasgn". This will allow you to do:

obj.myProperty = value;

and call you own set function without receiving an error about the recursion limit. Here is what the class definition would look like:

classdef myClass < hgsetget
    properties
       myProperty
    end
    methods
      function mySetFunction(obj,value)
           obj.myProperty = value;
      end
         function a = subsasgn(a,s,b)
             if strcmp(s.subs,'myProperty')
                 mySetFunction(a,b);
             end
         end
      end
  end

MATLAB: Modifying an immutable/protected variable of a subclass in a superclass method

You're trying to break the fundamental model of OOP: encapsulation. The whole concept of protected properties is that only the class (or its subclasses) can modify them. A superclass has no way to modify the properties of its subclasses. For that matter, there's no guarantee that a subclass would have the propery that it's trying to modify.

Secondly, why are you trying this indirect method for setting properties? Can't you just set the properties of the subclass the normal way? Or even just override your setProperties method in the subclass?

If you really want to set the properties from the superclass, what you can do though is have a method setsubProperties in the superclass that you then override in the subclass. You dispatch to this method from the setProperties method:

classdef Sup < handle %has to be a handle class to modify its own properties
    methods
       function setProperties(this, varargin)
           this.setsubProperties(varargin);
       end
   end 
     methods (Access = protected)
         function setsubProperties(this, varargin)
              error('function must be overriden');
         end
     end
  end
classdef sub < Sup
    methods (Access = proteced)
       function setsubProperties(this, varargin)
           for varg = 1:2:numel(varargin)
               %...
           end
       end
    end
 end

Best Answer

Related Solutions

MATLAB: Using builtin assignment for classes that overload the assignment operator ‘=’

MATLAB: Modifying an immutable/protected variable of a subclass in a superclass method

Related Question