JDB - Kurzanleitung

Das Debuggen ist ein technisches Verfahren, um Fehler oder Defekte in einem Programm zu finden und zu entfernen und erwartete Ergebnisse zu erzielen. Das Debuggen umfasst das Testen und Überwachen. Es ist sehr komplex, wenn die Untereinheiten eines Programms eng miteinander verbunden sind. Wir können ein Programm mit den Debugger-Tools debuggen, die den vorgeschriebenen APIs folgen. Mit einem Debugger können Sie jeden Aspekt eines Codes durchgehen, alle Elemente überprüfen und gegebenenfalls Fehler entfernen.

Debugging-Techniken

Es gibt verschiedene Arten von Techniken zum Debuggen eines Java-Programms. Die alte Methode zum Debuggen besteht darin, am Ende jedes Segments print-Anweisungen zu verwenden, die die trace-Anweisungen auf der Konsole drucken. Schauen Sie sich den folgenden Code an.

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);
   }
}

Hier haben wir ein Programm, das zwei Zahlen hinzufügt und die Ausgabe druckt. Beachten Sie, dass wir bei jedem Schritt eine print-Anweisung eingeführt haben, die den Status des Programms auf der Konsole druckt. Dies ist der traditionelle Ansatz zum Debuggen eines Programms.

Darüber hinaus verfügen wir über erweiterte Konzepte, mit denen ein Programm debuggt werden kann, z.

• stepping
• Haltepunkte und
• Ausnahmen oder Überwachungspunkte.

Arten des Debuggens

Wir können ein Programm mit verschiedenen Methoden debuggen:

• Verwenden von Java-Bytecode (kompilierte Version von Java-Code)
• Verwenden von Kommentaren in den Programmen
• Klasse an ein laufendes Programm anhängen
• Remote-Debugging
• Debugging auf Anfrage
• Optimiertes Code-Debugging

Java-Debugger

Hier sind einige Beispiele für Java-Debugger, die auf dem Markt verfügbar sind:

• IDEs wie Eclipse, Netbeans usw. enthalten ihre eigenen Debugger (Visual Cafe, Borland, JBuilder).
• Standalone-Debugger-GUIs (wie Jikes, Java-Plattform-Debugger und JProbe)
• Befehlszeilen-Debugger (Suns JDB)
• Notepad- oder VI-gesteuert (Stack-Trace)

Dieses Tutorial behandelt die Verwendung des Befehlszeilen-Debuggers. jdb.

JDB

Der Java-Debugger (JDB) ist ein Tool für Java-Klassen zum Debuggen eines Programms in der Befehlszeile. Es implementiert die Java Platform Debugger-Architektur. Es hilft beim Erkennen und Beheben von Fehlern in einem Java-Programm mithilfe der Java Debug Interface (JDI).

JDB in JDK

Die folgende Architektur definiert die Rolle von JDB in JDK. Es enthält hauptsächlich drei Einheiten:

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

JVM TI

Es ist eine native Programmierschnittstelle, die von VM implementiert wird. Es bietet Möglichkeiten zum Überprüfen und Debuggen des Status der Anwendung, die auf der VM ausgeführt wird. Es ermöglicht einen Implementierer (VM Implementer), der einfach in die Debugging-Architektur integriert werden kann. Es wird auch ein Drittanbieter-Kanal namens aufgerufenJDWP Für die Kommunikation.

JDWP

Es definiert das Format der Informationen und die Anforderungen, die zwischen dem Debuggee-Prozess und dem Debugger-Frontend übertragen werden. Der Hauptzweck eines JDWP besteht darin, dem Debugger und dem Debugger die Kommunikation zu ermöglichen, wenn sie unter separaten VMs oder auf separaten Plattformen ausgeführt werden.

JDI

Es ist eine Java-Schnittstelle auf hoher Ebene, die als Front-End implementiert ist. Es definiert die Variableninformationen auf Benutzercodeebene. Es wird empfohlen, für die gesamte Debugger-Entwicklung eine JDI-Schicht zu verwenden. Es verwendet JDWP für die Kommunikation mit der Debuggee-JVM.

In diesem Kapitel wird erläutert, wie Sie JDB auf Windows- und Linux-basierten Systemen installieren. JDB ist ein Teil von JDK. Daher reicht die JDK-Installation aus, um JDB in der Eingabeaufforderung zu verwenden.

