Class Members Access

Basic Knowledge

The material presented in this section builds on an understanding of these concepts:

 Terminology and Concepts

• Class members — Properties, methods, and events defined by a class

• Defining class — The class defining the class member for which access is being specified

• Get access — Permission to read the value of a property, controlled by the property GetAccess attribute

• Set access — Permission to assign a value to a property; controlled by the property SetAccess attribute

• Method access – Determines what other methods and functions can call the class method; controlled by the method Access attribute

• Listen access — Permission to define listeners; controlled by the event ListenAccess attribute

• Notify access — Permission to trigger events, controlled by the event NotifyAccess attribute

 Possible Values for Access to Class Members

The following class member attributes can contain a list of classes:

• Properties — Access, GetAccess, and SetAccess. For a list of all property attributes, see Property Attributes.

• Methods — Access. For a list of all method attributes, see Method Attributes.

• Events — ListenAccess and NotifyAccess. For a list of all event attributes, see Event Attributes.

These attributes accept these values:

• public — Unrestricted access

• protected — Access by defining class and its subclasses

• private — Access by defining class only

• Access list — A list of one or more classes. Only the defining class and the classes in the list have access to the class members to which the attribute applies. If you specify a list of classes, MATLAB^® does not allow access by any other class (that is, access is private, except for the listed classes).

Applications for Access Control Lists

Access control lists enable you to control access to specific class properties, methods, and events. Access control lists specify a list of classes to which you grant access to these class members.

This technique provides greater flexibility and control in the design of a system of classes. For example, use access control lists to define separate classes, but not allow access to class members from outside the class system.

Specify Access to Class Members

Specify the classes that are allowed to access a particular class member in the member access attribute statement. For example:

methods (Access = {?ClassName1,?ClassName2,...})

Use the class matlab.metadata.Class object to refer to classes in the access list. To specify more than one class, use a cell array of matlab.metadata.Class objects. Use the namespace name when referring to classes that are in namespaces.

Note

Specify the matlab.metadata.Class objects explicitly (created with the ? operator), not as values returned by functions or other MATLAB expressions.

How MATLAB Interprets Attribute Values

• Granting access to a list of classes restricts access to only:

  • The defining class

  • The classes in the list

  • Subclasses of the classes in the list

• Including the defining class in the access list gives all subclasses of the defining class access.

• MATLAB resolves references to classes in the access list only when the class is loaded. If MATLAB cannot find a class that is included in the access list, that class is effectively removed from access.

• MATLAB replaces unresolved matlab.metadata.Class entries in the list with empty matlab.metadata.Class objects.

• An empty access list (that is, an empty cell array) is equivalent to private access.

Specify Metaclass Objects

Generate the matlab.metadata.Class objects using only the ? operator and the class name. Values assigned to the attributes cannot contain any other MATLAB expressions, including functions that return allowed attribute values:

• matlab.metadata.Class objects

• Cell arrays of matlab.metadata.Class objects

• The values public, protected, or private

Specify these values explicitly, as shown in the example code in this section.

Properties with Access Lists

These sample classes show the behavior of a property that grants read access (GetAccess) to a class. The GrantAccess class gives GetAccess to the NeedAccess class for the Prop1 property:

classdef GrantAccess
   properties (GetAccess = ?NeedAccess)
      Prop1 = 7
   end
end

The NeedAccess class defines a method that uses the value of the GrantAccess Prop1 value. The dispObj method is defined as a Static method, however, it could be an ordinary method.

classdef NeedAccess
   methods (Static)
      function dispObj(GrantAccessObj)
         disp(['Prop1 is: ',num2str(GrantAccessObj.Prop1)])
      end
   end
end

Get access to Prop1 is private so MATLAB returns an error if you attempt to access the property from outside the class definition. For example, from the command line:

a = GrantAccess;
a.Prop1

Getting the 'Prop1' property of the 'GrantAccess' class is not allowed.

However, MATLAB allows access to Prop1 by the NeedAccess class:

NeedAccess.dispObj(a)

Prop1 is: 7

Methods with Access Lists

Classes granted access to a method can:

• Call the method using an instance of the defining class.

• Define their own method with the same name (if not a subclass).

• Override the method in a subclass only if the superclass defining the method includes itself or the subclass in the access list.

These sample classes show the behavior of methods called from methods of other classes that are in the access list. The class AcListSuper gives the AcListNonSub class access to its m1 method:

