Tilgang Modifikatorer i Java

Hei! I dagens leksjon vil vi bli kjent med konseptet med tilgangsmodifikatorer og vurdere eksempler på hvordan man kan jobbe med dem. Å si "bli kjent" er selvfølgelig ikke helt riktig: du er allerede kjent med de fleste av dem fra tidligere leksjoner. Bare i tilfelle, la oss friske opp minnet om det viktigste punktet. Modifikatortilgang er oftest nøkkelord som regulerer tilgangen til ulike deler av koden din. Hvorfor 'oftest'? Fordi en av dem er satt som standard uten bruk av et nøkkelord :) Java har fire tilgangsmodifikatorer. Vi lister dem opp i rekkefølge fra mest restriktive til mest 'låsomme':

• privat;
• standard (pakken synlig);
• beskyttet;
• offentlig.

La oss ta en titt på hver av dem og identifisere når de kan være nyttige. Og vi skal gi eksempler :)

Den private modifikatoren

privat er den mest restriktive tilgangsmodifikatoren. Det begrenser synligheten av data og metoder til innenfor en enkelt klasse. Du kjenner denne modifikatoren fra leksjonen om gettere og settere. Husker du dette eksemplet?

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;
   }
}

Vi vurderte det i en tidligere leksjon. Vi gjorde en alvorlig feil her: Vi offentliggjør dataene våre, noe som tillot andre programmerere å få tilgang til feltene direkte og endre verdiene deres. Dessuten... disse verdiene ble tildelt uten noen kontroller. Dette betyr at programmet vårt kunne lage en katt som heter "" med en alder på -1000 år og vekt på 0. For å løse dette problemet brukte vi gettere og settere, og brukte også den private modifikatoren for å begrense tilgangen til dataene.

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) {
       // input parameter check
       this.name = name;
   }

   public int getAge() {
       return age;
   }

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

   public int getWeight() {
       return weight;
   }

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

I utgangspunktet er begrenset tilgang til felt og implementering av gettere og settere de vanligste eksemplene på hvor privatville bli brukt i virkelig arbeid. Med andre ord, hovedformålet med denne modifikatoren er å oppnå innkapsling i et program. Dette gjelder forresten ikke bare for felt. Tenk deg at programmet ditt har en metode som implementerer en VELDIG kompleks funksjonalitet. Hva kan vi foreslå som eksempel? La oss si at din readDataFromCollider()-metode godtar en dataadresse som input, leser data fra Large Hadron Collider i byteformat, konverterer disse dataene til tekst, skriver dem til en fil og skriver dem ut. Selv en beskrivelse av metoden ser skummel ut, for ikke å si noe om koden :) For å gjøre koden mer lesbar, ville det være best å ikke skrive all metodens komplekse logikk på ett sted. I stedet bør vi dele opp funksjonaliteten i separate metoder. For eksempel, readByteData()metoden er ansvarlig for å lese data, convertBytesToSymbols() -metoden konverterer dataene som er lest fra kollideren til tekst, saveToFile()- metoden lagrer den mottatte teksten til en fil, og printColliderData()- metoden skriver ut datafilen vår. Til slutt vil vår readDataFromCollider()- metode være mye enklere:

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) {

       // Converts bytes to characters
   }

   public File saveToFile(String[] colliderData) {

       // Saves read data to a file
   }

   public void printColliderData(File fileWithColliderData) {

       // Prints data from the file
   }
}

Men som du vil huske fra leksjonen om grensesnitt, får brukeren kun tilgang til det eksterne grensesnittet. Og våre 4 metoder er ikke en del av det. De er hjelpemetoder: vi opprettet dem for å forbedre lesbarheten til koden og for ikke å stappe fire forskjellige oppgaver i én metode. Du trenger ikke gi brukeren tilgang til disse metodene. Hvis brukere har tilgang til convertBytesToSymbols() -metoden når de jobber med kollideren, vil de mest sannsynlig ganske enkelt bli forvirret av metoden og lure på hva den er til for. Hvilke byte konverteres? Hvor kom de fra? Hvorfor konvertere dem til tekst? Logikken som utføres i denne metoden er ikke en del av grensesnittet som er eksponert for brukeren. Bare readDataFromCollider()metoden er en del av grensesnittet. Så hva gjør vi med disse fire 'interne' metodene? Ikke sant! Bruk den private modifikatoren for å begrense tilgangen til dem. Ved å gjøre dette kan de fredelig utføre arbeidet sitt i klassen uten å forvirre brukeren, som ikke trenger å kjenne logikken til hver enkelt metode.

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) {
       // Converts bytes to characters
   }

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

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

Den beskyttede modifikatoren

Den neste mest restriktive modifikatoren er beskyttet . Felter og metoder merket med modifikatoren for beskyttet tilgang vil være synlige:

• innenfor alle klasser inkludert i samme pakke som vår;
• innenfor alle klasser som arver klassen vår.