System Anforderungen

Hier sind die Systemanforderungen für die Installation von JDB:

JDK	Java SE 2 JDK 1.5 oder höher
Erinnerung	1 GB RAM (empfohlen)
Festplattenplatz	Keine Mindestanforderung
Betriebssystemversion	Windows XP oder höher, Linux

Führen Sie die folgenden einfachen Schritte aus, um JDB auf Ihrem System zu installieren.

Schritt 1: Überprüfen der Java-Installation

Zunächst muss das Java Software Development Kit (SDK) auf Ihrem System installiert sein. Um dies zu überprüfen, führen Sie je nach Plattform, auf der Sie arbeiten, einen der beiden Befehle aus.

Wenn die Java-Installation ordnungsgemäß durchgeführt wurde, werden die aktuelle Version und die Spezifikationen der Java-Installation angezeigt. Eine Beispielausgabe ist in der folgenden Tabelle angegeben.

Plattform	Befehl	Beispielausgabe
Windows	Öffnen Sie die Befehlskonsole und geben Sie Folgendes ein: \>java –version	Java-Version "1.7.0_60" Java (TM) SE-Laufzeitumgebung (Build 1.7.0_60-b19) Java Hotspot (TM) 64-Bit-Server-VM (Build 24.60-b09, gemischter Modus)
Linux	Öffnen Sie das Befehlsterminal und geben Sie Folgendes ein: $java –version	Java-Version "1.7.0_25" Öffnen Sie die JDK-Laufzeitumgebung (rhel-2.3.10.4.el6_4-x86_64). Öffnen Sie die JDK 64-Bit-Server-VM (Build 23.7-b01, gemischter Modus).

Wir gehen davon aus, dass die Leser dieses Tutorials Java SDK Version 1.7.0_60 auf ihrem System installiert haben. Falls Sie kein Java SDK haben, laden Sie die aktuelle Version über den Link herunterhttp://www.oracle.com/technetwork/java/javase/downloads/index.html und installieren Sie es.

Schritt 2: Einrichten der Java-Umgebung

Stellen Sie die Umgebungsvariable JAVA_HOME so ein, dass sie auf den Speicherort des Basisverzeichnisses verweist, in dem Java auf Ihrem Computer installiert ist. Zum Beispiel,

Plattform	Beschreibung
Windows	Setzen Sie JAVA_HOME auf C: \ ProgramFiles \ java \ jdk1.7.0_60
Linux	exportiere JAVA_HOME = / usr / local / java

Hängen Sie den vollständigen Pfad des Java-Compiler-Speicherorts an den Systempfad an.

Plattform	Beschreibung
Windows	Fügen Sie am Ende der Systemvariablen PATH die Zeichenfolge "C: \ Programme \ Java \ jdk1.7.0_60 \ bin" hinzu.
Linux	export PATH = $ PATH: $ JAVA_HOME / bin /

Führen Sie den Befehl aus java -version an der Eingabeaufforderung wie oben erläutert.

Schritt 3: Überprüfen der JDB-Installation

Überprüfen Sie die JDB-Version wie folgt:

Plattform	Befehl	Beispielausgabe
Windows	Öffnen Sie die Befehlskonsole und geben Sie Folgendes ein: \>jdb –version	Dies ist JDB Version 1.6 (Java SE Version 1.7.0_60)
Linux	Öffnen Sie das Befehlsterminal und geben Sie Folgendes ein: $jdb –version	Dies ist JDB Version 1.6 (Java SE Version 1.7.0_60)

In diesem Kapitel wird die Syntax des JDB-Befehls erläutert. Die Syntax enthält vier Abschnitte, die wie folgt aufgelistet sind:

• JDB
• option
• class
• arguments

Syntax

Die Syntax von JDB lautet wie folgt.

jdb [ options ] [ class ] [ arguments ]

JDB

Es ruft jdb.exe aus dem Java Development Kit auf.

Optionen

Dazu gehören die Befehlszeilenoptionen, mit denen ein Java-Programm auf effiziente Weise debuggt wird. Der JDB-Starter akzeptiert alle Optionen (wie -D, -classpath und -X) und einige zusätzliche erweiterte Optionen wie (-attach, -listen, -launch usw.).

Klasse

