Zgodnie z założeniem programowania obiektowego klasa jest modelem, który określa typ oraz zachowanie pewnego zbioru danych – obiektu. Obiekt zwany jest instancją klasy. W uproszczeniu można powiedzieć, że klasa jest typem, a obiekt zmienną.

W przypadku typów prostych – int, double , boolean – nie martwimy się ich implementacją, ponieważ zostały nam dostarczone wraz ze środowiskiem programistycznym. W programowaniu obiektowym mamy możliwość samodzielnego tworzenia typów, dzięki czemu idealnie wpasowują się one w nasze potrzeby.

Definicja klasy może zawierać zarówno pola, które stanowią stan obiektu, jak i funkcje (zwane metodami), które określają zachowanie danego obiektu.

Struktura programu obiektowego w języku Java

Program w języku Java rozpoczynamy od definicji klasy. Może ona przyjmować różne nazwy. Niektórzy klasę główną nazywają tak jak swój program, inni wolą nazwać tę klasę: Main. Dobrą praktyką jest rozpoczynanie nazwy klasy wielką literą. Wewnątrz niej wpisujemy definicję publicznej statycznej funkcji typu void o nazwie main. Typowy program w języku Java zawsze przyjmuje podaną strukturę.

public class Main {
    public static void main(String[] args) {
        // w tym miejscu zaczynamy pisać nasz program
    }
}

Programując w ten sposób, masz już podstawy programowania obiektowego. Wiesz, co oznaczają poszczególne słowa w tej strukturze?

Zacznijmy od linijki nr 1. Znajdują się w niej dwa słowa kluczowe: public oraz class. W połączeniu z nazwą Main stanowią one definicję klasy publicznej. W języku Java określamy w ten sposób klasę, którą można użyć w dowolnym miejscu programu. Związane jest z nią pojęcie hermetyzacji, które zostanie omówione w kolejnych e‑materiałach. W tym momencie możemy przyjąć, że słowo to jest zbędne – jego usunięcie nie zmieni działania programu. Java jest językiem ściśle obiektowym, w którym nawet funkcja rozpoczynająca wykonywanie programu musi być zadeklarowana w klasie.

Przechodzimy do linijki nr 2. Widzimy bardzo charakterystyczną dla języka Java definicję funkcji main – metody, która uruchamiana jest w trakcie startu programu. W momencie kompilacji we wszystkich plikach programu szukana jest właśnie taka definicja. Nie jest określone, w jakiej klasie powinna być zadeklarowana, jednak jest niezbędna do uruchomienia programu.

Wspomniane wcześniej słowo kluczowe public oznacza, że dostęp do metody main jest powszechny – można ją wywołać w dowolnym miejscu programu, w którym posiadamy dostęp do jej klasy. W tym wypadku również klasa ma ustawiony powszechny dostęp, zatem wywołanie funkcji main byłoby możliwe w dowolnym momencie działania programu. Należy jednak pamiętać, że program nie powinien wywoływać sam siebie bez wyraźnej przyczyny, zatem nie należy na przykład wywoływać funkcji main z poziomu funkcji main.

Słowo kluczowe static oznacza, że funkcja main jest statyczna. W przypadku funkcji głównej programu nie należy przejmować się jej statycznością. Jak wspomnieliśmy wcześniej, najprawdopodobniej nie będziemy chcieli jej wywoływać. Nie zmienia to faktu, że słowo static jest niezbędne do uruchomienia programu.

Słowo kluczowe void oznacza, że metoda main jest tak naprawdę procedurą – nie zwraca żadnej wartości. W wielu językach uznano, że funkcja główna programu powinna zwracać status, tj. informację czy wszystkie operacje zakończyły się poprawnie, jako typ integer. Jednak nie dotyczy to języka Java, w którym nie musimy zwracać statusu programu.

Ostatnią charakterystyczną cechą linijki nr 2 są przyjmowane parametry. Widzimy, że metoda przyjmuje tablicę łańcuchów znaków – String. Są to parametry wywołania programu, które mogą pochodzić z systemu operacyjnego lub jego wywołania – np. z poziomu konsoli. Jedynym, co możemy zmienić w drugiej linijce, aby nadal pozostała ona definicją funkcji głównej programu, jest właśnie nazwa tych parametrów.

Dziedziczenie w języku Java

