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

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

เทคนิคการดีบัก

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

pubic class Add
{
   public static void main(String ar[])
   {
      int a=ar[0];
      system.out.println("A : " +a);
      int b=ar[1];
      system.out.println("B : " +b);
      int c = a + b;
      system.out.println("C = a + b : " +c);
   }
}

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

นอกจากนี้เรายังมีแนวคิดขั้นสูงที่สามารถใช้ในการดีบักโปรแกรมเช่น:

• stepping
• จุดพักและ
• ข้อยกเว้นหรือจุดเฝ้าระวัง

ประเภทของการดีบัก

เราสามารถดีบักโปรแกรมโดยใช้วิธีการต่างๆ:

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

Java Debuggers

นี่คือตัวอย่างบางส่วนของดีบักเกอร์ Java ที่มีอยู่ในตลาด:

• IDE เช่น Eclipse, Netbeans และอื่น ๆ มี debuggers ของตัวเอง (Visual cafe, Borland, JBuilder)
• GUI ดีบักเกอร์แบบสแตนด์อโลน (เช่น Jikes, โปรแกรมดีบักแพลตฟอร์ม Java และ JProbe)
• ดีบักเกอร์บรรทัดคำสั่ง (JDB ของ Sun)
• Notepad หรือ VI ขับเคลื่อน (การติดตามสแต็ก)

บทช่วยสอนนี้ครอบคลุมถึงวิธีการใช้ดีบักเกอร์บรรทัดคำสั่ง jdb.

JDB

Java debugger (JDB) เป็นเครื่องมือสำหรับคลาส Java เพื่อดีบักโปรแกรมในบรรทัดรับคำสั่ง ใช้สถาปัตยกรรม Java Platform Debugger ช่วยในการตรวจจับและแก้ไขจุดบกพร่องในโปรแกรม Java โดยใช้ Java Debug Interface (JDI)

JDB ใน JDK

สถาปัตยกรรมต่อไปนี้กำหนดบทบาทของ JDB ใน JDK ประกอบด้วยสามหน่วยส่วนใหญ่:

• Java Virtual Machine Tool Interface (JVM TI)
• Java Debug Wiring Pool (JDWP)
• Java Debugger Interface (JDI)

JVM TI

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

JDWP

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

JDI

เป็นอินเทอร์เฟซ Java ระดับสูงที่ใช้งานเป็นส่วนหน้า กำหนดข้อมูลตัวแปรในระดับรหัสผู้ใช้ ขอแนะนำให้ใช้เลเยอร์ JDI สำหรับการพัฒนาดีบักเกอร์ทั้งหมด ใช้ JDWP สำหรับการสื่อสารกับ debuggee JVM

บทนี้อธิบายวิธีการติดตั้ง JDB บนระบบที่ใช้ Windows และ Linux JDB เป็นส่วนหนึ่งของ JDK ดังนั้นการติดตั้ง JDK จึงเพียงพอสำหรับการใช้ JDB ในพรอมต์คำสั่ง

ความต้องการของระบบ

ข้อกำหนดของระบบสำหรับการติดตั้ง JDB มีดังนี้:

JDK	Java SE 2 JDK 1.5 ขึ้นไป
หน่วยความจำ	RAM 1 GB (แนะนำ)
พื้นที่ดิสก์	ไม่มีข้อกำหนดขั้นต่ำ
เวอร์ชันระบบปฏิบัติการ	Windows XP ขึ้นไปลินุกซ์

ทำตามขั้นตอนง่ายๆด้านล่างเพื่อติดตั้ง JDB บนระบบของคุณ

ขั้นตอนที่ 1: ตรวจสอบการติดตั้ง Java

ก่อนอื่นคุณต้องติดตั้ง Java Software Development Kit (SDK) ในระบบของคุณ ในการตรวจสอบสิ่งนี้ให้ดำเนินการคำสั่งใด ๆ จากสองคำสั่งทั้งนี้ขึ้นอยู่กับแพลตฟอร์มที่คุณกำลังทำงานอยู่

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