Dies ist der Klassenname, für den Sie Debugging-Vorgänge ausführen möchten.

Argumente

Dies sind die Eingabewerte, die einem Programm zur Laufzeit gegeben werden. Zum Beispiel arg [0], arg [1] zur main () -Methode.

In den oben genannten vier Segmenten sind Optionen die wichtigsten.

In diesem Kapitel werden die wichtigen Optionen beschrieben, die in JDB verfügbar sind und mit dem Befehl jdb als Argumente übergeben werden.

Optionen

Die folgende Tabelle enthält eine Liste der von JDB akzeptierten Optionen:

Name	Beschreibung
-Hilfe	Zeigt die Hilfemeldung an und listet die zugehörigen Optionen auf.
-Quellepfad	Verwendet den angegebenen Pfad für Quelldateien, wenn der Pfad nicht angegeben ist, und verwendet dann den Standardpfad ".", Dh das aktuelle Verzeichnis.
-anfügen	Hängt den Debugger an die laufende VM an, indem die Adresse der laufenden VM angegeben wird.
-Hör mal zu	Wartet darauf, dass die laufende VM über den Standardconnector eine Verbindung herstellt.
-listenany	Wartet darauf, dass die laufende VM eine Verbindung mit einer beliebigen Adresse herstellt.
-starten	Startet die debuggte Anwendung sofort beim Startjob.
-listconnectors	Listet die in dieser VM verfügbaren Konnektoren auf.
-verbinden	Stellt eine Verbindung zur Ziel-VM über einen benannten Connector mit aufgelisteten Argumentwerten her.
-dbgtrace	Druckt Informationen zum Debuggen von JDB.
-tclient	Führt die Anwendung in Java Hotspot VM (Client) aus.
-tserver	Führt die Anwendung in Java Hotspot VM (Server) aus.
-Joption	Übergibt die Option an die Java Virtual Machine, die zum Ausführen von JDB verwendet wird.

Verwenden von Optionen mit Befehlen

Die folgenden Befehle zeigen, wie einige der oben genannten Optionen verwendet werden:

-Hilfe

Der folgende Befehl ruft -help bei der Verwendung von JDB ab.

\>jdb -help

-anfügen

Der folgende Befehl hängt den Debugger an eine angegebene VM an (Portnummer: 1099).

\> jdb -attach 1099

-Hör mal zu

Mit dem folgenden Befehl wartet der JDB-Prozess, der auf der aktuellen VM ausgeführt wird, mithilfe des Standardconnectors (VM in 8008).

\>jdb -listen 8088

-listenany

Mit dem folgenden Befehl wartet der JDB-Prozess, der auf der aktuellen VM ausgeführt wird, über einen beliebigen Connector (VM im aktuell ausgeführten Port).

\>jdb –listenany

-tclient

Der folgende Befehl führt die Anwendung in Java Hotspot (™) VM (Client) aus.

\>jdb –tclient

-tserver

Der folgende Befehl führt die Anwendung in Java Hotspot (™) VM (Server) aus.

\>jdb -tserver

In diesem Kapitel wird beschrieben, wie Sie eine JDB-Sitzung auf verschiedene Arten starten. Der JDB-Start ist die häufig verwendete Technik zum Starten einer JDB-Sitzung.

Es gibt zwei verschiedene Möglichkeiten, eine JDB-Sitzung zu starten:

• Starten der JDB-Sitzung durch Hinzufügen einer Klasse (Hauptklassenname).
• Hinzufügen von JDB zur Ausführung von JVM zum Starten der Sitzung.

Starten Sie eine Sitzung, indem Sie eine Klasse hinzufügen

Der folgende Befehl startet eine JDB-Sitzung:

Syntax

\>jdb <classname>

Beispiel

Nehmen wir an, wir haben eine Klasse mit dem Namen TestClass. Der folgende Befehl startet eine JDB-Sitzung über die Testklasse.

\>jdb TestClass

Wenn Sie diesem Befehl folgen, wird eine neue Java-VM mit den angegebenen Parametern gestartet. Danach lädt es die Klasse und stoppt sie, bevor die erste Anweisung der Klasse ausgeführt wird.

Starten Sie eine Sitzung, indem Sie einer laufenden JVM JDB hinzufügen

Im Folgenden finden Sie die Syntax und das Beispiel zum Starten einer JDB-Sitzung durch Hinzufügen der JDB zu einer laufenden JVM.

