Java Boolean

Ang salitang "boolean" sa konteksto ng wikang Java ay maaaring gamitin sa iba't ibang kahulugan, kahit na may kaugnayan. Maaaring ito ay:

• boolean primitive type o boolean variable ng ganitong uri
• Java Boolean class o Boolean wrapper object
• Boolean expression, boolean value, ilang kundisyon
• Mga operator ng Java Boolean

Sa artikulong ito, tatalakayin natin ang lahat ng mga opsyong ito at ipaliwanag kung anong mga konsepto ang sumasailalim sa mga expression ng Boolean .

Ano ang boolean sa pangkalahatang kahulugan

Ang konsepto ng isang Boolean expression ay nagmula sa matematika, o sa halip, mula sa mathematical logic. Ang Boolean na expression sa propositional algebra ay isang expression na masasabing totoo o mali. Halimbawa: Kasabay nito, ang "2" o "snow" ay hindi mga Boolean na expression.

Java boolean primitive na uri ng data at boolean variable

Kung pag-uusapan ang isang boolean sa Java, una ay malamang na ito ay isang boolean primitive na uri ng data at boolean na mga variable ng ganitong uri. Tulad ng malamang na nahulaan mo na, ang mga variable ng ganitong uri ay maaari lamang tumagal ng dalawang halaga, totoo at mali. Ang Java ay may medyo mahigpit na mga paghihigpit: ang isang boolean sa Java ay hindi mako-convert sa anumang iba pang uri ng data, at vice versa. Sa partikular, ang boolean sa Java ay hindi isang mahalagang uri, at ang mga halaga ng integer ay hindi magagamit sa halip na mga boolean. Narito ang isang halimbawa ng direktang pagtatakda ng isang uri ng boolean :

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

Narito mayroon kaming 2 boolean variable. Sumulat tayo ng isang maliit na programa na may isang halimbawa ng paggamit ng isang uri ng boolean :

