ஆபரேட்டரின் ஜாவா உதாரணம்

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

public class Main {

   public static void main(String[] args) {

       Integer x = new Integer(22);

       System.out.println(x instanceof Integer);
   }
}

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

public class Main {

   public static void main(String[] args) {

       Integer x = new Integer(22);

       System.out.println(x instanceof String); // Error!
   }
}

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

public class Animal {

}

public class Cat extends Animal {

}

public class MaineCoon extends Cat {

}

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

public class Main {

   public static void main(String[] args) {

       Cat cat = new Cat();

       System.out.println(cat instanceof Animal);

       System.out.println(cat instanceof MaineCoon);

   }
}

வெளியீடு: உண்மை தவறு, 'ஒரு வகுப்பின் அடிப்படையில் உருவாக்கப்பட்ட பொருளை' எவ்வாறு சரியாக விளக்குகிறது என்பதுதான் பதிலளிக்க வேண்டிய முக்கிய கேள்வி ? ' cat instance of Animal ' உண்மை என்று மதிப்பிடுகிறது , ஆனால் அந்த வார்த்தைகளில் கண்டிப்பாக நாம் தவறு காணலாம். விலங்கு வகுப்பின் அடிப்படையில் பூனைப் பொருள் ஏன் உருவாக்கப்பட்டது ? அது தன் வர்க்கத்தை மட்டும் அடிப்படையாக வைத்து உருவாக்கப்படவில்லையா? பதில் மிகவும் எளிமையானது, நீங்கள் ஏற்கனவே யோசித்திருக்கலாம். ஒரு பொருளை உருவாக்கும் போது கன்ஸ்ட்ரக்டர்கள் அழைக்கப்படும் மற்றும் மாறிகள் துவக்கப்படும் வரிசையை நினைவில் கொள்ளுங்கள். இந்த தலைப்பை நாங்கள் ஏற்கனவே வகுப்பு கட்டமைப்பாளர்கள் பற்றிய கட்டுரையில் உள்ளடக்கியுள்ளோம் . அந்த பாடத்திலிருந்து ஒரு எடுத்துக்காட்டு இங்கே:

public class Animal {

   String brain = "Initial value of brain in the Animal class";
   String heart = "Initial value of heart in the Animal class";

   public static int animalCount = 7700000;

   public Animal(String brain, String heart) {
       System.out.println("Animal base class constructor is running");
       System.out.println("Have the variables of the Animal class already been initialized?");
       System.out.println("Current value of static variable animalCount = " + animalCount);
       System.out.println("Current value of brain in the Animal class = " + this.brain);
       System.out.println("Current value of heart in the Animal class = " + this.heart);
       System.out.println("Have the variables of the Cat class already been initialized?");
       System.out.println("Current value of static variable catCount = " + Cat.catCount);

       this.brain = brain;
       this.heart = heart;
       System.out.println("Animal base class constructor is done!");
       System.out.println("Current value of brain = " + this.brain);
       System.out.println("Current value of heart = " + this.heart);
   }
}

public class Cat extends Animal {

   String tail = "Initial value of tail in the Cat class";

   static int catCount = 37;

   public Cat(String brain, String heart, String tail) {
       super(brain, heart);
       System.out.println("The Cat class constructor has started (The Animal constructor already finished)");
       System.out.println("Current value of static variable catCount = " + catCount);
       System.out.println("Current value of tail = " + this.tail);
       this.tail = tail;
       System.out.println("Current value of tail = " + this.tail);
   }

   public static void main(String[] args) {
       Cat cat = new Cat("Brain", "Heart", "Tail");
   }
}

