ลำดับความสำคัญของตัวดำเนินการ - 1

"สวัสดี บิลาโบ!"

"Bilaabo ยินดีที่จะทักทายเพื่อนของเขา!"

"วันนี้ Bilaabo จะบอกคุณเกี่ยวกับลำดับความสำคัญของตัวดำเนินการ แต่ก่อนอื่น เขาจะบอกคุณเกี่ยวกับตัวดำเนินการเอง"

"คุณพูดถึงโอเปอเรเตอร์เหล่านี้ว่าอะไร"

"อันที่จริง คุณคุ้นเคยกับพวกมันอยู่แล้ว คุณอาจไม่รู้ว่าพวกมันถูกเรียกว่าโอเปอเรเตอร์"

"เช่น สมมติว่าเรามีนิพจน์  c = a + b; "

"มีตัวดำเนินการสองตัว: ตัวดำเนินการเพิ่มและตัวดำเนินการมอบหมาย"

"อีกนัยหนึ่ง ตัวดำเนินการเป็นเพียงสัญลักษณ์ทางคณิตศาสตร์ เช่นเดียวกับการคูณ การหาร และการบวก"

"ใช่ นั่นเป็นความจริง อย่างไรก็ตาม มีความแตกต่าง"

"ฉันจะไม่กำหนดโอเปอเรเตอร์ให้คุณ: คำจำกัดความไม่ได้ทำให้คุณฉลาดขึ้น จะดีกว่าถ้าดูโอเปอเรเตอร์ในการดำเนินการ โอเปอเรเตอร์สามารถแบ่งออกเป็นหลายกลุ่ม ซึ่งเราจะตรวจสอบในตอนนี้"

1) " ตัวดำเนินการทางคณิตศาสตร์ "

เครื่องหมาย ตัวอย่าง ชื่อ คำอธิบาย (มันทำอะไร)
+ a + b ตัวดำเนินการเพิ่มเติม ตัวดำเนินการเพิ่มเติม
- c - d ตัวดำเนินการลบ ลบหมายเลขที่สองจากหมายเลขแรก
* a * t ตัวดำเนินการคูณ คูณสองจำนวน
/ a / b ผู้ดำเนินการส่วน นำตัวเลขตัวแรกมาหารด้วยตัวที่สอง
% c % d นำตัวเลขตัวแรกมาหารด้วยตัวที่สอง คำนวณเศษที่เหลือหลังจากหารจำนวนแรกด้วยจำนวนที่สอง
- -a ยูนารี ลบ เปลี่ยนเครื่องหมายของตัวแปรเป็นตรงกันข้าม
บวกเป็นลบ และลบเป็นบวก
+ +a อูนารีพลัส ไม่เปลี่ยนแปลงอะไร สิ่งนี้ถูกเพิ่มเพื่อชมเชยตัวดำเนินการลบแบบเอกนารี มันเป็นเพียงรูปลักษณ์

"ฉันจำสิ่งเหล่านี้ได้จากโรงเรียน เฟิร์มแวร์ของฉันมีหลักสูตรของโรงเรียน"

“ว่าแต่ เครื่องหมายเปอร์เซ็นต์นั่นมันอะไร เวทมนตร์บางอย่าง?”

"มันคือตัวดำเนินการ " เศษที่เหลือหลังจากการหาร " ถ้า 11 หารด้วย 5 เราจะได้ 2 และเศษที่เหลือเป็น 1 1 นี้ได้จากการเขียน 11 % 5;"

"เมื่อคุณหารจำนวนเต็มใน Java ผลลัพธ์จะเป็นจำนวนเต็มเช่นกัน ส่วนที่เหลือจากการหารจะถูกละเว้น ถ้าเราหาร 8 ด้วย 5 เราจะได้ 1"

การแสดงออก ผลลัพธ์
19 / 10 1 ถ้าเราหาร 19 ด้วย 10 ผลลัพธ์คือ 1 เหลือเศษ 9
19 % 10 9 ถ้าเราหาร 19 ด้วย 10 ผลลัพธ์คือ 1 เหลือเศษ 9
2 / 5 0 ถ้าเราหาร 2 ด้วย 5  ผลลัพธ์คือ 0 โดยเหลือเศษ 2
16 % 2 0 ถ้าเราหาร 16 ด้วย 2 ผลลัพธ์คือ 8 เหลือเศษ 0