แพลตฟอร์ม	คำสั่ง	ตัวอย่างผลลัพธ์
Windows	เปิดคอนโซลคำสั่งและพิมพ์: \>java –version	เวอร์ชัน Java "1.7.0_60" Java (TM) SE Run Time Environment (บิวด์ 1.7.0_60-b19) Java Hotspot (TM) 64-bit Server VM (build 24.60-b09, mixed mode)
ลินุกซ์	เปิดเทอร์มินัลคำสั่งและพิมพ์: $java –version	เวอร์ชัน java "1.7.0_25" เปิด JDK Runtime Environment (rhel-2.3.10.4.el6_4-x86_64) เปิด JDK 64-Bit Server VM (สร้าง 23.7-b01 โหมดผสม)

เราถือว่าผู้อ่านบทช่วยสอนนี้ติดตั้ง Java SDK เวอร์ชัน 1.7.0_60 ในระบบของตน ในกรณีที่คุณไม่มี Java SDK ให้ดาวน์โหลดเวอร์ชันปัจจุบันจากลิงค์http://www.oracle.com/technetwork/java/javase/downloads/index.html และติดตั้ง

ขั้นตอนที่ 2: การตั้งค่าสภาพแวดล้อม Java

ตั้งค่าตัวแปรสภาพแวดล้อม JAVA_HOME ให้ชี้ไปยังตำแหน่งไดเร็กทอรีฐานที่ติดตั้ง Java บนเครื่องของคุณ ตัวอย่างเช่น,

แพลตฟอร์ม	คำอธิบาย
Windows	ตั้งค่า JAVA_HOME เป็น C: \ ProgramFiles \ java \ jdk1.7.0_60
ลินุกซ์	ส่งออก JAVA_HOME = / usr / local / java

ผนวกพา ธ แบบเต็มของตำแหน่งคอมไพเลอร์ Java เข้ากับ System Path

แพลตฟอร์ม	คำอธิบาย
Windows	ต่อท้ายสตริง "C: \ Program Files \ Java \ jdk1.7.0_60 \ bin" ที่ส่วนท้ายของตัวแปรระบบ PATH
ลินุกซ์	ส่งออก PATH = $ PATH: $ JAVA_HOME / bin /

ดำเนินการคำสั่ง java -version จากพรอมต์คำสั่งตามที่อธิบายไว้ข้างต้น

ขั้นตอนที่ 3: ตรวจสอบการติดตั้ง JDB

ตรวจสอบเวอร์ชัน JDB ดังนี้:

แพลตฟอร์ม	คำสั่ง	ตัวอย่างผลลัพธ์
Windows	เปิดคอนโซลคำสั่งและพิมพ์: \>jdb –version	นี่คือ JDB เวอร์ชัน 1.6 (Java SE เวอร์ชัน 1.7.0_60)
ลินุกซ์	เปิดเทอร์มินัลคำสั่งและพิมพ์: $jdb –version	นี่คือ JDB เวอร์ชัน 1.6 (Java SE เวอร์ชัน 1.7.0_60)

บทนี้จะอธิบายเกี่ยวกับไวยากรณ์ของคำสั่ง JDB ไวยากรณ์ประกอบด้วยสี่ส่วนดังต่อไปนี้:

• JDB
• option
• class
• arguments

ไวยากรณ์

ไวยากรณ์ของ JDB มีดังนี้

jdb [ options ] [ class ] [ arguments ]

JDB

มันเรียก jdb.exe จาก Java Development Kit

ตัวเลือก

ซึ่งรวมถึงตัวเลือกบรรทัดคำสั่งที่ใช้ในการดีบักโปรแกรม Java อย่างมีประสิทธิภาพ ตัวเรียกใช้งาน JDB ยอมรับตัวเลือกทั้งหมด (เช่น -D, -classpath และ -X) และตัวเลือกขั้นสูงเพิ่มเติมบางอย่างเช่น (-attach, -listen, -launch เป็นต้น)