Dziedziczenie to mechanizm współdzielenia pól oraz metod. W programowaniu obiektowym typy mogą pochodzić od innych typów. Klasy pochodne mogą zarówno dziedziczyć, jak i nadpisywać metody klasy, od której pochodzą. Można wyróżnić m.in. klasy właściwe (czyli takie, które mogą być instancjonowane) oraz klasy abstrakcyjne, które stanowią bazę dla klas pochodnych i nie można utworzyć ich instancji. Instancjonowaniem nazywamy tworzenie obiektów danej klasy. Zasada dziedziczenia stanowi zatem również wzór projektowy, dzięki któremu wspólna praca wielu programistów nad tym samym kodem jest łatwiejsza.

Klasa abstrakcyjna w języku Java może zostać utworzona przez słowo kluczowe abstract.

abstract class Owoc {
    // w tym miejscu możemy deklarować pola oraz metody
    // przykładowe pole w klasie Owoc
    double masa;
    
    // przykładowa metoda w klasie Owoc
    void ugryz() {
        // ugryzienie powoduje zmniejszenie masy owocu
        masa -= 0.01;
    }

}

Klasa Owoc została zaimplementowana jako abstrakcyjna, ponieważ definiuje ona tylko ogólną kategorię, jaką są owoce. Definicja ta powinna zostać jednak doprecyzowana, żeby mogła faktycznie zaistnieć. Gdybyśmy pozwolili na utworzenie instancji klasy Owoc, nie wiedzielibyśmy, jaki to owoc. Zaimplementujmy zatem klasę pochodną, która powie nam więcej o wybranym owocu. W języku Java klasę pochodną możemy utworzyć poprzez następującą konstrukcję:

class Jablko extends Owoc {
    // w tym miejscu możemy deklarować pola oraz metody
    // klasy pochodnej
    // przykładowe pole w klasie Jablko, które nie występuje
    // w klasie pierwotnej
    int liczbaPestek;
    
    // przykładowa metoda w klasie Jablko, która nie występuje
    // w klasie pierwotnej
    void zabierzPestke() {
        liczbaPestek--;
    }

}

Zauważ, że w przypadku klasy Jablko nie mamy już do czynienia z klasą abstrakcyjną, zatem możemy utworzyć jej instancję. Sama definicja klasy Jablko nie może istnieć samodzielnie, ponieważ odnosi się do definicji klasy abstrakcyjnej Owoc. Zwróć uwagę, że w klasie pochodnej nie musimy zawierać informacji o polach oraz metodach, które już występują w klasie bazowej.

Aby zaobserwować mechanizm dziedziczenia oraz potwierdzić fakt, że w klasie Jablko istnieją pola oraz metody z klasy bazowej Owoc, a także pola i metody dodane w definicji klasy pochodnej, możemy napisać prosty program wykorzystujący utworzone klasy.

abstract class Owoc {
    // w tym miejscu możemy deklarować pola oraz metody
    // przykładowe pole w klasie Owoc
    double masa;
    
    // przykładowa metoda w klasie Owoc
    void ugryz() {
        // ugryzienie powoduje zmniejszenie masy owocu
        masa -= 0.01;
    }

}

class Jablko extends Owoc {
// w tym miejscu możemy deklarować pola oraz metody
// klasy pochodnej
    // przykładowe pole w klasie Jablko, które nie występuje
    // w klasie pierwotnej
    int liczbaPestek;
    
    // przykładowa metoda w klasie Jablko, która nie występuje
    // w klasie pierwotnej
    void zabierzPestke() {
        liczbaPestek--;
    }

}

public class Main {
public static void main(String[] args) {
// nowa instancja klasy Jablko
Jablko jablko = new Jablko();
        // ustawienie wartości masa oraz liczbaPestek
        // instancji klasy Jablko
        jablko.masa = 0.3;
        jablko.liczbaPestek = 3;
    
        // wywołanie metod klasy Jablko
        jablko.ugryz();
        jablko.zabierzPestke();
    
        // poniższa linijka powinna wypisać: 0.29 2
        System.out.println(jablko.masa + " " + jablko.liczbaPestek);
    }

}

Konstruktory

W omawianym dotychczas programie, jeśli chcemy przypisać wartość atrybutów obiektów klasy Jablko, odwołujemy się bezpośrednio do atrybutów obiektu po znaku kropki. Istnieje jednak specjalny rodzaj funkcji, który pozwala na przypisanie wartości atrybutom obiektów podczas ich tworzenia. Nazywamy go konstruktorem. Prześledźmy definicję konstruktora na przykładzie klasy Jablko:

class Jablko extends Owoc {
	// w tym miejscu możemy deklarować pola oraz metody
    // klasy pochodnej
    // przykładowe pole w klasie Jablko, które nie występuje
    // w klasie pierwotnej
    int liczbaPestek;
    
    // konstruktor
    Jablko() {
        // funkcja ta zostanie wywołana przy tworzeniu obiektu
        // klasy Jablko
        // w tym miejscu możemy przypisywać wartości atrybutom
        // oraz wywoływać metody
    }
    
    // przykładowa metoda w klasie Jablko, która nie występuje
    // w klasie pierwotnej
    void zabierzPestke() {
        liczbaPestek--;
    }

}

W definicji konstruktora możemy zawrzeć także parametry przekazywane tak jak w przypadku zwykłej funkcji:

class Jablko extends Owoc {
	// w tym miejscu możemy deklarować pola oraz metody
    // klasy pochodnej
    // przykładowe pole w klasie Jablko, które nie występuje
    // w klasie pierwotnej
    int liczbaPestek;
    
    // konstruktor
    Jablko(double masa, int liczbaPestek) {
        // funkcja ta zostanie wywołana przy tworzeniu obiektu
        // klasy Jablko
        // w tym miejscu możemy przypisywać wartości atrybutom
        // oraz wywoływać metody
    }
    
    // przykładowa metoda w klasie Jablko, która nie występuje
    // w klasie pierwotnej
    void zabierzPestke() {
        liczbaPestek--;
    }

}

Przypisujemy przekazane do konstruktora wartości do atrybutów. Jeżeli przesłoniliśmy nazwę atrybutu w konstruktorze (lub innej metodzie), dostęp do atrybutu gwarantuje nam konstrukcja this.

class Jablko extends Owoc {
	// w tym miejscu możemy deklarować pola oraz metody
    // klasy pochodnej
    // przykładowe pole w klasie Jablko, które nie występuje
    // w klasie pierwotnej
    int liczbaPestek;
    
    // konstruktor
    Jablko(double masa, int liczbaPestek) {
        // funkcja ta zostanie wywołana przy tworzeniu obiektu
        // klasy Jablko
        // w tym miejscu możemy przypisywać wartości atrybutom
        // oraz wywoływać metody
        
        // przypisanie wartości atrybutu z klasy bazowej
        this.masa = masa;
        // przypisanie wartości atrybutu z klasy pochodnej
        this.liczbaPestek = liczbaPestek;
    }
    
    // przykładowa metoda w klasie Jablko, która nie występuje
    // w klasie pierwotnej
    void zabierzPestke() {
        liczbaPestek--;
    }

}

Tak zdefiniowaną klasę możemy instancjonować w następujący sposób:

Jablko jablko = Jablko(0.3, 3);

Analizowany program,wzbogacony o wykorzystanie konstruktora, prezentuje się następująco:

abstract class Owoc {
    // w tym miejscu możemy deklarować pola oraz metody
    // przykładowe pole w klasie Owoc
    double masa;
    
    // przykładowa metoda w klasie Owoc
    void ugryz() {
        // ugryzienie powoduje zmniejszenie masy owocu
        masa -= 0.01;
    }

}

class Jablko extends Owoc {
// w tym miejscu możemy deklarować pola oraz metody
// klasy pochodnej
    // przykładowe pole w klasie Jablko, które nie występuje
    // w klasie pierwotnej
    int liczbaPestek;
    
    // konstruktor
    Jablko(double masa, int liczbaPestek) {
        // funkcja ta zostanie wywołana przy tworzeniu obiektu
        // klasy Jablko
        // w tym miejscu możemy przypisywać wartości atrybutom
        // oraz wywoływać metody
        
        // przypisanie wartości atrybutu z klasy bazowej
        this.masa = masa;
        // przypisanie wartości atrybutu z klasy pochodnej
        this.liczbaPestek = liczbaPestek;
    }
    
    // przykładowa metoda w klasie Jablko, która nie występuje
    // w klasie pierwotnej
    void zabierzPestke() {
        liczbaPestek--;
    }

}

public class Main {
public static void main(String[] args) {
// nowa instancja klasy Jablko z ustawieniem atrybutów
// masa = 0.3 oraz liczbaPestek = 3
Jablko jablko = new Jablko(0.3, 3);
        // wywołanie metod klasy Jablko
        jablko.ugryz();
        jablko.zabierzPestke();
    
        // poniższa linijka powinna wypisać: 0.29 2
        System.out.println(jablko.masa + " " + jablko.liczbaPestek);
    }

}

Słownik