"แต่เราต้องการอะไรในโลกที่เหลือ"

"สมมติว่าคุณต้องการตรวจสอบว่าจำนวนเต็มเป็นเลขคู่หรือไม่ จากนั้นคุณสามารถเขียน:"

if (a % 2 == 0)

"และถ้าคุณต้องการตรวจสอบว่า b เป็นเลขคี่หรือไม่ คุณก็เขียนได้ว่า:"

Java university 
if (b % 2 == 1)

"หรือตรวจสอบว่า d หารด้วย 3 ลงตัวหรือไม่:"

if (d % 3 == 0)

"น่าสนใจ ฉันจะจำไว้"

2)  " ตัวดำเนินการเปรียบเทียบ "

เครื่องหมาย ตัวอย่าง ชื่อ คำอธิบาย (มันทำอะไร)
< a < b น้อยกว่า ตรวจสอบว่า a น้อยกว่า b หรือไม่
<= c <= d น้อยกว่าหรือเท่ากับ ตรวจสอบว่า c น้อยกว่าหรือเท่ากับ d หรือไม่
> a > b มากกว่า ตรวจสอบว่า a มากกว่า b หรือไม่
>= c >= d มากกว่าหรือเท่ากับ ตรวจสอบว่า c มากกว่าหรือเท่ากับ d หรือไม่
== i == j เท่ากับ ตรวจสอบว่า i เท่ากับ j หรือไม่
!= a != 0 ไม่เท่ากับ ตรวจสอบว่า a ไม่เท่ากับศูนย์หรือไม่

"ฉันใช้ทั้งหมดนี้แล้ว"

"และอะไรคือความแตกต่างที่สำคัญระหว่างตัวดำเนินการเหล่านี้กับตัวดำเนินการทางคณิตศาสตร์"

"ถ้าเราบวกตัวเลขสองตัว เราจะได้ตัวเลข แต่ถ้าเราเปรียบเทียบตัวเลขสองตัว เราจะได้ค่าจริงหรือเท็จ"

"ถูกต้อง ผลลัพธ์ของการเปรียบเทียบคือค่า " ค่าตรรกะ " ซึ่งอย่างที่คุณทราบ จะแสดงด้วยประเภทบูลีน มีความเป็นไปได้สองอย่าง: จริงหรือเท็จ

“ใช่ ชัดเจนหมดแล้ว ฉันรู้แล้ว”

3) " ตัวดำเนินการเชิงตรรกะ "

เครื่องหมาย ตัวอย่าง ชื่อ คำอธิบาย (มันทำอะไร)
&& a && b และ ผลลัพธ์ของนิพจน์จะเป็นจริงก็ต่อเมื่อทั้ง a และ b เป็นจริง
|| c || d หรือ ผลลัพธ์ของนิพจน์จะเป็นจริงถ้า a หรือ b เป็นจริง ทั้งสองอย่างหรืออย่างน้อยหนึ่งอย่าง
! !a ไม่ ผลลัพธ์ของนิพจน์จะเป็นจริงก็ต่อเมื่อ a เป็นเท็จ

"ตัวดำเนินการเชิงตรรกะสามารถใช้ได้กับตัวแปรบูลีนหรือนิพจน์เท่านั้น"

ตัวอย่าง คำอธิบาย
boolean a = true;
boolean b = true;if (a && b)		 เงื่อนไข if เป็นจริง ถ้าค่าทั้งสองเป็นจริงกล่าว
คือ ถ้าทั้งa และ bเป็นจริง ผลลัพธ์จะเป็นจริง
boolean a = true;
boolean b = false;if (a || b)		 เงื่อนไข if เป็นจริง ถ้าอย่างน้อยหนึ่งค่าเป็นจริงกล่าว
อีกนัยหนึ่ง ถ้าa หรือ bเป็นจริง ผลลัพธ์จะเป็นจริง
boolean b = false;

if (!b)

 เงื่อนไข if เป็นจริง ถ้า b ไม่เป็นความจริง
กล่าวอีกนัยหนึ่ง ถ้า   b เป็นเท็จผลลัพธ์จะ  เป็น จริง
int a = 2, b = 3, c = 4;

if (a < b && a < c)
if ((a < b) && (a < c))

 ถ้า a น้อยกว่า b และ a น้อยกว่า c ผลลัพธ์ของนิพจน์จะเป็นจริง