คลาส

เป็นชื่อคลาสที่คุณต้องการดำเนินการดีบัก

อาร์กิวเมนต์

นี่คือค่าอินพุตที่กำหนดให้กับโปรแกรมขณะรันไทม์ ตัวอย่างเช่น arg [0], arg [1] ไปยังเมธอด main ()

ในสี่กลุ่มข้างต้นตัวเลือกมีความสำคัญที่สุด

บทนี้อธิบายถึงอ็อพชันที่สำคัญที่มีอยู่ใน JDB ที่ส่งเป็นอาร์กิวเมนต์ด้วยคำสั่ง jdb

ตัวเลือก

ตารางต่อไปนี้มีรายการตัวเลือกที่ JDB ยอมรับ:

ชื่อ	คำอธิบาย
-ช่วยด้วย	แสดงข้อความวิธีใช้และแสดงรายการตัวเลือกที่เกี่ยวข้อง
-sourcepath	ใช้พา ธ ที่กำหนดสำหรับไฟล์ต้นทางหากไม่ได้ระบุพา ธ ก็จะใช้พา ธ เริ่มต้น“.” นั่นคือไดเร็กทอรีปัจจุบัน
-แนบ	แนบดีบักเกอร์กับ VM ที่กำลังทำงานอยู่โดยระบุที่อยู่ VM ที่กำลังทำงานอยู่
-ฟัง	รอให้ VM ที่รันอยู่เพื่อเชื่อมต่อโดยใช้ตัวเชื่อมต่อมาตรฐาน
- น่าฟัง	รอให้ VM ที่รันอยู่เพื่อเชื่อมต่อโดยใช้ที่อยู่ใดก็ได้
-เปิด	เปิดแอปพลิเคชันที่แก้ไขข้อบกพร่องทันทีเมื่อเริ่มต้นงาน
-listconnectors	แสดงรายการตัวเชื่อมต่อที่มีอยู่ใน VM นี้
- เชื่อมต่อ	เชื่อมต่อกับ VM เป้าหมายโดยใช้ตัวเชื่อมต่อที่มีชื่อพร้อมค่าอาร์กิวเมนต์ที่แสดงรายการ
-dbgtrace	พิมพ์ข้อมูลสำหรับการดีบัก jdb
- ลูกค้า	รันแอปพลิเคชันใน Java Hotspot VM (ไคลเอนต์)
- เซิร์ฟเวอร์	รันแอปพลิเคชันใน Java Hotspot VM (เซิร์ฟเวอร์)
- ตัวเลือก	ส่งผ่านอ็อพชันไปยังเครื่องเสมือน Java ที่ใช้เพื่อรัน JDB

การใช้ตัวเลือกพร้อมคำสั่ง

คำสั่งต่อไปนี้แสดงวิธีใช้บางตัวเลือกข้างต้น:

-ช่วยด้วย

คำสั่งต่อไปนี้ได้รับ -help ในการใช้ JDB

\>jdb -help

-แนบ

คำสั่งต่อไปนี้แนบดีบักเกอร์กับ VM ที่ระบุ (หมายเลขพอร์ต: 1099)

\> jdb -attach 1099

-ฟัง

คำสั่งต่อไปนี้ทำให้กระบวนการ JDB ทำงานบน VM ปัจจุบันรอโดยใช้ตัวเชื่อมต่อมาตรฐาน (VM ใน 8008)

\>jdb -listen 8088

- น่าฟัง

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

\>jdb –listenany

- ลูกค้า

คำสั่งต่อไปนี้เรียกใช้งานแอปพลิเคชันใน Java Hotspot (™) VM (ไคลเอนต์)

\>jdb –tclient

- เซิร์ฟเวอร์

คำสั่งต่อไปนี้เรียกใช้แอ็พพลิเคชันใน Java Hotspot (™) VM (เซิร์ฟเวอร์)

\>jdb -tserver

