\b;Instrução \c;class\n;
Esta palavra permite a você criar uma definição de classe usando a seguinte sintaxe:
\c;
\s;public class NomeDaClasse 
\s;{
\s;	declarações;
\s;}
\n;
\t;Todas as classes são públicas
Classes só podem ser \l;publicas\u cbot\public;. Isto significa que elas podem ser utilizadas por todos os robôs em uma missão.

\b;Membros da classe
Membros da classe são atributos (\l;variáveis\u cbot\var;) e métodos (\l;funções\u cbot\function;).

Por exemplo, a seguinte classe chamada \c;MinhaClasse\n; contém 4 atributos  (\c;a\n;, \c;b\n;, \c;x\n; e \c;s\n;) e um método (\c;MinhaFuncao\n;).
\c;
\s;public class MinhaClasse
\s;{
\s;	int     a, b;
\s;	float   x = 3.33;
\s;	string  s = "olá";
\s;	float   MinhaFuncao(float value)
\s;	{
\s;		return (value * x) - 1;
\s;	}
\s;}
\n;
\b;Acessando membros da classe
Membros da classe podem ser acessados fora da definição da classe utilizando o operador \c;.\n;. Exemplo:
\c;
\s;public class MinhaClasse
\s;{
\s;	int meuAtributo = 0;
\s;	int minhaFuncao()
\s;	{
\s;		return meuCampo * 2;
\s;	}
\s;}
\s;
\s;extern void object::Teste()
\s;{
\s;	MinhaClasse meuObjeto();
\s;	meuObjeto.meuAtributo = 10;
\s;	message(meuObjeto.minhaFuncao()); // 20
\s;	MinhaClasse meuSegundoObjeto();
\s;	meuSegundoObjeto.meuCampo = meuObjeto.meuCampo - 2;
\s;	message(meuSegundoObjeto.minhaFuncao()); // 16
\s;}
\n;
Membros de classe são \l;public\u cbot\public; por padrão, o que significa que eles são acessíveis fora da definição da classe. Eles também pode ser declarados \c;\l;private\u cbot\private;\n; ou \c;\l;protected\u cbot\protected;\n;. Estes membros só podem ser acessados dentro da definição da classe.

\t;Modificadores de membros de classe
Atributos e métodos também podem ser declarados como \c;\l;static\u cbot\static;\n;. Métodos também podem ser adicionalmente declarados como \c;\l;synchronized\u cbot\synchro;\n;.

\t;Inicialização de membros
Como mostrado no exemplo anterior, os membros da classe podem ser inicializados na definição da classe  (\c;int x = 3.33;\n;).

Outra forma de inicializar os atributos é definindo um construtor que é um método especial com o mesmo nome da classe. Este método será chamado automaticamente no tempo de \l;criação\u cbot\new; da instância da classe. Construtores também podem ser  \l;sobrecarregados\u cbot\function;.

Exemplo:\c;
\s;public class MinhaClasse
\s;{
\s;	int  a, b;
\s;	void MinhaClasse()
\s;	{
\s;		a = 2;  b = 3;
\s;	}
\s;	void MinhaClasse(int a, int b)
\s;	{
\s;		this.a = a;  this.b = b;
\s;	}
\s;}
\n;

\t;Usando \c;\l;this\u cbot\this;\n;
Como os nomes dos parâmetros do segundo construtor são iguais aos nomes dos dois membros \c;a\n; e \c;b\n;, nós devemos usar a  \l;referência\u cbot\pointer; \l;this\u cbot\this; para evitar confusão com os nomes dos parâmetros.

\b;Criação de objetos
Você pode criar objetos do tipo \c;SuaClasse\n; usando a palavra-chave  \c;\l;new\u cbot\new;\n;. Exemplo:
\c;
\s;extern void object::Teste()
\s;{
\s;	MinhaClasse objeto1();       // Chama o construtor padrão (sem parâmetros)
\s;	MinhaClasse objeto2(4, 5);   // Chama o construtor com 2 parâmetros int
\s;	MinhaClasse objeto3;         // Nenhum construtor chamado, objeto3 == null
\s;	objeto3 = new MinhaClasse(); // Chamamos o construtor agora, objeto3 != null
\s;}
\n;

\b;Destruição de objetos
Você também pode definir um destrutor. Este deve uma função  \c;\l;void\u cbot\void;\n;sem parâmetros, que deve ter o mesmo nome da classe porém com o prefixada com o caráctere \c;~\n;. O destrutor é chamado automaticamente assim que a instância da classe não é mais referenciada por ninguém. Exemplo:
\c;
\s;public class MinhaClasse
\s;{
\s;	static private int contador = 0; // contador de instância
\s;	void  MinhaClasse( )
\s;	{
\s;		contador++;  // uma instância a mais
\s;	}
\s;	void ~MinhaClasse( )
\s;	{
\s;		contador--;  // uma instância a menos
\s;	}
\s;}
\s;extern void object::Teste()
\s;{
\s;	                   // contador == 0
\s;	MinhaClasse item1( );  // contador == 1
\s;	MinhaClasse item2( );  // contador == 2
\s;	item1 = null;      // contador == 1
\s;}
\s;// contador == 0
\n;
\b;Passando objetos para funções
Objetos em CBOT são passados por \l;referência\u cbot\pointer;. Isto significa que quando um objeto é passado para uma \l;função\u cbot\function;, a função recebe uma cópia de um ponteiro para a instância, não uma cópia do objeto, então quaisquer modificações realizadas ao objeto dentro da função serão visíveis fora da função.

\b;Herança
Uma classe pode herdar membros públicos e protegidos de outra classe usando a palavra-chave \c;\l;extends\u cbot\extends;\n;.

\t;Veja também
\c;\l;public\u cbot\public;\n;, \c;\l;private\u cbot\private;\n;, \c;\l;protected\u cbot\protected;\n;, \c;\l;static\u cbot\static;\n;, \c;\l;synchronized\u cbot\synchro;\n;, \c;\l;new\u cbot\new;\n;, \c;\l;referência\u cbot\pointer;\n;, \c;\l;this\u cbot\this;\n;, \c;\l;super\u cbot\super;\n;, \c;\l;extends\u cbot\extends;\n;
\l;Programação\u cbot;, \l;tipos\u cbot\type; e \l;categorias\u cbot\category;.
