import com.github.javaparser.ast.expr.QualifiedNameExpr; //导入依赖的package包/类
public String getPrelude() {

        for (ImportDeclaration node : nodes) {

            try {
                if (node.isStatic()) {
                    if (node.isAsterisk()) {
                        importStatic(node.getName().toString());
                    } else {
                        QualifiedNameExpr fqn = (QualifiedNameExpr) node.getChildrenNodes().get(0);
                        importMethod(fqn.getQualifier().toString(), fqn.getName());
                    }
                } else if (node.isAsterisk()) {
                    importPackage(node.getName().toString());
                } else {
                    importClass(node.getName().toString());
                }
            } catch (ClassNotFoundException | NoSuchMethodException ex) {
                LOG.log(Level.WARNING, null, ex);
            }

        }

        return prelude.toString();

    }
 

import com.github.javaparser.ast.expr.QualifiedNameExpr; //导入依赖的package包/类
@Override
public void visit(final QualifiedNameExpr n, final Object arg) {
    printer.printLn("QualifiedNameExpr");
    printJavaComment(n.getComment(), arg);
    n.getQualifier().accept(this, arg);
    printer.print(".");
    printer.print(n.getName());

    printOrphanCommentsEnding(n);
}
 

import com.github.javaparser.ast.expr.QualifiedNameExpr; //导入依赖的package包/类
@Override
public JCTree visit(final QualifiedNameExpr n, final Object arg) {
    //ARG0: JCExpression selected
    JCExpression arg0 = (JCExpression) n.getQualifier().accept(this, arg);

    //ARG1: Name selector
    Name arg1 = names.fromString(n.getName());

    return new AJCFieldAccess(make.Select(arg0, arg1), ((n.getComment() != null) ? n.getComment().getContent() : null));
}
 

import com.github.javaparser.ast.expr.QualifiedNameExpr; //导入依赖的package包/类
@Override
public NameExpr asQualifiedNameExpr(NameExpr nameExpr) {
    if (nameExpr instanceof QualifiedNameExpr) {
        return nameExpr;
    } else return importDeclarations.stream()
            .filter(i -> i.getName().getName().equals(nameExpr.getName()))
            .map(i -> new QualifiedNameExpr(((QualifiedNameExpr) i.getName()).getQualifier(), nameExpr.getName()))
            .findFirst()
            .map(NameExpr.class::cast)
            .orElse(nameExpr);
}
 

import com.github.javaparser.ast.expr.QualifiedNameExpr; //导入依赖的package包/类
public static String toQualifiedNameString(final NameExpr nameExpr) {
    NameExpr pointer = nameExpr;
    final LinkedList<NameExpr> elements = new LinkedList<>();

    do {
        elements.push(pointer);
        if (pointer instanceof QualifiedNameExpr) {
            pointer = ((QualifiedNameExpr) pointer).getQualifier();
        } else {
            pointer = null;
        }
    } while (pointer != null);

    return elements.stream().map(NameExpr::getName).collect(joining("."));
}
 

import com.github.javaparser.ast.expr.QualifiedNameExpr; //导入依赖的package包/类
@Override public QualifiedNameExpr doMerge(QualifiedNameExpr first, QualifiedNameExpr second) {
  QualifiedNameExpr qne = new QualifiedNameExpr();

  qne.setName(first.getName());
  qne.setQualifier(mergeSingle(first.getQualifier(),second.getQualifier()));

  return qne;
}
 

import com.github.javaparser.ast.expr.QualifiedNameExpr; //导入依赖的package包/类
public String apply(Node node) {
    if (node instanceof NamedNode) {
        String name = ((NamedNode)node).getName();
        Node current = node;
        while (!(current instanceof CompilationUnit)) {
            current = current.getParentNode();
        }

        CompilationUnit compilationUnit = (CompilationUnit) current;

        for (ImportDeclaration importDecl : compilationUnit.getImports()) {
            NameExpr importExpr = importDecl.getName();
            if (importExpr instanceof QualifiedNameExpr) {
                QualifiedNameExpr qualifiedNameExpr = (QualifiedNameExpr) importExpr;
                String className = qualifiedNameExpr.getName();
                if (name.equals(className)) {
                    return qualifiedNameExpr.getQualifier().toString();
                }
            } else if (importDecl.getName().getName().endsWith(SEPARATOR + name)) {
                String importName = importDecl.getName().getName();
                return  importName.substring(0, importName.length() - name.length() -1);
            }
        }

       try {
           Class.forName(JAVA_LANG + "." + name);
           return JAVA_LANG;
       } catch (ClassNotFoundException ex) {
           return compilationUnit.getPackage().getPackageName();
       }
    }
    return null;
}
 

