คอมพิวเตอร์ Windows อินเทอร์เน็ต
ขยาย
บ้าน ›

ไวยากรณ์หน้า JSP โครงสร้างแบบมีเงื่อนไข

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

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

คุณอาจเคยได้ยินคำว่า "โปรแกรมเขียนขึ้นภายใต้ 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 ในตอนนี้ เราจะเขียนคลาส 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;
NS--;
// 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" อย่างไร้ประโยชน์

A * B || บี * ซี;

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

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

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

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

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

เพจ JSP มีไวยากรณ์ที่รวมกัน: การรวมกันของไวยากรณ์มาตรฐานที่สอดคล้องกับข้อกำหนด HTML และไวยากรณ์ JSP ที่กำหนดโดยข้อมูลจำเพาะ Java Server Pages ไวยากรณ์ JSP กำหนดกฎสำหรับการเขียนหน้า JSP ซึ่งประกอบด้วยแท็ก HTML มาตรฐานและแท็ก JSP หน้า JSP นอกจากแท็ก HTML แล้ว ยังมีแท็ก JSP ในหมวดหมู่ต่อไปนี้:

คำสั่ง JSP

คำสั่งให้ข้อมูลทั่วโลกเกี่ยวกับคำขอเฉพาะไปยัง JSP และให้ข้อมูลที่จำเป็นในระหว่างขั้นตอนการแปล

คำสั่งจะถูกวางไว้ที่จุดเริ่มต้นของหน้า JSP ก่อนแท็กอื่นๆ ทั้งหมด ดังนั้น พาร์เซอร์(parser) JSP เมื่อแยกวิเคราะห์ข้อความที่จุดเริ่มต้น เน้นคำสั่งส่วนกลาง ดังนั้น JSP Engine (รันไทม์ JSP) จะแยกวิเคราะห์โค้ดและสร้างเซิร์ฟเล็ตจาก JSP คำสั่งเป็นข้อความที่ส่งไปยังคอนเทนเนอร์ JSP ไวยากรณ์ คำสั่ง JSP มีลักษณะดังนี้:

<%@ директива имяАтрибута="значение" %>ไวยากรณ์งาน คำสั่งใน XML: คำสั่งสามารถมีคุณลักษณะหลายอย่าง ในกรณีนี้ คำสั่งสามารถทำซ้ำได้สำหรับแต่ละแอตทริบิวต์ ในขณะเดียวกันคู่รัก "ชื่อแอตทริบิวต์ = ค่า"สามารถวางไว้ภายใต้คำสั่งเดียวโดยมีช่องว่างเป็นตัวคั่น คำสั่งมีสามประเภท:

  • หน้า (หน้า)
  • taglib (ไลบรารีแท็ก)
  • รวม (รวม)

คำสั่งหน้า

คำสั่ง หน้าหนังสือกำหนดคุณสมบัติ หน้า JSPที่ส่งผลต่อนักแปล ลำดับของคุณลักษณะในคำสั่ง หน้าหนังสือไม่เป็นไร. การละเมิดไวยากรณ์หรือการมีอยู่ของแอตทริบิวต์ที่ไม่รู้จักส่งผลให้เกิดข้อผิดพลาดในการแปล ตัวอย่างของคำสั่ง หน้าหนังสือรหัสต่อไปนี้สามารถให้บริการ:<%@ page buffer="none" isThreadSafe="yes" errorPage="/error.jsp" %>คำสั่งนี้ประกาศว่า หน้านี้ JSP ไม่ใช้การบัฟเฟอร์ ซึ่งเป็นไปได้สำหรับผู้ใช้จำนวนมากที่จะเข้าถึงหน้า JSP ที่ระบุพร้อมกัน และหน้าแสดงข้อผิดพลาดที่ชื่อว่า error.jsp.
คำสั่ง หน้าหนังสืออาจมีข้อมูลเกี่ยวกับหน้า:<%@ page info = "JSP Sample 1" %>รายการแอตทริบิวต์คำสั่งที่เป็นไปได้ หน้าหนังสือนำเสนอในตาราง
ชื่อแอตทริบิวต์ความหมาย คำอธิบาย
ภาษา เส้น กำหนดภาษาที่ใช้ในสคริปต์เล็ตไฟล์ JSP นิพจน์ หรือไฟล์ที่รวมไว้ รวมถึงเนื้อหาของโค้ดที่แปลแล้ว ค่าเริ่มต้นคือ "java"
ยืดออก เส้น ระบุซูเปอร์คลาสสำหรับเซิร์ฟเล็ตที่สร้างขึ้น แอตทริบิวต์นี้ควรใช้อย่างระมัดระวัง เนื่องจากเป็นไปได้ว่าเซิร์ฟเวอร์กำลังใช้ซูเปอร์คลาสอยู่แล้ว
นำเข้า เส้น คำจำกัดความของแพ็คเกจที่จะนำเข้า เช่น
& lt% @ การนำเข้าหน้า = "java.util. *%>
การประชุม จริงหรือเท็จ ความหมาย จริง(ค่าเริ่มต้น) ระบุว่าตัวแปรที่กำหนดไว้ล่วงหน้า การประชุม(ประเภท HttpSession) ต้องถูกผูกไว้กับเซสชันที่มีอยู่ หากมี มิฉะนั้น เซสชันใหม่จะถูกสร้างขึ้นและผูกไว้ ความหมาย เท็จกำหนดว่าจะไม่ใช้เซสชันและพยายามเข้าถึงตัวแปร การประชุมจะทำให้เกิดข้อผิดพลาดเมื่อแปลหน้า JSP เป็น servlet
กันชน ไม่มีหรือขนาดของบัฟเฟอร์ในหน่วย kB ตั้งค่าขนาดบัฟเฟอร์สำหรับ JspWriter ค่าเริ่มต้นขึ้นอยู่กับการตั้งค่าเซิร์ฟเวอร์และไม่ควรเกิน 8 kB ถ้าค่าเป็น ไม่มีเอาต์พุตไปที่วัตถุโดยตรง
ออโต้ฟลัช จริงหรือเท็จ กำหนดว่าควรล้างบัฟเฟอร์โดยอัตโนมัติเมื่อล้นหรือเกิดข้อผิดพลาด ค่าเริ่มต้นคือ จริง
isThreadSafe จริงหรือเท็จ ความหมาย จริง(ค่าดีฟอลต์) ระบุโหมดการดำเนินการปกติของเซิร์ฟเล็ต โดยที่คำขอหลายรายการได้รับการประมวลผลพร้อมกันโดยใช้อินสแตนซ์เซิร์ฟเล็ตตัวเดียว สมมติว่าผู้เขียนได้ซิงโครไนซ์การเข้าถึงตัวแปรของอินสแตนซ์นั้น ค่าเท็จส่งสัญญาณว่าเซิร์ฟเล็ตควรสืบทอด SingleThreadModel(โมเดลเธรดเดียว) โดยที่การร้องขอแบบต่อเนื่องหรือพร้อมกันได้รับการจัดการโดยอินสแตนซ์ที่แยกจากกันของเซิร์ฟเล็ต
ข้อมูล เส้น กำหนดสตริงของข้อมูลเกี่ยวกับหน้า JSP ที่จะเข้าถึงได้โดยใช้เมธอด Servlet.getServletInfo ()
errorPage เส้น ค่าแอตทริบิวต์คือ URL ของหน้าที่ควรจะแสดงในเหตุการณ์ ความผิดพลาดที่เป็นไปได้โยนข้อยกเว้น
isErrorPage จริงหรือเท็จ ส่งสัญญาณว่าสามารถใช้หน้านี้เพื่อจัดการข้อผิดพลาดสำหรับหน้า JSP อื่นๆ ได้หรือไม่ ค่าเริ่มต้นคือ เท็จ
ชนิดของเนื้อหา เส้น ระบุการเข้ารหัสสำหรับเพจ JSP และการตอบกลับ และประเภท MIME ของการตอบกลับ JSP ค่าเริ่มต้นของประเภทเนื้อหาคือ ข้อความ / html, การเข้ารหัส - ISO-8859-1ตัวอย่างเช่น:
contentType = "ข้อความ / html; ชุดอักขระ = ISO-8859-1"
การเข้ารหัสหน้า เส้น กำหนดการเข้ารหัสอักขระของเพจ JSP ค่าเริ่มต้นคือ ชุดอักขระจากแอตทริบิวต์ ชนิดของเนื้อหาหากมีการกำหนดไว้ที่นั่น ถ้าค่า ชุดอักขระในแอตทริบิวต์ ชนิดของเนื้อหา undefined ค่า การเข้ารหัสหน้ามีค่าเท่ากัน ISO-8859-1

คำสั่ง Taglib

คำสั่ง taglibประกาศว่าหน้า JSP ที่กำหนดใช้ไลบรารีแท็ก ระบุหน้า JSP โดยไม่ซ้ำกันด้วย URI และจับคู่คำนำหน้าแท็กที่ไลบรารีสามารถดำเนินการได้ หากคอนเทนเนอร์ไม่พบไลบรารีแท็ก จะเกิดข้อผิดพลาดในการแปลที่ร้ายแรง คำสั่ง taglibมีไวยากรณ์ต่อไปนี้:<%@ taglib uri="URI ของไลบรารีแท็กรวม"คำนำหน้า =" คำนำหน้าชื่อ"%> คำนำหน้า" คำนำหน้าชื่อ"ใช้อ้างอิงถึงห้องสมุด ตัวอย่างการใช้ tag library mytags: <%@ taglib uri="http://www.taglib/mytags" prefix="customs" %> . . . วี ตัวอย่างนี้ไลบรารีแท็กมี URI "http: //www.taglib/mytags", สตริงถูกกำหนดเป็นคำนำหน้า ศุลกากรที่ใช้ในหน้า JSP เมื่อเข้าถึงองค์ประกอบของไลบรารีแท็ก

