分析 Java 源文件中的变量定义和使用情况

爱的叹息

515人浏览 · 2026-02-10 22:27:23

爱的叹息 · 2026-02-10 22:27:23 发布

分析 Java 源文件中的变量定义和使用情况
在这里插入图片描述

VariableAnalyzer

package com.burns.VariableAnalyzer1;

import com.github.javaparser.StaticJavaParser;
import com.github.javaparser.ast.CompilationUnit;
import com.github.javaparser.ast.body.*;
import com.github.javaparser.ast.expr.*;
import com.github.javaparser.ast.visitor.VoidVisitorAdapter;
import com.github.javaparser.ast.Node;

import java.io.File;
import java.io.FileNotFoundException;
import java.util.*;

public class VariableAnalyzer {

    // 存储变量信息的结构
    private static class VariableInfo {
        String name; // 变量名
        String scopeType; // 作用域类型：类变量 / 方法名
        String definitionLocation; // 定义位置
        Set<String> usageLocations; // 使用位置列表

        VariableInfo(String name, String scopeType, String definitionLocation) {
            this.name = name;
            this.scopeType = scopeType;
            this.definitionLocation = definitionLocation;
            this.usageLocations = new HashSet<>();
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder();
            sb.append("变量名：").append(name).append("\n");
            sb.append("变量定义所在类或方法：").append(scopeType).append("\n");
            sb.append("变量定义位置：").append(definitionLocation).append("\n");
            sb.append("变量使用位置：").append(String.join(", ", usageLocations)).append("\n");
            return sb.toString();
        }
    }

    private final Map<String, VariableInfo> variableMap = new LinkedHashMap<>();

    /**
     * 分析指定 Java 文件中的变量定义和使用情况
     *
     * @param filePath Java 文件路径
     */
    public void analyzeFile(String filePath) throws FileNotFoundException {
        File file = new File(filePath);
        CompilationUnit cu = StaticJavaParser.parse(file);

        // 清空之前的结果
        variableMap.clear();

        // 提取类变量
        cu.accept(new ClassVariableVisitor(), null);

        // 提取方法参数和局部变量
        cu.accept(new MethodVariableVisitor(), null);

        // 统计变量使用位置
        cu.accept(new UsageVisitor(), null);

        // 输出结果
        printResults();
    }

    /**
     * 打印变量分析结果
     */
    private void printResults() {
        System.out.println("变量分析结果：");
        for (VariableInfo info : variableMap.values()) {
            System.out.println(info);
        }
    }

    /**
     * 访问类变量（字段）
     */
    private class ClassVariableVisitor extends VoidVisitorAdapter<Void> {
        @Override
        public void visit(FieldDeclaration fd, Void arg) {
            super.visit(fd, arg);
            for (VariableDeclarator vd : fd.getVariables()) {
                String varName = vd.getNameAsString();
                String location = getLocation(fd);
                variableMap.put(varName, new VariableInfo(varName, "类变量", location));
            }
        }
    }

    /**
     * 访问方法参数和局部变量
     */
    private class MethodVariableVisitor extends VoidVisitorAdapter<Void> {
        @Override
        public void visit(MethodDeclaration md, Void arg) {
            super.visit(md, arg);

            // 处理方法参数
            for (Parameter param : md.getParameters()) {
                String paramName = param.getNameAsString();
                String location = getLocation(param);
                variableMap.put(paramName, new VariableInfo(paramName, md.getNameAsString(), location));
            }

            // 处理方法体内的局部变量
            md.accept(new LocalVariableVisitor(md.getNameAsString()), null);
        }
    }

    /**
     * 访问局部变量定义
     */
    private class LocalVariableVisitor extends VoidVisitorAdapter<Void> {
        private final String methodName;

        LocalVariableVisitor(String methodName) {
            this.methodName = methodName;
        }

        @Override
        public void visit(VariableDeclarationExpr vde, Void arg) {
            super.visit(vde, arg);
            for (VariableDeclarator vd : vde.getVariables()) {
                String varName = vd.getNameAsString();
                String location = getLocation(vde);
                variableMap.put(varName, new VariableInfo(varName, methodName, location));
            }
        }
    }

    /**
     * 统计变量使用位置
     */
    private class UsageVisitor extends VoidVisitorAdapter<Void> {
        @Override
        public void visit(NameExpr ne, Void arg) {
            super.visit(ne, arg);
            String varName = ne.getNameAsString();
            if (variableMap.containsKey(varName)) {
                String location = getLocation(ne);
                variableMap.get(varName).usageLocations.add(location);
            }
        }

        @Override
        public void visit(MethodCallExpr mce, Void arg) {
            super.visit(mce, arg);
            // 处理方法调用中的参数
            for (Expression expr : mce.getArguments()) {
                if (expr instanceof NameExpr) {
                    String varName = ((NameExpr) expr).getNameAsString();
                    if (variableMap.containsKey(varName)) {
                        String location = getLocation(expr);
                        variableMap.get(varName).usageLocations.add(location);
                    }
                }
            }
        }
    }

    /**
     * 获取节点的位置信息（行号）
     */
    private String getLocation(Node node) {
        return "第 " + node.getBegin().get().line + " 行";
    }

    /**
     * 主函数：测试工具类
     */
    public static void main(String[] args) {
        try {
            VariableAnalyzer analyzer = new VariableAnalyzer();
            analyzer.analyzeFile("D:\\workspaces\\idea_workspace\\algorithm\\java_algorithm_20250529\\src\\main\\java\\com\\burns\\VariableAnalyzer1\\Example.java"); // 替换为实际文件路径
        } catch (FileNotFoundException e) {
            System.err.println("文件未找到：" + e.getMessage());
        }
    }
}

Example

package com.burns.VariableAnalyzer1;

public class Example {
    private int classVar = 10;
    private static int staticVar = 30;

    public void method(int param,int param2) {
        int localVar = 20;
        System.out.println(classVar + localVar + param);
        anotherMethod(localVar);
    }

    public void anotherMethod(int value) {
        int x = 10;
        System.out.println(value);
    }
}