\b;Instrukcja \c;class\n;
To słowo kluczowe pozwala ci tworzyć definicje klasy, używając następującej składni:
\c;
\s;public class NazwaKlasy
\s;{
\s;	deklaracje;
\s;}
\n;
\t;Wszystkie klasy są publiczne
Klasy mogą być wyłącznie \l;publiczne\u cbot\public;. To oznacza, że mogą być wykonane przez wszystkie roboty obecne w bieżącej misji.

\b;Elementy klasy
Elementy klasy to pola (\l;zmienne\u cbot\var;) i metody (\l;funkcje\u cbot\function;).

Na przykład, poniższa klasa nazwana \c;MojaKlasa\n; zawiera 4 pola (\c;a\n;, \c;b\n;, \c;x\n; i \c;s\n;) i jedną metodę (\c;MojaFunkcja\n;).
\c;
\s;public class MojaKlasa
\s;{
\s;	int     a, b;
\s;	float   x = 3.33;
\s;	string  s = "Witaj";
\s;	float   MojaFunkcja(float wartość)
\s;	{
\s;		return (wartość * x) - 1;
\s;	}
\s;}
\n;
\b;Dostęp do elementów klasy
Do elementów klasy można uzyskać dostęp spoza definicji klasy używając operatora \c;.\n; (kropka). Przykład:
\c;
\s;public class MojaKlasa
\s;{
\s;	int mojePole = 0;
\s;	int MojaFunkcja()
\s;	{
\s;		return mojePole * 2;
\s;	}
\s;}
\s;
\s;extern void object::Test()
\s;{
\s;	MojaKlasa mojObiekt();
\s;	mojObiekt.mojePole = 10;
\s;	message(mojObiekt.MojaFunkcja()); // 20
\s;	MojaKlasa mojDrugiObiekt();
\s;	mojDrugiObiekt.mojePole = mojObiekt.mojePole - 2;
\s;	message(mojDrugiObiekt.MojaFunkcja()); // 16
\s;}
\n;
Elementy klasy są domyślnie zadeklarowane jako \l;public\u cbot\public;, co oznacza, że są dostępne spoza definicji klasy. Mogą być również zadeklarowane jako \c;\l;private\u cbot\private;\n; lub \c;\l;protected\u cbot\protected;\n;. Takie elementy mogą być dostępne jedynie z wewnątrz definicji klasy.

\t;Modyfikatory elementów klas
Pola i metody mogą być również zadeklarowane jako \c;\l;static\u cbot\static;\n;. Metody mogą być również deklarowane jako \c;\l;synchronized\u cbot\synchro;\n;.

\t;Inicjalizowanie elementów
Jak pokazano w poprzednim przykładzie, elementy klasy mogą być inicjalizowane w definicji klasy (\c;int x = 3.33;\n;).

Innym sposobem inicjalizacji pól jest zdefiniowanie konstruktora. Jest to specjalna metoda o tej samej nazwie co klasa. Jest on wywoływany automatycznie podczas \l;tworzenia\u cbot\new; instancji klasy. Konstruktory mogą być \l;przeciążane\u cbot\function;.

Przykład:\c;
\s;public class MojaKlasa
\s;{
\s;	int  a, b;
\s;	void MojaKlasa()
\s;	{
\s;		a = 2;  b = 3;
\s;	}
\s;	void MojaKlasa(int a, int b)
\s;	{
\s;		this.a = a;  this.b = b;
\s;	}
\s;}
\n;

\t;Używanie \c;\l;this\u cbot\this;\n;
Ponieważ nazwy parametrów drugiego konstruktora są takie same jak nazwy elementów \c;a\n; and \c;b\n;, musimy użyć \l;referencji\u cbot\pointer; \c;\l;this\u cbot\this;\n;, by uniknąć pomyłki z nazwami parametrów.

\b;Tworzenie obiektu
Możesz tworzyć obiekty typu \c;TwojaKlasa\n;, używając słowa kluczowego \c;\l;new\u cbot\new;\n;. Przykład:
\c;
\s;extern void object::Test()
\s;{
\s;\MojaKlasa obiekt1();       // Wywołanie domyślnego konstruktora (bez parametrów)
\s;\MojaKlasa obiekt2(4, 5);   // Wywołanie konstruktora z dwoma parametrami typu całkowitego
\s;\MojaKlasa obiekt3;         // Brak wywołania konstruktora, object3 == null
\s;	obiekt3 = new MojaKlasa(); // Teraz wywołujemy konstruktor, obiekt3 != null
\s;}
\n;

\b;Niszczenie obiektu
Możesz również zdefiniować destruktor. Musi to być funkcja zwracająca \c;\l;void\u cbot\void;\n; nieprzyjmująca parametrów, mająca taką samą nazwę jak klasa, ale z przedrostkiem \c;~\n;. Destruktor jest wzywany automatycznie gdy klasa przestanie być odwoływana przez cokolwiek. Przykład:
\c;
\s;public class MojaKlasa
\s;{
\s;	static private int licznik = 0; // licznik instancji
\s;	void  MojaKlasa( )
\s;	{
\s;		licznik++;  // jedna instancja więcej
\s;	}
\s;	void ~MojaKlasa( )
\s;	{
\s;		licznik--;  // jedna instancja mniej
\s;	}
\s;}
\s;extern void object::Test()
\s;{
\s;	                   // licznik == 0
\s;	MojaKlasa przedmiot1( );  // licznik == 1
\s;	MojaKlasa przedmiot2( );  // licznik == 2
\s;	iprzedmiot = null;      // licznik == 1
\s;}
\s;// licznik == 0
\n;
\b;Przekazywanie obiektów do funkcji
Obiekty w języku CBOT są przekazywane przez \l;referencję\u cbot\pointer;. Oznacza to, że gdy obiekt jest przekazywany do \l;funkcji\u cbot\function;, funkcja otrzymuje kopię wskaźnika do instancji, nie kopię obiektu, więc wszelkie modyfikacje obiektu są widoczne poza funkcją.

\b;Dziedziczenie
Klasa może dziedziczyć publiczne i chronione elementy innej klasy przez użycie słowa kluczowego \c;\l;extends\u cbot\extends;\n;.

\t;Zobacz również
\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;reference\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;Programowanie\u cbot;, \l;typy\u cbot\type; i \l;kategorie\u cbot\category;.
