JavaRush /Java Blog /Random-TL /Mga pagpapatakbo ng numero sa Java

Antas

28 February 2021
47 views
0 comments

Mga pagpapatakbo ng numero sa Java

Kamusta! Ngayon ay titingnan natin ang isang napakahalagang paksa, ibig sabihin, mga pagpapatakbo ng numero sa Java . Ang mga numero ay nasa lahat ng dako sa programming. Kung maghuhukay ka sa kurikulum ng paaralan, maaalala mo na ang lahat ng impormasyon sa isang computer ay ipinakita sa isang numerical na format - mga kumbinasyon ng mga zero at isa - na tinatawag ding binary code. Mga pagpapatakbo ng numero sa Java - 2

Napakaraming operasyon sa mga numero sa programming, kaya titingnan natin ang pinakamahalaga sa kanila na may mga halimbawa :)

Mga operasyon sa aritmetika

Magsimula tayo sa pinakasimpleng bagay - sa mga pagpapatakbo ng aritmetika. Ito ay ang kilalang karagdagan (+ sign), pagbabawas (-), pagpaparami (*) at paghahati (/).

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:

Nagamit mo na ang lahat ng ito. Maaari kang magdagdag ng isang operasyon sa kanila %- ang natitira sa dibisyon.

public class Main {

   public static void main(String[] args) {

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

Output ng console:

Sa halimbawang ito, hinahati natin ang 33 sa 2. Bilang resulta, nakakakuha tayo ng 16 at may nananatiling dagdag na "buntot" na hindi nahahati sa 2 - isa. Ang "buntot" na ito ay magiging resulta ng "natitira sa dibisyon" na operasyon. Ang Java (pati na rin ang matematika) ay nagpapatupad ng mga operator ng paghahambing . Marahil ay kilala mo rin sila mula sa paaralan:

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

Narito ito ay nagkakahalaga ng pagbibigay pansin sa isang mahalagang punto kung saan maraming mga nagsisimula ang nagkakamali. Ang "katumbas" na operasyon ay isinusulat bilang ==, at hindi sa isang tanda =. Ang unit sign =sa Java ay isang assignment operator, kung saan ang isang variable ay nakatalaga ng isang numero, string, o ang halaga ng isa pang variable. Mga pagpapatakbo ng numero sa Java - 3

public class Main {

   public static void main(String[] args) {

       int x = 33;
       int y = 999;
       System.out.println(x=y);// expect false to be printed to the console
   }
}

Output ng console:

Oops! Malinaw na hindi ito ang resulta na inaasahan namin. Isa itong ganap na kakaibang uri ng data: inaasahan naming makita ang boolean, ngunit nakakuha ng numero. Ito ay dahil sa mga panaklong mayroon kaming operasyon ng pagtatalaga, hindi isang paghahambing. x=y Ang value y(999) ay itinalaga sa variable x, at pagkatapos ay na-print namin ito xsa console. Tamang opsyon:

public class Main {

   public static void main(String[] args) {

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

Output ng console:


false

Ngayon ay naihambing namin nang tama ang 2 numero! :) Ang isa pang tampok ng pagpapatakbo ng pagtatalaga ( =) ay maaari itong gawin "nakadena":

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:

Tandaan: ang pagtatalaga ay ginagawa mula kanan pakaliwa. Ang expression na ito ( x = y = z) ay isasagawa sa mga hakbang:

y = z, ibig sabihin, y = 256
x = y, iyon ay x = 256

Unary na mga operasyon

Tinatawag silang "unary" mula sa salitang "uno" - "isa". Natanggap nila ang pangalang ito dahil, hindi tulad ng mga nauna, isinasagawa sila sa isang numero, at hindi sa ilan. Kabilang dito ang:

Unary minus. Binabaliktad nito ang tanda 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 a second time
       x= -x;
       System.out.println(x);
   }
}

Output ng console:


-999
999

Dalawang beses naming ginamit ang unary minus. Bilang isang resulta, ang aming numero ay naging negatibo sa una, at pagkatapos ay positibo muli!

Pagtaas ( ++) at pagbaba ( --)

Ang isang operasyon ++ay nagdaragdag ng isang numero ng isa, at ang isang operasyon --ay nagpapababa nito ng parehong yunit.

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 anyo ng notasyong ito kung narinig mo na ang C++ na wika. Sa tulong ng ganoong kawili-wiling pangalan, ipinarating ng mga tagalikha nito ang kanilang ideya: "Ang C++ ay isang extension ng wikang C." Ang isang sikat na pinahusay na bersyon ng Notepad ay tinatawag na Notepad++ Mahalagang punto. Mayroong dalawang uri ng pagpapatakbo ng pagtaas at pagbaba: postfix at prefix. x++- postfix notation ++x- prefix notation Ano ang pangunahing pagkakaiba kung maglalagay ka ng plus at minuses bago o pagkatapos ng numero? Tingnan natin sa isang halimbawa:

public class Main {

