当前位置：文江博客话题详情

“找不到符号”是什么意思？或“无法解析符号”错误是什么意思？

发布于 2025-01-10 16:49:23 字数 170 浏览 0 评论 0原文

请解释以下有关“找不到符号”、“无法解析符号”或“找不到符号”错误（Java 中）的信息：

它们是什么意思？
哪些因素会导致它们？
程序员如何修复它们？

这个问题旨在对 Java 中的这些常见编译错误进行全面的问答。

原文

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

月亮坠入山谷 2025-01-17 16:49:23

0. 这些错误之间有什么区别吗？

并不真地。 “找不到符号”、“无法解析符号”和“找不到符号”都意味着同一件事。（不同的Java编译器是由不同的人编写的，不同的人用不同的措辞来表达同一件事。）

1. “找不到符号”错误是什么意思？

首先，这是一个编译错误¹。这意味着您的 Java 源代码中存在问题，或者您的编译方式存在问题。

Java 源代码由以下部分组成：

关键字：如 class、while 等。
文字：如 true、false、42、'X' 和 “嗨妈妈！”< /代码>。
运算符和其他非字母数字标记：例如 +、=、{ 等。
标识符：如Reader、i、toString、processEquibalancedElephants等。
注释和空白。

“找不到符号”错误与标识符有关。编译代码时，编译器需要计算出代码中每个标识符的含义。

“找不到符号”错误意味着编译器无法执行此操作。您的代码似乎引用了编译器无法理解的内容。

2. 什么会导致“找不到符号”错误？

作为第一顺序，只有一个原因。编译器查看了应该定义标识符的所有位置，但找不到定义。这可能是由多种原因造成的。常见的如下：

对于一般标识符：
- 也许您的名字拼写错误；即，StringBiulder 而不是 StringBuilder。 Java 不能也不会尝试弥补错误的拼写或输入错误。
- 也许你弄错了；即 stringBuilder 而不是 StringBuilder。所有 Java 标识符都区分大小写。
- 也许您使用下划线的方式不当；即，mystring 和 my_string 是不同的。（如果你坚持 Java 风格规则，你将在很大程度上避免这个错误......）
- 也许您正在尝试使用“在其他地方”声明的内容；即在与您隐式告诉编译器查看的上下文不同的上下文中。（不同的类？不同的范围？不同的包？不同的代码库？）
对于应该引用变量的标识符：
- 也许您忘记声明变量。
- 也许变量声明在您尝试使用它时超出了范围。（参见下面的示例）
对于应该是方法或字段名称的标识符：
- 也许您正在尝试引用未在父/祖先类或接口中声明的继承方法或字段。
- 也许您正在尝试引用您正在使用的类型中不存在（即尚未声明）的方法或字段；例如，"rope".push()²。
- 也许您正在尝试将方法用作字段，反之亦然；例如 "rope".length 或 someArray.length()。
- 也许您错误地操作了数组而不是数组元素；例如，
```
 字符串字符串[] = ...
    if (strings.charAt(3)) { ... }
    // 也许应该是 'strings[0].charAt(3)'
```
对于应该是类名的标识符：
- 也许您忘记导入该类。
- 也许您使用了“星号”导入，但该类未在您导入的任何包中定义。
- 也许您忘记了一个new，如下所示：
```
 String s = String(); // 应该是 'new String()'
```
- 也许您正在尝试导入或以其他方式使用已在默认包中声明的类；即，没有 package 语句的类所在的位置。
  提示：了解包。您应该只对由一个类组成的简单应用程序使用默认包...或者至少由一个 Java 源文件组成。
对于类型或实例似乎不具有您期望它具有的成员（例如方法或字段）的情况：
- 也许您已经声明了一个嵌套类或泛型参数，隐藏您想要使用的类型。
- 也许您正在隐藏静态变量或实例变量。
- 也许您导入了错误的类型；例如，由于 IDE 完成或自动更正可能会建议 java.awt.List 而不是 java.util.List。
- 也许您使用（编译）了错误版本的 API。
- 也许您忘记将对象转换为适当的子类。
- 也许您已将变量的类型声明为您要查找的成员的超类型。

问题通常是上述问题的组合。例如，也许您“明星”导入了 java.io.*，然后尝试使用 Files 类...它位于 java.nio而不是java.io。或者，也许您打算编写 File ...，它是 java.io 中的一个类。

以下示例说明了不正确的变量作用域如何导致“找不到符号”错误：

List<String> strings = ...

for (int i = 0; i < strings.size(); i++) {
    if (strings.get(i).equalsIgnoreCase("fnord")) {
        break;
    }
}
if (i < strings.size()) {
    ...
}

这将为 if 语句中的 i 提供“找不到符号”错误。尽管我们之前声明了 i，但该声明仅for 语句及其主体范围。 if 语句中对 i 的引用看不到 i 的声明。它超出范围。

（此处适当的更正可能是将 if 语句移至循环内部，或在循环开始之前声明 i。）

下面是一个令人困惑的示例，其中拼写错误会导致看似莫名其妙的“找不到符号”错误：

for (int i = 0; i < 100; i++); {
    System.out.println("i is " + i);
}

这将在 println 调用中给出编译错误，指出无法找到 i。但是（我听到你说）我确实宣布了！

问题在于 { 之前的分号 ( ; )。 Java 语言语法将上下文中的分号定义为空语句。然后，空语句将成为 for 循环的主体。因此，该代码实际上意味着：

for (int i = 0; i < 100; i++);

// The previous and following are separate statements!!

{
    System.out.println("i is " + i);
}

{ ... } 块不是 for 循环的主体，因此之前的 ifor 语句中的 > 超出了块中的范围。

这是由拼写错误引起的“找不到符号”错误的另一个示例。

int tmp = ...
int res = tmp(a + b);

尽管有前面的声明，tmp(...) 表达式中的 tmp 是错误的。编译器将查找名为 tmp 的方法，但找不到。前面声明的 tmp 位于变量的命名空间中，而不是方法的命名空间中。

在我遇到的例子中，程序员实际上遗漏了一个运算符。他的意思是这样写的：

int res = tmp * (a + b);

如果从命令行编译，编译器可能找不到符号还有另一个原因。您可能只是忘记编译或重新编译其他一些类。例如，如果您有类 Foo 和 Bar，其中 Foo 使用 Bar。如果您从未编译过 Bar 并且运行 javac Foo.java，您很容易发现编译器找不到符号 Bar 。简单的答案是将 Foo 和 Bar 一起编译；例如，javac Foo.java Bar.java 或javac *.java。或者最好还是使用 Java 构建工具；例如，Ant、Maven、Gradle 和很快。

还有一些其他更模糊的原因......我将在下面讨论。

3. 如何修复这些错误？

一般来说，您首先要找出导致编译错误的原因。

查看文件中由编译错误消息指示的行。
确定错误消息所谈论的是哪个符号。
弄清楚编译器为什么说找不到该符号；见上文！

然后你思考你的代码应该说什么。最后，您确定需要对源代码进行哪些修正才能实现您想要的功能。

请注意，并非每个“更正”都是正确的。考虑一下：

for (int i = 1; i < 10; i++) {
    for (j = 1; j < 10; j++) {
        ...
    }
}

假设编译器对 j 说“找不到符号”。有很多方法可以“修复”这个问题：

我可以将内部 for 更改为 for (int j = 1; j < 10; j++) - 可能是正确的。
我可以在内部 for 循环或外部 for 循环之前添加一个 for j 声明 - 可能是正确的。
我可以在内部 for 循环中将 j 更改为 i - 可能是错误的！
等等。

关键是您需要了解您的代码正在尝试做什么，以便找到正确的修复方法。

4. 不明原因

以下是一些“找不到符号”似乎令人费解的情况……除非您仔细观察。

不正确的依赖项：如果您使用的是管理构建路径和项目依赖项的 IDE 或构建工具，则您可能在依赖项方面犯了错误；例如，遗漏了依赖项，或选择了错误的版本。如果您使用构建工具（Ant、Maven、Gradle 等），请检查项目的构建文件。如果您使用的是 IDE，请检查项目的构建路径配置。
找不到符号“var”：您可能正在尝试使用较旧的编译器或更旧的编译器来编译使用局部变量类型推断（即 var 声明）的源代码--source 级别。 var 是在 Java 10 中引入的。检查您的 JDK 版本和构建文件，以及（如果在 IDE 中发生这种情况）IDE 设置。
您没有编译/重新编译：有时，新的 Java 程序员不了解 Java 工具链的工作原理，或者没有实现可重复的“构建过程”；例如使用 IDE、Ant、Maven、Gradle 等。在这种情况下，程序员最终可能会穷追不舍地寻找一个虚幻的错误，而这些错误实际上是由于未正确重新编译代码等造成的。
另一个示例是当您使用 (Java 9+) java SomeClass.java 编译和运行类时。如果该类依赖于您尚未编译（或重新编译）的另一个类，则您可能会收到涉及第二类的“无法解析符号”错误。其他源文件不会自动编译。 java 命令的新“编译并运行”模式不适用于运行具有多个源代码文件的程序。
早期构建问题：早期构建可能会失败，导致 JAR 文件缺少类。如果您使用构建工具，通常会注意到此类失败。然而，如果您从其他人那里获取 JAR 文件，您就依赖于它们的正确构建并注意到错误。如果您怀疑这一点，请使用 tar -tvf 列出可疑 JAR 文件的内容。
IDE 问题：人们报告过他们的 IDE 出现混乱并且 IDE 中的编译器无法找到存在的类的情况......或者相反的情况。
- 如果 IDE 配置了错误的 JDK 版本，则可能会发生这种情况。
- 如果 IDE 的缓存与文件系统不同步，则可能会发生这种情况。有一些 IDE 特定的方法可以解决这个问题。
- 这可能是 IDE 错误。例如，@Joel Costigliola 描述了 Eclipse 无法正确处理 Maven“测试”树的场景：查看此答案。（显然这个特定的错误很久以前就被修复了。）
Android 问题：当您为 Android 编程时，您遇到与 R< 相关的“找不到符号”错误/code>，请注意 R 符号是由 context.xml 文件定义的。检查您的 context.xml 文件是否正确且位于正确的位置，以及是否已生成/编译相应的 R 类文件。请注意，Java 符号区分大小写，因此相应的 XML id 也区分大小写。
Android 上的其他符号错误可能是由于前面提到的原因造成的；例如，缺少或不正确的依赖项、不正确的包名称、特定 API 版本中不存在的方法或字段、拼写/输入错误等等。
隐藏系统类：我见过编译器抱怨 substring 是未知符号的情况，如下所示
```
字符串 s = ...
字符串 s1 = s.substring(1);
```
事实证明，程序员创建了他们自己的 String 版本，并且他的类版本没有定义 substring 方法。我见过人们使用 System、Scanner 和其他类来执行此操作。
教训：不要定义与公共库类同名的自己的类！
该问题也可以通过使用完全限定名称来解决。例如，在上面的示例中，程序员可以编写：
```
java.lang.String s = ...
java.lang.String s1 = s.substring(1);
```
同形文字：如果您对源文件使用 UTF-8 编码，则可能有标识符看起来相同，但实际上不同，因为它们包含同形文字。请参阅此页面了解更多信息。
您可以通过限制自己使用 ASCII 或 Latin-1 作为源文件编码，并使用 Java \uxxxx 转义其他字符来避免这种情况。

^{1 - 如果您确实在运行时异常或错误消息中看到此情况，则说明您已将 IDE 配置为运行带有编译错误的代码，或者您的应用程序正在生成和编译代码..在运行时。
2 - 土木工程的三个基本原则：水不往上流，木板往上流侧面更坚固，你无法推动绳子。}

0. Is there any difference between these errors?

Not really. "Cannot find symbol", "Cannot resolve symbol" and "Symbol not found" all mean the same thing. (Different Java compilers are written by different people, and different people use different phraseology to say the same thing.)

1. What does a "Cannot find symbol" error mean?

Firstly, it is a compilation error¹. It means that either there is a problem in your Java source code, or there is a problem in the way that you are compiling it.

Your Java source code consists of the following things:

Keywords: like class, while, and so on.
Literals: like true, false, 42, 'X' and "Hi mum!".
Operators and other non-alphanumeric tokens: like +, =, {, and so on.
Identifiers: like Reader, i, toString, processEquibalancedElephants, and so on.
Comments and whitespace.

A "Cannot find symbol" error is about the identifiers. When your code is compiled, the compiler needs to work out what each and every identifier in your code means.

A "Cannot find symbol" error means that the compiler cannot do this. Your code appears to be referring to something that the compiler doesn't understand.

2. What can cause a "Cannot find symbol" error?

As a first order, there is only one cause. The compiler looked in all of the places where the identifier should be defined, and it couldn't find the definition. This could be caused by a number of things. The common ones are as follows:

For identifiers in general:
- Perhaps you spelled the name incorrectly; i.e., StringBiulder instead of StringBuilder. Java cannot and will not attempt to compensate for bad spelling or typing errors.
- Perhaps you got the case wrong; i.e. stringBuilder instead of StringBuilder. All Java identifiers are case sensitive.
- Perhaps you used underscores inappropriately; i.e., mystring and my_string are different. (If you stick to the Java style rules, you will be largely protected from this mistake...)
- Perhaps you are trying to use something that was declared "somewhere else"; i.e. in a different context to where you have implicitly told the compiler to look. (A different class? A different scope? A different package? A different code-base?)
For identifiers that should refer to variables:
- Perhaps you forgot to declare the variable.
- Perhaps the variable declaration is out of scope at the point you tried to use it. (See example below)
For identifiers that should be method or field names:
- Perhaps you are trying to refer to an inherited method or field that wasn't declared in the parent / ancestor classes or interfaces.
- Perhaps you are trying to refer to a method or field that does not exist (i.e., has not been declared) in the type you are using; e.g., "rope".push()².
- Perhaps you are trying to use a method as a field, or vice versa; e.g. "rope".length or someArray.length().
- Perhaps you are mistakenly operating on an array rather than array element; e.g.,
```
    String strings[] = ...
    if (strings.charAt(3)) { ... }
    // Maybe that should be 'strings[0].charAt(3)'
```
For identifiers that should be class names:
- Perhaps you forgot to import the class.
- Perhaps you used "star" imports, but the class isn't defined in any of the packages that you imported.
- Perhaps you forgot a new as in:
```
    String s = String();  // Should be 'new String()'
```
- Perhaps you are trying to import or otherwise use a class that has been declared in the default package; i.e., the one where classes with no package statements go.
  Hint: learn about packages. You should only use the default package for simple applications that consist of one class ... or at a stretch, one Java source file.
For cases where type or instance doesn't appear to have the member (e.g., method or field) you were expecting it to have:
- Perhaps you have declared a nested class or a generic parameter that shadows the type you were meaning to use.
- Perhaps you are shadowing a static or instance variable.
- Perhaps you imported the wrong type; e.g., due to IDE completion or auto-correction may have suggested java.awt.List rather than java.util.List.
- Perhaps you are using (compiling against) the wrong version of an API.
- Perhaps you forgot to cast your object to an appropriate subclass.
- Perhaps you have declared the variable's type to be a supertype of the one with the member you are looking for.

The problem is often a combination of the above. For example, maybe you "star" imported java.io.* and then tried to use the Files class ... which is in java.nio not java.io. Or maybe you meant to write File ... which is a class in java.io.

Here is an example of how incorrect variable scoping can lead to a "Cannot find symbol" error:

List<String> strings = ...

for (int i = 0; i < strings.size(); i++) {
    if (strings.get(i).equalsIgnoreCase("fnord")) {
        break;
    }
}
if (i < strings.size()) {
    ...
}

This will give a "Cannot find symbol" error for i in the if statement. Though we previously declared i, that declaration is only in scope for the for statement and its body. The reference to i in the if statement cannot see that declaration of i. It is out of scope.

(An appropriate correction here might be to move the if statement inside the loop, or to declare i before the start of the loop.)

Here is an example that causes puzzlement where a typo leads to a seemingly inexplicable "Cannot find symbol" error:

for (int i = 0; i < 100; i++); {
    System.out.println("i is " + i);
}

This will give you a compilation error in the println call saying that i cannot be found. But (I hear you say) I did declare it!

The problem is the sneaky semicolon ( ; ) before the {. The Java language syntax defines a semicolon in that context to be an empty statement. The empty statement then becomes the body of the for loop. So that code actually means this:

for (int i = 0; i < 100; i++);

// The previous and following are separate statements!!

{
    System.out.println("i is " + i);
}

The { ... } block is NOT the body of the for loop, and therefore the previous declaration of i in the for statement is out of scope in the block.

Here is another example of "Cannot find symbol" error that is caused by a typo.

int tmp = ...
int res = tmp(a + b);

Despite the previous declaration, the tmp in the tmp(...) expression is erroneous. The compiler will look for a method called tmp, and won't find one. The previously declared tmp is in the namespace for variables, not the namespace for methods.

In the example I came across, the programmer had actually left out an operator. What he meant to write was this:

int res = tmp * (a + b);

There is another reason why the compiler might not find a symbol if you are compiling from the command line. You might simply have forgotten to compile or recompile some other class. For example, if you have classes Foo and Bar where Foo uses Bar. If you have never compiled Bar and you run javac Foo.java, you are liable to find that the compiler can't find the symbol Bar. The simple answer is to compile Foo and Bar together; e.g., javac Foo.java Bar.java or javac *.java. Or better still use a Java build tool; e.g., Ant, Maven, Gradle and so on.

There are some other more obscure causes too ... which I will deal with below.

3. How do I fix these errors?

Generally speaking, you start out by figuring out what caused the compilation error.

Look at the line in the file indicated by the compilation error message.
Identify which symbol that the error message is talking about.
Figure out why the compiler is saying that it cannot find the symbol; see above!

Then you think about what your code is supposed to be saying. Then finally you work out what correction you need to make to your source code to do what you want.

Note that not every "correction" is correct. Consider this:

for (int i = 1; i < 10; i++) {
    for (j = 1; j < 10; j++) {
        ...
    }
}

Suppose that the compiler says "Cannot find symbol" for j. There are many ways I could "fix" that:

I could change the inner for to for (int j = 1; j < 10; j++) - probably correct.
I could add a declaration for j before the inner for loop, or the outer for loop - possibly correct.
I could change j to i in the inner for loop - probably wrong!
and so on.

The point is that you need to understand what your code is trying to do in order to find the right fix.

4. Obscure causes

Here are a couple of cases where the "Cannot find symbol" is seemingly inexplicable ... until you look closer.

Incorrect dependencies: If you are using an IDE or a build tool that manages the build path and project dependencies, you may have made a mistake with the dependencies; e.g., left out a dependency, or selected the wrong version. If you are using a build tool (Ant, Maven, Gradle, etc), check the project's build file. If you are using an IDE, check the project's build path configuration.
Cannot find symbol 'var': You are probably trying to compile source code that uses local variable type inference (i.e. a var declaration) with an older compiler or older --source level. The var was introduced in Java 10. Check your JDK version and your build files, and (if this occurs in an IDE), the IDE settings.
You are not compiling / recompiling: It sometimes happens that new Java programmers don't understand how the Java tool chain works, or haven't implemented a repeatable "build process"; e.g. using an IDE, Ant, Maven, Gradle and so on. In such a situation, the programmer can end up chasing his tail looking for an illusory error that is actually caused by not recompiling the code properly, and the like.
Another example of this is when you use (Java 9+) java SomeClass.java to compile and run a class. If the class depends on another class that you haven't compiled (or recompiled), you are liable to get "Cannot resolve symbol" errors referring to the 2nd class. The other source file(s) are not automatically compiled. The java command's new "compile and run" mode is not designed for running programs with multiple source code files.
An earlier build problem: It is possible that an earlier build failed in a way that gave a JAR file with missing classes. Such a failure would typically be noticed if you were using a build tool. However if you are getting JAR files from someone else, you are dependent on them building properly, and noticing errors. If you suspect this, use tar -tvf to list the contents of the suspect JAR file.
IDE issues: People have reported cases where their IDE gets confused and the compiler in the IDE cannot find a class that exists ... or the reverse situation.
- This could happen if the IDE has been configured with the wrong JDK version.
- This could happen if the IDE's caches get out of sync with the file system. There are IDE specific ways to fix that.
- This could be an IDE bug. For instance @Joel Costigliola described a scenario where Eclipse did not handle a Maven "test" tree correctly: see this answer. (Apparently that particular bug was been fixed a long time ago.)
Android issues: When you are programming for Android, and you have "Cannot find symbol" errors related to R, be aware that the R symbols are defined by the context.xml file. Check that your context.xml file is correct and in the correct place, and that the corresponding R class file has been generated / compiled. Note that the Java symbols are case sensitive, so the corresponding XML ids are case sensitive too.
Other symbol errors on Android are likely to be due to previously mention reasons; e.g., missing or incorrect dependencies, incorrect package names, method or fields that don't exist in a particular API version, spelling / typing errors, and so on.
Hiding system classes: I've seen cases where the compiler complains that substring is an unknown symbol in something like the following
```
String s = ...
String s1 = s.substring(1);
```
It turned out that the programmer had created their own version of String and that his version of the class didn't define a substring methods. I've seen people do this with System, Scanner and other classes.
Lesson: Don't define your own classes with the same names as common library classes!
The problem can also be solved by using the fully qualified names. For example, in the example above, the programmer could have written:
```
java.lang.String s = ...
java.lang.String s1 = s.substring(1);
```
Homoglyphs: If you use UTF-8 encoding for your source files, it is possible to have identifiers that look the same, but are in fact different because they contain homoglyphs. See this page for more information.
You can avoid this by restricting yourself to ASCII or Latin-1 as the source file encoding, and using Java \uxxxx escapes for other characters.

^{1 - If, perchance, you do see this in a runtime exception or error message, then either you have configured your IDE to run code with compilation errors, or your application is generating and compiling code .. at runtime.
2 - The three basic principles of civil engineering: water doesn't flow uphill, a plank is stronger on its side, and you can't push on a rope.}

“找不到符号”是什么意思？或“无法解析符号”错误是什么意思？

如果你对这篇内容有疑问，欢迎到本站社区发帖提问 参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

评论（19）

0. 这些错误之间有什么区别吗？

1. “找不到符号”错误是什么意思？

2. 什么会导致“找不到符号”错误？

3. 如何修复这些错误？

4. 不明原因

0. Is there any difference between these errors?

1. What does a "Cannot find symbol" error mean?

2. What can cause a "Cannot find symbol" error?

3. How do I fix these errors?

4. Obscure causes

我很高兴在 IDE 中使用 ! Optional.isEmpty(

为什么？

Optional.isEmpty()

Why?

关于作者

相关话题

热门标签

推荐作者

卷耳

佚名

℉服软

qq_2gSKZM

凉宸

gyhjy

友情链接

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

我很高兴在 IDE 中使用 `! Optional.isEmpty(`