Syntax

Die folgende Syntax gilt für JDB-Sitzungen:

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

Beispiel

Nehmen wir an, der Name der Hauptklasse lautet TestClassund JVM ermöglicht es der JDB, sie später zu verbinden. Mit dem folgenden Befehl können Sie JDB zu JVM hinzufügen:

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

Jetzt können Sie die JDB mit dem folgenden Befehl an die JVM anhängen:

\> jdb -attach jdbconn

Note: Hier das TestClass wird dem JDB-Befehl nicht hinzugefügt, da JDB mit der laufenden VM verbunden ist, anstatt eine neue zu starten.

Dieses Kapitel führt Sie durch die grundlegenden Befehle von JDB. Nach dem Starten einer Sitzung werden diese Befehle zum Debuggen eines Programms verwendet.

Das Folgende ist die Liste der Befehle, die zum Debuggen verwendet werden.

Name	Beschreibung
Hilfe oder?	Das wichtigste JDBBefehl; Es zeigt eine Liste der erkannten Befehle mit einer kurzen Beschreibung an.
Lauf	Nach dem Start JDB Wenn Sie die erforderlichen Haltepunkte festlegen, können Sie mit diesem Befehl die Ausführung starten und eine Anwendung debuggen.
Forts	Setzt die Ausführung der debuggten Anwendung nach einem Haltepunkt, einer Ausnahme oder einem Schritt fort.
drucken	Zeigt Java-Objekte und primitive Werte an.
Dump	Bei primitiven Werten ist dieser Befehl identisch mit print. Für Objekte wird der aktuelle Wert jedes im Objekt definierten Felds gedruckt. Statische und Instanzfelder sind enthalten.
Fäden	Listet die aktuell ausgeführten Threads auf.
Faden	Wählt einen Thread als aktuellen Thread aus.
wo	Gibt den Stapel des aktuellen Threads aus.

Beispiel

Nehmen wir an, wir haben eine Beispielklasse namens Add für die folgenden Beispiele:

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);
   }
}

Kompilieren Sie diese Klasse Add.java mit dem folgenden Befehl:

\>javac Add.java

Lauf

Dieser Befehl führt die Hauptklassendatei aus, die JDB zum Debuggen hinzugefügt wird. Führen Sie die folgenden Befehle aus, um die Add-Klasse auszuführen.

\>jdb Add
initializing jdb …
>run

Wenn Sie diese Befehle ausführen, wird die folgende Ausgabe angezeigt:

In diesem Kapitel wird das Konzept der Haltepunkte und das Festlegen von Haltepunkten in einem Programm erläutert. Ein Haltepunkt führt beim Debuggen zu einem expliziten Stopp oder einer Pause bei der Ausführung eines Programms in einer bestimmten Codezeile. Es ist nützlich, sich bei der Ausführung Kenntnisse über Variablen im Programm anzueignen.

Syntax

Der folgende Befehl richtet einen Haltepunkt an einer bestimmten Zeilennummer ein:

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

Der folgende Befehl legt einen Haltepunkt für eine bestimmte Methode oder eine bestimmte Variable fest:

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

Beispiel

Das folgende Beispiel zeigt, wie Sie einen Haltepunkt in einer Klasse einrichten.

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);
   }
}

Speichern Sie die obige Datei als Add.java. Kompilieren Sie diese Datei mit dem folgenden Befehl:

\>javac Add.java

Debuggen

Nehmen wir ein Beispiel für das Debuggen. Hier starten wir den Debugging-Prozess, indem wir einen Haltepunkt für main () einrichten. Im Folgenden sind die Schritte aufgeführt, die beim Debuggen ausgeführt werden müssen:

Schritt 1: Starten Sie eine JDB-Sitzung

Der folgende Befehl startet eine JDB-Sitzung in der Add-Klasse zum Debuggen:

\> jdb Add

Schritt 2: Legen Sie einen Haltepunkt fest

Der folgende Befehl richtet einen Haltepunkt für die main () -Methode der Add-Klasse ein.

> stop in Add.main

Wenn der Haltepunkt erfolgreich gesetzt wurde, wird die folgende Ausgabe angezeigt:

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

Schritt 3: Starten Sie das Debuggen

