Dziedziczenie  

Dziedziczenie  pozwala  na  definiowanie  nowej  klasy  przy  wykorzystaniu  innej  klasy,  już 

wcześniej  zdefiniowanej.  Jeżeli  np.  mamy  zdefiniowaną  już  klasę  Osoba,  a  chcemy  jeszcze 
zdefiniować  klasy  Pracownik  i  Student,  to  nie  musimy  definiować  tych  klas  od  początku,  ale 
wystarczy  napisać,  że  te  nowe  klasy  dziedziczą  po  klasie  Osoba  (bo  posiadają  pewne  wspólne 
pola i metody, np. imię, nazwisko, data urodzenia; metodę wypisującą dane).  

Dziedziczenie  wyraża  się  za  pomocą  słowa  extends.  Jest  ono  zawsze  publiczne.  Nie  ma 

dziedziczenia  wielokrotnego  (tak  jak  w  C++),  czyli  każda  klasa  jest  podklasą  tylko  jednej 
nadklasy. U podstawy hierarchii dziedziczenia znajduje się klasa Object.  

Ogólnie mechanizm dziedziczenia klas można opisać następująco:  

class NazwaNadklasy  
{  
//Definicje pól, metod, zmiennych i funkcji składowych nadklasy  
private Typ1 pole1;  
private Typ2 pole2;  
...  
public NazwaNadklasy(Typ1 pole1, Typ2 pole2) //Konstruktor Nadklasy  
{  
this.pole1 = pole1;  
this.pole2 = pole2;  
}  
...  
}  
class NazwaPodklasy extends NazwaNadklasy  
{  
//Definicje DODATKOWYCH pól, metod, zmiennych i funkcji składowych podklasy  
Typ3 pole3;  
...  
public NazwaPodklasy(Typ1 pole1, Typ2 pole2, Typ3 pole3) //Konstruktor Nadklasy  
{  
super(pole1, pole2); //wywołanie konstruktora nadklasy danej klasy  
this.pole3 = pole3;  
}  
...  
}  

Mamy  tu  zdefiniowaną  nadklasę 

NazwaNadklasy 

oraz  podklasę 

NazwaPodklasy

.  Ponadto 

nadklasą klasy 

NazwaNadklasy 

oraz 

NazwaPodklasy 

jest klasa Object.  

Obiekt  klasy 

NazwaNadklasy 

zawiera  zmienne  opisane  przez  pola 

pole1 

i 

pole2

,  a  także 

konstruktor.  Natomiast  obiekt  klasy 

NazwaPodklasy 

zawiera  takie  same  zmienne  jak  obiekt  klasy 

NazwaNadklasy 

oraz  dodatkowo  zmienną  opisaną  przez  pole 

pole3 

(czyli  zawiera  zmienne 

pole1

, 

pole2 

i 

pole3

), a także własny konstruktor, wywołujący konstruktor nadklasy.  

Przykłąd 

 

Program definiujący klasę Osoba oraz dziedziczącą po niej klasę Pracownik.  

inicja nadklasy Osoba, charakteryzująca pojedynczą osobę  
//Defclass Osoba  
{  
String imie, nazwisko; //Pola klasy Osoba  
int rok_ur;  
//Konstruktor 3-argumentowy, inicjujący pola obiektu klasy Osoba  
Osoba (String imie, String nazwisko, int rok_ur)  
{  
this.imie = imie; //nadanie wartości początkowych polom obiektu klasy Osoba  
...  
}  
//Metoda wypisująca dane obiektu - osoby  
void WypiszDane()  
{  
...  
}  
}  

inicja podkacownik, dziedziczącej po klasie Osoba  
//Deflasy Prclass Pracownik extends Osoba  
{  
String stanowisko; //dodatkowe pola klasy Pracownik  
int staz;  
//Konstruktor 5-argumentowy, inicjujący pola obiektu klasy Pracownik  
Pracownik(String imie, String nazwisko, int rok_ur, String stanowisko, int staz)  
{  
super(imie, nazwisko, rok_ur); //wywołanie konstruktora nadklasy (Osoba), który  
//zainicjuje pola imie, nazwisko i rok_ur  
this.stanowisko = stanowisko; //zainicjowanie pól stanowisko i staz  
...  
}  
//Metoda wypisująca dane obiektu Pracownik  
void WypiszDane()  
{  
System.out.println("Pracownik "+imie+" "+nazwisko+", ur. w roku "+rok_ur+",");  
System.out.println("zatrudniony na stanowisku "+stanowisko+", pracuje lat: "+staz+".\n");  
}  
}  
//Definicja klasy RozneOsoby, zawierającej funkcję główną programu  
public class RozneOsoby  
{  
//Definicja funkcji głównej  
public static void main(String args[])  
{  
//Utworzenie obiektu klasy Pracownik  
Pracownik prac1 = new Pracownik("Jan", "Kowalski", 1961, "wykladowca", 10);  
//Wywołanie metody WypiszDane dla obiektu klasy Pracownik  
prac1.WypiszDane();  
}  
}  

