Modyfikatory dostępu
Skoro już mówimy o klasach oraz dziedziczeniu to obowiązkowo trzeba wspomnieć o modyfikatorach dostępu – czyli przysłanianiu pewnych cech klas – a mówiąc profesjonalnym językiem będziemy mówić o hermetyzacji lub enkapsulacji.
Tak jak wspomniałem będziemy mówić o przysłanianiu cech – czyli “ukrywaniu” cech klas przed innymi klasami.
Mówiąc o cechach mam na myśli pola oraz metody.
Tyle słów wstępu przejdźmy do przykładu.
I ruszyli…
Na początku stwórzmy sobie dwie prosty klasy – gdzie jedna będzie dziedziczyć po drugie.
Powiedzmy, że będzie to Human oraz SuperHero.
Implementacja Human:
public class Human { String name; int age; public Human(String name, int age) { this.name = name; this.age = age; } }
oraz SuperHero:
public class SuperHero extends Human { String superPower; public SuperHero(String name, int age, String superPower) { super(name, age); this.superPower = superPower; } }
I jak zauważyłeś w tych klasach jak i w poprzednich stworzonych w tym kursie – pola nie miały przed sobą żadnego przedrostka – zaś metody miały public.
To własnie o tym będziemy mówić w tej lekcji. 😉
Modyfikatory
Posiadamy w Javie kilka modyfikatorów dostępu – tak jak wspomniałem służą one do ukrywania/odkrywania cech (danych) klasy.
Dwa z nich już poznałeś: public oraz brak modyfikatora czyli – no-modifier.
Są jeszcze dwa: protected oraz private. O wszystkich sobie dzisiaj powiemy.
Public
Zaczniemy spokojnie – czyli od najprostszego – public.
Jak sama nazwa wskazuje, że coś jest publiczne – może to być właśnie pole lub metoda.
Skoro coś jest publiczne, to znaczy, że dostępne z każdego miejsca – prawda?
No to dodajmy public do naszych pól:
public class Human { public String name; public int age; public Human(String name, int age) { this.name = name; this.age = age; } }
I jeszcze tu:
public class SuperHero extends Human { public String superPower; public SuperHero(String name, int age, String superPower) { super(name, age); this.superPower = superPower; } }
Spróbujmy teraz dostać się do wszystkich pól w main:
public class Main { public static void main(String[] args) { Human human = new Human("human", 20); SuperHero superHero = new SuperHero("superHero", 25, "Flying"); System.out.println("Human: " + human.name + ", age: " + human.age); System.out.println("Super Hero: " + superHero.name + ", age: " + superHero.age + ", super power: "+ superHero.superPower); } }
Po uruchomieniu otrzymujemy:
Human: human, age: 20 Super Hero: superHero, age: 25, super power: Flying
Czyli faktycznie wszystko się zgadza – mamy dostęp do wszystkiego. 😉
protected
Kolejnym modyfikatorem, którym omówimy jest protected – czyli coś chronionego – sprawdźmy jak bardzo. 😉
Działamy na tych samych klasach – tylko zmieniamy pola z public na protected.
W Human dodamy sobię jeszcze prostą metodę – z modyfikatorem dostępu protected.
public class Human { protected String name; protected int age; public Human(String name, int age) { this.name = name; this.age = age; } protected void displayInfo() { System.out.println("Imię: " + name + ", wiek: "+age); } }
A w SuperHero użyjmy tej metody w kolejnej metodzie – która będzie public.
public class SuperHero extends Human { protected String superPower; public SuperHero(String name, int age, String superPower) { super(name, age); this.superPower = superPower; } public void displayAboutMe() { displayInfo(); System.out.println("A super moc to: "+ superPower); } }
No i czas na testowanie w main. 😉
public class Main { public static void main(String[] args) { Human human = new Human("human", 20); SuperHero superHero = new SuperHero("superHero", 25, "Flying"); System.out.println("Human: " + human.name + ", age: " + human.age); System.out.println("Super Hero: " + superHero.name + ", age: " + superHero.age + ", super power: "+ superHero.superPower); human.displayInfo(); superHero.displayAboutMe(); superHero.displayInfo(); } }
A rezultat jest taki:
Human: human, age: 20 Super Hero: superHero, age: 25, super power: Flying Imię: human, wiek: 20 Imię: superHero, wiek: 25 A super moc to: Flying Imię: superHero, wiek: 25
Czyli wszystko działa nadal poprawnie – o co tutaj chodzi?
Protected oczywiście musi się różnić od public – to oczywiste, ale czym?
O ile public jest dostępny wszędzie – to protected jest dostępny tylko w tej samej klasie, klasie dziedziczącej oraz tym samym pakiecie!
Ze względu, że u nas klasy są w tym samym pakiecie – tym samym folderze – to mamy dostęp do wszystkiego.
Gdyby klasa Human była w innymi folderze niż Main to nie moglibyśmy już wywołac funkcji diplayInfo, ani wyciągnąć wartości z pól z klasy Human.
private
Można o nim napisać krótko – pole lub metoda z private jest widoczna tylko w tej samej klasie.
Nie jest widoczna, ani w tym samym pakiecie, ani w klasie dziedziczącej – nigdzie indziej!
Mając teraz takie klasy:
public class Human { private String name; private int age; public Human(String name, int age) { this.name = name; this.age = age; } private void displayInfo() { System.out.println("Imię: " + name + ", wiek: "+age); } }
I taką:
public class SuperHero extends Human { private String superPower; public SuperHero(String name, int age, String superPower) { super(name, age); this.superPower = superPower; } private void displayAboutMe() { displayInfo(); System.out.println("A super moc to: "+ superPower); } }
Nie jesteśmy już w stanie wywołać żadnej metody, ani dostać się do żadnego pola z poziomu innego niż sama klasa!
Main już nie zadziała – bo wszystko jest prywatne – nie dla psa kiełbasa. 😉
no-modifier
Brak modyfikatora można utożsamiać z protected – jest on nieco bardziej rygorystyczny.
Protected jest widoczny w tej samej klasie, pakiecie oraz klasie dziedziczącej.
Brak modyfikatora oznacza, że element jest widoczny tylko w tym samym pakiecie. 😉
A jego użycie wygląda po prostu tak:
public class User { String login; String pass; }
Po prostu go nie ma. 😉
Podsumowanie
Jedynym zadaniem po dzisiejszej lekcji jest przeczytanie i próba przyswojenia artykułu o hermetyzacji danych w Javie. Nie zniechęcaj się, gdy wszystkiego nie zrozumiesz – ważne, abyś coś więcej wyciągnął na temat hermetyzacji. 😉
Zadania będą dostępne dopiero po następnej lekcji – gdzie powiemy sobie o settera i getterach – co jest ściśle związane z modyfikatorem dostępu – private. 😉
Tutaj piszesz: “Brak modyfikatora oznacza, że element jest widoczny tylko w klasie dziedziczącej.” – tak właśnie nie jest, a na tej stronie https://1024kb.pl/programowanie/java/hermetyzacja-java/, że “Brak modyfikatora oznacza, że pola i metody są widoczne tylko w klasie i pakiecie.” – to jest ok.
Tak w zupełności się zgadza, błąd już jest poprawiony. 😉