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

หน้า JSP นอกจากแท็ก HTML แล้ว ยังมีแท็ก JSP ในหมวดหมู่ต่อไปนี้:

คำสั่ง JSP

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

ไวยากรณ์ คำสั่ง JSPดังนี้

<%@ директива имяАтрибута="значение" %>

ไวยากรณ์งาน คำสั่งใน XML:

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

คำสั่งมีสามประเภท:

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

คำสั่งหน้า JSP

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

<%@ page buffer="none" isThreadSafe="yes" errorPage="/error.jsp" %>

คำสั่งเพจประกาศว่า หน้านี้ JSP ไม่ใช้การบัฟเฟอร์ ซึ่งทำให้เข้าถึงได้พร้อมกัน หน้า JSPผู้ใช้จำนวนมากและหน้าข้อผิดพลาดที่มีชื่อ error.jsp.

คำสั่งหน้า JSPอาจมีข้อมูลเกี่ยวกับหน้า:

<%@ page info = "JSP Sample 1" %>

รายการแอตทริบิวต์ directive ที่เป็นไปได้ หน้าหนังสือนำเสนอในตาราง

ชื่อแอตทริบิวต์	ความหมาย	คำอธิบาย
ภาษา	เส้น	กำหนดภาษาที่ใช้ในสคริปต์เล็ตไฟล์ JSP นิพจน์ หรือไฟล์ที่รวมไว้ รวมถึงเนื้อหาของโค้ดที่แปลแล้ว ค่าเริ่มต้นคือ "java"
ยืดออก	เส้น	ระบุซูเปอร์คลาสสำหรับเซิร์ฟเล็ตที่สร้างขึ้น แอตทริบิวต์นี้ควรใช้อย่างระมัดระวัง เนื่องจากเป็นไปได้ว่าเซิร์ฟเวอร์กำลังใช้ซูเปอร์คลาสอยู่แล้ว
นำเข้า	เส้น	คำจำกัดความของแพ็คเกจที่จะนำเข้า เช่น <%@ page import="java.util.* %>
การประชุม	จริงหรือเท็จ	ความหมาย จริง(ค่าเริ่มต้น) ระบุว่าตัวแปรที่กำหนดไว้ล่วงหน้า การประชุม(ประเภท HttpSession) ต้องถูกผูกไว้กับเซสชันที่มีอยู่ หากมี มิฉะนั้น เซสชันใหม่จะถูกสร้างขึ้นและผูกไว้ ความหมาย เท็จกำหนดว่าจะไม่ใช้เซสชันและพยายามเข้าถึงตัวแปร การประชุมจะทำให้เกิดข้อผิดพลาดเมื่อแปลหน้า JSP เป็น servlet
กันชน	ไม่มีหรือขนาดของบัฟเฟอร์ในหน่วย kB	ตั้งค่าขนาดบัฟเฟอร์สำหรับ JspWriter ค่าเริ่มต้นขึ้นอยู่กับการตั้งค่าเซิร์ฟเวอร์และไม่ควรเกิน 8 kB ถ้าค่าเป็น ไม่มีเอาต์พุตไปที่วัตถุโดยตรง ServletResponse
ออโต้ฟลัช	จริงหรือเท็จ	กำหนดว่าควรล้างบัฟเฟอร์โดยอัตโนมัติเมื่อล้นหรือเกิดข้อผิดพลาด ค่าเริ่มต้นคือ จริง
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

คำสั่ง JSP taglib

คำสั่ง JSP 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 รวมคำสั่ง

คำสั่ง 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 ประกาศมีวัตถุประสงค์เพื่อกำหนดตัวแปรและเมธอดในภาษาสคริปต์ ซึ่งจะใช้ในหน้า JSP ในภายหลัง ไวยากรณ์ ประกาศมีลักษณะดังนี้:

<%! код Java %>

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