Der folgende Befehl startet die Ausführung der Klasse Add:

> run Add

Wenn Sie diesen Befehl ausführen, wird die folgende Ausgabe angezeigt. In dieser Ausgabe finden Sie, dass die Ausführung an der Haltepunktposition stoppt, dh an der main () - Funktion.

Die Ausführung stoppt in der ersten Zeile der Hauptmethode, dh bei "int a = 5, b = 6;" oder Zeile Nr. 11 im Code. Sie können diese Informationen in der Ausgabe beobachten.

Schritt 4: Setzen Sie die Ausführung fort

Der folgende Befehl setzt die Programmausführung fort:

cont

Sie erhalten den verbleibenden Ausführungsteil und die Ausgabe wie folgt:

> Add:11
The application exited
\>

In diesem Kapitel wird erläutert, wie Sie das Konzept des Steppens beim Debuggen eines Programms verwenden. Stepping ist die Debugger-Funktion, mit der Sie den Code ausführen können, indem Sie zeilenweise durchlaufen. Auf diese Weise können Sie jede Zeile des Codes untersuchen, um sicherzustellen, dass sie sich wie beabsichtigt verhält.

Die folgenden Befehle werden im Schrittprozess verwendet:

• Schritt: Schritte zur nächsten Ausführungszeile
• Liste: Untersucht, wo Sie sich im Code befinden
• cont: setzt die verbleibende Ausführung fort

Beispiel

Im folgenden Beispiel wird die Add-Klasse verwendet, die wir im vorherigen Kapitel verwendet haben:

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);
   }
}

Speichern Sie die obige Datei als Add.java. Kompilieren Sie diese Datei mit dem folgenden Befehl:

\>javac Add.java

Nehmen wir an, dass der Haltepunkt für die main () -Methode der Add-Klasse festgelegt ist. Die folgenden Schritte zeigen, wie Sie Schritte in der Add-Klasse anwenden.

Schritt 1: Führen Sie den Job aus

Der folgende Befehl startet die Ausführung der Klasse Add.

> run Add

Wenn Sie diesen Befehl ausführen, wird die folgende Ausgabe angezeigt. In dieser Ausgabe können Sie feststellen, dass die Ausführung an der Haltepunktposition, dh an der main () -Methode, stoppt.

Die Ausführung stoppt in der ersten Zeile der Hauptmethode, dh bei "int a = 5, b = 6;" oder Zeile Nr. 11 im Code. Sie können diese Informationen in der Ausgabe beobachten.

Schritt 2: Schritt durch den Code

Der folgende Befehl führt die Ausführung zur nächsten Zeile.

main[1] step

Nun geht die Ausführung zu Zeile Nr. 12 über. 12. Sie sehen die folgende Ausgabe.

Schritt 3: Listen Sie den Code auf

Der folgende Befehl listet den Code auf:

main[1] list

Sie erhalten die folgende Ausgabe. Mit dem Befehl List werden Sie über die Zeile im Code informiert, bis zu der die Programmsteuerung gelangt ist. Beachten Sie die Pfeilmarkierung => im folgenden Screenshot, die die aktuelle Position der Programmsteuerung zeigt.

Schritt 4: Setzen Sie die Ausführung fort

Der folgende Befehl führt den Code weiter aus:

main[1] cont

Dieser Befehl führt die Ausführung der verbleibenden Codezeilen weiter aus. Die Ausgabe ist wie folgt:

> Add:11
The application exited
\>

Im Allgemeinen gibt es drei Arten von Schritten:

• Hineinsteigen
• Schritt über
• Aussteigen

Hineinsteigen

Mit diesem Befehl können Sie zur nächsten Codezeile wechseln. Wenn die nächste Zeile des Codes ein Funktionsaufruf ist, tritt er in die Funktion ein, indem die Steuerung in der obersten Zeile der Funktion angesteuert wird.

Im folgenden Code definiert die Pfeilmarkierung den Controller im Code.

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);
   }
}

Wenn Sie die verwenden step intoBefehl bewegt sich die Steuerung zur nächsten Zeile, dh "int c = ob.addition (a, b);". In dieser Zeile befindet sich ein Funktionsaufrufaddition(int, int) Daher bewegt sich der Controller mit der Pfeilmarkierung in die oberste Zeile der Additionsfunktion, wie unten gezeigt:

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);
   }
}