classdef AcListSuper
   methods (Access = {?AcListNonSub})
      function obj = m1(obj)
         disp ('Method m1 called')
      end
   end
end

Because AcListNonSub is in the access list of m1, its methods can call m1 using an instance of AcListSuper:

classdef AcListNonSub
   methods
      function obj = nonSub1(obj,AcListSuper_Obj)
         % Call m1 on AcListSuper class
         AcListSuper_Obj.m1;
      end
      function obj = m1(obj)
         % Define a method named m1
         disp(['Method m1 defined by ',class(obj)])
      end
   end
end

Create objects of both classes:

a = AcListSuper;
b = AcListNonSub;

Call the AcListSuper m1 method using an AcListNonSub method:

b.nonSub1(a);

Method m1 called

Call the AcListNonSub m1 method:

b.m1;

Method m1 defined by AcListNonSub

Subclasses Without Access

Including the defining class in the access list for a method grants access to all subclasses derived from that class. When you derive from a class that has a method with an access list and that list does not include the defining class:

• Subclass methods cannot call the superclass method.

• Subclass methods can call the superclass method indirectly using an instance of a class that is in the access list.

• Subclasses cannot override the superclass method.

• Methods of classes that are in the superclass method access list, but that are not subclasses, can call the superclass method.

For example, AcListSub is a subclass of AcListSuper. The AcListSuper class defines an access list for method m1. However, this list does not include AcListSuper, so subclasses of AcListSuper do not have access to method m1:

classdef AcListSub < AcListSuper
   methods
      function obj = sub1(obj,AcListSuper_Obj)
         % Access m1 via superclass object (***NOT ALLOWED***)
         AcListSuper_Obj.m1;
      end
      function obj = sub2(obj,AcListNonSub_Obj,AcListSuper_obj)
         % Access m1 via object that is in access list (is allowed)
         AcListNonSub_Obj.nonSub1(AcListSuper_Obj);
      end
   end
end

No Direct Call to Superclass Method

Attempting to call the superclass m1 method from the sub1 method results in an error because subclasses are not in the access list for m1:

a = AcListSuper;
c = AcListSub;
c.sub1(a);

Cannot access method 'm1' in class 'AcListSuper'.

Error in AcListSub/sub1 (line 4)
         AcListSuper_Obj.m1;

Indirect Call to Superclass Method

You can call a superclass method from a subclass that does not have access to that method using an object of a class that is in the superclass method access list.

The AcListSub sub2 method calls a method of a class (AcListNonSub) that is on the access list for m1. This method, nonSub1, does have access to the superclass m1 method:

a = AcListSuper;
b = AcListNonSub;
c = AcListSub;
c.sub2(b,a);

Method m1 called

No Redefining Superclass Method

When subclasses are not included in the access list for a method, those subclasses cannot define a method with the same name. This behavior is not the same as cases in which the method Access is explicitly declared as private.

For example, adding the following method to the AcListSub class definition produces an error when you attempt to instantiate the class.

methods (Access = {?AcListNonSub})
   function obj = m1(obj)
      disp('AcListSub m1 method')
   end
end

c = AcListSub;

Class 'AcListSub' is not allowed to override the method 'm1' because neither it nor its
superclasses have been granted access to the method by class 'AcListSuper'.

Call Superclass from Listed Class Via Subclass

The AcListNonSub class is in the m1 method access list. This class can define a method that calls the m1 method using an object of the AcListSub class. While AcListSub is not in the access list for method m1, it is a subclass of AcListSuper.

For example, add the following method to the AcListNonSub class:

methods
   function obj = nonSub2(obj,AcListSub_Obj)
      disp('Call m1 via subclass object:')
      AcListSub_Obj.m1;
   end
end

Calling the nonSub2 method results in execution of the superclass m1 method:

b = AcListNonSub;
c = AcListSub;
b.nonSub2(c);

Call m1 via subclass object:
Method m1 called

This behavior is consistent with the behavior of any subclass object, which can substitute for an object of its superclass.

Abstract Methods with Access Lists

A class containing a method declared as Abstract is an abstract class. It is the responsibility of subclasses to implement the abstract method using the function signature declared in the class definition.

When an abstract method has an access list, only the classes in the access list can implement the method. A subclass that is not in the access list cannot implement the abstract method so that subclass is itself abstract.

Related Topics

• Property Attributes
• Method Access List
• Event Access List