ประกาศสามารถมีได้หลายบรรทัด เช่น ในโค้ดด้านล่างสำหรับคำนวณค่าของฟังก์ชัน ความจริง (int n)ซึ่งควรเท่ากับ 1 เมื่อ n น้อยกว่า 2 และ n! ด้วยค่าบวกของ n;

<%! public static int fact (int n) { if (n <= 1) return 1; else return n * fact (n - 1); } %>

ประกาศห้ามสร้างเอาต์พุตใด ๆ ให้เป็นเอาต์พุตมาตรฐาน ออก... ตัวแปรและเมธอดที่ประกาศในการประกาศเริ่มต้นและพร้อมใช้งานสำหรับ scriptlets และอื่นๆ โฆษณาในขณะที่หน้า 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 นิพจน์ที่สั่งการได้ซึ่งเขียนด้วยภาษาสคริปต์ที่ระบุในการประกาศภาษา (โดยทั่วไปคือ Java) ผลลัพธ์ สำนวน JSP ซึ่งเป็นประเภท String ที่ต้องการจะถูกส่งไปยังเอาต์พุตสตรีมมาตรฐาน ออกโดยใช้วัตถุปัจจุบัน JspWriter... ถ้าผลลัพธ์คือ สำนวนหล่อไม่ได้ สตริงอาจเกิดข้อผิดพลาดในการแปลหากตรวจพบปัญหาในขั้นตอนการแปล หรือมีข้อยกเว้นเกิดขึ้น ClassCastExceptionหากตรวจพบความไม่สอดคล้องกันระหว่างการดำเนินการตามคำขอ การแสดงออกมีไวยากรณ์ต่อไปนี้:

<%= текст выражения %>

ไวยากรณ์ทางเลือกสำหรับ JSP สำนวนเมื่อใช้ XML:

ข้อความนิพจน์

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

สำนวนถูกดำเนินการในขณะที่โปรโตคอล HTTP กำลังทำงาน ค่านิพจน์จะถูกแปลงเป็นสตริงและรวมอยู่ในตำแหน่งที่เหมาะสมในไฟล์ JSP

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

เวลาปัจจุบัน:<%= new java.util.Date () %>

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

• คำขอ HttpServletRequest;
• การตอบสนอง HttpServletResponse;
• เซสชัน HttpSession - เกี่ยวข้องกับคำขอ ถ้ามี;
• ออกไป PrintWriter - เวอร์ชันบัฟเฟอร์ของประเภท JspWriter สำหรับการส่งข้อมูลไปยังไคลเอ็นต์

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

ภาษา Java ใช้เงื่อนไขต่อไปนี้: if..else และ switch..case

ถ้า / อื่นสร้าง

นิพจน์ if / else ตรวจสอบความจริงของเงื่อนไขบางอย่างและรันโค้ดบางอย่างขึ้นอยู่กับผลการทดสอบ:

Int num1 = 6; int num2 = 4; if (num1> num2) (System.out.println ("ตัวเลขตัวแรกมากกว่าตัวที่สอง"))

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

เนื่องจาก ในกรณีนี้ ตัวเลขตัวแรกมากกว่าตัวที่สอง นิพจน์ num1> num2 จึงเป็น true และคืนค่า true ดังนั้น การควบคุมจะส่งผ่านไปยังบล็อกของรหัสหลังจากวงเล็บปีกกาและเริ่มดำเนินการตามคำแนะนำที่มีอยู่ โดยเฉพาะวิธี System.out.println ("ตัวเลขแรกมากกว่าตัวเลขที่สอง"); ... หากตัวเลขแรกน้อยกว่าหรือเท่ากับตัวเลขที่สอง คำสั่งในบล็อก if จะไม่ถูกดำเนินการ

แต่ถ้าเราต้องการดำเนินการบางอย่างหากไม่เป็นไปตามเงื่อนไข ในกรณีนี้ เราสามารถเพิ่มบล็อกอื่นได้:

