Hermetyzacja Pakiety Składowe statyczne i ﬁnalne

(1)

Hermetyzacja Pakiety

Składowe statyczne i finalne

(2)

Specyfikatory dostępu

- Przed każdą składową (polem lub metodą) klasy może, a często wręcz powinien pojawiać się specyfikator dostępu (modyfikator dostępu, ang. access modifier ).

- Specyfikator taki pozwala na określenie praw dostępu do składowych klas, a także do samych klas.

Dostęp do pola i metody może być:

publiczny - public prywatny - private chroniony - protected

pakietowy - domyślny, gdy brak specyfikatora

- Domyślnie, jeżeli przed składową klasy nie występuje żadne określenie, dostęp jest pakietowy - dostęp do tej składowej mają wszystkie klasy wchodzące w skład danego pakietu.

Monika Wrzosek (IM UG) Programowanie obiektowe 112 / 136

(3)

Specyfikatory dostępu - public

Dostęp publiczny - public

Jeżeli składowa klasy jest publiczna, oznacza to, że mają do niej dostęp wszystkie inne klasy; dostęp jest nieograniczony.

c l a s s Punkt { p u b l i c i n t x ; p u b l i c i n t y ;

p u b l i c i n t p o b i e r z X ( ) { r e t u r n x ;

}

p u b l i c v o i d ustawXy (i n t wspX , i n t wspY ) { x = wspX ;

y = wspY ; }

}

(4)

Specyfikatory dostępu - private

Dostęp prywatny - private

- Składowe oznaczone jako private to takie, które są dostępne jedynie z wnętrza danej klasy.

- Wszystkie metody danej klasy mogą je dowolnie odczytywać i zapisywać;

dostęp z zewnątrz jest zabroniony zarówno dla zapisu, jak i odczytu.

Kompilacja poniższego programu zakończy się błędem.

c l a s s Punkt { p r i v a t e i n t x ; p r i v a t e i n t y ; }

c l a s s Main {

p u b l i c s t a t i c v o i d main ( S t r i n g a r g s [ ] ) { Punkt P = new Punkt ( ) ;

P . x = 1 0 0 ; P . y = 2 0 0 ;

S y s t e m . o u t . p r i n t l n ("P . x = " + P . x + " , P . y = " + P . y ) ; }

}

(5)

c l a s s Punkt { p r i v a t e i n t x ; p r i v a t e i n t y ; }

P . x = 1 0 0 ; P . y = 2 0 0 ;

S y s t e m . o u t . p r i n t l n ("P . x = " + P . x + " , P . y = " + P . y ) ; }

}

Main . j a v a : 4 : e r r o r : x h a s p r i v a t e a c c e s s i n Punkt P . x = 1 0 0 ;

^

Main . j a v a : 5 : e r r o r : y h a s p r i v a t e a c c e s s i n Punkt P . y = 2 0 0 ;

^

Main . j a v a : 6 : e r r o r : x h a s p r i v a t e a c c e s s i n Punkt

S y s t e m . o u t . p r i n t l n ("P . x = " + P . x + " , P . y = " + P . y ) ;

^

Main . j a v a : 6 : e r r o r : y h a s p r i v a t e a c c e s s i n Punkt

S y s t e m . o u t . p r i n t l n ("P . x = " + P . x + " , P . y = " + P . y ) ;

^

(6)

W jaki zatem sposób odwołać się do pola prywatnego? Wystarczy napisać publiczne metody pobierające i ustawiające pola prywatne.

c l a s s Punkt { p r i v a t e i n t x , y ; p u b l i c i n t p o b i e r z X ( ) {

r e t u r n x ; }

p u b l i c i n t p o b i e r z Y ( ) { r e t u r n y ;

}

p u b l i c v o i d ustawX (i n t wspX ) { x = wspX ;

}

p u b l i c v o i d ustawY (i n t wspY ) { y = wspY ;

} }

P . ustawX ( 1 0 0 ) ; // z a m i a s t : P . x = 1 0 0 ;

P . ustawY ( 2 0 0 ) ; // z a m i a s t : P . y = 2 0 0 ;