Schritt über

Step Over führt auch die nächste Zeile aus. Wenn es sich bei der nächsten Zeile jedoch um einen Funktionsaufruf handelt, wird diese Funktion im Hintergrund ausgeführt und das Ergebnis zurückgegeben.

Nehmen wir ein Beispiel. Im folgenden Code definiert die Pfeilmarkierung das Steuerelement im Code.

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);
   }
}

Wenn Sie die verwenden step overBefehl bewegt sich die Steuerung zur nächsten Zeile, dh "int c = ob.addition (a, b);". In dieser Zeile gibt es einen Funktionsaufrufaddition(int, int) Daher erfolgt die Funktionsausführung im Hintergrund und das Ergebnis wird wie unten gezeigt mit der Pfeilmarkierung in die aktuelle Zeile zurückgegeben:

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);
   }
}

Aussteigen

Step Out führt die nächste Zeile aus. Wenn es sich bei der nächsten Zeile um einen Funktionsaufruf handelt, wird dieser übersprungen und die Funktionsausführung mit den verbleibenden Zeilen des Codes fortgesetzt.

Nehmen wir ein Beispiel. Im folgenden Code definiert die Pfeilmarkierung den Controller im Code.

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);
   }
}

Wenn Sie die verwenden step outBefehl bewegt sich die Steuerung zur nächsten Zeile, dh "int c = ob.addition (a, b);". In dieser Zeile gibt es einen Funktionsaufrufaddition(int, int) Daher wird die Funktionsausführung übersprungen und die verbleibende Ausführung wird mit der Pfeilmarkierung fortgesetzt, wie unten gezeigt:

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);
   }
}

In diesem Kapitel wird erläutert, wie Sie die Ausnahmeklasse mit JDB behandeln. Im Allgemeinen druckt die VM immer dann, wenn ein Programm eine Ausnahme ohne catch-Anweisung auslöst, die Ausnahmezeile, die Ursache der Ausnahme und wird beendet. Wenn die Ausnahme mit einer catch-Anweisung ausgelöst wurde, wird die Ausnahme von der catch-Anweisung behandelt. Hier druckt die VM die Ausgabe mit der Ursache der Ausnahme.

Wenn die Klasse, die die Ausnahme auslöst, unter JDB ausgeführt wird, wird auch die ausgelöst uncaughtAusnahme. Diese Ausnahme kann mit dem behandelt werdencatch Befehl.

Beispiel

Nehmen wir ein Beispiel für die Klasse 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));
   }
}

Speichern Sie die obige Datei unter dem Namen JdbException.java. Kompilieren Sie diese Datei mit dem folgenden Befehl:

\>javac JdbException.java

Führen Sie die folgenden Schritte aus, um die Ausnahme zu behandeln.

Schritt 1: Führen Sie die Klasse aus

Der folgende Befehl führt die benannte Klasse aus JdbException wie folgt:

\>jdb JdbException
>run

Diese JdbException Klasse enthält eine Ausnahme, daher wird die folgende Ausgabe angezeigt:

Schritt 2: Fangen Sie die Ausnahme

Der folgende Befehl fängt die Ausnahme ab:

mian[1] catch java.lang.ArithmeticException

Sie erhalten folgende Ausgabe:

Set all java.lang.ArithmeticException

Schritt 3: Ausführung fortsetzen

Der folgende Befehl setzt die Ausführung fort. Jetzt behandelt der catch die arithmetische Ausnahme wie folgt:

In diesem Kapitel wird die Verwendung von JDB in Eclipse erläutert. Bevor Sie fortfahren, müssen Sie Eclipse Indigo installieren. Führen Sie die folgenden Schritte aus, um Eclipse Indigo auf Ihrem System zu installieren.

Schritt 1: Laden Sie Eclipse herunter und installieren Sie es

Sie können Eclipse über den folgenden Link herunterladen: http://www.eclipse.org/downloads/packages/eclipse-ide-java-ee-developers/indigosr2

Schritt 2: Erstellen Sie ein neues Projekt und eine neue Klasse

• Erstellen Sie ein neues Java-Projekt, indem Sie den Optionen folgen File-> New -> Java project.
• Nennen Sie es als “sampledebug”.
• Erstellen Sie eine neue Klasse, indem Sie mit der rechten Maustaste auf klicken samplebebug Projekt.
• Wählen options ->new -> class
• Nennen Sie es als “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);
   }
}

