Java - คู่มือฉบับย่อ

ภาษาโปรแกรม Java ได้รับการพัฒนาโดย Sun Microsystems ซึ่งริเริ่มโดย James Gosling และเผยแพร่ในปี 1995 เป็นส่วนประกอบหลักของแพลตฟอร์ม Java ของ Sun Microsystems (Java 1.0 [J2SE])

Java Standard Edition รุ่นล่าสุดคือ Java SE 8 ด้วยความก้าวหน้าของ Java และความนิยมอย่างกว้างขวางการกำหนดค่าต่างๆจึงถูกสร้างขึ้นเพื่อให้เหมาะกับแพลตฟอร์มประเภทต่างๆ ตัวอย่างเช่น J2EE for Enterprise Applications, J2ME for Mobile Applications

J2 เวอร์ชันใหม่ถูกเปลี่ยนชื่อเป็น Java SE, Java EE และ Java ME ตามลำดับ Java รับประกันว่าเป็นWrite Once, Run Anywhere.

Java คือ -

  • Object Oriented- ใน Java ทุกอย่างเป็น Object Java สามารถขยายได้อย่างง่ายดายเนื่องจากเป็นไปตาม Object model

  • Platform Independent- แตกต่างจากภาษาการเขียนโปรแกรมอื่น ๆ รวมถึง C และ C ++ เมื่อคอมไพล์ Java จะไม่รวบรวมลงในเครื่องเฉพาะแพลตฟอร์มแทนที่จะเป็นรหัสไบต์ที่เป็นอิสระจากแพลตฟอร์ม โค้ดไบต์นี้เผยแพร่ผ่านเว็บและตีความโดย Virtual Machine (JVM) บนแพลตฟอร์มใดก็ตามที่รันอยู่

  • Simple- Java ออกแบบมาให้เรียนรู้ได้ง่าย หากคุณเข้าใจแนวคิดพื้นฐานของ OOP Java มันจะเป็นเรื่องง่ายที่จะเชี่ยวชาญ

  • Secure- ด้วยคุณสมบัติที่ปลอดภัยของ Java ช่วยให้สามารถพัฒนาระบบที่ปราศจากไวรัสและไม่มีการปลอมแปลง เทคนิคการพิสูจน์ตัวตนขึ้นอยู่กับการเข้ารหัสคีย์สาธารณะ

  • Architecture-neutral - คอมไพเลอร์ Java สร้างรูปแบบไฟล์อ็อบเจ็กต์สถาปัตยกรรมที่เป็นกลางซึ่งทำให้โค้ดที่คอมไพล์สามารถเรียกใช้งานได้บนโปรเซสเซอร์หลายตัวโดยมีระบบรันไทม์ Java อยู่

  • Portable- การเป็นสถาปัตยกรรมที่เป็นกลางและไม่มีลักษณะที่ขึ้นกับการใช้งานของข้อกำหนดทำให้ Java พกพาได้ คอมไพเลอร์ใน Java เขียนด้วย ANSI C โดยมีขอบเขตการพกพาที่สะอาดซึ่งเป็นชุดย่อย POSIX

  • Robust - Java พยายามขจัดสถานการณ์ที่เกิดข้อผิดพลาดโดยเน้นที่การตรวจสอบข้อผิดพลาดในการคอมไพล์และการตรวจสอบรันไทม์

  • Multithreaded- ด้วยคุณสมบัติมัลติเธรดของ Java ทำให้สามารถเขียนโปรแกรมที่สามารถทำงานหลายอย่างพร้อมกันได้ คุณลักษณะการออกแบบนี้ช่วยให้นักพัฒนาสามารถสร้างแอปพลิเคชันแบบโต้ตอบที่สามารถทำงานได้อย่างราบรื่น

  • Interpreted- โค้ด Java byte ได้รับการแปลตามคำแนะนำของเครื่องโดยใช้งานง่ายและไม่ได้จัดเก็บไว้ที่ใด กระบวนการพัฒนามีความรวดเร็วและวิเคราะห์ได้มากขึ้นเนื่องจากการเชื่อมโยงเป็นกระบวนการที่เพิ่มขึ้นและมีน้ำหนักเบา

  • High Performance - ด้วยการใช้คอมไพเลอร์ Just-In-Time Java ทำให้มีประสิทธิภาพสูง

  • Distributed - Java ออกแบบมาสำหรับสภาพแวดล้อมแบบกระจายของอินเทอร์เน็ต

  • Dynamic- Java ถือว่ามีไดนามิกมากกว่า C หรือ C ++ เนื่องจากออกแบบมาเพื่อปรับให้เข้ากับสภาพแวดล้อมที่กำลังพัฒนา โปรแกรม Java สามารถมีข้อมูลรันไทม์จำนวนมากที่สามารถใช้เพื่อตรวจสอบและแก้ไขการเข้าถึงอ็อบเจ็กต์ในรันไทม์

ประวัติของ Java

James Gosling ริเริ่มโครงการภาษา Java ในเดือนมิถุนายน พ.ศ. 2534 เพื่อใช้ในโครงการกล่องรับสัญญาณหลายโครงการของเขา ภาษาเริ่มแรกเรียกว่า 'Oak' ตามต้นโอ๊กที่ยืนอยู่นอกสำนักงานของ Gosling ก็ใช้ชื่อว่า 'Green' และต่อมาถูกเปลี่ยนชื่อเป็น Java จากรายการคำสุ่ม

Sun เปิดตัวการใช้งานแบบสาธารณะครั้งแรกในชื่อ Java 1.0 ในปี 1995 โดยสัญญาไว้ Write Once, Run Anywhere (WORA) ให้เวลารันบนแพลตฟอร์มยอดนิยมโดยไม่มีค่าใช้จ่าย

เมื่อวันที่ 13 พฤศจิกายน 2549 Sun ได้เปิดตัว Java ส่วนใหญ่เป็นซอฟต์แวร์ฟรีและโอเพ่นซอร์สภายใต้เงื่อนไขของ GNU General Public License (GPL)

เมื่อวันที่ 8 พฤษภาคม 2550 Sun ได้เสร็จสิ้นกระบวนการทำให้โค้ดหลักของ Java ทั้งหมดเป็นแบบฟรีและเป็นโอเพ่นซอร์สนอกเหนือจากโค้ดส่วนเล็ก ๆ ที่ Sun ไม่ได้ถือลิขสิทธิ์

เครื่องมือที่คุณต้องการ

สำหรับการดำเนินการตามตัวอย่างที่กล่าวถึงในบทช่วยสอนนี้คุณจะต้องมีคอมพิวเตอร์ Pentium 200 MHz ที่มี RAM ขั้นต่ำ 64 MB (แนะนำให้ใช้ RAM 128 MB)

คุณจะต้องมีโปรแกรมต่อไปนี้ -

  • ระบบปฏิบัติการ Linux 7.1 หรือ Windows xp / 7/8
  • Java JDK 8
  • Microsoft Notepad หรือโปรแกรมแก้ไขข้อความอื่น ๆ

บทช่วยสอนนี้จะให้ทักษะที่จำเป็นในการสร้าง GUI ระบบเครือข่ายและเว็บแอปพลิเคชันโดยใช้ Java

Next คืออะไร?

บทต่อไปจะแนะนำคุณเกี่ยวกับวิธีรับ Java และเอกสารประกอบ สุดท้ายนี้จะแนะนำวิธีการติดตั้ง Java และเตรียมสภาพแวดล้อมเพื่อพัฒนาแอปพลิเคชัน Java

ในบทนี้เราจะพูดถึงแง่มุมต่างๆของการตั้งค่าสภาพแวดล้อมที่เหมาะสำหรับ Java

การตั้งค่าสภาพแวดล้อมท้องถิ่น

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

Java SE เป็นอิสระที่มีอยู่จากการเชื่อมโยงดาวน์โหลด Java คุณสามารถดาวน์โหลดเวอร์ชันตามระบบปฏิบัติการของคุณ

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

การตั้งค่าเส้นทางสำหรับ Windows

สมมติว่าคุณติดตั้ง Java ในไดเร็กทอรีc: \ Program Files \ java \ jdk -

  • คลิกขวาที่ 'My Computer' และเลือก 'Properties'

  • คลิกปุ่ม "ตัวแปรสภาพแวดล้อม" ใต้แท็บ "ขั้นสูง"

  • ตอนนี้เปลี่ยนตัวแปร 'Path' เพื่อให้มีพา ธ ไปยังไฟล์ปฏิบัติการ Java ตัวอย่างหากเส้นทางถูกตั้งค่าเป็น 'C: \ WINDOWS \ SYSTEM32' ให้เปลี่ยนเส้นทางของคุณเป็นอ่าน 'C: \ WINDOWS \ SYSTEM32; c: \ Program Files \ java \ jdk \ bin'

การตั้งค่าเส้นทางสำหรับ Linux, UNIX, Solaris, FreeBSD

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

ตัวอย่างเช่นหากคุณใช้bashเป็นเชลล์ของคุณคุณจะต้องเพิ่มบรรทัดต่อไปนี้ต่อท้าย '.bashrc: export PATH = / path / to / java: $ PATH'

บรรณาธิการ Java ยอดนิยม

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

  • Notepad - บนเครื่อง Windows คุณสามารถใช้โปรแกรมแก้ไขข้อความง่ายๆเช่น Notepad (แนะนำสำหรับบทช่วยสอนนี้), TextPad

  • Netbeans - Java IDE ที่เป็นโอเพ่นซอร์สและฟรีซึ่งสามารถดาวน์โหลดได้จาก https://www.netbeans.org/index.html.

  • Eclipse - Java IDE ที่พัฒนาโดยชุมชนโอเพนซอร์ส eclipse และสามารถดาวน์โหลดได้จาก https://www.eclipse.org/.

Next คืออะไร?

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

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

  • Object- วัตถุมีสถานะและพฤติกรรม ตัวอย่าง: สุนัขมีสถานะ - สีชื่อพันธุ์ตลอดจนพฤติกรรมเช่นกระดิกหางเห่ากินอาหาร วัตถุคือตัวอย่างของการเรียน.

  • Class - คลาสสามารถกำหนดเป็นเทมเพลต / พิมพ์เขียวที่อธิบายพฤติกรรม / สถานะที่อ็อบเจ็กต์ประเภทนั้นรองรับ

  • Methods- โดยพื้นฐานแล้ววิธีการคือพฤติกรรม คลาสสามารถมีหลายวิธี มันอยู่ในเมธอดที่เขียนลอจิกข้อมูลจะถูกจัดการและดำเนินการทั้งหมด

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

โปรแกรม Java แรก

ให้เราดูรหัสง่ายๆที่จะพิมพ์คำ Hello World.

ตัวอย่าง

public class MyFirstJavaProgram {

   /* This is my first java program.
    * This will print 'Hello World' as the output
    */

   public static void main(String []args) {
      System.out.println("Hello World"); // prints Hello World
   }
}

มาดูวิธีบันทึกไฟล์คอมไพล์และรันโปรแกรมกัน โปรดทำตามขั้นตอนต่อไป -

  • เปิดแผ่นจดบันทึกและเพิ่มรหัสตามด้านบน

  • บันทึกไฟล์เป็น: MyFirstJavaProgram.java

  • เปิดหน้าต่างพรอมต์คำสั่งและไปที่ไดเร็กทอรีที่คุณบันทึกคลาส สมมติว่าเป็น C: \.

  • พิมพ์ 'javac MyFirstJavaProgram.java' แล้วกด Enter เพื่อคอมไพล์โค้ดของคุณ หากรหัสของคุณไม่มีข้อผิดพลาดพรอมต์คำสั่งจะนำคุณไปยังบรรทัดถัดไป (สมมติฐาน: ตัวแปรเส้นทางถูกตั้งค่า)

  • ตอนนี้พิมพ์ 'java MyFirstJavaProgram' เพื่อเรียกใช้โปรแกรมของคุณ

  • คุณจะเห็น 'Hello World' พิมพ์อยู่บนหน้าต่าง

เอาต์พุต

C:\> javac MyFirstJavaProgram.java
C:\> java MyFirstJavaProgram 
Hello World

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

เกี่ยวกับโปรแกรม Java จำเป็นอย่างยิ่งที่จะต้องคำนึงถึงประเด็นต่อไปนี้

  • Case Sensitivity - Java เป็นกรณีที่สำคัญซึ่งหมายถึงตัวระบุ Hello และ hello จะมีความหมายแตกต่างกันในภาษา Java

  • Class Names- สำหรับชื่อคลาสทั้งหมดอักษรตัวแรกควรอยู่ในตัวพิมพ์ใหญ่ หากมีการใช้คำหลายคำเพื่อสร้างชื่อของชั้นเรียนอักษรตัวแรกของคำภายในแต่ละคำควรอยู่ในตัวพิมพ์ใหญ่

    Example: คลาส MyFirstJavaClass

  • Method Names- ชื่อเมธอดทั้งหมดควรขึ้นต้นด้วยตัวอักษรตัวพิมพ์เล็ก หากมีการใช้คำหลายคำเพื่อสร้างชื่อของวิธีการอักษรตัวแรกของคำภายในแต่ละคำควรอยู่ในตัวพิมพ์ใหญ่

    Example: โมฆะสาธารณะ myMethodName ()

  • Program File Name - ชื่อไฟล์โปรแกรมควรตรงกับชื่อคลาสทุกประการ

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

    Example:สมมติว่า 'MyFirstJavaProgram' คือชื่อคลาส จากนั้นไฟล์ควรถูกบันทึกเป็น'MyFirstJavaProgram.java'

  • public static void main(String args[]) - การประมวลผลโปรแกรม Java เริ่มจากเมธอด main () ซึ่งเป็นส่วนบังคับของโปรแกรม Java ทุกโปรแกรม

ตัวระบุ Java

ส่วนประกอบ Java ทั้งหมดต้องการชื่อ มีการเรียกชื่อที่ใช้สำหรับคลาสตัวแปรและวิธีการidentifiers.

ใน Java มีหลายจุดที่ต้องจำเกี่ยวกับตัวระบุ มีดังนี้ -

  • ตัวระบุทั้งหมดควรขึ้นต้นด้วยตัวอักษร (A ถึง Z หรือ a ถึง z) อักขระสกุลเงิน ($) หรือขีดล่าง (_)

  • หลังจากอักขระตัวแรกตัวระบุสามารถมีอักขระผสมกันได้

  • ไม่สามารถใช้คำสำคัญเป็นตัวระบุได้

  • สิ่งสำคัญที่สุดคือตัวระบุต้องตรงตามตัวพิมพ์เล็กและใหญ่

  • ตัวอย่างตัวระบุทางกฎหมาย: อายุ $ เงินเดือน _value __1_value

  • ตัวอย่างของตัวระบุที่ไม่ถูกต้อง: 123abc, -salary

ตัวปรับแต่ง Java

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

  • Access Modifiers - ค่าเริ่มต้นสาธารณะการป้องกันส่วนตัว

  • Non-access Modifiers - สุดท้ายนามธรรมเข้มงวด fp

เราจะดูรายละเอียดเพิ่มเติมเกี่ยวกับตัวปรับแต่งในส่วนถัดไป

ตัวแปร Java

ต่อไปนี้เป็นประเภทของตัวแปรใน Java -

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

อาร์เรย์ Java

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

Java Enums

Enums ถูกนำมาใช้ใน Java 5.0 Enums จำกัด ตัวแปรให้มีค่าที่กำหนดไว้ล่วงหน้าเพียงไม่กี่ค่า ค่าในรายการแจกแจงนี้เรียกว่า enums

ด้วยการใช้ enums คุณสามารถลดจำนวนข้อบกพร่องในโค้ดของคุณได้

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

ตัวอย่าง

class FreshJuice {
   enum FreshJuiceSize{ SMALL, MEDIUM, LARGE }
   FreshJuiceSize size;
}

public class FreshJuiceTest {

   public static void main(String args[]) {
      FreshJuice juice = new FreshJuice();
      juice.size = FreshJuice.FreshJuiceSize.MEDIUM ;
      System.out.println("Size: " + juice.size);
   }
}

ตัวอย่างข้างต้นจะให้ผลลัพธ์ดังต่อไปนี้ -

เอาต์พุต

Size: MEDIUM

Note- Enums สามารถประกาศเป็นของตนเองหรือภายในชั้นเรียน วิธีการตัวแปรตัวสร้างสามารถกำหนดได้ภายใน enums เช่นกัน

คีย์เวิร์ด Java

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

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

ความคิดเห็นใน Java

Java รองรับความคิดเห็นแบบบรรทัดเดียวและหลายบรรทัดคล้ายกับ C และ C ++ อักขระทั้งหมดที่มีอยู่ในข้อคิดเห็นใด ๆ จะถูกละเว้นโดยคอมไพเลอร์ Java

ตัวอย่าง

public class MyFirstJavaProgram {

   /* This is my first java program.
    * This will print 'Hello World' as the output
    * This is an example of multi-line comments.
    */

   public static void main(String []args) {
      // This is an example of single line comment
      /* This is also an example of single line comment. */
      System.out.println("Hello World");
   }
}

เอาต์พุต

Hello World

ใช้เส้นว่าง

บรรทัดที่มีเพียงช่องว่างสีขาวอาจมีข้อคิดเห็นเรียกว่าบรรทัดว่างและ Java จะละเว้นโดยสิ้นเชิง

มรดก

ใน Java คลาสสามารถได้มาจากคลาส โดยพื้นฐานแล้วหากคุณต้องการสร้างคลาสใหม่และนี่คือคลาสที่มีโค้ดบางส่วนที่คุณต้องการอยู่แล้วคุณสามารถได้คลาสใหม่ของคุณจากโค้ดที่มีอยู่แล้ว

แนวคิดนี้ช่วยให้คุณสามารถใช้ฟิลด์และวิธีการของคลาสที่มีอยู่ซ้ำได้โดยไม่ต้องเขียนโค้ดซ้ำในคลาสใหม่ ในสถานการณ์สมมตินี้คลาสที่มีอยู่เรียกว่าsuperclass และคลาสที่ได้รับเรียกว่า subclass.

อินเทอร์เฟซ

ในภาษา Java อินเทอร์เฟซสามารถกำหนดเป็นสัญญาระหว่างอ็อบเจ็กต์เกี่ยวกับวิธีการสื่อสารระหว่างกัน อินเทอร์เฟซมีบทบาทสำคัญในแนวคิดเรื่องการสืบทอด

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

Next คืออะไร?

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

Java เป็นภาษาเชิงวัตถุ ในฐานะภาษาที่มีคุณลักษณะเชิงวัตถุ Java สนับสนุนแนวคิดพื้นฐานดังต่อไปนี้ -

  • Polymorphism
  • Inheritance
  • Encapsulation
  • Abstraction
  • Classes
  • Objects
  • Instance
  • Method
  • ข้อความผ่าน

ในบทนี้เราจะพิจารณาแนวคิด - คลาสและวัตถุ

  • Object- วัตถุมีสถานะและพฤติกรรม ตัวอย่าง: สุนัขมีสถานะ - สีชื่อสายพันธุ์ตลอดจนพฤติกรรม - กระดิกหางเห่ากิน วัตถุคือตัวอย่างของการเรียน.

  • Class - คลาสสามารถกำหนดเป็นเทมเพลต / พิมพ์เขียวที่อธิบายพฤติกรรม / สถานะที่อ็อบเจ็กต์ประเภทรองรับ

วัตถุใน Java

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

หากเราพิจารณาสุนัขสถานะของมันคือ - ชื่อสายพันธุ์สีและพฤติกรรมคือ - เห่ากระดิกหางวิ่ง

หากคุณเปรียบเทียบออบเจ็กต์ซอฟต์แวร์กับวัตถุในโลกแห่งความเป็นจริงพวกมันมีลักษณะที่คล้ายคลึงกันมาก

ออบเจ็กต์ซอฟต์แวร์ยังมีสถานะและพฤติกรรม สถานะของอ็อบเจ็กต์ซอฟต์แวร์จะถูกเก็บไว้ในฟิลด์และพฤติกรรมจะแสดงผ่านวิธีการ

ดังนั้นในการพัฒนาซอฟต์แวร์เมธอดจะดำเนินการกับสถานะภายในของอ็อบเจ็กต์และการสื่อสารอ็อบเจ็กต์กับอ็อบเจ็กต์จะกระทำผ่านวิธี

คลาสใน Java

คลาสคือพิมพ์เขียวที่ใช้สร้างวัตถุแต่ละชิ้น

ต่อไปนี้เป็นตัวอย่างของคลาส

ตัวอย่าง

public class Dog {
   String breed;
   int age;
   String color;

   void barking() {
   }

   void hungry() {
   }

   void sleeping() {
   }
}

คลาสสามารถมีตัวแปรประเภทใดก็ได้ดังต่อไปนี้

  • Local variables- ตัวแปรที่กำหนดภายในวิธีการตัวสร้างหรือบล็อกเรียกว่าตัวแปรท้องถิ่น ตัวแปรจะถูกประกาศและเริ่มต้นภายในเมธอดและตัวแปรจะถูกทำลายเมื่อเมธอดเสร็จสมบูรณ์

  • Instance variables- ตัวแปรอินสแตนซ์คือตัวแปรภายในคลาส แต่อยู่นอกเมธอดใด ๆ ตัวแปรเหล่านี้จะเริ่มต้นเมื่อคลาสถูกสร้างอินสแตนซ์ ตัวแปรอินสแตนซ์สามารถเข้าถึงได้จากภายในเมธอดตัวสร้างหรือบล็อคของคลาสนั้น ๆ

  • Class variables - ตัวแปรคลาสคือตัวแปรที่ประกาศภายในคลาสนอกเมธอดใด ๆ ด้วยคีย์เวิร์ดแบบคงที่

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

ต่อไปนี้เป็นหัวข้อสำคัญบางส่วนที่ต้องพูดถึงเมื่อพิจารณาถึงคลาสของภาษา Java

ตัวสร้าง

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

ทุกครั้งที่สร้างออบเจ็กต์ใหม่จะมีการเรียกตัวสร้างอย่างน้อยหนึ่งตัว กฎหลักของคอนสตรัคเตอร์คือควรมีชื่อเดียวกับคลาส คลาสสามารถมีตัวสร้างได้มากกว่าหนึ่งตัว

ต่อไปนี้เป็นตัวอย่างของตัวสร้าง -

ตัวอย่าง

public class Puppy {
   public Puppy() {
   }

   public Puppy(String name) {
      // This constructor has one parameter, name.
   }
}

Java ยังรองรับSingleton Classesซึ่งคุณจะสามารถสร้างคลาสได้เพียงอินสแตนซ์เดียว

Note- เรามีผู้สร้างสองประเภทที่แตกต่างกัน เราจะพูดถึงผู้สร้างโดยละเอียดในบทต่อ ๆ ไป

การสร้างวัตถุ

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

มีสามขั้นตอนในการสร้างวัตถุจากคลาส -

  • Declaration - การประกาศตัวแปรด้วยชื่อตัวแปรที่มีประเภทออบเจ็กต์

  • Instantiation - คำหลัก 'ใหม่' ใช้ในการสร้างวัตถุ

  • Initialization- คำหลัก 'ใหม่' ตามด้วยการเรียกไปยังผู้สร้าง สายนี้เริ่มต้นวัตถุใหม่

ต่อไปนี้เป็นตัวอย่างการสร้างวัตถุ -

ตัวอย่าง

public class Puppy {
   public Puppy(String name) {
      // This constructor has one parameter, name.
      System.out.println("Passed Name is :" + name );
   }

   public static void main(String []args) {
      // Following statement would create an object myPuppy
      Puppy myPuppy = new Puppy( "tommy" );
   }
}

หากเราคอมไพล์และรันโปรแกรมข้างต้นมันจะให้ผลลัพธ์ดังต่อไปนี้ -

เอาต์พุต

Passed Name is :tommy

การเข้าถึงตัวแปรอินสแตนซ์และวิธีการ

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

/* First create an object */
ObjectReference = new Constructor();

/* Now call a variable as follows */
ObjectReference.variableName;

/* Now you can call a class method as follows */
ObjectReference.MethodName();

ตัวอย่าง

ตัวอย่างนี้อธิบายวิธีเข้าถึงตัวแปรอินสแตนซ์และวิธีการของคลาส

public class Puppy {
   int puppyAge;

   public Puppy(String name) {
      // This constructor has one parameter, name.
      System.out.println("Name chosen is :" + name );
   }

   public void setAge( int age ) {
      puppyAge = age;
   }

   public int getAge( ) {
      System.out.println("Puppy's age is :" + puppyAge );
      return puppyAge;
   }

   public static void main(String []args) {
      /* Object creation */
      Puppy myPuppy = new Puppy( "tommy" );

      /* Call class method to set puppy's age */
      myPuppy.setAge( 2 );

      /* Call another class method to get puppy's age */
      myPuppy.getAge( );

      /* You can access instance variable as follows as well */
      System.out.println("Variable Value :" + myPuppy.puppyAge );
   }
}

หากเราคอมไพล์และรันโปรแกรมข้างต้นมันจะให้ผลลัพธ์ดังต่อไปนี้ -

เอาต์พุต

Name chosen is :tommy
Puppy's age is :2
Variable Value :2

กฎการประกาศไฟล์ต้นฉบับ

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

  • สามารถมีคลาสสาธารณะได้เพียงหนึ่งคลาสต่อไฟล์ต้นทาง

  • ซอร์สไฟล์สามารถมีคลาสที่ไม่เป็นสาธารณะได้หลายคลาส

  • ชื่อคลาสสาธารณะควรเป็นชื่อของซอร์สไฟล์เช่นกันซึ่งควรต่อท้ายด้วย .javaในตอนท้าย ตัวอย่างเช่นชื่อคลาสเป็นคลาสสาธารณะ Employee {}ดังนั้นซอร์สไฟล์ควรเป็น Employee.java

  • ถ้าคลาสถูกกำหนดไว้ภายในแพ็กเกจคำสั่งแพ็กเกจควรเป็นคำสั่งแรกในไฟล์ต้นทาง

  • หากมีคำสั่ง import จะต้องเขียนระหว่างคำสั่ง package และ class declaration หากไม่มีคำสั่งแพ็กเกจคำสั่งนำเข้าควรเป็นบรรทัดแรกในไฟล์ต้นฉบับ

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

ชั้นเรียนมีระดับการเข้าถึงหลายระดับและมีชั้นเรียนหลายประเภท คลาสนามธรรมคลาสสุดท้าย ฯลฯ เราจะอธิบายเกี่ยวกับสิ่งเหล่านี้ทั้งหมดในบทตัวปรับการเข้าถึง

นอกเหนือจากประเภทของคลาสที่กล่าวมาแล้ว Java ยังมีคลาสพิเศษบางคลาสที่เรียกว่าคลาสภายในและคลาส Anonymous

แพ็คเกจ Java

พูดง่ายๆก็คือวิธีการจัดหมวดหมู่คลาสและอินเทอร์เฟซ เมื่อพัฒนาแอปพลิเคชันใน Java จะมีการเขียนคลาสและอินเทอร์เฟซหลายร้อยรายการดังนั้นการจัดหมวดหมู่คลาสเหล่านี้จึงเป็นสิ่งที่จำเป็นและทำให้ชีวิตง่ายขึ้นมาก

นำเข้างบ

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

ตัวอย่างเช่นบรรทัดต่อไปนี้จะขอให้คอมไพลเลอร์โหลดคลาสทั้งหมดที่มีอยู่ในไดเร็กทอรี java_installation / java / io -

import java.io.*;

กรณีศึกษาง่ายๆ

สำหรับกรณีศึกษาของเราเราจะสร้างสองคลาส พวกเขาคือ Employee และ EmployeeTest

ก่อนอื่นให้เปิดแผ่นจดบันทึกและเพิ่มรหัสต่อไปนี้ จำไว้ว่านี่คือคลาสพนักงานและคลาสนี้เป็นคลาสสาธารณะ ตอนนี้บันทึกไฟล์ต้นฉบับนี้ด้วยชื่อ Employee.java

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

ตัวอย่าง

import java.io.*;
public class Employee {

   String name;
   int age;
   String designation;
   double salary;

   // This is the constructor of the class Employee
   public Employee(String name) {
      this.name = name;
   }

   // Assign the age of the Employee  to the variable age.
   public void empAge(int empAge) {
      age = empAge;
   }

   /* Assign the designation to the variable designation.*/
   public void empDesignation(String empDesig) {
      designation = empDesig;
   }

   /* Assign the salary to the variable	salary.*/
   public void empSalary(double empSalary) {
      salary = empSalary;
   }

   /* Print the Employee details */
   public void printEmployee() {
      System.out.println("Name:"+ name );
      System.out.println("Age:" + age );
      System.out.println("Designation:" + designation );
      System.out.println("Salary:" + salary);
   }
}

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

ต่อไปนี้คือคลาสEmployeeTestซึ่งสร้างสองอินสแตนซ์ของคลาส Employee และเรียกใช้เมธอดสำหรับแต่ละอ็อบเจ็กต์เพื่อกำหนดค่าสำหรับตัวแปรแต่ละตัว

บันทึกรหัสต่อไปนี้ในไฟล์ EmployeeTest.java

import java.io.*;
public class EmployeeTest {

   public static void main(String args[]) {
      /* Create two objects using constructor */
      Employee empOne = new Employee("James Smith");
      Employee empTwo = new Employee("Mary Anne");

      // Invoking methods for each object created
      empOne.empAge(26);
      empOne.empDesignation("Senior Software Engineer");
      empOne.empSalary(1000);
      empOne.printEmployee();

      empTwo.empAge(21);
      empTwo.empDesignation("Software Engineer");
      empTwo.empSalary(500);
      empTwo.printEmployee();
   }
}

ตอนนี้รวบรวมทั้งสองคลาสแล้วเรียกใช้EmployeeTestเพื่อดูผลลัพธ์ดังนี้ -

เอาต์พุต

C:\> javac Employee.java
C:\> javac EmployeeTest.java
C:\> java EmployeeTest
Name:James Smith
Age:26
Designation:Senior Software Engineer
Salary:1000.0
Name:Mary Anne
Age:21
Designation:Software Engineer
Salary:500.0

Next คืออะไร?

ในเซสชันถัดไปเราจะพูดถึงประเภทข้อมูลพื้นฐานใน Java และวิธีใช้เมื่อพัฒนาแอปพลิเคชัน Java

ตัวสร้างเริ่มต้นอ็อบเจ็กต์เมื่อสร้างขึ้น มีชื่อเดียวกับคลาสและมีลักษณะทางไวยากรณ์คล้ายกับวิธีการ อย่างไรก็ตามคอนสตรัคเตอร์ไม่มีประเภทการส่งคืนที่ชัดเจน

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

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

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์ของตัวสร้าง -

class ClassName {
   ClassName() {
   }
}

Java อนุญาตให้มีตัวสร้างสองประเภทคือ -

  • ไม่มีตัวสร้างอาร์กิวเมนต์
  • ตัวสร้างพารามิเตอร์

ไม่มีตัวสร้างอาร์กิวเมนต์

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

ตัวอย่าง

Public class MyClass {
   Int num;
   MyClass() {
      num = 100;
   }
}

คุณจะเรียกตัวสร้างเพื่อเตรียมใช้งานวัตถุดังต่อไปนี้

public class ConsDemo {
   public static void main(String args[]) {
      MyClass t1 = new MyClass();
      MyClass t2 = new MyClass();
      System.out.println(t1.num + " " + t2.num);
   }
}

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้

100 100

ตัวสร้างพารามิเตอร์

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

ตัวอย่าง

นี่คือตัวอย่างง่ายๆที่ใช้ตัวสร้าง -

// A simple constructor.
class MyClass {
   int x;
   
   // Following is the constructor
   MyClass(int i ) {
      x = i;
   }
}

คุณจะเรียกตัวสร้างเพื่อเริ่มต้นวัตถุดังต่อไปนี้ -

public class ConsDemo {
   public static void main(String args[]) {
      MyClass t1 = new MyClass( 10 );
      MyClass t2 = new MyClass( 20 );
      System.out.println(t1.x + " " + t2.x);
   }
}

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -

10 20

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

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

มีข้อมูลสองประเภทใน Java -

  • ประเภทข้อมูลดั้งเดิม
  • ประเภทข้อมูลอ้างอิง / ออบเจ็กต์

ประเภทข้อมูลดั้งเดิม

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

ไบต์

  • ชนิดข้อมูลไบต์คือจำนวนเต็มเสริมของสองที่ลงนาม 8 บิต

  • ค่าต่ำสุดคือ -128 (-2 ^ 7)

  • ค่าสูงสุดคือ 127 (รวม) (2 ^ 7 -1)

  • ค่าดีฟอลต์คือ 0

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

  • ตัวอย่าง: byte a = 100, byte b = -50

สั้น

  • ชนิดข้อมูลแบบสั้นคือจำนวนเต็มเสริมของสองเซ็น 16 บิต

  • ค่าต่ำสุดคือ -32,768 (-2 ^ 15)

  • ค่าสูงสุดคือ 32,767 (รวม) (2 ^ 15 -1)

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

  • ค่าดีฟอลต์คือ 0

  • ตัวอย่าง: short s = 10000, short r = -20000

int

  • ชนิดข้อมูล Int คือจำนวนเต็มเสริมของสองเครื่องหมาย 32 บิต

  • ค่าต่ำสุดคือ - 2,147,483,648 (-2 ^ 31)

  • ค่าสูงสุดคือ 2,147,483,647 (รวม) (2 ^ 31 -1)

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

  • ค่าเริ่มต้นคือ 0

  • ตัวอย่าง: int a = 100000, int b = -200000

ยาว

  • ชนิดข้อมูลแบบยาวคือจำนวนเต็มเสริมของสองเครื่องหมาย 64 บิต
  • ค่าต่ำสุดคือ -9,223,372,036,854,775,808 (-2 ^ 63)
  • ค่าสูงสุดคือ 9,223,372,036,854,775,807 (รวม) (2 ^ 63 -1)
  • ประเภทนี้ใช้เมื่อต้องการช่วงที่กว้างกว่า int
  • ค่าเริ่มต้นคือ 0L
  • ตัวอย่าง: long a = 100000L, long b = -200000L

ลอย

  • ประเภทข้อมูล Float คือจุดลอยตัว IEEE 754 32 บิตที่มีความแม่นยำเดียว

  • Float ส่วนใหญ่จะใช้เพื่อบันทึกหน่วยความจำในอาร์เรย์ขนาดใหญ่ของตัวเลขทศนิยม

  • ค่าดีฟอลต์คือ 0.0f

  • ไม่มีการใช้ประเภทข้อมูล Float สำหรับค่าที่แน่นอนเช่นสกุลเงิน

  • ตัวอย่าง: float f1 = 234.5f

สองเท่า

  • ชนิดข้อมูลคู่คือจุดลอยตัว IEEE 754 64 บิตที่มีความแม่นยำสองเท่า

  • โดยทั่วไปประเภทข้อมูลนี้จะใช้เป็นชนิดข้อมูลเริ่มต้นสำหรับค่าทศนิยมโดยทั่วไปจะเป็นตัวเลือกเริ่มต้น

  • ไม่ควรใช้ประเภทข้อมูลคู่สำหรับค่าที่แน่นอนเช่นสกุลเงิน

  • ค่าดีฟอลต์คือ 0.0d

  • ตัวอย่าง: double d1 = 123.4

บูลีน

  • ชนิดข้อมูลบูลีนแสดงถึงข้อมูลหนึ่งบิต
  • ค่าที่เป็นไปได้มีเพียงสองค่าเท่านั้น: จริงและเท็จ
  • ชนิดข้อมูลนี้ใช้สำหรับแฟล็กธรรมดาที่ติดตามเงื่อนไขจริง / เท็จ
  • ค่าเริ่มต้นเป็นเท็จ
  • ตัวอย่าง: boolean one = true

ถ่าน

  • ชนิดข้อมูล char เป็นอักขระ Unicode 16 บิตเดียว
  • ค่าต่ำสุดคือ "\ u0000" (หรือ 0)
  • ค่าสูงสุดคือ "\ uffff" (หรือรวม 65,535)
  • ชนิดข้อมูล Char ใช้ในการจัดเก็บอักขระใด ๆ
  • ตัวอย่าง: char letterA = 'A'

ประเภทข้อมูลอ้างอิง

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

  • คลาสออบเจ็กต์และตัวแปรอาร์เรย์ประเภทต่างๆอยู่ภายใต้ประเภทข้อมูลอ้างอิง

  • ค่าเริ่มต้นของตัวแปรอ้างอิงใด ๆ เป็นค่าว่าง

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

  • ตัวอย่าง: Animal animal = สัตว์ใหม่ ("ยีราฟ");

Java Literals

ลิเทอรัลคือการแสดงซอร์สโค้ดของค่าคงที่ โดยจะแสดงโดยตรงในโค้ดโดยไม่มีการคำนวณใด ๆ

สามารถกำหนดตัวอักษรให้กับตัวแปรประเภทดั้งเดิม ตัวอย่างเช่น -

byte a = 68;
char a = 'A';

ไบต์ int ยาวและสั้นสามารถแสดงเป็นเลขฐานสิบ (ฐาน 10) เลขฐานสิบหก (ฐาน 16) หรือฐานแปด (ฐาน 8) ได้เช่นกัน

คำนำหน้า 0 ใช้เพื่อระบุฐานแปดและคำนำหน้า 0x ระบุเลขฐานสิบหกเมื่อใช้ระบบตัวเลขเหล่านี้สำหรับตัวอักษร ตัวอย่างเช่น -

int decimal = 100;
int octal = 0144;
int hexa =  0x64;

สตริงลิเทอรัลใน Java ถูกระบุเหมือนกับในภาษาอื่น ๆ ส่วนใหญ่โดยใส่ลำดับของอักขระระหว่างคู่ของเครื่องหมายคำพูดคู่ ตัวอย่างของตัวอักษรสตริงคือ -

ตัวอย่าง

"Hello World"
"two\nlines"
"\"This is in quotes\""

ประเภทสตริงและอักขระอักขระสามารถมีอักขระ Unicode ใดก็ได้ ตัวอย่างเช่น -

char a = '\u0001';
String a = "\u0001";

ภาษา Java สนับสนุนลำดับการหลีกพิเศษบางอย่างสำหรับ String และตัวอักษร char ด้วย พวกเขาคือ -

สัญกรณ์ ตัวละครที่แสดง
\ n ขึ้นบรรทัดใหม่ (0x0a)
\ r การกลับรถ (0x0d)
\ ฉ Formfeed (0x0c)
\ b Backspace (0x08)
\ s พื้นที่ (0x20)
\ t แท็บ
\ " อ้างสองครั้ง
\ ' ใบเสนอราคาเดียว
\\ แบ็กสแลช
\ ddd อักขระเลขฐานแปด (DDD)
\ uxxxx อักขระ UNICODE เลขฐานสิบหก (xxxx)

Next คืออะไร?

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

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

