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

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

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





จำนวนตัวถูกดำเนินการที่ตัวดำเนินการใช้เป็นตัวกำหนดประเภทของตัวถูกดำเนินการ โอเปอเรเตอร์ที่รับตัวถูกดำเนินการหนึ่งตัวเรียกว่า 'unary' ตัวดำเนินการที่ใช้ตัวถูกดำเนินการสองตัวเรียกว่า 'ไบนารี'



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





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

ใช้เพื่อสร้างคำสั่งเชิงตรรกะขณะเขียนโปรแกรม มีตัวดำเนินการเชิงตรรกะหกตัวใน Java ตารางด้านล่างสรุปพวกเขา

โอเปอเรเตอร์ชื่อพิมพ์
|ตรรกะบูลีนORไบนารี่
&ตรรกะบูลีนและไบนารี่
^Boolean Logical Exclusive ORไบนารี่
||OR . แบบมีเงื่อนไขไบนารี่
&&เงื่อนไขและไบนารี่
!ตรรกะไม่อูนารี

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



การรวมตรรกะบูลีนหรือ (|)

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

if ( dob <2005 | height <= 5){
money++;
}

ตัวอย่างข้างต้นจะให้เงินแก่ใครบางคนมากขึ้นหากวันเกิดของพวกเขา (dob) น้อยกว่า 2005 หรือถ้าความสูงของพวกเขาน้อยกว่าหรือเท่ากับ 5 ฟุต



ตรรกะบูลีนและ (&)

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

ที่เกี่ยวข้อง: วิธีตรวจสอบสตริงโดยใช้วิธีบูลีนใน Python



Boolean Logical Exclusive หรือ (^)

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

การแสดงออก1การแสดงออก2นิพจน์1 ^ นิพจน์2
เท็จเท็จเท็จ
เท็จจริงจริง
จริงเท็จจริง
จริงจริงเท็จ

เงื่อนไขบูลีนและ (&&)

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

หากพบว่าส่วนซ้ายเป็นเท็จ การดำเนินการจะหยุดทันที มิฉะนั้น การประเมินส่วนที่ถูกต้องจะดำเนินต่อไป คุณลักษณะนี้เรียกว่าการประเมินการลัดวงจร

ดูตารางความจริงด้านล่างเพื่อทำความเข้าใจโอเปอเรเตอร์นี้

การแสดงออก1การแสดงออก2นิพจน์1 && นิพจน์2
เท็จเท็จเท็จ
เท็จจริงเท็จ
จริงเท็จเท็จ
จริงจริงจริง

เงื่อนไขหรือ (||)

หากเงื่อนไขใดเงื่อนไขหนึ่งเป็นเท็จ การดำเนินการจะข้ามไปยังส่วนถัดไปของโปรแกรม กล่าวอีกนัยหนึ่งเงื่อนไขทั้งสองจะต้องเป็นจริง

โอเปอเรเตอร์นี้คล้ายกับ Logical OR นอกจากนี้ยังตรวจสอบว่าเงื่อนไขใดเงื่อนไขหนึ่งหรือทั้งสองเป็นจริงก่อนที่จะรันโค้ดบางตัว

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

ที่เกี่ยวข้อง: ตัวสร้างใน Java คืออะไรและคุณใช้งานอย่างไร?

วอลล์เปเปอร์สด hd ที่ดีที่สุดสำหรับ android

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

ตรรกะไม่ (!)

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

if(!(x>5)){
// statements
}

ข้อความข้างต้นหมายความว่าถ้า 'x มากกว่า 5' ไม่เป็นความจริง ให้ดำเนินการคำสั่งภายใน ถ้า .

สังเกตการใช้วงเล็บเหลี่ยมกับนิพจน์ (x>5) หากคุณไม่ได้ใส่วงเล็บเหล่านี้ขณะเขียนโปรแกรม คุณจะได้รับข้อผิดพลาดในการคอมไพล์ สาเหตุก็เพราะ ! เป็นตัวดำเนินการเอกพจน์ที่ทำหน้าที่ในเงื่อนไข หากไม่มีวงเล็บ คอมไพเลอร์จะตีความว่าเป็นโอเปอเรเตอร์ที่ดำเนินการกับ x ไม่ใช่ x>5

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

age >= 7 && height <5

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

