I-access ang mga modifier. Pribado, protektado, default, pampubliko

Kamusta! Sa lektura ngayon, makikilala natin ang konsepto ng " access modifiers " at titingnan ang mga halimbawa ng pagtatrabaho sa kanila. Bagama't ang salitang "magkakilala tayo" ay hindi magiging ganap na tama: pamilyar ka na sa karamihan sa kanila mula sa mga nakaraang lektura. Kung sakali, i-refresh natin ang ating memorya tungkol sa pangunahing bagay. Ang mga modifier ng access ay kadalasang mga keyword na kumokontrol sa antas ng pag-access sa iba't ibang bahagi ng iyong code. Bakit "pinaka madalas"? Dahil ang isa sa mga ito ay nakatakda bilang default at hindi ipinahiwatig ng isang keyword :) Mayroong kabuuang apat na access modifier sa Java. Inilista namin ang mga ito sa pagkakasunud-sunod mula sa pinaka mahigpit hanggang sa pinaka "malambot":

• pribado;
• protektado;
• default (nakikita ang package);
• pampubliko

Tingnan natin ang bawat isa sa kanila, magpasya kung kailan sila maaaring maging kapaki-pakinabang sa atin at magbigay ng mga halimbawa :)

Pribado ang modifier

Private— ang pinaka-mahigpit na access modifier. Nililimitahan nito ang kakayahang makita ng data at mga pamamaraan sa loob ng isang klase. Alam mo ang modifier na ito mula sa lecture tungkol sa mga getter at setter. Tandaan ang halimbawang ito?

public class Cat {

   public String name;
   public int age;
   public int weight;

   public Cat(String name, int age, int weight) {
       this.name = name;
       this.age = age;
       this.weight = weight;
   }

   public Cat() {
   }

   public void sayMeow() {
       System.out.println("Meow!");
   }
}

public class Main {

   public static void main(String[] args) {

       Cat cat = new Cat();
       cat.name = "";
       cat.age = -1000;
       cat.weight = 0;
   }
}

Tiningnan namin ito sa isa sa mga artikulo kanina. Dito kami nakagawa ng isang malubhang pagkakamali: binuksan namin ang aming data, bilang isang resulta kung saan ang mga kapwa programmer ay may direktang access sa mga field ng klase at binabago ang kanilang mga halaga. Bukod dito, ang mga halagang ito ay itinalaga nang walang mga tseke, bilang isang resulta kung saan sa aming programa posible na lumikha ng isang pusa na may edad na -1000 taon, isang pangalan "" at isang timbang na 0. Upang malutas ang problemang ito, kami gumamit ng mga getter at setter , at limitado rin ang access sa data gamit ang isang modifier private.

public class Cat {

   private String name;
   private int age;
   private int weight;

   public Cat(String name, int age, int weight) {
       this.name = name;
       this.age = age;
       this.weight = weight;
   }

   public Cat() {
   }

   public void sayMeow() {
       System.out.println("Meow!");
   }

   public String getName() {
       return name;
   }

   public void setName(String name) {
       // checking the input parameter
       this.name = name;
   }

   public int getAge() {
       return age;
   }

   public void setAge(int age) {
       // checking the input parameter
       this.age = age;
   }

   public int getWeight() {
       return weight;
   }

   public void setWeight(int weight) {
       // checking the input parameter
       this.weight = weight;
   }
}

Sa totoo lang, ang paghihigpit sa pag-access sa mga field at pagpapatupad ng mga getter-setters ang pinakakaraniwang halimbawa ng paggamit privatesa totoong trabaho. Ibig sabihin, ang pagpapatupad ng encapsulation sa isang programa ang pangunahing layunin ng modifier na ito. Nalalapat ito hindi lamang sa mga patlang, sa pamamagitan ng paraan. Isipin na sa iyong programa ay mayroong isang paraan na nagpapatupad ng ilang NAPAKA-komplikadong pag-andar. Upang makabuo nito bilang isang halimbawa... Sabihin nating ang iyong pamamaraan readDataFromCollider()ay kumukuha ng isang address na may data bilang input, nagbabasa ng data mula sa Large Hadron Collider sa byte na format, nagko-convert ng data na ito sa text, nagsusulat nito sa isang file at nagpi-print nito. Kahit na ang paglalarawan ng pamamaraan ay mukhang katakut-takot, pabayaan ang code :) Upang madagdagan ang pagiging madaling mabasa ng code, makabubuting huwag isulat ang kumplikadong lohika ng pamamaraan sa isang lugar, ngunit, sa kabaligtaran, upang masira ang pag-andar sa magkakahiwalay na pamamaraan. Halimbawa, ang pamamaraan readByteData()ay may pananagutan sa pagbabasa ng data, convertBytesToSymbols()pag-convert ng data na nabasa mula sa collider sa text, saveToFile()pag-save ng resultang text sa isang file, at printColliderData()pag-print ng aming data file. Ang pamamaraan readDataFromCollider()ay magiging mas simple:

public class ColliderUtil {

   public void readDataFromCollider(Path pathToData) {
       byte[] colliderData = readByteData(pathToData);
       String[] textData = convertBytesToSymbols(colliderData);
       File fileWithData = saveToFile(textData);
       printColliderData(fileWithData);
   }

   public byte[] readByteData(Path pathToData) {

       // reads data in bytes
   }

   public String[] convertBytesToSymbols(byte[] colliderDataInBytes) {

       // convert bytes to characters
   }

   public File saveToFile(String[] colliderData) {

       // save the read data to a file
   }

   public void printColliderData(File fileWithColliderData) {

       // print data from file
   }
}

Gayunpaman, tulad ng naaalala mo mula sa panayam sa mga interface, ang gumagamit ay nakakakuha lamang ng access sa panghuling interface. At ang aming 4 na pamamaraan ay hindi bahagi nito. Ang mga ito ay pantulong : nilikha namin ang mga ito upang mapabuti ang pagiging madaling mabasa ng code at upang maiwasan ang pag-cramming ng apat na magkakaibang gawain sa isang paraan. Hindi na kailangang bigyan ang user ng access sa mga pamamaraang ito. Kung ang isang user ay may access sa pamamaraan kapag nagtatrabaho sa isang collider convertBytesToSymbols(), malamang na hindi niya maintindihan kung ano ang pamamaraang ito at kung bakit ito kinakailangan. Anong mga byte ang na-convert? Saan sila nanggaling? Bakit i-convert ang mga ito sa text? Ang logic na tumatakbo sa paraang ito ay hindi bahagi ng user interface. Ang pamamaraan lamang readDataFromCollider()ang bahagi ng interface. Ano ang gagawin sa apat na "panloob" na pamamaraang ito? Tama! Limitahan ang pag-access sa kanila gamit ang isang modifier private. Sa ganitong paraan madali nilang magagawa ang kanilang trabaho sa loob ng klase at hindi malito ang gumagamit, na hindi nangangailangan ng lohika ng bawat isa sa kanila nang hiwalay.

public class ColliderUtil {

   public void readDataFromCollider(Path pathToData) {
       byte[] colliderData = readByteData(pathToData);
       String[] textData = convertBytesToSymbols(colliderData);
       File fileWithData = saveToFile(textData);
       printColliderData(fileWithData);
   }

   private byte[] readByteData(Path pathToData) {
       // reads data in bytes
   }

   private String[] convertBytesToSymbols(byte[] colliderDataInBytes) {
       // convert bytes to characters
   }

   private File saveToFile(String[] colliderData) {
       // save the read data to a file
   }

   private void printColliderData(File fileWithColliderData) {
       // print data from file
   }
}

Pinoprotektahan ang modifier

Ang susunod na pinaka-mahigpit na access modifier ay protected. Makikita ang mga field at pamamaraan na itinalaga kasama ng access modifier :protected

• sa loob ng lahat ng klase na nasa parehong pakete ng sa amin;
• sa lahat ng kapalit na klase ng aming klase.

Ito ay kaagad na mahirap isipin kung kailan ito maaaring kailanganin. Huwag magtaka: protectedmay mas kaunting mga kaso ng aplikasyon kaysa sa private, at partikular ang mga ito. Isipin na mayroon kaming abstract na klase AbstractSecretAgentna nagpapahiwatig ng isang lihim na ahente ng ilang ahensya ng paniktik, pati na rin ang isang pakete top_secretna naglalaman ng klase na ito at mga inapo nito. Ang mga konkretong klase - FBISecretAgent, MI6SecretAgent, MossadSecretAgentatbp. - ay minana mula rito. Sa loob ng abstract na klase gusto naming ipatupad ang isang ahente counter. Kapag ang isang bagong bagay na ahente ay nilikha sa isang lugar sa programa, ito ay tataas.

package top_secret;

public abstract class AbstractSecretAgent {

   public static int agentCount = 0;
}

Ngunit ang aming mga ahente ay sikreto! Ibig sabihin, sila lang at walang iba ang dapat makaalam ng kanilang numero. Madali kaming makakapagdagdag ng modifier protectedsa field agentCount, at pagkatapos ay alinman sa mga object ng iba pang secret agent classes, o iyong mga class na matatagpuan sa aming "secret" package, ay makakakuha ng value nito top_secret.

public abstract class AbstractSecretAgent {

   protected static int agentCount = 0;
}