รวมคำสั่ง

คำสั่ง รวมอนุญาตให้คุณแทรกข้อความหรือโค้ดขณะแปลเพจ JSP เป็นเซิร์ฟเล็ต ไวยากรณ์คำสั่ง รวมมีลักษณะดังนี้:<%@ include file="URI สัมพัทธ์ของเพจที่จะรวม"%> คำสั่ง รวมมีหนึ่งคุณลักษณะ - ไฟล์... ซึ่งจะรวมข้อความของทรัพยากรที่ระบุในไฟล์ JSP คำสั่งนี้สามารถใช้เพื่อวางส่วนหัวลิขสิทธิ์มาตรฐานบนทุกหน้า JSP:<%@ include file="copyright.html" %>คอนเทนเนอร์ JSP เข้าถึงไฟล์รวม หากไฟล์รวมมีการเปลี่ยนแปลง คอนเทนเนอร์สามารถคอมไพล์หน้า JSP ใหม่ได้ คำสั่ง รวมถือว่าทรัพยากร เช่น หน้า JSP เป็นวัตถุแบบคงที่ URI ที่ให้มามักจะถูกตีความโดยสัมพันธ์กับ JSP ของหน้าเว็บที่มีลิงก์ แต่เช่นเดียวกับ URI ที่เกี่ยวข้อง คุณสามารถบอกระบบถึงตำแหน่งของทรัพยากรที่น่าสนใจซึ่งสัมพันธ์กับโฮมไดเร็กทอรีของเว็บเซิร์ฟเวอร์โดยนำหน้า URI ที่มีอักขระ "/" เนื้อหาของไฟล์รวมถือเป็นข้อความ JSP ธรรมดา ดังนั้นจึงสามารถรวมองค์ประกอบต่างๆ เช่น HTML แบบคงที่ องค์ประกอบสคริปต์ คำสั่ง และการดำเนินการได้ เว็บไซต์หลายแห่งใช้แถบนำทางขนาดเล็กในทุกหน้า เนื่องจากปัญหาในการใช้เฟรม HTML งานนี้จึงมักแก้ไขได้ด้วยการวางตารางขนาดเล็กไว้ด้านบนหรือด้านซ้ายของหน้า ซึ่งโค้ด HTML จะถูกทำซ้ำหลายครั้งในแต่ละหน้าของเว็บไซต์ คำสั่ง รวม- นี่เป็นวิธีที่เป็นธรรมชาติที่สุดในการแก้ปัญหานี้ ซึ่งช่วยให้นักพัฒนาพ้นจากฝันร้ายของกิจวัตรในการคัดลอก HTML ลงในแต่ละไฟล์ที่แยกจากกัน เนื่องจากคำสั่ง รวมรวมไฟล์ระหว่างการแปลหน้า จากนั้นหลังจากทำการเปลี่ยนแปลงแถบนำทางแล้ว ต้องทำการแปลหน้า JSP ทั้งหมดอีกครั้งโดยใช้มัน หากไฟล์แนบเปลี่ยนค่อนข้างบ่อย คุณสามารถใช้การกระทำได้ jsp: รวมที่เชื่อมต่อไฟล์เมื่อเข้าถึงหน้า JSP

ประกาศ JSP