บทนี้อธิบายวิธีการเริ่มเซสชัน JDB ด้วยวิธีต่างๆ การเรียกใช้ JDB เป็นเทคนิคที่ใช้บ่อยในการเริ่มเซสชัน JDB

มีสองวิธีที่แตกต่างกันในการเริ่มเซสชัน JDB:

• เริ่มต้นเซสชัน JDB โดยการเพิ่มคลาส (ชื่อคลาสหลัก) เข้าไป
• การเพิ่ม JDB เพื่อรัน JVM เพื่อเริ่มเซสชัน

เริ่มเซสชันโดยการเพิ่มคลาส

คำสั่งต่อไปนี้เริ่มเซสชัน JDB:

ไวยากรณ์

\>jdb <classname>

ตัวอย่าง

สมมติว่าเรามีคลาสชื่อ TestClass. คำสั่งต่อไปนี้เริ่มต้นเซสชัน JDB จาก TestClass

\>jdb TestClass

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

เริ่มเซสชันโดยการเพิ่ม JDB ให้กับ JVM ที่กำลังรัน

ด้านล่างนี้คือไวยากรณ์และตัวอย่างในการเริ่มต้นเซสชัน JDB โดยการเพิ่ม JDB ให้กับ JVM ที่รันอยู่

ไวยากรณ์

ไวยากรณ์ต่อไปนี้ใช้สำหรับเซสชัน JDB:

-agentlib:jdwp=transport=dt_shmem,address=
      
       ,server=y,suspend=n 
      

ตัวอย่าง

ให้เราถือว่าชื่อชั้นหลักคือ TestClassและ JVM อนุญาตให้ JDB เชื่อมต่อในภายหลัง ต่อไปนี้เป็นคำสั่งเพื่อเพิ่ม JDB ให้กับ JVM:

\>java
-agentlib:jdwp=transport=dt_shmem,address=jdbconn,server=y,suspend=n TestClass

ตอนนี้คุณสามารถแนบ JDB กับ JVM ด้วยคำสั่งต่อไปนี้:

\> jdb -attach jdbconn

Note: ที่นี่ TestClass ไม่ถูกเพิ่มลงในคำสั่ง JDB เนื่องจาก JDB เชื่อมต่อกับ VM ที่รันอยู่แทนที่จะเรียกใช้งานใหม่

บทนี้จะนำคุณผ่านคำสั่งพื้นฐานของ JDB หลังจากเรียกใช้เซสชันคำสั่งเหล่านี้จะใช้สำหรับการดีบักโปรแกรม

ต่อไปนี้เป็นรายการคำสั่งที่ใช้สำหรับการดีบัก

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

ตัวอย่าง

สมมติว่าเรามีคลาสตัวอย่างที่เรียกว่า Add สำหรับตัวอย่างต่อไปนี้:

Add.java

public class Add
{
   public int addition( int x, int y)
   {
      int z = x+y;
      return z;
   }
   public static void main( String ar[ ] )
   {
      int a = 5, b = 6;
      Add ob = new Add();
      int c = ob.addition(a,b);
      System.out.println("Add: "+c);
   }
}

คอมไพล์คลาสนี้ Add.java โดยใช้คำสั่งต่อไปนี้:

\>javac Add.java

วิ่ง

คำสั่งนี้เรียกใช้ไฟล์คลาสหลักซึ่งเพิ่มลงใน JDB สำหรับการดีบัก ดำเนินการคำสั่งต่อไปนี้เพื่อรันคลาส Add

\>jdb Add
initializing jdb …
>run

ในการดำเนินการคำสั่งเหล่านี้คุณจะเห็นผลลัพธ์ต่อไปนี้:

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

ไวยากรณ์

คำสั่งต่อไปนี้ตั้งค่าเบรกพอยต์ที่หมายเลขบรรทัดเฉพาะ:

> stop at <class name>:<Line no>

คำสั่งต่อไปนี้ตั้งค่าเบรกพอยต์สำหรับวิธีการเฉพาะหรือบนตัวแปรเฉพาะ:

> stop in <class name>:< Method name | Variable name>

ตัวอย่าง

ตัวอย่างต่อไปนี้แสดงวิธีตั้งค่าเบรกพอยต์ในคลาส

public class Add
{
   public int addition( int x, int y)
   {
      int z = x+y;
      return z;
   }
   public static void main( String ar[ ] )
   {
      int a = 5, b = 6;
      Add ob = new Add();
      int c = ob.addition(a,b);
      System.out.println("Add: "+c);
   }
}

บันทึกไฟล์ด้านบนเป็น Add.java คอมไพล์ไฟล์นี้โดยใช้คำสั่งต่อไปนี้:

\>javac Add.java

การแก้จุดบกพร่อง

ให้เราเป็นตัวอย่างสำหรับการดีบัก ที่นี่เราเริ่มกระบวนการดีบักโดยตั้งค่าเบรกพอยต์บน main () ด้านล่างนี้เป็นขั้นตอนที่ต้องปฏิบัติตามในกระบวนการดีบัก:

ขั้นตอนที่ 1: เริ่มเซสชัน JDB

คำสั่งต่อไปนี้เริ่มต้นเซสชัน JDB บนคลาสเพิ่มสำหรับการดีบัก:

\> jdb Add

ขั้นตอนที่ 2: ตั้งค่าเบรกพอยต์

คำสั่งต่อไปนี้ตั้งค่าเบรกพอยต์บนเมธอด main () ของ Add class

> stop in Add.main

หากตั้งเบรกพอยต์สำเร็จคุณจะเห็นผลลัพธ์ต่อไปนี้:

Deferring breakpoint Add.main.
It will set after the class is loaded.
>

ขั้นตอนที่ 3: เริ่มการดีบัก

คำสั่งต่อไปนี้เริ่มดำเนินการของคลาส Add:

> run Add

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

การดำเนินการหยุดที่บรรทัดแรกของเมธอดหลักนั่นคือที่ "int a = 5, b = 6;" หรือหมายเลขบรรทัด: 11 ในรหัส คุณสามารถสังเกตข้อมูลนี้ได้ในเอาต์พุต

ขั้นตอนที่ 4: ดำเนินการต่อ

คำสั่งต่อไปนี้ดำเนินการโปรแกรมต่อไป:

cont

มันให้ส่วนการดำเนินการที่เหลือและเอาต์พุตดังนี้:

> Add:11
The application exited
\>

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

คำสั่งต่อไปนี้ใช้ในขั้นตอนการก้าว:

• ขั้นตอน: ขั้นตอนไปยังบรรทัดการดำเนินการถัดไป
• รายการ: ตรวจสอบว่าคุณอยู่ที่ไหนในรหัส
• ต่อ: ดำเนินการดำเนินการที่เหลือต่อไป

ตัวอย่าง

ตัวอย่างต่อไปนี้ใช้ Add class ที่เราเคยใช้ในบทก่อนหน้านี้:

public class Add
{
   public int addition( int x, int y)
   {
      int z = x+y;
      return z;
   }
   public static void main( String ar[ ] )
   {
      int a = 5, b = 6;
      Add ob = new Add();
      int c = ob.addition(a,b);
      System.out.println("Add: "+c);
   }
}

บันทึกไฟล์ด้านบนเป็น Add.java คอมไพล์ไฟล์นี้โดยใช้คำสั่งต่อไปนี้:

\>javac Add.java

สมมติว่าเบรกพอยต์ถูกตั้งค่าบนเมธอด main () ของคลาส Add ขั้นตอนต่อไปนี้แสดงวิธีการใช้สเต็ปในคลาสเพิ่ม

ขั้นตอนที่ 1: ดำเนินการงาน

คำสั่งต่อไปนี้เริ่มเรียกใช้คลาสที่ชื่อว่า Add

> run Add

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

การดำเนินการหยุดที่บรรทัดแรกของเมธอดหลักนั่นคือที่ "int a = 5, b = 6;" หรือหมายเลขบรรทัด: 11 ในรหัส คุณสามารถสังเกตข้อมูลนี้ได้ในเอาต์พุต

