ஜாவாவில் மாற்றிகளை அணுகவும்

வணக்கம்! இன்றைய பாடத்தில், அணுகல் மாற்றியமைப்பாளர்களின் கருத்தை நாங்கள் அறிந்துகொள்வோம் , மேலும் அவர்களுடன் எவ்வாறு வேலை செய்வது என்பதற்கான எடுத்துக்காட்டுகளைக் கருத்தில் கொள்வோம். நிச்சயமாக, 'அறிமுகம்' என்று சொல்வது சரியல்ல: முந்தைய பாடங்களில் இருந்து பெரும்பாலானவற்றை நீங்கள் ஏற்கனவே அறிந்திருக்கிறீர்கள். ஒரு வேளை, மிக முக்கியமான விஷயத்தைப் பற்றிய நமது நினைவைப் புதுப்பிப்போம். மாற்றியமைப்பாளர் அணுகல் என்பது உங்கள் குறியீட்டின் வெவ்வேறு பகுதிகளுக்கான அணுகலைக் கட்டுப்படுத்தும் முக்கிய வார்த்தைகளாகும். ஏன் 'அடிக்கடி'? ஏனெனில் அவற்றில் ஒன்று முக்கிய சொல்லைப் பயன்படுத்தாமல் இயல்புநிலையாக அமைக்கப்பட்டுள்ளது :) ஜாவாவில் நான்கு அணுகல் மாற்றிகள் உள்ளன. நாங்கள் அவற்றை மிகவும் கட்டுப்படுத்தப்பட்டவையிலிருந்து மிகவும் 'இளக்கமானவை' வரை பட்டியலிடுகிறோம்:

• தனியார்;
• இயல்புநிலை (தொகுப்பு தெரியும்);
• பாதுகாக்கப்பட்ட;
• பொது

அவை ஒவ்வொன்றையும் பார்த்து, அவை எப்போது பயனுள்ளதாக இருக்கும் என்பதைக் கண்டுபிடிப்போம். நாங்கள் உதாரணங்கள் தருவோம் :)

தனியார் மாற்றி

தனியார் என்பது மிகவும் கட்டுப்படுத்தப்பட்ட அணுகல் மாற்றியாகும். இது தரவு மற்றும் முறைகளின் தெரிவுநிலையை ஒரு வகுப்பிற்குள் கட்டுப்படுத்துகிறது. பெறுபவர்கள் மற்றும் செட்டர்கள் பற்றிய பாடத்திலிருந்து இந்த மாற்றியமைப்பை நீங்கள் அறிவீர்கள். இந்த உதாரணம் நினைவிருக்கிறதா?

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 சுருக்க வகுப்பு உள்ளது என்று கற்பனை செய்து பாருங்கள், இது சில உளவுத்துறை சேவையில் ஒரு இரகசிய முகவரைப் பிரதிநிதித்துவப்படுத்துகிறது, அத்துடன் இந்த வகுப்பையும் அதன் சந்ததியினரையும் உள்ளடக்கிய ஒரு top_secret தொகுப்பு. FBISecretAgent , MI6SecretAgent , MossadSecretAgent போன்ற உறுதியான வகுப்புகள் இதைப் பெறுகின்றன. சுருக்க வகுப்பிற்குள், நாங்கள் ஒரு முகவர் கவுண்டரைச் செயல்படுத்த விரும்புகிறோம். நிரலில் எங்காவது ஒரு புதிய முகவர் உருவாக்கப்படும் போது அது அதிகரிக்கும். தொகுப்பு மேல்_ரகசியம்;

public abstract class AbstractSecretAgent {

   public static int agentCount = 0;
}

ஆனால் எங்கள் முகவர்கள் ரகசியம்! அவற்றில் எத்தனை உள்ளன என்பதை அவர்களும் வேறு யாரும் அறியக்கூடாது என்பதே இதன் பொருள். agent_counter புலத்தில் பாதுகாக்கப்பட்ட மாற்றியை நாம் எளிதாகச் சேர்க்கலாம் . எங்கள் top_secret தொகுப்பில் உள்ள பிற ரகசிய முகவர் வகுப்புகள் மற்றும் பிற வகுப்புகளின் நிகழ்வுகள் அதன் மதிப்பைப் பெறலாம்.

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 WITH TIME ZONE> என சேமிக்கப்படும் என்று கற்பனை செய்து பாருங்கள்...

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

