Mga numerong operator sa Java

Hi! Ngayon ay isasaalang-alang natin ang isang napakahalagang paksa, ibig sabihin, mga numeric operator sa Java . Sa programming, ang mga numero ay nasa lahat ng dako. Kung maghuhukay ka ng malalim at maaalala ang high school, maaari mong maalala na ang isang computer ay kumakatawan sa lahat ng impormasyon sa isang numerical na format: mga kumbinasyon ng mga zero at isa, na kilala rin bilang binary code. Maraming numeric operator sa programming, kaya gagamit tayo ng mga halimbawa para tuklasin ang pinakamahalaga sa kanila :) Magsimula tayo sa pinakasimpleng: arithmetic operators . Ito ang mga kilalang karagdagan ( +), pagbabawas ( -), pagpaparami ( *), at paghahati ( /) na mga operator.

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = 33;

       System.out.println(x+y);
       System.out.println(x-y);
       System.out.println(x*y);
       System.out.println(x/y);
   }
}

Output ng console: 1032 966 32967 30 Nagamit mo na ang lahat ng ito. Sa grupong ito, maaari kang magdagdag sa natitira o modulo ( %) operator.

public class Main {

   public static void main(String[] args) {

       int x = 33;
       int y = 33%2;
       System.out.println(y);
   }
}

Output ng console: 1 Sa halimbawang ito, hinati namin ang 33 sa 2. Nagbubunga ito ng 16, na may dagdag na "buntot" (isa) na hindi nahahati sa 2. Ang "buntot" na ito ay resulta ng "natitira mula sa dibisyon" na operasyon. Ang Java ay nagpapatupad din ng paghahambing/relasyon na mga operator (tulad ng sa matematika). Marahil ay pamilyar din sila sa iyo mula sa paaralan:

• katumbas ng ( ==)
• mas malaki kaysa sa ( >)
• mas mababa sa ( <)
• mas malaki sa o katumbas ng ( >=)
• mas mababa sa o katumbas ng ( <=)
• hindi pantay ( !=)

Dito dapat mong bigyang pansin ang isang mahalagang punto na nagiging sanhi ng maraming mga nagsisimula na magkamali. Ang "katumbas" na operator ay nakasulat ==, hindi =. Sa Java, ang isang solong =ay ang assignment operator, na ginagamit kapag ang isang variable ay nakatalaga ng isang numero, string, o ang halaga ng isa pang variable.

public class Main {

   public static void main(String[] args) {

       int x = 33;
       int y = 999;
       System.out.println(x=y);// We expect false to be displayed
   }
}

Output ng console: 999 Oops! Malinaw na hindi ito ang resulta na inaasahan namin. Isa itong ganap na kakaibang uri ng data: inaasahan naming makakita ng boolean , ngunit nakakuha kami ng numero. Lahat dahil gumamit kami ng assignment operator sa mga panaklong sa halip na isang paghahambing . x=y Ang halaga ng y(999) ay itinalaga sa variable x, at pagkatapos ay ipinakita namin ang halaga ng x. Narito ang tamang paraan upang gawin ito:

public class Main {

   public static void main(String[] args) {

       int x = 33;
       int y = 999;
       System.out.println(x==y);
   }
}

Console output: false Ngayon ay naihambing namin nang maayos ang dalawang numero! :) Narito ang isa pang tampok ng assignment operator ( =): maaari itong "naka-chain" nang magkasama:

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = 33;
       int z = 256;

       x = y = z;
       System.out.println(x);
   }
}

Output ng console: 256 Tandaan na ang pagtatalaga ay mula kanan papuntang kaliwa . Ang expression na ito ( x = y = z) ay isasagawa sa mga hakbang:

• y = z, yan ay,y = 256
• x = y, yan ay,x = 256

Unary operator.

Tinatawag silang " unary " mula sa salitang " uno ", na nangangahulugang " isa ". Nakuha nila ang pangalang ito dahil, hindi katulad ng mga naunang operator, kumikilos sila sa isang numero, hindi sa ilan. Kabilang dito ang:

• Unary minus. Pinihit nito ang sign ng numero.

public class Main {

   public static void main(String[] args) {

       int x = 999;

       // Change the sign for the first time
       x = -x;
       System.out.println(x);

       // Change the sign for the second time
       x= -x;
       System.out.println(x);
   }
}

Output ng console: -999 999 Dalawang beses naming ginamit ang unary minus operator. Bilang resulta, ang aming numero ay unang negatibo, at pagkatapos ay naging positibo muli!

• Pagtaas (++) at pagbaba (--)

Ang ++operator ay nagdaragdag ng isang numero ng isa, at ang --operator ay nagbabawas ng isang numero sa parehong halaga.

