ไวยากรณ์ของจาวา โครงสร้างแบบมีเงื่อนไข - วิธีการเริ่มต้นสำหรับอินเทอร์เฟซ

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

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

คุณอาจเคยได้ยินคำว่า "โปรแกรมเขียนขึ้นภายใต้ Windows หรือภายใต้ Linux, Unix" มากกว่าหนึ่งครั้ง ความจริงก็คือสภาพแวดล้อมการเขียนโปรแกรมสำหรับการแปลภาษาการเขียนโปรแกรมเป็นรหัสเครื่องสามารถเป็นได้สองประเภท - คอมไพเลอร์และล่าม การคอมไพล์หรือตีความโปรแกรมระบุว่าโปรแกรมจะทำงานบนอุปกรณ์ต่อไปอย่างไร โปรแกรมที่เขียนด้วยภาษา Java ทำงานบนพื้นฐานของการตีความเสมอ ในขณะที่โปรแกรมที่เขียนด้วย C / C ++ - การรวบรวม ความแตกต่างระหว่างสองวิธีนี้คืออะไร?

คอมไพเลอร์หลังจากเขียนซอร์สโค้ดในขณะที่คอมไพล์แล้ว จะอ่านซอร์สโค้ดทั้งหมดของโปรแกรมทันทีและแปลเป็นรหัสเครื่อง หลังจากที่โปรแกรมมีอยู่โดยรวมและสามารถดำเนินการได้ในนั้นเท่านั้น ระบบปฏิบัติการที่มันเขียน ดังนั้นโปรแกรมที่เขียนภายใต้ Windows จึงไม่สามารถทำงานได้ภายใต้ Linux และในทางกลับกัน ล่ามจะก้าวผ่านหรือดำเนินการทีละบรรทัดของโปรแกรมทุกครั้งที่มีการดำเนินการ ระหว่างการตีความ โค้ดที่รันไม่ได้จะถูกสร้างขึ้น แต่เป็นโค้ดเสมือน ซึ่งถูกรันโดยเครื่องเสมือน Java ในเวลาต่อมา ดังนั้นบนแพลตฟอร์มใด ๆ - Windows หรือ Linux โปรแกรม Java สามารถดำเนินการได้ในลักษณะเดียวกันหากมีเครื่อง Java เสมือนในระบบซึ่งเรียกอีกอย่างว่า Runtime System

การเขียนโปรแกรมเชิงวัตถุ

การเขียนโปรแกรมเชิงวัตถุขึ้นอยู่กับวัตถุซึ่งค่อนข้างคล้ายกับโลกของเรา หากคุณมองไปรอบ ๆ ตัวคุณ คุณจะพบบางสิ่งที่จะช่วยให้คุณเข้าใจรูปแบบการเขียนโปรแกรมดังกล่าวได้ชัดเจนยิ่งขึ้น ตัวอย่างเช่น ตอนนี้ฉันกำลังนั่งอยู่ที่โต๊ะและพิมพ์บทนี้บนคอมพิวเตอร์ที่ประกอบด้วยจอภาพ หน่วยระบบ แป้นพิมพ์ เมาส์ ลำโพง และอื่นๆ ทุกส่วนเหล่านี้เป็นวัตถุที่ประกอบขึ้นเป็นคอมพิวเตอร์ เมื่อทราบสิ่งนี้แล้ว มันง่ายมากที่จะกำหนดแบบจำลองทั่วไปบางประเภทสำหรับการทำงานของคอมพิวเตอร์ทั้งเครื่อง หากคุณไม่เข้าใจความซับซ้อนของคุณสมบัติซอฟต์แวร์และฮาร์ดแวร์ของคอมพิวเตอร์ เราสามารถพูดได้ว่าวัตถุหน่วยระบบดำเนินการบางอย่างที่แสดงโดยวัตถุตรวจสอบ ในทางกลับกัน อ็อบเจ็กต์ Keyboard สามารถแก้ไขหรือตั้งค่าการดำเนินการสำหรับออบเจ็กต์ System unit ที่ส่งผลต่อการทำงานของอ็อบเจ็กต์ Monitor ได้ กระบวนการที่นำเสนอนี้แสดงให้เห็นถึงลักษณะที่ดีของระบบการเขียนโปรแกรมเชิงวัตถุทั้งหมด

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

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

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

