జావాలో మాడిఫైయర్‌లను యాక్సెస్ చేయండి

హాయ్! నేటి పాఠంలో, మేము యాక్సెస్ మాడిఫైయర్ల భావనతో పరిచయం పొందుతాము మరియు వారితో ఎలా పని చేయాలో ఉదాహరణలను పరిశీలిస్తాము. వాస్తవానికి, 'పరిచయం చేసుకోండి' అని చెప్పడం సరైనది కాదు: మునుపటి పాఠాల నుండి మీరు చాలా మందిని ఇప్పటికే పరిచయం చేసారు. ఒక వేళ, అతి ముఖ్యమైన విషయం గురించి మన జ్ఞాపకశక్తిని రిఫ్రెష్ చేద్దాం. మాడిఫైయర్‌ల యాక్సెస్ అనేది మీ కోడ్‌లోని వివిధ భాగాలకు యాక్సెస్‌ని నియంత్రించే కీలక పదాలు. ఎందుకు 'చాలా తరచుగా'? ఎందుకంటే వాటిలో ఒకటి కీవర్డ్ ఉపయోగించకుండా డిఫాల్ట్‌గా సెట్ చేయబడింది :) జావాకు నాలుగు యాక్సెస్ మాడిఫైయర్‌లు ఉన్నాయి. మేము వాటిని చాలా పరిమితుల నుండి చాలా 'సడలింపు' వరకు జాబితా చేస్తాము:

• ప్రైవేట్;
• డిఫాల్ట్ (ప్యాకేజీ కనిపిస్తుంది);
• రక్షిత;
• ప్రజా.

వాటిలో ప్రతి ఒక్కటి పరిశీలించి, అవి ఎప్పుడు ఉపయోగపడతాయో తెలుసుకుందాం. మరియు మేము ఉదాహరణలు ఇస్తాము :)

ప్రైవేట్ మాడిఫైయర్

ప్రైవేట్ అనేది అత్యంత పరిమిత యాక్సెస్ మాడిఫైయర్. ఇది డేటా మరియు పద్ధతుల దృశ్యమానతను ఒకే తరగతికి పరిమితం చేస్తుంది. గెట్టర్స్ మరియు సెట్టర్స్ గురించిన పాఠం నుండి ఈ మాడిఫైయర్ మీకు తెలుసు. ఈ ఉదాహరణ గుర్తుందా?

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

మేము దానిని మునుపటి పాఠంలో పరిగణించాము. మేము ఇక్కడ ఒక తీవ్రమైన పొరపాటు చేసాము: మేము మా డేటాను పబ్లిక్ చేస్తాము, ఇది తోటి ప్రోగ్రామర్లు ఫీల్డ్‌లను నేరుగా యాక్సెస్ చేయడానికి మరియు వారి విలువలను మార్చడానికి అనుమతించింది. అంతేకాదు... ఎలాంటి తనిఖీలు లేకుండానే ఈ విలువలు కేటాయించబడ్డాయి. మా ప్రోగ్రామ్ -1000 సంవత్సరాల వయస్సు మరియు 0 బరువుతో "" అనే పిల్లిని సృష్టించగలదని దీని అర్థం. ఈ సమస్యను పరిష్కరించడానికి, మేము గెట్టర్‌లు మరియు సెట్టర్‌లను ఉపయోగించాము మరియు డేటాకు ప్రాప్యతను పరిమితం చేయడానికి ప్రైవేట్ మాడిఫైయర్‌ను కూడా ఉపయోగించాము.

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

