I have this class:

```
class ListView: UIView {

    var labels: [UnderlineLabel]

    var listItems: [String] {   return []   }
    var areUnselectable: Bool {   return false   }

...
}

```

I've been using this class up until now by subclassing it and overriding it's computed properties. But now I'm in a situation where I need to use this class, but the only change I need to make is to the `listItems` property (which provides the list of strings, that are turned into `UnderlineLabels`, and can be selected (underlined)). So I'm figuring that rather than subclass `ListView` for such a trivial change, and for a single use-case, it'd be better to refactor the class to enable use by composition.

I've only been able to come up with one solution that allows me to preserve computed property semantics (`listItems` instead of `getListItems()`) and offer customizability to subclasses via overriding, and to instantiators through initializing:

1. Create an additional stored property, perhaps `private let getListItems: (() -> [String])?`
2. Return the result of that, or `[]` if `nil`, by default in `listItems`
3. Allow `getListItems` to be initialized by passing a custom value in `init`

Is this the only way to get the capability I want? And if not, is there a more definitive way of doing this?

Keep in mind that the reason `listItems` is a computed property is to give the list the ability to change during execution.