Til å begynne med er det vanskelig å forestille seg når dette kan være nødvendig. Ikke bli overrasket: det er langt færre brukstilfeller for beskyttede enn for private , og de er veldig spesifikke. Tenk deg at vi har en AbstractSecretAgent abstrakt klasse som representerer en hemmelig agent i en eller annen etterretningstjeneste, samt en top_secret- pakke som inneholder denne klassen og dens etterkommere. Konkrete klasser som FBISecretAgent , MI6SecretAgent , MossadSecretAgent osv. arver det. Inne i abstraktklassen ønsker vi å implementere en agentteller. Den vil øke når en ny agent opprettes et sted i programmet. pakke topp_hemmelig;

public abstract class AbstractSecretAgent {

   public static int agentCount = 0;
}

Men våre agenter er hemmelige! Det betyr at de og ingen andre skal vite hvor mange av dem som finnes. Vi kan enkelt legge til den beskyttede modifikatoren i agent_counter- feltet. Da kan forekomster av andre hemmelige agentklasser og andre klasser som ligger i vår top_secret- pakke få sin verdi.

public abstract class AbstractSecretAgent {

   protected static int agent_counter = 0;
}

Og det er den typen spesialisert oppgave som krever den beskyttede modifikatoren :)

Pakkens synlige modifikator

Neste på listen er standardmodifikatoren , også kjent som pakkens synlige modifikator. Det er ikke angitt med et nøkkelord, siden Java bruker det som standard på alle felt og metoder. Hvis du skriver følgende i koden din:

int x = 10

x - variabelen vil ha denne pakken synlig tilgang. Det er lett å huske hva det gjør. I utgangspunktet er standard = beskyttet arv :) I likhet med den beskyttede modifikatoren er applikasjonen begrenset. Oftest brukes standardtilgang i en pakke som har noen verktøyklasser som ikke implementerer funksjonaliteten til alle de andre klassene i pakken. La oss gi et eksempel. Tenk deg at vi har en "tjenester"-pakke. Den inneholder ulike klasser som fungerer med en database. For eksempel er det en UserService- klasse som leser brukerdata fra databasen, en CarServiceklasse som leser bildata fra samme database, og andre klasser, som hver fungerer med bestemte typer objekter og leser tilsvarende data fra databasen.

package services;

public class UserService {
}

package services;

public class CarService {
}

Men det ville være lett for dataene i databasen å være i ett format og vi trenger det i et annet. Tenk deg at brukernes fødselsdatoer i databasen er lagret som <TIMESTAMP WITH TIME SONE>...

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

...og i stedet trenger vi det enkleste objektet - en java.util.Date . For å løse dette problemet, inne i tjenestepakken , kan vi opprette en spesiell Mapper- klasse. Den vil være ansvarlig for å konvertere data fra databasen til våre kjente Java-objekter. En enkel hjelperklasse. Vi erklærer vanligvis alle klasser som offentlig klasse ClassName , men dette er ikke et krav. Vi kan erklære hjelperklassen vår ganske enkelt som klassekartlegger . I dette tilfellet gjør den fortsatt jobben sin, men den er ikke synlig for noen utenfor tjenestepakken !

package services;

class Mapper {
}


package services;

public class CarService {

   Mapper mapper;
}

Og her er den grunnleggende begrunnelsen: hvorfor skulle noen utenfor en pakke trenge å se en hjelpeklasse som bare fungerer med klassene i den pakken?

Den offentlige modifikatoren

Og sist men ikke minst, den offentlige modifikatoren! Du møtte denne modifikatoren på din første studiedag på CodeGym første gang du kjørte public static void main(String[] args) . Nå som du har studert leksjonen om grensesnitt, er formålet åpenbart for deg :) Tross alt ble den offentlige modifikatoren laget for å gi noe til brukerne. For eksempel programmets grensesnitt. Anta at du har skrevet et oversetterprogram som kan oversette russisk tekst til engelsk. Du opprettet en translate(String textInRussian) metode som implementerer all nødvendig logikk. Du merket denne metoden med ordet offentlig , og nå er den en del av grensesnittet:

public class Translator {

   public String translate(String textInRussian) {

       // Translates text from Russian to English
   }
}

Du kan binde denne metoden til 'Oversett'-knappen på skjermen, og du er ferdig! Hvem som helst kan bruke den. Delene av koden merket med den offentlige modifikatoren er beregnet på sluttbrukeren. Som et eksempel fra det virkelige liv, privat er for alle prosesser som skjer inne i en TV, men offentlig er for knappene på fjernkontrollen som brukes til å administrere TVen. Dessuten trenger ikke brukeren å vite hvordan fjernsynet er bygget eller hvordan det fungerer. Fjernkontrollen er settet med offentlige -metoder: on() , off() , nextChannel() , previousChannel() , increaseVolume() , reductionVolume() osv. For å forsterke det du lærte, foreslår vi at du ser en videoleksjon fra vårt Java-kurs