(age >= 7) && (height <5)

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

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

โอเปอเรเตอร์ชื่อ
>มากกว่า
<น้อยกว่า
> =มากกว่าหรือเท่ากับ
<=น้อยกว่าหรือเท่ากับ

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

if( x <= 7 ){
x++;
}

ข้างบน ถ้า คำสั่งตรวจสอบว่า x น้อยกว่าหรือเท่ากับ 7 หรือไม่ ถ้าเป็นจริง คำสั่งในวงเล็บจะดำเนินการ มิฉะนั้น จะไม่ทำ

ตอนนี้เป็นเวลาที่ดีที่จะพูดถึงตัวดำเนินการความเท่าเทียมกัน มีเพียงสองคนเท่านั้น (เท่ากับ == และ != ไม่เท่ากับ ) ตามชื่อของมัน พวกมันถูกใช้เพื่อทดสอบความเท่าเทียมกันระหว่างตัวถูกดำเนินการสองตัว

ที่เกี่ยวข้อง: วิธีสร้างและดำเนินการกับอาร์เรย์ใน Java

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

ตัวดำเนินการกำหนด (=) กำหนดค่าให้กับตัวแปรในขณะที่ตัวดำเนินการความเท่าเทียมกัน (==) ทดสอบความเท่าเทียมกัน ดูตัวอย่างด้านล่างเพื่อทำความเข้าใจความแตกต่าง:

if(x=5){
// statements
}

โค้ดด้านบนจะทำงานเสมอโดยไม่คำนึงว่า x จะเท่ากับ 5 จริงหรือไม่ ในขณะเดียวกันโค้ดด้านล่างจะทำงานก็ต่อเมื่อ x เท่ากับ 5 เท่านั้น ดังนั้นจึงเป็นเรื่องสำคัญที่จะไม่ผสมทั้งสองอย่างเข้าด้วยกัน

if(x==5){
// statements
}

ตัวดำเนินการความเท่าเทียมกันทั้งสองที่กล่าวถึงมีลำดับความสำคัญเท่ากัน แม้ว่าจะต่ำกว่าตัวดำเนินการเชิงสัมพันธ์

ตัวดำเนินการเชิงสัมพันธ์ก็มีระดับความสำคัญเท่ากันเช่นกัน การดำเนินการของตัวดำเนินการเหล่านี้เริ่มต้นจากซ้ายไปขวา

ข้อควรพิจารณาเพิ่มเติมของตัวดำเนินการ Java

คุณต้องสังเกตว่ามีช่องว่างระหว่างโอเปอเรเตอร์บางตัวกับตัวถูกดำเนินการในตัวอย่างบางตัว ขณะที่ตัวดำเนินการอื่นๆ ไม่มี

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

Y>=7 // no whitespace
Y >= 7 // with whitespace

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

สิ่งสำคัญคือต้องสังเกตว่าตัวดำเนินการเชิงตรรกะ ( |, &, ^) สามารถเป็นตัวดำเนินการระดับบิตได้เมื่อมีตัวถูกดำเนินการรวม เมื่อใช้เป็นโอเปอเรเตอร์ระดับบิต พวกมันจะทำงานบนบิตของตัวถูกดำเนินการ

ด้วยความรู้เกี่ยวกับโอเปอเรเตอร์นี้ คุณควรพร้อมที่จะเรียนรู้คลาส Java

แบ่งปัน แบ่งปัน ทวีต อีเมล เรียนรู้วิธีสร้างคลาสใน Java

หากคุณกำลังเรียนรู้การเขียนโปรแกรมใน Java คุณจะต้องรู้วิธีสร้างคลาส

อ่านต่อไป หัวข้อที่เกี่ยวข้อง
  • การเขียนโปรแกรม
  • Java
  • บทเรียนการเข้ารหัส
เกี่ยวกับผู้เขียน เจอโรม เดวิดสัน(ตีพิมพ์บทความ 22 บทความ)

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

เพิ่มเติมจาก Jerome Davidson

สมัครรับจดหมายข่าวของเรา

เข้าร่วมจดหมายข่าวของเราสำหรับเคล็ดลับทางเทคนิค บทวิจารณ์ eBook ฟรี และดีลพิเศษ!

คลิกที่นี่เพื่อสมัครสมาชิก