class(n) TclOO Commands class(n)

```

```

# [NAME](#NAME)

oo::class - The class of all classes

# [SYNOPSIS](#SYNOPSIS)

```
package require tcl::oo
oo::class method ?arg ...?
```

# [CLASS HIERARCHY](#CLASS_HIERARCHY)

```
oo::object


   → oo::class
```

```

```

# [DESCRIPTION](#DESCRIPTION)

Classes are objects that can manufacture other objects according to a pattern stored in the factory object (the class). An instance of the class is created by calling one of the class's factory methods, typically either **create** if an explicit name is being given, or **new** if an arbitrary unique name is to be automatically selected.

The **oo::class** class is the class of all classes; every class is an instance of this class, which is consequently an instance of itself. This class is a subclass of **oo::object**, so every class is also an object. Additional metaclasses (i.e., classes of classes) can be defined if necessary by subclassing **oo::class**. Note that the **oo::class** object hides the **new** method on itself, so new classes should always be made using the **create** method.

## [CONSTRUCTOR](#CONSTRUCTOR)

The constructor of the **oo::class** class takes an optional argument which, if present, is sent to the **oo::define** command (along with the name of the newly-created class) to allow the class to be conveniently configured at creation time.

## [DESTRUCTOR](#DESTRUCTOR)

The **oo::class** class does not define an explicit destructor. However, when a class is destroyed, all its subclasses and instances are also destroyed, along with all objects that it has been mixed into.

## [EXPORTED METHODS](#EXPORTED_METHODS)

[*cls create name* ?*arg ...*?](#cls)

This creates a new instance of the class *cls* called *name* (which is resolved within the calling context's namespace if not fully qualified), passing the arguments, *arg ...*, to the constructor, and (if that returns a successful result) returning the fully qualified name of the created object (the result of the constructor is ignored). If the constructor fails (i.e. returns a non-OK result) then the object is destroyed and the error message is the result of this method call.

[*cls new* ?*arg ...*?](#cls~2)

This creates a new instance of the class *cls* with a new unique name, passing the arguments, *arg ...*, to the constructor, and (if that returns a successful result) returning the fully qualified name of the created object (the result of the constructor is ignored). If the constructor fails (i.e., returns a non-OK result) then the object is destroyed and the error message is the result of this method call.

Note that this method is not exported by the **oo::class** object itself, so classes should not be created using this method.

## [NON-EXPORTED METHODS](#NON-EXPORTED_METHODS)

The **oo::class** class supports the following non-exported methods:

[*cls createWithNamespace name nsName* ?*arg ...*?](#cls~3)

This creates a new instance of the class *cls* called *name* (which is resolved within the calling context's namespace if not fully qualified), passing the arguments, *arg ...*, to the constructor, and (if that returns a successful result) returning the fully qualified name of the created object (the result of the constructor is ignored). The name of the instance's internal namespace will be *nsName*; it is an error if that namespace cannot be created. If the constructor fails (i.e., returns a non-OK result) then the object is destroyed and the error message is the result of this method call.

# [EXAMPLES](#EXAMPLES)

This example defines a simple class hierarchy and creates a new instance of it. It then invokes a method of the object before destroying the hierarchy and showing that the destruction is transitive.

```
oo::class create fruit {


    method eat {} {


        puts "yummy!"


    }
}
oo::class create banana {


    superclass fruit


    constructor {} {


        my variable peeled


        set peeled 0


    }


    method peel {} {


        my variable peeled


        set peeled 1


        puts "skin now off"


    }


    method edible? {} {


        my variable peeled


        return $peeled


    }


    method eat {} {


        if {![my edible?]} {


            my peel


        }


        next


    }
}
set b [banana new]
$b eat               → prints "skin now off" and "yummy!"
fruit destroy
$b eat               → error "unknown command"
```

# [SEE ALSO](#SEE_ALSO)

[oo::define(n)](/man/os/tcl/oo::define.n), [oo::object(n)](/man/os/tcl/oo::object.n)

# [KEYWORDS](#KEYWORDS)

class, metaclass, object

0.1 TclOO

---

Document: oo_class(n) from tcl 9.1.0-r1 (Chainguard OS)
Source: https://downloads.sourceforge.net/project/tcl/Tcl/9.1.0/tcl9.1.0-src.tar.gz