Documentation

This is machine translation

Translated by Microsoft
Mouse over text to see original. Click the button below to return to the English verison of the page.

Packages Create Namespaces

Package Folders

Packages are special folders that can contain class folders, function, and class definition files, and other packages. The names of classes and functions are scoped to the package folder. A package is a namespace within which names must be unique. Function and class names must be unique only within the package. Using a package provides a means to organize classes and functions. Packages also enable you to reuse the names of classes and functions in different packages.

    Note:   Packages are not supported for classes created prior to MATLAB® Version 7.6 (that is, classes that do not use classdef).

Package folders always begin with the + character. For example,

+mypack
+mypack/pkfcn.m  % a package function
+mypack/@myClass % class folder in a package

The parent of the top-level package folder must be on the MATLAB path.

Listing the Contents of a Package

List the contents of a package using the help command:

help event
Contents of event:

EventData                      - event.EVENTDATA    Base class for event data 
PropertyEvent                  - event.PROPERTYEVENT    Event data for object property events
listener                       - event.LISTENER    Listener object
proplistener                   - event.PROPLISTENER    Listener object for property events

You can also use the what command:

what event
Classes in directory Y:xxx\matlab\toolbox\matlab\lang\+event

EventData      PropertyEvent  listener       proplistener  

Internal Packages

MathWorks® reserves the use of packages named internal for utility functions used by internal MATLAB code. Functions that belong to an internal package are intended for MathWorks use only. Using functions or classes that belong to an internal package is discouraged. These functions and classes are not guaranteed to work in a consistent manner from one release to the next. Any of these functions and classes might be removed from the MATLAB software in any subsequent release without notice and without documentation in the product release notes.

Referencing Package Members Within Packages

All references to packages, functions, and classes in the package must use the package name prefix, unless you import the package. (See Import Classes.) For example, call this package function:

+mypack/pkfcn.m

With this syntax:

z = mypack.pkfcn(x,y);

Definitions do not use the package prefix. For example, the function definition line of the pkfcn.m function would include only the function name:

function z = pkfcn(x,y)

Define a package class with only the class name:

classdef myClass

but call it with the package prefix:

obj = mypack.myClass(arg1,arg2,...);

Calling class methods does not require the package name because you have an object of the class. You can use dot or function notation:

obj.myMethod(arg)
myMethod(obj,arg)

A static method requires the full class name, which includes the package name:

mypack.myClass.stMethod(arg)

Referencing Package Members from Outside the Package

Functions, classes, and other packages contained in a package are scoped to that package. To reference any of the package members, prefix the package name to the member name, separated by a dot. For example, the following statement creates an instance of MyClass, which is contained in mypack package.

obj = mypack.MyClass;

Accessing Class Members — Various Scenarios

This section shows you how to access various package members from outside a package. Suppose that you have a package mypack with the following contents:

+mypack
+mypack/myfcn.m
+mypack/@MyFirstClass
+mypack/@MyFirstClass/myFcn.m
+mypack/@mMyFirstClass/otherFcn.m
+mypack/@MyFirstClass/MyFirstClass.m
+mypack/@MySecondClass
+mypack/@MySecondClass/MySecondClass.m
+mypack/+mysubpack
+mypack/+mysubpack/myFcn.m

Invoke the myFcn function in mypack:

mypack.myFcn(arg)

Create an instance of each class in mypack:

obj1 = mypack.MyFirstClass;
obj2 = mypack.MySecondClass(arg);

Invoke the myFcn function that is in the package mysubpack:

mypack.mysubpack.myFcn(arg1,arg2);

If mypack.MyFirstClass has a method called myFcn, call it like any method call on an object:

obj = mypack.MyFirstClass;
myFcn(obj,arg);

If mypack.MyFirstClass has a property called MyProp, assign it using dot notation and the object:

obj = mypack.MyFirstClass;
obj.MyProp = x;

Packages and the MATLAB Path

You cannot add package folders to the MATLAB path, but you must add the package parent folder to the MATLAB path. Package members are not accessible if the package parent folder is not on the MATLAB path, even if the package folder is the current folder. Making the package folder the current folder is not sufficient to add the package parent folder to the path.

Package members remain scoped to the package. Always refer to the package members using the package name. Alternatively, import the package into the function in which you call the package member, see Import Classes.

Package folders do not shadow other package folders that are positioned later on the path, unlike classes, which do shadow other classes. If two or more packages have the same name, MATLAB treats them all as one package. If redundantly named packages in different path folders define the same function name, then MATLAB finds only one of these functions.

Resolving Redundant Names

Suppose a package and a class have the same name. For example:

fldr_1/+foo
fldr_2/@foo/foo.m

A call to which foo returns the path to the executable class constructor:

>> which foo
fldr_2/@foo/foo.m

A function and a package can have the same name. However, a package name by itself is not an identifier. Therefore, if a redundant name occurs alone, it identifies the function. Executing a package name alone returns an error.

Package Functions vs. Static Methods

In cases where a package and a class have the same name, a static method takes precedence over a package function. For example, path folder fldrA contains a package function and path folder fldrB contains a class static method:

fldrA/+foo/bar.m % bar is a function in package foo
fldrB/@foo/bar.m % bar is a static method of class foo

A call to which foo.bar returns the path to the static method:

which foo.bar
fldrB/@foo/bar.m

In cases where the same path folder contains both package and class folders with the same name, the class static method takes precedence over the package function.

fldr/@foo/bar.m % bar is a static method of class foo
fldr/+foo/bar.m % bar is a function in package foo

A call to which foo.bar returns the path to the static method:

which foo.bar
fldr/@foo/bar.m

More About

Was this topic helpful?