วัตถุประสงค์ คุณสมบัติ และประโยชน์ของ 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 (เช่น รหัสที่มามีให้สำหรับทุกคนและทุกคนสามารถเข้าร่วมการพัฒนาเครื่องมือนี้ได้) 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 ยกกำลังของคำสั่งและคูณด้วย mantissa บางครั้งการเขียน 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 ไบต์ตามลำดับ

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

ตัวเลขจริง (ของจริง) (หรือตัวเลขทศนิยม) มีสองประเภท: ทศนิยมและสองเท่า ประเภทโฟลตใช้หน่วยความจำสูงสุด 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 มีการดำเนินการที่คล้ายกัน & และ | พวกเขาประเมินค่าของตัวถูกดำเนินการทั้งสองก่อนดำเนินการกับตัวถูกดำเนินการ

กะการทำงาน

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

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

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

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

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

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

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

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

สวิตช์ (นิพจน์) (กรณี value1: ลำดับคำสั่ง 1 ตัวแบ่ง; 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 วนรอบกับ 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 (คล้ายกับ ในขณะที่ตัวอย่างลูป):

สำหรับ (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 ของหนังสือเล่มแรกสำหรับนักเรียนทุกคนที่สมัครเรียนเพื่อให้ได้เกรดดีเยี่ยม

เพจ 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 สำหรับการส่งข้อมูลไปยังไคลเอ็นต์