Vamos começar criando uma classe simples chamada Contador que permitirá incrementar, retornar o valor atual e zerar (reiniciar). (Fonte: Tcl 8.5 Networking Programming, 2010)

#!/usr/bin/env tclsh
#Exemplo de uma classe

package require TclOO

oo::class create Contador {
    constructor {} {
	my ZerarContador
    }

    method ZerarContador {} {
	#mapeia a variável c como variável local e define o conteúdo como 0
	my variable c
	set c 0
    }

    method incrementar {} {
	#mapeia a variável c como variável local e incrementa
	my variable c
	incr c
    }

    method retornarvalor {} {
	#retornar valor corrente
	my variable c
	return $c
    }

}

#Teste

set c1 [Contador new]
set c2 [Contador new]

puts "c1 = $c1 e c2 = $c2 \n"

$c1 incrementar
$c2 incrementar
$c1 incrementar

puts [$c1 retornarvalor]
puts [$c2 retornarvalor]

O comando package require TclOO carrega o pacote TclOO e em seguida a linha oo::class create Contador cria uma classe chamada Contador e define um construtor que chama o método ZerarContador para zerar o conteúdo.

...
package require TclOO

oo::class create Contador {
    constructor {} {
	my ZerarContador
    }
...

O comando my, usado na criação do método ZerarContadordefine o método ZerarContador como um método “privado”. E o comando my variable é usado para mapear a variável de um objeto específico como uma variável local, e portanto my variable c faz com que a variável c (específica de um objeto) se torne disponível para um método específico.

O método incrementar aumenta o valor do Contador e o método retornarvalor retorna o valor do Contador.

Para testar o uso da classe foram criados dois objetos da classe Contador com o comando

o qual retorna um identificador único que é armazenado na variável c1 e c2 respectivamente.

set c1 [Contador new]
set c2 [Contador new]

Os conteúdos são exibidos com o comando puts [$c1 retornarvalor], em seguida são incrementados ($c1 incrementar) e novamente exibidos.

puts [$c1 retornarvalor]
puts [$c2 retornarvalor]

$c1 incrementar
$c2 incrementar
$c1 incrementar

puts [$c1 retornarvalor]
puts [$c2 retornarvalor]

No final os objetos são removidos da memória com o comando destroy.

Os objetos também podem ser criados com a sintaxe

, e o teste do programa anterior poderia ser escrito como:

...
Contador create c1
Contador create c2

puts [c1 retornarvalor]
puts [c2 retornarvalor]

c1 incrementar
c2 incrementar

puts [c1 retornarvalor]
puts [c2 retornarvalor]

c1 destroy
c2 destroy

Um outro método poderia ser definido para objetos da classe Contador com os comandos:

oo::define Contador {
    method defvalor {valor} {
        my variable c
        set c $valor
    }
}

ou

oo::define Contador method defvalor {valor} {
    my variable c
    set c $valor
}

Podemos criar classes que herdam as características de outras classes.

Por exemplo, podemos criar uma classe Contador_zero (classe filho)que herda as características da classe Contador (classe pai) mas com a diferença de poder zerar o Contador após cada leitura.

oo::class create Contador_zero {
    #Declara a classe Contador como superclasse
    superclass Contador
    method retornarvalor {} {
        #obtem o resultado da classe Contador
        set result [next]
        my ZerarContador
        return $result
    }
}

E para testar o código com os comandos:

Contador_zero create c0
puts [c0 retornarvalor]
c0 incrementar
puts [c0 retornarvalor]
puts [c0 retornarvalor]

Em TclOO o comando superclass Contador declara a classe Contador como a superclasse da nova classe Contador_zero.

Com a linha method retornarvalor {} { estamos sobrescrevendo o método retornarvalor que passa a ter um novo comportamento quando for chamado pelos objetos da classe Contador_zero.

A linha set result [next] utiliza o comando next o qual executa o método retornarvalor “da classe Contador” e atribui o resultado à variável result.

E em seguida é executado o método ZerarContador com o comando my pois se trata de um método privado.

Por exemplo, se você tenter acessar (executar) o método ZerarContador com o comando c1 ZerarContador receberá uma mensagem de erro:

unknown method "ZerarContador": must be defvalor, destroy, incrementar or retornarvalor
    while executing
"c1 ZerarContador"

O pacote TclOO permite que os métodos sejam chamados de dentro do objeto ( my [nome_do_método]) e de fora do objeto ( c1 [nome_do_método] ). Mas esse comportamento pode ser modificado com o uso dos comandos export e unexport na definição da classe.

Por exemplo, podemos criar uma classe (Ex: Contador_tempo que não permite o método incrementar seja chamado de fora do objeto.

oo::class create Contador_tempo {

  superclass Contador

  constructor {} {
      #Implementar alguma rotina para incrementar o contador
      #em intervalos periódicos
  }

  unexport incrementar

}  

oo::class create Classe_teste {
    method retornarvalor {} {
        puts "Método retornarvalor da Classe_teste"
        next
    }
}
oo::class create Contador_teste {
    superclass Classe_teste Contador
}

O comando oo::objdefine permite editar o código de um método para um objeto específico.

oo::objdefine c1 {
    method retornarvalor {} {
        puts "Executando o método retornarvalor para o objeto c1"
        next
    }
}

No exemplo anterior foi acrescentado o comando puts "Executando..." ao método retornarvalor apenas para o objeto c1. E o comando next chama a execução do método retornarvalor original (da classe Contador).