//boolean variable example
public class BoolTest {

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

Ang program na ito ay nagpi-print ng "false" sa console. Sa pamamagitan ng paraan, ang isang boolean variable ay nakatakda sa false bilang default, ngunit hindi ka pinapayagan ng Java na magtrabaho kasama ang mga hindi nasimulang lokal na variable.

Mga Boolean na expression sa Java

Bilang karagdagan sa tahasang pagsisimula ng boolean variable sa true o false, ang uri ng data ng boolean ay tahasang ginagamit sa maraming lugar. Kung paanong ang resulta ng anumang pagdaragdag ng mga numero ay magiging isang numero, ang resulta ng anumang paghahambing ay magiging totoo o mali, iyon ay, ito ay magiging isang boolean na uri. Nangangahulugan ito na, bilang karagdagan sa direktang pagtukoy ng boolean value sa pamamagitan ng boolean variable assignment statement, ang mga boolean value ay nagreresulta mula sa iba't ibang paghahambing, gaya ng 5 > 2 , at pangunahing ginagamit sa mga conditional at loop statement. Narito ang isang halimbawa ng ganitong paggamit ng boolean type:

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

Ang output ay: Sa kaso ng a < b , inihambing ng < operator ang expression sa kaliwa sa expression sa kanan. Ipinakita namin ang resulta ng paghahambing sa screen. Dahil 5 < 7 (ang pahayag ay totoo), ang halagang totoo ay ipi-print sa console. Sa pangalawang kaso, nagpapakita kami ng direktang paghahambing ng zero at pito, at sa pangatlo, itatanong namin kung mali ang value ng variable na myBoolean . Dahil ito ang kaso, inilalabas namin ang halagang true . Sa katunayan, upang bumuo ng mga boolean na expression sa Java, maaari naming gamitin ang anumang mga operator ng paghahambing:

Kung saan ginagamit ang mga boolean value

Ang mga boolean value at conditional expression ay kadalasang ginagamit sa mga kundisyon ng branch statement, ternary operator, at loops. Sa katunayan, ang kanilang paggamit ay batay sa pagsuri sa ilang mga Boolean na expression. Halimbawa:

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

Ang program na ito ay nagpi-print ng isang pagkakasunud-sunod ng mga integer at dinadagdagan ang mga ito ng isa hangga't ang kundisyon sa mga bracket pagkatapos ng habang ay natutugunan. Iyon ay, habang ang expression na i <=10 ay totoo.

Java boolean operator. Pagbuo ng mga Boolean Expression gamit ang mga Boolean Operator

Ang mga sumusunod na lohikal (o boolean) na operasyon ay magagamit sa Java:

• Logical negation, ito rin ay HINDI o inversion. Sa Java, tinutukoy ng simbolo ! bago ang pagpapahayag.

• Lohikal at, ito rin ay AT o conjunction. Tinutukoy ng simbolo at sa pagitan ng dalawang ekspresyon kung saan ito inilalapat.

• Logical o sa Java, ito rin ay OR, ito ay disjunction din. Sa Java, na tinutukoy ng simbolo | sa pagitan ng dalawang ekspresyon.

• Eksklusibo o, XOR, mahigpit na disjunction. Sa Java, ito ay tinutukoy ng simbolo ^ sa pagitan ng dalawang expression.

• Sa Java, kasama sa mga lohikal na operator ang conditional o, na tinutukoy bilang || , pati na rin ang kondisyon at, && .

Tingnan natin ang talahanayan na may maikling paglalarawan ng bawat isa sa mga Java boolean operator, at sa ibaba ay ilalarawan natin ang mga ito nang mas detalyado at magbibigay ng mga halimbawa ng code. Sa pamamagitan ng "operand" sa talahanayan, ang ibig naming sabihin ay ang lohikal na expression o mga variable kung saan inilalapat ang operator.

a | b == true

Tandaan na sa Java, ang mga operator at , | at ^ nalalapat din sa integer. Sa kasong ito, gumagana ang mga ito nang medyo naiiba at tinatawag na bitwise (o bitwise) na mga lohikal na operator. Kumuha tayo ng isang halimbawa at ipakita ang ilang mga lohikal na expression na binubuo gamit ang mga lohikal na operator.

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

Narito ang output: Sa katunayan, maaari kang gumawa ng napakakumplikadong lohikal na mga konstruksyon gamit ang mga lohikal na operator. Halimbawa Kung sinimulan ang lahat ng mga variable, gagana ang mga naturang construction. Gayunpaman, hindi mo dapat abusuhin ang mga ito, ginagawa nilang mahirap basahin ang code. Gayunpaman, ito ay lubhang kapaki-pakinabang upang harapin ang gayong mga lohikal na konstruksyon. Subukang gumawa ng mga lohikal na expression sa iba pang mga lohikal na operator na ibinigay sa talahanayan.

Nangunguna sa mga lohikal na operasyon

Tulad ng sa matematika, sa programming, ang mga operator ay may isang tiyak na pagkakasunud-sunod ng pagpapatupad kung sila ay nangyari sa parehong expression. Ang mga unary operator ay may mga pakinabang kaysa sa mga binary, at multiplikasyon (kahit na lohikal) kaysa sa karagdagan. Narito ang mga lohikal na operator na inilagay sa listahan ng mga paksa na mas mataas, mas mataas ang kanilang priyoridad:

• !

• at

• ^

• |

• &&

• ||

Java Boolean wrapper

Sa Java, ang bawat primitive na uri ay may "kapatid", isang klase ng wrapper ( Wrapper ). Ang wrapper ay isang espesyal na klase na nag-iimbak ng halaga ng isang primitive sa loob. Gayunpaman ito ay isang klase, kaya maaari kang lumikha ng mga pagkakataon (mga bagay) nito. Ang mga bagay na ito ay nag-iimbak ng mga kinakailangang halaga ng mga primitive sa loob, habang sila ay magiging mga tunay na bagay. Ang Java boolean primitive type ay may wrapper na Java Boolean (na may capital B) na klase. Ang mga bagay sa Boolean Class ay nilikha tulad ng iba pa:

Boolean b = new Boolean(false);

Ang Java Boolean class ay may mga kapaki-pakinabang na pamamaraan. Isa sa mga pinaka-kawili-wili sa mga ito ay ang parseBoolean method. Ang static na boolean parseBoolean(String s) na pamamaraan ay nag-parse ng string argument bilang isang boolean. Kinakatawan ng ibinalik na boolean ang value na true kung ang string argument ay hindi null at pantay, hindi pinapansin ang case, sa string na "true". Kung hindi, ito ay nagbabalik ng false .

Halimbawa ng parseBoolean method

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"));

        }
    }

Ang output ay: Upang palakasin ang iyong natutunan, iminumungkahi naming manood ka ng isang video lesson mula sa aming Java Course