Ito ay para sa mga partikular na gawain na kailangan ng modifier protected:)

package na nakikitang modifier

Susunod sa aming listahan ay ang modifier defaulto, kung tawagin din ito, package visible. Hindi ito ipinahiwatig ng isang keyword dahil nakatakda ito bilang default sa Java para sa lahat ng mga field at pamamaraan. Kung sumulat ka sa iyong code -

int x = 10;

... ang variable xay magkakaroon ng parehong package visibleaccess. Kung ang isang paraan (o variable) ay hindi minarkahan ng anumang modifier, ito ay itinuturing na minarkahan ng "default na modifier". Ang mga variable o pamamaraan na may ganitong modifier (i.e. wala man lang) ay makikita sa lahat ng klase ng package kung saan sila idineklara. At sa kanila lamang. Limitado ang mga gamit nito, tulad ng modifier protected. Kadalasan, defaultginagamit ang -access sa isang package kung saan may ilang mga utility class na hindi nagpapatupad ng functionality ng lahat ng iba pang klase sa package na ito. Magbigay tayo ng halimbawa. Isipin na mayroon kaming isang " mga serbisyo " na pakete. Sa loob nito ay iba't ibang mga klase na gumagana sa database. Halimbawa, mayroong isang klase UserServicena nagbabasa ng data ng user mula sa isang database, isang klase CarServicena nagbabasa ng data tungkol sa mga kotse mula sa parehong database, at iba pang mga klase, na ang bawat isa ay gumagana sa sarili nitong uri ng mga bagay at nagbabasa ng data tungkol sa mga ito mula sa database.

package services;

public class UserService {
}

package services;

public class CarService {
}

Gayunpaman, ang isang sitwasyon ay madaling mangyari kapag ang data sa database ay nasa isang format, ngunit kailangan namin ito sa isa pa. Isipin na ang petsa ng kapanganakan ng user sa database ay nakaimbak sa format na TIMESTAMP WITH TIME ZONE...

2014-04-04 20:32:59.390583+02

...kailangan namin sa halip ang pinakasimpleng bagay - java.util.Date. Para sa layuning ito, maaari tayong lumikha servicesng isang espesyal na klase sa loob ng package Mapper. Siya ang mananagot sa pag-convert ng data mula sa database patungo sa mga Java object na pamilyar sa atin. Isang simpleng klase ng katulong. Karaniwan naming ginagawa ang lahat ng mga klase bilang public class ClassName, ngunit hindi ito kinakailangan. Maaari naming ideklara ang aming helper class bilang class Mapper. Sa kasong ito, ginagawa pa rin nito ang trabaho nito, ngunit hindi nakikita ng sinuman sa labas ng package services!

package services;

class Mapper {
}


package services;

public class CarService {

   Mapper mapper;
}

At ito, sa katunayan, ang tamang lohika: bakit ang isang tao sa labas ng package ay makakakita ng isang auxiliary class na gumagana lamang sa mga klase ng parehong pakete?

pampublikong modifier

At huling sa listahan, ngunit hindi bababa sa - ang modifier public! Nakilala mo siya sa unang araw ng pag-aaral sa JavaRush, naglulunsad ng public static void main(String[] args). Ngayong napag-aralan mo na ang mga lektura tungkol sa mga interface, ang layunin nito ay halata sa iyo :) Pagkatapos ng lahat, publicito ay nilikha upang magbigay ng isang bagay sa mga gumagamit. Halimbawa, ang interface ng iyong programa. Sabihin nating nagsulat ka ng isang programa ng tagasalin, at maaari nitong isalin ang Russian text sa English. Gumawa ka ng paraan translate(String textInRussian)kung saan ipinatupad ang kinakailangang lohika. Minarkahan mo ang paraang ito ng salitang public, at ngayon ito ay magiging bahagi ng interface:

public class Translator {

   public String translate(String textInRussian) {

       // translates text from Russian to English
   }
}

Maaari mong iugnay ang isang tawag sa paraang ito sa pindutang "isalin" sa screen ng programa - at iyon na! Kahit sino ay maaaring gumamit nito. Ang mga bahagi ng code na minarkahan ng modifier publicay inilaan para sa end user. Upang magbigay ng isang halimbawa mula sa buhay, privateito ang lahat ng mga prosesong nagaganap sa loob ng TV kapag ito ay gumagana, at publicito ang mga pindutan sa remote control ng TV kung saan makokontrol ito ng user. Kasabay nito, hindi niya kailangang malaman kung paano gumagana ang TV at kung paano ito gumagana. Ang remote control ay isang set publicng -methods: on(), off(), nextChannel(), previousChannel(), increaseVolume(), decreaseVolume()etc.