import com.github.javaparser.ast.expr.QualifiedNameExpr; //导入依赖的package包/类
/**
 * Converts the indicated {@link NameExpr} into a
 * {@link ClassOrInterfaceType}.
 * <p>
 * Note that no effort is made to manage imports etc.
 * 
 * @param nameExpr to convert (required)
 * @return the corresponding {@link ClassOrInterfaceType} (never null)
 */
public static ClassOrInterfaceType getClassOrInterfaceType(
        final NameExpr nameExpr) {
    Validate.notNull(nameExpr, "Java type required");
    if (nameExpr instanceof QualifiedNameExpr) {
        final QualifiedNameExpr qne = (QualifiedNameExpr) nameExpr;
        if (StringUtils.isNotBlank(qne.getQualifier().getName())) {
            return new ClassOrInterfaceType(qne.getQualifier().getName()
                    + "." + qne.getName());
        }
        return new ClassOrInterfaceType(qne.getName());
    }
    return new ClassOrInterfaceType(nameExpr.getName());
}
 

import com.github.javaparser.ast.expr.QualifiedNameExpr; //导入依赖的package包/类
/**
 * Looks up the import declaration applicable to the presented name
 * expression.
 * <p>
 * If a fully-qualified name is passed to this method, the corresponding
 * import will be evaluated for a complete match. If a simple name is passed
 * to this method, the corresponding import will be evaluated if its simple
 * name matches. This therefore reflects the normal Java semantics for using
 * simple type names that have been imported.
 * 
 * @param compilationUnitService the types in the compilation unit
 *            (required)
 * @param nameExpr the expression to locate an import for (which would
 *            generally be a {@link NameExpr} and thus not have a package
 *            identifier; required)
 * @return the relevant import, or null if there is no import for the
 *         expression
 */
private static ImportDeclaration getImportDeclarationFor(
        final CompilationUnitService compilationUnitService,
        final NameExpr nameExpr) {
    Validate.notNull(compilationUnitService,
            "Compilation unit services required");
    Validate.notNull(nameExpr, "Name expression required");

    final List<ImportDeclaration> imports = compilationUnitService
            .getImports();

    for (final ImportDeclaration candidate : imports) {
        final NameExpr candidateNameExpr = candidate.getName();
        if (!candidate.toString().contains("*")) {
            if(!(candidateNameExpr instanceof QualifiedNameExpr)) {
                System.out.println("Expected import '" + candidate
                    + "' to use a fully-qualified type name");
            }
        }
        if (nameExpr instanceof QualifiedNameExpr) {
            // User is asking for a fully-qualified name; let's see if there
            // is a full match
            if (isEqual(nameExpr, candidateNameExpr)) {
                return candidate;
            }
        }
        else {
            // User is not asking for a fully-qualified name, so let's do a
            // simple name comparison that discards the import's
            // qualified-name package
            if (candidateNameExpr.getName().equals(nameExpr.getName())) {
                return candidate;
            }
        }
    }
    return null;
}
 

import com.github.javaparser.ast.expr.QualifiedNameExpr; //导入依赖的package包/类
/**
 * Converts the presented class name into a name expression (either a
 * {@link NameExpr} or {@link QualifiedNameExpr} depending on whether a
 * package was presented).
 * 
 * @param className to convert (required; can be fully qualified or simple
 *            name only)
 * @return a compatible expression (never returns null)
 */
public static NameExpr getNameExpr(final String className) {
    Validate.notEmpty(className, "Class name required");
    if (className.contains(".")) {
        final int offset = className.lastIndexOf(".");
        final String packageName = className.substring(0, offset);
        final String typeName = className.substring(offset + 1);
        return new QualifiedNameExpr(new NameExpr(packageName), typeName);
    }
    return new NameExpr(className);
}
 

import com.github.javaparser.ast.expr.QualifiedNameExpr; //导入依赖的package包/类
/**
 * Looks up the import declaration applicable to the presented name
 * expression.
 * <p>
 * If a fully-qualified name is passed to this method, the corresponding
 * import will be evaluated for a complete match. If a simple name is passed
 * to this method, the corresponding import will be evaluated if its simple
 * name matches. This therefore reflects the normal Java semantics for using
 * simple type names that have been imported.
 *
 * @param compilationUnit the types in the compilation unit
 *            (required)
 * @param nameExpr the expression to locate an import for (which would
 *            generally be a {@link NameExpr} and thus not have a package
 *            identifier; required)
 * @return the relevant import, or null if there is no import for the
 *         expression
 */
