คำหลักใน Java: รายการคำหลัก Java ยอดนิยมทั้งหมด
เผยแพร่แล้ว: 2022-03-04คำหลักใน Java หมายถึงคำศัพท์สงวน 52 คำที่มีความหมายที่กำหนดไว้ล่วงหน้าในภาษาการเขียนโปรแกรม ดังนั้นจึงไม่สามารถใช้เป็นชื่อของเมธอด ตัวแปร อ็อบเจ็กต์ คลาส คลาสย่อย หรือตัวระบุได้ กล่าวอีกนัยหนึ่ง คีย์เวิร์ด Java เหล่านี้เพิ่มความหมายเฉพาะให้กับคอมไพเลอร์ Java และสงวนไว้สำหรับวัตถุประสงค์พิเศษ ดังนั้น การใช้พวกมันเป็นชื่อตัวระบุจะทำให้คอมไพเลอร์เกิดข้อผิดพลาด ใน Java มีคำหลักที่สงวนไว้ทั้งหมด 52 คำ ในจำนวนนี้ มี 49 รายการที่ใช้งานอยู่ สองรายการไม่ได้ใช้งาน และรายการหนึ่งอยู่ในการแสดงตัวอย่าง
สารบัญ
คีย์เวิร์ดยอดนิยมใน Java ที่โปรแกรมเมอร์ทุกคนควรรู้
เราได้รวบรวม คำหลักที่เกี่ยวข้องมากที่สุดใน Java การใช้งาน และตัวอย่างไว้ในรายการด้านล่าง
1. นามธรรม
คีย์เวิร์ด abstract ใน Java ใช้เพื่อประกาศคลาสนามธรรม คลาสนามธรรมสามารถมีวิธีการที่เป็นนามธรรมและไม่ใช่นามธรรมได้ แต่ไม่สามารถใช้เพื่อสร้างวัตถุได้ วิธีนามธรรมไม่มีเนื้อหาและสามารถใช้ได้เฉพาะในคลาสนามธรรมเท่านั้น คลาสย่อยที่สืบทอดมาจากการจัดหาร่างกาย ยิ่งไปกว่านั้น ในขณะที่คลาสนามธรรมสามารถขยายได้ พวกมันไม่สามารถสร้างอินสแตนซ์ได้ นอกจากนี้ ไม่สามารถใช้คีย์เวิร์ด abstract กับคอนสตรัคเตอร์และตัวแปรได้
รับด้านล่างเป็นข้อมูลโค้ดเพื่อแสดงคลาสนามธรรมด้วยวิธีการนามธรรม:
คลาสนามธรรม ยานพาหนะ
{
รถโมฆะนามธรรม ();
}
คลาส Maruti ขยายยานพาหนะ
{
@แทนที่
รถโมฆะ () {
System.out.println("รถกำลังเคลื่อนที่");
}
}
คลาสสาธารณะ AbstractExample1 {
โมฆะคงที่สาธารณะหลัก (สตริง [] args) {
Maruti obj=ใหม่ Maruti();
obj.รถ();
}
}
ผลลัพธ์: รถกำลังเคลื่อนที่
2. บูลีน
ชนิดข้อมูลดั้งเดิม คีย์เวิร์ดบูลีนใน Java สามารถเก็บได้เพียงสองค่าเท่านั้น – จริงและเท็จ ค่าดีฟอลต์ของคีย์เวิร์ดบูลีนเป็นเท็จ และโดยทั่วไปมักใช้กับคำสั่งแบบมีเงื่อนไข อย่างไรก็ตาม คีย์เวิร์ดบูลีนสามารถใช้กับเมธอดและตัวแปรได้ และการประกาศตัวแปรใดๆ ด้วยคีย์เวิร์ดบูลีนหมายความว่ามีค่าบูลีน
รับด้านล่างเป็นตัวอย่างบูลีนอย่างง่ายใน Java:
BooleanExample1 คลาสสาธารณะ {
โมฆะคงที่สาธารณะหลัก (สตริง [] args) {
int num1=67;
int num2=43;
บูลีน b1=จริง;
บูลีน b2=เท็จ;
ถ้า(num1<num2)
{
System.out.println(b1);
}
อื่น
{
System.out.println(b2);
}
}
}
ผลลัพธ์: false
3. คลาส
คลาสคีย์เวิร์ดใน Java เป็นหนึ่งในคำศัพท์ที่สงวนไว้มากที่สุด มันถูกใช้เพื่อประกาศคลาสใน Java ที่มีบล็อกของรหัสที่มีฟิลด์ เมธอด ตัวสร้าง ฯลฯ คลาสอาจมีหนึ่งคลาสหรือมากกว่า แนวคิดที่เรียกว่าคลาสที่ซ้อนกัน ทุกอ็อบเจ็กต์คืออินสแตนซ์ของคลาส และชื่อคลาสควรเป็นชื่อที่ไม่ซ้ำกันภายในแพ็กเกจ หนึ่งสามารถกำหนด abstract, public, strictfp และตัวแก้ไขสุดท้ายให้กับคลาสเท่านั้น แต่ตัวดัดแปลงอื่นๆ เช่น ไพรเวต ป้องกัน และสแตติก สามารถกำหนดให้กับคลาสภายในได้
รับด้านล่างเป็นตัวอย่างง่ายๆของ class คำสำคัญ:
ตัวอย่างคลาสสาธารณะ {
โมฆะคงที่สาธารณะหลัก (สตริง [] args) {
System.out.println("สวัสดี!");
}
}
เอาท์พุต: สวัสดี!
4. ค่าเริ่มต้น
คีย์เวิร์ดเริ่มต้นใน Java คือตัวแก้ไขการเข้าถึง ดังนั้น หากไม่ได้กำหนดตัวแก้ไขการเข้าถึงใดๆ ให้กับเมธอด ตัวแปร คลาส และตัวสร้างโดยค่าเริ่มต้น จะถือว่าเป็นตัวแก้ไขการเข้าถึงเริ่มต้น อีกทางหนึ่ง คีย์เวิร์ดเริ่มต้นสามารถใช้ในคำสั่ง switch เพื่อติดป้ายกำกับบล็อกของโค้ดที่จะดำเนินการ หากไม่มีกรณีที่ตรงกับค่าที่ระบุ จาก Java 8 คีย์เวิร์ดเริ่มต้นยังพบการใช้งานในการอนุญาตให้อินเทอร์เฟซจัดเตรียมการใช้งานเมธอด ตัวแก้ไขการเข้าถึงเริ่มต้นสามารถเข้าถึงได้ภายในแพ็คเกจเท่านั้น
รับด้านล่างเป็นข้อมูลโค้ดเป็นตัวอย่างของคำหลักเริ่มต้นใน Java:
คลาส A {
String msg=”เข้าถึงตัวแปรเริ่มต้นภายนอกคลาสภายในแพ็คเกจ”;
}
คลาสสาธารณะ DefaultExample2 {
โมฆะคงที่สาธารณะหลัก (สตริง [] args) {
A = ใหม่ A();
System.out.println(a.msg);
}
}
เอาต์พุต: เข้าถึงตัวแปรเริ่มต้นภายนอกคลาสภายใน package
5. enum
คีย์เวิร์ด enum ใน Java เป็นชนิดข้อมูลที่มีชุดค่าคงที่ที่แน่นอน กล่าวอีกนัยหนึ่ง enum สามารถคิดได้ว่าเป็นคลาสที่มีชุดค่าคงที่คงที่ enum สามารถกำหนดได้ภายในหรือภายนอกคลาส นอกจากนี้ เนื่องจาก Java enum สืบทอดคลาส Enum ภายใน จึงไม่สามารถสืบทอดคลาสอื่นได้ อย่างไรก็ตาม มันสามารถใช้อินเทอร์เฟซได้มากมาย Java enum สามารถมีฟิลด์ เมธอด ตัวสร้าง และวิธีการหลัก
ตัวอย่างคลาส Enum{
//กำหนด enum ภายในคลาส
สัปดาห์สาธารณะ { วันอาทิตย์ วันจันทร์ วันอังคาร วันพุธ วันพฤหัสบดี วันศุกร์ วันเสาร์ }
//เมธอดหลัก
โมฆะคงที่สาธารณะหลัก (สตริง [] args) {
// ข้าม enum
สำหรับ (สัปดาห์ที่ : Week.values())
System.out.println(w);
}}
เอาท์พุท:
วันอาทิตย์
วันจันทร์
วันอังคาร
วันพุธ
วันพฤหัสบดี
วันศุกร์
วันเสาร์
6. นำเข้า
คีย์เวิร์ดนำเข้าช่วยให้โปรแกรมเมอร์เข้าถึงแพ็คเกจ Java ที่มีอยู่ได้ ใช้สำหรับการนำเข้าแพ็คเกจ แพ็คเกจย่อย อินเตอร์เฟส คลาส หรือ enum ในโปรแกรม Java ไวยากรณ์สำหรับการใช้คีย์เวิร์ด Java คือ import packageName.*;
ข้อมูลโค้ดต่อไปนี้สาธิตการใช้คำสำคัญนำเข้า:
นำเข้า java.util.*; //นำเข้าคลาสและอินเทอร์เฟซทั้งหมดของแพ็คเกจ util
คลาสสาธารณะ ImportExample
{
/* รหัสไดรเวอร์ */
โมฆะคงที่สาธารณะ main(String ar[])
{
System.out.println("การใช้คำสั่งนำเข้าใน Java");
/* เมธอดจากคลาส java.util.Date */
System.out.println (วันที่ใหม่ ());
}
}
เอาท์พุท:
การใช้คำสั่งนำเข้าใน Java
ศ. 29 ต.ค. 15:42:43 UTC 2021
7. ป้องกัน
คีย์เวิร์ดที่ได้รับการป้องกันใน Java เป็นโมดิฟายเออร์การเข้าถึงที่สามารถใช้สำหรับแอ็ตทริบิวต์ คลาส คอนสตรัคเตอร์ และเมธอด และสามารถเข้าถึงได้ภายในแพ็กเกจ มันยังสามารถเข้าถึงได้นอกแพ็คเกจ แต่ผ่านการสืบทอดเท่านั้น
ตัวอย่างต่อไปนี้แสดงให้เห็นว่าตัวแปรที่ได้รับการป้องกันสามารถเข้าถึงได้ภายนอกคลาสและภายในแพ็คเกจ:
คลาส X {
msg สตริงที่ได้รับการป้องกัน=”เข้าถึงตัวแปรที่ได้รับการป้องกันภายนอกคลาสภายในแพ็คเกจ”;
}
คลาสสาธารณะ ProtectedExample2 {
โมฆะคงที่สาธารณะหลัก (สตริง [] args) {
X x=ใหม่ X();
System.out.println(x.msg);
}
}
เอาท์พุท:
เข้าถึงตัวแปรที่ได้รับการป้องกันภายนอกคลาสภายในแพ็คเกจ
8. คงที่
คีย์เวิร์ด ส แตติกใน Java ใช้สำหรับการจัดการหน่วยความจำเป็นหลัก และสามารถนำไปใช้กับเมธอด บล็อก ตัวแปร และคลาสที่ซ้อนกันได้ ดังนั้น สแตติกอาจเป็นเมธอด (เมธอดของคลาส) ตัวแปร (ตัวแปรคลาส) คลาสที่ซ้อนกัน หรือบล็อก สมาชิกของคลาสคงที่จะถูกเก็บไว้ในหน่วยความจำของคลาส และสามารถเข้าถึงได้โดยตรงผ่านชื่อคลาส ดังนั้นจึงไม่มีข้อกำหนดในการสร้างอินสแตนซ์ของคลาส ข้อได้เปรียบที่สำคัญที่สุดของตัวแปรสแตติกคือทำให้โปรแกรมหน่วยความจำมีประสิทธิภาพเนื่องจากได้รับหน่วยความจำในพื้นที่คลาสเพียงครั้งเดียวในระหว่างการโหลดคลาส
รับด้านล่างเป็นข้อมูลโค้ดเพื่อแสดงการใช้ คำหลักแบบคงที่ใน Java :
แบบทดสอบคลาส
{
// วิธีคงที่
โมฆะคงที่ abc()
{
System.out.println(“จาก abc”);
}
โมฆะคงที่สาธารณะ main(String[] args)
{
// เรียก abc โดยไม่ต้องสร้าง
// วัตถุใด ๆ ของคลาส Test
เอบีซี();
}
}
เอาท์พุท:
จาก abc
9. สุดยอด
ซู เปอร์คีย์เวิร์ดใน Java เป็นตัวแปรอ้างอิงที่ใช้เพื่ออ้างถึงอ็อบเจ็กต์คลาสพาเรนต์ การใช้งานหลักคือการเรียกใช้เมธอดคลาสพาเรนต์ทันที เมื่อใดก็ตามที่สร้างอินสแตนซ์ของคลาสย่อย อินสแตนซ์ของคลาสหลักจะถูกสร้างขึ้นโดยปริยาย ซึ่งอ้างอิงโดยตัวแปร super reference โดยสรุป ซูเปอร์คีย์เวิร์ดใน Java สามารถเรียกเมธอดคลาสพาเรนต์ คอนสตรัคเตอร์คลาสพาเรนต์ทันที และอ้างถึงตัวแปรอินสแตนซ์คลาสพาเรนต์ในทันที
รับด้านล่างเป็นข้อมูลโค้ดเพื่อแสดงการใช้ super keyword ใน Java :
ผู้ปกครองชั้นเรียน {
สีสตริง = "สีน้ำเงิน";
}
คลาส Child ขยาย Parent {
เป็นโมฆะ getColor () {
System.out.println(super.color); System.out.println(ซุปเปอร์.สี);
}
}
คลาสสาธารณะหลัก () {
โมฆะคงที่สาธารณะหลัก (สตริง args []) {
ลูก obj = ลูกใหม่ ();
obj.getColor();
}
}
เอาท์พุท:
สีฟ้า
10. ขว้าง
คีย์เวิร์ด throws ใน Java ประกาศ exception -colour ซึ่งระบุข้อยกเว้นที่เมธอดปัจจุบันอาจส่ง ดังนั้น โปรแกรมเมอร์ควรจัดเตรียมโค้ดจัดการข้อยกเว้น เพื่อรักษาโฟลว์ปกติของโปรแกรม
ตัวอย่างต่อไปนี้แสดงให้เห็นถึงการใช้คีย์เวิร์ด throws:
นำเข้า java.io.IOException;
การทดสอบคลาส{
โมฆะ m() โยน IOException{
โยน IOException ใหม่ ("อุปกรณ์ผิดพลาด"); // ตรวจสอบข้อยกเว้น
}
เป็นโมฆะ n() โยน IOException{
ม.();
}
เป็นโมฆะ p(){
พยายาม{
น();
}จับ(ข้อยกเว้น จ){System.out.println("จัดการข้อยกเว้น");}
}
โมฆะคงที่สาธารณะหลัก (สตริง args[]){
Testthrows obj=ใหม่ Testthrows();
obj.p();
System.out.println("กระแสปกติ");
}
}
เอาท์พุท:
มีการจัดการข้อยกเว้น
การไหลปกติ
รายการ คำหลักด้านบนใน Java ไม่ได้ครอบคลุมและอธิบายเฉพาะบางคำที่ใช้บ่อยที่สุดเท่านั้น มีคีย์เวิร์ด Java อื่นๆ อีกหลายคำ ซึ่งแต่ละคำมีจุดประสงค์เฉพาะในบริบทของภาษาการเขียนโปรแกรม
ในบันทึกย่อนั้น หากคุณต้องการยกระดับทักษะ Java ของคุณ upGrad's Job-linked PG Certification in Software Engineering เป็นหลักสูตรที่เหมาะสำหรับคุณ โปรแกรมออนไลน์ 5 เดือนจัดทำขึ้นเป็นพิเศษสำหรับผู้ที่ต้องการเริ่มต้นอาชีพที่มีแนวโน้มในการพัฒนาซอฟต์แวร์
ต่อไปนี้คือไฮไลต์บางส่วนเพื่อให้คุณได้ทราบคร่าวๆ ว่าหลักสูตรมีอะไรบ้าง:
- MERN Stack และความเชี่ยวชาญพิเศษ Cloud-Native
- เนื้อหามากกว่า 500 ชั่วโมงพร้อมการฝึกปฏิบัติจริงมากกว่า 350 ชั่วโมง
- 50+ เซสชันสดและห้าโครงการอุตสาหกรรม
- เครือข่ายเพียร์และกระดานสนทนา
- คำแนะนำด้านอาชีพและเครือข่ายอุตสาหกรรม
ลงทะเบียนวันนี้เพื่อเรียนรู้จากสิ่งที่ดีที่สุดในอุตสาหกรรม EdTech ระดับสูง
1. อะไรไม่ใช่คำสำคัญ Java?
ใน Java ค่า null จริง และเท็จ ไม่ใช่คีย์เวิร์ด เป็นคำสงวนสำหรับค่าตามตัวอักษรและไม่สามารถใช้เป็นตัวระบุได้
2. Java interfaces สามารถมีตัวแปรได้หรือไม่?
เช่นเดียวกับคลาส อินเตอร์เฟส Java สามารถมีตัวแปรและวิธีการ อย่างไรก็ตาม เมธอดที่ประกาศในอินเทอร์เฟซนั้นเป็นนามธรรมโดยดีฟอลต์ หมายความว่าเมธอดมีลายเซ็นเมธอดเท่านั้นที่ไม่มีเนื้อหา
3. การใช้คีย์เวิร์ดสุดท้ายใน Java คืออะไร?
คีย์เวิร์ดสุดท้ายใน Java เป็นตัวระบุที่ไม่เข้าถึงซึ่งใช้เพื่อจำกัดตัวแปร คลาส และเมธอด ดังนั้น หากคุณเริ่มต้นตัวแปรโดยใช้คีย์เวิร์ดสุดท้าย คุณจะไม่สามารถแก้ไขค่าของตัวแปรได้ ในทำนองเดียวกัน หากคุณประกาศเมธอดเป็นขั้นสุดท้าย ไม่มีคลาสย่อยใดสามารถแทนที่เมธอดได้ นอกจากนี้ คลาสที่ประกาศเป็นขั้นสุดท้ายไม่สามารถสืบทอดโดยคลาสอื่นได้เช่นกัน