Why can't a concrete subclass use size and validator functions on abstract superclass properties?

Hello all,

I will throw together a little example here; lets create an abstract super class (containing mixed abstract and concrete properties),

classdef (Abstract) abstractSuper
   properties
       conc (:,1) = zeros(10,1)
   end
   
   properties (Abstract)
      abst  
   end
end

where conc is a concrete property initially set for all sub-classes, and I have some abstract property that may have abstract methods associated with it.

Now I create a concrete sub-class.

classdef concreteSub < abstractSuper
   properties 
       abst (1,3) char = 'tst';    
   end     
end

where I want to enforce the property abst as being a 1x3 char vector. Unfortunately, trying to instantiate a concreteSubObj returns

"Error using concreteSub

Size and validator functions not supported for properties defined as abstract in superclasses. Property 'abst' is defined as abstract property in

superclass 'abstractSuper'."

Question

I understand that I cannot use the size/validator in my concrete class, since I defined it as abstract in my super. I do not understand why, since I thought that the point of abstraction was to define an interface, while leaving complete freedom to the concrete subclasses. I also cannot partially define abst in abstractSuper and override it in concreteSub, (e.g. define it in the super, and then add the size/validator function to the sub-class).

I had hoped to do something like force the property to be a character vector in the super, and then be 3 chars long in the sub, but that is even further beyond where I am stuck in this example.

TLDR: Why does defining an abstract property in a superclass prevent me from using size/validator functions in the concrete sub-class?

Answer 1

[per isakson]

The R2019b doc on Validate Property Values says

[...]

Abstract Property Validation

You can define property validation for abstract properties. The validation applies to all subclasses that implement the property. However, subclasses cannot use any validation on their implementation of the property. When inheriting validation for a property from multiple classes, only a single Abstract property in one superclass can define the validation. None of the superclasses can define the property as nonAbstract.

Try this

>> cs = concreteSub
cs = 
  concreteSub with properties:
    abst: 'tst'
    conc: [10×1 double]

where

classdef (Abstract) abstractSuper
   properties
       conc (:,1) = zeros(10,1)
   end
   properties (Abstract)
      abst (1,3) char
   end
end

classdef concreteSub < abstractSuper
   properties 
       abst = 'tst';    
   end     
end

Answer 2

[Nikolaus Koopmann]

i have the same question

Answer 3

[Sören Kohnert]

You can use a set method in comination with assert() in your subclass to define different validators for each subclass.

classdef (Abstract) abstractSuper
   properties (Abstract)
      abst  
   end
end

classdef concreteSub < abstractSuper
   properties 
       abst   
   end 
   methods
       function obj = set.abst(obj,value)
           assert(ischar(value) && all(size(value) == [1,3]))
           obj.abst = value;
       end
       
   end
end

[Nikolaus Koopmann]

or like

classdef concreteSub < abstractSuper
   properties 
       abst   
   end 
   methods
       function obj = set.abst(obj,value)
           validateattributes(value,{'char'},{'size',[1 3]});
           obj.abst = value;
       end
       
   end
end