அதற்கு பதிலாக நமக்கு எளிமையான பொருள் தேவை — java.util.Date . இந்தச் சிக்கலைத் தீர்க்க, சேவைகள் தொகுப்பின் உள்ளே, நாம் ஒரு சிறப்பு மேப்பர் வகுப்பை உருவாக்கலாம் . தரவுத்தளத்திலிருந்து தரவை நமக்குப் பழக்கமான ஜாவா பொருள்களாக மாற்றுவதற்கு இது பொறுப்பாகும். ஒரு எளிய உதவி வகுப்பு. நாங்கள் பொதுவாக அனைத்து வகுப்புகளையும் பொது வகுப்பின் பெயராக அறிவிப்போம் , ஆனால் இது ஒரு தேவையல்ல. எங்கள் உதவி வகுப்பை வகுப்பு மேப்பராக எளிமையாக அறிவிக்கலாம் . இந்த விஷயத்தில், அது இன்னும் அதன் வேலையைச் செய்கிறது, ஆனால் இது சேவைத் தொகுப்பிற்கு வெளியே யாருக்கும் தெரியாது !

package services;

class Mapper {
}


package services;

public class CarService {

   Mapper mapper;
}

இதோ அடிப்படை காரணம்: தொகுப்பிற்கு வெளியே உள்ள எவரும் அந்த தொகுப்பில் உள்ள வகுப்புகளுடன் மட்டுமே செயல்படும் உதவி வகுப்பை ஏன் பார்க்க வேண்டும்?

பொது மாற்றி

இறுதியாக, பொது மாற்றியமைப்பாளர்! பொது நிலையான வெற்றிடத்தை முதன்மை (ஸ்ட்ரிங்[] args) இயக்கிய போது, ​​CodeGym இல் நீங்கள் படித்த முதல் நாளில் இந்த மாற்றியை நீங்கள் சந்தித்தீர்கள் . இப்போது நீங்கள் இடைமுகங்களைப் பற்றிய பாடத்தைப் படித்துள்ளீர்கள், அதன் நோக்கம் உங்களுக்குத் தெளிவாகத் தெரிகிறது :) எல்லாவற்றிற்கும் மேலாக, பொது மாற்றியமைப்பாளர் பயனர்களுக்கு ஏதாவது கொடுக்க உருவாக்கப்பட்டது. எடுத்துக்காட்டாக, உங்கள் நிரலின் இடைமுகம். ரஷ்ய உரையை ஆங்கிலத்தில் மொழிபெயர்க்கக்கூடிய ஒரு மொழிபெயர்ப்பாளர் நிரலை நீங்கள் எழுதியிருக்கிறீர்கள் என்று வைத்துக்கொள்வோம். தேவையான அனைத்து தர்க்கங்களையும் செயல்படுத்தும் ஒரு மொழிபெயர்ப்பு (ஸ்ட்ரிங் டெக்ஸ்ட்இன் ரஷ்யன்) முறையை உருவாக்கியுள்ளீர்கள் . இந்த முறையை பொது என்ற வார்த்தையுடன் குறித்தீர்கள் , இப்போது இது இடைமுகத்தின் ஒரு பகுதியாகும்:

public class Translator {

   public String translate(String textInRussian) {

       // Translates text from Russian to English
   }
}

திரையில் உள்ள 'மொழிபெயர்ப்பு' பொத்தானுடன் இந்த முறையைப் பிணைக்கலாம், நீங்கள் முடித்துவிட்டீர்கள்! யார் வேண்டுமானாலும் பயன்படுத்தலாம். பொது மாற்றியமைப்புடன் குறிக்கப்பட்ட குறியீட்டின் பகுதிகள் இறுதிப் பயனருக்கானது. நிஜ வாழ்க்கை உதாரணத்தை வழங்குவது, டிவியில் நிகழும் அனைத்து செயல்முறைகளுக்கும் தனிப்பட்டது , ஆனால் டிவியை நிர்வகிக்கப் பயன்படுத்தப்படும் ரிமோட் கண்ட்ரோலில் உள்ள பொத்தான்களுக்கானது பொது . மேலும் என்னவென்றால், தொலைக்காட்சி எவ்வாறு கட்டமைக்கப்பட்டுள்ளது அல்லது அது எவ்வாறு இயங்குகிறது என்பதை பயனர் அறிய வேண்டிய அவசியமில்லை. ரிமோட் கண்ட்ரோல் என்பது பொது முறைகளின் தொகுப்பாகும் : on() , off() , nextChannel() , previousChannel() , increaseVolume() , lowerVolume() etc. நீங்கள் கற்றுக்கொண்டதை வலுப்படுத்த, எங்கள் ஜாவா பாடத்திட்டத்திலிருந்து வீடியோ பாடத்தைப் பார்க்க பரிந்துரைக்கிறோம்