a, b และ c เป็นจำนวนเต็ม แต่ผลลัพธ์ของการเปรียบเทียบจำนวนเต็มคือค่าตรรกะ (จริง, เท็จ) ซึ่งหมายความว่าเราสามารถใช้ตัวดำเนินการเชิงตรรกะได้

"ฉันรู้ทั้งหมดนี้แล้ว"

“จริงเหรอ?

4) " ตัวดำเนินการระดับบิต "

เครื่องหมาย ตัวอย่าง ชื่อ คำอธิบาย (มันทำอะไร)
& a & b และ ในระดับบิตและ
| c | d หรือ ในระดับบิตหรือ
~ ~a ไม่ บิตไม่
^ a ^ b เอ็กซ์ออร์ Bitwise "พิเศษหรือ"

" ตัวดำเนินการระดับบิตดำเนินการแบบบิตต่อบิตกับจำนวนเต็ม"

"นั่นอะไร?"

"แต่ละหมายเลขจะแสดงเป็นชุดของบิต จากนั้นจึงคำนวณผลลัพธ์ดังนี้:"

"ถ้าบิตแรกของทั้งสองจำนวนเป็น 1 บิตแรกของผลลัพธ์จะเป็น 1"

"ถ้าบิตที่สองของทั้งสองจำนวนเป็น 1 บิตที่สองของผลลัพธ์จะเป็น 1 ไปเรื่อยๆ"

"นั่นเป็นเรื่องจริงสำหรับตัวดำเนินการระดับบิตทั้งหมดหรือไม่"

"มันง่ายกว่านั้นมาก บิตสามารถมีค่าได้สองค่าเท่านั้น 0 และ 1 ใช่ไหม"

"ขวา."

"จากนั้นให้คิดว่า 1 เป็นจริงและ 0 เป็นเท็จ การดำเนินการในแต่ละบิตจะเกือบจะเหมือนกันกับการดำเนินการทางตรรกะ:"

นิพจน์เชิงตรรกะ การแสดงออกในระดับบิต
จริง && จริง == จริง 1&1 == 1
จริง && เท็จ == เท็จ 1&0 == 0
จริง || จริง == จริง 1|1 == 1
จริง || เท็จ == จริง 1|0 == 1
เท็จ || เท็จ = เท็จ 0|0 == 0
!false == จริง ~0 == 1
!true == เท็จ ~1 == 0

"โอ้! ง่ายจัง"

"ใช่ อย่าลืมว่าการดำเนินการระดับบิตใช้บิตที่สอดคล้องกันจากตัวเลขสองตัว"

"ใช่ ฉันจำได้: บิตแรกของหมายเลขหนึ่งจับคู่กับบิตแรกของวินาที และผลลัพธ์จะถูกเขียนไปยังบิตแรกด้วย และบิตที่เหลือก็จะเหมือนกัน"

“ถูกต้องแล้ว คุณมีคำถามอะไรอีกไหม”

"อะไรคือ XOR และ 'พิเศษหรือ'"

"มันเหมือนเค้กชิ้นหนึ่ง: เมื่อค่าต่างกัน มันก็จริง เมื่อมันเหมือนกัน มันก็เป็นเท็จ"

นิพจน์เชิงตรรกะ การแสดงออกในระดับบิต
XOR จริง จริง == เท็จ 1 ^ 1 == 0
XOR เท็จ เท็จ == เท็จ 0 ^ 0 == 0
XOR จริง เท็จ == จริง 1 ^ 0 == 1
XOR เท็จ จริง == จริง 0 ^ 1 == 1

ต่อไปนี้คือตัวอย่างเพิ่มเติมของการดำเนินการระดับบิต:

ตัวอย่าง ตัวเลขเป็นบิต ผลลัพธ์เป็นบิต ผลลัพธ์
5 & 3 0000010 1  & 0000001 1 0000000 1 1
7 & 2 000001 1 1 & 000000 1 0 00000010 2
5 | 9 00000 1 0 1  | 0000 1 00 1 00001101 13
5 ^ 9 00000 101  ^00001001 0000 1100 12
~9 ~ 00001001 11110110 246

"ขอบคุณ บิลาโบ ตอนนี้ฉันรู้แล้ว"

"มีตัวดำเนินการระดับบิตอีกหนึ่งกลุ่ม นั่นคือตัวดำเนินการ shift:"

5) " ตัวดำเนินการกะ "

