คำอธิบายโดยละเอียดเกี่ยวกับผู้ประกอบการและการใช้งานใน Java

ในเนื้อหาก่อนหน้านี้ฉันได้เรียนรู้วิธีกำหนดและเริ่มต้นตัวแปร วัตถุประสงค์ของการกำหนดตัวแปรคือการจัดการข้อมูล ภาษา Java ให้สัญลักษณ์รหัสที่ใช้โดยเฉพาะในการใช้งานข้อมูลเหล่านี้เรียกว่า "ตัวดำเนินการ" โดยรวม

ตามการใช้งานของผู้ประกอบการเราสามารถแบ่งพวกเขาออกเป็นหมวดหมู่ต่อไปนี้:

ผู้ประกอบการเลขคณิต

ผู้ดำเนินการที่ได้รับมอบหมาย

ผู้ประกอบการที่เพิ่มขึ้นและลดขนาดตัวเอง

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

ผู้ประกอบการเชิงสัมพันธ์

บิตโอเปอเรเตอร์

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

1. ตัวดำเนินการเลขคณิต

ตัวดำเนินการทางคณิตศาสตร์เป็นการดำเนินการทางคณิตศาสตร์สำหรับการเพิ่มการลบการคูณการหารและการใช้ตัวแปรตัวเลขที่เหลือ:

เพิ่ม: +
ลด:-
เอา:*
ลบ:/
รับสมดุล: %

 ตัวดำเนินการระดับสาธารณะ DEMO {โมฆะคงที่สาธารณะหลัก (สตริง [] args) {int num1 = 100; int num2 = 20; // เพิ่ม system.out.println ("num1 + num2:" + (num1 + num2)); // ลบ System.out.println ("num1 - num2:" + (num1 - num2)); // คูณ System.out.println ("num1 * num2:" + (num1 * num2)); // ส่วนลด System.out.println ("num1 / num2:" + (num1 / num2)); // รับ System.out.println ("num1 % num2:" + (num1 % num2)); -

ผลลัพธ์ผลลัพธ์:

 NUM1 + NUM2: 120NUM1 - NUM2: 80NUM1 * NUM2: 2000NUM1 / NUM2: 5NUM1 % NUM2: 0

2. ผู้ดำเนินการที่ได้รับมอบหมาย

เช่นเดียวกับภาษาการเขียนโปรแกรมส่วนใหญ่ Java ใช้ตัวดำเนินการ '=' เพื่อดำเนินการที่ได้รับมอบหมาย การดำเนินการนี้กำหนดผลการคำนวณทางด้านขวา (เรียกว่า rvalue) ให้กับตัวแปรทางด้านซ้าย ผู้ให้บริการที่ได้รับมอบหมายใน Java รวมถึง:

= (num2 = num1)
+= (num2 += num1 เทียบเท่า num2 = num2 +num1)
-= (num2 -= num1 เทียบเท่า num2 = num2 -num1)
*= (num2 *= num1 เทียบเท่า num2 = num2 *num1)
/= (num2 /= num1 เทียบเท่า num2 = num2 /num1)
%= (num2 %= num1 เทียบเท่า num2 = num2 %num1)

 ตัวดำเนินการระดับสาธารณะ DEMO {โมฆะคงที่สาธารณะหลัก (สตริง [] args) {int num1 = 10; int num2 = 20; num2 = num1; System.out.println ("= เอาต์พุต:"+num2); num2 += num1; System.out.println ("+= เอาต์พุต:"+num2); num2 -= num1; System.out.println ("-= เอาต์พุต:"+num2); num2 *= num1; System.out.println ("*= output:"+num2); num2 /= num1; System.out.println ("/= output:"+num2); num2 %= num1; System.out.println ("%= เอาต์พุต:"+num2); -

ผลลัพธ์ผลลัพธ์:

 = เอาต์พุต: 10+= เอาต์พุต: 20- = เอาต์พุต: 10*= เอาต์พุต: 100/= เอาต์พุต: 10%= เอาต์พุต: 0

3. ผู้ประกอบการที่เพิ่มขึ้นและลดขนาดตัวเอง

ตัวดำเนินการในตัวเองและการสูญเสียตนเองจะทำงานกับตัวแปรเดียวเท่านั้นและค่าของการเปลี่ยนแปลงตัวแปร

NUM ++ (เทียบเท่า num = num+ 1) เพิ่มขึ้นด้วยตัวเองส่วนใหญ่สำหรับตัวแปรตัวเลขเพิ่ม 1 ถึงค่าของตัวแปรของตัวเอง
Num― (เทียบเท่า num = num -1) การลดค่าตัวเองส่วนใหญ่กำหนดเป้าหมายตัวแปรตัวเลขลบค่าของตัวแปรร่างกายโดย 1

 ตัวดำเนินการระดับสาธารณะ DEMO {โมฆะคงที่สาธารณะหลัก (สตริง [] args) {int num1 = 100; int num2 = 200; num1 ++; num2--; System.out.println ("num1 ++ คือ:"+num1); System.out.println ("num2-- คือ:"+num2); -

ผลลัพธ์ผลลัพธ์:

 num1 ++ คือ: 101num2-- คือ: 199

4. ตัวดำเนินการเชิงตรรกะ

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

b1 && b2: ถ้าทั้ง B1 และ B2 เป็นจริง B1 && b2 จะกลับมาเป็นจริงมิฉะนั้นเท็จ

B1 || B2: หากทั้ง B1 และ B2 เป็นเท็จเท็จจะถูกส่งคืนมิฉะนั้นจะถูกส่งคืนจริง

- B1: จะส่งคืนค่าตรงข้ามกับ B1 ถ้า B1 เป็นเท็จกลับมาจริง หาก B1 เป็นจริงให้ส่งคืน FALSE

 ตัวดำเนินการระดับสาธารณะ DEMO {โมฆะคงที่สาธารณะหลัก (สตริง [] args) {บูลีน b1 = true; บูลีน B2 = เท็จ; System.out.println ("b1 && b2:" + (b1 && b2)); System.out.println ("B1 || b2:" + (b1 || b2)); System.out.println ("! (b1 && b2):" +! (b1 && b2)); -

ผลลัพธ์ผลลัพธ์:

 b1 && b2: falseb1 || B2: จริง! (b1 && b2): จริง

ลัดวงจรเชิงตรรกะ:

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

 if (object! = null && object.somefunction ()! = null) {// ทำอะไรบางอย่าง}

หากวัตถุว่างเปล่าวัตถุนิพจน์ส่วนแรก! = null จะกลับมาเป็นเท็จโดยไม่คำนึงถึงผลลัพธ์ของวัตถุนิพจน์ somefunction ()! = null หลังจากตัวดำเนินการ && ตัวดำเนินการค่าสุดท้ายเป็นเท็จ คอมไพเลอร์จะเพิ่มประสิทธิภาพส่วนนี้ของการดำเนินการโดยอัตโนมัติและจะไม่ดำเนินการ object.somefunction ()! = null

5. ผู้ประกอบการเชิงสัมพันธ์

ใช้เพื่อเปรียบเทียบขนาดของข้อมูลตัวแปรสองตัวส่งคืนค่าของบูลีนนั่นคือจริงหรือเท็จ

ผู้ประกอบการเชิงสัมพันธ์รวมถึง:

'==' และ '! =' เหมาะสำหรับค่าและวัตถุทุกประเภท (เช่นตัวแปรประเภทดั้งเดิมและตัวแปรประเภทอ้างอิง)

'>', '<', '> =' และ '<=' ไม่ได้ใช้กับค่าของประเภทบูลีนเพราะพวกเขามีเพียงจริงหรือเท็จและมากกว่าและน้อยกว่าไม่มีความสำคัญในทางปฏิบัติ

 ตัวดำเนินการระดับสาธารณะ DEMO {โมฆะคงที่สาธารณะหลัก (สตริง [] args) {int num1 = 10; int num2 = 50; if (num1 == num2) {system.out.println ("num1 และ num2 มีค่าเท่ากัน"); } else {system.out.println ("num1 และ num2 ไม่เท่ากัน"); } if (num1! = num2) {system.out.println ("num1 และ num2 ไม่เท่ากัน"); } else {system.out.println ("num1 และ num2 ไม่เท่ากัน"); } else {system.out.println ("num1 และ num2 ไม่เท่ากัน"); } equal ");} if (num1> num2) {system.out.println (" num1 มากกว่า num2 ");} else {system.out.println (" num1 ไม่มากกว่า num2 ");} ถ้า (num1> = num2) {system.out.out.print.print. น้อยกว่า num2 ");} ถ้า (num1 <num2) {system.out.println (" num1 น้อยกว่า num2 ");} ถ้า (num1 <num2) {system.out.println (" num1 น้อยกว่า num2 "); System.out.println ("NUM1 น้อยกว่าหรือเท่ากับ num2")} อื่น {system.out.println ("num1 มากกว่า num2");

ผลลัพธ์ผลลัพธ์:

 NUM1 และ NUM2 ไม่เท่ากัน 1 และ NUM2 ไม่เท่ากัน 1 ไม่เกิน NUM2NUM1 น้อยกว่า NUM2NUM1 น้อยกว่า NUM2NUM1 น้อยกว่าหรือเท่ากับ NUM2

6. บิตโอเปอเรเตอร์

วัตถุการดำเนินการที่กำหนดเป้าหมายโดยบิตโอเปอเรเตอร์คือไบนารี "บิต" ซึ่งสามารถนำไปใช้กับประเภทจำนวนเต็ม (int), ยาว, สั้น, ชนิดอักขระ (ถ่าน) และประเภทไบต์ (ไบต์) และประเภทอื่น ๆ ในระหว่างการดำเนินการบิตบิตที่สอดคล้องกัน (0 หรือ 1) จะดำเนินการในการทำงานพีชคณิตบูลีนหรือการดำเนินการเคลื่อนที่

คำอธิบายของตรรกะการคำนวณค่อนข้างคลุมเครือและเราสามารถใช้ตัวอย่างเพื่อทำความเข้าใจได้ชัดเจนยิ่งขึ้นว่าผู้ประกอบการบิตทำการคำนวณอย่างไร สมมติว่าถ้า x เท่ากับ 60; y เท่ากับ 13; การเป็นตัวแทนไบนารีของพวกเขาและผลลัพธ์ของการดำเนินการบิตมีดังนี้:

 x = 0011 1100y = 0000 1101 -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -

สังเกตความแตกต่างระหว่าง >> และ >>>:

ตัวดำเนินการเลื่อนขวา >> หากค่าของการดำเนินการเป็นบวก 0 จะถูกแทรกในตำแหน่งสูง; หากค่าเป็นลบ 1 จะถูกแทรกในตำแหน่งสูง

ย้ายไปทางขวาเพื่อเติมเต็มตัวดำเนินการศูนย์ >>> ใส่ 0 ที่ตำแหน่งสูงโดยไม่คำนึงถึงบวกหรือลบ

> หากคุณไม่เข้าใจการดำเนินการบิตให้ข้ามไปก่อน เมื่อใช้งานจริงคุณสามารถศึกษาได้อีกครั้ง

7. ลำดับความสำคัญของผู้ประกอบการ

ลำดับความสำคัญของผู้ประกอบการกำหนดการจัดกลุ่มของคำศัพท์ในนิพจน์ มันมีผลต่อวิธีการประเมินการแสดงออก ผู้ประกอบการบางรายมีลำดับความสำคัญสูงกว่าผู้ประกอบการอื่น

ตัวอย่างเช่น: ตัวดำเนินการคูณมีลำดับความสำคัญสูงกว่าตัวดำเนินการเพิ่มและนิพจน์ 1 + 5 * 6 ตามลำดับความสำคัญของผู้ประกอบการคอมไพเลอร์จะคำนวณ 5 * 6 ก่อนจากนั้นคำนวณ 30 + 1 และในที่สุดก็รับผลลัพธ์ 31

ลำดับความสำคัญของผู้ให้บริการต่าง ๆ คือจากขนาดใหญ่ถึงขนาดเล็ก:

 ., (), [] monocular +(ขวาไปซ้ายรวมกัน), monocular - (ขวาไปซ้ายรวมกัน), ++, -, ~,!*, /,% +(จากซ้ายไปขวารวมกัน), - (จากซ้ายไปขวา) >>, <<, >>> <, <=,> ==,!

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

8. ผู้ให้บริการอื่น ๆ

ผู้ให้บริการสามทาง:

ตัวดำเนินการแบบมีเงื่อนไขใน Java เป็นตัวดำเนินการที่สามและรูปแบบของมันมีดังนี้:

 BooleanExpression? Valuewhentrue: ValueWhenfalse

หากค่าการแสดงออกของบูลีนเป็นจริงค่าของนิพจน์คือค่าของ valueWhentRue มิฉะนั้นค่าของ valueWhenfalse

ตัวอย่างเช่นหากเราต้องการคำนวณค่าสัมบูรณ์ของ X เราสามารถนำไปใช้ผ่านรหัสต่อไปนี้:

 if (x> = 0) {y = x;} else {y = -x;}

ผ่านตัวดำเนินการ Ternary คุณต้องการเพียงหนึ่งคำสั่ง y = x> = 0? x: -x; เพื่อให้เสร็จสมบูรณ์ซึ่งกระชับมากขึ้น

ประเภทตัวดำเนินการแปลง:

เราใช้การแปลงประเภทในหลายกรณี ในเวลาที่เหมาะสม Java จะแปลงชนิดข้อมูลเป็นแบบอื่นโดยอัตโนมัติตามชนิดข้อมูล ตัวอย่างเช่นหากเรากำหนดค่าจำนวนเต็มให้กับตัวแปรลอยตัวคอมไพเลอร์จะแปลง int เป็นลอยและกำหนดให้กับตัวแปร

อย่างไรก็ตามในหลายกรณี Java ไม่สามารถระบุได้ว่าเราจำเป็นต้องทำการแปลงประเภทหรือไม่ ในเวลานี้เราจำเป็นต้องมีตัวดำเนินการแปลงประเภทซึ่งช่วยให้เราสามารถทำการแปลงประเภทได้อย่างชัดเจนเช่น:

 int a = 10; ยาว b = (ยาว) a; ยาว c = (ยาว) 100;

เราสามารถพิมพ์ทั้งตัวแปรและค่าคงที่

เมื่อทำการแปลงประเภทของหมายเลขลอยตัวเราต้องให้ความสนใจกับปัญหาการตัดทอน หากเราต้องการพิมพ์แปลง 10.9: (int) 10.9 ค่าของมันไม่ได้โค้งมน 11 แต่ 10