ప్రాథమికంగా, ఫీల్డ్‌లకు యాక్సెస్‌ని పరిమితం చేయడం మరియు గెట్టర్‌లు మరియు సెట్టర్‌లను అమలు చేయడం ఎంత ప్రైవేట్ అనేదానికి అత్యంత సాధారణ ఉదాహరణలునిజమైన పనిలో ఉపయోగించబడుతుంది. మరో మాటలో చెప్పాలంటే, ఈ మాడిఫైయర్ యొక్క ముఖ్య ఉద్దేశ్యం ప్రోగ్రామ్‌లో ఎన్‌క్యాప్సులేషన్‌ను సాధించడం. ఇది ఫీల్డ్‌లకు మాత్రమే వర్తించదు. మీ ప్రోగ్రామ్‌లో కొన్ని క్లిష్టమైన కార్యాచరణలను అమలు చేసే పద్ధతి ఉందని ఊహించండి. ఉదాహరణగా మనం ఏమి సూచించగలం? మీ readDataFromCollider() పద్ధతి డేటా అడ్రస్‌ను ఇన్‌పుట్‌గా అంగీకరిస్తుంది, బైట్ ఫార్మాట్‌లో లార్జ్ హాడ్రాన్ కొలైడర్ నుండి డేటాను రీడ్ చేస్తుంది, ఈ డేటాను టెక్స్ట్‌గా మారుస్తుంది, ఫైల్‌కి వ్రాసి ప్రింట్ చేస్తుంది. పద్ధతి యొక్క వివరణ కూడా భయానకంగా కనిపిస్తుంది, కోడ్ గురించి ఏమీ చెప్పలేము :) కోడ్‌ను మరింత చదవగలిగేలా చేయడానికి, అన్ని పద్ధతి యొక్క సంక్లిష్ట తర్కాన్ని ఒకే చోట వ్రాయకపోవడమే ఉత్తమం. బదులుగా, మేము ఫంక్షనాలిటీని ప్రత్యేక పద్ధతులుగా విభజించాలి. ఉదాహరణకు, readByteData()పద్ధతి డేటాను చదవడానికి బాధ్యత వహిస్తుంది, convertBytesToSymbols() పద్ధతి కొలైడర్ నుండి చదివిన డేటాను టెక్స్ట్‌గా మారుస్తుంది, saveToFile() పద్ధతి అందుకున్న వచనాన్ని ఫైల్‌లో సేవ్ చేస్తుంది మరియు printColliderData() పద్ధతి మన డేటా ఫైల్‌ను ప్రింట్ చేస్తుంది. చివరికి, మా readDataFromCollider() పద్ధతి చాలా సరళంగా ఉంటుంది:

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

అయితే, మీరు ఇంటర్‌ఫేస్‌ల గురించి పాఠం నుండి గుర్తుంచుకున్నట్లుగా, వినియోగదారు బాహ్య ఇంటర్‌ఫేస్‌కు మాత్రమే ప్రాప్యతను పొందుతారు. మరియు మా 4 పద్ధతులు దానిలో భాగం కాదు. అవి సహాయక పద్ధతులు: మేము కోడ్ యొక్క రీడబిలిటీని మెరుగుపరచడానికి మరియు నాలుగు వేర్వేరు టాస్క్‌లను ఒక పద్ధతిలో క్రామ్ చేయకుండా వాటిని సృష్టించాము. మీరు ఈ పద్ధతులకు వినియోగదారు యాక్సెస్ ఇవ్వాల్సిన అవసరం లేదు. కొలైడర్‌తో పని చేస్తున్నప్పుడు వినియోగదారులు convertBytesToSymbols() పద్ధతికి ప్రాప్యత కలిగి ఉంటే , వారు చాలా మటుకు ఈ పద్ధతిని చూసి గందరగోళానికి గురవుతారు మరియు అది దేనికోసం అని ఆశ్చర్యపోతారు. ఏ బైట్‌లు మార్చబడతాయి? ఎక్కడి నుంచి వచ్చారు? వాటిని టెక్స్ట్‌గా ఎందుకు మార్చాలి? ఈ పద్ధతిలో అమలు చేయబడిన లాజిక్ వినియోగదారుకు బహిర్గతమయ్యే ఇంటర్‌ఫేస్‌లో భాగం కాదు. ReadDataFromCollider() మాత్రమేపద్ధతి ఇంటర్‌ఫేస్‌లో భాగం. కాబట్టి ఈ నాలుగు 'అంతర్గత' పద్ధతులతో మనం ఏమి చేయాలి? నిజమే! వాటికి యాక్సెస్‌ని పరిమితం చేయడానికి ప్రైవేట్ మాడిఫైయర్‌ని ఉపయోగించండి . ఇలా చేయడం వలన వారు వినియోగదారుని గందరగోళానికి గురిచేయకుండా తరగతి లోపల శాంతియుతంగా తమ పనిని నిర్వహించగలుగుతారు, వారు ఒక్కొక్క పద్ధతి యొక్క తర్కాన్ని తెలుసుకోవాల్సిన అవసరం లేదు.

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

రక్షిత మాడిఫైయర్

తదుపరి అత్యంత నిరోధక మాడిఫైయర్ రక్షించబడింది . రక్షిత యాక్సెస్ మాడిఫైయర్ ద్వారా గుర్తించబడిన ఫీల్డ్‌లు మరియు పద్ధతులు కనిపిస్తాయి:

• మాది అదే ప్యాకేజీలో చేర్చబడిన అన్ని తరగతులలో;
• మా తరగతిని వారసత్వంగా పొందే అన్ని తరగతులలో.

