Programowanie w środowisku graficznym- wykład 5 Klasy c.d. (przeciążanie metod, polimorfizm) Metody i klasy abstrakcyjne Interfejsy

1 Programowanie w środowisku graficznym- wykład 5 Klasy c.d. (przeciążanie metod, polimorfizm) Metody i klasy abstrakcyjne Interfejsy Treści prezentowane w wykładzie zostały oparte o: Barteczko, JAVA Programowanie praktyczne od podstaw, PWN, 2014 Barteczko, JAVA Uniwersalne techniki programowania, PWN, 2017 http://docs.oracle.com/javase/8/docs/ C. S. Horstmann, G. Cornell, Java. Podstawy, Helion, Gliwice 2013 S. Stępniak JDK 8 WPROWADZENIE DO WYBRANYCH ZAGADNIEŃ

Bloki inicjacyjne (ang. initialization blocks) 2 W Javie zasadniczo nie można używać instrukcji sterujących poza ciałami metod i konstruktorów. Od tej zasady istnieją dwa wyjątki, a mianowicie użycie: niestatycznego bloku inicjacyjnego (inicjującego lub inicjalizacyjnego) statycznego bloku inicjacyjnego (inicjującego lub inicjalizacyjnego) Niestatyczny blok inicjacyjny wprowadzamy ujmując kod wykonywalny w nawiasy klamrowe i umieszczając taką konstrukcję w definicji klasy poza ciałem jakiejkolwiek metody (czy konstruktora). Kod bloku zostanie wykonany na etapie inicjacji obiektu, czyli przy tworzeniu obiektu, przed wywołaniem konstruktora. Taka możliwość może okazać się przydatna, gdy mamy kilka konstruktorów i chcemy wyróżnić pewien kod, który będzie inicjował obiekt niezależnie od użytego konstruktora i przed użyciem jakiegokolwiek z nich. Jeśli blok inicjujący zgłasza wyjątek, to musi on być zadeklarowany w klauzuli throws każdego konstruktora. Bloki inicjujące mogą zawierać dowolne instrukcje (np. pętle). Można zdefiniować wiele bloków inicjujących (ale nie należy tego robić, ze względu na czytelność).