คุณต้องประกาศตัวแปรทั้งหมดก่อนจึงจะใช้ได้ ต่อไปนี้เป็นรูปแบบพื้นฐานของการประกาศตัวแปร -

data type variable [ = value][, variable [ = value] ...] ;

ประเภทข้อมูลที่นี่เป็นหนึ่งในประเภทข้อมูลของ Java และตัวแปรคือชื่อของตัวแปร หากต้องการประกาศมากกว่าหนึ่งตัวแปรของประเภทที่ระบุคุณสามารถใช้รายการที่คั่นด้วยจุลภาค

ต่อไปนี้เป็นตัวอย่างที่ถูกต้องของการประกาศตัวแปรและการเริ่มต้นใน Java -

ตัวอย่าง

int a, b, c;         // Declares three ints, a, b, and c.
int a = 10, b = 10;  // Example of initialization
byte B = 22;         // initializes a byte type variable B.
double pi = 3.14159; // declares and assigns a value of PI.
char a = 'A';        // the char variable a iis initialized with value 'a'

บทนี้จะอธิบายประเภทตัวแปรต่างๆที่มีอยู่ในภาษา Java ตัวแปรใน Java มีสามประเภท -

  • ตัวแปรท้องถิ่น
  • ตัวแปรอินสแตนซ์
  • คลาส / ตัวแปรคงที่

ตัวแปรท้องถิ่น

  • ตัวแปรท้องถิ่นถูกประกาศในวิธีการตัวสร้างหรือบล็อก

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

  • ไม่สามารถใช้ตัวปรับแต่งการเข้าถึงสำหรับตัวแปรโลคัล

  • ตัวแปรโลคัลสามารถมองเห็นได้ภายในเมธอดตัวสร้างหรือบล็อกที่ประกาศไว้เท่านั้น

  • ตัวแปรท้องถิ่นถูกนำไปใช้ที่ระดับสแต็กภายใน

  • ไม่มีค่าเริ่มต้นสำหรับตัวแปรโลคัลดังนั้นควรประกาศตัวแปรโลคัลและควรกำหนดค่าเริ่มต้นก่อนการใช้งานครั้งแรก

ตัวอย่าง

นี่อายุเป็นตัวแปรท้องถิ่น สิ่งนี้ถูกกำหนดไว้ภายในเมธอด pupAge ()และขอบเขตถูก จำกัด ไว้เฉพาะเมธอดนี้เท่านั้น

public class Test {
   public void pupAge() {
      int age = 0;
      age = age + 7;
      System.out.println("Puppy age is : " + age);
   }

   public static void main(String args[]) {
      Test test = new Test();
      test.pupAge();
   }
}

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -

เอาต์พุต

Puppy age is: 7

ตัวอย่าง

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

public class Test {
   public void pupAge() {
      int age;
      age = age + 7;
      System.out.println("Puppy age is : " + age);
   }

   public static void main(String args[]) {
      Test test = new Test();
      test.pupAge();
   }
}

สิ่งนี้จะทำให้เกิดข้อผิดพลาดต่อไปนี้ขณะคอมไพล์ -

เอาต์พุต

Test.java:4:variable number might not have been initialized
age = age + 7;
         ^
1 error

ตัวแปรอินสแตนซ์

  • มีการประกาศตัวแปรอินสแตนซ์ในคลาส แต่อยู่นอกเมธอดตัวสร้างหรือบล็อกใด ๆ

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

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

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

  • สามารถประกาศตัวแปรอินสแตนซ์ในระดับชั้นเรียนก่อนหรือหลังการใช้งาน

  • สามารถกำหนดตัวปรับแต่งการเข้าถึงสำหรับตัวแปรอินสแตนซ์

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

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

  • ตัวแปรอินสแตนซ์สามารถเข้าถึงได้โดยตรงโดยการเรียกชื่อตัวแปรภายในคลาส อย่างไรก็ตามภายในวิธีการแบบคงที่ (เมื่อตัวแปรอินสแตนซ์ได้รับการเข้าถึง) ควรเรียกใช้โดยใช้ชื่อแบบเต็ม ObjectReference.VariableName

ตัวอย่าง

import java.io.*;
public class Employee {

   // this instance variable is visible for any child class.
   public String name;

   // salary  variable is visible in Employee class only.
   private double salary;

   // The name variable is assigned in the constructor.
   public Employee (String empName) {
      name = empName;
   }

   // The salary variable is assigned a value.
   public void setSalary(double empSal) {
      salary = empSal;
   }

   // This method prints the employee details.
   public void printEmp() {
      System.out.println("name  : " + name );
      System.out.println("salary :" + salary);
   }

   public static void main(String args[]) {
      Employee empOne = new Employee("Ransika");
      empOne.setSalary(1000);
      empOne.printEmp();
   }
}

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -

เอาต์พุต

name  : Ransika
salary :1000.0

คลาส / ตัวแปรคงที่

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

  • จะมีเพียงหนึ่งสำเนาของตัวแปรคลาสต่อคลาสเท่านั้นไม่ว่าจะสร้างอ็อบเจ็กต์จากจำนวนเท่าใดก็ตาม

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

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

  • ตัวแปรคงถูกสร้างขึ้นเมื่อโปรแกรมเริ่มทำงานและทำลายเมื่อโปรแกรมหยุดทำงาน

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

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

  • ตัวแปรคงที่สามารถเข้าถึงได้โดยการเรียกด้วยชื่อชั้นClassName.VariableName

  • เมื่อประกาศตัวแปรคลาสเป็น public static final ชื่อตัวแปร (ค่าคงที่) จะเป็นตัวพิมพ์ใหญ่ทั้งหมด หากตัวแปรคงที่ไม่ใช่แบบสาธารณะและสุดท้ายไวยากรณ์การตั้งชื่อจะเหมือนกับอินสแตนซ์และตัวแปรโลคัล

ตัวอย่าง

import java.io.*;
public class Employee {

   // salary  variable is a private static variable
   private static double salary;

   // DEPARTMENT is a constant
   public static final String DEPARTMENT = "Development ";

   public static void main(String args[]) {
      salary = 1000;
      System.out.println(DEPARTMENT + "average salary:" + salary);
   }
}

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -

เอาต์พุต

Development average salary:1000

Note - หากมีการเข้าถึงตัวแปรจากคลาสภายนอกค่าคงที่ควรเข้าถึงเป็น Employee.DEPARTMENT

Next คืออะไร?

คุณได้ใช้ตัวแก้ไขการเข้าถึง (สาธารณะและส่วนตัว) ในบทนี้แล้ว บทต่อไปจะอธิบายรายละเอียด Access Modifiers และ Non-Access Modifiers

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

  • Java Access Modifiers

  • Non Access Modifiers

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

ตัวอย่าง

public class className {
   // ...
}

private boolean myFlag;
static final double weeks = 9.5;
protected static final int BOXWIDTH = 42;

public static void main(String[] arguments) {
   // body of method
}

ตัวปรับการควบคุมการเข้าถึง

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

  • มองเห็นแพ็กเกจซึ่งเป็นค่าเริ่มต้น ไม่จำเป็นต้องมีตัวปรับแต่ง
  • ปรากฏแก่ชั้นเรียนเท่านั้น (ส่วนตัว)
  • ปรากฏแก่โลก (สาธารณะ)
  • มองเห็นแพ็กเกจและคลาสย่อยทั้งหมด (มีการป้องกัน)

Non-Access Modifiers

Java จัดเตรียมตัวดัดแปลงที่ไม่สามารถเข้าถึงได้จำนวนหนึ่งเพื่อให้สามารถใช้งานฟังก์ชันอื่น ๆ ได้มากมาย

  • คงปรับปรุงสำหรับการสร้างวิธีการเรียนและตัวแปร

  • สุดท้ายปรับปรุงสำหรับจบการใช้งานของการเรียนวิธีการและตัวแปร

  • นามธรรมปรับปรุงสำหรับการสร้างคลาสนามธรรมและวิธีการ

  • ตรงกันและมีความผันผวนปรับเปลี่ยนซึ่งจะใช้สำหรับหัวข้อ

Next คืออะไร?

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

Java จัดเตรียมชุดตัวดำเนินการที่หลากหลายเพื่อจัดการกับตัวแปร เราสามารถแบ่งตัวดำเนินการ Java ทั้งหมดออกเป็นกลุ่มต่อไปนี้ -

  • ตัวดำเนินการเลขคณิต
  • ตัวดำเนินการเชิงสัมพันธ์
  • ตัวดำเนินการ Bitwise
  • ตัวดำเนินการทางตรรกะ
  • ผู้ดำเนินการมอบหมาย
  • ตัวดำเนินการอื่น ๆ

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

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

สมมติตัวแปรจำนวนเต็ม A ถือ 10 และตัวแปร B ถือ 20 จากนั้น -

แสดงตัวอย่าง

ตัวดำเนินการ คำอธิบาย ตัวอย่าง
+ (เพิ่มเติม) เพิ่มค่าที่ด้านใดด้านหนึ่งของตัวดำเนินการ A + B จะให้ 30
- (การลบ) ลบตัวถูกดำเนินการทางขวามือออกจากตัวถูกดำเนินการด้านซ้าย A - B จะให้ -10
* (การคูณ) คูณค่าที่ด้านใดด้านหนึ่งของตัวดำเนินการ A * B จะให้ 200
/ (แผนก) แบ่งตัวถูกดำเนินการทางซ้ายด้วยตัวถูกดำเนินการทางขวามือ B / A จะให้ 2
% (โมดูลัส) หารตัวถูกดำเนินการทางซ้ายด้วยตัวถูกดำเนินการทางขวามือและส่งคืนส่วนที่เหลือ B% A จะให้ 0
++ (เพิ่มขึ้น) เพิ่มค่าของตัวถูกดำเนินการขึ้น 1 B ++ ให้ 21
- (ลดลง) ลดค่าของตัวถูกดำเนินการลง 1 B-- ให้ 19

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

มีตัวดำเนินการเชิงสัมพันธ์ต่อไปนี้ที่สนับสนุนโดยภาษา Java

สมมติว่าตัวแปร A ถือ 10 และตัวแปร B ถือ 20 จากนั้น -

แสดงตัวอย่าง

ตัวดำเนินการ คำอธิบาย ตัวอย่าง
== (เท่ากับ) ตรวจสอบว่าค่าของตัวถูกดำเนินการสองค่าเท่ากันหรือไม่ถ้าใช่เงื่อนไขจะกลายเป็นจริง (A == B) ไม่เป็นความจริง
! = (ไม่เท่ากับ) ตรวจสอบว่าค่าของตัวถูกดำเนินการสองค่าเท่ากันหรือไม่หากค่าไม่เท่ากันเงื่อนไขจะกลายเป็นจริง (A! = B) เป็นจริง
> (มากกว่า) ตรวจสอบว่าค่าของตัวถูกดำเนินการด้านซ้ายมากกว่าค่าของตัวถูกดำเนินการด้านขวาหรือไม่ถ้าใช่เงื่อนไขจะกลายเป็นจริง (A> B) ไม่เป็นความจริง
<(น้อยกว่า) ตรวจสอบว่าค่าของตัวถูกดำเนินการด้านซ้ายน้อยกว่าค่าของตัวถูกดำเนินการด้านขวาหรือไม่ถ้าใช่เงื่อนไขจะกลายเป็นจริง (A <B) เป็นจริง
> = (มากกว่าหรือเท่ากับ) ตรวจสอบว่าค่าของตัวถูกดำเนินการด้านซ้ายมากกว่าหรือเท่ากับค่าของตัวถูกดำเนินการด้านขวาหรือไม่ถ้าใช่เงื่อนไขจะกลายเป็นจริง (A> = B) ไม่เป็นความจริง
<= (น้อยกว่าหรือเท่ากับ) ตรวจสอบว่าค่าของตัวถูกดำเนินการด้านซ้ายน้อยกว่าหรือเท่ากับค่าของตัวถูกดำเนินการด้านขวาหรือไม่ถ้าใช่เงื่อนไขจะกลายเป็นจริง (A <= B) เป็นจริง

ตัวดำเนินการ Bitwise

Java กำหนดตัวดำเนินการระดับบิตหลายตัวซึ่งสามารถใช้ได้กับประเภทจำนวนเต็ม long, int, short, char และ byte

ตัวดำเนินการ Bitwise ทำงานบนบิตและดำเนินการแบบบิตต่อบิต สมมติว่า a = 60 และ b = 13; ตอนนี้ในรูปแบบไบนารีพวกเขาจะเป็นดังนี้ -

a = 0011 1100

b = 0000 1101

-----------------

a & b = 0000 1100

a | b = 0011 1101

a ^ b = 0011 0001

~ a = 1100 0011

ตารางต่อไปนี้แสดงรายการตัวดำเนินการระดับบิต -

สมมติตัวแปรจำนวนเต็ม A ถือ 60 และตัวแปร B ถือ 13 แล้ว -

แสดงตัวอย่าง

ตัวดำเนินการ คำอธิบาย ตัวอย่าง
& (bitwise และ) ไบนารี AND Operator จะคัดลอกบิตไปยังผลลัพธ์หากมีอยู่ในตัวถูกดำเนินการทั้งสอง (A & B) จะให้ 12 ซึ่งเท่ากับ 0000 1100
| (บิตหรือ) ไบนารีหรือตัวดำเนินการจะคัดลอกบิตหากมีอยู่ในตัวถูกดำเนินการอย่างใดอย่างหนึ่ง (A | B) จะให้ 61 ซึ่งก็คือ 0011 1101
^ (XOR แบบบิต) ตัวดำเนินการ XOR ไบนารีจะคัดลอกบิตหากตั้งค่าไว้ในตัวถูกดำเนินการเดียว แต่ไม่ใช่ทั้งสองอย่าง (A ^ B) จะให้ 49 ซึ่งก็คือ 0011 0001
~ (ชมเชยระดับบิต) Binary Ones Complement Operator เป็นเอกภาพและมีผลของบิต 'พลิก' (~ A) จะให้ -61 ซึ่งก็คือ 1100 0011 ในรูปแบบส่วนเติมเต็มของ 2 เนื่องจากเลขฐานสองที่ลงนาม
<< (เลื่อนซ้าย) ตัวดำเนินการกะซ้ายแบบไบนารี ค่าตัวถูกดำเนินการด้านซ้ายจะถูกย้ายไปทางซ้ายตามจำนวนบิตที่ระบุโดยตัวถูกดำเนินการด้านขวา A << 2 จะให้ 240 ซึ่งก็คือ 1111 0000
>> (กะขวา) ตัวดำเนินการกะไบนารีขวา ค่าตัวถูกดำเนินการด้านซ้ายจะถูกย้ายไปทางขวาตามจำนวนบิตที่ระบุโดยตัวถูกดำเนินการด้านขวา A >> 2 จะให้ 15 ซึ่งก็คือ 1111
>>> (ศูนย์เติมกะขวา) เลื่อนตัวดำเนินการเติมศูนย์ไปทางขวา ค่าตัวถูกดำเนินการด้านซ้ายจะถูกย้ายไปทางขวาตามจำนวนบิตที่ระบุโดยตัวถูกดำเนินการด้านขวาและค่าที่เลื่อนจะเต็มไปด้วยศูนย์ A >>> 2 จะให้ 15 ซึ่งก็คือ 0000 1111

ตัวดำเนินการทางตรรกะ

ตารางต่อไปนี้แสดงรายการตัวดำเนินการทางตรรกะ -

สมมติว่าตัวแปรบูลีน A ถือเป็นจริงและตัวแปร B ถือเป็นเท็จจากนั้น -

แสดงตัวอย่าง

ตัวดำเนินการ คำอธิบาย ตัวอย่าง
&& (ตรรกะและ) เรียกว่าตัวดำเนินการ Logical AND ถ้าตัวถูกดำเนินการทั้งสองไม่ใช่ศูนย์เงื่อนไขจะกลายเป็นจริง (A && B) เป็นเท็จ
|| (ตรรกะหรือ) เรียกว่า Logical OR Operator หากตัวถูกดำเนินการสองตัวใดตัวหนึ่งไม่ใช่ศูนย์เงื่อนไขจะกลายเป็นจริง (A || B) เป็นจริง
! (ตรรกะไม่) เรียกว่า Logical NOT Operator ใช้เพื่อย้อนกลับสถานะตรรกะของตัวถูกดำเนินการ หากเงื่อนไขเป็นจริงตัวดำเนินการ Logical NOT จะสร้างเท็จ ! (A && B) เป็นเรื่องจริง

ผู้ดำเนินการมอบหมาย

ต่อไปนี้เป็นตัวดำเนินการกำหนดที่รองรับโดยภาษา Java -

แสดงตัวอย่าง

ตัวดำเนินการ คำอธิบาย ตัวอย่าง
= ตัวดำเนินการกำหนดง่าย กำหนดค่าจากตัวถูกดำเนินการด้านขวาไปยังตัวถูกดำเนินการด้านซ้าย C = A + B จะกำหนดค่า A + B ให้เป็น C
+ = เพิ่มและกำหนดตัวดำเนินการ เพิ่มตัวถูกดำเนินการด้านขวาให้กับตัวถูกดำเนินการด้านซ้ายและกำหนดผลลัพธ์ให้กับตัวถูกดำเนินการด้านซ้าย C + = A เทียบเท่ากับ C = C + A
- = ตัวดำเนินการลบและกำหนด มันจะลบตัวถูกดำเนินการด้านขวาออกจากตัวถูกดำเนินการด้านซ้ายและกำหนดผลลัพธ์ให้กับตัวถูกดำเนินการด้านซ้าย C - = A เทียบเท่ากับ C = C - A
* = ตัวดำเนินการคูณและกำหนด จะคูณตัวถูกดำเนินการด้านขวากับตัวถูกดำเนินการด้านซ้ายและกำหนดผลลัพธ์ให้กับตัวถูกดำเนินการด้านซ้าย C * = A เทียบเท่ากับ C = C * A
/ = หารและกำหนดตัวดำเนินการ มันแบ่งตัวถูกดำเนินการด้านซ้ายกับตัวถูกดำเนินการด้านขวาและกำหนดผลลัพธ์ให้กับตัวถูกดำเนินการด้านซ้าย C / = A เทียบเท่ากับ C = C / A
% = โมดูลัสและตัวดำเนินการกำหนด ใช้โมดูลัสโดยใช้ตัวถูกดำเนินการสองตัวและกำหนดผลลัพธ์ให้กับตัวถูกดำเนินการด้านซ้าย C% = A เทียบเท่ากับ C = C% A
<< = กะซ้ายและตัวดำเนินการกำหนด C << = 2 เหมือนกับ C = C << 2
>> = กะขวาและตัวดำเนินการกำหนด C >> = 2 เหมือนกับ C = C >> 2
& = ตัวดำเนินการกำหนด Bitwise AND C & = 2 เหมือนกับ C = C & 2
^ = บิตพิเศษ OR และตัวดำเนินการกำหนด C ^ = 2 เหมือนกับ C = C ^ 2
| = รวมบิตหรือและตัวดำเนินการกำหนด C | = 2 เหมือนกับ C = C | 2

ตัวดำเนินการเบ็ดเตล็ด

มีตัวดำเนินการอื่น ๆ ที่รองรับโดยภาษา Java

ตัวดำเนินการตามเงื่อนไข (?:)

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

variable x = (expression) ? value if true : value if false

ต่อไปนี้เป็นตัวอย่าง -

Example

public class Test {

   public static void main(String args[]) {
      int a, b;
      a = 10;
      b = (a == 1) ? 20: 30;
      System.out.println( "Value of b is : " +  b );

      b = (a == 10) ? 20: 30;
      System.out.println( "Value of b is : " + b );
   }
}

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -

Output

Value of b is : 30
Value of b is : 20

อินสแตนซ์ของโอเปอเรเตอร์

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

( Object reference variable ) instanceof  (class/interface type)

หากอ็อบเจ็กต์ที่อ้างถึงโดยตัวแปรทางด้านซ้ายของตัวดำเนินการผ่านการตรวจสอบ IS-A สำหรับประเภทคลาส / อินเทอร์เฟซทางด้านขวาผลลัพธ์จะเป็นจริง ต่อไปนี้เป็นตัวอย่าง -

Example

public class Test {

   public static void main(String args[]) {

      String name = "James";

      // following will return true since name is type of String
      boolean result = name instanceof String;
      System.out.println( result );
   }
}

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -

Output

true

ตัวดำเนินการนี้จะยังคงคืนค่าเป็นจริงหากวัตถุที่กำลังเปรียบเทียบเป็นงานที่เข้ากันได้กับประเภททางด้านขวา ต่อไปนี้เป็นอีกหนึ่งตัวอย่าง -

Example

class Vehicle {}

public class Car extends Vehicle {

   public static void main(String args[]) {

      Vehicle a = new Car();
      boolean result =  a instanceof Car;
      System.out.println( result );
   }
}

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -

Output

true

ลำดับความสำคัญของ Java Operators

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

ตัวอย่างเช่น x = 7 + 3 * 2; ที่นี่ x ถูกกำหนด 13 ไม่ใช่ 20 เนื่องจากตัวดำเนินการ * มีลำดับความสำคัญสูงกว่า + ดังนั้นก่อนอื่นจึงคูณด้วย 3 * 2 แล้วบวกเป็น 7

ที่นี่ตัวดำเนินการที่มีลำดับความสำคัญสูงสุดจะปรากฏที่ด้านบนสุดของตารางตัวดำเนินการที่มีค่าต่ำสุดจะปรากฏที่ด้านล่าง ภายในนิพจน์ตัวดำเนินการที่มีลำดับความสำคัญสูงกว่าจะได้รับการประเมินก่อน

ประเภท ตัวดำเนินการ ความสัมพันธ์
Postfix นิพจน์ ++ นิพจน์ - จากซ้ายไปขวา
ยูนารี ++ นิพจน์ --- นิพจน์ + นิพจน์ - นิพจน์ ~! จากขวาไปซ้าย
หลายหลาก * /% จากซ้ายไปขวา
สารเติมแต่ง + - จากซ้ายไปขวา
กะ << >> >>> จากซ้ายไปขวา
เชิงสัมพันธ์ <> <=> = อินสแตนซ์ของ จากซ้ายไปขวา
ความเท่าเทียมกัน ==! = จากซ้ายไปขวา
Bitwise AND & จากซ้ายไปขวา
Bitwise XOR ^ จากซ้ายไปขวา
Bitwise หรือ | จากซ้ายไปขวา
ตรรกะ AND && จากซ้ายไปขวา
ตรรกะหรือ || จากซ้ายไปขวา
เงื่อนไข ?: จากขวาไปซ้าย
การมอบหมายงาน = + = - = * = / =% = ^ = | = << = >> = >>> = จากขวาไปซ้าย

Next คืออะไร?

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

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

ภาษาโปรแกรมจัดเตรียมโครงสร้างการควบคุมต่างๆที่ช่วยให้เส้นทางการดำเนินการซับซ้อนมากขึ้น

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

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

ซีเนียร์ ห่วงและคำอธิบาย
1 ในขณะที่วนซ้ำ

ทำซ้ำคำสั่งหรือกลุ่มของคำสั่งในขณะที่เงื่อนไขที่กำหนดเป็นจริง จะทดสอบเงื่อนไขก่อนที่จะดำเนินการร่างกายลูป
2 สำหรับห่วง

เรียกใช้ลำดับของคำสั่งหลาย ๆ ครั้งและย่อโค้ดที่จัดการตัวแปรลูป
3 ทำ ... ในขณะที่วนซ้ำ

เช่นเดียวกับคำสั่ง while ยกเว้นว่าจะทดสอบเงื่อนไขที่ส่วนท้ายของตัวห่วง

คำสั่งควบคุมลูป

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

Java สนับสนุนคำสั่งควบคุมต่อไปนี้ คลิกลิงก์ต่อไปนี้เพื่อตรวจสอบรายละเอียด

ซีเนียร์ คำชี้แจงและคำอธิบายการควบคุม
1 คำสั่งทำลาย

ยุติไฟล์ loop หรือ switch คำสั่งและโอนการดำเนินการไปยังคำสั่งทันทีตามลูปหรือสวิตช์
2 ดำเนินการต่อ

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

ปรับปรุงสำหรับการวนซ้ำใน Java

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

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์ของการปรับปรุงสำหรับลูป -

for(declaration : expression) {
   // Statements
}

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

  • Expression- สิ่งนี้จะประเมินกับอาร์เรย์ที่คุณต้องวนซ้ำ นิพจน์สามารถเป็นตัวแปรอาร์เรย์หรือการเรียกใช้เมธอดที่ส่งคืนอาร์เรย์

ตัวอย่าง

public class Test {

   public static void main(String args[]) {
      int [] numbers = {10, 20, 30, 40, 50};

      for(int x : numbers ) {
         System.out.print( x );
         System.out.print(",");
      }
      System.out.print("\n");
      String [] names = {"James", "Larry", "Tom", "Lacy"};

      for( String name : names ) {
         System.out.print( name );
         System.out.print(",");
      }
   }
}

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -

เอาต์พุต

10, 20, 30, 40, 50,
James, Larry, Tom, Lacy,

Next คืออะไร?

ในบทต่อไปนี้เราจะเรียนรู้เกี่ยวกับงบการตัดสินใจในการเขียนโปรแกรม Java

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

ต่อไปนี้เป็นรูปแบบทั่วไปของโครงสร้างการตัดสินใจทั่วไปที่พบในภาษาโปรแกรมส่วนใหญ่ -

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

ซีเนียร์ คำชี้แจงและคำอธิบาย
1 ถ้าคำสั่ง

อัน if statement ประกอบด้วยนิพจน์บูลีนตามด้วยหนึ่งคำสั่งขึ้นไป
2 if ... else คำสั่ง

อัน if statement ตามด้วยตัวเลือกก็ได้ else statementซึ่งดำเนินการเมื่อนิพจน์บูลีนเป็นเท็จ
3 คำสั่ง if ซ้อนกัน

คุณสามารถใช้ if หรือ else if คำสั่งภายในอื่น if หรือ else if คำสั่ง (s)
4 สลับคำสั่ง

ก switch คำสั่งอนุญาตให้ทดสอบตัวแปรเพื่อความเท่าเทียมกับรายการค่า

เดอะ? : ผู้ปฏิบัติงาน

เราได้ครอบคลุม conditional operator ? : ในบทก่อนหน้าซึ่งสามารถใช้เพื่อแทนที่ if...elseงบ มีรูปแบบทั่วไปดังต่อไปนี้ -

Exp1 ? Exp2 : Exp3;

โดยที่ Exp1, Exp2 และ Exp3 เป็นนิพจน์ สังเกตการใช้และตำแหน่งของลำไส้ใหญ่

ในการกำหนดค่าของนิพจน์ทั้งหมดระบบจะประเมิน exp1 ในขั้นต้น

  • ถ้าค่า exp1 เป็นจริงค่าของ Exp2 จะเป็นค่าของนิพจน์ทั้งหมด

  • หากค่าของ exp1 เป็นเท็จระบบจะประเมิน Exp3 และค่าของมันจะกลายเป็นค่าของนิพจน์ทั้งหมด

Next คืออะไร?

ในบทต่อไปเราจะพูดถึงคลาส Number (ในแพ็คเกจ java.lang) และคลาสย่อยในภาษา Java

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

โดยปกติเมื่อเราทำงานกับ Numbers เราจะใช้ชนิดข้อมูลดั้งเดิมเช่น byte, int, long, double เป็นต้น

ตัวอย่าง

int i = 5000;
float gpa = 13.65f;
double mask = 125;

อย่างไรก็ตามในการพัฒนาเราเจอสถานการณ์ที่เราต้องใช้วัตถุแทนชนิดข้อมูลดั้งเดิม เพื่อให้บรรลุเป้าหมายนี้ Java จัดเตรียมwrapper classes.

คลาส Wrapper ทั้งหมด (Integer, Long, Byte, Double, Float, Short) เป็นคลาสย่อยของคลาสนามธรรม Number

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

และวัตถุ Wrapper จะถูกแปลงกลับไปเป็นชนิดข้อมูลดั้งเดิมและกระบวนการนี้เรียกว่าการแกะกล่อง Number คลาสเป็นส่วนหนึ่งของแพ็คเกจ java.lang

ต่อไปนี้เป็นตัวอย่างของการชกมวยและการแกะกล่อง -

ตัวอย่าง

public class Test {

   public static void main(String args[]) {
      Integer x = 5; // boxes int to an Integer object
      x =  x + 10;   // unboxes the Integer to a int
      System.out.println(x); 
   }
}

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -

เอาต์พุต

15

เมื่อ x ถูกกำหนดค่าจำนวนเต็มคอมไพเลอร์จะใส่กล่องจำนวนเต็มเนื่องจาก x เป็นอ็อบเจ็กต์จำนวนเต็ม ต่อมา x จะไม่ถูกใส่กล่องเพื่อให้สามารถเพิ่มเป็นจำนวนเต็มได้

วิธีการจำนวน

ต่อไปนี้เป็นรายการของวิธีการอินสแตนซ์ที่คลาสย่อยทั้งหมดของคลาส Number ใช้ -

ซีเนียร์ วิธีการและคำอธิบาย
1 xxxValue ()

แปลงค่าของอ็อบเจ็กต์ Number นี้เป็นชนิดข้อมูล xxx และส่งกลับ
2 เปรียบเทียบกับ()

เปรียบเทียบอ็อบเจ็กต์ Number นี้กับอาร์กิวเมนต์
3 เท่ากับ ()

กำหนดว่านี้วัตถุจำนวนเท่ากับการโต้แย้ง
4 มูลค่าของ()

ส่งคืนอ็อบเจ็กต์จำนวนเต็มที่ถือค่าของไพรเมติกที่ระบุ
5 toString ()

ส่งคืนอ็อบเจ็กต์ String ที่แทนค่าของ int หรือ Integer ที่ระบุ
6 parseInt ()

วิธีนี้ใช้เพื่อรับชนิดข้อมูลดั้งเดิมของสตริงที่กำหนด
7 เอบีเอส ()

ส่งคืนค่าสัมบูรณ์ของอาร์กิวเมนต์
8 เพดาน ()

ส่งคืนจำนวนเต็มที่น้อยที่สุดที่มากกว่าหรือเท่ากับอาร์กิวเมนต์ กลับมาเป็นสองเท่า
9 ชั้น ()

ส่งคืนจำนวนเต็มที่มากที่สุดที่น้อยกว่าหรือเท่ากับอาร์กิวเมนต์ กลับมาเป็นสองเท่า
10 รินท์ ()

ส่งคืนจำนวนเต็มที่มีค่าใกล้เคียงที่สุดกับอาร์กิวเมนต์ กลับมาเป็นสองเท่า
11 รอบ()

ส่งคืนค่า long หรือ int ที่ใกล้เคียงที่สุดตามที่ระบุโดยประเภทการส่งคืนของเมธอดไปยังอาร์กิวเมนต์
12 นาที()

ส่งคืนอาร์กิวเมนต์ที่เล็กกว่าของสองอาร์กิวเมนต์
13 สูงสุด ()

ส่งคืนอาร์กิวเมนต์ที่ใหญ่กว่าของทั้งสอง
14 ประสบการณ์ ()

ส่งกลับฐานของลอการิทึมธรรมชาติ e เป็นพลังของอาร์กิวเมนต์
15 บันทึก ()

ส่งคืนลอการิทึมธรรมชาติของอาร์กิวเมนต์
16 ธาร ()

ส่งคืนค่าของอาร์กิวเมนต์แรกยกกำลังของอาร์กิวเมนต์ที่สอง
17 sqrt ()

ส่งคืนค่ารากที่สองของอาร์กิวเมนต์
18 บาป()

ส่งคืนค่าไซน์ของค่าคู่ที่ระบุ
19 cos ()

ส่งคืนโคไซน์ของค่าคู่ที่ระบุ
20 ผิวสีแทน ()

ส่งคืนแทนเจนต์ของค่าคู่ที่ระบุ
21 asin ()

ส่งคืนอาร์กไซน์ของค่าคู่ที่ระบุ
22 เอคอส ()

ส่งคืนค่าอาร์คโคซีนของค่าคู่ที่ระบุ
23 atan ()

ส่งคืนอาร์กแทนเจนต์ของค่าคู่ที่ระบุ
24 atan2 ()

แปลงพิกัดสี่เหลี่ยม (x, y) เป็นพิกัดเชิงขั้ว (r, theta) และส่งกลับทีต้า
25 ถึงองศา ()

แปลงอาร์กิวเมนต์เป็นองศา
26 ถึงเรเดียน ()

แปลงอาร์กิวเมนต์เป็นเรเดียน
27 สุ่ม ()

ส่งคืนตัวเลขสุ่ม

Next คืออะไร?

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

โดยปกติเมื่อเราทำงานกับอักขระเราจะใช้ชนิดข้อมูลดั้งเดิม char

ตัวอย่าง

char ch = 'a';

// Unicode for uppercase Greek omega character
char uniChar = '\u039A'; 

// an array of chars
char[] charArray ={ 'a', 'b', 'c', 'd', 'e' };

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

คลาสตัวละครนำเสนอคลาสที่มีประโยชน์จำนวนมาก (เช่นแบบคงที่) สำหรับการจัดการกับอักขระ คุณสามารถสร้างวัตถุอักขระด้วยตัวสร้างอักขระ -

Character ch = new Character('a');

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

ตัวอย่าง

// Here following primitive char 'a'
// is boxed into the Character object ch
Character ch = 'a';

// Here primitive 'x' is boxed for method test,
// return is unboxed to char 'c'
char c = test('x');

ลำดับการหลบหนี

อักขระที่นำหน้าด้วยแบ็กสแลช (\) เป็นลำดับการหลีกเลี่ยงและมีความหมายพิเศษสำหรับคอมไพเลอร์

อักขระขึ้นบรรทัดใหม่ (\ n) ถูกใช้บ่อยในบทช่วยสอนนี้ในคำสั่ง System.out.println () เพื่อเลื่อนไปยังบรรทัดถัดไปหลังจากพิมพ์สตริง

ตารางต่อไปนี้แสดงลำดับการหลีกเลี่ยง Java -

ลำดับการหลบหนี คำอธิบาย
\ t แทรกแท็บในข้อความที่จุดนี้
\ b แทรก backspace ในข้อความ ณ จุดนี้
\ n แทรกขึ้นบรรทัดใหม่ในข้อความ ณ จุดนี้
\ r แทรกการกลับแคร่ในข้อความ ณ จุดนี้
\ ฉ แทรกฟีดแบบฟอร์มในข้อความ ณ จุดนี้
\ ' แทรกอักขระเครื่องหมายคำพูดเดี่ยวในข้อความ ณ จุดนี้
\ " แทรกอักขระอัญประกาศคู่ในข้อความ ณ จุดนี้
\\ แทรกอักขระแบ็กสแลชในข้อความ ณ จุดนี้

เมื่อพบลำดับการหลีกเลี่ยงในคำสั่งพิมพ์คอมไพลเลอร์จะตีความตามนั้น

ตัวอย่าง

หากคุณต้องการใส่เครื่องหมายคำพูดไว้ในเครื่องหมายคำพูดคุณต้องใช้ลำดับการหลีก \ "บนเครื่องหมายคำพูดภายใน -

public class Test {

   public static void main(String args[]) {
      System.out.println("She said \"Hello!\" to me.");
   }
}

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -

เอาต์พุต

She said "Hello!" to me.

วิธีการของตัวละคร

ต่อไปนี้เป็นรายการของวิธีการอินสแตนซ์ที่สำคัญที่คลาสย่อยทั้งหมดของคลาส Character นำไปใช้ -

ซีเนียร์ วิธีการและคำอธิบาย
1 isLetter ()

กำหนดว่าค่าถ่านที่ระบุเป็นตัวอักษรหรือไม่
2 isDigit ()

กำหนดว่าค่าถ่านที่ระบุเป็นตัวเลขหรือไม่
3 isWhitespace ()

กำหนดว่าค่าถ่านที่ระบุเป็นช่องว่างหรือไม่
4 isUpperCase ()

กำหนดว่าค่าถ่านที่ระบุเป็นตัวพิมพ์ใหญ่หรือไม่
5 isLowerCase ()

กำหนดว่าค่าถ่านที่ระบุเป็นตัวพิมพ์เล็กหรือไม่
6 toUpperCase ()

ส่งคืนรูปแบบตัวพิมพ์ใหญ่ของค่าถ่านที่ระบุ
7 toLowerCase ()

ส่งคืนรูปแบบตัวพิมพ์เล็กของค่าถ่านที่ระบุ
8 toString ()

ส่งคืนอ็อบเจ็กต์ String ที่แสดงค่าอักขระที่ระบุนั่นคือสตริงหนึ่งอักขระ

สำหรับรายการวิธีการทั้งหมดโปรดดูที่ข้อกำหนด java.lang.Character API

Next คืออะไร?

ในส่วนถัดไปเราจะพูดถึงคลาส String ใน Java คุณจะได้เรียนรู้วิธีการประกาศและใช้ Strings อย่างมีประสิทธิภาพรวมถึงวิธีการที่สำคัญบางอย่างในคลาส String

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

แพลตฟอร์ม Java จัดเตรียมคลาส String เพื่อสร้างและจัดการสตริง

การสร้างสตริง

วิธีที่ตรงที่สุดในการสร้างสตริงคือการเขียน -

String greeting = "Hello world!";

เมื่อใดก็ตามที่พบสตริงลิเทอรัลในโค้ดของคุณคอมไพลเลอร์จะสร้างอ็อบเจกต์ String ที่มีค่าในกรณีนี้คือ "Hello world!"

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

ตัวอย่าง

public class StringDemo {

   public static void main(String args[]) {
      char[] helloArray = { 'h', 'e', 'l', 'l', 'o', '.' };
      String helloString = new String(helloArray);  
      System.out.println( helloString );
   }
}

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -

เอาต์พุต

hello.

Note- คลาส String ไม่เปลี่ยนรูปดังนั้นเมื่อสร้างอ็อบเจกต์ String แล้วจะไม่สามารถเปลี่ยนแปลงได้ หากมีความจำเป็นในการปรับเปลี่ยนสตริงของอักขระจำนวนมากคุณควรใช้String Buffer & String Builder Classes

ความยาวสตริง

วิธีการที่ใช้ในการรับข้อมูลเกี่ยวกับวัตถุเรียกว่า accessor methods. วิธีการเข้าถึงวิธีหนึ่งที่คุณสามารถใช้กับสตริงคือเมธอด length () ซึ่งจะส่งคืนจำนวนอักขระที่มีอยู่ในอ็อบเจ็กต์สตริง

โปรแกรมต่อไปนี้เป็นตัวอย่างของ length(), คลาส String วิธีการ

ตัวอย่าง

public class StringDemo {

   public static void main(String args[]) {
      String palindrome = "Dot saw I was Tod";
      int len = palindrome.length();
      System.out.println( "String Length is : " + len );
   }
}

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -

เอาต์พุต

String Length is : 17

การเชื่อมต่อสตริง

คลาส String มีวิธีการเชื่อมสองสตริงเข้าด้วยกัน -

