## Define Enumeration Classes

### Enumeration Class

Create an enumeration class by adding an `enumeration` block to a class definition. For example, the `WeekDays` class enumerates a set of days of the week.

```classdef WeekDays enumeration Monday, Tuesday, Wednesday, Thursday, Friday end end```

To execute the MATLAB® code in the following sections, place the `WeekDays` class definition in a `.m` file on your path.

### Construct an Enumeration Member

Refer to an enumeration member using the class name and the member name:

`ClassName.MemberName`

For example, assign the enumeration member `WeekDays.Tuesday` to the variable `today`:

`today = WeekDays.Tuesday;`

`today` is a variable of class `WeekDays`:

`whos`
``` Name Size Bytes Class Attributes today 1x1 104 WeekDays ```
`today`
```today = Tuesday```

### Convert to Superclass Value

If an enumeration class specifies a superclass, you can convert an enumeration object to the superclass by passing the object to the superclass constructor. However, the superclass constructor must be able to accept its own class as input and return an instance of the superclass. MATLAB built-in numeric classes, such as `uint32`, allow this conversion.

For example, the `Bearing` class derives from the `uint32` built-in class:

```classdef Bearing < uint32 enumeration North (0) East (90) South (180) West (270) end end```

Assign the `Bearing.East` member to the variable `a`:

`a = Bearing.East;`

Pass `a` to the superclass constructor and return a `uint32` value:

```b = uint32(a); whos```
``` Name Size Bytes Class Attributes a 1x1 4 Bearing b 1x1 4 uint32 ```

The `uint32` constructor accepts an object of the subclass `Bearing` and returns an object of class `uint32`.

### Define Methods in Enumeration Classes

Define methods in an enumeration class like any MATLAB class. For example, define a method called `isMeetingDay` for the `WeekDays` enumeration class. The use case is that the user has a recurring meeting on Tuesdays. The method checks if the input argument is an instance of the `WeekDays` member `Tuesday`.

```classdef WeekDays enumeration Monday, Tuesday, Wednesday, Thursday, Friday end methods function tf = isMeetingDay(obj) tf = WeekDays.Tuesday == obj; end end end```

Call `isMeetingDay` with an instance of the `WeekDays` class:

```today = WeekDays.Tuesday; today.isMeetingDay ```
```ans = 1```

You can also use the enumeration member as a direct input to the method:

```isMeetingDay(WeekDays.Wednesday) ```
```ans = 0```

### Define Properties in Enumeration Classes

Add properties to an enumeration class when you must store data related to the enumeration members. Set the property values in the class constructor. For example, the `SyntaxColors` class defines three properties. The class constructor assigns the values of the input arguments to the corresponding properties when you reference a class member.

```classdef SyntaxColors properties R G B end methods function c = SyntaxColors(r, g, b) c.R = r; c.G = g; c.B = b; end end enumeration Error (1, 0, 0) Comment (0, 1, 0) Keyword (0, 0, 1) String (1, 0, 1) end end```

When you refer to an enumeration member, the constructor initializes the property values:

```e = SyntaxColors.Error; e.R```
```ans = 1```

Because `SyntaxColors` is a value class (it does not derive from `handle`), only the class constructor can set property values:

```e.R = 0 ```
`You cannot set the read-only property 'R' of SyntaxColors.`

For more information on enumeration classes that define properties, see Mutable Handle vs. Immutable Value Enumeration Members.

### Enumeration Class Constructor Calling Sequence

Each statement in an enumeration block is the name of an enumeration member, optionally followed by an argument list. If the enumeration class defines a constructor, MATLAB calls the constructor to create the enumerated instances.

MATLAB provides a default constructor for all enumeration classes that do not explicitly define a constructor. The default constructor creates an instance of the enumeration class:

• Using no input arguments, if the enumeration member defines no input arguments

• Using the input arguments defined in the enumeration class for that member

For example, the input arguments for the `Bool` class are `0` for `Bool.No` and `1` for `Bool.Yes`.

```classdef Bool < logical enumeration No (0) Yes (1) end end```

The values of `0` and `1` are of class `logical` because the default constructor passes the argument to the first superclass. That is, this statement:

`n = Bool.No;`

Results in a call to `logical` that is equivalent to the following statement in a constructor:

```function obj = Bool(val) obj@logical(val) end```

MATLAB passes the member argument only to the first superclass. For example, suppose `Bool` derived from another class:

```classdef Bool < logical & MyBool enumeration No (0) Yes (1) end end```

The `MyBool` class can add some specialized behavior:

```classdef MyBool methods function boolValues = testBools(obj) ... end end end```

The default `Bool` constructor behaves as if defined like this function:

• Argument passed to first superclass constructor

• No arguments passed to subsequent constructors

```function obj = Bool(val) obj@logical(val) obj@MyBool end```