3 Bloki inicjacyjne (inicjujące) -przykład class A { final static int n = 10; int tab[] = new int[n]; { //Blok inicjujący tablicę, nie musimy tej inicjacji //wpisywać do poszczególnych konstruktorów. //Można to osiągnąć przy pomocy odpowiedniej metody. for(int i=0; i<n; i++) tab[i] = i; System.out.println("Inicjalizacja"); //Wywołanie metod też jest dozwolone //konstruktory A() { //... A(int i) { //...

Bloki inicjacyjne 4 Bloki inicjujące są przydatne: w klasach anonimowych, bo tam nie da się zdefiniować konstruktora, instrukcje w bloku inicjującym mogą inicjować zmienne final, czego nie można zrobić w treści metody. Statyczne (klasowe) bloki inicjacyjne. Można też definiować bloki inicjujące wykonujące się przy tworzeniu klasy (a nie obiektu). Czyli dokonujące inicjacji na rzecz całej klasy. Ich deklaracja wygląda tak samo jak w przypadku zwykłych (egzemplarzowych) bloków inicjujących, tyle że cały blok poprzedza słowo static. Oczywiście nie ma w nim dostępu do zmiennych egzemplarzowych. W tych blokach nie można także zgłaszać sprawdzalnych wyjątków (bo nie ma gdzie ich przechwytywać). Korzystamy z nich, gdy pojawia się potrzeba wykonania jakiegoś kodu jeden raz, przy pierwszym odwołaniu do klasy (np. użyciu metody statycznej lub stworzeniu pierwszego obiektu). Przy inicjacji pól statycznych możemy skorzystać z dowolnych wyrażeń, składających się ze zmiennych i stałych statycznych oraz z wywołań statycznych metod, ale - oczywiście - nie sposób użyć instrukcji wykonywalnych (np. sterujących).

REGUŁY INICJACJI Inicjacja klasy powoduje jednokrotne zainicjowanie elementów statycznych tzn. najpierw wszystkie pola statyczne uzyskują wartości domyślne, a następnie wykonywane są inicjatory statyczne (tzn. inicjatory pól statycznych oraz statyczne bloki inicjacyjne) w kolejności ich występowania w klasie. Inicjacja klasy następuje w wyniku jej załadowania przez JVM, co może się zdarzyć przy uruchomieniu głównej klasy programu lub pierwszym odwołaniu z programu do innej klasy na skutek odwołania do składowej statycznej Tworzenie każdego obiektu (new) powoduje nadanie niestatycznym polom klasy wartości domyślnych (0, false dla typu boolean, null dla referencji), następnie wykonanie inicjatorów niestatycznych w kolejności ich występowania w klasie, po czym wykonywany jest konstruktor. W momencie tworzenia jakiegokolwiek obiektu wszystkie pola statyczne są już zainicjowane i zostały już wykonane wszystkie inicjatory statyczne. W inicjatorach statycznych można odwoływać się do wszystkich statycznych metod klasy, ale tylko do tych statycznych pól, których deklaracje poprzedzają inicjator. W inicjatorach niestatycznych można odwoływać się do wszystkich metod klasy, do wszystkich pól statycznych (niezależnie od miejsca ich występowania), ale tylko do tych pól niestatycznych, których deklaracje poprzedzają inicjator. W konstruktorze można odwoływać się do wszystkich metod i pól klasy (są już zainicjowane). 5

public class InitOrder { REGUŁY INICJACJI private static int s = 100; private static final int C; private int a = 1; InitOrder() { report("konstruktor: s, C, a, b mają wartości :", s, C, a, b); private int b = 2; { report("blok inicjacyjny: s, C, a =", s, C, a); static { report("statyczny blok inicjacyjny, zmienna s = ", s); C = 101; // opóźniona inicjacja stałej! private static void report(string msg, int... args ) { System.out.print(msg + " "); for (int i : args) { System.out.print(i + " "); System.out.println(); public static void main(string[] args) { report("wywołanie metody main"); new InitOrder();new InitOrder(); 6

REGUŁY INICJACJI 7 W wyniku zostanie wyprowadzony kod: Statyczny blok inicjacyjny, zmienna s = 100 Wywołanie metody main Blok inicjacyjny: s, C, a = 100 101 1 Konstruktor: s, C, a, b mają wartości : 100 101 1 2 Blok inicjacyjny: s, C, a = 100 101 1 Konstruktor: s, C, a, b mają wartości : 100 101 1 2 Podsumowując: najpierw - i tylko raz - inicjowane są kolejno pola statyczne, a przy każdym tworzeniu obiektu - kolejno - pola niestatyczne.

Dziedziczenie - przedefiniowanie metod Przedefiniowanie (nadpisywanie) metody (ang. overriding) nadklasy w klasie pochodnej oznacza dostarczenie w klasie pochodnej definicji nieprywatnej i niestatycznej metody z taką samą sygnaturą (czyli nazwą i listą parametrów) jak sygnatura metody nadklasy, ale z ewentualnie inną definicją ciała metody, przy czym: typy wyników tych metod muszą być takie same lub kowariantne (co oznacza m.in., że typ wyniku metody z podklasy może być podtypem wyniku metody nadklasy), przedefiniowanie nie może ograniczać dostępu: specyfikator dostępu metody przedefiniowanej w podklasie musi być taki sam lub szerszy (np. public zamiast protected) niż metody przedefiniowywanej, metoda przedefiniowana (z podklasy) nie może zgłaszać więcej lub bardziej ogólnych wyjątków kontrolowanych niż metoda przedefiniowywana (z nadklasy). 8

9 Dziedziczenie - przedefiniowanie metod Istotą przedefiniowania jest modyfikacja, uszczegółowienie funkcjonalności. Jest to wielka zaleta, bez tego programowanie obiektowe nie byłoby możliwe. Aby uniknąć możliwości popełniania podobnych błędów w przypadkach, gdy zmiany funkcjonalności fragmentów kodu nie są potrzebne, czy też są nawet niebezpieczne, w deklaracji metod stosuje się słowo kluczowe final. Słowo to użyte w deklaracji metody zabrania jej przedefiniowania. Uwaga: Przy przedefiniowaniu metod używajmy adnotacji @Override class Thought { public void message() { System.out.println("I like holidays"); public class Advice extends Thought { @Override // adnotacja @Override jest opcjonalna public void message() { System.out.println("Don't worry be happy"); super.message();// metoda z nadklasy

Przedefiniowanie i klauzula throws 10 Przedefiniowanie metody nie może poszerzać zakresu wyjatków kontrolowanych wymienionych w klauzuli throws ( wyjątki kontrolowane, to te których klasy są pochodne od klasy Exception, ale nie RuntimeException). Oznacza to, że: jeżeli metoda z klasy bazowej nie ma klauzuli throws, to metoda przedefiniowująca ją w klasie pochodnej nie może wymienić w swojej klauzuli throws żadnych wyjątków kontrolowanych, jeżeli metoda z klasy bazowej wymienia w swojej klauzuli throws jakieś wyjatki kontrolowane, to metoda przedefiniowująca ją w klasie pochodnej nie może wymienić żadnej nadklasy tych wyjątków ani żadnych dodatkowych innych klas wyjątków kontrolowanych, może natomiast wymienić dowolne wyjątki pochodzące z podklas wyjątków, zgłaszanych przez metodę z klasy bazowej, niezależnie od metody z klasy bazowej metoda przedefiniowana w klasie pochodnej może nie zgłaszać żadnych wyjatków i nie mieć klauzuli throws, metoda przedefiniowana w klasie pochodnej zawsze może zgłaszać wyjatki niekontrolowane i ewentualnie wymieniać je w swojej klauzuli throws

11 Przykład: class A { Przedefiniowanie i klauzula throws void met1() throws Exception { void met2() throws IOException { void met3() throws Exception { void met4() { class B extends A { void met1() throws IOException { //wyjątek IOException jest pochodny od Exception void met2() throws FileNotFoundException, IOException { //FileNotFoundException jest pochodny od IOException, void met3() { void met4() throws NumberFormatException { // NumberFormatException jest pochodny od RuntimeException

Przedefiniowywanie i przeciążanie metod 12 Przedefiniowanie (nadpisywanie) metod (overriding) należy odróżniać od przeciążania metod (overloading) Metody przeciążone mają po prostu te same nazwy, ale inną liczbę i/lub typy parametrów. Zwróćmy uwagę, że: po pierwsze, przeciążone metody mogą należeć do tej samej lub różnych klas (z których jedna pośrednio lub bezpośrednio dziedziczy inną), po drugie przeciążanie nie wyklucza przedefiniowania: jeśli np. w klasie A zdefiniowano dwie publiczne metody z tą samą nazwą (co oznacza, że są one przeciążone, bo sygnatury metod deklarowanych w jednej klasie muszą się różnić), to w klasie B dziedziczącej klasę A możemy je dodatkowo przeciążyć (czyli podać w deklaracji inny zestaw parametrów) oraz przedefiniować (pozostawiając sygnaturę bez zmian i dostarczając innej definicji kodu metody). Metoda prywatna nigdy nie może być przedefiniowana w podklasie. Deklaracja w podklasie metody o tej samej sygnaturze co metoda prywatna nadklasy oznacza praktycznie wprowadzenie "niezależnego" bytu do naszego programu (zatem możemy tu już mieć np. całkiem inny typ wyniku niż w metodzie prywatnej o tej samej sygnaturze z nadklasy).

Pokrywanie metod (hiding) 13 Pokryciem metody nazywa się dostarczenie w podklasie definicji metody statycznej o tej samej sygnaturze i tym samym lub kowariantnym typem wyniku jak metoda statyczna z nadklasy. Pokrywanie (hiding) nie dotyczy metod niestatycznych, co więcej jeśli w podklasie dostarczymy definicji metody statycznej o tej samej sygnaturze jak metoda niestatyczna nadklasy, to wystąpi błąd w kompilacji. Pokrywanie może dotyczyć również pól: oznacza ono wtedy deklarację w podklasie pola o takim samym identyfikatorze jak pole z nadklasy. Pokrycie identyfikatorów pól różni się zarówno od pokrywania identyfikatorów metod jak i przedefiniowania metod. Pole statyczne może pokryć pole niestatyczne i odwrotnie. Pole pokrywające pole nadklasy może mieć całkiem inny typ niż pokryte pole nadklasy. Odwołania do przedefiniowanych metod oraz pokrytych metod i pól nadklasy z poziomu metod podklasy realizowane są za pomocą konstrukcji: super.odwołanie_do_składowej

Metody wirtualne. Polimorfizm 14 Przypomnijmy, że obiekt klasy pochodnej posiada wszystkie atrybuty i metody klasy bazowej, a więc zawiera w sobie obiekt klasy bazowej (nadklasy). Dlatego odniesienie do takiego obiektu można zapamiętać w zmiennej referencyjnej klasy bazowej. class A { class B extends A { public class TestAB{ A ob1 = new A(); A ob2 = new B(); Jeśli w podklasie (klasie pochodnej) zostanie przedefiniowana jakaś metoda, zdefiniowana pierwotnie w nadklasie (klasie bazowej), to przy wywołaniu tej metody zostanie uruchomiona metoda tej klasy, do której faktycznie należy obiekt, a nie tej klasy która jest typem zmiennej referencyjnej zawierającej odniesienie do obiektu. Oznacza to, że wiązanie odwołań do metod z kodem programu następuje nie w czasie kompilacji programu, lecz fazie wykonania programu tuż przed każdorazowym wykonaniem instrukcji wywołującej przedefiniowaną metodę.

Metody wirtualne. Polimorfizm 15 class A { //... void fun() { System.out.println("Jestem z nadklasy"); //... class B extends A { // @Override void fun() { System.out.println("Jestem z podklasy"); // public class TestAB{ public static void main(string[] args) { A ob1 = new A(); A ob2 = new B(); ob1.fun();//jestem z nadklasy ob2.fun();//jestem z podklasy

Metody wirtualne. Polimorfizm 16 Metody wirtualne to takie metody, dla których wiązanie odwołań z kodem programu następuje w fazie wykonania programu. Nazywa się to "dynamic binding" lub "late binding". W Javie wszystkie metody są wirtualne za wyjątkiem: metod statycznych (bo nie dotyczą obiektów, a klasy) metod deklarowanych ze specyfikatorem final, który oznacza, że metoda jest ostateczna i nie może być przedefiniowana, metod prywatnych (bo metody prywatne nie mogą zostać przedefiniowane). Mówi się, że odwołania do metod wirtualnych są polimorficzne, a słowo "polimorficzne" używane jest w tym sensie, iż konkretny efekt odwołania może przybierać różne kształty, w zależności od tego jaki jest faktyczny typ obiektu, na rzecz którego wywołano metodę wirtualną. Thought mysl1 = new Thought(); mysl1.message(); // "I like holidays" mysl1 = new Advice(); mysl1.message(); //"Don't worry be happy" - polimorfizm

Polimorfizm - przykład class Pojazd { public void ruszaj() { System.out.println("Pojazdy służą do " + "przemieszczania się "); class Auto extends Pojazd { @Override public void ruszaj() { super.ruszaj(); // wywołanie metody nadklasy System.out.println("Auto to wygodny środek transportu"); public class TestAuto { public static void main (String args []){ Pojazd b = new Auto (); // ref. do Pojazdu, ale obiekt Auto b.ruszaj(); //wywoła metodę z klasy Auto Output: Pojazdy służą do przemieszczania się Auto to wygodny środek transportu 17

Polimorfizm - przykład Rozważmy klasę Zwierz opisującą takie właściwości różnych zwierząt jak: nazwa rodzaju, sposób komunikowania się ze światem oraz imię. class Zwierz { private String imie = "bez imienia"; Zwierz() { Zwierz(String imie) { this.imie = imie; String zwrocgatunek(){ return "Jakis zwierz"; final String zwrocimie(){ return imie; String dajglos(){ return "?"; //Metoda "mowa" symuluje wydanie głosu //wypisując odpowiedni komunikat void mowa() { System.out.println(zwrocGatunek()+" " +zwrocimie()+" mówi "+dajglos()); 18

Polimorfizm - przykład 19 Dla bazowej klasy Zwierz zdefiniujmy klasy pochodne Pies i Kot: class Pies extends Zwierz { Pies() { Pies(String imie) { super(imie); @Override String zwrocgatunek() { return "Pies"; @Override String dajglos(){ return "HAU, HAU!";

Polimorfizm - przykład 20 class Kot extends Zwierz { Kot(){ Kot(String imie) { super(imie); @Override String zwrocgatunek() { return "Kot"; @Override String dajglos(){ return "Miauuuu...";

Polimorfizm - przykład W klasie TestPolimorfizm wypróbujemy naszą hierarchię klas zwierząt przy symulowaniu rozmów pomiędzy poszczególnymi osobnikami. Rozmowę symuluje statyczna funkcja rozmowazwierzat, która ma dwa argumenty obiekty typu Zwierz, oznaczające aktualnych rozmówców. public class TestPolimorfizm{ static void rozmowazwierzat(zwierz z1, Zwierz z2) { z1.mowa(); z2.mowa(); System.out.println("--------------------------------"); public static void main(string[] arg) { Zwierz z1 = new Zwierz(),z2 = new Zwierz(); Pies pies = new Pies(), kuba = new Pies("Kuba"), reksio = new Pies("Reksio"); Kot kot = new Kot(); rozmowazwierzat(z1, z2); rozmowazwierzat(kuba, reksio); rozmowazwierzat(kuba, kot); rozmowazwierzat(reksio, pies); 21

Polimorfizm - przykład 22 W wyniku wykonania programu otrzymamy: Jakis zwierz bez imienia mówi? Jakis zwierz bez imienia mówi? ---------------------------------------- Pies Kuba mówi HAU, HAU! Pies Reksio mówi HAU, HAU! ---------------------------------------- Pies Kuba mówi HAU, HAU! Kot bez imienia mówi Miauuuu... ---------------------------------------- Pies Reksio mówi HAU, HAU! Pies bez imienia mówi HAU, HAU! ---------------------------------------- Podsumowując polimorfizm polega na tym, że metoda mowa(), określona w klasie Zwierz, dzięki wirtualności metod zwrocgatunek() i dajglos() działa prawidłowo dla różnych zwierząt (obiektów podklas klasy Zwierz).

Polimorfizm przykład Z polimorfizmem spotkaliśmy się już wielokrotnie korzystając z metody tostring(), która jest po raz pierwszy zdefiniowana w klasie Object: public class Object{ //tostring()- zwraca id obiektu jako napis //nazwa_klasy@unikalny_identyfikator_obiektu. Klasę Object dziedziczą wszystkie klasy (pośrednio lub bezpośrednio). W klasach tych można więc zawsze przedefiniować metodę tostring(). A przedefiniowane metody wołane są polimorficznie - zawsze więc uzyskamy właściwy opis obiektu (określony w danej klasie), lub - jeśli nie zdefiniowano w niej metody tostring - opis z pierwszej nadklasy, w której jest ona zdefiniowana, np. public class Para{ int a,b; @Override public String tostring(){ return "(" + a + "," + b + ")"; Pamiętajmy, że przedefiniowanie metody wymaga, aby miała ona identyczną sygnaturę i identyczny (lub kowariantny) typ wyniku jak metoda z nadklasy, a także by nie ograniczała jej widzialności (dostępu). 23

Metody i klasy abstrakcyjne Metoda abstrakcyjna to metoda, która nie ma implementacji (ciała) i jest zadeklarowana ze specyfikatorem abstract. abstract int getsomething(); //nie ma ciała {, tylko ; Klasa, w której zadeklarowano jakąkolwiek metodę abstrakcyjną jest klasą abstrakcyjną i musi być opatrzona specyfikatorem abstract. Klasa abstrakcyjna może (ale nie musi) zawierać metody abstrakcyjne. Wystarczy zadeklarować ją ze specyfikatorem abstract. abstract class SomeClass { int n; abstract int getsomething(); void say() { System.out.println("Coś tam, coś tam"); Nie można tworzyć obiektów klasy abstrakcyjnej. Klasa abstrakcyjna może być dziedziczona przez nowe klasy. Klasa pochodna powinna przedefiniować (a właściwie zdefiniować) wszystkie metody abstrakcyjne, które odziedziczyła z abstrakcyjnej klasy bazowej. W przeciwnym wypadku klasa pochodna nadal pozostanie klasą abstrakcyjną i nie będzie można tworzyć jej obiektów. 24

Metody i klasy abstrakcyjne Metody abstrakcyjne to takie, co do których nie wiemy jeszcze jaka może być ich konkretna implementacja, ale wiemy, że powinny wystąpić w zestawie metod każdej konkretnej klasy dziedziczącej klasę abstrakcyjną. Konkretna implementacja (definicja w klasie kodu metody) może być bardzo różna, w zależności od konkretnego rodzaju obiektów, które opisuje dana klasa. Przykład. Rozważmy klasę Figura, reprezentującą dowolną figurę geometryczną, którą można narysować i zmazać. Przyjmiemy, ze chociaż figury rysuje się różnie, to ściera się je tak samo. Dla zapewnienia wspólnego interfejsu dla wszystkich figur metody rysuj() i zmaz() powinny być zadeklarowane w klasie Figura. Ponieważ nie można narysować ogólnej figury, to metoda rysuj będzie abstrakcyjna. Poza tym, ogólne figury nie istnieją, zatem klasa Figura nie powinna w ogóle mieć instancji (każdy obiekt klasy Figura musi być jakąś konkretną figurą, obiektem jakiejś klasy pochodnej) public abstract class Figura { public abstract void rysuj(); public void zmaz() { System.out.println("Figura zmazana"); 25

Metody i klasy abstrakcyjne W definicji klasy pochodnej po klasie Figura musimy przedefiniować metodę rysuj(), zaś metodę zmaz() możemy, ale nie musimy, gdyż nie jest ona abstrakcyjna. class Trojkat extends Figura { private int wysokosc; public Trójkat(int wysokosc) { this.wysokosc = wysokosc; @Override public void rysuj() { for (int i = 0; i < wysokosc; i++) { for (int j = 0; j < wysokosc - i; j++) System.out.print( ); for (int j = 0; j < i * 2-1; j++) System.out.print( ^ ); System.out.println(); 26

Metody i klasy abstrakcyjne 27 Wówczas możemy używać tej klasy jak poniżej: Trojkat t = new Trojkat(7); Figura f = new Trojkat(3); //! Figura g = new Figura(); // nie można tworzyć instancji t.rysuj(); t.zmaz(); f.rysuj(); Oczywiście należy pamiętać, że referencje do obiektu typu Trojkat możemy przechowywać w zmiennej typu Figura, co wcale nie oznacza, że obiekt f z powyższego listingu jest klasy Figura jest on klasy Trojkat.

INTERFEJSY 28 Interfejs (deklarowany za pomocą słowa kluczowego interface) to: zestaw publicznych abstrakcyjnych metod (ich nagłówków) i/lub publicznych stałych (statycznych) Poczynając od wersji 8 Javy, w definicji interfejsu mogą się znaleźć definicje publicznych metod statycznych oraz publicznych domyślnych metod niestatycznych, poprzedzone słowem kluczowym default Od Javy 9 interfejsy mogą ponadto zawierać metody prywatne. Implementacja interfejsu w klasie - to zdefiniowanie w tej klasie wszystkich abstrakcyjnych metod interfejsu. To że klasa ma implementować interfejs X oznaczamy słowem kluczowym implements X. Każda klasa implementująca interfejs musi zdefiniować WSZYSTKIE jego metody abstrakcyjne albo musi być zadeklarowana jako klasa abstrakcyjna. W Javie klasa (oprócz dziedziczenia innej klasy) może implementować dowolną liczbę interfejsów. Zatem w Javie nie ma wielodziedziczenia klas, ale za to jest możliwe wielodziedziczenie interfejsów.

Interfejsy 29 Ogólna postać definicji interfejsu : [public] interface NazwaInterfejsu [extends other interfaces]{ typ nazwazmiennej = wartosc;... typ nazwametody(lista_parametrów);... Uwagi: modyfikator dostępu public przed słowem interface może nie występować - wówczas interfejs jest dostępny tylko w bieżącym pakiecie, pola to zawsze publiczne stałe statyczne nawet jeśli nie użyjemy żadnych modyfikatorów kompilator traktuje je jako public static final metody to: metody abstrakcyjne (bez implementacji) (ponieważ do tej pory interfejsy zawierały tylko metody abstrakcyjne, to słowo abstract pomijamy), metody domyślne default oraz metody statyczne Interfejsy - podobnie jak klasy - wyznaczają typy danych (referencyjne). Możemy korzystać z operatora instanceof oraz rzutowania.

Interfejsy 30 Ogólna postać definicji klasy implementującej interfejs: [modyfikator] class NazwaKlasy [extends KlasaBazowa] implements NazwaInterfejsu_1,..., NazwaInterfejsu_n{... Uwagi: klasa może implementować wiele interfejsów, klasa musi definiować wszystkie metody implementowanych interfejsów albo musi być zadeklarowana jako klasa abstrakcyjna klasa może zawierać własne (nie będące częścią interfejsu) pola i metody.

Interfejsy - przykład Przykład: Interfejs określający abstrakcyjną funkcjonalność "wydającego głos" : public interface Speakable { int QUIET = 0; int LOUD = 1; // <- publiczne stałe statyczne // domyślnie public static final String getvoice(int voice); // <- metoda abstrakcyjna; // ponieważ w interfejsie mogą być // tylko publiczne metody abstrakcyjne, // specyfikatory public i abstract niepotrzebne a jego implementacja w przykładowej klasie Wodospad: public class Wodospad implements Speakable { @Override public String getvoice(int voice) { // metody interfejsu muszą być zdefiniowane jako publiczne! if (voice == LOUD) return "SZSZSZSZSZSZ..."; else if (voice == QUIET) return "szszszszszsz..."; else return "?"; 31

Interfejsy - przykład 32 Rozważmy teraz interfejs, opisujący obiekty zdolne się poruszać: public interface Moveable { void start(); void stop(); Zauważmy, że ta funkcjonalność dotyczy zarówno Psa, jak i pojazdów np. Samochodu. Zdefiniujmy ponownie klasę Zwierz jako abstrakcyjną: public abstract class Zwierz { private String name = "bez imienia"; public Zwierz() { public Zwierz(String name) { this.name = name; public abstract String gettyp(); public String getname() { return name;

Interfejsy - przykład public class Pies extends Zwierz implements Speakable, Moveable { public Pies() { public Pies(String name) { super(name); @Override //nadpisujemy metodę z klasy Zwierz public String gettyp() { return "Pies"; @Override //implementujemy metodę z interfejsu Speakable public String getvoice(int voice) { if (voice == LOUD) return "HAU... HAU... HAU... "; else return "hau... hau..."; @Override //implementujemy metodę z interfejsu Moveable public void start() { System.out.println("Pies " + getname() + " biegnie"); @Override //implementujemy metodę z interfejsu Moveable public void stop() { System.out.println("Pies " + getname() + " stanął"); 33

Interfejsy - przykład 34 public class TestInterfaces { public static void main(string[] args) { Pies kuba = new Pies("Kuba"); kuba.start(); System.out.println(kuba.getVoice(Speakable.LOUD)); kuba.stop(); Wyjście: Pies Kuba biegnie HAU... HAU... HAU... Pies Kuba stanął Zmienna kuba jest typu Pies, a to znaczy, że jest również typu Zwierz oraz typu Speakable i Moveable. Dzięki koncepcji interfejsów uzyskaliśmy poszerzenie polimorfizmu. Polimorficzne odwołania są teraz możliwe nie tylko wzdłuż hierarchii dziedziczenia klas, ale również w poprzek.

Interfejsy przykład polimorfizmu 35 public class TestInterfaces { public static void rozmowa(speakable... rozmowcy) { for (Speakable rozmowca : rozmowcy) { if (rozmowca instanceof Zwierz) System.out.print(((Zwierz)rozmowca).getTyp() + ": "); System.out.println(rozmowca.getVoice(Speakable.LOUD)); public static void main(string[] args) { System.out.println("Rozmowa:"); rozmowa(new Pies("Burek"), new Wodospad(), new Pies("Azor")); Wynik: Rozmowa: Pies: HAU... HAU... HAU... SZSZSZSZSZSZ... Pies: HAU... HAU... HAU...

36 Interfejsy metody domyślne W Javie 8 wprowadzono możliwość definiowania metod domyślnych poprzedzonych słowem kluczowym default. W takim przypadku w interfejsie zawarta jest implementacja tych metod. Klasy implementujące ten interfejs mogą, ale nie muszą przedefiniowywać takie metody, chyba że klasa implementuje dwa lub więcej interfejsów zawierających metodę o identycznej sygnaturze. Wówczas musi ona zostać przedefiniowana w klasie. Przykład: W interfejsie Speakable zdefiniujmy domyślną metodę bezparametrową getvoice(): public interface Speakable { int QUIET = 0; // <- publiczne stałe statyczne int LOUD = 1; // domyślnie public static final String getvoice(int voice); // <- metoda abstrakcyjna; default String getvoice(){ return getvoice(quiet); Nie zmieniając nic w klasie Pies, dla obiektu tej klasy można np. Pies kuba = new Pies("Kuba"); System.out.println(kuba.getVoice()); //hau... hau...

Interfejsy metody domyślne 37 Kolejny przykład metoda domyślna foreach z interfejsu Iterable // (stripped down version of the real Iterable.java) public interface Iterable<T> { Iterator<T> iterator(); // As in prior versions // example of a new JDK 8 default method default void foreach(consumer<? super T> action) { Objects.requireNonNull(action); for (T t : this) { Przykład: action.accept(t); String[] names={"ala", "Ola", "Ula"; Stream.of(names).forEach(name -> System.out.println(name)); Metody domyślne umożliwiają prostą rozbudowę interfejsów. Dzięki ich wprowadzeniu można było rozbudować wybrane interfejsy Javy, tak by mogły być używane z nowo wprowadzonymi elementami programowania funkcyjnego.

Interfejsy metody domyślne - dziedziczenie 38 DZIEDZICZENIE METOD DOMYŚLNYCH public interface A { default int foo(integer n) { return n + n; public interface B { default int foo(integer n) { return n + 2; public class C implements A,B { @Override public int foo(integer n) { return A.super.foo(n);

Interfejsy funkcyjne 39 INTERFEJSY FUNKCYJNE to interfejsy posiadające dokładnie jedną metodę abstrakcyjną (mogą posiadać dowolnie wiele metod default) @FunctionalInterface public interface Command<T,V> { V execute(t parameter); default void itmaycontainsdefaultmethod() { //... default Long andanotherdefaultmethod() { return 20L; Adnotacja @FunctionalInterface - opcjonalnie

Metody statyczne w interfejsach 40 Jak wspominaliśmy wcześniej interfejsy oprócz metod abstrakcyjnych i metod domyślnych mogą zawierać również metody statyczne: public interface InterfaceWithStaticMethod { public static String itworks(int number) { return String.format("Works for %d", number); Uwaga: Znak % -znacznik formatowania, np.: double[] arr = { 23.59004, 35.7, 3.0, 9; for ( double el : arr ) { System.out.format( "%.2f ", el ) ;//2-miejsca po przecinku output: 23,59 35,70 3,00 9,00

Metody prywatne w interfejsach Java 9 41 Od Java 9 w interfejsach mogą występować: stałe (constant variables) metody abstrakcyjne (abstract methods) metody domyślne (default methods) metody statyczne (static methods) metody prywatne (private methods) prywatne metody statyczne (private static methods) Prywatne metody i prywatne metody statyczne zostały dodane do interfejsów w Java 9. Zatem od Java 9 możemy umieszczać metody prywatne w interejsach używając modyfikatora private (tak jak w przypadku zwykłych metod prywatnych). W metodach tych możemy umieszczać np. powtarzający się w innych metodach kod. Ponadto umożliwiają one ukrycie części kodu przed odbiorcą. Oczywiście metody private nie mogą być jednocześnie abstract. Metody te muszą być zaimplementowane (mieć swoje ciało), gdyż klasy potomne ich nie dziedziczą ( więc nie mogą w nich być zaimplementowane).

Metody prywatne w interfejsach Java 9 interface Calc{ default int addnaturalnumbers(int... nums){ return add(nums); default int addevennumbers(int... nums){ return add(nums); default int addoddnumbers(int... nums){ return add(nums); private int add(int...nums){//w funkcji private powtarzający się kod int sum = 0; for(int i:nums){ sum = sum+i; return sum; public class MyCalc implements Calc{ public static void main(string[] args){ MyCalc mycalc = new MyCalc(); int sumofnaturalnumbers = mycalc.addnaturalnumbers(1,2,3,4,5); System.out.println(sumOfNaturalNumbers); int sumofevens = mycalc.addevennumbers(2,4,6); System.out.println(sumOfEvens); int sumofodds = mycalc.addoddnumbers(1,3,5); System.out.println(sumOfOdds); 42

43 public interface DBLogging { String MONGO_DB_NAME = "ABC_Mongo_Datastore"; String NEO4J_DB_NAME = "ABC_Neo4J_Datastore"; String CASSANDRA_DB_NAME = "ABC_Cassandra_Datastore"; Metody prywatne w interfejsach Java 9 default void loginfo(string message) { log(message, "INFO"); default void logwarn(string message) { log(message, "WARN"); default void logerror(string message) { log(message, "ERROR"); default void logfatal(string message) { log(message, "FATAL"); private void log(string message, String msgprefix) { // Step 1: Connect to DataStore // Step 2: Log Message with Prefix and styles etc. // Step 3: Close the DataStore connection // Any other abstract, static, default methods

Mixin 44 Dzięki metodom domyślnym staje się możliwe wielodziedziczenie implementacji metod- mixin. MIXIN oznacza kombinację metod z różnych klas, która może być dodana do innej klasy interface Bear{ default String bear(){return "Bear"; interface Cat{ default String cat(){return "Cat"; class Bintorung implements Bear, Cat{ private String name; public Bintorung(String name){this.name=name; public String tostring(){ return " nazywam się" + name+ "\n jestem Bintorung,\n czyli" + bear() + cat();

Mixin 45 Przez implementację dwóch interfejsów w klasie Bintorung uzyskaliśmy mixin domyślnych (zaimplementowanych) metod tych interfejsów, co pozwala na rzecz obiektu Bintorung wywoływać metody: bear() i cat(). Dzięki temu nasz bintorung- zwierze z Azji, znane też jako bearcat, po wykonaniu: Bintorung wayan = new Bintorung("Wayan"); System.out.println(wayan); może o sobie powiedzieć Nazywam się Wayan i jestem Bintorung, czyli BearCat