string1.concat(string2);

สิ่งนี้จะส่งคืนสตริงใหม่ที่เป็น string1 โดยมีการเพิ่ม string2 เข้าไปในตอนท้าย คุณยังสามารถใช้เมธอด concat () กับสตริงลิเทอรัลเช่นใน -

"My name is ".concat("Zara");

โดยทั่วไปแล้วสตริงจะเชื่อมต่อกับตัวดำเนินการ + เช่นเดียวกับใน -

"Hello," + " world" + "!"

ซึ่งส่งผลให้ -

"Hello, world!"

ให้เราดูตัวอย่างต่อไปนี้ -

ตัวอย่าง

public class StringDemo {

   public static void main(String args[]) {
      String string1 = "saw I was ";
      System.out.println("Dot " + string1 + "Tod");
   }
}

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -

เอาต์พุต

Dot saw I was Tod

การสร้างสตริงรูปแบบ

คุณมีวิธี printf () และ format () ในการพิมพ์ผลลัพธ์ด้วยตัวเลขที่จัดรูปแบบ คลาส String มีเมธอดคลาสเทียบเท่ารูปแบบ () ที่ส่งคืนอ็อบเจ็กต์ String แทนที่จะเป็นอ็อบเจ็กต์ PrintStream

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

ตัวอย่าง

System.out.printf("The value of the float variable is " +
                  "%f, while the value of the integer " +
                  "variable is %d, and the string " +
                  "is %s", floatVar, intVar, stringVar);

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

String fs;
fs = String.format("The value of the float variable is " +
                   "%f, while the value of the integer " +
                   "variable is %d, and the string " +
                   "is %s", floatVar, intVar, stringVar);
System.out.println(fs);

วิธีการสตริง

นี่คือรายการวิธีที่รองรับโดยคลาส String -

ซีเนียร์ วิธีการและคำอธิบาย
1 ถ่าน charAt (ดัชนี int)

ส่งกลับอักขระที่ดัชนีที่ระบุ
2 int CompareTo (วัตถุ o)

เปรียบเทียบ String นี้กับ Object อื่น
3 int CompareTo (สตริง anotherString)

เปรียบเทียบสองสายตามศัพท์
4 int CompareToIgnoreCase (สตริง str)

เปรียบเทียบสองสตริงตามศัพท์โดยไม่สนใจความแตกต่างของตัวพิมพ์
5 การต่อสายอักขระ (String str)

เชื่อมสตริงที่ระบุเข้ากับจุดสิ้นสุดของสตริงนี้
6 boolean contentEquals (StringBuffer sb)

ส่งคืนค่าจริงถ้าและเฉพาะในกรณีที่สตริงนี้แสดงถึงลำดับของอักขระเดียวกันกับ StringBuffer ที่ระบุ
7 สตริงคง copyValueOf (ถ่าน [] ข้อมูล)

ส่งคืนสตริงที่แสดงถึงลำดับอักขระในอาร์เรย์ที่ระบุ
8 สตริงแบบคงที่ copyValueOf (ถ่าน [] ข้อมูล, ออฟเซ็ต int, จำนวน int)

ส่งคืนสตริงที่แสดงถึงลำดับอักขระในอาร์เรย์ที่ระบุ
9 บูลีน endWith (String ต่อท้าย)

ทดสอบว่าสตริงนี้ลงท้ายด้วยคำต่อท้ายที่ระบุหรือไม่
10 บูลีนเท่ากับ (Object anObject)

เปรียบเทียบสตริงนี้กับวัตถุที่ระบุ
11 บูลีนเท่ากับ IgnoreCase (สตริง anotherString)

เปรียบเทียบสตริงนี้กับสตริงอื่นโดยไม่สนใจการพิจารณากรณี
12 ไบต์ getBytes ()

เข้ารหัสสตริงนี้เป็นลำดับไบต์โดยใช้ชุดอักขระเริ่มต้นของแพลตฟอร์มเก็บผลลัพธ์ไว้ในอาร์เรย์ไบต์ใหม่
13 ไบต์ [] getBytes (สตริง charsetName)

เข้ารหัสสตริงนี้เป็นลำดับของไบต์โดยใช้ชุดอักขระที่มีชื่อเก็บผลลัพธ์ไว้ในอาร์เรย์ไบต์ใหม่
14 โมฆะ getChars (int srcBegin, int srcEnd, ถ่าน [] dst, int dstBegin)

คัดลอกอักขระจากสตริงนี้ไปยังอาร์เรย์อักขระปลายทาง
15 int hashCode ()

ส่งคืนรหัสแฮชสำหรับสตริงนี้
16 int indexOf (int ch)

ส่งคืนดัชนีภายในสตริงของการเกิดครั้งแรกของอักขระที่ระบุนี้
17 int indexOf (int ch, int fromIndex)

ส่งคืนดัชนีภายในสตริงนี้ของการเกิดครั้งแรกของอักขระที่ระบุโดยเริ่มการค้นหาที่ดัชนีที่ระบุ
18 int indexOf (สตริง str)

ส่งคืนดัชนีภายในสตริงของการเกิดขึ้นครั้งแรกของสตริงย่อยที่ระบุ
19 int indexOf (สตริง str, int fromIndex)

ส่งคืนดัชนีภายในสตริงนี้ของการเกิดขึ้นครั้งแรกของสตริงย่อยที่ระบุโดยเริ่มต้นที่ดัชนีที่ระบุ
20 ฝึกงานสตริง ()

ส่งคืนการแสดงตามรูปแบบบัญญัติสำหรับวัตถุสตริง
21 int lastIndexOf (int ch)

ส่งคืนดัชนีภายในสตริงของการเกิดครั้งสุดท้ายของอักขระที่ระบุนี้
22 int lastIndexOf (int ch, int fromIndex)

ส่งกลับดัชนีภายในสตริงนี้ของการเกิดครั้งสุดท้ายของอักขระที่ระบุโดยค้นหาย้อนหลังโดยเริ่มจากดัชนีที่ระบุ
23 int lastIndexOf (สตริง str)

ส่งคืนดัชนีภายในสตริงของการเกิดขวาสุดของสตริงย่อยที่ระบุนี้
24 int lastIndexOf (สตริง str, int fromIndex)

ส่งคืนดัชนีภายในสตริงของการเกิดครั้งสุดท้ายของสตริงย่อยที่ระบุโดยค้นหาย้อนหลังโดยเริ่มจากดัชนีที่ระบุ
25 ความยาว int ()

ส่งกลับความยาวของสตริงนี้
26 การจับคู่แบบบูลีน (String regex)

บอกว่าสตริงนี้ตรงกับนิพจน์ทั่วไปที่กำหนดหรือไม่
27 boolean regionMatches (boolean ignase, int toffset, String other, int ooffset, int len)

ทดสอบว่าสองพื้นที่สตริงเท่ากันหรือไม่
28 boolean regionMatches (int toffset, String other, int ooffset, int len)

ทดสอบว่าสองพื้นที่สตริงเท่ากันหรือไม่
29 เปลี่ยนสตริง (ถ่าน oldChar ถ่าน newChar)

