ஜாவா பூலியன்

ஜாவா மொழியின் சூழலில் "பூலியன்" என்ற வார்த்தை மிகவும் தொடர்புடையதாக இருந்தாலும், வெவ்வேறு அர்த்தங்களில் பயன்படுத்தப்படலாம். அவ்வாறு இருந்திருக்கலாம்:

• பூலியன் பழமையான வகை அல்லது இந்த வகையின் பூலியன் மாறி
• ஜாவா பூலியன் வகுப்பு அல்லது பூலியன் ரேப்பர் பொருள்
• பூலியன் வெளிப்பாடு, பூலியன் மதிப்பு, சில நிபந்தனைகள்
• ஜாவா பூலியன் ஆபரேட்டர்கள்

இந்த கட்டுரையில், இந்த விருப்பங்கள் அனைத்தையும் உள்ளடக்கி, பூலியன் வெளிப்பாடுகளுக்கு என்ன கருத்துக்கள் உள்ளன என்பதை விளக்கப் போகிறோம் .

பொது அர்த்தத்தில் பூலியன் என்றால் என்ன

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

ஜாவா பூலியன் பழமையான தரவு வகை மற்றும் பூலியன் மாறிகள்

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

boolean myBoolean; //boolean variable
myBoolean = false; 
boolean myBoolean1 = true; //another boolean variable

இங்கு 2 பூலியன் மாறிகள் உள்ளன . பூலியன் வகையைப் பயன்படுத்துவதற்கான உதாரணத்துடன் ஒரு சிறிய நிரலை எழுதுவோம் :

//boolean variable example
public class BoolTest {

   public static void main(String[] args) {
       boolean myBoolean = false;
       System.out.println(myBoolean);
   }
}

இந்த நிரல் கன்சோலில் "தவறான" அச்சிடுகிறது. மூலம், ஒரு பூலியன் மாறி முன்னிருப்பாக தவறானதாக அமைக்கப்பட்டுள்ளது, ஆனால் துவக்கப்படாத உள்ளூர் மாறிகளுடன் வேலை செய்ய ஜாவா உங்களை அனுமதிக்காது.

ஜாவாவில் பூலியன் வெளிப்பாடுகள்

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

public class BoolTest {

   public static void main(String[] args) {
       boolean myBoolean = false;
       int a = 5;
       int b = 7;
       System.out.println(a < b);
       System.out.println(0 > 7);
       System.out.println(myBoolean == false);
   }
}

வெளியீடு: ஒரு <b வழக்கில் , < ஆபரேட்டர் இடதுபுறத்தில் உள்ள வெளிப்பாட்டை வலதுபுறத்தில் உள்ள வெளிப்பாட்டுடன் ஒப்பிட்டார். ஒப்பீட்டின் முடிவை திரையில் காட்டினோம். 5 <7 (அறிக்கை உண்மை) என்பதால் , உண்மை மதிப்பு கன்சோலில் அச்சிடப்படும். இரண்டாவது வழக்கில், பூஜ்ஜியம் மற்றும் ஏழு ஆகியவற்றின் நேரடி ஒப்பீட்டைக் காண்பிப்போம், மூன்றாவதாக, myBoolean மாறியின் மதிப்பு தவறானதா என்று கேட்கிறோம். இப்படி இருப்பதால், மதிப்பை உண்மை என்பதை வெளியிடுகிறோம் . உண்மையில், ஜாவாவில் பூலியன் வெளிப்பாடுகளை உருவாக்க, நாம் எந்த ஒப்பீட்டு ஆபரேட்டர்களையும் பயன்படுத்தலாம்:

பூலியன் மதிப்புகள் பயன்படுத்தப்படும் இடத்தில்

பூலியன் மதிப்புகள் மற்றும் நிபந்தனை வெளிப்பாடுகள் கிளை அறிக்கைகள், மும்முனை ஆபரேட்டர்கள் மற்றும் லூப்களின் நிலைமைகளில் பெரும்பாலும் பயன்படுத்தப்படுகின்றன. உண்மையில், அவற்றின் பயன்பாடு சில பூலியன் வெளிப்பாடுகளைச் சரிபார்ப்பதை அடிப்படையாகக் கொண்டது. உதாரணத்திற்கு:

public class BoolTest2 {
       public static void main(String[] args) {
           int i = 0;
           while (i <= 10)
           {
               System.out.println(i);
               i++;
           }         
      }
}

இந்த நிரல் முழு எண்களின் வரிசையை அச்சிடுகிறது மற்றும் அடைப்புக்குறிக்குள் உள்ள நிபந்தனையை பூர்த்தி செய்யும் வரை அவற்றை ஒன்று அதிகரிக்கிறது. அதாவது, i <=10 என்ற வெளிப்பாடு உண்மையானது.

ஜாவா பூலியன் ஆபரேட்டர்கள். பூலியன் ஆபரேட்டர்களுடன் பூலியன் வெளிப்பாடுகளை உருவாக்குதல்