ขั้นตอนที่ 2: ก้าวผ่านรหัส

คำสั่งต่อไปนี้ขั้นตอนการดำเนินการในบรรทัดถัดไป

main[1] step

ตอนนี้ขั้นตอนการดำเนินการไปยังหมายเลขบรรทัด: 12 คุณจะเห็นผลลัพธ์ต่อไปนี้

ขั้นตอนที่ 3: แสดงรหัส

คำสั่งต่อไปนี้แสดงรายการรหัส:

main[1] list

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

ขั้นตอนที่ 4: ดำเนินการต่อ

คำสั่งต่อไปนี้ดำเนินการโค้ดต่อไป:

main[1] cont

คำสั่งนี้ดำเนินการบรรทัดที่เหลือของโค้ดต่อไป ผลลัพธ์เป็นดังที่แสดงด้านล่าง:

> Add:11
The application exited
\>

โดยทั่วไปการก้าวมีสามประเภท:

• ก้าวเข้าสู่
• ก้าวข้าม
• ก้าวออกมา

ก้าวเข้าสู่

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

ในรหัสต่อไปนี้เครื่องหมายลูกศรกำหนดตัวควบคุมในรหัส

public class Add
{
   public int addition( int x, int y)
   {
      int z = x+y;
      return z;
   }
   public static void main( String ar[ ] )
   {
      int a = 5, b = 6;
      -> Add ob = new Add();
      int c = ob.addition(a,b);
      System.out.println("Add: "+c);
   }
}

หากคุณใช้ไฟล์ step intoคำสั่งตัวควบคุมจะย้ายไปยังบรรทัดถัดไปนั่นคือ "int c = ob.addition (a, b);" ที่บรรทัดนี้มีการเรียกใช้ฟังก์ชันaddition(int, int) ด้วยเหตุนี้คอนโทรลเลอร์จึงเลื่อนไปที่บรรทัดบนสุดของฟังก์ชันการเพิ่มด้วยเครื่องหมายลูกศรดังที่แสดงด้านล่าง:

public class Add
{
   public int addition( int x, int y)
   -> {
      int z = x+y;
      return z;
   }
   public static void main( String ar[ ] )
   {
      int a = 5, b = 6;
      Add ob = new Add();
      int c = ob.addition(a,b);
   System.out.println("Add: "+c);
   }
}

ก้าวข้าม

Step Over ยังดำเนินการในบรรทัดถัดไป แต่ถ้าบรรทัดถัดไปเป็นการเรียกใช้ฟังก์ชันจะเรียกใช้ฟังก์ชันนั้นในพื้นหลังและส่งกลับผลลัพธ์

ให้เราเป็นตัวอย่าง ในรหัสต่อไปนี้เครื่องหมายลูกศรกำหนดตัวควบคุมในรหัส

public class Add
{
   public int addition( int x, int y)
   {
      int z = x+y;
      return z;
   }
   public static void main( String ar[ ] )
   {
      int a = 5, b = 6;
      -> Add ob = new Add();
      int c = ob.addition(a,b);
      System.out.println("Add: "+c);
   }
}

หากคุณใช้ไฟล์ step overคำสั่งตัวควบคุมจะย้ายไปยังบรรทัดถัดไปนั่นคือ "int c = ob.addition (a, b);" ในบรรทัดนี้มีการเรียกใช้ฟังก์ชันaddition(int, int) ดังนั้นการเรียกใช้ฟังก์ชันจะเสร็จสิ้นในพื้นหลังและผลลัพธ์จะถูกส่งกลับไปยังบรรทัดปัจจุบันพร้อมกับเครื่องหมายลูกศรดังที่แสดงด้านล่าง:

public class Add
{
   public int addition( int x, int y)
   {
      int z = x+y;
      return z;
   }
   public static void main( String ar[ ] )
   {
      int a = 5, b = 6;
      Add ob = new Add();
      -> int c = ob.addition(a,b);
      System.out.println("Add: "+c);
   }
}