ประกาศ (ประกาศ)มีไว้สำหรับกำหนดตัวแปรและเมธอดในภาษาสคริปต์ ซึ่งจะใช้ในหน้า JSP ในภายหลัง ไวยากรณ์ ประกาศมีลักษณะดังนี้:<%! код Java %> โฆษณาอยู่ในบล็อกการประกาศและถูกเรียกในบล็อกนิพจน์ของหน้า JSP รหัสในบล็อกการประกาศมักจะเขียนด้วยภาษาจาวา แต่เซิร์ฟเวอร์แอปพลิเคชันสามารถใช้ไวยากรณ์ของสคริปต์อื่นได้ โฆษณาบางครั้งใช้เพื่อเพิ่มฟังก์ชันการทำงานเพิ่มเติมเมื่อทำงานกับข้อมูลไดนามิกที่ได้รับจากคุณสมบัติของคอมโพเนนต์ JavaBeans ตัวอย่างของ โฆษณาถูกนำเสนอในตาราง ประกาศสามารถมีได้หลายบรรทัด เช่น ในโค้ดด้านล่างสำหรับคำนวณค่าของฟังก์ชัน ความจริง (int n)ซึ่งควรเท่ากับ 1 เมื่อ n น้อยกว่า 2 และ n! ด้วยค่าบวกของ n;<%! public static int fact (int n) { if (n โฆษณาห้ามสร้างเอาต์พุตใด ๆ ให้เป็นเอาต์พุตมาตรฐาน ออก... ตัวแปรและวิธีการประกาศใน ประกาศถูกเตรียมใช้งานและพร้อมใช้งานสำหรับสคริปต์เล็ตและอื่น ๆ โฆษณาในขณะที่หน้า JSP ถูกเตรียมใช้งาน

JSP Scriptlets

สคริปต์รวมโค้ดต่างๆ ที่เขียนด้วยภาษาสคริปต์ที่กำหนดไว้ใน directive ภาษา... ข้อมูลโค้ดต้องสอดคล้องกับโครงสร้างวากยสัมพันธ์ของภาษา สคริปต์กล่าวคือ โดยปกติแล้ว ไวยากรณ์ของภาษา Java สคริปต์มีไวยากรณ์ต่อไปนี้:<% текст скриптлета %>เทียบเท่าไวยากรณ์ scriptletสำหรับ XML คือ: ข้อความสคริปต์
ถ้าอยู่ในข้อความ scriptletจำเป็นต้องใช้ลำดับของตัวอักษร%> เหมือนกับการรวมกันของอักขระและไม่ใช่เป็นแท็ก - เครื่องหมายสิ้นสุด scriptletแทนที่จะใช้ลำดับ%> ให้ใช้อักขระ% \> ต่อไปนี้รวมกัน
ข้อกำหนด JSP ให้ตัวอย่างที่ง่ายและตรงไปตรงมา scriptletที่เปลี่ยนแปลงเนื้อหาของหน้า JSP แบบไดนามิกตลอดทั้งวัน<% if (Calendar.getInstance ().get (Calendar.AM_PM) == Calendar.AM) {%>สวัสดีตอนเช้า<% } else { %>สวัสดีตอนบ่าย<% } %>ควรสังเกตว่ารหัสภายใน scriptletแทรกตามที่เขียนและข้อความ HTML แบบคงที่ทั้งหมด (ข้อความเทมเพลต) ก่อนหรือหลัง scriptletแปลงโดยใช้ตัวดำเนินการ พิมพ์... ซึ่งหมายความว่าสคริปต์เล็ตไม่จำเป็นต้องมีชิ้นส่วน Java ที่สมบูรณ์ และการปล่อยให้ชิ้นส่วนที่เปิดอยู่อาจส่งผลต่อ HTML แบบคงที่ภายนอก scriptlet. สคริปต์มีสิทธิ์เข้าถึงตัวแปรที่กำหนดอัตโนมัติเหมือนกับนิพจน์ ตัวอย่างเช่น หากจำเป็นต้องแสดงข้อมูลใด ๆ บนเพจ คุณต้องใช้ตัวแปร ออก. <% String queryData = request.getQueryString (); out.println ("Дополнительные данные запроса: " + queryData); %>

นิพจน์ JSP

การแสดงออกในหน้า JSP เป็นนิพจน์ปฏิบัติการที่เขียนในภาษาสคริปต์ที่ระบุในการประกาศ ภาษา(อย่างไร กฎจาวา). ผลลัพธ์ สำนวน JSP ของประเภทที่ต้องการ สตริง, ส่งไปยังเอาต์พุตมาตรฐาน ออกโดยใช้วัตถุปัจจุบัน JspWriter... ถ้าผลลัพธ์คือ สำนวนหล่อไม่ได้ สตริงอาจเกิดข้อผิดพลาดในการแปลหากตรวจพบปัญหาในขั้นตอนการแปล หรือมีข้อยกเว้นเกิดขึ้น ClassCastExceptionหากตรวจพบความไม่สอดคล้องกันระหว่างการดำเนินการตามคำขอ การแสดงออกมีไวยากรณ์ต่อไปนี้: & lt% = ข้อความนิพจน์%> ไวยากรณ์ทางเลือกสำหรับ สำนวน JSP เมื่อใช้ XML: ข้อความนิพจน์คำสั่งดำเนินการ สำนวนในหน้า JSP จากซ้ายไปขวา ถ้า การแสดงออกปรากฏในแอตทริบิวต์รันไทม์มากกว่าหนึ่งรายการ จากนั้นจะรันจากซ้ายไปขวาในแท็กนั้น การแสดงออกต้องเป็นนิพจน์ที่สมบูรณ์ในสคริปต์เฉพาะ (โดยทั่วไปคือ Java) นิพจน์จะถูกดำเนินการในขณะที่โปรโตคอล HTTP กำลังทำงาน ค่านิพจน์จะถูกแปลงเป็นสตริงและรวมอยู่ในตำแหน่งที่เหมาะสมในไฟล์ JSP นิพจน์มักใช้ในการคำนวณและแสดงการแสดงสตริงของตัวแปรและเมธอดที่กำหนดไว้ในบล็อกการประกาศเพจ JSP หรือได้มาจาก JavaBeans ที่สามารถเข้าถึงได้จาก JSP รหัสต่อไปนี้ สำนวนทำหน้าที่แสดงวันที่และเวลาของคำขอสำหรับหน้านี้: เวลาปัจจุบัน: & lt% = new java.util.Date ()%> เพื่อให้ง่ายขึ้น สำนวนมีตัวแปรที่กำหนดไว้ล่วงหน้าหลายตัวที่คุณสามารถใช้ได้ ตัวแปรที่ใช้บ่อยที่สุดคือ:
  • คำขอ HttpServletRequest;
  • การตอบสนอง HttpServletResponse;
  • เซสชัน HttpSession - เกี่ยวข้องกับคำขอ ถ้ามี;
  • ออกไป PrintWriter - เวอร์ชันบัฟเฟอร์ของประเภท JspWriter สำหรับการส่งข้อมูลไปยังไคลเอ็นต์

ต้องตรงกับชื่อของคลาสที่มีการเรียกเมธอด main () เมื่อเครื่อง Java เริ่มทำงาน

  • Object - คลาสที่จะสืบทอด ทั้งหมดออบเจ็กต์ใน Java รวมถึงอาร์เรย์และสตริง ()
  • ตัวระบุการเข้าถึงเป็นรายบุคคลสำหรับสมาชิกแต่ละคน (ระบุก่อนการประกาศ)
  • โดยค่าเริ่มต้น สมาชิกชั้นเรียนทุกคนจะเปิดขอบเขต บรรจุุภัณฑ์... ขอบเขตเริ่มต้นคือการข้ามระหว่างส่วนตัวและการป้องกัน ดู
  • แต่ละไฟล์ * .java สามารถมี หนึ่งเดียวคลาสที่ประกาศเป็นสาธารณะและสามารถเข้าถึงได้จากภายนอก
  • คำจำกัดความและการประกาศของคลาสจะอยู่ในไฟล์เดียวเสมอ เป็นไปไม่ได้ที่จะใส่ต้นแบบในส่วนหัว
  • พอยน์เตอร์หายไป
  • ตัวแปรคลาสทั้งหมดอ้างอิงถึงอ็อบเจ็กต์ ไม่ใช่ตัวอ็อบเจกต์เอง การเริ่มต้นใช้งานจะต้องทำผ่าน new<конструктор-класса>(...) .
  • ตาม วรรคก่อน- เมื่อกำหนดตัวแปรอ็อบเจ็กต์หนึ่งให้กับอีกตัวแปรหนึ่ง เฉพาะการอ้างอิงเท่านั้นที่เปลี่ยนแปลง แต่ไม่ใช่การคัดลอกอ็อบเจ็กต์
  • ตัวแปรในฟังก์ชันจะถูกส่งผ่านด้วยค่าถ้าเป็น ประเภทประถม(int, byte, long, etc ...) หรือโดยการอ้างอิงหากเป็นวัตถุ
  • สมาชิกสแตติกสาธารณะของคลาสสามารถเข้าถึงได้ผ่านตัวดำเนินการจุด และไม่ผ่าน :: ซึ่งในความคิดของฉันทำให้เกิดความสับสนจากภายนอก
  • ไม่มี destructor แต่มี finalize ()
  • Finalize () ไม่ควรสับสนกับ C ++ destructor จบ () เรียกว่า เก็บขยะเท่านั้นซึ่งไม่มีส่วนเกี่ยวข้องกับวัตถุที่อยู่นอกขอบเขตและไม่มีการอ้างอิงถึงวัตถุนี้อย่างน้อยหนึ่งครั้ง
  • คุณสามารถบังคับการรวบรวมขยะโดยเรียกใช้เมธอด Runtime.gc () บนอ็อบเจ็กต์รันไทม์ปัจจุบันหรือเมธอด System.gc () แบบสแตติก ตัดสินโดยการทดลองที่ดำเนินการ การปล่อยหน่วยความจำให้ทำงานภายในเท่านั้น เครื่องเสมือน Java และหน่วยความจำที่จัดสรรครั้งเดียวในระบบปฏิบัติการจะไม่ส่งคืนจนกว่าเครื่องจะสิ้นสุด
  • ในการเข้ารหัสสไตล์ Java ฟังก์ชันจะส่งข้อยกเว้นแทนที่จะส่งคืนโค้ด ระบบข้อผิดพลาดหรือข้อผิดพลาดในตรรกะของเครื่องเสมือน ดังนั้น หลายฟังก์ชันต้องดำเนินการภายในบล็อก try (...) catch (...) (...) ที่จัดการข้อยกเว้น หรือวิธีการเรียกฟังก์ชันเหล่านี้ต้องระบุผ่านอย่างชัดเจน จะแสดงรายการข้อยกเว้นที่ส่งโดย ฟังก์ชั่นเหล่านี้ที่ไม่ได้ถูกจัดการโดยพวกเขาสำหรับการประมวลผลโดยวิธีการของพวกเขาใน call stack
  • ข้อยกเว้นแบ่งออกเป็นและ
  • บล็อก try (...) ยังสามารถจบลงด้วยบล็อกสุดท้าย (...) ซึ่งถูกดำเนินการโดยไม่คำนึงถึงการมี/ไม่มีข้อยกเว้นในบล็อก try (...) ก่อนหน้า สะดวกในการใช้สิ่งนี้เพื่อดำเนินการใดๆ ที่จำเป็น โดยไม่คำนึงถึงผลลัพธ์ของการดำเนินการบล็อกของรหัส เช่น เพื่อปล่อยทรัพยากรทั้งหมดที่จัดสรรในนั้นโดยอัตโนมัติ
  • char ไม่ใช่ประเภทไบต์เดียวเหมือน C / C ++ เป็นประเภท 16 บิตที่รองรับ ยูนิโค้ดสตริง
  • bool เรียกว่าบูลีนในภาษาจาวา
  • โครงสร้างแบบมีเงื่อนไขยอมรับ เท่านั้นประเภทของตัวแปรหรือนิพจน์บูลีน ซึ่งหมายความว่ารหัสมีลักษณะดังนี้:
    int ก; ... การกระทำกับตัวแปร a ...; ถ้า (ก) (...)
    ไม่ถูกต้องในแง่ของไวยากรณ์ Java และจะไม่คอมไพล์
  • ค่าคงที่ถูกประกาศให้สิ้นสุดและไม่ใช่ค่าคงที่
  • อาร์เรย์ทั้งหมดเป็นวัตถุ
  • แม้แต่ค่าคงที่สตริง (เช่น "const สตริงใดๆ") ก็เป็นวัตถุ
  • สำหรับสตริง (สตริงคลาส) มีการกำหนดโอเปอเรเตอร์เพียงตัวเดียว - + การต่อกัน
  • การเปรียบเทียบสตริงทำได้โดยใช้เมธอด bool equals () ของคลาส String เช่น s1.equals (s2)
  • เนื้อหาของอ็อบเจ็กต์ String เป็นค่าคงที่และไม่ได้หมายความถึงการเปลี่ยนแปลงองค์ประกอบเดียวของสตริง ซึ่งทำขึ้นเพื่อเหตุผลด้านประสิทธิภาพ หากคุณต้องการการดำเนินการดังกล่าว คุณสามารถใช้คลาส StringBuffer
  • เมื่อเชื่อมสตริงที่ไม่ได้กำหนดค่าเริ่มต้นกับสตริงที่ไม่ว่าง คุณจะได้รับ null + non-empty-stringตัวอย่างเช่น s + = "| string"; จะเท่ากับ "null | string"
  • อาร์เรย์มีความยาวตัวแปรสมาชิกสาธารณะ สตริงไม่มีแต่ใช้วิธีความยาว () แทน
  • Java ไม่สนับสนุนมรดกหลายรายการ ฟังก์ชันบางอย่างดำเนินการผ่าน "อินเทอร์เฟซ" อินเทอร์เฟซรองรับการใช้งาน "การสืบทอด" หลายรายการของอินเทอร์เฟซหลายรายการในคลาสเดียว และโดยทั่วไป (อินเทอร์เฟซ) จำนวนมากถึงหลาย (คลาส) ความสัมพันธ์และในทางกลับกัน
  • อินเตอร์เฟสอนุญาตให้สร้างลิงค์ซึ่งคุณสามารถอ้างถึงอ็อบเจ็กต์ของคลาสที่ใช้อินเตอร์เฟสเหล่านี้ จริงอยู่ การค้นหาแบบไดนามิกสำหรับวิธีการที่เหมาะสมเมื่อเข้าถึงผ่านอินเทอร์เฟซอ้างอิงต้องใช้ค่าใช้จ่ายจำนวนมาก ดังนั้นจึงไม่พึงปรารถนา
  • แทนที่จะใช้การแจงนับ คุณสามารถใช้อินเทอร์เฟซได้โดยไม่ต้องมีการประกาศเมธอด ในกรณีนี้ ตัวแปรอินเทอร์เฟซทั้งหมดจะต้องเริ่มต้นเมื่อกำหนดอินเทอร์เฟซและค่าจะคงที่โดยอัตโนมัติ หลังจากนั้น พวกเขาสามารถ "เชื่อมต่อ" กับคลาสที่กำหนดไว้ได้โดยใช้อุปกรณ์ต่างๆ
  • นอกจากนี้ เนื่องจาก JDK 5 มี ภายนอกการแจงนับแบบคลาสสิก - enum อันที่จริง นี่ไม่ใช่แค่รายการของค่าคงที่ที่มีชื่อเท่านั้น แต่เป็นคลาสพิเศษที่สืบทอดมาจากซูเปอร์คลาส Enum แต่ละองค์ประกอบของการแจงนับเป็นวัตถุของคลาสนี้ ค่าตัวเลขของอ็อบเจกต์การแจงนับสามารถหาได้ด้วยฟังก์ชันในตัวลำดับ
  • กำหนดเอง โอเปอเรเตอร์โอเวอร์โหลดคุ้นเคยใน C ++ ใน Java ไม่รองรับ.
  • ในการทำงานในสภาพแวดล้อมของวัตถุด้วย "ประเภทดั้งเดิม" (int, float, char, ฯลฯ ... ) Java ใช้ ออโต้บ็อกซ์ / ออโต้บ็อกซ์เป็นประเภทเสื้อคลุม (จำนวนเต็ม, ลอย, ตัวละคร, ฯลฯ ... ) อันที่จริง นี่คือการใช้งานโอเปอเรเตอร์โอเวอร์โหลดสำหรับคลาสในตัวหลายคลาสที่ใช้ฟังก์ชันของประเภทดั้งเดิม + เมธอดอ็อบเจ็กต์
  • super - คำหลักที่อนุญาตให้คุณเรียกตัวสร้างของ superclass จาก subclass หรืออ้างถึงสมาชิกของ superclass ที่ซ่อนอยู่โดยสมาชิกของ subclass
    • เมื่อใช้เป็นคอนสตรัคเตอร์ - super ควรมาก่อนเสมอโอเปอเรเตอร์ในตัวสร้างของคลาสย่อย
  • เพื่อกำหนด บทคัดย่อเมธอด, คีย์เวิร์ด abstract ถูกใช้, คลาสที่มีเมธอด abstract จะต้องถูกกำหนดเป็นคลาสนามธรรมด้วย ....
  • สุดท้ายห้ามวิธีการเอาชนะในคลาสย่อย สำหรับเมธอด "สั้น" ที่ประกาศเป็นขั้นสุดท้าย คีย์เวิร์ดนี้มีผลเช่นเดียวกับอินไลน์ใน C ++ - ในคลาสย่อยแทนที่จะเรียกใช้ฟังก์ชัน อาจจะแทรก bytecode วิธี superclass ในการเรียกรหัสวิธีการเรียน
  • ขั้นสุดท้ายยังห้ามมิให้สืบทอดจากคลาสที่ประกาศเป็นขั้นสุดท้าย
  • เนมสเปซ(เนมสเปซ) ใน Java ถูกนำมาใช้เป็น แพ็คเกจ(บรรจุุภัณฑ์).
  • หากต้องการเชื่อมต่อกับ แพ็คเกจใช้การนำเข้า คุณยังสามารถใช้การนำเข้าแบบคงที่ ..(*|) เพื่อนำเข้าสมาชิกแบบคงที่ของคลาส
  • Java รองรับเธรดผ่านคลาสเธรดในตัวและอินเทอร์เฟซที่รันได้ สำหรับการซิงโครไนซ์ ให้ใช้ตัวระบุที่ซิงโครไนซ์ก่อนเมธอดในคำอธิบายคลาส หรือซิงโครไนซ์ ( ) (...) สำหรับบล็อกของรหัสที่ซิงโครไนซ์กับ ... สำหรับสัญญาณระหว่างเธรดที่ซิงโครไนซ์จะใช้เมธอดของคลาสอ็อบเจ็กต์หลัก: wait () / แจ้ง () / notifyAll ()
  • ชั่วคราว - ตัวดัดแปลงที่ระบุว่าค่าของวัตถุ / ตัวแปรไม่จำเป็นต้อง "ถือ" เมื่อบันทึกวัตถุเช่นเมื่อทำให้เป็นอนุกรมก่อนที่จะเขียนลงในดิสก์ / ฐานข้อมูล มีเหตุผลที่จะทำเครื่องหมายตัวแปรที่มี ตัวระบุที่ไม่ซ้ำรันไทม์และข้อมูลอื่นที่คล้ายคลึงกันซึ่งสมเหตุสมผลเฉพาะในอินสแตนซ์ปัจจุบันของกระบวนการจาวาเท่านั้น
  • ตัวอย่างของ - การดำเนินการรันไทม์ส่งคืน จริงถ้า มีลิงค์ไปยังชั้นเรียน หรือจะนำไปอ้างอิงถึงคลาสนี้ก็ได้ มิฉะนั้น เท็จ.
  • ยืนยัน - การยืนยัน Java ถูกใช้ในลักษณะเดียวกับใน C: assert [: คำอธิบายล้มเหลวการยืนยัน] แต่ ต้องจำไว้ว่าพวกเขาจะ "ฝัง" ลงใน bytecode ที่คอมไพล์แล้ว และสามารถรวมด้วย วิ่งจาวา-อี
  • this (...) - สามารถใช้ภายใน Constructor ของคลาสเพื่อเรียก Constructor อื่นในคลาสเดียวกัน โดยจับคู่ลายเซ็นของอาร์กิวเมนต์
  • แทน แม่แบบถูกนำมาใช้ ลักษณะทั่วไป, ดูคล้ายกันมาก: class CLASS_NAME (...) โดยทั่วไป เป็นสิ่งต้องห้ามใช้ ดั้งเดิมประเภท ( int, ไบต์, ถ่าน, ฯลฯ ...). สามารถใช้พารามิเตอร์ได้ เฉพาะชั้นเรียน.
    นอกจากนี้ยังรองรับ ประเภทจำกัดโดยการระบุซูเปอร์คลาสสำหรับคลาสพารามิเตอร์ ตัวอย่างเช่น การประกาศคลาส "generic class" CLASS_NAME ซึ่งอนุญาตให้ใช้เฉพาะคลาสลูกหลานของคลาสตัวเลขทั่วไปเท่านั้น
  • สะดวกในการใช้ System.arraycopy () เพื่อคัดลอกอาร์เรย์อย่างรวดเร็ว

    • สตานิสลาฟ กอร์นาคอฟ

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

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

    Class Phone (เปิดใช้งาน () วิธี (// การดำเนินการเพื่อเปิดโทรศัพท์) วิธีปิด () (// การดำเนินการเพื่อปิดโทรศัพท์))

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

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

    Class Telefon (เป็นโมฆะบน () (// เนื้อหาของวิธีการบน ()) โมฆะปิด () (// เนื้อหาของวิธีการปิด ()))

    คีย์เวิร์ด 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 () อีกต่อไป เราจะเพิ่มวิธีการใหม่ๆ ที่สามารถแก้ปัญหาบางอย่างได้จริงๆ

    Class Telefon (// S - พื้นที่แสดงผล // w - display width // h - display height int w, h, S; // วิธีการคำนวณพื้นที่แสดงผล void Area () (S = w * h;))

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


    วัตถุประสงค์ คุณสมบัติ และประโยชน์ของ Eclipse

    Eclipse เป็น IDE ที่ขยายได้ (Integrated Development Environment) IDE คือชุดเครื่องมือที่จัดระเบียบอย่างสะดวกซึ่งจำเป็นต่อการทำงานในโครงการซอฟต์แวร์

    Eclipse เป็นแพลตฟอร์มสากลที่สามารถใช้ในการพัฒนาแอปพลิเคชันในภาษาการเขียนโปรแกรมใด ๆ (เช่น คุณสามารถใช้ Python หลังจากติดตั้งการเชื่อมต่อ Pydev () แต่ Java นั้นมาจาก Eclipse (ซึ่งก็คือเขียนใน Eclipse) .

    คุณสมบัติที่สำคัญที่สุดของ Eclipse คือ:

    1. ข้ามแพลตฟอร์ม Eclipse ทำงานบนแพลตฟอร์มทั่วไปทั้งหมด: Windows, Linux และ MacOS X ที่สำคัญกว่านั้น ฟังก์ชันการทำงานจะเหมือนกันในแต่ละแพลตฟอร์มเหล่านี้
    2. ความเก่งกาจและการขยาย Eclipse มีความสามารถในการใช้เครื่องมือของบุคคลที่สามที่หลากหลาย
    3. การเปิดกว้างและบำเหน็จ Eclipse เป็นโปรเจ็กต์ OpenSource (เช่น its รหัสที่มามีให้สำหรับทุกคนและทุกคนสามารถเข้าร่วมการพัฒนาเครื่องมือนี้ได้) Eclipse มีชุมชนที่กระตือรือร้นทำงานอย่างต่อเนื่องเพื่อปรับปรุงโปรแกรมและขยายขีดความสามารถ

    พื้นที่ทำงาน Eclipse

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

    หลังจากเลือกพื้นที่ทำงานแล้ว หน้าเริ่มต้นจะปรากฏขึ้นบนหน้าจอ พร้อมคำแนะนำในการดูบทช่วยสอน ตัวอย่าง ฯลฯ เลือก Workbench แล้วคุณจะเข้าสู่หน้าต่าง สภาพแวดล้อมในการทำงาน (Workbench) ซึ่งงานต่อไปของคุณจะเกิดขึ้น

    ส่วนประกอบหลักของเวิร์กสเปซคือมุมมอง เอดิเตอร์ และเปอร์สเปคทีฟ

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

    การเปลี่ยนแปลงใดๆ ที่เกิดขึ้นกับมุมมองจะถูกบันทึกทันที

    ส่วนประกอบภาพ Workbench อีกประเภทหนึ่ง - บรรณาธิการซึ่งใช้ในการดูและแก้ไขทรัพยากรบางอย่าง (เช่น รหัสโปรแกรม) เมื่อคุณเลือกทรัพยากร ตัวแก้ไขที่เหมาะสมจะปรากฏขึ้น ตัวอย่างเช่น เปิดเอกสารข้อความใดๆ (ที่มีนามสกุล .txt) โดยใช้คำสั่ง File -> Open File ... แล้วคุณจะเห็นโปรแกรมแก้ไขข้อความธรรมดาในตัว หากคุณพิมพ์บางอย่างในตัวแก้ไขนี้ เครื่องหมายดอกจันจะปรากฏบนแท็บที่มีการเขียนชื่อไฟล์ หมายความว่าตัวแก้ไขมีการเปลี่ยนแปลงที่ยังไม่ได้บันทึก พวกเขาจะถูกบันทึกไว้หากคุณกด Ctrl + S หรือเลือกคำสั่งไฟล์ -> บันทึก

    มีมุมมองที่มีประโยชน์มากมายที่สามารถเพิ่มลงในหน้าต่างพื้นที่ทำงานด้วยคำสั่ง Window -> Show View อย่างไรก็ตาม แทนที่จะเพิ่มทีละรายการ จะสะดวกกว่าในการเปลี่ยนมุมมอง การฉายภาพ(หรือ ทัศนคติ) เป็นชุดของมุมมองและบรรณาธิการที่ได้รับการปรับแต่งเป็นพิเศษเพื่อให้งานสำเร็จลุล่วง หลังจากเรียกใช้งานใน Eclipse มุมมอง Java จะเปิดขึ้น ซึ่งกำหนดค่าไว้สำหรับการเขียนโปรแกรมจริง การฉายภาพดีบักมักใช้เพื่อดีบักโปรแกรม คุณสามารถเปลี่ยนการฉายภาพโดยใช้คำสั่ง Window -> Open Perspective ชื่อของโปรเจ็กต์ปัจจุบันจะแสดงที่มุมขวาบนของสภาพแวดล้อมการทำงาน (ดูรูป)

    โปรแกรม Java ตัวแรก

    ก่อนที่คุณจะเริ่มเขียนโปรแกรม คุณต้องสร้างโครงการที่ Eclipse จะจัดเก็บทรัพยากรทั้งหมดที่เกี่ยวข้องกับโปรแกรมของคุณ

    ในการสร้างโครงการ ให้รันคำสั่ง File -> New -> Project ในหน้าต่างที่ปรากฏขึ้น ให้เลือก Java Project แล้วคลิก Next ระบุชื่อสำหรับโครงการของคุณ โปรดทราบว่าโฟลเดอร์ที่มีชื่อโครงการของคุณจะถูกสร้างขึ้นในไดเร็กทอรีที่คุณระบุเป็นพื้นที่ทำงาน (เว้นแต่คุณจะเปลี่ยนการตั้งค่าในหน้าต่างนี้ ซึ่งเราจะไม่ทำในครั้งแรก) คลิกปุ่มเสร็จสิ้น

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

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

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

    โปรแกรม Java ประกอบด้วยอย่างน้อยหนึ่งรายการเสมอ ชั้นเรียน... คุณสามารถสร้างคลาสโดยใช้คำสั่ง New -> Class ใน เมนูบริบทมุมมองเนวิเกเตอร์ (หรือ Package Explorer ไม่สำคัญ) เมื่อสร้างคลาส คุณต้องเลือกแพ็คเกจที่จะใช้ (เลือกแพ็คเกจที่คุณเพิ่งสร้างขึ้น) และตั้งชื่อให้คลาสนั้น เป็นเรื่องปกติที่จะเริ่มต้นชื่อคลาสด้วยอักษรตัวพิมพ์ใหญ่ หากคุณไม่ปฏิบัติตามกฎเกณฑ์ที่ดีนี้ Eclipse จะออกคำเตือน แต่จะไม่มีอะไรเลวร้ายเกิดขึ้น

    เพื่อจุดประสงค์ของเรา ให้เลือกช่องทำเครื่องหมายใต้ "คุณต้องการสร้างวิธีการใดในชั้นเรียนของคุณ" ทางเลือกตรงข้าม โมฆะคงที่สาธารณะหลัก (สตริง args)... เป็นผลให้เมธอด main () (ฟังก์ชัน) จะถูกสร้างขึ้นในเนื้อหาของคลาส Java ต้องการให้อย่างน้อยหนึ่งคลาสของโปรแกรมมีเมธอดที่มีส่วนหัวดังกล่าว เป็นผู้ที่จะถูกประหารชีวิตเมื่อเริ่มโปรแกรม

    จากการกระทำของเรา ไฟล์ที่มีชื่อคลาสของเราและนามสกุล .java จะถูกสร้างขึ้นในโฟลเดอร์แพ็คเกจ Eclipse จะเปิดโปรแกรมแก้ไขโค้ดที่แสดงเนื้อหาของไฟล์นี้ มันจะเป็นดังนี้ (แน่นอนว่าชื่อแพ็คเกจและคลาสอาจแตกต่างกัน):

    แพ็คเกจ mainPack; คลาสสาธารณะ MyClass (/ ** * @param args * / public static void main (String args) ())

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

    System.out.println ("สวัสดีชาวโลก!");

    มันยังคงรันโปรแกรม ในการดำเนินการนี้ ให้รันคำสั่ง Run -> Run และรับกล่องโต้ตอบที่มีการตั้งค่าการเรียกใช้ที่ไม่สำคัญ ที่ด้านซ้ายของหน้าต่างนี้ ให้เลือก Java Application ( แอปพลิเคชัน Java). หลังจากครุ่นคิดเล็กน้อย Eclipse จะพบคลาสของเราที่มีเมธอด main () และเสนอให้เริ่มโปรแกรมจากมัน (ทางด้านขวาของหน้าต่าง บนแท็บ Main ชื่อของโปรเจ็กต์และคลาสของเราควรปรากฏขึ้น) นอกจากนี้ยังมีการเสนอแท็บเพิ่มเติมอีกสองสามแท็บเพื่อให้ความสนใจของโปรแกรมเมอร์ ตัวอย่างเช่นในข้อที่สอง - อาร์กิวเมนต์ - คุณจะได้รับแจ้งให้ป้อนพารามิเตอร์บรรทัดคำสั่ง (หากโปรแกรมได้รับการออกแบบให้เรียกจากบรรทัดคำสั่งพร้อมพารามิเตอร์) สำหรับโปรแกรมอย่างง่ายของเรา คุณไม่จำเป็นต้องระบุอย่างอื่น เพียงคลิกปุ่มเรียกใช้

    จากการทำงานของโปรแกรม ข้อมูลจะถูกส่งออกไปยังคอนโซลที่เรียกว่า ในระบบปฏิบัติการ MS DOS หน้าจอมอนิเตอร์ทั้งหมดทำหน้าที่เป็นคอนโซล Eclipse เปิดมุมมอง Console ให้เรา ซึ่ง (หากทุกอย่างถูกต้อง) บรรทัด "สวัสดีชาวโลก!" คือผลลัพธ์ของโปรแกรมของเรา

    ตอนนี้ ในการรันโปรแกรมอีกครั้ง (เช่น หากเราตัดสินใจที่จะทำการเปลี่ยนแปลงบางอย่างกับมันหรือต้องการแสดงให้ครูเห็น) คุณสามารถไปที่วิธีที่ง่ายกว่า - รันคำสั่ง Run -> Run Last Launched (เรียกใช้ แอปพลิเคชันก่อนหน้าอีกครั้ง) หรือเพียงแค่กด Ctrl + F11

    พื้นฐานไวยากรณ์ Java

    คำจำกัดความ

    ตัวถูกดำเนินการคือค่าที่เกี่ยวข้องกับการดำเนินการ

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

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

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

    แนวคิดของโปรแกรมและอัลกอริทึม (ซ้ำ)

    นัดใด้ โปรแกรมคอมพิวเตอร์- การแปลงข้อมูลอินพุตเป็นข้อมูลเอาต์พุต อัลกอริธึมของโปรแกรมกำหนดวิธีการแปลงข้อมูลอินพุตเป็นข้อมูลเอาต์พุต


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

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

    การเริ่มต้นเขียนโปรแกรมต้องเข้าใจทันที:

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

    เมื่อเขียนโปรแกรมอย่างง่าย คุณต้อง:

    1. รับข้อมูลเข้า
    2. ใช้อัลกอริทึมสำหรับการแปลงข้อมูลอินพุตเป็นเอาต์พุต
    3. ส่งออกผลงานของโปรแกรม (ข้อมูลขาออก): แสดง ส่งข้อมูลผ่านเครือข่าย ฯลฯ

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

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

    วรรณกรรมในหัวข้อ:

    การสร้างอัลกอริทึมพื้นฐาน (การทำซ้ำ)

    ความสนใจ! ในขั้นตอนนี้ของการฝึกอบรม คุณควรมีความรู้ในหัวข้อนี้อยู่แล้วหากไม่มีและวัสดุสำหรับการทำซ้ำนั้นเข้าใจยากหรือไม่เพียงพอ คุณจะไม่รับมือกับงาน! เป็นเรื่องเร่งด่วนที่จะปรึกษาวรรณกรรมในหัวข้อนี้

    ดังนั้น อัลกอริทึมคือลำดับของการกระทำเพื่อแปลงข้อมูลอินพุตเป็นเอาต์พุต

    อัลกอริทึมสามารถเขียนได้สามวิธีหลัก:

    ขั้นตอนแต่ละขั้นตอนของอัลกอริธึม (ไม่ว่าจะเขียนอย่างไร) จะเชื่อมโยงถึงกันโดยใช้โครงสร้างมาตรฐานสามแบบที่นำมาใช้ในภาษาโปรแกรมทั้งหมด:

      การดำเนินการตามลำดับ ขั้นตอนจะดำเนินการทีละรายการ

      การแตกแขนง. ขึ้นอยู่กับการปฏิบัติตามเงื่อนไขบางอย่าง (ในตัวอย่างที่พิจารณา มันคือ x> y?) ดำเนินการหนึ่งหรืออีกสาขาหนึ่งของโปรแกรม

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

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

    แผนภาพแรกดูชัดเจนขึ้น แต่ในกรณีที่ไม่จำเป็นต้องแสดงตัวเลข 5 ตัว แต่เป็น 100 แผนภาพ (และโปรแกรมที่สอดคล้องกับอัลกอริธึมนี้) จะเพิ่มขึ้น 20 เท่า และในโปรแกรมที่ตรงกับอัลกอริธึมที่สองเท่านั้น ที่เดียวจะเปลี่ยน: 10 จะเปลี่ยนเป็น 100 นั่นคือเหตุผลที่การกระทำซ้ำ ๆ ได้รับการออกแบบในรูปแบบของวัฏจักรแม้ว่าในหลาย ๆ กรณีสามารถจ่ายได้

    ข้อควรจำ: อัลกอริทึมควรสร้างจากโครงสร้างที่มีชื่อเพียงสามชื่อเท่านั้น!

    วรรณกรรมในหัวข้อ:

    1. หนังสือเรียนวิชาวิทยาการคอมพิวเตอร์

    พื้นฐานของพื้นฐานไวยากรณ์ Java

    1. ภาษา Java แยกความแตกต่างระหว่างตัวพิมพ์ใหญ่และตัวพิมพ์เล็กซึ่งหมายความว่าควรเขียนชื่อของฟังก์ชันและคำหลักทั้งหมดตามที่ปรากฏในตัวอย่างและหนังสืออ้างอิง
    2. ทุกคำสั่ง (ตัวดำเนินการ) ในภาษา Java ต้องลงท้ายด้วยอัฒภาค
    3. โปรแกรม Java ประกอบด้วยอย่างน้อยหนึ่งโปรแกรม ชั้นเรียน... ควรวางส่วนการทำงานทั้งหมดของโปรแกรม (เช่น ทำหน้าที่อะไร) ลงใน วิธีการบางชั้นเรียน (คลาสและเมธอด ตามแนวคิดการเขียนโปรแกรมเชิงวัตถุ จะครอบคลุมในบทที่ 3 ไวยากรณ์ของคลาสจะครอบคลุมด้วย ในแบบฝึกหัดแรก ให้ใช้คลาสที่ Eclipse สร้างโดยค่าเริ่มต้น)
    4. ชั้นเรียนถูกจัดกลุ่มเป็นแพ็คเกจ
    5. อย่างน้อยหนึ่งคลาสต้องมีเมธอด main () เหมือนกับในตัวอย่างที่เราพิจารณา (ในตอนแรก ไม่จำเป็นต้องเข้าใจหรือพยายามจำการสะกดที่ถูกต้องของวิธีนี้ - Eclipse จะสร้างทุกอย่างเองหากคุณทำเครื่องหมายในช่องที่จำเป็น) วิธีนี้จะถูกดำเนินการก่อน

    ในกรณีที่ง่ายที่สุด โปรแกรมสามารถประกอบด้วยหนึ่งแพ็คเกจ (หรือไม่มีเลย) หนึ่งคลาสภายในแพ็คเกจ และเมธอด main () เดียวภายในคลาส คำสั่งโปรแกรมจะถูกเขียนระหว่างบรรทัด

    โมฆะคงที่สาธารณะหลัก (สตริง args) (

    และวงเล็บปีกกาปิด) แสดงจุดสิ้นสุดของเนื้อหาวิธีการ ควรปฏิบัติตามแนวทางนี้เมื่อทำแบบฝึกหัดที่ง่ายที่สุด

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

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

    1. เครื่องหมายทับสองอัน // ถูกแทรก จากนี้ไปจนจบบรรทัด คุณสามารถเขียนอะไรก็ได้ที่คุณต้องการ - Java จะถือว่ามันเป็นความคิดเห็น
    2. ที่จุดเริ่มต้นของความคิดเห็น อักขระ / * จะถูกวาง และในตอนท้าย - * / ในกรณีนี้ ความคิดเห็นสามารถขยายได้หลายบรรทัด
    3. ไฮไลท์ ความคิดเห็นสำหรับเอกสารที่อยู่ระหว่างเครื่องหมาย / ** และ * / การใช้งานของพวกเขาจะกล่าวถึงในภายหลัง

    กฎการเขียนตามตัวอักษร

    เกี่ยวกับรูปแบบการเขียนต่างๆ

    จำนวนเต็ม (ตัวอักษรจำนวนเต็ม) ใน Java สามารถเขียนได้ตามปกติในรูปแบบทศนิยม: 12345, +4, -11

    นอกจากนี้ คุณสามารถเขียนจำนวนเต็มในรูปแบบฐานแปด โดยเริ่มจากศูนย์ (0777, -056) และในรูปแบบเลขฐานสิบหก โดยเริ่มจากศูนย์และอักษรละติน x (0xFFFF, 0x14, 0xA1BC)

    ตัวอักษรที่ถูกต้องเขียนด้วยเครื่องหมายทศนิยม ส่วนจำนวนเต็มแยกออกจากจุดทศนิยม

    สามารถเขียนจำนวนจริงได้ จุดลอยตัวตัวอย่างเช่น: 5.4e19, 17E-11, -123e + 4 ส่วนของตัวเลขที่อยู่ก่อนตัวอักษร e เรียกว่า mantissa และส่วนที่อยู่หลังตัวอักษร e เรียกว่า order สัญกรณ์หมายถึงสิ่งต่อไปนี้: คุณต้องเพิ่ม 10 ยกกำลังของคำสั่งและคูณด้วยแมนทิสซา บางครั้งการเขียน 1e-9 จะสะดวกกว่า 0.000000001

    อักขระตัวเดียวเขียนด้วยเครื่องหมายอะพอสทรอฟี เช่น "a", "D", "@"

    มีอักขระพิเศษและอักขระควบคุมบางตัวที่เขียนโดยใช้ลำดับหลีกพิเศษ รายการที่พบบ่อยที่สุดแสดงอยู่ในตาราง:

    ลำดับการหลบหนียังอยู่ในเครื่องหมายอะพอสทรอฟี

    บรรทัดแรกของตารางระบุว่าสามารถระบุอักขระใดก็ได้โดยใช้รหัส (ด้วยการเข้ารหัสทศนิยมตั้งแต่ 0 ถึง 255) โดยการเขียนโค้ดนี้ในระบบเลขฐานแปด ตัวอย่างเช่น ตัวอักษร "g" ในการเข้ารหัส CP1251 จะถูกเขียนด้วยลำดับหลีก "\ 346"

    หากจำเป็น คุณสามารถระบุรหัสของอักขระใดก็ได้ใน การเข้ารหัส Unicode- หลังแบ็กสแลชและตัวอักษรละติน u - เป็นอักขระฐานสิบหกสี่ตัว ตัวอย่างเช่น "\ u0055" คือตัวอักษร U

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

    สำหรับสตริง จะมีการกำหนดการดำเนินการต่อ + ซึ่งช่วยให้คุณสามารถรวบรวมสตริงต่างๆ ให้เป็นหนึ่งเดียว

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

    "นี่คือค่าคงที่สตริงที่ยาวมากที่เขียน" + "ในสองบรรทัดของแหล่งที่มา"

    อักขระควบคุมและรหัสถูกเขียนภายในสตริงในลักษณะเดียวกับ แบ็กสแลช(แต่ไม่มีอะพอสทรอฟี)

    ตัวอักษรบูลีนเป็นจริงและเท็จ

    ตัวระบุ

    เกี่ยวกับกฎของสไตล์ที่ดี

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

    ตัวระบุสามารถประกอบด้วยตัวอักษร ตัวเลข ขีดล่าง _ และเครื่องหมายดอลลาร์ $ (ไม่แนะนำให้ใช้ตัวหลัง Java ใช้เพื่อความต้องการของตนเอง) ตัวระบุไม่สามารถเริ่มต้นด้วยตัวเลขได้ คีย์เวิร์ด Java (หรือตามตัวอักษร ถูกผิดและ โมฆะ).

    ตามที่ระบุไว้ข้างต้น ภาษา Java แยกความแตกต่างระหว่างตัวอักษรธรรมดาและตัวพิมพ์เล็ก... ซึ่งหมายความว่า myAge, myage และ MyAge เป็นชื่อของอ็อบเจ็กต์ที่แตกต่างกันโดยสิ้นเชิง ระวัง: ข้อผิดพลาดในการลงทะเบียนเป็นกรณีทั่วไปมาก!

    ชื่อคลาสจะขึ้นต้นด้วยอักษรตัวพิมพ์ใหญ่ หากชื่อประกอบด้วยหลายคำ แต่ละคำจะขึ้นต้นด้วยอักษรตัวพิมพ์ใหญ่ ตัวอย่างเช่น: MyClass, หนังสือ

    ชื่อเมธอดและตัวแปรขึ้นต้นด้วยตัวพิมพ์เล็ก (ตัวพิมพ์เล็ก) ถ้าชื่อมีหลายคำ คำถัดไปแต่ละคำจะขึ้นต้นด้วยตัวพิมพ์ใหญ่ ตัวอย่างเช่น myVar, x, y, newBigCounter

    ชื่อคงที่เขียนเต็ม อักษรพิมพ์ใหญ่; ถ้าชื่อมีหลายคำ จะมีการขีดเส้นใต้ระหว่างคำเหล่านั้น ตัวอย่างเช่น PI COUNT_OF_MONTHS

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

    ชนิดข้อมูล

    เกี่ยวกับประเภทข้อมูล Java

    ประเภท int มักใช้ในการเก็บจำนวนเต็มใน Java

    โดยทั่วไป มีสี่ประเภทจำนวนเต็มในภาษา Java: ไบต์ สั้น int ยาว พวกเขาแตกต่างกันในจำนวนหน่วยความจำที่จะจัดสรรสำหรับตัวแปรและดังนั้นในช่วงของค่าที่สามารถเก็บไว้ในตัวแปรนี้ ประเภท int ที่ใช้บ่อยที่สุดมีหน่วยความจำ 4 ไบต์และเหมาะสำหรับการจัดเก็บตัวเลขตั้งแต่ -2147483648 ถึง 2147483647 ประเภทไบต์ใช้หน่วยความจำน้อยที่สุดและเหมาะสำหรับการทำงานกับตัวเลขขนาดเล็ก (ตั้งแต่ -128 ถึง 127) ประเภทสั้นและยาวคือ 2 และ 8 ไบต์ตามลำดับ

    ประเภทคู่เหมาะสำหรับจำนวนจริง

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

    ตัวอักษรที่ถูกต้อง เช่น 5.3, 8.0, 2e-3 ถูกพิจารณาโดย Java ว่าเป็นสองเท่า หากจะใช้เป็นแบบลอยตัวในโปรแกรม พวกเขาจะต้องลงท้ายด้วยตัวอักษร f: 5.3f, 8.0f, 2e-3f

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

    ค่าบูลีน (จริงหรือเท็จ) จะแสดงด้วยประเภทบูลีน

    ดังนั้น Java กำหนดแปดประเภทง่าย ๆ ซึ่งนำเสนอคุณสมบัติใน ตาราง:

    การประกาศตัวแปร

    ใน Java (เช่นเดียวกับในภาษาอื่น ๆ มากมาย) คุณต้องอธิบายก่อนใช้งาน ในการอธิบายตัวแปรคือการตั้งชื่อและกำหนดประเภทของตัวแปร

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

    ตัวอย่างการประกาศตัวแปร:

    int x; // ประกาศตัวแปรจำนวนเต็ม xสองเท่า, ข; // ประกาศตัวแปรจริงสองตัว a และ bตัวอักษรถ่าน = "Z"; // ประกาศตัวแปรตัวอักษร เริ่มต้นด้วยค่าเริ่มต้นของ "Z"บูลีน b1 = จริง, b2, b3 = เท็จ; // ประกาศตัวแปรบูลีนสามตัว ตัวแรกจะเป็นจริง ตัวสุดท้ายจะเป็นเท็จ

    การใช้งานภาษาพื้นฐาน

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

    การดำเนินการทางคณิตศาสตร์

    การดำเนินการเปรียบเทียบ ผลลัพธ์คือค่าบูลีน: จริงหรือเท็จ

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

    เกี่ยวกับการทำงานของจาวา

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

    กะการทำงาน

    (ทำงานกับการแสดงบิตของตัวถูกดำเนินการแรก)

    การดำเนินการระดับบิต

    (ทำงานกับการแสดงบิตของตัวถูกดำเนินการ)

    การดำเนินการ?:

    Operation ?: ternary นั่นคือมีตัวถูกดำเนินการสามตัว ตัวถูกดำเนินการแรกคือเงื่อนไข นิพจน์บูลีน ตัวถูกดำเนินการที่สองและสามคือนิพจน์ประเภทอื่น การดำเนินการทำงานดังนี้: ถ้าเงื่อนไขเป็นจริง จะส่งกลับตัวถูกดำเนินการที่สองเป็นผล และถ้าเป็นเท็จ ก็จะคืนค่าตัวถูกดำเนินการที่สาม

    ตัวอย่างเช่น นิพจน์ (5> 3)? 7 + 1: 2*2 จะมีค่าเป็น 8 แต่นิพจน์ (5 == 3)? 7 + 1: 2 * 2 - ค่า 4 สัญกรณ์นี้ดูไม่ค่อยสื่อความหมายนัก แต่โปรแกรมเมอร์มักใช้เพื่อย่อโค้ดของตน ดังนั้น แทนที่จะเป็นลำดับของคำสั่ง:

    ถ้า (x> 0) y = 45 + a * 2; // หากกล่าวถึงคำสั่งด้านล่างอย่างอื่น y = 45 - b * 3;

    คุณสามารถเขียน:

    Y = 45 + ((x> 0)? A * 2: -b * 3);

    ผู้ปฏิบัติงานที่ได้รับมอบหมาย

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

    ค่านี้เชื่อมโยงกับตัวแปรโดยใช้การมอบหมาย ในภาษา Java เขียนด้วยเครื่องหมายเท่ากับอย่างง่าย:

    ตัวแปร = นิพจน์;

    ทางด้านซ้ายของตัวดำเนินการกำหนดจะเป็นตัวแปรเสมอ ทางด้านขวาจะต้องตรงกับตัวแปรตามประเภท อาจเป็นแบบง่ายๆ (เช่น ตัวเลขหรือสัญลักษณ์):

    X = 7; // ตัวแปร x ถูกกำหนดเป็นค่า 7จดหมาย = "Q"; // ตัวอักษรถูกกำหนดเป็น "Q"

    โดยทั่วไป นิพจน์คือสิ่งที่สามารถคำนวณได้ (เช่น ผลลัพธ์ของการดำเนินการทางคณิตศาสตร์หรือผลลัพธ์ที่ส่งคืนโดยวิธีการบางอย่าง):

    A = 7.5 + 2.4; // ตัวแปร a ถูกกำหนด 9.9 อันเป็นผลมาจากการคำนวณ

    นอกเหนือจากตัวอักษรแล้ว ตัวแปรอื่นๆ สามารถมีส่วนร่วมในนิพจน์ได้ มูลค่าปัจจุบันของพวกเขาถูกแทนที่สำหรับพวกเขา อันเป็นผลมาจากคำสั่ง:

    B = a + 1;

    ตัวแปร b จะถูกตั้งค่าเป็น 10.9

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

    X = x + 4;

    คำสั่งนี้จะเพิ่มค่าปัจจุบันของตัวแปรจำนวนเต็ม x ขึ้น 4

    และคำสั่งต่อไปนี้เขียนอย่างไม่ถูกต้องและจะไม่ทำงาน:

    5 = x + 7; // ควรมีตัวแปรทางด้านซ้าย x + 3 = 14; // ควรมีตัวแปรเพียงตัวเดียวทางด้านซ้าย x = 4.5; // ตัวแปร x รับได้เฉพาะค่าจำนวนเต็ม

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

    เกี่ยวกับการหล่อแบบ

    เมื่อตัวแปรประเภทหนึ่งถูกกำหนดเป็นค่าของอีกประเภทหนึ่ง จะใช้ค่านั้น หล่อ (แปลง) ประเภท... สำหรับประเภทตัวเลข (byte, short, int, long, float, double, char) จะเกิดขึ้นโดยอัตโนมัติหากประเภทของตัวแปรที่เปลี่ยนแปลงสามารถ "รองรับ" ค่าของประเภทอื่นได้

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

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

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

    ยาว j = (ยาว) 1.0; // ใช้ตัวดำเนินการแคสต์เพื่อลอง, j = 1ถ่าน ch = (ถ่าน) 1001; // ใช้ตัวดำเนินการ cast to char ch = "d"ไบต์ b2 = (ไบต์) (100); // ใช้ตัวดำเนินการ cast จาก int เป็น byte, b2 = 100ไบต์ b3 = (ไบต์) (100 * 2); //ความสนใจ! การแบ่งโมดูโลเกิดขึ้น b3 = -56

    ข้อผิดพลาดประเภทไม่ตรงกันมักเกิดขึ้นกับตัวอักษรที่ถูกต้อง ตัวอย่างเช่น คุณไม่สามารถดำเนินการมอบหมาย a = 7.5 + 2.4; ถ้าตัวแปร a เป็นประเภท float เนื่องจากตัวอักษร 7.5 และ 2.4 ถือเป็นประเภท double เพื่อหลีกเลี่ยงข้อผิดพลาด จำเป็นต้องใช้ typecasting:

    A = (ลอย) (7.5 + 2.4);

    หรือเพื่อระบุว่าตัวอักษรนั้นลอยอยู่ด้วย:

    A = 7.5f + 2.4f; // นี่เป็นคำสั่งที่ถูกต้องเช่นกัน

    การดำเนินการไบนารีเกือบทุกครั้งมีตัวดำเนินการกำหนดประเภทของตัวเอง ตัวอย่างเช่น สำหรับการดำเนินการบวก + มีโอเปอเรเตอร์การกำหนดเอกพจน์ + = ซึ่งเพิ่มค่าของตัวถูกดำเนินการตามจำนวนที่กำหนด:

    X + = 8; // เหมือนกับ x = x + 8 (x เพิ่มขึ้น 8)

    ในทำนองเดียวกันสำหรับการดำเนินการอื่นๆ: ตัวดำเนินการ * =, - =, / =,% =, & = ^ = เป็นต้น

    X * = 3; // เหมือนกับ x = x * 3 (x เพิ่มขึ้น 3 เท่า) b1 ^ = b2; // เหมือนกับ b1 = b1 ^ b2

    แบบฝึกหัด 1

    ประกาศตัวแปรจำนวนเต็มสองตัวกำหนดค่าใด ๆ ให้กับพวกมัน พิมพ์ผลรวมและผลิตภัณฑ์

    แจ้ง:คุณสามารถใช้โปรเจ็กต์ที่สร้างไว้แล้วใน Eclipse โดยวาง คำสั่งที่จำเป็นหลังจากคำสั่งให้ส่งออกบรรทัด "สวัสดีชาวโลก!" หรือแทนมัน

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

    เกี่ยวกับตัวดำเนินการเพิ่มและลดค่า

    ตัวดำเนินการเพิ่มและลด ++ และ –– เพิ่มและลดค่าของตัวถูกดำเนินการทีละหนึ่ง สะดวกกว่ามากในการใช้คำสั่ง x ++; แทนคำสั่ง x = x + 1;

    ตัวดำเนินการ increment และ decrement ยังคืนค่าอีกด้วย ซึ่งหมายความว่าการดำเนินการตามคำสั่งนั้นถูกกฎหมาย

    Y = 7 * x ++;

    เป็นผลให้ตัวแปร x เพิ่มขึ้น 1 และตัวแปร y จะใช้ค่าเจ็ดเท่าของค่าเดิมของ x คุณยังสามารถเรียกใช้คำสั่งนี้:

    Y = 7 * ++ x;

    เป็นผลให้ตัวแปร x เพิ่มขึ้น 1 และตัวแปร y จะใช้ค่าเจ็ดเท่าของค่าใหม่ของ x

    เงื่อนไข if คำสั่ง

    รูปแบบที่ง่ายที่สุดของสัญกรณ์ ตัวดำเนินการตามเงื่อนไขดูเหมือนกับ:

    if (เงื่อนไข) คำสั่ง

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

    if (x // ถ้าค่าของตัวแปร x น้อยกว่า 17 ให้กำหนด x เป็น 17

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

    ถ้า (เงื่อนไข) command1 else command2

    เกี่ยวกับสิ่งอื่นถ้าสร้าง

    ในตัวอย่างข้างต้น เราอาจต้องกำหนดตัวแปร x เป็น 5 ถ้าเงื่อนไข x ไม่ถูกดำเนินการ (ทำไมเราต้องการมัน คำถามอื่น)

    ถ้า (x อื่น x = 5;

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

    if (condition1) command1 else if (condition2) command2 else if (เงื่อนไข3) command3 ... else commandN

    แบบฝึกหัดที่ 2

    ประกาศตัวแปรจำนวนเต็มสองตัวกำหนดค่าใด ๆ ให้กับพวกมัน ใช้คำสั่ง if เพื่อค้นหาและส่งออกค่าสูงสุด

    แจ้ง:อัลกอริธึมสำหรับการค้นหาค่าสูงสุดได้รับการพิจารณาในขณะที่ทำซ้ำการสร้างพื้นฐานของอัลกอริธึม

    คำสั่งผสม

    คำสั่งภาษา Java หลายคำสั่งสามารถรวมกันเป็นคำสั่งผสมเดียวโดยใช้เครื่องหมายปีกกา () ตัวอย่างเช่น คุณสามารถเขียน:

    (a = 12; ตัวอักษร = "D";)

    คำสั่งผสมสามารถใช้ได้ทุกที่ที่มีคำสั่งปกติ ตัวอย่างเช่น ในคำสั่ง if หากจำเป็นต้องดำเนินการหลายอย่างเมื่อตรงตามเงื่อนไข:

    ถ้า (x "S";) อื่น ๆ (x = 5;)

    โครงสร้างเหล็กดัดโค้งเรียกอีกอย่างว่า บล็อกของคำสั่งและเหล็กดัดงอคือ ปิดกั้นขอบเขต.

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

    เกี่ยวกับคำสั่งการเลือกสวิตช์

    คำสั่งสลับการเลือก

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

    สวิตช์ (นิพจน์) ( case value1: ลำดับคำสั่ง 1 break; case value2: ลำดับคำสั่ง 2 break; ... ค่าเริ่มต้น: ลำดับคำสั่งเริ่มต้น)

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

    ตัวดำเนินการถ่าน; // ป้ายการทำงาน จะถูกเลือกโดยผู้ใช้ ... // สมมุติว่าตอนนี้ผู้ใช้ได้เลือกเครื่องหมายแล้วสวิตช์ (oper) (ตัวพิมพ์ "+": System.out.println (a + b); break; case "-": System.out.println (a - b); break; case "*": System.out println (a * b); แตก; ค่าเริ่มต้น: System.out.println ( "สัญญาณธุรกรรมไม่ถูกต้อง"); }

    คุณสามารถละเว้นส่วนเริ่มต้น ในกรณีนี้ หากไม่พบรายการที่ตรงกัน จะไม่มีการดำเนินการคำสั่งใดๆ

    ในขณะที่คำสั่งวนรอบ

    while loop มีรูปแบบดังนี้:

    ในขณะที่ (เงื่อนไข) คำสั่ง

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

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

    ตัวอย่างเช่น ข้อมูลโค้ดต่อไปนี้พิมพ์เลขคู่ตั้งแต่ 2 ถึง 10:

    int x = 2; ในขณะที่ (x<= 10){ System.out.println(x); x += 2; }

    เกี่ยวกับ while loop กับ postcondition

    มีอีกวิธีในการเขียน while loop:

    ทำคำสั่งในขณะที่ (เงื่อนไข)

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

    แบบฝึกหัด # 3

    ใช้ while loop เพื่อพิมพ์เลขคี่ทั้งหมดตั้งแต่ 1 ถึง 10

    แจ้ง:เปลี่ยนอัลกอริทึมเล็กน้อยสำหรับการส่งออกเลขคู่

    สำหรับตัวดำเนินการลูป

    ลูป for มักใช้เมื่อทราบล่วงหน้าว่าควรทำซ้ำการดำเนินการคำสั่ง (หรือลำดับของคำสั่ง) กี่ครั้ง มีรูปแบบดังนี้

    สำหรับ (คำสั่ง init; เงื่อนไข; คำสั่งกระโดด) loop-body

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

    โดยทั่วไปจะใช้ for loop ดังนี้:

    สำหรับ (int i = 1; i<= 10; i++) тело_цикла;

    ในตัวอย่างนี้ loop_body จะถูกดำเนินการ 10 ครั้งพอดี ในกรณีนี้ ในการวนซ้ำแต่ละครั้ง ตัวแปร i จะพร้อมใช้งาน (เรียกว่าตัวแปรลูป) ซึ่งจะรันค่าตามลำดับตั้งแต่ 1 ถึง 10 แฟรกเมนต์โปรแกรมถัดไปจะส่งออกตัวเลขคู่ตั้งแต่ 2 ถึง 10 (คล้ายกับ ตัวอย่างลูป while):

    สำหรับ (int i = 1; i<= 5; i++) System.out.println(i*2);

    แบบฝึกหัด 4

    ใช้ a for loop เพื่อพิมพ์เลขคี่ทั้งหมดตั้งแต่ 1 ถึง 10

    ทำลายและดำเนินการต่องบ

    เมื่อเนื้อความของลูป (for หรือ while) ประกอบด้วยคำสั่งหลายคำสั่ง สถานการณ์อาจเกิดขึ้นซึ่งไม่จำเป็นต้องดำเนินการทั้งหมดในการวนซ้ำครั้งถัดไป ในกรณีนี้ คำสั่ง break และ continue จะมีประโยชน์

    คำสั่ง break จะยุติการดำเนินการของลูปปัจจุบัน โดยไม่คำนึงว่าเงื่อนไขการสิ้นสุดจะตรงตามเงื่อนไขหรือไม่

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

    บทสรุป

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

    วรรณกรรมเพิ่มเติม

    1. Vyazovik N.A. การเขียนโปรแกรมจาวา (บทที่ 1 - 4, 7, 10)

    2. Khabibullin I.Sh. Java Self Tutorial 2 (บทที่ 1)

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



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