เครื่องหมาย ตัวอย่าง ชื่อ คำอธิบาย (มันทำอะไร)
>> a >> b กะขวา เลื่อนบิตของตัวเลข a ไปทางขวาทีละ b หลัก
<< c << d กะซ้าย เลื่อนบิตของตัวเลข c ไปทางซ้ายทีละหลัก
>>> a >>> 2 กะขวาที่ไม่ได้ลงนาม เลื่อนบิตของตัวเลข a ไปทางขวา 2 หลัก

"นี่คือเวทมนตร์แห่งท้องถนนแบบไหนกัน?"

"จริงๆแล้วมันง่ายมาก ลองดูสิ:"

ตัวอย่าง ตัวเลขเป็นบิต ผลลัพธ์เป็นบิต ผลลัพธ์
10 >> 1 0000 101 0 >> 1 00000 101 5
10 >> 2 0000 101 0 >> 2 000000 10 2
10 << 1 0000 101 0 << 1 000 101 00 20
10 << 2 0000 101 0 << 2 00 101 000 40

"การเลื่อนบิตของตัวเลขไปทางซ้ายด้วย 1 นั้นเหมือนกับการคูณจำนวนด้วย 2 การเลื่อนด้วยสองหลักจะเทียบเท่ากับการคูณด้วย 4 ด้วยสามหลัก - คูณด้วย 8 เป็นต้น"

"การเลื่อนไปทางขวาสอดคล้องกับการหารด้วย 2, 4, 8, 16 ฯลฯ"

"แต่อะไรคือความแตกต่างระหว่างตัวดำเนินการ >>> และ >>"

"ความแตกต่างเมื่อทำงานกับจำนวนลบ นี่เป็นเพราะ  ตัวเลขที่มีเครื่องหมายใช้บิตซ้ายสุดเพื่อระบุเครื่องหมายดังนั้น ตัวเลขที่เป็นลบจะไม่กลายเป็นลบเมื่อเลื่อนไปทางขวา ดังนั้น พวกเขาจึงคิดโอเปอเรเตอร์สองตัวขึ้นมา ตรวจสอบออก:"

การแสดงออก ผลลัพธ์ คำอธิบาย
1 000 1010 >> 1 11,000 101 _ จำนวนลบยังคงเป็นลบ
สำหรับจำนวนลบ บิตที่เข้ามาจะถูกเติมด้วย 1 วินาที
1 000 1010 >> 2 111,000 10 _
1 000 1010 >> 3 1111 000 1
1 000 1010 >>> 1 01 000 101 จำนวนลบไม่เป็นลบอีกต่อไป สำหรับจำนวนลบ บิตที่เข้ามาจะถูกเติมด้วย 0
1 000 1010 >>> 2 001 000 10
1 000 1010 >>> 3 0001 000 1

"การเปลี่ยนแปลงไม่ได้เป็นวงจร บิตที่เคลื่อนเลยขอบซ้ายหรือขวาของตัวเลขจะถูกทิ้งไป"

6) " ผู้ดำเนินการกำหนด "

"ฉันรู้แล้วว่าการมอบหมายคืออะไร แต่ทำไมคุณถึงพูดว่า 'ผู้ดำเนินการ'"

"เพราะมีหลายตัว ☺"

โอเปอเรเตอร์ มันหมายถึงอะไร
a += b; a = a + b;
a -= b; a = a - b;
a *= b; a = a * b;
a %= b; a = a % b;
a |= b; a = a | b;
a &= b; a = a & b;

"ฉันคิดว่าคุณเข้าใจตรรกะ"

7) " ตัวดำเนินการเพิ่มและลด "

สัญกรณ์ ตัวอย่าง คำอธิบาย
++ a++;
++b;		 เพิ่มจำนวนทีละ 1
-- d--;
--i;		 ลดจำนวนหรือตัวแปรลง 1

"มีความแตกต่างระหว่างการใส่เครื่องหมายลบสองตัวก่อนหรือหลังตัวแปรหรือไม่"

"ใช่ มี แม้ว่าจะไม่ใหญ่มาก หากตัวแปรที่มีหนึ่งในตัวดำเนินการเหล่านี้เป็นส่วนหนึ่งของนิพจน์หรือการกำหนด แสดงว่ามีความแตกต่าง ฉันจะแสดงให้คุณเห็นตามตัวอย่าง:"