Klasy abstrakcyjne  

Klasa abstrakcyjna jest to klasa, zadeklarowana ze specyfikatorem 

abstract

. Dla takiej klasy nie 

można utworzyć obiektów, ponieważ jest ona definiowana tylko po to, aby  dziedziczyły po niej 
inne  klasy.  Jeżeli  na  danym  stopniu  opisu  ogólnego  możliwych  obiektów  nie  można  podać 
rzeczywistej realizacji (sposobu działania) jednej lub kilku metod, to wtedy nadklasę definiuje się 
jako klasę abstrakcyjną.  

Przykładowo,  jeżeli  w  programie  definiujemy  klasy  opisujące  różne  osoby  (pracowników, 

studentów i in.), to pola i metody wspólne dla różnych osób możemy wyodrębnić w abstrakcyjnej 
nadklasie Osoba. Wtedy, definiując klasę Osoba, możemy pominąć definicję metody wypisującej 
dane osoby, ponieważ dokładne działanie tej metody zależy od typu osoby (np. dla pracowników 
wypisujemy  dodatkowo  stanowisko  i  staż,  a  dla  studentów  –  kierunek,  rok  studiów  i  numer 
indeksu). Dopiero w klasach pochodnych (Pracownik i Student) możemy sprecyzować działanie 
poszczególnych metod wypisujących dane obiektów poszczególnych klas. Dzięki dziedziczeniu z 
klasy  abstrakcyjnej,  wszystkie  rodzaje  osób  opisywane  własnymi  klasami  będą  miały  podobny 
opis ogólny, ułatwiający wymianę informacji.  

Czyli  jeżeli  definicja  klasy  Osoba  będzie  poprzedzona  słowem  kluczowym 

abstract

,  to  nie 

będzie można bezpośrednio utworzyć obiektów klasy Osoba w taki sposób:  

Osoba osoba1 = new Osoba("Jan", "Kowalski", 1990);  

Jeżeli  jakaś  klasa  zawiera  definicję  metody  abstrakcyjnej  (czyli  metody  zadeklarowanej  ze 

specyfikatorem 

abstract

, w której zamiast ciała metody występuje średnik), to musi być jawnie 

zadeklarowana jako abstrakcyjna – czyli nazwę klasy trzeba poprzedzić specyfikatorem 

abstract

. 

Natomiast  w  jednej  z  podklas  klasy  abstrakcyjnej,  dla  każdej  metody  abstrakcyjnej  musi  być 
podana pełna definicja odpowiedniej metody.  

Uwaga!  Jeżeli  podklasa  klasy  abstrakcyjnej  nie  przedefiniuje  wszystkich  metod 

abstrakcyjnych jej nadklasy, to sama staje się klasą abstrakcyjną.  

Program 1  
Program definiujący klasę abstrakcyjną Osoba (zawierającą metodę abstrakcyjną WypiszDane()) 
oraz dziedziczące po niej klasy Pracownik oraz Student.  