ชั้นเรียน

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

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

วิธีการ

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

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

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

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

ไวยากรณ์ Java และความหมาย

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

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

คลาสโฟน
{
รวม () วิธีการ
{
// การดำเนินการเพื่อเปิดโทรศัพท์
}
ปิดการใช้งาน () วิธีการ
{
// การดำเนินการเพื่อปิดโทรศัพท์
}
}

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

ตอนนี้เรามาเขียนคลาสเดียวกันใน Java เท่านั้น

คลาสโทรศัพท์
{
เป็นโมฆะเมื่อ ()
{
// เนื้อหาของ on () วิธีการ
}
ถือเป็นโมฆะ ()
{
// เนื้อหาของ off () method
}
}

คีย์เวิร์ด class ในภาษา Java ประกาศคลาส ตามด้วยชื่อของคลาสเอง ในกรณีของเรา นี่คือโทรศัพท์ เพียงไม่กี่คำเกี่ยวกับการลงทะเบียนบันทึก ในเกือบทุกภาษาโปรแกรม สิ่งสำคัญคือต้องเก็บชื่อไว้ในกรณีที่สร้างชื่อขึ้นมา หากคุณเขียน Telefon การสะกดเช่น telefon หรือ TELefoN จะทำให้เกิดข้อผิดพลาดระหว่างการรวบรวม อย่างที่เขียนไว้แต่แรก จึงต้องเขียนต่อไป

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

มีสองวิธีในเนื้อหาของคลาส Telefon: เปิด () - เปิดโทรศัพท์และปิด () วิธี - ปิดโทรศัพท์ ทั้งสองวิธีมีเนื้อหาของตัวเอง และในทางทฤษฎี ควรมีซอร์สโค้ดบางประเภทที่อธิบายการดำเนินการที่จำเป็นของทั้งสองวิธี สำหรับเราตอนนี้ ไม่ว่าวิธีการเหล่านี้จะถูกนำไปใช้อย่างไร สิ่งสำคัญคือไวยากรณ์ของภาษา Java

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

ความคิดเห็น (1)

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

ความคิดเห็นใน Java สามารถมีได้สามประเภท ได้แก่:

//, /*…*/ และ /**…*/

ความคิดเห็นที่เขียนโดยใช้ตัวดำเนินการ // ต้องอยู่ในบรรทัดเดียว:

// หนึ่งบรรทัด
!!! ข้อผิดพลาด! คุณไม่สามารถตัดไปยังบรรทัดที่สองได้!
// เส้นแรก
// บรรทัดที่สอง
// …
//บรรทัดสุดท้าย

ความคิดเห็นโดยใช้ตัวดำเนินการ / *… * / สามารถขยายได้หลายบรรทัด ที่จุดเริ่มต้นของความคิดเห็นของคุณให้ใส่ / * และเมื่อสิ้นสุดการแสดงความคิดเห็นโค้ด ให้ใส่เครื่องหมาย * / ความคิดเห็นแบบสุดท้าย / ** ... * / ใช้สำหรับบันทึกโค้ดและระบุตำแหน่งได้หลายบรรทัด

ประเภทข้อมูล Java

ชนิดข้อมูลมีอยู่ใน Java เพื่อตั้งค่าตามอำเภอใจ ในคลาส Telefon เราได้สร้างสองวิธี ทั้งสองวิธีไม่มีพารามิเตอร์ แต่เมื่อให้ตัวอย่างของวิธี on (int time) พร้อมพารามิเตอร์เวลา มีการกล่าวถึงการส่งค่าไปยังวิธีการ ค่านี้ระบุเวลาที่ควรจะเปิดโทรศัพท์ ตัวระบุ int กำหนดประเภทของค่าเวลา Java 2 ME มีข้อมูลหกประเภท