ก้าวออกมา

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

ให้เราเป็นตัวอย่าง ในรหัสต่อไปนี้เครื่องหมายลูกศรกำหนดตัวควบคุมในรหัส

public class Add
{
   public int addition( int x, int y)
   {
      int z = x+y;
      return z;
   }
   public static void main( String ar[ ] )
   {
      int a = 5, b = 6;
      -> Add ob = new Add();
      int c = ob.addition(a,b);
      System.out.println("Add: "+c);
   }
}

หากคุณใช้ไฟล์ step outคำสั่งตัวควบคุมจะย้ายไปยังบรรทัดถัดไปนั่นคือ "int c = ob.addition (a, b);" ในบรรทัดนี้มีการเรียกใช้ฟังก์ชันaddition(int, int) ดังนั้นการเรียกใช้ฟังก์ชันจึงถูกข้ามไปและการดำเนินการที่เหลือจะดำเนินต่อไปโดยมีเครื่องหมายลูกศรดังที่แสดงด้านล่าง:

public class Add
{
   public int addition( int x, int y)
   {
      int z = x+y;
      return z;
   }
   public static void main( String ar[ ] )
   {
      int a = 5, b = 6;
      Add ob = new Add();
      -> int c = ob.addition(a,b);
      System.out.println("Add: "+c);
   }
}

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

เมื่อคลาสที่เพิ่มข้อยกเว้นกำลังทำงานภายใต้ JDB คลาสนั้นจะพ่นไฟล์ uncaughtข้อยกเว้น ข้อยกเว้นนั้นสามารถจัดการได้โดยใช้catch คำสั่ง

ตัวอย่าง

ให้เรายกตัวอย่างคลาส JdbException:

public class JdbException
{
   public static void main(String ar[]) throws Exception
   {
      int a=8, b=0;
      System.out.println("Welcome");
      System.out.println("Ex: "+(a/b));
   }
}

บันทึกไฟล์ด้านบนด้วยชื่อ JdbException.java คอมไพล์ไฟล์นี้โดยใช้คำสั่งต่อไปนี้:

\>javac JdbException.java

ทำตามขั้นตอนด้านล่างเพื่อจัดการกับข้อยกเว้น

ขั้นตอนที่ 1: เรียกใช้คลาส

คำสั่งต่อไปนี้รันคลาสที่ชื่อ JdbException ดังต่อไปนี้:

\>jdb JdbException
>run

นี้ JdbException คลาสมีข้อยกเว้นดังนั้นคุณจะเห็นผลลัพธ์ต่อไปนี้:

ขั้นตอนที่ 2: จับข้อยกเว้น

คำสั่งต่อไปนี้จับข้อยกเว้น:

mian[1] catch java.lang.ArithmeticException

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

Set all java.lang.ArithmeticException

ขั้นตอนที่ 3: ดำเนินการต่อ

คำสั่งต่อไปนี้ดำเนินการต่อไป ตอนนี้การจับจะจัดการกับข้อยกเว้นทางคณิตศาสตร์ดังนี้:

บทนี้อธิบายวิธีใช้ JDB ใน Eclipse ก่อนดำเนินการต่อคุณต้องติดตั้ง Eclipse Indigo ทำตามขั้นตอนด้านล่างเพื่อติดตั้ง Eclipse Indigo บนระบบของคุณ

ขั้นตอนที่ 1: ดาวน์โหลดและติดตั้ง Eclipse

คุณสามารถดาวน์โหลด Eclipse ได้จากลิงค์ต่อไปนี้: http://www.eclipse.org/downloads/packages/eclipse-ide-java-ee-developers/indigosr2

ขั้นตอนที่ 2: สร้างโครงการใหม่และชั้นเรียนใหม่