ส่งคืนสตริงใหม่ที่เกิดจากการแทนที่ oldChar ที่เกิดขึ้นทั้งหมดในสตริงนี้ด้วย newChar
30 String replaceAll (สตริง regex การแทนที่สตริง

แทนที่แต่ละสตริงย่อยของสตริงนี้ที่ตรงกับนิพจน์ทั่วไปที่กำหนดด้วยการแทนที่ที่กำหนด
31 สตริง replaceFirst (String regex การแทนที่สตริง)

แทนที่สตริงย่อยแรกของสตริงนี้ที่ตรงกับนิพจน์ทั่วไปที่กำหนดด้วยการแทนที่ที่กำหนด
32 แยกสตริง [] (สตริง regex)

แยกสตริงนี้รอบการจับคู่ของนิพจน์ทั่วไปที่กำหนด
33 สตริง [] แยก (สตริง regex ขีด จำกัด int)

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

ทดสอบว่าสตริงนี้เริ่มต้นด้วยคำนำหน้าที่ระบุหรือไม่
35 บูลีนเริ่มต้นด้วย (คำนำหน้าสตริง, int toffset)

ทดสอบว่าสตริงนี้เริ่มต้นด้วยคำนำหน้าที่ระบุโดยเริ่มดัชนีที่ระบุหรือไม่
36 CharSequence subSequence (int beginIndex, int endIndex)

ส่งคืนลำดับอักขระใหม่ที่เป็นลำดับต่อมาของลำดับนี้
37 สตริงย่อย (int beginIndex)

ส่งคืนสตริงใหม่ที่เป็นสตริงย่อยของสตริงนี้
38 สตริงย่อย (int beginIndex, int endIndex)

ส่งคืนสตริงใหม่ที่เป็นสตริงย่อยของสตริงนี้
39 ถ่าน [] toCharArray ()

แปลงสตริงนี้เป็นอาร์เรย์อักขระใหม่
40 สตริง toLowerCase ()

แปลงอักขระทั้งหมดในสตริงนี้เป็นตัวพิมพ์เล็กโดยใช้กฎของโลแคลเริ่มต้น
41 สตริง toLowerCase (โลแคลโลแคล)

แปลงอักขระทั้งหมดในสตริงนี้เป็นตัวพิมพ์เล็กโดยใช้กฎของโลแคลที่กำหนด
42 สตริง toString ()

วัตถุนี้ (ซึ่งเป็นสตริงแล้ว!) จะถูกส่งคืนเอง
43 สตริง toUpperCase ()

แปลงอักขระทั้งหมดในสตริงนี้เป็นตัวพิมพ์ใหญ่โดยใช้กฎของโลแคลเริ่มต้น
44 สตริง toUpperCase (โลแคลโลแคล)

แปลงอักขระทั้งหมดในสตริงนี้เป็นตัวพิมพ์ใหญ่โดยใช้กฎของโลแคลที่กำหนด
45 ตัดแต่งสตริง ()

ส่งคืนสำเนาของสตริงโดยเว้นช่องว่างนำหน้าและต่อท้าย
46 ค่าสตริงคงที่ f (ชนิดข้อมูลดั้งเดิม x)

ส่งกลับการแสดงสตริงของอาร์กิวเมนต์ชนิดข้อมูลที่ส่ง

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

แทนที่จะประกาศตัวแปรเดี่ยวเช่น number0, number1, ... และ number99 คุณประกาศตัวแปรอาร์เรย์หนึ่งตัวเช่นตัวเลขและใช้ตัวเลข [0], ตัวเลข [1] และ ... , ตัวเลข [99] เพื่อแสดง ตัวแปรแต่ละตัว

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

การประกาศตัวแปรอาร์เรย์

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

ไวยากรณ์

dataType[] arrayRefVar;   // preferred way.
or
dataType arrayRefVar[];  // works but not preferred way.

Note - สไตล์ dataType[] arrayRefVarเป็นที่ต้องการ รูปแบบdataType arrayRefVar[] มาจากภาษา C / C ++ และถูกนำมาใช้ใน Java เพื่อรองรับโปรแกรมเมอร์ C / C ++

ตัวอย่าง

ตัวอย่างโค้ดต่อไปนี้เป็นตัวอย่างของไวยากรณ์นี้ -

double[] myList;   // preferred way.
or
double myList[];   // works but not preferred way.

การสร้างอาร์เรย์

คุณสามารถสร้างอาร์เรย์โดยใช้ตัวดำเนินการใหม่ด้วยไวยากรณ์ต่อไปนี้ -

ไวยากรณ์

arrayRefVar = new dataType[arraySize];

ข้อความข้างต้นทำสองสิ่ง -

  • สร้างอาร์เรย์โดยใช้ dataType [arraySize] ใหม่

  • กำหนดการอ้างอิงของอาร์เรย์ที่สร้างขึ้นใหม่ให้กับตัวแปร arrayRefVar

การประกาศตัวแปรอาร์เรย์การสร้างอาร์เรย์และการกำหนดการอ้างอิงของอาร์เรย์ให้กับตัวแปรสามารถรวมไว้ในคำสั่งเดียวดังที่แสดงด้านล่าง -

dataType[] arrayRefVar = new dataType[arraySize];

หรือคุณสามารถสร้างอาร์เรย์ได้ดังนี้ -

dataType[] arrayRefVar = {value0, value1, ..., valuek};

องค์ประกอบอาร์เรย์สามารถเข้าถึงได้ผ่านไฟล์ index. ดัชนีอาร์เรย์เป็นแบบ 0 นั่นคือพวกมันเริ่มจาก 0 ถึงarrayRefVar.length-1.

ตัวอย่าง

คำสั่งต่อไปนี้ประกาศตัวแปรอาร์เรย์ myList สร้างอาร์เรย์ 10 องค์ประกอบประเภทคู่และกำหนดการอ้างอิงไปยัง myList -

double[] myList = new double[10];

ภาพต่อไปนี้แสดงถึงอาร์เรย์ myList ที่นี่ myList มีสิบค่าสองค่าและดัชนีอยู่ระหว่าง 0 ถึง 9

อาร์เรย์การประมวลผล

เมื่อประมวลผลองค์ประกอบอาร์เรย์เรามักใช้อย่างใดอย่างหนึ่ง for ห่วงหรือ foreach วนซ้ำเนื่องจากองค์ประกอบทั้งหมดในอาร์เรย์เป็นประเภทเดียวกันและทราบขนาดของอาร์เรย์

ตัวอย่าง

นี่คือตัวอย่างที่สมบูรณ์ที่แสดงวิธีการสร้างเริ่มต้นและประมวลผลอาร์เรย์ -

public class TestArray {

   public static void main(String[] args) {
      double[] myList = {1.9, 2.9, 3.4, 3.5};

      // Print all the array elements
      for (int i = 0; i < myList.length; i++) {
         System.out.println(myList[i] + " ");
      }
     
      // Summing all elements
      double total = 0;
      for (int i = 0; i < myList.length; i++) {
         total += myList[i];
      }
      System.out.println("Total is " + total);
      
      // Finding the largest element
      double max = myList[0];
      for (int i = 1; i < myList.length; i++) {
         if (myList[i] > max) max = myList[i];
      }
      System.out.println("Max is " + max);  
   }
}

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -

เอาต์พุต

1.9
2.9
3.4
3.5
Total is 11.7
Max is 3.5

ลูปหน้า

JDK 1.5 เปิดตัวใหม่สำหรับลูปที่เรียกว่า foreach loop หรือปรับปรุงสำหรับลูปซึ่งช่วยให้คุณสำรวจอาร์เรย์ที่สมบูรณ์ตามลำดับโดยไม่ต้องใช้ตัวแปรดัชนี

ตัวอย่าง

รหัสต่อไปนี้แสดงองค์ประกอบทั้งหมดในอาร์เรย์ myList -

public class TestArray {

   public static void main(String[] args) {
      double[] myList = {1.9, 2.9, 3.4, 3.5};

      // Print all the array elements
      for (double element: myList) {
         System.out.println(element);
      }
   }
}

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -

เอาต์พุต

1.9
2.9
3.4
3.5

การส่งอาร์เรย์ไปยังเมธอด

เช่นเดียวกับที่คุณสามารถส่งผ่านค่าประเภทดั้งเดิมไปยังเมธอดคุณยังสามารถส่งอาร์เรย์ไปยังเมธอดได้อีกด้วย ตัวอย่างเช่นวิธีการต่อไปนี้แสดงองค์ประกอบในไฟล์int อาร์เรย์ -

ตัวอย่าง

public static void printArray(int[] array) {
   for (int i = 0; i < array.length; i++) {
      System.out.print(array[i] + " ");
   }
}

คุณสามารถเรียกใช้โดยส่งอาร์เรย์ ตัวอย่างเช่นคำสั่งต่อไปนี้เรียกใช้เมธอด printArray เพื่อแสดง 3, 1, 2, 6, 4 และ 2 -

ตัวอย่าง

printArray(new int[]{3, 1, 2, 6, 4, 2});

การส่งคืนอาร์เรย์จากวิธีการ

เมธอดอาจส่งคืนอาร์เรย์ ตัวอย่างเช่นวิธีการต่อไปนี้จะส่งคืนอาร์เรย์ที่เป็นการกลับรายการของอาร์เรย์อื่น -

ตัวอย่าง

public static int[] reverse(int[] list) {
   int[] result = new int[list.length];

   for (int i = 0, j = result.length - 1; i < list.length; i++, j--) {
      result[j] = list[i];
   }
   return result;
}

คลาสอาร์เรย์

คลาส java.util.Arrays มีวิธีการแบบคงที่หลายแบบสำหรับการเรียงลำดับและค้นหาอาร์เรย์เปรียบเทียบอาร์เรย์และการเติมองค์ประกอบอาร์เรย์ วิธีการเหล่านี้มีมากเกินไปสำหรับประเภทดั้งเดิมทั้งหมด

ซีเนียร์ วิธีการและคำอธิบาย
1

public static int binarySearch(Object[] a, Object key)

ค้นหาอาร์เรย์ของ Object ที่ระบุ (Byte, Int, double และอื่น ๆ ) สำหรับค่าที่ระบุโดยใช้อัลกอริทึมการค้นหาแบบไบนารี ต้องเรียงอาร์เรย์ก่อนที่จะทำการโทรนี้ สิ่งนี้ส่งคืนดัชนีของคีย์การค้นหาหากมีอยู่ในรายการ มิฉะนั้นจะส่งกลับ (- (จุดแทรก + 1))
2

public static boolean equals(long[] a, long[] a2)

ส่งคืนค่าจริงถ้าอาร์เรย์ของ longs ที่ระบุสองอาร์เรย์เท่ากับอีกอันหนึ่ง อาร์เรย์สองอาร์เรย์จะถือว่าเท่ากันหากอาร์เรย์ทั้งสองมีจำนวนองค์ประกอบเท่ากันและคู่ขององค์ประกอบที่เกี่ยวข้องทั้งหมดในอาร์เรย์ทั้งสองมีค่าเท่ากัน สิ่งนี้จะคืนค่าเป็นจริงหากอาร์เรย์ทั้งสองเท่ากัน วิธีการเดียวกันนี้สามารถใช้ได้กับชนิดข้อมูลดั้งเดิมอื่น ๆ ทั้งหมด (Byte, short, Int ฯลฯ )
3

public static void fill(int[] a, int val)

กำหนดค่า int ที่ระบุให้กับแต่ละองค์ประกอบของอาร์เรย์ของ ints ที่ระบุ วิธีการเดียวกันนี้สามารถใช้ได้กับประเภทข้อมูลดั้งเดิมอื่น ๆ ทั้งหมด (Byte, short, Int ฯลฯ )
4

public static void sort(Object[] a)

จัดเรียงอาร์เรย์ของออบเจ็กต์ที่ระบุเป็นลำดับจากน้อยไปมากตามลำดับขององค์ประกอบตามธรรมชาติ วิธีการเดียวกันนี้สามารถใช้ได้กับประเภทข้อมูลดั้งเดิมอื่น ๆ ทั้งหมด (Byte, short, Int ฯลฯ )

Java จัดเตรียมไฟล์ Date คลาสที่มีอยู่ใน java.util แพ็กเกจคลาสนี้จะสรุปวันที่และเวลาปัจจุบัน

คลาส Date รองรับตัวสร้างสองตัวดังแสดงในตารางต่อไปนี้

ซีเนียร์ ตัวสร้างและคำอธิบาย
1

Date( )

ตัวสร้างนี้เริ่มต้นวัตถุด้วยวันที่และเวลาปัจจุบัน
2

Date(long millisec)

ตัวสร้างนี้ยอมรับอาร์กิวเมนต์ที่เท่ากับจำนวนมิลลิวินาทีที่ผ่านไปนับตั้งแต่เที่ยงคืนวันที่ 1 มกราคม 1970

ต่อไปนี้เป็นวิธีการของคลาสวันที่

ซีเนียร์ วิธีการและคำอธิบาย
1

boolean after(Date date)

ส่งคืนค่าจริงหากอ็อบเจ็กต์วันที่เรียกใช้มีวันที่ที่ช้ากว่าวันที่ที่ระบุมิฉะนั้นจะส่งกลับเท็จ
2

boolean before(Date date)

ส่งคืนค่าจริงหากอ็อบเจ็กต์วันที่เรียกใช้มีวันที่ก่อนหน้าวันที่ระบุไว้มิฉะนั้นจะส่งกลับเท็จ
3

Object clone( )

ทำซ้ำอ็อบเจ็กต์ Date ที่เรียกใช้
4

int compareTo(Date date)

เปรียบเทียบค่าของวัตถุที่เรียกใช้กับวันที่ ส่งคืน 0 หากค่าเท่ากัน ส่งคืนค่าลบหากออบเจ็กต์ที่เรียกใช้ก่อนหน้าวันที่ ส่งคืนค่าบวกหากวัตถุที่เรียกใช้ช้ากว่าวันที่
5

int compareTo(Object obj)

ดำเนินการเหมือนกันกับ CompareTo (Date) ถ้า obj เป็นคลาส Date มิฉะนั้นจะพ่น ClassCastException
6

boolean equals(Object date)

ส่งคืนจริงหากอ็อบเจ็กต์วันที่เรียกใช้มีเวลาและวันที่เดียวกันกับที่ระบุโดยวันที่มิฉะนั้นจะส่งกลับเท็จ
7

long getTime( )

ส่งคืนจำนวนมิลลิวินาทีที่ผ่านไปนับตั้งแต่วันที่ 1 มกราคม 1970
8

int hashCode( )

ส่งคืนรหัสแฮชสำหรับวัตถุที่เรียกใช้
9

void setTime(long time)

ตั้งเวลาและวันที่ตามที่ระบุโดยเวลาซึ่งแสดงเวลาที่ผ่านไปในหน่วยมิลลิวินาทีจากเที่ยงคืนวันที่ 1 มกราคม 1970
10

String toString( )

แปลงอ็อบเจ็กต์วันที่เรียกใช้เป็นสตริงและส่งคืนผลลัพธ์

รับวันที่และเวลาปัจจุบัน

นี่เป็นวิธีที่ง่ายมากในการรับวันที่และเวลาปัจจุบันใน Java คุณสามารถใช้ออบเจ็กต์ Date อย่างง่ายด้วยวิธีtoString ()เพื่อพิมพ์วันที่และเวลาปัจจุบันดังนี้ -

ตัวอย่าง

import java.util.Date;
public class DateDemo {

   public static void main(String args[]) {
      // Instantiate a Date object
      Date date = new Date();

      // display time and date using toString()
      System.out.println(date.toString());
   }
}

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -

เอาต์พุต

on May 04 09:51:52 CDT 2009

การเปรียบเทียบวันที่

ต่อไปนี้เป็นสามวิธีในการเปรียบเทียบวันที่สองวัน -

  • คุณสามารถใช้ getTime () เพื่อรับจำนวนมิลลิวินาทีที่ผ่านไปตั้งแต่เที่ยงคืนวันที่ 1 มกราคม 1970 สำหรับวัตถุทั้งสองแล้วเปรียบเทียบค่าทั้งสองนี้

  • คุณสามารถใช้วิธีก่อน (), หลัง () และเท่ากับ () เนื่องจากวันที่ 12 ของเดือนมาก่อนวันที่ 18 ตัวอย่างเช่นวันที่ใหม่ (99, 2, 12) ก่อน (วันที่ใหม่ (99, 2, 18)) จะคืนค่าจริง

  • คุณสามารถใช้วิธีการ CompareTo () ซึ่งกำหนดโดยอินเทอร์เฟซเปรียบเทียบและดำเนินการโดยวันที่

การจัดรูปแบบวันที่โดยใช้ SimpleDateFormat

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

ตัวอย่าง

import java.util.*;
import java.text.*;

public class DateDemo {

   public static void main(String args[]) {
      Date dNow = new Date( );
      SimpleDateFormat ft = 
      new SimpleDateFormat ("E yyyy.MM.dd 'at' hh:mm:ss a zzz");

      System.out.println("Current Date: " + ft.format(dNow));
   }
}

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -

เอาต์พุต

Current Date: Sun 2004.07.18 at 04:14:09 PM PDT

รหัสรูปแบบ DateFormat อย่างง่าย

ในการระบุรูปแบบเวลาให้ใช้สตริงรูปแบบเวลา ในรูปแบบนี้ตัวอักษร ASCII ทั้งหมดสงวนไว้เป็นตัวอักษรรูปแบบซึ่งกำหนดไว้ดังต่อไปนี้ -

ตัวละคร คำอธิบาย ตัวอย่าง
ช ผู้กำหนดยุค ค.ศ.
ย ปีเป็นตัวเลขสี่หลัก พ.ศ. 2544
ม เดือนในปี กรกฎาคมหรือ 07
ง วันในเดือน 10
ซ ชั่วโมงใน AM / PM (1 ~ 12) 12
ซ ชั่วโมงในวัน (0 ~ 23) 22
ม นาทีในชั่วโมง 30
เอส วินาทีในหนึ่งนาที 55
ส มิลลิวินาที 234
จ วันในสัปดาห์ วันอังคาร
ง วันในปี 360
ฉ วันของสัปดาห์ในเดือน 2 (วันพุธที่สองของเดือนกรกฎาคม)
ว สัปดาห์ในปี 40
ว สัปดาห์ในเดือน 1
ก เครื่องหมาย AM / PM น
k ชั่วโมงในวัน (1 ~ 24) 24
เค ชั่วโมงใน AM / PM (0 ~ 11) 10
z เขตเวลา เวลามาตรฐานตะวันออก
' Escape สำหรับข้อความ ตัวคั่น
" ใบเสนอราคาเดียว `

การจัดรูปแบบวันที่โดยใช้ printf

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

ตัวอย่าง

import java.util.Date;
public class DateDemo {

   public static void main(String args[]) {
      // Instantiate a Date object
      Date date = new Date();

      // display time and date
      String str = String.format("Current Date/Time : %tc", date );

      System.out.printf(str);
   }
}

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -

เอาต์พุต

Current Date/Time : Sat Dec 15 16:37:57 MST 2012

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

ดัชนีจะต้องเป็นไปตาม% ทันทีและจะต้องถูกยกเลิกโดย $

ตัวอย่าง

import java.util.Date;
public class DateDemo {

   public static void main(String args[]) {
      // Instantiate a Date object
      Date date = new Date();
  
      // display time and date
      System.out.printf("%1$s %2$tB %2$td, %2$tY", "Due date:", date);
   }
}

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -

เอาต์พุต

Due date: February 09, 2004

หรือคุณสามารถใช้แฟล็ก < บ่งชี้ว่าควรใช้อาร์กิวเมนต์เดียวกันกับในข้อกำหนดรูปแบบก่อนหน้านี้อีกครั้ง

ตัวอย่าง

import java.util.Date;
public class DateDemo {

   public static void main(String args[]) {
      // Instantiate a Date object
      Date date = new Date();
  
      // display formatted date
      System.out.printf("%s %tB %<te, %<tY", "Due date:", date);
   }
}

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -

เอาต์พุต

Due date: February 09, 2004

อักขระการแปลงวันที่และเวลา

ตัวละคร คำอธิบาย ตัวอย่าง
ค วันที่และเวลาที่สมบูรณ์ จ. 04 พฤษภาคม 09:51:52 CDT 2552
ฉ วันที่ ISO 8601 พ.ศ. 2547-02-09
ง วันที่จัดรูปแบบสหรัฐอเมริกา (เดือน / วัน / ปี) 02/09/2547
ที เวลา 24 ชั่วโมง 18:05:19 น
ร เวลา 12 ชั่วโมง 06:05:19 น
ร เวลา 24 ชั่วโมงไม่มีวินาที 18:05 น
ย ปีสี่หลัก (มีเลขศูนย์นำหน้า) พ.ศ. 2547
ย สองหลักสุดท้ายของปี (โดยมีเลขศูนย์นำหน้า) 04
ค ตัวเลขสองหลักแรกของปี (มีเลขศูนย์นำหน้า) 20
ข ชื่อเต็มเดือน กุมภาพันธ์
ข ชื่อเดือนแบบย่อ ก.พ.
ม เดือนสองหลัก (มีเลขศูนย์นำหน้า) 02
ง วันสองหลัก (มีเลขศูนย์นำหน้า) 03
จ วันสองหลัก (ไม่มีศูนย์นำหน้า) 9
ก ชื่อเต็มวันทำงาน วันจันทร์
ก ชื่อย่อวันทำงาน จ
ญ วันสามหลักของปี (มีเลขศูนย์นำหน้า) 069
ซ ชั่วโมงสองหลัก (โดยมีเลขศูนย์นำหน้า) ระหว่าง 00 ถึง 23 18
k ชั่วโมงสองหลัก (ไม่มีศูนย์นำหน้า) ระหว่าง 0 ถึง 23 18
ผม ชั่วโมงสองหลัก (โดยมีเลขศูนย์นำหน้า) ระหว่าง 01 ถึง 12 06
ล ชั่วโมงสองหลัก (ไม่มีศูนย์นำหน้า) ระหว่าง 1 ถึง 12 6
ม นาทีสองหลัก (มีเลขศูนย์นำหน้า) 05
ส วินาทีสองหลัก (มีศูนย์นำหน้า) 19
ล มิลลิวินาทีสามหลัก (มีศูนย์นำหน้า) 047
น นาโนวินาทีเก้าหลัก (มีศูนย์นำหน้า) 047000000
ป ตัวพิมพ์ใหญ่เช้าหรือบ่าย น
น ตัวพิมพ์เล็กตอนเช้าหรือตอนบ่าย น
z ค่าชดเชยตัวเลข RFC 822 จาก GMT -0800
Z เขตเวลา PST
เอส วินาทีตั้งแต่ 1970-01-01 00:00:00 GMT 1078884319
ถาม มิลลิวินาทีตั้งแต่ 1970-01-01 00:00:00 GMT 1078884319047

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

การแยกสตริงเป็นวันที่

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

ตัวอย่าง

import java.util.*;
import java.text.*;
  
public class DateDemo {

   public static void main(String args[]) {
      SimpleDateFormat ft = new SimpleDateFormat ("yyyy-MM-dd"); 
      String input = args.length == 0 ? "1818-11-11" : args[0]; 

      System.out.print(input + " Parses as "); 
      Date t;
      try {
         t = ft.parse(input); 
         System.out.println(t); 
      } catch (ParseException e) { 
         System.out.println("Unparseable using " + ft); 
      }
   }
}

ตัวอย่างการรันโปรแกรมข้างต้นจะให้ผลลัพธ์ดังต่อไปนี้ -

เอาต์พุต

1818-11-11 Parses as Wed Nov 11 00:00:00 EST 1818

นอนสักพัก

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

ตัวอย่าง

import java.util.*;
public class SleepDemo {

   public static void main(String args[]) {
      try { 
         System.out.println(new Date( ) + "\n"); 
         Thread.sleep(5*60*10); 
         System.out.println(new Date( ) + "\n"); 
      } catch (Exception e) {
         System.out.println("Got an exception!"); 
      }
   }
}

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -

เอาต์พุต

Sun May 03 18:04:41 GMT 2009
Sun May 03 18:04:51 GMT 2009

การวัดเวลาที่ผ่านไป

บางครั้งคุณอาจต้องวัดจุดในเวลาเป็นมิลลิวินาที ลองเขียนตัวอย่างด้านบนอีกครั้ง -

ตัวอย่าง

import java.util.*;
public class DiffDemo {

   public static void main(String args[]) {
      try {
         long start = System.currentTimeMillis( );
         System.out.println(new Date( ) + "\n");
         
         Thread.sleep(5*60*10);
         System.out.println(new Date( ) + "\n");
         
         long end = System.currentTimeMillis( );
         long diff = end - start;
         System.out.println("Difference is : " + diff);
      } catch (Exception e) {
         System.out.println("Got an exception!");
      }
   }
}

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -

เอาต์พุต

Sun May 03 18:16:51 GMT 2009
Sun May 03 18:16:57 GMT 2009
Difference is : 5993

คลาส GregorianCalendar

GregorianCalendar คือการนำคลาสปฏิทินไปใช้อย่างเป็นรูปธรรมซึ่งใช้ปฏิทินเกรกอเรียนตามปกติที่คุณคุ้นเคย เราไม่ได้พูดถึงคลาสปฏิทินในบทช่วยสอนนี้คุณสามารถค้นหาเอกสาร Java มาตรฐานสำหรับสิ่งนี้ได้

getInstance( )วิธีการของปฏิทินส่งคืน GregorianCalendar ที่เริ่มต้นด้วยวันที่และเวลาปัจจุบันในตำแหน่งที่ตั้งเริ่มต้นและเขตเวลา GregorianCalendar กำหนดสองฟิลด์: AD และ BC สิ่งเหล่านี้แสดงถึงสองยุคที่กำหนดโดยปฏิทินเกรกอเรียน

นอกจากนี้ยังมีตัวสร้างหลายตัวสำหรับวัตถุ GregorianCalendar -

ซีเนียร์ ตัวสร้างและคำอธิบาย
1

GregorianCalendar()

สร้าง GregorianCalendar เริ่มต้นโดยใช้เวลาปัจจุบันในเขตเวลาเริ่มต้นด้วยโลแคลเริ่มต้น
2

GregorianCalendar(int year, int month, int date)

สร้าง GregorianCalendar ด้วยวันที่ที่กำหนดไว้ในเขตเวลาเริ่มต้นด้วยโลแคลเริ่มต้น
3

GregorianCalendar(int year, int month, int date, int hour, int minute)

สร้าง GregorianCalendar ด้วยวันที่และเวลาที่กำหนดสำหรับโซนเวลาเริ่มต้นด้วยโลแคลเริ่มต้น
4

GregorianCalendar(int year, int month, int date, int hour, int minute, int second)

สร้าง GregorianCalendar ด้วยวันที่และเวลาที่กำหนดสำหรับโซนเวลาเริ่มต้นด้วยโลแคลเริ่มต้น
5

GregorianCalendar(Locale aLocale)

สร้าง GregorianCalendar ตามเวลาปัจจุบันในเขตเวลาเริ่มต้นด้วยโลแคลที่กำหนด
6

GregorianCalendar(TimeZone zone)

สร้าง GregorianCalendar ตามเวลาปัจจุบันในเขตเวลาที่กำหนดด้วยโลแคลเริ่มต้น
7

GregorianCalendar(TimeZone zone, Locale aLocale)

สร้าง GregorianCalendar ตามเวลาปัจจุบันในเขตเวลาที่กำหนดด้วยโลแคลที่กำหนด

นี่คือรายการวิธีการสนับสนุนที่เป็นประโยชน์บางประการที่มีให้โดยคลาส GregorianCalendar -

ซีเนียร์ วิธีการและคำอธิบาย
1

void add(int field, int amount)

เพิ่มระยะเวลาที่ระบุ (เซ็นชื่อ) ลงในฟิลด์เวลาที่กำหนดโดยยึดตามกฎของปฏิทิน
2

protected void computeFields()

แปลง UTC เป็นมิลลิวินาทีเป็นค่าฟิลด์เวลา
3

protected void computeTime()

แทนที่ปฏิทินจะแปลงค่าฟิลด์เวลาเป็น UTC เป็นมิลลิวินาที
4

boolean equals(Object obj)

เปรียบเทียบ GregorianCalendar นี้กับการอ้างอิงวัตถุ
5

int get(int field)

รับค่าสำหรับฟิลด์เวลาที่กำหนด
6

int getActualMaximum(int field)

ส่งคืนค่าสูงสุดที่ฟิลด์นี้สามารถมีได้โดยระบุวันที่ปัจจุบัน
7

int getActualMinimum(int field)

ส่งคืนค่าต่ำสุดที่ฟิลด์นี้สามารถมีได้โดยระบุวันที่ปัจจุบัน
8

int getGreatestMinimum(int field)

ส่งคืนค่าต่ำสุดสูงสุดสำหรับฟิลด์ที่กำหนดหากแตกต่างกัน
9

Date getGregorianChange()

รับวันที่เปลี่ยนปฏิทินเกรกอเรียน
10

int getLeastMaximum(int field)

ส่งคืนค่าสูงสุดต่ำสุดสำหรับฟิลด์ที่กำหนดหากแตกต่างกัน
11

int getMaximum(int field)

ส่งคืนค่าสูงสุดสำหรับฟิลด์ที่กำหนด
12

Date getTime()

รับเวลาปัจจุบันของปฏิทินนี้
13

long getTimeInMillis()

รับเวลาปัจจุบันของปฏิทินนี้เป็นเวลานาน
14

TimeZone getTimeZone()

รับเขตเวลา
15

int getMinimum(int field)

ส่งคืนค่าต่ำสุดสำหรับฟิลด์ที่กำหนด
16

int hashCode()

แทนที่ hashCode
17

boolean isLeapYear(int year)

พิจารณาว่าปีที่กำหนดเป็นปีอธิกสุรทินหรือไม่
18

void roll(int field, boolean up)

เพิ่มหรือลบ (ขึ้น / ลง) หน่วยเวลาเดียวในฟิลด์เวลาที่กำหนดโดยไม่ต้องเปลี่ยนฟิลด์ขนาดใหญ่
19

void set(int field, int value)

ตั้งค่าฟิลด์เวลาด้วยค่าที่กำหนด
20

void set(int year, int month, int date)

ตั้งค่าสำหรับฟิลด์ปีเดือนและวันที่
21

void set(int year, int month, int date, int hour, int minute)

ตั้งค่าสำหรับฟิลด์ปีเดือนวันที่ชั่วโมงและนาที
22

void set(int year, int month, int date, int hour, int minute, int second)

ตั้งค่าสำหรับฟิลด์ปีเดือนวันที่ชั่วโมงนาทีและวินาที
23

void setGregorianChange(Date date)

ตั้งค่าวันที่เปลี่ยนแปลง GregorianCalendar
24

void setTime(Date date)

ตั้งเวลาปัจจุบันของปฏิทินด้วยวันที่ที่กำหนด
25

void setTimeInMillis(long millis)

ตั้งค่าเวลาปัจจุบันของปฏิทินจากค่ายาวที่กำหนด
26

void setTimeZone(TimeZone value)

ตั้งค่าโซนเวลาด้วยค่าโซนเวลาที่กำหนด
27

String toString()

ส่งกลับการแสดงสตริงของปฏิทินนี้

ตัวอย่าง

import java.util.*;
public class GregorianCalendarDemo {

   public static void main(String args[]) {
      String months[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", 
         "Oct", "Nov", "Dec"};
      
      int year;
      // Create a Gregorian calendar initialized
      // with the current date and time in the
      // default locale and timezone.
      
      GregorianCalendar gcalendar = new GregorianCalendar();
      
      // Display current time and date information.
      System.out.print("Date: ");
      System.out.print(months[gcalendar.get(Calendar.MONTH)]);
      System.out.print(" " + gcalendar.get(Calendar.DATE) + " ");
      System.out.println(year = gcalendar.get(Calendar.YEAR));
      System.out.print("Time: ");
      System.out.print(gcalendar.get(Calendar.HOUR) + ":");
      System.out.print(gcalendar.get(Calendar.MINUTE) + ":");
      System.out.println(gcalendar.get(Calendar.SECOND));

      // Test if the current year is a leap year
      if(gcalendar.isLeapYear(year)) {
         System.out.println("The current year is a leap year");
      }else {
         System.out.println("The current year is not a leap year");
      }
   }
}

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -

เอาต์พุต

Date: Apr 22 2009
Time: 11:25:27
The current year is not a leap year

สำหรับรายการค่าคงที่ทั้งหมดที่มีอยู่ในคลาสปฏิทินคุณสามารถอ้างอิงเอกสาร Java มาตรฐาน

Java จัดเตรียมแพ็กเกจ java.util.regex สำหรับการจับคู่รูปแบบกับนิพจน์ทั่วไป นิพจน์ทั่วไปของ Java นั้นคล้ายกับภาษาโปรแกรม Perl มากและเรียนรู้ได้ง่ายมาก

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

แพ็คเกจ java.util.regex ส่วนใหญ่ประกอบด้วยสามคลาสต่อไปนี้ -

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

  • Matcher Class- วัตถุ Matcher เป็นเครื่องมือที่ตีความรูปแบบและดำเนินการจับคู่กับสตริงอินพุต เช่นเดียวกับคลาส Pattern Matcher ไม่ได้กำหนดตัวสร้างสาธารณะ คุณได้รับวัตถุ Matcher โดยเรียกใช้ไฟล์matcher() วิธีการบนวัตถุ Pattern

  • PatternSyntaxException - ออบเจ็กต์ PatternSyntaxException เป็นข้อยกเว้นที่ไม่ได้เลือกไว้ซึ่งบ่งชี้ข้อผิดพลาดทางไวยากรณ์ในรูปแบบนิพจน์ทั่วไป

การจับภาพกลุ่ม

การจับกลุ่มเป็นวิธีการปฏิบัติต่ออักขระหลายตัวเป็นหน่วยเดียว สร้างขึ้นโดยการวางอักขระที่จะจัดกลุ่มภายในชุดวงเล็บ ตัวอย่างเช่นนิพจน์ทั่วไป (สุนัข) สร้างกลุ่มเดียวที่มีตัวอักษร "d" "o" และ "g"

การจับภาพกลุ่มจะมีหมายเลขโดยการนับวงเล็บเปิดจากด้านซ้ายไปทางขวา ในนิพจน์ ((A) (B (C))) ตัวอย่างเช่นมีสี่กลุ่มดังกล่าว -

  • ((A)(B(C)))
  • (A)
  • (B(C))
  • (C)

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

นอกจากนี้ยังมีกลุ่มพิเศษกลุ่ม 0 ซึ่งแสดงถึงนิพจน์ทั้งหมดเสมอ กลุ่มนี้ไม่รวมอยู่ในจำนวนทั้งหมดที่รายงานโดย groupCount

Example

ตัวอย่างต่อไปนี้แสดงให้เห็นถึงวิธีการค้นหาสตริงหลักจากสตริงตัวอักษรและตัวเลขที่กำหนด -

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatches {

   public static void main( String args[] ) {
      // String to be scanned to find the pattern.
      String line = "This order was placed for QT3000! OK?";
      String pattern = "(.*)(\\d+)(.*)";

      // Create a Pattern object
      Pattern r = Pattern.compile(pattern);

      // Now create matcher object.
      Matcher m = r.matcher(line);
      if (m.find( )) {
         System.out.println("Found value: " + m.group(0) );
         System.out.println("Found value: " + m.group(1) );
         System.out.println("Found value: " + m.group(2) );
      }else {
         System.out.println("NO MATCH");
      }
   }
}

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -

Output

Found value: This order was placed for QT3000! OK?
Found value: This order was placed for QT300
Found value: 0

ไวยากรณ์นิพจน์ทั่วไป

นี่คือตารางที่แสดงรายการไวยากรณ์ของนิพจน์ทั่วไป metacharacter ทั้งหมดที่มีอยู่ใน Java -

Subexpression ตรงกัน
^ ตรงกับจุดเริ่มต้นของบรรทัด
$ ตรงกับจุดสิ้นสุดของบรรทัด
. จับคู่อักขระเดี่ยวใด ๆ ยกเว้นขึ้นบรรทัดใหม่ การใช้m ตัวเลือกช่วยให้ตรงกับบรรทัดใหม่เช่นกัน
[... ] จับคู่อักขระเดี่ยวใด ๆ ในวงเล็บ
[^ ... ] จับคู่อักขระเดี่ยวใด ๆ ที่ไม่อยู่ในวงเล็บ
\ ก จุดเริ่มต้นของสตริงทั้งหมด
\ z สิ้นสุดสตริงทั้งหมด
\ Z สิ้นสุดสตริงทั้งหมดยกเว้นตัวยุติบรรทัดสุดท้ายที่อนุญาต
re * จับคู่ 0 หรือมากกว่าที่เกิดขึ้นของนิพจน์ก่อนหน้า
re + ตรงกับสิ่งก่อนหน้าอย่างน้อย 1 อย่าง
รี? จับคู่ 0 หรือ 1 ครั้งของนิพจน์ก่อนหน้า
อีกครั้ง {n} ตรงกับจำนวนครั้งที่เกิดขึ้นของนิพจน์ก่อนหน้า
re {n,} จับคู่ n เหตุการณ์ขึ้นไปของนิพจน์ก่อนหน้า
ใหม่ {n, m} จับคู่อย่างน้อย n และมากที่สุด m ที่เกิดขึ้นของนิพจน์ก่อนหน้า
ก | ข จับคู่ a หรือ b
(อีกครั้ง) จัดกลุ่มนิพจน์ทั่วไปและจดจำข้อความที่ตรงกัน
(?: re) จัดกลุ่มนิพจน์ทั่วไปโดยไม่จำข้อความที่ตรงกัน
(?> อีกครั้ง) จับคู่รูปแบบอิสระโดยไม่ต้องย้อนรอย
\ w จับคู่อักขระคำ
\ ว จับคู่อักขระที่ไม่ใช่คำหลัก
\ s ตรงกับช่องว่าง เทียบเท่ากับ [\ t \ n \ r \ f]
\ S ตรงกับ nonwhitespace
\ d ตรงกับตัวเลข เทียบเท่ากับ [0-9]
\ D ตรงกับ nondigits
\ ก ตรงกับจุดเริ่มต้นของสตริง
\ Z ตรงกับจุดสิ้นสุดของสตริง หากมีขึ้นบรรทัดใหม่จะตรงกับก่อนขึ้นบรรทัดใหม่
\ z ตรงกับจุดสิ้นสุดของสตริง
\ G ตรงกับจุดที่นัดสุดท้ายจบ
\ n อ้างอิงย้อนกลับเพื่อจับหมายเลขกลุ่ม "n"
\ b จับคู่ขอบเขตของคำเมื่ออยู่นอกเครื่องหมายวงเล็บ จับคู่ backspace (0x08) เมื่ออยู่ในวงเล็บ
\ B ตรงกับขอบเขตที่ไม่ใช่คำ
\ n, t ฯลฯ จับคู่การขึ้นบรรทัดใหม่การคืนค่าขนส่งแท็บ ฯลฯ
\ Q Escape (quote) อักขระทั้งหมดไม่เกิน \ E
\ E สิ้นสุดการอ้างอิงเริ่มต้นด้วย \ Q

วิธีการของคลาส Matcher

นี่คือรายการวิธีการอินสแตนซ์ที่มีประโยชน์ -

วิธีการจัดทำดัชนี

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

ซีเนียร์ วิธีการและคำอธิบาย
1

public int start()

ส่งคืนดัชนีเริ่มต้นของการแข่งขันก่อนหน้า
2

public int start(int group)

ส่งคืนดัชนีเริ่มต้นของลำดับต่อมาที่จับโดยกลุ่มที่ระบุระหว่างการดำเนินการจับคู่ก่อนหน้า
3

public int end()

ส่งคืนค่าชดเชยหลังจากอักขระสุดท้ายที่ตรงกัน
4

public int end(int group)

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

วิธีการศึกษา

วิธีการศึกษาตรวจสอบสตริงอินพุตและส่งคืนบูลีนที่ระบุว่าพบรูปแบบหรือไม่ -

ซีเนียร์ วิธีการและคำอธิบาย
1

public boolean lookingAt()

พยายามจับคู่ลำดับการป้อนข้อมูลโดยเริ่มต้นที่จุดเริ่มต้นของภูมิภาคกับรูปแบบ
2

public boolean find()

พยายามค้นหาลำดับต่อไปของลำดับอินพุตที่ตรงกับรูปแบบ
3

public boolean find(int start)

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

public boolean matches()

พยายามจับคู่ภูมิภาคทั้งหมดกับรูปแบบ

วิธีการเปลี่ยน

วิธีการแทนที่เป็นวิธีที่มีประโยชน์ในการแทนที่ข้อความในสตริงอินพุต -

ซีเนียร์ วิธีการและคำอธิบาย
1

public Matcher appendReplacement(StringBuffer sb, String replacement)

ใช้ขั้นตอนการผนวกและแทนที่ที่ไม่ใช่เทอร์มินัล
2

public StringBuffer appendTail(StringBuffer sb)

ใช้ขั้นตอนต่อท้ายและแทนที่เทอร์มินัล
3

public String replaceAll(String replacement)

แทนที่ลำดับการป้อนข้อมูลในลำดับต่อ ๆ มาที่ตรงกับรูปแบบด้วยสตริงการแทนที่ที่กำหนด
4

public String replaceFirst(String replacement)

แทนที่ลำดับการป้อนข้อมูลลำดับแรกที่ตรงกับรูปแบบด้วยสตริงการแทนที่ที่กำหนด
5

public static String quoteReplacement(String s)

ส่งคืนสตริงการแทนที่ตามตัวอักษรสำหรับสตริงที่ระบุ วิธีนี้สร้างสตริงที่จะใช้แทนตัวอักษรs ในเมธอด appendReplacement ของคลาส Matcher

วิธีการเริ่มต้นและสิ้นสุด

ต่อไปนี้เป็นตัวอย่างที่นับจำนวนครั้งที่คำว่า "cat" ปรากฏในสตริงอินพุต -

Example

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatches {

   private static final String REGEX = "\\bcat\\b";
   private static final String INPUT = "cat cat cat cattie cat";

   public static void main( String args[] ) {
      Pattern p = Pattern.compile(REGEX);
      Matcher m = p.matcher(INPUT);   // get a matcher object
      int count = 0;

      while(m.find()) {
         count++;
         System.out.println("Match number "+count);
         System.out.println("start(): "+m.start());
         System.out.println("end(): "+m.end());
      }
   }
}

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -

Output

Match number 1
start(): 0
end(): 3
Match number 2
start(): 4
end(): 7
Match number 3
start(): 8
end(): 11
Match number 4
start(): 19
end(): 22

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

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

การจับคู่และการมองหาที่วิธีการ

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

ทั้งสองวิธีเริ่มต้นที่จุดเริ่มต้นของสตริงอินพุตเสมอ นี่คือตัวอย่างที่อธิบายฟังก์ชันการทำงาน -

Example

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatches {

   private static final String REGEX = "foo";
   private static final String INPUT = "fooooooooooooooooo";
   private static Pattern pattern;
   private static Matcher matcher;

   public static void main( String args[] ) {
      pattern = Pattern.compile(REGEX);
      matcher = pattern.matcher(INPUT);

      System.out.println("Current REGEX is: "+REGEX);
      System.out.println("Current INPUT is: "+INPUT);

      System.out.println("lookingAt(): "+matcher.lookingAt());
      System.out.println("matches(): "+matcher.matches());
   }
}

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -

Output

Current REGEX is: foo
Current INPUT is: fooooooooooooooooo
lookingAt(): true
matches(): false

replaceFirst และ replaceAll Methods

วิธีการ replaceFirst และ replaceAll จะแทนที่ข้อความที่ตรงกับนิพจน์ทั่วไปที่กำหนด ตามที่ระบุชื่อไว้ replaceFirst จะแทนที่เหตุการณ์แรกและ replaceAll จะแทนที่เหตุการณ์ทั้งหมด

นี่คือตัวอย่างที่อธิบายฟังก์ชันการทำงาน -

Example

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatches {

   private static String REGEX = "dog";
   private static String INPUT = "The dog says meow. " + "All dogs say meow.";
   private static String REPLACE = "cat";

   public static void main(String[] args) {
      Pattern p = Pattern.compile(REGEX);
      
      // get a matcher object
      Matcher m = p.matcher(INPUT); 
      INPUT = m.replaceAll(REPLACE);
      System.out.println(INPUT);
   }
}

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -

Output

The cat says meow. All cats say meow.

วิธี appendReplacement และ appendTail

คลาส Matcher ยังมีวิธี appendReplacement และ appendTail สำหรับการแทนที่ข้อความ

นี่คือตัวอย่างที่อธิบายฟังก์ชันการทำงาน -

Example

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatches {

   private static String REGEX = "a*b";
   private static String INPUT = "aabfooaabfooabfoob";
   private static String REPLACE = "-";
   public static void main(String[] args) {

      Pattern p = Pattern.compile(REGEX);
      
      // get a matcher object
      Matcher m = p.matcher(INPUT);
      StringBuffer sb = new StringBuffer();
      while(m.find()) {
         m.appendReplacement(sb, REPLACE);
      }
      m.appendTail(sb);
      System.out.println(sb.toString());
   }
}

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -

Output

-foo-foo-foo-

วิธีการเรียน PatternSyntaxException

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

ซีเนียร์ วิธีการและคำอธิบาย
1

public String getDescription()

ดึงคำอธิบายของข้อผิดพลาด
2

public int getIndex()

ดึงดัชนีข้อผิดพลาด
3

public String getPattern()

ดึงรูปแบบนิพจน์ทั่วไปที่ผิดพลาด
4

public String getMessage()

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

วิธี Java คือชุดของคำสั่งที่รวมกลุ่มกันเพื่อดำเนินการ เมื่อคุณเรียก System.outprintln() วิธีการตัวอย่างเช่นระบบเรียกใช้คำสั่งต่างๆเพื่อแสดงข้อความบนคอนโซล

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

การสร้างวิธีการ

พิจารณาตัวอย่างต่อไปนี้เพื่ออธิบายไวยากรณ์ของวิธีการ -

Syntax

public static int methodName(int a, int b) {
   // body
}

ที่นี่

  • public static - ตัวปรับแต่ง

  • int - ประเภทผลตอบแทน

  • methodName - ชื่อของวิธีการ

  • a, b - พารามิเตอร์ทางการ

  • int a, int b - รายการพารามิเตอร์

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

Syntax

modifier returnType nameOfMethod (Parameter List) {
   // method body
}

ไวยากรณ์ที่แสดงด้านบนประกอบด้วย -

  • modifier - กำหนดประเภทการเข้าถึงของวิธีการและเป็นทางเลือกที่จะใช้

  • returnType - เมธอดอาจส่งคืนค่า

  • nameOfMethod- นี่คือชื่อเมธอด ลายเซ็นเมธอดประกอบด้วยชื่อเมธอดและรายการพารามิเตอร์

  • Parameter List- รายการพารามิเตอร์เป็นประเภทลำดับและจำนวนพารามิเตอร์ของวิธีการ วิธีเหล่านี้เป็นทางเลือกวิธีการอาจมีพารามิเตอร์เป็นศูนย์

  • method body - เนื้อความของวิธีการกำหนดว่าวิธีการนี้ทำอะไรกับงบ

Example

นี่คือซอร์สโค้ดของวิธีการที่กำหนดไว้ข้างต้นที่เรียกว่า min(). วิธีนี้ใช้สองพารามิเตอร์ num1 และ num2 และส่งกลับค่าสูงสุดระหว่างสอง -

/** the snippet returns the minimum between two numbers */

public static int minFunction(int n1, int n2) {
   int min;
   if (n1 > n2)
      min = n2;
   else
      min = n1;

   return min; 
}

วิธีการโทร

สำหรับการใช้วิธีนั้นควรเรียกว่า มีสองวิธีที่เรียกเมธอดคือเมธอดส่งคืนค่าหรือคืนค่าอะไร (ไม่มีค่าส่งคืน)

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

  • คำสั่ง return ถูกดำเนินการ
  • ถึงเมธอดที่สิ้นสุดการปิดวงเล็บปีกกา

วิธีการคืนโมฆะถือเป็นการเรียกไปยังคำสั่ง ลองพิจารณาตัวอย่าง -

System.out.println("This is tutorialspoint.com!");

วิธีการคืนค่าสามารถเข้าใจได้จากตัวอย่างต่อไปนี้ -

int result = sum(6, 9);

ต่อไปนี้เป็นตัวอย่างเพื่อสาธิตวิธีการกำหนดวิธีการและวิธีการเรียกใช้ -

Example

public class ExampleMinNumber {
   
   public static void main(String[] args) {
      int a = 11;
      int b = 6;
      int c = minFunction(a, b);
      System.out.println("Minimum Value = " + c);
   }

   /** returns the minimum of two numbers */
   public static int minFunction(int n1, int n2) {
      int min;
      if (n1 > n2)
         min = n2;
      else
         min = n1;

      return min; 
   }
}

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -

Output

Minimum value = 6

คีย์เวิร์ดที่เป็นโมฆะ

คีย์เวิร์ดที่เป็นโมฆะช่วยให้เราสามารถสร้างเมธอดที่ไม่ส่งคืนค่า ที่นี่ในตัวอย่างต่อไปนี้เรากำลังพิจารณาวิธีการที่เป็นโมฆะmethodRankPoints วิธีนี้เป็นวิธีโมฆะซึ่งไม่คืนค่าใด ๆ การเรียกใช้เมธอด void ต้องเป็นคำสั่งเช่นmethodRankPoints (255.7); . เป็นคำสั่ง Java ที่ลงท้ายด้วยอัฒภาคตามที่แสดงในตัวอย่างต่อไปนี้

Example

public class ExampleVoid {

   public static void main(String[] args) {
      methodRankPoints(255.7);
   }

   public static void methodRankPoints(double points) {
      if (points >= 202.5) {
         System.out.println("Rank:A1");
      }else if (points >= 122.4) {
         System.out.println("Rank:A2");
      }else {
         System.out.println("Rank:A3");
      }
   }
}

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -

Output

Rank:A1

การส่งผ่านพารามิเตอร์ตามค่า

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

การส่งผ่านพารามิเตอร์ตามค่าหมายถึงการเรียกใช้เมธอดด้วยพารามิเตอร์ ด้วยวิธีนี้ค่าอาร์กิวเมนต์จะถูกส่งไปยังพารามิเตอร์

Example

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

public class swappingExample {

   public static void main(String[] args) {
      int a = 30;
      int b = 45;
      System.out.println("Before swapping, a = " + a + " and b = " + b);

      // Invoke the swap method
      swapFunction(a, b);
      System.out.println("\n**Now, Before and After swapping values will be same here**:");
      System.out.println("After swapping, a = " + a + " and b is " + b);
   }

   public static void swapFunction(int a, int b) {
      System.out.println("Before swapping(Inside), a = " + a + " b = " + b);
      
      // Swap n1 with n2
      int c = a;
      a = b;
      b = c;
      System.out.println("After swapping(Inside), a = " + a + " b = " + b);
   }
}

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -

Output

Before swapping, a = 30 and b = 45
Before swapping(Inside), a = 30 b = 45
After swapping(Inside), a = 45 b = 30

**Now, Before and After swapping values will be same here**:
After swapping, a = 30 and b is 45

วิธีการโอเวอร์โหลด

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

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

ตัวอย่างต่อไปนี้อธิบายเหมือนกัน -

Example

public class ExampleOverloading {

   public static void main(String[] args) {
      int a = 11;
      int b = 6;
      double c = 7.3;
      double d = 9.4;
      int result1 = minFunction(a, b);
      
      // same function name with different parameters
      double result2 = minFunction(c, d);
      System.out.println("Minimum Value = " + result1);
      System.out.println("Minimum Value = " + result2);
   }

   // for integer
   public static int minFunction(int n1, int n2) {
      int min;
      if (n1 > n2)
         min = n2;
      else
         min = n1;

      return min; 
   }
   
   // for double
   public static double minFunction(double n1, double n2) {
     double min;
      if (n1 > n2)
         min = n2;
      else
         min = n1;

      return min; 
   }
}

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -

Output

Minimum Value = 6
Minimum Value = 7.3

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

ใช้อาร์กิวเมนต์บรรทัดคำสั่ง

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

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

Example

โปรแกรมต่อไปนี้แสดงอาร์กิวเมนต์บรรทัดคำสั่งทั้งหมดที่เรียกด้วย -

public class CommandLine {

   public static void main(String args[]) { 
      for(int i = 0; i<args.length; i++) {
         System.out.println("args[" + i + "]: " +  args[i]);
      }
   }
}

ลองรันโปรแกรมนี้ตามที่แสดงไว้ที่นี่ -

$java CommandLine this is a command line 200 -100

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -

Output

args[0]: this
args[1]: is
args[2]: a
args[3]: command
args[4]: line
args[5]: 200
args[6]: -100

คีย์เวิร์ดนี้

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

Note- คีย์เวิร์ดนี้ใช้ภายในวิธีการอินสแตนซ์หรือตัวสร้างเท่านั้น

โดยทั่วไปคำหลักนี้ใช้เพื่อ -

  • แยกความแตกต่างของตัวแปรอินสแตนซ์จากตัวแปรโลคัลหากมีชื่อเดียวกันภายในตัวสร้างหรือวิธีการ

class Student {
   int age;   
   Student(int age) {
      this.age = age;	
   }
}

  • เรียกตัวสร้างประเภทหนึ่ง (ตัวสร้างพารามิเตอร์หรือค่าเริ่มต้น) จากตัวสร้างอื่น ๆ ในคลาส เรียกว่าการเรียกตัวสร้างที่ชัดเจน

class Student {
   int age
   Student() {
      this(20);
   }
   
   Student(int age) {
      this.age = age;	
   }
}

Example

นี่คือตัวอย่างที่ใช้คีย์เวิร์ดนี้เพื่อเข้าถึงสมาชิกของคลาส คัดลอกและวางโปรแกรมต่อไปนี้ในไฟล์ที่มีชื่อThis_Example.java.

public class This_Example {
   // Instance variable num
   int num = 10;
	
   This_Example() {
      System.out.println("This is an example program on keyword this");	
   }

   This_Example(int num) {
      // Invoking the default constructor
      this();
      
      // Assigning the local variable num to the instance variable num
      this.num = num;	   
   }
   
   public void greet() {
      System.out.println("Hi Welcome to Tutorialspoint");
   }
      
   public void print() {
      // Local variable num
      int num = 20;
      
      // Printing the local variable
      System.out.println("value of local variable num is : "+num);
      
      // Printing the instance variable
      System.out.println("value of instance variable num is : "+this.num);
      
      // Invoking the greet method of a class
      this.greet();     
   }
   
   public static void main(String[] args) {
      // Instantiating the class
      This_Example obj1 = new This_Example();
      
      // Invoking the print method
      obj1.print();
	  
      // Passing a new value to the num variable through Parameterized constructor
      This_Example obj2 = new This_Example(30);
      
      // Invoking the print method again
      obj2.print(); 
   }
}

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -

Output

This is an example program on keyword this 
value of local variable num is : 20
value of instance variable num is : 10
Hi Welcome to Tutorialspoint
This is an example program on keyword this 
value of local variable num is : 20
value of instance variable num is : 30
Hi Welcome to Tutorialspoint

อาร์กิวเมนต์ตัวแปร (var-args)

JDK 1.5 ช่วยให้คุณสามารถส่งผ่านจำนวนตัวแปรของอาร์กิวเมนต์ประเภทเดียวกันไปยังเมธอด พารามิเตอร์ในวิธีการประกาศดังต่อไปนี้ -

typeName... parameterName

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

Example

public class VarargsDemo {

   public static void main(String args[]) {
      // Call method with variable args  
	   printMax(34, 3, 3, 2, 56.5);
      printMax(new double[]{1, 2, 3});
   }

   public static void printMax( double... numbers) {
      if (numbers.length == 0) {
         System.out.println("No argument passed");
         return;
      }

      double result = numbers[0];

      for (int i = 1; i <  numbers.length; i++)
      if (numbers[i] >  result)
      result = numbers[i];
      System.out.println("The max value is " + result);
   }
}

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -

Output

The max value is 56.5
The max value is 3.0

วิธีการสรุป ()

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

ตัวอย่างเช่นคุณอาจใช้ finalize () เพื่อให้แน่ใจว่าไฟล์ที่เปิดอยู่ของอ็อบเจ็กต์นั้นปิดอยู่

ในการเพิ่ม Finalizer ให้กับคลาสคุณเพียงแค่กำหนดเมธอด finalize () รันไทม์ของ Java เรียกใช้เมธอดนั้นเมื่อใดก็ตามที่กำลังจะรีไซเคิลอ็อบเจ็กต์ของคลาสนั้น

ภายในเมธอด finalize () คุณจะระบุการดำเนินการที่ต้องดำเนินการก่อนที่วัตถุจะถูกทำลาย

วิธี finalize () มีรูปแบบทั่วไปนี้ -

protected void finalize( ) {
   // finalization code here
}

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

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

แพ็คเกจ java.io มีเกือบทุกคลาสที่คุณอาจต้องใช้เพื่อดำเนินการอินพุตและเอาต์พุต (I / O) ใน Java สตรีมทั้งหมดเหล่านี้แสดงถึงแหล่งอินพุตและปลายทางเอาต์พุต สตรีมในแพ็กเกจ java.io รองรับข้อมูลมากมายเช่น primitives object ตัวอักษรที่แปลเป็นภาษาท้องถิ่นเป็นต้น

กระแส

สตรีมสามารถกำหนดเป็นลำดับของข้อมูลได้ สตรีมมีสองประเภท -

  • InPutStream - InputStream ใช้เพื่ออ่านข้อมูลจากแหล่งที่มา

  • OutPutStream - OutputStream ใช้สำหรับเขียนข้อมูลไปยังปลายทาง

Java ให้การสนับสนุนที่แข็งแกร่ง แต่ยืดหยุ่นสำหรับ I / O ที่เกี่ยวข้องกับไฟล์และเครือข่าย แต่บทช่วยสอนนี้ครอบคลุมฟังก์ชันพื้นฐานที่เกี่ยวข้องกับสตรีมและ I / O เราจะเห็นตัวอย่างที่ใช้บ่อยที่สุดทีละตัวอย่าง -

ไบต์สตรีม

สตรีม Java byte ใช้เพื่อดำเนินการอินพุตและเอาต์พุตของไบต์ 8 บิต แม้ว่าจะมีหลายคลาสที่เกี่ยวข้องกับไบต์สตรีม แต่คลาสที่ใช้บ่อยที่สุดคือFileInputStream และ FileOutputStream. ต่อไปนี้เป็นตัวอย่างที่ใช้ประโยชน์จากสองคลาสนี้เพื่อคัดลอกไฟล์อินพุตไปยังไฟล์เอาต์พุต -

Example

import java.io.*;
public class CopyFile {

   public static void main(String args[]) throws IOException {  
      FileInputStream in = null;
      FileOutputStream out = null;

      try {
         in = new FileInputStream("input.txt");
         out = new FileOutputStream("output.txt");
         
         int c;
         while ((c = in.read()) != -1) {
            out.write(c);
         }
      }finally {
         if (in != null) {
            in.close();
         }
         if (out != null) {
            out.close();
         }
      }
   }
}

ตอนนี้ขอมีไฟล์ input.txt โดยมีเนื้อหาดังต่อไปนี้ -

This is test for copy file.

ในขั้นตอนต่อไปให้คอมไพล์โปรแกรมข้างต้นและดำเนินการซึ่งจะส่งผลให้สร้างไฟล์ output.txt ที่มีเนื้อหาเดียวกับที่เรามีใน input.txt ลองใส่รหัสด้านบนในไฟล์ CopyFile.java แล้วทำสิ่งต่อไปนี้ -

$javac CopyFile.java $java CopyFile

สตรีมตัวละคร

Java Byte สตรีมใช้เพื่อดำเนินการอินพุตและเอาต์พุตของ 8 บิตไบต์ในขณะที่ Java Characterสตรีมใช้เพื่อดำเนินการอินพุตและเอาต์พุตสำหรับยูนิโคด 16 บิต แม้ว่าจะมีคลาสมากมายที่เกี่ยวข้องกับสตรีมตัวละคร แต่คลาสที่ใช้บ่อยที่สุดคือFileReader และ FileWriter. แม้ว่า FileReader ภายในจะใช้ FileInputStream และ FileWriter ใช้ FileOutputStream แต่ที่นี่ข้อแตกต่างที่สำคัญคือ FileReader อ่านครั้งละสองไบต์และ FileWriter เขียนครั้งละสองไบต์

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

Example

import java.io.*;
public class CopyFile {

   public static void main(String args[]) throws IOException {
      FileReader in = null;
      FileWriter out = null;

      try {
         in = new FileReader("input.txt");
         out = new FileWriter("output.txt");
         
         int c;
         while ((c = in.read()) != -1) {
            out.write(c);
         }
      }finally {
         if (in != null) {
            in.close();
         }
         if (out != null) {
            out.close();
         }
      }
   }
}

ตอนนี้ขอมีไฟล์ input.txt โดยมีเนื้อหาดังต่อไปนี้ -

This is test for copy file.

ในขั้นตอนต่อไปให้คอมไพล์โปรแกรมข้างต้นและดำเนินการซึ่งจะส่งผลให้สร้างไฟล์ output.txt ที่มีเนื้อหาเดียวกับที่เรามีใน input.txt ลองใส่รหัสด้านบนในไฟล์ CopyFile.java แล้วทำสิ่งต่อไปนี้ -

$javac CopyFile.java $java CopyFile

สตรีมมาตรฐาน

ภาษาโปรแกรมทั้งหมดให้การสนับสนุน I / O มาตรฐานซึ่งโปรแกรมของผู้ใช้สามารถรับอินพุตจากแป้นพิมพ์จากนั้นสร้างเอาต์พุตบนหน้าจอคอมพิวเตอร์ หากคุณรู้จักภาษาโปรแกรม C หรือ C ++ คุณต้องระวังอุปกรณ์มาตรฐานสามอย่าง STDIN, STDOUT และ STDERR ในทำนองเดียวกัน Java มีสตรีมมาตรฐานสามรายการต่อไปนี้ -

  • Standard Input - ใช้เพื่อป้อนข้อมูลไปยังโปรแกรมของผู้ใช้และโดยปกติแป้นพิมพ์จะใช้เป็นสตรีมอินพุตมาตรฐานและแสดงเป็น System.in.

  • Standard Output - ใช้เพื่อส่งออกข้อมูลที่สร้างโดยโปรแกรมของผู้ใช้และโดยปกติหน้าจอคอมพิวเตอร์จะใช้สำหรับสตรีมเอาต์พุตมาตรฐานและแสดงเป็น System.out.

  • Standard Error - ใช้เพื่อส่งออกข้อมูลข้อผิดพลาดที่สร้างโดยโปรแกรมของผู้ใช้และโดยปกติหน้าจอคอมพิวเตอร์จะใช้สำหรับสตรีมข้อผิดพลาดมาตรฐานและแสดงเป็น System.err.

ต่อไปนี้เป็นโปรแกรมง่ายๆที่สร้าง InputStreamReader เพื่ออ่านอินพุตมาตรฐานจนกว่าผู้ใช้จะพิมพ์ "q" -

Example

import java.io.*;
public class ReadConsole {

   public static void main(String args[]) throws IOException {
      InputStreamReader cin = null;

      try {
         cin = new InputStreamReader(System.in);
         System.out.println("Enter characters, 'q' to quit.");
         char c;
         do {
            c = (char) cin.read();
            System.out.print(c);
         } while(c != 'q');
      }finally {
         if (cin != null) {
            cin.close();
         }
      }
   }
}

มาเก็บโค้ดด้านบนไว้ในไฟล์ ReadConsole.java แล้วลองคอมไพล์และรันตามที่แสดงในโปรแกรมต่อไปนี้ โปรแกรมนี้ยังคงอ่านและส่งออกอักขระเดียวกันจนกว่าเราจะกด 'q' -

$javac ReadConsole.java $java ReadConsole
Enter characters, 'q' to quit.
1
1
e
e
q
q

การอ่านและเขียนไฟล์

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

นี่คือลำดับชั้นของคลาสเพื่อจัดการกับอินพุตและเอาต์พุตสตรีม

กระแสที่สำคัญสองสายคือ FileInputStream และ FileOutputStreamซึ่งจะกล่าวถึงในบทช่วยสอนนี้

FileInputStream

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

ตัวสร้างต่อไปนี้ใช้ชื่อไฟล์เป็นสตริงเพื่อสร้างอ็อบเจ็กต์สตรีมอินพุตเพื่ออ่านไฟล์ -

InputStream f = new FileInputStream("C:/java/hello");

ตัวสร้างต่อไปนี้ใช้อ็อบเจ็กต์ไฟล์เพื่อสร้างอ็อบเจ็กต์สตรีมอินพุตเพื่ออ่านไฟล์ ก่อนอื่นเราสร้างวัตถุไฟล์โดยใช้เมธอด File () ดังนี้ -

File f = new File("C:/java/hello");
InputStream f = new FileInputStream(f);

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

ซีเนียร์ วิธีการและคำอธิบาย
1

public void close() throws IOException{}

วิธีนี้จะปิดสตรีมเอาต์พุตไฟล์ เผยแพร่รีซอร์สระบบใด ๆ ที่เกี่ยวข้องกับไฟล์ พ่น IOException
2

protected void finalize()throws IOException {}

วิธีนี้จะล้างการเชื่อมต่อกับไฟล์ ตรวจสอบให้แน่ใจว่าเมธอดปิดของสตรีมเอาต์พุตไฟล์นี้ถูกเรียกเมื่อไม่มีการอ้างอิงถึงสตรีมนี้อีกต่อไป พ่น IOException
3

public int read(int r)throws IOException{}

วิธีนี้อ่านไบต์ข้อมูลที่ระบุจาก InputStream ส่งกลับค่า int ส่งคืนข้อมูลไบต์ถัดไปและ -1 จะถูกส่งกลับหากเป็นจุดสิ้นสุดของไฟล์
4

public int read(byte[] r) throws IOException{}

วิธีนี้อ่าน r.length ไบต์จากอินพุตสตรีมไปยังอาร์เรย์ ส่งคืนจำนวนไบต์ทั้งหมดที่อ่าน ถ้าเป็นจุดสิ้นสุดของไฟล์ -1 จะถูกส่งกลับ
5

public int available() throws IOException{}

ระบุจำนวนไบต์ที่สามารถอ่านได้จากสตรีมอินพุตไฟล์นี้ ส่งกลับค่า int

มีสตรีมอินพุตที่สำคัญอื่น ๆ สำหรับรายละเอียดเพิ่มเติมคุณสามารถอ้างถึงลิงค์ต่อไปนี้ -

  • ByteArrayInputStream

  • DataInputStream

FileOutputStream

FileOutputStream ใช้ในการสร้างไฟล์และเขียนข้อมูลลงในไฟล์ สตรีมจะสร้างไฟล์หากยังไม่มีอยู่ก่อนเปิดเพื่อส่งออก

นี่คือตัวสร้างสองตัวที่สามารถใช้เพื่อสร้างอ็อบเจ็กต์ FileOutputStream

ตัวสร้างต่อไปนี้ใช้ชื่อไฟล์เป็นสตริงเพื่อสร้างอ็อบเจ็กต์สตรีมอินพุตเพื่อเขียนไฟล์ -

OutputStream f = new FileOutputStream("C:/java/hello")

คอนสตรัคเตอร์ต่อไปนี้ใช้อ็อบเจ็กต์ไฟล์เพื่อสร้างอ็อบเจ็กต์สตรีมเอาต์พุตเพื่อเขียนไฟล์ ขั้นแรกเราสร้างวัตถุไฟล์โดยใช้เมธอด File () ดังนี้ -

File f = new File("C:/java/hello");
OutputStream f = new FileOutputStream(f);

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

ซีเนียร์ วิธีการและคำอธิบาย
1

public void close() throws IOException{}

วิธีนี้จะปิดสตรีมเอาต์พุตไฟล์ เผยแพร่รีซอร์สระบบใด ๆ ที่เกี่ยวข้องกับไฟล์ พ่น IOException
2

protected void finalize()throws IOException {}

วิธีนี้จะล้างการเชื่อมต่อกับไฟล์ ตรวจสอบให้แน่ใจว่าเมธอดปิดของสตรีมเอาต์พุตไฟล์นี้ถูกเรียกเมื่อไม่มีการอ้างอิงถึงสตรีมนี้อีกต่อไป พ่น IOException
3

public void write(int w)throws IOException{}

วิธีนี้เขียนไบต์ที่ระบุไปยังเอาต์พุตสตรีม
4

public void write(byte[] w)

เขียน w.length ไบต์จากอาร์เรย์ไบต์ที่กล่าวถึงไปยัง OutputStream

มีสตรีมเอาต์พุตที่สำคัญอื่น ๆ สำหรับรายละเอียดเพิ่มเติมคุณสามารถอ้างอิงลิงค์ต่อไปนี้ -

  • ByteArrayOutputStream

  • DataOutputStream

Example

ต่อไปนี้เป็นตัวอย่างเพื่อสาธิต InputStream และ OutputStream -

import java.io.*;
public class fileStreamTest {

   public static void main(String args[]) {
   
      try {
         byte bWrite [] = {11,21,3,40,5};
         OutputStream os = new FileOutputStream("test.txt");
         for(int x = 0; x < bWrite.length ; x++) {
            os.write( bWrite[x] );   // writes the bytes
         }
         os.close();
     
         InputStream is = new FileInputStream("test.txt");
         int size = is.available();

         for(int i = 0; i < size; i++) {
            System.out.print((char)is.read() + "  ");
         }
         is.close();
      } catch (IOException e) {
         System.out.print("Exception");
      }	
   }
}

โค้ดด้านบนจะสร้างไฟล์ test.txt และจะเขียนตัวเลขที่กำหนดในรูปแบบไบนารี เช่นเดียวกับผลลัพธ์บนหน้าจอ stdout

การนำทางไฟล์และ I / O

ยังมีคลาสอื่น ๆ อีกมากมายที่เราจะไปทำความรู้จักกับพื้นฐานของ File Navigation และ I / O

  • คลาสไฟล์

  • คลาส FileReader

  • คลาส FileWriter

ไดเร็กทอรีใน Java

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

การสร้างไดเรกทอรี

มีประโยชน์สองอย่าง File วิธีการยูทิลิตี้ซึ่งสามารถใช้ในการสร้างไดเร็กทอรี -

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

  • mkdirs() วิธีการสร้างทั้งไดเร็กทอรีและพาเรนต์ทั้งหมดของไดเร็กทอรี

ตัวอย่างต่อไปนี้สร้างไดเร็กทอรี "/ tmp / user / java / bin" -

Example

import java.io.File;
public class CreateDir {

   public static void main(String args[]) {
      String dirname = "/tmp/user/java/bin";
      File d = new File(dirname);
      
      // Create directory now.
      d.mkdirs();
   }
}

คอมไพล์และรันโค้ดด้านบนเพื่อสร้าง "/ tmp / user / java / bin"

Note- Java ดูแลตัวคั่นเส้นทางบน UNIX และ Windows โดยอัตโนมัติตามข้อตกลง หากคุณใช้เครื่องหมายทับ (/) บน Java เวอร์ชัน Windows เส้นทางจะยังคงแก้ไขได้อย่างถูกต้อง

รายชื่อไดเรกทอรี

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

Example

import java.io.File;
public class ReadDir {

   public static void main(String[] args) {
      File file = null;
      String[] paths;
  
      try {      
         // create new file object
         file = new File("/tmp");

         // array of files and directory
         paths = file.list();

         // for each name in the path array
         for(String path:paths) {
            // prints filename and directory name
            System.out.println(path);
         }
      } catch (Exception e) {
         // if any error occurs
         e.printStackTrace();
      }
   }
}

สิ่งนี้จะให้ผลลัพธ์ต่อไปนี้ตามไดเร็กทอรีและไฟล์ที่มีอยู่ในไฟล์ /tmp ไดเรกทอรี -

Output

test1.txt
test2.txt
ReadDir.java
ReadDir.class

ข้อยกเว้น (หรือเหตุการณ์พิเศษ) คือปัญหาที่เกิดขึ้นระหว่างการทำงานของโปรแกรม เมื่อException เกิดขึ้นขั้นตอนปกติของโปรแกรมหยุดชะงักและโปรแกรม / แอปพลิเคชันหยุดทำงานอย่างผิดปกติซึ่งไม่แนะนำดังนั้นจึงต้องจัดการข้อยกเว้นเหล่านี้

ข้อยกเว้นอาจเกิดขึ้นได้จากหลายสาเหตุ ต่อไปนี้เป็นสถานการณ์บางอย่างที่มีข้อยกเว้นเกิดขึ้น

  • ผู้ใช้ป้อนข้อมูลที่ไม่ถูกต้อง

  • ไม่พบไฟล์ที่ต้องเปิด

  • การเชื่อมต่อเครือข่ายขาดหายไประหว่างการสื่อสารหรือ JVM มีหน่วยความจำไม่เพียงพอ

ข้อยกเว้นเหล่านี้บางส่วนเกิดจากข้อผิดพลาดของผู้ใช้ข้อผิดพลาดอื่น ๆ เกิดจากข้อผิดพลาดของโปรแกรมเมอร์และอื่น ๆ โดยทรัพยากรทางกายภาพที่ล้มเหลวในบางลักษณะ

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

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

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

ตัวอย่าง

import java.io.File;
import java.io.FileReader;

public class FilenotFound_Demo {

   public static void main(String args[]) {		
      File file = new File("E://file.txt");
      FileReader fr = new FileReader(file); 
   }
}

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

เอาต์พุต

C:\>javac FilenotFound_Demo.java
FilenotFound_Demo.java:8: error: unreported exception FileNotFoundException; must be caught or declared to be thrown
      FileReader fr = new FileReader(file);
                      ^
1 error

Note - ตั้งแต่วิธีการ read() และ close() ของคลาส FileReader พ่น IOException คุณสามารถสังเกตได้ว่าคอมไพเลอร์แจ้งให้จัดการ IOException พร้อมกับ FileNotFoundException

  • Unchecked exceptions- ข้อยกเว้นที่ไม่ได้ตรวจสอบคือข้อยกเว้นที่เกิดขึ้นในขณะดำเนินการ สิ่งเหล่านี้เรียกอีกอย่างว่าRuntime Exceptions. ซึ่งรวมถึงข้อบกพร่องในการเขียนโปรแกรมเช่นข้อผิดพลาดทางตรรกะหรือการใช้ API อย่างไม่เหมาะสม ข้อยกเว้นรันไทม์จะถูกละเว้นในช่วงเวลาของการคอมไพล์

ตัวอย่างเช่นถ้าคุณได้ประกาศอาร์เรย์ของขนาด 5 ในโปรแกรมของคุณและพยายามที่จะเรียก 6 THองค์ประกอบของอาร์เรย์แล้วArrayIndexOutOfBoundsExceptionexceptionเกิดขึ้น

ตัวอย่าง

public class Unchecked_Demo {
   
   public static void main(String args[]) {
      int num[] = {1, 2, 3, 4};
      System.out.println(num[5]);
   }
}

หากคุณคอมไพล์และรันโปรแกรมข้างต้นคุณจะได้รับข้อยกเว้นดังต่อไปนี้

เอาต์พุต

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 5
	at Exceptions.Unchecked_Demo.main(Unchecked_Demo.java:8)

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

ลำดับชั้นของข้อยกเว้น

คลาสข้อยกเว้นทั้งหมดเป็นประเภทย่อยของคลาส java.lang.Exception คลาสข้อยกเว้นคือคลาสย่อยของคลาส Throwable นอกเหนือจากคลาสข้อยกเว้นยังมีคลาสย่อยอื่นที่เรียกว่า Error ซึ่งได้มาจากคลาส Throwable

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

คลาส Exception มีคลาสย่อยหลักสองคลาส: คลาส IOException และคลาส RuntimeException

ต่อไปนี้เป็นรายการที่พบบ่อยที่สุดตรวจสอบและไม่ได้ตรวจสอบJava ในตัวของข้อยกเว้น

วิธีการยกเว้น

ต่อไปนี้เป็นรายการวิธีการสำคัญที่มีอยู่ในคลาส Throwable

ซีเนียร์ วิธีการและคำอธิบาย
1

public String getMessage()

ส่งคืนข้อความโดยละเอียดเกี่ยวกับข้อยกเว้นที่เกิดขึ้น ข้อความนี้เริ่มต้นในตัวสร้าง Throwable
2

public Throwable getCause()

ส่งคืนสาเหตุของข้อยกเว้นที่แสดงโดยวัตถุ Throwable
3

public String toString()

ส่งคืนชื่อของคลาสที่เชื่อมต่อกับผลลัพธ์ของ getMessage ()
4

public void printStackTrace()

พิมพ์ผลลัพธ์ของ toString () พร้อมกับการติดตามสแต็กไปยัง System.err สตรีมเอาต์พุตข้อผิดพลาด
5

public StackTraceElement [] getStackTrace()

ส่งคืนอาร์เรย์ที่มีแต่ละองค์ประกอบในการติดตามสแต็ก องค์ประกอบที่ดัชนี 0 แสดงถึงด้านบนสุดของ call stack และองค์ประกอบสุดท้ายในอาร์เรย์แสดงถึงวิธีการที่ด้านล่างของ call stack
6

public Throwable fillInStackTrace()

เติมการติดตามสแต็กของอ็อบเจ็กต์ Throwable นี้ด้วยการติดตามสแต็กปัจจุบันโดยเพิ่มข้อมูลก่อนหน้านี้ในการติดตามสแต็ก

การจับข้อยกเว้น

เมธอดจับข้อยกเว้นโดยใช้การรวมกันของ try และ catchคำหลัก บล็อก try / catch ถูกวางไว้รอบ ๆ โค้ดที่อาจสร้างข้อยกเว้น โค้ดภายในบล็อก try / catch เรียกว่าโค้ดที่มีการป้องกันและไวยากรณ์สำหรับการใช้ try / catch มีลักษณะดังนี้ -

ไวยากรณ์

try {
   // Protected code
} catch (ExceptionName e1) {
   // Catch block
}

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

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

ตัวอย่าง

ต่อไปนี้เป็นอาร์เรย์ที่ประกาศด้วย 2 องค์ประกอบ จากนั้นโค้ดจะพยายามเข้าถึงองค์ประกอบ3 rdของอาร์เรย์ซึ่งทำให้เกิดข้อยกเว้น

// File Name : ExcepTest.java
import java.io.*;

public class ExcepTest {

   public static void main(String args[]) {
      try {
         int a[] = new int[2];
         System.out.println("Access element three :" + a[3]);
      } catch (ArrayIndexOutOfBoundsException e) {
         System.out.println("Exception thrown  :" + e);
      }
      System.out.println("Out of the block");
   }
}

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -

เอาต์พุต

Exception thrown  :java.lang.ArrayIndexOutOfBoundsException: 3
Out of the block

หลาย Catch Blocks

บล็อกลองสามารถตามด้วยบล็อกจับหลาย ๆ ไวยากรณ์สำหรับบล็อกการจับหลายรายการมีลักษณะดังต่อไปนี้ -

ไวยากรณ์

try {
   // Protected code
} catch (ExceptionType1 e1) {
   // Catch block
} catch (ExceptionType2 e2) {
   // Catch block
} catch (ExceptionType3 e3) {
   // Catch block
}

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

ตัวอย่าง

นี่คือส่วนของโค้ดที่แสดงวิธีใช้คำสั่ง try / catch หลายรายการ

try {
   file = new FileInputStream(fileName);
   x = (byte) file.read();
} catch (IOException i) {
   i.printStackTrace();
   return -1;
} catch (FileNotFoundException f) // Not valid! {
   f.printStackTrace();
   return -1;
}