ไบต์ - ค่าจำนวนเต็มขนาดเล็กจาก –128 ถึง 128;
ค่าจำนวนเต็มสั้น - สั้นในช่วงตั้งแต่ –32768 ถึง 32767;
int - มีค่าจำนวนเต็มตั้งแต่ –2147483648 ถึง 2147483647
long เป็นค่าจำนวนเต็มที่มีขนาดใหญ่มาก ตั้งแต่ –922337203685475808 ถึง 9223372036854775807
char คือค่าคงที่อักขระ Unicode พิสัย รูปแบบนี้จาก 0 ถึง 65536 ซึ่งเท่ากับ 256 อักขระ อักขระประเภทนี้ต้องเขียนด้วยเครื่องหมายคำพูดเดี่ยว เช่น 'G';
บูลีน - ประเภทบูลีน มีเพียงสองค่า: เท็จ - เท็จ และ จริง - จริง ประเภทนี้มักจะใช้ในลูปซึ่งในภายหลัง แนวคิดนี้ง่ายมาก - หากคุณมีเงินอยู่ในกระเป๋า น่าจะเป็นเรื่องจริง และถ้าไม่ใช่ แสดงว่าเป็นเท็จ ดังนั้น ถ้ามีเงิน เราก็ไปที่ร้านเพื่อซื้อขนมปังหรือเบียร์ (ขีดเส้นใต้ว่าจำเป็น) ถ้าไม่มีเงิน เราก็อยู่บ้าน นั่นคือมันเป็นค่าตรรกะที่มีส่วนช่วยในการเลือก การดำเนินการต่อไปโปรแกรมของคุณ

ในการประกาศค่าที่จำเป็น จะใช้รายการต่อไปนี้:

ทันเวลา;
BigTime ยาว;
คำถ่าน;

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

Mt เวลา, เวลา 1, เวลา 2;

ตอนนี้มาปรับปรุงคลาส Telefon ของเราโดยเพิ่มค่าบางอย่างลงไป เราไม่ต้องการวิธีการ on () และ off () อีกต่อไป เราจะเพิ่มวิธีการใหม่ๆ ที่สามารถแก้ปัญหาบางอย่างได้จริงๆ

คลาสโทรศัพท์
{
// S - พื้นที่แสดงผล
// w - ความกว้างของการแสดงผล
// h - แสดงความสูง
int w, h, S;
// วิธีการคำนวณพื้นที่แสดงผล
พื้นที่ vord ()
{
S = w * h;
}
}

ดังนั้นเราจึงมีตัวแปรสามตัว S, w และ h ซึ่งรับผิดชอบตามลำดับสำหรับพื้นที่ ความกว้าง และความสูงของจอแสดงผลเป็นพิกเซล วิธีการ Area () คำนวณพื้นที่ของหน้าจอโทรศัพท์เป็นพิกเซล การดำเนินการนั้นไร้ประโยชน์ แต่บ่งบอกถึงและเข้าใจง่ายมาก เนื้อความของวิธี Area () ได้รับมาเองและมีรูปแบบ S = w * h ในวิธีนี้เราเพียงแค่คูณความกว้างด้วยความสูงและกำหนดหรือตามที่พวกเขาพูดเก็บผลลัพธ์ไว้ในตัวแปร S ตัวแปรนี้จะมีค่าของพื้นที่แสดงผล โทรศัพท์เครื่องนี้.

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

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

ตัวดำเนินการเลขคณิตทั้งหมดนั้นง่ายมากและคล้ายกับตัวดำเนินการสำหรับการคูณ "*", การหาร "/", การบวก "+" และการลบ "-" ที่ใช้ในวิชาคณิตศาสตร์ มีโอเปอเรเตอร์โมดูโล "%" และสถานการณ์ที่มีโอเปอเรเตอร์เท่ากับ "=" ทำให้สับสนเล็กน้อยในแวบแรก ตัวดำเนินการเท่ากับในภาษาโปรแกรมเรียกว่าตัวดำเนินการมอบหมาย:

ที่นี่คุณกำหนดค่า 3 ให้กับตัวแปร x และตัวดำเนินการ "เท่ากับ" ในภาษาการเขียนโปรแกรมสอดคล้องกับการเขียนตัวดำเนินการสองตัวที่ต่อเนื่องกัน "เท่ากับ": "==" ลองดูตัวอย่างว่าตัวดำเนินการเลขคณิตต่างๆ ทำอะไรได้บ้าง

Int x, y, z;
x = 5;
y = 3;
z = 0;
z = x + y;

