IDE (Eclipse) Debug-Ausführung, Schrittausführung (Java)

Einführung

Dieser Artikel ist eine Aufzeichnung dessen, was ich für diejenigen verstehe, die derzeit Java studieren.

In vielen Fällen wird Java-Code in einer integrierten Entwicklungsumgebung debuggt und ausgeführt, und der Vorgang wird durch schrittweise Ausführung bestätigt. Daher werde ich die Reihe der Schritte beschreiben.

Installieren Sie Eclipse

Installieren Sie Eclipse, das derzeit kostenlos in einer integrierten Java-Entwicklungsumgebung verwendet werden kann. Sie können es unter dem folgenden Link herunterladen.

https://mergedoc.osdn.jp/

Wählen Sie zu diesem Zeitpunkt die neueste Version von Eclipse 2020 aus.

Dann erscheint der Bildschirm des folgenden Bildes. Dieses Mal werde ich es entsprechend meiner Umgebung installieren. Da es sich um eine 64-Bit-CPU auf einem Mac handelt und eine Java-Umgebung erforderlich ist, wählen Sie den roten Rahmen unten aus.

Sie werden zur Download-Seite weitergeleitet und der Download startet automatisch. Öffnen Sie nach dem Herunterladen die Datei und verschieben Sie sie in die Anwendung.

Erstellen Sie eine Klasse für die Debug-Ausführung

Sie haben es jetzt auf Ihrem Mac installiert. Beginnen wir sofort. Dann wird ein Bildschirm wie das Bild angezeigt. Wählen Sie also Java-Projekt erstellen.

Wenn Sie Erstellen auswählen, wird der Bildbildschirm angezeigt. Dieses Mal möchte ich die Java-Datei verschieben und das Debuggen ausführen, also nur den Projektnamen eingeben und abschließen.

Wenn Sie fertig sind, wird Ihr Projekt erstellt. Erstellen Sie also eine Klasse innerhalb des Projekts. Klicken Sie mit der rechten Maustaste und wählen Sie Neu, Klasse, um den Erstellungsbildschirm anzuzeigen.

Wenn der Erstellungsbildschirm angezeigt wird, nennen Sie ihn Main und überprüfen Sie, ob der öffentliche statische void main (String args []) abgeschlossen ist.

Nachdem die Klasse erstellt wurde, geben Sie den folgenden Code in den Eclipse-Editor ein.

public class Main{
    int instans = 60;
    static int global = 95;

    static void debug(){
        System.out.println("Debug-Ausführung");
    }

    void print(){
        System.out.println("print()");
    }

    public static void main(String args[]){
        Main.debug();
        System.out.println("main start");

        int x = 50;

        String str = "Zeichentyp";

        Main m = new Main();

        x = 100;

        str = "Zeichentypkonvertierung";

        m.print();

        System.out.println("main end");
    }
}

Lassen Sie uns diesen Code debuggen und sehen, wie er funktioniert.

Haltepunkt

Von hier aus können Sie die Debug-Ausführung starten. Um die Debug-Ausführung auszuführen, müssen Sie jedoch zuerst den Speicherort angeben, an dem Sie das Programm stoppen möchten. Das nennt man einen Haltepunkt. Lassen Sie uns tatsächlich einen Haltepunkt in Eclipse setzen.

System.out.println("main start");

Setzen Sie diesmal einen Haltepunkt an der oben genannten Stelle. Klicken Sie mit der rechten Maustaste auf die linke Seite der Anzahl der Codezeilen oben im Eclipse-Editor, um das Menü aufzurufen und Haltepunkt umschalten auszuwählen.

Da Sie das Debuggen mit dieser Einstellung ausführen können, wählen Sie die Fehlermarkierung oben links in Eclipse aus. Hier beginnt der Debug-Lauf.

Dadurch wird die Debug-Funktion gestartet. Und die Verarbeitung wird an dem zuvor festgelegten Haltepunkt gestoppt. Daher wird die Ausgabe der "Debug-Ausführung", die vor dem Haltepunkt ausgeführt wird, ausgegeben, und das unten stehende f "Hauptende" wird nicht ausgegeben. Daher können Sie sehen, dass der Prozess an dem Haltepunkt zwischen den beiden Prozessen gestoppt wird.

Schrittausführung

Bis zu diesem Punkt haben wir die Verarbeitung gestoppt, aber lassen Sie uns eine Schrittausführung durchführen, die die Verarbeitung zeilenweise vorantreibt. Klicken Sie in der Fortsetzung des obigen Abschnitts auf die Schaltfläche zum Übersteigen.

Nach dem Klicken wird der gestoppte Prozess in einer Zeile ausgeführt und der ausgewählte Status wird in der nächsten Zeile angezeigt. Haltepunkt

System.out.println("main start");

Da eine Zeile durch schrittweise Ausführung ausgeführt wurde, wird der Hauptstart in der Ausgabespalte angezeigt.

Nachdem Sie nun ein Bild der Schrittausführung haben, das sich Zeile für Zeile bewegt, drücken wir zweimal die Schritt-über-Taste, um fortzufahren. Auf der rechten Seite des Editors befindet sich eine Liste mit Variablen, der Inhalt wurde jedoch aktualisiert.

Durch zweimaliges Ausführen der Schrittausführung werden die Variablen definiert und initialisiert.

int x = 50;
String str = "Zeichentyp";

Durch Übergeben dieser beiden Prozesse kann der Wert der aktuell gehaltenen Variablen angezeigt werden. Klicken Sie noch dreimal auf die Stepover-Schaltfläche, um fortzufahren.

Es gibt einen Prozess, bei dem die Werte der Variablen x und str durch dreimaliges Ausführen der Schrittausführung aktualisiert werden.

x = 100;
str = "Zeichentypkonvertierung";

Daher wurde der aktuelle Wert der Variablenliste aktualisiert.

Übrigens wird die Variable m in der Verarbeitung zwischen ihnen definiert und die generierte Instanz zugewiesen.

Main m = new Main();

Die Hauptklasse verfügt über eine Instanzvariable instans, sodass Sie sehen können, dass sie auch definiert ist. Klicken Sie in der Variablenliste auf den Rechtspfeil des Variablennamens m.

Sie können die Instanzvariablen auch wie folgt überprüfen. Übrigens wird die statische Variable nicht angezeigt, da die statische Variable ein unabhängiges Element ist und die Variable m es nicht hat, so dass sie nicht angezeigt wird.

Am Ende

In diesem Artikel haben wir das Verfahren zum Ausführen der Debug-Ausführung in der IDE und zum zeilenweisen Überprüfen der Operation auf wichtige Schrittausführungen beschrieben.

Da Sie den Status des Werts zu dem Zeitpunkt sehen können, zu dem das Programm während der Ausführung überwacht wird, können Sie jederzeit überprüfen, ob der von Ihnen beabsichtigte Wert bei der Überprüfung des Vorgangs eingegeben wurde. Integrieren Sie daher die Debug-Ausführung Wie wäre es, es zu versuchen?