การจับข้อยกเว้นหลายประเภท

เนื่องจาก Java 7 คุณสามารถจัดการข้อยกเว้นได้มากกว่าหนึ่งรายการโดยใช้บล็อกเดียวคุณลักษณะนี้ช่วยลดความซับซ้อนของโค้ด นี่คือวิธีที่คุณจะทำ -

catch (IOException|FileNotFoundException ex) {
   logger.log(ex);
   throw ex;

คำหลักโยน / โยน

หากเมธอดไม่จัดการกับข้อยกเว้นที่ถูกตรวจสอบเมธอดจะต้องประกาศโดยใช้ throwsคำสำคัญ. คีย์เวิร์ดพ่นจะปรากฏที่ส่วนท้ายของลายเซ็นของเมธอด

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

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

วิธีการต่อไปนี้ประกาศว่าจะพ่น RemoteException -

ตัวอย่าง

import java.io.*;
public class className {

   public void deposit(double amount) throws RemoteException {
      // Method implementation
      throw new RemoteException();
   }
   // Remainder of class definition
}

เมธอดสามารถประกาศได้ว่ามีการแสดงข้อยกเว้นมากกว่าหนึ่งข้อซึ่งในกรณีนี้จะมีการประกาศข้อยกเว้นในรายการโดยคั่นด้วยเครื่องหมายจุลภาค ตัวอย่างเช่นวิธีการต่อไปนี้ประกาศว่าจะพ่น RemoteException และ InsufficientFundsException -

ตัวอย่าง

import java.io.*;
public class className {

   public void withdraw(double amount) throws RemoteException, 
      InsufficientFundsException {
      // Method implementation
   }
   // Remainder of class definition
}

สุดท้ายบล็อก

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

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

ในที่สุดบล็อกจะปรากฏที่ส่วนท้ายของบล็อกจับและมีไวยากรณ์ต่อไปนี้ -

ไวยากรณ์

try {
   // Protected code
} catch (ExceptionType1 e1) {
   // Catch block
} catch (ExceptionType2 e2) {
   // Catch block
} catch (ExceptionType3 e3) {
   // Catch block
}finally {
   // The finally block always executes.
}

ตัวอย่าง

public class ExcepTest {

   public static void main(String args[]) {
      int a[] = new int[2];
      try {
         System.out.println("Access element three :" + a[3]);
      } catch (ArrayIndexOutOfBoundsException e) {
         System.out.println("Exception thrown  :" + e);
      }finally {
         a[0] = 6;
         System.out.println("First element value: " + a[0]);
         System.out.println("The finally statement is executed");
      }
   }
}

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -

เอาต์พุต

Exception thrown  :java.lang.ArrayIndexOutOfBoundsException: 3
First element value: 6
The finally statement is executed

หมายเหตุต่อไปนี้ -

  • ประโยค catch ไม่สามารถอยู่ได้หากไม่มีคำสั่ง try

  • ไม่จำเป็นที่จะต้องมีประโยคสุดท้ายเมื่อใดก็ตามที่มีการบล็อก try / catch

  • ไม่สามารถนำเสนอ try block ได้หากไม่มีประโยค catch หรือประโยคสุดท้าย

  • ไม่สามารถแสดงรหัสใด ๆ ระหว่างการลองจับสุดท้ายบล็อกได้

ลองใช้ทรัพยากร

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

ตัวอย่าง

import java.io.File;
import java.io.FileReader;
import java.io.IOException;

public class ReadData_Demo {

   public static void main(String args[]) {
      FileReader fr = null;		
      try {
         File file = new File("file.txt");
         fr = new FileReader(file); char [] a = new char[50];
         fr.read(a);   // reads the content to the array
         for(char c : a)
         System.out.print(c);   // prints the characters one by one
      } catch (IOException e) {
         e.printStackTrace();
      }finally {
         try {
            fr.close();
         } catch (IOException ex) {		
            ex.printStackTrace();
         }
      }
   }
}

try-with-resourcesหรือเรียกอีกอย่างว่า automatic resource managementเป็นกลไกการจัดการข้อยกเว้นใหม่ที่เปิดตัวใน Java 7 ซึ่งจะปิดทรัพยากรที่ใช้ภายในบล็อก try catch โดยอัตโนมัติ

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

ไวยากรณ์

try(FileReader fr = new FileReader("file path")) {
   // use the resource
   } catch () {
      // body of catch 
   }
}

ต่อไปนี้เป็นโปรแกรมที่อ่านข้อมูลในไฟล์โดยใช้คำสั่ง try-with-resources

ตัวอย่าง

import java.io.FileReader;
import java.io.IOException;

public class Try_withDemo {