S y s t e m . o u t . p r i n t l n ("P . x = " + P . p o b i e r z X ( ) ) ; S y s t e m . o u t . p r i n t l n ("P . y = " + P . p o b i e r z Y ( ) ) ; }}

(7)

Składowe prywatne nie są dostępne dla klas potomnych. Jeżeli z klasy Punkt

c l a s s Punkt { p r i v a t e i n t x ; p r i v a t e i n t y ;

p u b l i c i n t p o b i e r z X ( ) { r e t u r n x ;

}

} }

wyprowadzimy klasę Punkt3D w postaci:

c l a s s Punkt3D e x t e n d s Punkt { p r i v a t e i n t z ;

}

klasa ta nie będzie miała żadnego dostępu do pól x i y .

(8)

Specyfikatory dostępu - protected

- Składowe oznaczone słowem protected to składowe chronione.

- Są one dostępne jedynie dla metod danej klasy, klas potomnych oraz klas z tego samego pakietu.

c l a s s Punkt { p r o t e c t e d i n t x ; p r o t e c t e d i n t y ; }

c l a s s Punkt3D e x t e n d s Punkt { p r o t e c t e d i n t z ;

}

Klasa Punkt3D będzie miała (inaczej niż w przypadku składowych prywatnych) pełny dostęp do pól x i y klasy Punkt.

(9)

Specyfikatory dostępu - przykład

Dlaczego zabraniać przy użyciu modyfikatorów private i protected bezpośredniego dostępu do niektórych składowych klas?

Chodzi o ukrycie implementacji wnętrza klasy.

Programista, projektując daną klasę, udostępnia na zewnątrz (innym

programistom) pewien interfejs służący do posługiwania się jej obiektami. Określa więc sposób, w jaki można korzystać z danego obiektu.

To, co znajduje się we wnętrzu, jest ukryte, dzięki temu można całkowicie zmienić wewnętrzną konstrukcję klasy, nie zmieniając zupełnie sposobu korzystania z niej.

Mówimy wtedy o hermetyzacji lub enkapsulacji (ang. encapsulation).

(10)

Przypomnijmy postać klasy Punkt i klasy Main:

c l a s s Punkt { p r i v a t e i n t x , y ; p u b l i c i n t p o b i e r z X ( ) {

r e t u r n x ; }

}

} }

p u b l i c s t a t i c v o i d main ( S t r i n g a r g s [ ] ) { Punkt p u n k t = new Punkt ( ) ;

p u n k t . ustawX ( 1 0 0 ) ; p u n k t . ustawY ( 2 0 0 ) ;

S y s t e m . o u t . p r i n t l n (" p u n k t . x = " + p u n k t . p o b i e r z X ( ) ) ; S y s t e m . o u t . p r i n t l n (" p u n k t . y = " + p u n k t . p o b i e r z Y ( ) ) ; }

}

(11)

Załóżmy, że zaistniała konieczność zmiany sposobu reprezentacji współrzędnych punktu na układ biegunowy, w którym położenie punktu jest opisywane za pomocą dwóch parametrów: kąta α oraz odległości od początku układu współrzędnych.

- W klasie Punkt nie będzie już pól x i y , więc przestaną mieć sens wszelkie odwołania do nich.

- Gdyby pola te były zadeklarowane jako publiczne, byłby to spory problem. Nie dość, że we wszystkich programach wykorzystujących klasę Punkt trzeba byłoby zmieniać odwołania, to dodatkowo w każdym takim miejscu należałoby

dokonywać przeliczania współrzędnych.

- Jednak dzięki temu, że pola x i y są prywatne, a dostęp do nich odbywa się przez publiczne metody, wystarczy tylko odpowiednio zmienić interfejs klasy Punkt.

- Pola int x i int y zamieniamy na pola reprezentujące kąt i odległość.

- Do zmodyfikowania metod potrzebne będą wzory przekształcające wartości współrzędnych kartezjańskich na układ biegunowy i odwrotnie:

x = r · cos(α) = r · q

1 − sin²(α), r =p

x²+ y²,

y = r · sin(α), sin(α) = y

r.

(12)

