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

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

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

我更喜欢特定的导入，因为它允许我查看文件中使用的所有外部引用，而无需查看整个文件。(是的，我知道不一定会有完全合格的推荐信。但我尽量避免使用。)

它使您的名称空间变得混乱，要求您完全指定任何有歧义的类名。最常见的情况是:

import java.util.*;
import java.awt.*;

...
List blah; // Ambiguous, needs to be qualified.

它还有助于使依赖项具体化，因为所有依赖项都列在文件的顶部。

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也会为您这样做)。

这里是对明星进口的投票。import语句用于导入包，而不是类。导入整个包要干净得多;这里指出的问题(例如java.sql.Date vs . java.util.Date)很容易通过其他方法来补救，而不是通过特定的导入来真正解决，当然也不能证明对所有类进行疯狂的迂腐的导入是正确的。没有什么比打开一个源文件并不得不翻看100条import语句更令人不安的了。

执行特定的导入会使重构更加困难;如果删除/重命名一个类，则需要删除其所有特定的导入。如果您将一个实现切换到同一个包中的不同类，则必须修复导入。虽然这些额外的步骤是可以自动化的，但它们实际上是对生产力的打击，没有真正的收益。

如果Eclipse在默认情况下不进行特定的类导入，那么每个人仍然会进行星型导入。我很抱歉，但是做特定的导入确实没有合理的理由。

下面是处理阶级冲突的方法:

import java.sql.*;
import java.util.*;
import java.sql.Date;

请参阅我的文章“按需进口是邪恶的”

简而言之，最大的问题是当一个类被添加到您导入的包中时，您的代码可能会中断。例如:

import java.awt.*;
import java.util.*;

// ...

List list;

在Java 1.1中，这很好;在java中找到列表。啊，没有冲突。

现在假设您检入了运行良好的代码，一年后，其他人使用Java 1.2编辑了它。

Java 1.2在Java .util中添加了一个名为List的接口。繁荣!冲突。完美工作的代码不再工作。

这是一个邪恶的语言特性。没有理由仅仅因为一个类型被添加到包中就停止编译……

此外，它使读者难以确定您使用的是哪个“Foo”。

在以前的项目中，我发现将*-imports更改为特定的导入可以将编译时间减少一半(从大约10分钟减少到大约5分钟)。*-import使编译器搜索列出的每个包，以查找与您使用的类相匹配的类。虽然这段时间可能很小，但对于大项目来说，它会累积起来。

*-import的一个副作用是开发人员会复制和粘贴常用的导入行，而不是考虑他们需要什么。

在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.

性能:由于字节码相同，对性能没有影响。 尽管这会导致一些编译开销。

编译:在我的个人机器上，编译一个空白类而不导入任何东西需要100毫秒，但导入java时是同一个类。*占用170毫秒。

在DDD书中

在实现将基于的任何开发技术中，寻找最小化的方法 重构模块的工作。在Java中，无法逃避导入到单个类中，只能逃避导入到您 一次至少可以导入整个包，以反映包是高度内聚单元的意图吗 同时减少了更改包名的工作量。

如果它弄乱了本地命名空间，那不是你的错——是包的大小造成的。

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

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

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

资源:

Java进口

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

There is no runtime impact, as compiler automatically replaces the * with concrete class names. If you decompile the .class file, you would never see import ...*. C# always uses * (implicitly) as you can only using package name. You can never specify the class name at all. Java introduces the feature after c#. (Java is so tricky in many aspects but it's beyond this topic). In Intellij Idea when you do "organize imports", it automatically replaces multiple imports of the same package with *. This is a mandantory feature as you can not turn it off (though you can increase the threshold). The case listed by the accepted reply is not valid. Without * you still got the same issue. You need specify the pakcage name in your code no matter you use * or not.

郑重声明: 当您添加导入时，您也在指示您的依赖项。

您可以很快看到文件的依赖关系(不包括相同名称空间的类)。

导入包中的所有类被认为是一种盲目的方法。这样做的一个主要原因是，它会使类名称空间变得混乱，并可能导致具有相同名称的不同包中的类之间发生冲突。

具体地填充必要的类可以避免这个问题，并清楚地显示需要哪些版本。这有利于代码的可维护性。

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

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

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

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

以下是我关于这个话题的一些发现。

During compilation, the compiler tries to find classes that are used in the code from the .* import and the corresponding byte code will be generated by selecting the used classes from .* import. So the byte code of using .* import or .class names import will be same and the runtime performance will also be the same because of the same byte code. In each compilation, the compiler has to scan all the classes of .* package to match the classes that are actually used in the code. So, code with .* import takes more time during the compilation process as compared to using .class name imports. Using .* import helps to make code more cleaner Using .* import can create ambiguity when we use two classes of the same name from two different packages. Eg, Date is available in both packages. import java.util.*; import java.sql.*; public class DateDemo { private Date utilDate; private Date sqlDate; }

为什么在Java导入语句中使用通配符是不好的?

如果你正在使用一个IDE(这是你应该做的)，并且有比你更多的代码所有者，使用通配符导入是不好的，因为它:

对团队其他成员隐瞒信息 提供给您的只是虚假的好处(使用IDE功能比使用通配符导入更好地解决的事情)

大多数“使用通配符”的支持者都专注于个人:我不想维护列表，我不想看到混乱等等。下面是几个常见的例子:

维护更加困难——当您想要在源代码中引入一个新类时，您必须手动添加import语句 重构更加困难——如果代码被移动了，那么导入语句就必须更新 减少混乱，整理文件内容——这里的目标是“消除干扰”。

These arguments were more convincing before IDEs did all of that automatically. If you're using a plain text editor instead of an IDE, then these arguments have some merit. But if you're using a plain text editor, you are already subjecting yourself to a number of other much more significant inefficiencies, and managing import statements is just one among many things that you should stop doing by hand. IDEs offer automatic management of imports, powerful refactoring tools, and folding (hiding) of any parts of the code you don't want to see.

对于“避免通配符”的支持者，有很多例子，但我只指出一个:

清晰度——特别是当有新人进入代码库时。他们将带着问题来到这里，并在探索代码的过程中继续发现新的问题。对于这个新的代码贡献者，通配符导入语句不能回答任何问题，在最坏的情况下可能会产生混乱、误解和新问题。相反，对于显式导入(并使用IDE)，最坏的情况是中性的:没有提供新的信息;最好的情况是，它不仅可以减少歧义，而且还可以提供答案。

在一天结束的时候，它帮助整个团队降低(尽管是以一种很小的方式)代码的复杂性，减少混乱，增加清晰度。