Schritt 3: Öffnen Sie die Debug-Perspektive

Befolgen Sie die nachstehenden Anweisungen, um die Debug-Perspektive zu öffnen.

Gehen Sie in der Eclipse-IDE zu Window -> Open perspective -> Debug. Jetzt erhalten Sie die Debug-Perspektive für das Programm Add.java. Sie sehen das folgende Fenster.

Abschnitte in der Debug-Perspektive

Die Abschnitte in der Debug-Perspektive lauten wie folgt:

Codierungsabschnitt

In diesem Abschnitt wird Java-Code angezeigt. Es ist der Code, den Sie debuggen möchten, dhAdd.java. Hier können wir einen Haltepunkt auf einer Linie hinzufügen, indem wir vor der Linie doppelklicken. Sie finden die blaue Blase mit einem Pfeilsymbol, um den Haltepunkt dieser Linie anzuzeigen. Siehe folgenden Screenshot; Sie finden den ausgewählten Bereich mit einem roten Kreis, der auf „1“ zeigt.

1. Doppelklicken Sie hier. Sie können den Haltepunkt für diese Zeile festlegen.

Haltepunktabschnitt

Dieser Abschnitt definiert die Liste der Haltepunkte, die auf den Programmcode gesetzt sind. Hier können wir die Haltepunkte hinzufügen, löschen, finden und verwalten. Der folgende Screenshot zeigt den Haltepunktabschnitt.

Beachten Sie die folgenden Optionen im angegebenen Screenshot:

1. Mit dem Kontrollkästchen links können wir einen Haltepunkt auswählen oder die Auswahl aufheben. Hier verwenden wir einen Haltepunkt, dh die Methode add class-main ().

2. Das einzelne Kreuzsymbol „X“ wird verwendet, um den ausgewählten Haltepunkt zu löschen.

3. Das Doppelkreuzsymbol „XX“ wird verwendet, um alle Haltepunkte in Ihrem Code zu löschen.

4. Der Pfeilzeiger zeigt auf den Code, auf den der ausgewählte Haltepunkt angewendet wird.

Die verbleibenden Funktionen im Haltepunktabschnitt sind wie folgt:

• Hitcount: Zeigt an, wie oft das Steuerelement diesen Haltepunkt erreicht. Es wird für die rekursive Logik verwendet.

• Suspend thread : Wir können den aktuellen Thread anhalten, indem wir ihn auswählen.

• Suspend VM : Wir können die VM anhalten, indem wir sie auswählen.

Debug-Bereich

Dieser Abschnitt wird für den Debugging-Prozess verwendet. Es enthält Optionen, die beim Debuggen verwendet werden.

Start debugging : Befolgen Sie die nachstehenden Anweisungen, um mit dem Debuggen zu beginnen.

Klicken Sie mit der rechten Maustaste auf code -> klicken Debug as -> klicken 1 Java application.

Der Debugging-Vorgang beginnt wie im folgenden Screenshot gezeigt. Es enthält einige ausgewählte Optionen, die durch numerische Ziffern hervorgehoben werden.

1. Wir wenden einen Haltepunkt auf die Methode add class main () an. Wenn wir mit dem Debuggen beginnen, wird diecontroller bleibt in der ersten Zeile der main () -Methode stecken.

2. Es ist daran gewöhnt Resumeden Debugging-Prozess und überspringen Sie den aktuellen Haltepunkt. Es funktioniert ähnlich wie dascont Befehl in der JDB-Befehlszeile.

3. Es wird verwendet, um den Debugging-Prozess zu stoppen.

4. Es funktioniert ähnlich wie das step inProzess in der JDB-Befehlszeile. Es wird verwendet, um das Steuerelement in die nächste Zeile zu verschieben, dh Punkt „1“ wird in die nächste Zeile verschoben.

5. Es funktioniert ähnlich wie das step over Prozess in der JDB-Befehlszeile.

6. Es wird verwendet, um zu sehen, auf welcher Zeile der Haltepunkt angewendet wird.

Befolgen Sie die angegebenen Schritte und Abschnitte, um Ihren Code in der Eclipse-IDE zu debuggen. Standardmäßig enthält jede IDE diesen Debugging-Prozess.