நீங்கள் அதை IDE இல் இயக்கினால், கன்சோல் வெளியீடு இப்படி இருக்கும்: அனிமல் பேஸ் கிளாஸ் கன்ஸ்ட்ரக்டர் இயங்குகிறது விலங்கு வகுப்பின் மாறிகள் ஏற்கனவே துவக்கப்பட்டதா? நிலையான மாறி விலங்குகளின் தற்போதைய மதிப்பு = 7700000 விலங்கு வகுப்பில் மூளையின் தற்போதைய மதிப்பு = விலங்கு வகுப்பில் மூளையின் ஆரம்ப மதிப்பு விலங்கு வகுப்பில் இதயத்தின் தற்போதைய மதிப்பு = விலங்கு வகுப்பில் இதயத்தின் ஆரம்ப மதிப்பு ஏற்கனவே பூனை வகுப்பின் மாறிகள் உள்ளன துவக்கப்பட்டதா? நிலையான மாறி catCount இன் தற்போதைய மதிப்பு = 37 அனிமல் பேஸ் கிளாஸ் கன்ஸ்ட்ரக்டர் முடிந்தது! மூளையின் தற்போதைய மதிப்பு = மூளையின் தற்போதைய மதிப்பு இதயம் = இதயம் பூனை வகுப்பு கட்டமைப்பாளர் தொடங்கப்பட்டது (விலங்கு கட்டமைப்பாளர் ஏற்கனவே முடிக்கப்பட்டுவிட்டார்) நிலையான மாறியின் தற்போதைய மதிப்பு catCount = 37 வால் தற்போதைய மதிப்பு = பூனை வகுப்பில் வால் ஆரம்ப மதிப்பு வால் தற்போதைய மதிப்பு = வால் இப்போது உங்களுக்கு நினைவிருக்கிறதா?:) அடிப்படை வகுப்பின் கட்டமைப்பாளர், ஒரு அடிப்படை வகுப்பு இருந்தால், ஒரு பொருளை உருவாக்கும் போது எப்போதும் முதலில் அழைக்கப்படுவார். A ஆப்ஜெக்ட் B வகுப்பின் அடிப்படையில் உருவாக்கப்பட்டதா என்பதை தீர்மானிக்க முயற்சிக்கும் போது, ​​ஆபரேட்டரின் நிகழ்வு இந்தக் கொள்கையால் வழிநடத்தப்படுகிறது . அடிப்படை வகுப்பு கன்ஸ்ட்ரக்டர் என்று அழைக்கப்பட்டால், எந்த சந்தேகமும் இருக்க முடியாது. இரண்டாவது சரிபார்ப்புடன், எல்லாம் எளிமையானது:

System.out.println(cat instanceof MaineCoon);

கேட் பொருள் உருவாக்கப்பட்ட போது MaineCoon கட்டமைப்பாளர் அழைக்கப்படவில்லை , இது அர்த்தமுள்ளதாக இருக்கிறது. எல்லாவற்றிற்கும் மேலாக, மைனேகூன் பூனையின் வழித்தோன்றல் , ஒரு மூதாதையர் அல்ல. மேலும் இது பூனைக்கான டெம்ப்ளேட் அல்ல . சரி, நாங்கள் அதில் தெளிவாக இருக்கிறோம் என்று நினைக்கிறேன். ஆனால் இதைச் செய்தால் என்ன நடக்கும்?:

public class Main {

   public static void main(String[] args) {

       Cat cat = new MaineCoon();

       System.out.println(cat instanceof Cat);
       System.out.println(cat instanceof MaineCoon);


   }
}

ம்ம்ம்... இப்போது அது கடினமாகிவிட்டது. அதை பேசி முடிப்போம். எங்களிடம் கேட் மாறி உள்ளது, அதற்கு மைன்கூன் பொருளை ஒதுக்கினோம் . மூலம், அது ஏன் வேலை செய்கிறது? நாம் அதை செய்ய முடியும், இல்லையா? ஆம் நம்மால் முடியும். எல்லாவற்றிற்கும் மேலாக, ஒவ்வொரு MaineCoon ஒரு பூனை. இது முற்றிலும் தெளிவாக இல்லை என்றால், பழமையான வகைகளை விரிவுபடுத்துவதற்கான உதாரணத்தை நினைவில் கொள்க:

public class Main {

   public static void main(String[] args) {

       long x = 1024;

   }
}

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

Cat cat = new MaineCoon();
System.out.println(cat instanceof Cat);
System.out.println(cat instanceof MaineCoon);

சோதனையின் உதாரணம் என்ன ? எங்கள் பூனை மாறி அல்லது எங்கள் MaineCoon பொருள்? பதில் இந்த கேள்வி உண்மையில் எளிமையானது. ஆபரேட்டரின் வரையறையை நீங்கள் மீண்டும் படிக்க வேண்டும்: X மாறியால் குறிப்பிடப்பட்ட ஒரு பொருள் சில Y வகுப்பின் அடிப்படையில் உருவாக்கப்பட்டதா என்பதைச் சரிபார்க்க, ஆபரேட்டரின் உதாரணம் தேவை . ஆபரேட்டரின் நிகழ்வு ஒரு பொருளின் தோற்றத்தை சோதிக்கிறது, மாறி வகை அல்ல. எனவே, இந்த எடுத்துக்காட்டில், எங்கள் நிரல் இரண்டு நிகழ்வுகளிலும் உண்மையாகக் காண்பிக்கப்படும் : எங்களிடம் ஒரு MaineCoon பொருள் உள்ளது. வெளிப்படையாக, இது MaineCoon வகுப்பின் அடிப்படையில் உருவாக்கப்பட்டது , ஆனால் அது பூனையின் அடிப்படையில் உருவாக்கப்பட்டதுபெற்றோர் வர்க்கமும்!