Sierpień 9, 2018

Modyfikatory dostępu

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 JavieNie 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. 😉