   public static void main(String[] args) {

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

Output ng console:

May mali ba! Nais naming dagdagan xng 1 at magtalaga ng bagong halaga sa variable y. Iyon ay, ang y ay dapat na katumbas ng 1000. Ngunit mayroon kaming ibang resulta - 999. Lumalabas na xhindi ito nadagdagan, at ang pagpapatakbo ng pagtaas ay hindi gumana? Paano ito gumana. Upang i-verify ito, subukang i-print ang x sa console sa 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, iyon ang dahilan kung bakit ang operasyon ng postfix ay tinatawag na ganoong paraan: ito ay isinasagawa pagkatapos ng pangunahing expression. Iyon ay, sa aming kaso: int y = x++; una ito ay naisakatuparan y = x(at ang variable na y ay itatalaga sa paunang halaga x), at pagkatapos lamang x++ . Paano kung hindi tayo nasisiyahan sa pag-uugaling ito? Kailangan mong gamitin ang prefix notation:

public class Main {

   public static void main(String[] args) {

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

Sa kasong ito, ito ay gagana muna ++x at pagkatapos lamang nito. y = x; Ang pagkakaibang ito ay nararapat na tandaan kaagad upang hindi magkamali sa isang tunay na programa, kung saan ang lahat ng pag-uugali ay maaaring mabaligtad dahil dito :)

Pinagsamang operasyon

Bilang karagdagan, sa Java mayroong mga tinatawag na pinagsamang operasyon. Gumagamit sila ng kumbinasyon ng dalawang operasyon:

Takdang-aralin
Pagpapatakbo ng aritmetika

Kabilang dito ang mga operasyon:

+=
-=
*=
/=
%=

Tingnan 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:

x += yibig sabihin x = x + y. Para lang sa kaiklian, dalawang magkasunod na character ang ginagamit. Gumagana rin ito sa mga kumbinasyon ng -=, *=, /=at %=.

Mga lohikal na operasyon

Bilang karagdagan sa mga pagpapatakbo sa mga numero, ang Java ay mayroon ding mga pagpapatakbo sa mga variable ng Boolean - trueat false. Ang mga operasyong ito ay isinasagawa gamit ang mga lohikal na operator

!— “HINDI” operator. Binabaliktad ang halaga ng isang boolean variable

public class Main {

   public static void main(String[] args) {

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

Output ng console:


false

&&— operator “AT”. Nagbabalik lamang ng halaga truekung ang parehong mga operand ay true.
```
public class Main {

   public static void main(String[] args) {

       System.out.println(100 > 10 && 100 > 200);
       System.out.println(100 > 50 && 100 >= 100);
   }
}
```
Output ng console:
```
false
true
```
Ang resulta ng unang operasyon ay false, dahil mali ang isa sa mga kundisyon, ibig sabihin, 100 > 200. Kinakailangan ng operator na maging totoo ang lahat ng kundisyon (tulad ng sa pangalawang linya, halimbawa) &&upang maibalik ang .true
||— “O” operator. Nagbabalik truekapag ang kahit isa sa mga operand ay totoo.

Narito ang aming nakaraang halimbawa ay gagana nang iba:
```
public class Main {

   public static void main(String[] args) {

       System.out.println(100 > 10 || 100 > 200);
   }
}
```
Output ng console:
```
true
```
Выражение 100 > 200 по-прежнему ложно, но оператору “or” вполне достаточно, что первая часть (100 > 10) является истинной.

Mga komento

TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION