Was ist JavaParser?

Wie der Name schon sagt, eine Bibliothek, die Java-Quellcode analysiert
Das Analyseergebnis der Quelle kann als abstrakter Syntaxbaum (AST) abgerufen werden, und auf das Analyseergebnis kann mit einer Methode wie dem Besuchermuster zugegriffen werden.
Beim Sprechen der Java-Quellanalysebibliothek gibt es eine Möglichkeit, Eclipse JDT zu verwenden [^ 1] --JDT ist hauptsächlich für Eclipse-Plug-Ins vorgesehen, während JavaParser ausschließlich für die Analyse der Java-Syntax vorgesehen ist.
Da die erforderliche Bibliothek ein Glas (ca. 800 KB) umfasst, ist die Installation einfach.
Es scheint Java 9 zu unterstützen
Da "Optional" für die API verwendet wird, kann es nur mit Java 8 oder höher verwendet werden.

Hello World ** Abhängigkeiten **

`build.gradle`


dependencies {
    compile 'com.github.javaparser:javaparser-core:3.3.0'
}

Implementierung

`Main.java`


package sample.javaparser;

import com.github.javaparser.JavaParser;
import com.github.javaparser.ast.CompilationUnit;

import java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Paths;

public class Main {
    public static void main(String[] args) {
        Path source = Paths.get("src/main/java/sample/javaparser/Main.java");
        try {
            CompilationUnit unit = JavaParser.parse(source);
            System.out.println("***********************************************");
            System.out.println(unit);
            System.out.println("***********************************************");
        } catch (IOException e) {
            e.printStackTrace(System.err);
        }
    }
}

** Ausführungsergebnis **

***********************************************
package sample.javaparser;

import com.github.javaparser.JavaParser;
import com.github.javaparser.ast.CompilationUnit;
import java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Paths;

public class Main {

    public static void main(String[] args) {
        Path source = Paths.get("src/main/java/sample/javaparser/Main.java");
        try {
            CompilationUnit unit = JavaParser.parse(source);
            System.out.println("***********************************************");
            System.out.println(unit);
            System.out.println("***********************************************");
        } catch (IOException e) {
            e.printStackTrace(System.err);
        }
    }
}

***********************************************

Erläuterung

Sie können das Parsen von Java-Quellcode mit der Methode parse () von JavaParser durchführen
Das Analyseergebnis wird als "CompilationUnit" zurückgegeben. --CompilationUnit erbt von der Node-Klasse

VoidVisitor Implementierung

`MyVoidVisitor.java`


package sample.javaparser;

import com.github.javaparser.ast.body.VariableDeclarator;
import com.github.javaparser.ast.visitor.VoidVisitorAdapter;

public class MyVoidVisitor extends VoidVisitorAdapter<String> {

    @Override
    public void visit(VariableDeclarator n, String arg) {
        System.out.println("n > " + n);
        System.out.println("arg > " + arg);
        super.visit(n, arg);
    }
}

`Main.java`


package sample.javaparser;

import com.github.javaparser.JavaParser;
import com.github.javaparser.ast.CompilationUnit;

import java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Paths;

public class Main {
    public static void main(String[] args) {
        Path source = Paths.get("src/main/java/sample/javaparser/Main.java");
        
        try {
            CompilationUnit unit = JavaParser.parse(source);
            
            unit.accept(new MyVoidVisitor(), "ARG!!");
            
        } catch (IOException e) {
            e.printStackTrace(System.err);
        }
    }
}

** Ausführungsergebnis **

n > source = Paths.get("src/main/java/sample/javaparser/Main.java")
arg > ARG!!
n > unit = JavaParser.parse(source)
arg > ARG!!

Erläuterung

`MyVoidVisitor.java`


import com.github.javaparser.ast.body.VariableDeclarator;
import com.github.javaparser.ast.visitor.VoidVisitorAdapter;

public class MyVoidVisitor extends VoidVisitorAdapter<String> {

    @Override
    public void visit(VariableDeclarator n, String arg) {
        System.out.println("n > " + n);
        System.out.println("arg > " + arg);
        super.visit(n, arg);
    }

Die VoidVisitor -Schnittstelle wird alsVisitor zum Durchlaufen des Syntaxbaums bereitgestellt.
In VoidVisitor werden etwas weniger als 100 Methoden für jeden Knotentyp als zurückgerufen deklariert.
Die Klasse "VoidVisitorAdapter" wird als Implementierung bereitgestellt, die all diese implementiert und die Knoten einfach rekursiv scannt.
Erben Sie dies und erstellen Sie Ihren eigenen "Besucher"
Überschreiben Sie die Methode, die den Knoten empfängt, den Sie nach Bedarf verarbeiten möchten, und führen Sie den Prozess aus.
Schließlich können Sie durch Aufrufen von "super.visit ()" weiter nach weiteren untergeordneten Knoten suchen.

`Main.java`


            CompilationUnit unit = JavaParser.parse(source);
            
            unit.accept(new MyVoidVisitor(), "ARG!!");

--Visitor kann verwendet werden, indem es anaccept ()der Klasse CompliationUnit` übergeben wird.

Die Methode "accept ()" wird in der Schnittstelle "Visitable" definiert und von "CompliationUnit" implementiert.
Übrigens gibt es auch eine Möglichkeit, den zu scannenden Knoten an die Methode "visit ()" von "VoidVisitor" zu übergeben, aber selbst wenn Sie "accept ()" verwenden, wird diese Methode "visit ()" doch aufgerufen und funktioniert. Wird dasselbe sein

`Compliation Unit akzeptieren()Methodenimplementierung`


    @Override
    public <A> void accept(VoidVisitor<A> v, A arg) {
        v.visit(this, arg); //★ Besucherbesuch stornieren()Wird so genannt wie es ist
    }

Wenn Sie einen Wert an das zweite Argument der Methode "accept ()" (und "visit ()") übergeben, arbeitet dieser Wert beim Durchlaufen des Knotens weiterhin zusammen.
Möglicherweise zum Verknüpfen von Daten und Verarbeiten von Delegierungszielobjekten, auf die Sie gemeinsam verweisen möchten?

GenericVisitor Implementierung

`MyGenericVisitor.java`


package sample.javaparser;

import com.github.javaparser.ast.body.VariableDeclarator;
import com.github.javaparser.ast.visitor.GenericVisitorAdapter;

public class MyGenericVisitor extends GenericVisitorAdapter<Integer, String> {
    
    @Override
    public Integer visit(VariableDeclarator n, String arg) {
        System.out.println(arg);
        System.out.println(n);
        super.visit(n, arg);
        return -1;
    }
}

`Main.java`


package sample.javaparser;

import com.github.javaparser.JavaParser;
import com.github.javaparser.ast.CompilationUnit;

import java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Paths;

public class Main {
    public static void main(String[] args) {
        Path source = Paths.get("src/main/java/sample/javaparser/Main.java");
        
        try {
            CompilationUnit unit = JavaParser.parse(source);
            
            int result = unit.accept(new MyGenericVisitor(), "ARG!!");
            System.out.println(result);
            
        } catch (IOException e) {
            e.printStackTrace(System.err);
        }
    }
}

** Ausführungsergebnis **

ARG!!
source = Paths.get("src/main/java/sample/javaparser/Main.java")
-1

Erläuterung

`MyGenericVisitor.java`


import com.github.javaparser.ast.body.VariableDeclarator;
import com.github.javaparser.ast.visitor.GenericVisitorAdapter;

public class MyGenericVisitor extends GenericVisitorAdapter<Integer, String> {
    
    @Override
    public Integer visit(VariableDeclarator n, String arg) {
        System.out.println(arg);
        System.out.println(n);
        super.visit(n, arg);
        return -1;
    }

--VoidVisitorsvisit ()hat keinen Rückgabewert, aber GenericVisitors visit () hat einen Rückgabewert.

Der GenericVisitorAdaptor, eine abstrakte Klasse, die GenericVisitor implementiert, ** unterbricht den Scan ** und ruft den Aufrufer auf, wenn die Methodevisit ()während des Scans einen anderen Wert als null zurückgibt. Gibt den zurückgegebenen Wert zurück
Das zweite Argument von "visit ()" wird genauso behandelt wie "VoidVisitor".

Knotentyp

Die im abstrakten Syntaxbaum enthaltenen Knoten erben von der Node-Klasse und haben die folgende Vererbungsbeziehung.

Node
┣━ArrayCreationLevel
┣━CatchClause
┣━CompilationUnit
┣━ImportDeclaration
┣━MemberValuePair
┣━ModuleDeclaration
┣━Name
┣━PackageDeclaration
┣━Parameter
┣━SimpleName
┣━VariableDeclarator
┃　
┣━BodyDeclaration
┃　┣━AnnotationMemberDeclaration
┃　┣━EnumConstantDeclaration
┃　┣━FieldDeclaration
┃　┣━InitializerDeclaration
┃　┣━CallableDeclaration
┃　┃　┣━ConstructorDeclaration
┃　┃　┗━MethodDeclaration
┃　┗━TypeDeclaration
┃　　　┣━AnnotationDeclaration
┃　　　┣━ClassOrInterfaceDeclaration
┃　　　┗━EnumDeclaration
┃　
┣━Comment
┃　┣━BlockComment
┃　┣━JavadocComment
┃　┗━LineComment
┃　
┣━Expression
┃　┣━ArrayAccessExpr
┃　┣━ArrayCreationExpr
┃　┣━ArrayInitializerExpr
┃　┣━AssignExpr
┃　┣━BinaryExpr
┃　┣━CastExpr
┃　┣━ClassExpr
┃　┣━ConditionalExpr
┃　┣━EnclosedExpr
┃　┣━FieldAccessExpr
┃　┣━InstanceOfExpr
┃　┣━LambdaExpr
┃　┣━MethodCallExpr
┃　┣━MethodReferenceExpr
┃　┣━NameExpr
┃　┣━ObjectCreationExpr
┃　┣━SuperExpr
┃　┣━ThisExpr
┃　┣━TypeExpr
┃　┣━UnaryExpr
┃　┣━VariableDeclarationExpr
┃　┣━AnnotationExpr
┃　┃　┣━MarkerAnnotationExpr
┃　┃　┣━NormalAnnotationExpr
┃　┃　┗━SingleMemberAnnotationExpr
┃　┗━LiteralExpr
┃　　　┣━BooleanLiteralExpr
┃　　　┣━NullLiteralExpr
┃　　　┗━LiteralStringValueExpr
┃　　　　　┣━CharLiteralExpr
┃　　　　　┣━DoubleLiteralExpr
┃　　　　　┣━IntegerLiteralExpr
┃　　　　　┣━LongLiteralExpr
┃　　　　　┗━StringLiteralExpr
┃　
┣━ModuleStmt
┃　┣━ModuleExportsStmt
┃　┣━ModuleOpensStmt
┃　┣━ModuleProvidesStmt
┃　┣━ModuleRequiresStmt
┃　┗━ModuleUsesStmt
┃　
┣━Statement
┃　┣━AssertStmt
┃　┣━BlockStmt
┃　┣━BreakStmt
┃　┣━ContinueStmt
┃　┣━DoStmt
┃　┣━EmptyStmt
┃　┣━ExplicitConstructorInvocationStmt
┃　┣━ExpressionStmt
┃　┣━ForeachStmt
┃　┣━ForStmt
┃　┣━IfStmt
┃　┣━LabeledStmt
┃　┣━LocalClassDeclarationStmt
┃　┣━ReturnStmt
┃　┣━SwitchEntryStmt
┃　┣━SwitchStmt
┃　┣━SynchronizedStmt
┃　┣━ThrowStmt
┃　┣━TryStmt
┃　┣━UnparsableStmt
┃　┗━WhileStmt
┃　
┗━Type
　┣━IntersectionType
　┣━PrimitiveType
　┣━UnionType
　┣━UnknownType
　┣━VoidType
　┣━WildcardType
　┗━ReferenceType
　　　┣━ArrayType
　　　┣━ClassOrInterfaceType
　　　┗━TypeParameter

Das Argument der Methode "visit ()" kann die letzte Klasse von diesen empfangen (es gibt keine Methode, die eine Klasse in der Mitte der Hierarchie empfängt, wie z. B. "Type" oder "ReferenceType").

Sie können sich vorstellen, welchem Element des Codes der Klassenname entspricht, aber es gibt einige Dinge, die Sie sich nicht vorstellen können. Nehmen Sie also nur diesen Teil und überprüfen Sie die Operation.

ArrayCreationLevel

Angabe der Anfangsgröße beim Deklarieren eines Arrays --int [] array = new int [10]; `` [10] Teil von`

MemberValuePair

Der Teil, in dem das Argument der Anmerkung durch den Namen angegeben wird --@ SomeAnnotation (value = "text") `` value = "text"part

AnnotationMemberDeclaration

@interface MyAnnotation {
    String value() default "text"; //Mit hier
    int number();                  //Ungefähr hier
}

ConditionalExpr

Drei-Term-Betreiber

EnclosedExpr

Die im Ausdruck verwendete () Gruppe

ExplicitConstructorInvocationStmt --this () undsuper (), die im Konstruktor explizit aufgerufen werden

UnionType

Der Teil der "catch" -Klausel, der mehrere Ausnahmetypen abfängt --} catch (OneException | OtherException e) {

UnknownType --Null Objekt, das einen Parameter darstellt, dessen Typdeklaration im Argument des Lambda-Ausdrucks weggelassen wird --Typ von line von .forEach (line-> ...)

MarkerAnnotationExpr, NormalAnnotationExpr, SingleMemberAnnotationExpr

MarkerAnnotationExpr
Ein Ort, an dem es ohne Verwendung von Attributen verwendet wird, z. B. "@ Override"
NormalAnnotationExpr
Ein Ort, an dem der Attributwert durch Angabe des Attributnamens festgelegt wird, z. B. "@SuppressWarnings (value =" unused ")"
SingleMemberAnnotationExpr
Ein Ort, an dem der Attributname für einen einzelnen "Wert" weggelassen wird, z. B. "@SuppressWarnings (" unbenutzt ")"

Diejenigen, die aufschauten, aber nicht verstanden

Name
SimpleName
UnparsableStmt
IntersectionType

Erhalten Sie Kommentare

Zeilenkommentare und Blockkommentare werden anders behandelt als andere normale Java-Syntax.

`ParseCommentSample.java`


package sample.javaparser;

// a comment

// b comment
public class ParseCommentSample {
    
    // c comment
    
    private String name; // d comment
}

Die zu analysierende Klasse. Versuchen Sie, diese Klasse zu analysieren, um Kommentare zu erhalten.

`Main.java`


package sample.javaparser;

import com.github.javaparser.JavaParser;
import com.github.javaparser.ast.CompilationUnit;
import com.github.javaparser.ast.comments.LineComment;
import com.github.javaparser.ast.visitor.VoidVisitorAdapter;

import java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Paths;

public class Main {
    public static void main(String[] args) {
        Path source = Paths.get("src/main/java/sample/javaparser/ParseCommentSample.java");
        
        try {
            CompilationUnit unit = JavaParser.parse(source);
            
            unit.accept(new VoidVisitorAdapter<Void>() {
                @Override
                public void visit(LineComment n, Void arg) {
                    System.out.println(n);
                    super.visit(n, arg);
                }
            }, null);
        } catch (IOException e) {
            e.printStackTrace(System.err);
        }
    }
}

** Ausführungsergebnis **

// d comment

// b comment

// ein Kommentar und // c Kommentar wurden ignoriert.

An den Knoten angehängte Kommentare und isolierte Kommentare

Kommentare werden in eine der folgenden Kategorien eingeteilt:

An den Knoten angehängte Kommentare
Isolierter Kommentar

Implementieren Sie VoidVisitor wie folgt und überprüfen Sie den Betrieb.

`Main.java`


package sample.javaparser;

import com.github.javaparser.JavaParser;
import com.github.javaparser.ast.CompilationUnit;
import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration;
import com.github.javaparser.ast.body.FieldDeclaration;
import com.github.javaparser.ast.visitor.VoidVisitorAdapter;

import java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Paths;

public class Main {
    public static void main(String[] args) {
        Path source = Paths.get("src/main/java/sample/javaparser/ParseCommentSample.java");
        
        try {
            CompilationUnit unit = JavaParser.parse(source);

            System.out.println("unit orphan comment > " + unit.getOrphanComments());

            unit.accept(new VoidVisitorAdapter<Void>() {
                @Override
                public void visit(ClassOrInterfaceDeclaration n, Void arg) {
                    System.out.println("<<ClassOrInterfaceDeclaration>>");
                    System.out.println("comment > " + n.getComment());
                    System.out.println("orphan comment > " + n.getOrphanComments());
                    super.visit(n, arg);
                }

                @Override
                public void visit(FieldDeclaration n, Void arg) {
                    System.out.println("<<FieldDeclaration>>");
                    System.out.println("comment > " + n.getComment());
                    super.visit(n, arg);
                }
            }, null);
        } catch (IOException e) {
            e.printStackTrace(System.err);
        }
    }
}

** Ausführungsergebnis **

unit orphan comment > [// a comment
]

<<ClassOrInterfaceDeclaration>>
comment > Optional[// b comment
]
orphan comment > [// c comment
]

<<FieldDeclaration>>
comment > Optional[// d comment
]

--Node hatgetComment ()und getOrphanComment (), Methoden zum Abrufen des dem Knoten zugeordneten Kommentars. --Wenn ein Kommentar an einen Knoten angrenzt, wird der Kommentar als an diesen Knoten angehängt behandelt.

In diesem Fall kann der Kommentar vom angehängten Knoten mit getComment () abgerufen werden.
Auf der anderen Seite werden Kommentare, die nicht mit einem Knoten verknüpft sind, als ** isolierte Kommentare ** behandelt.
Isolierte Kommentare können mit getOrphanComment () abgerufen werden
Die Methode "visit ()", die "LineComment" und "BlockComment" empfängt, wird nur für Kommentare aufgerufen, die an einen Knoten angehängt sind.
Wenn Sie verwaiste Kommentare verarbeiten möchten, können Sie getOrphanComment () oder getAllContainedComments () verwenden, um alle Kommentare abzurufen.

Übrigens, da einem Knoten nur ein Kommentar zugeordnet ist (getComment () gibt nur einen einzigen Kommentar zurück),

// a comment
String s = "xxx"; // b comment

Wenn es so aussieht, wird // b Kommentar als Kommentar behandelt, der der Variablendeklaration zugeordnet ist, und // ein Kommentar wird zu einem isolierten Kommentar (eine solche Regel).

Ausgabe als Zeichenkette

`ToStringSample.java`


package sample.javaparser;

/**
 * Javadoc
 */
public class ToStringSample {
    // line comment

    /**
     * Javadoc
     * @param age age
     * @param name name
     */
    public void method(
       int age,
       String name
    ) {
        /* block comment */
        System.out.println(
            "age=" + age +
            "name=" + name
        );
    }
}

Das Format zeichnet sich durch das absichtliche Einfügen von Zeilenumbrüchen aus.

`Main.java`


package sample.javaparser;

import com.github.javaparser.JavaParser;
import com.github.javaparser.ast.CompilationUnit;

import java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Paths;

public class Main {
    public static void main(String[] args) {
        Path source = Paths.get("src/main/java/sample/javaparser/ToStringSample.java");
        
        try {
            CompilationUnit unit = JavaParser.parse(source);
            System.out.println(unit);
        } catch (IOException e) {
            e.printStackTrace(System.err);
        }
    }
}

** Ausführungsergebnis **

package sample.javaparser;

/**
 * Javadoc
 */
public class ToStringSample {

    // line comment
    /**
     * Javadoc
     * @param age age
     * @param name name
     */
    public void method(int age, String name) {
        /* block comment */
        System.out.println("age=" + age + "name=" + name);
    }
}

Erläuterung

Wenn Sie einen Knoten toString () verwenden, ist dies normalerweise eine etwas formatierte Zeichenfolge anstelle des Eingabeformulars.
Außerdem werden Kommentare ausgegeben, ohne gelöscht zu werden.

Passen Sie die Formmethode an

`Main.java`


package sample.javaparser;

import com.github.javaparser.JavaParser;
import com.github.javaparser.ast.CompilationUnit;
import com.github.javaparser.printer.PrettyPrinterConfiguration;

import java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Paths;

public class Main {
    public static void main(String[] args) {
        Path source = Paths.get("src/main/java/sample/javaparser/ToStringSample.java");
        
        try {
            CompilationUnit unit = JavaParser.parse(source);
            PrettyPrinterConfiguration conf = new PrettyPrinterConfiguration();
            conf.setIndent("  ");
            conf.setPrintComments(false);
            conf.setPrintJavaDoc(false);
            conf.setEndOfLineCharacter("<Neue Zeile>\n");
            
            System.out.println(unit.toString(conf));
        } catch (IOException e) {
            e.printStackTrace(System.err);
        }
    }
}

** Ausführungsergebnis **

package sample.javaparser;<Neue Zeile>
<Neue Zeile>
public class ToStringSample {<Neue Zeile>
<Neue Zeile>
  public void method(int age, String name) {<Neue Zeile>
    System.out.println("age=" + age + "name=" + name);<Neue Zeile>
  }<Neue Zeile>
}<Neue Zeile>

Erläuterung

Indem Sie "PrettyPrinterConfiguration" an das Argument "toString ()" übergeben, können Sie die Formatierungsmethode angeben, wenn Sie den Syntaxbaum an eine Zeichenfolge zurückgeben.

Methode	Erläuterung	Standard
`setIndent(String)`	Geben Sie die Zeichenfolge an, die für einen Einzug verwendet werden soll	(4 Felder)
`setPrintComments(boolean)`	Geben Sie an, ob Kommentare angezeigt werden sollen	`true`
`setPrintJavaDoc(boolean)`	Geben Sie an, ob Javadoc angezeigt werden soll	`true`
`setEndOfLineCharacter(String)`	Geben Sie die Zeichenfolge an, die für Zeilenumbrüche verwendet werden soll	`System.getProperty("line.separator")`

Schreiben Sie den Syntaxbaum neu

`Main.java`


package sample.javaparser;

import com.github.javaparser.JavaParser;
import com.github.javaparser.ast.CompilationUnit;
import com.github.javaparser.ast.Modifier;
import com.github.javaparser.ast.body.ConstructorDeclaration;
import com.github.javaparser.ast.stmt.BlockStmt;

import java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Paths;

public class Main {
    public static void main(String[] args) {
        Path source = Paths.get("src/main/java/sample/javaparser/Main.java");
        
        try {
            CompilationUnit unit = JavaParser.parse(source);

            unit.getClassByName("Main").ifPresent(mainClass -> {
                // private final String textValue;Feld hinzufügen
                mainClass.addField(String.class, "textValue", Modifier.PRIVATE, Modifier.FINAL);
                
                //Konstruktor zum Initialisieren von textValue hinzugefügt
                ConstructorDeclaration constructor = mainClass.addConstructor(Modifier.PUBLIC);
                constructor.addParameter(String.class, "textValue"); //Konstruktorargument hinzufügen
                BlockStmt body = constructor.createBody(); //Konstruktorkörper hinzugefügt
                body.addStatement("this.textValue = textValue;");
            });

            System.out.println(unit);
        } catch (IOException e) {
            e.printStackTrace(System.err);
        }
    }
}

** Ausführungsergebnis **

package sample.javaparser;

import com.github.javaparser.JavaParser;
import com.github.javaparser.ast.CompilationUnit;
import com.github.javaparser.ast.Modifier;
import com.github.javaparser.ast.body.ConstructorDeclaration;
import com.github.javaparser.ast.stmt.BlockStmt;
import java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Paths;

public class Main {

    public static void main(String[] args) {
        Path source = Paths.get("src/main/java/sample/javaparser/Main.java");
        try {
            CompilationUnit unit = JavaParser.parse(source);
            unit.getClassByName("Main").ifPresent(mainClass -> {
                // private final String textValue;Feld hinzufügen
                mainClass.addField(String.class, "textValue", Modifier.PRIVATE, Modifier.FINAL);
                //Konstruktor zum Initialisieren von textValue hinzugefügt
                ConstructorDeclaration constructor = mainClass.addConstructor(Modifier.PUBLIC);
                //Konstruktorargument hinzufügen
                constructor.addParameter(String.class, "textValue");
                //Konstruktorkörper hinzugefügt
                BlockStmt body = constructor.createBody();
                body.addStatement("this.textValue = textValue;");
            });
            System.out.println(unit);
        } catch (IOException e) {
            e.printStackTrace(System.err);
        }
    }

    private final String textValue;

    public Main(String textValue) {
        this.textValue = textValue;
    }
}

--Node bietet eine Methode zum Umschreiben des Syntaxbaums in eine beliebige Form.

Die API ist leicht zu verstehen, wenn Sie sich den Methodenabschluss der IDE ansehen.
Es gibt auch eine Methode zum Entfernen wie "remove ()"

Referenz

Home · javaparser/javaparser Wiki

[^ 1]: JDT Java-Quellcode-Analyse - Qiita

Verwendungshinweise zu JavaParser

Was ist JavaParser?

build.gradle

Main.java

MyVoidVisitor.java

Main.java

MyVoidVisitor.java

Main.java

Compliation Unit akzeptieren()Methodenimplementierung

MyGenericVisitor.java

Main.java

MyGenericVisitor.java

Knotentyp

Diejenigen, die aufschauten, aber nicht verstanden

Erhalten Sie Kommentare

ParseCommentSample.java

Main.java

An den Knoten angehängte Kommentare und isolierte Kommentare

Main.java

Ausgabe als Zeichenkette

ToStringSample.java

Main.java

Passen Sie die Formmethode an

Main.java

Schreiben Sie den Syntaxbaum neu

Main.java

Referenz

`build.gradle`

`Main.java`

`MyVoidVisitor.java`

`Main.java`

`MyVoidVisitor.java`

`Main.java`

`Compliation Unit akzeptieren()Methodenimplementierung`

`MyGenericVisitor.java`

`Main.java`

`MyGenericVisitor.java`

`ParseCommentSample.java`

`Main.java`

`Main.java`

`ToStringSample.java`

`Main.java`

`Main.java`

`Main.java`