   public static void main(String args[]) {
      try(FileReader fr = new FileReader("E://file.txt")) {
         char [] a = new char[50];
         fr.read(a);   // reads the contentto the array
         for(char c : a)
         System.out.print(c);   // prints the characters one by one
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
}

ควรคำนึงถึงประเด็นต่อไปนี้ในขณะที่ทำงานกับคำสั่ง try-with-resources

  • ในการใช้คลาสที่มีคำสั่ง try-with-resources ควรใช้ AutoCloseable อินเตอร์เฟซและ close() วิธีการของมันถูกเรียกโดยอัตโนมัติเมื่อรันไทม์

  • คุณสามารถประกาศมากกว่าหนึ่งคลาสในคำสั่ง try-with-resources

  • ในขณะที่คุณประกาศหลายคลาสในบล็อก try ของคำสั่ง try-with-resources คลาสเหล่านี้จะปิดตามลำดับย้อนกลับ

  • ยกเว้นการประกาศทรัพยากรภายในวงเล็บทุกอย่างจะเหมือนกับบล็อก try / catch ปกติของบล็อก try

  • ทรัพยากรที่ประกาศในการลองจะได้รับการสร้างอินสแตนซ์ก่อนที่จะเริ่มบล็อกการลอง

  • ทรัพยากรที่ประกาศในบล็อกลองถูกประกาศโดยปริยายว่าเป็นขั้นสุดท้าย

ข้อยกเว้นที่ผู้ใช้กำหนด

คุณสามารถสร้างข้อยกเว้นของคุณเองใน Java โปรดคำนึงถึงประเด็นต่อไปนี้เมื่อเขียนคลาสข้อยกเว้นของคุณเอง -

  • ข้อยกเว้นทั้งหมดต้องเป็นลูกของ Throwable

  • หากคุณต้องการเขียนข้อยกเว้นที่ตรวจสอบแล้วซึ่งบังคับใช้โดยอัตโนมัติโดยกฎ Handle หรือ Declare คุณต้องขยายคลาส Exception

  • หากคุณต้องการเขียนข้อยกเว้นรันไทม์คุณต้องขยายคลาส RuntimeException

เราสามารถกำหนดคลาส Exception ของเราเองได้ดังนี้ -

class MyException extends Exception {
}

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

ตัวอย่าง

// File Name InsufficientFundsException.java
import java.io.*;

public class InsufficientFundsException extends Exception {
   private double amount;
   
   public InsufficientFundsException(double amount) {
      this.amount = amount;
   }
   
   public double getAmount() {
      return amount;
   }
}

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

// File Name CheckingAccount.java
import java.io.*;

public class CheckingAccount {
   private double balance;
   private int number;
   
   public CheckingAccount(int number) {
      this.number = number;
   }
   
   public void deposit(double amount) {
      balance += amount;
   }
   
   public void withdraw(double amount) throws InsufficientFundsException {
      if(amount <= balance) {
         balance -= amount;
      }else {
         double needs = amount - balance;
         throw new InsufficientFundsException(needs);
      }
   }
   
   public double getBalance() {
      return balance;
   }
   
   public int getNumber() {
      return number;
   }
}

โปรแกรม BankDemo ต่อไปนี้แสดงให้เห็นถึงการเรียกใช้วิธีการฝาก () และถอน () ของ CheckingAccount

// File Name BankDemo.java
public class BankDemo {

   public static void main(String [] args) {
      CheckingAccount c = new CheckingAccount(101);
      System.out.println("Depositing $500..."); c.deposit(500.00); try { System.out.println("\nWithdrawing $100...");
         c.withdraw(100.00);
         System.out.println("\nWithdrawing $600..."); c.withdraw(600.00); } catch (InsufficientFundsException e) { System.out.println("Sorry, but you are short $" + e.getAmount());
         e.printStackTrace();
      }
   }
}

รวบรวมไฟล์ทั้งสามไฟล์ข้างต้นและเรียกใช้ BankDemo สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -

เอาต์พุต

Depositing $500... Withdrawing $100...

Withdrawing $600... Sorry, but you are short $200.0
InsufficientFundsException
         at CheckingAccount.withdraw(CheckingAccount.java:25)
         at BankDemo.main(BankDemo.java:13)

ข้อยกเว้นทั่วไป

ใน Java สามารถกำหนดส่วนจัดเลี้ยงของข้อยกเว้นและข้อผิดพลาดได้สองรายการ

  • JVM Exceptions- นี่คือข้อยกเว้น / ข้อผิดพลาดที่ JVM โยนมาโดยเฉพาะหรือมีเหตุผล ตัวอย่าง: NullPointerException, ArrayIndexOutOfBoundsException, ClassCastException

  • Programmatic Exceptions- ข้อยกเว้นเหล่านี้ถูกโยนทิ้งอย่างชัดเจนโดยแอปพลิเคชันหรือโปรแกรมเมอร์ API ตัวอย่าง: IllegalArgumentException, IllegalStateException

ในบทนี้เราจะพูดถึงคลาสภายในของ Java

ชั้นเรียนที่ซ้อนกัน

ใน Java เช่นเดียวกับวิธีการตัวแปรของคลาสก็สามารถมีคลาสอื่นเป็นสมาชิกได้ อนุญาตให้เขียนคลาสภายในอื่นใน Java คลาสที่เขียนภายในเรียกว่าnested classและคลาสที่มีชั้นในเรียกว่า outer class.

Syntax

ต่อไปนี้เป็นไวยากรณ์ในการเขียนคลาสที่ซ้อนกัน ที่นี่ชั้นเรียนOuter_Demo คือชั้นนอกและชั้นเรียน Inner_Demo เป็นคลาสที่ซ้อนกัน

class Outer_Demo {
   class Inner_Demo {
   }
}

คลาสที่ซ้อนกันแบ่งออกเป็นสองประเภท -

  • Non-static nested classes - นี่คือสมาชิกที่ไม่คงที่ของคลาส

  • Static nested classes - นี่คือสมาชิกคงที่ของคลาส

ชั้นเรียนชั้นใน (คลาสที่ซ้อนกันไม่คงที่)

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

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

  • ชั้นใน
  • Method-local Inner Class
  • ชั้นในนิรนาม

ชั้นใน

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

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

Example

class Outer_Demo {
   int num;
   
   // inner class
   private class Inner_Demo {
      public void print() {
         System.out.println("This is an inner class");
      }
   }
   
   // Accessing he inner class from the method within
   void display_Inner() {
      Inner_Demo inner = new Inner_Demo();
      inner.print();
   }
}
   
public class My_class {

   public static void main(String args[]) {
      // Instantiating the outer class 
      Outer_Demo outer = new Outer_Demo();
      
      // Accessing the display_Inner() method.
      outer.display_Inner();
   }
}

ที่นี่คุณสามารถสังเกตได้ว่า Outer_Demo เป็นชั้นนอก Inner_Demo เป็นชั้นใน display_Inner() เป็นวิธีการที่เรากำลังสร้างอินสแตนซ์คลาสภายในและวิธีนี้ถูกเรียกใช้จากไฟล์ main วิธี.

หากคุณคอมไพล์และรันโปรแกรมข้างต้นคุณจะได้ผลลัพธ์ดังต่อไปนี้ -

Output

This is an inner class.

การเข้าถึงสมาชิกส่วนตัว

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

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

Outer_Demo outer = new Outer_Demo();
Outer_Demo.Inner_Demo inner = outer.new Inner_Demo();

โปรแกรมต่อไปนี้แสดงวิธีการเข้าถึงสมาชิกส่วนตัวของคลาสโดยใช้คลาสภายใน

Example

class Outer_Demo {
   // private variable of the outer class
   private int num = 175;  
   
   // inner class
   public class Inner_Demo {
      public int getNum() {
         System.out.println("This is the getnum method of the inner class");
         return num;
      }
   }
}

public class My_class2 {

   public static void main(String args[]) {
      // Instantiating the outer class
      Outer_Demo outer = new Outer_Demo();
      
      // Instantiating the inner class
      Outer_Demo.Inner_Demo inner = outer.new Inner_Demo();
      System.out.println(inner.getNum());
   }
}

หากคุณคอมไพล์และรันโปรแกรมข้างต้นคุณจะได้ผลลัพธ์ดังต่อไปนี้ -

Output

This is the getnum method of the inner class: 175

Method-local Inner Class

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

เมธอดคลาสภายในสามารถสร้างอินสแตนซ์ได้เฉพาะภายในเมธอดที่คลาสภายในถูกกำหนดไว้ โปรแกรมต่อไปนี้แสดงวิธีใช้คลาสภายในของ method-local

Example

public class Outerclass {
   // instance method of the outer class 
   void my_Method() {
      int num = 23;

      // method-local inner class
      class MethodInner_Demo {
         public void print() {
            System.out.println("This is method inner class "+num);	   
         }   
      } // end of inner class
	   
      // Accessing the inner class
      MethodInner_Demo inner = new MethodInner_Demo();
      inner.print();
   }
   
   public static void main(String args[]) {
      Outerclass outer = new Outerclass();
      outer.my_Method();	   	   
   }
}

หากคุณคอมไพล์และรันโปรแกรมข้างต้นคุณจะได้ผลลัพธ์ดังต่อไปนี้ -

Output

This is method inner class 23

ชั้นในนิรนาม

คลาสภายในที่ประกาศโดยไม่มีชื่อคลาสเรียกว่า anonymous inner class. ในกรณีของคลาสภายในที่ไม่ระบุชื่อเราจะประกาศและสร้างอินสแตนซ์พร้อมกัน โดยทั่วไปจะใช้เมื่อใดก็ตามที่คุณต้องการแทนที่เมธอดของคลาสหรืออินเทอร์เฟซ ไวยากรณ์ของคลาสภายในที่ไม่ระบุชื่อมีดังนี้ -

Syntax

AnonymousInner an_inner = new AnonymousInner() {
   public void my_method() {
      ........
      ........
   }   
};

โปรแกรมต่อไปนี้แสดงวิธีการแทนที่เมธอดของคลาสโดยใช้คลาสภายในที่ไม่ระบุชื่อ

Example

abstract class AnonymousInner {
   public abstract void mymethod();
}

public class Outer_class {

   public static void main(String args[]) {
      AnonymousInner inner = new AnonymousInner() {
         public void mymethod() {
            System.out.println("This is an example of anonymous inner class");
         }
      };
      inner.mymethod();	
   }
}

หากคุณคอมไพล์และรันโปรแกรมข้างต้นคุณจะได้ผลลัพธ์ดังต่อไปนี้ -

Output

This is an example of anonymous inner class

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

ชั้นในที่ไม่ระบุชื่อเป็นอาร์กิวเมนต์

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

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

obj.my_Method(new My_Class() {
   public void Do() {
      .....
      .....
   }
});

โปรแกรมต่อไปนี้แสดงวิธีการส่งผ่านคลาสภายในที่ไม่ระบุชื่อเป็นอาร์กิวเมนต์เมธอด

Example

// interface
interface Message {
   String greet();
}

public class My_class {
   // method which accepts the object of interface Message
   public void displayMessage(Message m) {
      System.out.println(m.greet() +
         ", This is an example of anonymous inner class as an argument");  
   }

   public static void main(String args[]) {
      // Instantiating the class
      My_class obj = new My_class();

      // Passing an anonymous inner class as an argument
      obj.displayMessage(new Message() {
         public String greet() {
            return "Hello";
         }
      });
   }
}

หากคุณคอมไพล์และรันโปรแกรมข้างต้นจะให้ผลลัพธ์ดังต่อไปนี้ -

Output

Hello, This is an example of anonymous inner class as an argument

คลาสซ้อนแบบคงที่

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

Syntax

class MyOuter {
   static class Nested_Demo {
   }
}

การสร้างอินสแตนซ์คลาสซ้อนแบบคงที่แตกต่างจากการสร้างอินสแตนซ์คลาสภายในเล็กน้อย โปรแกรมต่อไปนี้แสดงวิธีใช้คลาสซ้อนแบบคงที่

Example

public class Outer {
   static class Nested_Demo {
      public void my_method() {
         System.out.println("This is my nested class");
      }
   }
   
   public static void main(String args[]) {
      Outer.Nested_Demo nested = new Outer.Nested_Demo();	 
      nested.my_method();
   }
}

หากคุณคอมไพล์และรันโปรแกรมข้างต้นคุณจะได้ผลลัพธ์ดังต่อไปนี้ -

Output

This is my nested class

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

คลาสที่สืบทอดคุณสมบัติของอื่น ๆ เรียกว่าคลาสย่อย (คลาสที่ได้รับคลาสย่อย) และคลาสที่มีคุณสมบัติสืบทอดเรียกว่าซูเปอร์คลาส (คลาสพื้นฐานคลาสพาเรนต์)

ขยายคำหลัก

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

Syntax

class Super {
   .....
   .....
}
class Sub extends Super {
   .....
   .....
}

ตัวอย่างรหัส

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

การใช้คีย์เวิร์ดขยาย My_Calculation จะสืบทอดวิธีการเพิ่ม () และการลบ () ของคลาสการคำนวณ

คัดลอกและวางโปรแกรมต่อไปนี้ในไฟล์ชื่อ My_Calculation.java

Example

class Calculation {
   int z;
	
   public void addition(int x, int y) {
      z = x + y;
      System.out.println("The sum of the given numbers:"+z);
   }
	
   public void Subtraction(int x, int y) {
      z = x - y;
      System.out.println("The difference between the given numbers:"+z);
   }
}

public class My_Calculation extends Calculation {
   public void multiplication(int x, int y) {
      z = x * y;
      System.out.println("The product of the given numbers:"+z);
   }
	
   public static void main(String args[]) {
      int a = 20, b = 10;
      My_Calculation demo = new My_Calculation();
      demo.addition(a, b);
      demo.Subtraction(a, b);
      demo.multiplication(a, b);
   }
}

คอมไพล์และรันโค้ดด้านบนตามที่แสดงด้านล่าง

javac My_Calculation.java
java My_Calculation

หลังจากรันโปรแกรมแล้วจะให้ผลลัพธ์ดังนี้ -

Output

The sum of the given numbers:30
The difference between the given numbers:10
The product of the given numbers:200

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

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

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

Calculation demo = new My_Calculation();
demo.addition(a, b);
demo.Subtraction(a, b);

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

ซูเปอร์คีย์เวิร์ด

super คำหลักคล้ายกับ thisคำสำคัญ. ต่อไปนี้เป็นสถานการณ์จำลองที่ใช้ซุปเปอร์คีย์เวิร์ด

  • มันถูกใช้เพื่อ differentiate the members ของซูเปอร์คลาสจากสมาชิกของคลาสย่อยหากมีชื่อเดียวกัน

  • มันถูกใช้เพื่อ invoke the superclass ตัวสร้างจากคลาสย่อย

สร้างความแตกต่างให้กับสมาชิก

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

super.variable
super.method();

ตัวอย่างรหัส

ส่วนนี้แสดงโปรแกรมที่สาธิตการใช้งานไฟล์ super คำสำคัญ.

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

คัดลอกและวางโปรแกรมในไฟล์ชื่อ Sub_class.java

Example

class Super_class {
   int num = 20;

   // display method of superclass
   public void display() {
      System.out.println("This is the display method of superclass");
   }
}

public class Sub_class extends Super_class {
   int num = 10;

   // display method of sub class
   public void display() {
      System.out.println("This is the display method of subclass");
   }

   public void my_method() {
      // Instantiating subclass
      Sub_class sub = new Sub_class();

      // Invoking the display() method of sub class
      sub.display();

      // Invoking the display() method of superclass
      super.display();

      // printing the value of variable num of subclass
      System.out.println("value of the variable named num in sub class:"+ sub.num);

      // printing the value of variable num of superclass
      System.out.println("value of the variable named num in super class:"+ super.num);
   }

   public static void main(String args[]) {
      Sub_class obj = new Sub_class();
      obj.my_method();
   }
}

คอมไพล์และรันโค้ดด้านบนโดยใช้ไวยากรณ์ต่อไปนี้

javac Super_Demo
java Super

ในการดำเนินการโปรแกรมคุณจะได้รับผลลัพธ์ดังต่อไปนี้ -

Output

This is the display method of subclass
This is the display method of superclass
value of the variable named num in sub class:10
value of the variable named num in super class:20

เรียกใช้ Superclass Constructor

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

super(values);

ตัวอย่างรหัส

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

คัดลอกและวางโปรแกรมต่อไปนี้ในไฟล์ชื่อ Subclass.java

Example

class Superclass {
   int age;

   Superclass(int age) {
      this.age = age; 		 
   }

   public void getAge() {
      System.out.println("The value of the variable named age in super class is: " +age);
   }
}

public class Subclass extends Superclass {
   Subclass(int age) {
      super(age);
   }

   public static void main(String args[]) {
      Subclass s = new Subclass(24);
      s.getAge();
   }
}

คอมไพล์และรันโค้ดด้านบนโดยใช้ไวยากรณ์ต่อไปนี้

javac Subclass
java Subclass

ในการดำเนินการโปรแกรมคุณจะได้รับผลลัพธ์ดังต่อไปนี้ -

Output

The value of the variable named age in super class is: 24

IS-A ความสัมพันธ์

IS-A เป็นวิธีการพูด: วัตถุนี้เป็นประเภทของวัตถุนั้น ให้เราดูว่าextends คีย์เวิร์ดใช้เพื่อบรรลุการสืบทอด

public class Animal {
}

public class Mammal extends Animal {
}

public class Reptile extends Animal {
}

public class Dog extends Mammal {
}

ตอนนี้ตามตัวอย่างข้างต้นในเงื่อนไขเชิงวัตถุต่อไปนี้เป็นจริง -

  • สัตว์เป็นซุปเปอร์คลาสของสัตว์เลี้ยงลูกด้วยนม
  • สัตว์เป็นซุปเปอร์คลาสของสัตว์เลื้อยคลาน
  • สัตว์เลี้ยงลูกด้วยนมและสัตว์เลื้อยคลานเป็นคลาสย่อยของคลาสสัตว์
  • สุนัขเป็นคลาสย่อยของทั้งสัตว์เลี้ยงลูกด้วยนมและสัตว์

ตอนนี้ถ้าเราพิจารณาความสัมพันธ์ IS-A เราสามารถพูดได้ว่า -

  • สัตว์เลี้ยงลูกด้วยนม IS-A
  • สัตว์เลื้อยคลาน IS-A สัตว์
  • สุนัข IS-A เลี้ยงลูกด้วยนม
  • ดังนั้น: Dog IS-A Animal เช่นกัน

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

เราสามารถมั่นใจได้ว่าสัตว์เลี้ยงลูกด้วยนมเป็นสัตว์ที่มีการใช้ตัวดำเนินการอินสแตนซ์

Example

class Animal {
}

class Mammal extends Animal {
}

class Reptile extends Animal {
}

public class Dog extends Mammal {

   public static void main(String args[]) {
      Animal a = new Animal();
      Mammal m = new Mammal();
      Dog d = new Dog();

      System.out.println(m instanceof Animal);
      System.out.println(d instanceof Mammal);
      System.out.println(d instanceof Animal);
   }
}

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -

Output

true
true
true

เนื่องจากเรามีความเข้าใจเป็นอย่างดีเกี่ยวกับไฟล์ extends คำหลักให้เราดูว่า implements คีย์เวิร์ดใช้เพื่อรับความสัมพันธ์ IS-A

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

Example

public interface Animal {
}

public class Mammal implements Animal {
}

public class Dog extends Mammal {
}

อินสแตนซ์ของคำหลัก

ให้เราใช้ไฟล์ instanceof เจ้าหน้าที่ตรวจสอบว่าสัตว์เลี้ยงลูกด้วยนมเป็นสัตว์จริงหรือไม่และสุนัขเป็นสัตว์จริงหรือไม่

Example

interface Animal{}
class Mammal implements Animal{}

public class Dog extends Mammal {

   public static void main(String args[]) {
      Mammal m = new Mammal();
      Dog d = new Dog();

      System.out.println(m instanceof Animal);
      System.out.println(d instanceof Mammal);
      System.out.println(d instanceof Animal);
   }
}

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -

Output

true
true
true

HAS-A ความสัมพันธ์

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

มาดูตัวอย่างกัน -

Example

public class Vehicle{}
public class Speed{}

public class Van extends Vehicle {
   private Speed sp;
}

นี่แสดงว่าคลาส Van HAS-A Speed ด้วยการมีคลาสแยกต่างหากสำหรับ Speed ​​เราไม่จำเป็นต้องใส่โค้ดทั้งหมดที่เป็นของ speed ไว้ในคลาส Van ซึ่งทำให้สามารถนำคลาส Speed ​​มาใช้ซ้ำในหลาย ๆ แอพพลิเคชั่นได้

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

ประเภทของมรดก

การถ่ายทอดทางพันธุกรรมมีหลายประเภทดังแสดงด้านล่าง

ข้อเท็จจริงที่สำคัญมากที่ต้องจำคือ Java ไม่รองรับการสืบทอดหลายรายการ ซึ่งหมายความว่าคลาสไม่สามารถขยายมากกว่าหนึ่งคลาสได้ การทำตามจึงผิดกฎหมาย -

Example

public class extends Animal, Mammal{}

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

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

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

ในแง่เชิงวัตถุการแทนที่หมายถึงการแทนที่การทำงานของวิธีการที่มีอยู่

ตัวอย่าง

ให้เราดูตัวอย่าง

class Animal {
   public void move() {
      System.out.println("Animals can move");
   }
}

class Dog extends Animal {
   public void move() {
      System.out.println("Dogs can walk and run");
   }
}

public class TestDog {

   public static void main(String args[]) {
      Animal a = new Animal();   // Animal reference and object
      Animal b = new Dog();   // Animal reference but Dog object

      a.move();   // runs the method in Animal class
      b.move();   // runs the method in Dog class
   }
}

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -

เอาต์พุต

Animals can move
Dogs can walk and run

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

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

ลองพิจารณาตัวอย่างต่อไปนี้ -

ตัวอย่าง

class Animal {
   public void move() {
      System.out.println("Animals can move");
   }
}

class Dog extends Animal {
   public void move() {
      System.out.println("Dogs can walk and run");
   }
   public void bark() {
      System.out.println("Dogs can bark");
   }
}

public class TestDog {

   public static void main(String args[]) {
      Animal a = new Animal();   // Animal reference and object
      Animal b = new Dog();   // Animal reference but Dog object

      a.move();   // runs the method in Animal class
      b.move();   // runs the method in Dog class
      b.bark();
   }
}

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -

เอาต์พุต

TestDog.java:26: error: cannot find symbol
      b.bark();
       ^
  symbol:   method bark()
  location: variable b of type Animal
1 error

โปรแกรมนี้จะแสดงข้อผิดพลาดเกี่ยวกับเวลาคอมไพล์เนื่องจากประเภทการอ้างอิงของ b Animal ไม่มีเมธอดตามชื่อของ bark

กฎสำหรับการแทนที่วิธีการ

  • รายการอาร์กิวเมนต์ควรเหมือนกับของเมธอดที่ถูกลบล้าง

  • ประเภทการส่งคืนควรเหมือนกันหรือเป็นประเภทย่อยของประเภทการส่งคืนที่ประกาศในเมธอดเดิมที่ถูกแทนที่ในซูเปอร์คลาส

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

  • เมธอดอินสแตนซ์สามารถถูกแทนที่ได้ก็ต่อเมื่อมีการสืบทอดโดยคลาสย่อยเท่านั้น

  • ไม่สามารถแทนที่เมธอดที่ประกาศขั้นสุดท้ายได้

  • ไม่สามารถแทนที่เมธอดที่ประกาศแบบคงที่ได้ แต่สามารถประกาศใหม่ได้

  • หากไม่สามารถสืบทอดเมธอดได้ก็จะไม่สามารถลบล้างได้

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

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

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

  • ไม่สามารถลบล้างตัวสร้างได้

การใช้ super Keyword

เมื่อเรียกใช้เมธอดที่ถูกแทนที่รุ่น superclass super ใช้คำหลัก

ตัวอย่าง

class Animal {
   public void move() {
      System.out.println("Animals can move");
   }
}

class Dog extends Animal {
   public void move() {
      super.move();   // invokes the super class method
      System.out.println("Dogs can walk and run");
   }
}

public class TestDog {

   public static void main(String args[]) {
      Animal b = new Dog();   // Animal reference but Dog object
      b.move();   // runs the method in Dog class
   }
}

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -

เอาต์พุต

Animals can move
Dogs can walk and run

Polymorphism คือความสามารถของวัตถุในหลายรูปแบบ การใช้ความหลากหลายของความหลากหลายใน OOP เกิดขึ้นเมื่อการอ้างอิงคลาสพาเรนต์ถูกใช้เพื่ออ้างถึงอ็อบเจ็กต์คลาสลูก

ออบเจ็กต์ Java ใด ๆ ที่สามารถผ่านการทดสอบ IS-A ได้มากกว่าหนึ่งรายการจะถือว่าเป็นโพลีมอร์ฟิก ใน Java อ็อบเจ็กต์ Java ทั้งหมดเป็นโพลีมอร์ฟิกเนื่องจากอ็อบเจ็กต์ใด ๆ จะผ่านการทดสอบ IS-A สำหรับประเภทของตนเองและคลาสอ็อบเจ็กต์

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

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

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

ตัวอย่าง

ให้เราดูตัวอย่าง

public interface Vegetarian{}
public class Animal{}
public class Deer extends Animal implements Vegetarian{}

ตอนนี้คลาส Deer ถือเป็นหลายรูปแบบเนื่องจากมีการสืบทอดหลายแบบ ต่อไปนี้เป็นจริงสำหรับตัวอย่างข้างต้น -

  • กวางเป็นสัตว์
  • กวางเป็นมังสวิรัติ
  • กวางคือกวาง
  • กวางเป็นวัตถุ

เมื่อเราใช้ข้อเท็จจริงของตัวแปรอ้างอิงกับการอ้างอิงอ็อบเจ็กต์ Deer การประกาศต่อไปนี้ถือเป็นกฎหมาย -

ตัวอย่าง

Deer d = new Deer();
Animal a = d;
Vegetarian v = d;
Object o = d;

ตัวแปรอ้างอิงทั้งหมด d, a, v, o อ้างถึงอ็อบเจกต์ Deer เดียวกันในฮีป

วิธีการเสมือนจริง

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

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

ตัวอย่าง

/* File name : Employee.java */
public class Employee {
   private String name;
   private String address;
   private int number;

   public Employee(String name, String address, int number) {
      System.out.println("Constructing an Employee");
      this.name = name;
      this.address = address;
      this.number = number;
   }

   public void mailCheck() {
      System.out.println("Mailing a check to " + this.name + " " + this.address);
   }

   public String toString() {
      return name + " " + address + " " + number;
   }

   public String getName() {
      return name;
   }

   public String getAddress() {
      return address;
   }

   public void setAddress(String newAddress) {
      address = newAddress;
   }

   public int getNumber() {
      return number;
   }
}

สมมติว่าเราขยายคลาสพนักงานดังนี้ -

/* File name : Salary.java */
public class Salary extends Employee {
   private double salary; // Annual salary
   
   public Salary(String name, String address, int number, double salary) {
      super(name, address, number);
      setSalary(salary);
   }
   
   public void mailCheck() {
      System.out.println("Within mailCheck of Salary class ");
      System.out.println("Mailing check to " + getName()
      + " with salary " + salary);
   }
   
   public double getSalary() {
      return salary;
   }
   
   public void setSalary(double newSalary) {
      if(newSalary >= 0.0) {
         salary = newSalary;
      }
   }
   
   public double computePay() {
      System.out.println("Computing salary pay for " + getName());
      return salary/52;
   }
}

ตอนนี้คุณศึกษาโปรแกรมต่อไปนี้อย่างรอบคอบและพยายามกำหนดผลลัพธ์ -

/* File name : VirtualDemo.java */
public class VirtualDemo {

   public static void main(String [] args) {
      Salary s = new Salary("Mohd Mohtashim", "Ambehta, UP", 3, 3600.00);
      Employee e = new Salary("John Adams", "Boston, MA", 2, 2400.00);
      System.out.println("Call mailCheck using Salary reference --");   
      s.mailCheck();
      System.out.println("\n Call mailCheck using Employee reference--");
      e.mailCheck();
   }
}

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -

เอาต์พุต

Constructing an Employee
Constructing an Employee

Call mailCheck using Salary reference --
Within mailCheck of Salary class
Mailing check to Mohd Mohtashim with salary 3600.0

Call mailCheck using Employee reference--
Within mailCheck of Salary class
Mailing check to John Adams with salary 2400.0

ที่นี่เราสร้างตัวอย่างวัตถุเงินเดือนสองรายการ หนึ่งโดยใช้การอ้างอิงเงินเดือนsและอื่น ๆ โดยใช้การอ้างอิงของพนักงาน e.

ขณะเรียกใช้s.mailCheck ()คอมไพเลอร์จะเห็น mailCheck () ในคลาส Salary ในเวลาคอมไพล์และ JVM จะเรียกใช้ mailCheck () ในคลาส Salary ในขณะรันไทม์

mailCheck () บน e ค่อนข้างแตกต่างกันเพราะ eเป็นข้อมูลอ้างอิงของพนักงาน เมื่อคอมไพเลอร์เห็นe.mailCheck ()คอมไพเลอร์จะเห็นเมธอด mailCheck () ในคลาส Employee

ในเวลาคอมไพล์คอมไพเลอร์ใช้ mailCheck () ใน Employee เพื่อตรวจสอบคำสั่งนี้ อย่างไรก็ตามในขณะทำงาน JVM จะเรียกใช้ mailCheck () ในคลาส Salary

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

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

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

ใน Java การทำนามธรรมสามารถทำได้โดยใช้คลาสบทคัดย่อและอินเทอร์เฟซ

คลาสนามธรรม

คลาสที่มีไฟล์ abstract คำหลักในการประกาศเรียกว่าคลาสนามธรรม

  • คลาสนามธรรมอาจมีหรือไม่มีวิธีนามธรรมเช่นวิธีการที่ไม่มีร่างกาย (โมฆะสาธารณะ get ();)

  • แต่ถ้าคลาสมีวิธีนามธรรมอย่างน้อยหนึ่งคลาส must ได้รับการประกาศว่าเป็นนามธรรม

  • ถ้าคลาสถูกประกาศว่าเป็นนามธรรมจะไม่สามารถสร้างอินสแตนซ์ได้

  • ในการใช้คลาสนามธรรมคุณต้องสืบทอดคลาสจากคลาสอื่นจัดเตรียมการนำไปใช้กับวิธีนามธรรมในนั้น

  • หากคุณสืบทอดคลาสนามธรรมคุณต้องจัดเตรียมการนำไปใช้กับวิธีนามธรรมทั้งหมดในนั้น

ตัวอย่าง

ส่วนนี้ให้ตัวอย่างของคลาสนามธรรม ในการสร้างคลาสนามธรรมให้ใช้ไฟล์abstract คีย์เวิร์ดก่อนคีย์เวิร์ดคลาสในการประกาศคลาส

/* File name : Employee.java */
public abstract class Employee {
   private String name;
   private String address;
   private int number;

   public Employee(String name, String address, int number) {
      System.out.println("Constructing an Employee");
      this.name = name;
      this.address = address;
      this.number = number;
   }
   
   public double computePay() {
     System.out.println("Inside Employee computePay");
     return 0.0;
   }
   
   public void mailCheck() {
      System.out.println("Mailing a check to " + this.name + " " + this.address);
   }

   public String toString() {
      return name + " " + address + " " + number;
   }

   public String getName() {
      return name;
   }
 
   public String getAddress() {
      return address;
   }
   
   public void setAddress(String newAddress) {
      address = newAddress;
   }
 
   public int getNumber() {
      return number;
   }
}

คุณสามารถสังเกตได้ว่ายกเว้นวิธีการนามธรรมคลาส Employee จะเหมือนกับคลาสปกติใน Java ตอนนี้ชั้นเรียนเป็นนามธรรม แต่ยังคงมีสามช่องเจ็ดวิธีและตัวสร้างหนึ่งตัว

ตอนนี้คุณสามารถลองสร้างอินสแตนซ์คลาสพนักงานได้ด้วยวิธีต่อไปนี้ -

/* File name : AbstractDemo.java */
public class AbstractDemo {

   public static void main(String [] args) {
      /* Following is not allowed and would raise error */
      Employee e = new Employee("George W.", "Houston, TX", 43);
      System.out.println("\n Call mailCheck using Employee reference--");
      e.mailCheck();
   }
}

เมื่อคุณรวบรวมคลาสข้างต้นจะทำให้คุณมีข้อผิดพลาดดังต่อไปนี้ -

Employee.java:46: Employee is abstract; cannot be instantiated
      Employee e = new Employee("George W.", "Houston, TX", 43);
                   ^
1 error

การสืบทอดคลาสบทคัดย่อ

เราสามารถสืบทอดคุณสมบัติของคลาสพนักงานเหมือนกับคลาสคอนกรีตได้ด้วยวิธีต่อไปนี้ -

ตัวอย่าง

/* File name : Salary.java */
public class Salary extends Employee {
   private double salary;   // Annual salary
   
   public Salary(String name, String address, int number, double salary) {
      super(name, address, number);
      setSalary(salary);
   }
   
   public void mailCheck() {
      System.out.println("Within mailCheck of Salary class ");
      System.out.println("Mailing check to " + getName() + " with salary " + salary);
   }
 
   public double getSalary() {
      return salary;
   }
   
   public void setSalary(double newSalary) {
      if(newSalary >= 0.0) {
         salary = newSalary;
      }
   }
   
   public double computePay() {
      System.out.println("Computing salary pay for " + getName());
      return salary/52;
   }
}

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

/* File name : AbstractDemo.java */
public class AbstractDemo {

   public static void main(String [] args) {
      Salary s = new Salary("Mohd Mohtashim", "Ambehta, UP", 3, 3600.00);
      Employee e = new Salary("John Adams", "Boston, MA", 2, 2400.00);
      System.out.println("Call mailCheck using Salary reference --");
      s.mailCheck();
      System.out.println("\n Call mailCheck using Employee reference--");
      e.mailCheck();
   }
}

สิ่งนี้ก่อให้เกิดผลลัพธ์ดังต่อไปนี้ -

เอาต์พุต

Constructing an Employee
Constructing an Employee
Call mailCheck using Salary reference --
Within mailCheck of Salary class 
Mailing check to Mohd Mohtashim with salary 3600.0

 Call mailCheck using Employee reference--
Within mailCheck of Salary class 
Mailing check to John Adams with salary 2400.0

วิธีนามธรรม

หากคุณต้องการให้คลาสมีเมธอดเฉพาะ แต่คุณต้องการให้การใช้เมธอดนั้นถูกกำหนดโดยคลาสย่อยคุณสามารถประกาศเมธอดในคลาสพาเรนต์เป็นนามธรรมได้

  • abstract คำสำคัญใช้เพื่อประกาศวิธีการเป็นนามธรรม

  • คุณต้องวางไฟล์ abstract คำสำคัญก่อนชื่อวิธีการในการประกาศวิธีการ

  • วิธีนามธรรมมีลายเซ็นของวิธีการ แต่ไม่มีเนื้อความของวิธีการ

  • แทนที่จะใช้วงเล็บปีกกาวิธีนามธรรมจะมีลำไส้ใหญ่เซโมอิ (;) อยู่ท้าย

ต่อไปนี้เป็นตัวอย่างของวิธีนามธรรม

ตัวอย่าง

public abstract class Employee {
   private String name;
   private String address;
   private int number;
   
   public abstract double computePay();
   // Remainder of class definition
}

การประกาศวิธีการเป็นนามธรรมมีผลสองประการ -

  • คลาสที่มีจะต้องถูกประกาศว่าเป็นนามธรรม

  • คลาสใด ๆ ที่สืบทอดคลาสปัจจุบันต้องลบล้างเมธอดนามธรรมหรือประกาศตัวเองว่าเป็นนามธรรม

Note- ในที่สุดคลาสผู้สืบทอดจะต้องใช้วิธีนามธรรม มิฉะนั้นคุณจะมีลำดับชั้นของคลาสนามธรรมที่ไม่สามารถสร้างอินสแตนซ์ได้

สมมติว่าระดับเงินเดือนสืบทอดคลาสพนักงานจากนั้นควรใช้ computePay() วิธีการดังแสดงด้านล่าง -

/* File name : Salary.java */
public class Salary extends Employee {
   private double salary;   // Annual salary
  
   public double computePay() {
      System.out.println("Computing salary pay for " + getName());
      return salary/52;
   }
   // Remainder of class definition
}

Encapsulationเป็นหนึ่งในสี่แนวคิด OOP พื้นฐาน อีกสามอย่างคือการถ่ายทอดทางพันธุกรรมความหลากหลายและนามธรรม

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

เพื่อให้บรรลุการห่อหุ้มใน Java -

  • ประกาศตัวแปรของคลาสเป็นส่วนตัว

  • จัดเตรียม public setter และ getter method เพื่อแก้ไขและดูค่าตัวแปร

ตัวอย่าง

ต่อไปนี้เป็นตัวอย่างที่แสดงให้เห็นถึงวิธีการบรรลุ Encapsulation ใน Java -

/* File name : EncapTest.java */
public class EncapTest {
   private String name;
   private String idNum;
   private int age;

   public int getAge() {
      return age;
   }

   public String getName() {
      return name;
   }

   public String getIdNum() {
      return idNum;
   }

   public void setAge( int newAge) {
      age = newAge;
   }

   public void setName(String newName) {
      name = newName;
   }

   public void setIdNum( String newId) {
      idNum = newId;
   }
}

เมธอด setXXX () และ getXXX () สาธารณะคือจุดเชื่อมต่อของตัวแปรอินสแตนซ์ของคลาส EncapTest โดยปกติวิธีการเหล่านี้เรียกว่า getters และ setters ดังนั้นคลาสใด ๆ ที่ต้องการเข้าถึงตัวแปรควรเข้าถึงผ่าน getters และ setters เหล่านี้

ตัวแปรของคลาส EncapTest สามารถเข้าถึงได้โดยใช้โปรแกรมต่อไปนี้ -

/* File name : RunEncap.java */
public class RunEncap {

   public static void main(String args[]) {
      EncapTest encap = new EncapTest();
      encap.setName("James");
      encap.setAge(20);
      encap.setIdNum("12343ms");

      System.out.print("Name : " + encap.getName() + " Age : " + encap.getAge());
   }
}

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -

เอาต์พุต

Name : James Age : 20

ประโยชน์ของการห่อหุ้ม

  • ฟิลด์ของชั้นเรียนสามารถทำให้เป็นแบบอ่านอย่างเดียวหรือเขียนอย่างเดียว

  • คลาสสามารถควบคุมสิ่งที่จัดเก็บไว้ในฟิลด์ได้ทั้งหมด

อินเทอร์เฟซคือประเภทการอ้างอิงใน Java มันคล้ายกับคลาส เป็นการรวบรวมวิธีการที่เป็นนามธรรม คลาสใช้อินเทอร์เฟซซึ่งจะสืบทอดวิธีการที่เป็นนามธรรมของอินเทอร์เฟซ

นอกจากวิธีนามธรรมแล้วอินเทอร์เฟซยังอาจมีค่าคงที่วิธีการเริ่มต้นวิธีการแบบคงที่และประเภทที่ซ้อนกัน เมธอดมีอยู่สำหรับเมธอดเริ่มต้นและเมธอดแบบคงที่เท่านั้น

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

เว้นแต่ว่าคลาสที่ใช้อินเทอร์เฟซจะเป็นนามธรรมต้องกำหนดวิธีการทั้งหมดของอินเทอร์เฟซในคลาส

อินเทอร์เฟซคล้ายกับคลาสด้วยวิธีต่อไปนี้ -

  • อินเทอร์เฟซสามารถมีได้หลายวิธี

  • อินเทอร์เฟซถูกเขียนในไฟล์ที่มีนามสกุล .java โดยมีชื่อของอินเทอร์เฟซที่ตรงกับชื่อของไฟล์

  • รหัสไบต์ของอินเทอร์เฟซปรากฏในไฟล์ .class ไฟล์.

  • อินเทอร์เฟซปรากฏในแพ็กเกจและไฟล์ไบต์โค้ดที่เกี่ยวข้องต้องอยู่ในโครงสร้างไดเร็กทอรีที่ตรงกับชื่อแพ็กเกจ

อย่างไรก็ตามอินเทอร์เฟซแตกต่างจากคลาสในหลาย ๆ ด้าน ได้แก่ -

  • คุณไม่สามารถสร้างอินเทอร์เฟซได้

  • อินเทอร์เฟซไม่มีตัวสร้างใด ๆ

  • วิธีการทั้งหมดในอินเทอร์เฟซเป็นนามธรรม

  • อินเทอร์เฟซต้องไม่มีฟิลด์อินสแตนซ์ ฟิลด์เดียวที่สามารถปรากฏในอินเทอร์เฟซต้องถูกประกาศทั้งแบบคงที่และขั้นสุดท้าย

  • อินเทอร์เฟซไม่ได้ถูกขยายโดยคลาส มันถูกนำไปใช้โดยชั้นเรียน

  • อินเทอร์เฟซสามารถขยายได้หลายอินเทอร์เฟซ

การประกาศอินเทอร์เฟซ

interfaceคีย์เวิร์ดใช้ในการประกาศอินเทอร์เฟซ นี่คือตัวอย่างง่ายๆในการประกาศอินเทอร์เฟซ -

ตัวอย่าง

ต่อไปนี้เป็นตัวอย่างของอินเทอร์เฟซ -

/* File name : NameOfInterface.java */
import java.lang.*;
// Any number of import statements

public interface NameOfInterface {
   // Any number of final, static fields
   // Any number of abstract method declarations\
}

อินเทอร์เฟซมีคุณสมบัติดังต่อไปนี้ -

  • อินเทอร์เฟซเป็นนามธรรมโดยปริยาย คุณไม่จำเป็นต้องใช้ไฟล์abstract คำสำคัญในขณะที่ประกาศอินเทอร์เฟซ

  • แต่ละวิธีในอินเทอร์เฟซยังเป็นนามธรรมโดยปริยายดังนั้นจึงไม่จำเป็นต้องใช้คีย์เวิร์ดที่เป็นนามธรรม

  • วิธีการในอินเทอร์เฟซเป็นแบบสาธารณะโดยปริยาย

ตัวอย่าง

/* File name : Animal.java */
interface Animal {
   public void eat();
   public void travel();
}

การใช้อินเทอร์เฟซ

เมื่อคลาสใช้อินเทอร์เฟซคุณสามารถคิดว่าคลาสเป็นการเซ็นสัญญาตกลงที่จะดำเนินการตามพฤติกรรมเฉพาะของอินเทอร์เฟซ หากคลาสไม่ดำเนินการตามพฤติกรรมทั้งหมดของอินเทอร์เฟซคลาสจะต้องประกาศตัวเองว่าเป็นนามธรรม

คลาสใช้ไฟล์ implementsคำหลักในการติดตั้งอินเทอร์เฟซ คีย์เวิร์ด implements จะปรากฏในการประกาศคลาสหลังจากส่วนขยายของการประกาศ

ตัวอย่าง

/* File name : MammalInt.java */
public class MammalInt implements Animal {

   public void eat() {
      System.out.println("Mammal eats");
   }

   public void travel() {
      System.out.println("Mammal travels");
   } 

   public int noOfLegs() {
      return 0;
   }

   public static void main(String args[]) {
      MammalInt m = new MammalInt();
      m.eat();
      m.travel();
   }
}

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -

เอาต์พุต

Mammal eats
Mammal travels

เมื่อลบล้างวิธีการที่กำหนดไว้ในอินเทอร์เฟซมีกฎหลายข้อที่ต้องปฏิบัติตาม -

  • ไม่ควรประกาศข้อยกเว้นที่ตรวจสอบในวิธีการใช้งานนอกเหนือจากที่ประกาศโดยวิธีการอินเตอร์เฟสหรือคลาสย่อยของข้อยกเว้นที่ประกาศโดยวิธีอินเตอร์เฟส

  • ลายเซ็นของเมธอดอินเทอร์เฟซและประเภทการส่งคืนเดียวกันหรือประเภทย่อยควรได้รับการดูแลเมื่อแทนที่เมธอด

  • คลาสการใช้งานเองอาจเป็นนามธรรมและหากเป็นเช่นนั้นก็ไม่จำเป็นต้องใช้วิธีการเชื่อมต่อ

เมื่ออินเทอร์เฟซการใช้งานมีกฎหลายข้อ -

  • คลาสสามารถใช้งานได้มากกว่าหนึ่งอินเทอร์เฟซในแต่ละครั้ง

  • คลาสสามารถขยายได้เพียงคลาสเดียว แต่ใช้อินเทอร์เฟซจำนวนมาก

  • อินเทอร์เฟซสามารถขยายอินเทอร์เฟซอื่นได้ในลักษณะเดียวกันเนื่องจากคลาสสามารถขยายคลาสอื่นได้

การขยายอินเตอร์เฟส

อินเทอร์เฟซสามารถขยายอินเทอร์เฟซอื่นในลักษณะเดียวกับที่คลาสสามารถขยายคลาสอื่นได้ extends คีย์เวิร์ดใช้เพื่อขยายอินเทอร์เฟซและอินเทอร์เฟซลูกสืบทอดวิธีการของอินเทอร์เฟซหลัก

อินเทอร์เฟซ Sports ต่อไปนี้ถูกขยายโดยอินเตอร์เฟสฮอกกี้และฟุตบอล

ตัวอย่าง

// Filename: Sports.java
public interface Sports {
   public void setHomeTeam(String name);
   public void setVisitingTeam(String name);
}

// Filename: Football.java
public interface Football extends Sports {
   public void homeTeamScored(int points);
   public void visitingTeamScored(int points);
   public void endOfQuarter(int quarter);
}

// Filename: Hockey.java
public interface Hockey extends Sports {
   public void homeGoalScored();
   public void visitingGoalScored();
   public void endOfPeriod(int period);
   public void overtimePeriod(int ot);
}

อินเทอร์เฟซ Hockey มีสี่วิธี แต่สืบทอดมาจาก Sports สองอย่าง ดังนั้นคลาสที่ใช้ฮอกกี้จำเป็นต้องใช้ทั้งหกวิธี ในทำนองเดียวกันคลาสที่ใช้ฟุตบอลจำเป็นต้องกำหนดสามวิธีจากฟุตบอลและสองวิธีจากกีฬา

การขยายหลายอินเทอร์เฟซ

คลาส Java สามารถขยายคลาสพาเรนต์ได้เพียงคลาสเดียว ไม่อนุญาตให้มีการสืบทอดหลายรายการ อินเทอร์เฟซไม่ใช่คลาสอย่างไรก็ตามอินเทอร์เฟซสามารถขยายได้มากกว่าหนึ่งอินเทอร์เฟซหลัก

คีย์เวิร์ดขยายถูกใช้ครั้งเดียวและอินเทอร์เฟซหลักถูกประกาศในรายการที่คั่นด้วยเครื่องหมายจุลภาค

ตัวอย่างเช่นหากอินเทอร์เฟซ Hockey ขยายทั้ง Sports และ Event ก็จะประกาศเป็น -

ตัวอย่าง

public interface Hockey extends Sports, Event

อินเทอร์เฟซการแท็ก

การใช้อินเตอร์เฟสการขยายส่วนใหญ่เกิดขึ้นเมื่ออินเทอร์เฟซหลักไม่มีเมธอดใด ๆ ตัวอย่างเช่นอินเทอร์เฟซ MouseListener ในแพ็คเกจ java.awt.event ขยาย java.util.EventListener ซึ่งกำหนดเป็น -

ตัวอย่าง

package java.util;
public interface EventListener
{}

อินเทอร์เฟซที่ไม่มีเมธอดเรียกว่าไฟล์ taggingอินเตอร์เฟซ. วัตถุประสงค์ในการออกแบบพื้นฐานของอินเทอร์เฟซการติดแท็กมีสองประการคือ

Creates a common parent- เช่นเดียวกับอินเทอร์เฟซ EventListener ซึ่งขยายโดยอินเทอร์เฟซอื่น ๆ อีกมากมายใน Java API คุณสามารถใช้อินเทอร์เฟซการติดแท็กเพื่อสร้างพาเรนต์ทั่วไปในกลุ่มของอินเทอร์เฟซ ตัวอย่างเช่นเมื่ออินเทอร์เฟซขยาย EventListener JVM จะรู้ว่าอินเทอร์เฟซเฉพาะนี้จะถูกใช้ในสถานการณ์การมอบหมายเหตุการณ์

Adds a data type to a class- สถานการณ์นี้เป็นที่มาของคำว่าการแท็ก คลาสที่ใช้อินเทอร์เฟซการแท็กไม่จำเป็นต้องกำหนดวิธีการใด ๆ (เนื่องจากอินเทอร์เฟซไม่มี) แต่คลาสจะกลายเป็นประเภทอินเทอร์เฟซผ่านความหลากหลาย

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

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

แพ็คเกจที่มีอยู่บางส่วนใน Java ได้แก่ -

  • java.lang - รวมคลาสพื้นฐาน

  • java.io - คลาสสำหรับอินพุตฟังก์ชันเอาต์พุตรวมอยู่ในแพ็คเกจนี้

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

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

การสร้างแพ็คเกจ

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

คำสั่งแพ็กเกจควรเป็นบรรทัดแรกในไฟล์ต้นฉบับ สามารถมีคำสั่งแพ็กเกจเพียงชุดเดียวในไฟล์ต้นฉบับแต่ละไฟล์และใช้ได้กับทุกประเภทในไฟล์

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

ในการคอมไพล์โปรแกรม Java ด้วยคำสั่งแพ็กเกจคุณต้องใช้อ็อพชัน -d ดังที่แสดงด้านล่าง

javac -d Destination_folder file_name.java

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

ตัวอย่าง

ให้เราดูตัวอย่างที่สร้างแพ็คเกจที่เรียกว่า animals. เป็นแนวทางปฏิบัติที่ดีในการใช้ชื่อแพ็กเกจที่มีอักษรตัวพิมพ์เล็กเพื่อหลีกเลี่ยงความขัดแย้งกับชื่อคลาสและอินเทอร์เฟซ

ตัวอย่างแพ็คเกจต่อไปนี้มีส่วนต่อประสานที่ชื่อสัตว์ -

/* File name : Animal.java */
package animals;

interface Animal {
   public void eat();
   public void travel();
}

ตอนนี้ให้เราใช้อินเทอร์เฟซด้านบนในสัตว์แพ็คเกจเดียวกัน-

package animals;
/* File name : MammalInt.java */

public class MammalInt implements Animal {

   public void eat() {
      System.out.println("Mammal eats");
   }

   public void travel() {
      System.out.println("Mammal travels");
   } 

   public int noOfLegs() {
      return 0;
   }

   public static void main(String args[]) {
      MammalInt m = new MammalInt();
      m.eat();
      m.travel();
   }
}

ตอนนี้รวบรวมไฟล์ java ดังที่แสดงด้านล่าง -

$ javac -d . Animal.java $ javac -d . MammalInt.java

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

คุณสามารถเรียกใช้ไฟล์คลาสภายในแพ็กเกจและรับผลลัพธ์ตามที่แสดงด้านล่าง

Mammal eats
Mammal travels

คีย์เวิร์ดนำเข้า

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

ตัวอย่าง

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

package payroll;
public class Boss {
   public void payEmployee(Employee e) {
      e.mailCheck();
   }
}

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

  • สามารถใช้ชื่อแบบเต็มของคลาสได้ ตัวอย่างเช่น -
payroll.Employee

  • สามารถนำเข้าแพ็กเกจได้โดยใช้คีย์เวิร์ด import และ wild card (*) ตัวอย่างเช่น -

import payroll.*;
  • คลาสเองสามารถนำเข้าได้โดยใช้คีย์เวิร์ดนำเข้า ตัวอย่างเช่น -
import payroll.Employee;

Note- ไฟล์คลาสสามารถมีคำสั่งนำเข้าจำนวนเท่าใดก็ได้ คำสั่งนำเข้าต้องปรากฏหลังคำสั่งแพ็กเกจและก่อนการประกาศคลาส

โครงสร้างไดเรกทอรีของแพ็คเกจ

ผลลัพธ์หลักสองประการเกิดขึ้นเมื่อคลาสถูกวางไว้ในแพ็คเกจ -

  • ชื่อของแพ็กเกจจะกลายเป็นส่วนหนึ่งของชื่อคลาสดังที่เราเพิ่งกล่าวไปในหัวข้อก่อนหน้านี้

  • ชื่อของแพ็กเกจต้องตรงกับโครงสร้างไดเร็กทอรีที่มีไบต์โค้ดที่เกี่ยวข้องอยู่

นี่คือวิธีง่ายๆในการจัดการไฟล์ของคุณใน Java -

ใส่ซอร์สโค้ดสำหรับคลาสอินเทอร์เฟซการแจงนับหรือประเภทคำอธิบายประกอบในไฟล์ข้อความที่มีชื่อเป็นชื่อแบบง่ายของชนิดและนามสกุลคือ .java.

ตัวอย่างเช่น -

// File Name :  Car.java
package vehicle;

public class Car {
   // Class implementation.   
}

ตอนนี้ใส่ซอร์สไฟล์ในไดเร็กทอรีที่มีชื่อสะท้อนถึงชื่อของแพ็กเกจที่คลาสนั้นอยู่ -

....\vehicle\Car.java

ตอนนี้ชื่อคลาสและชื่อพา ธ ที่ผ่านการรับรองจะเป็นดังนี้ -

  • ชื่อชั้น→ยานพาหนะรถ
  • ชื่อพา ธ → vehicle \ Car.java (ใน windows)

โดยทั่วไป บริษัท จะใช้ชื่อโดเมนอินเทอร์เน็ตที่กลับรายการเป็นชื่อแพ็กเกจ

Example- ชื่อโดเมนอินเทอร์เน็ตของ บริษัท คือ apple.com จากนั้นชื่อแพ็กเกจทั้งหมดจะขึ้นต้นด้วย com.apple ส่วนประกอบของชื่อแพ็กเกจแต่ละส่วนสอดคล้องกับไดเร็กทอรีย่อย

Example - บริษัท มีแพ็คเกจ com.apple.computers ที่มีไฟล์ซอร์ส Dell.java ซึ่งจะอยู่ในไดเร็กทอรีย่อยหลายชุดเช่นนี้ -

....\com\apple\computers\Dell.java

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

ตัวอย่างเช่น -

// File Name: Dell.java
package com.apple.computers;

public class Dell {
}

class Ups {
}

ตอนนี้รวบรวมไฟล์นี้ดังต่อไปนี้โดยใช้ตัวเลือก -d -

$javac -d . Dell.java

ไฟล์จะถูกรวบรวมดังนี้ -

.\com\apple\computers\Dell.class
.\com\apple\computers\Ups.class

คุณสามารถนำเข้าคลาสหรืออินเทอร์เฟซทั้งหมดที่กำหนดใน\ com \ apple \ คอมพิวเตอร์ \ดังต่อไปนี้ -

import com.apple.computers.*;

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

<path-one>\sources\com\apple\computers\Dell.java

<path-two>\classes\com\apple\computers\Dell.class

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

พา ธ แบบเต็มไปยังไดเร็กทอรีคลาส <path-two> \ class เรียกว่าคลาสพา ธ และตั้งค่าด้วยตัวแปรระบบ CLASSPATH ทั้งคอมไพลเลอร์และ JVM สร้างพา ธ ไปยังไฟล์. class ของคุณโดยเพิ่มชื่อแพ็กเกจลงในคลาสพา ธ

พูดว่า <path-two> \ class คือเส้นทางของคลาสและชื่อแพ็กเกจคือ com.apple.computers จากนั้นคอมไพเลอร์และ JVM จะค้นหาไฟล์. class ใน <path-two> \ class \ com \ apple \ คอมพิวเตอร์

เส้นทางชั้นเรียนอาจมีหลายเส้นทาง หลายเส้นทางควรคั่นด้วยอัฒภาค (Windows) หรือโคลอน (Unix) โดยดีฟอลต์คอมไพลเลอร์และ JVM ค้นหาไดเร็กทอรีปัจจุบันและไฟล์ JAR ที่มีคลาสแพลตฟอร์ม Java เพื่อให้ไดเร็กทอรีเหล่านี้อยู่ในคลาสพา ธ โดยอัตโนมัติ

ตั้งค่าตัวแปรระบบ CLASSPATH

ในการแสดงตัวแปร CLASSPATH ปัจจุบันให้ใช้คำสั่งต่อไปนี้ใน Windows และ UNIX (Bourne shell) -

  • ใน Windows → C: \> ตั้งค่า CLASSPATH
  • ใน UNIX →% echo $ CLASSPATH

ในการลบเนื้อหาปัจจุบันของตัวแปร CLASSPATH ให้ใช้ -

  • ใน Windows → C: \> ตั้งค่า CLASSPATH =
  • ใน UNIX →% unset CLASSPATH; ส่งออก CLASSPATH

ในการตั้งค่าตัวแปร CLASSPATH -

  • ใน Windows →ตั้งค่า CLASSPATH = C: \ users \ jack \ java \ class
  • ใน UNIX →% CLASSPATH = / home / jack / java / class; ส่งออก CLASSPATH

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

  • Enumeration
  • BitSet
  • Vector
  • Stack
  • Dictionary
  • Hashtable
  • Properties

คลาสเหล่านี้ทั้งหมดเป็นแบบดั้งเดิมและ Java-2 ได้เปิดตัวเฟรมเวิร์กใหม่ที่เรียกว่า Collections Framework ซึ่งจะกล่าวถึงในบทถัดไป -

การแจงนับ

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

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

จะมีรายละเอียดเพิ่มเติมเกี่ยวกับอินเตอร์เฟซนี้ตรวจสอบการแจงนับ

BitSet

คลาส BitSet ใช้กลุ่มของบิตหรือแฟล็กที่สามารถตั้งค่าและล้างทีละรายการ

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

สำหรับรายละเอียดเพิ่มเติมเกี่ยวกับคลาสนี้ให้ตรวจสอบBitSet

เวกเตอร์

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

เช่นเดียวกับอาร์เรย์องค์ประกอบของวัตถุเวกเตอร์สามารถเข้าถึงได้โดยใช้ดัชนีเข้าไปในเวกเตอร์

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

สำหรับรายละเอียดเพิ่มเติมเกี่ยวกับคลาสนี้ให้ตรวจสอบเวกเตอร์

กอง

คลาส Stack ใช้สแต็กองค์ประกอบสุดท้ายในก่อนออก (LIFO)

คุณสามารถคิดว่าสแต็กเป็นแบบแนวตั้งของวัตถุ เมื่อคุณเพิ่มองค์ประกอบใหม่องค์ประกอบนั้นจะซ้อนอยู่ด้านบนขององค์ประกอบอื่น ๆ

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

สำหรับรายละเอียดเพิ่มเติมเกี่ยวกับคลาสนี้ให้ตรวจสอบสแต็ค

พจนานุกรม

คลาสพจนานุกรมเป็นคลาสนามธรรมที่กำหนดโครงสร้างข้อมูลสำหรับการแมปคีย์กับค่า

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

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

สำหรับรายละเอียดเพิ่มเติมเกี่ยวกับคลาสนี้ให้ตรวจสอบพจนานุกรม

Hashtable

คลาส Hashtable มีวิธีการจัดระเบียบข้อมูลตามโครงสร้างคีย์ที่ผู้ใช้กำหนดเอง

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

ความหมายเฉพาะของคีย์ที่เกี่ยวข้องกับตารางแฮชนั้นขึ้นอยู่กับการใช้ตารางแฮชและข้อมูลที่มีอยู่ทั้งหมด

สำหรับรายละเอียดเพิ่มเติมเกี่ยวกับคลาสนี้ให้ตรวจสอบHashtable

คุณสมบัติ

คุณสมบัติเป็นคลาสย่อยของ Hashtable ใช้เพื่อรักษารายการของค่าที่คีย์เป็น String และค่านี้ยังเป็น String

คลาส Properties ถูกใช้โดยคลาส Java อื่น ๆ ตัวอย่างเช่นเป็นชนิดของวัตถุที่ส่งคืนโดย System.getProperties () เมื่อได้รับค่าสิ่งแวดล้อม

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

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

กรอบการรวบรวมได้รับการออกแบบมาเพื่อให้บรรลุเป้าหมายหลายประการเช่น -

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

  • กรอบงานต้องอนุญาตให้คอลเล็กชันประเภทต่างๆทำงานในลักษณะที่คล้ายคลึงกันและมีความสามารถในการทำงานร่วมกันได้ในระดับสูง

  • กรอบต้องขยายและ / หรือปรับเปลี่ยนคอลเล็กชันได้ง่าย

ในตอนท้ายนี้เฟรมเวิร์กคอลเลกชันทั้งหมดได้รับการออกแบบโดยใช้อินเตอร์เฟสมาตรฐาน การใช้งานมาตรฐานหลายอย่างเช่นLinkedList, HashSet, และ TreeSetอินเทอร์เฟซเหล่านี้มีไว้เพื่อให้คุณสามารถใช้ตามที่เป็นอยู่และคุณสามารถใช้คอลเลคชันของคุณเองได้หากคุณเลือก

เฟรมเวิร์กคอลเลกชันเป็นสถาปัตยกรรมแบบรวมสำหรับการแสดงและจัดการคอลเลกชัน กรอบคอลเลกชันทั้งหมดประกอบด้วยสิ่งต่อไปนี้ -

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

  • Implementations, i.e., Classes- นี่คือการนำอินเทอร์เฟซการรวบรวมมาใช้อย่างเป็นรูปธรรม โดยพื้นฐานแล้วเป็นโครงสร้างข้อมูลที่ใช้ซ้ำได้

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

นอกจากคอลเล็กชันแล้วเฟรมเวิร์กยังกำหนดอินเตอร์เฟสแผนที่และคลาสต่างๆ แผนที่จัดเก็บคู่คีย์ / ค่า แม้ว่าแผนที่จะไม่ใช่คอลเล็กชันในการใช้คำศัพท์ที่เหมาะสม แต่ก็รวมเข้ากับคอลเล็กชันได้อย่างสมบูรณ์

อินเทอร์เฟซการรวบรวม

เฟรมเวิร์กคอลเลกชันกำหนดอินเทอร์เฟซต่างๆ ส่วนนี้ให้ภาพรวมของแต่ละอินเทอร์เฟซ -

ซีเนียร์ อินเทอร์เฟซและคำอธิบาย
1 อินเทอร์เฟซการรวบรวม

สิ่งนี้ช่วยให้คุณสามารถทำงานกับกลุ่มของวัตถุ อยู่ที่ด้านบนสุดของลำดับชั้นคอลเลกชัน
2 อินเทอร์เฟซรายการ

สิ่งนี้ขยายออกไป Collection และอินสแตนซ์ของรายการจะจัดเก็บชุดองค์ประกอบตามลำดับ
3 ชุด

สิ่งนี้ขยายคอลเล็กชันเพื่อจัดการกับชุดซึ่งต้องมีองค์ประกอบที่ไม่ซ้ำกัน
4 SortedSet

สิ่งนี้ขยาย Set เพื่อจัดการชุดที่เรียงลำดับ
5 แผนที่

การจับคู่คีย์ที่ไม่ซ้ำกับค่านี้
6 แผนที่รายการ

สิ่งนี้อธิบายองค์ประกอบ (คู่คีย์ / ค่า) ในแผนที่ นี่คือคลาสภายในของแผนที่
7 SortedMap

สิ่งนี้จะขยายแผนที่เพื่อให้คีย์คงอยู่ในลำดับจากน้อยไปมาก
8 การแจงนับ

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

คลาสคอลเลกชัน

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

คลาสคอลเลกชันมาตรฐานสรุปไว้ในตารางต่อไปนี้ -

ซีเนียร์ ชั้นเรียนและคำอธิบาย
1

AbstractCollection

ใช้อินเทอร์เฟซคอลเลคชันส่วนใหญ่
2

AbstractList

ขยาย AbstractCollection และใช้ส่วนต่อประสานรายการส่วนใหญ่
3

AbstractSequentialList

ขยาย AbstractList สำหรับการใช้งานโดยคอลเล็กชันที่ใช้ตามลำดับแทนที่จะเข้าถึงแบบสุ่มขององค์ประกอบ
4 LinkedList

ใช้รายการที่เชื่อมโยงโดยการขยาย AbstractSequentialList
5 ArrayList

ใช้อาร์เรย์แบบไดนามิกโดยการขยาย AbstractList
6

AbstractSet

ขยาย AbstractCollection และใช้งานส่วนต่อประสาน Set ส่วนใหญ่
7 แฮชเซ็ต

ขยาย AbstractSet เพื่อใช้กับตารางแฮช
8 LinkedHashSet

ขยาย HashSet เพื่ออนุญาตให้มีการทำซ้ำลำดับการแทรก
9 ทรีเซ็ต

ใช้ชุดที่เก็บไว้ในต้นไม้ ขยาย AbstractSet
10

AbstractMap

ใช้ส่วนต่อประสานแผนที่ส่วนใหญ่
11 HashMap

ขยาย AbstractMap เพื่อใช้ตารางแฮช
12 TreeMap

ขยาย AbstractMap เพื่อใช้ต้นไม้
13 WeakHashMap

ขยาย AbstractMap เพื่อใช้ตารางแฮชที่มีคีย์ที่อ่อนแอ
14 LinkedHashMap

ขยาย HashMap เพื่ออนุญาตให้มีการทำซ้ำลำดับการแทรก
15 IdentityHashMap

ขยาย AbstractMap และใช้ความเท่าเทียมกันในการอ้างอิงเมื่อเปรียบเทียบเอกสาร

AbstractCollection, AbstractSet, AbstractList, AbstractSequentialListและAbstractMapเรียนให้การใช้งานโครงกระดูกคอลเลกชันของอินเตอร์เฟซหลักเพื่อลดความจำเป็นในการใช้พวกเขา

คลาสดั้งเดิมต่อไปนี้ที่กำหนดโดย java.util ได้รับการกล่าวถึงในบทที่แล้ว -

ซีเนียร์ ชั้นเรียนและคำอธิบาย
1 เวกเตอร์

สิ่งนี้ใช้อาร์เรย์แบบไดนามิก คล้ายกับ ArrayList แต่มีความแตกต่างบางประการ
2 ซ้อนกัน

Stack เป็นคลาสย่อยของ Vector ที่ใช้ stack last-in, first-out มาตรฐาน
3 พจนานุกรม

พจนานุกรมเป็นคลาสนามธรรมที่แสดงถึงที่เก็บคีย์ / ค่าและทำงานเหมือนกับแผนที่
4 Hashtable

Hashtable เป็นส่วนหนึ่งของ java.util ดั้งเดิมและเป็นการนำพจนานุกรมไปใช้อย่างเป็นรูปธรรม
5 คุณสมบัติ

คุณสมบัติเป็นคลาสย่อยของ Hashtable ใช้เพื่อรักษารายการของค่าที่คีย์เป็น String และค่านี้ยังเป็น String
6 BitSet

คลาส BitSet สร้างอาร์เรย์ชนิดพิเศษที่เก็บค่าบิต อาร์เรย์นี้สามารถเพิ่มขนาดได้ตามต้องการ

อัลกอริทึมการรวบรวม

เฟรมเวิร์กคอลเลกชันกำหนดอัลกอริทึมต่างๆที่สามารถใช้กับคอลเล็กชันและแผนที่ อัลกอริทึมเหล่านี้ถูกกำหนดให้เป็นวิธีการแบบคงที่ภายในคลาส Collections

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

คอลเล็กชันกำหนดตัวแปรแบบคงที่สามตัวแปร: EMPTY_SET, EMPTY_LIST และ EMPTY_MAP ทั้งหมดไม่เปลี่ยนรูป

ซีเนียร์ อัลกอริทึมและคำอธิบาย
1 อัลกอริทึมการรวบรวม

นี่คือรายการของการใช้อัลกอริทึมทั้งหมด

จะใช้ Iterator ได้อย่างไร?

บ่อยครั้งคุณอาจต้องการหมุนเวียนองค์ประกอบต่างๆในคอลเล็กชัน ตัวอย่างเช่นคุณอาจต้องการแสดงแต่ละองค์ประกอบ

วิธีที่ง่ายที่สุดในการดำเนินการนี้คือการใช้ตัววนซ้ำซึ่งเป็นอ็อบเจ็กต์ที่ใช้อินเทอร์เฟซ Iterator หรือ ListIterator

Iterator ช่วยให้คุณวนรอบคอลเลกชันรับหรือลบองค์ประกอบ ListIterator ขยาย Iterator เพื่ออนุญาตการส่งผ่านรายการแบบสองทิศทางและการปรับเปลี่ยนองค์ประกอบ

ซีเนียร์ วิธีการและคำอธิบาย Iterator
1 ใช้ Java Iterator

นี่คือรายการของวิธีการทั้งหมดพร้อมตัวอย่างที่จัดเตรียมโดยอินเทอร์เฟซ Iterator และ ListIterator

จะใช้เครื่องเปรียบเทียบได้อย่างไร?

ทั้ง TreeSet และ TreeMap จัดเก็บองค์ประกอบตามลำดับที่เรียงกัน แต่ก็เป็นตัวเปรียบเทียบที่กำหนดสิ่งที่แม่นยำเรียงเพื่อหมายถึง

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

ซีเนียร์ วิธีการและคำอธิบาย Iterator
1 ใช้ Java Comparator

นี่คือรายการของวิธีการทั้งหมดพร้อมตัวอย่างที่จัดทำโดย Comparator Interface

สรุป

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

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

คลาสและอินเทอร์เฟซของเฟรมเวิร์กคอลเลกชันอยู่ในแพ็คเกจ java.util

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

Java Generic วิธีการและคลาสทั่วไปช่วยให้โปรแกรมเมอร์สามารถระบุด้วยการประกาศวิธีเดียวชุดของวิธีการที่เกี่ยวข้องหรือด้วยการประกาศคลาสเดียวชุดของประเภทที่เกี่ยวข้องตามลำดับ

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

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

วิธีการทั่วไป

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

  • การประกาศเมธอดทั่วไปทั้งหมดมีส่วนพารามิเตอร์ type ที่คั่นด้วยวงเล็บมุม (<และ>) ที่นำหน้าประเภทการส่งคืนของเมธอด (<E> ในตัวอย่างถัดไป)

  • ส่วนพารามิเตอร์แต่ละประเภทมีพารามิเตอร์ประเภทอย่างน้อยหนึ่งรายการโดยคั่นด้วยเครื่องหมายจุลภาค พารามิเตอร์ type หรือที่เรียกว่าตัวแปร type คือตัวระบุที่ระบุชื่อชนิดทั่วไป

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

  • มีการประกาศเนื้อความของวิธีการทั่วไปเช่นเดียวกับวิธีการอื่น ๆ โปรดทราบว่าพารามิเตอร์ประเภทสามารถแสดงได้เฉพาะประเภทอ้างอิงเท่านั้นไม่ใช่ประเภทดั้งเดิม (เช่น int, double และ char)

ตัวอย่าง

ตัวอย่างต่อไปนี้แสดงให้เห็นว่าเราสามารถพิมพ์อาร์เรย์ประเภทต่างๆได้อย่างไรโดยใช้วิธี Generic เดียว -

public class GenericMethodTest {
   // generic method printArray
   public static < E > void printArray( E[] inputArray ) {
      // Display array elements
      for(E element : inputArray) {
         System.out.printf("%s ", element);
      }
      System.out.println();
   }

   public static void main(String args[]) {
      // Create arrays of Integer, Double and Character
      Integer[] intArray = { 1, 2, 3, 4, 5 };
      Double[] doubleArray = { 1.1, 2.2, 3.3, 4.4 };
      Character[] charArray = { 'H', 'E', 'L', 'L', 'O' };

      System.out.println("Array integerArray contains:");
      printArray(intArray);   // pass an Integer array

      System.out.println("\nArray doubleArray contains:");
      printArray(doubleArray);   // pass a Double array

      System.out.println("\nArray characterArray contains:");
      printArray(charArray);   // pass a Character array
   }
}

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -

เอาต์พุต

Array integerArray contains:
1 2 3 4 5 

Array doubleArray contains:
1.1 2.2 3.3 4.4 

Array characterArray contains:
H E L L O

พารามิเตอร์ประเภทขอบเขต

อาจมีบางครั้งที่คุณต้องการ จำกัด ประเภทของประเภทที่อนุญาตให้ส่งผ่านไปยังพารามิเตอร์ type ตัวอย่างเช่นวิธีการที่ดำเนินการกับตัวเลขอาจต้องการยอมรับเฉพาะอินสแตนซ์ของ Number หรือคลาสย่อยเท่านั้น นี่คือพารามิเตอร์ชนิดที่มีขอบเขต

ในการประกาศพารามิเตอร์ชนิดที่มีขอบเขตให้ระบุชื่อพารามิเตอร์ type ตามด้วยคีย์เวิร์ดขยายตามด้วยขอบเขตบน

ตัวอย่าง

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

public class MaximumTest {
   // determines the largest of three Comparable objects
   
   public static <T extends Comparable<T>> T maximum(T x, T y, T z) {
      T max = x;   // assume x is initially the largest
      
      if(y.compareTo(max) > 0) {
         max = y;   // y is the largest so far
      }
      
      if(z.compareTo(max) > 0) {
         max = z;   // z is the largest now                 
      }
      return max;   // returns the largest object   
   }
   
   public static void main(String args[]) {
      System.out.printf("Max of %d, %d and %d is %d\n\n", 
         3, 4, 5, maximum( 3, 4, 5 ));

      System.out.printf("Max of %.1f,%.1f and %.1f is %.1f\n\n",
         6.6, 8.8, 7.7, maximum( 6.6, 8.8, 7.7 ));

      System.out.printf("Max of %s, %s and %s is %s\n","pear",
         "apple", "orange", maximum("pear", "apple", "orange"));
   }
}

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -

เอาต์พุต

Max of 3, 4 and 5 is 5

Max of 6.6,8.8 and 7.7 is 8.8

Max of pear, apple and orange is pear

คลาสทั่วไป

การประกาศคลาสทั่วไปดูเหมือนการประกาศคลาสที่ไม่ใช่ทั่วไปยกเว้นว่าชื่อคลาสจะตามด้วยส่วนพารามิเตอร์ type

เช่นเดียวกับวิธีการทั่วไปส่วนพารามิเตอร์ type ของคลาสทั่วไปสามารถมีพารามิเตอร์ชนิดหนึ่งหรือหลายตัวคั่นด้วยเครื่องหมายจุลภาค คลาสเหล่านี้เรียกว่าคลาสที่กำหนดพารามิเตอร์หรือชนิดพารามิเตอร์เนื่องจากยอมรับพารามิเตอร์อย่างน้อยหนึ่งพารามิเตอร์

ตัวอย่าง

ตัวอย่างต่อไปนี้แสดงให้เห็นว่าเราสามารถกำหนดคลาสทั่วไปได้อย่างไร -

public class Box<T> {
   private T t;

   public void add(T t) {
      this.t = t;
   }

   public T get() {
      return t;
   }

   public static void main(String[] args) {
      Box<Integer> integerBox = new Box<Integer>();
      Box<String> stringBox = new Box<String>();
    
      integerBox.add(new Integer(10));
      stringBox.add(new String("Hello World"));

      System.out.printf("Integer Value :%d\n\n", integerBox.get());
      System.out.printf("String Value :%s\n", stringBox.get());
   }
}

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -

เอาต์พุต

Integer Value :10
String Value :Hello World

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

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

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

ชั้นเรียน ObjectInputStream และ ObjectOutputStream เป็นสตรีมระดับสูงที่มีวิธีการในการทำให้เป็นอนุกรมและการแยกส่วนของวัตถุ

คลาส ObjectOutputStream มีวิธีการเขียนมากมายสำหรับการเขียนข้อมูลประเภทต่างๆ แต่วิธีการหนึ่งที่โดดเด่น -

public final void writeObject(Object x) throws IOException

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

public final Object readObject() throws IOException, ClassNotFoundException

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

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

ตัวอย่าง

public class Employee implements java.io.Serializable {
   public String name;
   public String address;
   public transient int SSN;
   public int number;
   
   public void mailCheck() {
      System.out.println("Mailing a check to " + name + " " + address);
   }
}

โปรดสังเกตว่าสำหรับคลาสที่จะทำให้เป็นอนุกรมได้สำเร็จต้องปฏิบัติตามเงื่อนไขสองประการ -

  • คลาสต้องใช้อินเทอร์เฟซ java.io.Serializable

  • ฟิลด์ทั้งหมดในคลาสต้องต่ออนุกรมกันได้ หากฟิลด์ไม่สามารถต่ออนุกรมกันได้จะต้องทำเครื่องหมายtransient.

หากคุณอยากรู้ว่า Java Standard Class สามารถต่ออนุกรมได้หรือไม่ให้ตรวจสอบเอกสารประกอบสำหรับคลาส การทดสอบนั้นง่ายมาก: หากชั้นเรียนใช้ java.io.Serializable จะทำให้เป็นอนุกรมได้ มิฉะนั้นก็ไม่ใช่

การทำให้วัตถุเป็นอนุกรม

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

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

Note - เมื่อทำให้ออบเจ็กต์เป็นอนุกรมกับไฟล์แบบแผนมาตรฐานใน Java คือให้ไฟล์เป็นไฟล์ .ser ส่วนขยาย.

ตัวอย่าง

import java.io.*;
public class SerializeDemo {

   public static void main(String [] args) {
      Employee e = new Employee();
      e.name = "Reyan Ali";
      e.address = "Phokka Kuan, Ambehta Peer";
      e.SSN = 11122333;
      e.number = 101;
      
      try {
         FileOutputStream fileOut =
         new FileOutputStream("/tmp/employee.ser");
         ObjectOutputStream out = new ObjectOutputStream(fileOut);
         out.writeObject(e);
         out.close();
         fileOut.close();
         System.out.printf("Serialized data is saved in /tmp/employee.ser");
      } catch (IOException i) {
         i.printStackTrace();
      }
   }
}

Deserializing วัตถุ

โปรแกรม DeserializeDemo ต่อไปนี้ deserializes อ็อบเจ็กต์ Employee ที่สร้างในโปรแกรม SerializeDemo ศึกษาโปรแกรมและพยายามกำหนดผลลัพธ์ -

ตัวอย่าง

import java.io.*;
public class DeserializeDemo {

   public static void main(String [] args) {
      Employee e = null;
      try {
         FileInputStream fileIn = new FileInputStream("/tmp/employee.ser");
         ObjectInputStream in = new ObjectInputStream(fileIn);
         e = (Employee) in.readObject();
         in.close();
         fileIn.close();
      } catch (IOException i) {
         i.printStackTrace();
         return;
      } catch (ClassNotFoundException c) {
         System.out.println("Employee class not found");
         c.printStackTrace();
         return;
      }
      
      System.out.println("Deserialized Employee...");
      System.out.println("Name: " + e.name);
      System.out.println("Address: " + e.address);
      System.out.println("SSN: " + e.SSN);
      System.out.println("Number: " + e.number);
   }
}

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -

เอาต์พุต

Deserialized Employee...
Name: Reyan Ali
Address:Phokka Kuan, Ambehta Peer
SSN: 0
Number:101

ต่อไปนี้เป็นประเด็นสำคัญที่ควรสังเกต -

  • บล็อก try / catch พยายามจับ ClassNotFoundException ซึ่งประกาศโดยเมธอด readObject () เพื่อให้ JVM สามารถ deserialize อ็อบเจ็กต์ได้นั้นต้องสามารถค้นหา bytecode สำหรับคลาสได้ หาก JVM ไม่พบคลาสระหว่างการดีซีเรียลไลเซชั่นของอ็อบเจ็กต์มันจะพ่น ClassNotFoundException

  • สังเกตว่าค่าส่งคืนของ readObject () ถูกส่งไปยังการอ้างอิงของพนักงาน

  • ค่าของฟิลด์ SSN คือ 11122333 เมื่ออ็อบเจ็กต์ถูกทำให้เป็นอนุกรม แต่เนื่องจากฟิลด์เป็นแบบชั่วคราวค่านี้จึงไม่ถูกส่งไปยังเอาต์พุตสตรีม ฟิลด์ SSN ของอ็อบเจ็กต์ Deserialized Employee คือ 0

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

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

แพ็คเกจ java.net รองรับโปรโตคอลเครือข่ายทั่วไปสองโปรโตคอล -

  • TCP- TCP ย่อมาจาก Transmission Control Protocol ซึ่งช่วยให้การสื่อสารที่เชื่อถือได้ระหว่างสองแอปพลิเคชัน โดยทั่วไปแล้ว TCP จะใช้ผ่านอินเทอร์เน็ตโปรโตคอลซึ่งเรียกว่า TCP / IP

  • UDP - UDP ย่อมาจาก User Datagram Protocol ซึ่งเป็นโปรโตคอลที่ไม่ต้องเชื่อมต่อซึ่งช่วยให้สามารถส่งแพ็กเก็ตข้อมูลระหว่างแอปพลิเคชันได้

บทนี้ให้ความเข้าใจที่ดีในสองเรื่องต่อไปนี้ -

  • Socket Programming - นี่เป็นแนวคิดที่ใช้กันอย่างแพร่หลายในระบบเครือข่ายและได้รับการอธิบายอย่างละเอียด

  • URL Processing- สิ่งนี้จะครอบคลุมแยกต่างหาก คลิกที่นี่เพื่อเรียนรู้เกี่ยวกับการประมวลผล URLในภาษา Java

การเขียนโปรแกรมซ็อกเก็ต

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

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

คลาส java.net.Socket แสดงถึงซ็อกเก็ตและคลาส java.net.ServerSocket จัดเตรียมกลไกสำหรับโปรแกรมเซิร์ฟเวอร์เพื่อรับฟังไคลเอ็นต์และสร้างการเชื่อมต่อกับพวกเขา

ขั้นตอนต่อไปนี้เกิดขึ้นเมื่อสร้างการเชื่อมต่อ TCP ระหว่างคอมพิวเตอร์สองเครื่องโดยใช้ซ็อกเก็ต -

  • เซิร์ฟเวอร์สร้างอินสแตนซ์อ็อบเจ็กต์ ServerSocket แสดงว่าการสื่อสารหมายเลขพอร์ตใดที่จะเกิดขึ้น

  • เซิร์ฟเวอร์เรียกใช้วิธีการยอมรับ () ของคลาส ServerSocket วิธีนี้รอจนกว่าไคลเอ็นต์จะเชื่อมต่อกับเซิร์ฟเวอร์บนพอร์ตที่กำหนด

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

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

  • ในฝั่งเซิร์ฟเวอร์วิธีการ accept () จะส่งคืนการอ้างอิงไปยังซ็อกเก็ตใหม่บนเซิร์ฟเวอร์ที่เชื่อมต่อกับซ็อกเก็ตของไคลเอ็นต์

หลังจากสร้างการเชื่อมต่อแล้วการสื่อสารสามารถเกิดขึ้นได้โดยใช้สตรีม I / O แต่ละซ็อกเก็ตมีทั้ง OutputStream และ InputStream OutputStream ของไคลเอ็นต์เชื่อมต่อกับ InputStream ของเซิร์ฟเวอร์และ InputStream ของไคลเอ็นต์เชื่อมต่อกับ OutputStream ของเซิร์ฟเวอร์

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

วิธีการคลาส ServerSocket

java.net.ServerSocket คลาสถูกใช้โดยเซิร์ฟเวอร์แอ็พพลิเคชันเพื่อรับพอร์ตและรับฟังคำขอของไคลเอ็นต์

คลาส ServerSocket มีตัวสร้างสี่ตัว -

ซีเนียร์ วิธีการและคำอธิบาย
1

public ServerSocket(int port) throws IOException

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

public ServerSocket(int port, int backlog) throws IOException

คล้ายกับตัวสร้างก่อนหน้าพารามิเตอร์ backlog ระบุจำนวนไคลเอ็นต์ขาเข้าที่จะจัดเก็บในคิวรอ
3

public ServerSocket(int port, int backlog, InetAddress address) throws IOException

คล้ายกับตัวสร้างก่อนหน้านี้พารามิเตอร์ InetAddress ระบุที่อยู่ IP ในเครื่องที่จะผูก InetAddress ใช้สำหรับเซิร์ฟเวอร์ที่อาจมีที่อยู่ IP หลายรายการทำให้เซิร์ฟเวอร์สามารถระบุที่อยู่ IP ที่จะยอมรับคำขอของไคลเอ็นต์ได้
4

public ServerSocket() throws IOException

สร้างซ็อกเก็ตเซิร์ฟเวอร์ที่ไม่ถูกผูกไว้ เมื่อใช้ตัวสร้างนี้ให้ใช้เมธอด bind () เมื่อคุณพร้อมที่จะโยงซ็อกเก็ตเซิร์ฟเวอร์

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

ต่อไปนี้เป็นวิธีการทั่วไปบางส่วนของคลาส ServerSocket -

ซีเนียร์ วิธีการและคำอธิบาย
1

public int getLocalPort()

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

public Socket accept() throws IOException

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

public void setSoTimeout(int timeout)

ตั้งค่าการหมดเวลาสำหรับระยะเวลาที่ซ็อกเก็ตเซิร์ฟเวอร์รอไคลเอ็นต์ระหว่างการยอมรับ ()
4

public void bind(SocketAddress host, int backlog)

ผูกซ็อกเก็ตกับเซิร์ฟเวอร์ที่ระบุและพอร์ตในอ็อบเจ็กต์ SocketAddress ใช้วิธีนี้หากคุณสร้างอินสแตนซ์ ServerSocket โดยใช้ตัวสร้างไม่มีอาร์กิวเมนต์

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

วิธีการคลาสของซ็อกเก็ต

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

คลาส Socket มีคอนสตรัคเตอร์ห้าตัวที่ไคลเอนต์ใช้เพื่อเชื่อมต่อกับเซิร์ฟเวอร์ -

ซีเนียร์ วิธีการและคำอธิบาย
1

public Socket(String host, int port) throws UnknownHostException, IOException.

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

public Socket(InetAddress host, int port) throws IOException

เมธอดนี้เหมือนกับตัวสร้างก่อนหน้ายกเว้นว่าโฮสต์ถูกแสดงโดยอ็อบเจ็กต์ InetAddress
3

public Socket(String host, int port, InetAddress localAddress, int localPort) throws IOException.

เชื่อมต่อกับโฮสต์และพอร์ตที่ระบุสร้างซ็อกเก็ตบนโลคัลโฮสต์ตามแอดเดรสและพอร์ตที่ระบุ
4

public Socket(InetAddress host, int port, InetAddress localAddress, int localPort) throws IOException.

เมธอดนี้เหมือนกับตัวสร้างก่อนหน้ายกเว้นว่าโฮสต์ถูกแสดงโดยอ็อบเจ็กต์ InetAddress แทนที่จะเป็นสตริง
5

public Socket()

สร้างซ็อกเก็ตที่ไม่ได้เชื่อมต่อ ใช้วิธีการเชื่อมต่อ () เพื่อเชื่อมต่อซ็อกเก็ตนี้กับเซิร์ฟเวอร์

เมื่อตัวสร้างซ็อกเก็ตส่งคืนมันไม่เพียงแค่สร้างอินสแตนซ์อ็อบเจ็กต์ Socket แต่จริงๆแล้วพยายามเชื่อมต่อกับเซิร์ฟเวอร์และพอร์ตที่ระบุ

วิธีการบางอย่างที่น่าสนใจในคลาส Socket แสดงไว้ที่นี่ สังเกตว่าทั้งไคลเอนต์และเซิร์ฟเวอร์มีอ็อบเจ็กต์ Socket ดังนั้นเมธอดเหล่านี้จึงสามารถเรียกใช้ได้ทั้งไคลเอนต์และเซิร์ฟเวอร์

ซีเนียร์ วิธีการและคำอธิบาย
1

public void connect(SocketAddress host, int timeout) throws IOException

วิธีนี้เชื่อมต่อซ็อกเก็ตกับโฮสต์ที่ระบุ วิธีนี้จำเป็นเฉพาะเมื่อคุณสร้างอินสแตนซ์ Socket โดยใช้ตัวสร้างไม่มีอาร์กิวเมนต์
2

public InetAddress getInetAddress()

วิธีนี้จะส่งคืนที่อยู่ของคอมพิวเตอร์เครื่องอื่นที่ซ็อกเก็ตนี้เชื่อมต่ออยู่
3

public int getPort()

ส่งคืนพอร์ตที่ซ็อกเก็ตผูกไว้บนเครื่องระยะไกล
4

public int getLocalPort()

ส่งคืนพอร์ตที่ซ็อกเก็ตเชื่อมโยงกับเครื่องโลคัล
5

public SocketAddress getRemoteSocketAddress()

ส่งกลับที่อยู่ของรีโมตซ็อกเก็ต
6

public InputStream getInputStream() throws IOException

ส่งคืนอินพุตสตรีมของซ็อกเก็ต อินพุตสตรีมเชื่อมต่อกับสตรีมเอาต์พุตของซ็อกเก็ตระยะไกล
7

public OutputStream getOutputStream() throws IOException

ส่งคืนกระแสเอาต์พุตของซ็อกเก็ต สตรีมเอาต์พุตเชื่อมต่อกับอินพุตสตรีมของซ็อกเก็ตระยะไกล
8

public void close() throws IOException

ปิดซ็อกเก็ตซึ่งทำให้อ็อบเจ็กต์ Socket นี้ไม่สามารถเชื่อมต่อกับเซิร์ฟเวอร์ใด ๆ ได้อีกต่อไป

วิธีการเรียน InetAddress

คลาสนี้แสดงที่อยู่ Internet Protocol (IP) ต่อไปนี้เป็นวิธีการที่มีประโยชน์ซึ่งคุณจำเป็นต้องใช้ในการเขียนโปรแกรมซ็อกเก็ต -

ซีเนียร์ วิธีการและคำอธิบาย
1

static InetAddress getByAddress(byte[] addr)

ส่งคืนอ็อบเจ็กต์ InetAddress ที่กำหนดที่อยู่ IP ดิบ
2

static InetAddress getByAddress(String host, byte[] addr)

สร้าง InetAddress ตามชื่อโฮสต์และที่อยู่ IP ที่ระบุ
3

static InetAddress getByName(String host)

กำหนดที่อยู่ IP ของโฮสต์โดยระบุชื่อโฮสต์
4

String getHostAddress()

ส่งคืนสตริงที่อยู่ IP ในการนำเสนอแบบข้อความ
5

String getHostName()

รับชื่อโฮสต์สำหรับที่อยู่ IP นี้
6

static InetAddress InetAddress getLocalHost()

ส่งคืนโลคัลโฮสต์
7

String toString()

แปลงที่อยู่ IP นี้เป็นสตริง

ตัวอย่าง Socket Client

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

ตัวอย่าง

// File Name GreetingClient.java
import java.net.*;
import java.io.*;

public class GreetingClient {

   public static void main(String [] args) {
      String serverName = args[0];
      int port = Integer.parseInt(args[1]);
      try {
         System.out.println("Connecting to " + serverName + " on port " + port);
         Socket client = new Socket(serverName, port);
         
         System.out.println("Just connected to " + client.getRemoteSocketAddress());
         OutputStream outToServer = client.getOutputStream();
         DataOutputStream out = new DataOutputStream(outToServer);
         
         out.writeUTF("Hello from " + client.getLocalSocketAddress());
         InputStream inFromServer = client.getInputStream();
         DataInputStream in = new DataInputStream(inFromServer);
         
         System.out.println("Server says " + in.readUTF());
         client.close();
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
}

ตัวอย่างเซิร์ฟเวอร์ซ็อกเก็ต

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

ตัวอย่าง

// File Name GreetingServer.java
import java.net.*;
import java.io.*;

public class GreetingServer extends Thread {
   private ServerSocket serverSocket;
   
   public GreetingServer(int port) throws IOException {
      serverSocket = new ServerSocket(port);
      serverSocket.setSoTimeout(10000);
   }

   public void run() {
      while(true) {
         try {
            System.out.println("Waiting for client on port " + 
               serverSocket.getLocalPort() + "...");
            Socket server = serverSocket.accept();
            
            System.out.println("Just connected to " + server.getRemoteSocketAddress());
            DataInputStream in = new DataInputStream(server.getInputStream());
            
            System.out.println(in.readUTF());
            DataOutputStream out = new DataOutputStream(server.getOutputStream());
            out.writeUTF("Thank you for connecting to " + server.getLocalSocketAddress()
               + "\nGoodbye!");
            server.close();
            
         } catch (SocketTimeoutException s) {
            System.out.println("Socket timed out!");
            break;
         } catch (IOException e) {
            e.printStackTrace();
            break;
         }
      }
   }
   
   public static void main(String [] args) {
      int port = Integer.parseInt(args[0]);
      try {
         Thread t = new GreetingServer(port);
         t.start();
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
}

คอมไพล์ไคลเอนต์และเซิร์ฟเวอร์จากนั้นเริ่มเซิร์ฟเวอร์ดังต่อไปนี้ -

$ java GreetingServer 6066
Waiting for client on port 6066...

ตรวจสอบโปรแกรมไคลเอนต์ดังนี้ -

เอาต์พุต

$ java GreetingClient localhost 6066
Connecting to localhost on port 6066
Just connected to localhost/127.0.0.1:6066
Server says Thank you for connecting to /127.0.0.1:6066
Goodbye!

ในการส่งอีเมลโดยใช้ Java Application ของคุณนั้นง่ายพอ แต่จะเริ่มต้นด้วยคุณควรมี JavaMail API และ Java Activation Framework (JAF) ติดตั้งบนเครื่องของคุณ

  • คุณสามารถดาวน์โหลดJavaMailเวอร์ชันล่าสุด(เวอร์ชัน 1.2) ได้จากเว็บไซต์มาตรฐานของ Java

  • คุณสามารถดาวน์โหลดJAFเวอร์ชันล่าสุด(เวอร์ชัน 1.1.1) ได้จากเว็บไซต์มาตรฐานของ Java

ดาวน์โหลดและแตกไฟล์เหล่านี้ในไดเร็กทอรีระดับบนสุดที่สร้างขึ้นใหม่คุณจะพบไฟล์ jar จำนวนหนึ่งสำหรับทั้งสองแอปพลิเคชัน คุณต้องเพิ่มmail.jar และ activation.jar ไฟล์ใน CLASSPATH ของคุณ

ส่งอีเมลธรรมดา

นี่คือตัวอย่างการส่งอีเมลง่ายๆจากเครื่องของคุณ สันนิษฐานว่าเป็นไฟล์localhost เชื่อมต่อกับอินเทอร์เน็ตและมีความสามารถเพียงพอที่จะส่งอีเมล

ตัวอย่าง

// File Name SendEmail.java

import java.util.*;
import javax.mail.*;
import javax.mail.internet.*;
import javax.activation.*;

public class SendEmail {

   public static void main(String [] args) {    
      // Recipient's email ID needs to be mentioned.
      String to = "[email protected]";

      // Sender's email ID needs to be mentioned
      String from = "[email protected]";

      // Assuming you are sending email from localhost
      String host = "localhost";

      // Get system properties
      Properties properties = System.getProperties();

      // Setup mail server
      properties.setProperty("mail.smtp.host", host);

      // Get the default Session object.
      Session session = Session.getDefaultInstance(properties);

      try {
         // Create a default MimeMessage object.
         MimeMessage message = new MimeMessage(session);

         // Set From: header field of the header.
         message.setFrom(new InternetAddress(from));

         // Set To: header field of the header.
         message.addRecipient(Message.RecipientType.TO, new InternetAddress(to));

         // Set Subject: header field
         message.setSubject("This is the Subject Line!");

         // Now set the actual message
         message.setText("This is actual message");

         // Send message
         Transport.send(message);
         System.out.println("Sent message successfully....");
      } catch (MessagingException mex) {
         mex.printStackTrace();
      }
   }
}

คอมไพล์และรันโปรแกรมนี้เพื่อส่งอีเมลธรรมดา -

เอาต์พุต

$ java SendEmail
Sent message successfully....

หากคุณต้องการส่งอีเมลไปยังผู้รับหลายคนจะใช้วิธีการต่อไปนี้เพื่อระบุรหัสอีเมลหลายรายการ -

void addRecipients(Message.RecipientType type, Address[] addresses)
   throws MessagingException

นี่คือคำอธิบายของพารามิเตอร์ -

  • type- จะตั้งค่าเป็น TO, CC หรือ BCC CC ในที่นี้หมายถึง Carbon Copy และ BCC หมายถึง Black Carbon Copy ตัวอย่าง: Message.RecipientType.TO

  • addresses- นี่คืออาร์เรย์ของ ID อีเมล คุณจะต้องใช้วิธี InternetAddress () ในขณะที่ระบุรหัสอีเมล

ส่งอีเมล HTML

นี่คือตัวอย่างการส่งอีเมล HTML จากเครื่องของคุณ ที่นี่สันนิษฐานว่าเป็นไฟล์localhost เชื่อมต่อกับอินเทอร์เน็ตและมีความสามารถเพียงพอที่จะส่งอีเมล

ตัวอย่างนี้คล้ายกับตัวอย่างก่อนหน้านี้มากยกเว้นที่นี่เราใช้เมธอด setContent () เพื่อตั้งค่าเนื้อหาที่มีอาร์กิวเมนต์ที่สองคือ "text / html" เพื่อระบุว่าเนื้อหา HTML รวมอยู่ในข้อความ

เมื่อใช้ตัวอย่างนี้คุณสามารถส่งเนื้อหา HTML ได้มากเท่าที่คุณต้องการ

ตัวอย่าง

// File Name SendHTMLEmail.java

import java.util.*;
import javax.mail.*;
import javax.mail.internet.*;
import javax.activation.*;

public class SendHTMLEmail {

   public static void main(String [] args) {
      // Recipient's email ID needs to be mentioned.
      String to = "[email protected]";

      // Sender's email ID needs to be mentioned
      String from = "[email protected]";

      // Assuming you are sending email from localhost
      String host = "localhost";

      // Get system properties
      Properties properties = System.getProperties();

      // Setup mail server
      properties.setProperty("mail.smtp.host", host);

      // Get the default Session object.
      Session session = Session.getDefaultInstance(properties);

      try {
         // Create a default MimeMessage object.
         MimeMessage message = new MimeMessage(session);

         // Set From: header field of the header.
         message.setFrom(new InternetAddress(from));

         // Set To: header field of the header.
         message.addRecipient(Message.RecipientType.TO, new InternetAddress(to));

         // Set Subject: header field
         message.setSubject("This is the Subject Line!");

         // Send the actual HTML message, as big as you like
         message.setContent("<h1>This is actual message</h1>", "text/html");

         // Send message
         Transport.send(message);
         System.out.println("Sent message successfully....");
      } catch (MessagingException mex) {
         mex.printStackTrace();
      }
   }
}

คอมไพล์และรันโปรแกรมนี้เพื่อส่งอีเมล HTML -

เอาต์พุต

$ java SendHTMLEmail
Sent message successfully....

ส่งไฟล์แนบในอีเมล

นี่คือตัวอย่างการส่งอีเมลพร้อมไฟล์แนบจากเครื่องของคุณ ที่นี่สันนิษฐานว่าเป็นไฟล์localhost เชื่อมต่อกับอินเทอร์เน็ตและมีความสามารถเพียงพอที่จะส่งอีเมล

ตัวอย่าง

// File Name SendFileEmail.java

import java.util.*;
import javax.mail.*;
import javax.mail.internet.*;
import javax.activation.*;

public class SendFileEmail {

   public static void main(String [] args) {     
      // Recipient's email ID needs to be mentioned.
      String to = "[email protected]";

      // Sender's email ID needs to be mentioned
      String from = "[email protected]";

      // Assuming you are sending email from localhost
      String host = "localhost";

      // Get system properties
      Properties properties = System.getProperties();

      // Setup mail server
      properties.setProperty("mail.smtp.host", host);

      // Get the default Session object.
      Session session = Session.getDefaultInstance(properties);

      try {
         // Create a default MimeMessage object.
         MimeMessage message = new MimeMessage(session);

         // Set From: header field of the header.
         message.setFrom(new InternetAddress(from));

         // Set To: header field of the header.
         message.addRecipient(Message.RecipientType.TO,new InternetAddress(to));

         // Set Subject: header field
         message.setSubject("This is the Subject Line!");

         // Create the message part 
         BodyPart messageBodyPart = new MimeBodyPart();

         // Fill the message
         messageBodyPart.setText("This is message body");
         
         // Create a multipar message
         Multipart multipart = new MimeMultipart();

         // Set text message part
         multipart.addBodyPart(messageBodyPart);

         // Part two is attachment
         messageBodyPart = new MimeBodyPart();
         String filename = "file.txt";
         DataSource source = new FileDataSource(filename);
         messageBodyPart.setDataHandler(new DataHandler(source));
         messageBodyPart.setFileName(filename);
         multipart.addBodyPart(messageBodyPart);

         // Send the complete message parts
         message.setContent(multipart );

         // Send message
         Transport.send(message);
         System.out.println("Sent message successfully....");
      } catch (MessagingException mex) {
         mex.printStackTrace();
      }
   }
}

คอมไพล์และรันโปรแกรมนี้เพื่อส่งอีเมล HTML -

เอาต์พุต

$ java SendFileEmail
Sent message successfully....

ส่วนการตรวจสอบผู้ใช้

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

props.setProperty("mail.user", "myuser");
props.setProperty("mail.password", "mypwd");

กลไกการส่งอีเมลที่เหลือจะยังคงเป็นไปตามที่อธิบายไว้ข้างต้น

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

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

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

วงจรชีวิตของเธรด

เธรดต้องผ่านขั้นตอนต่างๆในวงจรชีวิต ตัวอย่างเช่นเธรดเกิดเริ่มทำงานแล้วก็ตาย แผนภาพต่อไปนี้แสดงวงจรชีวิตที่สมบูรณ์ของเธรด

ต่อไปนี้เป็นขั้นตอนของวงจรชีวิต -

  • New- เธรดใหม่เริ่มวงจรชีวิตในสถานะใหม่ มันยังคงอยู่ในสถานะนี้จนกว่าโปรแกรมจะเริ่มเธรด นอกจากนี้ยังเรียกว่าไฟล์born thread.

  • Runnable- หลังจากเธรดเกิดใหม่เริ่มต้นเธรดจะรันได้ เธรดในสถานะนี้จะถือว่ากำลังดำเนินการตามภารกิจ

  • Waiting- บางครั้งเธรดจะเปลี่ยนเป็นสถานะกำลังรอในขณะที่เธรดรอให้เธรดอื่นทำงาน เธรดจะเปลี่ยนกลับสู่สถานะรันได้ก็ต่อเมื่อเธรดอื่นส่งสัญญาณให้เธรดรอดำเนินการต่อ

  • Timed Waiting- เธรดที่รันได้สามารถเข้าสู่สถานะรอหมดเวลาสำหรับช่วงเวลาที่กำหนด เธรดในสถานะนี้จะเปลี่ยนกลับไปเป็นสถานะที่รันได้เมื่อช่วงเวลานั้นหมดอายุหรือเมื่อมีเหตุการณ์ที่รอให้เกิดขึ้น

  • Terminated (Dead) - เธรดที่รันได้เข้าสู่สถานะสิ้นสุดเมื่อทำงานเสร็จสมบูรณ์หรือถูกยกเลิก

ลำดับความสำคัญของเธรด

เธรด Java ทุกเธรดมีลำดับความสำคัญที่ช่วยให้ระบบปฏิบัติการกำหนดลำดับการจัดกำหนดการเธรด

ลำดับความสำคัญของเธรด Java อยู่ในช่วงระหว่าง MIN_PRIORITY (ค่าคงที่ 1) และ MAX_PRIORITY (ค่าคงที่ 10) ตามค่าเริ่มต้นทุกเธรดจะได้รับลำดับความสำคัญ NORM_PRIORITY (ค่าคงที่ 5)

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

สร้างเธรดโดยใช้อินเทอร์เฟซที่รันได้

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

ขั้นตอนที่ 1

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

public void run( )

ขั้นตอนที่ 2

ในขั้นตอนที่สองคุณจะเริ่มต้นไฟล์ Thread วัตถุโดยใช้ตัวสร้างต่อไปนี้ -

Thread(Runnable threadObj, String threadName);

โดยที่threadObjเป็นอินสแตนซ์ของคลาสที่ใช้Runnable อินเทอร์เฟซและ threadName เป็นชื่อที่ตั้งให้กับเธรดใหม่

ขั้นตอนที่ 3

เมื่อสร้างวัตถุ Thread แล้วคุณสามารถเริ่มได้โดยการโทร start()เมธอดซึ่งเรียกใช้เมธอด call to run () ต่อไปนี้เป็นไวยากรณ์อย่างง่ายของ start () วิธีการ -

void start();

ตัวอย่าง

นี่คือตัวอย่างที่สร้างเธรดใหม่และเริ่มรัน -

class RunnableDemo implements Runnable {
   private Thread t;
   private String threadName;
   
   RunnableDemo( String name) {
      threadName = name;
      System.out.println("Creating " +  threadName );
   }
   
   public void run() {
      System.out.println("Running " +  threadName );
      try {
         for(int i = 4; i > 0; i--) {
            System.out.println("Thread: " + threadName + ", " + i);
            // Let the thread sleep for a while.
            Thread.sleep(50);
         }
      } catch (InterruptedException e) {
         System.out.println("Thread " +  threadName + " interrupted.");
      }
      System.out.println("Thread " +  threadName + " exiting.");
   }
   
   public void start () {
      System.out.println("Starting " +  threadName );
      if (t == null) {
         t = new Thread (this, threadName);
         t.start ();
      }
   }
}

public class TestThread {

   public static void main(String args[]) {
      RunnableDemo R1 = new RunnableDemo( "Thread-1");
      R1.start();
      
      RunnableDemo R2 = new RunnableDemo( "Thread-2");
      R2.start();
   }   
}

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -

เอาต์พุต

Creating Thread-1
Starting Thread-1
Creating Thread-2
Starting Thread-2
Running Thread-1
Thread: Thread-1, 4
Running Thread-2
Thread: Thread-2, 4
Thread: Thread-1, 3
Thread: Thread-2, 3
Thread: Thread-1, 2
Thread: Thread-2, 2
Thread: Thread-1, 1
Thread: Thread-2, 1
Thread Thread-1 exiting.
Thread Thread-2 exiting.

สร้างเธรดโดยการขยายคลาสของเธรด

วิธีที่สองในการสร้างเธรดคือการสร้างคลาสใหม่ที่ขยาย Threadเรียนโดยใช้สองขั้นตอนง่ายๆต่อไปนี้ แนวทางนี้ให้ความยืดหยุ่นมากขึ้นในการจัดการเธรดหลายเธรดที่สร้างขึ้นโดยใช้เมธอดที่มีอยู่ในคลาสเธรด

ขั้นตอนที่ 1

คุณจะต้องลบล้าง run( )วิธีการที่มีอยู่ในคลาสเธรด วิธีนี้เป็นจุดเริ่มต้นสำหรับเธรดและคุณจะใส่ตรรกะทางธุรกิจที่สมบูรณ์ของคุณไว้ในวิธีนี้ ต่อไปนี้เป็นไวยากรณ์ง่ายๆของ run () method -

public void run( )

ขั้นตอนที่ 2

เมื่อสร้างวัตถุ Thread แล้วคุณสามารถเริ่มได้โดยการโทร start()เมธอดซึ่งเรียกใช้เมธอด call to run () ต่อไปนี้เป็นไวยากรณ์อย่างง่ายของ start () วิธีการ -

void start( );

ตัวอย่าง

นี่คือโปรแกรมก่อนหน้านี้ที่เขียนใหม่เพื่อขยายเธรด -

class ThreadDemo extends Thread {
   private Thread t;
   private String threadName;
   
   ThreadDemo( String name) {
      threadName = name;
      System.out.println("Creating " +  threadName );
   }
   
   public void run() {
      System.out.println("Running " +  threadName );
      try {
         for(int i = 4; i > 0; i--) {
            System.out.println("Thread: " + threadName + ", " + i);
            // Let the thread sleep for a while.
            Thread.sleep(50);
         }
      } catch (InterruptedException e) {
         System.out.println("Thread " +  threadName + " interrupted.");
      }
      System.out.println("Thread " +  threadName + " exiting.");
   }
   
   public void start () {
      System.out.println("Starting " +  threadName );
      if (t == null) {
         t = new Thread (this, threadName);
         t.start ();
      }
   }
}

public class TestThread {

   public static void main(String args[]) {
      ThreadDemo T1 = new ThreadDemo( "Thread-1");
      T1.start();
      
      ThreadDemo T2 = new ThreadDemo( "Thread-2");
      T2.start();
   }   
}

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -

เอาต์พุต

Creating Thread-1
Starting Thread-1
Creating Thread-2
Starting Thread-2
Running Thread-1
Thread: Thread-1, 4
Running Thread-2
Thread: Thread-2, 4
Thread: Thread-1, 3
Thread: Thread-2, 3
Thread: Thread-1, 2
Thread: Thread-2, 2
Thread: Thread-1, 1
Thread: Thread-2, 1
Thread Thread-1 exiting.
Thread Thread-2 exiting.

วิธีการด้าย

ต่อไปนี้เป็นรายการวิธีการสำคัญที่มีอยู่ในคลาสเธรด

ซีเนียร์ วิธีการและคำอธิบาย
1

public void start()

เริ่มต้นเธรดในเส้นทางการดำเนินการแยกต่างหากจากนั้นเรียกใช้เมธอด run () บนอ็อบเจ็กต์เธรดนี้
2

public void run()

หากอ็อบเจ็กต์เธรดนี้ถูกสร้างอินสแตนซ์โดยใช้เป้าหมาย Runnable ที่แยกจากกันเมธอด run () จะถูกเรียกใช้บนอ็อบเจ็กต์ Runnable นั้น
3

public final void setName(String name)

เปลี่ยนชื่อของวัตถุเธรด นอกจากนี้ยังมี getName () เมธอดในการดึงชื่อ
4

public final void setPriority(int priority)

ตั้งค่าลำดับความสำคัญของวัตถุเธรดนี้ ค่าที่เป็นไปได้อยู่ระหว่าง 1 ถึง 10
5

public final void setDaemon(boolean on)

พารามิเตอร์ของ true แสดงว่า Thread นี้เป็น daemon thread
6

public final void join(long millisec)

เธรดปัจจุบันเรียกใช้เมธอดนี้บนเธรดที่สองทำให้เธรดปัจจุบันถูกบล็อกจนกว่าเธรดที่สองจะสิ้นสุดหรือผ่านไปตามจำนวนมิลลิวินาทีที่ระบุ
7

public void interrupt()

ขัดจังหวะเธรดนี้ทำให้ดำเนินการต่อหากถูกบล็อกไม่ว่าด้วยเหตุผลใดก็ตาม
8

public final boolean isAlive()

ส่งคืนค่าจริงหากเธรดยังมีชีวิตอยู่ซึ่งเป็นเวลาใดก็ได้หลังจากเธรดเริ่มทำงาน แต่ก่อนที่เธรดจะทำงานจนเสร็จสิ้น

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

ซีเนียร์ วิธีการและคำอธิบาย
1

public static void yield()

ทำให้เธรดที่กำลังรันอยู่เพื่อส่งผลให้กับเธรดอื่น ๆ ที่มีลำดับความสำคัญเดียวกันซึ่งกำลังรอการจัดกำหนดการ
2

public static void sleep(long millisec)

ทำให้เธรดที่กำลังรันอยู่ในปัจจุบันบล็อกเป็นเวลาอย่างน้อยตามจำนวนมิลลิวินาทีที่ระบุ
3

public static boolean holdsLock(Object x)

ส่งคืนจริงหากเธรดปัจจุบันมีการล็อกบนวัตถุที่กำหนด
4

public static Thread currentThread()

ส่งคืนการอ้างอิงไปยังเธรดที่กำลังรันอยู่ซึ่งเป็นเธรดที่เรียกใช้เมธอดนี้
5

public static void dumpStack()

พิมพ์การติดตามสแต็กสำหรับเธรดที่กำลังรันอยู่ซึ่งมีประโยชน์เมื่อทำการดีบักแอ็พพลิเคชันแบบมัลติเธรด

ตัวอย่าง

โปรแกรม ThreadClassDemo ต่อไปนี้แสดงวิธีการเหล่านี้บางส่วนของคลาส Thread พิจารณาชั้นเรียนDisplayMessage ซึ่งดำเนินการ Runnable -

// File Name : DisplayMessage.java
// Create a thread to implement Runnable

public class DisplayMessage implements Runnable {
   private String message;
   
   public DisplayMessage(String message) {
      this.message = message;
   }
   
   public void run() {
      while(true) {
         System.out.println(message);
      }
   }
}

ต่อไปนี้เป็นคลาสอื่นที่ขยายคลาสเธรด -

// File Name : GuessANumber.java
// Create a thread to extentd Thread

public class GuessANumber extends Thread {
   private int number;
   public GuessANumber(int number) {
      this.number = number;
   }
   
   public void run() {
      int counter = 0;
      int guess = 0;
      do {
         guess = (int) (Math.random() * 100 + 1);
         System.out.println(this.getName() + " guesses " + guess);
         counter++;
      } while(guess != number);
      System.out.println("** Correct!" + this.getName() + "in" + counter + "guesses.**");
   }
}

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

// File Name : ThreadClassDemo.java
public class ThreadClassDemo {

   public static void main(String [] args) {
      Runnable hello = new DisplayMessage("Hello");
      Thread thread1 = new Thread(hello);
      thread1.setDaemon(true);
      thread1.setName("hello");
      System.out.println("Starting hello thread...");
      thread1.start();
      
      Runnable bye = new DisplayMessage("Goodbye");
      Thread thread2 = new Thread(bye);
      thread2.setPriority(Thread.MIN_PRIORITY);
      thread2.setDaemon(true);
      System.out.println("Starting goodbye thread...");
      thread2.start();

      System.out.println("Starting thread3...");
      Thread thread3 = new GuessANumber(27);
      thread3.start();
      try {
         thread3.join();
      } catch (InterruptedException e) {
         System.out.println("Thread interrupted.");
      }
      System.out.println("Starting thread4...");
      Thread thread4 = new GuessANumber(75);
      
      thread4.start();
      System.out.println("main() is ending...");
   }
}

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

เอาต์พุต

Starting hello thread...
Starting goodbye thread...
Hello
Hello
Hello
Hello
Hello
Hello
Goodbye
Goodbye
Goodbye
Goodbye
Goodbye
.......

แนวคิดเกี่ยวกับ Java Multithreading ที่สำคัญ

ในขณะที่ทำการเขียนโปรแกรม Multithreading ใน Java คุณจะต้องมีแนวคิดต่อไปนี้ที่มีประโยชน์มาก -

  • การซิงโครไนซ์เธรดคืออะไร?

  • การจัดการการสื่อสารระหว่างเธรด

  • การจัดการการหยุดชะงักของเธรด

  • การทำงานของเธรดหลัก

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

มีความแตกต่างที่สำคัญบางประการระหว่างแอพเพล็ตและแอ็พพลิเคชัน Java แบบสแตนด์อโลนรวมถึงสิ่งต่อไปนี้ -

  • แอพเพล็ตคือคลาส Java ที่ขยายคลาส java.applet.Applet

  • เมธอด main () ไม่ถูกเรียกใช้บนแอพเพล็ตและคลาสแอพเพล็ตจะไม่กำหนด main ()

  • แอพเพล็ตถูกออกแบบมาให้ฝังอยู่ในหน้า HTML

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

  • ต้องมี JVM เพื่อดูแอพเพล็ต JVM สามารถเป็นปลั๊กอินของเว็บเบราว์เซอร์หรือสภาพแวดล้อมรันไทม์แยกต่างหาก

  • JVM บนเครื่องของผู้ใช้สร้างอินสแตนซ์ของคลาสแอพเพล็ตและเรียกใช้วิธีการต่างๆในช่วงอายุของแอพเพล็ต

  • แอพเพล็ตมีกฎความปลอดภัยที่เข้มงวดซึ่งบังคับใช้โดยเว็บเบราว์เซอร์ ความปลอดภัยของแอพเพล็ตมักเรียกว่าการรักษาความปลอดภัยแบบแซนด์บ็อกซ์โดยเปรียบเทียบแอพเพล็ตกับเด็กที่เล่นในแซนด์บ็อกซ์กับกฎต่างๆที่ต้องปฏิบัติตาม

  • คลาสอื่น ๆ ที่แอพเพล็ตต้องการสามารถดาวน์โหลดได้ในไฟล์ Java Archive (JAR) ไฟล์เดียว

วงจรชีวิตของแอพเพล็ต

สี่วิธีในคลาส Applet ให้กรอบการทำงานที่คุณสร้างแอพเพล็ตที่จริงจัง -

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

  • start- วิธีนี้เรียกโดยอัตโนมัติหลังจากเบราว์เซอร์เรียกใช้เมธอด init เรียกอีกอย่างว่าเมื่อใดก็ตามที่ผู้ใช้กลับไปที่เพจที่มีแอพเพล็ตหลังจากออกไปยังเพจอื่นแล้ว

  • stop- วิธีนี้จะถูกเรียกโดยอัตโนมัติเมื่อผู้ใช้ย้ายออกจากหน้าที่แอพเพล็ตนั่งอยู่ ดังนั้นจึงสามารถเรียกซ้ำ ๆ ในแอพเพล็ตเดียวกันได้

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

  • paint- เรียกใช้ทันทีหลังจากเมธอด start () และทุกครั้งที่แอพเพล็ตจำเป็นต้องทาสีใหม่ในเบราว์เซอร์ เมธอด paint () สืบทอดมาจาก java.awt

แอพเพล็ต "สวัสดีชาวโลก"

ต่อไปนี้เป็นแอพเพล็ตธรรมดาที่ชื่อว่า HelloWorldApplet.java -

import java.applet.*;
import java.awt.*;

public class HelloWorldApplet extends Applet {
   public void paint (Graphics g) {
      g.drawString ("Hello World", 25, 50);
   }
}

คำสั่งนำเข้าเหล่านี้นำคลาสเข้าสู่ขอบเขตของคลาสแอพเพล็ตของเรา -

  • java.applet.Applet
  • java.awt.Graphics

หากไม่มีคำสั่งอิมพอร์ตเหล่านั้นคอมไพเลอร์ Java จะไม่รู้จักคลาส Applet และ Graphics ซึ่งคลาสแอพเพล็ตอ้างถึง

แอปเพล็ตคลาส

ทุกแอปเพล็เป็นส่วนขยายของชั้น java.applet.Applet คลาส Applet พื้นฐานจัดเตรียมเมธอดที่คลาส Applet ที่ได้รับอาจเรียกเพื่อขอรับข้อมูลและบริการจากบริบทของเบราว์เซอร์

ซึ่งรวมถึงวิธีการดังต่อไปนี้ -

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

นอกจากนี้คลาส Applet ยังมีอินเทอร์เฟซที่วิวเวอร์หรือเบราว์เซอร์รับข้อมูลเกี่ยวกับแอพเพล็ตและควบคุมการทำงานของแอพเพล็ต ผู้ชมอาจ -

  • ขอข้อมูลเกี่ยวกับผู้แต่งเวอร์ชันและลิขสิทธิ์ของแอพเพล็ต
  • ขอคำอธิบายพารามิเตอร์ที่แอพเพล็ตรู้จัก
  • เริ่มต้นแอพเพล็ต
  • ทำลายแอพเพล็ต
  • เริ่มการทำงานของแอพเพล็ต
  • หยุดการทำงานของแอพเพล็ต

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

แอพเพล็ต "Hello, World" เสร็จสมบูรณ์ตามที่ระบุ วิธีเดียวที่ถูกแทนที่คือวิธีการทาสี

การเรียกใช้แอพเพล็ต

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

แท็ก <applet> เป็นพื้นฐานสำหรับการฝังแอพเพล็ตในไฟล์ HTML ต่อไปนี้เป็นตัวอย่างที่เรียกใช้แอพเพล็ต "Hello, World" -

<html>
   <title>The Hello, World Applet</title>
   <hr>
   <applet code = "HelloWorldApplet.class" width = "320" height = "120">
      If your browser was Java-enabled, a "Hello, World"
      message would appear here.
   </applet>
   <hr>
</html>

Note- คุณสามารถอ้างถึงHTML Applet Tagเพื่อทำความเข้าใจเพิ่มเติมเกี่ยวกับการเรียกแอพเพล็ตจาก HTML

จำเป็นต้องมีโค้ดแอตทริบิวต์ของแท็ก <applet> ระบุคลาส Applet ที่จะรัน ต้องใช้ความกว้างและความสูงเพื่อระบุขนาดเริ่มต้นของพาเนลที่แอพเพล็ตทำงาน ต้องปิดคำสั่งแอพเพล็ตด้วยแท็ก </applet>

หากแอพเพล็ตรับพารามิเตอร์อาจมีการส่งผ่านค่าสำหรับพารามิเตอร์โดยการเพิ่มแท็ก <param> ระหว่าง <applet> และ </applet> เบราว์เซอร์จะละเว้นข้อความและแท็กอื่น ๆ ระหว่างแท็กแอพเพล็ต

เบราว์เซอร์ที่ไม่เปิดใช้งาน Java จะไม่ประมวลผล <applet> และ </applet> ดังนั้นสิ่งที่ปรากฏระหว่างแท็กที่ไม่เกี่ยวข้องกับแอพเพล็ตจะปรากฏให้เห็นในเบราว์เซอร์ที่ไม่ได้เปิดใช้งาน Java

วิวเวอร์หรือเบราว์เซอร์มองหาโค้ด Java ที่คอมไพล์แล้วที่ตำแหน่งของเอกสาร หากต้องการระบุเป็นอย่างอื่นให้ใช้แอตทริบิวต์ codebase ของแท็ก <applet> ดังที่แสดง -

<applet codebase = "https://amrood.com/applets" code = "HelloWorldApplet.class"
   width = "320" height = "120">

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

<applet  = "mypackage.subpackage.TestApplet.class" 
   width = "320" height = "120">

รับพารามิเตอร์ Applet

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

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

CheckerApplet รับพารามิเตอร์ในเมธอด init () นอกจากนี้ยังอาจได้รับพารามิเตอร์ในวิธีการ paint () อย่างไรก็ตามการรับค่าและบันทึกการตั้งค่าครั้งเดียวในตอนเริ่มต้นของแอพเพล็ตแทนที่จะเป็นการรีเฟรชทุกครั้งจะสะดวกและมีประสิทธิภาพ

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

Applet.getParameter () วิธีการดึงพารามิเตอร์ที่กำหนดชื่อของพารามิเตอร์ (ค่าของพารามิเตอร์เป็นสตริงเสมอ) หากค่าเป็นตัวเลขหรือข้อมูลอื่น ๆ ที่ไม่ใช่อักขระต้องแยกวิเคราะห์สตริง

ต่อไปนี้เป็นโครงกระดูกของ CheckerApplet.java -

import java.applet.*;
import java.awt.*;

public class CheckerApplet extends Applet {
   int squareSize = 50;   // initialized to default size
   public void init() {}
   private void parseSquareSize (String param) {}
   private Color parseColor (String param) {}
   public void paint (Graphics g) {}
}

นี่คือวิธีการ init () และ parseSquareSize () ของ CheckerApplet -

public void init () {
   String squareSizeParam = getParameter ("squareSize");
   parseSquareSize (squareSizeParam);
   
   String colorParam = getParameter ("color");
   Color fg = parseColor (colorParam);
   
   setBackground (Color.black);
   setForeground (fg);
}

private void parseSquareSize (String param) {
   if (param == null) return;
   try {
      squareSize = Integer.parseInt (param);
   } catch (Exception e) {
      // Let default value remain
   }
}

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

ดังนั้น parseSquareSize () จึงจับข้อยกเว้นแทนที่จะปล่อยให้แอพเพล็ตล้มเหลวในการป้อนข้อมูลที่ไม่ถูกต้อง

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

การระบุพารามิเตอร์แอปเพล็ต

ต่อไปนี้เป็นตัวอย่างของไฟล์ HTML ที่มี CheckerApplet ฝังอยู่ ไฟล์ HTML ระบุพารามิเตอร์ทั้งสองให้กับแอพเพล็ตโดยใช้แท็ก <param>

<html>
   <title>Checkerboard Applet</title>
   <hr>
   <applet code = "CheckerApplet.class" width = "480" height = "320">
      <param name = "color" value = "blue">
      <param name = "squaresize" value = "30">
   </applet>
   <hr>
</html>

Note - ชื่อพารามิเตอร์ไม่คำนึงถึงขนาดตัวพิมพ์

การแปลงแอปพลิเคชันเป็นแอพเพล็ต

การแปลงแอปพลิเคชัน Java แบบกราฟิกเป็นเรื่องง่าย (นั่นคือแอปพลิเคชันที่ใช้ AWT และคุณสามารถเริ่มต้นด้วยตัวเรียกใช้โปรแกรม Java) เป็นแอพเพล็ตที่คุณสามารถฝังในเว็บเพจได้

ต่อไปนี้เป็นขั้นตอนเฉพาะสำหรับการแปลงแอปพลิเคชันเป็นแอพเพล็ต

  • สร้างหน้า HTML ด้วยแท็กที่เหมาะสมเพื่อโหลดโค้ดแอพเพล็ต

  • จัดหาคลาสย่อยของคลาส JApplet กำหนดให้ชั้นเรียนนี้เป็นแบบสาธารณะ มิฉะนั้นจะไม่สามารถโหลดแอพเพล็ตได้

  • กำจัดวิธีการหลักในแอปพลิเคชัน อย่าสร้างกรอบหน้าต่างสำหรับแอปพลิเคชัน แอปพลิเคชันของคุณจะแสดงภายในเบราว์เซอร์

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

  • ลบการโทรเพื่อ setSize; สำหรับแอพเพล็ตการปรับขนาดทำได้ด้วยพารามิเตอร์ความกว้างและความสูงในไฟล์ HTML

  • ลบการเรียกไปที่ setDefaultCloseOperation ไม่สามารถปิดแอพเพล็ตได้ จะยุติเมื่อเบราว์เซอร์ออก

  • หากแอปพลิเคชันเรียกใช้ setTitle ให้ยกเลิกการเรียกใช้เมธอด แอพเพล็ตไม่สามารถมีแถบชื่อเรื่อง (แน่นอนคุณสามารถตั้งชื่อหน้าเว็บได้โดยใช้แท็กหัวเรื่อง HTML)

  • อย่าเรียก setVisible (จริง) แอพเพล็ตจะแสดงโดยอัตโนมัติ

การจัดการเหตุการณ์

แอพเพล็ตสืบทอดกลุ่มวิธีการจัดการเหตุการณ์จากคลาสคอนเทนเนอร์ คลาส Container กำหนดเมธอดต่างๆเช่น processKeyEvent และ processMouseEvent สำหรับจัดการเหตุการณ์บางประเภทจากนั้นก็ใช้วิธี catch-all หนึ่งวิธีที่เรียกว่า processEvent

ในการตอบสนองต่อเหตุการณ์แอพเพล็ตจะต้องแทนที่วิธีการเฉพาะเหตุการณ์ที่เหมาะสม

import java.awt.event.MouseListener;
import java.awt.event.MouseEvent;
import java.applet.Applet;
import java.awt.Graphics;

public class ExampleEventHandling extends Applet implements MouseListener {
   StringBuffer strBuffer;

   public void init() {
      addMouseListener(this);
      strBuffer = new StringBuffer();
      addItem("initializing the apple ");
   }

   public void start() {
      addItem("starting the applet ");
   }

   public void stop() {
      addItem("stopping the applet ");
   }

   public void destroy() {
      addItem("unloading the applet");
   }

   void addItem(String word) {
      System.out.println(word);
      strBuffer.append(word);
      repaint();
   }

   public void paint(Graphics g) {
      // Draw a Rectangle around the applet's display area.
      g.drawRect(0, 0, 
      getWidth() - 1,
      getHeight() - 1);

      // display the string inside the rectangle.
      g.drawString(strBuffer.toString(), 10, 20);
   }

   
   public void mouseEntered(MouseEvent event) {
   }
   public void mouseExited(MouseEvent event) {
   }
   public void mousePressed(MouseEvent event) {
   }
   public void mouseReleased(MouseEvent event) {
   }
   public void mouseClicked(MouseEvent event) {
      addItem("mouse clicked! ");
   }
}

ตอนนี้ให้เราเรียกแอพเพล็ตนี้ดังนี้ -

<html>
   <title>Event Handling</title>
   <hr>
   <applet code = "ExampleEventHandling.class" 
      width = "300" height = "300">
   </applet>
   <hr>
</html>

เริ่มแรกแอพเพล็ตจะแสดง "initializing the applet. start the applet." จากนั้นเมื่อคุณคลิกภายในสี่เหลี่ยมผืนผ้า "คลิกเมาส์" จะปรากฏขึ้นเช่นกัน

การแสดงภาพ

แอพเพล็ตสามารถแสดงภาพในรูปแบบ GIF, JPEG, BMP และอื่น ๆ ในการแสดงภาพภายในแอพเพล็ตคุณใช้เมธอด drawImage () ที่พบในคลาส java.awt.Graphics

ต่อไปนี้เป็นตัวอย่างที่แสดงขั้นตอนทั้งหมดในการแสดงภาพ -

import java.applet.*;
import java.awt.*;
import java.net.*;

public class ImageDemo extends Applet {
   private Image image;
   private AppletContext context;
   
   public void init() {
      context = this.getAppletContext();
      String imageURL = this.getParameter("image");
      if(imageURL == null) {
         imageURL = "java.jpg";
      }
      try {
         URL url = new URL(this.getDocumentBase(), imageURL);
         image = context.getImage(url);
      } catch (MalformedURLException e) {
         e.printStackTrace();
         // Display in browser status bar
         context.showStatus("Could not load image!");
      }
   }
   
   public void paint(Graphics g) {
      context.showStatus("Displaying image");
      g.drawImage(image, 0, 0, 200, 84, null);
      g.drawString("www.javalicense.com", 35, 100);
   }  
}

ตอนนี้ให้เราเรียกแอพเพล็ตนี้ดังนี้ -

<html>
   <title>The ImageDemo applet</title>
   <hr>
   <applet code = "ImageDemo.class" width = "300" height = "200">
      <param name = "image" value = "java.jpg">
   </applet>
   <hr>
</html>

กำลังเล่นเสียง

แอพเพล็ตสามารถเล่นไฟล์เสียงที่แสดงโดยอินเทอร์เฟซ AudioClip ในแพ็คเกจ java.applet อินเทอร์เฟซ AudioClip มีสามวิธี ได้แก่ -

  • public void play() - เล่นคลิปเสียงหนึ่งครั้งตั้งแต่เริ่มต้น

  • public void loop() - ทำให้คลิปเสียงเล่นซ้ำอย่างต่อเนื่อง

  • public void stop() - หยุดเล่นคลิปเสียง

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

ต่อไปนี้เป็นตัวอย่างที่แสดงขั้นตอนทั้งหมดในการเล่นเสียง -

import java.applet.*;
import java.awt.*;
import java.net.*;

public class AudioDemo extends Applet {
   private AudioClip clip;
   private AppletContext context;
   
   public void init() {
      context = this.getAppletContext();
      String audioURL = this.getParameter("audio");
      if(audioURL == null) {
         audioURL = "default.au";
      }
      try {
         URL url = new URL(this.getDocumentBase(), audioURL);
         clip = context.getAudioClip(url);
      } catch (MalformedURLException e) {
         e.printStackTrace();
         context.showStatus("Could not load audio file!");
      }
   }
   
   public void start() {
      if(clip != null) {
         clip.loop();
      }
   }
   
   public void stop() {
      if(clip != null) {
         clip.stop();
      }
   }
}

ตอนนี้ให้เราเรียกแอพเพล็ตนี้ดังนี้ -

<html>
   <title>The ImageDemo applet</title>
   <hr>
   <applet code = "ImageDemo.class" width = "0" height = "0">
      <param name = "audio" value = "test.wav">
   </applet>
   <hr>
</html>

คุณสามารถใช้ test.wav บนพีซีของคุณเพื่อทดสอบตัวอย่างข้างต้น

ภาษา Java รองรับข้อคิดเห็นสามประเภท -

ซีเนียร์ แสดงความคิดเห็นและคำอธิบาย
1

/* text */

คอมไพเลอร์ละเว้นทุกอย่างตั้งแต่ / * ถึง * /
2

//text

คอมไพลเลอร์จะละเว้นทุกอย่างตั้งแต่ // ถึงท้ายบรรทัด
3

/** documentation */

นี่คือเอกสารแสดงความคิดเห็นและโดยทั่วไปจะเรียกว่า doc comment. JDK javadocเครื่องมือใช้ความคิดเห็นของเอกสารเมื่อจัดเตรียมเอกสารที่สร้างขึ้นโดยอัตโนมัติ

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

Javadoc คืออะไร?

Javadoc เป็นเครื่องมือที่มาพร้อมกับ JDK และใช้สำหรับสร้างเอกสารโค้ด Java ในรูปแบบ HTML จากซอร์สโค้ด Java ซึ่งต้องใช้เอกสารประกอบในรูปแบบที่กำหนดไว้ล่วงหน้า

ต่อไปนี้เป็นตัวอย่างง่ายๆที่บรรทัดภายใน/*….*/เป็นคอมเมนต์ Java แบบหลายบรรทัด ในทำนองเดียวกันบรรทัดที่นำหน้า // คือ Java single-line comment

ตัวอย่าง

/**
* The HelloWorld program implements an application that
* simply displays "Hello World!" to the standard output.
*
* @author  Zara Ali
* @version 1.0
* @since   2014-03-31 
*/
public class HelloWorld {

   public static void main(String[] args) {
      // Prints Hello, World! on standard output.
      System.out.println("Hello World!");
   }
}

คุณสามารถรวมแท็ก HTML ที่จำเป็นไว้ในส่วนคำอธิบาย ตัวอย่างเช่นตัวอย่างต่อไปนี้ใช้ <h1> .... </h1> สำหรับหัวเรื่องและ <p> ถูกใช้สำหรับการสร้างตัวแบ่งย่อหน้า -

ตัวอย่าง

/**
* <h1>Hello, World!</h1>
* The HelloWorld program implements an application that
* simply displays "Hello World!" to the standard output.
* <p>
* Giving proper comments in your program makes it more
* user friendly and it is assumed as a high quality code.
* 
*
* @author  Zara Ali
* @version 1.0
* @since   2014-03-31 
*/
public class HelloWorld {

   public static void main(String[] args) {
      // Prints Hello, World! on standard output.
      System.out.println("Hello World!");
   }
}

แท็ก Javadoc

เครื่องมือ javadoc รู้จักแท็กต่อไปนี้ -

แท็ก คำอธิบาย ไวยากรณ์
@ ผู้ว่า เพิ่มผู้เขียนของชั้นเรียน @ ชื่อผู้เขียน - ข้อความ
{@รหัส} แสดงข้อความในโค้ดฟอนต์โดยไม่ตีความข้อความเป็นมาร์กอัป HTML หรือแท็ก javadoc ที่ซ้อนกัน {@code text}
{@docRoot} แสดงพา ธ สัมพัทธ์ไปยังไดเร็กทอรีรูทของเอกสารที่สร้างขึ้นจากเพจที่สร้างขึ้น {@docRoot}
@deprecated เพิ่มความคิดเห็นที่ระบุว่าไม่ควรใช้ API นี้อีกต่อไป @deprecated เลิกใช้งานข้อความ
@ ข้อยกเว้น เพิ่มไฟล์ Throws หัวเรื่องย่อยไปยังเอกสารประกอบที่สร้างขึ้นโดยมีชื่อคลาสและข้อความคำอธิบาย คำอธิบายชื่อคลาส @exception
{@inheritDoc} รับความคิดเห็นจากไฟล์ nearest คลาสที่สืบทอดได้หรืออินเทอร์เฟซที่ใช้งานได้ รับฟังความคิดเห็นจาก Surperclass ทันที
{@link} แทรกลิงก์ในบรรทัดพร้อมป้ายข้อความที่มองเห็นได้ซึ่งชี้ไปยังเอกสารประกอบสำหรับแพ็กเกจคลาสหรือชื่อสมาชิกที่ระบุของคลาสที่อ้างอิง {@link package.class # member label}
{@linkplain} เหมือนกับ {@link} ยกเว้นป้ายของลิงก์จะแสดงเป็นข้อความธรรมดามากกว่าแบบอักษรรหัส {@linkplain package.class # member label}
@ พารา เพิ่มพารามิเตอร์ที่มีชื่อพารามิเตอร์ที่ระบุตามด้วยคำอธิบายที่ระบุในส่วน "พารามิเตอร์" คำอธิบายพารามิเตอร์ชื่อพารามิเตอร์ @param
@กลับ เพิ่มส่วน "Returns" พร้อมข้อความอธิบาย @ กลับคำอธิบาย
@ดู เพิ่มหัวเรื่อง "ดูเพิ่มเติม" พร้อมลิงก์หรือรายการข้อความที่ชี้ไปยังการอ้างอิง @ ดูข้อมูลอ้างอิง
@serial ใช้ในความคิดเห็นของเอกสารสำหรับฟิลด์ซีเรียลที่เป็นค่าเริ่มต้น @ คำอธิบายฟิลด์เซิร์ฟเวอร์ | รวม | ไม่รวม
@serialData จัดทำเอกสารข้อมูลที่เขียนโดยเมธอด writeObject () หรือ writeExternal () คำอธิบายข้อมูล @serialData
@serialField จัดทำเอกสารคอมโพเนนต์ ObjectStreamField @serialField ฟิลด์ชื่อฟิลด์ชนิดฟิลด์คำอธิบาย
@ตั้งแต่ เพิ่มส่วนหัว "ตั้งแต่" พร้อมด้วยข้อความที่ระบุในเอกสารประกอบที่สร้างขึ้น @ ตั้งแต่เปิดตัว
@throws แท็ก @throws และ @exception เป็นคำพ้องความหมาย คำอธิบายชื่อคลาส @throws
{@value} เมื่อใช้ {@value} ในความคิดเห็นเอกสารของฟิลด์คงที่จะแสดงค่าของค่าคงที่นั้น {@value package.class # field}
@ รุ่น เพิ่มหัวเรื่องย่อย "เวอร์ชัน" พร้อมข้อความเวอร์ชันที่ระบุลงในเอกสารที่สร้างขึ้นเมื่อใช้ตัวเลือก -version ข้อความเวอร์ชัน @version

ตัวอย่าง

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

เอกสารเกี่ยวกับคลาส AddNum จะถูกสร้างขึ้นในไฟล์ HTML AddNum.html แต่ในเวลาเดียวกันไฟล์หลักที่มีชื่อ index.html ก็จะถูกสร้างขึ้นด้วย

import java.io.*;

/**
* <h1>Add Two Numbers!</h1>
* The AddNum program implements an application that
* simply adds two given integer numbers and Prints
* the output on the screen.
* <p>
* <b>Note:</b> Giving proper comments in your program makes it more
* user friendly and it is assumed as a high quality code.
*
* @author  Zara Ali
* @version 1.0
* @since   2014-03-31
*/
public class AddNum {
   /**
   * This method is used to add two integers. This is
   * a the simplest form of a class method, just to
   * show the usage of various javadoc Tags.
   * @param numA This is the first paramter to addNum method
   * @param numB  This is the second parameter to addNum method
   * @return int This returns sum of numA and numB.
   */
   public int addNum(int numA, int numB) {
      return numA + numB;
   }

   /**
   * This is the main method which makes use of addNum method.
   * @param args Unused.
   * @return Nothing.
   * @exception IOException On input error.
   * @see IOException
   */

   public static void main(String args[]) throws IOException {
      AddNum obj = new AddNum();
      int sum = obj.addNum(10, 20);

      System.out.println("Sum of 10 and 20 is :" + sum);
   }
}

ตอนนี้ประมวลผลไฟล์ AddNum.java ด้านบนโดยใช้ยูทิลิตี้ javadoc ดังนี้ -

$ javadoc AddNum.java
Loading source file AddNum.java...
Constructing Javadoc information...
Standard Doclet version 1.7.0_51
Building tree for all the packages and classes...
Generating /AddNum.html...
AddNum.java:36: warning - @return tag cannot be used in method with void return type.
Generating /package-frame.html...
Generating /package-summary.html...
Generating /package-tree.html...
Generating /constant-values.html...
Building index for all the packages and classes...
Generating /overview-tree.html...
Generating /index-all.html...
Generating /deprecated-list.html...
Building index for all classes...
Generating /allclasses-frame.html...
Generating /allclasses-noframe.html...
Generating /index.html...
Generating /help-doc.html...
1 warning
$

คุณสามารถตรวจสอบเอกสารทั้งหมดที่สร้างขึ้นที่นี่ - AddNum หากคุณใช้ JDK 1.7 javadoc จะไม่สร้างไฟล์stylesheet.cssดังนั้นเราขอแนะนำให้ดาวน์โหลดและใช้สไตล์ชีตมาตรฐานจาก https://docs.oracle.com/javase/7/docs/api/stylesheet.css

ja/tutorial
es/tutorial
de/tutorial
fr/tutorial
th/tutorial
pt/tutorial
ru/tutorial
vi/tutorial
it/tutorial
ko/tutorial
tr/tutorial
id/tutorial
pl/tutorial
hi/tutorial
japost
espost
depost
frpost
thpost
ptpost
rupost
vipost
itpost
kopost
trpost
idpost
plpost
hipost

© Copyright 2021 - 2024 | All Rights Reserved