c l a s s Punkt {

p r i v a t e d o u b l e s i n u s a l f a ; p r i v a t e d o u b l e modul ; p u b l i c i n t p o b i e r z X ( ) {

d o u b l e x = modul ∗ Math . s q r t ( 1 − s i n u s a l f a ∗ s i n u s a l f a ) ; r e t u r n (i n t) x ;

}

p u b l i c i n t p o b i e r z Y ( ) { d o u b l e y = modul ∗ s i n u s a l f a ; r e t u r n (i n t) y ;

}

p u b l i c v o i d ustawX (i n t wspX ) { i n t x = wspX ;

i n t y = p o b i e r z Y ( ) ;

modul = Math . s q r t ( x ∗ x + y ∗ y ) ; s i n u s a l f a = y / modul ;

}

p u b l i c v o i d ustawY (i n t wspY ) { i n t x = p o b i e r z Y ( ) ;

i n t y = wspY ;

modul = Math . s q r t ( x ∗ x + y ∗ y ) ; s i n u s a l f a = y / modul ;

} }

Klasa Main nie ulega żadnym zmianom.

(13)

Pakiety

Klasy w Javie są grupowane w jednostki nazywane pakietami.

Pakiet to inaczej biblioteka, zestaw powiązanych ze sobą tematycznie klas.

Tworzenie pakietów package nazwa_pakietu;

Ten zapis musi być umieszczony na początku pliku, przed nim nie mogą znajdować się żadne instrukcje.