பின்வரும் தருக்க (அல்லது பூலியன்) செயல்பாடுகள் ஜாவாவில் கிடைக்கின்றன:

• தர்க்கரீதியான மறுப்பு, அதுவும் இல்லை அல்லது தலைகீழ் அல்ல. ஜாவாவில், சின்னத்தால் குறிக்கப்படுகிறது ! வெளிப்பாடு முன்.

• தருக்க மற்றும், இது AND அல்லது இணைப்பு. குறியீட்டால் & அது பயன்படுத்தப்படும் இரண்டு வெளிப்பாடுகளுக்கு இடையில் குறிக்கப்படுகிறது.

• லாஜிக்கல் அல்லது ஜாவாவில், அதுவும் OR, அதுவும் டிஸ்ஜங்க்ஷன். ஜாவாவில், குறியீட்டால் குறிக்கப்படுகிறது | இரண்டு வெளிப்பாடுகளுக்கு இடையில்.

• பிரத்தியேகமான அல்லது, XOR, கடுமையான டிஸ்ஜங்க்ஷன். ஜாவாவில், இது இரண்டு வெளிப்பாடுகளுக்கு இடையில் ^ என்ற குறியீட்டால் குறிக்கப்படுகிறது .

• ஜாவாவில், தருக்க ஆபரேட்டர்களில் நிபந்தனை அல்லது || , அத்துடன் நிபந்தனை மற்றும், && .

ஜாவா பூலியன் ஆபரேட்டர்கள் ஒவ்வொன்றின் சுருக்கமான விளக்கத்துடன் அட்டவணையைப் பார்ப்போம், மேலும் கீழே அவற்றை இன்னும் விரிவாக விவரிப்போம் மற்றும் குறியீடு எடுத்துக்காட்டுகளை வழங்குவோம். அட்டவணையில் உள்ள "ஒப்பராண்ட்ஸ்" என்பதன் மூலம், ஆபரேட்டர் பயன்படுத்தப்படும் தருக்க வெளிப்பாடு அல்லது மாறிகள் என்று அர்த்தம்.

a | b == true

ஜாவாவில், ஆபரேட்டர்கள் & , | மற்றும் ^ முழு எண்களுக்கும் பொருந்தும். இந்த வழக்கில், அவர்கள் சற்று வித்தியாசமாக வேலை செய்கிறார்கள் மற்றும் பிட்வைஸ் (அல்லது பிட்வைஸ்) தருக்க ஆபரேட்டர்கள் என்று அழைக்கப்படுகிறார்கள். ஒரு உதாரணத்தை எடுத்து, தருக்க ஆபரேட்டர்களைப் பயன்படுத்தி உருவாக்கப்பட்ட பல தருக்க வெளிப்பாடுகளைக் காண்பிப்போம்.

public class BoolTest2 {
   public static void main(String[] args) {
   int a = 5;
   int b = 7;
   boolean myBool1 = true;
   boolean myBool2 = false;
       System.out.println(myBool1&myBool2);
       System.out.println(myBool1|myBool2);
       System.out.println(!myBool1);
       System.out.println((a > b) & !myBool1 | myBool2);
   }
}

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

தருக்க செயல்பாடுகளின் முன்னுரிமை

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

• !

• &

• ^

• |

• &&

• ||

ஜாவா பூலியன் ரேப்பர்

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

Boolean b = new Boolean(false);

ஜாவா பூலியன் வகுப்பில் பயனுள்ள முறைகள் உள்ளன. இவற்றில் மிகவும் சுவாரஸ்யமான ஒன்று பார்ஸ்பூலியன் முறை. நிலையான பூலியன் பார்ஸ்பூலியன்(ஸ்ட்ரிங் கள்) முறை சரம் வாதத்தை பூலியனாக பாகுபடுத்துகிறது. சரம் வாதம் பூஜ்யமாக இல்லாமலும் சமமாக இருந்தால், "உண்மை" என்ற சரத்திற்கு வழக்கைப் புறக்கணித்து, திரும்பிய பூலியன் மதிப்பு உண்மை என்பதைக் குறிக்கிறது. இல்லையெனில் அது பொய்யாகிவிடும் .

பார்ஸ்பூலியன் முறை உதாரணம்

public class BoolTest2 {

        public static void main(String[] args)
        {
            System.out.println(Boolean.parseBoolean("True"));
            System.out.println(Boolean.parseBoolean("TRuE"));
            System.out.println(Boolean.parseBoolean("False"));
            System.out.println(Boolean.parseBoolean("here"));

        }
    }

வெளியீடு: நீங்கள் கற்றுக்கொண்டதை வலுப்படுத்த, எங்கள் ஜாவா பாடத்திட்டத்திலிருந்து வீடியோ பாடத்தைப் பார்க்க பரிந்துரைக்கிறோம்