మొదట, ఇది ఎప్పుడు అవసరమో ఊహించడం కష్టం. ఆశ్చర్యపోకండి: ప్రైవేట్ కంటే రక్షిత కోసం చాలా తక్కువ వినియోగ సందర్భాలు ఉన్నాయి మరియు అవి చాలా నిర్దిష్టంగా ఉంటాయి. మేము కొన్ని గూఢచార సేవలో రహస్య ఏజెంట్‌ను సూచించే AbstractSecretAgent అబ్‌స్ట్రాక్ట్ క్లాస్‌ని కలిగి ఉన్నామని, అలాగే ఈ తరగతి మరియు దాని వారసులను కలిగి ఉన్న టాప్_సీక్రెట్ ప్యాకేజీని ఊహించుకోండి. FBISecretAgent , MI6SecretAgent , MossadSecretAgent మొదలైన కాంక్రీట్ తరగతులు దీనిని వారసత్వంగా పొందుతాయి. వియుక్త తరగతి లోపల, మేము ఏజెంట్ కౌంటర్‌ని అమలు చేయాలనుకుంటున్నాము. ప్రోగ్రామ్‌లో ఎక్కడో కొత్త ఏజెంట్ సృష్టించబడినప్పుడు ఇది పెరుగుతుంది. ప్యాకేజీ టాప్_సీక్రెట్;

public abstract class AbstractSecretAgent {

   public static int agentCount = 0;
}

కానీ మా ఏజెంట్లు రహస్యంగా ఉన్నారు! అంటే, వాటిలో ఎన్ని ఉన్నాయో వారికి మరియు ఇతరులకు తెలియకూడదు. agent_counter ఫీల్డ్‌కు మేము రక్షిత మాడిఫైయర్‌ని సులభంగా జోడించవచ్చు . ఆపై మా టాప్_సీక్రెట్ ప్యాకేజీలో ఉన్న ఇతర సీక్రెట్ ఏజెంట్ క్లాస్‌లు మరియు ఇతర క్లాస్‌ల ఉదాహరణలు దాని విలువను పొందవచ్చు.

public abstract class AbstractSecretAgent {

   protected static int agent_counter = 0;
}

మరియు అది రక్షిత మాడిఫైయర్ అవసరమయ్యే ప్రత్యేకమైన పని :)

ప్యాకేజీ కనిపించే మాడిఫైయర్

జాబితాలో తదుపరిది డిఫాల్ట్ మాడిఫైయర్, దీనిని ప్యాకేజీ కనిపించే మాడిఫైయర్ అని కూడా పిలుస్తారు . ఇది కీవర్డ్ ద్వారా సూచించబడదు, ఎందుకంటే జావా దీనిని డిఫాల్ట్‌గా అన్ని ఫీల్డ్‌లు మరియు పద్ధతులకు వర్తింపజేస్తుంది. మీరు మీ కోడ్‌లో కింది వాటిని వ్రాస్తే:

int x = 10

x వేరియబుల్ ఈ ప్యాకేజీని కనిపించే యాక్సెస్‌ని కలిగి ఉంటుంది . ఇది ఏమి చేస్తుందో గుర్తుంచుకోవడం సులభం. ప్రాథమికంగా, డిఫాల్ట్ = రక్షిత వారసత్వం :) రక్షిత మాడిఫైయర్ వలె , దాని అప్లికేషన్ పరిమితం చేయబడింది. చాలా తరచుగా, డిఫాల్ట్ యాక్సెస్ ప్యాకేజీలోని అన్ని ఇతర తరగతుల కార్యాచరణను అమలు చేయని కొన్ని యుటిలిటీ తరగతులను కలిగి ఉన్న ప్యాకేజీలో ఉపయోగించబడుతుంది. ఒక ఉదాహరణ ఇద్దాం. మనకు 'సేవలు' ప్యాకేజీ ఉందని ఊహించండి. ఇది డేటాబేస్తో పనిచేసే వివిధ తరగతులను కలిగి ఉంటుంది. ఉదాహరణకు, డేటాబేస్, కార్‌సర్వీస్ నుండి వినియోగదారు డేటాను చదివే వినియోగదారు సేవా తరగతి ఉంది.ఒకే డేటాబేస్ నుండి కారు డేటాను చదివే తరగతి మరియు ఇతర తరగతులు, వీటిలో ప్రతి ఒక్కటి నిర్దిష్ట రకాల వస్తువులతో పని చేస్తుంది మరియు డేటాబేస్ నుండి సంబంధిత డేటాను రీడ్ చేస్తుంది.

package services;

public class UserService {
}

package services;

public class CarService {
}

కానీ డేటాబేస్‌లోని డేటా ఒక ఫార్మాట్‌లో మరియు మనకు మరొక ఫార్మాట్‌లో ఉండటం చాలా సులభం. డేటాబేస్‌లో వినియోగదారుల పుట్టిన తేదీలు <TIMESTAMP విత్ టైమ్ జోన్>గా నిల్వ చేయబడిందని ఊహించండి...

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