p a c k a g e g r a f i k a ; c l a s s Punkt {

// t r e ś ć k l a s y Main }

Aby móc korzystać z obiektów klasy Punkt w innych klasach (np. w Main), należy użyć polecenia import

i m p o r t g r a f i k a . Punkt ; c l a s s Main {

// t r e ś ć k l a s y Main }

Polecenie import grafika.Punkt mówi kompilatorowi, że będziemy korzystać z klasy Punkt znajdującej się w pakiecie grafika.

(14)

Jeżeli nie napiszemy polecenia import grafika.Punkt; to w przypadku odwoływania się do klasy Punkt trzeba będzie podać pełną nazwę pakietową, np:

g r a f i k a . Punkt P = new g r a f i k a . Punkt ( ) ;

Aby zaimportować wszystkie klasy z pakietu grafika, należy użyć polecenia import grafika.*;

Pakiety pozwalają również na uniknięcie konfliktu nazw. Jeżeli dwóch

programistów utworzy klasy o tej samej nazwie, to aby można było skorzystać z obu tych klas naraz w programie, należy umieścić je w dwóch różnych pakietach, np:

Plik o nazwie Punkt w katalogu grafika2d:

p a c k a g e g r a f i k a 2 d ; p u b l i c c l a s s Punkt {

p u b l i c i n t x , y ; }

Plik o nazwie Punkt w katalogu grafika3d:

p a c k a g e g r a f i k a 3 d ; p u b l i c c l a s s Punkt {

p u b l i c i n t x , y , z ; }

(15)

p u b l i c s t a t i c v o i d main ( S t r i n g a r g s [ ] ) {

g r a f i k a 2 d . Punkt p u n k t 2 d = new g r a f i k a 2 d . Punkt ( ) ; g r a f i k a 3 d . Punkt p u n k t 3 d = new g r a f i k a 3 d . Punkt ( ) ; p u n k t 2 d . x = 1 0 0 ;

p u n k t 2 d . y = 2 0 0 ;

S y s t e m . o u t . p r i n t l n (" p u n k t 2 d . x = " + p u n k t 2 d . x ) ; S y s t e m . o u t . p r i n t l n (" p u n k t 2 d . y = " + p u n k t 2 d . y ) ; p u n k t 3 d . x = 1 1 0 ;

p u n k t 3 d . y = 1 2 0 ; p u n k t 3 d . z = 1 3 0 ;

S y s t e m . o u t . p r i n t l n (" \ n p u n k t 3 d . x = " + p u n k t 3 d . x ) ; S y s t e m . o u t . p r i n t l n (" p u n k t 3 d . y = " + p u n k t 3 d . y ) ; S y s t e m . o u t . p r i n t l n (" p u n k t 3 d . y = " + p u n k t 3 d . z ) ; }

}

Katalogi grafika2d i grafika3d umieszczamy w folderze, w którym znajduje się kod klas korzystających z tych pakietów (w naszym przykładzie: w folderze, w którym jest kod klasy Main).

W przeciwnym przypadku należy ustawić zmienną środowiskową CLASSPATH tak, aby zawierała oddzielone średnikami nazwy wszystkich katalogów, w których zaczynają się struktury pakietów, np: C:\dokumenty\java\.

(16)

Pakiety

Klasy w Javie można podzielić na trzy typy:

publiczne - jeśli przed nazwą klasy jest modyfikator public pakietowe - jeśli przed nazwą klasy nie ma modyfikatora public.

wewnętrzne.

- Do tej pory trzymaliśmy się zasady, że w jednym pliku o rozszerzeniu java można umieścić tylko jedną klasę. Nie jest to prawda.

- Prawidłowo: w jednym pliku java może znaleźć się tylko jedna klasa publiczna.

- W takim pliku można dodatkowo umieszczać klasy o dostępie pakietowym.

Poniższy kod wpisujemy do jednego pliku o nazwie Punkt.java:

p a c k a g e g r a f i k a ; p u b l i c c l a s s Punkt {

i n t x , y

P o m o c n i c z a pom ; // d a l s z a t r e ś ć k l a s y }

c l a s s P o m o c n i c z a { // t r e ś ć k l a s y }

(17)

p a c k a g e g r a f i k a ; p u b l i c c l a s s Punkt {

i n t x , y

P o m o c n i c z a pom ; // d a l s z a t r e ś ć k l a s y }

c l a s s P o m o c n i c z a { // t r e ś ć k l a s y }

Ponieważ obie klasy należą do pakietu grafika, plik Punkt.java powinien

znajdować się w podkatalogu grafika. Ścieżkę do tego katalogu należy zapisać w zmiennej CLASSPATH lub podkatalog ten umieścić bezpośrednio w katalogu, w którym jest plik Main.java.

Dostęp do klasy Pomocnicza jest możliwy wyłącznie dla klas z pakietu grafika.

Testowa klasa Main (spoza pakietu grafika) nie będzie miała dostępu do klasy Pomocnicza a poniższy kod zakończy się błędem kompilacji.

i m p o r t g r a f i k a . ∗ ; c l a s s Main {

p u b l i c s t a t i c v o i d main ( S t r i n g a r g s [ ] ) { Punkt p u n k t = new Punkt ( ) ;

P o m o c n i c z a pom = new P o m o c n i c z a ( ) ; // b ł ą d − b r a k d o s t ę pu }

}

(18)

Składowe statyczne

Składowe statyczne - oznaczane słowem static - to pola i metody klasy, które mogą istnieć, nawet jeśli nie istnieje obiekt tej klasy.

Metoda/pole statyczne jest umieszczane w specjalnie zarezerwowanym obszarze pamięci i jeśli powstaną obiekty danej klasy, będzie ono dla nich wspólne. To znaczy, że dla każdego obiektu klasy nie tworzy się kopii metody/pola statycznego.

p u b l i c c l a s s A {

p u b l i c s t a t i c v o i d f ( ) {

S y s t e m . o u t . p r i n t l n (" Metoda f k l a s y A") ; }

}

Metodę statyczną f można wywołać klasycznie (tzn. po utworzeniu obiektu klasy A):

p u b l i c c l a s s Main {

p u b l i c s t a t i c v o i d main ( S t r i n g a r g s [ ] ) { A a = new A ( ) ;

a . f ( ) ; }}

lub statycznie (bez tworzenia obiektu klasy A):

p u b l i c s t a t i c v o i d main ( S t r i n g a r g s [ ] ) { A . f ( ) ;

}}

(19)

p u b l i c c l a s s A {

p u b l i c s t a t i c i n t l i c z b a ; }

p u b l i c s t a t i c v o i d main ( S t r i n g a r g s [ ] ) { A . l i c z b a = 1 0 0 ;

S y s t e m . o u t . p r i n t l n (" Po p r z y p i s a n i u : A . l i c z b a = 1 0 0 : ") ; S y s t e m . o u t . p r i n t l n ("A . l i c z b a : " + A . l i c z b a ) ;

A a1 = new A ( ) ; A a2 = new A ( ) ;

S y s t e m . o u t . p r i n t l n (" \ n Po u t w o r z e n i u o b i e k t ów : ") ; S y s t e m . o u t . p r i n t l n (" a1 . l i c z b a : " + a1 . l i c z b a ) ; S y s t e m . o u t . p r i n t l n (" a2 . l i c z b a : " + a2 . l i c z b a ) ; a1 . l i c z b a = 2 0 0 ;

S y s t e m . o u t . p r i n t l n (" \ n Po p r z y p i s a n i u : a1 . l i c z b a = 2 0 0 : ") ; S y s t e m . o u t . p r i n t l n (" a1 . l i c z b a : " + a1 . l i c z b a ) ;

S y s t e m . o u t . p r i n t l n (" a2 . l i c z b a : " + a2 . l i c z b a ) ; a2 . l i c z b a = 3 0 0 ;

S y s t e m . o u t . p r i n t l n (" \ n Po p r z y p i s a n i u : a2 . l i c z b a = 3 0 0 : ") ; S y s t e m . o u t . p r i n t l n (" a1 . l i c z b a : " + a1 . l i c z b a ) ;

S y s t e m . o u t . p r i n t l n (" a2 . l i c z b a : " + a2 . l i c z b a ) ; }

}

(20)

Wynik działania programu:

Po p r z y p i s a n i u : A . l i c z b a = 1 0 0 : A . l i c z b a : 100

Po u t w o r z e n i u o b i e k t ów : a1 . l i c z b a : 100

a2 . l i c z b a : 100

Po p r z y p i s a n i u : a1 . l i c z b a = 2 0 0 : a1 . l i c z b a : 200

a2 . l i c z b a : 200

Po p r z y p i s a n i u : a2 . l i c z b a = 3 0 0 : a1 . l i c z b a : 300

a2 . l i c z b a : 300

(21)

Klasy finalne

Klasa finalna - oznaczana słowem final - to taka, która nie będzie miała klas pochodnych.

p u b l i c f i n a l c l a s s O s t a t e c z n a { p u b l i c i n t l i c z b a ;

p u b l i c v o i d w y s w i e t l ( ) { S y s t e m . o u t . p r i n t l n ( l i c z b a ) ; }

}

Poniższa definicja klasy Ostateczna2 jest niepoprawna; kompilacja zakończy się błędem.

p u b l i c c l a s s O s t a t e c z n a 2 e x t e n d s O s t a t e c z n a { p u b l i c i n t l i c z b a 2 ;

// d a l s z a t r e ś ć k l a s y }

(22)

Pola finalne

Pole finalne to takie, którego wartość jest stała i nie można jej zmieniać.

p u b l i c f i n a l c l a s s O b l i c z e n i a { p u b l i c f i n a l i n t l i c z b a 1 = 1 0 0 ; p u b l i c i n t l i c z b a 2 ;

p u b l i c v o i d l i c z ( ) {

// p r a w i d ł owo : o d c z y t p o l a l i c z b a 1 , z a p i s p o l a l i c z b a 2 : l i c z b a 2 = 2 ∗ l i c z b a 1 ;

// p r a w i d ł owo : o d c z y t p ó l l i c z b a 1 i l i c z b a 2 , z a p i s p o l a l i c z b a 2 : l i c z b a 2 = l i c z b a 2 + l i c z b a 1 ;

// n i e p r a w i d ł owo : n i e d o z w o l o n y z a p i s p o l a l i c z b a 1 : // l i c z b a 1 = l i c z b a 2 / 2 ;

S y s t e m . o u t . p r i n t l n ( l i c z b a 1 + " " + l i c z b a 2 ) ; }

p u b l i c s t a t i c v o i d main ( S t r i n g a r g s [ ] ) { O b l i c z e n i a ob = new O b l i c z e n i a ( ) ; ob . l i c z ( ) ;

} }

(23)

Pola finalne

Pole finalne typu referencyjnego:

p u b l i c c l a s s Punkt { p u b l i c i n t x , y ; }

p u b l i c s t a t i c f i n a l Punkt p u n k t = new Punkt ( ) ;

p u b l i c s t a t i c v o i d main ( S t r i n g a r g s [ ] ) {

// p r a w i d ł owo , moż na m o d y f i k o w a ć p o l a o b i e k t u p u n k t : p u n k t . x = 1 0 0 ;

p u n k t . y = 2 0 0 ;

// n i e p r a w i d ł owo , n i e moż na z m i e n i a ć r e f e r e n c j i f i n a l n e j : // p u n k t = new Punkt ( ) ;

} }

(24)

Pola finalne można też deklarować bez ich inicjalizacji. Wartością takiego pola staje się wartość użyta w pierwszym przypisaniu i dopiero od tej chwili nie wolno jej zmieniać.

Pole takie musi zostać zainicjalizowane w konstruktorze danej klasy.

p u b l i c f i n a l i n t l i c z b a 1 = 1 0 0 ; p u b l i c f i n a l i n t l i c z b a 2 ;

p u b l i c f i n a l Punkt p u n k t 1 = new Punkt ( ) ; p u b l i c f i n a l Punkt p u n k t 2 ;

p u b l i c Main ( ) {

// p r a w i d ł owo , moż na m o d y f i k o w a ć p o l a o b i e k t u p u n k t 1 : p u n k t 1 . x = 1 0 0 ; p u n k t 1 . y = 2 0 0 ;

// n i e p r a w i d ł owo , n i e ma j e s z c z e o b i e k t u p u n k t 2 : p u n k t 2 . x = 2 0 0 ; p u n k t 2 . y = 3 0 0 ;

// n i e p r a w i d ł owo , n i e moż na z m i e n i a ć r e f e r e n c j i f i n a l n e j : p u n k t 1 = new Punkt ( ) ;

// p r a w i d ł owo , i n i c j a l i z a c j a p o l a f i n a l n e g o : p u n k t 2 = new Punkt ( ) ;

// p r a w i d ł owo , moż na m o d y f i k o w a ć p o l a o b i e k t u p u n k t 2 : p u n k t 2 . x = 2 0 0 ; p u n k t 2 . y = 3 0 0 ;

// n i e p r a w i d ł owo , n i e moż na m o d y f i k o w a ć p o l a f i n a l n e g o : l i c z b a 1 = 2 0 0 ;

// p r a w i d ł owo , i n i c j a l i z a c j a p o l a f i n a l n e g o : l i c z b a 2 = 3 0 0 ;

// n i e p r a w i d ł owo , p o l e l i c z b a 2 z o s t a ł o j u ż z a i n i c j a l i z o w a n e : l i c z b a 2 = 4 0 0 ;

}}

(25)

Metody finalne

Metoda finalna to taka, której nie można przesłonić w klasie potomnej.

Poniższy kod jest nieprawidłowy.

p u b l i c c l a s s Bazowa {

p u b l i c f i n a l v o i d metoda ( ) { // kod metody

} }

p u b l i c c l a s s Pochodna e x t e n d s Bazowa { p u b l i c v o i d metoda ( ) {

// kod metody }

}

(26)

Argumenty finalne

Argument finalny to taki, którego nie wolno zmieniać wewnątrz metody.

p u b l i c c l a s s A r g u m e n t y F i n a l n e {

p u b l i c v o i d metoda1 (f i n a l i n t l i c z b a ) {

// p r a w i d ł owo , moż na o d c z y t y w a ć w a r t o ś ć a r g u m e n t u : i n t x = l i c z b a ;

// n i e p r a w i d ł owo , n i e moż na m o d y f i k o w a ć a r g u m e n t u f i n a l n e g o : // l i c z b a = 1 0 0 ;

}

p u b l i c v o i d metoda2 (f i n a l Punkt p u n k t ) {

// p r a w i d ł owo , moż na o d c z y t y w a ć w a r t o ś c i p ó l o b i e k t u // w s k a z y w a n e g o p r z e z p u n k t :

i n t x = p u n k t . x ; i n t y = p u n k t . y ;

// n i e p r a w i d ł owo , n i e moż na m o d y f i k o w a ć a r g u m e n t u f i n a l n e g o : // p u n k t = new Punkt ( ) ;

// p r a w i d ł owo , moż na z a p i s y w a ć p o l a o b i e k t u // w s k a z y w a n e g o p r z e z a r g u m e n t f i n a l n y p u n k t : p u n k t . x = 1 0 0 ;

p u n k t . y = 1 0 0 ; }

}