public static ImportDeclaration getImportDeclarationFor(
    final CompilationUnit compilationUnit,
    final NameExpr nameExpr) {
    Validate.notNull(compilationUnit,
        "Compilation unit services required");
    Validate.notNull(nameExpr, "Name expression required");

    final List<ImportDeclaration> imports = compilationUnit
        .getImports();

    for (final ImportDeclaration candidate : imports) {
        final NameExpr candidateNameExpr = candidate.getName();
        if (!candidate.toString().contains("*")) {
            if(!(candidateNameExpr instanceof QualifiedNameExpr)) {
                System.out.println("Expected import '" + candidate
                    + "' to use a fully-qualified type name");
            }
        }
        if (nameExpr instanceof QualifiedNameExpr) {
            // User is asking for a fully-qualified name; let's see if there
            // is a full match
            if (NameUtil.isEqual(nameExpr, candidateNameExpr)) {
                return candidate;
            }
        }
        else {
            // User is not asking for a fully-qualified name, so let's do a
            // simple name comparison that discards the import's
            // qualified-name package
            if (candidateNameExpr.getName().equals(nameExpr.getName())) {
                return candidate;
            }
        }
    }
    return null;
}
 

import com.github.javaparser.ast.expr.QualifiedNameExpr; //导入依赖的package包/类
@Override public Boolean visit(final QualifiedNameExpr n1, final Node arg) {
	final QualifiedNameExpr n2 = (QualifiedNameExpr) arg;

	if (!nodeEquals(n1.getQualifier(), n2.getQualifier())) {
		return false;
	}

	if (!objEquals(n1.getName(), n2.getName())) {
		return false;
	}

	return true;
}
 

import com.github.javaparser.ast.expr.QualifiedNameExpr; //导入依赖的package包/类
@Override
public Node visit(QualifiedNameExpr _n, Object _arg) {
	NameExpr scope = cloneNodes(_n.getQualifier(), _arg);
	Comment comment = cloneNodes(_n.getComment(), _arg);

	QualifiedNameExpr r = new QualifiedNameExpr(
			_n.getRange(),
			scope, _n.getName()
	);
	r.setComment(comment);
	return r;
}
 

import com.github.javaparser.ast.expr.QualifiedNameExpr; //导入依赖的package包/类
@Nonnull
public static StringBuilder prepend(@Nonnull NameExpr nameExpr, @Nonnull StringBuilder buffy) {
    for (; ; ) {
        prependSeparatorIfNecessary('.', buffy).insert(0, nameExpr.getName());
        if (!QualifiedNameExpr.class.isInstance(nameExpr)) {
            return buffy;
        }
        nameExpr = QualifiedNameExpr.class.cast(nameExpr).getQualifier();
    }
}
 

import com.github.javaparser.ast.expr.QualifiedNameExpr; //导入依赖的package包/类
@Test
public void prependsQualifiedNameExpression() {
    QualifiedNameExpr qualifiedNameExpr =
            new QualifiedNameExpr(new QualifiedNameExpr(new NameExpr("de"), "is24"), "foo");
    StringBuilder buffy = Nodes.prepend(qualifiedNameExpr, new StringBuilder("Bar"));

    assertThat(buffy.toString(), is("de.is24.foo.Bar"));
}
 

import com.github.javaparser.ast.expr.QualifiedNameExpr; //导入依赖的package包/类
@Override
public void visit(QualifiedNameExpr n, Script arg) {
}
 

import com.github.javaparser.ast.expr.QualifiedNameExpr; //导入依赖的package包/类
@Override public Node visit(final QualifiedNameExpr n, final A arg) {
	n.setQualifier((NameExpr) n.getQualifier().accept(this, arg));
	return n;
}
 

import com.github.javaparser.ast.expr.QualifiedNameExpr; //导入依赖的package包/类
@Override public void visit(final QualifiedNameExpr n, final A arg) {
	visitComment(n.getComment(), arg);
	n.getQualifier().accept(this, arg);
}
 

import com.github.javaparser.ast.expr.QualifiedNameExpr; //导入依赖的package包/类
@Override public Node visit(final QualifiedNameExpr n, final A arg) {
	visitComment(n, arg);
	n.setQualifier((NameExpr) n.getQualifier().accept(this, arg));
	return n;
}
 

import com.github.javaparser.ast.expr.QualifiedNameExpr; //导入依赖的package包/类
@Override
public void visit(final QualifiedNameExpr n, final Context ctx) {
  visitNode(n, ctx);
  super.visit(n, ctx);

}