ตัวอย่าง เกิดอะไรขึ้นจริงๆ คำอธิบาย
int a = 3;
int b = ++a;		 int a = 3;
a = a + 1;
int b = a;		 a จะเพิ่มทีละ 1 ก่อน จากนั้นจึงใช้ในนิพจน์
int a = 3;
int b = a++;		 int a = 3;
int b = a;
a = a + 1;		 a ถูกใช้ครั้งแรกในนิพจน์ จากนั้นจึงเพิ่มขึ้นทีละ 1
int a = 3;
return a++;		 int a = 3;
int result = a;
a = a + 1;
return result;		 ฟังก์ชันจะส่งกลับ 3 แต่ค่าของ a จะเพิ่มขึ้น 1
int x = 5;
x = ++x + ++x;		 int x = 5;
int a = x + 1;// The first term is 6
x = a;
int b = x + 1;// The second term is 7
x = b;
x = a + b;		 ผลลัพธ์ในที่นี้คือ 13 อย่างแรก x จะเพิ่มขึ้น 1 และค่านี้จะแทนที่พจน์แรก แล้ว x จะเพิ่มขึ้นอีก 1 อีกครั้ง

"ว้าว!

"ฉันดีใจที่คุณชอบมัน แต่ถ้าไม่มีการแสดงออกหรือการมอบหมาย ก็ไม่มีความแตกต่าง:"

"x++ เทียบเท่ากับ x = x + 1"

"++x เทียบเท่ากับ x = x + 1"

"ฉันจะจำมันไว้ ขอบคุณ บิลาโบ"

8)  " ตัวดำเนินการแบบไตรภาค "

"ตัวดำเนินการนี้ไม่ได้ใช้เพียงหนึ่งหรือสองตัวแปรหรือนิพจน์ แต่ใช้สามตัวแปรหรือนิพจน์ทั้งหมดพร้อมกัน:"

สัญกรณ์ รหัสเทียบเท่า:
a ? b : c; if (a)
b
else
c
int min = a < b ? a : b; if (a < b)
min = a;
else
min = b;
return a != null ? a.length : 0; if (a != null)
return a.length;
else
return 0;

"อืม สะดวกสุดๆ"

"ใช่ กะทัดรัดและอ่านรหัสได้ ขอให้สนุกกับการใช้มัน!"

9) " อื่นๆ "

"ไม่ว่าคอลเลคชันเพลงของคุณจะจัดระเบียบได้ดีเพียงใด คุณยังคงต้องสร้างโฟลเดอร์ "เบ็ดเตล็ด"

"ใช่ ใครก็ตามที่ต้องจัดหมวดหมู่เพลงจะเห็นด้วยอย่างยิ่ง"

"มีโอเปอเรเตอร์อีกสามคนที่ฉันอยากจะบอกคุณเกี่ยวกับ:"

สัญกรณ์ ตัวอย่าง คำอธิบาย
() (a + b) * c วงเล็บเพิ่มลำดับความสำคัญของตัวดำเนินการ
สิ่งที่อยู่ในวงเล็บจะดำเนินการก่อน
[] c [i] = c [i + 1]; รับองค์ประกอบอาร์เรย์ตามดัชนี
. int n = a.length; " ตัวดำเนินการจุด " เข้าถึงตัวแปรและวิธีการของวัตถุ

"และสุดท้าย นี่คือตารางที่สรุปลำดับความสำคัญของตัวดำเนินการ:"

ผู้ประกอบการ ตัวอย่าง
ลำดับความสำคัญสูงสุด (ตัวดำเนินการจะดำเนินการตามลำดับในตารางนี้)
()
[]
.		 (a + b)
c [i] = c [i] + 1
++
--
~
!
+
-		 i++; ++i;
--j; a--;
~c
!f
return +a;
return -a;
*
/
%		 a * b
c / d
a % b
+
-		 a + b
c - d
String s = "count"+"35";
>>
<<
>>>		 a >> 3
b << 2
c >>> 3
<
<=
>
>=		 a < b
a <= b
c > b
c >= b
==
!=		 a == 3
a != 0
& a & 7
^ a ^ b
| a | b
&& (a < b) && (a < c)
|| (b != 0) || (c != 0)
? : = a > 0 ? a : -a;
=
*=, /=, %=
-=, +=
<<=. >>=, >>>=
&=, ^=. |=
ลำดับความสำคัญต่ำสุด (ดำเนินการล่าสุด)