最重要的是导入java.awt。*可以使您的程序与未来的Java版本不兼容:

假设你有一个名为“ABC”的类，你使用的是JDK 8，你导入java.util.*。现在，假设Java 9出来了，它在包Java中有一个新类。直到它碰巧也被称为“ABC”。您的程序现在不能在Java 9上编译，因为编译器不知道您的“ABC”名称是指您自己的类还是Java .awt中的新类。

如果只从java显式地导入这些类，就不会遇到这个问题。你实际使用的。

资源:

Java进口

唯一的问题是它会混淆本地名称空间。例如，假设您正在编写一个Swing应用程序，因此需要java.awt。事件，并且还与公司的日历系统进行接口，该系统具有com.mycompany.calendar.Event。如果你使用通配符方法导入两者，会发生以下三种情况之一:

event和com.mycompany.calendar之间存在完全的命名冲突。事件，因此您甚至无法编译。 您实际上只导入了一个(两个导入中只有一个导入了。*)，但它是错误的，并且您很难弄清楚为什么代码声称类型是错误的。 在编译代码时，没有com.mycompany.calendar。事件，但当他们后来添加一个时，您以前有效的代码突然停止编译。

显式列出所有导入的好处是，我可以一眼看出您打算使用哪个类，这使得代码的阅读更加容易。如果您只是在做一个快速的一次性的事情，那么没有什么明显的错误，但是未来的维护者会因为您的清晰而感谢您。

在双方提出的所有有效观点中，我还没有找到避免通配符的主要原因:我喜欢能够阅读代码并直接知道每个类是什么，或者如果它的定义不在语言或文件中，那么在哪里可以找到它。如果用*导入了多个包，我必须搜索它们中的每一个，以找到我不认识的类。可读性是至高无上的，我同意代码不应该需要IDE来读取。

忘掉混乱的命名空间……想想那些不得不在GitHub、vi、notepad++或其他非ide文本编辑器中阅读和理解你的代码的可怜人吧。

这个人必须煞费苦心地查找每个通配符作用域中所有类和引用中来自一个通配符的每个标记……只是想搞清楚到底发生了什么。

如果你只是为编译器编写代码——而且你知道你在做什么——我相信通配符没有问题。

但是，如果其他人(包括未来的您)希望一次阅读就能快速理解某个特定的代码文件，那么显式引用会有很大帮助。

在Java import语句中使用通配符并不坏。

在《Clean Code》中，Robert C. Martin建议使用它们来避免冗长的导入列表。

以下是建议:

J1: Avoid Long Import Lists by Using Wildcards If you use two or more classes from a package, then import the whole package with import package.*; Long lists of imports are daunting to the reader. We don’t want to clutter up the tops of our modules with 80 lines of imports. Rather we want the imports to be a concise statement about which packages we collaborate with. Specific imports are hard dependencies, whereas wildcard imports are not. If you specifically import a class, then that class must exist. But if you import a package with a wildcard, no particular classes need to exist. The import statement simply adds the package to the search path when hunting for names. So no true dependency is created by such imports, and they therefore serve to keep our modules less coupled. There are times when the long list of specific imports can be useful. For example, if you are dealing with legacy code and you want to find out what classes you need to build mocks and stubs for, you can walk down the list of specific imports to find out the true qualified names of all those classes and then put the appropriate stubs in place. However, this use for specific imports is very rare. Furthermore, most modern IDEs will allow you to convert the wildcarded imports to a list of specific imports with a single command. So even in the legacy case it’s better to import wildcards. Wildcard imports can sometimes cause name conflicts and ambiguities. Two classes with the same name, but in different packages, will need to be specifically imported, or at least specifically qualified when used. This can be a nuisance but is rare enough that using wildcard imports is still generally better than specific imports.

It helps to identify classname conflicts: two classes in different packages that have the same name. This can be masked with the * import. It makes dependencies explicit, so that anyone who has to read your code later knows what you meant to import and what you didn't mean to import. It can make some compilation faster because the compiler doesn't have to search the whole package to identify depdencies, though this is usually not a huge deal with modern compilers. The inconvenient aspects of explicit imports are minimized with modern IDEs. Most IDEs allow you to collapse the import section so it's not in the way, automatically populate imports when needed, and automatically identify unused imports to help clean them up.

我工作过的大多数使用大量Java的地方都将显式导入作为编码标准的一部分。我有时仍然使用*来快速创建原型，然后在产品化代码时展开导入列表(一些ide也会为您这样做)。