ในกรณีนี้ z จะมีค่าของผลรวมของ x และ y นั่นคือ 8

ตัวแปร x มีค่าเท่ากับ 5 แต่หลังจากบันทึกดังกล่าว ค่าก่อนหน้าจะหายไปและเขียนผลคูณ z * x (8 * 5) ซึ่งเท่ากับ 40 ตอนนี้ หากเราดำเนินการโค้ดของเราต่อไป ตัวแปรจะ มีลักษณะดังนี้:

// x = 40;
// y = 3;
// z = 8;

ตัวดำเนินการบวกและลบมีจุดประสงค์เดียวกับในวิชาคณิตศาสตร์ ตัวเลขติดลบมีความเกี่ยวข้องในทำนองเดียวกัน

ตัวดำเนินการลดค่า “––” และตัวดำเนินการเพิ่มค่า “++” มีความเฉพาะเจาะจงมาก แต่ง่ายมาก มีบ่อยครั้งในการเขียนโปรแกรมเมื่อคุณต้องการเพิ่มหรือลดค่าหนึ่งค่า นี้มักจะพบในลูป การดำเนินการที่เพิ่มขึ้นจะเพิ่มตัวแปรทีละตัว

Int x = 5;
x ++;
// นี่ x อยู่แล้ว 6

การดำเนินการลดจะลดตัวแปรลงหนึ่งตัว

Int x = 5;
x--;
// x คือ 4

การดำเนินการเพิ่มและลดลงสามารถโพสต์และนำหน้าได้:

Int x = 5;
int y = 0;
y = x ++;

ในบรรทัดสุดท้ายของโค้ด ขั้นแรกให้กำหนดค่า x ให้กับ y นี่คือค่า 5 จากนั้นตัวแปร x จะเพิ่มขึ้นหนึ่งค่าเท่านั้น ปรากฎว่า:

การเพิ่มคำนำหน้าคือ:

Int x = 3;
int y = 0;
y = ++ x;

และในกรณีนี้ ขั้นแรก ตัวแปร x จะเพิ่มขึ้นหนึ่ง จากนั้นจึงกำหนดค่าที่เพิ่มขึ้นแล้วให้กับ y

ตัวดำเนินการเชิงสัมพันธ์

ตัวดำเนินการความสัมพันธ์ช่วยให้คุณตรวจสอบความเท่าเทียมกันของทั้งสองส่วนของนิพจน์ได้ มีโอเปอเรเตอร์ความเท่าเทียมกัน "==" ตัวดำเนินการน้อยกว่า "<» и больше «>" น้อยกว่าหรือเท่ากับ "<=» и больше или равно «>= ", เช่นเดียวกับตัวดำเนินการปฏิเสธ"! = ".
9 == 10;

นิพจน์นี้ไม่เป็นความจริง เก้าไม่เท่ากับสิบ ดังนั้นค่าของนิพจน์นี้จึงเป็นเท็จ

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

ตัวดำเนินการลอจิก

มีตัวดำเนินการเชิงตรรกะสองตัว ตัวดำเนินการ AND แทนด้วย && และตัวดำเนินการ OR แทนด้วยเครื่องหมายทับ "||" สองตัว ตัวอย่างเช่น มีนิพจน์:

เอ * บี && บี * C;

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

เอ * บี || บี * ซี;

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

เอ * บี || B * C && C * D || บี * เอ;

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

, ., (),
!, ~, ++, - -, + (unary), - (unary), ใหม่,
*, /, %,
+, –,
<<, >>, >>>,
<, <=, >, >=,
= =, !=,
&, ^, |,
&&,
||,
?:,
=, +=, –=, *=, /=, %=, |=, ^=, <<=, >>=, >>>=.

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

ไม่พบคำตอบสำหรับคำถามของคุณ? ดูที่นี่

ทำไมหน้าจอสีน้ำเงินเปิดบน iPhone หน้าจอสีน้ำเงินบน iPhone 5s ต้องทำอย่างไร

ทุกสิ่งที่คุณจำเป็นต้องรู้เกี่ยวกับ Apple Music

วิธีตั้งค่า iPhone เหมือนใหม่จากศูนย์ - คำแนะนำโดยละเอียด