• สร้างโปรเจ็กต์ Java ใหม่โดยทำตามตัวเลือก File-> New -> Java project.
• ตั้งชื่อเป็น “sampledebug”.
• สร้างชั้นเรียนใหม่โดยคลิกขวาที่ไฟล์ samplebebug โครงการ.
• เลือก options ->new -> class
• ตั้งชื่อเป็น “Add.java”

Add.java

public class Add
{
   public int addition( int x, int y)
   {
      int z = x+y;
      return z;
   }
   public static void main( String ar[ ] )
   {
      int a = 5, b = 6;
      Add ob = new Add();
      int c = ob.addition(a,b);
      System.out.println("Add: "+c);
   }
}

ขั้นตอนที่ 3: เปิดมุมมองการดีบัก

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

บน Eclipse IDE ไปที่ Window -> Open perspective -> Debug. ตอนนี้คุณจะได้รับมุมมองการดีบักสำหรับโปรแกรม Add.java คุณจะเห็นหน้าต่างต่อไปนี้

ส่วนต่างๆในมุมมองการดีบัก

ส่วนต่างๆในมุมมองการดีบักมีดังนี้:

ส่วนการเข้ารหัส

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

1. ดับเบิลคลิกที่นี่ คุณสามารถตั้งค่าเบรกพอยต์สำหรับบรรทัดนี้

ส่วนเบรกพอยต์

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

สังเกตตัวเลือกต่อไปนี้ในภาพหน้าจอที่กำหนด:

1. ใช้กล่องกาเครื่องหมายทางด้านซ้ายเราสามารถเลือกหรือยกเลิกการเลือกเบรกพอยต์ ที่นี่เราใช้เบรกพอยต์หนึ่งอันคือเมธอด Add class-main ()

2. ไอคอนกากบาทเดี่ยว“ X” ใช้เพื่อลบเบรกพอยต์ที่เลือก

3. ไอคอนกากบาทคู่“ XX” ใช้เพื่อลบเบรกพอยต์ทั้งหมดในโค้ดของคุณ

4. ตัวชี้ลูกศรใช้เพื่อชี้ไปที่รหัสที่ใช้เบรกพอยต์ที่เลือก

ฟังก์ชันที่เหลือในส่วนเบรกพอยต์มีดังนี้:

• Hitcount: แสดงจำนวนครั้งที่ตัวควบคุมมาถึงจุดพักนี้ ใช้สำหรับตรรกะแบบวนซ้ำ

• Suspend thread : เราสามารถระงับเธรดปัจจุบันได้โดยการเลือก

• Suspend VM : เราสามารถระงับ VM ได้โดยการเลือก

ส่วนการแก้ปัญหา

ส่วนนี้ใช้สำหรับขั้นตอนการดีบัก ประกอบด้วยตัวเลือกที่ใช้ในการดีบัก

Start debugging : ทำตามคำแนะนำด้านล่างเพื่อเริ่มการดีบัก

คลิกขวาที่ไฟล์ code -> คลิก Debug as -> คลิก 1 Java application.

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

1. เราใช้เบรกพอยต์ในเมธอด Add class main () เมื่อเราเริ่มการดีบักไฟล์controller ติดอยู่ที่บรรทัดแรกของเมธอด main ()

2. มันถูกใช้เพื่อ Resumeขั้นตอนการดีบักและข้ามจุดพักปัจจุบัน มันทำงานคล้ายกับไฟล์cont คำสั่งในบรรทัดคำสั่ง JDB

3. ใช้เพื่อหยุดกระบวนการดีบัก

4. มันทำงานคล้ายกับไฟล์ step inกระบวนการในบรรทัดรับคำสั่ง JDB ใช้สำหรับการย้ายตัวควบคุมไปยังบรรทัดถัดไปกล่าวคือจุด“ 1” จะเลื่อนไปยังบรรทัดถัดไป

5. มันทำงานคล้ายกับไฟล์ step over กระบวนการในบรรทัดรับคำสั่ง JDB

6. ใช้เพื่อดูว่ามีการใช้เบรกพอยต์ในบรรทัดใด

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