/*********************************************************************************************
*  
* Klasę Osoba (charakteryzującą pojedynczą osobę) definiowaliśmy już na poprzednich zajęciach  
**********************************************************************************************
/  
//Definicja ABSTRAKCYJNEJ KLASY Osoba  
abstract class Osoba  
{  
String imie, //Pola klasy Osoba  
nazwisko;  
int rok_ur;  
static int liczba_osob = 0; //Zmienna statyczna, zainicjowana zerem  
//Konstruktor 3-argumentowy, inicjujący pola obiektu klasy Osoba  
Osoba (String imie, String nazwisko, int rok_ur)  
{  
this.imie = imie; //nadanie wartości początkowych polom obiektu  
this.nazwisko = nazwisko;  
this.rok_ur = rok_ur;  
System.out.println("Dziala konstruktor klasy Osoba dla obiektu: "+imie+" "+nazwisko+".");  
liczba_osob++; //uaktualnienie zmiennej statycznej  
}  
//ABSTRAKCYJNA METODA wypisująca dane obiektu  
abstract void WypiszDane();  
//Statyczna funkcja składowa, wypisujące ile obiektów-osób utworzono  
static void IleOsob()  
{  
if (liczba_osob == 0)  
System.out.println("W sytemie nie ma zadnych osob!");  
else  
System.out.println("Liczba osob w systemie: "+liczba_osob+".");  
}  
}  
/****************************************************************************************  
* Dodajemy definicje klas Pracownik i Student, dziedziczących po klasie Osoba  
****************************************************************************************/  
//Definicja klasy Pracownik  
class Pracownik extends Osoba  
{  
String stanowisko; //dodatkowe pola klasy Pracownik  
int staz;  
//Konstruktor 5-argumentowy, inicjujący pola obiektu klasy Pracownik  
Pracownik(String imie, String nazwisko, int rok_ur, String stanowisko, int staz)  
{  
super(imie, nazwisko, rok_ur); //wywołanie konstruktora nadklasy (Osoba), który  
//zainicjuje pola imie, nazwisko i rok_ur  
this.stanowisko = stanowisko; //zainicjowanie pól stanowisko i staz  
this.staz = staz;  
System.out.println("Dziala konstruktor klasy Pracownik dla obiektu: "+imie+" "+nazwisko+".");  
}  
//Pełna definicja metody wypisującej dane dla obiektu Pracownik  
void WypiszDane()  
{  
System.out.println("Pracownik "+imie+" "+nazwisko+", ur. w roku "+rok_ur+",");  
System.out.println("zatrudniony na stanowisku "+stanowisko+", pracuje lat: "+staz+".\n");  
}  
}  
//Definicja klasy Student  
class Student extends Osoba  
{  
String kier; //dodatkowe pola klasy Pracownik  
int rok_stud,  
nr_indeksu;  
//Konstruktor 6-argumentowy, inicjujący pola obiektu klasy Student  
Student(String imie, String nazwisko, int rok_ur, String kier, int rok_stud, int nr_indeksu)  
{  
super(imie, nazwisko, rok_ur); //wywołanie konstruktora nadklasy (Osoba), który  
//zainicjuje pola imie, nazwisko i rok_ur  
this.kier = kier; //zainicjowanie pól kier, rok_stud oraz nr_indeksu  
this.rok_stud = rok_stud;  
this.nr_indeksu = nr_indeksu;  
System.out.println("Dziala konstruktor klasy Student dla obiektu: "+imie+" "+nazwisko+".");  
}  

//Pełna definicja metody wypisującej dane dla obiektu Student  
void WypiszDane()  
{  
System.out.println("Student "+imie+" "+nazwisko+", ur. w roku "+rok_ur+",");  
System.out.print("studiuje na kierunku "+kier+", na roku "+rok_stud);  
System.out.println(", numer indeksu: "+nr_indeksu+".\n");  
}  
}  
/****************************************************************************************  
* Definicja klasy RozneOsobyA, która zawiera funkcję główną programu  
****************************************************************************************/  
//Definicja klasy RozneOsoby  
public class RozneOsobyA  
{  
//Definicja funkcji głównej  
public static void main(String args[])  
{  
Osoba.IleOsob(); //Wywołanie funkcji statycznej składowej klasy Osoba  
//(tu dla klasy Osoba, a nie dla konkretnego obiektu)  
//Utworzenie dwóch obiektów klasy Pracownik  
Pracownik prac1 = new Pracownik("Jan", "Kowalski", 1961, "wykladowca", 10),  
prac2 = new Pracownik("Anna", "Nowak", 1970, "sekretarka", 5);  
//Utworzenie dwóch obiektów klasy Student  
Student stud1 = new Student("Adam", "Kita", 1983, "informatyka", 4, 34332),  
stud2 = new Student("Ada", "Kwiatkowska", 1985, "elektrotechnika", 2, 34338);  
Osoba.IleOsob(); //Wywołanie funkcji statycznej składowej klasy Osoba  
//(można by również napisać np. osoba1.IleOsob())  
//Wywołanie metody WypiszDane dla obiektów klasy Pracownik i Student  
System.out.println("\nPRACOWNICY:");  
prac1.WypiszDane();  
prac2.WypiszDane();  
System.out.println("\nSTUDENCI:");  
stud1.WypiszDane();  
stud2.WypiszDane();  
}  
}  

Interfejsy  
Interfejs (interface) jest to klasa abstrakcyjna, która składa się wyłącznie ze zbioru metod 
abstrakcyjnych oraz ze zbioru statycznych (static) i stałych (final) pól. Kiedy tworzymy nową 
klasę, która wykorzystuje opis metod podanych w danym interfejsie, mówimy, że klasa 
implementuje (implements) dany interfejs, tworząc definicję (realizację) każdej metody 
abstrakcyjnej interfejsu.