మరియు బదులుగా మనకు సరళమైన వస్తువు అవసరం — java.util.Date . ఈ సమస్యను పరిష్కరించడానికి, సేవల ప్యాకేజీ లోపల, మేము ఒక ప్రత్యేక మ్యాపర్ తరగతిని సృష్టించవచ్చు . డేటాబేస్ నుండి డేటాను మనకు తెలిసిన జావా ఆబ్జెక్ట్‌లుగా మార్చడానికి ఇది బాధ్యత వహిస్తుంది. ఒక సాధారణ సహాయక తరగతి. మేము సాధారణంగా అన్ని తరగతులను పబ్లిక్ క్లాస్ క్లాస్‌నేమ్‌గా ప్రకటిస్తాము , కానీ ఇది అవసరం లేదు. మేము మా సహాయక తరగతిని క్లాస్ మ్యాపర్‌గా ప్రకటించవచ్చు . ఈ సందర్భంలో, ఇది ఇప్పటికీ తన పనిని చేస్తుంది, అయితే ఇది సేవల ప్యాకేజీ వెలుపల ఎవరికీ కనిపించదు !

package services;

class Mapper {
}


package services;

public class CarService {

   Mapper mapper;
}

మరియు ఇక్కడ ప్రాథమిక తార్కికం ఉంది: ప్యాకేజీకి వెలుపల ఉన్న ఎవరైనా ఆ ప్యాకేజీలోని తరగతులతో మాత్రమే పనిచేసే సహాయక తరగతిని ఎందుకు చూడాలి?

పబ్లిక్ మాడిఫైయర్

మరియు చివరిది కాని, పబ్లిక్ మాడిఫైయర్! మీరు కోడ్‌జిమ్‌లో మీ మొదటి రోజు అధ్యయనంలో పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్[] ఆర్గ్స్)ని మొదటిసారిగా అమలు చేసినప్పుడు మీరు ఈ మాడిఫైయర్‌ని కలుసుకున్నారు . ఇప్పుడు మీరు ఇంటర్‌ఫేస్‌ల గురించి పాఠాన్ని అధ్యయనం చేసారు, దాని ప్రయోజనం మీకు స్పష్టంగా ఉంది :) అన్నింటికంటే, వినియోగదారులకు ఏదైనా అందించడానికి పబ్లిక్ మాడిఫైయర్ సృష్టించబడింది. ఉదాహరణకు, మీ ప్రోగ్రామ్ యొక్క ఇంటర్ఫేస్. మీరు రష్యన్ టెక్స్ట్‌ను ఆంగ్లంలోకి అనువదించగల అనువాదకుల ప్రోగ్రామ్‌ను వ్రాసారని అనుకుందాం. మీరు అవసరమైన అన్ని లాజిక్‌లను అమలు చేసే అనువాద (స్ట్రింగ్ టెక్స్ట్‌ఇన్‌రష్యన్) పద్ధతిని సృష్టించారు. మీరు ఈ పద్ధతిని పబ్లిక్ అనే పదంతో గుర్తు పెట్టారు మరియు ఇప్పుడు ఇది ఇంటర్‌ఫేస్‌లో భాగం:

public class Translator {

   public String translate(String textInRussian) {

       // Translates text from Russian to English
   }
}

మీరు ఈ పద్ధతిని స్క్రీన్‌పై ఉన్న 'అనువాదం' బటన్‌కు బైండ్ చేయవచ్చు మరియు మీరు పూర్తి చేసారు! దీన్ని ఎవరైనా ఉపయోగించుకోవచ్చు. పబ్లిక్ మాడిఫైయర్‌తో గుర్తు పెట్టబడిన కోడ్ భాగాలు తుది వినియోగదారు కోసం ఉద్దేశించబడ్డాయి. నిజ జీవిత ఉదాహరణను అందించడం ద్వారా, TV లోపల జరిగే అన్ని ప్రక్రియల కోసం ప్రైవేట్‌గా ఉంటుంది, కానీ TVని నిర్వహించడానికి ఉపయోగించే రిమోట్ కంట్రోల్‌లోని బటన్‌ల కోసం పబ్లిక్ . ఇంకా ఏమిటంటే, టెలివిజన్ ఎలా నిర్మించబడిందో లేదా అది ఎలా పని చేస్తుందో వినియోగదారు తెలుసుకోవలసిన అవసరం లేదు. రిమోట్ కంట్రోల్ అనేది పబ్లిక్ -మెథడ్‌ల సమితి : on() , off() , nextChannel() , previousChannel() , increaseVolume() , lowerVolume() etc. మీరు నేర్చుకున్న వాటిని బలోపేతం చేయడానికి, మా జావా కోర్సు నుండి వీడియో పాఠాన్ని చూడమని మేము మీకు సూచిస్తున్నాము