public class Main {

   public static void main(String[] args) {

       int x = 999;
       x++;
       System.out.println(x);

       x--;
       System.out.println(x);
   }
}

Output ng console: 1000 999 Maaaring pamilyar sa iyo ang notasyong ito kung narinig mo na ang C++ na wika. Ginamit ng mga tagalikha nito ang kawili-wiling pangalan na ito upang ihatid ang ideya na "Ang C++ ay isang extension ng wikang C" Isang sikat na pinahusay na bersyon ng Notepad ay tinatawag na Notepad++ Narito ang isang mahalagang punto. Mayroong dalawang uri ng increment at decrement operator: postfix at prefix . x++- postfix ++x- prefix Ano ang pangunahing pagkakaiba sa pagitan ng paglalagay ng mga plus/minus bago o pagkatapos ng numero? Makikita natin sa sumusunod na halimbawa:

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = x++;
       System.out.println(y);
   }
}

Output ng console: 999 May hindi tama! Nais naming dagdagan xng 1 at italaga ang bagong halaga sa variable na y. Sa madaling salita, ang y ay dapat na 1000. Ngunit sa halip ay nakakuha tayo ng iba: 999. Mukhang hindi nadagdagan ang x at hindi gumana ang increment operator? Ngunit ito ay gumana. Upang kumbinsihin ang iyong sarili, subukang ipakita xsa dulo :)

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = x++;
       System.out.println(y);
       System.out.println(x);
   }
}

Output ng console: 999 1000 Sa katunayan, ito mismo ang dahilan kung bakit ang operasyong ito ay tinatawag na postfix: ito ay ginagawa pagkatapos ng pangunahing expression. Nangangahulugan ito, sa aming kaso: int y = x++; y = xay ginanap muna (at ang variable yay pasisimulan sa halaga ng x), at pagkatapos lamang ay x++isasagawa Paano kung hindi ito ang pag-uugali na gusto natin? Pagkatapos ay kailangan nating gumamit ng prefix notation:

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = ++x;
       System.out.println(y);
   }
}

Sa kasong ito, ++xnaproseso muna at pagkatapos lamang ay y = x; pinaandar. Dapat mong ilagay ang pagkakaibang ito sa memorya kaagad upang maiwasan ang magkamali sa isang tunay na programa kung saan ang paggamit ng postfix sa halip na prefix ay maaaring mabaligtad ang lahat :)

Mga operator ng compound

Bilang karagdagan, sa Java ay may mga tinatawag na compound operator. Pinagsasama nila ang dalawang operator:

• Takdang-aralin
• Mga operator ng aritmetika

Kabilang dito ang:

• +=
• -=
• *=
• /=
• %=

Isaalang-alang natin ang isang halimbawa:

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = 33;

       x += y;
       System.out.println(x);
   }
}

Output ng console: 1032 x += y ay nangangahulugang x = x + y. Ang dalawang simbolo ay magkasunod na ginagamit para sa kapakanan ng kaiklian. Ang mga kumbinasyon -=, *=, /=at %=gumagana sa katulad na paraan.

Mga lohikal na operator

Bilang karagdagan sa mga numeric operator, ang Java ay mayroon ding mga operasyon na may kasamang boolean value ( true at false ). Ang mga operasyong ito ay isinasagawa gamit ang mga lohikal na operator

• !- lohikal na HINDI . Binabaluktot nito ang halaga ng isang boolean

public class Main {

   public static void main(String[] args) {

       boolean x = true;
       System.out.println(!x);
   }
}

Output ng console: false

• &&- lohikal AT . Nagbabalik lamang ito ng totoo kung ang parehong mga operand ay totoo.

public class Main {

   public static void main(String[] args) {

       System.out.println(100 > 10 && 100 > 200);
       System.out.println(100 > 50 && 100 >= 100);
   }
}

Console output: false true Ang resulta ng unang operasyon ay false, dahil ang isa sa mga operand ay false, namely 100 > 200. Upang ibalik ang true, &&hinihiling ng operator na ang parehong mga operand ay totoo (tulad ng kaso sa pangalawang linya).

• ||- lohikal O . Nagbabalik ito ng totoo kapag ang kahit isa sa mga operand ay totoo.

Kapag ginamit namin ang operator na ito, ang aming nakaraang halimbawa ay gumagawa ng ibang resulta:

public class Main {

   public static void main(String[] args) {

       System.out.println(100 > 10 || 100 > 200);
   }
}

Output ng console: true Ang expression 100 > 200ay mali pa rin, ngunit para sa operator na OR ganap na sapat na ang unang bahagi ( 100 > 10) ay totoo.