Int num1 = 6; int num2 = 4; if (num1> num2) (System.out.println ("หมายเลขแรกมากกว่าวินาที");) อื่น (System.out.println ("หมายเลขแรกน้อยกว่าวินาที");

Int num1 = 6; int num2 = 8; if (num1> num2) (System.out.println ("ตัวเลขตัวแรกมากกว่าตัวที่สอง")) else if (num1

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

Int num1 = 8; int num2 = 6; if (num1> num2 && num1> 7) (System.out.println ("ตัวเลขตัวแรกมากกว่าตัวที่สองและมากกว่า 7"))

ที่นี่ if block จะถูกดำเนินการถ้า num1> num2 เป็นจริงและในเวลาเดียวกัน num1> 7 เป็นจริง

โครงสร้างสวิตช์

ออกแบบ สวิตช์ / เคสคล้ายกับโครงสร้าง if / else เนื่องจากช่วยให้คุณสามารถประมวลผลหลายเงื่อนไขพร้อมกัน:

จำนวนเต็ม = 8; switch (num) (กรณีที่ 1: System.out.println ("number is 1"); break; case 8: System.out.println ("number is 8"); num ++; break; case 9: System. ออก println ("number is 9"); break; default: System.out.println ("number is not 1, 8, 9");)

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

คำสั่ง break จะถูกวางไว้ที่ส่วนท้ายของ case block เพื่อหลีกเลี่ยงการดำเนินการของ block อื่นๆ ตัวอย่างเช่น หากคำสั่ง break ถูกลบในกรณีต่อไปนี้:

กรณีที่ 8: System.out.println ("หมายเลข 8"); เลขที่ ++; กรณีที่ 9: System.out.println ("หมายเลขคือ 9"); หยุดพัก;

เนื่องจากตัวแปร num ของเราเท่ากับ 8 ดังนั้น case 8 block จะถูกดำเนินการ แต่เนื่องจากในบล็อกนี้ ตัวแปร num จะเพิ่มขึ้นหนึ่งรายการ จึงไม่มีคำสั่ง break ดังนั้น case 9 block จะเริ่มดำเนินการ

หากเราต้องการจัดการสถานการณ์เมื่อไม่พบรายการที่ตรงกัน เราก็สามารถเพิ่มบล็อกเริ่มต้นได้ดังในตัวอย่างด้านบน บล็อกเริ่มต้นเป็นทางเลือกแม้ว่า

เริ่มต้นด้วย JDK 7 ในนิพจน์ switch..case นอกเหนือจากประเภทดั้งเดิม คุณยังสามารถใช้สตริงได้:

แพ็คเกจ firstapp; นำเข้า java.util.Scanner; คลาสสาธารณะ FirstApp (โมฆะคงที่สาธารณะหลัก (สตริง args) (สแกนเนอร์ใน = สแกนเนอร์ใหม่ (System.in); System.out.println ("ป้อน Y หรือ N:"); อินพุตสตริง = in.nextLine (); สวิตช์ ( input) (ตัวพิมพ์ "Y": System.out.println ("You pressed the letter Y"); break; case "N": System.out.println ("You pressed the letter N"); break; default: System .out .println ("คุณกดตัวอักษรที่ไม่รู้จัก");)))

การดำเนินงานแบบไตรภาค

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

Int x = 3; int y = 2; int z = x

ในที่นี้ ผลลัพธ์ของการดำเนินการแบบไตรภาคคือตัวแปร z ขั้นแรกเงื่อนไข x

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

วัตถุ- วัตถุมีสภาพและพฤติกรรม ตัวอย่างเช่น: สุนัขสามารถมีสถานะ - สี, ชื่อ, เช่นเดียวกับพฤติกรรม - พยักหน้า, วิ่ง, เห่า, กิน วัตถุเป็นตัวอย่างของการเรียน.

ระดับ- สามารถกำหนดเป็นเทมเพลตที่อธิบายพฤติกรรมของวัตถุ

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

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

โปรแกรมแรกและความคุ้นเคยกับไวยากรณ์ของภาษา

มาดูโค้ดง่ายๆ ที่จะแสดงคำว่า "Hello world!" และสำหรับไวยากรณ์ Java อย่างหนึ่ง

MyFirstJavaProgram คลาสสาธารณะ (public static void main (String args) (/ * นี่เป็นโปรแกรม java แรกของฉัน การดำเนินการจะแสดง "Hello world!" * / System.out.println ("Hello world!"); / / กำลังแสดงข้อความ บนหน้าจอ))

• เปิดแผ่นจดบันทึกและเพิ่มรหัสด้านบน
• บันทึกไฟล์เป็น "MyFirstJavaProgram.java" ด้านล่างเราจะดูที่ไวยากรณ์ Java และค้นหาสาเหตุภายใต้ชื่อนั้น
• เปิดหน้าต่างพรอมต์คำสั่งและเปลี่ยนเป็นไดเร็กทอรีที่บันทึกไฟล์ สมมติว่าเป็น "C: \"
• พิมพ์ "Javac MyFirstJavaProgram.java" แล้วกด Enter เพื่อคอมไพล์โค้ด หากไม่มีข้อผิดพลาดในโค้ด บรรทัดคำสั่งจะนำคุณไปยังบรรทัดต่อไปนี้: (Assumption: The path variable is set)
• ตอนนี้ป้อน "java MyFirstJavaProgram" เพื่อเรียกใช้โปรแกรม
• ตอนนี้คุณจะเห็น "Hello World!" พิมพ์ในหน้าต่าง

C:> javac MyFirstJavaProgram.java C:> java MyFirstJavaProgram สวัสดีชาวโลก!

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

มันสำคัญมากที่จะต้องรู้และจำประเด็นต่อไปนี้ในไวยากรณ์:

• ความละเอียดอ่อนของตัวพิมพ์ - Java คำนึงถึงขนาดตัวพิมพ์ หมายความว่า สวัสดี และ สวัสดี มีความหมายต่างกัน
• ชื่อคลาส - สำหรับทุกคน อักษรตัวแรกต้องเป็นตัวพิมพ์ใหญ่
• หากมีการใช้คำหลายคำเพื่อสร้างชื่อคลาส อักษรตัวแรกของคำภายในแต่ละคำจะต้องเป็นตัวพิมพ์ใหญ่ เช่น "MyJavaClass"
• ชื่อเมธอด - ในไวยากรณ์ Java ชื่อเมธอดทั้งหมดต้องขึ้นต้นด้วยอักษรตัวพิมพ์เล็ก
• หากมีการใช้หลายคำเพื่อสร้างชื่อเมธอด อักษรตัวแรกของคำภายในแต่ละคำจะต้องเป็นตัวพิมพ์ใหญ่ เช่น "public void myMethodName ()"
• ชื่อไฟล์โปรแกรม - ชื่อไฟล์โปรแกรม must ตรงเป๊ะด้วยชื่อชั้น
• เมื่อบันทึกไฟล์ คุณต้องบันทึกโดยใช้ชื่อคลาส (อย่าลืมเกี่ยวกับตัวพิมพ์เล็กและตัวพิมพ์ใหญ่) และเพิ่ม ".java" ที่ท้ายชื่อ (หากชื่อไม่ตรงกัน โปรแกรมของคุณจะไม่คอมไพล์) เช่น " MyJavaProgram" เป็นชื่อของคลาส ดังนั้นไฟล์ควรถูกบันทึกเป็น "MyJavaProgram.java"
• public static void main (String args) - การประมวลผลโปรแกรมเริ่มต้นด้วยเมธอด Main () ซึ่งเป็นส่วนบังคับของทุกโปรแกรม

ตัวระบุ Java

ตัวระบุ- ชื่อที่ใช้สำหรับคลาส ตัวแปร และเมธอด คอมโพเนนต์ Java ทั้งหมดต้องมีชื่อ

มีกฎหลายข้อในไวยากรณ์ Java ที่ต้องจำเกี่ยวกับตัวระบุ พวกเขามีดังนี้:

• ตัวระบุแต่ละตัวต้องขึ้นต้นด้วย "A" ถึง "Z" หรือ "a" ถึง "z", "$" หรือ "_"
• การรวมกันของอักขระใดๆ สามารถอยู่หลังอักขระตัวแรกได้
• ไม่สามารถใช้คีย์เวิร์ดเป็นตัวระบุได้
• สิ่งสำคัญที่สุดคือตัวระบุใน Java คำนึงถึงขนาดตัวพิมพ์
• ตัวอย่างการสะกดที่ถูกต้อง: อายุ $ เงินเดือน _value ___1_value
• ตัวอย่างการสะกดผิด: 123abc, -salary

การแจงนับ

การแจงนับถูกนำมาใช้ใน Java 5.0 พวกเขาจำกัดตัวแปรให้เลือกค่าที่กำหนดไว้ล่วงหน้าเพียงหนึ่งค่าเท่านั้น ค่าในรายการที่แจกแจงนี้เรียกว่า โอน.

เมื่อใช้การแจงนับใน Java คุณสามารถลดจำนวนข้อผิดพลาดในโค้ดของคุณได้

ตัวอย่างเช่น หากดูคำสั่งซื้อน้ำผลไม้สดในร้านค้า เราอาจจำกัดขนาดของแพ็คน้ำผลไม้สำหรับขนาดเล็ก กลาง และใหญ่ ทำให้สามารถใช้การแจงนับใน Java ได้เพื่อไม่ให้ใครสั่งขนาดแพ็คเกจอื่นนอกจากขนาดเล็ก กลาง หรือใหญ่

ตัวอย่างโค้ด Java enum

คลาส FreshJuice (enum FreshJuiceSize (เล็ก กลาง ใหญ่) FreshJuiceSize ขนาด;) คลาสสาธารณะ FreshJuiceTest (โมฆะคงที่สาธารณะหลัก (สตริง args) (FreshJuice juice = ใหม่ FreshJuice (); juice.size = FreshJuice.FreshJuiceSize.MEDIUM; System.Juice.FreshJuiceSize.MEDIUM .println ("ขนาด:" + juice.size);))

ผลลัพธ์ที่ได้จากตัวอย่างข้างต้น:

ขนาด: MEDIUM

บันทึก:ใน Java สามารถประกาศ enums ได้อย่างอิสระหรือภายในคลาส เมธอด ตัวแปร คอนสตรัคเตอร์ สามารถกำหนดได้ในการแจงนับ

ประเภทตัวแปร

• ตัวแปรท้องถิ่น
• ตัวแปรคลาส (คงที่)
• ตัวแปรอินสแตนซ์ (ไดนามิก)

ตัวดัดแปลง

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

• ด้วยการเข้าถึง: ค่าเริ่มต้น สาธารณะ ป้องกัน ส่วนตัว
• Accessless: สุดท้าย, นามธรรม, เข้มงวดfp.

เราจะพิจารณาตัวดัดแปลงคลาส ตัวดัดแปลงวิธีการ และอื่นๆ อย่างละเอียดในหัวข้อถัดไป

Array

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

ต้องตรงกับชื่อของคลาสที่มีการเรียกเมธอด 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 เรียกว่าบูลีนในภาษาจาวา

โครงสร้างแบบมีเงื่อนไข take เท่านั้นประเภทของตัวแปรหรือนิพจน์บูลีน ซึ่งหมายความว่ารหัสมีลักษณะดังนี้:
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 รองรับเธรดผ่านคลาสเธรดในตัวและอินเตอร์เฟสที่รันได้ สำหรับการซิงโครไนซ์ ให้ใช้ตัวระบุที่ซิงโครไนซ์ก่อนเมธอดในคำอธิบายคลาส หรือซิงโครไนซ์ (