Einführung Dieser Artikel ist eine Aufzeichnung dessen, was ich für diejenigen verstehe, die Java studieren.
Die Java-Funktionen und Beschreibungsmethoden werden in der folgenden Liste beschrieben.
In diesem Artikel werde ich jedoch neben der Liste die Ausführung in der Befehlszeile beschreiben, die im Artikel ausgeführt wurde.
Als ich dieses Wort zum ersten Mal hörte, verstand ich es nicht, aber es scheint, dass die in der Eingabeaufforderung in Windows und im Terminal in Mac angezeigte Zeile als Befehlszeile bezeichnet wird. In diesem Artikel gehe ich davon aus, dass Java installiert ist, und versuche, Java über das Mac-Terminal und die Windows-Eingabeaufforderung auszuführen. Es gibt auch einen Artikel, den ich zuvor über den Aufbau von Umgebungen erwähnt habe, also hoffe ich, dass Sie darauf verweisen können. Java-Entwicklungsumgebung
Ich muss Code kompilieren, also habe ich Hello World erstellt.
class Test{
public static void main(String args[]){
System.out.println("Hello World!");
}
}
Dies ist die erste Hello World-Anweisung, die häufig beim Erlernen eines Programms angezeigt wird. Ein einfacher Code, der Hello World ausgibt.
Lassen Sie uns den obigen Code kompilieren. Beim Kompilieren wird der geschriebene Code übrigens einfach in einen Satz umgeschrieben, der von einem Computer gelesen werden kann.
$Java-Java-Datei, die Sie kompilieren möchten
Kompilieren Sie test.java mit dem obigen Code im Testordner.
test$ javac test.java
Dieser Befehl lädt test.java, überprüft die Klassen im Code und generiert eine Klassendatei. Übrigens, wenn die Java-Datei mehrere Klassen enthält, werden alle Klassendateien generiert.
class Test{
public static void main(String args[]){
System.out.println("Hello World!");
}
}
class Sample{}
class Mikan{}
Ich habe eine Beispielklasse und eine Mikan-Klasse erstellt, aber in ihnen ist nichts beschrieben. Kompilieren Sie diesen Code.
test$ javac test.java
Sie haben jetzt drei Klassendateien generiert: Test.class, Sample.class und Mikan.class.
$Name der Java-Klassendatei, die Sie ausführen möchten
Dieser Befehl wird in der Hauptmethode in der Klasse ausgeführt. Geben Sie das Obige an der Eingabeaufforderung (Terminal) ein.
test$ java Test
Ergebnis ist
Hello World!
Die Ausgabeanweisung in der Hauptmethode in der Testklasse wird angezeigt.
Das ist alles, um an der Eingabeaufforderung (Terminal) ausgeführt zu werden, aber eines ist zu beachten.
Da es innerhalb der Hauptmethode ausgeführt wird, tritt auch dann ein Fehler auf, wenn die Kompilierung ohne die Hauptmethode erfolgreich ist.
class Test{}
Ich kompiliere diesen Code, kann aber ohne Fehler eine Klassendatei (Test.class) generieren.
test$ javac test.java
Lassen Sie es uns mit der erstellten Datei ausführen.
test$ java Test
Ich habe einen Fehler erhalten, als ich es ausgeführt habe.
Error:Die Hauptmethode kann nicht in der Klasse Test gefunden werden. Definieren Sie die Hauptmethode wie folgt:
public static void main(String[] args)
Denken Sie daran, dass für die von Ihnen ausgeführte Klasse eine Hauptmethode erforderlich ist.
Sie können auch über die Befehlszeile debuggen. Um es einfach auszudrücken: Bei der Debug-Ausführung wird überprüft, wie das implementierte Programm funktioniert. Lassen Sie es uns tatsächlich in der Befehlszeile tun.
test.java
class Main{
int instans = 60;
static int global = 95;
static void debug(){
System.out.println();
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");
}
}
Kompilieren Sie die oben beschriebene Java-Datei, aber es gibt einige Dinge, die Sie beachten müssen, wenn Sie das Debug ausführen möchten.
$ javac -g test.java
Lassen Sie uns -g als Option zur Kompilierungszeit festlegen. Jetzt können Sie die integrierte JDK-Debug-Funktion namens jdb verwenden. Beginnen wir sofort mit jdb.
$ jdb Main
>
Sie können debuggen, indem Sie verschiedene Befehle in den obigen Pfeil eingeben. Zuerst können Sie jedoch nichts tun, es sei denn, Sie führen es aus. Geben Sie also den Befehl run ein. Jetzt funktioniert VM.
> run
VM gestartet:
Debug-Ausführung
main start
print()
main end
Mit dem Befehl run allein wird jdb jedoch nur durch Ausführen beendet. Setzen Sie daher im Voraus einen Haltepunkt. Ein Haltepunkt ist ein Ort, an dem die Operation während der Ausführung angehalten wird, und Sie können diesen Ort mit einem Befehl angeben.
> stop in Main.debug
Ich denke, dass der Befehlseingabestatus eingegeben wird, wenn die in der Hauptmethode ausgeführte Debug-Methode ausgeführt wird. Lassen Sie es uns tatsächlich ausführen.
> run
VM gestartet:Verzögerter Haltepunkt Main.Debug-Einstellungen
Haltepunkt treffen: "Faden=main", Main.debug(),Linie=8 bci=0
8 System.out.println();
main[1]
Dieser Status zeigt an, dass das Programm an dieser Stelle gestoppt ist. Verwenden Sie für einen genaueren Blick die Liste der Befehle zur Bestätigung des Ausführungsorts.
main[1] list
4 int instans = 60;
5 static int global = 95;
6
7 static void debug(){
8 => System.out.println();
9 System.out.println("Debug-Ausführung");
10 }
11
12 void print(){
13 System.out.println("print()");
Es wird angezeigt. Ich denke, es ist einfacher zu erkennen, dass es an der Ausgabe der Debug-Methode gestoppt ist.
Fahren wir mit dem Programm fort, das durch den obigen Code gestoppt wurde. Mit diesem Schritt können Sie den Code zeilenweise durchlaufen. Fahren wir mit dem oben Gesagten fort.
step
Schritt abgeschlossen: "Faden=main", Main.debug(),Linie=9 bci=6
9 System.out.println("Debug-Ausführung");
Die Schrittausführung wurde durchgeführt. Schauen Sie sich die Liste noch einmal an.
5 static int global = 95;
6
7 static void debug(){
8 System.out.println();
9 => System.out.println("Debug-Ausführung");
10 }
11
12 void print(){
13 System.out.println("print()");
14 }
Vor der Schrittausführung wurde es in der 8. Zeile angehalten, jetzt ist es die 9. Zeile. Dies bedeutet, dass Sie Zeile für Zeile fortfahren. Gehen wir weiter und zeigen die Liste an
step
>Debug-Ausführung
Durch schrittweises Arbeiten funktioniert die Ausgabeverarbeitung.
Überprüfen Sie die Liste, nachdem Sie den Schritt ausgeführt haben.
list
6
7 static void debug(){
8 System.out.println();
9 System.out.println("Debug-Ausführung");
10 => }
11
12 void print(){
13 System.out.println("print()");
14 }
15
Ich denke auch, dass es leicht zu verstehen ist, dass Sie den einzeiligen Code lesen.
Bisher haben wir die Befehle und Operationen der Schrittausführung eingeführt, aber von hier aus werden wir die Nützlichkeit der Schrittausführung erläutern.
Lassen Sie uns zunächst die Liste durchgehen, bis die Warteliste wie folgt lautet.
20 int x = 50;
21
22 String str = "Zeichentyp";
23
24 => Main m = new Main();
25
26 x = 100;
27
28 str = "Zeichentypkonvertierung";
29
Zu dem Zeitpunkt, zu dem die Verarbeitung bis zu diesem Punkt ausgeführt wird, werden Werte in die Variablen x bzw. str eingegeben. Ich weise nach diesem Code einen anderen Wert zu, aber während dieses Schritts können Sie den Wert der Variablen an dieser Stelle sehen.
Verwenden Sie den Befehl local, um die Werte lokaler Variablen anzuzeigen.
main[1] locals
Lokale Variablen:
x = 50
str = "Zeichentyp"
Wie Sie sehen können, wird der aktuelle Wert der lokalen Variablen angezeigt.
Wenn Sie mit diesem Code fortfahren, wird der Wert neu geschrieben. Lassen Sie uns also zunächst bis zum Ende der Zuweisung durchgehen.
26 x = 100;
27
28 str = "Zeichentypkonvertierung";
29
30 => m.print();
31
32 System.out.println("main end");
33 }
34 }
Zu diesem Zeitpunkt haben wir die Werte für x bzw. str ersetzt. Lassen Sie es uns noch einmal mit dem Befehl local überprüfen.
main[1] locals
Lokale Variablen:
x = 100
str = "Zeichentypkonvertierung"
m = instance of Main(id=422)
Die Werte wurden neu geschrieben, da die Änderungen der x- und str-Werte in der aktuellen Schrittausführungsphase funktionieren. Da die Variable m deklariert und die Instanz zugewiesen wird, wird auch die Variable m neu angezeigt.
Auf diese Weise können Sie den Status des Werts zu dem Zeitpunkt anzeigen, zu dem das Programm ausgeführt und angezeigt wird. Wenn Sie also den Vorgang überprüfen, können Sie jederzeit überprüfen, ob der von Ihnen beabsichtigte Wert enthalten ist.
Wenn Sie eine lokale Variable überprüfen möchten, können Sie übrigens auch den Inhalt von Instanzvariablen und statischen Variablen mit dem Befehl print überprüfen.
Lokale Variablen
main[1] print str
str = "Zeichentypkonvertierung"
Instanzvariable
main[1] print m.instans
m.instans = 60
statische Variable
main[1] print Main.global
Main.global = 95
In diesem Artikel habe ich versucht, Java beim Kompilieren, Ausführen und Debuggen an der Eingabeaufforderung (Terminal) schrittweise auszuführen. Sobald Sie Java installiert haben, können Sie dies tun. Probieren Sie es aus.
Ich denke jedoch, dass die in der Entwicklungsumgebung usw. installierten Tools einfacher zu verwenden sind als die Debug-Ausführung über die Befehlszeile. Weitere Informationen zum Ausführen des Debugs mit Eclipse finden Sie im folgenden Artikel.